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('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('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('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 __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")
}
)
