def test_dataset_cache(self, mockcache):
mockcache.get_cache = Mock(return_value=Cache('TEST'))
from etl.model.dataset import DST_CACHE, DEFAULT_LIMIT_FOR_PERFORMANCE
dataset = model.DBSession.query(model.DataSet).get(self.dataset)
cache_key = dataset.cache_key(DEFAULT_LIMIT_FOR_PERFORMANCE)
assert dataset.sample is DST_CACHE.get_value(cache_key)
dataset.query = 'SELECT * FROM tg_user LIMIT 10'
model.DBSession.add(dataset)
model.DBSession.flush()
transaction.commit()
assert_raises(
KeyError,
DST_CACHE.get_value,
cache_key
)
dataset = model.DBSession.query(model.DataSet).get(self.dataset)
assert dataset.sample is DST_CACHE.get_value(cache_key)
model.DBSession.delete(dataset)
model.DBSession.flush()
transaction.commit()
assert_raises(
KeyError,
DST_CACHE.get_value,
cache_key
)
def test_clear():
cache = Cache('test', data_dir='./cache', url=db_url, type='ext:database')
o = object()
cache.set_value("test", o)
assert "test" in cache
cache.clear()
assert "test" not in cache
def make_cache():
"""Return a ``Cache`` for use by the unit tests."""
return Cache('test',
data_dir='./cache',
bind=engine,
table=cache_table,
type='ext:sqla')
def test_clear():
cache = Cache('test', url=db_url, type=db_type, database=db_name)
o = object()
cache.set_value("test", o)
assert "test" in cache
cache.clear()
assert "test" not in cache
def test_clear():
cache = Cache('test', url=db_url, type=db_type, database=db_name)
o = object()
cache.set_value("test", o)
assert cache.has_key("test")
cache.clear()
assert not cache.has_key("test")
def test_dropping_keys():
cache = Cache('test',
data_dir='./cache',
url=uri,
type='mongodb',
sparse_collection=True)
cache.set_value('test', 20)
cache.set_value('fred', 10)
assert cache.has_key('test')
assert 'test' in cache
assert cache.has_key('fred')
# Directly nuke the actual key, to simulate it being removed by mongodb
cache.namespace.mongo.update({'_id': {
'namespace': 'test',
'key': 'test'
}}, {'$unset': {
'data': True
}},
safe=True)
assert not cache.has_key('test')
assert cache.has_key('fred')
# Nuke the keys dict, it might die, who knows
cache.namespace.mongo.remove(
{
'_id': 'test',
'data.test': {
'$exists': True
}
}, safe=True)
assert cache.has_key('fred')
# And we still need clear to work, even if it won't work well
cache.clear()
def test_uses_mongo_client(self):
from mongodb_gridfs_beaker import MongoDBGridFSNamespaceManager
cache = Cache('test',
data_dir='./cache',
url=uri,
type="mongodb_gridfs")
assert isinstance(cache.namespace, MongoDBGridFSNamespaceManager)
def test_multi_keys():
cache = Cache('newtests', data_dir='./cache', type='dbm')
cache.clear()
called = {}
def create_func():
called['here'] = True
return 'howdy'
try:
cache.get_value('key1')
except KeyError:
pass
else:
raise Exception("Failed to keyerror on nonexistent key")
assert 'howdy' == cache.get_value('key2', createfunc=create_func)
assert called['here'] == True
del called['here']
try:
cache.get_value('key3')
except KeyError:
pass
else:
raise Exception("Failed to keyerror on nonexistent key")
try:
cache.get_value('key1')
except KeyError:
pass
else:
raise Exception("Failed to keyerror on nonexistent key")
assert 'howdy' == cache.get_value('key2', createfunc=create_func)
assert called == {}
def test_createfunc(self):
cache = Cache('test', **self.CACHE_ARGS)
def createfunc():
createfunc.count += 1
return createfunc.count
createfunc.count = 0
def keepitlocked():
lock = cache.namespace.get_creation_lock('test')
lock.acquire()
time.sleep(1.0)
lock.release()
v0 = cache.get_value('test', createfunc=createfunc)
self.assertEqual(v0, 1)
v0 = cache.get_value('test', createfunc=createfunc)
self.assertEqual(v0, 1)
cache.remove_value('test')
begin = datetime.datetime.utcnow()
t = threading.Thread(target=keepitlocked)
t.start()
v0 = cache.get_value('test', createfunc=createfunc)
self.assertEqual(v0, 2)
# Ensure that the `get_value` was blocked by the concurrent thread.
assert datetime.datetime.utcnow() - begin > datetime.timedelta(seconds=1)
t.join()
def test_spaces_in_unicode_keys(self):
cache = Cache("test", **self.CACHE_ARGS)
o = object()
cache.set_value(u_("hi ŏ"), o)
assert u_("hi ŏ") in cache
assert u_("hŏa") not in cache
cache.remove_value(u_("hi ŏ"))
assert u_("hi ŏ") not in cache
def test_unicode_keys():
cache = Cache('test', url=db_url, type=db_type, database=db_name)
o = object()
cache.set_value('hiŏ', o)
assert 'hiŏ' in cache
assert 'hŏa' not in cache
cache.remove_value('hiŏ')
assert 'hiŏ' not in cache
def test_spaces_in_keys():
cache = Cache("test", data_dir="./cache", url=mc_url, type="ext:memcached")
cache.set_value("has space", 24)
assert cache.has_key("has space")
assert 24 == cache.get_value("has space")
cache.set_value("hasspace", 42)
assert cache.has_key("hasspace")
assert 42 == cache.get_value("hasspace")
def test_spaces_in_unicode_keys():
cache = Cache("test", data_dir="./cache", url=mc_url, type="ext:memcached")
o = object()
cache.set_value(u_("hi ŏ"), o)
assert u_("hi ŏ") in cache
assert u_("hŏa") not in cache
cache.remove_value(u_("hi ŏ"))
assert u_("hi ŏ") not in cache
def test_uses_pylibmc_client(self):
from beaker.ext import memcached
cache = Cache('test',
data_dir='./cache',
memcache_module='pylibmc',
url=mc_url,
type="ext:memcached")
assert isinstance(cache.namespace, memcached.PyLibMCNamespaceManager)
def test_unicode_keys():
cache = Cache('test', data_dir='./cache', url=db_url, type='ext:database')
o = object()
cache.set_value(u_('hiŏ'), o)
assert u_('hiŏ') in cache
assert u_('hŏa') not in cache
cache.remove_value(u_('hiŏ'))
assert u_('hiŏ') not in cache
def test_spaces_in_unicode_keys():
cache = Cache('test', data_dir='./cache', url=mc_url, type='ext:memcached')
o = object()
cache.set_value(u_('hi ŏ'), o)
assert u_('hi ŏ') in cache
assert u_('hŏa') not in cache
cache.remove_value(u_('hi ŏ'))
assert u_('hi ŏ') not in cache
def test_spaces_in_keys():
cache = Cache('test', data_dir='./cache', url=mc_url, type='ext:memcached')
cache.set_value("has space", 24)
assert cache.has_key("has space")
assert 24 == cache.get_value("has space")
cache.set_value("hasspace", 42)
assert cache.has_key("hasspace")
assert 42 == cache.get_value("hasspace")
def test_unicode_keys():
cache = Cache('test', data_dir='./cache', url=mc_url, type='ext:memcached')
o = object()
cache.set_value(u'hiŏ', o)
assert u'hiŏ' in cache
assert u'hŏa' not in cache
cache.remove_value(u'hiŏ')
assert u'hiŏ' not in cache
def test_uses_mongo_client(self):
from beaker_mongodb import MongoDBNamespaceManager
cache = Cache('test',
data_dir='./cache',
url=uri,
type="mongodb",
sparse_collection=True)
assert isinstance(cache.namespace, MongoDBNamespaceManager)
def test_spaces_in_unicode_keys():
cache = Cache('test', data_dir='./cache', url=uri, type='mongodb')
o = object()
cache.set_value(u'hi ŏ', o)
assert u'hi ŏ' in cache
assert u'hŏa' not in cache
cache.remove_value(u'hi ŏ')
assert u'hi ŏ' not in cache
def test_spaces_in_keys():
cache = Cache('test', data_dir='./cache', url=uri, type='mongodb')
cache.set_value("has space", 24)
assert cache.has_key("has space")
assert 24 == cache.get_value("has space")
cache.set_value("hasspace", 42)
assert cache.has_key("hasspace")
assert 42 == cache.get_value("hasspace")
def test_unicode_keys():
cache = Cache("test", data_dir="./cache", type="dbm")
o = object()
cache.set_value(u_("hiŏ"), o)
assert u_("hiŏ") in cache
assert u_("hŏa") not in cache
cache.remove_value(u_("hiŏ"))
assert u_("hiŏ") not in cache
def test_spaces_in_keys(self):
cache = Cache('test', **self.CACHE_ARGS)
cache.set_value("has space", 24)
assert cache.has_key("has space")
assert 24 == cache.get_value("has space")
cache.set_value("hasspace", 42)
assert cache.has_key("hasspace")
assert 42 == cache.get_value("hasspace")
def test_spaces_in_unicode_keys(self):
cache = Cache('test', **self.CACHE_ARGS)
o = object()
cache.set_value(u_('hi ŏ'), o)
assert u_('hi ŏ') in cache
assert u_('hŏa') not in cache
cache.remove_value(u_('hi ŏ'))
assert u_('hi ŏ') not in cache
def test_expiretime():
cache = Cache('test', data_dir='./cache', url=uri, type='mongodb_gridfs')
cache.set_value('test', 20, expiretime=-10)
cache.set_value('foo', 20)
assert not cache.has_key('test')
assert 'test' not in cache
assert cache.has_key('foo')
assert 'foo' in cache
def test_has_key_multicache():
cache = Cache('test',
data_dir='./cache',
url=uri,
type='mongodb',
sparse_collection=True,
skip_pickle=True)
o = object()
cache.set_value("test", o)
assert cache.has_key("test")
assert "test" in cache
cache = Cache('test',
data_dir='./cache',
url=uri,
type='mongodb',
sparse_collection=True,
skip_pickle=True)
assert cache.has_key("test")
def test_dont_use_pylibmc_client(self):
from beaker.ext.memcached import _load_client
load_mock = mock.Mock()
load_mock.return_value = _load_client("memcache")
with mock.patch("beaker.ext.memcached._load_client", load_mock):
cache = Cache("test", data_dir="./cache", url=mc_url, type="ext:memcached")
assert not isinstance(cache.namespace, memcached.PyLibMCNamespaceManager)
assert isinstance(cache.namespace, memcached.MemcachedNamespaceManager)
def test_clear(self):
cache = Cache('test', **self.CACHE_ARGS)
cache.set_value('test', 20)
cache.set_value('fred', 10)
assert cache.has_key('test')
assert 'test' in cache
assert cache.has_key('fred')
cache.clear()
assert not cache.has_key("test")
def test_clear(self):
cache = Cache("test", **self.CACHE_ARGS)
cache.set_value("test", 20)
cache.set_value("fred", 10)
assert cache.has_key("test")
assert "test" in cache
assert cache.has_key("fred")
cache.clear()
assert not cache.has_key("test")
def test_expiretime_automatic(self):
if not self.SUPPORTS_EXPIRATION:
self.skipTest("NamespaceManager does not support automatic expiration")
cache = Cache("test", **self.CACHE_ARGS)
cache.set_value("has space", 24, expiretime=1)
assert cache.namespace.has_key("has space")
time.sleep(1.1)
assert not cache.namespace.has_key("has space")
