emmental/lib/test_tagstore.py

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

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

class TestTagStore(unittest.TestCase):
    def setUp(self):
        self.added = None
        self.removed = None

    def on_store_added(self, tag):
        self.added = tag

    def on_store_removed(self, tag):
        self.removed = tag

    def test_tag_store(self):
        store = tagstore.TagStore()
        self.assertEqual(store.store, { })
        self.assertIsInstance(store.lock, type(threading.Lock()))
        self.assertIsInstance(store.Added, publisher.Publisher)
        self.assertIsInstance(store.Removed, publisher.Publisher)

    def test_tag_store_add_remove(self):
        store = tagstore.TagStore()
        store.Added.register(self.on_store_added)
        store.Removed.register(self.on_store_removed)

        tag = store.add("test", 1)
        self.assertEqual(self.added, tag)
        self.assertEqual(tag.tracks, [ 1 ])

        self.added = None
        self.assertEqual(store.add("test  ", 2), tag)
        self.assertEqual(tag.tracks, [ 1, 2 ])
        self.assertIsNone(self.added)

        store.remove(tag, 1)
        self.assertEqual(tag.tracks, [ 2 ])
        self.assertIn("test", store.store.keys())
        self.assertIsNone(self.removed)

        store.remove(tag, 2)
        self.assertEqual(tag.tracks, [ ])
        self.assertNotIn("test", store.store.keys())
        self.assertEqual(self.removed, tag)

    def test_tag_store_add_remove_none(self):
        store = tagstore.TagStore()
        tag = store.add("test")
        self.assertEqual(tag.tracks, [ ])

        tag.add_track(1)
        tag.add_track(2)

        store.remove(tag)
        self.assertNotIn("test", store.store.keys())

    def test_tag_store_reset(self):
        store = tagstore.TagStore()
        tag = store.add("test", 1)
        store.Added.register(self.on_store_added)
        store.Removed.register(self.on_store_removed)

        store.reset()
        self.assertNotIn(tag.name, store.store.keys())
        self.assertEqual(store.Added.subscribers, set())
        self.assertEqual(store.Removed.subscribers, set())

    def test_tag_store_state(self):
        store = tagstore.TagStore()
        track = FakeTrack(1)
        tag = store.add("test", 1)

        state = store.__getstate__()
        self.assertEqual(set(state.keys()), set([ "store" ]))

        store.__dict__.clear()
        store.__setstate__(state)
        self.assertEqual(store.store, { "test" : tag })
        self.assertIsInstance(store.lock, type(threading.Lock()))
        self.assertIsInstance(store.Added, publisher.Publisher)
        self.assertIsInstance(store.Removed, publisher.Publisher)

        self.assertEqual(store.init_track("test", track), tag)
        self.assertEqual(tag.tracks, [ track ])