NG-RO/osm_ng_ro/tests/test_monitor.py

   1 #######################################################################################
   2 # Copyright ETSI Contributors and Others.
   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
  13 # implied.
  14 # See the License for the specific language governing permissions and
  15 # limitations under the License.
  16 #######################################################################################
  17 from copy import deepcopy
  18 import logging
  19 import threading
  20 import unittest
  21 from unittest.mock import MagicMock, mock_open, patch
  22
  23 from novaclient.v2.servers import Server as NovaServer
  24 from osm_common import dbmongo
  25 from osm_common.dbbase import DbException
  26 from osm_ng_ro.monitor import (
  27     MonitorDbException,
  28     MonitorVimException,
  29     MonitorVms,
  30     MonitorVmsException,
  31     start_monitoring,
  32     stop_monitoring,
  33     VimToMonitor,
  34     VmToMonitor,
  35 )
  36 from osm_ng_ro.tests.sample_data import (
  37     config,
  38     db_vim_cacert,
  39     db_vim_collection,
  40     deleted_externally,
  41     file_name,
  42     interface_info2,
  43     interface_with_binding,
  44     ip1_addr,
  45     mac1_addr,
  46     mac2_addr,
  47     net1_id,
  48     old_interface,
  49     old_interface2,
  50     plugin_name,
  51     port1,
  52     port2,
  53     ro_task1,
  54     ro_task2,
  55     sample_vim,
  56     sample_vim_info,
  57     sample_vnfr,
  58     serialized_interface_info,
  59     serialized_server_info,
  60     server_other_info,
  61     target_id,
  62     target_record,
  63     target_record2,
  64     vdur_path,
  65     vim1_id,
  66     vim2_id,
  67     vim3_id,
  68     vim4_id,
  69     vim_info_path,
  70     vims,
  71     vims_to_monitor,
  72     vm1_id,
  73     vm2_id,
  74     vnfr_id,
  75     wrong_ro_task,
  76 )
  77 from osm_ro_plugin.vimconn import VimConnector
  78 import yaml
  79
  80
  81 def create_server(id: str, name: str, status: str = "ACTIVE", info: dict = {}):
  82     instance = NovaServer(manager="manager", info=info)
  83     instance.id = id
  84     instance.name = name
  85     instance.status = status
  86     return instance
  87
  88
  89 # The preparation for the tests
  90 sample_vim_connector_instance = VimConnector(
  91     uuid=sample_vim["_id"],
  92     name=sample_vim["name"],
  93     tenant_id=sample_vim.get("vim_tenant_id"),
  94     tenant_name=sample_vim.get("vim_tenant_name"),
  95     url=sample_vim["vim_url"],
  96 )
  97 sample_vm = VmToMonitor(vm1_id, target_record)
  98 sample_vm2 = VmToMonitor(vm2_id, target_record)
  99 sample_vm3 = VmToMonitor("deleted-vm-id", target_record)
 100 server1 = create_server(vm1_id, "server1")
 101 server2 = create_server(vm2_id, "server2")
 102 server3 = create_server("other-vm-id3", "other-vm3")
 103 server4 = create_server("other-vm-id4", "other-vm4")
 104 all_server_info = deepcopy(server_other_info)
 105 server7 = create_server(vm1_id, "server7", info=all_server_info)
 106
 107
 108 class CopyingMock(MagicMock):
 109     def __call__(self, *args, **kwargs):
 110         args = deepcopy(args)
 111         kwargs = deepcopy(kwargs)
 112         return super(CopyingMock, self).__call__(*args, **kwargs)
 113
 114
 115 def check_if_assert_not_called(mocks: list):
 116     for mocking in mocks:
 117         mocking.assert_not_called()
 118
 119
 120 class TestMonitorVms(unittest.TestCase):
 121     @patch("osm_ng_ro.monitor.MonitorVms.__init__")
 122     @patch("osm_ng_ro.ns_thread.ConfigValidate")
 123     @patch("osm_ng_ro.monitor.MonitorVms.get_db_vims")
 124     @patch("osm_ng_ro.monitor.MonitorVms.load_vims")
 125     @patch("logging.getLogger", autospec=True)
 126     def setUp(
 127         self,
 128         mock_logger,
 129         mock_load_vims,
 130         mock_get_db_vims,
 131         mock_config_validate,
 132         mock_init,
 133     ):
 134         # We are disabling the logging of exception not to print them to console.
 135         mock_logger = logging.getLogger()
 136         mock_logger.disabled = True
 137         mock_init.return_value = None
 138         self.monitor = MonitorVms(config=config)
 139         self.monitor.db_vims = []
 140         self.monitor.db = CopyingMock(dbmongo.DbMongo(), autospec=True)
 141         self.monitor.config = config
 142         self.monitor.logger = mock_logger
 143         self.monitor.my_vims = {}
 144         self.monitor.refresh_config = mock_config_validate
 145
 146     @patch("osm_ng_ro.ns_thread.ConfigValidate.__init__")
 147     @patch("osm_ng_ro.monitor.MonitorVms.get_db_vims")
 148     @patch("osm_ng_ro.monitor.MonitorVms.load_vims")
 149     @patch("logging.getLogger", autospec=True)
 150     @patch("osm_ng_ro.monitor.MonitorVms.connect_db")
 151     def test_init(
 152         self,
 153         mock_connect_db,
 154         mock_logger,
 155         mock_load_vims,
 156         mock_get_db_vims,
 157         mock_config_validate_init,
 158     ):
 159         mock_config_validate_init.return_value = None
 160         mock_get_db_vims.return_value = vims
 161         instance = MonitorVms(config)
 162         mock_config_validate_init.assert_called_once_with(config)
 163         self.assertDictEqual(instance.config, config)
 164         mock_load_vims.assert_called_once()
 165         self.assertEqual(instance.db_vims, vims)
 166         mock_connect_db.assert_called_once()
 167         self.assertIsNone(instance.db)
 168         self.assertIsNotNone(instance.db_vims)
 169         mock_logger.assert_called_once_with("ro.monitor")
 170
 171     @patch("osm_ng_ro.monitor.MonitorVms._load_vim")
 172     def test_load_vims_empty_db_vims(self, mock_load_vim):
 173         self.monitor.load_vims()
 174         mock_load_vim.assert_not_called()
 175
 176     @patch("osm_ng_ro.monitor.MonitorVms._load_vim")
 177     def test_load_vims_vim_id_not_in_my_vims(self, mock_load_vim):
 178         self.monitor.db_vims = vims
 179         self.monitor.my_vims = {vim3_id: "vim-obj3"}
 180         self.monitor.load_vims()
 181         _call_mock_load_vim = mock_load_vim.call_args_list
 182         self.assertEqual(mock_load_vim.call_count, 2)
 183         self.assertEqual(
 184             _call_mock_load_vim[0][0],
 185             (vim1_id,),
 186         )
 187         self.assertEqual(
 188             _call_mock_load_vim[1][0],
 189             (vim2_id,),
 190         )
 191
 192     @patch("osm_ng_ro.monitor.MonitorVms._load_vim")
 193     def test_load_vims_vim_id_in_my_vims(self, mock_load_vim):
 194         self.monitor.db_vims = vims
 195         self.monitor.my_vims = {vim1_id: "vim-obj1", vim2_id: "vim-obj2"}
 196         self.monitor.load_vims()
 197         mock_load_vim.assert_not_called()
 198
 199     @patch("osm_common.dbmongo.DbMongo.db_connect")
 200     @patch("osm_common.dbmongo.DbMongo.__init__")
 201     @patch("osm_common.dbmemory.DbMemory.db_connect")
 202     @patch("osm_common.dbmemory.DbMemory.__init__")
 203     def test_connect_db_type_mongo(
 204         self,
 205         mock_dbmemory_init,
 206         mock_dbmemory_connect,
 207         mock_dbmongo_init,
 208         mock_dbmongo_connect,
 209     ):
 210         self.monitor.db = None
 211         self.monitor.config["database"]["driver"] = "mongo"
 212         mock_dbmongo_init.return_value = None
 213         self.monitor.connect_db()
 214         mock_dbmongo_init.assert_called_once()
 215         mock_dbmongo_connect.assert_called_once()
 216         self.monitor.db.db_connect.assert_called_once_with(
 217             self.monitor.config["database"]
 218         )
 219         check_if_assert_not_called([mock_dbmemory_init, mock_dbmemory_connect])
 220
 221     @patch("osm_common.dbmongo.DbMongo.db_connect")
 222     @patch("osm_common.dbmongo.DbMongo.__init__")
 223     @patch("osm_common.dbmemory.DbMemory.db_connect")
 224     @patch("osm_common.dbmemory.DbMemory.__init__")
 225     def test_connect_db_type_mongo_initialize_exception(
 226         self,
 227         mock_dbmemory_init,
 228         mock_dbmemory_connect,
 229         mock_dbmongo_init,
 230         mock_dbmongo_connect,
 231     ):
 232         self.monitor.db = None
 233         self.monitor.config["database"]["driver"] = "mongo"
 234         mock_dbmongo_init.side_effect = ValueError("Db object could not be created.")
 235         with self.assertRaises(MonitorDbException) as err:
 236             self.monitor.connect_db()
 237         self.assertEqual(str(err.exception), "Db object could not be created.")
 238         mock_dbmongo_init.assert_called_once()
 239         check_if_assert_not_called(
 240             [mock_dbmongo_connect, mock_dbmemory_init, mock_dbmemory_connect]
 241         )
 242
 243     @patch("osm_common.dbmongo.DbMongo.db_connect")
 244     @patch("osm_common.dbmongo.DbMongo.__init__")
 245     @patch("osm_common.dbmemory.DbMemory.db_connect")
 246     @patch("osm_common.dbmemory.DbMemory.__init__")
 247     def test_connect_db_type_mongo_connection_exception(
 248         self,
 249         mock_dbmemory_init,
 250         mock_dbmemory_connect,
 251         mock_dbmongo_init,
 252         mock_dbmongo_connect,
 253     ):
 254         self.monitor.db = None
 255         self.monitor.config["database"]["driver"] = "mongo"
 256         mock_dbmongo_init.return_value = None
 257         mock_dbmongo_connect.side_effect = DbException("Connection failed")
 258         with self.assertRaises(MonitorDbException) as err:
 259             self.monitor.connect_db()
 260         self.assertEqual(str(err.exception), "database exception Connection failed")
 261         mock_dbmongo_init.assert_called_once()
 262         mock_dbmongo_connect.assert_called_once_with(self.monitor.config["database"])
 263         check_if_assert_not_called([mock_dbmemory_init, mock_dbmemory_connect])
 264
 265     @patch("osm_common.dbmongo.DbMongo.db_connect")
 266     @patch("osm_common.dbmongo.DbMongo.__init__")
 267     @patch("osm_common.dbmemory.DbMemory.db_connect")
 268     @patch("osm_common.dbmemory.DbMemory.__init__")
 269     def test_connect_db_type_memory(
 270         self,
 271         mock_dbmemory_init,
 272         mock_dbmemory_connect,
 273         mock_dbmongo_init,
 274         mock_dbmongo_connect,
 275     ):
 276         self.monitor.db = None
 277         self.monitor.config["database"]["driver"] = "memory"
 278         mock_dbmemory_init.return_value = None
 279         self.monitor.connect_db()
 280         mock_dbmemory_init.assert_called_once()
 281         mock_dbmemory_connect.assert_called_once_with(self.monitor.config["database"])
 282         check_if_assert_not_called([mock_dbmongo_init, mock_dbmongo_connect])
 283
 284     @patch("osm_common.dbmongo.DbMongo.db_connect")
 285     @patch("osm_common.dbmongo.DbMongo.__init__")
 286     @patch("osm_common.dbmemory.DbMemory.db_connect")
 287     @patch("osm_common.dbmemory.DbMemory.__init__")
 288     def test_connect_db_existing_db(
 289         self,
 290         mock_dbmemory_init,
 291         mock_dbmemory_connect,
 292         mock_dbmongo_init,
 293         mock_dbmongo_connect,
 294     ):
 295         self.monitor.connect_db()
 296         check_if_assert_not_called(
 297             [
 298                 mock_dbmemory_init,
 299                 mock_dbmongo_init,
 300                 mock_dbmemory_connect,
 301                 mock_dbmongo_connect,
 302             ]
 303         )
 304
 305     @patch("osm_common.dbmongo.DbMongo.db_connect")
 306     @patch("osm_common.dbmongo.DbMongo.__init__")
 307     @patch("osm_common.dbmemory.DbMemory.db_connect")
 308     @patch("osm_common.dbmemory.DbMemory.__init__")
 309     def test_connect_db_wrong_driver_type(
 310         self,
 311         mock_dbmemory_init,
 312         mock_dbmemory_connect,
 313         mock_dbmongo_init,
 314         mock_dbmongo_connect,
 315     ):
 316         self.monitor.db = None
 317         self.monitor.config["database"]["driver"] = "posgresql"
 318         with self.assertRaises(MonitorDbException) as err:
 319             self.monitor.connect_db()
 320         self.assertEqual(
 321             str(err.exception),
 322             "Invalid configuration param 'posgresql' at '[database]':'driver'",
 323         )
 324         check_if_assert_not_called(
 325             [
 326                 mock_dbmemory_init,
 327                 mock_dbmongo_init,
 328                 mock_dbmemory_connect,
 329                 mock_dbmongo_connect,
 330             ]
 331         )
 332
 333     def test_get_db_vims(self):
 334         self.monitor.db.get_list.return_value = vims
 335         result = self.monitor.get_db_vims()
 336         self.assertEqual(result, vims)
 337         self.monitor.db.get_list.assert_called_once_with(
 338             "vim_accounts", {"vim_type": "openstack"}
 339         )
 340
 341     def test_get_db_vims_db_raises(self):
 342         self.monitor.db.get_list.side_effect = DbException("Connection failed.")
 343         with self.assertRaises(DbException) as err:
 344             result = self.monitor.get_db_vims()
 345             self.assertEqual(result, None)
 346         self.assertEqual(str(err.exception), "database exception Connection failed.")
 347         self.monitor.db.get_list.assert_called_once_with(
 348             "vim_accounts", {"vim_type": "openstack"}
 349         )
 350
 351     def test_find_ro_tasks_to_monitor(self):
 352         self.monitor.db.get_list.return_value = [ro_task1]
 353         result = self.monitor.find_ro_tasks_to_monitor()
 354         self.assertEqual(result, [ro_task1])
 355         self.monitor.db.get_list.assert_called_once_with(
 356             "ro_tasks",
 357             q_filter={
 358                 "tasks.status": ["DONE"],
 359                 "tasks.item": ["vdu"],
 360             },
 361         )
 362
 363     def test_find_ro_tasks_to_monitor_db_exception(self):
 364         self.monitor.db.get_list.side_effect = DbException("Wrong database status")
 365         with self.assertRaises(DbException) as err:
 366             result = self.monitor.find_ro_tasks_to_monitor()
 367             self.assertEqual(result, None)
 368         self.assertEqual(str(err.exception), "database exception Wrong database status")
 369         self.monitor.db.get_list.assert_called_once_with(
 370             "ro_tasks",
 371             q_filter={
 372                 "tasks.status": ["DONE"],
 373                 "tasks.item": ["vdu"],
 374             },
 375         )
 376
 377     def test_initialize_target_vim(self):
 378         vim_module_conn = VimConnector
 379         vim_connector_instance = self.monitor._initialize_target_vim(
 380             vim_module_conn, sample_vim
 381         )
 382         self.assertIsInstance(vim_connector_instance, VimConnector)
 383         self.assertListEqual(
 384             [vim_connector_instance.id, vim_connector_instance.name],
 385             [target_id, "openstackETSI1"],
 386         )
 387
 388     def test_initialize_target_vim_invalid_vim_connector_input(self):
 389         vim_module_conn = "openstack_vim_connector"
 390         with self.assertRaises(TypeError) as err:
 391             self.monitor._initialize_target_vim(vim_module_conn, sample_vim)
 392         self.assertEqual(str(err.exception), "'str' object is not callable")
 393
 394     def test_initialize_target_vim_missing_vim_keys(self):
 395         vim_module_conn = VimConnector
 396         sample_vim = {
 397             "_id": target_id,
 398             "name": "openstackETSI1",
 399             "vim_type": "openstack",
 400         }
 401         with self.assertRaises(KeyError) as err:
 402             self.monitor._initialize_target_vim(vim_module_conn, sample_vim)
 403         self.assertEqual(str(err.exception.args[0]), "vim_url")
 404
 405     def test_initialize_target_vim_invalid_vim_input_type(self):
 406         vim_module_conn = VimConnector
 407         sample_vim = [target_id, "openstackETSI1"]
 408         with self.assertRaises(TypeError) as err:
 409             self.monitor._initialize_target_vim(vim_module_conn, sample_vim)
 410         self.assertEqual(
 411             str(err.exception), "list indices must be integers or slices, not str"
 412         )
 413
 414     @patch("osm_ng_ro.monitor.MonitorVms._process_vim_config")
 415     @patch("osm_ng_ro.monitor.MonitorVms._load_plugin")
 416     @patch("osm_ng_ro.monitor.MonitorVms._initialize_target_vim")
 417     def test_load_vim(self, mock_target_vim, mock_load_plugin, mock_vim_config):
 418         self.monitor.my_vims = {}
 419         sample_vim["schema_version"] = "1.11"
 420         self.monitor.db.get_one.return_value = sample_vim
 421         mock_load_plugin.return_value = VimConnector
 422         mock_target_vim.return_value = sample_vim_connector_instance
 423         self.monitor._load_vim(target_id)
 424         self.assertEqual(self.monitor.my_vims[target_id], sample_vim_connector_instance)
 425         mock_vim_config.assert_called_once()
 426         self.monitor.db.get_one.assert_called_once_with(
 427             db_vim_collection, {"_id": target_id}
 428         )
 429         self.monitor.db.encrypt_decrypt_fields.assert_called_once_with(
 430             sample_vim,
 431             "decrypt",
 432             fields=("password", "secret"),
 433             schema_version="1.11",
 434             salt=target_id,
 435         )
 436         mock_vim_config.assert_called_once_with(target_id, sample_vim)
 437         mock_load_plugin.assert_called_once_with(plugin_name)
 438         mock_target_vim.assert_called_once_with(VimConnector, sample_vim)
 439
 440     @patch("osm_ng_ro.monitor.MonitorVms._process_vim_config")
 441     @patch("osm_ng_ro.monitor.MonitorVms._load_plugin")
 442     @patch("osm_ng_ro.monitor.MonitorVms._initialize_target_vim")
 443     def test_load_vim_target_vim_not_found(
 444         self, mock_target_vim, mock_load_plugin, mock_vim_config
 445     ):
 446         self.monitor.my_vims = {}
 447         self.monitor.db.get_one.return_value = None
 448         with self.assertRaises(MonitorVimException) as err:
 449             self.monitor._load_vim(target_id)
 450         self.assertEqual(
 451             str(err.exception),
 452             "Cannot load 55b2219a-7bb9-4644-9612-980dada84e83 plugin=rovim_openstack: "
 453             "'NoneType' object has no attribute 'get'",
 454         )
 455         self.monitor.db.get_one.assert_called_once_with(
 456             db_vim_collection, {"_id": target_id}
 457         )
 458         check_if_assert_not_called(
 459             [
 460                 self.monitor.db.encrypt_decrypt_fields,
 461                 mock_vim_config,
 462                 mock_load_plugin,
 463                 mock_target_vim,
 464             ]
 465         )
 466
 467     @patch("osm_ng_ro.monitor.MonitorVms._process_vim_config")
 468     @patch("osm_ng_ro.monitor.MonitorVms._load_plugin")
 469     @patch("osm_ng_ro.monitor.MonitorVms._initialize_target_vim")
 470     def test_load_vim_decrypt_fields_raises(
 471         self, mock_target_vim, mock_load_plugin, mock_vim_config
 472     ):
 473         self.monitor.my_vims = {}
 474         sample_vim["schema_version"] = "1.11"
 475         self.monitor.db.get_one.return_value = sample_vim
 476         self.monitor.db.encrypt_decrypt_fields.side_effect = DbException(
 477             "Value could not decrypted."
 478         )
 479         with self.assertRaises(MonitorVimException) as err:
 480             self.monitor._load_vim(target_id)
 481         self.assertEqual(
 482             str(err.exception),
 483             "Cannot load 55b2219a-7bb9-4644-9612-980dada84e83 plugin=rovim_openstack: "
 484             "database exception Value could not decrypted.",
 485         )
 486         self.monitor.db.get_one.assert_called_once_with(
 487             db_vim_collection, {"_id": target_id}
 488         )
 489         self.monitor.db.encrypt_decrypt_fields.assert_called_once_with(
 490             sample_vim,
 491             "decrypt",
 492             fields=("password", "secret"),
 493             schema_version="1.11",
 494             salt=target_id,
 495         )
 496         check_if_assert_not_called([mock_vim_config, mock_load_plugin, mock_target_vim])
 497
 498     @patch("osm_ng_ro.monitor.MonitorVms._process_vim_config")
 499     @patch("osm_ng_ro.monitor.MonitorVms._load_plugin")
 500     @patch("osm_ng_ro.monitor.MonitorVms._initialize_target_vim")
 501     def test_load_vim_process_vim_config_raises(
 502         self, mock_target_vim, mock_load_plugin, mock_vim_config
 503     ):
 504         self.monitor.my_vims = {}
 505         sample_vim["schema_version"] = "1.11"
 506         self.monitor.db.get_one.return_value = sample_vim
 507         mock_vim_config.side_effect = MonitorVimException(
 508             "Error writing file config_1234"
 509         )
 510         with self.assertRaises(MonitorVimException) as err:
 511             self.monitor._load_vim(target_id)
 512         self.assertEqual(
 513             str(err.exception),
 514             "Cannot load 55b2219a-7bb9-4644-9612-980dada84e83 plugin=rovim_openstack: "
 515             "Error writing file config_1234",
 516         )
 517         self.monitor.db.get_one.assert_called_once_with(
 518             db_vim_collection, {"_id": target_id}
 519         )
 520         self.monitor.db.encrypt_decrypt_fields.assert_called_once_with(
 521             sample_vim,
 522             "decrypt",
 523             fields=("password", "secret"),
 524             schema_version="1.11",
 525             salt=target_id,
 526         )
 527         mock_vim_config.assert_called_once_with(target_id, sample_vim)
 528         check_if_assert_not_called([mock_load_plugin, mock_target_vim])
 529
 530     @patch("osm_ng_ro.monitor.MonitorVms._process_vim_config")
 531     @patch("osm_ng_ro.monitor.MonitorVms._load_plugin")
 532     @patch("osm_ng_ro.monitor.MonitorVms._initialize_target_vim")
 533     def test_load_vim_load_plugin_raises(
 534         self, mock_target_vim, mock_load_plugin, mock_vim_config
 535     ):
 536         self.monitor.my_vims = {}
 537         sample_vim["schema_version"] = "1.11"
 538         self.monitor.db.get_one.return_value = sample_vim
 539         mock_load_plugin.side_effect = MonitorVimException(
 540             "Cannot load plugin osm_rovim_openstack"
 541         )
 542         with self.assertRaises(MonitorVimException) as err:
 543             self.monitor._load_vim(target_id)
 544         self.assertEqual(
 545             str(err.exception),
 546             "Cannot load 55b2219a-7bb9-4644-9612-980dada84e83 plugin=rovim_openstack: "
 547             "Cannot load plugin osm_rovim_openstack",
 548         )
 549         self.monitor.db.get_one.assert_called_once_with(
 550             db_vim_collection, {"_id": target_id}
 551         )
 552         self.monitor.db.encrypt_decrypt_fields.assert_called_once_with(
 553             sample_vim,
 554             "decrypt",
 555             fields=("password", "secret"),
 556             schema_version="1.11",
 557             salt=target_id,
 558         )
 559         mock_vim_config.assert_called_once_with(target_id, sample_vim)
 560         mock_load_plugin.assert_called_once_with(plugin_name)
 561         mock_target_vim.assert_not_called()
 562
 563     @patch("osm_ng_ro.monitor.MonitorVms._process_vim_config")
 564     @patch("osm_ng_ro.monitor.MonitorVms._load_plugin")
 565     @patch("osm_ng_ro.monitor.MonitorVms._initialize_target_vim")
 566     def test_load_vim_initialize_target_vim_raises(
 567         self, mock_target_vim, mock_load_plugin, mock_vim_config
 568     ):
 569         self.monitor.my_vims = {}
 570         self.monitor.db.get_one.return_value = sample_vim
 571         sample_vim["schema_version"] = "1.0"
 572         mock_load_plugin.return_value = VimConnector
 573         mock_target_vim.side_effect = TypeError("'module' object is not callable")
 574         with self.assertRaises(MonitorVimException) as err:
 575             self.monitor._load_vim(target_id)
 576         self.assertEqual(
 577             str(err.exception),
 578             "Cannot load 55b2219a-7bb9-4644-9612-980dada84e83 plugin=rovim_openstack: "
 579             "'module' object is not callable",
 580         )
 581         self.monitor.db.get_one.assert_called_once_with(
 582             db_vim_collection, {"_id": target_id}
 583         )
 584         self.monitor.db.encrypt_decrypt_fields.assert_called_once_with(
 585             sample_vim,
 586             "decrypt",
 587             fields=("password", "secret"),
 588             schema_version="1.0",
 589             salt=target_id,
 590         )
 591         mock_vim_config.assert_called_once_with(target_id, sample_vim)
 592         mock_load_plugin.assert_called_once_with(plugin_name)
 593         mock_target_vim.assert_called_once_with(VimConnector, sample_vim)
 594
 595     @patch("osm_ng_ro.monitor.makedirs")
 596     @patch("osm_ng_ro.monitor.path")
 597     @patch("builtins.open", new_callable=mock_open())
 598     def test_process_vim_config_vim_without_config(
 599         self, mock_open, mock_path, mock_makedirs
 600     ):
 601         db_vim = {}
 602         self.monitor._process_vim_config(target_id, db_vim)
 603         check_if_assert_not_called([mock_open, mock_path.isdir, mock_makedirs])
 604
 605     @patch("osm_ng_ro.monitor.random")
 606     @patch("osm_ng_ro.monitor.makedirs")
 607     @patch("osm_ng_ro.monitor.path")
 608     @patch("builtins.open", new_callable=mock_open())
 609     def test_process_vim_config_vim_with_ca_cert(
 610         self, mock_open, mock_path, mock_makedirs, mock_random
 611     ):
 612         db_vim = {"config": {"ca_cert_content": "my_vim_cert"}}
 613         mock_path.isdir.return_value = False
 614         mock_random.randint.return_value = 23242
 615         self.monitor._process_vim_config(target_id, db_vim)
 616         self.assertEqual(db_vim["config"].get("ca_cert_content"), None)
 617         self.assertEqual(
 618             db_vim["config"].get("ca_cert"),
 619             db_vim_cacert,
 620         )
 621         mock_path.isdir.asssert_called_once_with(file_name)
 622         mock_makedirs.assert_called_once_with(file_name)
 623         mock_random.randint.assert_called_once()
 624         mock_open.assert_called_once_with(file_name + "/ca_cert", "w")
 625
 626     @patch("osm_ng_ro.monitor.random")
 627     @patch("osm_ng_ro.monitor.makedirs")
 628     @patch("osm_ng_ro.monitor.path")
 629     @patch("builtins.open", new_callable=mock_open())
 630     def test_process_vim_config_vim_with_cacert_path_is_dir(
 631         self, mock_open, mock_path, mock_makedirs, mock_random
 632     ):
 633         db_vim = {"config": {"ca_cert_content": "my_vim_cert"}}
 634         mock_path.isdir.return_value = True
 635         mock_random.randint.return_value = 23242
 636         self.monitor._process_vim_config(target_id, db_vim)
 637         self.assertEqual(db_vim["config"].get("ca_cert_content"), None)
 638         self.assertEqual(
 639             db_vim["config"].get("ca_cert"),
 640             db_vim_cacert,
 641         )
 642         mock_path.isdir.asssert_called_once_with(file_name)
 643         mock_makedirs.assert_not_called()
 644         mock_random.randint.assert_called_once()
 645         mock_open.assert_called_once_with(file_name + "/ca_cert", "w")
 646
 647     @patch("osm_ng_ro.monitor.random")
 648     @patch("osm_ng_ro.monitor.makedirs")
 649     @patch("osm_ng_ro.monitor.path")
 650     @patch("builtins.open", new_callable=mock_open())
 651     def test_process_vim_config_vim_with_cacert_makedir_raises(
 652         self, mock_open, mock_path, mock_makedirs, mock_random
 653     ):
 654         db_vim = {"config": {"ca_cert_content": "my_vim_cert"}}
 655         mock_path.isdir.return_value = False
 656         mock_random.randint.return_value = 23242
 657         mock_makedirs.side_effect = OSError("Can not create directory")
 658         with self.assertRaises(MonitorVimException) as err:
 659             self.monitor._process_vim_config(target_id, db_vim)
 660         self.assertEqual(
 661             str(err.exception),
 662             "Error writing to file '/app/osm_ro/certs/55b2219a-7bb9-4644-9612-980dada84e83:23242': "
 663             "Can not create directory",
 664         )
 665         self.assertEqual(db_vim["config"].get("ca_cert_content"), "my_vim_cert")
 666         self.assertEqual(db_vim["config"].get("ca_cert"), None)
 667         mock_path.isdir.asssert_called_once_with(file_name)
 668         mock_makedirs.assert_called_once_with(file_name)
 669         mock_random.randint.assert_called_once()
 670         mock_open.assert_not_called()
 671
 672     @patch("osm_ng_ro.monitor.random")
 673     @patch("osm_ng_ro.monitor.makedirs")
 674     @patch("osm_ng_ro.monitor.path")
 675     @patch("builtins.open", new_callable=mock_open())
 676     def test_process_vim_config_vim_with_cacert_mock_open_raises(
 677         self, mock_open, mock_path, mock_makedirs, mock_random
 678     ):
 679         db_vim = {"config": {"ca_cert_content": "my_vim_cert"}}
 680         mock_path.isdir.return_value = False
 681         mock_random.randint.return_value = 23242
 682         mock_open.side_effect = FileNotFoundError("File is not found.")
 683         with self.assertRaises(MonitorVimException) as err:
 684             self.monitor._process_vim_config(target_id, db_vim)
 685         self.assertEqual(
 686             str(err.exception),
 687             "Error writing to file '/app/osm_ro/certs/55b2219a-7bb9-4644-9612-980dada84e83:23242/ca_cert': "
 688             "File is not found.",
 689         )
 690         self.assertEqual(db_vim["config"].get("ca_cert_content"), "my_vim_cert")
 691         self.assertEqual(db_vim["config"].get("ca_cert"), None)
 692         mock_path.isdir.asssert_called_once_with(file_name)
 693         mock_makedirs.assert_called_once_with(file_name)
 694         mock_random.randint.assert_called_once()
 695         mock_open.assert_called_once_with(file_name + "/ca_cert", "w")
 696
 697     @patch("osm_ng_ro.monitor.random")
 698     @patch("osm_ng_ro.monitor.makedirs")
 699     @patch("osm_ng_ro.monitor.path")
 700     @patch("builtins.open", new_callable=mock_open())
 701     def test_process_vim_config_vim_without_cacert(
 702         self, mock_open, mock_path, mock_makedirs, mock_random
 703     ):
 704         db_vim = {"config": {}}
 705         self.monitor._process_vim_config(target_id, db_vim)
 706         self.assertEqual(db_vim["config"].get("ca_cert"), None)
 707         check_if_assert_not_called(
 708             [mock_path.isdir, mock_makedirs, mock_random.randint, mock_open]
 709         )
 710
 711     @patch("osm_ng_ro.monitor.entry_points")
 712     def test_load_plugin_name_exists(self, mock_entry_points):
 713         self.monitor.plugins = {plugin_name: VimConnector}
 714         result = self.monitor._load_plugin(plugin_name)
 715         mock_entry_points.assert_not_called()
 716         self.assertEqual(self.monitor.plugins, {plugin_name: VimConnector})
 717         self.assertEqual(result, VimConnector)
 718
 719     @patch("osm_ng_ro.monitor.entry_points")
 720     def test_load_plugin_name_does_not_exist(self, mock_entry_points):
 721         self.monitor.plugins = {}
 722         mock_ep = MagicMock()
 723         mock_ep.load.return_value = sample_vim_connector_instance
 724         mock_entry_points.return_value = [mock_ep]
 725         result = self.monitor._load_plugin(plugin_name)
 726         self.assertEqual(mock_entry_points.call_count, 1)
 727         mock_entry_points.assert_called_once_with(
 728             group="osm_rovim.plugins", name=plugin_name
 729         )
 730         self.assertEqual(
 731             self.monitor.plugins, {plugin_name: sample_vim_connector_instance}
 732         )
 733         self.assertEqual(result, sample_vim_connector_instance)
 734
 735     @patch("osm_ng_ro.monitor.entry_points")
 736     def test_load_plugin_load_raises(self, mock_entry_points):
 737         self.monitor.plugins = {}
 738         mock_entry_points.return_value = None
 739         with self.assertRaises(MonitorVimException) as err:
 740             self.monitor._load_plugin(plugin_name)
 741         self.assertEqual(
 742             str(err.exception),
 743             "Cannot load plugin osm_rovim_openstack: 'NoneType' object is not iterable",
 744         )
 745         self.assertEqual(mock_entry_points.call_count, 1)
 746         mock_entry_points.assert_called_once_with(
 747             group="osm_rovim.plugins", name=plugin_name
 748         )
 749         self.assertEqual(self.monitor.plugins, {})
 750
 751     @patch("osm_ng_ro.monitor.VmToMonitor")
 752     def test_create_vm_to_monitor_empty_ro_task(self, mock_vm_to_monitor):
 753         ro_task = {}
 754         result = self.monitor.create_vm_to_monitor(ro_task)
 755         self.assertEqual(result, None)
 756         mock_vm_to_monitor.assert_not_called()
 757
 758     @patch("osm_ng_ro.monitor.VmToMonitor")
 759     def test_create_vm_to_monitor(self, mock_vm_to_monitor):
 760         sample_vm = VmToMonitor("sample_id", "sample_target_record")
 761         mock_vm_to_monitor.return_value = sample_vm
 762         result = self.monitor.create_vm_to_monitor(ro_task1)
 763         self.assertEqual(result, sample_vm)
 764         mock_vm_to_monitor.assert_called_once_with(
 765             "ebd39f37-e607-4bce-9f10-ea4c5635f726", target_record
 766         )
 767
 768     @patch("osm_ng_ro.monitor.VmToMonitor")
 769     def test_create_vm_to_monitor_wrong_ro_task_format(self, mock_vm_to_monitor):
 770         mock_vm_to_monitor.return_value = "VmtoMonitor"
 771         with self.assertRaises(KeyError) as err:
 772             self.monitor.create_vm_to_monitor(wrong_ro_task)
 773         self.assertEqual(str(err.exception.args[0]), "vim_info")
 774         mock_vm_to_monitor.assert_not_called()
 775
 776     @patch("osm_ng_ro.monitor.MonitorVms.create_vm_to_monitor")
 777     def test_add_vm_to_existing_vim(self, mock_create_vm_to_monitor):
 778         sample_vim1 = VimToMonitor(vim1_id, [vm1_id])
 779         vims_to_monitor = [sample_vim1]
 780         result = self.monitor.add_vm_to_existing_vim(vims_to_monitor, ro_task2, vim1_id)
 781         self.assertEqual(result, True)
 782         mock_create_vm_to_monitor.assert_called_once_with(ro_task2)
 783         self.assertEqual(2, len(sample_vim1.vms))
 784
 785     @patch("osm_ng_ro.monitor.MonitorVms.create_vm_to_monitor")
 786     def test_add_vm_to_existing_vim_empty_vims_list(self, mock_create_vm_to_monitor):
 787         vims_to_monitor = []
 788         result = self.monitor.add_vm_to_existing_vim(vims_to_monitor, ro_task1, vim1_id)
 789         self.assertEqual(result, False)
 790         mock_create_vm_to_monitor.assert_not_called()
 791
 792     @patch("osm_ng_ro.monitor.MonitorVms.create_vm_to_monitor")
 793     def test_add_vm_to_existing_vim_different_target_vim_id(
 794         self, mock_create_vm_to_monitor
 795     ):
 796         sample_vim1 = VimToMonitor(vim1_id, [vm1_id])
 797         vims_to_monitor = [sample_vim1]
 798         result = self.monitor.add_vm_to_existing_vim(vims_to_monitor, ro_task2, vim2_id)
 799         self.assertEqual(result, False)
 800         mock_create_vm_to_monitor.assert_not_called()
 801         self.assertEqual(1, len(sample_vim1.vms))
 802
 803     @patch("osm_ng_ro.monitor.MonitorVms.create_vm_to_monitor")
 804     def test_add_vm_to_existing_vim_create_vm_to_monitor_raises(
 805         self, mock_create_vm_to_monitor
 806     ):
 807         sample_vim1 = VimToMonitor(vim1_id, [vm1_id])
 808         vims_to_monitor = [sample_vim1]
 809         mock_create_vm_to_monitor.side_effect = KeyError(
 810             "target_record does not exist."
 811         )
 812         with self.assertRaises(KeyError) as err:
 813             self.monitor.add_vm_to_existing_vim(vims_to_monitor, ro_task2, vim1_id)
 814         self.assertEqual(str(err.exception.args[0]), "target_record does not exist.")
 815         mock_create_vm_to_monitor.assert_called_once_with(ro_task2)
 816         self.assertEqual(1, len(sample_vim1.vms))
 817
 818     @patch("osm_ng_ro.monitor.MonitorVms.create_vm_to_monitor")
 819     @patch("osm_ng_ro.monitor.VimToMonitor")
 820     def test_add_new_vim_for_monitoring(
 821         self, mock_vim_to_monitor, mock_create_vm_to_monitor
 822     ):
 823         sample_vim = VimToMonitor(vim1_id, [])
 824         mock_vim_to_monitor.return_value = sample_vim
 825         self.monitor.add_new_vim_for_monitoring(vims_to_monitor, ro_task1, vim1_id)
 826         mock_vim_to_monitor.assert_called_once_with(vim1_id, [])
 827         mock_create_vm_to_monitor.assert_called_once_with(ro_task1)
 828         self.assertEqual(len(sample_vim.vms), 1)
 829         self.assertEqual(len(vims_to_monitor), 1)
 830
 831     @patch("osm_ng_ro.monitor.MonitorVms.create_vm_to_monitor")
 832     @patch("osm_ng_ro.monitor.VimToMonitor")
 833     def test_add_new_vim_for_monitoring_vim_to_monitor_raises(
 834         self, mock_vim_to_monitor, mock_create_vm_to_monitor
 835     ):
 836         vims_to_monitor = []
 837         mock_vim_to_monitor.side_effect = TypeError(
 838             "Missing required positional arguments"
 839         )
 840         with self.assertRaises(TypeError) as err:
 841             self.monitor.add_new_vim_for_monitoring(vims_to_monitor, ro_task1, None)
 842         self.assertEqual(
 843             str(err.exception.args[0]), "Missing required positional arguments"
 844         )
 845         mock_vim_to_monitor.assert_called_once_with(None, [])
 846         mock_create_vm_to_monitor.assert_not_called()
 847         self.assertEqual(len(vims_to_monitor), 0)
 848
 849     @patch("osm_ng_ro.monitor.MonitorVms.create_vm_to_monitor")
 850     @patch("osm_ng_ro.monitor.VimToMonitor")
 851     def test_add_new_vim_for_monitoring_create_vm_to_monitor_raises(
 852         self, mock_vim_to_monitor, mock_create_vm_to_monitor
 853     ):
 854         vims_to_monitor = []
 855         mock_create_vm_to_monitor.side_effect = KeyError("target_record is not found.")
 856         with self.assertRaises(KeyError) as err:
 857             self.monitor.add_new_vim_for_monitoring(vims_to_monitor, ro_task1, vim1_id)
 858         self.assertEqual(str(err.exception.args[0]), "target_record is not found.")
 859         mock_vim_to_monitor.assert_called_once_with(vim1_id, [])
 860         mock_create_vm_to_monitor.assert_called_once_with(ro_task1)
 861         self.assertEqual(len(vims_to_monitor), 0)
 862
 863     @patch("osm_ng_ro.monitor.MonitorVms.add_vm_to_existing_vim")
 864     @patch("osm_ng_ro.monitor.MonitorVms.add_new_vim_for_monitoring")
 865     def test_prepare_vims_to_monitor_no_proper_existing_vim(
 866         self, mock_add_new_vim_for_monitoring, mock_add_vm_to_existing_vim
 867     ):
 868         mock_add_vm_to_existing_vim.return_value = False
 869         self.monitor.prepare_vims_to_monitor(vims_to_monitor, ro_task1, vim1_id)
 870         mock_add_vm_to_existing_vim.assert_called_once_with(
 871             vims_to_monitor, ro_task1, vim1_id
 872         )
 873         mock_add_new_vim_for_monitoring.assert_called_once_with(
 874             vims_to_monitor, ro_task1, vim1_id
 875         )
 876
 877     @patch("osm_ng_ro.monitor.MonitorVms.add_vm_to_existing_vim")
 878     @patch("osm_ng_ro.monitor.MonitorVms.add_new_vim_for_monitoring")
 879     def test_prepare_vims_to_monitor_proper_existing_vim(
 880         self, mock_add_new_vim_for_monitoring, mock_add_vm_to_existing_vim
 881     ):
 882         mock_add_vm_to_existing_vim.return_value = True
 883         self.monitor.prepare_vims_to_monitor(vims_to_monitor, ro_task1, vim1_id)
 884         mock_add_vm_to_existing_vim.assert_called_once_with(
 885             vims_to_monitor, ro_task1, vim1_id
 886         )
 887         mock_add_new_vim_for_monitoring.assert_not_called()
 888
 889     @patch("osm_ng_ro.monitor.MonitorVms.add_vm_to_existing_vim")
 890     @patch("osm_ng_ro.monitor.MonitorVms.add_new_vim_for_monitoring")
 891     def test_prepare_vims_to_monitor_add_vm_to_existing_vim_raises(
 892         self, mock_add_new_vim_for_monitoring, mock_add_vm_to_existing_vim
 893     ):
 894         mock_add_vm_to_existing_vim.side_effect = KeyError(
 895             "target_record is not found."
 896         )
 897         with self.assertRaises(KeyError) as err:
 898             self.monitor.prepare_vims_to_monitor(vims_to_monitor, ro_task1, vim1_id)
 899         self.assertEqual(str(err.exception.args[0]), "target_record is not found.")
 900         mock_add_vm_to_existing_vim.assert_called_once_with(
 901             vims_to_monitor, ro_task1, vim1_id
 902         )
 903         mock_add_new_vim_for_monitoring.assert_not_called()
 904
 905     @patch("osm_ng_ro.monitor.MonitorVms.add_vm_to_existing_vim")
 906     @patch("osm_ng_ro.monitor.MonitorVms.add_new_vim_for_monitoring")
 907     def test_prepare_vims_to_monitor_add_new_vim_for_monitoring_raises(
 908         self, mock_add_new_vim_for_monitoring, mock_add_vm_to_existing_vim
 909     ):
 910         mock_add_vm_to_existing_vim.return_value = False
 911         mock_add_new_vim_for_monitoring.side_effect = KeyError(
 912             "target_record is not found."
 913         )
 914         with self.assertRaises(KeyError) as err:
 915             self.monitor.prepare_vims_to_monitor(vims_to_monitor, ro_task1, vim1_id)
 916         self.assertEqual(str(err.exception.args[0]), "target_record is not found.")
 917         mock_add_vm_to_existing_vim.assert_called_once_with(
 918             vims_to_monitor, ro_task1, vim1_id
 919         )
 920         mock_add_new_vim_for_monitoring.assert_called_once_with(
 921             vims_to_monitor, ro_task1, vim1_id
 922         )
 923
 924     def test_get_db_paths(self):
 925         self.monitor.db.get_one.return_value = sample_vnfr
 926         (
 927             vim_info_path,
 928             vim_id,
 929             vnfr_id,
 930             vdur_path,
 931             vdur_index,
 932             db_vnfr,
 933         ) = self.monitor._get_db_paths(target_record)
 934         self.assertEqual(
 935             vim_info_path, "vdur.0.vim_info.vim:f239ed93-756b-408e-89f8-fcbf47a9d8f7"
 936         )
 937         self.assertEqual(vim_id, vim4_id)
 938         self.assertEqual(vdur_path, "vdur.0")
 939         self.assertEqual(vdur_index, 0)
 940         self.assertEqual(vnfr_id, vnfr_id)
 941         self.assertDictEqual(db_vnfr, sample_vnfr)
 942         self.monitor.db.get_one.assert_called_once_with(
 943             "vnfrs",
 944             {"_id": vnfr_id},
 945             fail_on_empty=False,
 946         )
 947
 948     def test_get_db_paths_empty_vnfr(self):
 949         self.monitor.db.get_one.return_value = None
 950         (
 951             vim_info_path,
 952             vim_id,
 953             vnfr_id,
 954             vdur_path,
 955             vdur_index,
 956             db_vnfr,
 957         ) = self.monitor._get_db_paths(target_record)
 958         self.assertEqual(
 959             vim_info_path, "vdur.0.vim_info.vim:f239ed93-756b-408e-89f8-fcbf47a9d8f7"
 960         )
 961         self.assertEqual(vim_id, vim4_id)
 962         self.assertEqual(vdur_path, "vdur.0")
 963         self.assertEqual(vdur_index, 0)
 964         self.assertEqual(vnfr_id, vnfr_id)
 965         self.assertEqual(db_vnfr, None)
 966         self.monitor.db.get_one.assert_called_once_with(
 967             "vnfrs",
 968             {"_id": vnfr_id},
 969             fail_on_empty=False,
 970         )
 971
 972     def test_get_db_paths_invalid_target_record(self):
 973         invalid_target_record = "vnfrs:35c034cc-8c5b-48c4-bfa2-17a71577ef19:f239ed93-756b-408e-89f8-fcbf47a9d8f7"
 974         with self.assertRaises(MonitorVmsException) as err:
 975             self.monitor._get_db_paths(invalid_target_record)
 976         self.assertEqual(
 977             str(err.exception.args[0]),
 978             "not enough values to unpack (expected 4, got 3)",
 979         )
 980         self.monitor.db.get_one.assert_not_called()
 981
 982     def test_get_db_paths_db_raises(self):
 983         self.monitor.db.get_one.side_effect = DbException("Connection Failed.")
 984         with self.assertRaises(MonitorVmsException) as err:
 985             self.monitor._get_db_paths(target_record)
 986         self.assertEqual(
 987             str(err.exception.args[0]), "database exception Connection Failed."
 988         )
 989         self.monitor.db.get_one.assert_called_once_with(
 990             "vnfrs",
 991             {"_id": vnfr_id},
 992             fail_on_empty=False,
 993         )
 994
 995     def test_check_if_vdur_vim_info_exists(self):
 996         vdur_index = 0
 997         result = self.monitor._check_if_vdur_vim_info_exists(sample_vnfr, vdur_index)
 998         self.assertEqual(result, True)
 999
1000     def test_check_if_vdur_vim_info_exists_wrong_vdur_index(self):
1001         vdur_index = 3
1002         result = self.monitor._check_if_vdur_vim_info_exists(sample_vnfr, vdur_index)
1003         self.assertEqual(result, None)
1004
1005     def test_check_if_vdur_vim_info_exists_empty_vnfr(self):
1006         vdur_index = 2
1007         result = self.monitor._check_if_vdur_vim_info_exists({}, vdur_index)
1008         self.assertEqual(result, None)
1009
1010     def test_check_if_vdur_vim_info_exists_str_vdur_index(self):
1011         vdur_index = "2"
1012         result = self.monitor._check_if_vdur_vim_info_exists({}, vdur_index)
1013         self.assertEqual(result, None)
1014
1015     def test_check_if_vdur_vim_info_exists_none_vnfr(self):
1016         vdur_index = 2
1017         result = self.monitor._check_if_vdur_vim_info_exists(None, vdur_index)
1018         self.assertEqual(result, None)
1019
1020     @patch("osm_ng_ro.monitor.MonitorVms._get_db_paths")
1021     @patch("osm_ng_ro.monitor.MonitorVms._check_if_vdur_vim_info_exists")
1022     @patch("osm_ng_ro.monitor.deepcopy")
1023     def test_get_vm_data_from_db(
1024         self, mock_deepcopy, mock_vim_info_exists, mock_get_db_paths
1025     ):
1026         vim_id = vim4_id
1027         vdur_index = 0
1028         db_vnfr = sample_vnfr
1029         mock_get_db_paths.return_value = (
1030             vim_info_path,
1031             vim_id,
1032             vnfr_id,
1033             vdur_path,
1034             vdur_index,
1035             db_vnfr,
1036         )
1037         mock_vim_info_exists.return_value = True
1038         mock_deepcopy.return_value = sample_vim_info
1039         (
1040             vdur_path_result,
1041             vdur_vim_info_update_result,
1042             db_vnfr_result,
1043             existing_vim_info_result,
1044             vnfr_id_result,
1045             vim_info_path_result,
1046         ) = self.monitor._get_vm_data_from_db(sample_vm)
1047         self.assertEqual(vdur_path_result, vdur_path)
1048         self.assertEqual(vdur_vim_info_update_result, sample_vim_info)
1049         self.assertEqual(db_vnfr_result, db_vnfr)
1050         self.assertEqual(existing_vim_info_result, sample_vim_info)
1051         self.assertEqual(vnfr_id_result, vnfr_id)
1052         self.assertEqual(vim_info_path_result, vim_info_path)
1053         mock_deepcopy.assert_called_once_with(sample_vim_info)
1054         mock_get_db_paths.assert_called_once_with(target_record)
1055         mock_vim_info_exists.assert_called_once_with(db_vnfr, vdur_index)
1056
1057     @patch("osm_ng_ro.monitor.MonitorVms._get_db_paths")
1058     @patch("osm_ng_ro.monitor.MonitorVms._check_if_vdur_vim_info_exists")
1059     @patch("osm_ng_ro.monitor.deepcopy")
1060     def test_get_vm_data_from_db_no_vim_info(
1061         self, mock_deepcopy, mock_vim_info_exists, mock_get_db_paths
1062     ):
1063         vim_id = vim4_id
1064         vdur_index = 0
1065         db_vnfr = sample_vnfr
1066         mock_get_db_paths.return_value = (
1067             vim_info_path,
1068             vim_id,
1069             vnfr_id,
1070             vdur_path,
1071             vdur_index,
1072             db_vnfr,
1073         )
1074         mock_vim_info_exists.return_value = False
1075         result = self.monitor._get_vm_data_from_db(sample_vm)
1076         self.assertEqual(result, None)
1077         mock_deepcopy.assert_not_called()
1078         mock_get_db_paths.assert_called_once_with(target_record)
1079         mock_vim_info_exists.assert_called_once_with(db_vnfr, vdur_index)
1080
1081     @patch("osm_ng_ro.monitor.MonitorVms._get_db_paths")
1082     @patch("osm_ng_ro.monitor.MonitorVms._check_if_vdur_vim_info_exists")
1083     @patch("osm_ng_ro.monitor.deepcopy")
1084     def test_get_vm_data_from_db_get_db_path_raises(
1085         self, mock_deepcopy, mock_vim_info_exists, mock_get_db_paths
1086     ):
1087         mock_get_db_paths.side_effect = DbException("Connection failed.")
1088         with self.assertRaises(DbException) as err:
1089             self.monitor._get_vm_data_from_db(sample_vm)
1090         self.assertEqual(
1091             str(err.exception.args[0]), "database exception Connection failed."
1092         )
1093         mock_get_db_paths.assert_called_once_with(target_record)
1094         check_if_assert_not_called([mock_deepcopy, mock_vim_info_exists])
1095
1096     @patch("osm_ng_ro.monitor.MonitorVms._get_db_paths")
1097     @patch("osm_ng_ro.monitor.MonitorVms._check_if_vdur_vim_info_exists")
1098     @patch("osm_ng_ro.monitor.deepcopy")
1099     def test_get_vm_data_from_db_vnfr_without_correct_vdur_index(
1100         self, mock_deepcopy, mock_vim_info_exists, mock_get_db_paths
1101     ):
1102         vim_id = vim4_id
1103         vdur_index = 2
1104         db_vnfr = sample_vnfr
1105         mock_get_db_paths.return_value = (
1106             vim_info_path,
1107             vim_id,
1108             vnfr_id,
1109             vdur_path,
1110             vdur_index,
1111             db_vnfr,
1112         )
1113         mock_vim_info_exists.return_value = True
1114         with self.assertRaises(IndexError) as err:
1115             self.monitor._get_vm_data_from_db(sample_vm)
1116         self.assertEqual(str(err.exception.args[0]), "list index out of range")
1117         mock_deepcopy.assert_not_called()
1118         mock_get_db_paths.assert_called_once_with(target_record)
1119         mock_vim_info_exists.assert_called_once_with(db_vnfr, vdur_index)
1120
1121     @patch("osm_ng_ro.monitor.MonitorVms._get_db_paths")
1122     @patch("osm_ng_ro.monitor.MonitorVms._check_if_vdur_vim_info_exists")
1123     @patch("osm_ng_ro.monitor.deepcopy")
1124     def test_get_vm_data_from_db_vnfr_without_proper_vim_id(
1125         self, mock_deepcopy, mock_vim_info_exists, mock_get_db_paths
1126     ):
1127         vim_id = "5239ed93-756b-408e-89f8-fcbf47a9d8f7"
1128         vdur_index = 0
1129         db_vnfr = sample_vnfr
1130         mock_get_db_paths.return_value = (
1131             vim_info_path,
1132             vim_id,
1133             vnfr_id,
1134             vdur_path,
1135             vdur_index,
1136             db_vnfr,
1137         )
1138         mock_vim_info_exists.return_value = True
1139         self.monitor._get_vm_data_from_db(sample_vm)
1140         mock_deepcopy.assert_not_called()
1141         mock_get_db_paths.assert_called_once_with(target_record)
1142         mock_vim_info_exists.assert_called_once_with(db_vnfr, vdur_index)
1143
1144     def test_update_vim_info_for_deleted_vm_empty_input_dict(self):
1145         vdur_vim_info_update = {}
1146         self.monitor.update_vim_info_for_deleted_vm(vdur_vim_info_update)
1147         self.assertEqual(
1148             vdur_vim_info_update,
1149             deleted_externally,
1150         )
1151
1152     def test_update_vim_info_for_deleted_vm_update_existing_info(self):
1153         vdur_vim_info_update = {
1154             "vim_status": "ACTIVE",
1155             "vim_message": None,
1156             "vim_details": None,
1157             "vim_id": vm1_id,
1158             "vim_name": "test7-vnf-hackfest_basic-VM-000000",
1159         }
1160         self.monitor.update_vim_info_for_deleted_vm(vdur_vim_info_update)
1161         self.assertEqual(
1162             vdur_vim_info_update,
1163             deleted_externally,
1164         )
1165
1166     @patch("osm_ng_ro.monitor.MonitorVms._get_vm_data_from_db")
1167     @patch("osm_ng_ro.monitor.MonitorVms.update_vim_info_for_deleted_vm")
1168     @patch("osm_ng_ro.monitor.MonitorVms.backup_vdu_interfaces")
1169     @patch("osm_ng_ro.monitor.MonitorVms.update_in_database")
1170     def test_report_deleted_vdur_no_vm_data_in_db(
1171         self,
1172         mock_update_in_database,
1173         mock_backup_vdu_interfaces,
1174         mock_update_vim_info_for_deleted_vm,
1175         mock_get_vm_data_from_db,
1176     ):
1177         mock_get_vm_data_from_db.return_value = None
1178         self.monitor.report_deleted_vdur(sample_vm)
1179         self.assertEqual(mock_get_vm_data_from_db.call_count, 1)
1180         check_if_assert_not_called(
1181             [
1182                 mock_update_in_database,
1183                 mock_backup_vdu_interfaces,
1184                 mock_update_vim_info_for_deleted_vm,
1185             ]
1186         )
1187
1188     @patch("osm_ng_ro.monitor.MonitorVms._get_vm_data_from_db")
1189     @patch("osm_ng_ro.monitor.MonitorVms.update_vim_info_for_deleted_vm")
1190     @patch("osm_ng_ro.monitor.MonitorVms.backup_vdu_interfaces")
1191     @patch("osm_ng_ro.monitor.MonitorVms.update_in_database")
1192     def test_report_deleted_vdur(
1193         self,
1194         mock_update_in_database,
1195         mock_backup_vdu_interfaces,
1196         mock_update_vim_info_for_deleted_vm,
1197         mock_get_vm_data_from_db,
1198     ):
1199         existing_vim_info = sample_vim_info
1200         vdur_vim_info_update = deleted_externally
1201         mock_get_vm_data_from_db.return_value = (
1202             vdur_path,
1203             vdur_vim_info_update,
1204             None,
1205             existing_vim_info,
1206             vnfr_id,
1207             vim_info_path,
1208         )
1209         vdur_update = {
1210             vdur_path + ".status": "DELETED",
1211         }
1212         self.monitor.report_deleted_vdur(sample_vm)
1213         self.assertEqual(mock_get_vm_data_from_db.call_count, 1)
1214         mock_get_vm_data_from_db.assert_called_with(sample_vm)
1215         mock_update_vim_info_for_deleted_vm.assert_called_once_with(
1216             vdur_vim_info_update
1217         )
1218         mock_backup_vdu_interfaces.assert_called_once_with(vdur_vim_info_update)
1219         mock_update_in_database.assert_called_once_with(
1220             [vdur_update, {vim_info_path: vdur_vim_info_update}], vnfr_id
1221         )
1222
1223     @patch("osm_ng_ro.monitor.MonitorVms._get_vm_data_from_db")
1224     @patch("osm_ng_ro.monitor.MonitorVms.update_vim_info_for_deleted_vm")
1225     @patch("osm_ng_ro.monitor.MonitorVms.backup_vdu_interfaces")
1226     @patch("osm_ng_ro.monitor.MonitorVms.update_in_database")
1227     def test_report_deleted_vdur_vm_db_already_updated(
1228         self,
1229         mock_update_in_database,
1230         mock_backup_vdu_interfaces,
1231         mock_update_vim_info_for_deleted_vm,
1232         mock_get_vm_data_from_db,
1233     ):
1234         vdur_vim_info_update = existing_vim_info = deleted_externally
1235         mock_get_vm_data_from_db.return_value = (
1236             vdur_path,
1237             vdur_vim_info_update,
1238             None,
1239             existing_vim_info,
1240             vnfr_id,
1241             vim_info_path,
1242         )
1243         self.monitor.report_deleted_vdur(sample_vm)
1244         self.assertEqual(mock_get_vm_data_from_db.call_count, 1)
1245         mock_get_vm_data_from_db.assert_called_with(sample_vm)
1246         mock_update_vim_info_for_deleted_vm.assert_called_once_with(
1247             vdur_vim_info_update
1248         )
1249         check_if_assert_not_called(
1250             [mock_backup_vdu_interfaces, mock_update_in_database]
1251         )
1252
1253     @patch("osm_ng_ro.monitor.MonitorVms._get_vm_data_from_db")
1254     @patch("osm_ng_ro.monitor.MonitorVms.update_vim_info_for_deleted_vm")
1255     @patch("osm_ng_ro.monitor.MonitorVms.backup_vdu_interfaces")
1256     @patch("osm_ng_ro.monitor.MonitorVms.update_in_database")
1257     def test_report_deleted_vdur_get_vm_data_raises(
1258         self,
1259         mock_update_in_database,
1260         mock_backup_vdu_interfaces,
1261         mock_update_vim_info_for_deleted_vm,
1262         mock_get_vm_data_from_db,
1263     ):
1264         mock_get_vm_data_from_db.side_effect = IndexError("list index out of range.")
1265         with self.assertRaises(IndexError) as err:
1266             self.monitor.report_deleted_vdur(sample_vm)
1267         self.assertEqual(str(err.exception.args[0]), "list index out of range.")
1268         self.assertEqual(mock_get_vm_data_from_db.call_count, 1)
1269         mock_get_vm_data_from_db.assert_called_with(sample_vm)
1270         check_if_assert_not_called(
1271             [
1272                 mock_update_vim_info_for_deleted_vm,
1273                 mock_backup_vdu_interfaces,
1274                 mock_update_in_database,
1275             ]
1276         )
1277
1278     @patch("osm_ng_ro.monitor.MonitorVms._get_vm_data_from_db")
1279     @patch("osm_ng_ro.monitor.MonitorVms.update_vim_info_for_deleted_vm")
1280     @patch("osm_ng_ro.monitor.MonitorVms.backup_vdu_interfaces")
1281     @patch("osm_ng_ro.monitor.MonitorVms.update_in_database")
1282     def test_report_deleted_vdur_update_in_database_raises(
1283         self,
1284         mock_update_in_database,
1285         mock_backup_vdu_interfaces,
1286         mock_update_vim_info_for_deleted_vm,
1287         mock_get_vm_data_from_db,
1288     ):
1289         existing_vim_info = sample_vim_info
1290         vdur_vim_info_update = deleted_externally
1291         mock_update_in_database.side_effect = MonitorDbException(
1292             "Error while updating differences in VNFR."
1293         )
1294         mock_get_vm_data_from_db.return_value = (
1295             vdur_path,
1296             vdur_vim_info_update,
1297             None,
1298             existing_vim_info,
1299             vnfr_id,
1300             vim_info_path,
1301         )
1302         vdur_update = {
1303             vdur_path + ".status": "DELETED",
1304         }
1305         with self.assertRaises(MonitorDbException) as err:
1306             self.monitor.report_deleted_vdur(sample_vm)
1307         self.assertEqual(
1308             str(err.exception.args[0]), "Error while updating differences in VNFR."
1309         )
1310         self.assertEqual(mock_get_vm_data_from_db.call_count, 1)
1311         mock_get_vm_data_from_db.assert_called_with(sample_vm)
1312         mock_update_vim_info_for_deleted_vm.assert_called_once_with(
1313             vdur_vim_info_update
1314         )
1315         mock_backup_vdu_interfaces.assert_called_once_with(vdur_vim_info_update)
1316         mock_update_in_database.assert_called_once_with(
1317             [vdur_update, {vim_info_path: vdur_vim_info_update}], vnfr_id
1318         )
1319
1320     @patch("osm_ng_ro.monitor.MonitorVms.report_vdur_updates")
1321     @patch("osm_ng_ro.monitor.MonitorVms.report_deleted_vdur")
1322     def test_update_vnfrs(self, mock_report_deleted_vdur, mock_report_vdur_updates):
1323         vms_to_monitor = [sample_vm, sample_vm2, sample_vm3]
1324         servers = [server1, server2, server3, server4]
1325         ports = {"ports": [port1, port2]}
1326         self.monitor.update_vnfrs(servers, ports, vms_to_monitor)
1327         self.assertEqual(mock_report_vdur_updates.call_count, 2)
1328         mock_report_deleted_vdur.assert_called_once_with(sample_vm3)
1329         _call_mock_report_vdur_updates = mock_report_vdur_updates.call_args_list
1330         self.assertEqual(
1331             _call_mock_report_vdur_updates[0].args,
1332             (server1, sample_vm, ports),
1333         )
1334         self.assertEqual(
1335             _call_mock_report_vdur_updates[1].args,
1336             (server2, sample_vm2, ports),
1337         )
1338
1339     @patch("osm_ng_ro.monitor.MonitorVms.report_vdur_updates")
1340     @patch("osm_ng_ro.monitor.MonitorVms.report_deleted_vdur")
1341     def test_update_vnfrs_empty_vms_to_monitor(
1342         self, mock_report_deleted_vdur, mock_report_vdur_updates
1343     ):
1344         vms_to_monitor = []
1345         servers = [server1, server2, server3, server4]
1346         ports = {"ports": [port1, port2]}
1347         self.monitor.update_vnfrs(servers, ports, vms_to_monitor)
1348         check_if_assert_not_called([mock_report_deleted_vdur, mock_report_vdur_updates])
1349
1350     @patch("osm_ng_ro.monitor.MonitorVms.report_vdur_updates")
1351     @patch("osm_ng_ro.monitor.MonitorVms.report_deleted_vdur")
1352     def test_update_vnfrs_empty_servers(
1353         self, mock_report_deleted_vdur, mock_report_vdur_updates
1354     ):
1355         vms_to_monitor = [sample_vm, sample_vm2, sample_vm3]
1356         servers = []
1357         ports = {"ports": [port1, port2]}
1358         self.monitor.update_vnfrs(servers, ports, vms_to_monitor)
1359         mock_report_vdur_updates.assert_not_called()
1360         self.assertEqual(mock_report_deleted_vdur.call_count, 3)
1361         _call_mock_report_deleted_vdur = mock_report_deleted_vdur.call_args_list
1362         self.assertEqual(
1363             _call_mock_report_deleted_vdur[0].args[0],
1364             (sample_vm),
1365         )
1366         self.assertEqual(
1367             _call_mock_report_deleted_vdur[1].args[0],
1368             (sample_vm2),
1369         )
1370         self.assertEqual(
1371             _call_mock_report_deleted_vdur[2].args[0],
1372             (sample_vm3),
1373         )
1374
1375     @patch("osm_ng_ro.monitor.MonitorVms.report_vdur_updates")
1376     @patch("osm_ng_ro.monitor.MonitorVms.report_deleted_vdur")
1377     def test_update_vnfrs_report_vdur_updates_raises(
1378         self, mock_report_deleted_vdur, mock_report_vdur_updates
1379     ):
1380         vms_to_monitor = [sample_vm, sample_vm2, sample_vm3]
1381         servers = [server1, server2, server3, server4]
1382         ports = {"ports": [port1, port2]}
1383         mock_report_vdur_updates.side_effect = IndexError("list index out of range.")
1384         with self.assertRaises(IndexError) as err:
1385             self.monitor.update_vnfrs(servers, ports, vms_to_monitor)
1386         self.assertEqual(str(err.exception.args[0]), "list index out of range.")
1387         self.assertEqual(mock_report_vdur_updates.call_count, 1)
1388         mock_report_deleted_vdur.assert_not_called()
1389         _call_mock_report_vdur_updates = mock_report_vdur_updates.call_args_list
1390         self.assertEqual(
1391             _call_mock_report_vdur_updates[0].args,
1392             (server1, sample_vm, ports),
1393         )
1394
1395     @patch("osm_ng_ro.monitor.MonitorVms.report_vdur_updates")
1396     @patch("osm_ng_ro.monitor.MonitorVms.report_deleted_vdur")
1397     def test_update_vnfrs_report_deleted_vdur_raises(
1398         self, mock_report_deleted_vdur, mock_report_vdur_updates
1399     ):
1400         vms_to_monitor = [sample_vm, sample_vm2, sample_vm3]
1401         servers = [server1, server2, server3, server4]
1402         ports = {"ports": [port1, port2]}
1403         mock_report_deleted_vdur.side_effect = DbException("DB is not in active state.")
1404         with self.assertRaises(DbException) as err:
1405             self.monitor.update_vnfrs(servers, ports, vms_to_monitor)
1406         self.assertEqual(
1407             str(err.exception.args[0]), "database exception DB is not in active state."
1408         )
1409         self.assertEqual(mock_report_vdur_updates.call_count, 2)
1410         mock_report_deleted_vdur.assert_called_once_with(sample_vm3)
1411         _call_mock_report_vdur_updates = mock_report_vdur_updates.call_args_list
1412         self.assertEqual(
1413             _call_mock_report_vdur_updates[0].args,
1414             (server1, sample_vm, ports),
1415         )
1416         self.assertEqual(
1417             _call_mock_report_vdur_updates[1].args,
1418             (server2, sample_vm2, ports),
1419         )
1420
1421     @patch("osm_ng_ro.monitor.yaml")
1422     def test_serialize_string_value(self, mock_yaml):
1423         value = "some string"
1424         result = self.monitor.serialize(value)
1425         mock_yaml.dump.assert_not_called()
1426         self.assertEqual(result, value)
1427
1428     @patch("osm_ng_ro.monitor.yaml")
1429     def test_serialize_list_value(self, mock_yaml):
1430         value = [
1431             {"version": 3.4},
1432             ["image", "ghcr.io/foo/mysvc"],
1433             {"MYSVC_ENV": "to_nice_yaml"},
1434         ]
1435         output = [
1436             {"version": 3.4},
1437             ["image", "ghcr.io/foo/mysvc"],
1438             {"MYSVC_ENV": "to_nice_yaml"},
1439         ]
1440         mock_yaml.dump.return_value = output
1441         result = self.monitor.serialize(value)
1442         mock_yaml.dump.assert_called_once()
1443         self.assertEqual(result, output)
1444
1445     @patch("osm_ng_ro.monitor.yaml")
1446     def test_serialize_dict_value(self, mock_yaml):
1447         value = {
1448             "version": 3.4,
1449             "MYSVC_ENV": "to_nice_yaml_to_nice_yaml_to_nice_yaml_to_nice_yaml_to_nice_yaml",
1450         }
1451         output = {
1452             "MYSVC_ENV": "to_nice_yaml_to_nice_yaml_to_nice_yaml_to_nice_yaml_to_nice_yaml",
1453             "version": 3.4,
1454         }
1455         mock_yaml.dump.return_value = output
1456         result = self.monitor.serialize(value)
1457         mock_yaml.dump.assert_called_once()
1458         self.assertEqual(result, output)
1459
1460     @patch("osm_ng_ro.monitor.yaml")
1461     def test_serialize_raise_representer_error(self, mock_yaml):
1462         value = {
1463             "name": {"firstname": str, "lastname": str},
1464             "age": int,
1465         }
1466         mock_yaml.dump.side_effect = yaml.representer.RepresenterError(
1467             "cannot represent an object"
1468         )
1469         result = self.monitor.serialize(value)
1470         mock_yaml.dump.assert_called_once()
1471         self.assertEqual(result, str(value))
1472
1473     @patch("osm_ng_ro.monitor.yaml")
1474     def test_serialize_raise_yaml_error(self, mock_yaml):
1475         value = {
1476             "name": {"firstname": str, "lastname": str},
1477             "age": int,
1478         }
1479
1480         mock_yaml.dump.side_effect = yaml.YAMLError("cannot represent an object.")
1481         with self.assertRaises(yaml.YAMLError) as err:
1482             result = self.monitor.serialize(value)
1483             self.assertEqual(result, None)
1484         self.assertEqual(str(err.exception.args[0]), "cannot represent an object.")
1485         mock_yaml.dump.assert_called_once()
1486
1487     @patch("osm_ng_ro.monitor.MonitorVms.serialize")
1488     def test_get_server_info_with_user_data(self, mock_serialize):
1489         all_server_info = deepcopy(server_other_info)
1490         user_data = {
1491             "OS-EXT-SRV-ATTR:user_data": "EXT-USER-DATA",
1492             "user_data": "some-data",
1493         }
1494         mock_serialize.return_value = serialized_server_info
1495         all_server_info.update(user_data)
1496         server5 = create_server(vm1_id, "server5", info=all_server_info)
1497         result = self.monitor._get_server_info(server5)
1498         self.assertEqual(result, serialized_server_info)
1499         mock_serialize.assert_called_once_with(server_other_info)
1500
1501     @patch("osm_ng_ro.monitor.MonitorVms.serialize")
1502     def test_get_server_info_without_user_data(self, mock_serialize):
1503         mock_serialize.return_value = serialized_server_info
1504         server5 = create_server(vm1_id, "server5", info=server_other_info)
1505         result = self.monitor._get_server_info(server5)
1506         self.assertEqual(result, serialized_server_info)
1507         mock_serialize.assert_called_once_with(server_other_info)
1508
1509     @patch("osm_ng_ro.monitor.MonitorVms.serialize")
1510     def test_get_server_info_empty_server_info(self, mock_serialize):
1511         server_other_info = {}
1512         expected_result = {}
1513         mock_serialize.return_value = expected_result
1514         server5 = create_server(vm1_id, "server5", info=server_other_info)
1515         result = self.monitor._get_server_info(server5)
1516         self.assertEqual(result, expected_result)
1517         mock_serialize.assert_called_once_with(server_other_info)
1518
1519     @patch("osm_ng_ro.monitor.MonitorVms.serialize")
1520     def test_get_server_info_serialize_raises(self, mock_serialize):
1521         server_other_info = {
1522             "admin_state_up": "true",
1523             "binding:host_id": int,
1524             "binding:profile": {},
1525             "binding:vif_type": str,
1526             "binding:vnic_type": "normal",
1527             "created_at": "2023-02-22T05:35:46Z",
1528         }
1529         mock_serialize.side_effect = yaml.YAMLError("cannot represent an object.")
1530         server5 = create_server(vm1_id, "server5", info=server_other_info)
1531         with self.assertRaises(yaml.YAMLError) as err:
1532             self.monitor._get_server_info(server5)
1533         self.assertEqual(str(err.exception.args[0]), "cannot represent an object.")
1534         mock_serialize.assert_called_once_with(server_other_info)
1535
1536     @patch("osm_ng_ro.monitor.MonitorVms._get_server_info")
1537     def test_check_vm_status_updates_server_status_ok(self, mock_server_info):
1538         server6 = create_server("server6-id", "server6", status="PAUSED")
1539         mock_server_info.return_value = serialized_server_info
1540         vdur_vim_info_update = {}
1541         vdur_update = {}
1542         expected_vdur_vim_info_update = {
1543             "vim_status": "PAUSED",
1544             "vim_details": serialized_server_info,
1545             "vim_id": server6.id,
1546             "vim_name": server6.name,
1547         }
1548         expected_vdur_update = {
1549             "vdur.0.status": "PAUSED",
1550             "vdur.0.name": server6.name,
1551         }
1552         self.monitor.check_vm_status_updates(
1553             vdur_vim_info_update, vdur_update, server6, vdur_path
1554         )
1555         self.assertDictEqual(vdur_vim_info_update, expected_vdur_vim_info_update)
1556         self.assertDictEqual(vdur_update, expected_vdur_update)
1557         mock_server_info.assert_called_once_with(server6)
1558
1559     @patch("osm_ng_ro.monitor.MonitorVms._get_server_info")
1560     def test_check_vm_status_updates_server_status_nok(self, mock_server_info):
1561         server8 = create_server("server8-id", "server8", status="FAILED")
1562         mock_server_info.return_value = serialized_server_info
1563         vdur_vim_info_update = {}
1564         vdur_update = {}
1565         expected_vdur_vim_info_update = {
1566             "vim_status": "FAILED",
1567             "vim_details": serialized_server_info,
1568             "vim_id": server8.id,
1569             "vim_name": server8.name,
1570             "vim_message": "VIM status reported FAILED",
1571         }
1572         expected_vdur_update = {
1573             "vdur.0.status": "FAILED",
1574             "vdur.0.name": server8.name,
1575         }
1576         self.monitor.check_vm_status_updates(
1577             vdur_vim_info_update, vdur_update, server8, vdur_path
1578         )
1579         self.assertDictEqual(vdur_vim_info_update, expected_vdur_vim_info_update)
1580         self.assertDictEqual(vdur_update, expected_vdur_update)
1581         mock_server_info.assert_called_once_with(server8)
1582
1583     @patch("osm_ng_ro.monitor.MonitorVms._get_server_info")
1584     def test_check_vm_status_updates_get_server_info_raises(self, mock_server_info):
1585         server8 = create_server("server8-id", "server8", status="FAILED")
1586         mock_server_info.side_effect = yaml.YAMLError("Cannot represent an object.")
1587         vdur_vim_info_update = {}
1588         vdur_update = {}
1589         expected_vdur_vim_info_update = {
1590             "vim_status": "FAILED",
1591             "vim_message": "VIM status reported FAILED",
1592         }
1593         expected_vdur_update = {
1594             "vdur.0.status": "FAILED",
1595         }
1596         with self.assertRaises(yaml.YAMLError) as err:
1597             self.monitor.check_vm_status_updates(
1598                 vdur_vim_info_update, vdur_update, server8, vdur_path
1599             )
1600         self.assertEqual(str(err.exception.args[0]), "Cannot represent an object.")
1601         self.assertDictEqual(vdur_vim_info_update, expected_vdur_vim_info_update)
1602         self.assertDictEqual(vdur_update, expected_vdur_update)
1603         mock_server_info.assert_called_once_with(server8)
1604
1605     def test_get_interface_info(self):
1606         interface = {"vim_interface_id": "4d081f50-e13a-4306-a67e-1edb28d76013"}
1607         ports = {"ports": [port1, port2]}
1608         result = self.monitor.get_interface_info(ports, interface, server1)
1609         self.assertEqual(result, port1)
1610
1611     def test_get_interface_info_port_id_mismatch(self):
1612         interface = {"vim_interface_id": "4d081f50-e13a-4306-a67e-1edb28d76013"}
1613         ports = {"ports": [port2]}
1614         result = self.monitor.get_interface_info(ports, interface, server1)
1615         self.assertEqual(result, None)
1616
1617     def test_get_interface_info_device_id_mismatch(self):
1618         interface = {"vim_interface_id": "4d081f50-e13a-4306-a67e-1edb28d76013"}
1619         ports = {"ports": [port1, port2]}
1620         result = self.monitor.get_interface_info(ports, interface, server2)
1621         self.assertEqual(result, None)
1622
1623     def test_get_interface_info_empty_ports(self):
1624         interface = {"vim_interface_id": "4d081f50-e13a-4306-a67e-1edb28d76013"}
1625         ports = {"ports": []}
1626         result = self.monitor.get_interface_info(ports, interface, server2)
1627         self.assertEqual(result, None)
1628
1629     def test_check_vlan_pci_update(self):
1630         interface_info = interface_with_binding
1631         index = 1
1632         vdur_vim_info_update = {"interfaces": [{}, {}]}
1633         expected_vdur_vim_info_update = {
1634             "interfaces": [{}, {"pci": "0000:86:17.4", "vlan": 400}]
1635         }
1636         self.monitor.check_vlan_pci_updates(interface_info, index, vdur_vim_info_update)
1637         self.assertDictEqual(vdur_vim_info_update, expected_vdur_vim_info_update)
1638
1639     def test_check_vlan_pci_update_empty_interface_info(self):
1640         interface_info = {}
1641         index = 1
1642         vdur_vim_info_update = {"interfaces": [{}, {}]}
1643         expected_vdur_vim_info_update = {"interfaces": [{}, {}]}
1644         self.monitor.check_vlan_pci_updates(interface_info, index, vdur_vim_info_update)
1645         self.assertDictEqual(vdur_vim_info_update, expected_vdur_vim_info_update)
1646
1647     def test_check_vlan_pci_update_index_out_of_range(self):
1648         interface_info = interface_with_binding
1649         index = 3
1650         vdur_vim_info_update = {"interfaces": [{}]}
1651         expected_vdur_vim_info_update = {"interfaces": [{}]}
1652         with self.assertRaises(IndexError) as err:
1653             self.monitor.check_vlan_pci_updates(
1654                 interface_info, index, vdur_vim_info_update
1655             )
1656         self.assertEqual(str(err.exception.args[0]), "list index out of range")
1657         self.assertEqual(vdur_vim_info_update, expected_vdur_vim_info_update)
1658
1659     def test_check_vlan_pci_update_empty_vdur_vim_info_update(self):
1660         interface_info = interface_with_binding
1661         index = 0
1662         vdur_vim_info_update = {}
1663         expected_vdur_vim_info_update = {}
1664         with self.assertRaises(KeyError) as err:
1665             self.monitor.check_vlan_pci_updates(
1666                 interface_info, index, vdur_vim_info_update
1667             )
1668         self.assertEqual(str(err.exception.args[0]), "interfaces")
1669         self.assertEqual(vdur_vim_info_update, expected_vdur_vim_info_update)
1670
1671     @patch("osm_ng_ro.monitor.MonitorVms._get_current_ip_address")
1672     def test_check_vdur_interface_updates(self, mock_get_current_ip_address):
1673         vdur_update, vnfr_update = {}, {}
1674         index = 0
1675         interface_info = {
1676             "fixed_ips": [{"ip_address": ip1_addr}],
1677             "mac_address": mac1_addr,
1678         }
1679         mock_get_current_ip_address.return_value = ip1_addr
1680         expected_vdur_update = {
1681             "vdur.0.interfaces.0.ip-address": ip1_addr,
1682             "vdur.0.ip-address": ip1_addr,
1683             "vdur.0.interfaces.0.mac-address": mac1_addr,
1684         }
1685         expected_vnfr_update = {
1686             "35c034cc-8c5b-48c4-bfa2-17a71577ef19.ip-address": ip1_addr
1687         }
1688         self.monitor.check_vdur_interface_updates(
1689             vdur_update,
1690             vdur_path,
1691             index,
1692             interface_info,
1693             old_interface2,
1694             vnfr_update,
1695             vnfr_id,
1696         )
1697         self.assertEqual(vnfr_update, expected_vnfr_update)
1698         self.assertEqual(vdur_update, expected_vdur_update)
1699         mock_get_current_ip_address.assert_called_once_with(interface_info)
1700
1701     @patch("osm_ng_ro.monitor.MonitorVms._get_current_ip_address")
1702     def test_check_vdur_interface_updates_not_mgmt_interface(
1703         self, mock_get_current_ip_address
1704     ):
1705         vdur_update, vnfr_update = {}, {}
1706         index = 0
1707         interface_info = {
1708             "fixed_ips": [{"ip_address": ip1_addr}],
1709             "mac_address": mac1_addr,
1710         }
1711         mock_get_current_ip_address.return_value = ip1_addr
1712         old_interface = {}
1713         expected_vdur_update = {
1714             "vdur.0.interfaces.0.ip-address": ip1_addr,
1715             "vdur.0.interfaces.0.mac-address": mac1_addr,
1716         }
1717         self.monitor.check_vdur_interface_updates(
1718             vdur_update,
1719             vdur_path,
1720             index,
1721             interface_info,
1722             old_interface,
1723             vnfr_update,
1724             vnfr_id,
1725         )
1726         self.assertEqual(vnfr_update, {})
1727         self.assertEqual(vdur_update, expected_vdur_update)
1728         mock_get_current_ip_address.assert_called_once_with(interface_info)
1729
1730     @patch("osm_ng_ro.monitor.MonitorVms._get_current_ip_address")
1731     def test_check_vdur_interface_updates_without_mac_address(
1732         self, mock_get_current_ip_address
1733     ):
1734         vdur_update, vnfr_update = {}, {}
1735         index = 0
1736         interface_info = {"fixed_ips": [{"ip_address": ip1_addr}]}
1737         mock_get_current_ip_address.return_value = ip1_addr
1738         expected_vdur_update = {
1739             "vdur.0.interfaces.0.ip-address": ip1_addr,
1740             "vdur.0.ip-address": ip1_addr,
1741             "vdur.0.interfaces.0.mac-address": None,
1742         }
1743         expected_vnfr_update = {
1744             "35c034cc-8c5b-48c4-bfa2-17a71577ef19.ip-address": ip1_addr
1745         }
1746         self.monitor.check_vdur_interface_updates(
1747             vdur_update,
1748             vdur_path,
1749             index,
1750             interface_info,
1751             old_interface2,
1752             vnfr_update,
1753             vnfr_id,
1754         )
1755         self.assertEqual(vnfr_update, expected_vnfr_update)
1756         self.assertEqual(vdur_update, expected_vdur_update)
1757         mock_get_current_ip_address.assert_called_once_with(interface_info)
1758
1759     @patch("osm_ng_ro.monitor.MonitorVms._get_current_ip_address")
1760     def test_check_vdur_interface_updates_without_ip_address(
1761         self, mock_get_current_ip_address
1762     ):
1763         vdur_update, vnfr_update = {}, {}
1764         index = 0
1765         interface_info = {"fixed_ips": [], "mac_address": mac1_addr}
1766         mock_get_current_ip_address.return_value = None
1767         expected_vdur_update = {
1768             "vdur.0.interfaces.0.mac-address": mac1_addr,
1769         }
1770         expected_vnfr_update = {}
1771         self.monitor.check_vdur_interface_updates(
1772             vdur_update,
1773             vdur_path,
1774             index,
1775             interface_info,
1776             old_interface2,
1777             vnfr_update,
1778             vnfr_id,
1779         )
1780         self.assertEqual(vnfr_update, expected_vnfr_update)
1781         self.assertEqual(vdur_update, expected_vdur_update)
1782         mock_get_current_ip_address.assert_called_once_with(interface_info)
1783
1784     @patch("osm_ng_ro.monitor.MonitorVms._get_current_ip_address")
1785     def test_check_vdur_interface_updates_wrong_interface_info_format(
1786         self, mock_get_current_ip_address
1787     ):
1788         vdur_update, vnfr_update = {}, {}
1789         index = 0
1790         interface_info = {"fixed_ips": ip1_addr, "mac_address": mac1_addr}
1791         mock_get_current_ip_address.side_effect = TypeError(
1792             "str is not list like object."
1793         )
1794         old_interface = {}
1795         with self.assertRaises(TypeError) as err:
1796             self.monitor.check_vdur_interface_updates(
1797                 vdur_update,
1798                 vdur_path,
1799                 index,
1800                 interface_info,
1801                 old_interface,
1802                 vnfr_update,
1803                 vnfr_id,
1804             )
1805         self.assertEqual(str(err.exception), "str is not list like object.")
1806         self.assertEqual(vnfr_update, {})
1807         self.assertEqual(vdur_update, {})
1808         mock_get_current_ip_address.assert_called_once_with(interface_info)
1809
1810     def test_get_current_ip_address(self):
1811         interface_info = {
1812             "fixed_ips": [{"ip_address": ip1_addr}],
1813             "mac_address": mac1_addr,
1814         }
1815         result = self.monitor._get_current_ip_address(interface_info)
1816         self.assertEqual(result, ip1_addr)
1817
1818     def test_get_current_ip_address_no_ip(self):
1819         interface_info = {"fixed_ips": [{}], "mac_address": mac1_addr}
1820         result = self.monitor._get_current_ip_address(interface_info)
1821         self.assertEqual(result, None)
1822
1823     def test_backup_vdu_interfaces_without_vim_message(self):
1824         vdur_vim_info_update = {
1825             "interfaces": {"mac_address": mac1_addr},
1826         }
1827         expected_vdur_vim_info_update = {
1828             "interfaces": {"mac_address": mac1_addr},
1829             "interfaces_backup": {"mac_address": mac1_addr},
1830         }
1831         self.monitor.backup_vdu_interfaces(vdur_vim_info_update)
1832         self.assertDictEqual(expected_vdur_vim_info_update, vdur_vim_info_update)
1833
1834     def test_backup_vdu_interfaces_with_vim_message(self):
1835         vdur_vim_info_update = {
1836             "interfaces": {"mac_address": mac1_addr},
1837             "vim_message": "Deleted Externally",
1838         }
1839         expected_vdur_vim_info_update = {
1840             "interfaces": {"mac_address": mac1_addr},
1841             "vim_message": "Deleted Externally",
1842         }
1843         self.monitor.backup_vdu_interfaces(vdur_vim_info_update)
1844         self.assertDictEqual(expected_vdur_vim_info_update, vdur_vim_info_update)
1845
1846     def test_backup_vdu_interfaces_with_empty_interfaces(self):
1847         vdur_vim_info_update = {
1848             "interfaces": {},
1849         }
1850         expected_vdur_vim_info_update = {
1851             "interfaces": {},
1852         }
1853         self.monitor.backup_vdu_interfaces(vdur_vim_info_update)
1854         self.assertDictEqual(expected_vdur_vim_info_update, vdur_vim_info_update)
1855
1856     @patch("osm_ng_ro.monitor.MonitorVms.serialize")
1857     def test_update_vdur_vim_info_interfaces(self, mock_serialize):
1858         index = 1
1859         vdur_vim_info_update = {
1860             "interfaces": [{}, {"mac_address": mac1_addr, "compute_node": "host1"}]
1861         }
1862         all_server_info = deepcopy(server_other_info)
1863         host_data = {"OS-EXT-SRV-ATTR:host": "nova"}
1864         mock_serialize.return_value = serialized_interface_info
1865         all_server_info.update(host_data)
1866         server7 = create_server(vm1_id, "server7", info=all_server_info)
1867         expected_vdur_vim_info_update = {
1868             "interfaces": [
1869                 {},
1870                 {
1871                     "mac_address": mac2_addr,
1872                     "compute_node": "nova",
1873                     "vim_info": serialized_interface_info,
1874                     "vim_net_id": net1_id,
1875                     "ip_address": ip1_addr,
1876                 },
1877             ]
1878         }
1879         self.monitor.update_vdur_vim_info_interfaces(
1880             vdur_vim_info_update, index, interface_info2, server7
1881         )
1882         self.assertDictEqual(vdur_vim_info_update, expected_vdur_vim_info_update)
1883         mock_serialize.assert_called_once_with(interface_info2)
1884
1885     @patch("osm_ng_ro.monitor.MonitorVms.serialize")
1886     def test_update_vdur_vim_info_interfaces_serialize_raises(self, mock_serialize):
1887         index = 1
1888         vdur_vim_info_update = {
1889             "interfaces": [{}, {"mac_address": mac1_addr, "compute_node": "host1"}]
1890         }
1891         all_server_info = deepcopy(server_other_info)
1892         host_data = {"OS-EXT-SRV-ATTR:host": "nova"}
1893         mock_serialize.side_effect = yaml.YAMLError("Cannot represent an object.")
1894         all_server_info.update(host_data)
1895         server7 = create_server(vm1_id, "server7", info=all_server_info)
1896         expected_vdur_vim_info = deepcopy(vdur_vim_info_update)
1897         with self.assertRaises(yaml.YAMLError) as err:
1898             self.monitor.update_vdur_vim_info_interfaces(
1899                 vdur_vim_info_update, index, interface_info2, server7
1900             )
1901         self.assertEqual(str(err.exception), "Cannot represent an object.")
1902         self.assertDictEqual(vdur_vim_info_update, expected_vdur_vim_info)
1903         mock_serialize.assert_called_once_with(interface_info2)
1904
1905     @patch("osm_ng_ro.monitor.MonitorVms.serialize")
1906     def test_update_vdur_vim_info_interfaces_empty_interface_info(self, mock_serialize):
1907         index = 1
1908         vdur_vim_info_update = {
1909             "interfaces": [{}, {"mac_address": mac1_addr, "compute_node": "host1"}]
1910         }
1911         interface_info = {}
1912         all_server_info = deepcopy(server_other_info)
1913         host_data = {"OS-EXT-SRV-ATTR:host": "nova"}
1914         all_server_info.update(host_data)
1915         server7 = create_server(vm1_id, "server7", info=all_server_info)
1916         expected_vdur_vim_info = deepcopy(vdur_vim_info_update)
1917         with self.assertRaises(KeyError) as err:
1918             self.monitor.update_vdur_vim_info_interfaces(
1919                 vdur_vim_info_update, index, interface_info, server7
1920             )
1921         self.assertEqual(str(err.exception.args[0]), "mac_address")
1922         self.assertDictEqual(vdur_vim_info_update, expected_vdur_vim_info)
1923         mock_serialize.assert_not_called()
1924
1925     @patch("osm_ng_ro.monitor.MonitorVms.serialize")
1926     def test_update_vdur_vim_info_interfaces_invalid_vdur_vim_info(
1927         self, mock_serialize
1928     ):
1929         index = 1
1930         vdur_vim_info_update = {
1931             "interfaces": [{"mac_address": mac1_addr, "compute_node": "host1"}, {}]
1932         }
1933         expected_vdur_vim_info = deepcopy(vdur_vim_info_update)
1934         with self.assertRaises(MonitorVmsException) as err:
1935             self.monitor.update_vdur_vim_info_interfaces(
1936                 vdur_vim_info_update, index, interface_info2, server7
1937             )
1938         self.assertEqual(
1939             str(err.exception.args[0]), "Existing interfaces info could not found."
1940         )
1941         self.assertDictEqual(vdur_vim_info_update, expected_vdur_vim_info)
1942         mock_serialize.assert_not_called()
1943
1944     @patch("osm_ng_ro.monitor.MonitorVms.update_vdur_vim_info_interfaces")
1945     @patch("osm_ng_ro.monitor.MonitorVms.check_vlan_pci_updates")
1946     @patch("osm_ng_ro.monitor.MonitorVms.check_vdur_interface_updates")
1947     def test_prepare_interface_updates(
1948         self,
1949         mock_check_vdur_interface_updates,
1950         mock_check_vlan_pci_updates,
1951         mock_update_vdur_vim_info_interfaces,
1952     ):
1953         vdur_vim_info_update = {
1954             "interfaces": [{"mac_address": mac1_addr, "compute_node": "host1"}]
1955         }
1956         interface_info = {
1957             "fixed_ips": [{"ip_address": ip1_addr}],
1958             "mac_address": mac2_addr,
1959             "network_id": net1_id,
1960         }
1961         old_interface = {
1962             "mgmt_vdu_interface": True,
1963             "mgmt_vnf_interface": True,
1964         }
1965         index = 0
1966         vnfr_update, vdur_update = {}, {}
1967         self.monitor.prepare_interface_updates(
1968             vdur_vim_info_update,
1969             index,
1970             interface_info,
1971             server7,
1972             vdur_path,
1973             vnfr_update,
1974             old_interface2,
1975             vdur_update,
1976             vnfr_id,
1977         )
1978         mock_update_vdur_vim_info_interfaces.assert_called_once_with(
1979             vdur_vim_info_update, index, interface_info, server7
1980         )
1981         mock_check_vlan_pci_updates.assert_called_once_with(
1982             interface_info, index, vdur_vim_info_update
1983         )
1984         mock_check_vdur_interface_updates.assert_called_once_with(
1985             vdur_update,
1986             vdur_path,
1987             index,
1988             interface_info,
1989             old_interface,
1990             vnfr_update,
1991             vnfr_id,
1992         )
1993
1994     @patch("osm_ng_ro.monitor.MonitorVms.update_vdur_vim_info_interfaces")
1995     @patch("osm_ng_ro.monitor.MonitorVms.check_vlan_pci_updates")
1996     @patch("osm_ng_ro.monitor.MonitorVms.check_vdur_interface_updates")
1997     def test_prepare_interface_updates_update_vdur_vim_info_interfaces_raises(
1998         self,
1999         mock_check_vdur_interface_updates,
2000         mock_check_vlan_pci_updates,
2001         mock_update_vdur_vim_info_interfaces,
2002     ):
2003         vdur_vim_info_update = {
2004             "interfaces": [{"mac_address": mac1_addr, "compute_node": "host1"}]
2005         }
2006         index = 0
2007         vnfr_update, vdur_update = {}, {}
2008         mock_update_vdur_vim_info_interfaces.side_effect = MonitorVmsException(
2009             "Existing interfaces info could not found."
2010         )
2011         with self.assertRaises(MonitorVmsException) as err:
2012             self.monitor.prepare_interface_updates(
2013                 vdur_vim_info_update,
2014                 index,
2015                 interface_info2,
2016                 server7,
2017                 vdur_path,
2018                 vnfr_update,
2019                 old_interface2,
2020                 vdur_update,
2021                 vnfr_id,
2022             )
2023         self.assertEqual(
2024             str(err.exception.args[0]), "Existing interfaces info could not found."
2025         )
2026         mock_update_vdur_vim_info_interfaces.assert_called_once_with(
2027             vdur_vim_info_update, index, interface_info2, server7
2028         )
2029         check_if_assert_not_called(
2030             [mock_check_vlan_pci_updates, mock_check_vdur_interface_updates]
2031         )
2032
2033     @patch("osm_ng_ro.monitor.MonitorVms.update_vdur_vim_info_interfaces")
2034     @patch("osm_ng_ro.monitor.MonitorVms.check_vlan_pci_updates")
2035     @patch("osm_ng_ro.monitor.MonitorVms.check_vdur_interface_updates")
2036     def test_prepare_interface_updates_check_vlan_pci_updates_raises(
2037         self,
2038         mock_check_vdur_interface_updates,
2039         mock_check_vlan_pci_updates,
2040         mock_update_vdur_vim_info_interfaces,
2041     ):
2042         vdur_vim_info_update = {
2043             "interfaces": [{"mac_address": mac1_addr, "compute_node": "host1"}]
2044         }
2045         index = 0
2046         vnfr_update, vdur_update = {}, {}
2047         mock_check_vlan_pci_updates.side_effect = KeyError("vlan is not found.")
2048         with self.assertRaises(KeyError) as err:
2049             self.monitor.prepare_interface_updates(
2050                 vdur_vim_info_update,
2051                 index,
2052                 interface_info2,
2053                 server7,
2054                 vdur_path,
2055                 vnfr_update,
2056                 old_interface2,
2057                 vdur_update,
2058                 vnfr_id,
2059             )
2060         self.assertEqual(str(err.exception.args[0]), "vlan is not found.")
2061         mock_update_vdur_vim_info_interfaces.assert_called_once_with(
2062             vdur_vim_info_update, index, interface_info2, server7
2063         )
2064         mock_check_vlan_pci_updates.assert_called_once_with(
2065             interface_info2, index, vdur_vim_info_update
2066         )
2067         mock_check_vdur_interface_updates.assert_not_called()
2068
2069     @patch("osm_ng_ro.monitor.MonitorVms.get_interface_info")
2070     @patch("osm_ng_ro.monitor.MonitorVms.prepare_interface_updates")
2071     def test_check_vm_interface_updates(
2072         self, mock_prepare_interface_updates, mock_get_interface_info
2073     ):
2074         vdur_vim_info_update = {
2075             "interfaces": [{"mac_address": mac1_addr, "compute_node": "host1"}]
2076         }
2077         index = 0
2078         interface_info = {
2079             "fixed_ips": [{"ip_address": ip1_addr}],
2080             "mac_address": mac2_addr,
2081             "network_id": net1_id,
2082             "status": "ACTIVE",
2083         }
2084         vnfr_update, vdur_update = {}, {}
2085         ports = {"ports": [port1, port2]}
2086         existing_vim_info = sample_vim_info
2087         mock_get_interface_info.return_value = interface_info
2088         self.monitor.check_vm_interface_updates(
2089             server7,
2090             existing_vim_info,
2091             ports,
2092             vdur_vim_info_update,
2093             vdur_update,
2094             vdur_path,
2095             vnfr_update,
2096             vnfr_id,
2097         )
2098         mock_get_interface_info.assert_called_once_with(ports, old_interface, server7)
2099         mock_prepare_interface_updates.assert_called_once_with(
2100             vdur_vim_info_update,
2101             index,
2102             interface_info,
2103             server7,
2104             vdur_path,
2105             vnfr_update,
2106             old_interface,
2107             vdur_update,
2108             vnfr_id,
2109         )
2110         self.assertNotIn("vim_message", vdur_vim_info_update)
2111
2112     @patch("osm_ng_ro.monitor.MonitorVms.get_interface_info")
2113     @patch("osm_ng_ro.monitor.MonitorVms.prepare_interface_updates")
2114     def test_check_vm_interface_updates_interface_new_status_is_nok(
2115         self, mock_prepare_interface_updates, mock_get_interface_info
2116     ):
2117         vdur_vim_info_update = {
2118             "interfaces": [{"mac_address": mac1_addr, "compute_node": "host1"}]
2119         }
2120         interface_info = {
2121             "fixed_ips": [{"ip_address": ip1_addr}],
2122             "mac_address": mac2_addr,
2123             "network_id": net1_id,
2124             "status": "DOWN",
2125         }
2126         vnfr_update, vdur_update = {}, {}
2127         ports = {"ports": [port1, port2]}
2128         existing_vim_info = sample_vim_info
2129         mock_get_interface_info.return_value = interface_info
2130         self.monitor.check_vm_interface_updates(
2131             server7,
2132             existing_vim_info,
2133             ports,
2134             vdur_vim_info_update,
2135             vdur_update,
2136             vdur_path,
2137             vnfr_update,
2138             vnfr_id,
2139         )
2140         mock_get_interface_info.assert_called_once_with(ports, old_interface, server7)
2141         mock_prepare_interface_updates.assert_not_called()
2142         self.assertEqual(
2143             vdur_vim_info_update["vim_message"],
2144             "Interface 4d081f50-e13a-4306-a67e-1edb28d76013 status: DOWN",
2145         )
2146
2147     @patch("osm_ng_ro.monitor.MonitorVms.get_interface_info")
2148     @patch("osm_ng_ro.monitor.MonitorVms.prepare_interface_updates")
2149     def test_check_vm_interface_updates_no_new_interface_info(
2150         self, mock_prepare_interface_updates, mock_get_interface_info
2151     ):
2152         vdur_vim_info_update = {
2153             "interfaces": [{"mac_address": mac1_addr, "compute_node": "host1"}]
2154         }
2155         vnfr_update, vdur_update = {}, {}
2156         ports = {"ports": [port1, port2]}
2157         existing_vim_info = sample_vim_info
2158         mock_get_interface_info.return_value = None
2159         self.monitor.check_vm_interface_updates(
2160             server7,
2161             existing_vim_info,
2162             ports,
2163             vdur_vim_info_update,
2164             vdur_update,
2165             vdur_path,
2166             vnfr_update,
2167             vnfr_id,
2168         )
2169         mock_get_interface_info.assert_called_once_with(ports, old_interface, server7)
2170         mock_prepare_interface_updates.assert_not_called()
2171         self.assertEqual(
2172             vdur_vim_info_update["vim_message"],
2173             "Interface 4d081f50-e13a-4306-a67e-1edb28d76013 deleted externally.",
2174         )
2175
2176     @patch("osm_ng_ro.monitor.MonitorVms.get_interface_info")
2177     @patch("osm_ng_ro.monitor.MonitorVms.prepare_interface_updates")
2178     def test_check_vm_interface_updates_no_existing_interface(
2179         self, mock_prepare_interface_updates, mock_get_interface_info
2180     ):
2181         vdur_vim_info_update = {
2182             "interfaces": [{"mac_address": mac1_addr, "compute_node": "host1"}]
2183         }
2184         interface_info = {
2185             "fixed_ips": [{"ip_address": ip1_addr}],
2186             "mac_address": mac2_addr,
2187             "network_id": net1_id,
2188             "status": "ACTIVE",
2189         }
2190         vnfr_update, vdur_update = {}, {}
2191         ports = {"ports": [port1, port2]}
2192         updated_sample_vim_info = deepcopy(sample_vim_info)
2193         updated_sample_vim_info["interfaces"] = []
2194         existing_vim_info = updated_sample_vim_info
2195         mock_get_interface_info.return_value = interface_info
2196         self.monitor.check_vm_interface_updates(
2197             server7,
2198             existing_vim_info,
2199             ports,
2200             vdur_vim_info_update,
2201             vdur_update,
2202             vdur_path,
2203             vnfr_update,
2204             vnfr_id,
2205         )
2206         check_if_assert_not_called(
2207             [mock_get_interface_info, mock_prepare_interface_updates]
2208         )
2209         self.assertNotIn("vim_message", vdur_vim_info_update)
2210
2211     def test_update_in_database(self):
2212         all_updates = [{"some-key": "some-value"}, {"other-key": "other-value"}]
2213         self.monitor.update_in_database(all_updates, vnfr_id)
2214         self.assertEqual(self.monitor.db.set_list.call_count, 2)
2215         _call_mock_set_list = self.monitor.db.set_list.call_args_list
2216         self.assertEqual(
2217             _call_mock_set_list[0][0],
2218             ("vnfrs",),
2219         )
2220         self.assertEqual(
2221             _call_mock_set_list[0][1],
2222             (
2223                 {
2224                     "q_filter": {"_id": vnfr_id},
2225                     "update_dict": {"some-key": "some-value"},
2226                 }
2227             ),
2228         )
2229         self.assertEqual(
2230             _call_mock_set_list[1][0],
2231             ("vnfrs",),
2232         )
2233         self.assertEqual(
2234             _call_mock_set_list[1][1],
2235             (
2236                 {
2237                     "q_filter": {"_id": vnfr_id},
2238                     "update_dict": {"other-key": "other-value"},
2239                 }
2240             ),
2241         )
2242
2243     def test_update_in_database_set_list_raises(self):
2244         all_updates = [{"some-key": "some-value"}, {"other-key": "other-value"}]
2245         self.monitor.db.set_list.side_effect = DbException("Connection failed.")
2246         with self.assertRaises(MonitorDbException) as err:
2247             self.monitor.update_in_database(all_updates, vnfr_id)
2248         self.assertEqual(
2249             str(err.exception.args[0]),
2250             "Error while updating differences in VNFR database exception Connection failed.",
2251         )
2252         self.assertEqual(self.monitor.db.set_list.call_count, 1)
2253         _call_mock_set_list = self.monitor.db.set_list.call_args_list
2254         self.assertEqual(
2255             _call_mock_set_list[0][0],
2256             ("vnfrs",),
2257         )
2258         self.assertEqual(
2259             _call_mock_set_list[0][1],
2260             (
2261                 {
2262                     "q_filter": {"_id": vnfr_id},
2263                     "update_dict": {"some-key": "some-value"},
2264                 }
2265             ),
2266         )
2267
2268     def test_update_in_database_empty_all_updates(self):
2269         all_updates = []
2270         self.monitor.update_in_database(all_updates, vnfr_id)
2271         self.monitor.db.set_list.assert_not_called()
2272
2273     @patch("osm_ng_ro.monitor.MonitorVms._get_vm_data_from_db")
2274     @patch("osm_ng_ro.monitor.MonitorVms.check_vm_status_updates")
2275     @patch("osm_ng_ro.monitor.MonitorVms.check_vm_interface_updates")
2276     @patch("osm_ng_ro.monitor.MonitorVms.backup_vdu_interfaces")
2277     @patch("osm_ng_ro.monitor.MonitorVms.update_in_database")
2278     def test_report_vdur_updates_no_change_in_vdur(
2279         self,
2280         mock_update_in_database,
2281         mock_backup_vdu_interfaces,
2282         mock_check_vm_interface_updates,
2283         mock_check_vm_status_updates,
2284         mock_get_vm_data_from_db,
2285     ):
2286         existing_vim_info = sample_vim_info
2287         vdur_vim_info_update = deepcopy(existing_vim_info)
2288         mock_get_vm_data_from_db.return_value = (
2289             vdur_path,
2290             vdur_vim_info_update,
2291             None,
2292             existing_vim_info,
2293             vnfr_id,
2294             vim_info_path,
2295         )
2296         ports = {"ports": [port1, port2]}
2297         self.monitor.report_vdur_updates(server7, sample_vm, ports)
2298         check_if_assert_not_called(
2299             [mock_update_in_database, mock_backup_vdu_interfaces]
2300         )
2301         mock_get_vm_data_from_db.assert_called_with(sample_vm)
2302         self.assertEqual(mock_get_vm_data_from_db.call_count, 1)
2303         mock_check_vm_status_updates.assert_called_once_with(
2304             vdur_vim_info_update, {}, server7, vdur_path
2305         )
2306         mock_check_vm_interface_updates.assert_called_once_with(
2307             server7,
2308             existing_vim_info,
2309             ports,
2310             vdur_vim_info_update,
2311             {},
2312             vdur_path,
2313             {},
2314             vnfr_id,
2315         )
2316
2317     @patch("osm_ng_ro.monitor.MonitorVms._get_vm_data_from_db")
2318     @patch("osm_ng_ro.monitor.MonitorVms.check_vm_status_updates")
2319     @patch("osm_ng_ro.monitor.MonitorVms.check_vm_interface_updates")
2320     @patch("osm_ng_ro.monitor.MonitorVms.backup_vdu_interfaces")
2321     @patch("osm_ng_ro.monitor.MonitorVms.update_in_database")
2322     def test_report_vdur_updates_vdur_changed(
2323         self,
2324         mock_update_in_database,
2325         mock_backup_vdu_interfaces,
2326         mock_check_vm_interface_updates,
2327         mock_check_vm_status_updates,
2328         mock_get_vm_data_from_db,
2329     ):
2330         existing_vim_info = sample_vim_info
2331         vdur_vim_info_update = {
2332             "interfaces": [{"mac_address": mac1_addr, "compute_node": "host1"}]
2333         }
2334         mock_get_vm_data_from_db.return_value = (
2335             vdur_path,
2336             vdur_vim_info_update,
2337             None,
2338             existing_vim_info,
2339             vnfr_id,
2340             vim_info_path,
2341         )
2342         all_updates = [{}, {vim_info_path: vdur_vim_info_update}, {}]
2343         ports = {"ports": [port1, port2]}
2344         self.monitor.report_vdur_updates(server7, sample_vm, ports)
2345         mock_get_vm_data_from_db.assert_called_with(sample_vm)
2346         self.assertEqual(mock_get_vm_data_from_db.call_count, 1)
2347         mock_check_vm_status_updates.assert_called_once_with(
2348             vdur_vim_info_update, {}, server7, vdur_path
2349         )
2350         mock_check_vm_interface_updates.assert_called_once_with(
2351             server7,
2352             existing_vim_info,
2353             ports,
2354             vdur_vim_info_update,
2355             {},
2356             vdur_path,
2357             {},
2358             vnfr_id,
2359         )
2360         mock_backup_vdu_interfaces.assert_called_once_with(vdur_vim_info_update)
2361         mock_update_in_database.assert_called_once_with(all_updates, vnfr_id)
2362
2363     @patch("osm_ng_ro.monitor.MonitorVms._get_vm_data_from_db")
2364     @patch("osm_ng_ro.monitor.MonitorVms.check_vm_status_updates")
2365     @patch("osm_ng_ro.monitor.MonitorVms.check_vm_interface_updates")
2366     @patch("osm_ng_ro.monitor.MonitorVms.backup_vdu_interfaces")
2367     @patch("osm_ng_ro.monitor.MonitorVms.update_in_database")
2368     def test_report_vdur_updates_check_vm_status_updates_raises(
2369         self,
2370         mock_update_in_database,
2371         mock_backup_vdu_interfaces,
2372         mock_check_vm_interface_updates,
2373         mock_check_vm_status_updates,
2374         mock_get_vm_data_from_db,
2375     ):
2376         existing_vim_info = sample_vim_info
2377         vdur_vim_info_update = {
2378             "interfaces": [{"mac_address": mac1_addr, "compute_node": "host1"}]
2379         }
2380         mock_get_vm_data_from_db.return_value = (
2381             vdur_path,
2382             vdur_vim_info_update,
2383             None,
2384             existing_vim_info,
2385             vnfr_id,
2386             vim_info_path,
2387         )
2388         ports = {"ports": [port1, port2]}
2389         mock_check_vm_status_updates.side_effect = yaml.YAMLError(
2390             "Cannot represent an object."
2391         )
2392         with self.assertRaises(yaml.YAMLError) as err:
2393             self.monitor.report_vdur_updates(server7, sample_vm, ports)
2394         self.assertEqual(str(err.exception), "Cannot represent an object.")
2395         mock_get_vm_data_from_db.assert_called_with(sample_vm)
2396         self.assertEqual(mock_get_vm_data_from_db.call_count, 1)
2397         mock_check_vm_status_updates.assert_called_once_with(
2398             vdur_vim_info_update, {}, server7, vdur_path
2399         )
2400         check_if_assert_not_called(
2401             [
2402                 mock_check_vm_interface_updates,
2403                 mock_backup_vdu_interfaces,
2404                 mock_update_in_database,
2405             ]
2406         )
2407
2408     @patch("osm_ng_ro.monitor.MonitorVms._get_vm_data_from_db")
2409     @patch("osm_ng_ro.monitor.MonitorVms.check_vm_status_updates")
2410     @patch("osm_ng_ro.monitor.MonitorVms.check_vm_interface_updates")
2411     @patch("osm_ng_ro.monitor.MonitorVms.backup_vdu_interfaces")
2412     @patch("osm_ng_ro.monitor.MonitorVms.update_in_database")
2413     def test_report_vdur_updates_database_update_raises(
2414         self,
2415         mock_update_in_database,
2416         mock_backup_vdu_interfaces,
2417         mock_check_vm_interface_updates,
2418         mock_check_vm_status_updates,
2419         mock_get_vm_data_from_db,
2420     ):
2421         existing_vim_info = sample_vim_info
2422         vdur_vim_info_update = {
2423             "interfaces": [{"mac_address": mac1_addr, "compute_node": "host1"}]
2424         }
2425         mock_get_vm_data_from_db.return_value = (
2426             vdur_path,
2427             vdur_vim_info_update,
2428             None,
2429             existing_vim_info,
2430             vnfr_id,
2431             vim_info_path,
2432         )
2433         all_updates = [{}, {vim_info_path: vdur_vim_info_update}, {}]
2434         ports = {"ports": [port1, port2]}
2435         mock_update_in_database.side_effect = MonitorDbException(
2436             f"Error while updating differences in VNFR {vnfr_id}."
2437         )
2438         with self.assertRaises(MonitorDbException) as err:
2439             self.monitor.report_vdur_updates(server7, sample_vm, ports)
2440         self.assertEqual(
2441             str(err.exception), f"Error while updating differences in VNFR {vnfr_id}."
2442         )
2443         mock_get_vm_data_from_db.assert_called_with(sample_vm)
2444         self.assertEqual(mock_get_vm_data_from_db.call_count, 1)
2445         mock_check_vm_status_updates.assert_called_once_with(
2446             vdur_vim_info_update, {}, server7, vdur_path
2447         )
2448         mock_check_vm_interface_updates.assert_called_once_with(
2449             server7,
2450             existing_vim_info,
2451             ports,
2452             vdur_vim_info_update,
2453             {},
2454             vdur_path,
2455             {},
2456             vnfr_id,
2457         )
2458         mock_backup_vdu_interfaces.assert_called_once_with(vdur_vim_info_update)
2459         mock_update_in_database.assert_called_once_with(all_updates, vnfr_id)
2460
2461     @patch("osm_ng_ro.monitor.MonitorVms._get_vm_data_from_db")
2462     @patch("osm_ng_ro.monitor.MonitorVms.check_vm_status_updates")
2463     @patch("osm_ng_ro.monitor.MonitorVms.check_vm_interface_updates")
2464     @patch("osm_ng_ro.monitor.MonitorVms.backup_vdu_interfaces")
2465     @patch("osm_ng_ro.monitor.MonitorVms.update_in_database")
2466     def test_report_vdur_updates_no_vm_data(
2467         self,
2468         mock_update_in_database,
2469         mock_backup_vdu_interfaces,
2470         mock_check_vm_interface_updates,
2471         mock_check_vm_status_updates,
2472         mock_get_vm_data_from_db,
2473     ):
2474         mock_get_vm_data_from_db.return_value = None
2475         ports = {"ports": [port1, port2]}
2476         self.monitor.report_vdur_updates(server7, sample_vm, ports)
2477         check_if_assert_not_called(
2478             [
2479                 mock_update_in_database,
2480                 mock_backup_vdu_interfaces,
2481                 mock_check_vm_interface_updates,
2482                 mock_check_vm_status_updates,
2483             ]
2484         )
2485         mock_get_vm_data_from_db.assert_called_once_with(sample_vm)
2486
2487     @patch("osm_ng_ro.monitor.MonitorVms.find_ro_tasks_to_monitor")
2488     @patch("osm_ng_ro.monitor.MonitorVms.prepare_vims_to_monitor")
2489     @patch("osm_ng_ro.monitor.MonitorVms.update_vnfrs")
2490     def test_run_no_db_vims(
2491         self,
2492         mock_update_vnfrs,
2493         mock_prepare_vims_to_monitor,
2494         mock_find_ro_tasks_to_monitor,
2495     ):
2496         self.monitor.db_vims = None
2497         self.monitor.run()
2498         check_if_assert_not_called(
2499             [
2500                 mock_prepare_vims_to_monitor,
2501                 mock_find_ro_tasks_to_monitor,
2502                 mock_update_vnfrs,
2503             ]
2504         )
2505
2506     @patch("osm_ng_ro.monitor.MonitorVms.find_ro_tasks_to_monitor")
2507     @patch("osm_ng_ro.monitor.MonitorVms.prepare_vims_to_monitor")
2508     @patch("osm_ng_ro.monitor.MonitorVms.update_vnfrs")
2509     def test_run_refresh_disabled(
2510         self,
2511         mock_update_vnfrs,
2512         mock_prepare_vims_to_monitor,
2513         mock_find_ro_tasks_to_monitor,
2514     ):
2515         self.monitor.db_vims = vims
2516         self.monitor.refresh_config.active = -1
2517         self.monitor.run()
2518         check_if_assert_not_called(
2519             [
2520                 mock_prepare_vims_to_monitor,
2521                 mock_find_ro_tasks_to_monitor,
2522                 mock_update_vnfrs,
2523             ]
2524         )
2525
2526     @patch("osm_ng_ro.monitor.MonitorVms.find_ro_tasks_to_monitor")
2527     @patch("osm_ng_ro.monitor.MonitorVms.prepare_vims_to_monitor")
2528     @patch("osm_ng_ro.monitor.MonitorVms.update_vnfrs")
2529     def test_run_no_proper_ro_task(
2530         self,
2531         mock_update_vnfrs,
2532         mock_prepare_vims_to_monitor,
2533         mock_find_ro_tasks_to_monitor,
2534     ):
2535         self.monitor.db_vims = vims
2536         self.monitor.refresh_config.active = 60
2537         mock_find_ro_tasks_to_monitor.return_value = []
2538         self.monitor.run()
2539         check_if_assert_not_called([mock_prepare_vims_to_monitor, mock_update_vnfrs])
2540         mock_find_ro_tasks_to_monitor.assert_called_once()
2541
2542     @patch("osm_ng_ro.monitor.MonitorVms.find_ro_tasks_to_monitor")
2543     @patch("osm_ng_ro.monitor.MonitorVms.update_vnfrs")
2544     def test_run_with_proper_ro_task(
2545         self, mock_update_vnfrs, mock_find_ro_tasks_to_monitor
2546     ):
2547         self.monitor.db_vims = vims
2548         all_servers = [server1, server2]
2549         vim1_vms = [
2550             VmToMonitor(
2551                 vm_id=vm1_id,
2552                 target_record=target_record,
2553             )
2554         ]
2555         vim2_vms = [
2556             VmToMonitor(
2557                 vm_id=vm2_id,
2558                 target_record=target_record2,
2559             )
2560         ]
2561         all_ports = {"ports": [port1, port2]}
2562         mock_vim_connector = MagicMock()
2563         mock_vim_connector.get_monitoring_data.return_value = all_servers, all_ports
2564         self.monitor.my_vims = {
2565             vim1_id: mock_vim_connector,
2566             vim2_id: mock_vim_connector,
2567             vim3_id: mock_vim_connector,
2568         }
2569         self.monitor.refresh_config.active = 60
2570         mock_find_ro_tasks_to_monitor.return_value = [ro_task1, ro_task2]
2571         self.monitor.run()
2572         mock_find_ro_tasks_to_monitor.assert_called_once()
2573         _call_mock_update_vnfrs = mock_update_vnfrs.call_args_list
2574         self.assertEqual(mock_update_vnfrs.call_count, 2)
2575         self.assertEqual(
2576             _call_mock_update_vnfrs[0][0],
2577             (all_servers, all_ports, vim1_vms),
2578         )
2579         self.assertEqual(
2580             _call_mock_update_vnfrs[1][0],
2581             (all_servers, all_ports, vim2_vms),
2582         )
2583         self.assertEqual(mock_vim_connector.get_monitoring_data.call_count, 2)
2584
2585     @patch("osm_ng_ro.monitor.MonitorVms.find_ro_tasks_to_monitor")
2586     @patch("osm_ng_ro.monitor.MonitorVms.update_vnfrs")
2587     def test_run_update_vnfrs_raises(
2588         self, mock_update_vnfrs, mock_find_ro_tasks_to_monitor
2589     ):
2590         self.monitor.db_vims = vims
2591         all_servers = [server1, server2]
2592         vim1_vms = [
2593             VmToMonitor(
2594                 vm_id=vm1_id,
2595                 target_record=target_record,
2596             )
2597         ]
2598         all_ports = {"ports": [port1, port2]}
2599         mock_vim_connector = MagicMock()
2600         mock_vim_connector.get_monitoring_data.return_value = all_servers, all_ports
2601         self.monitor.my_vims = {
2602             vim1_id: mock_vim_connector,
2603             vim2_id: mock_vim_connector,
2604             vim3_id: mock_vim_connector,
2605         }
2606         self.monitor.refresh_config.active = 60
2607         mock_find_ro_tasks_to_monitor.return_value = [ro_task1, ro_task2]
2608         mock_update_vnfrs.side_effect = DbException("DB is not active state.")
2609         with self.assertRaises(MonitorVmsException) as err:
2610             self.monitor.run()
2611         self.assertEqual(
2612             str(err.exception),
2613             "Exception while monitoring Openstack VMs: database exception DB is not active state.",
2614         )
2615         mock_find_ro_tasks_to_monitor.assert_called_once()
2616         _call_mock_update_vnfrs = mock_update_vnfrs.call_args_list
2617         self.assertEqual(mock_update_vnfrs.call_count, 1)
2618         self.assertEqual(
2619             _call_mock_update_vnfrs[0][0],
2620             (all_servers, all_ports, vim1_vms),
2621         )
2622         self.assertEqual(mock_vim_connector.get_monitoring_data.call_count, 1)
2623
2624     @patch("osm_ng_ro.monitor.MonitorVms.prepare_vims_to_monitor")
2625     @patch("osm_ng_ro.monitor.MonitorVms.find_ro_tasks_to_monitor")
2626     @patch("osm_ng_ro.monitor.MonitorVms.update_vnfrs")
2627     def test_run_prepare_vims_to_monitor_raises(
2628         self,
2629         mock_update_vnfrs,
2630         mock_find_ro_tasks_to_monitor,
2631         mock_prepare_vims_to_monitor,
2632     ):
2633         self.monitor.db_vims = vims
2634         mock_vim_connector = MagicMock()
2635         self.monitor.my_vims = {
2636             vim1_id: mock_vim_connector,
2637             vim2_id: mock_vim_connector,
2638             vim3_id: mock_vim_connector,
2639         }
2640         self.monitor.refresh_config.active = 60
2641         mock_find_ro_tasks_to_monitor.return_value = [ro_task1, ro_task2]
2642         mock_prepare_vims_to_monitor.side_effect = KeyError("vim_id")
2643         with self.assertRaises(MonitorVmsException) as err:
2644             self.monitor.run()
2645         self.assertEqual(
2646             str(err.exception), "Exception while monitoring Openstack VMs: 'vim_id'"
2647         )
2648         mock_find_ro_tasks_to_monitor.assert_called_once()
2649         check_if_assert_not_called(
2650             [mock_update_vnfrs, mock_vim_connector.get_monitoring_data]
2651         )
2652
2653     @patch("osm_ng_ro.monitor.monitoring_task")
2654     @patch("osm_ng_ro.monitor.threading.Timer")
2655     @patch("osm_ng_ro.monitor.MonitorVms")
2656     def test_start_monitoring(
2657         self, mock_monitor_vms, mock_threading_timer, mock_monitoring_task
2658     ):
2659         mock_monitor_vms.return_value.refresh_config.active = 20
2660         mock_threading_timer.return_value = mock_monitoring_task
2661         start_monitoring(config)
2662         mock_threading_timer.assert_called_once_with(
2663             20, start_monitoring, args=(config,)
2664         )
2665         mock_threading_timer.return_value = CopyingMock(threading.Timer)
2666         self.assertEqual(mock_threading_timer.call_count, 1)
2667         mock_monitor_vms.return_value.run.assert_called_once()
2668         mock_monitor_vms.assert_called_once_with(config)
2669         mock_monitoring_task.start.assert_called_once()
2670
2671     @patch("osm_ng_ro.monitor.monitoring_task")
2672     @patch("osm_ng_ro.monitor.threading.Timer")
2673     @patch("osm_ng_ro.monitor.MonitorVms")
2674     def test_start_monitoring_empty_config(
2675         self, mock_monitor_vms, mock_threading_timer, mock_monitoring_task
2676     ):
2677         with self.assertRaises(MonitorVmsException) as err:
2678             start_monitoring(config={})
2679         self.assertEqual(
2680             str(err.exception),
2681             "Wrong configuration format is provided.",
2682         )
2683         check_if_assert_not_called(
2684             [mock_threading_timer, mock_monitor_vms, mock_monitoring_task]
2685         )
2686
2687     @patch("osm_ng_ro.monitor.monitoring_task")
2688     @patch("osm_ng_ro.monitor.threading.Timer")
2689     @patch("osm_ng_ro.monitor.MonitorVms")
2690     def test_start_monitoring_monitor_vms_raises(
2691         self, mock_monitor_vms, mock_threading_timer, mock_monitoring_task
2692     ):
2693         mock_monitor_vms.side_effect = MonitorDbException("Can not connect to DB.")
2694         with self.assertRaises(MonitorDbException) as err:
2695             start_monitoring(config)
2696         self.assertEqual(str(err.exception), "Can not connect to DB.")
2697         mock_monitor_vms.assert_called_once_with(config)
2698         check_if_assert_not_called([mock_threading_timer, mock_monitoring_task])
2699
2700     @patch("osm_ng_ro.monitor.monitoring_task")
2701     @patch("osm_ng_ro.monitor.threading.Timer")
2702     @patch("osm_ng_ro.monitor.MonitorVms")
2703     def test_start_monitoring_timer_thread_raises(
2704         self, mock_monitor_vms, mock_threading_timer, mock_monitoring_task
2705     ):
2706         mock_threading_timer.side_effect = RuntimeError(
2707             "cannot release un-acquired lock"
2708         )
2709         mock_monitor_vms.return_value.refresh_config.active = 2
2710         with self.assertRaises(RuntimeError) as err:
2711             start_monitoring(config)
2712         self.assertEqual(str(err.exception), "cannot release un-acquired lock")
2713         mock_monitor_vms.assert_called_once_with(config)
2714         mock_monitor_vms.return_value.run.assert_called_once()
2715         mock_threading_timer.assert_called_once_with(
2716             2, start_monitoring, args=(config,)
2717         )
2718         mock_monitoring_task.start.assert_not_called()
2719
2720     @patch("osm_ng_ro.monitor.monitoring_task")
2721     def test_stop_monitoring(self, mock_monitoring_task):
2722         mock_monitoring_task.return_value = CopyingMock(threading.Timer)
2723         stop_monitoring()
2724         self.assertIsNotNone(mock_monitoring_task)
2725         mock_monitoring_task.cancel.assert_called_once()
2726
2727     @patch("osm_ng_ro.monitor.monitoring_task")
2728     def test_stop_monitoring_no_task(self, mock_monitoring_task):
2729         mock_monitoring_task = CopyingMock(threading.Timer, return_value=None)
2730         stop_monitoring()
2731         mock_monitoring_task.cancel.assert_not_called()
2732
2733
2734 if __name__ == "__main__":
2735     unittest.main()