ricsdl-package/tests/test_syncstorage.py

   1 # Copyright (c) 2019 AT&T Intellectual Property.
   2 # Copyright (c) 2018-2019 Nokia.
   3 #
   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
   7 #
   8 #     http://www.apache.org/licenses/LICENSE-2.0
   9 #
  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.
  15
  16 #
  17 # This source code is part of the near-RT RIC (RAN Intelligent Controller)
  18 # platform project (RICP).
  19 #
  20
  21
  22 from unittest.mock import patch, Mock
  23 import pytest
  24 from ricsdl.syncstorage import SyncStorage
  25 from ricsdl.syncstorage import SyncLock
  26 from ricsdl.syncstorage import func_arg_checker
  27 from ricsdl.exceptions import (SdlTypeError, NotConnected)
  28
  29
  30 @pytest.fixture()
  31 def sync_storage_fixture(request):
  32     request.cls.ns = 'some-ns'
  33     request.cls.key = 'a'
  34     request.cls.keys = {'a', 'b'}
  35     request.cls.dm = {'b': b'2', 'a': b'1'}
  36     request.cls.old_data = b'1'
  37     request.cls.new_data = b'3'
  38     request.cls.keyprefix = 'x'
  39     request.cls.matchedkeys = ['x1', 'x2', 'x3', 'x4', 'x5']
  40     request.cls.group = 'some-group'
  41     request.cls.groupmembers = set([b'm1', b'm2'])
  42     request.cls.groupmember = b'm1'
  43     request.cls.lock_name = 'some-lock-name'
  44     request.cls.lock_int_expiration = 10
  45     request.cls.lock_float_expiration = 1.1
  46
  47     with patch('ricsdl.backend.get_backend_instance') as mock_db_backend:
  48         storage = SyncStorage()
  49         request.cls.mock_db_backend = mock_db_backend.return_value
  50     request.cls.storage = storage
  51     yield
  52
  53
  54 @pytest.mark.usefixtures('sync_storage_fixture')
  55 class TestSyncStorage:
  56     def test_is_active_function_success(self):
  57         self.mock_db_backend.is_connected.return_value = True
  58         ret = self.storage.is_active()
  59         self.mock_db_backend.is_connected.assert_called_once()
  60         assert ret is True
  61
  62     def test_is_active_function_can_catch_backend_exception_and_return_false(self):
  63         self.mock_db_backend.is_connected.side_effect = NotConnected
  64         ret = self.storage.is_active()
  65         self.mock_db_backend.is_connected.assert_called_once()
  66         assert ret is False
  67
  68     def test_set_function_success(self):
  69         self.storage.set(self.ns, self.dm)
  70         self.mock_db_backend.set.assert_called_once_with(self.ns, self.dm)
  71
  72     def test_set_function_can_raise_exception_for_wrong_argument(self):
  73         with pytest.raises(SdlTypeError):
  74             self.storage.set(123, {'a': b'v1'})
  75         with pytest.raises(SdlTypeError):
  76             self.storage.set('ns', [1, 2])
  77
  78     def test_set_if_function_success(self):
  79         self.mock_db_backend.set_if.return_value = True
  80         ret = self.storage.set_if(self.ns, self.key, self.old_data, self.new_data)
  81         self.mock_db_backend.set_if.assert_called_once_with(self.ns, self.key, self.old_data,
  82                                                             self.new_data)
  83         assert ret is True
  84
  85     def test_set_if_function_can_return_false_if_same_data_already_exists(self):
  86         self.mock_db_backend.set_if.return_value = False
  87         ret = self.storage.set_if(self.ns, self.key, self.old_data, self.new_data)
  88         self.mock_db_backend.set_if.assert_called_once_with(self.ns, self.key, self.old_data,
  89                                                             self.new_data)
  90         assert ret is False
  91
  92     def test_set_if_function_can_raise_exception_for_wrong_argument(self):
  93         with pytest.raises(SdlTypeError):
  94             self.storage.set_if(0xbad, 'key', b'v1', b'v2')
  95         with pytest.raises(SdlTypeError):
  96             self.storage.set_if('ns', 0xbad, b'v1', b'v2')
  97         with pytest.raises(SdlTypeError):
  98             self.storage.set_if('ns', 'key', 0xbad, b'v2')
  99         with pytest.raises(SdlTypeError):
 100             self.storage.set_if('ns', 'key', b'v1', 0xbad)
 101
 102     def test_set_if_not_exists_function_success(self):
 103         self.mock_db_backend.set_if_not_exists.return_value = True
 104         ret = self.storage.set_if_not_exists(self.ns, self.key, self.new_data)
 105         self.mock_db_backend.set_if_not_exists.assert_called_once_with(self.ns, self.key,
 106                                                                        self.new_data)
 107         assert ret is True
 108
 109     def test_set_if_not_exists_function_can_return_false_if_key_already_exists(self):
 110         self.mock_db_backend.set_if_not_exists.return_value = False
 111         ret = self.storage.set_if_not_exists(self.ns, self.key, self.new_data)
 112         self.mock_db_backend.set_if_not_exists.assert_called_once_with(self.ns, self.key,
 113                                                                        self.new_data)
 114         assert ret is False
 115
 116     def test_set_if_not_exists_function_can_raise_exception_for_wrong_argument(self):
 117         with pytest.raises(SdlTypeError):
 118             self.storage.set_if_not_exists(0xbad, 'key', b'v1')
 119         with pytest.raises(SdlTypeError):
 120             self.storage.set_if_not_exists('ns', 0xbad, b'v1')
 121         with pytest.raises(SdlTypeError):
 122             self.storage.set_if_not_exists('ns', 'key', 0xbad)
 123
 124     def test_get_function_success(self):
 125         self.mock_db_backend.get.return_value = self.dm
 126         ret = self.storage.get(self.ns, self.keys)
 127         self.mock_db_backend.get.assert_called_once()
 128         call_args, _ = self.mock_db_backend.get.call_args
 129         assert call_args[0] == self.ns
 130         assert len(call_args[1]) == len(self.keys)
 131         assert all(k in call_args[1] for k in self.keys)
 132         assert ret == self.dm
 133         # Validate that SDL returns a dictionary with keys in alphabetical order
 134         assert sorted(self.dm)[0] == list(ret.keys())[0]
 135
 136     def test_get_function_can_return_empty_dict_when_no_key_values_exist(self):
 137         self.mock_db_backend.get.return_value = dict()
 138         ret = self.storage.get(self.ns, self.keys)
 139         self.mock_db_backend.get.assert_called_once()
 140         call_args, _ = self.mock_db_backend.get.call_args
 141         assert call_args[0] == self.ns
 142         assert len(call_args[1]) == len(self.keys)
 143         assert all(k in call_args[1] for k in self.keys)
 144         assert ret == dict()
 145
 146     def test_get_function_can_raise_exception_for_wrong_argument(self):
 147         with pytest.raises(SdlTypeError):
 148             self.storage.get(0xbad, self.key)
 149         with pytest.raises(SdlTypeError):
 150             self.storage.get(self.ns, 0xbad)
 151
 152     def test_find_keys_function_success(self):
 153         self.mock_db_backend.find_keys.return_value = self.matchedkeys
 154         ret = self.storage.find_keys(self.ns, self.keyprefix)
 155         self.mock_db_backend.find_keys.assert_called_once_with(self.ns, self.keyprefix)
 156         assert ret == self.matchedkeys
 157
 158     def test_find_keys_function_can_return_empty_list_when_no_keys_exist(self):
 159         self.mock_db_backend.find_keys.return_value = list()
 160         ret = self.storage.find_keys(self.ns, self.keyprefix)
 161         self.mock_db_backend.find_keys.assert_called_once_with(self.ns, self.keyprefix)
 162         assert ret == list()
 163
 164     def test_find_keys_function_can_raise_exception_for_wrong_argument(self):
 165         with pytest.raises(SdlTypeError):
 166             self.storage.find_keys(0xbad, self.keyprefix)
 167         with pytest.raises(SdlTypeError):
 168             self.storage.find_keys(self.ns, 0xbad)
 169
 170     def test_find_and_get_function_success(self):
 171         self.mock_db_backend.find_and_get.return_value = self.dm
 172         ret = self.storage.find_and_get(self.ns, self.keyprefix)
 173         self.mock_db_backend.find_and_get.assert_called_once_with(self.ns, self.keyprefix)
 174         assert ret == self.dm
 175         # Validate that SDL returns a dictionary with keys in alphabetical order
 176         assert sorted(self.dm)[0] == list(ret.keys())[0]
 177
 178     def test_find_and_get_function_can_return_empty_dict_when_no_keys_exist(self):
 179         self.mock_db_backend.find_and_get.return_value = dict()
 180         ret = self.storage.find_and_get(self.ns, self.keyprefix)
 181         self.mock_db_backend.find_and_get.assert_called_once_with(self.ns, self.keyprefix)
 182         assert ret == dict()
 183
 184     def test_find_and_get_function_can_raise_exception_for_wrong_argument(self):
 185         with pytest.raises(SdlTypeError):
 186             self.storage.find_and_get(0xbad, self.keyprefix)
 187         with pytest.raises(SdlTypeError):
 188             self.storage.find_and_get(self.ns, 0xbad)
 189
 190     def test_remove_function_success(self):
 191         self.storage.remove(self.ns, self.keys)
 192         self.mock_db_backend.remove.assert_called_once()
 193         call_args, _ = self.mock_db_backend.remove.call_args
 194         assert call_args[0] == self.ns
 195         assert isinstance(call_args[1], list)
 196         assert len(call_args[1]) == len(self.keys)
 197         assert all(k in call_args[1] for k in self.keys)
 198
 199     def test_remove_function_can_raise_exception_for_wrong_argument(self):
 200         with pytest.raises(SdlTypeError):
 201             self.storage.remove(0xbad, self.keys)
 202         with pytest.raises(SdlTypeError):
 203             self.storage.remove(self.ns, 0xbad)
 204
 205     def test_remove_if_function_success(self):
 206         self.mock_db_backend.remove_if.return_value = True
 207         ret = self.storage.remove_if(self.ns, self.key, self.new_data)
 208         self.mock_db_backend.remove_if.assert_called_once_with(self.ns, self.key, self.new_data)
 209         assert ret is True
 210
 211     def test_remove_if_function_can_return_false_if_data_does_not_match(self):
 212         self.mock_db_backend.remove_if.return_value = False
 213         ret = self.storage.remove_if(self.ns, self.key, self.old_data)
 214         self.mock_db_backend.remove_if.assert_called_once_with(self.ns, self.key, self.old_data)
 215         assert ret is False
 216
 217     def test_remove_if_function_can_raise_exception_for_wrong_argument(self):
 218         with pytest.raises(SdlTypeError):
 219             self.storage.remove_if(0xbad, self.keys, self.old_data)
 220         with pytest.raises(SdlTypeError):
 221             self.storage.remove_if(self.ns, 0xbad, self.old_data)
 222         with pytest.raises(SdlTypeError):
 223             self.storage.remove_if(self.ns, self.keys, 0xbad)
 224
 225     def test_remove_all_function_success(self):
 226         self.mock_db_backend.find_keys.return_value = ['a1']
 227         self.storage.remove_all(self.ns)
 228         self.mock_db_backend.find_keys.assert_called_once_with(self.ns, '*')
 229         self.mock_db_backend.remove.assert_called_once_with(self.ns,
 230                                                             self.mock_db_backend.find_keys.return_value)
 231
 232     def test_remove_all_function_can_raise_exception_for_wrong_argument(self):
 233         with pytest.raises(SdlTypeError):
 234             self.storage.remove_all(0xbad)
 235
 236     def test_add_member_function_success(self):
 237         self.storage.add_member(self.ns, self.group, self.groupmembers)
 238         self.mock_db_backend.add_member.assert_called_once_with(self.ns,
 239                                                                 self.group, self.groupmembers)
 240
 241     def test_add_member_function_can_raise_exception_for_wrong_argument(self):
 242         with pytest.raises(SdlTypeError):
 243             self.storage.add_member(0xbad, self.group, self.groupmembers)
 244         with pytest.raises(SdlTypeError):
 245             self.storage.add_member(self.ns, 0xbad, self.groupmembers)
 246         with pytest.raises(SdlTypeError):
 247             self.storage.add_member(self.ns, self.group, 0xbad)
 248
 249     def test_remove_member_function_success(self):
 250         self.storage.remove_member(self.ns, self.group, self.groupmembers)
 251         self.mock_db_backend.remove_member.assert_called_once_with(self.ns, self.group,
 252                                                                    self.groupmembers)
 253
 254     def test_remove_member_function_can_raise_exception_for_wrong_argument(self):
 255         with pytest.raises(SdlTypeError):
 256             self.storage.remove_member(0xbad, self.group, self.groupmembers)
 257         with pytest.raises(SdlTypeError):
 258             self.storage.remove_member(self.ns, 0xbad, self.groupmembers)
 259         with pytest.raises(SdlTypeError):
 260             self.storage.remove_member(self.ns, self.group, 0xbad)
 261
 262     def test_remove_group_function_success(self):
 263         self.storage.remove_group(self.ns, self.group)
 264         self.mock_db_backend.remove_group.assert_called_once_with(self.ns, self.group)
 265
 266     def test_remove_group_function_can_raise_exception_for_wrong_argument(self):
 267         with pytest.raises(SdlTypeError):
 268             self.storage.remove_group(0xbad, self.group)
 269         with pytest.raises(SdlTypeError):
 270             self.storage.remove_group(self.ns, 0xbad)
 271
 272     def test_get_members_function_success(self):
 273         self.mock_db_backend.get_members.return_value = self.groupmembers
 274         ret = self.storage.get_members(self.ns, self.group)
 275         self.mock_db_backend.get_members.assert_called_once_with(self.ns, self.group)
 276         assert ret == self.groupmembers
 277
 278     def test_get_members_function_can_raise_exception_for_wrong_argument(self):
 279         with pytest.raises(SdlTypeError):
 280             self.storage.get_members(0xbad, self.group)
 281         with pytest.raises(SdlTypeError):
 282             self.storage.get_members(self.ns, 0xbad)
 283
 284     def test_is_member_function_success(self):
 285         self.mock_db_backend.is_member.return_value = True
 286         ret = self.storage.is_member(self.ns, self.group, self.groupmember)
 287         self.mock_db_backend.is_member.assert_called_once_with(self.ns, self.group,
 288                                                                self.groupmember)
 289         assert ret is True
 290
 291     def test_is_member_function_can_raise_exception_for_wrong_argument(self):
 292         with pytest.raises(SdlTypeError):
 293             self.storage.is_member(0xbad, self.group, self.groupmember)
 294         with pytest.raises(SdlTypeError):
 295             self.storage.is_member(self.ns, 0xbad, self.groupmember)
 296         with pytest.raises(SdlTypeError):
 297             self.storage.is_member(self.ns, self.group, 0xbad)
 298
 299     def test_group_size_function_success(self):
 300         self.mock_db_backend.group_size.return_value = 100
 301         ret = self.storage.group_size(self.ns, self.group)
 302         self.mock_db_backend.group_size.assert_called_once_with(self.ns, self.group)
 303         assert ret == 100
 304
 305     def test_group_size_function_can_raise_exception_for_wrong_argument(self):
 306         with pytest.raises(SdlTypeError):
 307             self.storage.group_size(0xbad, self.group)
 308         with pytest.raises(SdlTypeError):
 309             self.storage.group_size(self.ns, 0xbad)
 310
 311     @patch('ricsdl.syncstorage.SyncLock')
 312     def test_get_lock_resource_function_success_when_expiration_time_is_integer(self, mock_db_lock):
 313         ret = self.storage.get_lock_resource(self.ns, self.lock_name, self.lock_int_expiration)
 314         mock_db_lock.assert_called_once_with(self.ns, self.lock_name, self.lock_int_expiration,
 315                                              self.storage)
 316         assert ret == mock_db_lock.return_value
 317
 318     @patch('ricsdl.syncstorage.SyncLock')
 319     def test_get_lock_resource_function_success_when_expiration_time_is_float_number(self,
 320                                                                                      mock_db_lock):
 321         ret = self.storage.get_lock_resource(self.ns, self.lock_name, self.lock_float_expiration)
 322         mock_db_lock.assert_called_once_with(self.ns, self.lock_name, self.lock_float_expiration,
 323                                              self.storage)
 324         assert ret == mock_db_lock.return_value
 325
 326     def test_get_lock_resource_function_can_raise_exception_for_wrong_argument(self):
 327         with pytest.raises(SdlTypeError):
 328             self.storage.get_lock_resource(0xbad, self.lock_name, self.lock_int_expiration)
 329         with pytest.raises(SdlTypeError):
 330             self.storage.get_lock_resource(self.ns, 0xbad, self.lock_int_expiration)
 331         with pytest.raises(SdlTypeError):
 332             self.storage.get_lock_resource(self.ns, self.lock_name, 'bad')
 333
 334     def test_get_backend_function_success(self):
 335         ret = self.storage.get_backend()
 336         assert ret == self.mock_db_backend
 337
 338     def test_storage_object_string_representation(self):
 339         str_out = str(self.storage)
 340         assert str_out is not None
 341
 342
 343 @pytest.fixture()
 344 def lock_fixture(request):
 345     request.cls.ns = 'some-ns'
 346     request.cls.lockname = 'some-lock-name'
 347     request.cls.expiration = 10
 348     request.cls.retry_interval = 0.1
 349     request.cls.retry_timeout = 1
 350
 351     with patch('ricsdl.backend.get_backend_lock_instance') as mock_db_backend_lock:
 352         lock = SyncLock('test-ns', 'test-lock-name', request.cls.expiration, Mock())
 353         request.cls.mock_db_backend_lock = mock_db_backend_lock.return_value
 354     request.cls.lock = lock
 355     yield
 356
 357
 358 @pytest.mark.usefixtures('lock_fixture')
 359 class TestSyncLock:
 360     def test_acquire_function_success_when_timeout_and_interval_are_integers(self):
 361         self.lock.acquire(self.retry_interval, self.retry_timeout)
 362         self.mock_db_backend_lock.acquire.assert_called_once_with(self.retry_interval,
 363                                                                   self.retry_timeout)
 364
 365     def test_acquire_function_success_when_timeout_and_interval_are_float_numbers(self):
 366         self.lock.acquire(float(self.retry_interval), float(self.retry_timeout))
 367         self.mock_db_backend_lock.acquire.assert_called_once_with(float(self.retry_interval),
 368                                                                   float(self.retry_timeout))
 369
 370     def test_acquire_function_can_raise_exception_for_wrong_argument(self):
 371         with pytest.raises(SdlTypeError):
 372             self.lock.acquire('bad', self.retry_timeout)
 373         with pytest.raises(SdlTypeError):
 374             self.lock.acquire(self.retry_interval, 'bad')
 375
 376     def test_release_function_success(self):
 377         self.lock.release()
 378         self.mock_db_backend_lock.release.assert_called_once()
 379
 380     def test_refresh_function_success(self):
 381         self.lock.refresh()
 382         self.mock_db_backend_lock.refresh.assert_called_once()
 383
 384     def test_get_validity_time_function_success(self):
 385         self.mock_db_backend_lock.get_validity_time.return_value = self.expiration
 386         ret = self.lock.get_validity_time()
 387         self.mock_db_backend_lock.get_validity_time.assert_called_once()
 388         assert ret == self.expiration
 389
 390     def test_get_validity_time_function_success_when_returned_time_is_float(self):
 391         self.mock_db_backend_lock.get_validity_time.return_value = float(self.expiration)
 392         ret = self.lock.get_validity_time()
 393         self.mock_db_backend_lock.get_validity_time.assert_called_once()
 394         assert ret == float(self.expiration)
 395
 396     def test_lock_object_string_representation(self):
 397         str_out = str(self.lock)
 398         assert str_out is not None
 399
 400
 401 def test_function_arg_validator():
 402     @func_arg_checker(SdlTypeError, 0, a=str, b=(int, float), c=set, d=(dict, type(None)))
 403     def _my_func(a='abc', b=1, c={'x', 'y'}, d={'x': b'1'}):
 404         pass
 405     with pytest.raises(SdlTypeError, match=r"Wrong argument type: 'a'=<class 'NoneType'>. "
 406                                            r"Must be: <class 'str'>"):
 407         _my_func(None)
 408
 409     with pytest.raises(SdlTypeError, match=r"Wrong argument type: 'b'=<class 'str'>. "):
 410         _my_func('abc', 'wrong type')
 411
 412     with pytest.raises(SdlTypeError, match=r"Wrong argument type: 'c'=<class 'str'>. "
 413                                            r"Must be: <class 'set'>"):
 414         _my_func('abc', 1.0, 'wrong type')
 415
 416     with pytest.raises(SdlTypeError, match=r"Wrong argument type: 'd'=<class 'str'>. "):
 417         _my_func('abc', 1.0, {'x', 'y'}, 'wrong type')
 418
 419
 420 def test_function_kwarg_validator():
 421     @func_arg_checker(SdlTypeError, 0, a=str, b=(int, float), c=set, d=(dict, type(None)))
 422     def _my_func(a='abc', b=1, c={'x', 'y'}, d={'x': b'1'}):
 423         pass
 424     with pytest.raises(SdlTypeError, match=r"Wrong argument type: 'a'=<class 'NoneType'>. "
 425                                            r"Must be: <class 'str'>"):
 426         _my_func(a=None)
 427
 428     with pytest.raises(SdlTypeError, match=r"Wrong argument type: 'b'=<class 'str'>. "):
 429         _my_func(b='wrong type')
 430
 431     with pytest.raises(SdlTypeError, match=r"Wrong argument type: 'c'=<class 'str'>. "
 432                                            r"Must be: <class 'set'>"):
 433         _my_func(c='wrong type')
 434
 435     with pytest.raises(SdlTypeError, match=r"Wrong argument type: 'd'=<class 'str'>. "):
 436         _my_func(d='wrong type')