class TestStore(unittest.TestCase): def setUp(self): self.redis_storage = RedisStorage(host=os.getenv('REDIS_HOST'), port=int(os.getenv('REDIS_PORT'))) self.store = Store(self.redis_storage) self.key = 'key1' self.value = 'value1' def test_store_connected(self): self.assertTrue(self.store.storage.set(self.key, self.value)) self.assertEqual(self.store.get(self.key), self.value) def test_store_disconnected(self): self.redis_storage.db.get = MagicMock(side_effect=ConnectionError()) self.assertRaises(ConnectionError, self.store.get, self.key) self.assertEqual(self.redis_storage.db.get.call_count, Store.max_retries) def test_cache_connected(self): self.assertTrue(self.store.cache_set(self.key, self.value)) self.assertEqual(self.store.cache_get(self.key), self.value) def test_cache_disconnected(self): self.redis_storage.db.get = MagicMock(side_effect=ConnectionError()) self.redis_storage.db.set = MagicMock(side_effect=ConnectionError()) self.assertEqual(self.store.cache_get(self.key), None) self.assertEqual(self.store.cache_set(self.key, self.value), None) self.assertEqual(self.redis_storage.db.get.call_count, Store.max_retries) self.assertEqual(self.redis_storage.db.set.call_count, Store.max_retries)
def test_cache_get_error_connect(self): store = Store( MemcacheAdapter(address=os.environ['STORE_PORT_11211_TCP_ADDR'], port=8000, ignore_exc=False)) with self.assertRaises(Exception): store.cache_get('error_get_key', )
class TestStore(unittest.TestCase): def setUp(self): self.store = Store(RedisStorage()) @cases([('key_0', 0), ('key_1', 1), ('key_2', 2)]) def test_store_set_cache_get(self, key, value): self.store.cache_set(key, value, 1) cache_value = self.store.cache_get(key).decode('utf-8') self.assertEqual(cache_value, str(value)) @cases([('key_3', 0), ('key_4', 1), ('key_5', 2)]) def test_store_set_get(self, key, value): self.store.cache_set(key, value, 1) cache_value = self.store.get(key).decode('utf-8') self.assertEqual(cache_value, str(value)) def test_cache_get_and_set_not_raise_connection_error(self): # create store with incorrect port for redis store = Store(RedisStorage(port=6378)) # try to get and set cache value in not working storage self.assertEqual(store.cache_get('key_0'), None) self.assertEqual(store.cache_set('key_0', 0), None) def test_get_raise_connection_error(self): # create store with incorrect port for redis store = Store(RedisStorage(port=6378)) # try to get value in not working storage self.assertRaises(ConnectionError, store.get, 'key_0')
def test_cache_get(self, value): self.redis_base.flushall() store = Store(RedisStore()) key, val = value self.redis_base.set(key, val) self.assertEqual(val, store.cache_get(key)) self.assertIsInstance(store.cache_get(key), basestring)
class StorageTest(unittest.TestCase): def setUp(self): self.store = Store(connect_timeout=5, attempts=3) def test_on_disconnected_store_cache_set_cache_get(self): self.store = Store(port=9999, connect_timeout=1, attempts=1) key = "uid:c20ad4d76fe97759aa27a0c99bff6710" self.store.cache_set(key, -1, 60) value = self.store.cache_get(key) or 0 self.assertEqual(value, 0) @cases([{ 'key': "uid:123456", 'value': 1 }, { 'key': "uid:123456", 'value': -3.7 }]) def test_on_connected_store_get_cache_get(self, kwargs): self.store.connect() key = kwargs['key'] self.store.cache_set(key, kwargs['value'], 60 * 60) value = self.store.cache_get(key) or 0 self.assertEqual(value, kwargs['value']) @cases([{ 'key': "uid:654321", 'value': 'books' }, { 'key': "uid:654321", 'value': 'путешествие' }]) def test_on_connected_store_get(self, kwargs): self.store.connect() key = kwargs['key'] self.store.redis.delete(key) self.store.redis.rpush(key, kwargs['value']) value = self.store.get(key) or None self.assertEqual(value, [kwargs['value']])
class TestStore(unittest.TestCase): def setUp(self): self.redis_storage = RedisStore(host=os.getenv('REDIS_HOST', 'localhost'), port=os.getenv('REDIS_PORT', 6379)) self.store = Store(self.redis_storage) self.store.connect() self.key = 'sample_key' self.value = 'sample_value' def test_connect_to_store(self): self.assertTrue(self.store.ping()) def test_connect_to_redis(self): self.assertTrue(self.redis_storage.ping()) def test_redis_set_value(self): key = self.key + '_redis' self.assertTrue(self.redis_storage.set(key, self.value, 30)) self.assertEqual(self.store.cache_get(key), self.value) def test_redis_connection_error(self): self.redis_storage.client.disconnect() self.assertRaises(ConnectionError, self.store.cache_get, self.key) def test_cache_set_value(self): key = self.key + '_cache' self.assertTrue(self.store.cache_set(key, self.value, 30)) self.assertEqual(self.store.cache_get(key), self.value) def test_cache_connection_error(self): self.redis_storage.client.disconnect() self.assertRaises(ConnectionError, self.store.cache_get, self.key) self.assertRaises(ConnectionError, self.store.cache_set, self.key, self.value) def test_store_set_value(self): key = self.key + '_store' self.assertTrue(self.store.set(key, self.value, 30)) self.assertEqual(self.store.get(key), self.value)
def test_redis_timeout_error(self): redis_store = RedisStore() redis_store.get = MagicMock(side_effect=TimeoutError()) redis_store.set = MagicMock(side_effect=TimeoutError()) store = Store(redis_store) self.assertEqual(store.cache_get("key"), None) self.assertEqual(store.cache_set("key", "value"), None) self.assertEqual(redis_store.get.call_count, Store.MAX_ATTEMPT) self.assertEqual(redis_store.set.call_count, Store.MAX_ATTEMPT) with self.assertRaises(TimeoutError): redis_store.get('key') with self.assertRaises(TimeoutError): redis_store.set('key', 'value', 10)
def get_score(store: Store, phone, email, birthday=None, gender=None, first_name=None, last_name=None) -> float: key_parts = [ first_name or "", last_name or "", birthday.strftime("%Y%m%d") if birthday is not None else "", ] key = "".join(key_parts).encode() key = "uid:" + hashlib.md5(key).hexdigest() # try get from cache, # fallback to heavy calculation in case of cache miss score = store.cache_get(key) or 0 if score: return float(score) if phone: score += 1.5 if email: score += 1.5 if birthday and gender: score += 1.5 if first_name and last_name: score += 0.5 # cache for 60 minutes store.cache_set(key, score, 60 * 60) return score
def test_cache_get_and_set_not_raise_connection_error(self): # create store with incorrect port for redis store = Store(RedisStorage(port=6378)) # try to get and set cache value in not working storage self.assertEqual(store.cache_get('key_0'), None) self.assertEqual(store.cache_set('key_0', 0), None)
def test_unavailable_cache(self): store = Store(MockedCache().disable_connection()) store.cache_set('key', 'test') self.assertEqual(store.cache_get('key'), False)
def test_cache_get_nonexistent_key(self, value): store = Store(RedisStore()) key = hashlib.md5("".join(value) + time.ctime()).hexdigest() self.assertIsNone(store.cache_get(key))
def test_cache_get_store_not_available(self, value): store = Store(RedisStore(db=1)) key = hashlib.md5("".join(value) + time.ctime()).hexdigest() self.assertIsNone(store.cache_get(key))
class TestStore(unittest.TestCase): def setUp(self): self.store = Store(RedisStore()) self.redis_store = RedisStore() self.redis_start() def redis_start(self): subprocess.Popen(shlex.split('redis-server'), shell=False, env=None, stdout=subprocess.PIPE) time.sleep(0.1) @cases([['key_one','value_one'],['key_two','value_two']]) def test_ok_store_get(self, value): key, val = value self.store.cache_set(key, val, 1) self.assertEqual(val, self.store.get(key)) self.assertIsInstance(val, basestring) @cases([['key_one','value_one'],['key_two','value_two']]) def test_ok_store_cache_get(self, value): key, val = value self.store.cache_set(key, val, 1) self.assertEqual(val, self.store.cache_get(key)) self.assertIsInstance(val, basestring) @cases(['key_one','key_two']) def test_nonexistent_key_store_cache_get(self, key): self.assertIsNone(self.store.cache_get(key)) @cases(['key_one','key_two']) def test_nonexistent_key_store_get(self, key): self.assertIsNone(self.store.get(key)) @cases([['key_one','value_one'],['key_two','value_two']]) def test_ok_redis_store_get(self, value): key, val = value self.redis_store.set(key, val, 1) self.assertEqual(val, self.redis_store.get(key)) self.assertIsInstance(val, basestring) @cases(['key_one','key_two']) def test_nonexistent_key_redis_store_get(self, key): self.redis_store.redis_base.flushall() self.assertIsNone(self.redis_store.get(key)) def test_redis_connection_error(self): redis_store = RedisStore() redis_store.get = MagicMock(side_effect=ConnectionError()) redis_store.set = MagicMock(side_effect=ConnectionError()) store = Store(redis_store) self.assertEqual(store.cache_get("key"), None) self.assertEqual(store.cache_set("key", "value"), None) self.assertEqual(redis_store.get.call_count, Store.MAX_ATTEMPT) self.assertEqual(redis_store.set.call_count, Store.MAX_ATTEMPT) with self.assertRaises(ConnectionError): redis_store.get('key') with self.assertRaises(ConnectionError): redis_store.set('key', 'value', 10) def test_redis_timeout_error(self): redis_store = RedisStore() redis_store.get = MagicMock(side_effect=TimeoutError()) redis_store.set = MagicMock(side_effect=TimeoutError()) store = Store(redis_store) self.assertEqual(store.cache_get("key"), None) self.assertEqual(store.cache_set("key", "value"), None) self.assertEqual(redis_store.get.call_count, Store.MAX_ATTEMPT) self.assertEqual(redis_store.set.call_count, Store.MAX_ATTEMPT) with self.assertRaises(TimeoutError): redis_store.get('key') with self.assertRaises(TimeoutError): redis_store.set('key', 'value', 10)
def test_cache_set(self, value): store = Store( MemcacheAdapter(address=os.environ['STORE_PORT_11211_TCP_ADDR'], port=os.environ['STORE_PORT_11211_TCP_PORT'])) store.cache_set('test_cache_set', value) self.assertNotEqual(store.cache_get('test_cache_set'), None)
def test_set_get_key(self): store = Store(RedisStore(), 3, 2, (TimeoutError, ConnectionError)) store.set('key1', 'val1') self.assertEqual(store.cache_get("key1"), 'val1')
def test_cache_get_empty(self, key): store = Store( MemcacheAdapter(address=os.environ['STORE_PORT_11211_TCP_ADDR'], port=os.environ['STORE_PORT_11211_TCP_PORT'])) self.assertEqual(store.cache_get(key), None)
def test_get_not_exists_key(self): store = Store(RedisStore(), 3, 2, (TimeoutError, ConnectionError)) self.assertEqual(store.cache_get("key2"), None)
def test_cache_get_error_connect_and_ignore_exc(self, key): store = Store( MemcacheAdapter(address=os.environ['STORE_PORT_11211_TCP_ADDR'], port=8000)) self.assertEqual(store.cache_get(key), None)
def test_available_cache(self): store = Store(MockedCache()) store.cache_set('key', 'test') store.cache_set('another_key', 'another_test') self.assertEqual(store.cache_get('key'), 'test') self.assertEqual(store.cache_get('another_key'), 'another_test')