Anna Schumaker
01de88f474
The Collection playlist uses this to emit the "refreshed" signal to notify higher layers that the contents of the playlist has changed. Eventually, this will also be used to update playlists when sorting. Implements: Issue #15 (Convert Playlists into Gio.ListModels) Signed-off-by: Anna Schumaker <Anna@NoWheyCreamery.com>
313 lines
12 KiB
Python
313 lines
12 KiB
Python
# Copyright 2021 (c) Anna Schumaker.
|
|
import db
|
|
import sqlite3
|
|
import unittest
|
|
from gi.repository import GObject
|
|
from . import sql
|
|
|
|
class TestCollection(unittest.TestCase):
|
|
def track_added(self, plist, added):
|
|
self.added = added
|
|
|
|
def track_removed(self, plist, removed):
|
|
self.removed = removed
|
|
|
|
def refreshed(self, plist):
|
|
self.refreshed = True
|
|
|
|
def setUp(self): db.reset()
|
|
|
|
def test_init(self):
|
|
collection = db.user.Table.find("Collection")
|
|
self.assertIsInstance(collection, db.playlist.Playlist)
|
|
self.assertIsInstance(collection, db.user.Collection)
|
|
self.assertEqual(collection.name, "Collection")
|
|
self.assertEqual(collection.icon_name, "media-playback-start")
|
|
self.assertTrue(collection.plist_state.loop)
|
|
|
|
def test_tracks(self):
|
|
collection = db.user.Table.find("Collection")
|
|
collection.connect("track-added", self.track_added)
|
|
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)
|
|
self.assertEqual(collection.get_track(0), track)
|
|
self.assertEqual(collection.get_track_index(track), 0)
|
|
self.assertEqual(self.added, track)
|
|
|
|
collection.connect("track-removed", self.track_removed)
|
|
db.track.Table.delete(track)
|
|
self.assertEqual(self.removed, track)
|
|
|
|
def test_library_enabled(self):
|
|
collection = db.user.Table.find("Collection")
|
|
track1 = db.make_fake_track(1, 1, "Test Track 1", "/a/b/c/1.ogg")
|
|
track2 = db.make_fake_track(2, 2, "Test Track 2", "/a/b/c/2.ogg")
|
|
self.assertEqual(collection.get_n_tracks(), 2)
|
|
collection.connect("refreshed", self.refreshed)
|
|
|
|
track1.library.enabled = False
|
|
self.assertEqual(collection.get_n_tracks(), 0)
|
|
self.assertTrue(self.refreshed)
|
|
|
|
self.refreshed = None
|
|
track1.library.enabled = True
|
|
self.assertEqual(collection.get_n_tracks(), 2)
|
|
self.assertTrue(self.refreshed)
|
|
|
|
|
|
class TestFavorites(unittest.TestCase):
|
|
def track_added(self, plist, added):
|
|
self.added = added
|
|
|
|
def track_removed(self, plist, removed):
|
|
self.removed = removed
|
|
|
|
def setUp(self): db.reset()
|
|
|
|
def test_init(self):
|
|
favorites = db.user.Table.find("Favorites")
|
|
self.assertIsInstance(favorites, db.playlist.MappedPlaylist)
|
|
self.assertIsInstance(favorites, db.user.UserPlaylist)
|
|
self.assertEqual(favorites.name, "Favorites")
|
|
self.assertEqual(favorites.icon_name, "emmental-favorites")
|
|
self.assertEqual(favorites.map_table, "playlist_map")
|
|
self.assertFalse(favorites.plist_state.loop)
|
|
|
|
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")
|
|
favorites.connect("track-added", self.track_added)
|
|
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.assertEqual(favorites.get_track(0), track)
|
|
self.assertEqual(favorites.get_track_index(track), 0)
|
|
self.assertEqual(self.added, track)
|
|
|
|
favorites.connect("track-removed", self.track_removed)
|
|
self.assertTrue(favorites.remove_track(track))
|
|
self.assertFalse(favorites.remove_track(track))
|
|
self.assertEqual(favorites.get_n_tracks(), 0)
|
|
self.assertEqual(self.removed, track)
|
|
|
|
|
|
class TestNewTracks(unittest.TestCase):
|
|
def track_added(self, plist, added):
|
|
self.added = added
|
|
|
|
def track_removed(self, plist, removed):
|
|
self.removed = removed
|
|
|
|
def setUp(self): db.reset()
|
|
|
|
def test_init(self):
|
|
new = db.user.Table.find("New Tracks")
|
|
self.assertIsInstance(new, db.playlist.MappedPlaylist)
|
|
self.assertIsInstance(new, db.user.UserPlaylist)
|
|
self.assertEqual(new.name, "New Tracks")
|
|
self.assertEqual(new.icon_name, "starred")
|
|
self.assertEqual(new.map_table, "temp_playlist_map")
|
|
self.assertFalse(new.plist_state.loop)
|
|
|
|
def test_add_remove_track(self):
|
|
new = db.user.Table.find("New Tracks")
|
|
new.connect("track-added", self.track_added)
|
|
self.assertEqual(new.get_n_tracks(), 0)
|
|
|
|
track = db.make_fake_track(1, 1, "Test Track", "/a/b/c/1.ogg")
|
|
self.assertEqual(new.get_n_tracks(), 1)
|
|
self.assertEqual(new.get_track(0), track)
|
|
self.assertEqual(new.get_track_index(track), 0)
|
|
self.added = track
|
|
|
|
new.connect("track-removed", self.track_removed)
|
|
self.assertTrue(new.remove_track(track))
|
|
self.assertFalse(new.remove_track(track))
|
|
self.assertEqual(new.get_n_tracks(), 0)
|
|
self.assertEqual(self.removed, track)
|
|
|
|
|
|
class TestPrevious(unittest.TestCase):
|
|
def track_added(self, plist, added):
|
|
self.added = added
|
|
|
|
def track_removed(self, plist, removed):
|
|
self.removed = removed
|
|
|
|
def setUp(self): db.reset()
|
|
|
|
def test_init(self):
|
|
previous = db.user.Table.find("Previous")
|
|
self.assertIsInstance(previous, db.user.UserPlaylist)
|
|
self.assertIsInstance(previous, db.user.Previous)
|
|
self.assertEqual(previous.name, "Previous")
|
|
self.assertEqual(previous.icon_name, "edit-undo")
|
|
self.assertEqual(previous.map_table, "temp_playlist_map")
|
|
self.assertEqual(previous.plist_state.sort, [ "temp_playlist_map.rowid DESC" ])
|
|
self.assertFalse(previous.plist_state.loop)
|
|
|
|
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")
|
|
track2 = db.make_fake_track(2, 2, "Test Track 2", "/a/b/c/2.ogg")
|
|
previous.connect("track-added", self.track_added)
|
|
self.assertEqual(previous.get_n_tracks(), 0)
|
|
|
|
self.assertTrue(previous.add_track(track1))
|
|
self.assertEqual(previous.get_n_tracks(), 1)
|
|
self.assertEqual(previous.get_track(0), track1)
|
|
self.assertEqual(previous.get_track_index(track1), 0)
|
|
self.assertEqual(self.added, track1)
|
|
|
|
self.assertTrue(previous.add_track(track2))
|
|
self.assertEqual(previous.get_n_tracks(), 2)
|
|
self.assertEqual(previous.get_track(0), track2)
|
|
self.assertEqual(previous.get_track(1), track1)
|
|
self.assertEqual(previous.get_track_index(track2), 0)
|
|
self.assertEqual(previous.get_track_index(track1), 1)
|
|
self.assertEqual(self.added, track2)
|
|
|
|
previous.connect("track-removed", self.track_removed)
|
|
self.assertTrue(previous.add_track(track1))
|
|
self.assertEqual(previous.get_n_tracks(), 2)
|
|
self.assertEqual(previous.get_track(0), track1)
|
|
self.assertEqual(previous.get_track(1), track2)
|
|
self.assertEqual(previous.get_track_index(track1), 0)
|
|
self.assertEqual(previous.get_track_index(track2), 1)
|
|
self.assertEqual(self.removed, track1)
|
|
self.assertEqual(self.added, track1)
|
|
|
|
self.assertTrue(previous.remove_track(track1))
|
|
self.assertFalse(previous.remove_track(track1))
|
|
self.assertEqual(previous.get_n_tracks(), 1)
|
|
self.assertEqual(previous.get_track_index(track2), 0)
|
|
self.assertEqual(self.removed, track1)
|
|
|
|
|
|
class TestQueuedTracks(unittest.TestCase):
|
|
def track_added(self, plist, added):
|
|
self.added = added
|
|
|
|
def track_removed(self, plist, removed):
|
|
self.removed = removed
|
|
|
|
def setUp(self): db.reset()
|
|
|
|
def test_init(self):
|
|
queued = db.user.Table.find("Queued Tracks")
|
|
self.assertIsInstance(queued, db.playlist.MappedPlaylist)
|
|
self.assertIsInstance(queued, db.user.UserPlaylist)
|
|
self.assertEqual(queued.name, "Queued Tracks")
|
|
self.assertEqual(queued.icon_name, "edit-redo")
|
|
self.assertEqual(queued.map_table, "playlist_map")
|
|
self.assertEqual(queued.plist_state.sort, [ "playlist_map.rowid ASC" ])
|
|
self.assertFalse(queued.plist_state.loop)
|
|
|
|
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")
|
|
queued.connect("track-added", self.track_added)
|
|
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.assertEqual(queued.get_track(0), track)
|
|
self.assertEqual(queued.get_track_index(track), 0)
|
|
self.assertEqual(self.added, track)
|
|
|
|
queued.connect("track-removed", self.track_removed)
|
|
self.assertTrue(queued.remove_track(track))
|
|
self.assertFalse(queued.remove_track(track))
|
|
self.assertEqual(queued.get_n_tracks(), 0)
|
|
self.assertEqual(self.removed, track)
|
|
|
|
|
|
class TestUserPlaylist(unittest.TestCase):
|
|
def track_added(self, plist, added):
|
|
self.added = added
|
|
|
|
def track_removed(self, plist, removed):
|
|
self.removed = removed
|
|
|
|
def setUp(self): db.reset()
|
|
|
|
def test_init(self):
|
|
plist = db.user.Table.find("Test Playlist")
|
|
self.assertIsInstance(plist, db.playlist.MappedPlaylist)
|
|
self.assertIsInstance(plist, db.user.UserPlaylist)
|
|
self.assertEqual(plist.name, "Test Playlist")
|
|
self.assertEqual(plist.icon_name, "audio-x-generic")
|
|
self.assertEqual(plist.map_table, "playlist_map")
|
|
self.assertFalse(plist.plist_state.loop)
|
|
|
|
def test_delete(self):
|
|
track = db.make_fake_track(1, 1, "Test Track", "/a/b/c/1.ogg")
|
|
plist = db.user.Table.find("Test Playlist")
|
|
plist.add_track(track)
|
|
plist.delete()
|
|
self.assertEqual(plist.get_n_tracks(), 0)
|
|
self.assertIsNone(db.user.Table.lookup("Test Playlist"))
|
|
|
|
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")
|
|
plist.connect("track-added", self.track_added)
|
|
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.assertEqual(plist.get_track(0), track)
|
|
self.assertEqual(plist.get_track_index(track), 0)
|
|
self.assertEqual(self.added, track)
|
|
|
|
plist.connect("track-removed", self.track_removed)
|
|
self.assertTrue(plist.remove_track(track))
|
|
self.assertFalse(plist.remove_track(track))
|
|
self.assertEqual(plist.get_n_tracks(), 0)
|
|
self.assertEqual(self.removed, track)
|
|
|
|
|
|
class TestUserTable(unittest.TestCase):
|
|
def setUp(self):
|
|
db.reset()
|
|
|
|
def test_init(self):
|
|
table = db.user.UserTable()
|
|
self.assertIsInstance(table, db.playlist.Model)
|
|
self.assertEqual(table.table, "playlists")
|
|
self.assertEqual(table.order, "sort")
|
|
|
|
self.assertIsInstance(db.user.Table, db.user.UserTable)
|
|
db.sql.execute("SELECT playlistid,plstateid,name,sort FROM playlists")
|
|
|
|
def test_insert(self):
|
|
table = db.user.UserTable()
|
|
playlist = table.find("Test Playlist")
|
|
|
|
self.assertIsInstance(playlist, db.user.UserPlaylist)
|
|
self.assertEqual(playlist._name, "Test Playlist")
|
|
self.assertEqual(playlist._rowkey, "playlistid")
|
|
|
|
with self.assertRaises(sqlite3.IntegrityError):
|
|
db.user.Table.insert("Test Playlist")
|
|
|
|
def test_lookup(self):
|
|
playlist = db.user.Table.insert("Test Playlist")
|
|
self.assertEqual(db.user.Table.lookup("Test Playlist"), playlist)
|
|
self.assertIsNone(db.user.Table.lookup("none"))
|
|
|
|
def test_default_playlists(self):
|
|
table = db.user.UserTable()
|
|
self.assertEqual(table.get_n_items(), 5)
|
|
self.assertEqual(table.get_item(0).name, "Collection")
|
|
self.assertEqual(table.get_item(1).name, "Favorites")
|
|
self.assertEqual(table.get_item(2).name, "New Tracks")
|
|
self.assertEqual(table.get_item(3).name, "Previous")
|
|
self.assertEqual(table.get_item(4).name, "Queued Tracks")
|