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 VimInteractionNet
  23 from osm_ro_plugin.vimconn import VimConnConnectionException, VimConnException
  24
  25
  26 class TestVimInteractionNet(unittest.TestCase):
  27     def setUp(self):
  28         module_name = "osm_ro_plugin"
  29         self.target_vim = MagicMock(name=f"{module_name}.vimconn.VimConnector")
  30         self.task_depends = None
  31
  32         patches = [patch(f"{module_name}.vimconn.VimConnector", self.target_vim)]
  33
  34         # Enabling mocks and add cleanups
  35         for mock in patches:
  36             mock.start()
  37             self.addCleanup(mock.stop)
  38
  39     def test__mgmt_net_id_in_find_params_mgmt_several_vim_nets(self):
  40         """
  41         mgmt network is set in find_params
  42         management_network_id in vim config
  43         More than one network found in the VIM
  44         """
  45         db = "test_db"
  46         logger = "test_logger"
  47         my_vims = "test-vim"
  48         db_vims = {
  49             0: {
  50                 "config": {
  51                     "management_network_id": "test_mgmt_id",
  52                 },
  53             },
  54         }
  55
  56         instance = VimInteractionNet(db, logger, my_vims, db_vims)
  57         with patch.object(instance, "my_vims", [self.target_vim]), patch.object(
  58             instance, "logger", logging
  59         ), patch.object(instance, "db_vims", db_vims):
  60             ro_task = {
  61                 "target_id": 0,
  62                 "tasks": {
  63                     "task_index_2": {
  64                         "target_id": 0,
  65                         "action_id": "123456",
  66                         "nsr_id": "654321",
  67                         "task_id": "123456:1",
  68                         "status": "SCHEDULED",
  69                         "action": "CREATE",
  70                         "item": "test_item",
  71                         "target_record": "test_target_record",
  72                         "target_record_id": "test_target_record_id",
  73                         # values coming from extra_dict
  74                         "params": {},
  75                         "find_params": {
  76                             "mgmt": True,
  77                             "name": "some_mgmt_name",
  78                         },
  79                         "depends_on": "test_depends_on",
  80                     },
  81                 },
  82             }
  83
  84             task_index = "task_index_2"
  85             self.target_vim.get_network_list.return_value = [
  86                 {"id": "existing_net_1"},
  87                 {"id": "existing_net_2"},
  88             ]
  89             with self.assertLogs() as captured:
  90                 result = instance.new(ro_task, task_index, self.task_depends)
  91                 self.assertEqual(len(captured.records), 1)
  92                 self.assertTrue(
  93                     "More than one network found with this criteria"
  94                     in captured.records[0].getMessage()
  95                 )
  96                 self.assertEqual(captured.records[0].levelname, "ERROR")
  97                 self.assertEqual(result[0], "FAILED")
  98                 self.assertEqual(result[1].get("created"), False)
  99                 self.assertEqual(result[1].get("vim_status"), "VIM_ERROR")
 100
 101     def test__mgmt_net_id_in_find_params_mgmt_no_vim_nets(self):
 102         """
 103         mgmt network is set in find_params
 104         management_network_id in vim config
 105         The network could not be found in the VIM
 106         """
 107         db = "test_db"
 108         logger = "test_logger"
 109         my_vims = "test-vim"
 110         db_vims = {
 111             0: {
 112                 "config": {
 113                     "management_network_id": "test_mgmt_id",
 114                 },
 115             },
 116         }
 117
 118         instance = VimInteractionNet(db, logger, my_vims, db_vims)
 119         with patch.object(instance, "my_vims", [self.target_vim]), patch.object(
 120             instance, "db_vims", db_vims
 121         ), patch.object(instance, "logger", logging):
 122             ro_task = {
 123                 "target_id": 0,
 124                 "tasks": {
 125                     "task_index_3": {
 126                         "target_id": 0,
 127                         "action_id": "123456",
 128                         "nsr_id": "654321",
 129                         "task_id": "123456:1",
 130                         "status": "SCHEDULED",
 131                         "action": "CREATE",
 132                         "item": "test_item",
 133                         "target_record": "test_target_record",
 134                         "target_record_id": "test_target_record_id",
 135                         "params": {},
 136                         # values coming from extra_dict
 137                         "find_params": {
 138                             "mgmt": True,
 139                             "name": "some_mgmt_name",
 140                         },
 141                         "depends_on": "test_depends_on",
 142                     },
 143                 },
 144             }
 145
 146             task_index = "task_index_3"
 147             self.target_vim.get_network_list.return_value = []
 148             with self.assertLogs() as captured:
 149                 result = instance.new(ro_task, task_index, self.task_depends)
 150                 self.assertEqual(len(captured.records), 1)
 151                 self.assertTrue(
 152                     "Network not found with this criteria"
 153                     in captured.records[0].getMessage()
 154                 )
 155                 self.assertEqual(captured.records[0].levelname, "ERROR")
 156                 self.assertEqual(result[0], "FAILED")
 157                 self.assertEqual(result[1].get("created"), False)
 158                 self.assertEqual(result[1].get("vim_status"), "VIM_ERROR")
 159
 160     def test__mgmt_net_in_find_params_no_vim_config_no_vim_nets(self):
 161         """
 162         mgmt network is set in find_params
 163         vim config does not have management_network_id or management_network_id
 164         The network could not be found in the VIM
 165         """
 166         db = "test_db"
 167         logger = "test_logger"
 168         my_vims = "test-vim"
 169         db_vims = {
 170             0: {
 171                 "config": {},
 172             },
 173         }
 174
 175         instance = VimInteractionNet(db, logger, my_vims, db_vims)
 176         with patch.object(instance, "my_vims", [self.target_vim]), patch.object(
 177             instance, "db_vims", db_vims
 178         ), patch.object(instance, "logger", logging):
 179             ro_task = {
 180                 "target_id": 0,
 181                 "tasks": {
 182                     "task_index_3": {
 183                         "target_id": 0,
 184                         "action_id": "123456",
 185                         "nsr_id": "654321",
 186                         "task_id": "123456:1",
 187                         "status": "SCHEDULED",
 188                         "action": "CREATE",
 189                         "item": "test_item",
 190                         "target_record": "test_target_record",
 191                         "target_record_id": "test_target_record_id",
 192                         "params": {},
 193                         # values coming from extra_dict
 194                         "find_params": {
 195                             "mgmt": True,
 196                             "name": "some_mgmt_name",
 197                         },
 198                         "depends_on": "test_depends_on",
 199                     },
 200                 },
 201             }
 202
 203             task_index = "task_index_3"
 204             self.target_vim.get_network_list.return_value = []
 205             self.target_vim.new_network.return_value = "sample_net_id", {
 206                 "item1": "sample_created_item"
 207             }
 208             result = instance.new(ro_task, task_index, self.task_depends)
 209             self.assertEqual(result[0], "BUILD")
 210             self.assertEqual(result[1].get("vim_id"), "sample_net_id")
 211             self.assertEqual(result[1].get("created"), True)
 212             self.assertDictEqual(
 213                 result[1].get("created_items"), {"item1": "sample_created_item"}
 214             )
 215             self.assertEqual(result[1].get("vim_status"), "BUILD")
 216
 217     def test__mgmt_net_name_in_find_params_mgmt_several_vim_nets(self):
 218         """
 219         mgmt network is set in find_params
 220         management_network_name in vim config
 221         More than one network found in the VIM
 222         """
 223         db = "test_db"
 224         logger = "test_logger"
 225         my_vims = "test-vim"
 226         db_vims = {
 227             0: {
 228                 "config": {
 229                     "management_network_name": "test_mgmt_name",
 230                 },
 231             },
 232         }
 233
 234         instance = VimInteractionNet(db, logger, my_vims, db_vims)
 235         with patch.object(instance, "my_vims", [self.target_vim]), patch.object(
 236             instance, "logger", logging
 237         ), patch.object(instance, "db_vims", db_vims):
 238             ro_task = {
 239                 "target_id": 0,
 240                 "tasks": {
 241                     "task_index_4": {
 242                         "target_id": 0,
 243                         "action_id": "123456",
 244                         "nsr_id": "654321",
 245                         "task_id": "123456:1",
 246                         "status": "SCHEDULED",
 247                         "action": "CREATE",
 248                         "item": "test_item",
 249                         "target_record": "test_target_record",
 250                         "target_record_id": "test_target_record_id",
 251                         # values coming from extra_dict
 252                         "params": {},
 253                         "find_params": {
 254                             "mgmt": True,
 255                             "name": "some_mgmt_name",
 256                         },
 257                         "depends_on": "test_depends_on",
 258                     },
 259                 },
 260             }
 261
 262             task_index = "task_index_4"
 263             self.target_vim.get_network_list.return_value = [
 264                 {"id": "existing_net_1"},
 265                 {"id": "existing_net_2"},
 266             ]
 267             with self.assertLogs() as captured:
 268                 result = instance.new(ro_task, task_index, self.task_depends)
 269                 self.assertEqual(len(captured.records), 1)
 270                 self.assertTrue(
 271                     "More than one network found with this criteria"
 272                     in captured.records[0].getMessage()
 273                 )
 274                 self.assertEqual(captured.records[0].levelname, "ERROR")
 275                 self.assertEqual(result[0], "FAILED")
 276                 self.assertEqual(result[1].get("created"), False)
 277                 self.assertEqual(result[1].get("vim_status"), "VIM_ERROR")
 278
 279     def test__mgmt_net_name_in_find_params_mgmt_no_vim_nets(self):
 280         """
 281         mgmt network is set in find_params
 282         management_network_name in vim config
 283         The network could not be found in the VIM
 284         """
 285         db = "test_db"
 286         logger = "test_logger"
 287         my_vims = "test-vim"
 288         db_vims = {
 289             0: {
 290                 "config": {
 291                     "management_network_name": "test_mgmt_name",
 292                 },
 293             },
 294         }
 295
 296         instance = VimInteractionNet(db, logger, my_vims, db_vims)
 297         with patch.object(instance, "my_vims", [self.target_vim]), patch.object(
 298             instance, "logger", logging
 299         ), patch.object(instance, "db_vims", db_vims):
 300             ro_task = {
 301                 "target_id": 0,
 302                 "tasks": {
 303                     "task_index_5": {
 304                         "target_id": 0,
 305                         "action_id": "123456",
 306                         "nsr_id": "654321",
 307                         "task_id": "123456:1",
 308                         "status": "SCHEDULED",
 309                         "action": "CREATE",
 310                         "item": "test_item",
 311                         "target_record": "test_target_record",
 312                         "target_record_id": "test_target_record_id",
 313                         # values coming from extra_dict
 314                         "params": {},
 315                         "find_params": {
 316                             "mgmt": True,
 317                             "name": "some_mgmt_name",
 318                         },
 319                         "depends_on": "test_depends_on",
 320                     },
 321                 },
 322             }
 323
 324             task_index = "task_index_5"
 325             self.target_vim.get_network_list.return_value = []
 326             with self.assertLogs() as captured:
 327                 result = instance.new(ro_task, task_index, self.task_depends)
 328                 self.assertEqual(len(captured.records), 1)
 329                 self.assertTrue(
 330                     "Network not found with this criteria"
 331                     in captured.records[0].getMessage()
 332                 )
 333                 self.assertEqual(captured.records[0].levelname, "ERROR")
 334                 self.assertEqual(result[0], "FAILED")
 335                 self.assertEqual(result[1].get("created"), False)
 336                 self.assertEqual(result[1].get("vim_status"), "VIM_ERROR")
 337
 338     def test__mgmt_net_name_in_find_params_filterdict_several_vim_nets(self):
 339         """
 340         mgmt network is set in find_params
 341         management_network_name in vim config
 342         network_name is set in find_params.get('filterdict')
 343         More than one network found in the VIM
 344         """
 345         db = "test_db"
 346         logger = "test_logger"
 347         my_vims = "test-vim"
 348         db_vims = {
 349             0: {
 350                 "config": {
 351                     "management_network_name": "test_mgmt_name",
 352                 },
 353             },
 354         }
 355         instance = VimInteractionNet(db, logger, my_vims, db_vims)
 356         with patch.object(instance, "my_vims", [self.target_vim]), patch.object(
 357             instance, "logger", logging
 358         ), patch.object(instance, "db_vims", db_vims):
 359             ro_task = {
 360                 "target_id": 0,
 361                 "tasks": {
 362                     "task_index_6": {
 363                         "target_id": 0,
 364                         "action_id": "123456",
 365                         "nsr_id": "654321",
 366                         "task_id": "123456:1",
 367                         "status": "SCHEDULED",
 368                         "action": "CREATE",
 369                         "item": "test_item",
 370                         "target_record": "test_target_record",
 371                         "target_record_id": "test_target_record_id",
 372                         # values coming from extra_dict
 373                         "params": {},
 374                         "find_params": {
 375                             "filter_dict": {
 376                                 "name": "some-network-name",
 377                             },
 378                             "mgmt": True,
 379                             "name": "some_mgmt_name",
 380                         },
 381                         "depends_on": "test_depends_on",
 382                     },
 383                 },
 384             }
 385
 386             task_index = "task_index_6"
 387             self.target_vim.get_network_list.return_value = [
 388                 {"id": "existing_net_1"},
 389                 {"id": "existing_net_2"},
 390             ]
 391             with self.assertLogs() as captured:
 392                 result = instance.new(ro_task, task_index, self.task_depends)
 393                 self.assertEqual(len(captured.records), 1)
 394                 self.assertTrue(
 395                     "More than one network found with this criteria"
 396                     in captured.records[0].getMessage()
 397                 )
 398                 self.assertEqual(captured.records[0].levelname, "ERROR")
 399                 self.assertEqual(result[0], "FAILED")
 400                 self.assertEqual(result[1].get("created"), False)
 401                 self.assertEqual(result[1].get("vim_status"), "VIM_ERROR")
 402
 403     def test__mgmt_net_name_in_find_params_no_filterdict_no_mgmt(self):
 404         """
 405         There is find_params in the task
 406         No mgmt in find_params
 407         No filter_dict in find_params
 408         """
 409         db = "test_db"
 410         logger = "test_logger"
 411         my_vims = "test-vim"
 412         db_vims = {
 413             0: {
 414                 "config": {
 415                     "management_network_name": "test_mgmt_name",
 416                 },
 417             },
 418         }
 419         instance = VimInteractionNet(db, logger, my_vims, db_vims)
 420         with patch.object(instance, "my_vims", [self.target_vim]), patch.object(
 421             instance, "logger", logging
 422         ), patch.object(instance, "db_vims", db_vims):
 423             ro_task = {
 424                 "target_id": 0,
 425                 "tasks": {
 426                     "task_index_4": {
 427                         "target_id": 0,
 428                         "action_id": "123456",
 429                         "nsr_id": "654321",
 430                         "task_id": "123456:1",
 431                         "status": "SCHEDULED",
 432                         "action": "CREATE",
 433                         "item": "test_item",
 434                         "target_record": "test_target_record",
 435                         "target_record_id": "test_target_record_id",
 436                         # values coming from extra_dict
 437                         "params": {},
 438                         "find_params": {"wrong_param": "wrong_value"},
 439                         "depends_on": "test_depends_on",
 440                     },
 441                 },
 442             }
 443
 444             task_index = "task_index_4"
 445             with self.assertLogs() as captured:
 446                 result = instance.new(ro_task, task_index, self.task_depends)
 447                 self.assertEqual(len(captured.records), 1)
 448                 self.assertTrue(
 449                     "Invalid find_params for new_net"
 450                     in captured.records[0].getMessage()
 451                 )
 452                 self.assertEqual(captured.records[0].levelname, "ERROR")
 453                 self.assertEqual(result[0], "FAILED")
 454                 self.assertEqual(result[1].get("created"), False)
 455                 self.assertEqual(result[1].get("vim_status"), "VIM_ERROR")
 456
 457     def test__mgmt_net_name_in_find_params_filterdict_no_vim_nets_params_in_task(self):
 458         """
 459         management_network_name in find_params.get('filterdict')
 460         The network could not be found in the VIM
 461         There are items in the task.get(params)
 462         """
 463         db = "test_db"
 464         logger = "test_logger"
 465         my_vims = "test-vim"
 466         db_vims = {
 467             0: {
 468                 "config": {
 469                     "management_network_name": "test_mgmt_name",
 470                 },
 471             },
 472         }
 473         instance = VimInteractionNet(db, logger, my_vims, db_vims)
 474         with patch.object(instance, "my_vims", [self.target_vim]), patch.object(
 475             instance, "logger", logging
 476         ), patch.object(instance, "db_vims", db_vims):
 477             ro_task = {
 478                 "target_id": 0,
 479                 "tasks": {
 480                     "task_index_8": {
 481                         "target_id": 0,
 482                         "action_id": "123456",
 483                         "nsr_id": "654321",
 484                         "task_id": "123456:1",
 485                         "status": "SCHEDULED",
 486                         "action": "CREATE",
 487                         "item": "test_item",
 488                         "target_record": "test_target_record",
 489                         "target_record_id": "test_target_record_id",
 490                         # values coming from extra_dict
 491                         "params": {
 492                             "net_name": "test_params",
 493                         },
 494                         "find_params": {
 495                             "filter_dict": {
 496                                 "name": "some-network-name",
 497                             },
 498                             "mgmt": True,
 499                             "name": "some_mgmt_name",
 500                         },
 501                         "depends_on": "test_depends_on",
 502                     },
 503                 },
 504             }
 505
 506             task_index = "task_index_8"
 507             self.target_vim.get_network_list.return_value = []
 508             result = instance.new(ro_task, task_index, self.task_depends)
 509             self.assertEqual(result[0], "BUILD")
 510             self.assertEqual(result[1].get("created"), False)
 511             self.assertEqual(result[1].get("vim_id"), None)
 512             self.assertEqual(result[1].get("created_items"), {})
 513             self.assertEqual(result[1].get("vim_status"), "BUILD")
 514
 515     def test__mgmt_net_name_in_find_params_filterdict_no_vim_nets(self):
 516         """
 517         mgmt network is set in find_params
 518         management_network_name in vim config
 519         network_name is set in find_params.get('filterdict')
 520         Any network could not be found in the VIM
 521         """
 522         db = "test_db"
 523         logger = "test_logger"
 524         my_vims = "test-vim"
 525         db_vims = {
 526             0: {
 527                 "config": {
 528                     "management_network_name": "test_mgmt_name",
 529                 },
 530             },
 531         }
 532         instance = VimInteractionNet(db, logger, my_vims, db_vims)
 533         with patch.object(instance, "my_vims", [self.target_vim]), patch.object(
 534             instance, "logger", logging
 535         ), patch.object(instance, "db_vims", db_vims):
 536             ro_task = {
 537                 "target_id": 0,
 538                 "tasks": {
 539                     "task_index_9": {
 540                         "target_id": 0,
 541                         "action_id": "123456",
 542                         "nsr_id": "654321",
 543                         "task_id": "123456:1",
 544                         "status": "SCHEDULED",
 545                         "action": "CREATE",
 546                         "item": "test_item",
 547                         "target_record": "test_target_record",
 548                         "target_record_id": "test_target_record_id",
 549                         # values coming from extra_dict
 550                         "params": "",
 551                         "find_params": {
 552                             "filter_dict": {
 553                                 "name": "some-network-name",
 554                             },
 555                             "mgmt": True,
 556                             "name": "some_mgmt_name",
 557                         },
 558                         "depends_on": "test_depends_on",
 559                     },
 560                 },
 561             }
 562
 563             task_index = "task_index_9"
 564             self.target_vim.get_network_list.return_value = []
 565             with self.assertLogs() as captured:
 566                 result = instance.new(ro_task, task_index, self.task_depends)
 567                 self.assertEqual(len(captured.records), 1)
 568                 self.assertTrue(
 569                     "Network not found with this criteria"
 570                     in captured.records[0].getMessage()
 571                 )
 572                 self.assertEqual(captured.records[0].levelname, "ERROR")
 573                 self.assertEqual(result[0], "FAILED")
 574                 self.assertEqual(result[1].get("created"), False)
 575                 self.assertEqual(result[1].get("vim_status"), "VIM_ERROR")
 576
 577     def test__mgmt_net_in_find_params_filterdict_no_config_no_vim_nets(self):
 578         """
 579         mgmt network is set in find_params
 580         vim config is empty
 581         network_name is set in find_params.get('filterdict')
 582         Any network could not be found in the VIM
 583         """
 584         db = "test_db"
 585         logger = "test_logger"
 586         my_vims = "test-vim"
 587         db_vims = {
 588             0: {
 589                 "config": {},
 590             },
 591         }
 592         instance = VimInteractionNet(db, logger, my_vims, db_vims)
 593         with patch.object(instance, "my_vims", [self.target_vim]), patch.object(
 594             instance, "logger", logging
 595         ), patch.object(instance, "db_vims", db_vims):
 596             ro_task = {
 597                 "target_id": 0,
 598                 "tasks": {
 599                     "task_index_9": {
 600                         "target_id": 0,
 601                         "action_id": "123456",
 602                         "nsr_id": "654321",
 603                         "task_id": "123456:1",
 604                         "status": "SCHEDULED",
 605                         "action": "CREATE",
 606                         "item": "test_item",
 607                         "target_record": "test_target_record",
 608                         "target_record_id": "test_target_record_id",
 609                         # values coming from extra_dict
 610                         "params": {},
 611                         "find_params": {
 612                             "filter_dict": {
 613                                 "name": "some-network-name",
 614                             },
 615                             "mgmt": True,
 616                             "name": "some_mgmt_name",
 617                         },
 618                         "depends_on": "test_depends_on",
 619                     },
 620                 },
 621             }
 622
 623             task_index = "task_index_9"
 624             self.target_vim.get_network_list.return_value = []
 625             with self.assertLogs() as captured:
 626                 result = instance.new(ro_task, task_index, self.task_depends)
 627                 self.assertEqual(len(captured.records), 1)
 628                 self.assertTrue(
 629                     "Network not found with this criteria"
 630                     in captured.records[0].getMessage()
 631                 )
 632                 self.assertEqual(captured.records[0].levelname, "ERROR")
 633                 self.assertEqual(result[0], "FAILED")
 634                 self.assertEqual(result[1].get("created"), False)
 635                 self.assertEqual(result[1].get("vim_status"), "VIM_ERROR")
 636
 637     def test__mgmt_net_name_in_find_params_mgmt_no_config_one_vim_net(self):
 638         """
 639         mgmt network is set in find_params
 640         management_network_name is not in db_vims.get('config')
 641         One network found in the VIM
 642         """
 643         db = "test_db"
 644         logger = "test_logger"
 645         my_vims = "test-vim"
 646         db_vims = {
 647             0: {
 648                 "config": {},
 649             },
 650         }
 651         instance = VimInteractionNet(db, logger, my_vims, db_vims)
 652         with patch.object(instance, "my_vims", [self.target_vim]), patch.object(
 653             instance, "logger", logging
 654         ), patch.object(instance, "db_vims", db_vims):
 655             ro_task = {
 656                 "target_id": 0,
 657                 "tasks": {
 658                     "task_index_2": {
 659                         "target_id": 0,
 660                         "action_id": "123456",
 661                         "nsr_id": "654321",
 662                         "task_id": "123456:1",
 663                         "status": "SCHEDULED",
 664                         "action": "CREATE",
 665                         "item": "test_item",
 666                         "target_record": "test_target_record",
 667                         "target_record_id": "test_target_record_id",
 668                         # values coming from extra_dict
 669                         "params": {},
 670                         "find_params": {
 671                             "mgmt": True,
 672                             "name": "some_mgmt_name",
 673                         },
 674                         "depends_on": "test_depends_on",
 675                     },
 676                 },
 677             }
 678
 679             task_index = "task_index_2"
 680             self.target_vim.get_network_list.return_value = [
 681                 {"id": "4d83a7c9-3ef4-4a45-99c8-aca3550490dd"}
 682             ]
 683             result = instance.new(ro_task, task_index, self.task_depends)
 684             self.assertEqual(result[0], "BUILD")
 685             self.assertEqual(result[1].get("created"), False)
 686             self.assertEqual(result[1].get("vim_status"), "BUILD")
 687
 688     def test__params_in_task_no_find_params(self):
 689         """
 690         params in the task
 691         find_params does not exist in the task
 692         """
 693         db = "test_db"
 694         logger = "test_logger"
 695         my_vims = "test-vim"
 696         db_vims = {
 697             0: {
 698                 "config": {
 699                     "management_network_name": "test_mgmt_name",
 700                 },
 701             },
 702         }
 703         instance = VimInteractionNet(db, logger, my_vims, db_vims)
 704         with patch.object(instance, "my_vims", [self.target_vim]), patch.object(
 705             instance, "logger", logging
 706         ), patch.object(instance, "db_vims", db_vims):
 707             ro_task = {
 708                 "target_id": 0,
 709                 "tasks": {
 710                     "task_index_11": {
 711                         "target_id": 0,
 712                         "action_id": "123456",
 713                         "nsr_id": "654321",
 714                         "task_id": "123456:1",
 715                         "status": "SCHEDULED",
 716                         "action": "CREATE",
 717                         "item": "test_item",
 718                         "target_record": "test_target_record",
 719                         "target_record_id": "test_target_record_id",
 720                         # values coming from extra_dict
 721                         "params": {
 722                             "net_name": "test-network",
 723                             "net_type": "vlan",
 724                         },
 725                         "depends_on": "test_depends_on",
 726                     },
 727                 },
 728             }
 729
 730             task_index = "task_index_11"
 731             self.target_vim.new_network.return_value = "sample_net_id", {
 732                 "item1": "sample_created_item"
 733             }
 734             result = instance.new(ro_task, task_index, self.task_depends)
 735             self.assertEqual(result[0], "BUILD")
 736             self.assertEqual(result[1].get("vim_id"), "sample_net_id")
 737             self.assertEqual(result[1].get("created"), True)
 738             self.assertEqual(
 739                 result[1].get("created_items"), {"item1": "sample_created_item"}
 740             )
 741             self.assertEqual(result[1].get("vim_status"), "BUILD")
 742
 743     def test__no_params_in_task_no_find_params(self):
 744         """
 745         empty params in the task
 746         find_params does not exist in the task
 747         """
 748         db = "test_db"
 749         logger = "test_logger"
 750         my_vims = "test-vim"
 751         db_vims = {
 752             0: {
 753                 "config": {
 754                     "management_network_name": "test_mgmt_name",
 755                 },
 756             },
 757         }
 758         instance = VimInteractionNet(db, logger, my_vims, db_vims)
 759         with patch.object(instance, "my_vims", [self.target_vim]), patch.object(
 760             instance, "logger", logging
 761         ), patch.object(instance, "db_vims", db_vims):
 762             ro_task = {
 763                 "target_id": 0,
 764                 "tasks": {
 765                     "task_index_12": {
 766                         "target_id": 0,
 767                         "action_id": "123456",
 768                         "nsr_id": "654321",
 769                         "task_id": "123456:1",
 770                         "status": "SCHEDULED",
 771                         "action": "CREATE",
 772                         "item": "test_item",
 773                         "target_record": "test_target_record",
 774                         "target_record_id": "test_target_record_id",
 775                         # values coming from extra_dict
 776                         "params": {},
 777                         "depends_on": "test_depends_on",
 778                     },
 779                 },
 780             }
 781
 782             task_index = "task_index_12"
 783             self.target_vim.new_network.side_effect = VimConnConnectionException(
 784                 "VimConnConnectionException occurred."
 785             )
 786             with self.assertLogs() as captured:
 787                 instance.new(ro_task, task_index, self.task_depends)
 788                 self.assertEqual(captured.records[0].levelname, "ERROR")
 789
 790     def test__refresh_ro_task_vim_status_active(self):
 791         """
 792         vim_info.get('status') is ACTIVE
 793         """
 794         db = "test_db"
 795         logger = "test_logger"
 796         my_vims = "test-vim"
 797         db_vims = {
 798             "vim_openstack_1": {
 799                 "config": {},
 800             },
 801         }
 802         instance = VimInteractionNet(db, logger, my_vims, db_vims)
 803         with patch.object(
 804             instance, "my_vims", {"vim_openstack_1": self.target_vim}
 805         ), patch.object(instance, "logger", logging), patch.object(
 806             instance, "db_vims", db_vims
 807         ):
 808             ro_task = {
 809                 "_id": "122436:1",
 810                 "locked_by": None,
 811                 "locked_at": 0.0,
 812                 "target_id": "vim_openstack_1",
 813                 "vim_info": {
 814                     "created": False,
 815                     "created_items": None,
 816                     "vim_id": "test-vim-id",
 817                     "vim_name": "test-vim",
 818                     "vim_status": None,
 819                     "vim_details": "some-details",
 820                     "refresh_at": None,
 821                 },
 822                 "modified_at": 1637324200.994312,
 823                 "created_at": 1637324200.994312,
 824                 "to_check_at": 1637324200.994312,
 825                 "tasks": {},
 826             }
 827
 828             self.target_vim.refresh_nets_status.return_value = {
 829                 "test-vim-id": {
 830                     "vim_info": "some-details",
 831                     "status": "ACTIVE",
 832                     "name": "test-vim",
 833                     "error_msg": "",
 834                 }
 835             }
 836             task_status = "DONE"
 837             ro_vim_item_update = {
 838                 "vim_status": "ACTIVE",
 839             }
 840             result = instance.refresh(ro_task)
 841             self.assertEqual(result[0], task_status)
 842             self.assertDictEqual(result[1], ro_vim_item_update)
 843
 844     def test__refresh_ro_task_vim_status_build(self):
 845         """
 846         vim_info.get('status') is BUILD
 847         """
 848         db = "test_db"
 849         logger = "test_logger"
 850         my_vims = "test-vim"
 851         db_vims = {
 852             "vim_openstack_1": {
 853                 "config": {},
 854             },
 855         }
 856         instance = VimInteractionNet(db, logger, my_vims, db_vims)
 857         with patch.object(
 858             instance, "my_vims", {"vim_openstack_1": self.target_vim}
 859         ), patch.object(instance, "logger", logging), patch.object(
 860             instance, "db_vims", db_vims
 861         ):
 862             ro_task = {
 863                 "_id": "122436:1",
 864                 "locked_by": None,
 865                 "locked_at": 0.0,
 866                 "target_id": "vim_openstack_1",
 867                 "vim_info": {
 868                     "created": False,
 869                     "created_items": None,
 870                     "vim_id": "test-vim-id",
 871                     "vim_name": "test-vim",
 872                     "vim_status": "BUILD",
 873                     "vim_details": "",
 874                     "refresh_at": None,
 875                 },
 876                 "modified_at": 1637324200.994312,
 877                 "created_at": 1637324200.994312,
 878                 "to_check_at": 1637324200.994312,
 879                 "tasks": {},
 880             }
 881
 882             self.target_vim.refresh_nets_status.return_value = {
 883                 "test-vim-id": {
 884                     "vim_info": "some-details",
 885                     "status": "BUILD",
 886                     "name": "other-vim",
 887                     "error_msg": "",
 888                 }
 889             }
 890             task_status = "BUILD"
 891             ro_vim_item_update = {
 892                 "vim_name": "other-vim",
 893                 "vim_details": "some-details",
 894             }
 895             result = instance.refresh(ro_task)
 896             self.assertEqual(result[0], task_status)
 897             self.assertDictEqual(result[1], ro_vim_item_update)
 898
 899     def test__refresh_ro_task_vim_status_error(self):
 900         """
 901         vim_info.get('status') is ERROR
 902         """
 903         db = "test_db"
 904         logger = "test_logger"
 905         my_vims = "test-vim"
 906         db_vims = {
 907             "vim_openstack_1": {
 908                 "config": {},
 909             },
 910         }
 911         instance = VimInteractionNet(db, logger, my_vims, db_vims)
 912         with patch.object(
 913             instance, "my_vims", {"vim_openstack_1": self.target_vim}
 914         ), patch.object(instance, "logger", logging), patch.object(
 915             instance, "db_vims", db_vims
 916         ):
 917             ro_task = {
 918                 "_id": "122436:1",
 919                 "locked_by": None,
 920                 "locked_at": 0.0,
 921                 "target_id": "vim_openstack_1",
 922                 "vim_info": {
 923                     "created": False,
 924                     "created_items": None,
 925                     "vim_id": "test-vim-id",
 926                     "vim_name": "test-vim",
 927                     "vim_status": "BUILD",
 928                     "vim_details": "",
 929                     "refresh_at": None,
 930                 },
 931                 "modified_at": 1637324200.994312,
 932                 "created_at": 1637324200.994312,
 933                 "to_check_at": 1637324200.994312,
 934                 "tasks": {},
 935             }
 936
 937             self.target_vim.refresh_nets_status.return_value = {
 938                 "test-vim-id": {
 939                     "vim_info": "some-details",
 940                     "status": "ERROR",
 941                     "name": "test-vim",
 942                     "error_msg": "some error message",
 943                 }
 944             }
 945             task_status = "FAILED"
 946             ro_vim_item_update = {
 947                 "vim_status": "ERROR",
 948                 "vim_details": "some error message",
 949             }
 950             result = instance.refresh(ro_task)
 951             self.assertEqual(result[0], task_status)
 952             self.assertDictEqual(result[1], ro_vim_item_update)
 953
 954     def test__refresh_ro_task_VimConnException_occurred(self):
 955         """
 956         vimconn.VimConnException has occured
 957         """
 958         db = "test_db"
 959         logger = "test_logger"
 960         my_vims = "test-vim"
 961         db_vims = {
 962             "vim_openstack_1": {
 963                 "config": {},
 964             },
 965         }
 966         instance = VimInteractionNet(db, logger, my_vims, db_vims)
 967         with patch.object(
 968             instance, "my_vims", {"vim_openstack_1": self.target_vim}
 969         ), patch.object(instance, "logger", logging), patch.object(
 970             instance, "db_vims", db_vims
 971         ):
 972             ro_task = {
 973                 "_id": "122436:1",
 974                 "locked_by": None,
 975                 "locked_at": 0.0,
 976                 "target_id": "vim_openstack_1",
 977                 "vim_info": {
 978                     "created": False,
 979                     "created_items": None,
 980                     "vim_id": "test-vim-id",
 981                     "vim_name": "test-vim",
 982                     "vim_status": "BUILD",
 983                     "vim_details": "",
 984                     "refresh_at": None,
 985                 },
 986                 "modified_at": 1637324200.994312,
 987                 "created_at": 1637324200.994312,
 988                 "to_check_at": 1637324200.994312,
 989                 "tasks": {},
 990             }
 991             self.target_vim.refresh_nets_status.side_effect = VimConnException(
 992                 "VimConnException occurred."
 993             )
 994             with self.assertLogs() as captured:
 995                 instance.refresh(ro_task)
 996                 self.assertEqual(captured.records[0].levelname, "ERROR")
 997
 998     def test__refresh_ro_task_vim_status_deleted(self):
 999         """
1000         vim_info.get('status') is DELETED
1001         """
1002         db = "test_db"
1003         logger = "test_logger"
1004         my_vims = "test-vim"
1005         db_vims = {
1006             "vim_openstack_1": {
1007                 "config": {},
1008             },
1009         }
1010         instance = VimInteractionNet(db, logger, my_vims, db_vims)
1011         with patch.object(
1012             instance, "my_vims", {"vim_openstack_1": self.target_vim}
1013         ), patch.object(instance, "logger", logging), patch.object(
1014             instance, "db_vims", db_vims
1015         ):
1016             ro_task = {
1017                 "_id": "122436:1",
1018                 "locked_by": None,
1019                 "locked_at": 0.0,
1020                 "target_id": "vim_openstack_1",
1021                 "vim_info": {
1022                     "created": False,
1023                     "created_items": None,
1024                     "vim_id": "test-vim-id",
1025                     "vim_name": "test-vim",
1026                     "vim_status": "BUILD",
1027                     "vim_details": "",
1028                     "refresh_at": None,
1029                 },
1030                 "modified_at": 163724200.994312,
1031                 "created_at": 1637324200.994312,
1032                 "to_check_at": 1637324200.994312,
1033                 "tasks": {},
1034             }
1035             self.target_vim.refresh_nets_status.return_value = {
1036                 "test-vim-id": {
1037                     "vim_info": "some-details",
1038                     "status": "DELETED",
1039                     "name": "test-vim",
1040                     "error_msg": "some error message",
1041                 }
1042             }
1043             task_status = "FAILED"
1044             ro_vim_item_update = {
1045                 "vim_status": "DELETED",
1046                 "vim_details": "Deleted externally",
1047                 "vim_id": None,
1048             }
1049             result = instance.refresh(ro_task)
1050             self.assertEqual(result[0], task_status)
1051             self.assertDictEqual(result[1], ro_vim_item_update)
1052
1053     def test__refresh_ro_task_empty_vim_dict(self):
1054         """
1055         vim_dict does not include vim_id key
1056         Raises KeyError
1057         """
1058         db = "test_db"
1059         logger = "test_logger"
1060         my_vims = "test-vim"
1061         db_vims = {
1062             "vim_openstack_2": {
1063                 "config": {},
1064             },
1065         }
1066         instance = VimInteractionNet(db, logger, my_vims, db_vims)
1067         with patch.object(
1068             instance, "my_vims", {"vim_openstack_2": self.target_vim}
1069         ), patch.object(instance, "logger", logging), patch.object(
1070             instance, "db_vims", db_vims
1071         ):
1072             ro_task = {
1073                 "_id": "128436:1",
1074                 "locked_by": None,
1075                 "locked_at": 0.0,
1076                 "target_id": "vim_openstack_2",
1077                 "vim_info": {
1078                     "created": False,
1079                     "created_items": None,
1080                     "vim_id": "test-vim-id",
1081                     "vim_name": "test-vim",
1082                     "vim_status": "BUILD",
1083                     "vim_details": "",
1084                     "refresh_at": None,
1085                 },
1086                 "modified_at": 163724211.994312,
1087                 "created_at": 1637324211.994312,
1088                 "to_check_at": 1637324211.994312,
1089                 "tasks": {},
1090             }
1091             self.target_vim.refresh_nets_status.return_value = {}
1092             with self.assertRaises(KeyError):
1093                 instance.refresh(ro_task)