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