159 lines
5.7 KiB
Python
159 lines
5.7 KiB
Python
# Copyright 2021 (c) Anna Schumaker.
|
|
import db
|
|
import sqlite3
|
|
import unittest
|
|
from gi.repository import GObject
|
|
|
|
class TestCollection(unittest.TestCase):
|
|
def test_init(self):
|
|
collection = db.user.Table.find("Collection")
|
|
self.assertIsInstance(collection, db.user.UserPlaylist)
|
|
|
|
|
|
class TestFavorites(unittest.TestCase):
|
|
def test_init(self):
|
|
favorites = db.user.Table.find("Favorites")
|
|
self.assertIsInstance(favorites, db.user.UserPlaylist)
|
|
|
|
|
|
class TestNewTracks(unittest.TestCase):
|
|
def test_init(self):
|
|
new = db.user.Table.find("New Tracks")
|
|
self.assertIsInstance(new, db.user.UserPlaylist)
|
|
|
|
|
|
class TestPrevious(unittest.TestCase):
|
|
def test_init(self):
|
|
previous = db.user.Table.find("Previous")
|
|
self.assertIsInstance(previous, db.user.UserPlaylist)
|
|
|
|
|
|
class TestQueuedTracks(unittest.TestCase):
|
|
def test_init(self):
|
|
queued = db.user.Table.find("Queued Tracks")
|
|
self.assertIsInstance(queued, db.user.UserPlaylist)
|
|
|
|
|
|
class TestUserPlaylist(unittest.TestCase):
|
|
def test_init(self):
|
|
plist = db.user.Table.find("Test Playlist")
|
|
self.assertIsInstance(plist, db.playlist.Playlist)
|
|
self.assertEqual(plist._name, "Test Playlist")
|
|
self.assertEqual(plist.get_property("name"), "Test Playlist")
|
|
|
|
|
|
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")
|
|
|
|
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")
|
|
|
|
|
|
class TestPlaylistMap(unittest.TestCase):
|
|
def setUp(self):
|
|
db.reset()
|
|
|
|
def test_playlist_map_init(self):
|
|
self.assertIsInstance(db.user.Map, db.user.PlaylistMap)
|
|
self.assertIsInstance(db.user.TempMap, db.user.PlaylistMap)
|
|
|
|
self.assertEqual(db.user.Map.map_lhs, db.user.Table.get)
|
|
self.assertEqual(db.user.Map.map_rhs, db.track.Table.get)
|
|
|
|
self.assertFalse(db.user.Map.temporary)
|
|
self.assertTrue( db.user.TempMap.temporary)
|
|
|
|
db.sql.execute("SELECT playlistid,trackid FROM playlist_map")
|
|
db.sql.execute("SELECT playlistid,trackid FROM temp_playlist_map")
|
|
|
|
def test_playlist_map_insert(self):
|
|
track = db.make_fake_track(1, 1.234, "Test Title", "/a/b.cde")
|
|
collection = db.user.Table.find("Collection")
|
|
|
|
db.user.Map.insert(collection, track)
|
|
with self.assertRaises(sqlite3.IntegrityError):
|
|
db.user.Map.insert(collection, track)
|
|
|
|
def test_playlist_map_delete(self):
|
|
track = db.make_fake_track(1, 1.234, "Test Title", "/a/b.cde")
|
|
playlist = db.user.Table.find("Test Playlist")
|
|
|
|
db.user.Map.insert(playlist, track)
|
|
db.user.Map.delete(playlist, track)
|
|
self.assertEqual(db.user.Map.lookup_tracks(playlist), [ ])
|
|
|
|
def test_playlist_map_lookup_tracks(self):
|
|
track1 = db.make_fake_track(1, 1.234, "Test Title", "/a/b.cde")
|
|
track2 = db.make_fake_track(2, 2.345, "Test Title 2", "/a/c.def")
|
|
playlist = db.user.Table.find("Collection")
|
|
|
|
db.user.Map.insert(playlist, track1)
|
|
db.user.Map.insert(playlist, track2)
|
|
|
|
lookup_res = db.user.Map.lookup_tracks(playlist)
|
|
self.assertEqual(lookup_res, [ track1, track2 ])
|
|
|
|
def test_playlist_map_lookup_playlists(self):
|
|
track = db.make_fake_track(1, 1.234, "Test Title", "/a/b.cde")
|
|
collection = db.user.Table.find("Collection")
|
|
favorites = db.user.Table.find("Favorites")
|
|
|
|
db.user.Map.insert(collection, track)
|
|
db.user.Map.insert(favorites, track)
|
|
|
|
lookup_res = db.user.Map.lookup_playlists(track)
|
|
self.assertEqual(lookup_res, [ collection, favorites ])
|
|
|
|
def test_playlist_map_delete_track(self):
|
|
track = db.make_fake_track(1, 1.234, "Test Title", "/a/b.cde")
|
|
collection = db.user.Table.find("Collection")
|
|
favorites = db.user.Table.find("Favorites")
|
|
|
|
db.user.Map.insert(collection, track)
|
|
db.user.Map.insert(favorites, track)
|
|
|
|
db.user.Map.delete_track(track)
|
|
self.assertEqual(db.user.Map.lookup_playlists(track), [ ])
|
|
|
|
def test_playlist_map_delete_playlist(self):
|
|
track1 = db.make_fake_track(1, 1.234, "Test Title", "/a/b.cde")
|
|
track2 = db.make_fake_track(2, 2.345, "Test Title 2", "/a/c.def")
|
|
playlist = db.user.Table.find("Collection")
|
|
|
|
db.user.Map.insert(playlist, track1)
|
|
db.user.Map.insert(playlist, track2)
|
|
|
|
db.user.Map.delete_playlist(playlist)
|
|
self.assertEqual(db.user.Map.lookup_tracks(playlist), [ ])
|