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 VimInteractionAffinityGroup, 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                     "vim_message": None,
 821                     "refresh_at": None,
 822                 },
 823                 "modified_at": 1637324200.994312,
 824                 "created_at": 1637324200.994312,
 825                 "to_check_at": 1637324200.994312,
 826                 "tasks": {},
 827             }
 828
 829             self.target_vim.refresh_nets_status.return_value = {
 830                 "test-vim-id": {
 831                     "vim_info": "some-details",
 832                     "status": "ACTIVE",
 833                     "name": "test-vim",
 834                     "error_msg": "",
 835                 }
 836             }
 837             task_status = "DONE"
 838             ro_vim_item_update = {
 839                 "vim_status": "ACTIVE",
 840             }
 841             result = instance.refresh(ro_task)
 842             self.assertEqual(result[0], task_status)
 843             self.assertDictEqual(result[1], ro_vim_item_update)
 844
 845     def test__refresh_ro_task_vim_status_build(self):
 846         """
 847         vim_info.get('status') is BUILD
 848         """
 849         db = "test_db"
 850         logger = "test_logger"
 851         my_vims = "test-vim"
 852         db_vims = {
 853             "vim_openstack_1": {
 854                 "config": {},
 855             },
 856         }
 857         instance = VimInteractionNet(db, logger, my_vims, db_vims)
 858         with patch.object(
 859             instance, "my_vims", {"vim_openstack_1": self.target_vim}
 860         ), patch.object(instance, "logger", logging), patch.object(
 861             instance, "db_vims", db_vims
 862         ):
 863             ro_task = {
 864                 "_id": "122436:1",
 865                 "locked_by": None,
 866                 "locked_at": 0.0,
 867                 "target_id": "vim_openstack_1",
 868                 "vim_info": {
 869                     "created": False,
 870                     "created_items": None,
 871                     "vim_id": "test-vim-id",
 872                     "vim_name": "test-vim",
 873                     "vim_status": "BUILD",
 874                     "vim_details": "",
 875                     "vim_message": None,
 876                     "refresh_at": None,
 877                 },
 878                 "modified_at": 1637324200.994312,
 879                 "created_at": 1637324200.994312,
 880                 "to_check_at": 1637324200.994312,
 881                 "tasks": {},
 882             }
 883
 884             self.target_vim.refresh_nets_status.return_value = {
 885                 "test-vim-id": {
 886                     "vim_info": "some-details",
 887                     "status": "BUILD",
 888                     "name": "other-vim",
 889                     "error_msg": "",
 890                 }
 891             }
 892             task_status = "BUILD"
 893             ro_vim_item_update = {
 894                 "vim_name": "other-vim",
 895                 "vim_details": "some-details",
 896             }
 897             result = instance.refresh(ro_task)
 898             self.assertEqual(result[0], task_status)
 899             self.assertDictEqual(result[1], ro_vim_item_update)
 900
 901     def test__refresh_ro_task_vim_status_error(self):
 902         """
 903         vim_info.get('status') is ERROR
 904         """
 905         db = "test_db"
 906         logger = "test_logger"
 907         my_vims = "test-vim"
 908         db_vims = {
 909             "vim_openstack_1": {
 910                 "config": {},
 911             },
 912         }
 913         instance = VimInteractionNet(db, logger, my_vims, db_vims)
 914         with patch.object(
 915             instance, "my_vims", {"vim_openstack_1": self.target_vim}
 916         ), patch.object(instance, "logger", logging), patch.object(
 917             instance, "db_vims", db_vims
 918         ):
 919             ro_task = {
 920                 "_id": "122436:1",
 921                 "locked_by": None,
 922                 "locked_at": 0.0,
 923                 "target_id": "vim_openstack_1",
 924                 "vim_info": {
 925                     "created": False,
 926                     "created_items": None,
 927                     "vim_id": "test-vim-id",
 928                     "vim_name": "test-vim",
 929                     "vim_status": "BUILD",
 930                     "vim_details": "",
 931                     "vim_message": None,
 932                     "refresh_at": None,
 933                 },
 934                 "modified_at": 1637324200.994312,
 935                 "created_at": 1637324200.994312,
 936                 "to_check_at": 1637324200.994312,
 937                 "tasks": {},
 938             }
 939
 940             self.target_vim.refresh_nets_status.return_value = {
 941                 "test-vim-id": {
 942                     "vim_info": "some-details",
 943                     "status": "ERROR",
 944                     "name": "test-vim",
 945                     "error_msg": "some error message",
 946                 }
 947             }
 948             task_status = "FAILED"
 949             ro_vim_item_update = {
 950                 "vim_status": "ERROR",
 951                 "vim_message": "some error message",
 952             }
 953             result = instance.refresh(ro_task)
 954             self.assertEqual(result[0], task_status)
 955             self.assertDictEqual(result[1], ro_vim_item_update)
 956
 957     def test__refresh_ro_task_VimConnException_occurred(self):
 958         """
 959         vimconn.VimConnException has occured
 960         """
 961         db = "test_db"
 962         logger = "test_logger"
 963         my_vims = "test-vim"
 964         db_vims = {
 965             "vim_openstack_1": {
 966                 "config": {},
 967             },
 968         }
 969         instance = VimInteractionNet(db, logger, my_vims, db_vims)
 970         with patch.object(
 971             instance, "my_vims", {"vim_openstack_1": self.target_vim}
 972         ), patch.object(instance, "logger", logging), patch.object(
 973             instance, "db_vims", db_vims
 974         ):
 975             ro_task = {
 976                 "_id": "122436:1",
 977                 "locked_by": None,
 978                 "locked_at": 0.0,
 979                 "target_id": "vim_openstack_1",
 980                 "vim_info": {
 981                     "created": False,
 982                     "created_items": None,
 983                     "vim_id": "test-vim-id",
 984                     "vim_name": "test-vim",
 985                     "vim_status": "BUILD",
 986                     "vim_details": "",
 987                     "vim_message": None,
 988                     "refresh_at": None,
 989                 },
 990                 "modified_at": 1637324200.994312,
 991                 "created_at": 1637324200.994312,
 992                 "to_check_at": 1637324200.994312,
 993                 "tasks": {},
 994             }
 995             self.target_vim.refresh_nets_status.side_effect = VimConnException(
 996                 "VimConnException occurred."
 997             )
 998             with self.assertLogs() as captured:
 999                 instance.refresh(ro_task)
1000                 self.assertEqual(captured.records[0].levelname, "ERROR")
1001
1002     def test__refresh_ro_task_vim_status_deleted(self):
1003         """
1004         vim_info.get('status') is DELETED
1005         """
1006         db = "test_db"
1007         logger = "test_logger"
1008         my_vims = "test-vim"
1009         db_vims = {
1010             "vim_openstack_1": {
1011                 "config": {},
1012             },
1013         }
1014         instance = VimInteractionNet(db, logger, my_vims, db_vims)
1015         with patch.object(
1016             instance, "my_vims", {"vim_openstack_1": self.target_vim}
1017         ), patch.object(instance, "logger", logging), patch.object(
1018             instance, "db_vims", db_vims
1019         ):
1020             ro_task = {
1021                 "_id": "122436:1",
1022                 "locked_by": None,
1023                 "locked_at": 0.0,
1024                 "target_id": "vim_openstack_1",
1025                 "vim_info": {
1026                     "created": False,
1027                     "created_items": None,
1028                     "vim_id": "test-vim-id",
1029                     "vim_name": "test-vim",
1030                     "vim_status": "BUILD",
1031                     "vim_details": "",
1032                     "vim_message": None,
1033                     "refresh_at": None,
1034                 },
1035                 "modified_at": 163724200.994312,
1036                 "created_at": 1637324200.994312,
1037                 "to_check_at": 1637324200.994312,
1038                 "tasks": {},
1039             }
1040             self.target_vim.refresh_nets_status.return_value = {
1041                 "test-vim-id": {
1042                     "vim_info": "some-details",
1043                     "status": "DELETED",
1044                     "name": "test-vim",
1045                     "error_msg": "some error message",
1046                 }
1047             }
1048             task_status = "FAILED"
1049             ro_vim_item_update = {
1050                 "vim_status": "DELETED",
1051                 "vim_message": "Deleted externally",
1052                 "vim_id": None,
1053             }
1054             result = instance.refresh(ro_task)
1055             self.assertEqual(result[0], task_status)
1056             self.assertDictEqual(result[1], ro_vim_item_update)
1057
1058     def test__refresh_ro_task_empty_vim_dict(self):
1059         """
1060         vim_dict does not include vim_id key
1061         Raises KeyError
1062         """
1063         db = "test_db"
1064         logger = "test_logger"
1065         my_vims = "test-vim"
1066         db_vims = {
1067             "vim_openstack_2": {
1068                 "config": {},
1069             },
1070         }
1071         instance = VimInteractionNet(db, logger, my_vims, db_vims)
1072         with patch.object(
1073             instance, "my_vims", {"vim_openstack_2": self.target_vim}
1074         ), patch.object(instance, "logger", logging), patch.object(
1075             instance, "db_vims", db_vims
1076         ):
1077             ro_task = {
1078                 "_id": "128436:1",
1079                 "locked_by": None,
1080                 "locked_at": 0.0,
1081                 "target_id": "vim_openstack_2",
1082                 "vim_info": {
1083                     "created": False,
1084                     "created_items": None,
1085                     "vim_id": "test-vim-id",
1086                     "vim_name": "test-vim",
1087                     "vim_status": "BUILD",
1088                     "vim_details": "",
1089                     "vim_message": None,
1090                     "refresh_at": None,
1091                 },
1092                 "modified_at": 163724211.994312,
1093                 "created_at": 1637324211.994312,
1094                 "to_check_at": 1637324211.994312,
1095                 "tasks": {},
1096             }
1097             self.target_vim.refresh_nets_status.return_value = {}
1098             with self.assertRaises(KeyError):
1099                 instance.refresh(ro_task)
1100
1101
1102 class TestVimInteractionAffinityGroup(unittest.TestCase):
1103     def setUp(self):
1104         module_name = "osm_ro_plugin"
1105         self.target_vim = MagicMock(name=f"{module_name}.vimconn.VimConnector")
1106         self.task_depends = None
1107
1108         patches = [patch(f"{module_name}.vimconn.VimConnector", self.target_vim)]
1109
1110         # Enabling mocks and add cleanups
1111         for mock in patches:
1112             mock.start()
1113             self.addCleanup(mock.stop)
1114
1115     def test__new_affinity_group_ok(self):
1116         """
1117         create affinity group with attributes set in params
1118         """
1119         db = "test_db"
1120         logger = "test_logger"
1121         my_vims = "test-vim"
1122         db_vims = {
1123             0: {
1124                 "config": {},
1125             },
1126         }
1127
1128         instance = VimInteractionAffinityGroup(db, logger, my_vims, db_vims)
1129         with patch.object(instance, "my_vims", [self.target_vim]), patch.object(
1130             instance, "logger", logging
1131         ), patch.object(instance, "db_vims", db_vims):
1132             ro_task = {
1133                 "target_id": 0,
1134                 "tasks": {
1135                     "task_index_1": {
1136                         "target_id": 0,
1137                         "action_id": "123456",
1138                         "nsr_id": "654321",
1139                         "task_id": "123456:1",
1140                         "status": "SCHEDULED",
1141                         "action": "CREATE",
1142                         "item": "test_item",
1143                         "target_record": "test_target_record",
1144                         "target_record_id": "test_target_record_id",
1145                         # values coming from extra_dict
1146                         "params": {
1147                             "affinity_group_data": {
1148                                 "name": "affinity_group_1",
1149                                 "type": "affinity",
1150                                 "scope": "nfvi-node",
1151                             }
1152                         },
1153                         "find_params": {},
1154                         "depends_on": "test_depends_on",
1155                     },
1156                 },
1157             }
1158
1159             task_index = "task_index_1"
1160             self.target_vim.new_affinity_group.return_value = (
1161                 "sample_affinity_group_id_1"
1162             )
1163             result = instance.new(ro_task, task_index, self.task_depends)
1164             self.assertEqual(result[0], "DONE")
1165             self.assertEqual(result[1].get("vim_id"), "sample_affinity_group_id_1")
1166             self.assertEqual(result[1].get("created"), True)
1167             self.assertEqual(result[1].get("vim_status"), "DONE")
1168
1169     def test__new_affinity_group_failed(self):
1170         """
1171         create affinity group with no attributes set in params
1172         """
1173         db = "test_db"
1174         logger = "test_logger"
1175         my_vims = "test-vim"
1176         db_vims = {
1177             0: {
1178                 "config": {},
1179             },
1180         }
1181
1182         instance = VimInteractionAffinityGroup(db, logger, my_vims, db_vims)
1183         with patch.object(instance, "my_vims", [self.target_vim]), patch.object(
1184             instance, "logger", logging
1185         ), patch.object(instance, "db_vims", db_vims):
1186             ro_task = {
1187                 "target_id": 0,
1188                 "tasks": {
1189                     "task_index_2": {
1190                         "target_id": 0,
1191                         "action_id": "123456",
1192                         "nsr_id": "654321",
1193                         "task_id": "123456:1",
1194                         "status": "SCHEDULED",
1195                         "action": "CREATE",
1196                         "item": "test_item",
1197                         "target_record": "test_target_record",
1198                         "target_record_id": "test_target_record_id",
1199                         # values coming from extra_dict
1200                         "params": {},
1201                         "find_params": {},
1202                         "depends_on": "test_depends_on",
1203                     },
1204                 },
1205             }
1206
1207             task_index = "task_index_2"
1208             self.target_vim.new_affinity_group.return_value = (
1209                 "sample_affinity_group_id_1"
1210             )
1211             result = instance.new(ro_task, task_index, self.task_depends)
1212             self.assertEqual(result[0], "DONE")
1213             self.assertEqual(result[1].get("vim_id"), None)
1214             self.assertEqual(result[1].get("created"), False)
1215             self.assertEqual(result[1].get("vim_status"), "DONE")
1216
1217     def test__delete_affinity_group_ok(self):
1218         """
1219         delete affinity group with a proper vim_id
1220         """
1221         db = "test_db"
1222         logger = "test_logger"
1223         my_vims = "test-vim"
1224         db_vims = {
1225             0: {
1226                 "config": {},
1227             },
1228         }
1229
1230         instance = VimInteractionAffinityGroup(db, logger, my_vims, db_vims)
1231         with patch.object(instance, "my_vims", [self.target_vim]), patch.object(
1232             instance, "logger", logging
1233         ), patch.object(instance, "db_vims", db_vims):
1234             ro_task = {
1235                 "target_id": 0,
1236                 "tasks": {
1237                     "task_index_3": {
1238                         "target_id": 0,
1239                         "task_id": "123456:1",
1240                     },
1241                 },
1242                 "vim_info": {
1243                     "created": False,
1244                     "created_items": None,
1245                     "vim_id": "sample_affinity_group_id_3",
1246                     "vim_name": "sample_affinity_group_id_3",
1247                     "vim_status": None,
1248                     "vim_details": "some-details",
1249                     "vim_message": None,
1250                     "refresh_at": None,
1251                 },
1252             }
1253
1254             task_index = "task_index_3"
1255             self.target_vim.delete_affinity_group.return_value = (
1256                 "sample_affinity_group_id_3"
1257             )
1258             result = instance.delete(ro_task, task_index)
1259             self.assertEqual(result[0], "DONE")
1260             self.assertEqual(result[1].get("vim_message"), "DELETED")
1261             self.assertEqual(result[1].get("created"), False)
1262             self.assertEqual(result[1].get("vim_status"), "DELETED")
1263
1264     def test__delete_affinity_group_failed(self):
1265         """
1266         delete affinity group with missing vim_id
1267         """
1268         db = "test_db"
1269         logger = "test_logger"
1270         my_vims = "test-vim"
1271         db_vims = {
1272             0: {
1273                 "config": {},
1274             },
1275         }
1276
1277         instance = VimInteractionAffinityGroup(db, logger, my_vims, db_vims)
1278         with patch.object(instance, "my_vims", [self.target_vim]), patch.object(
1279             instance, "logger", logging
1280         ), patch.object(instance, "db_vims", db_vims):
1281             ro_task = {
1282                 "target_id": 0,
1283                 "tasks": {
1284                     "task_index_4": {
1285                         "target_id": 0,
1286                         "task_id": "123456:1",
1287                     },
1288                 },
1289                 "vim_info": {
1290                     "created": False,
1291                     "created_items": None,
1292                     "vim_id": None,
1293                     "vim_name": None,
1294                     "vim_status": None,
1295                     "vim_details": "some-details",
1296                     "vim_message": None,
1297                     "refresh_at": None,
1298                 },
1299             }
1300
1301             task_index = "task_index_4"
1302             self.target_vim.delete_affinity_group.return_value = ""
1303             result = instance.delete(ro_task, task_index)
1304             self.assertEqual(result[0], "DONE")
1305             self.assertEqual(result[1].get("vim_message"), "DELETED")
1306             self.assertEqual(result[1].get("created"), False)
1307             self.assertEqual(result[1].get("vim_status"), "DELETED")