db: Create a PlaylistTable and Playlist object

And populate the table with some default playlist values.

Signed-off-by: Anna Schumaker <Anna@NoWheyCreamery.com>

db/__init__.py

@@ -20,6 +20,7 @@ from . import decade
 from . import year
 from . import library
 from . import track
+from . import playlist
 
 def make_fake_track(trackno, length, title, path, lib="/a/b/c", art="Test Artist",
                     alb="Test Album", disk=1, subtitle=None, yeer=2021):
@@ -32,7 +33,7 @@ def make_fake_track(trackno, length, title, path, lib="/a/b/c", art="Test Artist
                               length, title, pathlib.Path(path))
 
 def reset():
-    mods = [ artist, album, disc, genre, decade, year, library, track ]
+    mods = [ artist, album, disc, genre, decade, year, library, track, playlist ]
 
     for mod in mods: mod.Table.drop()
     for mod in mods: mod.Table.do_create()

db/playlist.py

@@ -0,0 +1,58 @@
+# Copyright 2021 (c) Anna Schumaker.
+#
+# Table: playlists
+# +------   ---+------+------+
+# | playlistid | name | sort |
+# +--------   -+------+------+
+#
+# Index: playlist_index
+# +--------------------+
+# | name -> playlistid |
+# +--------------------+
+from . import execute
+from . import executemany
+from . import objects
+from . import track
+
+Default = [ "Collection", "Favorites", "New Tracks",
+            "Previous", "Queued Tracks" ]
+
+
+class Playlist(objects.Tag):
+    def do_get_column(self, column):
+        return execute(f"SELECT {column} FROM playlists "
+                        "WHERE playlistid=?", [ self.rowid ])
+
+
+class PlaylistTable(objects.Table):
+    def __init__(self):
+        objects.Table.__init__(self, "playlists", Playlist)
+
+    def do_create(self):
+        execute("CREATE TABLE IF NOT EXISTS playlists "
+                   "(playlistid INTEGER PRIMARY KEY, "
+                   " name TEXT UNIQUE, "
+                   " sort TEXT)")
+        execute("CREATE INDEX IF NOT EXISTS playlist_index "
+                "ON playlists(name)")
+        executemany("INSERT OR IGNORE INTO playlists (name, sort) "
+                    "VALUES (?, ?)",
+                    [ (p, p.casefold()) for p in Default ])
+
+    def do_insert(self, name):
+        return execute("INSERT INTO playlists (name, sort) "
+                       "VALUES (?, ?)", (name, name.casefold()))
+
+    def do_delete(self, playlist):
+        return execute("DELETE FROM playlists WHERE playlistid=?", [ int(playlist) ])
+
+    def do_get(self, rowid):
+        return execute("SELECT playlistid FROM playlists "
+                       "WHERE playlistid=?", [ rowid ])
+
+    def do_lookup(self, name):
+        return execute("SELECT playlistid FROM playlists "
+                       "WHERE name=?", [ name ])
+
+
+Table = PlaylistTable()

db/test_playlist.py

@@ -0,0 +1,55 @@
+# Copyright 2021 (c) Anna Schumaker.
+import db
+import sqlite3
+import unittest
+from gi.repository import GObject
+
+expected = [ (1, "Collection",    "collection"),
+             (2, "Favorites",     "favorites"),
+             (3, "New Tracks",    "new tracks"),
+             (4, "Previous",      "previous"),
+             (5, "Queued Tracks", "queued tracks") ]
+
+
+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" ])
+
+        rows = db.execute("SELECT playlistid,name,sort "
+                          "FROM playlists").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")
+
+        with self.assertRaises(sqlite3.IntegrityError):
+            db.playlist.Table.insert("Test Playlist")
+
+    def test_playlist_table_delete(self):
+        playlist = db.playlist.Table.find("Test Playlist")
+        db.playlist.Table.delete(playlist)
+        self.assertIsNone(db.playlist.Table.lookup("Test Playlist"))
+
+    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"))