354 lines
15 KiB
Python
354 lines
15 KiB
Python
# Copyright 2021 (c) Anna Schumaker.
|
|
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 TestPlaylistModel(unittest.TestCase):
|
|
def items_changed(self, mod, pos, rm, add): self.changed = (pos, rm, add)
|
|
def setUp(self): db.reset()
|
|
|
|
def test_init(self):
|
|
plist = model.PlaylistModel()
|
|
self.assertIsInstance(plist, Gio.ListModel)
|
|
self.assertIsNone(plist.playlist)
|
|
self.assertEqual(plist.tracks, [ ])
|
|
|
|
self.assertEqual(plist.get_item_type(), GObject.TYPE_PYOBJECT)
|
|
self.assertEqual(plist.get_n_items(), 0)
|
|
self.assertIsNone(plist.get_item(0))
|
|
|
|
def test_set_playlist(self):
|
|
test1 = db.user.Table.find("Test Playlist 1")
|
|
test2 = db.user.Table.find("Test Playlist 2")
|
|
track = db.make_fake_track(1, 1, "Test Track 1", "/a/b/c/1.ogg")
|
|
plist = model.PlaylistModel()
|
|
|
|
test1.add_track(track)
|
|
plist.set_playlist(test1)
|
|
self.assertEqual(plist.playlist, test1)
|
|
self.assertEqual(plist.get_playlist(), test1)
|
|
self.assertEqual(plist.tracks, [ track ])
|
|
|
|
plist.set_playlist(test2)
|
|
self.assertEqual(plist.tracks, [ ])
|
|
test1.add_track(db.make_fake_track(2, 2, "Test Track 2", "/a/b/c/2.ogg"))
|
|
self.assertEqual(plist.tracks, [ ])
|
|
|
|
def test_add_remove(self):
|
|
test = db.user.Table.find("Test Playlist")
|
|
track = db.make_fake_track(1, 1, "Test Track", "/a/b/c/1.ogg")
|
|
plist = model.PlaylistModel()
|
|
plist.set_playlist(test)
|
|
plist.connect("items-changed", self.items_changed)
|
|
|
|
test.add_track(track)
|
|
self.assertEqual(plist.get_n_items(), 1)
|
|
self.assertEqual(plist.get_item(0), track)
|
|
self.assertEqual(self.changed, (0, 0, 1))
|
|
|
|
test.remove_track(track)
|
|
self.assertEqual(plist.get_n_items(), 0)
|
|
self.assertEqual(self.changed, (0, 1, 0))
|
|
|
|
def test_refresh(self):
|
|
test = db.user.Table.find("Test Playlist")
|
|
track = db.make_fake_track(1, 1, "Test Track", "/a/b/c/1.ogg")
|
|
plist = model.PlaylistModel()
|
|
|
|
test.add_track(track)
|
|
plist.set_playlist(test)
|
|
plist.connect("items-changed", self.items_changed)
|
|
test.refresh()
|
|
self.assertEqual(self.changed, (0, 1, 1))
|
|
|
|
|
|
class TestFilterPlaylistModel(unittest.TestCase):
|
|
def setUp(self):
|
|
db.reset()
|
|
model.PlaylistFilter.set_pattern("")
|
|
|
|
def test_init(self):
|
|
filter = model.FilterPlaylistModel()
|
|
self.assertIsInstance(filter, Gtk.FilterListModel)
|
|
self.assertIsInstance(filter.get_model(), model.PlaylistModel)
|
|
self.assertEqual(filter.get_filter(), model.PlaylistFilter)
|
|
self.assertIsNone(filter.get_playlist())
|
|
|
|
filter.set_playlist(db.user.Table.find("Test"))
|
|
self.assertEqual(filter.get_playlist(), db.user.Table.find("Test"))
|
|
|
|
def test_filter(self):
|
|
track = db.make_fake_track(1, 1, "Test Track", "/a/b/c/1.ogg",
|
|
subtitle="Test Subtitle")
|
|
self.assertIsInstance(model.PlaylistFilter, lib.filter.Regex)
|
|
|
|
model.PlaylistFilter.set_pattern("disc=1")
|
|
self.assertTrue(model.PlaylistFilter.do_match(track))
|
|
model.PlaylistFilter.set_pattern("disc=1 & track=1")
|
|
self.assertTrue(model.PlaylistFilter.do_match(track))
|
|
model.PlaylistFilter.set_pattern("track=1 & title=test")
|
|
self.assertTrue(model.PlaylistFilter.do_match(track))
|
|
model.PlaylistFilter.set_pattern("title=test track & artist=test artist")
|
|
self.assertTrue(model.PlaylistFilter.do_match(track))
|
|
model.PlaylistFilter.set_pattern("artist=test artist & album=test album")
|
|
self.assertTrue(model.PlaylistFilter.do_match(track))
|
|
model.PlaylistFilter.set_pattern("album=test album & subtitle=test subtitle")
|
|
self.assertTrue(model.PlaylistFilter.do_match(track))
|
|
model.PlaylistFilter.set_pattern("subtitle=test subtitle & year=2021")
|
|
self.assertTrue(model.PlaylistFilter.do_match(track))
|
|
model.PlaylistFilter.set_pattern("year=2021 & year=2022")
|
|
self.assertFalse(model.PlaylistFilter.do_match(track))
|
|
|
|
def test_runtime(self):
|
|
filter = model.FilterPlaylistModel()
|
|
filter.set_playlist(db.user.Table.find("Collection"))
|
|
|
|
self.assertEqual(filter.get_runtime(), 0)
|
|
track = db.make_fake_track(1, 1, "Test Track", "/a/b/c/1.ogg")
|
|
self.assertEqual(filter.get_runtime(), 1)
|
|
|
|
|
|
class TestPlaylistSelectionModel(unittest.TestCase):
|
|
def test_init(self):
|
|
selection = model.PlaylistSelection()
|
|
self.assertIsInstance(selection, Gtk.MultiSelection)
|
|
self.assertIsInstance(selection.get_model(), model.FilterPlaylistModel)
|
|
self.assertEqual(selection.get_filter_model(), selection.get_model())
|
|
self.assertIsNone(selection.get_playlist())
|
|
|
|
|
|
class TestSortPlaylistModel(unittest.TestCase):
|
|
def setUp(self):
|
|
db.reset()
|
|
|
|
def test_init(self):
|
|
sort = model.SortPlaylistModel()
|
|
self.assertIsInstance(sort, Gtk.StringList)
|
|
self.assertIsNone(sort.playlist)
|
|
|
|
def test_set_playlist(self):
|
|
collection = db.user.Table.find("Collection")
|
|
sort = model.SortPlaylistModel()
|
|
|
|
sort.set_playlist(collection)
|
|
self.assertEqual(sort.playlist, collection)
|
|
self.assertEqual(sort.get_string(0), "artists.sort ASC")
|
|
self.assertEqual(sort.get_string(1), "albums.release ASC")
|
|
self.assertEqual(sort.get_string(2), "albums.sort ASC")
|
|
self.assertEqual(sort.get_string(3), "tracks.number ASC")
|
|
|
|
def test_append(self):
|
|
collection = db.user.Table.find("Collection")
|
|
sort = model.SortPlaylistModel()
|
|
|
|
sort.set_playlist(collection)
|
|
sort.append("tracks.title")
|
|
self.assertEqual(sort.get_n_items(), 5)
|
|
self.assertEqual(sort.get_string(0), "artists.sort ASC")
|
|
self.assertEqual(sort.get_string(1), "albums.release ASC")
|
|
self.assertEqual(sort.get_string(2), "albums.sort ASC")
|
|
self.assertEqual(sort.get_string(3), "tracks.number ASC")
|
|
self.assertEqual(sort.get_string(4), "tracks.title ASC")
|
|
|
|
self.assertEqual(collection.sort, [ "artists.sort ASC",
|
|
"albums.release ASC",
|
|
"albums.sort ASC",
|
|
"discs.number ASC",
|
|
"tracks.number ASC",
|
|
"tracks.title ASC",
|
|
"tracks.trackid ASC" ])
|
|
|
|
def test_remove(self):
|
|
collection = db.user.Table.find("Collection")
|
|
sort = model.SortPlaylistModel()
|
|
|
|
sort.set_playlist(collection)
|
|
sort.remove("albums.release")
|
|
self.assertEqual(sort.get_n_items(), 3)
|
|
self.assertEqual(sort.get_string(0), "artists.sort ASC")
|
|
self.assertEqual(sort.get_string(1), "albums.sort ASC")
|
|
self.assertEqual(sort.get_string(2), "tracks.number ASC")
|
|
|
|
self.assertEqual(collection.sort, [ "artists.sort ASC",
|
|
"albums.sort ASC",
|
|
"discs.number ASC",
|
|
"tracks.number ASC",
|
|
"tracks.trackid ASC" ])
|
|
|
|
def test_move_up(self):
|
|
collection = db.user.Table.find("Collection")
|
|
sort = model.SortPlaylistModel()
|
|
sort.set_playlist(collection)
|
|
|
|
sort.move_up("albums.release")
|
|
self.assertEqual(sort.get_n_items(), 4)
|
|
self.assertEqual(sort.get_string(0), "albums.release ASC")
|
|
self.assertEqual(sort.get_string(1), "artists.sort ASC")
|
|
self.assertEqual(sort.get_string(2), "albums.sort ASC")
|
|
self.assertEqual(sort.get_string(3), "tracks.number ASC")
|
|
|
|
self.assertEqual(collection.sort, [ "albums.release ASC",
|
|
"artists.sort ASC",
|
|
"albums.sort ASC",
|
|
"discs.number ASC",
|
|
"tracks.number ASC",
|
|
"tracks.trackid ASC" ])
|
|
|
|
sort.move_up("artists.sort")
|
|
self.assertEqual(sort.get_n_items(), 4)
|
|
self.assertEqual(sort.get_string(0), "artists.sort ASC")
|
|
self.assertEqual(sort.get_string(1), "albums.release ASC")
|
|
self.assertEqual(sort.get_string(2), "albums.sort ASC")
|
|
self.assertEqual(sort.get_string(3), "tracks.number ASC")
|
|
|
|
def test_move_down(self):
|
|
collection = db.user.Table.find("Collection")
|
|
sort = model.SortPlaylistModel()
|
|
sort.set_playlist(collection)
|
|
|
|
sort.move_down("albums.sort")
|
|
self.assertEqual(sort.get_n_items(), 4)
|
|
self.assertEqual(sort.get_string(0), "artists.sort ASC")
|
|
self.assertEqual(sort.get_string(1), "albums.release ASC")
|
|
self.assertEqual(sort.get_string(2), "tracks.number ASC")
|
|
self.assertEqual(sort.get_string(3), "albums.sort ASC")
|
|
|
|
self.assertEqual(collection.sort, [ "artists.sort ASC",
|
|
"albums.release ASC",
|
|
"discs.number ASC",
|
|
"tracks.number ASC",
|
|
"albums.sort ASC",
|
|
"tracks.trackid ASC" ])
|
|
|
|
sort.move_down("tracks.number")
|
|
self.assertEqual(sort.get_n_items(), 4)
|
|
self.assertEqual(sort.get_string(0), "artists.sort ASC")
|
|
self.assertEqual(sort.get_string(1), "albums.release ASC")
|
|
self.assertEqual(sort.get_string(2), "albums.sort ASC")
|
|
self.assertEqual(sort.get_string(3), "tracks.number ASC")
|
|
|
|
def test_reverse(self):
|
|
collection = db.user.Table.find("Collection")
|
|
sort = model.SortPlaylistModel()
|
|
sort.set_playlist(collection)
|
|
|
|
sort.reverse("tracks.number")
|
|
self.assertEqual(sort.get_n_items(), 4)
|
|
self.assertEqual(sort.get_string(0), "artists.sort ASC")
|
|
self.assertEqual(sort.get_string(1), "albums.release ASC")
|
|
self.assertEqual(sort.get_string(2), "albums.sort ASC")
|
|
self.assertEqual(sort.get_string(3), "tracks.number DESC")
|
|
|
|
self.assertEqual(collection.sort, [ "artists.sort ASC",
|
|
"albums.release ASC",
|
|
"albums.sort ASC",
|
|
"discs.number DESC",
|
|
"tracks.number DESC",
|
|
"tracks.trackid ASC" ])
|
|
|
|
sort.reverse("tracks.number")
|
|
self.assertEqual(sort.get_n_items(), 4)
|
|
self.assertEqual(sort.get_string(0), "artists.sort ASC")
|
|
self.assertEqual(sort.get_string(1), "albums.release ASC")
|
|
self.assertEqual(sort.get_string(2), "albums.sort ASC")
|
|
self.assertEqual(sort.get_string(3), "tracks.number ASC")
|
|
|
|
|
|
|
|
class TestSortOptionsModel(unittest.TestCase):
|
|
def test_init(self):
|
|
sort = model.SortOptionsModel()
|
|
self.assertIsInstance(sort, Gtk.StringList)
|
|
self.assertEqual(sort.get_item(0).get_string(), "tracks.number ASC")
|
|
self.assertEqual(sort.get_item(1).get_string(), "tracks.title ASC")
|
|
self.assertEqual(sort.get_item(2).get_string(), "tracks.length ASC")
|
|
self.assertEqual(sort.get_item(3).get_string(), "artists.sort ASC")
|
|
self.assertEqual(sort.get_item(4).get_string(), "albums.sort ASC")
|
|
self.assertEqual(sort.get_item(5).get_string(), "discs.subtitle ASC")
|
|
self.assertEqual(sort.get_item(6).get_string(), "albums.release ASC")
|
|
self.assertEqual(sort.get_item(7).get_string(), "tracks.playcount ASC")
|
|
self.assertEqual(sort.get_item(8).get_string(), "tracks.lastplayed ASC")
|
|
|
|
|
|
class TestDisabledOptionsModel(unittest.TestCase):
|
|
def setUp(self):
|
|
db.reset()
|
|
|
|
def test_init(self):
|
|
collection = db.user.Table.find("Collection")
|
|
filter = model.DisabledOptionsModel()
|
|
self.assertIsInstance(filter, Gtk.FilterListModel)
|
|
self.assertIsInstance(filter.get_model(), model.SortOptionsModel)
|
|
self.assertIsInstance(filter.get_filter(), model.DisabledOptionsFilter)
|
|
self.assertIsNone(filter.get_filter().playlist)
|
|
|
|
filter.set_playlist(collection)
|
|
self.assertEqual(filter.get_filter().playlist, collection)
|
|
|
|
def test_filter(self):
|
|
collection = db.user.Table.find("Collection")
|
|
filter = model.DisabledOptionsFilter()
|
|
filter.set_playlist(collection)
|
|
self.assertFalse(filter.do_match(Gtk.StringObject.new("tracks.number ASC")))
|
|
self.assertTrue( filter.do_match(Gtk.StringObject.new("tracks.title DESC")))
|
|
self.assertTrue( filter.do_match(Gtk.StringObject.new("tracks.length ASC")))
|
|
self.assertFalse(filter.do_match(Gtk.StringObject.new("artists.sort DESC")))
|
|
self.assertFalse(filter.do_match(Gtk.StringObject.new("albums.sort ASC")))
|
|
self.assertTrue( filter.do_match(Gtk.StringObject.new("discs.subtitle DESC")))
|
|
self.assertFalse(filter.do_match(Gtk.StringObject.new("albums.release ASC")))
|
|
self.assertTrue( filter.do_match(Gtk.StringObject.new("tracks.playcount DESC")))
|
|
self.assertTrue( filter.do_match(Gtk.StringObject.new("tracks.lastplayed ASC")))
|
|
|
|
|
|
class TestSortModelsModel(unittest.TestCase):
|
|
def test_init(self):
|
|
sort = model.SortModelsModel()
|
|
self.assertIsInstance(sort, Gio.ListModel)
|
|
self.assertEqual(sort.get_n_items(), 2)
|
|
self.assertIsInstance(sort.get_item(0), model.SortPlaylistModel)
|
|
self.assertIsInstance(sort.get_item(1), model.DisabledOptionsModel)
|
|
|
|
def test_set_playlist(self):
|
|
collection = db.user.Table.find("Collection")
|
|
sort = model.SortModelsModel()
|
|
sort.set_playlist(collection)
|
|
self.assertEqual(sort.get_item(0).playlist, collection)
|
|
self.assertEqual(sort.get_item(1).get_filter().playlist, collection)
|
|
|
|
|
|
class TestFlatSortModel(unittest.TestCase):
|
|
def test_init(self):
|
|
sort = model.FlatSortModel()
|
|
self.assertIsInstance(sort, Gtk.FlattenListModel)
|
|
self.assertIsInstance(sort.get_model(), model.SortModelsModel)
|
|
self.assertEqual(sort.get_enabled_model(), sort.get_model()[0])
|
|
|
|
def test_set_playlist(self):
|
|
collection = db.user.Table.find("Collection")
|
|
sort = model.FlatSortModel()
|
|
models = sort.get_model()
|
|
sort.set_playlist(collection)
|
|
self.assertEqual(models.get_item(0).playlist, collection)
|
|
self.assertEqual(models.get_item(1).get_filter().playlist, collection)
|
|
|
|
def test_enable_disable(self):
|
|
collection = db.user.Table.find("Collection")
|
|
sort = model.FlatSortModel()
|
|
sort.set_playlist(collection)
|
|
models = sort.get_model()
|
|
|
|
sort.enable("tracks.title")
|
|
self.assertEqual(models.models[0].get_n_items(), 5)
|
|
self.assertEqual(models.models[1].get_n_items(), 4)
|
|
self.assertEqual(sort.get_n_enabled(), 5)
|
|
|
|
sort.disable("tracks.title")
|
|
self.assertEqual(models.models[0].get_n_items(), 4)
|
|
self.assertEqual(models.models[1].get_n_items(), 5)
|
|
self.assertEqual(sort.get_n_enabled(), 4)
|