def test_should_release_keys_on_caching_multiple_elements(self):
# given
value = 0
storage = LocalInMemoryCacheStorage()
key_extractor = Mock()
key_extractor.format_key = Mock(side_effect=lambda method, args, kwargs: str((args[0], kwargs.get('kwarg'))))
@memoize(
configuration=MutableCacheConfiguration
.initialized_with(DefaultInMemoryCacheConfiguration())
.set_eviction_strategy(LeastRecentlyUpdatedEvictionStrategy(capacity=2))
.set_key_extractor(key_extractor)
.set_storage(storage)
)
@gen.coroutine
def get_value(arg, kwarg=None):
return value
# when
yield get_value('test1', kwarg='args1')
yield get_value('test2', kwarg='args2')
yield get_value('test3', kwarg='args3')
yield get_value('test4', kwarg='args4')
yield _ensure_background_tasks_finished()
# then
s1 = yield storage.get("('test1', 'args1')")
s2 = yield storage.get("('test2', 'args2')")
s3 = yield storage.get("('test3', 'args3')")
s4 = yield storage.get("('test4', 'args4')")
self.assertIsNone(s1)
self.assertIsNone(s2)
self.assertIsNotNone(s3)
self.assertIsNotNone(s4)
def __init__(self) -> None:
self.__configured = True
self.__method_timeout = datetime.timedelta(minutes=2)
self.__storage = LocalInMemoryCacheStorage()
self.__key_extractor = EncodedMethodReferenceAndArgsKeyExtractor()
self.__eviction_strategy = LeastRecentlyUpdatedEvictionStrategy()
self.__entry_builder = ProvidedLifeSpanCacheEntryBuilder()
def __init__(
self,
capacity: int = 4096,
method_timeout: timedelta = timedelta(minutes=2),
update_after: timedelta = timedelta(minutes=10),
expire_after: timedelta = timedelta(minutes=30)
) -> None:
self.__configured = True
self.__method_timeout = method_timeout
self.__storage = LocalInMemoryCacheStorage()
self.__key_extractor = EncodedMethodReferenceAndArgsKeyExtractor()
self.__eviction_strategy = LeastRecentlyUpdatedEvictionStrategy(
capacity=capacity)
self.__entry_builder = ProvidedLifeSpanCacheEntryBuilder(
update_after=update_after, expire_after=expire_after)
class LocalInMemoryCacheStorageTests(AsyncTestCase):
def setUp(self):
super().setUp()
self.storage = LocalInMemoryCacheStorage()
def tearDown(self):
super().tearDown()
@gen_test
def test_offer_and_get_returns_same_object(self):
# given
yield self.storage.offer(CACHE_KEY, CACHE_SAMPLE_ENTRY)
# when
returned_value = yield self.storage.get(CACHE_KEY)
# then
self.assertEqual(returned_value.value, "value")
@gen_test
def test_get_without_offer_returns_none(self):
# given/when
returned_value = yield self.storage.get(CACHE_KEY)
# then
self.assertIsNone(returned_value)
@gen_test
def test_released_object_is_not_returned(self):
# given
yield self.storage.offer(CACHE_KEY, CACHE_SAMPLE_ENTRY)
yield self.storage.release(CACHE_KEY)
# when
returned_value = yield self.storage.get(CACHE_KEY)
# then
self.assertIsNone(returned_value)
from datetime import timedelta
from memoize.configuration import MutableCacheConfiguration, DefaultInMemoryCacheConfiguration
from memoize.entrybuilder import ProvidedLifeSpanCacheEntryBuilder
from memoize.eviction import LeastRecentlyUpdatedEvictionStrategy
from memoize.key import EncodedMethodNameAndArgsKeyExtractor
from memoize.storage import LocalInMemoryCacheStorage
from memoize.wrapper import memoize
@memoize(configuration=MutableCacheConfiguration
.initialized_with(DefaultInMemoryCacheConfiguration())
.set_method_timeout(value=timedelta(minutes=2))
.set_entry_builder(ProvidedLifeSpanCacheEntryBuilder(update_after=timedelta(minutes=2),
expire_after=timedelta(minutes=5)))
.set_eviction_strategy(LeastRecentlyUpdatedEvictionStrategy(capacity=2048))
.set_key_extractor(EncodedMethodNameAndArgsKeyExtractor(skip_first_arg_as_self=False))
.set_storage(LocalInMemoryCacheStorage())
)
async def cached():
return 'dummy'
def setUp(self):
super().setUp()
self.storage = LocalInMemoryCacheStorage()