X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;ds=sidebyside;f=ricsdl-package%2Ftests%2Fbackend%2Ftest_redis.py;h=4f46205ec24d66ad080f91bced29cc45cb438faf;hb=83a3e59661fc8d48095ae7ff0040b88763633e68;hp=d1b8223255cb665a7ef486dca871bd3ea80ec7fe;hpb=dada8463c0fd4c3b90eedc54b6c913f0fa0e7272;p=ric-plt%2Fsdlpy.git diff --git a/ricsdl-package/tests/backend/test_redis.py b/ricsdl-package/tests/backend/test_redis.py index d1b8223..4f46205 100644 --- a/ricsdl-package/tests/backend/test_redis.py +++ b/ricsdl-package/tests/backend/test_redis.py @@ -25,6 +25,7 @@ from redis import exceptions as redis_exceptions import ricsdl.backend from ricsdl.backend.redis import (RedisBackendLock, _map_to_sdl_exception) from ricsdl.configuration import _Configuration +from ricsdl.configuration import DbBackendType import ricsdl.exceptions @@ -41,25 +42,25 @@ def redis_backend_fixture(request): request.cls.data = b'123' request.cls.old_data = b'1' request.cls.new_data = b'3' - request.cls.keyprefix = 'x?' - request.cls.keyprefix_redis = r'{some-ns},x\?*' - request.cls.matchedkeys = ['x1', 'x2', 'x3', 'x4', 'x5'] - request.cls.matchedkeys_redis = [b'{some-ns},x1', b'{some-ns},x2', b'{some-ns},x3', - b'{some-ns},x4', b'{some-ns},x5'] - request.cls.matcheddata_dl_redis = [b'10', b'11', b'12', b'13', b'14'] - request.cls.matcheddata_dm = {'x1': b'10', 'x2': b'11', 'x3': b'12', - 'x4': b'13', 'x5': b'14'} + request.cls.keypattern = r'[Aa]bc-\[1\].?-*' + request.cls.keypattern_redis = r'{some-ns},[Aa]bc-\[1\].?-*' + request.cls.matchedkeys = ['Abc-[1].0-def', 'abc-[1].1-ghi'] + request.cls.matchedkeys_redis = [b'{some-ns},Abc-[1].0-def', + b'{some-ns},abc-[1].1-ghi'] + request.cls.matcheddata_redis = [b'10', b'11'] + request.cls.matchedkeydata = {'Abc-[1].0-def': b'10', + 'abc-[1].1-ghi': b'11'} request.cls.group = 'some-group' request.cls.group_redis = '{some-ns},some-group' request.cls.groupmembers = set([b'm1', b'm2']) request.cls.groupmember = b'm1' - request.cls.is_atomic = True request.cls.configuration = Mock() mock_conf_params = _Configuration.Params(db_host=None, db_port=None, db_sentinel_port=None, - db_sentinel_master_name=None) + db_sentinel_master_name=None, + db_type=DbBackendType.REDIS) request.cls.configuration.get_params.return_value = mock_conf_params with patch('ricsdl.backend.redis.Redis') as mock_redis: db = ricsdl.backend.get_backend_instance(request.cls.configuration) @@ -71,6 +72,23 @@ def redis_backend_fixture(request): @pytest.mark.usefixtures('redis_backend_fixture') class TestRedisBackend: + def test_is_connected_function_success(self): + self.mock_redis.ping.return_value = True + ret = self.db.is_connected() + self.mock_redis.ping.assert_called_once() + assert ret is True + + def test_is_connected_function_returns_false_if_ping_fails(self): + self.mock_redis.ping.return_value = False + ret = self.db.is_connected() + self.mock_redis.ping.assert_called_once() + assert ret is False + + def test_is_connected_function_can_map_redis_exception_to_sdl_exception(self): + self.mock_redis.ping.side_effect = redis_exceptions.ResponseError('redis error!') + with pytest.raises(ricsdl.exceptions.RejectedByBackend): + self.db.is_connected() + def test_set_function_success(self): self.db.set(self.ns, self.dm) self.mock_redis.mset.assert_called_once_with(self.dm_redis) @@ -87,7 +105,7 @@ class TestRedisBackend: self.new_data, self.old_data) assert ret is True - def test_set_if_function_returns_false_if_same_data_already_exists(self): + def test_set_if_function_returns_false_if_existing_key_value_not_expected(self): self.mock_redis.execute_command.return_value = False ret = self.db.set_if(self.ns, self.key, self.old_data, self.new_data) self.mock_redis.execute_command.assert_called_once_with('SETIE', self.key_redis, @@ -141,36 +159,77 @@ class TestRedisBackend: def test_find_keys_function_success(self): self.mock_redis.keys.return_value = self.matchedkeys_redis - ret = self.db.find_keys(self.ns, self.keyprefix) - self.mock_redis.keys.assert_called_once_with(self.keyprefix_redis) + ret = self.db.find_keys(self.ns, self.keypattern) + self.mock_redis.keys.assert_called_once_with(self.keypattern_redis) assert ret == self.matchedkeys def test_find_keys_function_returns_empty_list_when_no_matching_keys_found(self): self.mock_redis.keys.return_value = [] - ret = self.db.find_keys(self.ns, self.keyprefix) - self.mock_redis.keys.assert_called_once_with(self.keyprefix_redis) + ret = self.db.find_keys(self.ns, self.keypattern) + self.mock_redis.keys.assert_called_once_with(self.keypattern_redis) assert ret == [] def test_find_keys_function_can_map_redis_exception_to_sdl_exception(self): self.mock_redis.keys.side_effect = redis_exceptions.ResponseError('redis error!') with pytest.raises(ricsdl.exceptions.RejectedByBackend): - self.db.find_keys(self.ns, self.keyprefix) + self.db.find_keys(self.ns, self.keypattern) + + def test_find_keys_function_can_raise_exception_when_redis_key_convert_to_string_fails(self): + # Redis returns an illegal key, which conversion to string fails + corrupt_redis_key = b'\x81' + self.mock_redis.keys.return_value = [corrupt_redis_key] + with pytest.raises(ricsdl.exceptions.RejectedByBackend) as excinfo: + self.db.find_keys(self.ns, self.keypattern) + assert f"Namespace {self.ns} key:{corrupt_redis_key} " + "has no namespace prefix" in str(excinfo.value) + + def test_find_keys_function_can_raise_exception_when_redis_key_is_without_prefix(self): + # Redis returns an illegal key, which doesn't have comma separated namespace prefix + corrupt_redis_key = 'some-corrupt-key' + self.mock_redis.keys.return_value = [f'{corrupt_redis_key}'.encode()] + with pytest.raises(ricsdl.exceptions.RejectedByBackend) as excinfo: + self.db.find_keys(self.ns, self.keypattern) + assert f"Namespace {self.ns} key:{corrupt_redis_key} " + "has no namespace prefix" in str(excinfo.value) def test_find_and_get_function_success(self): self.mock_redis.keys.return_value = self.matchedkeys_redis - self.mock_redis.mget.return_value = self.matcheddata_dl_redis - ret = self.db.find_and_get(self.ns, self.keyprefix, self.is_atomic) - self.mock_redis.keys.assert_called_once_with(self.keyprefix_redis) + self.mock_redis.mget.return_value = self.matcheddata_redis + ret = self.db.find_and_get(self.ns, self.keypattern) + self.mock_redis.keys.assert_called_once_with(self.keypattern_redis) self.mock_redis.mget.assert_called_once_with([i.decode() for i in self.matchedkeys_redis]) - assert ret == self.matcheddata_dm + assert ret == self.matchedkeydata def test_find_and_get_function_returns_empty_dict_when_no_matching_keys_exist(self): self.mock_redis.keys.return_value = list() - ret = self.db.find_and_get(self.ns, self.keyprefix, self.is_atomic) - self.mock_redis.keys.assert_called_once_with(self.keyprefix_redis) + ret = self.db.find_and_get(self.ns, self.keypattern) + self.mock_redis.keys.assert_called_once_with(self.keypattern_redis) assert not self.mock_redis.mget.called assert ret == dict() + def test_find_and_get_function_can_map_redis_exception_to_sdl_exception(self): + self.mock_redis.keys.side_effect = redis_exceptions.ResponseError('redis error!') + with pytest.raises(ricsdl.exceptions.RejectedByBackend): + self.db.find_and_get(self.ns, self.keypattern) + + def test_find_and_get_function_can_raise_exception_when_redis_key_convert_to_string_fails(self): + # Redis returns an illegal key, which conversion to string fails + corrupt_redis_key = b'\x81' + self.mock_redis.keys.return_value = [corrupt_redis_key] + with pytest.raises(ricsdl.exceptions.RejectedByBackend) as excinfo: + self.db.find_and_get(self.ns, self.keypattern) + assert f"Namespace {self.ns} key:{corrupt_redis_key} " + "has no namespace prefix" in str(excinfo.value) + + def test_find_and_get_function_can_raise_exception_when_redis_key_is_without_prefix(self): + # Redis returns an illegal key, which doesn't have comma separated namespace prefix + corrupt_redis_key = 'some-corrupt-key' + self.mock_redis.keys.return_value = [f'{corrupt_redis_key}'.encode()] + with pytest.raises(ricsdl.exceptions.RejectedByBackend) as excinfo: + self.db.find_and_get(self.ns, self.keypattern) + assert f"Namespace {self.ns} key:{corrupt_redis_key} " + "has no namespace prefix" in str(excinfo.value) + def test_remove_function_success(self): self.db.remove(self.ns, self.keys) self.mock_redis.delete.assert_called_once_with(*self.keys_redis) @@ -306,8 +365,18 @@ def redis_backend_lock_fixture(request, mock_redis_lock): mocked_dbbackend = Mock() mocked_dbbackend.get_redis_connection.return_value = request.cls.mock_redis + + request.cls.configuration = Mock() + mock_conf_params = _Configuration.Params(db_host=None, + db_port=None, + db_sentinel_port=None, + db_sentinel_master_name=None, + db_type=DbBackendType.REDIS) + request.cls.configuration.get_params.return_value = mock_conf_params + with patch('ricsdl.backend.redis.Lock') as mock_redis_lock: - lock = ricsdl.backend.get_backend_lock_instance(request.cls.ns, request.cls.lockname, + lock = ricsdl.backend.get_backend_lock_instance(request.cls.configuration, + request.cls.ns, request.cls.lockname, request.cls.expiration, mocked_dbbackend) request.cls.mock_redis_lock = mock_redis_lock.return_value request.cls.lock = lock @@ -318,8 +387,16 @@ def redis_backend_lock_fixture(request, mock_redis_lock): @pytest.mark.usefixtures('redis_backend_lock_fixture') class TestRedisBackendLock: def test_acquire_function_success(self): - self.lock.acquire(self.retry_interval, self.retry_timeout) + self.mock_redis_lock.acquire.return_value = True + ret = self.lock.acquire(self.retry_interval, self.retry_timeout) self.mock_redis_lock.acquire.assert_called_once_with(blocking_timeout=self.retry_timeout) + assert ret is True + + def test_acquire_function_returns_false_if_lock_is_not_acquired(self): + self.mock_redis_lock.acquire.return_value = False + ret = self.lock.acquire(self.retry_interval, self.retry_timeout) + self.mock_redis_lock.acquire.assert_called_once_with(blocking_timeout=self.retry_timeout) + assert ret is False def test_acquire_function_can_map_redis_exception_to_sdl_exception(self): self.mock_redis_lock.acquire.side_effect = redis_exceptions.LockError('redis lock error!') @@ -353,6 +430,16 @@ class TestRedisBackendLock: keys=[self.lockname_redis], args=[123], client=self.mock_redis) assert ret == 2 + def test_get_validity_time_function_second_fraction_success(self): + self.mock_redis_lock.name = self.lockname_redis + self.mock_redis_lock.local.token = 123 + self.mock_lua_get_validity_time.return_value = 234 + + ret = self.lock.get_validity_time() + self.mock_lua_get_validity_time.assert_called_once_with( + keys=[self.lockname_redis], args=[123], client=self.mock_redis) + assert ret == 0.234 + def test_get_validity_time_function_can_raise_exception_if_lock_is_unlocked(self): self.mock_redis_lock.name = self.lockname_redis self.mock_redis_lock.local.token = None @@ -371,8 +458,19 @@ class TestRedisBackendLock: assert f"Getting validity time of a lock {self.lockname} failed with error code: -10" in str(excinfo.value) def test_redis_backend_lock_object_string_representation(self): - str_out = str(self.lock) - assert str_out is not None + expected_lock_info = {'lock DB type': 'Redis', + 'lock namespace': 'some-ns', + 'lock name': 'some-lock-name', + 'lock status': 'locked'} + assert str(self.lock) == str(expected_lock_info) + + def test_redis_backend_lock_object_string_representation_can_catch_redis_exception(self): + self.mock_redis_lock.owned.side_effect = redis_exceptions.LockError('redis lock error!') + expected_lock_info = {'lock DB type': 'Redis', + 'lock namespace': 'some-ns', + 'lock name': 'some-lock-name', + 'lock status': 'Error: redis lock error!'} + assert str(self.lock) == str(expected_lock_info) def test_redis_response_error_exception_is_mapped_to_rejected_by_backend_sdl_exception():