emmental/playlist/test_header.py

# Copyright 2021 (c) Anna Schumaker.
import audio
import db
import lib
import unittest
from gi.repository import Gtk
from . import header
from . import model
from . import view

class TestFilterEntry(unittest.TestCase):
    def test_init(self):
        entry = header.FilterEntry()
        self.assertIsInstance(entry, lib.filter.Entry)
        self.assertEqual(entry.filter, model.PlaylistFilter)
        self.assertEqual(entry.get_margin_start(), 200)
        self.assertEqual(entry.get_margin_end(), 200)
        self.assertTrue(entry.get_hexpand())


class TestPropertyToggle(unittest.TestCase):
    def test_init(self):
        prop = header.PropertyToggle("random", "media-playlist-shuffle")
        self.assertIsInstance(prop, Gtk.ToggleButton)
        self.assertEqual(prop.get_icon_name(), "media-playlist-shuffle")
        self.assertFalse(prop.get_sensitive())

        self.assertEqual(prop.property, "random")
        self.assertIsNone(prop.playlist)
        prop.set_active(True)

    def test_set_playlist(self):
        collection = db.user.Table.find("Collection")
        prop = header.PropertyToggle("random", "media-playlist-shuffle")

        collection.set_property("random", True)
        prop.set_playlist(collection)
        self.assertEqual(prop.playlist, collection)
        self.assertTrue(prop.get_active())
        self.assertFalse(prop.get_sensitive())

        collection.set_property("random", False)
        prop.set_playlist(collection)
        self.assertFalse(prop.get_active())

    def test_toggle(self):
        collection = db.user.Table.find("Collection")
        prop = header.PropertyToggle("random", "media-playlist-shuffle")

        collection.set_property("random", False)
        prop.set_playlist(collection)
        prop.set_active(True)
        self.assertTrue(collection.get_property("random"))
        prop.set_active(False)
        self.assertFalse(collection.get_property("random"))


class TestRandomToggle(unittest.TestCase):
    def test_init(self):
        random = header.RandomToggle()
        self.assertIsInstance(random, header.PropertyToggle)
        self.assertEqual(random.get_icon_name(), "media-playlist-shuffle")
        self.assertEqual(random.property, "random")

    def test_set_playlist(self):
        random = header.RandomToggle()
        random.set_playlist(db.user.Table.find("Collection"))
        self.assertTrue(random.get_sensitive())
        random.set_playlist(db.user.Table.find("Previous"))
        self.assertFalse(random.get_sensitive())


class TestLoopToggle(unittest.TestCase):
    def test_init(self):
        loop = header.LoopToggle()
        self.assertIsInstance(loop, header.PropertyToggle)
        self.assertEqual(loop.get_icon_name(), "media-playlist-repeat")
        self.assertEqual(loop.property, "loop")

    def test_set_playlist(self):
        loop = header.LoopToggle()
        loop.set_playlist(db.user.Table.find("Collection"))
        self.assertFalse(loop.get_sensitive())
        loop.set_playlist(db.user.Table.find("Favorites"))
        self.assertTrue(loop.get_sensitive())
        loop.set_playlist(db.user.Table.find("New Tracks"))
        self.assertTrue(loop.get_sensitive())
        loop.set_playlist(db.user.Table.find("Previous"))
        self.assertFalse(loop.get_sensitive())
        loop.set_playlist(db.user.Table.find("Queued Tracks"))
        self.assertFalse(loop.get_sensitive())


class TestSortButton(unittest.TestCase):
    def test_init(self):
        sort = header.SortButton()
        self.assertIsInstance(sort, Gtk.MenuButton)
        self.assertIsInstance(sort.get_popover(), Gtk.Popover)
        self.assertIsInstance(sort.get_popover(), view.SortOrderPopover)
        self.assertEqual(sort.get_icon_name(), "view-sort-ascending")
        self.assertFalse(sort.get_sensitive())

    def test_set_playlist(self):
        sort = header.SortButton()
        sort.set_playlist(db.user.Table.find("Collection"))
        self.assertTrue(sort.get_sensitive())
        sort.set_playlist(db.user.Table.find("Favorites"))
        self.assertTrue(sort.get_sensitive())
        sort.set_playlist(db.user.Table.find("New Tracks"))
        self.assertTrue(sort.get_sensitive())
        sort.set_playlist(db.user.Table.find("Previous"))
        self.assertFalse(sort.get_sensitive())
        sort.set_playlist(db.user.Table.find("Queued Tracks"))
        self.assertTrue(sort.get_sensitive())


class TestFavoriteButton(unittest.TestCase):
    def setUp(self):
        db.reset()
        audio.Player.track = None

    def test_init(self):
        fav = header.FavoriteButton()
        self.assertIsInstance(fav, Gtk.ToggleButton)
        self.assertEqual(fav.get_icon_name(), "emmental-favorites")
        self.assertFalse(fav.get_sensitive())

    def test_sensitive(self):
        track = db.make_fake_track(1, 1, "Test Track", "/a/b/c/1.ogg")
        fav = header.FavoriteButton()
        fav.track_changed(audio.Player, None, track)
        self.assertTrue(fav.get_sensitive())
        fav.track_changed(audio.Player, None, None)
        self.assertFalse(fav.get_sensitive())

    def test_active(self):
        fav = header.FavoriteButton()
        t1 = db.make_fake_track(1, 1, "Test Track 1", "/a/b/c/1.ogg")
        t2 = db.make_fake_track(2, 2, "Test Track 2", "/a/b/c/2.ogg")
        db.user.Table.find("Favorites").add_track(t1)

        fav.track_changed(audio.Player, None, t1)
        self.assertTrue(fav.get_active())
        fav.track_changed(audio.Player, t1, t2)
        self.assertFalse(fav.get_active())

    def test_toggle(self):
        track = db.make_fake_track(1, 1, "Test Track", "/a/b/c/1.ogg")
        fav = header.FavoriteButton()

        fav.set_active(True)
        self.assertEqual(db.user.Table.find("Favorites").get_n_tracks(), 0)
        fav.set_active(False)

        audio.Player.track = track
        self.assertNotIn(track, db.user.Table.find("Favorites").get_tracks())
        fav.set_active(True)
        self.assertIn(track, db.user.Table.find("Favorites").get_tracks())
        fav.set_active(False)
        self.assertNotIn(track, db.user.Table.find("Favorites").get_tracks())


class TestJumpButton(unittest.TestCase):
    def test_init(self):
        jump = header.JumpButton()
        self.assertIsInstance(jump, Gtk.Button)
        self.assertEqual(jump.get_icon_name(), "go-jump")
        self.assertFalse(jump.get_sensitive())

    def test_set_playlist(self):
        jump = header.JumpButton()
        self.assertFalse(jump.get_sensitive())
        jump.set_playlist(db.user.Table.find("Collection"))
        self.assertTrue(jump.get_sensitive())


class TestControlBox(unittest.TestCase):
    def test_init(self):
        box = header.ControlBox()
        self.assertIsInstance(box, Gtk.Box)
        self.assertEqual(box.get_orientation(), Gtk.Orientation.HORIZONTAL)
        self.assertEqual(box.get_margin_top(), 5)
        self.assertEqual(box.get_margin_bottom(), 5)
        self.assertEqual(box.get_margin_start(), 5)
        self.assertEqual(box.get_margin_end(), 5)
        self.assertTrue(box.has_css_class("linked"))


class TestTrackBox(unittest.TestCase):
    def test_init(self):
        box = header.TrackBox()
        self.assertIsInstance(box, header.ControlBox)

    def test_children(self):
        box = header.TrackBox()

        child = box.get_first_child()
        self.assertIsInstance(child, header.FavoriteButton)

        child = child.get_next_sibling()
        self.assertIsInstance(child, header.JumpButton)
        self.assertEqual(box.get_jump_button(), child)


class TestPlaylistBox(unittest.TestCase):
    def test_init(self):
        box = header.PlaylistBox()
        self.assertIsInstance(box, header.ControlBox)

    def test_children(self):
        collection = db.user.Table.find("Collection")
        box = header.PlaylistBox()
        box.set_playlist(collection)

        child = box.get_first_child()
        self.assertIsInstance(child, header.RandomToggle)
        self.assertEqual(child.playlist, collection)

        child = child.get_next_sibling()
        self.assertIsInstance(child, header.LoopToggle)
        self.assertEqual(child.playlist, collection)

        child = child.get_next_sibling()
        self.assertIsInstance(child, header.SortButton)


class TestHeader(unittest.TestCase):
    def test_init(self):
        box = header.Header()
        self.assertIsInstance(box, Gtk.Box)
        self.assertIsInstance(box.get_jump_button(), header.JumpButton)
        self.assertEqual(box.get_orientation(), Gtk.Orientation.HORIZONTAL)

    def test_children(self):
        collection = db.user.Table.find("Collection")
        box = header.Header()
        box.set_playlist(collection)

        child = box.get_first_child()
        self.assertIsInstance(child, header.TrackBox)

        child = child.get_next_sibling()
        self.assertIsInstance(child, header.FilterEntry)

        child = child.get_next_sibling()
        self.assertIsInstance(child, header.ControlBox)
        self.assertEqual(child.get_first_child().playlist, collection)