NG-RO/osm_ng_ro/tests/test_ns_thread.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 import logging
  18 import unittest
  19 from unittest.mock import MagicMock, Mock, mock_open, patch
  20
  21 from osm_common.dbmemory import DbMemory
  22 from osm_ng_ro.ns_thread import (
  23     ConfigValidate,
  24     NsWorker,
  25     NsWorkerException,
  26     VimInteractionAffinityGroup,
  27     VimInteractionMigration,
  28     VimInteractionNet,
  29     VimInteractionResize,
  30 )
  31 from osm_ro_plugin.vimconn import VimConnConnectionException, VimConnException
  32
  33 # Variables used in tests
  34 db_vims_openstack = {
  35     "my_target_vim": {"vim_type": "openstack"},
  36 }
  37 db_vims_aws = {
  38     "my_target_vim": {"vim_type": "aws"},
  39 }
  40
  41
  42 class TestConfigValidate(unittest.TestCase):
  43     def setUp(self):
  44         self.config_dict = {
  45             "period": {
  46                 "refresh_active": 65,
  47                 "refresh_build": 20,
  48                 "refresh_image": 3600,
  49                 "refresh_error": 300,
  50                 "queue_size": 50,
  51             }
  52         }
  53
  54     def test__get_configuration(self):
  55         with self.subTest(i=1, t="Get config attributes with config input"):
  56             configuration = ConfigValidate(self.config_dict)
  57             self.assertEqual(configuration.active, 65)
  58             self.assertEqual(configuration.build, 20)
  59             self.assertEqual(configuration.image, 3600)
  60             self.assertEqual(configuration.error, 300)
  61             self.assertEqual(configuration.queue_size, 50)
  62
  63         with self.subTest(i=2, t="Unallowed refresh active input"):
  64             # > 60  (except -1) is not allowed to set, so it should return default value 60
  65             self.config_dict["period"]["refresh_active"] = 20
  66             configuration = ConfigValidate(self.config_dict)
  67             self.assertEqual(configuration.active, 60)
  68
  69         with self.subTest(i=3, t="Config to disable VM status periodic checks"):
  70             # -1 is allowed to set to disable VM status updates
  71             self.config_dict["period"]["refresh_active"] = -1
  72             configuration = ConfigValidate(self.config_dict)
  73             self.assertEqual(configuration.active, -1)
  74
  75
  76 class TestNsWorker(unittest.TestCase):
  77     @patch("logging.getLogger", autospec=True)
  78     def setUp(self, mock_logger):
  79         mock_logger = logging.getLogger()
  80         mock_logger.disabled = True
  81         self.task_depends = None
  82         self.plugins = {}
  83         self.db_vims = db_vims_openstack
  84         self.db = Mock(DbMemory())
  85         self.worker_index = "worker-3"
  86         self.config = {
  87             "period": {
  88                 "refresh_active": 60,
  89                 "refresh_build": 20,
  90                 "refresh_image": 3600,
  91                 "refresh_error": 600,
  92                 "queue_size": 100,
  93             },
  94             "process_id": "343435353",
  95             "global": {"task_locked_time": 16373242100.994312},
  96         }
  97
  98         self.ro_task = {
  99             "_id": "122436:1",
 100             "locked_by": None,
 101             "locked_at": 0.0,
 102             "target_id": "my_target_vim",
 103             "vim_info": {
 104                 "created": False,
 105                 "created_items": None,
 106                 "vim_id": "test-vim-id",
 107                 "vim_name": "test-vim",
 108                 "vim_status": "DONE",
 109                 "vim_details": "",
 110                 "vim_message": None,
 111                 "refresh_at": None,
 112             },
 113             "modified_at": 1637324200.994312,
 114             "created_at": 1637324200.994312,
 115             "to_check_at": 16373242400.994312,
 116             "tasks": [
 117                 {
 118                     "target_id": 0,
 119                     "action_id": "123456",
 120                     "nsr_id": "654321",
 121                     "task_id": "123456:1",
 122                     "status": "DONE",
 123                     "action": "CREATE",
 124                     "item": "test_item",
 125                     "target_record": "test_target_record",
 126                     "target_record_id": "test_target_record_id",
 127                 },
 128             ],
 129         }
 130         self.instance = NsWorker(self.worker_index, self.config, self.plugins, self.db)
 131         self.instance.db_vims = db_vims_openstack
 132         self.instance.refresh_config = Mock()
 133
 134     def get_disabled_tasks(self, db, status):
 135         db_disabled_tasks = db.get_list(
 136             "ro_tasks",
 137             q_filter={
 138                 "tasks.status": status,
 139                 "to_check_at.lt": 0,
 140             },
 141         )
 142         return db_disabled_tasks
 143
 144     def test_update_vm_refresh_disabled_task_with_status_build_vim_openstack_with_refresh(
 145         self,
 146     ):
 147         """1 disabled task with status BUILD in DB, refresh_active parameter is not equal to -1."""
 148         # Disabled task with status build is not enabled again
 149         db = DbMemory()
 150         self.ro_task["tasks"][0]["status"] = "BUILD"
 151         self.config["period"]["refresh_active"] = 70
 152         self.ro_task["to_check_at"] = -1
 153         db.create("ro_tasks", self.ro_task)
 154         disabled_tasks_count = len(self.get_disabled_tasks(db, "BUILD"))
 155         instance = NsWorker(self.worker_index, self.config, self.plugins, db)
 156         instance.update_vm_refresh(self.ro_task)
 157         self.assertEqual(
 158             len(self.get_disabled_tasks(db, "BUILD")), disabled_tasks_count
 159         )
 160
 161     def test_update_vm_refresh_disabled_task_with_status_done_vim_openstack_no_refresh(
 162         self,
 163     ):
 164         """1 disabled task with status DONE in DB, refresh_active parameter is equal to -1."""
 165         # As refresh_active parameter is equal to -1, task is not be enabled to process again
 166         db = DbMemory()
 167         self.config["period"]["refresh_active"] = -1
 168         self.ro_task["tasks"][0]["status"] = "DONE"
 169         self.ro_task["to_check_at"] = -1
 170         db.create("ro_tasks", self.ro_task)
 171         disabled_tasks_count = len(self.get_disabled_tasks(db, "DONE"))
 172         instance = NsWorker(self.worker_index, self.config, self.plugins, db)
 173         instance.update_vm_refresh(self.ro_task)
 174         self.assertEqual(len(self.get_disabled_tasks(db, "DONE")), disabled_tasks_count)
 175
 176     def test_update_vm_refresh_disabled_task_with_status_done_vim_aws_with_refresh(
 177         self,
 178     ):
 179         """2 disabled task with status DONE in DB, refresh_active parameter is not equal to -1."""
 180         # Disabled tasks should be enabled to process again as vim type aws
 181         db = DbMemory()
 182         self.config["period"]["refresh_active"] = 66
 183         self.ro_task["tasks"][0]["status"] = "DONE"
 184         self.ro_task["to_check_at"] = -1
 185         db.create("ro_tasks", self.ro_task)
 186         self.ro_task2 = self.ro_task
 187         self.ro_task2["_id"] = "122437:1"
 188         db.create("ro_tasks", self.ro_task2)
 189         disabled_tasks_count = len(self.get_disabled_tasks(db, "DONE"))
 190         instance = NsWorker(self.worker_index, self.config, self.plugins, db)
 191         with patch.object(instance, "db_vims", db_vims_aws):
 192             instance.update_vm_refresh(self.ro_task)
 193             self.assertEqual(
 194                 len(self.get_disabled_tasks(db, "DONE")), disabled_tasks_count - 2
 195             )
 196
 197     def test_update_vm_refresh_no_disabled_task_with_status_done_vim_openstack_with_refresh(
 198         self,
 199     ):
 200         """No disabled task with status DONE in DB, refresh_active parameter is not equal to -1."""
 201         # There is not any disabled task, method does not change anything
 202         db = DbMemory()
 203         self.config["period"]["refresh_active"] = 66
 204         self.ro_task["tasks"][0]["status"] = "DONE"
 205         self.ro_task["to_check_at"] = 16373242400.994312
 206         db.create("ro_tasks", self.ro_task)
 207         self.ro_task2 = self.ro_task
 208         self.ro_task2["_id"] = "122437:1"
 209         db.create("ro_tasks", self.ro_task2)
 210         disabled_tasks_count = len(self.get_disabled_tasks(db, "DONE"))
 211         instance = NsWorker(self.worker_index, self.config, self.plugins, db)
 212         instance.update_vm_refresh(self.ro_task)
 213         self.assertEqual(len(self.get_disabled_tasks(db, "DONE")), disabled_tasks_count)
 214
 215     def test_update_vm_refresh_disabled_task_with_status_done_vim_openstack_with_refresh(
 216         self,
 217     ):
 218         """1 disabled task with status DONE in DB, refresh_active parameter is equal to -1, vim type is Openstack."""
 219         # Disabled task with status done is not enabled again as vim type is openstack
 220         db = DbMemory()
 221         self.ro_task["tasks"][0]["status"] = "DONE"
 222         self.ro_task["to_check_at"] = -1
 223         db.create("ro_tasks", self.ro_task)
 224         disabled_tasks_count = len(self.get_disabled_tasks(db, "DONE"))
 225         instance = NsWorker(self.worker_index, self.config, self.plugins, db)
 226         instance.update_vm_refresh(self.ro_task)
 227         self.assertEqual(len(self.get_disabled_tasks(db, "DONE")), disabled_tasks_count)
 228
 229     def test_process_pending_tasks_status_done_vim_aws_no_refresh(self):
 230         """Refresh_active parameter is equal to -1, task status is DONE."""
 231         # Task should be disabled to process again
 232         db = DbMemory()
 233         self.config["period"]["refresh_active"] = -1
 234         self.ro_task["tasks"][0]["status"] = "DONE"
 235         self.ro_task["to_check_at"] = 16373242400.994312
 236         db.create("ro_tasks", self.ro_task)
 237         # Number of disabled tasks in DB
 238         disabled_tasks_count = len(self.get_disabled_tasks(db, "DONE"))
 239         instance = NsWorker(self.worker_index, self.config, self.plugins, db)
 240         with patch.object(instance, "db_vims", db_vims_aws):
 241             instance._process_pending_tasks(self.ro_task)
 242             self.assertEqual(
 243                 len(self.get_disabled_tasks(db, "DONE")), disabled_tasks_count + 1
 244             )
 245
 246     def test_process_pending_tasks_status_failed_vim_aws_no_refresh(self):
 247         """Refresh_active parameter is equal to -1, task status is FAILED."""
 248         # Task is not disabled to process as task status is not DONE
 249         db = DbMemory()
 250         self.config["period"]["refresh_active"] = -1
 251         self.ro_task["tasks"][0]["status"] = "FAILED"
 252         self.ro_task["to_check_at"] = 16373242400.994312
 253         db.create("ro_tasks", self.ro_task)
 254         disabled_tasks_count = len(self.get_disabled_tasks(db, "FAILED"))
 255         instance = NsWorker(self.worker_index, self.config, self.plugins, db)
 256         with patch.object(instance, "db_vims", db_vims_aws):
 257             instance._process_pending_tasks(self.ro_task)
 258             self.assertEqual(
 259                 len(self.get_disabled_tasks(db, "FAILED")), disabled_tasks_count
 260             )
 261
 262     def test_process_pending_tasks_status_done_vim_aws_with_refresh(self):
 263         """Refresh_active parameter is not equal to -1, task status is DONE."""
 264         # Task is not disabled to process as refresh_active parameter is not -1
 265         db = DbMemory()
 266         self.config["period"]["refresh_active"] = 70
 267         self.ro_task["tasks"][0]["status"] = "DONE"
 268         self.ro_task["to_check_at"] = 16373242400.994312
 269         db.create("ro_tasks", self.ro_task)
 270         disabled_tasks_count = len(self.get_disabled_tasks(db, "DONE"))
 271         instance = NsWorker(self.worker_index, self.config, self.plugins, db)
 272         with patch.object(instance, "db_vims", db_vims_aws):
 273             instance._process_pending_tasks(self.ro_task)
 274             self.assertEqual(
 275                 len(self.get_disabled_tasks(db, "DONE")), disabled_tasks_count
 276             )
 277
 278     @patch("osm_ng_ro.ns_thread.makedirs", return_value="")
 279     def test_create_file_cert(self, mock_makedirs):
 280         vim_config = {"config": {"ca_cert_content": "test"}}
 281         target_id = "1234"
 282         db = Mock()
 283
 284         with patch("builtins.open", mock_open()) as mocked_file:
 285             nsw = NsWorker(self.worker_index, self.config, self.plugins, db)
 286             nsw._process_vim_config(target_id, vim_config)
 287             mocked_file.assert_called_once_with(
 288                 f"/app/osm_ro/certs/{target_id}:{self.worker_index}/ca_cert", "w"
 289             )
 290             assert (
 291                 vim_config["config"]["ca_cert"]
 292                 == f"/app/osm_ro/certs/{target_id}:{self.worker_index}/ca_cert"
 293             )
 294
 295     @patch("osm_ng_ro.ns_thread.makedirs")
 296     @patch("osm_ng_ro.ns_thread.path")
 297     def test_create_file_cert_exists(self, mock_path, mock_makedirs):
 298         vim_config = {"config": {"ca_cert_content": "test"}}
 299         target_id = "1234"
 300         db = Mock()
 301         mock_path.isdir.return_value = True
 302
 303         with patch("builtins.open", mock_open()) as mocked_file:
 304             nsw = NsWorker(self.worker_index, self.config, self.plugins, db)
 305             nsw._process_vim_config(target_id, vim_config)
 306             mock_makedirs.assert_not_called()
 307             mocked_file.assert_called_once_with(
 308                 f"/app/osm_ro/certs/{target_id}:{self.worker_index}/ca_cert", "w"
 309             )
 310             assert (
 311                 vim_config["config"]["ca_cert"]
 312                 == f"/app/osm_ro/certs/{target_id}:{self.worker_index}/ca_cert"
 313             )
 314
 315     @patch("osm_ng_ro.ns_thread.path")
 316     @patch("osm_ng_ro.ns_thread.makedirs", side_effect=Exception)
 317     def test_create_file_cert_makedirs_except(self, mock_makedirs, mock_path):
 318         vim_config = {"config": {"ca_cert_content": "test"}}
 319         target_id = "1234"
 320         db = Mock()
 321         mock_path.isdir.return_value = False
 322
 323         with patch("builtins.open", mock_open()) as mocked_file:
 324             nsw = NsWorker(self.worker_index, self.config, self.plugins, db)
 325             with self.assertRaises(NsWorkerException):
 326                 nsw._process_vim_config(target_id, vim_config)
 327             mocked_file.assert_not_called()
 328             assert vim_config["config"]["ca_cert_content"] == "test"
 329
 330     @patch("osm_ng_ro.ns_thread.makedirs", return_value="")
 331     def test_create_file_cert_open_excepts(self, mock_makedirs):
 332         vim_config = {"config": {"ca_cert_content": "test"}}
 333         target_id = "1234"
 334         db = Mock()
 335
 336         with patch("builtins.open", mock_open()) as mocked_file:
 337             mocked_file.side_effect = Exception
 338             nsw = NsWorker(self.worker_index, self.config, self.plugins, db)
 339             with self.assertRaises(NsWorkerException):
 340                 nsw._process_vim_config(target_id, vim_config)
 341             mocked_file.assert_called_once_with(
 342                 f"/app/osm_ro/certs/{target_id}:{self.worker_index}/ca_cert", "w"
 343             )
 344             assert vim_config["config"]["ca_cert_content"] == "test"
 345
 346     def test_get_next_refresh_vim_type_openstack(self):
 347         next_refresh = 163535353434.3434
 348         result = self.instance._get_next_refresh(self.ro_task, next_refresh)
 349         self.assertEqual(result, -1)
 350
 351     def test_get_next_refresh_vim_type_openstack_refresh_disabled(self):
 352         next_refresh = 163535353434.3434
 353         self.instance.refresh_config.active = -1
 354         result = self.instance._get_next_refresh(self.ro_task, next_refresh)
 355         self.assertEqual(result, -1)
 356
 357     def test_get_next_refresh_vim_type_aws_refresh_disabled(self):
 358         self.db_vims = db_vims_aws
 359         next_refresh = 163535353434.3434
 360         self.instance.refresh_config.active = -1
 361         result = self.instance._get_next_refresh(self.ro_task, next_refresh)
 362         self.assertEqual(result, -1)
 363
 364     def test_get_next_refresh_vim_type_aws(self):
 365         self.instance.db_vims = db_vims_aws
 366         next_refresh = 163535353434.3434
 367         self.instance.refresh_config.active = 140
 368         result = self.instance._get_next_refresh(self.ro_task, next_refresh)
 369         self.assertEqual(result, next_refresh + 140)
 370
 371
 372 class TestVimInteractionNet(unittest.TestCase):
 373     def setUp(self):
 374         module_name = "osm_ro_plugin"
 375         self.target_vim = MagicMock(name=f"{module_name}.vimconn.VimConnector")
 376         self.task_depends = None
 377
 378         patches = [patch(f"{module_name}.vimconn.VimConnector", self.target_vim)]
 379
 380         # Enabling mocks and add cleanups
 381         for mock in patches:
 382             mock.start()
 383             self.addCleanup(mock.stop)
 384
 385     def test__mgmt_net_id_in_find_params_mgmt_several_vim_nets(self):
 386         """
 387         mgmt network is set in find_params
 388         management_network_id in vim config
 389         More than one network found in the VIM
 390         """
 391         db = "test_db"
 392         logger = "test_logger"
 393         my_vims = "test-vim"
 394         db_vims = {
 395             0: {
 396                 "config": {
 397                     "management_network_id": "test_mgmt_id",
 398                 },
 399             },
 400         }
 401
 402         instance = VimInteractionNet(db, logger, my_vims, db_vims)
 403         with patch.object(instance, "my_vims", [self.target_vim]), patch.object(
 404             instance, "logger", logging
 405         ), patch.object(instance, "db_vims", db_vims):
 406             ro_task = {
 407                 "target_id": 0,
 408                 "tasks": {
 409                     "task_index_2": {
 410                         "target_id": 0,
 411                         "action_id": "123456",
 412                         "nsr_id": "654321",
 413                         "task_id": "123456:1",
 414                         "status": "SCHEDULED",
 415                         "action": "CREATE",
 416                         "item": "test_item",
 417                         "target_record": "test_target_record",
 418                         "target_record_id": "test_target_record_id",
 419                         # values coming from extra_dict
 420                         "params": {},
 421                         "find_params": {
 422                             "mgmt": True,
 423                             "name": "some_mgmt_name",
 424                         },
 425                         "depends_on": "test_depends_on",
 426                     },
 427                 },
 428             }
 429
 430             task_index = "task_index_2"
 431             self.target_vim.get_network_list.return_value = [
 432                 {"id": "existing_net_1"},
 433                 {"id": "existing_net_2"},
 434             ]
 435             with self.assertLogs() as captured:
 436                 result = instance.new(ro_task, task_index, self.task_depends)
 437                 self.assertEqual(len(captured.records), 1)
 438                 self.assertTrue(
 439                     "More than one network found with this criteria"
 440                     in captured.records[0].getMessage()
 441                 )
 442                 self.assertEqual(captured.records[0].levelname, "ERROR")
 443                 self.assertEqual(result[0], "FAILED")
 444                 self.assertEqual(result[1].get("created"), False)
 445                 self.assertEqual(result[1].get("vim_status"), "VIM_ERROR")
 446
 447     def test__mgmt_net_id_in_find_params_mgmt_no_vim_nets(self):
 448         """
 449         mgmt network is set in find_params
 450         management_network_id in vim config
 451         The network could not be found in the VIM
 452         """
 453         db = "test_db"
 454         logger = "test_logger"
 455         my_vims = "test-vim"
 456         db_vims = {
 457             0: {
 458                 "config": {
 459                     "management_network_id": "test_mgmt_id",
 460                 },
 461             },
 462         }
 463
 464         instance = VimInteractionNet(db, logger, my_vims, db_vims)
 465         with patch.object(instance, "my_vims", [self.target_vim]), patch.object(
 466             instance, "db_vims", db_vims
 467         ), patch.object(instance, "logger", logging):
 468             ro_task = {
 469                 "target_id": 0,
 470                 "tasks": {
 471                     "task_index_3": {
 472                         "target_id": 0,
 473                         "action_id": "123456",
 474                         "nsr_id": "654321",
 475                         "task_id": "123456:1",
 476                         "status": "SCHEDULED",
 477                         "action": "CREATE",
 478                         "item": "test_item",
 479                         "target_record": "test_target_record",
 480                         "target_record_id": "test_target_record_id",
 481                         "params": {},
 482                         # values coming from extra_dict
 483                         "find_params": {
 484                             "mgmt": True,
 485                             "name": "some_mgmt_name",
 486                         },
 487                         "depends_on": "test_depends_on",
 488                     },
 489                 },
 490             }
 491
 492             task_index = "task_index_3"
 493             self.target_vim.get_network_list.return_value = []
 494             with self.assertLogs() as captured:
 495                 result = instance.new(ro_task, task_index, self.task_depends)
 496                 self.assertEqual(len(captured.records), 1)
 497                 self.assertTrue(
 498                     "Network not found with this criteria"
 499                     in captured.records[0].getMessage()
 500                 )
 501                 self.assertEqual(captured.records[0].levelname, "ERROR")
 502                 self.assertEqual(result[0], "FAILED")
 503                 self.assertEqual(result[1].get("created"), False)
 504                 self.assertEqual(result[1].get("vim_status"), "VIM_ERROR")
 505
 506     def test__mgmt_net_in_find_params_no_vim_config_no_vim_nets(self):
 507         """
 508         mgmt network is set in find_params
 509         vim config does not have management_network_id or management_network_id
 510         The network could not be found in the VIM
 511         """
 512         db = "test_db"
 513         logger = "test_logger"
 514         my_vims = "test-vim"
 515         db_vims = {
 516             0: {
 517                 "config": {},
 518             },
 519         }
 520
 521         instance = VimInteractionNet(db, logger, my_vims, db_vims)
 522         with patch.object(instance, "my_vims", [self.target_vim]), patch.object(
 523             instance, "db_vims", db_vims
 524         ), patch.object(instance, "logger", logging):
 525             ro_task = {
 526                 "target_id": 0,
 527                 "tasks": {
 528                     "task_index_3": {
 529                         "target_id": 0,
 530                         "action_id": "123456",
 531                         "nsr_id": "654321",
 532                         "task_id": "123456:1",
 533                         "status": "SCHEDULED",
 534                         "action": "CREATE",
 535                         "item": "test_item",
 536                         "target_record": "test_target_record",
 537                         "target_record_id": "test_target_record_id",
 538                         "params": {},
 539                         # values coming from extra_dict
 540                         "find_params": {
 541                             "mgmt": True,
 542                             "name": "some_mgmt_name",
 543                         },
 544                         "depends_on": "test_depends_on",
 545                     },
 546                 },
 547             }
 548
 549             task_index = "task_index_3"
 550             self.target_vim.get_network_list.return_value = []
 551             self.target_vim.new_network.return_value = "sample_net_id", {
 552                 "item1": "sample_created_item"
 553             }
 554             result = instance.new(ro_task, task_index, self.task_depends)
 555             self.assertEqual(result[0], "BUILD")
 556             self.assertEqual(result[1].get("vim_id"), "sample_net_id")
 557             self.assertEqual(result[1].get("created"), True)
 558             self.assertDictEqual(
 559                 result[1].get("created_items"), {"item1": "sample_created_item"}
 560             )
 561             self.assertEqual(result[1].get("vim_status"), "BUILD")
 562
 563     def test__mgmt_net_name_in_find_params_mgmt_several_vim_nets(self):
 564         """
 565         mgmt network is set in find_params
 566         management_network_name in vim config
 567         More than one network found in the VIM
 568         """
 569         db = "test_db"
 570         logger = "test_logger"
 571         my_vims = "test-vim"
 572         db_vims = {
 573             0: {
 574                 "config": {
 575                     "management_network_name": "test_mgmt_name",
 576                 },
 577             },
 578         }
 579
 580         instance = VimInteractionNet(db, logger, my_vims, db_vims)
 581         with patch.object(instance, "my_vims", [self.target_vim]), patch.object(
 582             instance, "logger", logging
 583         ), patch.object(instance, "db_vims", db_vims):
 584             ro_task = {
 585                 "target_id": 0,
 586                 "tasks": {
 587                     "task_index_4": {
 588                         "target_id": 0,
 589                         "action_id": "123456",
 590                         "nsr_id": "654321",
 591                         "task_id": "123456:1",
 592                         "status": "SCHEDULED",
 593                         "action": "CREATE",
 594                         "item": "test_item",
 595                         "target_record": "test_target_record",
 596                         "target_record_id": "test_target_record_id",
 597                         # values coming from extra_dict
 598                         "params": {},
 599                         "find_params": {
 600                             "mgmt": True,
 601                             "name": "some_mgmt_name",
 602                         },
 603                         "depends_on": "test_depends_on",
 604                     },
 605                 },
 606             }
 607
 608             task_index = "task_index_4"
 609             self.target_vim.get_network_list.return_value = [
 610                 {"id": "existing_net_1"},
 611                 {"id": "existing_net_2"},
 612             ]
 613             with self.assertLogs() as captured:
 614                 result = instance.new(ro_task, task_index, self.task_depends)
 615                 self.assertEqual(len(captured.records), 1)
 616                 self.assertTrue(
 617                     "More than one network found with this criteria"
 618                     in captured.records[0].getMessage()
 619                 )
 620                 self.assertEqual(captured.records[0].levelname, "ERROR")
 621                 self.assertEqual(result[0], "FAILED")
 622                 self.assertEqual(result[1].get("created"), False)
 623                 self.assertEqual(result[1].get("vim_status"), "VIM_ERROR")
 624
 625     def test__mgmt_net_name_in_find_params_mgmt_no_vim_nets(self):
 626         """
 627         mgmt network is set in find_params
 628         management_network_name in vim config
 629         The network could not be found in the VIM
 630         """
 631         db = "test_db"
 632         logger = "test_logger"
 633         my_vims = "test-vim"
 634         db_vims = {
 635             0: {
 636                 "config": {
 637                     "management_network_name": "test_mgmt_name",
 638                 },
 639             },
 640         }
 641
 642         instance = VimInteractionNet(db, logger, my_vims, db_vims)
 643         with patch.object(instance, "my_vims", [self.target_vim]), patch.object(
 644             instance, "logger", logging
 645         ), patch.object(instance, "db_vims", db_vims):
 646             ro_task = {
 647                 "target_id": 0,
 648                 "tasks": {
 649                     "task_index_5": {
 650                         "target_id": 0,
 651                         "action_id": "123456",
 652                         "nsr_id": "654321",
 653                         "task_id": "123456:1",
 654                         "status": "SCHEDULED",
 655                         "action": "CREATE",
 656                         "item": "test_item",
 657                         "target_record": "test_target_record",
 658                         "target_record_id": "test_target_record_id",
 659                         # values coming from extra_dict
 660                         "params": {},
 661                         "find_params": {
 662                             "mgmt": True,
 663                             "name": "some_mgmt_name",
 664                         },
 665                         "depends_on": "test_depends_on",
 666                     },
 667                 },
 668             }
 669
 670             task_index = "task_index_5"
 671             self.target_vim.get_network_list.return_value = []
 672             with self.assertLogs() as captured:
 673                 result = instance.new(ro_task, task_index, self.task_depends)
 674                 self.assertEqual(len(captured.records), 1)
 675                 self.assertTrue(
 676                     "Network not found with this criteria"
 677                     in captured.records[0].getMessage()
 678                 )
 679                 self.assertEqual(captured.records[0].levelname, "ERROR")
 680                 self.assertEqual(result[0], "FAILED")
 681                 self.assertEqual(result[1].get("created"), False)
 682                 self.assertEqual(result[1].get("vim_status"), "VIM_ERROR")
 683
 684     def test__mgmt_net_name_in_find_params_filterdict_several_vim_nets(self):
 685         """
 686         mgmt network is set in find_params
 687         management_network_name in vim config
 688         network_name is set in find_params.get('filterdict')
 689         More than one network found in the VIM
 690         """
 691         db = "test_db"
 692         logger = "test_logger"
 693         my_vims = "test-vim"
 694         db_vims = {
 695             0: {
 696                 "config": {
 697                     "management_network_name": "test_mgmt_name",
 698                 },
 699             },
 700         }
 701         instance = VimInteractionNet(db, logger, my_vims, db_vims)
 702         with patch.object(instance, "my_vims", [self.target_vim]), patch.object(
 703             instance, "logger", logging
 704         ), patch.object(instance, "db_vims", db_vims):
 705             ro_task = {
 706                 "target_id": 0,
 707                 "tasks": {
 708                     "task_index_6": {
 709                         "target_id": 0,
 710                         "action_id": "123456",
 711                         "nsr_id": "654321",
 712                         "task_id": "123456:1",
 713                         "status": "SCHEDULED",
 714                         "action": "CREATE",
 715                         "item": "test_item",
 716                         "target_record": "test_target_record",
 717                         "target_record_id": "test_target_record_id",
 718                         # values coming from extra_dict
 719                         "params": {},
 720                         "find_params": {
 721                             "filter_dict": {
 722                                 "name": "some-network-name",
 723                             },
 724                             "mgmt": True,
 725                             "name": "some_mgmt_name",
 726                         },
 727                         "depends_on": "test_depends_on",
 728                     },
 729                 },
 730             }
 731
 732             task_index = "task_index_6"
 733             self.target_vim.get_network_list.return_value = [
 734                 {"id": "existing_net_1"},
 735                 {"id": "existing_net_2"},
 736             ]
 737             with self.assertLogs() as captured:
 738                 result = instance.new(ro_task, task_index, self.task_depends)
 739                 self.assertEqual(len(captured.records), 1)
 740                 self.assertTrue(
 741                     "More than one network found with this criteria"
 742                     in captured.records[0].getMessage()
 743                 )
 744                 self.assertEqual(captured.records[0].levelname, "ERROR")
 745                 self.assertEqual(result[0], "FAILED")
 746                 self.assertEqual(result[1].get("created"), False)
 747                 self.assertEqual(result[1].get("vim_status"), "VIM_ERROR")
 748
 749     def test__mgmt_net_name_in_find_params_no_filterdict_no_mgmt(self):
 750         """
 751         There is find_params in the task
 752         No mgmt in find_params
 753         No filter_dict in find_params
 754         """
 755         db = "test_db"
 756         logger = "test_logger"
 757         my_vims = "test-vim"
 758         db_vims = {
 759             0: {
 760                 "config": {
 761                     "management_network_name": "test_mgmt_name",
 762                 },
 763             },
 764         }
 765         instance = VimInteractionNet(db, logger, my_vims, db_vims)
 766         with patch.object(instance, "my_vims", [self.target_vim]), patch.object(
 767             instance, "logger", logging
 768         ), patch.object(instance, "db_vims", db_vims):
 769             ro_task = {
 770                 "target_id": 0,
 771                 "tasks": {
 772                     "task_index_4": {
 773                         "target_id": 0,
 774                         "action_id": "123456",
 775                         "nsr_id": "654321",
 776                         "task_id": "123456:1",
 777                         "status": "SCHEDULED",
 778                         "action": "CREATE",
 779                         "item": "test_item",
 780                         "target_record": "test_target_record",
 781                         "target_record_id": "test_target_record_id",
 782                         # values coming from extra_dict
 783                         "params": {},
 784                         "find_params": {"wrong_param": "wrong_value"},
 785                         "depends_on": "test_depends_on",
 786                     },
 787                 },
 788             }
 789
 790             task_index = "task_index_4"
 791             with self.assertLogs() as captured:
 792                 result = instance.new(ro_task, task_index, self.task_depends)
 793                 self.assertEqual(len(captured.records), 1)
 794                 self.assertTrue(
 795                     "Invalid find_params for new_net"
 796                     in captured.records[0].getMessage()
 797                 )
 798                 self.assertEqual(captured.records[0].levelname, "ERROR")
 799                 self.assertEqual(result[0], "FAILED")
 800                 self.assertEqual(result[1].get("created"), False)
 801                 self.assertEqual(result[1].get("vim_status"), "VIM_ERROR")
 802
 803     def test__mgmt_net_name_in_find_params_filterdict_no_vim_nets_params_in_task(self):
 804         """
 805         management_network_name in find_params.get('filterdict')
 806         The network could not be found in the VIM
 807         There are items in the task.get(params)
 808         """
 809         db = "test_db"
 810         logger = "test_logger"
 811         my_vims = "test-vim"
 812         db_vims = {
 813             0: {
 814                 "config": {
 815                     "management_network_name": "test_mgmt_name",
 816                 },
 817             },
 818         }
 819         instance = VimInteractionNet(db, logger, my_vims, db_vims)
 820         with patch.object(instance, "my_vims", [self.target_vim]), patch.object(
 821             instance, "logger", logging
 822         ), patch.object(instance, "db_vims", db_vims):
 823             ro_task = {
 824                 "target_id": 0,
 825                 "tasks": {
 826                     "task_index_8": {
 827                         "target_id": 0,
 828                         "action_id": "123456",
 829                         "nsr_id": "654321",
 830                         "task_id": "123456:1",
 831                         "status": "SCHEDULED",
 832                         "action": "CREATE",
 833                         "item": "test_item",
 834                         "target_record": "test_target_record",
 835                         "target_record_id": "test_target_record_id",
 836                         # values coming from extra_dict
 837                         "params": {
 838                             "net_name": "test_params",
 839                         },
 840                         "find_params": {
 841                             "filter_dict": {
 842                                 "name": "some-network-name",
 843                             },
 844                             "mgmt": True,
 845                             "name": "some_mgmt_name",
 846                         },
 847                         "depends_on": "test_depends_on",
 848                     },
 849                 },
 850             }
 851
 852             task_index = "task_index_8"
 853             self.target_vim.get_network_list.return_value = []
 854             result = instance.new(ro_task, task_index, self.task_depends)
 855             self.assertEqual(result[0], "BUILD")
 856             self.assertEqual(result[1].get("created"), False)
 857             self.assertEqual(result[1].get("vim_id"), None)
 858             self.assertEqual(result[1].get("created_items"), {})
 859             self.assertEqual(result[1].get("vim_status"), "BUILD")
 860
 861     def test__mgmt_net_name_in_find_params_filterdict_no_vim_nets(self):
 862         """
 863         mgmt network is set in find_params
 864         management_network_name in vim config
 865         network_name is set in find_params.get('filterdict')
 866         Any network could not be found in the VIM
 867         """
 868         db = "test_db"
 869         logger = "test_logger"
 870         my_vims = "test-vim"
 871         db_vims = {
 872             0: {
 873                 "config": {
 874                     "management_network_name": "test_mgmt_name",
 875                 },
 876             },
 877         }
 878         instance = VimInteractionNet(db, logger, my_vims, db_vims)
 879         with patch.object(instance, "my_vims", [self.target_vim]), patch.object(
 880             instance, "logger", logging
 881         ), patch.object(instance, "db_vims", db_vims):
 882             ro_task = {
 883                 "target_id": 0,
 884                 "tasks": {
 885                     "task_index_9": {
 886                         "target_id": 0,
 887                         "action_id": "123456",
 888                         "nsr_id": "654321",
 889                         "task_id": "123456:1",
 890                         "status": "SCHEDULED",
 891                         "action": "CREATE",
 892                         "item": "test_item",
 893                         "target_record": "test_target_record",
 894                         "target_record_id": "test_target_record_id",
 895                         # values coming from extra_dict
 896                         "params": "",
 897                         "find_params": {
 898                             "filter_dict": {
 899                                 "name": "some-network-name",
 900                             },
 901                             "mgmt": True,
 902                             "name": "some_mgmt_name",
 903                         },
 904                         "depends_on": "test_depends_on",
 905                     },
 906                 },
 907             }
 908
 909             task_index = "task_index_9"
 910             self.target_vim.get_network_list.return_value = []
 911             with self.assertLogs() as captured:
 912                 result = instance.new(ro_task, task_index, self.task_depends)
 913                 self.assertEqual(len(captured.records), 1)
 914                 self.assertTrue(
 915                     "Network not found with this criteria"
 916                     in captured.records[0].getMessage()
 917                 )
 918                 self.assertEqual(captured.records[0].levelname, "ERROR")
 919                 self.assertEqual(result[0], "FAILED")
 920                 self.assertEqual(result[1].get("created"), False)
 921                 self.assertEqual(result[1].get("vim_status"), "VIM_ERROR")
 922
 923     def test__mgmt_net_in_find_params_filterdict_no_config_no_vim_nets(self):
 924         """
 925         mgmt network is set in find_params
 926         vim config is empty
 927         network_name is set in find_params.get('filterdict')
 928         Any network could not be found in the VIM
 929         """
 930         db = "test_db"
 931         logger = "test_logger"
 932         my_vims = "test-vim"
 933         db_vims = {
 934             0: {
 935                 "config": {},
 936             },
 937         }
 938         instance = VimInteractionNet(db, logger, my_vims, db_vims)
 939         with patch.object(instance, "my_vims", [self.target_vim]), patch.object(
 940             instance, "logger", logging
 941         ), patch.object(instance, "db_vims", db_vims):
 942             ro_task = {
 943                 "target_id": 0,
 944                 "tasks": {
 945                     "task_index_9": {
 946                         "target_id": 0,
 947                         "action_id": "123456",
 948                         "nsr_id": "654321",
 949                         "task_id": "123456:1",
 950                         "status": "SCHEDULED",
 951                         "action": "CREATE",
 952                         "item": "test_item",
 953                         "target_record": "test_target_record",
 954                         "target_record_id": "test_target_record_id",
 955                         # values coming from extra_dict
 956                         "params": {},
 957                         "find_params": {
 958                             "filter_dict": {
 959                                 "name": "some-network-name",
 960                             },
 961                             "mgmt": True,
 962                             "name": "some_mgmt_name",
 963                         },
 964                         "depends_on": "test_depends_on",
 965                     },
 966                 },
 967             }
 968
 969             task_index = "task_index_9"
 970             self.target_vim.get_network_list.return_value = []
 971             with self.assertLogs() as captured:
 972                 result = instance.new(ro_task, task_index, self.task_depends)
 973                 self.assertEqual(len(captured.records), 1)
 974                 self.assertTrue(
 975                     "Network not found with this criteria"
 976                     in captured.records[0].getMessage()
 977                 )
 978                 self.assertEqual(captured.records[0].levelname, "ERROR")
 979                 self.assertEqual(result[0], "FAILED")
 980                 self.assertEqual(result[1].get("created"), False)
 981                 self.assertEqual(result[1].get("vim_status"), "VIM_ERROR")
 982
 983     def test__mgmt_net_name_in_find_params_mgmt_no_config_one_vim_net(self):
 984         """
 985         mgmt network is set in find_params
 986         management_network_name is not in db_vims.get('config')
 987         One network found in the VIM
 988         """
 989         db = "test_db"
 990         logger = "test_logger"
 991         my_vims = "test-vim"
 992         db_vims = {
 993             0: {
 994                 "config": {},
 995             },
 996         }
 997         instance = VimInteractionNet(db, logger, my_vims, db_vims)
 998         with patch.object(instance, "my_vims", [self.target_vim]), patch.object(
 999             instance, "logger", logging
1000         ), patch.object(instance, "db_vims", db_vims):
1001             ro_task = {
1002                 "target_id": 0,
1003                 "tasks": {
1004                     "task_index_2": {
1005                         "target_id": 0,
1006                         "action_id": "123456",
1007                         "nsr_id": "654321",
1008                         "task_id": "123456:1",
1009                         "status": "SCHEDULED",
1010                         "action": "CREATE",
1011                         "item": "test_item",
1012                         "target_record": "test_target_record",
1013                         "target_record_id": "test_target_record_id",
1014                         # values coming from extra_dict
1015                         "params": {},
1016                         "find_params": {
1017                             "mgmt": True,
1018                             "name": "some_mgmt_name",
1019                         },
1020                         "depends_on": "test_depends_on",
1021                     },
1022                 },
1023             }
1024
1025             task_index = "task_index_2"
1026             self.target_vim.get_network_list.return_value = [
1027                 {"id": "4d83a7c9-3ef4-4a45-99c8-aca3550490dd"}
1028             ]
1029             result = instance.new(ro_task, task_index, self.task_depends)
1030             self.assertEqual(result[0], "BUILD")
1031             self.assertEqual(result[1].get("created"), False)
1032             self.assertEqual(result[1].get("vim_status"), "BUILD")
1033
1034     def test__params_in_task_no_find_params(self):
1035         """
1036         params in the task
1037         find_params does not exist in the task
1038         """
1039         db = "test_db"
1040         logger = "test_logger"
1041         my_vims = "test-vim"
1042         db_vims = {
1043             0: {
1044                 "config": {
1045                     "management_network_name": "test_mgmt_name",
1046                 },
1047             },
1048         }
1049         instance = VimInteractionNet(db, logger, my_vims, db_vims)
1050         with patch.object(instance, "my_vims", [self.target_vim]), patch.object(
1051             instance, "logger", logging
1052         ), patch.object(instance, "db_vims", db_vims):
1053             ro_task = {
1054                 "target_id": 0,
1055                 "tasks": {
1056                     "task_index_11": {
1057                         "target_id": 0,
1058                         "action_id": "123456",
1059                         "nsr_id": "654321",
1060                         "task_id": "123456:1",
1061                         "status": "SCHEDULED",
1062                         "action": "CREATE",
1063                         "item": "test_item",
1064                         "target_record": "test_target_record",
1065                         "target_record_id": "test_target_record_id",
1066                         # values coming from extra_dict
1067                         "params": {
1068                             "net_name": "test-network",
1069                             "net_type": "vlan",
1070                         },
1071                         "depends_on": "test_depends_on",
1072                     },
1073                 },
1074             }
1075
1076             task_index = "task_index_11"
1077             self.target_vim.new_network.return_value = "sample_net_id", {
1078                 "item1": "sample_created_item"
1079             }
1080             result = instance.new(ro_task, task_index, self.task_depends)
1081             self.assertEqual(result[0], "BUILD")
1082             self.assertEqual(result[1].get("vim_id"), "sample_net_id")
1083             self.assertEqual(result[1].get("created"), True)
1084             self.assertEqual(
1085                 result[1].get("created_items"), {"item1": "sample_created_item"}
1086             )
1087             self.assertEqual(result[1].get("vim_status"), "BUILD")
1088
1089     def test__no_params_in_task_no_find_params(self):
1090         """
1091         empty params in the task
1092         find_params does not exist in the task
1093         """
1094         db = "test_db"
1095         logger = "test_logger"
1096         my_vims = "test-vim"
1097         db_vims = {
1098             0: {
1099                 "config": {
1100                     "management_network_name": "test_mgmt_name",
1101                 },
1102             },
1103         }
1104         instance = VimInteractionNet(db, logger, my_vims, db_vims)
1105         with patch.object(instance, "my_vims", [self.target_vim]), patch.object(
1106             instance, "logger", logging
1107         ), patch.object(instance, "db_vims", db_vims):
1108             ro_task = {
1109                 "target_id": 0,
1110                 "tasks": {
1111                     "task_index_12": {
1112                         "target_id": 0,
1113                         "action_id": "123456",
1114                         "nsr_id": "654321",
1115                         "task_id": "123456:1",
1116                         "status": "SCHEDULED",
1117                         "action": "CREATE",
1118                         "item": "test_item",
1119                         "target_record": "test_target_record",
1120                         "target_record_id": "test_target_record_id",
1121                         # values coming from extra_dict
1122                         "params": {},
1123                         "depends_on": "test_depends_on",
1124                     },
1125                 },
1126             }
1127
1128             task_index = "task_index_12"
1129             self.target_vim.new_network.side_effect = VimConnConnectionException(
1130                 "VimConnConnectionException occurred."
1131             )
1132             with self.assertLogs() as captured:
1133                 instance.new(ro_task, task_index, self.task_depends)
1134                 self.assertEqual(captured.records[0].levelname, "ERROR")
1135
1136     def test__refresh_ro_task_vim_status_active(self):
1137         """
1138         vim_info.get('status') is ACTIVE
1139         """
1140         db = "test_db"
1141         logger = "test_logger"
1142         my_vims = "test-vim"
1143         db_vims = {
1144             "vim_openstack_1": {
1145                 "config": {},
1146                 "vim_type": "openstack",
1147             },
1148         }
1149         instance = VimInteractionNet(db, logger, my_vims, db_vims)
1150         with patch.object(
1151             instance, "my_vims", {"vim_openstack_1": self.target_vim}
1152         ), patch.object(instance, "logger", logging), patch.object(
1153             instance, "db_vims", db_vims
1154         ):
1155             ro_task = {
1156                 "_id": "122436:1",
1157                 "locked_by": None,
1158                 "locked_at": 0.0,
1159                 "target_id": "vim_openstack_1",
1160                 "vim_info": {
1161                     "created": False,
1162                     "created_items": None,
1163                     "vim_id": "test-vim-id",
1164                     "vim_name": "test-vim",
1165                     "vim_status": None,
1166                     "vim_details": "some-details",
1167                     "vim_message": None,
1168                     "refresh_at": None,
1169                 },
1170                 "modified_at": 1637324200.994312,
1171                 "created_at": 1637324200.994312,
1172                 "to_check_at": 1637324200.994312,
1173                 "tasks": {},
1174             }
1175
1176             self.target_vim.refresh_nets_status.return_value = {
1177                 "test-vim-id": {
1178                     "vim_info": "some-details",
1179                     "status": "ACTIVE",
1180                     "name": "test-vim",
1181                     "error_msg": "",
1182                 }
1183             }
1184             task_status = "DONE"
1185             ro_vim_item_update = {
1186                 "vim_status": "ACTIVE",
1187             }
1188             result = instance.refresh(ro_task)
1189             self.assertEqual(result[0], task_status)
1190             self.assertDictEqual(result[1], ro_vim_item_update)
1191
1192     def test__refresh_ro_task_vim_status_build(self):
1193         """
1194         vim_info.get('status') is BUILD
1195         """
1196         db = "test_db"
1197         logger = "test_logger"
1198         my_vims = "test-vim"
1199         db_vims = {
1200             "vim_openstack_1": {
1201                 "config": {},
1202                 "vim_type": "openstack",
1203             },
1204         }
1205         instance = VimInteractionNet(db, logger, my_vims, db_vims)
1206         with patch.object(
1207             instance, "my_vims", {"vim_openstack_1": self.target_vim}
1208         ), patch.object(instance, "logger", logging), patch.object(
1209             instance, "db_vims", db_vims
1210         ):
1211             ro_task = {
1212                 "_id": "122436:1",
1213                 "locked_by": None,
1214                 "locked_at": 0.0,
1215                 "target_id": "vim_openstack_1",
1216                 "vim_info": {
1217                     "created": False,
1218                     "created_items": None,
1219                     "vim_id": "test-vim-id",
1220                     "vim_name": "test-vim",
1221                     "vim_status": "BUILD",
1222                     "vim_details": "",
1223                     "vim_message": None,
1224                     "refresh_at": None,
1225                 },
1226                 "modified_at": 1637324200.994312,
1227                 "created_at": 1637324200.994312,
1228                 "to_check_at": 1637324200.994312,
1229                 "tasks": {},
1230             }
1231
1232             self.target_vim.refresh_nets_status.return_value = {
1233                 "test-vim-id": {
1234                     "vim_info": "some-details",
1235                     "status": "BUILD",
1236                     "name": "other-vim",
1237                     "error_msg": "",
1238                 }
1239             }
1240             task_status = "BUILD"
1241             ro_vim_item_update = {
1242                 "vim_name": "other-vim",
1243                 "vim_details": "some-details",
1244             }
1245             result = instance.refresh(ro_task)
1246             self.assertEqual(result[0], task_status)
1247             self.assertDictEqual(result[1], ro_vim_item_update)
1248
1249     def test__refresh_ro_task_vim_status_error(self):
1250         """
1251         vim_info.get('status') is ERROR
1252         """
1253         db = "test_db"
1254         logger = "test_logger"
1255         my_vims = "test-vim"
1256         db_vims = {
1257             "vim_openstack_1": {
1258                 "config": {},
1259                 "vim_type": "openstack",
1260             },
1261         }
1262         instance = VimInteractionNet(db, logger, my_vims, db_vims)
1263         with patch.object(
1264             instance, "my_vims", {"vim_openstack_1": self.target_vim}
1265         ), patch.object(instance, "logger", logging), patch.object(
1266             instance, "db_vims", db_vims
1267         ):
1268             ro_task = {
1269                 "_id": "122436:1",
1270                 "locked_by": None,
1271                 "locked_at": 0.0,
1272                 "target_id": "vim_openstack_1",
1273                 "vim_info": {
1274                     "created": False,
1275                     "created_items": None,
1276                     "vim_id": "test-vim-id",
1277                     "vim_name": "test-vim",
1278                     "vim_status": "BUILD",
1279                     "vim_details": "",
1280                     "vim_message": None,
1281                     "refresh_at": None,
1282                 },
1283                 "modified_at": 1637324200.994312,
1284                 "created_at": 1637324200.994312,
1285                 "to_check_at": 1637324200.994312,
1286                 "tasks": {},
1287             }
1288
1289             self.target_vim.refresh_nets_status.return_value = {
1290                 "test-vim-id": {
1291                     "vim_info": "some-details",
1292                     "status": "ERROR",
1293                     "name": "test-vim",
1294                     "error_msg": "some error message",
1295                 }
1296             }
1297             task_status = "FAILED"
1298             ro_vim_item_update = {
1299                 "vim_status": "ERROR",
1300                 "vim_message": "some error message",
1301             }
1302             result = instance.refresh(ro_task)
1303             self.assertEqual(result[0], task_status)
1304             self.assertDictEqual(result[1], ro_vim_item_update)
1305
1306     def test__refresh_ro_task_VimConnException_occurred(self):
1307         """
1308         vimconn.VimConnException has occured
1309         """
1310         db = "test_db"
1311         logger = "test_logger"
1312         my_vims = "test-vim"
1313         db_vims = {
1314             "vim_openstack_1": {
1315                 "config": {},
1316                 "vim_type": "openstack",
1317             },
1318         }
1319         instance = VimInteractionNet(db, logger, my_vims, db_vims)
1320         with patch.object(
1321             instance, "my_vims", {"vim_openstack_1": self.target_vim}
1322         ), patch.object(instance, "logger", logging), patch.object(
1323             instance, "db_vims", db_vims
1324         ):
1325             ro_task = {
1326                 "_id": "122436:1",
1327                 "locked_by": None,
1328                 "locked_at": 0.0,
1329                 "target_id": "vim_openstack_1",
1330                 "vim_info": {
1331                     "created": False,
1332                     "created_items": None,
1333                     "vim_id": "test-vim-id",
1334                     "vim_name": "test-vim",
1335                     "vim_status": "BUILD",
1336                     "vim_details": "",
1337                     "vim_message": None,
1338                     "refresh_at": None,
1339                 },
1340                 "modified_at": 1637324200.994312,
1341                 "created_at": 1637324200.994312,
1342                 "to_check_at": 1637324200.994312,
1343                 "tasks": {},
1344             }
1345             self.target_vim.refresh_nets_status.side_effect = VimConnException(
1346                 "VimConnException occurred."
1347             )
1348             with self.assertLogs() as captured:
1349                 instance.refresh(ro_task)
1350                 self.assertEqual(captured.records[0].levelname, "ERROR")
1351
1352     def test__refresh_ro_task_vim_status_deleted(self):
1353         """
1354         vim_info.get('status') is DELETED
1355         """
1356         db = "test_db"
1357         logger = "test_logger"
1358         my_vims = "test-vim"
1359         db_vims = {
1360             "vim_openstack_1": {
1361                 "config": {},
1362                 "vim_type": "openstack",
1363             },
1364         }
1365         instance = VimInteractionNet(db, logger, my_vims, db_vims)
1366         with patch.object(
1367             instance, "my_vims", {"vim_openstack_1": self.target_vim}
1368         ), patch.object(instance, "logger", logging), patch.object(
1369             instance, "db_vims", db_vims
1370         ):
1371             ro_task = {
1372                 "_id": "122436:1",
1373                 "locked_by": None,
1374                 "locked_at": 0.0,
1375                 "target_id": "vim_openstack_1",
1376                 "vim_info": {
1377                     "created": False,
1378                     "created_items": None,
1379                     "vim_id": "test-vim-id",
1380                     "vim_name": "test-vim",
1381                     "vim_status": "BUILD",
1382                     "vim_details": "",
1383                     "vim_message": None,
1384                     "refresh_at": None,
1385                 },
1386                 "modified_at": 163724200.994312,
1387                 "created_at": 1637324200.994312,
1388                 "to_check_at": 1637324200.994312,
1389                 "tasks": {},
1390             }
1391             self.target_vim.refresh_nets_status.return_value = {
1392                 "test-vim-id": {
1393                     "vim_info": "some-details",
1394                     "status": "DELETED",
1395                     "name": "test-vim",
1396                     "error_msg": "some error message",
1397                 }
1398             }
1399             task_status = "FAILED"
1400             ro_vim_item_update = {
1401                 "vim_status": "DELETED",
1402                 "vim_message": "Deleted externally",
1403                 "vim_id": None,
1404             }
1405             result = instance.refresh(ro_task)
1406             self.assertEqual(result[0], task_status)
1407             self.assertDictEqual(result[1], ro_vim_item_update)
1408
1409     def test__refresh_ro_task_empty_vim_dict(self):
1410         """
1411         vim_dict does not include vim_id key
1412         Raises KeyError
1413         """
1414         db = "test_db"
1415         logger = "test_logger"
1416         my_vims = "test-vim"
1417         db_vims = {
1418             "vim_openstack_2": {
1419                 "config": {},
1420             },
1421         }
1422         instance = VimInteractionNet(db, logger, my_vims, db_vims)
1423         with patch.object(
1424             instance, "my_vims", {"vim_openstack_2": self.target_vim}
1425         ), patch.object(instance, "logger", logging), patch.object(
1426             instance, "db_vims", db_vims
1427         ):
1428             ro_task = {
1429                 "_id": "128436:1",
1430                 "locked_by": None,
1431                 "locked_at": 0.0,
1432                 "target_id": "vim_openstack_2",
1433                 "vim_info": {
1434                     "created": False,
1435                     "created_items": None,
1436                     "vim_id": "test-vim-id",
1437                     "vim_name": "test-vim",
1438                     "vim_status": "BUILD",
1439                     "vim_details": "",
1440                     "vim_message": None,
1441                     "refresh_at": None,
1442                 },
1443                 "modified_at": 163724211.994312,
1444                 "created_at": 1637324211.994312,
1445                 "to_check_at": 1637324211.994312,
1446                 "tasks": {},
1447             }
1448             self.target_vim.refresh_nets_status.return_value = {}
1449             with self.assertRaises(KeyError):
1450                 instance.refresh(ro_task)
1451
1452
1453 class TestVimInteractionAffinityGroup(unittest.TestCase):
1454     def setUp(self):
1455         module_name = "osm_ro_plugin"
1456         self.target_vim = MagicMock(name=f"{module_name}.vimconn.VimConnector")
1457         self.task_depends = None
1458
1459         patches = [patch(f"{module_name}.vimconn.VimConnector", self.target_vim)]
1460
1461         # Enabling mocks and add cleanups
1462         for mock in patches:
1463             mock.start()
1464             self.addCleanup(mock.stop)
1465
1466     def test__new_affinity_group_ok(self):
1467         """
1468         create affinity group with attributes set in params
1469         """
1470         db = "test_db"
1471         logger = "test_logger"
1472         my_vims = "test-vim"
1473         db_vims = {
1474             0: {
1475                 "config": {},
1476             },
1477         }
1478
1479         instance = VimInteractionAffinityGroup(db, logger, my_vims, db_vims)
1480         with patch.object(instance, "my_vims", [self.target_vim]), patch.object(
1481             instance, "logger", logging
1482         ), patch.object(instance, "db_vims", db_vims):
1483             ro_task = {
1484                 "target_id": 0,
1485                 "tasks": {
1486                     "task_index_1": {
1487                         "target_id": 0,
1488                         "action_id": "123456",
1489                         "nsr_id": "654321",
1490                         "task_id": "123456:1",
1491                         "status": "SCHEDULED",
1492                         "action": "CREATE",
1493                         "item": "test_item",
1494                         "target_record": "test_target_record",
1495                         "target_record_id": "test_target_record_id",
1496                         # values coming from extra_dict
1497                         "params": {
1498                             "affinity_group_data": {
1499                                 "name": "affinity_group_1",
1500                                 "type": "affinity",
1501                                 "scope": "nfvi-node",
1502                             }
1503                         },
1504                         "find_params": {},
1505                         "depends_on": "test_depends_on",
1506                     },
1507                 },
1508             }
1509
1510             task_index = "task_index_1"
1511             self.target_vim.new_affinity_group.return_value = (
1512                 "sample_affinity_group_id_1"
1513             )
1514             result = instance.new(ro_task, task_index, self.task_depends)
1515             self.assertEqual(result[0], "DONE")
1516             self.assertEqual(result[1].get("vim_id"), "sample_affinity_group_id_1")
1517             self.assertEqual(result[1].get("created"), True)
1518             self.assertEqual(result[1].get("vim_status"), "DONE")
1519
1520     def test__new_affinity_group_failed(self):
1521         """
1522         create affinity group with no attributes set in params
1523         """
1524         db = "test_db"
1525         logger = "test_logger"
1526         my_vims = "test-vim"
1527         db_vims = {
1528             0: {
1529                 "config": {},
1530             },
1531         }
1532
1533         instance = VimInteractionAffinityGroup(db, logger, my_vims, db_vims)
1534         with patch.object(instance, "my_vims", [self.target_vim]), patch.object(
1535             instance, "logger", logging
1536         ), patch.object(instance, "db_vims", db_vims):
1537             ro_task = {
1538                 "target_id": 0,
1539                 "tasks": {
1540                     "task_index_2": {
1541                         "target_id": 0,
1542                         "action_id": "123456",
1543                         "nsr_id": "654321",
1544                         "task_id": "123456:1",
1545                         "status": "SCHEDULED",
1546                         "action": "CREATE",
1547                         "item": "test_item",
1548                         "target_record": "test_target_record",
1549                         "target_record_id": "test_target_record_id",
1550                         # values coming from extra_dict
1551                         "params": {},
1552                         "find_params": {},
1553                         "depends_on": "test_depends_on",
1554                     },
1555                 },
1556             }
1557
1558             task_index = "task_index_2"
1559             self.target_vim.new_affinity_group.return_value = (
1560                 "sample_affinity_group_id_1"
1561             )
1562             result = instance.new(ro_task, task_index, self.task_depends)
1563             self.assertEqual(result[0], "DONE")
1564             self.assertEqual(result[1].get("vim_id"), None)
1565             self.assertEqual(result[1].get("created"), False)
1566             self.assertEqual(result[1].get("vim_status"), "DONE")
1567
1568     def test__delete_affinity_group_ok(self):
1569         """
1570         delete affinity group with a proper vim_id
1571         """
1572         db = "test_db"
1573         logger = "test_logger"
1574         my_vims = "test-vim"
1575         db_vims = {
1576             0: {
1577                 "config": {},
1578             },
1579         }
1580
1581         instance = VimInteractionAffinityGroup(db, logger, my_vims, db_vims)
1582         with patch.object(instance, "my_vims", [self.target_vim]), patch.object(
1583             instance, "logger", logging
1584         ), patch.object(instance, "db_vims", db_vims):
1585             ro_task = {
1586                 "target_id": 0,
1587                 "tasks": {
1588                     "task_index_3": {
1589                         "target_id": 0,
1590                         "task_id": "123456:1",
1591                     },
1592                 },
1593                 "vim_info": {
1594                     "created": False,
1595                     "created_items": None,
1596                     "vim_id": "sample_affinity_group_id_3",
1597                     "vim_name": "sample_affinity_group_id_3",
1598                     "vim_status": None,
1599                     "vim_details": "some-details",
1600                     "vim_message": None,
1601                     "refresh_at": None,
1602                 },
1603             }
1604
1605             task_index = "task_index_3"
1606             self.target_vim.delete_affinity_group.return_value = (
1607                 "sample_affinity_group_id_3"
1608             )
1609             result = instance.delete(ro_task, task_index)
1610             self.assertEqual(result[0], "DONE")
1611             self.assertEqual(result[1].get("vim_message"), "DELETED")
1612             self.assertEqual(result[1].get("created"), False)
1613             self.assertEqual(result[1].get("vim_status"), "DELETED")
1614
1615     def test__delete_affinity_group_failed(self):
1616         """
1617         delete affinity group with missing vim_id
1618         """
1619         db = "test_db"
1620         logger = "test_logger"
1621         my_vims = "test-vim"
1622         db_vims = {
1623             0: {
1624                 "config": {},
1625             },
1626         }
1627
1628         instance = VimInteractionAffinityGroup(db, logger, my_vims, db_vims)
1629         with patch.object(instance, "my_vims", [self.target_vim]), patch.object(
1630             instance, "logger", logging
1631         ), patch.object(instance, "db_vims", db_vims):
1632             ro_task = {
1633                 "target_id": 0,
1634                 "tasks": {
1635                     "task_index_4": {
1636                         "target_id": 0,
1637                         "task_id": "123456:1",
1638                     },
1639                 },
1640                 "vim_info": {
1641                     "created": False,
1642                     "created_items": None,
1643                     "vim_id": None,
1644                     "vim_name": None,
1645                     "vim_status": None,
1646                     "vim_details": "some-details",
1647                     "vim_message": None,
1648                     "refresh_at": None,
1649                 },
1650             }
1651
1652             task_index = "task_index_4"
1653             self.target_vim.delete_affinity_group.return_value = ""
1654             result = instance.delete(ro_task, task_index)
1655             self.assertEqual(result[0], "DONE")
1656             self.assertEqual(result[1].get("vim_message"), "DELETED")
1657             self.assertEqual(result[1].get("created"), False)
1658             self.assertEqual(result[1].get("vim_status"), "DELETED")
1659
1660
1661 class TestVimInteractionResize(unittest.TestCase):
1662     def setUp(self):
1663         module_name = "osm_ro_plugin"
1664         self.target_vim = MagicMock(name=f"{module_name}.vimconn.VimConnector")
1665         self.task_depends = None
1666
1667         patches = [patch(f"{module_name}.vimconn.VimConnector", self.target_vim)]
1668
1669         # Enabling mocks and add cleanups
1670         for mock in patches:
1671             mock.start()
1672             self.addCleanup(mock.stop)
1673
1674     def test__exec_resize_done(self):
1675         """
1676         create verticalscale task
1677         """
1678         db = "test_db"
1679         logger = "test_logger"
1680         my_vims = "test-vim"
1681         db_vims = {
1682             0: {
1683                 "config": {},
1684             },
1685         }
1686         target_record_id = (
1687             "vnfrs:665b4165-ce24-4320-bf19-b9a45bade49f:"
1688             "vdur.bb9c43f9-10a2-4569-a8a8-957c3528b6d1"
1689         )
1690
1691         instance = VimInteractionResize(db, logger, my_vims, db_vims)
1692         with patch.object(instance, "my_vims", [self.target_vim]), patch.object(
1693             instance, "logger", logging
1694         ), patch.object(instance, "db_vims", db_vims):
1695             ro_task = {
1696                 "target_id": 0,
1697                 "tasks": {
1698                     "task_index_1": {
1699                         "target_id": 0,
1700                         "action_id": "bb937f49-3870-4169-b758-9732e1ff40f3",
1701                         "nsr_id": "993166fe-723e-4680-ac4b-b1af2541ae31",
1702                         "task_id": "bb937f49-3870-4169-b758-9732e1ff40f3:0",
1703                         "status": "SCHEDULED",
1704                         "action": "EXEC",
1705                         "item": "verticalscale",
1706                         "target_record": "vnfrs:665b4165-ce24-4320-bf19-b9a45bade49f:vdur.0",
1707                         "target_record_id": target_record_id,
1708                         "params": {
1709                             "vim_vm_id": "f37b18ef-3caa-4dc9-ab91-15c669b16396",
1710                             "flavor_dict": "flavor_dict",
1711                         },
1712                     }
1713                 },
1714             }
1715             task_index = "task_index_1"
1716             result = instance.exec(ro_task, task_index, self.task_depends)
1717             self.assertEqual(result[0], "DONE")
1718             self.assertEqual(result[1].get("vim_status"), "DONE")
1719
1720
1721 class TestVimInteractionMigration(unittest.TestCase):
1722     def setUp(self):
1723         module_name = "osm_ro_plugin"
1724         self.target_vim = MagicMock(name=f"{module_name}.vimconn.VimConnector")
1725         self.task_depends = None
1726
1727         patches = [patch(f"{module_name}.vimconn.VimConnector", self.target_vim)]
1728
1729         # Enabling mocks and add cleanups
1730         for mock in patches:
1731             mock.start()
1732             self.addCleanup(mock.stop)
1733
1734     def test__exec_migration_done(self):
1735         """
1736         create migrate task
1737         """
1738         db = "test_db"
1739         logger = "test_logger"
1740         my_vims = "test-vim"
1741         db_vims = {
1742             0: {
1743                 "config": {},
1744             },
1745         }
1746         target_record_id = (
1747             "vnfrs:665b4165-ce24-4320-bf19-b9a45bade49f:"
1748             "vdur.bb9c43f9-10a2-4569-a8a8-957c3528b6d1"
1749         )
1750
1751         instance = VimInteractionMigration(db, logger, my_vims, db_vims)
1752         with patch.object(instance, "my_vims", [self.target_vim]), patch.object(
1753             instance, "logger", logging
1754         ), patch.object(instance, "db_vims", db_vims):
1755             ro_task = {
1756                 "target_id": 0,
1757                 "tasks": {
1758                     "task_index_1": {
1759                         "target_id": 0,
1760                         "action_id": "bb937f49-3870-4169-b758-9732e1ff40f3",
1761                         "nsr_id": "993166fe-723e-4680-ac4b-b1af2541ae31",
1762                         "task_id": "bb937f49-3870-4169-b758-9732e1ff40f3:0",
1763                         "status": "SCHEDULED",
1764                         "action": "EXEC",
1765                         "item": "migrate",
1766                         "target_record": "vnfrs:665b4165-ce24-4320-bf19-b9a45bade49f:vdur.0",
1767                         "target_record_id": target_record_id,
1768                         "params": {
1769                             "vim_vm_id": "f37b18ef-3caa-4dc9-ab91-15c669b16396",
1770                             "migrate_host": "osm-test2",
1771                             "vdu_vim_info": {0: {"interfaces": []}},
1772                         },
1773                     }
1774                 },
1775             }
1776             self.target_vim.migrate_instance.return_value = "ACTIVE", "test"
1777
1778             task_index = "task_index_1"
1779             result = instance.exec(ro_task, task_index, self.task_depends)
1780             self.assertEqual(result[0], "DONE")
1781             self.assertEqual(result[1].get("vim_status"), "ACTIVE")