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