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)
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 load_warm_store():
s = Store()
ttl = 20
for k, v in (('d41d8cd98f00b204e9800998ecf8427e',
3.0), ('efd4d906526f3a338d9eab83ea4c77e6',
2.0), ('a1301e1514843ca1973b941a88a58092',
0), ('a1301e1514843ca1973b941a88a58092', 1.5),
('187ef4436122d1cc2f40dc2b92f0eba0',
0.5), ('efd4d906526f3a338d9eab83ea4c77e6',
5.0), ('d41d8cd98f00b204e9800998ecf8427e', 3.0),
("1", 1), ("2", "2"), ("3", "3"), ("-1", "-1")):
s.cache_set(k, v, ttl)
return s
def test_cache_set(self, value):
self.redis_base.flushall()
store = Store(RedisStore())
key, val = value
is_set = store.cache_set(key, val, 10)
self.assertTrue(is_set)
self.assertEqual(val, self.redis_base.get(key))
self.assertIsInstance(self.redis_base.get(key), basestring)
def test_cache_set_expire(self, value):
store = Store(RedisStore())
key = hashlib.md5("".join(value) + time.ctime()).hexdigest()
is_set = store.cache_set(key, value[1], 1)
self.assertTrue(is_set)
time.sleep(1.1)
self.assertIs(None, self.redis_base.get(key))
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']])
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
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)
class TestSuite(unittest.TestCase):
def setUp(self):
self.context = {}
self.headers = {}
self.store = Store(RedisStorage())
def get_response(self, request):
return api.method_handler({'body': request, 'headers': self.headers}, self.context,
self.store)
@staticmethod
def set_valid_auth(request):
if request.get('login') == api.ADMIN_LOGIN:
msg = datetime.datetime.now().strftime('%Y%m%d%H') + api.ADMIN_SALT
else:
msg = request.get('account', '') + request.get('login', '') + api.SALT
request['token'] = hashlib.sha512(msg.encode()).hexdigest()
def test_empty_request(self):
_, code = self.get_response({})
self.assertEqual(api.INVALID_REQUEST, code)
@cases([
{'account': 'horns&hoofs', 'login': '******', 'method': 'online_score', 'token': '',
'arguments': {}},
{'account': 'horns&hoofs', 'login': '******', 'method': 'online_score', 'token': 'sdd',
'arguments': {}},
{'account': 'horns&hoofs', 'login': '******', 'method': 'online_score', 'token': '',
'arguments': {}},
])
def test_bad_auth(self, request):
_, code = self.get_response(request)
self.assertEqual(api.FORBIDDEN, code)
@cases([
{'account': 'horns&hoofs', 'login': '******', 'method': 'online_score'},
{'account': 'horns&hoofs', 'login': '******', 'arguments': {}},
{'account': 'horns&hoofs', 'method': 'online_score', 'arguments': {}},
])
def test_invalid_method_request(self, request):
self.set_valid_auth(request)
response, code = self.get_response(request)
self.assertEqual(api.INVALID_REQUEST, code)
self.assertTrue(len(response))
@cases([
{},
{'phone': '79175002040'},
{'phone': '89175002040', 'email': '*****@*****.**'},
{'phone': '79175002040', 'email': 'stupnikovotus.ru'},
{'phone': '79175002040', 'email': '*****@*****.**', 'gender': -1},
{'phone': '79175002040', 'email': '*****@*****.**', 'gender': '1'},
{'phone': '79175002040', 'email': '*****@*****.**', 'gender': 1,
'birthday': '01.01.1890'},
{'phone': '79175002040', 'email': '*****@*****.**', 'gender': 1,
'birthday': 'XXX'},
{'phone': '79175002040', 'email': '*****@*****.**', 'gender': 1,
'birthday': '01.01.2000', 'first_name': 1},
{'phone': '79175002040', 'email': '*****@*****.**', 'gender': 1,
'birthday': '01.01.2000', 'first_name': 's', 'last_name': 2},
{'phone': '79175002040', 'birthday': '01.01.2000', 'first_name': 's'},
{'email': '*****@*****.**', 'gender': 1, 'last_name': 2},
])
def test_invalid_score_request(self, arguments):
request = {'account': 'horns&hoofs', 'login': '******', 'method': 'online_score',
'arguments': arguments}
self.set_valid_auth(request)
response, code = self.get_response(request)
self.assertEqual(api.INVALID_REQUEST, code, arguments)
self.assertTrue(len(response))
@cases([
{'phone': '79175002040', 'email': '*****@*****.**'},
{'phone': 79175002040, 'email': '*****@*****.**'},
{'gender': 1, 'birthday': '01.01.2000', 'first_name': 'a', 'last_name': 'b'},
{'gender': 0, 'birthday': '01.01.2000'},
{'gender': 2, 'birthday': '01.01.2000'},
{'first_name': 'a', 'last_name': 'b'},
{'phone': '79175002040', 'email': '*****@*****.**', 'gender': 1,
'birthday': '01.01.2000', 'first_name': 'a', 'last_name': 'b'},
])
def test_ok_score_request(self, arguments):
request = {'account': 'horns&hoofs', 'login': '******', 'method': 'online_score',
'arguments': arguments}
self.set_valid_auth(request)
response, code = self.get_response(request)
self.assertEqual(api.OK, code, arguments)
score = response.get('score')
self.assertTrue(isinstance(score, (int, float)) and score >= 0, arguments)
self.assertEqual(sorted(self.context['has']), sorted(arguments.keys()))
def test_ok_score_admin_request(self):
arguments = {'phone': '79175002040', 'email': '*****@*****.**'}
request = {'account': 'horns&hoofs', 'login': '******', 'method': 'online_score',
'arguments': arguments}
self.set_valid_auth(request)
response, code = self.get_response(request)
self.assertEqual(api.OK, code)
score = response.get('score')
self.assertEqual(score, 42)
@cases([
{},
{'date': '20.07.2017'},
{'client_ids': [], 'date': '20.07.2017'},
{'client_ids': {1: 2}, 'date': '20.07.2017'},
{'client_ids': ['1', '2'], 'date': '20.07.2017'},
{'client_ids': [1, 2], 'date': 'XXX'},
])
def test_invalid_interests_request(self, arguments):
request = {'account': 'horns&hoofs', 'login': '******', 'method': 'clients_interests',
'arguments': arguments}
self.set_valid_auth(request)
response, code = self.get_response(request)
self.assertEqual(api.INVALID_REQUEST, code, arguments)
self.assertTrue(len(response))
@cases([
{'client_ids': [1, 2, 3], 'date': datetime.datetime.today().strftime('%d.%m.%Y')},
{'client_ids': [1, 2], 'date': '19.07.2017'},
{'client_ids': [0]},
])
@patch.object(api.uuid, 'uuid4', side_effect=[MOCK_CID])
def test_ok_interests_request(self, arguments, mock_uuid):
for cid in arguments['client_ids']:
self.store.cache_set('i:{}'.format(cid), json.dumps(MOCK_INTERESTS), 60)
request = {'account': 'horns&hoofs', 'login': '******', 'method': 'clients_interests',
'arguments': arguments}
self.set_valid_auth(request)
response, code = self.get_response(request)
self.assertEqual(api.OK, code, arguments)
self.assertEqual(len(arguments['client_ids']), len(response))
self.assertTrue(all(v and isinstance(v, list) and all(isinstance(i, str) for i in v)
for v in response.values()))
self.assertEqual(self.context.get('nclients'), len(arguments['client_ids']))
class TestValidRequests(unittest.TestCase):
@patch('redis.Redis', mock_redis_client)
def setUp(self):
HOST = 'host'
PASSWORD = '******'
PORT = 15377
TIMEOUT = 3
DB = 0
MAX_RETRIES = 3
self.context = {}
self.store = Store(host=HOST, port=PORT, password=PASSWORD, db=DB, timeout=TIMEOUT, max_retries=MAX_RETRIES)
@cases([{"phone": "79175002040", "email": "*****@*****.**"},
{"phone": 79175002040, "email": "*****@*****.**"},
{"gender": 1, "birthday": "01.01.2000", "first_name": "a", "last_name": "b"},
{"gender": 0, "birthday": "01.01.2000"},
{"gender": 2, "birthday": "01.01.2000"},
{"first_name": "a", "last_name": "b"},
{"phone": "79175002040", "email": "*****@*****.**", "gender": 1, "birthday": "01.01.2000",
"first_name": "a", "last_name": "b"}])
def test_ok_score_request(self, arguments):
""" Test valid online_score requests """
request = {'account': 'horns&hoofs', 'login': '******', 'method': 'online_score', 'arguments': arguments}
set_valid_auth(request)
response, code = get_response(request, context=self.context, store=self.store)
self.assertEqual(api.OK, code, arguments)
score = response.get("score")
self.assertTrue(isinstance(score, (int, float)) and score >= 0, arguments)
self.assertEqual(sorted(self.context["has"]), sorted(arguments.keys()))
def test_ok_score_admin_request(self):
""" Test valid admin online_score requests """
arguments = {"phone": "79175002040", "email": "*****@*****.**"}
request = {"account": "horns&hoofs", "login": "******", "method": "online_score", "arguments": arguments}
set_valid_auth(request)
response, code = get_response(request, context=self.context, store=self.store)
self.assertEqual(api.OK, code)
score = response.get("score")
self.assertEqual(score, 42)
@cases([
{"client_ids": [1, 2, 3], "date": datetime.datetime.today().strftime("%d.%m.%Y")},
{"client_ids": [1, 2], "date": "19.07.2017"},
{"client_ids": [0]},
])
def test_ok_interests_request(self, arguments):
""" Test valid interests requests """
self.store.cache_set('i:0', '[\"interest_c0\"]', 20)
self.store.cache_set('i:1', '[\"interest_c1\"]', 20)
self.store.cache_set('i:2', '[\"interest_c2\"]', 20)
self.store.cache_set('i:3', '[\"interest_c3\"]', 20)
self.c_int = {0: ['interest_c0'], 1: ['interest_c1'], 2: ['interest_c2'], 3: ['interest_c3'], }
request = {"account": "horns&hoofs", "login": "******", "method": "clients_interests", "arguments": arguments}
set_valid_auth(request)
response, code = get_response(request, context=self.context, store=self.store)
self.assertEqual(api.OK, code, arguments)
self.assertEqual(len(arguments["client_ids"]), len(response))
for k, v in response.items():
self.assertTrue(v == self.c_int[k])
self.assertEqual(self.context.get("nclients"), len(arguments["client_ids"]))
class MainHandlerTest(TestCase):
def setUp(self):
self.port = self.get_port()
self.handler_url = f'http://localhost:{self.port}/method/'
self.server = HTTPServer(('localhost', self.port), api.MainHTTPHandler)
self.server_thread = Thread(target=self.server.serve_forever)
self.server_thread.setDaemon(True)
self.server_thread.start()
self.store = Store(MemcacheAdapter(
address=os.environ['STORE_PORT_11211_TCP_ADDR'],
port=os.environ['STORE_PORT_11211_TCP_PORT']
))
def set_valid_auth(self, request):
if request.get('login') == api.ADMIN_LOGIN:
msg = (datetime.datetime.now().strftime('%Y%m%d%H') + api.ADMIN_SALT).encode('utf-8')
request['token'] = hashlib.sha512(msg).hexdigest()
else:
msg = (request.get('account', '') + request.get('login', '') + api.SALT).encode('utf-8')
request['token'] = hashlib.sha512(msg).hexdigest()
@staticmethod
def get_port():
soct = socket.socket(socket.AF_INET, type=socket.SOCK_STREAM)
soct.bind(('localhost', 0))
address, port = soct.getsockname()
soct.close()
return port
def test_check(self):
self.assertEqual(1, 1)
@cases([
{
'account': 'account_test',
'login': '******',
'method': 'online_score',
'token': '',
'arguments': {
'phone': '79175002040',
'email': '*****@*****.**',
'first_name': 'Test',
'last_name': 'Testovich',
'birthday': '01.01.2000',
'gender': 1
}
}
])
def test_score_request(self, request):
self.set_valid_auth(request)
response = requests.post(self.handler_url, json=request)
self.assertEqual(response.status_code, 200)
self.assertAlmostEqual(response.json()['response']['score'], 5.0)
@cases([
{
'account': 'account_test',
'login': '******',
'method': 'clients_interests',
'token': '',
'arguments': {
'client_ids': [1, 2, 3, 4],
'date': '01.01.2000'
}
}
])
def test_client_interests(self, request):
self.set_valid_auth(request)
score_data = {
"1": {'i': ["travel", "geek"]},
"2": {'i': ["sport", "cars"]},
"3": {'i': ["books", "sport"]},
"4": {'i': ["hi-tech", "cinema"]}
}
self.store.cache_set('i:1', json.dumps(score_data.get('1')).encode('utf-8'), 10)
self.store.cache_set('i:2', json.dumps(score_data.get('2')).encode('utf-8'), 10)
self.store.cache_set('i:3', json.dumps(score_data.get('3')).encode('utf-8'), 10)
self.store.cache_set('i:4', json.dumps(score_data.get('4')).encode('utf-8'), 10)
response = requests.post(self.handler_url, json=request)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json()['response'], score_data)
@cases([
{
'account': 'account_test',
'login': '******',
'method': '404_method',
'token': '',
'arguments': {}
}
])
def test_method_not_found(self, request):
self.set_valid_auth(request)
response = requests.post(self.handler_url, json=request)
self.assertEqual(response.status_code, 404)
@cases([
{
'account': 'account_test',
'login': '******',
'method': 'clients_interests',
'token': '',
'arguments': {}
}
])
def test_method_forbidden(self, request):
response = requests.post(self.handler_url, json=request)
self.assertEqual(response.status_code, 403)
def test_method_bad_request(self):
response = requests.post(self.handler_url)
self.assertEqual(response.status_code, 400)
@cases([
{
'account': 'account_test',
'login': '******',
'method': 'online_score',
'token': '',
'arguments': {
'phone': '79175002040',
'email': '*****@*****.**',
'first_name': 'Test',
'last_name': 'Testovich',
'birthday': '01.01.2000',
'gender': '4'
}
},
{
'account': 'account_test',
'login': '******',
'method': 'online_score',
'token': '',
'arguments': {
'phone': '89175002040',
'email': 'stupn@[email protected]',
'first_name': 'Test',
'last_name': 'Testovich',
'birthday': '01.01.2000',
'gender': 1
}
}
])
def test_score_request_invalid_request(self, request):
self.set_valid_auth(request)
response = requests.post(self.handler_url, json=request)
self.assertEqual(response.status_code, 422)
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)
class ScoringTest(unittest.TestCase):
def setUp(self):
self.store = Store(connect_timeout=5, attempts=3)
@unittest.skipUnless(flag_has_storage, 'Skipping get_interests cases')
@cases([{
'user_id': 1,
'interest1': 'books',
'interest2': 'cinema'
}, {
'user_id': 2,
'interest1': 'music',
'interest2': 'travel'
}, {
'user_id': 3,
'interest1': 'sport',
'interest2': 'tv'
}, {
'user_id': 4,
'interest1': 'photography',
'interest2': 'tourism'
}])
def test_on_connected_store_set_get_interests(self, user_interest):
key = 'i:{}'.format(user_interest['user_id'])
self.store.redis.delete(key)
self.store.redis.rpush(key, user_interest['interest1'])
self.store.redis.rpush(key, user_interest['interest2'])
self.assertEqual(
scoring.get_interests(self.store, user_interest['user_id']),
[user_interest['interest1'], user_interest['interest2']])
@unittest.skipUnless(flag_has_storage, 'Skipping get_score cases')
@cases([{
'first_name': 'ILDAR',
'last_name': 'Shamiev',
'gender': 1,
'phone': '',
'birthday': '01.01.1990',
'email': 'имя@domain.com',
'score': 3.5
}, {
'first_name': 'NAME',
'last_name': 'LAST',
'gender': 0,
'phone': '',
'birthday': '01.01.1980',
'email': 'имя@domain.com',
'score': 13.7
}, {
'first_name': '',
'last_name': '',
'gender': 0,
'phone': '79175002040',
'birthday': '06.01.2000',
'email': '',
'score': 3.0
}, {
'first_name': 'Name',
'last_name': 'name',
'gender': 1,
'phone': '',
'birthday': '13.01.1999',
'email': '',
'score': -0.9
}])
def test_on_connected_store_get_score(self, kwargs):
score = kwargs.pop('score')
kwargs['birthday'] = api.DateField.str_to_date(kwargs['birthday'])
self.store.cache_set('uid:9a423ca46b5c7d79f8d335405e273261', 13.7,
60 * 60)
self.store.cache_set('uid:99e176a6339c3ed7d753d610e2580f01', -0.9,
60 * 60)
self.assertAlmostEqual(scoring.get_score(self.store, **kwargs),
score,
delta=0.1)
@unittest.expectedFailure
def test_on_disconnected_store_get_interests(self):
self.store = Store(port=9999, connect_timeout=1, attempts=2)
self.assertRaises(socket.timeout,
scoring.get_interests(self.store, '12345'))
@cases([{
'first_name': 'ILDAR',
'last_name': 'Shamiev',
'gender': 1,
'phone': '',
'birthday': '01.01.1990',
'email': 'имя@domain.com',
'score': 3.5
}])
def test_on_disconnected_store_get_score(self, kwargs):
self.store = Store(port=9999, connect_timeout=1, attempts=1)
score = kwargs.pop('score')
kwargs['birthday'] = api.DateField.str_to_date(kwargs['birthday'])
self.assertAlmostEqual(scoring.get_score(self.store, **kwargs),
score,
delta=0.1)
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_unavailable_cache(self):
store = Store(MockedCache().disable_connection())
store.cache_set('key', 'test')
self.assertEqual(store.cache_get('key'), False)
def test_cache_set_error_connect(self):
store = Store(
MemcacheAdapter(address=os.environ['STORE_PORT_11211_TCP_ADDR'],
port=8000))
with self.assertRaises(Exception):
store.cache_set('error_set_key', 'test')
def test_get(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_get', value)
self.assertNotEqual(store.get('test_get'), 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')
