186 lines
7.0 KiB
Python
186 lines
7.0 KiB
Python
# Copyright 2022 (c) Anna Schumaker.
|
|
"""Tests our year Gio.ListModel."""
|
|
import pathlib
|
|
import unittest
|
|
import emmental.db
|
|
import tests.util
|
|
|
|
|
|
class TestYearObject(tests.util.TestCase):
|
|
"""Tests our year object."""
|
|
|
|
def setUp(self):
|
|
"""Set up common variables."""
|
|
super().setUp()
|
|
self.table = self.sql.years
|
|
self.year = emmental.db.years.Year(table=self.table, propertyid=123,
|
|
year=2023, name="2023")
|
|
|
|
def test_init(self):
|
|
"""Test that the Year is set up properly."""
|
|
self.assertIsInstance(self.year, emmental.db.playlist.Playlist)
|
|
self.assertEqual(self.year.table, self.table)
|
|
self.assertEqual(self.year.propertyid, 123)
|
|
self.assertEqual(self.year.year, 2023)
|
|
self.assertEqual(self.year.primary_key, 2023)
|
|
self.assertEqual(self.year.name, "2023")
|
|
|
|
def test_parent(self):
|
|
"""Test finding the parent Decade for this Year."""
|
|
self.assertIsNone(self.year.parent)
|
|
decade = self.sql.decades.create(2020)
|
|
self.assertEqual(self.year.parent, decade)
|
|
|
|
|
|
class TestYearTable(tests.util.TestCase):
|
|
"""Tests our year table."""
|
|
|
|
def setUp(self):
|
|
"""Set up common variables."""
|
|
super().setUp()
|
|
self.table = self.sql.years
|
|
|
|
self.album = self.sql.albums.create("Test Album", "Test Artist", "123")
|
|
self.medium = self.sql.media.create(self.album, "", number=1)
|
|
self.library = self.sql.libraries.create(pathlib.Path("/a/b"))
|
|
|
|
def test_init(self):
|
|
"""Test that the year model is configured correctly."""
|
|
self.assertIsInstance(self.table, emmental.db.playlist.Table)
|
|
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 Year playlist."""
|
|
year = self.sql.years.create(2023)
|
|
track = self.sql.tracks.create(self.library,
|
|
pathlib.Path("/a/b/c/1.ogg"),
|
|
self.medium, year)
|
|
|
|
self.assertTrue(self.table.add_track(year, track))
|
|
year2 = self.sql.years.create(2013)
|
|
self.assertFalse(self.table.add_track(year2, track))
|
|
|
|
def test_construct(self):
|
|
"""Test constructing a year playlist."""
|
|
year = self.table.construct(propertyid=1988, year=1988, name="1988")
|
|
self.assertIsInstance(year, emmental.db.years.Year)
|
|
self.assertEqual(year.table, self.table)
|
|
self.assertEqual(year.propertyid, 1988)
|
|
self.assertEqual(year.year, 1988)
|
|
self.assertEqual(year.name, "1988")
|
|
self.assertFalse(year.active)
|
|
self.assertFalse(year.tracks_movable)
|
|
|
|
def test_create(self):
|
|
"""Test creating a year playlist."""
|
|
decade = self.sql.decades.create(1980)
|
|
year = self.table.create(1988)
|
|
self.assertIsInstance(year, emmental.db.years.Year)
|
|
self.assertEqual(year.year, 1988)
|
|
self.assertEqual(year.name, "1988")
|
|
self.assertEqual(year.sort_order,
|
|
"release, albumartist, album, mediumno, number")
|
|
self.assertTrue(year in decade.child_set)
|
|
|
|
cur = self.sql("SELECT COUNT(year) FROM years")
|
|
self.assertEqual(cur.fetchone()["COUNT(year)"], 1)
|
|
|
|
row = self.sql("""SELECT COUNT(*) FROM playlist_properties
|
|
WHERE propertyid=?""", year.propertyid).fetchone()
|
|
self.assertEqual(row["COUNT(*)"], 1)
|
|
|
|
self.assertIsNone(self.table.create(1988))
|
|
|
|
def test_delete(self):
|
|
"""Test deleting a year playlist."""
|
|
decade = self.sql.decades.create(1980)
|
|
year = self.table.create(1988)
|
|
self.assertTrue(year.delete())
|
|
self.assertFalse(year in decade.child_set)
|
|
|
|
cur = self.sql("SELECT COUNT(year) FROM years")
|
|
self.assertEqual(cur.fetchone()["COUNT(year)"], 0)
|
|
self.assertEqual(len(self.table), 0)
|
|
self.assertIsNone(self.table.get_item(0))
|
|
|
|
row = self.sql("""SELECT COUNT(*) FROM playlist_properties
|
|
WHERE propertyid=?""", year.propertyid).fetchone()
|
|
self.assertEqual(row["COUNT(*)"], 0)
|
|
|
|
self.assertFalse(year.delete())
|
|
|
|
def test_filter(self):
|
|
"""Test filtering a year playlist."""
|
|
self.table.create(1985)
|
|
self.table.create(1988)
|
|
|
|
self.table.filter("*5", now=True)
|
|
self.assertSetEqual(self.table.get_filter().keys, {1985})
|
|
self.table.filter("19*", now=True)
|
|
self.assertSetEqual(self.table.get_filter().keys, {1985, 1988})
|
|
|
|
def test_get_sort_key(self):
|
|
"""Test getting a year playlist's sort key."""
|
|
year = self.table.create(1988)
|
|
self.assertEqual(self.table.get_sort_key(year), 1988)
|
|
|
|
def test_get_trackids(self):
|
|
"""Test loading year tracks from the database."""
|
|
year = self.sql.years.create(2023)
|
|
track1 = self.sql.tracks.create(self.library,
|
|
pathlib.Path("/a/b/c/1.ogg"),
|
|
self.medium, year)
|
|
track2 = self.sql.tracks.create(self.library,
|
|
pathlib.Path("/a/b/c/2.ogg"),
|
|
self.medium, year)
|
|
self.assertSetEqual(self.table.get_trackids(year),
|
|
{track1.trackid, track2.trackid})
|
|
|
|
def test_load(self):
|
|
"""Test loading the year table from the database."""
|
|
self.table.create(1985)
|
|
self.table.create(1988)
|
|
|
|
years2 = emmental.db.years.Table(self.sql)
|
|
self.assertEqual(len(years2), 0)
|
|
|
|
years2.load(now=True)
|
|
self.assertEqual(len(years2), 2)
|
|
|
|
self.assertEqual(years2.get_item(0).year, 1985)
|
|
self.assertEqual(years2.get_item(0).name, "1985")
|
|
|
|
self.assertEqual(years2.get_item(1).year, 1988)
|
|
self.assertEqual(years2.get_item(1).name, "1988")
|
|
|
|
def test_lookup(self):
|
|
"""Test looking up year playlists."""
|
|
year = self.table.create(1988)
|
|
self.assertEqual(self.table.lookup(1988), year)
|
|
self.assertIsNone(self.table.lookup(1985))
|
|
|
|
def test_remove_track(self):
|
|
"""Test removing a Track from the Year."""
|
|
year = self.table.create(2023)
|
|
self.assertTrue(self.table.remove_track(year, unittest.mock.Mock()))
|
|
|
|
def test_update(self):
|
|
"""Test updating year attributes."""
|
|
year = self.table.create(1980)
|
|
year.active = True
|
|
year.loop = "Track"
|
|
year.shuffle = True
|
|
year.sort_order = "trackid"
|
|
|
|
row = self.sql("""SELECT active, loop, shuffle,
|
|
sort_order, current_trackid
|
|
FROM years_view WHERE year=?""",
|
|
year.year).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"])
|