def test_typical_configuration(self): dp_region.make_region().configure( 'oslo_cache.etcd3gw', arguments=self.arguments ) self.assertTrue(True) # reached here means no initialization error
def test_typical_configuration(self): dp_region.make_region().configure( 'keystone.cache.mongo', arguments=self.arguments ) self.assertTrue(True) # reached here means no initialization error
def test_backend_multi_set_should_update_existing(self): region = dp_region.make_region().configure( 'keystone.cache.mongo', arguments=self.arguments ) random_key = uuid.uuid4().hex random_key1 = uuid.uuid4().hex random_key2 = uuid.uuid4().hex random_key3 = uuid.uuid4().hex mapping = {random_key1: 'dummyValue1', random_key2: 'dummyValue2', random_key3: 'dummyValue3'} region.set_multi(mapping) # should return NO_VALUE as key does not exist in cache self.assertEqual(api.NO_VALUE, region.get(random_key)) self.assertEqual("dummyValue1", region.get(random_key1)) self.assertEqual("dummyValue2", region.get(random_key2)) self.assertEqual("dummyValue3", region.get(random_key3)) mapping = {random_key1: 'dummyValue4', random_key2: 'dummyValue5'} region.set_multi(mapping) self.assertEqual(api.NO_VALUE, region.get(random_key)) self.assertEqual("dummyValue4", region.get(random_key1)) self.assertEqual("dummyValue5", region.get(random_key2)) self.assertEqual("dummyValue3", region.get(random_key3))
def main(global_config, **settings): """ This function returns a Pyramid WSGI application. """ config = Configurator(settings=settings) config.include('pyramid_jinja2') config.include('.site') config.scan() config.add_translation_dirs('kiberpipa.bookshelf:locale/') # setup cookie session cookie_session_secret = ''.join('%02x' % ord(x) for x in os.urandom(16)) my_session_factory = UnencryptedCookieSessionFactoryConfig( cookie_session_secret) config.set_session_factory(my_session_factory) # dogpile.cache configuration memory_region = make_region().configure_from_config(settings, "cache.memory.") config.set_request_property(lambda r: memory_region, name="cache_region_memory", reify=True) return config.make_wsgi_app()
def test_sessionmaker_new_conf(cache_dict): try: from dogpile.cache.region import make_region except ImportError: pytest.skip("dogpile.cache not available") region = make_region().configure('dogpile.cache.memory', arguments={'cache_dict': cache_dict}) settings = {'backend': 'dogpile', 'domain': 'example.com', 'signature_key': test_sig_key, 'region': region } Session = sessionmaker() assert not hasattr(Session, "settings") Session.configure(**settings) assert isinstance(Session(), DogpileSession) del Session.settings["region"] assert "region" not in Session.settings assert isinstance(Session(region=region), DogpileSession) Session.settings["region"] = region assert Session.settings["signature_key"] == test_sig_key session = Session(signature_key=test_enc_key) assert session.sig_key == test_enc_key
def test_backend_multi_delete_data(self): region = dp_region.make_region().configure( 'keystone.cache.mongo', arguments=self.arguments ) random_key = uuid.uuid4().hex random_key1 = uuid.uuid4().hex random_key2 = uuid.uuid4().hex random_key3 = uuid.uuid4().hex mapping = {random_key1: 'dummyValue1', random_key2: 'dummyValue2', random_key3: 'dummyValue3'} region.set_multi(mapping) # should return NO_VALUE as key does not exist in cache self.assertEqual(api.NO_VALUE, region.get(random_key)) self.assertEqual("dummyValue1", region.get(random_key1)) self.assertEqual("dummyValue2", region.get(random_key2)) self.assertEqual("dummyValue3", region.get(random_key3)) self.assertEqual(api.NO_VALUE, region.get("InvalidKey")) keys = mapping.keys() region.delete_multi(keys) self.assertEqual(api.NO_VALUE, region.get("InvalidKey")) # should return NO_VALUE as keys no longer exist in cache self.assertEqual(api.NO_VALUE, region.get(random_key1)) self.assertEqual(api.NO_VALUE, region.get(random_key2)) self.assertEqual(api.NO_VALUE, region.get(random_key3))
def test_additional_crud_method_arguments_support(self): """Additional arguments should works across find/insert/update.""" self.arguments['wtimeout'] = 30000 self.arguments['j'] = True self.arguments['continue_on_error'] = True self.arguments['secondary_acceptable_latency_ms'] = 60 region = dp_region.make_region().configure( 'keystone.cache.mongo', arguments=self.arguments ) # There is no proxy so can access MongoCacheBackend directly api_methargs = region.backend.api.meth_kwargs self.assertEqual(api_methargs['wtimeout'], 30000) self.assertEqual(api_methargs['j'], True) self.assertEqual(api_methargs['continue_on_error'], True) self.assertEqual(api_methargs['secondary_acceptable_latency_ms'], 60) random_key = uuid.uuid4().hex region.set(random_key, "dummyValue1") self.assertEqual("dummyValue1", region.get(random_key)) region.set(random_key, "dummyValue2") self.assertEqual("dummyValue2", region.get(random_key)) random_key = uuid.uuid4().hex region.set(random_key, "dummyValue3") self.assertEqual("dummyValue3", region.get(random_key))
def test_backend_multi_delete_data(self): region = dp_region.make_region().configure( 'oslo_cache.etcd3gw', arguments=self.arguments ) random_key = uuidutils.generate_uuid(dashed=False) random_key1 = uuidutils.generate_uuid(dashed=False) random_key2 = uuidutils.generate_uuid(dashed=False) random_key3 = uuidutils.generate_uuid(dashed=False) mapping = {random_key1: 'dummyValue1', random_key2: 'dummyValue2', random_key3: 'dummyValue3'} region.set_multi(mapping) # should return NO_VALUE as key does not exist in cache self.assertEqual(NO_VALUE, region.get(random_key)) self.assertEqual("dummyValue1", region.get(random_key1)) self.assertEqual("dummyValue2", region.get(random_key2)) self.assertEqual("dummyValue3", region.get(random_key3)) self.assertEqual(NO_VALUE, region.get("InvalidKey")) keys = mapping.keys() region.delete_multi(keys) self.assertEqual(NO_VALUE, region.get("InvalidKey")) # should return NO_VALUE as keys no longer exist in cache self.assertEqual(NO_VALUE, region.get(random_key1)) self.assertEqual(NO_VALUE, region.get(random_key2)) self.assertEqual(NO_VALUE, region.get(random_key3))
def test_backend_multi_set_should_update_existing(self): region = dp_region.make_region().configure( 'oslo_cache.mongo', arguments=self.arguments ) random_key = uuidutils.generate_uuid(dashed=False) random_key1 = uuidutils.generate_uuid(dashed=False) random_key2 = uuidutils.generate_uuid(dashed=False) random_key3 = uuidutils.generate_uuid(dashed=False) mapping = {random_key1: 'dummyValue1', random_key2: 'dummyValue2', random_key3: 'dummyValue3'} region.set_multi(mapping) # should return NO_VALUE as key does not exist in cache self.assertEqual(NO_VALUE, region.get(random_key)) self.assertEqual("dummyValue1", region.get(random_key1)) self.assertEqual("dummyValue2", region.get(random_key2)) self.assertEqual("dummyValue3", region.get(random_key3)) mapping = {random_key1: 'dummyValue4', random_key2: 'dummyValue5'} region.set_multi(mapping) self.assertEqual(NO_VALUE, region.get(random_key)) self.assertEqual("dummyValue4", region.get(random_key1)) self.assertEqual("dummyValue5", region.get(random_key2)) self.assertEqual("dummyValue3", region.get(random_key3))
def test_multiple_region_cache_configuration(self): arguments1 = copy.copy(self.arguments) arguments1['cache_collection'] = 'cache_region1' region1 = dp_region.make_region().configure('keystone.cache.mongo', arguments=arguments1) # There is no proxy so can access MongoCacheBackend directly self.assertEqual(region1.backend.api.hosts, 'localhost:27017') self.assertEqual(region1.backend.api.db_name, 'ks_cache') self.assertEqual(region1.backend.api.cache_collection, 'cache_region1') self.assertEqual(region1.backend.api.username, 'test_user') self.assertEqual(region1.backend.api.password, 'test_password') # Should be None because of delayed initialization self.assertIsNone(region1.backend.api._data_manipulator) random_key1 = uuid.uuid4().hex region1.set(random_key1, "dummyValue10") self.assertEqual("dummyValue10", region1.get(random_key1)) # Now should have initialized self.assertIsInstance(region1.backend.api._data_manipulator, mongo.BaseTransform) class_name = '%s.%s' % (MyTransformer.__module__, "MyTransformer") arguments2 = copy.copy(self.arguments) arguments2['cache_collection'] = 'cache_region2' arguments2['son_manipulator'] = class_name region2 = dp_region.make_region().configure('keystone.cache.mongo', arguments=arguments2) # There is no proxy so can access MongoCacheBackend directly self.assertEqual(region2.backend.api.hosts, 'localhost:27017') self.assertEqual(region2.backend.api.db_name, 'ks_cache') self.assertEqual(region2.backend.api.cache_collection, 'cache_region2') # Should be None because of delayed initialization self.assertIsNone(region2.backend.api._data_manipulator) random_key = uuid.uuid4().hex region2.set(random_key, "dummyValue20") self.assertEqual("dummyValue20", region2.get(random_key)) # Now should have initialized self.assertIsInstance(region2.backend.api._data_manipulator, MyTransformer) region1.set(random_key1, "dummyValue22") self.assertEqual("dummyValue22", region1.get(random_key1))
def test_backend_get_missing_data(self): region = dp_region.make_region().configure('oslo_cache.mongo', arguments=self.arguments) random_key = uuid.uuid4().hex # should return NO_VALUE as key does not exist in cache self.assertEqual(NO_VALUE, region.get(random_key))
def make_nsa_region(name): reg = make_region(key_mangler=md5_key_mangler).configure( 'dogpile.cache.dbm', expiration_time=3600, arguments={ 'filename': os.path.join(dogroot, '{0}_cache.dbm'.format(name)) }) return reg
def setUp(self): super(CacheDictBackendTest, self).setUp() self.config_fixture = self.useFixture(config_fixture.Config()) self.config_fixture.config(group='cache', backend='oslo_cache.dict') self.time_fixture = self.useFixture(time_fixture.TimeFixture()) self.region = dp_region.make_region() self.region.configure('oslo_cache.dict', arguments={'expiration_time': 0.5})
def test_backend_set_blank_as_data(self): region = dp_region.make_region().configure('oslo_cache.etcd3gw', arguments=self.arguments) random_key = uuidutils.generate_uuid(dashed=False) region.set(random_key, "") self.assertEqual("", region.get(random_key))
def test_backend_get_missing_data(self): region = dp_region.make_region().configure('oslo_cache.etcd3gw', arguments=self.arguments) random_key = uuidutils.generate_uuid(dashed=False) # should return NO_VALUE as key does not exist in cache self.assertEqual(NO_VALUE, region.get(random_key))
def cache_maker(name): reg= make_region().configure( dogpile_dict_config.keys().pop(), **dogpile_dict_config.values()[0] ) reg.put = reg.set reg.invalidate = reg.delete return reg
def test_backend_set_none_as_data(self): region = dp_region.make_region().configure('oslo_cache.mongo', arguments=self.arguments) random_key = uuid.uuid4().hex region.set(random_key, None) self.assertIsNone(region.get(random_key))
def test_backend_set_blank_as_data(self): region = dp_region.make_region().configure('oslo_cache.mongo', arguments=self.arguments) random_key = uuid.uuid4().hex region.set(random_key, "") self.assertEqual("", region.get(random_key))
def setUp(self): super(CacheDictBackendTest, self).setUp() self.config_fixture = self.useFixture(config_fixture.Config()) self.config_fixture.config(group='cache', backend='oslo_cache.dict') self.time_fixture = self.useFixture(time_fixture.TimeFixture()) self.region = dp_region.make_region() self.region.configure( 'oslo_cache.dict', arguments={'expiration_time': 0.5})
def test_backend_set_data(self): region = dp_region.make_region().configure( 'oslo_cache.etcd3gw', arguments=self.arguments ) random_key = uuidutils.generate_uuid(dashed=False) region.set(random_key, "dummyValue") self.assertEqual("dummyValue", region.get(random_key))
def test_backend_set_data_with_int_as_valid_ttl(self): self.arguments['mongo_ttl_seconds'] = 1800 region = dp_region.make_region().configure('keystone.cache.mongo', arguments=self.arguments) self.assertEqual(1800, region.backend.api.ttl_seconds) random_key = uuid.uuid4().hex region.set(random_key, "dummyValue") self.assertEqual("dummyValue", region.get(random_key))
def init_region(conf, region=None): """ Initialize the caching module. """ cache_region = make_region(function_key_generator=keygen_function) kwargs = dict((k, conf[k]) for k in ("arguments", "expiration_time") if k in conf) cache_region.configure(conf["backend"], **kwargs) _regions[region] = cache_region return cache_region
def test_correct_write_concern(self): self.arguments['w'] = 1 region = dp_region.make_region().configure('keystone.cache.mongo', arguments=self.arguments) random_key = uuid.uuid4().hex region.set(random_key, "dummyValue10") # There is no proxy so can access MongoCacheBackend directly self.assertEqual(1, region.backend.api.w)
def get_region(region=None): """ Return a cache region. """ try: return _REGION[region] except KeyError: # pragma: no cover LOG.error("No such caching region. A region must be initialized before it can be used") return make_region(function_key_generator=keygen_function)
def test_backend_set_data_with_string_as_valid_ttl(self): self.arguments['mongo_ttl_seconds'] = '3600' region = dp_region.make_region().configure('oslo_cache.mongo', arguments=self.arguments) self.assertEqual(3600, region.backend.api.ttl_seconds) random_key = uuid.uuid4().hex region.set(random_key, "dummyValue") self.assertEqual("dummyValue", region.get(random_key))
def test_correct_write_concern(self): self.arguments['w'] = 1 region = dp_region.make_region().configure('oslo_cache.mongo', arguments=self.arguments) random_key = uuidutils.generate_uuid(dashed=False) region.set(random_key, "dummyValue10") # There is no proxy so can access MongoCacheBackend directly self.assertEqual(1, region.backend.api.w)
def test_backend_set_data_with_int_as_valid_ttl(self): self.arguments['mongo_ttl_seconds'] = 1800 region = dp_region.make_region().configure('oslo_cache.mongo', arguments=self.arguments) self.assertEqual(1800, region.backend.api.ttl_seconds) random_key = uuidutils.generate_uuid(dashed=False) region.set(random_key, "dummyValue") self.assertEqual("dummyValue", region.get(random_key))
def test_correct_write_concern(self): self.arguments['w'] = 1 region = dp_region.make_region().configure('keystone.cache.mongo', arguments=self.arguments) random_key = uuid.uuid4().hex region.set(random_key, "dummyValue10") # There is no proxy so can access MongoCacheBackend directly self.assertEqual(region.backend.api.w, 1)
def test_backend_set_data_with_int_as_valid_ttl(self): self.arguments['mongo_ttl_seconds'] = 1800 region = dp_region.make_region().configure('keystone.cache.mongo', arguments=self.arguments) self.assertEqual(region.backend.api.ttl_seconds, 1800) random_key = uuid.uuid4().hex region.set(random_key, "dummyValue") self.assertEqual("dummyValue", region.get(random_key))
def test_incorrect_read_preference(self): self.arguments['read_preference'] = 'inValidValue' region = dp_region.make_region().configure('keystone.cache.mongo', arguments=self.arguments) # As per delayed loading of pymongo, read_preference value should # still be string and NOT enum self.assertEqual(region.backend.api.read_preference, 'inValidValue') random_key = uuid.uuid4().hex self.assertRaises(ValueError, region.set, random_key, "dummyValue10")
def init_region(conf, region=None): """ Initialize the caching module. """ cache_region = make_region(function_key_generator=keygen_function) kwargs = dict( (k, conf[k]) for k in ('arguments', 'expiration_time') if k in conf) cache_region.configure(conf['backend'], **kwargs) _regions[region] = cache_region return cache_region
def test_backend_set_data(self): region = dp_region.make_region().configure( 'keystone.cache.mongo', arguments=self.arguments ) random_key = uuid.uuid4().hex region.set(random_key, "dummyValue") self.assertEqual("dummyValue", region.get(random_key))
def test_backend_set_none_as_data(self): region = dp_region.make_region().configure( 'oslo_cache.etcd3gw', arguments=self.arguments ) random_key = uuidutils.generate_uuid(dashed=False) region.set(random_key, None) self.assertIsNone(region.get(random_key))
def test_backend_set_data(self): region = dp_region.make_region().configure( 'oslo_cache.mongo', arguments=self.arguments ) random_key = uuid.uuid4().hex region.set(random_key, "dummyValue") self.assertEqual("dummyValue", region.get(random_key))
def test_backend_set_blank_as_data(self): region = dp_region.make_region().configure( 'oslo_cache.mongo', arguments=self.arguments ) random_key = uuidutils.generate_uuid(dashed=False) region.set(random_key, "") self.assertEqual("", region.get(random_key))
def test_backend_get_missing_data(self): region = dp_region.make_region().configure( 'oslo_cache.mongo', arguments=self.arguments ) random_key = uuidutils.generate_uuid(dashed=False) # should return NO_VALUE as key does not exist in cache self.assertEqual(NO_VALUE, region.get(random_key))
def test_backend_set_data(self): region = dp_region.make_region().configure( 'oslo_cache.mongo', arguments=self.arguments ) random_key = uuidutils.generate_uuid(dashed=False) region.set(random_key, "dummyValue") self.assertEqual("dummyValue", region.get(random_key))
def test_backend_set_none_as_data(self): region = dp_region.make_region().configure( 'oslo_cache.mongo', arguments=self.arguments ) random_key = uuidutils.generate_uuid(dashed=False) region.set(random_key, None) self.assertIsNone(region.get(random_key))
def test_incorrect_read_preference(self): self.arguments['read_preference'] = 'inValidValue' region = dp_region.make_region().configure('oslo_cache.mongo', arguments=self.arguments) # As per delayed loading of pymongo, read_preference value should # still be string and NOT enum self.assertEqual('inValidValue', region.backend.api.read_preference) random_key = uuidutils.generate_uuid(dashed=False) self.assertRaises(ValueError, region.set, random_key, "dummyValue10")
def test_backend_set_blank_as_data(self): region = dp_region.make_region().configure( 'keystone.cache.mongo', arguments=self.arguments ) random_key = uuid.uuid4().hex region.set(random_key, "") self.assertEqual("", region.get(random_key))
def test_backend_get_missing_data(self): region = dp_region.make_region().configure( 'keystone.cache.mongo', arguments=self.arguments ) random_key = uuid.uuid4().hex # should return NO_VALUE as key does not exist in cache self.assertEqual(api.NO_VALUE, region.get(random_key))
def test_backend_set_none_as_data(self): region = dp_region.make_region().configure( 'keystone.cache.mongo', arguments=self.arguments ) random_key = uuid.uuid4().hex region.set(random_key, None) self.assertIsNone(region.get(random_key))
def init_region(conf, region=None): """ Initialize the caching module. """ cache_region = make_region(function_key_generator=keygen_function) kwargs = dict( (k, conf[k]) for k in ("arguments", "expiration_time") if k in conf) cache_region.configure(conf["backend"], **kwargs) _REGION[region] = cache_region return cache_region
def __init__(self, **option): self.name = option["name"] self.load() self.cache = make_region( ).configure( 'dogpile.cache.dbm', ### 2 days expiration_time = 3600 * 7 * 24, arguments = { "filename":"./%s.dbm" % option["name"] }) atexit.register(lambda: self.save())
def test_incorrect_read_preference(self): self.arguments['read_preference'] = 'inValidValue' region = dp_region.make_region().configure('keystone.cache.mongo', arguments=self.arguments) # As per delayed loading of pymongo, read_preference value should # still be string and NOT enum self.assertEqual('inValidValue', region.backend.api.read_preference) random_key = uuid.uuid4().hex self.assertRaises(ValueError, region.set, random_key, "dummyValue10")
def test_backend_delete_data(self): region = dp_region.make_region().configure('keystone.cache.mongo', arguments=self.arguments) random_key = uuid.uuid4().hex region.set(random_key, "dummyValue") self.assertEqual("dummyValue", region.get(random_key)) region.delete(random_key) # should return NO_VALUE as key no longer exists in cache self.assertEqual(api.NO_VALUE, region.get(random_key))
def test_backend_delete_data(self): region = dp_region.make_region().configure('oslo_cache.mongo', arguments=self.arguments) random_key = uuidutils.generate_uuid(dashed=False) region.set(random_key, "dummyValue") self.assertEqual("dummyValue", region.get(random_key)) region.delete(random_key) # should return NO_VALUE as key no longer exists in cache self.assertEqual(NO_VALUE, region.get(random_key))
def __init__(self, cachedir, enabled=True): if enabled: backend = 'dogpile.cache.dbm' cache_dir = self._get_cache_dir(cachedir) filename = os.path.join(cache_dir, 'cache.dbm') LOG.debug('Using cache: %s' % filename) arguments = { 'filename': filename, } else: backend = 'dogpile.cache.null' arguments = {} self.region = make_region().configure(backend, arguments=arguments)
def __init__(self, cachedir, enabled=True): if enabled: backend = "dogpile.cache.dbm" cache_dir = self._get_cache_dir(cachedir) filename = os.path.join(cache_dir, "cache.dbm") LOG.debug("Using cache: %s" % filename) arguments = { "filename": filename, } else: backend = "dogpile.cache.null" arguments = {} self.region = make_region().configure(backend, arguments=arguments)
def setup(self, app): """ Setup self. """ super().setup(app) if self.cfg.test: self.cfg.configs = {"cache.test.backend": "dogpile.cache.null"} for k in self.cfg.regions.keys(): self.cfg.regions[k] = "cache.test." for k, v in self.cfg.regions.items(): new_region = make_region(function_key_generator=self.cfg.function_key_generator) new_region.configure_from_config(self.cfg.configs, v) setattr(self, k, new_region)
def get_key_value_store(name, kvs_region=None): """Instantiate a new :class:`.KeyValueStore` or return a previous instantiation that has the same name. """ global KEY_VALUE_STORE_REGISTRY _register_backends() key_value_store = KEY_VALUE_STORE_REGISTRY.get(name) if key_value_store is None: if kvs_region is None: kvs_region = region.make_region(name=name) key_value_store = KeyValueStore(kvs_region) KEY_VALUE_STORE_REGISTRY[name] = key_value_store return key_value_store
def setup(self, app): """ Setup self. """ super().setup(app) if self.cfg.test: self.cfg.configs = {'cache.test.backend': 'dogpile.cache.null'} for k in self.cfg.regions.keys(): self.cfg.regions[k] = 'cache.test.' for k, v in self.cfg.regions.items(): new_region = make_region( function_key_generator=self.cfg.function_key_generator) new_region.configure_from_config(self.cfg.configs, v) setattr(self, k, new_region)
def test_backend_set_same_key_multiple_times(self): region = dp_region.make_region().configure('oslo_cache.mongo', arguments=self.arguments) random_key = uuidutils.generate_uuid(dashed=False) region.set(random_key, "dummyValue") self.assertEqual("dummyValue", region.get(random_key)) dict_value = {'key1': 'value1'} region.set(random_key, dict_value) self.assertEqual(dict_value, region.get(random_key)) region.set(random_key, "dummyValue2") self.assertEqual("dummyValue2", region.get(random_key))
def test_correct_read_preference(self): self.arguments['read_preference'] = 'secondaryPreferred' region = dp_region.make_region().configure('oslo_cache.mongo', arguments=self.arguments) # As per delayed loading of pymongo, read_preference value should # still be string and NOT enum self.assertEqual('secondaryPreferred', region.backend.api.read_preference) random_key = uuidutils.generate_uuid(dashed=False) region.set(random_key, "dummyValue10") # Now as pymongo is loaded so expected read_preference value is enum. # There is no proxy so can access MongoCacheBackend directly self.assertEqual(3, region.backend.api.read_preference)
def test_dict_backend_zero_expiration_time(self): self.region = dp_region.make_region() self.region.configure('oslo_cache.dict', arguments={'expiration_time': 0}) self.region.set(KEY, VALUE) self.time_fixture.advance_time_seconds(1) self.assertEqual(VALUE, self.region.get(KEY)) self.assertEqual(1, len(self.region.backend.cache)) self.region.backend._clear() self.assertEqual(VALUE, self.region.get(KEY)) self.assertEqual(1, len(self.region.backend.cache))
def test_backend_set_same_key_multiple_times(self): region = dp_region.make_region().configure('keystone.cache.mongo', arguments=self.arguments) random_key = uuid.uuid4().hex region.set(random_key, "dummyValue") self.assertEqual("dummyValue", region.get(random_key)) dict_value = {'key1': 'value1'} region.set(random_key, dict_value) self.assertEqual(dict_value, region.get(random_key)) region.set(random_key, "dummyValue2") self.assertEqual("dummyValue2", region.get(random_key))
def create_region(cachedir, name, time): regions[name] = make_region( # the "dbm" backend needs # string-encoded keys key_mangler=md5_key_mangler ).configure( # using type 'file' to illustrate # serialized persistence. Normally # memcached or similar is a better choice # for caching. 'dogpile.cache.dbm', expiration_time=time, arguments={ "filename": os.path.join(cachedir, "cache.dbm") } )