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