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