1 # Copyright (c) 2019 AT&T Intellectual Property.
2 # Copyright (c) 2018-2019 Nokia.
4 # Licensed under the Apache License, Version 2.0 (the "License");
5 # you may not use this file except in compliance with the License.
6 # You may obtain a copy of the License at
8 # http://www.apache.org/licenses/LICENSE-2.0
10 # Unless required by applicable law or agreed to in writing, software
11 # distributed under the License is distributed on an "AS IS" BASIS,
12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 # See the License for the specific language governing permissions and
14 # limitations under the License.
17 # This source code is part of the near-RT RIC (RAN Intelligent Controller)
18 # platform project (RICP).
22 from unittest.mock import patch, Mock
24 from redis import exceptions as redis_exceptions
26 from ricsdl.backend.redis import (RedisBackendLock, _map_to_sdl_exception)
27 from ricsdl.configuration import _Configuration
28 from ricsdl.configuration import DbBackendType
29 import ricsdl.exceptions
33 def redis_backend_fixture(request):
34 request.cls.ns = 'some-ns'
35 request.cls.dl_redis = [b'1', b'2']
36 request.cls.dm = {'a': b'1', 'b': b'2'}
37 request.cls.dm_redis = {'{some-ns},a': b'1', '{some-ns},b': b'2'}
39 request.cls.key_redis = '{some-ns},a'
40 request.cls.keys = ['a', 'b']
41 request.cls.keys_redis = ['{some-ns},a', '{some-ns},b']
42 request.cls.data = b'123'
43 request.cls.old_data = b'1'
44 request.cls.new_data = b'3'
45 request.cls.keypattern = r'[Aa]bc-\[1\].?-*'
46 request.cls.keypattern_redis = r'{some-ns},[Aa]bc-\[1\].?-*'
47 request.cls.matchedkeys = ['Abc-[1].0-def', 'abc-[1].1-ghi']
48 request.cls.matchedkeys_redis = [b'{some-ns},Abc-[1].0-def',
49 b'{some-ns},abc-[1].1-ghi']
50 request.cls.matcheddata_redis = [b'10', b'11']
51 request.cls.matchedkeydata = {'Abc-[1].0-def': b'10',
52 'abc-[1].1-ghi': b'11'}
53 request.cls.group = 'some-group'
54 request.cls.group_redis = '{some-ns},some-group'
55 request.cls.groupmembers = set([b'm1', b'm2'])
56 request.cls.groupmember = b'm1'
58 request.cls.configuration = Mock()
59 mock_conf_params = _Configuration.Params(db_host=None,
61 db_sentinel_port=None,
62 db_sentinel_master_name=None,
63 db_type=DbBackendType.REDIS)
64 request.cls.configuration.get_params.return_value = mock_conf_params
65 with patch('ricsdl.backend.redis.Redis') as mock_redis:
66 db = ricsdl.backend.get_backend_instance(request.cls.configuration)
67 request.cls.mock_redis = mock_redis.return_value
73 @pytest.mark.usefixtures('redis_backend_fixture')
74 class TestRedisBackend:
75 def test_set_function_success(self):
76 self.db.set(self.ns, self.dm)
77 self.mock_redis.mset.assert_called_once_with(self.dm_redis)
79 def test_set_function_can_map_redis_exception_to_sdl_exception(self):
80 self.mock_redis.mset.side_effect = redis_exceptions.ResponseError('redis error!')
81 with pytest.raises(ricsdl.exceptions.RejectedByBackend):
82 self.db.set(self.ns, self.dm)
84 def test_set_if_function_success(self):
85 self.mock_redis.execute_command.return_value = True
86 ret = self.db.set_if(self.ns, self.key, self.old_data, self.new_data)
87 self.mock_redis.execute_command.assert_called_once_with('SETIE', self.key_redis,
88 self.new_data, self.old_data)
91 def test_set_if_function_returns_false_if_existing_key_value_not_expected(self):
92 self.mock_redis.execute_command.return_value = False
93 ret = self.db.set_if(self.ns, self.key, self.old_data, self.new_data)
94 self.mock_redis.execute_command.assert_called_once_with('SETIE', self.key_redis,
95 self.new_data, self.old_data)
98 def test_set_if_function_can_map_redis_exception_to_sdl_exception(self):
99 self.mock_redis.execute_command.side_effect = redis_exceptions.ResponseError('redis error!')
100 with pytest.raises(ricsdl.exceptions.RejectedByBackend):
101 self.db.set_if(self.ns, self.key, self.old_data, self.new_data)
103 def test_set_if_not_exists_function_success(self):
104 self.mock_redis.setnx.return_value = True
105 ret = self.db.set_if_not_exists(self.ns, self.key, self.new_data)
106 self.mock_redis.setnx.assert_called_once_with(self.key_redis, self.new_data)
109 def test_set_if_not_exists_function_returns_false_if_key_already_exists(self):
110 self.mock_redis.setnx.return_value = False
111 ret = self.db.set_if_not_exists(self.ns, self.key, self.new_data)
112 self.mock_redis.setnx.assert_called_once_with(self.key_redis, self.new_data)
115 def test_set_if_not_exists_function_can_map_redis_exception_to_sdl_exception(self):
116 self.mock_redis.setnx.side_effect = redis_exceptions.ResponseError('redis error!')
117 with pytest.raises(ricsdl.exceptions.RejectedByBackend):
118 self.db.set_if_not_exists(self.ns, self.key, self.new_data)
120 def test_get_function_success(self):
121 self.mock_redis.mget.return_value = self.dl_redis
122 ret = self.db.get(self.ns, self.keys)
123 self.mock_redis.mget.assert_called_once_with(self.keys_redis)
124 assert ret == self.dm
126 def test_get_function_returns_empty_dict_when_no_key_values_exist(self):
127 self.mock_redis.mget.return_value = [None, None]
128 ret = self.db.get(self.ns, self.keys)
129 self.mock_redis.mget.assert_called_once_with(self.keys_redis)
132 def test_get_function_returns_dict_only_with_found_key_values_when_some_keys_exist(self):
133 self.mock_redis.mget.return_value = [self.data, None]
134 ret = self.db.get(self.ns, self.keys)
135 self.mock_redis.mget.assert_called_once_with(self.keys_redis)
136 assert ret == {self.key: self.data}
138 def test_get_function_can_map_redis_exception_to_sdl_exception(self):
139 self.mock_redis.mget.side_effect = redis_exceptions.ResponseError('redis error!')
140 with pytest.raises(ricsdl.exceptions.RejectedByBackend):
141 self.db.get(self.ns, self.keys)
143 def test_find_keys_function_success(self):
144 self.mock_redis.keys.return_value = self.matchedkeys_redis
145 ret = self.db.find_keys(self.ns, self.keypattern)
146 self.mock_redis.keys.assert_called_once_with(self.keypattern_redis)
147 assert ret == self.matchedkeys
149 def test_find_keys_function_returns_empty_list_when_no_matching_keys_found(self):
150 self.mock_redis.keys.return_value = []
151 ret = self.db.find_keys(self.ns, self.keypattern)
152 self.mock_redis.keys.assert_called_once_with(self.keypattern_redis)
155 def test_find_keys_function_can_map_redis_exception_to_sdl_exception(self):
156 self.mock_redis.keys.side_effect = redis_exceptions.ResponseError('redis error!')
157 with pytest.raises(ricsdl.exceptions.RejectedByBackend):
158 self.db.find_keys(self.ns, self.keypattern)
160 def test_find_keys_function_can_raise_exception_when_redis_key_convert_to_string_fails(self):
161 # Redis returns an illegal key, which conversion to string fails
162 corrupt_redis_key = b'\x81'
163 self.mock_redis.keys.return_value = [corrupt_redis_key]
164 with pytest.raises(ricsdl.exceptions.RejectedByBackend) as excinfo:
165 self.db.find_keys(self.ns, self.keypattern)
166 assert f"Namespace {self.ns} key:{corrupt_redis_key} "
167 "has no namespace prefix" in str(excinfo.value)
169 def test_find_keys_function_can_raise_exception_when_redis_key_is_without_prefix(self):
170 # Redis returns an illegal key, which doesn't have comma separated namespace prefix
171 corrupt_redis_key = 'some-corrupt-key'
172 self.mock_redis.keys.return_value = [f'{corrupt_redis_key}'.encode()]
173 with pytest.raises(ricsdl.exceptions.RejectedByBackend) as excinfo:
174 self.db.find_keys(self.ns, self.keypattern)
175 assert f"Namespace {self.ns} key:{corrupt_redis_key} "
176 "has no namespace prefix" in str(excinfo.value)
178 def test_find_and_get_function_success(self):
179 self.mock_redis.keys.return_value = self.matchedkeys_redis
180 self.mock_redis.mget.return_value = self.matcheddata_redis
181 ret = self.db.find_and_get(self.ns, self.keypattern)
182 self.mock_redis.keys.assert_called_once_with(self.keypattern_redis)
183 self.mock_redis.mget.assert_called_once_with([i.decode() for i in self.matchedkeys_redis])
184 assert ret == self.matchedkeydata
186 def test_find_and_get_function_returns_empty_dict_when_no_matching_keys_exist(self):
187 self.mock_redis.keys.return_value = list()
188 ret = self.db.find_and_get(self.ns, self.keypattern)
189 self.mock_redis.keys.assert_called_once_with(self.keypattern_redis)
190 assert not self.mock_redis.mget.called
193 def test_find_and_get_function_can_map_redis_exception_to_sdl_exception(self):
194 self.mock_redis.keys.side_effect = redis_exceptions.ResponseError('redis error!')
195 with pytest.raises(ricsdl.exceptions.RejectedByBackend):
196 self.db.find_and_get(self.ns, self.keypattern)
198 def test_find_and_get_function_can_raise_exception_when_redis_key_convert_to_string_fails(self):
199 # Redis returns an illegal key, which conversion to string fails
200 corrupt_redis_key = b'\x81'
201 self.mock_redis.keys.return_value = [corrupt_redis_key]
202 with pytest.raises(ricsdl.exceptions.RejectedByBackend) as excinfo:
203 self.db.find_and_get(self.ns, self.keypattern)
204 assert f"Namespace {self.ns} key:{corrupt_redis_key} "
205 "has no namespace prefix" in str(excinfo.value)
207 def test_find_and_get_function_can_raise_exception_when_redis_key_is_without_prefix(self):
208 # Redis returns an illegal key, which doesn't have comma separated namespace prefix
209 corrupt_redis_key = 'some-corrupt-key'
210 self.mock_redis.keys.return_value = [f'{corrupt_redis_key}'.encode()]
211 with pytest.raises(ricsdl.exceptions.RejectedByBackend) as excinfo:
212 self.db.find_and_get(self.ns, self.keypattern)
213 assert f"Namespace {self.ns} key:{corrupt_redis_key} "
214 "has no namespace prefix" in str(excinfo.value)
216 def test_remove_function_success(self):
217 self.db.remove(self.ns, self.keys)
218 self.mock_redis.delete.assert_called_once_with(*self.keys_redis)
220 def test_remove_function_can_map_redis_exception_to_sdl_exception(self):
221 self.mock_redis.delete.side_effect = redis_exceptions.ResponseError('redis error!')
222 with pytest.raises(ricsdl.exceptions.RejectedByBackend):
223 self.db.remove(self.ns, self.keys)
225 def test_remove_if_function_success(self):
226 self.mock_redis.execute_command.return_value = True
227 ret = self.db.remove_if(self.ns, self.key, self.new_data)
228 self.mock_redis.execute_command.assert_called_once_with('DELIE', self.key_redis,
232 def test_remove_if_function_returns_false_if_data_does_not_match(self):
233 self.mock_redis.execute_command.return_value = False
234 ret = self.db.remove_if(self.ns, self.key, self.new_data)
235 self.mock_redis.execute_command.assert_called_once_with('DELIE', self.key_redis,
239 def test_remove_if_function_can_map_redis_exception_to_sdl_exception(self):
240 self.mock_redis.execute_command.side_effect = redis_exceptions.ResponseError('redis error!')
241 with pytest.raises(ricsdl.exceptions.RejectedByBackend):
242 self.db.remove_if(self.ns, self.key, self.new_data)
244 def test_add_member_function_success(self):
245 self.db.add_member(self.ns, self.group, self.groupmembers)
246 self.mock_redis.sadd.assert_called_once_with(self.group_redis, *self.groupmembers)
248 def test_add_member_function_can_map_redis_exception_to_sdl_exception(self):
249 self.mock_redis.sadd.side_effect = redis_exceptions.ResponseError('redis error!')
250 with pytest.raises(ricsdl.exceptions.RejectedByBackend):
251 self.db.add_member(self.ns, self.group, self.groupmembers)
253 def test_remove_member_function_success(self):
254 self.db.remove_member(self.ns, self.group, self.groupmembers)
255 self.mock_redis.srem.assert_called_once_with(self.group_redis, *self.groupmembers)
257 def test_remove_member_function_can_map_redis_exception_to_sdl_exception(self):
258 self.mock_redis.srem.side_effect = redis_exceptions.ResponseError('redis error!')
259 with pytest.raises(ricsdl.exceptions.RejectedByBackend):
260 self.db.remove_member(self.ns, self.group, self.groupmembers)
262 def test_remove_group_function_success(self):
263 self.db.remove_group(self.ns, self.group)
264 self.mock_redis.delete.assert_called_once_with(self.group_redis)
266 def test_remove_group_function_can_map_redis_exception_to_sdl_exception(self):
267 self.mock_redis.delete.side_effect = redis_exceptions.ResponseError('redis error!')
268 with pytest.raises(ricsdl.exceptions.RejectedByBackend):
269 self.db.remove_group(self.ns, self.group)
271 def test_get_members_function_success(self):
272 self.mock_redis.smembers.return_value = self.groupmembers
273 ret = self.db.get_members(self.ns, self.group)
274 self.mock_redis.smembers.assert_called_once_with(self.group_redis)
275 assert ret is self.groupmembers
277 def test_get_members_function_can_map_redis_exception_to_sdl_exception(self):
278 self.mock_redis.smembers.side_effect = redis_exceptions.ResponseError('redis error!')
279 with pytest.raises(ricsdl.exceptions.RejectedByBackend):
280 self.db.get_members(self.ns, self.group)
282 def test_is_member_function_success(self):
283 self.mock_redis.sismember.return_value = True
284 ret = self.db.is_member(self.ns, self.group, self.groupmember)
285 self.mock_redis.sismember.assert_called_once_with(self.group_redis, self.groupmember)
288 def test_is_member_function_can_map_redis_exception_to_sdl_exception(self):
289 self.mock_redis.sismember.side_effect = redis_exceptions.ResponseError('redis error!')
290 with pytest.raises(ricsdl.exceptions.RejectedByBackend):
291 self.db.is_member(self.ns, self.group, self.groupmember)
293 def test_group_size_function_success(self):
294 self.mock_redis.scard.return_value = 100
295 ret = self.db.group_size(self.ns, self.group)
296 self.mock_redis.scard.assert_called_once_with(self.group_redis)
299 def test_group_size_function_can_map_redis_exception_to_sdl_exception(self):
300 self.mock_redis.scard.side_effect = redis_exceptions.ResponseError('Some redis error!')
301 with pytest.raises(ricsdl.exceptions.RejectedByBackend):
302 self.db.group_size(self.ns, self.group)
304 def test_get_redis_connection_function_success(self):
305 ret = self.db.get_redis_connection()
306 assert ret is self.mock_redis
308 def test_redis_backend_object_string_representation(self):
309 str_out = str(self.db)
310 assert str_out is not None
314 def __init__(self, redis, name, timeout=None, sleep=0.1,
315 blocking=True, blocking_timeout=None, thread_local=True):
318 self.timeout = timeout
320 self.blocking = blocking
321 self.blocking_timeout = blocking_timeout
322 self.thread_local = bool(thread_local)
325 @pytest.fixture(scope="module")
326 def mock_redis_lock():
327 def _mock_redis_lock(name, timeout=None, sleep=0.1,
328 blocking=True, blocking_timeout=None, thread_local=True):
329 return MockRedisLock(name, timeout, sleep, blocking, blocking_timeout, thread_local)
330 return _mock_redis_lock
334 def redis_backend_lock_fixture(request, mock_redis_lock):
335 request.cls.ns = 'some-ns'
336 request.cls.lockname = 'some-lock-name'
337 request.cls.lockname_redis = '{some-ns},some-lock-name'
338 request.cls.expiration = 10
339 request.cls.retry_interval = 0.1
340 request.cls.retry_timeout = 1
342 request.cls.mock_lua_get_validity_time = Mock()
343 request.cls.mock_lua_get_validity_time.return_value = 2000
345 request.cls.mock_redis = Mock()
346 request.cls.mock_redis.register_script = Mock()
347 request.cls.mock_redis.register_script.return_value = request.cls.mock_lua_get_validity_time
349 mocked_dbbackend = Mock()
350 mocked_dbbackend.get_redis_connection.return_value = request.cls.mock_redis
352 request.cls.configuration = Mock()
353 mock_conf_params = _Configuration.Params(db_host=None,
355 db_sentinel_port=None,
356 db_sentinel_master_name=None,
357 db_type=DbBackendType.REDIS)
358 request.cls.configuration.get_params.return_value = mock_conf_params
360 with patch('ricsdl.backend.redis.Lock') as mock_redis_lock:
361 lock = ricsdl.backend.get_backend_lock_instance(request.cls.configuration,
362 request.cls.ns, request.cls.lockname,
363 request.cls.expiration, mocked_dbbackend)
364 request.cls.mock_redis_lock = mock_redis_lock.return_value
365 request.cls.lock = lock
367 RedisBackendLock.lua_get_validity_time = None
370 @pytest.mark.usefixtures('redis_backend_lock_fixture')
371 class TestRedisBackendLock:
372 def test_acquire_function_success(self):
373 self.mock_redis_lock.acquire.return_value = True
374 ret = self.lock.acquire(self.retry_interval, self.retry_timeout)
375 self.mock_redis_lock.acquire.assert_called_once_with(blocking_timeout=self.retry_timeout)
378 def test_acquire_function_returns_false_if_lock_is_not_acquired(self):
379 self.mock_redis_lock.acquire.return_value = False
380 ret = self.lock.acquire(self.retry_interval, self.retry_timeout)
381 self.mock_redis_lock.acquire.assert_called_once_with(blocking_timeout=self.retry_timeout)
384 def test_acquire_function_can_map_redis_exception_to_sdl_exception(self):
385 self.mock_redis_lock.acquire.side_effect = redis_exceptions.LockError('redis lock error!')
386 with pytest.raises(ricsdl.exceptions.BackendError):
387 self.lock.acquire(self.retry_interval, self.retry_timeout)
389 def test_release_function_success(self):
391 self.mock_redis_lock.release.assert_called_once()
393 def test_release_function_can_map_redis_exception_to_sdl_exception(self):
394 self.mock_redis_lock.release.side_effect = redis_exceptions.LockError('redis lock error!')
395 with pytest.raises(ricsdl.exceptions.BackendError):
398 def test_refresh_function_success(self):
400 self.mock_redis_lock.reacquire.assert_called_once()
402 def test_refresh_function_can_map_redis_exception_to_sdl_exception(self):
403 self.mock_redis_lock.reacquire.side_effect = redis_exceptions.LockError('redis lock error!')
404 with pytest.raises(ricsdl.exceptions.BackendError):
407 def test_get_validity_time_function_success(self):
408 self.mock_redis_lock.name = self.lockname_redis
409 self.mock_redis_lock.local.token = 123
411 ret = self.lock.get_validity_time()
412 self.mock_lua_get_validity_time.assert_called_once_with(
413 keys=[self.lockname_redis], args=[123], client=self.mock_redis)
416 def test_get_validity_time_function_second_fraction_success(self):
417 self.mock_redis_lock.name = self.lockname_redis
418 self.mock_redis_lock.local.token = 123
419 self.mock_lua_get_validity_time.return_value = 234
421 ret = self.lock.get_validity_time()
422 self.mock_lua_get_validity_time.assert_called_once_with(
423 keys=[self.lockname_redis], args=[123], client=self.mock_redis)
426 def test_get_validity_time_function_can_raise_exception_if_lock_is_unlocked(self):
427 self.mock_redis_lock.name = self.lockname_redis
428 self.mock_redis_lock.local.token = None
430 with pytest.raises(ricsdl.exceptions.RejectedByBackend) as excinfo:
431 self.lock.get_validity_time()
432 assert f"Cannot get validity time of an unlocked lock {self.lockname}" in str(excinfo.value)
434 def test_get_validity_time_function_can_raise_exception_if_lua_script_fails(self):
435 self.mock_redis_lock.name = self.lockname_redis
436 self.mock_redis_lock.local.token = 123
437 self.mock_lua_get_validity_time.return_value = -10
439 with pytest.raises(ricsdl.exceptions.RejectedByBackend) as excinfo:
440 self.lock.get_validity_time()
441 assert f"Getting validity time of a lock {self.lockname} failed with error code: -10" in str(excinfo.value)
443 def test_redis_backend_lock_object_string_representation(self):
444 expected_lock_info = {'lock DB type': 'Redis',
445 'lock namespace': 'some-ns',
446 'lock name': 'some-lock-name',
447 'lock status': 'locked'}
448 assert str(self.lock) == str(expected_lock_info)
450 def test_redis_backend_lock_object_string_representation_can_catch_redis_exception(self):
451 self.mock_redis_lock.owned.side_effect = redis_exceptions.LockError('redis lock error!')
452 expected_lock_info = {'lock DB type': 'Redis',
453 'lock namespace': 'some-ns',
454 'lock name': 'some-lock-name',
455 'lock status': 'Error: redis lock error!'}
456 assert str(self.lock) == str(expected_lock_info)
459 def test_redis_response_error_exception_is_mapped_to_rejected_by_backend_sdl_exception():
460 with pytest.raises(ricsdl.exceptions.RejectedByBackend) as excinfo:
461 with _map_to_sdl_exception():
462 raise redis_exceptions.ResponseError('Some redis error!')
463 assert "SDL backend rejected the request: Some redis error!" in str(excinfo.value)
466 def test_redis_connection_error_exception_is_mapped_to_not_connected_sdl_exception():
467 with pytest.raises(ricsdl.exceptions.NotConnected) as excinfo:
468 with _map_to_sdl_exception():
469 raise redis_exceptions.ConnectionError('Some redis error!')
470 assert "SDL not connected to backend: Some redis error!" in str(excinfo.value)
473 def test_rest_redis_exceptions_are_mapped_to_backend_error_sdl_exception():
474 with pytest.raises(ricsdl.exceptions.BackendError) as excinfo:
475 with _map_to_sdl_exception():
476 raise redis_exceptions.RedisError('Some redis error!')
477 assert "SDL backend failed to process the request: Some redis error!" in str(excinfo.value)
480 def test_system_error_exceptions_are_not_mapped_to_any_sdl_exception():
481 with pytest.raises(SystemExit):
482 with _map_to_sdl_exception():
483 raise SystemExit('Fatal error')