168 lines
5.9 KiB
Python
168 lines
5.9 KiB
Python
# Copyright 2021 (c) Anna Schumaker.
|
|
from . import fake
|
|
from . import publisher
|
|
from . import tag
|
|
from . import tagstore
|
|
import threading
|
|
import unittest
|
|
|
|
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", fake.Track(1))
|
|
self.assertEqual(self.added, tag)
|
|
self.assertEqual(tag.tracks, [ fake.Track(1) ])
|
|
|
|
self.added = None
|
|
self.assertEqual(store.add("test ", fake.Track(2)), tag)
|
|
self.assertEqual(tag.tracks, [ fake.Track(1), fake.Track(2) ])
|
|
self.assertIsNone(self.added)
|
|
|
|
store.remove(tag, fake.Track(1))
|
|
self.assertEqual(tag.tracks, [ fake.Track(2) ])
|
|
self.assertIn("test", store.store.keys())
|
|
self.assertIsNone(self.removed)
|
|
|
|
store.remove(tag, fake.Track(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(fake.Track(1))
|
|
tag.add_track(fake.Track(2))
|
|
|
|
store.remove(tag)
|
|
self.assertNotIn("test", store.store.keys())
|
|
|
|
def test_tag_store_add_remove_sort(self):
|
|
store = tagstore.TagStore()
|
|
tag = store.add("test", sort="sort")
|
|
self.assertEqual(tag.sort, "sort")
|
|
|
|
def test_tag_store_items(self):
|
|
store = tagstore.TagStore()
|
|
self.assertEqual(len(store), 0)
|
|
|
|
tag1 = store.add("test1", fake.Track(1))
|
|
tag2 = store.add("test2", fake.Track(2))
|
|
tag3 = store.add("test3", fake.Track(3))
|
|
|
|
self.assertEqual(len(store), 3)
|
|
self.assertEqual( store["test1"], tag1)
|
|
self.assertEqual( store["test2"], tag2)
|
|
self.assertEqual( store["test3"], tag3)
|
|
self.assertIsNone(store["test4"])
|
|
|
|
result = [ tag for tag in store.tags() ]
|
|
self.assertEqual(len(result), 3)
|
|
self.assertIn(tag1, result)
|
|
self.assertIn(tag2, result)
|
|
self.assertIn(tag3, result)
|
|
|
|
def test_tag_store_reset(self):
|
|
store = tagstore.TagStore()
|
|
tag = store.add("test", fake.Track(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 = fake.Track(1)
|
|
tag = store.add("test", track)
|
|
|
|
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 ])
|
|
|
|
|
|
class TestTagSuperStore(unittest.TestCase):
|
|
def test_tag_superstore(self):
|
|
store = tagstore.TagStore()
|
|
superstore = tagstore.TagSuperStore()
|
|
self.assertIsInstance(superstore, tagstore.TagStore)
|
|
|
|
parent = store.add("parent", fake.Track(1))
|
|
supertag = superstore.add(parent, "test ", fake.Track(1))
|
|
self.assertIsInstance(supertag, tag.SuperTag)
|
|
self.assertEqual(supertag.name, "test")
|
|
self.assertEqual(supertag.tracks, [ fake.Track(1) ])
|
|
self.assertEqual(supertag.parent, parent)
|
|
|
|
superstore.remove(supertag, fake.Track(1))
|
|
self.assertEqual(supertag.tracks, [ ])
|
|
self.assertNotIn("test", superstore.store.keys())
|
|
|
|
def test_tag_superstore_items(self):
|
|
store = tagstore.TagStore()
|
|
superstore = tagstore.TagSuperStore()
|
|
|
|
parent1 = store.add("parent1", fake.Track(1))
|
|
parent2 = store.add("parent2", fake.Track(2))
|
|
tag1 = superstore.add(parent1, "test1", fake.Track(1))
|
|
tag2 = superstore.add(parent1, "test2", fake.Track(2))
|
|
tag3 = superstore.add(parent2, "test3", fake.Track(3))
|
|
|
|
self.assertEqual(len(superstore), 3)
|
|
self.assertEqual( superstore[parent1, "test1"], tag1)
|
|
self.assertEqual( superstore[parent1, "test2"], tag2)
|
|
self.assertEqual( superstore[parent2, "test3"], tag3)
|
|
self.assertIsNone(superstore[parent2, "test2"])
|
|
|
|
result = [ tag for tag in superstore.tags(parent1) ]
|
|
self.assertEqual(result, [ tag1, tag2 ])
|
|
result = [ tag for tag in superstore.tags(parent2) ]
|
|
self.assertEqual(result, [ tag3 ])
|
|
result = [ tag for tag in superstore.tags() ]
|
|
self.assertEqual(result, [ tag1, tag2, tag3 ])
|
|
|
|
def test_tag_superstore_init_track(self):
|
|
store = tagstore.TagStore()
|
|
superstore = tagstore.TagSuperStore()
|
|
|
|
track = fake.Track(1)
|
|
parent = store.add("test")
|
|
tag = superstore.add(parent, "test", track)
|
|
tag.tracks = [ 1 ]
|
|
|
|
self.assertEqual(superstore.init_track(parent, "test", track), tag)
|
|
self.assertEqual(tag.tracks, [ track ])
|