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)