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