anna/emmental
anna
/
emmental
1
0
Fork 0
Code Issues 11 Pull Requests Projects 1 Releases 12 Wiki Activity

db: Give playlists a get_n_tracks() function 

For finding the number of tracks in the specific playlist.

Implements: Issue #15 (Convert Playlists into Gio.ListModels)
Signed-off-by: Anna Schumaker <Anna@NoWheyCreamery.com>
This commit is contained in:
Anna Schumaker 2021-10-14 17:29:00 -04:00
parent 5ff03cf33f
commit 729b1efc9a
10 changed files with 92 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
db/playlist.py
View File

@ -16,6 +16,11 @@ class Playlist(GObject.GObject):
def has_children(self): return False
def get_n_tracks(self):
cur = sql.execute(f"SELECT COUNT(*) FROM tracks "
f"WHERE {self._rowkey}=?", [ self._rowid ])
return cur.fetchone()[0]
@GObject.Property
def name(self): raise NotImplementedError
@ -45,6 +50,11 @@ class MappedPlaylist(Playlist):
f"({self.rowkey}, trackid) VALUES (?, ?)",
[ self.rowid, track.rowid ]).rowcount == 1
def get_n_tracks(self):
cur = sql.execute(f"SELECT COUNT(*) FROM {self.map_table} "
f"WHERE {self._rowkey}=?", [ self._rowid ])
return cur.fetchone()[0]
def remove_track(self, track):
return sql.execute(f"DELETE FROM {self.map_table} "
f"WHERE {self.rowkey}=? AND trackid=?",

7
db/test_album.py
View File

@ -28,6 +28,13 @@ class TestAlbum(unittest.TestCase):
disc = album.find_disc(1, None)
self.assertIsInstance(disc, db.disc.Disc)
def test_n_tracks(self):
artist = db.artist.Table.find("Test Artist", "Test Sort")
album = artist.find_album("Test Album")
self.assertEqual(album.get_n_tracks(), 0)
track = db.make_fake_track(1, 1, "Test Track", "/a/b/c/1.ogg")
self.assertEqual(album.get_n_tracks(), 1)
class TestAlbumTable(unittest.TestCase):
def setUp(self):

6
db/test_artist.py
View File

@ -25,6 +25,12 @@ class TestArtist(unittest.TestCase):
album = artist.find_album("Test Album")
self.assertIsInstance(album, db.album.Album)
def test_n_tracks(self):
artist = db.artist.Table.find("Test Artist", "Test Sort")
self.assertEqual(artist.get_n_tracks(), 0)
track = db.make_fake_track(1, 1, "Test Track", "/a/b/c/1.ogg")
self.assertEqual(artist.get_n_tracks(), 1)
class TestArtistTable(unittest.TestCase):
def setUp(self):

6
db/test_decade.py
View File

@ -36,6 +36,12 @@ class TestDecade(unittest.TestCase):
self.assertIsInstance(year, db.year.Year)
self.assertEqual(self.changed, (0, 0, 1))
def test_n_tracks(self):
decade = db.decade.Table.insert(2020)
self.assertEqual(decade.get_n_tracks(), 0)
track = db.make_fake_track(1, 1, "Test Track", "/a/b/c/1.ogg")
self.assertEqual(decade.get_n_tracks(), 1)
class TestDecadeTable(unittest.TestCase):
def setUp(self):

6
db/test_disc.py
View File

@ -43,6 +43,12 @@ class TestDisc(unittest.TestCase):
self.assertEqual(disc.get_property("subtitle"), "")
self.assertEqual(disc.get_property("name"), "Disc 1")
def test_n_tracks(self):
disc = self.make_disc("Test Artist", "Test Album", 1, "Test Subtitle")
self.assertEqual(disc.get_n_tracks(), 0)
track = db.make_fake_track(1, 1, "Test Track", "/a/b/c/1.ogg")
self.assertEqual(disc.get_n_tracks(), 1)
class TestDiscTable(unittest.TestCase):
def setUp(self):

5
db/test_genre.py
View File

@ -26,7 +26,11 @@ class TestGenre(unittest.TestCase):
def test_add_remove_track(self):
genre = db.genre.Table.find("Test Genre")
track = db.make_fake_track(1, 1, "Test Track", "/a/b/c/1.ogg")
self.assertEqual(genre.get_n_tracks(), 0)
self.assertTrue(genre.add_track(track))
self.assertEqual(genre.get_n_tracks(), 1)
row = sql.execute("SELECT * FROM genre_map WHERE genreid=?",
[ genre.rowid ]).fetchone()
self.assertEqual(row["trackid"], track.rowid)
@ -34,6 +38,7 @@ class TestGenre(unittest.TestCase):
self.assertTrue(genre.remove_track(track))
self.assertFalse(genre.remove_track(track))
self.assertEqual(genre.get_n_tracks(), 0)
class TestGenreTable(unittest.TestCase):

6
db/test_library.py
View File

@ -34,6 +34,12 @@ class TestLibrary(unittest.TestCase):
library.enabled = False
self.assertFalse(library._enabled)
def test_n_tracks(self):
library = db.library.Table.insert(pathlib.Path("/a/b/c"))
self.assertEqual(library.get_n_tracks(), 0)
track = db.make_fake_track(1, 1, "Test Track", "/a/b/c/1.ogg")
self.assertEqual(library.get_n_tracks(), 1)
class TestLibraryTable(unittest.TestCase):
def setUp(self):

34
db/test_user.py
View File

@ -6,6 +6,8 @@ from gi.repository import GObject
from . import sql
class TestCollection(unittest.TestCase):
def setUp(self): db.reset()
def test_init(self):
collection = db.user.Table.find("Collection")
self.assertIsInstance(collection, db.playlist.Playlist)
@ -14,6 +16,14 @@ class TestCollection(unittest.TestCase):
self.assertEqual(collection.icon_name, "media-playback-start")
self.assertTrue(collection.plist_state.loop)
def test_n_tracks(self):
collection = db.user.Table.find("Collection")
self.assertEqual(collection.get_n_tracks(), 0)
track = db.make_fake_track(1, 1, "Test Track", "/a/b/c/1.ogg")
self.assertEqual(collection.get_n_tracks(), 1)
track.library.enabled = False
self.assertEqual(collection.get_n_tracks(), 0)
class TestFavorites(unittest.TestCase):
def setUp(self): db.reset()
@ -30,10 +40,15 @@ class TestFavorites(unittest.TestCase):
def test_add_remove_track(self):
favorites = db.user.Table.find("Favorites")
track = db.make_fake_track(1, 1, "Test Track", "/a/b/c/1.ogg")
self.assertEqual(favorites.get_n_tracks(), 0)
self.assertTrue(favorites.add_track(track))
self.assertFalse(favorites.add_track(track))
self.assertEqual(favorites.get_n_tracks(), 1)
self.assertTrue(favorites.remove_track(track))
self.assertFalse(favorites.remove_track(track))
self.assertEqual(favorites.get_n_tracks(), 0)
class TestNewTracks(unittest.TestCase):
@ -50,14 +65,18 @@ class TestNewTracks(unittest.TestCase):
def test_add_remove_track(self):
new = db.user.Table.find("New Tracks")
self.assertEqual(new.get_n_tracks(), 0)
track = db.make_fake_track(1, 1, "Test Track", "/a/b/c/1.ogg")
cur = sql.execute("SELECT * FROM temp_playlist_map "
"WHERE trackid=? AND playlistid=?",
[ track.rowid, new.rowid ])
self.assertEqual(cur.fetchone()["trackid"], track.rowid)
self.assertEqual(new.get_n_tracks(), 1)
self.assertTrue(new.remove_track(track))
self.assertFalse(new.remove_track(track))
self.assertEqual(new.get_n_tracks(), 0)
class TestPrevious(unittest.TestCase):
@ -76,11 +95,14 @@ class TestPrevious(unittest.TestCase):
def test_add_remove_track(self):
previous = db.user.Table.find("Previous")
track1 = db.make_fake_track(1, 1, "Test Track", "/a/b/c/1.ogg")
self.assertEqual(previous.get_n_tracks(), 0)
self.assertTrue(previous.add_track(track1))
cur = sql.execute("SELECT *,rowid FROM temp_playlist_map "
"WHERE trackid=? AND playlistid=?",
[ track1.rowid, previous.rowid ])
self.assertEqual(cur.fetchone()["rowid"], 2)
self.assertEqual(previous.get_n_tracks(), 1)
db.make_fake_track(2, 2, "Test Track 2", "/a/b/c/2.ogg")
self.assertTrue(previous.add_track(track1))
@ -88,9 +110,11 @@ class TestPrevious(unittest.TestCase):
"WHERE trackid=? AND playlistid=?",
[ track1.rowid, previous.rowid ])
self.assertEqual(cur.fetchone()["rowid"], 4)
self.assertEqual(previous.get_n_tracks(), 1)
self.assertTrue(previous.remove_track(track1))
self.assertFalse(previous.remove_track(track1))
self.assertEqual(previous.get_n_tracks(), 0)
class TestQueuedTracks(unittest.TestCase):
@ -109,10 +133,15 @@ class TestQueuedTracks(unittest.TestCase):
def test_add_remove_track(self):
queued = db.user.Table.find("Queued Tracks")
track = db.make_fake_track(1, 1, "Test Track", "/a/b/c/1.ogg")
self.assertEqual(queued.get_n_tracks(), 0)
self.assertTrue(queued.add_track(track))
self.assertFalse(queued.add_track(track))
self.assertEqual(queued.get_n_tracks(), 1)
self.assertTrue(queued.remove_track(track))
self.assertFalse(queued.remove_track(track))
self.assertEqual(queued.get_n_tracks(), 0)
class TestUserPlaylist(unittest.TestCase):
@ -135,10 +164,15 @@ class TestUserPlaylist(unittest.TestCase):
def test_add_remove_track(self):
plist = db.user.Table.find("Test Playlist")
track = db.make_fake_track(1, 1, "Test Track", "/a/b/c/1.ogg")
self.assertEqual(plist.get_n_tracks(), 0)
self.assertTrue(plist.add_track(track))
self.assertFalse(plist.add_track(track))
self.assertEqual(plist.get_n_tracks(), 1)
self.assertTrue(plist.remove_track(track))
self.assertFalse(plist.remove_track(track))
self.assertEqual(plist.get_n_tracks(), 0)
class TestUserTable(unittest.TestCase):

7
db/test_year.py
View File

@ -22,6 +22,13 @@ class TestYear(unittest.TestCase):
year.delete()
self.assertIsNone(db.year.Table.lookup(2021))
def test_n_tracks(self):
decade = db.decade.Table.find(2020)
year = decade.find_year(2021)
self.assertEqual(year.get_n_tracks(), 0)
track = db.make_fake_track(1, 1, "Test Track", "/a/b/c/1.ogg")
self.assertEqual(year.get_n_tracks(), 1)
class TestYearTable(unittest.TestCase):
def setUp(self):

5
db/user.py
View File

@ -21,6 +21,11 @@ class Collection(playlist.Playlist):
playlist.Playlist.__init__(self, row, "media-playback-start")
self._name = row["name"]
def get_n_tracks(self):
cur = sql.execute("SELECT COUNT(*) FROM tracks "
"JOIN libraries USING(libraryid) WHERE enabled=1")
return cur.fetchone()[0]
@GObject.Property
def name(self): return self._name