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