152 lines
6.1 KiB
Python
152 lines
6.1 KiB
Python
# Copyright 2021 (c) Anna Schumaker.
|
|
import db
|
|
import sqlite3
|
|
import unittest
|
|
from gi.repository import GObject
|
|
|
|
expected = [ (1, 1, "Collection", "collection", 0, 1),
|
|
(2, 2, "Favorites", "favorites", 0, 0),
|
|
(3, 3, "New Tracks", "new tracks", 0, 0),
|
|
(4, 4, "Previous", "previous", 0, 0),
|
|
(5, 5, "Queued Tracks", "queued tracks", 0, 0) ]
|
|
|
|
|
|
class TestPlaylistTable(unittest.TestCase):
|
|
def setUp(self):
|
|
db.reset()
|
|
|
|
def test_playlist_table_init(self):
|
|
self.assertIsInstance(db.playlist.Table, db.playlist.PlaylistTable)
|
|
self.assertEqual(db.playlist.Default, [ "Collection", "Favorites", "New Tracks",
|
|
"Previous", "Queued Tracks" ])
|
|
|
|
cur = db.execute("SELECT playlistid, "
|
|
"playlists.plstateid, "
|
|
"name, "
|
|
"playlists.sort, "
|
|
"random,loop "
|
|
"FROM playlists "
|
|
"JOIN playlist_states "
|
|
"ON playlists.plstateid = playlist_states.plstateid")
|
|
rows = cur.fetchall()
|
|
self.assertEqual(tuple(rows[0]), expected[0])
|
|
self.assertEqual(tuple(rows[1]), expected[1])
|
|
self.assertEqual(tuple(rows[2]), expected[2])
|
|
self.assertEqual(tuple(rows[3]), expected[3])
|
|
self.assertEqual(tuple(rows[4]), expected[4])
|
|
|
|
def test_playlist_table_insert(self):
|
|
playlist = db.playlist.Table.insert("Test Playlist")
|
|
self.assertIsInstance(playlist, db.playlist.Playlist)
|
|
self.assertIsInstance(playlist, db.objects.Tag)
|
|
|
|
self.assertEqual(playlist.name, "Test Playlist")
|
|
self.assertEqual(playlist.sort, "test playlist")
|
|
self.assertIsInstance(playlist.playlist_state, db.state.PlaylistState)
|
|
|
|
with self.assertRaises(sqlite3.IntegrityError):
|
|
db.playlist.Table.insert("Test Playlist")
|
|
|
|
def test_playlist_table_delete(self):
|
|
playlist = db.playlist.Table.find("Test Playlist")
|
|
track = db.make_fake_track(1, 1.234, "Test Title", "/a/b.cde")
|
|
|
|
db.playlist.Map.insert(playlist, track)
|
|
db.playlist.TempMap.insert(playlist, track)
|
|
db.playlist.Table.delete(playlist)
|
|
|
|
self.assertIsNone(db.playlist.Table.lookup("Test Playlist"))
|
|
self.assertEqual(db.playlist.Map.lookup_playlists(track), [ ])
|
|
self.assertEqual(db.playlist.TempMap.lookup_playlists(track), [ ])
|
|
|
|
def test_playlist_table_get(self):
|
|
playlist = db.playlist.Playlist(1)
|
|
self.assertEqual(db.playlist.Table.get(1), playlist)
|
|
self.assertIsNone(db.playlist.Table.get(6))
|
|
|
|
def test_playlist_table_lookup(self):
|
|
playlist = db.playlist.Table.insert("Test Playlist")
|
|
self.assertEqual(db.playlist.Table.lookup("Test Playlist"), playlist)
|
|
self.assertIsNone(db.playlist.Table.lookup("none"))
|
|
|
|
def test_playlist_create_default_playlists(self):
|
|
db.playlist.Table.create_default_playlists()
|
|
|
|
|
|
class TestPlaylistMap(unittest.TestCase):
|
|
def setUp(self):
|
|
db.reset()
|
|
|
|
def test_playlist_map_init(self):
|
|
self.assertIsInstance(db.playlist.Map, db.playlist.PlaylistMap)
|
|
self.assertIsInstance(db.playlist.TempMap, db.playlist.PlaylistMap)
|
|
|
|
self.assertEqual(db.playlist.Map.map_lhs, db.playlist.Playlist)
|
|
self.assertEqual(db.playlist.Map.map_rhs, db.track.Track)
|
|
|
|
self.assertFalse(db.playlist.Map.temporary)
|
|
self.assertTrue( db.playlist.TempMap.temporary)
|
|
|
|
db.execute("SELECT playlistid,trackid FROM playlist_map")
|
|
db.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.playlist.Table.find("Collection")
|
|
|
|
db.playlist.Map.insert(collection, track)
|
|
with self.assertRaises(sqlite3.IntegrityError):
|
|
db.playlist.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.playlist.Table.find("Test Playlist")
|
|
|
|
db.playlist.Map.insert(playlist, track)
|
|
db.playlist.Map.delete(playlist, track)
|
|
self.assertEqual(db.playlist.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.playlist.Table.find("Collection")
|
|
|
|
db.playlist.Map.insert(playlist, track1)
|
|
db.playlist.Map.insert(playlist, track2)
|
|
|
|
lookup_res = db.playlist.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.playlist.Table.find("Collection")
|
|
favorites = db.playlist.Table.find("Favorites")
|
|
|
|
db.playlist.Map.insert(collection, track)
|
|
db.playlist.Map.insert(favorites, track)
|
|
|
|
lookup_res = db.playlist.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.playlist.Table.find("Collection")
|
|
favorites = db.playlist.Table.find("Favorites")
|
|
|
|
db.playlist.Map.insert(collection, track)
|
|
db.playlist.Map.insert(favorites, track)
|
|
|
|
db.playlist.Map.delete_track(track)
|
|
self.assertEqual(db.playlist.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.playlist.Table.find("Collection")
|
|
|
|
db.playlist.Map.insert(playlist, track1)
|
|
db.playlist.Map.insert(playlist, track2)
|
|
|
|
db.playlist.Map.delete_playlist(playlist)
|
|
self.assertEqual(db.playlist.Map.lookup_tracks(playlist), [ ])
|