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')
