emmental/lib/test_tag.py

# Copyright 2021 (c) Anna Schumaker.
from . import publisher
from . import tag
import threading
import unittest

class FakeTrack:
    def __init__(self, trackid):
        self.trackid = trackid


class TestTag(unittest.TestCase):
    def setUp(self):
        self.changed = None

    def callback_func(self, tag, track):
        self.changed = (tag, track)

    def test_tag_init(self):
        t = tag.Tag("test")
        self.assertEqual(t.name, "test")
        self.assertEqual(t.sort, "test")
        self.assertEqual(t.current, -1)
        self.assertEqual(t.tracks, [ ])
        self.assertIsNone(t.widgets)
        self.assertIsInstance(t.lock, type(threading.Lock()))
        self.assertIsInstance(t.TrackAdded, publisher.Publisher)
        self.assertIsInstance(t.TrackRemoved, publisher.Publisher)

        self.assertEqual(str(t), "test")

    def test_tag_len(self):
        t = tag.Tag("Test")
        self.assertEqual(len(t), 0)
        t.tracks = [ FakeTrack(i) for i in range(5) ]
        self.assertEqual(len(t), 5)

    def test_tag_lt(self):
        a = tag.Tag("A")
        b = tag.Tag("B")
        c = tag.Tag("C")

        self.assertTrue( a < b)
        self.assertFalse(b < a)
        self.assertFalse(a < a)

        a2 = tag.SuperTag(b, "A")
        self.assertTrue(a < a2)
        self.assertTrue(b < a2)
        self.assertTrue(a2 < c)

    def test_tag_header(self):
        self.assertEqual(tag.Tag("Test").get_header(), "T")
        self.assertEqual(tag.Tag("Test", "sort").get_header(), "S")
        self.assertEqual(tag.Tag("").get_header(), "")

    def test_tag_state(self):
        t = tag.Tag("test")
        tracks = [ FakeTrack(i) for i in range(5) ]
        t.tracks = tracks

        state = t.__getstate__()
        self.assertEqual(set(state.keys()),
                set([ "name", "sort", "current", "tracks" ]))
        self.assertEqual(state["name"], "test")
        self.assertEqual(state["sort"], "test")
        self.assertEqual(state["current"], -1)
        self.assertEqual(state["tracks"], [ 0, 1, 2, 3, 4 ])

        state["sort"] = "sort"
        state["current"] = 42

        t.__dict__.clear()
        t.__setstate__(state)
        self.assertEqual(t.name, "test")
        self.assertEqual(t.sort, "sort")
        self.assertEqual(t.current, 42)
        self.assertEqual(t.tracks, [ 0, 1, 2, 3, 4 ])
        self.assertEqual(t.widgets, None)
        self.assertIsInstance(t.lock, type(threading.Lock()))
        self.assertIsInstance(t.TrackAdded, publisher.Publisher)
        self.assertIsInstance(t.TrackRemoved, publisher.Publisher)

        for track in tracks:
            t.init_track(track)
        self.assertEqual(t.tracks, tracks)

    def test_tag_add_track(self):
        t = tag.Tag("test")
        t.TrackAdded.register(self.callback_func)

        t.add_track(1)
        self.assertEqual(t.tracks, [ 1 ])
        self.assertEqual(self.changed, (t, 1))

        t.add_track(2)
        self.assertEqual(t.tracks, [ 1, 2 ])
        self.assertEqual(self.changed, (t, 2))

    def test_tag_remove_track(self):
        t = tag.Tag("test")
        t.tracks = [ 1, 2 ]
        t.TrackRemoved.register(self.callback_func)

        t.remove_track(1)
        self.assertEqual(t.tracks, [ 2 ])
        self.assertEqual(self.changed, (t, 1))

        t.remove_track(2)
        self.assertEqual(t.tracks, [ ])
        self.assertEqual(self.changed, (t, 2))

    def test_tag_next(self):
        t = tag.Tag("test")
        t.tracks = [ 1, 2, 3 ]

        self.assertEqual(t.next(), 1)
        self.assertEqual(t.current, 0)

        self.assertEqual(t.next(), 2)
        self.assertEqual(t.current, 1)

        self.assertEqual(t.next(), 3)
        self.assertEqual(t.current, 2)

        self.assertIsNone(t.next())
        self.assertEqual(t.current, 3)


class TestSuperTag(unittest.TestCase):
    def test_super_tag(self):
        parent = tag.Tag("parent")
        st = tag.SuperTag(parent, "test", "sort")
        st.tracks = [ FakeTrack(i) for i in range(5) ]

        self.assertIsInstance(st, tag.Tag)
        self.assertEqual(st.parent, parent)

        state = st.__getstate__()
        self.assertEqual(state["name"], "test")
        self.assertEqual(state["sort"], "sort")
        self.assertEqual(state["current"], -1)
        self.assertEqual(state["tracks"], [ 0, 1, 2, 3, 4 ])
        self.assertEqual(state["parent"], parent)

        st.__dict__.clear()
        st.__setstate__(state)
        self.assertEqual(st.name, "test")
        self.assertEqual(st.sort, "sort")
        self.assertEqual(st.tracks, [ 0, 1, 2, 3, 4 ])
        self.assertEqual(st.widgets, None)
        self.assertEqual(st.parent, parent)
        self.assertIsInstance(st.lock, type(threading.Lock()))

    def test_super_tag_lt(self):
        A = tag.Tag("A")
        B = tag.Tag("B")
        C = tag.Tag("C")

        aa = tag.SuperTag(A, "A")
        ba = tag.SuperTag(B, "A")
        bb = tag.SuperTag(B, "B")
        ca = tag.SuperTag(C, "A")

        lst = [ A, aa, B, ba, bb, C, ca ]
        for i, t in enumerate(lst):
            for u in lst[i+1:]:
                self.assertTrue(t < u)

        lst = [ ca, C, bb, ba, B, aa, A ]
        for i, t in enumerate(lst):
            for u in lst[i+1:]:
                self.assertFalse(t < u)