2021-08-21 16:47:33 -04:00
|
|
|
# Copyright 2021 (c) Anna Schumaker.
|
|
|
|
import db
|
|
|
|
import sqlite3
|
|
|
|
import unittest
|
|
|
|
from gi.repository import GObject
|
2021-10-15 16:06:02 -04:00
|
|
|
from . import sql
|
2021-08-21 16:47:33 -04:00
|
|
|
|
2021-10-10 13:49:19 -04:00
|
|
|
class TestCollection(unittest.TestCase):
|
2021-10-18 17:25:20 -04:00
|
|
|
def track_added(self, plist, added):
|
|
|
|
self.added = added
|
|
|
|
|
2021-10-19 14:48:08 -04:00
|
|
|
def track_removed(self, plist, removed):
|
|
|
|
self.removed = removed
|
|
|
|
|
2021-10-19 16:48:03 -04:00
|
|
|
def refreshed(self, plist):
|
|
|
|
self.refreshed = True
|
|
|
|
|
2021-10-14 17:29:00 -04:00
|
|
|
def setUp(self): db.reset()
|
|
|
|
|
2021-10-10 13:49:19 -04:00
|
|
|
def test_init(self):
|
|
|
|
collection = db.user.Table.find("Collection")
|
2021-10-15 10:14:58 -04:00
|
|
|
self.assertIsInstance(collection, db.playlist.Playlist)
|
|
|
|
self.assertIsInstance(collection, db.user.Collection)
|
|
|
|
self.assertEqual(collection.name, "Collection")
|
2021-10-13 17:04:26 -04:00
|
|
|
self.assertEqual(collection.icon_name, "media-playback-start")
|
2021-10-14 14:18:36 -04:00
|
|
|
self.assertTrue(collection.plist_state.loop)
|
2021-10-10 13:49:19 -04:00
|
|
|
|
2021-10-18 17:25:20 -04:00
|
|
|
def test_tracks(self):
|
2021-10-14 17:29:00 -04:00
|
|
|
collection = db.user.Table.find("Collection")
|
2021-10-18 17:25:20 -04:00
|
|
|
collection.connect("track-added", self.track_added)
|
2021-10-14 17:29:00 -04:00
|
|
|
self.assertEqual(collection.get_n_tracks(), 0)
|
2021-10-18 17:25:20 -04:00
|
|
|
|
2021-10-14 17:29:00 -04:00
|
|
|
track = db.make_fake_track(1, 1, "Test Track", "/a/b/c/1.ogg")
|
|
|
|
self.assertEqual(collection.get_n_tracks(), 1)
|
2021-10-17 16:43:09 -04:00
|
|
|
self.assertEqual(collection.get_track(0), track)
|
2021-10-17 21:48:17 -04:00
|
|
|
self.assertEqual(collection.get_track_index(track), 0)
|
2021-10-18 17:25:20 -04:00
|
|
|
self.assertEqual(self.added, track)
|
|
|
|
|
2021-10-19 14:48:08 -04:00
|
|
|
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")
|
2021-10-19 16:48:03 -04:00
|
|
|
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
|
2021-10-14 17:29:00 -04:00
|
|
|
self.assertEqual(collection.get_n_tracks(), 0)
|
2021-10-19 16:48:03 -04:00
|
|
|
self.assertTrue(self.refreshed)
|
|
|
|
|
|
|
|
self.refreshed = None
|
|
|
|
track1.library.enabled = True
|
|
|
|
self.assertEqual(collection.get_n_tracks(), 2)
|
|
|
|
self.assertTrue(self.refreshed)
|
2021-10-14 17:29:00 -04:00
|
|
|
|
2021-10-10 13:49:19 -04:00
|
|
|
|
|
|
|
class TestFavorites(unittest.TestCase):
|
2021-10-18 17:25:20 -04:00
|
|
|
def track_added(self, plist, added):
|
|
|
|
self.added = added
|
|
|
|
|
2021-10-19 14:48:08 -04:00
|
|
|
def track_removed(self, plist, removed):
|
|
|
|
self.removed = removed
|
|
|
|
|
2021-10-15 16:06:02 -04:00
|
|
|
def setUp(self): db.reset()
|
|
|
|
|
2021-10-10 13:49:19 -04:00
|
|
|
def test_init(self):
|
|
|
|
favorites = db.user.Table.find("Favorites")
|
2021-10-15 10:14:58 -04:00
|
|
|
self.assertIsInstance(favorites, db.playlist.MappedPlaylist)
|
2021-10-10 13:49:19 -04:00
|
|
|
self.assertIsInstance(favorites, db.user.UserPlaylist)
|
2021-10-15 10:14:58 -04:00
|
|
|
self.assertEqual(favorites.name, "Favorites")
|
2021-10-13 17:04:26 -04:00
|
|
|
self.assertEqual(favorites.icon_name, "emmental-favorites")
|
2021-10-15 10:14:58 -04:00
|
|
|
self.assertEqual(favorites.map_table, "playlist_map")
|
2021-10-14 14:18:36 -04:00
|
|
|
self.assertFalse(favorites.plist_state.loop)
|
2021-10-10 13:49:19 -04:00
|
|
|
|
2021-10-15 16:06:02 -04:00
|
|
|
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")
|
2021-10-18 17:25:20 -04:00
|
|
|
favorites.connect("track-added", self.track_added)
|
2021-10-14 17:29:00 -04:00
|
|
|
self.assertEqual(favorites.get_n_tracks(), 0)
|
|
|
|
|
2021-10-15 16:06:02 -04:00
|
|
|
self.assertTrue(favorites.add_track(track))
|
|
|
|
self.assertFalse(favorites.add_track(track))
|
2021-10-14 17:29:00 -04:00
|
|
|
self.assertEqual(favorites.get_n_tracks(), 1)
|
2021-10-17 16:43:09 -04:00
|
|
|
self.assertEqual(favorites.get_track(0), track)
|
2021-10-17 21:48:17 -04:00
|
|
|
self.assertEqual(favorites.get_track_index(track), 0)
|
2021-10-18 17:25:20 -04:00
|
|
|
self.assertEqual(self.added, track)
|
2021-10-14 17:29:00 -04:00
|
|
|
|
2021-10-19 14:48:08 -04:00
|
|
|
favorites.connect("track-removed", self.track_removed)
|
2021-10-15 16:06:02 -04:00
|
|
|
self.assertTrue(favorites.remove_track(track))
|
|
|
|
self.assertFalse(favorites.remove_track(track))
|
2021-10-14 17:29:00 -04:00
|
|
|
self.assertEqual(favorites.get_n_tracks(), 0)
|
2021-10-19 14:48:08 -04:00
|
|
|
self.assertEqual(self.removed, track)
|
2021-10-15 16:06:02 -04:00
|
|
|
|
2021-10-10 13:49:19 -04:00
|
|
|
|
|
|
|
class TestNewTracks(unittest.TestCase):
|
2021-10-18 17:25:20 -04:00
|
|
|
def track_added(self, plist, added):
|
|
|
|
self.added = added
|
|
|
|
|
2021-10-19 14:48:08 -04:00
|
|
|
def track_removed(self, plist, removed):
|
|
|
|
self.removed = removed
|
|
|
|
|
2021-10-15 16:06:02 -04:00
|
|
|
def setUp(self): db.reset()
|
|
|
|
|
2021-10-10 13:49:19 -04:00
|
|
|
def test_init(self):
|
|
|
|
new = db.user.Table.find("New Tracks")
|
2021-10-15 10:14:58 -04:00
|
|
|
self.assertIsInstance(new, db.playlist.MappedPlaylist)
|
2021-10-10 13:49:19 -04:00
|
|
|
self.assertIsInstance(new, db.user.UserPlaylist)
|
2021-10-15 10:14:58 -04:00
|
|
|
self.assertEqual(new.name, "New Tracks")
|
2021-10-13 17:04:26 -04:00
|
|
|
self.assertEqual(new.icon_name, "starred")
|
2021-10-15 10:14:58 -04:00
|
|
|
self.assertEqual(new.map_table, "temp_playlist_map")
|
2021-10-14 14:18:36 -04:00
|
|
|
self.assertFalse(new.plist_state.loop)
|
2021-10-10 13:49:19 -04:00
|
|
|
|
2021-10-15 16:06:02 -04:00
|
|
|
def test_add_remove_track(self):
|
|
|
|
new = db.user.Table.find("New Tracks")
|
2021-10-18 17:25:20 -04:00
|
|
|
new.connect("track-added", self.track_added)
|
2021-10-14 17:29:00 -04:00
|
|
|
self.assertEqual(new.get_n_tracks(), 0)
|
|
|
|
|
2021-10-15 16:06:02 -04:00
|
|
|
track = db.make_fake_track(1, 1, "Test Track", "/a/b/c/1.ogg")
|
2021-10-14 17:29:00 -04:00
|
|
|
self.assertEqual(new.get_n_tracks(), 1)
|
2021-10-17 16:43:09 -04:00
|
|
|
self.assertEqual(new.get_track(0), track)
|
2021-10-17 21:48:17 -04:00
|
|
|
self.assertEqual(new.get_track_index(track), 0)
|
2021-10-18 17:25:20 -04:00
|
|
|
self.added = track
|
2021-10-15 16:06:02 -04:00
|
|
|
|
2021-10-19 14:48:08 -04:00
|
|
|
new.connect("track-removed", self.track_removed)
|
2021-10-15 16:06:02 -04:00
|
|
|
self.assertTrue(new.remove_track(track))
|
|
|
|
self.assertFalse(new.remove_track(track))
|
2021-10-14 17:29:00 -04:00
|
|
|
self.assertEqual(new.get_n_tracks(), 0)
|
2021-10-19 14:48:08 -04:00
|
|
|
self.assertEqual(self.removed, track)
|
2021-10-15 16:06:02 -04:00
|
|
|
|
2021-10-10 13:49:19 -04:00
|
|
|
|
|
|
|
class TestPrevious(unittest.TestCase):
|
2021-10-18 17:25:20 -04:00
|
|
|
def track_added(self, plist, added):
|
|
|
|
self.added = added
|
|
|
|
|
2021-10-19 14:48:08 -04:00
|
|
|
def track_removed(self, plist, removed):
|
|
|
|
self.removed = removed
|
|
|
|
|
2021-10-15 16:06:02 -04:00
|
|
|
def setUp(self): db.reset()
|
|
|
|
|
2021-10-10 13:49:19 -04:00
|
|
|
def test_init(self):
|
|
|
|
previous = db.user.Table.find("Previous")
|
|
|
|
self.assertIsInstance(previous, db.user.UserPlaylist)
|
2021-10-15 16:06:02 -04:00
|
|
|
self.assertIsInstance(previous, db.user.Previous)
|
2021-10-15 10:14:58 -04:00
|
|
|
self.assertEqual(previous.name, "Previous")
|
2021-10-13 17:04:26 -04:00
|
|
|
self.assertEqual(previous.icon_name, "edit-undo")
|
2021-10-15 10:14:58 -04:00
|
|
|
self.assertEqual(previous.map_table, "temp_playlist_map")
|
2021-10-17 16:44:21 -04:00
|
|
|
self.assertEqual(previous.plist_state.sort, [ "temp_playlist_map.rowid DESC" ])
|
2021-10-14 14:18:36 -04:00
|
|
|
self.assertFalse(previous.plist_state.loop)
|
2021-10-10 13:49:19 -04:00
|
|
|
|
2021-10-15 16:06:02 -04:00
|
|
|
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")
|
2021-10-17 16:43:09 -04:00
|
|
|
track2 = db.make_fake_track(2, 2, "Test Track 2", "/a/b/c/2.ogg")
|
2021-10-18 17:25:20 -04:00
|
|
|
previous.connect("track-added", self.track_added)
|
2021-10-14 17:29:00 -04:00
|
|
|
self.assertEqual(previous.get_n_tracks(), 0)
|
|
|
|
|
2021-10-15 16:06:02 -04:00
|
|
|
self.assertTrue(previous.add_track(track1))
|
2021-10-14 17:29:00 -04:00
|
|
|
self.assertEqual(previous.get_n_tracks(), 1)
|
2021-10-17 16:43:09 -04:00
|
|
|
self.assertEqual(previous.get_track(0), track1)
|
2021-10-17 21:48:17 -04:00
|
|
|
self.assertEqual(previous.get_track_index(track1), 0)
|
2021-10-18 17:25:20 -04:00
|
|
|
self.assertEqual(self.added, track1)
|
2021-10-17 16:43:09 -04:00
|
|
|
|
|
|
|
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)
|
2021-10-17 21:48:17 -04:00
|
|
|
self.assertEqual(previous.get_track_index(track2), 0)
|
|
|
|
self.assertEqual(previous.get_track_index(track1), 1)
|
2021-10-18 17:25:20 -04:00
|
|
|
self.assertEqual(self.added, track2)
|
2021-10-15 16:06:02 -04:00
|
|
|
|
2021-10-19 14:48:08 -04:00
|
|
|
previous.connect("track-removed", self.track_removed)
|
2021-10-15 16:06:02 -04:00
|
|
|
self.assertTrue(previous.add_track(track1))
|
2021-10-17 16:43:09 -04:00
|
|
|
self.assertEqual(previous.get_n_tracks(), 2)
|
|
|
|
self.assertEqual(previous.get_track(0), track1)
|
|
|
|
self.assertEqual(previous.get_track(1), track2)
|
2021-10-17 21:48:17 -04:00
|
|
|
self.assertEqual(previous.get_track_index(track1), 0)
|
|
|
|
self.assertEqual(previous.get_track_index(track2), 1)
|
2021-10-19 14:48:08 -04:00
|
|
|
self.assertEqual(self.removed, track1)
|
2021-10-18 17:25:20 -04:00
|
|
|
self.assertEqual(self.added, track1)
|
2021-10-15 16:06:02 -04:00
|
|
|
|
|
|
|
self.assertTrue(previous.remove_track(track1))
|
|
|
|
self.assertFalse(previous.remove_track(track1))
|
2021-10-17 16:43:09 -04:00
|
|
|
self.assertEqual(previous.get_n_tracks(), 1)
|
2021-10-17 21:48:17 -04:00
|
|
|
self.assertEqual(previous.get_track_index(track2), 0)
|
2021-10-19 14:48:08 -04:00
|
|
|
self.assertEqual(self.removed, track1)
|
2021-10-15 16:06:02 -04:00
|
|
|
|
2021-10-10 13:49:19 -04:00
|
|
|
|
|
|
|
class TestQueuedTracks(unittest.TestCase):
|
2021-10-18 17:25:20 -04:00
|
|
|
def track_added(self, plist, added):
|
|
|
|
self.added = added
|
|
|
|
|
2021-10-19 14:48:08 -04:00
|
|
|
def track_removed(self, plist, removed):
|
|
|
|
self.removed = removed
|
|
|
|
|
2021-10-15 16:06:02 -04:00
|
|
|
def setUp(self): db.reset()
|
|
|
|
|
2021-10-10 13:49:19 -04:00
|
|
|
def test_init(self):
|
|
|
|
queued = db.user.Table.find("Queued Tracks")
|
2021-10-15 10:14:58 -04:00
|
|
|
self.assertIsInstance(queued, db.playlist.MappedPlaylist)
|
2021-10-10 13:49:19 -04:00
|
|
|
self.assertIsInstance(queued, db.user.UserPlaylist)
|
2021-10-15 10:14:58 -04:00
|
|
|
self.assertEqual(queued.name, "Queued Tracks")
|
2021-10-13 17:04:26 -04:00
|
|
|
self.assertEqual(queued.icon_name, "edit-redo")
|
2021-10-15 10:14:58 -04:00
|
|
|
self.assertEqual(queued.map_table, "playlist_map")
|
2021-10-17 16:44:21 -04:00
|
|
|
self.assertEqual(queued.plist_state.sort, [ "playlist_map.rowid ASC" ])
|
2021-10-14 14:18:36 -04:00
|
|
|
self.assertFalse(queued.plist_state.loop)
|
2021-10-10 13:49:19 -04:00
|
|
|
|
2021-10-15 16:06:02 -04:00
|
|
|
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")
|
2021-10-18 17:25:20 -04:00
|
|
|
queued.connect("track-added", self.track_added)
|
2021-10-14 17:29:00 -04:00
|
|
|
self.assertEqual(queued.get_n_tracks(), 0)
|
|
|
|
|
2021-10-15 16:06:02 -04:00
|
|
|
self.assertTrue(queued.add_track(track))
|
|
|
|
self.assertFalse(queued.add_track(track))
|
2021-10-14 17:29:00 -04:00
|
|
|
self.assertEqual(queued.get_n_tracks(), 1)
|
2021-10-17 16:43:09 -04:00
|
|
|
self.assertEqual(queued.get_track(0), track)
|
2021-10-17 21:48:17 -04:00
|
|
|
self.assertEqual(queued.get_track_index(track), 0)
|
2021-10-18 17:25:20 -04:00
|
|
|
self.assertEqual(self.added, track)
|
2021-10-14 17:29:00 -04:00
|
|
|
|
2021-10-19 14:48:08 -04:00
|
|
|
queued.connect("track-removed", self.track_removed)
|
2021-10-15 16:06:02 -04:00
|
|
|
self.assertTrue(queued.remove_track(track))
|
|
|
|
self.assertFalse(queued.remove_track(track))
|
2021-10-14 17:29:00 -04:00
|
|
|
self.assertEqual(queued.get_n_tracks(), 0)
|
2021-10-19 14:48:08 -04:00
|
|
|
self.assertEqual(self.removed, track)
|
2021-10-15 16:06:02 -04:00
|
|
|
|
2021-10-10 13:49:19 -04:00
|
|
|
|
|
|
|
class TestUserPlaylist(unittest.TestCase):
|
2021-10-18 17:25:20 -04:00
|
|
|
def track_added(self, plist, added):
|
|
|
|
self.added = added
|
|
|
|
|
2021-10-19 14:48:08 -04:00
|
|
|
def track_removed(self, plist, removed):
|
|
|
|
self.removed = removed
|
|
|
|
|
2021-10-15 16:06:02 -04:00
|
|
|
def setUp(self): db.reset()
|
|
|
|
|
2021-10-10 13:49:19 -04:00
|
|
|
def test_init(self):
|
|
|
|
plist = db.user.Table.find("Test Playlist")
|
2021-10-15 10:14:58 -04:00
|
|
|
self.assertIsInstance(plist, db.playlist.MappedPlaylist)
|
|
|
|
self.assertIsInstance(plist, db.user.UserPlaylist)
|
|
|
|
self.assertEqual(plist.name, "Test Playlist")
|
2021-10-13 17:04:26 -04:00
|
|
|
self.assertEqual(plist.icon_name, "audio-x-generic")
|
2021-10-15 10:14:58 -04:00
|
|
|
self.assertEqual(plist.map_table, "playlist_map")
|
2021-10-14 14:18:36 -04:00
|
|
|
self.assertFalse(plist.plist_state.loop)
|
2021-08-21 16:47:33 -04:00
|
|
|
|
2021-10-16 17:37:23 -04:00
|
|
|
def test_delete(self):
|
2021-10-16 18:33:00 -04:00
|
|
|
track = db.make_fake_track(1, 1, "Test Track", "/a/b/c/1.ogg")
|
2021-10-16 17:37:23 -04:00
|
|
|
plist = db.user.Table.find("Test Playlist")
|
2021-10-16 18:33:00 -04:00
|
|
|
plist.add_track(track)
|
2021-10-16 17:37:23 -04:00
|
|
|
plist.delete()
|
2021-10-16 18:33:00 -04:00
|
|
|
self.assertEqual(plist.get_n_tracks(), 0)
|
2021-10-16 17:37:23 -04:00
|
|
|
self.assertIsNone(db.user.Table.lookup("Test Playlist"))
|
|
|
|
|
2021-10-15 16:06:02 -04:00
|
|
|
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")
|
2021-10-18 17:25:20 -04:00
|
|
|
plist.connect("track-added", self.track_added)
|
2021-10-14 17:29:00 -04:00
|
|
|
self.assertEqual(plist.get_n_tracks(), 0)
|
|
|
|
|
2021-10-15 16:06:02 -04:00
|
|
|
self.assertTrue(plist.add_track(track))
|
|
|
|
self.assertFalse(plist.add_track(track))
|
2021-10-14 17:29:00 -04:00
|
|
|
self.assertEqual(plist.get_n_tracks(), 1)
|
2021-10-17 16:43:09 -04:00
|
|
|
self.assertEqual(plist.get_track(0), track)
|
2021-10-17 21:48:17 -04:00
|
|
|
self.assertEqual(plist.get_track_index(track), 0)
|
2021-10-18 17:25:20 -04:00
|
|
|
self.assertEqual(self.added, track)
|
2021-10-14 17:29:00 -04:00
|
|
|
|
2021-10-19 14:48:08 -04:00
|
|
|
plist.connect("track-removed", self.track_removed)
|
2021-10-15 16:06:02 -04:00
|
|
|
self.assertTrue(plist.remove_track(track))
|
|
|
|
self.assertFalse(plist.remove_track(track))
|
2021-10-14 17:29:00 -04:00
|
|
|
self.assertEqual(plist.get_n_tracks(), 0)
|
2021-10-19 14:48:08 -04:00
|
|
|
self.assertEqual(self.removed, track)
|
2021-10-15 16:06:02 -04:00
|
|
|
|
2021-08-21 16:47:33 -04:00
|
|
|
|
2021-10-07 20:28:34 -04:00
|
|
|
class TestUserTable(unittest.TestCase):
|
2021-08-21 16:47:33 -04:00
|
|
|
def setUp(self):
|
|
|
|
db.reset()
|
|
|
|
|
2021-10-10 13:49:19 -04:00
|
|
|
def test_init(self):
|
|
|
|
table = db.user.UserTable()
|
|
|
|
self.assertIsInstance(table, db.playlist.Model)
|
|
|
|
self.assertEqual(table.table, "playlists")
|
|
|
|
self.assertEqual(table.order, "sort")
|
2021-08-21 16:47:33 -04:00
|
|
|
|
2021-10-10 13:49:19 -04:00
|
|
|
self.assertIsInstance(db.user.Table, db.user.UserTable)
|
|
|
|
db.sql.execute("SELECT playlistid,plstateid,name,sort FROM playlists")
|
2021-08-21 16:47:33 -04:00
|
|
|
|
2021-10-10 13:49:19 -04:00
|
|
|
def test_insert(self):
|
|
|
|
table = db.user.UserTable()
|
|
|
|
playlist = table.find("Test Playlist")
|
2021-08-21 16:47:33 -04:00
|
|
|
|
2021-10-10 13:49:19 -04:00
|
|
|
self.assertIsInstance(playlist, db.user.UserPlaylist)
|
|
|
|
self.assertEqual(playlist._name, "Test Playlist")
|
2021-10-14 13:34:33 -04:00
|
|
|
self.assertEqual(playlist._rowkey, "playlistid")
|
2021-08-22 09:38:14 -04:00
|
|
|
|
2021-10-10 13:49:19 -04:00
|
|
|
with self.assertRaises(sqlite3.IntegrityError):
|
|
|
|
db.user.Table.insert("Test Playlist")
|
2021-08-21 16:47:33 -04:00
|
|
|
|
2021-10-10 13:49:19 -04:00
|
|
|
def test_lookup(self):
|
2021-10-07 20:28:34 -04:00
|
|
|
playlist = db.user.Table.insert("Test Playlist")
|
|
|
|
self.assertEqual(db.user.Table.lookup("Test Playlist"), playlist)
|
|
|
|
self.assertIsNone(db.user.Table.lookup("none"))
|
2021-08-22 09:38:14 -04:00
|
|
|
|
2021-10-10 13:49:19 -04:00
|
|
|
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")
|