def test_get_tags(self, get_top_tags, time, assert_config):
time.return_value = 1
get_top_tags.side_effect = [
[Tag(name=i) for i in range(0, 250)],
[Tag(name=i) for i in range(250, 500)],
[Tag(name=i) for i in range(500, 750)],
[Tag(name=i) for i in range(750, 1000)],
]
names = [t.name for t in LastService.get_tags()]
self.assertEqual(list(range(0, 1000)), names)
get_top_tags.assert_has_calls(
[
mock.call(limit=250, page=1),
mock.call(limit=250, page=2),
mock.call(limit=250, page=3),
mock.call(limit=250, page=4),
]
)
tags, ttl = Registry.get("last.fm_tag_list")
self.assertEqual(1000, len(tags))
self.assertEqual({"name": 0}, tags[0])
self.assertEqual(timedelta(days=30, seconds=1).total_seconds(), ttl)
assert_config.assert_called_once()
def get(cls, key, **kwargs):
with contextlib.suppress(KeyError):
data = Registry.get(cls.namespace, str(key), **kwargs)
with contextlib.suppress(TypeError):
return cls.model(**data)
return data
raise NotFound("No {} matched your argument: {}!".format(
cls.namespace, key))
def update_quota(cls, cost: int):
"""
Update current date youtube quota usage according to this guide
https://developers.google.com/youtube/v3/determine_quota_cost.
:param int cost:
"""
date = cls.quota_date()
quota = Registry.get(cls.quota_key, date, default=0) + cost
Registry.set(cls.quota_key, {date: quota})
def test_update(self):
foo = FooManager.set(self.data)
new_foo = FooManager.update(foo, dict(value=2))
self.assertIsNot(foo, new_foo)
self.assertIsInstance(new_foo, FooManager.model)
expected = dict(id="a", value=2, keeper="keep")
self.assertDictEqual(expected, Registry.get("foo", "a"))
self.assertDictEqual(expected, new_foo.asdict())
def test_set(self):
foo = FooManager.set(self.data)
self.assertIsInstance(foo, FooManager.model)
self.assertDictEqual(self.data, Registry.get("foo", "a"))
self.assertDictEqual(self.data, foo.asdict())
bar = FooManager.set(dict(id="a", value=1))
self.assertEqual(foo.asdict(), bar.asdict())
thug = FooManager.set(dict(id="a", value=1, keeper="peek"))
self.assertEqual("peek", thug.keeper)
def test_from_file(self):
try:
tmp = tempfile.mkdtemp()
file_path = os.path.join(tmp, "foo.json")
with open(file_path, "w") as fp:
json.dump(dict(a=True), fp)
Registry.from_file(file_path)
self.assertEqual(dict(a=True), Registry())
Registry.set("a", False)
self.assertFalse(Registry.get("a"))
Registry.from_file(file_path)
self.assertFalse(Registry.get("a"))
finally:
shutil.rmtree(tmp)
def set(cls, data: Dict):
obj = cls.model(**data)
key = getattr(obj, cls.key)
with contextlib.suppress(KeyError):
data = Registry.get(cls.namespace, key)
for field in attr.fields(cls.model):
if field.metadata.get("keep") and not getattr(obj, field.name):
setattr(obj, field.name, data.get(field.name))
Registry.set(cls.namespace, key, obj.asdict())
return obj
def test_get_user(self, find, time, assert_config):
time.return_value = 1
my_user = self.get_user()
find.return_value = my_user
self.assertEqual(my_user, LastService.get_user("rj"))
find.assert_called_once_with("rj")
user, ttl = Registry.get("last.fm_user_rj")
self.assertEqual(self.get_user().to_dict(), user)
self.assertEqual(timedelta(hours=24, seconds=1).total_seconds(), ttl)
assert_config.assert_called_once()
def test_get_artist(self, find, time, assert_config):
time.return_value = 1
find.return_value = Artist(name="Queen")
artist = LastService.get_artist("quueee")
self.assertEqual(Artist(name="Queen"), artist)
find.assert_called_once_with("quueee")
artist, ttl = Registry.get("last.fm_artist_quueee")
self.assertEqual({"name": "Queen"}, artist)
self.assertEqual(timedelta(days=30, seconds=1).total_seconds(), ttl)
assert_config.assert_called_once()
def test_cache(self, time):
time.side_effect = [10, 20.1, 20.1, 20.5, 20.8]
def callme(ttl, value, refresh=False):
return Registry.cache(
key="foo",
ttl=timedelta(seconds=ttl),
func=lambda: value,
refresh=refresh,
)
self.assertEqual("first", callme(10, "first"))
self.assertEqual(("first", 20.0), Registry.get("foo"))
self.assertEqual("second", callme(1, "second"))
self.assertEqual(("second", 21.1), Registry.get("foo"))
self.assertEqual("second", callme(1, "third"))
self.assertEqual(("second", 21.1), Registry.get("foo"))
self.assertEqual("third", callme(100, "third", refresh=True))
self.assertEqual(("third", 120.8), Registry.get("foo"))
self.assertEqual(5, time.call_count)
def find(cls, **kwargs):
def match(data, conditions):
with contextlib.suppress(Exception):
for k, v in conditions.items():
value = data.get(k)
if callable(v):
assert v(value)
elif v is None:
assert value is None
else:
assert type(value)(v) == value
return True
return False
return [
cls.model(**raw)
for raw in Registry.get(cls.namespace, default={}).values()
if match(raw, kwargs)
]
def keys(cls):
return list(Registry.get(cls.namespace, default={}).keys())
def test_clear(self):
Registry.set(1, 2, 3, 4, 5)
self.assertEqual({4: 5}, Registry.get(1, 2, 3))
Registry.clear()
self.assertEqual({}, Registry())
def get_quota_usage(cls):
return Registry.get(cls.quota_key, cls.quota_date(), default=0)
def find_youtube_id(cls, id: str):
return Registry.get(cls.namespace, id, "youtube_id", default=None)
def get(cls, key, default=None):
return Registry.get(cls.namespace, key, default=default)
def test_get(self):
Registry.set(1, 2, 3, 4, 5)
self.assertEqual({4: 5}, Registry.get(1, 2, 3))
with self.assertRaises(KeyError):
Registry.get(2)
