emmental/playlist/test_model.py

# 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 controls
from . import model
from . import runtime
from lib import bus
from lib import fake
from lib import tag


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 TestTagModel(unittest.TestCase):
    def setUp(self):
        self.changed = (None, None, None)

    def items_changed_cb(self, model, position, removed, added):
        self.changed = (position, removed, added)

    def test_tag_model_init(self):
        t = tag.Tag("Test")
        m = model.TagModel(t)

        self.assertIsInstance(m, GObject.Object)
        self.assertIsInstance(m, Gio.ListModel)
        self.assertIsInstance(m.bus, bus.Bus)
        self.assertIsInstance(m.Controls, controls.Controls)

        self.assertEqual(m.tag, t)
        self.assertEqual(m.items, [ ])

        self.assertEqual(m.get_item_type(), GObject.TYPE_PYOBJECT)
        self.assertEqual(m.get_n_items(), 0)
        self.assertIsNone(m.get_item(0))

    def test_tag_model_add_remove(self):
        t = tag.Tag("Test")
        m = model.TagModel(t)
        track = fake.Track(1)

        t.add_track(track)
        m.bus.complete()
        self.assertEqual(m.items, [ track ])
        self.assertEqual(m.get_n_items(), 1)
        self.assertEqual(m.get_item(0), fake.Track(1))
        self.assertEqual(runtime.Runtime.get_text(), "1 second")
        self.assertEqual(runtime.Visible.get_text(), "Showing 1 track")

        t.remove_track(track)
        m.bus.complete()
        self.assertEqual(m.items, [ ])
        self.assertEqual(m.get_n_items(), 0)
        self.assertIsNone(m.get_item(0))
        self.assertEqual(runtime.Runtime.get_text(), "0 seconds")
        self.assertEqual(runtime.Visible.get_text(), "Showing 0 tracks")

    def test_tag_model_init_none(self):
        m = model.TagModel()

        self.assertEqual(m.items, [ ])
        self.assertEqual(m.get_n_items(), 0)
        self.assertIsNone(m.get_item(0))

    def test_tag_model_switch_tag(self):
        t = tag.Tag("A")
        t.add_track(fake.Track(1))
        t.add_track(fake.Track(2))

        u = tag.Tag("B")
        u.add_track(fake.Track(5))

        m = model.TagModel()
        m.connect("items-changed", self.items_changed_cb)

        m.switch_tag(t)
        self.assertEqual(self.changed, (0, 0, 2))
        self.assertIn(m.track_added, t.TrackAdded.subscribers)
        self.assertEqual(runtime.Visible.get_text(), "Showing 2 tracks")
        self.assertEqual(runtime.Runtime.get_text(), "3 seconds")

        m.switch_tag(u)
        self.assertEqual(self.changed, (0, 2, 1))
        self.assertIn(m.track_added, u.TrackAdded.subscribers)
        self.assertNotIn(m.track_added, t.TrackAdded.subscribers)
        self.assertEqual(runtime.Visible.get_text(), "Showing 1 track")
        self.assertEqual(runtime.Runtime.get_text(), "5 seconds")