129 lines
5.0 KiB
Python
129 lines
5.0 KiB
Python
# Copyright 2021 (c) Anna Schumaker.
|
|
import datetime
|
|
import db
|
|
import lib
|
|
import unittest
|
|
from gi.repository import GObject
|
|
from gi.repository import Gio
|
|
from gi.repository import Gtk
|
|
from . import model
|
|
|
|
class TestChildModel(unittest.TestCase):
|
|
def items_changed(self, table, pos, rm, add):
|
|
self.changed = (pos, rm, add)
|
|
|
|
def setUp(self):
|
|
db.reset()
|
|
|
|
def test_init(self):
|
|
artist = db.artist.Table.find("Test Artist", "Test Sort")
|
|
child = model.ChildModel(artist)
|
|
|
|
self.assertIsInstance(child, GObject.GObject)
|
|
self.assertIsInstance(child, Gio.ListModel)
|
|
|
|
self.assertEqual(child.parent, artist)
|
|
self.assertEqual(child.get_item_type(), GObject.TYPE_PYOBJECT)
|
|
self.assertEqual(child.get_n_items(), 0)
|
|
|
|
def test_children(self):
|
|
artist = db.artist.Table.find("Test Artist", "Test Sort")
|
|
child = model.ChildModel(artist)
|
|
child.connect("items-changed", self.items_changed)
|
|
|
|
album = artist.find_album("Test Album", datetime.date.today())
|
|
self.assertEqual(child.get_n_items(), 1)
|
|
self.assertEqual(child.get_item(0), album)
|
|
self.assertEqual(self.changed, (0, 0, 1))
|
|
|
|
|
|
class TestTreeListModel(unittest.TestCase):
|
|
def test_init(self):
|
|
tree = model.TreeListModel(db.artist.Table)
|
|
self.assertIsInstance(tree, Gtk.TreeListModel)
|
|
self.assertEqual(tree.get_model(), db.artist.Table)
|
|
self.assertFalse(tree.get_autoexpand())
|
|
self.assertFalse(tree.get_passthrough())
|
|
|
|
def test_create_child_func(self):
|
|
artist = db.artist.Table.find("Test Artist", "Test Sort")
|
|
child = model.create_child_func(artist)
|
|
self.assertEqual(child.parent, artist)
|
|
|
|
genre = db.genre.Table.find("Test Genre")
|
|
self.assertIsNone(model.create_child_func(genre))
|
|
|
|
|
|
class TestFilterTableModel(unittest.TestCase):
|
|
def tearDown(self):
|
|
model.TableFilter.set_pattern("")
|
|
|
|
def test_init(self):
|
|
filter = model.FilterTableModel(db.artist.Table)
|
|
self.assertIsInstance(filter, Gtk.FilterListModel)
|
|
self.assertIsInstance(filter.get_model(), Gtk.TreeListModel)
|
|
self.assertEqual(filter.get_table(), db.artist.Table)
|
|
self.assertEqual(filter.get_filter(), model.TableFilter)
|
|
|
|
def test_filter(self):
|
|
artist = db.artist.Table.find("Test Artist", "Test Sort")
|
|
album = artist.find_album("Test Album", datetime.date.today())
|
|
self.assertIsInstance(model.TableFilter, lib.filter.Regex)
|
|
|
|
model.TableFilter.set_pattern("Artist")
|
|
self.assertTrue(model.TableFilter.do_check(artist))
|
|
model.TableFilter.set_pattern("Album")
|
|
self.assertTrue(model.TableFilter.do_check(artist))
|
|
model.TableFilter.set_pattern("Disc")
|
|
self.assertFalse(model.TableFilter.do_check(artist))
|
|
|
|
|
|
class TestTableSelectionModel(unittest.TestCase):
|
|
def test_init(self):
|
|
selection = model.TableSelection(db.artist.Table)
|
|
self.assertIsInstance(selection, Gtk.SingleSelection)
|
|
self.assertIsInstance(selection.get_model(), model.FilterTableModel)
|
|
self.assertEqual(selection.get_table(), db.artist.Table)
|
|
self.assertTrue(selection.get_can_unselect())
|
|
self.assertFalse(selection.get_autoselect())
|
|
|
|
def test_selected_playlist(self):
|
|
db.reset()
|
|
selection = model.TableSelection(db.artist.Table)
|
|
self.assertIsNone(selection.get_selected_playlist())
|
|
|
|
track = db.make_fake_track(1, 1, "Test Track", "/a/b/c/1.ogg")
|
|
selection.set_selected(0)
|
|
self.assertEqual(selection.get_selected_playlist(), track.artist)
|
|
|
|
def test_get_playlist(self):
|
|
selection = model.TableSelection(db.artist.Table)
|
|
track = db.make_fake_track(1, 1, "Test Track", "/a/b/c/1.ogg")
|
|
self.assertEqual(selection.get_playlist(0), track.artist)
|
|
self.assertIsNone(selection.get_playlist(1))
|
|
|
|
|
|
class TestFilterUserModel(unittest.TestCase):
|
|
def test_init(self):
|
|
filter = model.FilterUserModel()
|
|
self.assertIsInstance(filter, Gtk.FilterListModel)
|
|
self.assertIsInstance(filter.get_filter(), model.UserFilter)
|
|
self.assertEqual(filter.get_model(), db.user.Table)
|
|
|
|
def test_filter(self):
|
|
filter = model.UserFilter()
|
|
self.assertFalse(filter.do_match(db.user.Table.find("Collection")))
|
|
self.assertTrue(filter.do_match(db.user.Table.find("Favorites")))
|
|
self.assertFalse(filter.do_match(db.user.Table.find("New Tracks")))
|
|
self.assertFalse(filter.do_match(db.user.Table.find("Previous")))
|
|
self.assertTrue(filter.do_match(db.user.Table.find("Queued Tracks")))
|
|
self.assertTrue(filter.do_match(db.user.Table.find("Test Playlist")))
|
|
|
|
|
|
class TestUserSelectionModel(unittest.TestCase):
|
|
def test_init(self):
|
|
selection = model.UserSelection()
|
|
self.assertIsInstance(selection, Gtk.SingleSelection)
|
|
self.assertIsInstance(selection.get_model(), model.FilterUserModel)
|
|
self.assertEqual(selection.get_selected_item(), db.user.Table.find("Favorites"))
|