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