301 lines
12 KiB
Python
301 lines
12 KiB
Python
# Copyright 2022 (c) Anna Schumaker.
|
|
"""Tests our artist Gio.ListModel."""
|
|
import unittest.mock
|
|
import emmental.db
|
|
import tests.util
|
|
from gi.repository import Gtk
|
|
|
|
|
|
class TestArtistObject(tests.util.TestCase):
|
|
"""Tests our artist object."""
|
|
|
|
def setUp(self):
|
|
"""Set up common variables."""
|
|
tests.util.TestCase.setUp(self)
|
|
self.table = self.sql.artists
|
|
self.artist = emmental.db.artists.Artist(table=self.table,
|
|
artistid=123, propertyid=456,
|
|
name="Test Artist")
|
|
|
|
def test_init(self):
|
|
"""Test that the Artist is set up properly."""
|
|
self.assertIsInstance(self.artist, emmental.db.playlist.Playlist)
|
|
self.assertEqual(self.artist.table, self.table)
|
|
self.assertEqual(self.artist.propertyid, 456)
|
|
self.assertEqual(self.artist.artistid, 123)
|
|
self.assertEqual(self.artist.primary_key, 123)
|
|
self.assertEqual(self.artist.mbid, "")
|
|
self.assertIsNone(self.artist.parent)
|
|
|
|
def test_add_remove_album(self):
|
|
"""Test that the Album Artist filter works as expected."""
|
|
album = self.sql.albums.create("Test Album", "Album Artist", "2023-03")
|
|
|
|
with unittest.mock.patch.object(self.table, "add_album",
|
|
return_value=True) as mock_add:
|
|
self.artist.add_album(album)
|
|
|
|
mock_add.assert_called_with(self.artist, album)
|
|
self.assertIn(album, self.artist.child_set)
|
|
self.assertTrue(self.artist.has_album(album))
|
|
|
|
with unittest.mock.patch.object(self.table, "remove_album",
|
|
return_value=True) as mock_remove:
|
|
self.artist.remove_album(album)
|
|
|
|
mock_remove.assert_called_with(self.artist, album)
|
|
self.assertNotIn(album, self.artist.child_set)
|
|
self.assertFalse(self.artist.has_album(album))
|
|
|
|
def test_children(self):
|
|
"""Test that Albums have been added as Artist playlist children."""
|
|
self.assertIsInstance(self.artist.child_set,
|
|
emmental.db.table.TableSubset)
|
|
self.assertIsInstance(self.artist.children, Gtk.FilterListModel)
|
|
self.assertEqual(self.artist.children.get_filter(),
|
|
self.sql.albums.get_filter())
|
|
self.assertEqual(self.artist.child_set.table, self.sql.albums)
|
|
|
|
|
|
class TestFilter(tests.util.TestCase):
|
|
"""Test the artist filter."""
|
|
|
|
def setUp(self):
|
|
"""Set up common variables."""
|
|
super().setUp()
|
|
self.artists = self.sql.artists
|
|
self.filter = emmental.db.artists.Filter()
|
|
|
|
def test_init(self):
|
|
"""Test that the filter is initialized properly."""
|
|
self.assertIsInstance(self.filter, emmental.db.table.KeySet)
|
|
self.assertFalse(self.filter.show_all)
|
|
|
|
filter2 = emmental.db.artists.Filter(show_all=True)
|
|
self.assertTrue(filter2.show_all)
|
|
|
|
def test_strictness(self):
|
|
"""Test checking strictness."""
|
|
self.assertEqual(self.filter.get_strictness(), Gtk.FilterMatch.SOME)
|
|
self.filter.show_all = True
|
|
self.assertEqual(self.filter.get_strictness(), Gtk.FilterMatch.ALL)
|
|
|
|
def test_match(self):
|
|
"""Test matching an artist."""
|
|
artist = self.artists.create("Test Artist")
|
|
self.assertFalse(self.filter.match(artist))
|
|
self.filter.show_all = True
|
|
self.assertTrue(self.filter.match(artist))
|
|
|
|
|
|
class TestArtistTable(tests.util.TestCase):
|
|
"""Tests our artist table."""
|
|
|
|
def setUp(self):
|
|
"""Set up common variables."""
|
|
tests.util.TestCase.setUp(self)
|
|
self.table = self.sql.artists
|
|
self.album = self.sql.albums.create("Test Album", "Album Artist",
|
|
"2023-03")
|
|
|
|
def test_init(self):
|
|
"""Test that the artist model is configured correctly."""
|
|
self.assertIsInstance(self.table, emmental.db.playlist.Table)
|
|
self.assertIsInstance(self.table.get_filter(),
|
|
emmental.db.artists.Filter)
|
|
self.assertEqual(len(self.table), 0)
|
|
self.assertTrue(self.table.autodelete)
|
|
self.assertTrue(self.table.system_tracks)
|
|
|
|
def test_construct(self):
|
|
"""Test constructing a new artist playlist."""
|
|
artist = self.table.construct(artistid=1, propertyid=1,
|
|
name="Test Artist", mbid="ab-cd-ef")
|
|
self.assertIsInstance(artist, emmental.db.artists.Artist)
|
|
self.assertEqual(artist.table, self.table)
|
|
self.assertEqual(artist.propertyid, 1)
|
|
self.assertEqual(artist.artistid, 1)
|
|
self.assertEqual(artist.name, "Test Artist")
|
|
self.assertEqual(artist.mbid, "ab-cd-ef")
|
|
self.assertFalse(artist.active)
|
|
self.assertFalse(artist.tracks_movable)
|
|
|
|
def test_create(self):
|
|
"""Test creating an artist playlist."""
|
|
self.table.show_all = True
|
|
|
|
artist1 = self.table.create("Test Artist")
|
|
self.assertIsInstance(artist1, emmental.db.artists.Artist)
|
|
self.assertEqual(artist1.name, "Test Artist")
|
|
self.assertEqual(artist1.mbid, "")
|
|
self.assertEqual(artist1.sort_order,
|
|
"release, album, mediumno, number")
|
|
self.assertEqual(self.table[0], artist1)
|
|
|
|
cur = self.sql("SELECT COUNT(name) FROM artists")
|
|
self.assertEqual(cur.fetchone()["COUNT(name)"], 1)
|
|
|
|
row = self.sql("""SELECT COUNT(*) FROM playlist_properties
|
|
WHERE propertyid=?""", artist1.propertyid).fetchone()
|
|
self.assertEqual(row["COUNT(*)"], 1)
|
|
|
|
artist2 = self.table.create("Test Artist", mbid="AB-CD-EF")
|
|
self.assertEqual(artist2.mbid, "ab-cd-ef")
|
|
self.assertEqual(self.table[0], artist2)
|
|
self.assertEqual(self.table[1], artist1)
|
|
|
|
cur = self.sql("SELECT COUNT(name) FROM artists")
|
|
self.assertEqual(cur.fetchone()["COUNT(name)"], 2)
|
|
|
|
self.assertIsNone(self.table.create("Test Artist"))
|
|
|
|
def test_delete(self):
|
|
"""Test deleting an artist playlist."""
|
|
artist = self.table.create("Test Artist")
|
|
artist.add_album(self.album)
|
|
|
|
self.assertTrue(artist.delete())
|
|
self.assertIsNone(self.table.index(artist))
|
|
|
|
cur = self.sql("SELECT COUNT(name) FROM artists")
|
|
self.assertEqual(cur.fetchone()["COUNT(name)"], 0)
|
|
self.assertEqual(len(self.table), 0)
|
|
self.assertIsNone(self.table.get_item(0))
|
|
|
|
row = self.sql("""SELECT COUNT(*) FROM playlist_properties
|
|
WHERE propertyid=?""", artist.propertyid).fetchone()
|
|
self.assertEqual(row["COUNT(*)"], 0)
|
|
|
|
cur = self.sql("SELECT COUNT(albumid) FROM album_artist_link")
|
|
self.assertEqual(cur.fetchone()["COUNT(albumid)"], 0)
|
|
|
|
self.assertFalse(artist.delete())
|
|
|
|
def test_filter(self):
|
|
"""Test filtering an artist playlist."""
|
|
artist1 = self.table.create("Artist 1")
|
|
artist2 = self.table.create("Artist 2")
|
|
|
|
album = self.sql.albums.create("Album 1", "Artist 1", "1")
|
|
artist1.add_album(album)
|
|
artist1.add_album(self.sql.albums.create("Album 2", "Artist 1", "2"))
|
|
artist2.add_album(self.sql.albums.create("Album 3", "Artist 2", "3"))
|
|
artist2.add_album(self.sql.albums.create("Album 4", "Artist 2", "4"))
|
|
self.sql.media.create(album, "Medium 1", number=1)
|
|
self.sql.media.create(album, "Medium 2", number=2)
|
|
|
|
self.table.filter("*1", now=True)
|
|
self.assertSetEqual(self.table.get_filter().keys, {1})
|
|
self.table.filter("artist*", now=True)
|
|
self.assertSetEqual(self.table.get_filter().keys, {1, 2})
|
|
|
|
self.table.filter("*4", now=True)
|
|
self.assertSetEqual(self.table.get_filter().keys, {2})
|
|
|
|
self.table.filter("medium*", now=True)
|
|
self.assertSetEqual(self.table.get_filter().keys, {1})
|
|
|
|
def test_get_sort_key(self):
|
|
"""Test the get_sort_key() function."""
|
|
artist1 = self.table.create("Artist 1")
|
|
artist2 = self.table.create("Artist 2", mbid="ab-cd-ef")
|
|
|
|
self.assertTupleEqual(self.table.get_sort_key(artist1),
|
|
(("artist", "1"), True, ""))
|
|
self.assertTupleEqual(self.table.get_sort_key(artist2),
|
|
(("artist", "2"), False, "ab-cd-ef"))
|
|
|
|
def test_load(self):
|
|
"""Test loading the artist table."""
|
|
artist = self.table.create("Artist 1")
|
|
self.table.create("Artist 2", mbid="ab-cd-ef")
|
|
artist.add_album(self.album)
|
|
|
|
artists2 = emmental.db.artists.Table(self.sql, show_all=True)
|
|
self.assertEqual(len(artists2), 0)
|
|
|
|
artists2.load(now=True)
|
|
self.assertEqual(len(artists2), 2)
|
|
|
|
self.assertEqual(artists2.get_item(0).name, "Artist 1")
|
|
self.assertEqual(artists2.get_item(0).mbid, "")
|
|
self.assertSetEqual(artists2.get_item(0).child_set.keyset.keys, {1})
|
|
|
|
self.assertEqual(artists2.get_item(1).name, "Artist 2")
|
|
self.assertEqual(artists2.get_item(1).mbid, "ab-cd-ef")
|
|
self.assertSetEqual(artists2.get_item(1).child_set.keyset.keys, set())
|
|
|
|
def test_lookup(self):
|
|
"""Test looking up artist playlists."""
|
|
artist1 = self.table.create("Test Artist")
|
|
artist2 = self.table.create("Test Artist", mbid="ab-cd-ef")
|
|
|
|
self.assertEqual(self.table.lookup("Test Artist"), artist1)
|
|
self.assertEqual(self.table.lookup("test artist"), artist1)
|
|
self.assertEqual(self.table.lookup("Test Artist", mbid="ab-cd-ef"),
|
|
artist2)
|
|
self.assertEqual(self.table.lookup("test artist", mbid="AB-CD-EF"),
|
|
artist2)
|
|
self.assertIsNone(self.table.lookup("No Artist"))
|
|
|
|
self.assertEqual(self.table.lookup(mbid="ab-cd-ef"), artist2)
|
|
self.assertEqual(self.table.lookup(mbid="AB-CD-EF"), artist2)
|
|
self.assertIsNone(self.table.lookup(mbid="gh-ij-kl"))
|
|
|
|
def test_update(self):
|
|
"""Test updating artist attributes."""
|
|
artist = self.table.create("Test Artist")
|
|
artist.active = True
|
|
artist.loop = "Track"
|
|
artist.sort_order = "trackid"
|
|
artist.shuffle = True
|
|
|
|
row = self.sql("""SELECT active, loop, sort_order,
|
|
shuffle, current_trackid
|
|
FROM artists_view WHERE artistid=?""",
|
|
artist.artistid).fetchone()
|
|
self.assertTrue(row["active"])
|
|
self.assertEqual(row["loop"], "Track")
|
|
self.assertEqual(row["sort_order"], "trackid")
|
|
self.assertTrue(row["shuffle"])
|
|
self.assertIsNone(row["current_trackid"])
|
|
|
|
def test_add_remove_album(self):
|
|
"""Test adding an album to an artist."""
|
|
artist = self.table.create("Test Artist")
|
|
artist.add_album(self.album)
|
|
self.assertTrue(artist.has_album(self.album))
|
|
|
|
row = self.sql("""SELECT albumid FROM album_artist_link
|
|
WHERE artistid=?""", artist.artistid).fetchone()
|
|
self.assertEqual(row["albumid"], self.album.albumid)
|
|
|
|
artist.remove_album(self.album)
|
|
self.assertFalse(artist.has_album(self.album))
|
|
|
|
cur = self.sql("""SELECT albumid FROM album_artist_link
|
|
WHERE artistid=?""", artist.artistid)
|
|
self.assertIsNone(cur.fetchone())
|
|
|
|
artist.remove_album(self.album)
|
|
|
|
def test_get_albumids(self):
|
|
"""Test getting an artist's associated albumids from the database."""
|
|
artist = self.table.create("Artist")
|
|
artist.add_album(self.album)
|
|
artist.add_album(self.sql.albums.create("Album 1", "Artist", "1"))
|
|
artist.add_album(self.sql.albums.create("Album 2", "Artist", "2"))
|
|
self.assertSetEqual(self.table.get_albumids(artist), {1, 2, 3})
|
|
|
|
def test_show_all(self):
|
|
"""Test the show-all property."""
|
|
self.assertFalse(self.table.show_all)
|
|
self.table.show_all = True
|
|
self.assertTrue(self.table.get_filter().show_all)
|
|
self.table.show_all = False
|
|
self.assertFalse(self.table.get_filter().show_all)
|
|
|
|
table2 = emmental.db.artists.Table(self.sql, show_all=True)
|
|
self.assertTrue(table2.show_all)
|
|
self.assertTrue(table2.get_filter().show_all)
|