278 lines
12 KiB
Python
278 lines
12 KiB
Python
# Copyright 2022 (c) Anna Schumaker.
|
|
"""Tests our medium Gio.ListModel."""
|
|
import pathlib
|
|
import unittest.mock
|
|
import emmental.db
|
|
import tests.util
|
|
from gi.repository import Gtk
|
|
|
|
|
|
class TestMediumObject(tests.util.TestCase):
|
|
"""Tests our medium object."""
|
|
|
|
def setUp(self):
|
|
"""Set up common variables."""
|
|
super().setUp()
|
|
self.table = self.sql.media
|
|
self.medium = emmental.db.media.Medium(table=self.table, name="",
|
|
mediumid=123, propertyid=456)
|
|
|
|
def test_init(self):
|
|
"""Test that the Media is set up properly."""
|
|
self.assertIsInstance(self.medium, emmental.db.playlist.Playlist)
|
|
self.assertEqual(self.medium.table, self.table)
|
|
self.assertEqual(self.medium.propertyid, 456)
|
|
self.assertEqual(self.medium.mediumid, 123)
|
|
self.assertEqual(self.medium.primary_key, 123)
|
|
self.assertEqual(self.medium.albumid, 0)
|
|
self.assertEqual(self.medium.number, 1)
|
|
self.assertEqual(self.medium.name, "")
|
|
self.assertEqual(self.medium.type, "")
|
|
|
|
def test_get_album(self):
|
|
"""Test getting this Medium's Album."""
|
|
self.assertIsNone(self.medium.get_album())
|
|
self.assertIsNone(self.medium.parent)
|
|
|
|
album = self.sql.albums.create("Test Album", "Album Artist", "2023")
|
|
self.medium.albumid = album.albumid
|
|
self.assertEqual(self.medium.get_album(), album)
|
|
self.assertEqual(self.medium.parent, album)
|
|
|
|
def test_rename(self):
|
|
"""Test the rename() function."""
|
|
with unittest.mock.patch.object(self.table, "rename",
|
|
return_value=True) as mock_rename:
|
|
self.assertTrue(self.medium.rename("New Name"))
|
|
mock_rename.assert_called_with(self.medium, "New Name")
|
|
|
|
|
|
class TestFilter(tests.util.TestCase):
|
|
"""Test the medium filter."""
|
|
|
|
def setUp(self):
|
|
"""Set up common variables."""
|
|
super().setUp()
|
|
self.filter = emmental.db.media.Filter()
|
|
|
|
def test_init(self):
|
|
"""Test that the filter is initialized properly."""
|
|
self.assertIsInstance(self.filter, emmental.db.table.KeySet)
|
|
|
|
def test_strictness(self):
|
|
"""Test checking strictness."""
|
|
self.filter.keys = None
|
|
self.assertEqual(self.filter.get_strictness(), Gtk.FilterMatch.SOME)
|
|
self.filter.keys = set()
|
|
self.assertEqual(self.filter.get_strictness(), Gtk.FilterMatch.NONE)
|
|
self.filter.keys = {1, 2, 3}
|
|
self.assertEqual(self.filter.get_strictness(), Gtk.FilterMatch.SOME)
|
|
|
|
def test_match(self):
|
|
"""Test matching a Medium."""
|
|
album = self.sql.albums.create("Test Album", "Test Artist", "123")
|
|
medium = self.sql.media.create(album, "", number=1)
|
|
self.assertFalse(self.filter.match(medium))
|
|
medium.name = "abcde"
|
|
self.assertTrue(self.filter.match(medium))
|
|
|
|
|
|
class TestMediumsTable(tests.util.TestCase):
|
|
"""Tests our mediums table."""
|
|
|
|
def setUp(self):
|
|
"""Set up common variables."""
|
|
super().setUp()
|
|
self.album = self.sql.albums.create("Test Album", "Test Artist", "123")
|
|
self.table = self.sql.media
|
|
|
|
self.library = self.sql.libraries.create(pathlib.Path("/a/b"))
|
|
self.year = self.sql.years.create(2023)
|
|
|
|
def test_init(self):
|
|
"""Test that the medium model is configured corretly."""
|
|
self.assertIsInstance(self.table, emmental.db.playlist.Table)
|
|
self.assertIsInstance(self.table.get_filter(),
|
|
emmental.db.media.Filter)
|
|
self.assertEqual(len(self.table), 0)
|
|
self.assertTrue(self.table.autodelete)
|
|
self.assertFalse(self.table.system_tracks)
|
|
|
|
def test_add_track(self):
|
|
"""Test adding a Track to a Medium playlist."""
|
|
medium = self.table.create(self.album, "", number=1)
|
|
track = self.sql.tracks.create(self.library, pathlib.Path("1.ogg"),
|
|
medium, self.year)
|
|
self.assertTrue(self.table.add_track(medium, track))
|
|
|
|
medium2 = self.table.create(self.album, "", number=2)
|
|
self.assertFalse(self.table.add_track(medium2, track))
|
|
|
|
def test_construct(self):
|
|
"""Test constructing a medium playlist."""
|
|
medium = self.table.construct(mediumid=1, propertyid=1,
|
|
albumid=self.album.albumid,
|
|
name="Medium 2", number=2, type="CD")
|
|
self.assertIsInstance(medium, emmental.db.media.Medium)
|
|
self.assertEqual(medium.table, self.table)
|
|
self.assertEqual(medium.propertyid, 1)
|
|
self.assertEqual(medium.mediumid, 1)
|
|
self.assertEqual(medium.albumid, self.album.albumid)
|
|
self.assertEqual(medium.name, "Medium 2")
|
|
self.assertEqual(medium.number, 2)
|
|
self.assertEqual(medium.type, "CD")
|
|
self.assertFalse(medium.tracks_movable)
|
|
|
|
def test_create(self):
|
|
"""Test creating a medium playlist."""
|
|
medium1 = self.table.create(self.album, "", number=1)
|
|
self.assertIsInstance(medium1, emmental.db.media.Medium)
|
|
self.assertEqual(medium1.albumid, self.album.albumid)
|
|
self.assertEqual(medium1.name, "")
|
|
self.assertEqual(medium1.number, 1)
|
|
self.assertEqual(medium1.type, "")
|
|
self.assertEqual(medium1.sort_order, "mediumno, number")
|
|
self.assertTrue(self.album.has_medium(medium1))
|
|
|
|
cur = self.sql("SELECT COUNT(name) FROM media")
|
|
self.assertEqual(cur.fetchone()["COUNT(name)"], 1)
|
|
|
|
row = self.sql("""SELECT COUNT(*) FROM playlist_properties
|
|
WHERE propertyid=?""", medium1.propertyid).fetchone()
|
|
self.assertEqual(row["COUNT(*)"], 1)
|
|
|
|
medium2 = self.table.create(self.album, "Test Medium",
|
|
number=2, type="CD")
|
|
self.assertEqual(medium2.name, "Test Medium")
|
|
self.assertEqual(medium2.number, 2)
|
|
self.assertEqual(medium2.type, "CD")
|
|
|
|
cur = self.sql("SELECT COUNT(name) FROM media")
|
|
self.assertEqual(cur.fetchone()["COUNT(name)"], 2)
|
|
|
|
self.assertIsNone(self.table.create(self.album, "", number=1))
|
|
|
|
def test_delete(self):
|
|
"""Test deleting a medium playlist."""
|
|
medium = self.table.create(self.album, "Medium 1", number=1)
|
|
self.assertTrue(medium.delete())
|
|
self.assertIsNone(self.table.index(medium))
|
|
self.assertFalse(self.album.has_medium(medium))
|
|
|
|
cur = self.sql("SELECT COUNT(name) FROM media")
|
|
self.assertEqual(cur.fetchone()["COUNT(name)"], 0)
|
|
self.assertEqual(len(self.table), 0)
|
|
self.assertIsNone(self.table.get_item(0))
|
|
|
|
row = self.sql("""SELECT COUNT(*) FROM playlist_properties
|
|
WHERE propertyid=?""", medium.propertyid).fetchone()
|
|
self.assertEqual(row["COUNT(*)"], 0)
|
|
|
|
self.assertFalse(medium.delete())
|
|
|
|
def test_get_trackids(self):
|
|
"""Test loading medium tracks from the database."""
|
|
medium = self.table.create(self.album, "", number=1)
|
|
track1 = self.sql.tracks.create(self.library, pathlib.Path("1.ogg"),
|
|
medium, self.year)
|
|
track2 = self.sql.tracks.create(self.library, pathlib.Path("2.ogg"),
|
|
medium, self.year)
|
|
self.assertSetEqual(self.table.get_trackids(medium),
|
|
{track1.trackid, track2.trackid})
|
|
|
|
def test_filter(self):
|
|
"""Test filtering medium playlists."""
|
|
self.table.create(self.album, "Medium 1", number=1)
|
|
self.table.create(self.album, "Medium 2", number=2)
|
|
self.table.create(self.album, "", number=3)
|
|
|
|
self.table.filter("*1", now=True)
|
|
self.assertSetEqual(self.table.get_filter().keys, {1})
|
|
self.table.filter("medium*", now=True)
|
|
self.assertSetEqual(self.table.get_filter().keys, {1, 2})
|
|
|
|
def test_get_sort_key(self):
|
|
"""Test getting a medium's sort key."""
|
|
medium = self.table.create(self.album, "Medium 2", number=2)
|
|
self.assertTupleEqual(self.table.get_sort_key(medium),
|
|
(1, 2, ("medium", "2"), ""))
|
|
|
|
def test_load(self):
|
|
"""Test loading mediums from the database."""
|
|
self.table.create(self.album, "", number=1)
|
|
self.table.create(self.album, "Medium 2", number=2,
|
|
type="Digital Media")
|
|
|
|
mediums2 = emmental.db.media.Table(self.sql)
|
|
self.assertEqual(len(mediums2), 0)
|
|
|
|
mediums2.load(now=True)
|
|
self.assertEqual(len(mediums2.store), 2)
|
|
|
|
self.assertEqual(mediums2.store.get_item(0).albumid,
|
|
self.album.albumid)
|
|
self.assertEqual(mediums2.store.get_item(0).name, "")
|
|
self.assertEqual(mediums2.store.get_item(0).number, 1)
|
|
self.assertEqual(mediums2.store.get_item(0).type, "")
|
|
|
|
self.assertEqual(mediums2.store.get_item(1).albumid,
|
|
self.album.albumid)
|
|
self.assertEqual(mediums2.store.get_item(1).name, "Medium 2")
|
|
self.assertEqual(mediums2.store.get_item(1).number, 2)
|
|
self.assertEqual(mediums2.store.get_item(1).type, "Digital Media")
|
|
|
|
def test_lookup(self):
|
|
"""Test looking up medium playlists."""
|
|
medium1 = self.table.create(self.album, "Test Medium",
|
|
number=1, type="CD")
|
|
medium2 = self.table.create(self.album, "", number=2,
|
|
type="Digital Media")
|
|
|
|
self.assertEqual(self.table.lookup(self.album, number=1,
|
|
type="CD"), medium1)
|
|
self.assertEqual(self.table.lookup(self.album, number=2,
|
|
type="Digital Media"), medium2)
|
|
self.assertIsNone(self.table.lookup(self.album, number=3,
|
|
type="Enhanced CD"))
|
|
|
|
def test_remove_track(self):
|
|
"""Test removing a Track from the Medium."""
|
|
medium = self.table.create(self.album, "Test Medium",
|
|
number=1, type="CD")
|
|
self.assertTrue(self.table.remove_track(medium, unittest.mock.Mock()))
|
|
|
|
def test_rename(self):
|
|
"""Test renaming a medium playlist."""
|
|
medium1 = self.table.create(self.album, "Medium 1",
|
|
number=1, type="CD")
|
|
medium2 = self.table.create(self.album, "Medium 2",
|
|
number=1, type="Digital Medium")
|
|
|
|
self.assertTrue(medium1.rename("Medium 3"))
|
|
self.assertEqual(medium1.name, "Medium 3")
|
|
self.assertIsNone(self.sql("SELECT name FROM media WHERE name=?",
|
|
"Test Medium").fetchone())
|
|
|
|
self.assertListEqual(self.table.store.items, [medium2, medium1])
|
|
|
|
self.assertFalse(medium1.rename("Medium 3"))
|
|
|
|
def test_update(self):
|
|
"""Test updating medium attributes."""
|
|
medium = self.table.create(self.album, "Test Medium",
|
|
number=1, type="CD")
|
|
medium.active = True
|
|
medium.loop = "Track"
|
|
medium.shuffle = True
|
|
medium.sort_order = "trackid"
|
|
|
|
row = self.sql("""SELECT active, loop, shuffle,
|
|
sort_order, current_trackid
|
|
FROM media_view WHERE mediumid=?""",
|
|
medium.mediumid).fetchone()
|
|
self.assertTrue(row["active"])
|
|
self.assertEqual(row["loop"], "Track")
|
|
self.assertTrue(row["shuffle"])
|
|
self.assertEqual(row["sort_order"], "trackid")
|
|
self.assertIsNone(row["current_trackid"])
|