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