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