RO-VIM-openstack/osm_rovim_openstack/tests/test_vimconn_openstack.py

   1 # -*- coding: utf-8 -*-
   2
   3 ##
   4 # Copyright 2017 Intel Corporation.
   5 #
   6 # Licensed under the Apache License, Version 2.0 (the "License"); you may
   7 # not use this file except in compliance with the License. You may obtain
   8 # a copy of the License at
   9 #
  10 #         http://www.apache.org/licenses/LICENSE-2.0
  11 #
  12 # Unless required by applicable law or agreed to in writing, software
  13 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  14 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  15 # License for the specific language governing permissions and limitations
  16 # under the License.
  17 #
  18 # For those usages not covered by the Apache License, Version 2.0 please
  19 # contact with: nfvlabs@tid.es
  20 ##
  21
  22 """
  23 This module contains unit tests for the OpenStack VIM connector
  24 Run this directly with python2 or python3.
  25 """
  26 import copy
  27 from copy import deepcopy
  28 import logging
  29 import unittest
  30
  31 import mock
  32 from mock import MagicMock, patch
  33 from neutronclient.v2_0.client import Client
  34 from novaclient import exceptions as nvExceptions
  35 from osm_ro_plugin import vimconn
  36 from osm_ro_plugin.vimconn import (
  37     VimConnConnectionException,
  38     VimConnException,
  39     VimConnNotFoundException,
  40 )
  41 from osm_rovim_openstack.vimconn_openstack import vimconnector
  42
  43 __author__ = "Igor D.C."
  44 __date__ = "$23-aug-2017 23:59:59$"
  45
  46 # Variables Used in TestNewVmInstance Class
  47 name = "basicvm"
  48 description = "my firewall"
  49 start = True
  50 image_id = "408b73-e9cc-5a6a-t270-82cc4811bd4a"
  51 flavor_id = "208b73-e9cc-5a6a-t270-82cc4811bd4a"
  52 affinity_group_list = []
  53 net_list = []
  54 cloud_config = {}
  55 disk_list = []
  56 disk_list2 = [
  57     {"size": 10, "image_id": image_id},
  58     {"size": 20},
  59 ]
  60 availability_zone_index = 0
  61 availability_zone_list = ["nova"]
  62 floating_network_vim_id = "108b73-e9cc-5a6a-t270-82cc4811bd4a"
  63 net_id = "83372685-f67f-49fd-8722-eabb7692fc22"
  64 net2_id = "46472685-f67f-49fd-8722-eabb7692fc22"
  65 mac_address = "00:00:5e:00:53:af"
  66 port_id = "03372685-f67f-49fd-8722-eabb7692fc22"
  67 time_return_value = 156570000
  68 port2_id = "17472685-f67f-49fd-8722-eabb7692fc22"
  69 root_vol_id = "tc408b73-r9cc-5a6a-a270-82cc4811bd4a"
  70 ip_addr1 = "20.3.4.5"
  71 volume_id = "ac408b73-b9cc-4a6a-a270-82cc4811bd4a"
  72 volume_id2 = "o4e0e83-b9uu-4akk-a234-89cc4811bd4a"
  73 volume_id3 = "44e0e83-t9uu-4akk-a234-p9cc4811bd4a"
  74 virtual_mac_id = "64e0e83-t9uu-4akk-a234-p9cc4811bd4a"
  75 created_items_all_true = {
  76     f"floating_ip:{floating_network_vim_id}": True,
  77     f"volume:{volume_id}": True,
  78     f"port:{port_id}": True,
  79 }
  80
  81
  82 class TestSfcOperations(unittest.TestCase):
  83     @mock.patch("logging.getLogger", autospec=True)
  84     def setUp(self, mock_logger):
  85         # Instantiate dummy VIM connector so we can test it
  86         # It throws exception because of dummy parameters,
  87         # We are disabling the logging of exception not to print them to console.
  88         mock_logger = logging.getLogger()
  89         mock_logger.disabled = True
  90         self.vimconn = vimconnector(
  91             "123",
  92             "openstackvim",
  93             "456",
  94             "789",
  95             "http://dummy.url",
  96             None,
  97             "user",
  98             "pass",
  99         )
 100
 101     def _test_new_sfi(
 102         self,
 103         create_sfc_port_pair,
 104         sfc_encap,
 105         ingress_ports=["5311c75d-d718-4369-bbda-cdcc6da60fcc"],
 106         egress_ports=["230cdf1b-de37-4891-bc07-f9010cf1f967"],
 107     ):
 108         # input to VIM connector
 109         name = "osm_sfi"
 110         # + ingress_ports
 111         # + egress_ports
 112         # TODO(igordc): must be changed to NSH in Queens (MPLS is a workaround)
 113         correlation = "nsh"
 114         if sfc_encap is not None:
 115             if not sfc_encap:
 116                 correlation = None
 117
 118         # what OpenStack is assumed to respond (patch OpenStack"s return value)
 119         dict_from_neutron = {
 120             "port_pair": {
 121                 "id": "3d7ddc13-923c-4332-971e-708ed82902ce",
 122                 "name": name,
 123                 "description": "",
 124                 "tenant_id": "130b1e97-b0f1-40a8-8804-b6ad9b8c3e0c",
 125                 "project_id": "130b1e97-b0f1-40a8-8804-b6ad9b8c3e0c",
 126                 "ingress": ingress_ports[0] if len(ingress_ports) else None,
 127                 "egress": egress_ports[0] if len(egress_ports) else None,
 128                 "service_function_parameters": {"correlation": correlation},
 129             }
 130         }
 131         create_sfc_port_pair.return_value = dict_from_neutron
 132
 133         # what the VIM connector is expected to
 134         # send to OpenStack based on the input
 135         dict_to_neutron = {
 136             "port_pair": {
 137                 "name": name,
 138                 "ingress": "5311c75d-d718-4369-bbda-cdcc6da60fcc",
 139                 "egress": "230cdf1b-de37-4891-bc07-f9010cf1f967",
 140                 "service_function_parameters": {"correlation": correlation},
 141             }
 142         }
 143
 144         # call the VIM connector
 145         if sfc_encap is None:
 146             result = self.vimconn.new_sfi(name, ingress_ports, egress_ports)
 147         else:
 148             result = self.vimconn.new_sfi(name, ingress_ports, egress_ports, sfc_encap)
 149
 150         # assert that the VIM connector made the expected call to OpenStack
 151         create_sfc_port_pair.assert_called_with(dict_to_neutron)
 152         # assert that the VIM connector had the expected result / return value
 153         self.assertEqual(result, dict_from_neutron["port_pair"]["id"])
 154
 155     def _test_new_sf(self, create_sfc_port_pair_group):
 156         # input to VIM connector
 157         name = "osm_sf"
 158         instances = [
 159             "bbd01220-cf72-41f2-9e70-0669c2e5c4cd",
 160             "12ba215e-3987-4892-bd3a-d0fd91eecf98",
 161             "e25a7c79-14c8-469a-9ae1-f601c9371ffd",
 162         ]
 163
 164         # what OpenStack is assumed to respond (patch OpenStack"s return value)
 165         dict_from_neutron = {
 166             "port_pair_group": {
 167                 "id": "3d7ddc13-923c-4332-971e-708ed82902ce",
 168                 "name": name,
 169                 "description": "",
 170                 "tenant_id": "130b1e97-b0f1-40a8-8804-b6ad9b8c3e0c",
 171                 "project_id": "130b1e97-b0f1-40a8-8804-b6ad9b8c3e0c",
 172                 "port_pairs": instances,
 173                 "group_id": 1,
 174                 "port_pair_group_parameters": {
 175                     "lb_fields": [],
 176                     "ppg_n_tuple_mapping": {
 177                         "ingress_n_tuple": {},
 178                         "egress_n_tuple": {},
 179                     },
 180                 },
 181             }
 182         }
 183         create_sfc_port_pair_group.return_value = dict_from_neutron
 184
 185         # what the VIM connector is expected to
 186         # send to OpenStack based on the input
 187         dict_to_neutron = {
 188             "port_pair_group": {
 189                 "name": name,
 190                 "port_pairs": [
 191                     "bbd01220-cf72-41f2-9e70-0669c2e5c4cd",
 192                     "12ba215e-3987-4892-bd3a-d0fd91eecf98",
 193                     "e25a7c79-14c8-469a-9ae1-f601c9371ffd",
 194                 ],
 195             }
 196         }
 197
 198         # call the VIM connector
 199         result = self.vimconn.new_sf(name, instances)
 200
 201         # assert that the VIM connector made the expected call to OpenStack
 202         create_sfc_port_pair_group.assert_called_with(dict_to_neutron)
 203         # assert that the VIM connector had the expected result / return value
 204         self.assertEqual(result, dict_from_neutron["port_pair_group"]["id"])
 205
 206     def _test_new_sfp(self, create_sfc_port_chain, sfc_encap, spi):
 207         # input to VIM connector
 208         name = "osm_sfp"
 209         classifications = [
 210             "2bd2a2e5-c5fd-4eac-a297-d5e255c35c19",
 211             "00f23389-bdfa-43c2-8b16-5815f2582fa8",
 212         ]
 213         sfs = [
 214             "2314daec-c262-414a-86e3-69bb6fa5bc16",
 215             "d8bfdb5d-195e-4f34-81aa-6135705317df",
 216         ]
 217
 218         # TODO(igordc): must be changed to NSH in Queens (MPLS is a workaround)
 219         correlation = "nsh"
 220         chain_id = 33
 221         if spi:
 222             chain_id = spi
 223
 224         # what OpenStack is assumed to respond (patch OpenStack"s return value)
 225         dict_from_neutron = {
 226             "port_chain": {
 227                 "id": "5bc05721-079b-4b6e-a235-47cac331cbb6",
 228                 "name": name,
 229                 "description": "",
 230                 "tenant_id": "130b1e97-b0f1-40a8-8804-b6ad9b8c3e0c",
 231                 "project_id": "130b1e97-b0f1-40a8-8804-b6ad9b8c3e0c",
 232                 "chain_id": chain_id,
 233                 "flow_classifiers": classifications,
 234                 "port_pair_groups": sfs,
 235                 "chain_parameters": {"correlation": correlation},
 236             }
 237         }
 238         create_sfc_port_chain.return_value = dict_from_neutron
 239
 240         # what the VIM connector is expected to
 241         # send to OpenStack based on the input
 242         dict_to_neutron = {
 243             "port_chain": {
 244                 "name": name,
 245                 "flow_classifiers": [
 246                     "2bd2a2e5-c5fd-4eac-a297-d5e255c35c19",
 247                     "00f23389-bdfa-43c2-8b16-5815f2582fa8",
 248                 ],
 249                 "port_pair_groups": [
 250                     "2314daec-c262-414a-86e3-69bb6fa5bc16",
 251                     "d8bfdb5d-195e-4f34-81aa-6135705317df",
 252                 ],
 253                 "chain_parameters": {"correlation": correlation},
 254             }
 255         }
 256         if spi:
 257             dict_to_neutron["port_chain"]["chain_id"] = spi
 258
 259         # call the VIM connector
 260         if sfc_encap is None:
 261             dict_to_neutron["port_chain"]["chain_parameters"] = {"correlation": "mpls"}
 262             if spi is None:
 263                 result = self.vimconn.new_sfp(
 264                     name, classifications, sfs, sfc_encap=False
 265                 )
 266             else:
 267                 result = self.vimconn.new_sfp(
 268                     name, classifications, sfs, sfc_encap=False, spi=spi
 269                 )
 270         else:
 271             if spi is None:
 272                 result = self.vimconn.new_sfp(name, classifications, sfs, sfc_encap)
 273             else:
 274                 result = self.vimconn.new_sfp(
 275                     name, classifications, sfs, sfc_encap, spi
 276                 )
 277
 278         # assert that the VIM connector made the expected call to OpenStack
 279         create_sfc_port_chain.assert_called_with(dict_to_neutron)
 280         # assert that the VIM connector had the expected result / return value
 281         self.assertEqual(result, dict_from_neutron["port_chain"]["id"])
 282
 283     def _test_new_classification(self, create_sfc_flow_classifier, ctype):
 284         # input to VIM connector
 285         name = "osm_classification"
 286         definition = {
 287             "ethertype": "IPv4",
 288             "logical_source_port": "aaab0ab0-1452-4636-bb3b-11dca833fa2b",
 289             "protocol": "tcp",
 290             "source_ip_prefix": "192.168.2.0/24",
 291             "source_port_range_max": 99,
 292             "source_port_range_min": 50,
 293         }
 294
 295         # what OpenStack is assumed to respond (patch OpenStack"s return value)
 296         dict_from_neutron = {"flow_classifier": copy.copy(definition)}
 297         dict_from_neutron["flow_classifier"][
 298             "id"
 299         ] = "7735ec2c-fddf-4130-9712-32ed2ab6a372"
 300         dict_from_neutron["flow_classifier"]["name"] = name
 301         dict_from_neutron["flow_classifier"]["description"] = ""
 302         dict_from_neutron["flow_classifier"][
 303             "tenant_id"
 304         ] = "130b1e97-b0f1-40a8-8804-b6ad9b8c3e0c"
 305         dict_from_neutron["flow_classifier"][
 306             "project_id"
 307         ] = "130b1e97-b0f1-40a8-8804-b6ad9b8c3e0c"
 308         create_sfc_flow_classifier.return_value = dict_from_neutron
 309
 310         # what the VIM connector is expected to
 311         # send to OpenStack based on the input
 312         dict_to_neutron = {"flow_classifier": copy.copy(definition)}
 313         dict_to_neutron["flow_classifier"]["name"] = "osm_classification"
 314
 315         # call the VIM connector
 316         result = self.vimconn.new_classification(name, ctype, definition)
 317
 318         # assert that the VIM connector made the expected call to OpenStack
 319         create_sfc_flow_classifier.assert_called_with(dict_to_neutron)
 320         # assert that the VIM connector had the expected result / return value
 321         self.assertEqual(result, dict_from_neutron["flow_classifier"]["id"])
 322
 323     @mock.patch.object(Client, "create_sfc_flow_classifier")
 324     def test_new_classification(self, create_sfc_flow_classifier):
 325         self._test_new_classification(
 326             create_sfc_flow_classifier, "legacy_flow_classifier"
 327         )
 328
 329     @mock.patch.object(Client, "create_sfc_flow_classifier")
 330     def test_new_classification_unsupported_type(self, create_sfc_flow_classifier):
 331         self.assertRaises(
 332             vimconn.VimConnNotSupportedException,
 333             self._test_new_classification,
 334             create_sfc_flow_classifier,
 335             "h265",
 336         )
 337
 338     @mock.patch.object(Client, "create_sfc_port_pair")
 339     def test_new_sfi_with_sfc_encap(self, create_sfc_port_pair):
 340         self._test_new_sfi(create_sfc_port_pair, True)
 341
 342     @mock.patch.object(Client, "create_sfc_port_pair")
 343     def test_new_sfi_without_sfc_encap(self, create_sfc_port_pair):
 344         self._test_new_sfi(create_sfc_port_pair, False)
 345
 346     @mock.patch.object(Client, "create_sfc_port_pair")
 347     def test_new_sfi_default_sfc_encap(self, create_sfc_port_pair):
 348         self._test_new_sfi(create_sfc_port_pair, None)
 349
 350     @mock.patch.object(Client, "create_sfc_port_pair")
 351     def test_new_sfi_bad_ingress_ports(self, create_sfc_port_pair):
 352         ingress_ports = [
 353             "5311c75d-d718-4369-bbda-cdcc6da60fcc",
 354             "a0273f64-82c9-11e7-b08f-6328e53f0fa7",
 355         ]
 356         self.assertRaises(
 357             vimconn.VimConnNotSupportedException,
 358             self._test_new_sfi,
 359             create_sfc_port_pair,
 360             True,
 361             ingress_ports=ingress_ports,
 362         )
 363         ingress_ports = []
 364         self.assertRaises(
 365             vimconn.VimConnNotSupportedException,
 366             self._test_new_sfi,
 367             create_sfc_port_pair,
 368             True,
 369             ingress_ports=ingress_ports,
 370         )
 371
 372     @mock.patch.object(Client, "create_sfc_port_pair")
 373     def test_new_sfi_bad_egress_ports(self, create_sfc_port_pair):
 374         egress_ports = [
 375             "230cdf1b-de37-4891-bc07-f9010cf1f967",
 376             "b41228fe-82c9-11e7-9b44-17504174320b",
 377         ]
 378         self.assertRaises(
 379             vimconn.VimConnNotSupportedException,
 380             self._test_new_sfi,
 381             create_sfc_port_pair,
 382             True,
 383             egress_ports=egress_ports,
 384         )
 385         egress_ports = []
 386         self.assertRaises(
 387             vimconn.VimConnNotSupportedException,
 388             self._test_new_sfi,
 389             create_sfc_port_pair,
 390             True,
 391             egress_ports=egress_ports,
 392         )
 393
 394     @mock.patch.object(vimconnector, "get_sfi")
 395     @mock.patch.object(Client, "create_sfc_port_pair_group")
 396     def test_new_sf(self, create_sfc_port_pair_group, get_sfi):
 397         get_sfi.return_value = {"sfc_encap": True}
 398         self._test_new_sf(create_sfc_port_pair_group)
 399
 400     @mock.patch.object(vimconnector, "get_sfi")
 401     @mock.patch.object(Client, "create_sfc_port_pair_group")
 402     def test_new_sf_inconsistent_sfc_encap(self, create_sfc_port_pair_group, get_sfi):
 403         get_sfi.return_value = {"sfc_encap": "nsh"}
 404         self.assertRaises(
 405             vimconn.VimConnNotSupportedException,
 406             self._test_new_sf,
 407             create_sfc_port_pair_group,
 408         )
 409
 410     @mock.patch.object(Client, "create_sfc_port_chain")
 411     def test_new_sfp_with_sfc_encap(self, create_sfc_port_chain):
 412         self._test_new_sfp(create_sfc_port_chain, True, None)
 413
 414     @mock.patch.object(Client, "create_sfc_port_chain")
 415     def test_new_sfp_without_sfc_encap(self, create_sfc_port_chain):
 416         self._test_new_sfp(create_sfc_port_chain, None, None)
 417         self._test_new_sfp(create_sfc_port_chain, None, 25)
 418
 419     @mock.patch.object(Client, "create_sfc_port_chain")
 420     def test_new_sfp_default_sfc_encap(self, create_sfc_port_chain):
 421         self._test_new_sfp(create_sfc_port_chain, None, None)
 422
 423     @mock.patch.object(Client, "create_sfc_port_chain")
 424     def test_new_sfp_with_sfc_encap_spi(self, create_sfc_port_chain):
 425         self._test_new_sfp(create_sfc_port_chain, True, 25)
 426
 427     @mock.patch.object(Client, "create_sfc_port_chain")
 428     def test_new_sfp_default_sfc_encap_spi(self, create_sfc_port_chain):
 429         self._test_new_sfp(create_sfc_port_chain, None, 25)
 430
 431     @mock.patch.object(Client, "list_sfc_flow_classifiers")
 432     def test_get_classification_list(self, list_sfc_flow_classifiers):
 433         # what OpenStack is assumed to return to the VIM connector
 434         list_sfc_flow_classifiers.return_value = {
 435             "flow_classifiers": [
 436                 {
 437                     "source_port_range_min": 2000,
 438                     "destination_ip_prefix": "192.168.3.0/24",
 439                     "protocol": "udp",
 440                     "description": "",
 441                     "ethertype": "IPv4",
 442                     "l7_parameters": {},
 443                     "source_port_range_max": 2000,
 444                     "destination_port_range_min": 3000,
 445                     "source_ip_prefix": "192.168.2.0/24",
 446                     "logical_destination_port": None,
 447                     "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
 448                     "destination_port_range_max": None,
 449                     "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
 450                     "logical_source_port": "aaab0ab0-1452-4636-bb3b-11dca833fa2b",
 451                     "id": "22198366-d4e8-4d6b-b4d2-637d5d6cbb7d",
 452                     "name": "fc1",
 453                 }
 454             ]
 455         }
 456
 457         # call the VIM connector
 458         filter_dict = {"protocol": "tcp", "ethertype": "IPv4"}
 459         result = self.vimconn.get_classification_list(filter_dict.copy())
 460
 461         # assert that VIM connector called OpenStack with the expected filter
 462         list_sfc_flow_classifiers.assert_called_with(**filter_dict)
 463         # assert that the VIM connector successfully
 464         # translated and returned the OpenStack result
 465         self.assertEqual(
 466             result,
 467             [
 468                 {
 469                     "id": "22198366-d4e8-4d6b-b4d2-637d5d6cbb7d",
 470                     "name": "fc1",
 471                     "description": "",
 472                     "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
 473                     "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
 474                     "ctype": "legacy_flow_classifier",
 475                     "definition": {
 476                         "source_port_range_min": 2000,
 477                         "destination_ip_prefix": "192.168.3.0/24",
 478                         "protocol": "udp",
 479                         "ethertype": "IPv4",
 480                         "l7_parameters": {},
 481                         "source_port_range_max": 2000,
 482                         "destination_port_range_min": 3000,
 483                         "source_ip_prefix": "192.168.2.0/24",
 484                         "logical_destination_port": None,
 485                         "destination_port_range_max": None,
 486                         "logical_source_port": "aaab0ab0-1452-4636-bb3b-11dca833fa2b",
 487                     },
 488                 }
 489             ],
 490         )
 491
 492     def _test_get_sfi_list(self, list_port_pair, correlation, sfc_encap):
 493         # what OpenStack is assumed to return to the VIM connector
 494         list_port_pair.return_value = {
 495             "port_pairs": [
 496                 {
 497                     "ingress": "5311c75d-d718-4369-bbda-cdcc6da60fcc",
 498                     "description": "",
 499                     "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
 500                     "egress": "5311c75d-d718-4369-bbda-cdcc6da60fcc",
 501                     "service_function_parameters": {"correlation": correlation},
 502                     "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
 503                     "id": "c121ebdd-7f2d-4213-b933-3325298a6966",
 504                     "name": "osm_sfi",
 505                 }
 506             ]
 507         }
 508
 509         # call the VIM connector
 510         filter_dict = {"name": "osm_sfi", "description": ""}
 511         result = self.vimconn.get_sfi_list(filter_dict.copy())
 512
 513         # assert that VIM connector called OpenStack with the expected filter
 514         list_port_pair.assert_called_with(**filter_dict)
 515         # assert that the VIM connector successfully
 516         # translated and returned the OpenStack result
 517         self.assertEqual(
 518             result,
 519             [
 520                 {
 521                     "ingress_ports": ["5311c75d-d718-4369-bbda-cdcc6da60fcc"],
 522                     "description": "",
 523                     "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
 524                     "egress_ports": ["5311c75d-d718-4369-bbda-cdcc6da60fcc"],
 525                     "sfc_encap": sfc_encap,
 526                     "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
 527                     "id": "c121ebdd-7f2d-4213-b933-3325298a6966",
 528                     "name": "osm_sfi",
 529                 }
 530             ],
 531         )
 532
 533     @mock.patch.object(Client, "list_sfc_port_pairs")
 534     def test_get_sfi_list_with_sfc_encap(self, list_sfc_port_pairs):
 535         self._test_get_sfi_list(list_sfc_port_pairs, "nsh", True)
 536
 537     @mock.patch.object(Client, "list_sfc_port_pairs")
 538     def test_get_sfi_list_without_sfc_encap(self, list_sfc_port_pairs):
 539         self._test_get_sfi_list(list_sfc_port_pairs, None, False)
 540
 541     @mock.patch.object(Client, "list_sfc_port_pair_groups")
 542     def test_get_sf_list(self, list_sfc_port_pair_groups):
 543         # what OpenStack is assumed to return to the VIM connector
 544         list_sfc_port_pair_groups.return_value = {
 545             "port_pair_groups": [
 546                 {
 547                     "port_pairs": [
 548                         "08fbdbb0-82d6-11e7-ad95-9bb52fbec2f2",
 549                         "0d63799c-82d6-11e7-8deb-a746bb3ae9f5",
 550                     ],
 551                     "description": "",
 552                     "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
 553                     "port_pair_group_parameters": {},
 554                     "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
 555                     "id": "f4a0bde8-82d5-11e7-90e1-a72b762fa27f",
 556                     "name": "osm_sf",
 557                 }
 558             ]
 559         }
 560
 561         # call the VIM connector
 562         filter_dict = {"name": "osm_sf", "description": ""}
 563         result = self.vimconn.get_sf_list(filter_dict.copy())
 564
 565         # assert that VIM connector called OpenStack with the expected filter
 566         list_sfc_port_pair_groups.assert_called_with(**filter_dict)
 567         # assert that the VIM connector successfully
 568         # translated and returned the OpenStack result
 569         self.assertEqual(
 570             result,
 571             [
 572                 {
 573                     "sfis": [
 574                         "08fbdbb0-82d6-11e7-ad95-9bb52fbec2f2",
 575                         "0d63799c-82d6-11e7-8deb-a746bb3ae9f5",
 576                     ],
 577                     "description": "",
 578                     "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
 579                     "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
 580                     "id": "f4a0bde8-82d5-11e7-90e1-a72b762fa27f",
 581                     "name": "osm_sf",
 582                 }
 583             ],
 584         )
 585
 586     def _test_get_sfp_list(self, list_sfc_port_chains, correlation, sfc_encap):
 587         # what OpenStack is assumed to return to the VIM connector
 588         list_sfc_port_chains.return_value = {
 589             "port_chains": [
 590                 {
 591                     "port_pair_groups": [
 592                         "7d8e3bf8-82d6-11e7-a032-8ff028839d25",
 593                         "7dc9013e-82d6-11e7-a5a6-a3a8d78a5518",
 594                     ],
 595                     "flow_classifiers": [
 596                         "1333c2f4-82d7-11e7-a5df-9327f33d104e",
 597                         "1387ab44-82d7-11e7-9bb0-476337183905",
 598                     ],
 599                     "description": "",
 600                     "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
 601                     "chain_parameters": {"correlation": correlation},
 602                     "chain_id": 40,
 603                     "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
 604                     "id": "821bc9be-82d7-11e7-8ce3-23a08a27ab47",
 605                     "name": "osm_sfp",
 606                 }
 607             ]
 608         }
 609
 610         # call the VIM connector
 611         filter_dict = {"name": "osm_sfp", "description": ""}
 612         result = self.vimconn.get_sfp_list(filter_dict.copy())
 613
 614         # assert that VIM connector called OpenStack with the expected filter
 615         list_sfc_port_chains.assert_called_with(**filter_dict)
 616         # assert that the VIM connector successfully
 617         # translated and returned the OpenStack result
 618         self.assertEqual(
 619             result,
 620             [
 621                 {
 622                     "service_functions": [
 623                         "7d8e3bf8-82d6-11e7-a032-8ff028839d25",
 624                         "7dc9013e-82d6-11e7-a5a6-a3a8d78a5518",
 625                     ],
 626                     "classifications": [
 627                         "1333c2f4-82d7-11e7-a5df-9327f33d104e",
 628                         "1387ab44-82d7-11e7-9bb0-476337183905",
 629                     ],
 630                     "description": "",
 631                     "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
 632                     "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
 633                     "sfc_encap": sfc_encap,
 634                     "spi": 40,
 635                     "id": "821bc9be-82d7-11e7-8ce3-23a08a27ab47",
 636                     "name": "osm_sfp",
 637                 }
 638             ],
 639         )
 640
 641     @mock.patch.object(Client, "list_sfc_port_chains")
 642     def test_get_sfp_list_with_sfc_encap(self, list_sfc_port_chains):
 643         self._test_get_sfp_list(list_sfc_port_chains, "nsh", True)
 644
 645     @mock.patch.object(Client, "list_sfc_port_chains")
 646     def test_get_sfp_list_without_sfc_encap(self, list_sfc_port_chains):
 647         self._test_get_sfp_list(list_sfc_port_chains, None, False)
 648
 649     @mock.patch.object(Client, "list_sfc_flow_classifiers")
 650     def test_get_classification(self, list_sfc_flow_classifiers):
 651         # what OpenStack is assumed to return to the VIM connector
 652         list_sfc_flow_classifiers.return_value = {
 653             "flow_classifiers": [
 654                 {
 655                     "source_port_range_min": 2000,
 656                     "destination_ip_prefix": "192.168.3.0/24",
 657                     "protocol": "udp",
 658                     "description": "",
 659                     "ethertype": "IPv4",
 660                     "l7_parameters": {},
 661                     "source_port_range_max": 2000,
 662                     "destination_port_range_min": 3000,
 663                     "source_ip_prefix": "192.168.2.0/24",
 664                     "logical_destination_port": None,
 665                     "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
 666                     "destination_port_range_max": None,
 667                     "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
 668                     "logical_source_port": "aaab0ab0-1452-4636-bb3b-11dca833fa2b",
 669                     "id": "22198366-d4e8-4d6b-b4d2-637d5d6cbb7d",
 670                     "name": "fc1",
 671                 }
 672             ]
 673         }
 674
 675         # call the VIM connector
 676         result = self.vimconn.get_classification("22198366-d4e8-4d6b-b4d2-637d5d6cbb7d")
 677
 678         # assert that VIM connector called OpenStack with the expected filter
 679         list_sfc_flow_classifiers.assert_called_with(
 680             id="22198366-d4e8-4d6b-b4d2-637d5d6cbb7d"
 681         )
 682         # assert that VIM connector successfully returned the OpenStack result
 683         self.assertEqual(
 684             result,
 685             {
 686                 "id": "22198366-d4e8-4d6b-b4d2-637d5d6cbb7d",
 687                 "name": "fc1",
 688                 "description": "",
 689                 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
 690                 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
 691                 "ctype": "legacy_flow_classifier",
 692                 "definition": {
 693                     "source_port_range_min": 2000,
 694                     "destination_ip_prefix": "192.168.3.0/24",
 695                     "protocol": "udp",
 696                     "ethertype": "IPv4",
 697                     "l7_parameters": {},
 698                     "source_port_range_max": 2000,
 699                     "destination_port_range_min": 3000,
 700                     "source_ip_prefix": "192.168.2.0/24",
 701                     "logical_destination_port": None,
 702                     "destination_port_range_max": None,
 703                     "logical_source_port": "aaab0ab0-1452-4636-bb3b-11dca833fa2b",
 704                 },
 705             },
 706         )
 707
 708     @mock.patch.object(Client, "list_sfc_flow_classifiers")
 709     def test_get_classification_many_results(self, list_sfc_flow_classifiers):
 710         # what OpenStack is assumed to return to the VIM connector
 711         list_sfc_flow_classifiers.return_value = {
 712             "flow_classifiers": [
 713                 {
 714                     "source_port_range_min": 2000,
 715                     "destination_ip_prefix": "192.168.3.0/24",
 716                     "protocol": "udp",
 717                     "description": "",
 718                     "ethertype": "IPv4",
 719                     "l7_parameters": {},
 720                     "source_port_range_max": 2000,
 721                     "destination_port_range_min": 3000,
 722                     "source_ip_prefix": "192.168.2.0/24",
 723                     "logical_destination_port": None,
 724                     "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
 725                     "destination_port_range_max": None,
 726                     "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
 727                     "logical_source_port": "aaab0ab0-1452-4636-bb3b-11dca833fa2b",
 728                     "id": "22198366-d4e8-4d6b-b4d2-637d5d6cbb7d",
 729                     "name": "fc1",
 730                 },
 731                 {
 732                     "source_port_range_min": 1000,
 733                     "destination_ip_prefix": "192.168.3.0/24",
 734                     "protocol": "udp",
 735                     "description": "",
 736                     "ethertype": "IPv4",
 737                     "l7_parameters": {},
 738                     "source_port_range_max": 1000,
 739                     "destination_port_range_min": 3000,
 740                     "source_ip_prefix": "192.168.2.0/24",
 741                     "logical_destination_port": None,
 742                     "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
 743                     "destination_port_range_max": None,
 744                     "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
 745                     "logical_source_port": "aaab0ab0-1452-4636-bb3b-11dca833fa2b",
 746                     "id": "3196bafc-82dd-11e7-a205-9bf6c14b0721",
 747                     "name": "fc2",
 748                 },
 749             ]
 750         }
 751
 752         # call the VIM connector
 753         self.assertRaises(
 754             vimconn.VimConnConflictException,
 755             self.vimconn.get_classification,
 756             "3196bafc-82dd-11e7-a205-9bf6c14b0721",
 757         )
 758
 759         # assert the VIM connector called OpenStack with the expected filter
 760         list_sfc_flow_classifiers.assert_called_with(
 761             id="3196bafc-82dd-11e7-a205-9bf6c14b0721"
 762         )
 763
 764     @mock.patch.object(Client, "list_sfc_flow_classifiers")
 765     def test_get_classification_no_results(self, list_sfc_flow_classifiers):
 766         # what OpenStack is assumed to return to the VIM connector
 767         list_sfc_flow_classifiers.return_value = {"flow_classifiers": []}
 768
 769         # call the VIM connector
 770         self.assertRaises(
 771             vimconn.VimConnNotFoundException,
 772             self.vimconn.get_classification,
 773             "3196bafc-82dd-11e7-a205-9bf6c14b0721",
 774         )
 775
 776         # assert the VIM connector called OpenStack with the expected filter
 777         list_sfc_flow_classifiers.assert_called_with(
 778             id="3196bafc-82dd-11e7-a205-9bf6c14b0721"
 779         )
 780
 781     @mock.patch.object(Client, "list_sfc_port_pairs")
 782     def test_get_sfi(self, list_sfc_port_pairs):
 783         # what OpenStack is assumed to return to the VIM connector
 784         list_sfc_port_pairs.return_value = {
 785             "port_pairs": [
 786                 {
 787                     "ingress": "5311c75d-d718-4369-bbda-cdcc6da60fcc",
 788                     "description": "",
 789                     "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
 790                     "egress": "5311c75d-d718-4369-bbda-cdcc6da60fcc",
 791                     "service_function_parameters": {"correlation": "nsh"},
 792                     "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
 793                     "id": "c121ebdd-7f2d-4213-b933-3325298a6966",
 794                     "name": "osm_sfi1",
 795                 },
 796             ]
 797         }
 798
 799         # call the VIM connector
 800         result = self.vimconn.get_sfi("c121ebdd-7f2d-4213-b933-3325298a6966")
 801
 802         # assert the VIM connector called OpenStack with the expected filter
 803         list_sfc_port_pairs.assert_called_with(
 804             id="c121ebdd-7f2d-4213-b933-3325298a6966"
 805         )
 806         # assert the VIM connector successfully returned the OpenStack result
 807         self.assertEqual(
 808             result,
 809             {
 810                 "ingress_ports": ["5311c75d-d718-4369-bbda-cdcc6da60fcc"],
 811                 "egress_ports": ["5311c75d-d718-4369-bbda-cdcc6da60fcc"],
 812                 "sfc_encap": True,
 813                 "description": "",
 814                 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
 815                 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
 816                 "id": "c121ebdd-7f2d-4213-b933-3325298a6966",
 817                 "name": "osm_sfi1",
 818             },
 819         )
 820
 821     @mock.patch.object(Client, "list_sfc_port_pairs")
 822     def test_get_sfi_many_results(self, list_sfc_port_pairs):
 823         # what OpenStack is assumed to return to the VIM connector
 824         list_sfc_port_pairs.return_value = {
 825             "port_pairs": [
 826                 {
 827                     "ingress": "5311c75d-d718-4369-bbda-cdcc6da60fcc",
 828                     "description": "",
 829                     "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
 830                     "egress": "5311c75d-d718-4369-bbda-cdcc6da60fcc",
 831                     "service_function_parameters": {"correlation": "nsh"},
 832                     "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
 833                     "id": "c121ebdd-7f2d-4213-b933-3325298a6966",
 834                     "name": "osm_sfi1",
 835                 },
 836                 {
 837                     "ingress": "5311c75d-d718-4369-bbda-cdcc6da60fcc",
 838                     "description": "",
 839                     "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
 840                     "egress": "5311c75d-d718-4369-bbda-cdcc6da60fcc",
 841                     "service_function_parameters": {"correlation": "nsh"},
 842                     "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
 843                     "id": "c0436d92-82db-11e7-8f9c-5fa535f1261f",
 844                     "name": "osm_sfi2",
 845                 },
 846             ]
 847         }
 848
 849         # call the VIM connector
 850         self.assertRaises(
 851             vimconn.VimConnConflictException,
 852             self.vimconn.get_sfi,
 853             "c0436d92-82db-11e7-8f9c-5fa535f1261f",
 854         )
 855
 856         # assert that VIM connector called OpenStack with the expected filter
 857         list_sfc_port_pairs.assert_called_with(
 858             id="c0436d92-82db-11e7-8f9c-5fa535f1261f"
 859         )
 860
 861     @mock.patch.object(Client, "list_sfc_port_pairs")
 862     def test_get_sfi_no_results(self, list_sfc_port_pairs):
 863         # what OpenStack is assumed to return to the VIM connector
 864         list_sfc_port_pairs.return_value = {"port_pairs": []}
 865
 866         # call the VIM connector
 867         self.assertRaises(
 868             vimconn.VimConnNotFoundException,
 869             self.vimconn.get_sfi,
 870             "b22892fc-82d9-11e7-ae85-0fea6a3b3757",
 871         )
 872
 873         # assert that VIM connector called OpenStack with the expected filter
 874         list_sfc_port_pairs.assert_called_with(
 875             id="b22892fc-82d9-11e7-ae85-0fea6a3b3757"
 876         )
 877
 878     @mock.patch.object(Client, "list_sfc_port_pair_groups")
 879     def test_get_sf(self, list_sfc_port_pair_groups):
 880         # what OpenStack is assumed to return to the VIM connector
 881         list_sfc_port_pair_groups.return_value = {
 882             "port_pair_groups": [
 883                 {
 884                     "port_pairs": ["08fbdbb0-82d6-11e7-ad95-9bb52fbec2f2"],
 885                     "description": "",
 886                     "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
 887                     "port_pair_group_parameters": {},
 888                     "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
 889                     "id": "aabba8a6-82d9-11e7-a18a-d3c7719b742d",
 890                     "name": "osm_sf1",
 891                 }
 892             ]
 893         }
 894
 895         # call the VIM connector
 896         result = self.vimconn.get_sf("b22892fc-82d9-11e7-ae85-0fea6a3b3757")
 897
 898         # assert that VIM connector called OpenStack with the expected filter
 899         list_sfc_port_pair_groups.assert_called_with(
 900             id="b22892fc-82d9-11e7-ae85-0fea6a3b3757"
 901         )
 902         # assert that VIM connector successfully returned the OpenStack result
 903         self.assertEqual(
 904             result,
 905             {
 906                 "description": "",
 907                 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
 908                 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
 909                 "sfis": ["08fbdbb0-82d6-11e7-ad95-9bb52fbec2f2"],
 910                 "id": "aabba8a6-82d9-11e7-a18a-d3c7719b742d",
 911                 "name": "osm_sf1",
 912             },
 913         )
 914
 915     @mock.patch.object(Client, "list_sfc_port_pair_groups")
 916     def test_get_sf_many_results(self, list_sfc_port_pair_groups):
 917         # what OpenStack is assumed to return to the VIM connector
 918         list_sfc_port_pair_groups.return_value = {
 919             "port_pair_groups": [
 920                 {
 921                     "port_pairs": ["08fbdbb0-82d6-11e7-ad95-9bb52fbec2f2"],
 922                     "description": "",
 923                     "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
 924                     "port_pair_group_parameters": {},
 925                     "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
 926                     "id": "aabba8a6-82d9-11e7-a18a-d3c7719b742d",
 927                     "name": "osm_sf1",
 928                 },
 929                 {
 930                     "port_pairs": ["0d63799c-82d6-11e7-8deb-a746bb3ae9f5"],
 931                     "description": "",
 932                     "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
 933                     "port_pair_group_parameters": {},
 934                     "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
 935                     "id": "b22892fc-82d9-11e7-ae85-0fea6a3b3757",
 936                     "name": "osm_sf2",
 937                 },
 938             ]
 939         }
 940
 941         # call the VIM connector
 942         self.assertRaises(
 943             vimconn.VimConnConflictException,
 944             self.vimconn.get_sf,
 945             "b22892fc-82d9-11e7-ae85-0fea6a3b3757",
 946         )
 947
 948         # assert that VIM connector called OpenStack with the expected filter
 949         list_sfc_port_pair_groups.assert_called_with(
 950             id="b22892fc-82d9-11e7-ae85-0fea6a3b3757"
 951         )
 952
 953     @mock.patch.object(Client, "list_sfc_port_pair_groups")
 954     def test_get_sf_no_results(self, list_sfc_port_pair_groups):
 955         # what OpenStack is assumed to return to the VIM connector
 956         list_sfc_port_pair_groups.return_value = {"port_pair_groups": []}
 957
 958         # call the VIM connector
 959         self.assertRaises(
 960             vimconn.VimConnNotFoundException,
 961             self.vimconn.get_sf,
 962             "b22892fc-82d9-11e7-ae85-0fea6a3b3757",
 963         )
 964
 965         # assert that VIM connector called OpenStack with the expected filter
 966         list_sfc_port_pair_groups.assert_called_with(
 967             id="b22892fc-82d9-11e7-ae85-0fea6a3b3757"
 968         )
 969
 970     @mock.patch.object(Client, "list_sfc_port_chains")
 971     def test_get_sfp(self, list_sfc_port_chains):
 972         # what OpenStack is assumed to return to the VIM connector
 973         list_sfc_port_chains.return_value = {
 974             "port_chains": [
 975                 {
 976                     "port_pair_groups": ["7d8e3bf8-82d6-11e7-a032-8ff028839d25"],
 977                     "flow_classifiers": ["1333c2f4-82d7-11e7-a5df-9327f33d104e"],
 978                     "description": "",
 979                     "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
 980                     "chain_parameters": {"correlation": "nsh"},
 981                     "chain_id": 40,
 982                     "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
 983                     "id": "821bc9be-82d7-11e7-8ce3-23a08a27ab47",
 984                     "name": "osm_sfp1",
 985                 }
 986             ]
 987         }
 988
 989         # call the VIM connector
 990         result = self.vimconn.get_sfp("821bc9be-82d7-11e7-8ce3-23a08a27ab47")
 991
 992         # assert that VIM connector called OpenStack with the expected filter
 993         list_sfc_port_chains.assert_called_with(
 994             id="821bc9be-82d7-11e7-8ce3-23a08a27ab47"
 995         )
 996         # assert that VIM connector successfully returned the OpenStack result
 997         self.assertEqual(
 998             result,
 999             {
1000                 "service_functions": ["7d8e3bf8-82d6-11e7-a032-8ff028839d25"],
1001                 "classifications": ["1333c2f4-82d7-11e7-a5df-9327f33d104e"],
1002                 "description": "",
1003                 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
1004                 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
1005                 "sfc_encap": True,
1006                 "spi": 40,
1007                 "id": "821bc9be-82d7-11e7-8ce3-23a08a27ab47",
1008                 "name": "osm_sfp1",
1009             },
1010         )
1011
1012     @mock.patch.object(Client, "list_sfc_port_chains")
1013     def test_get_sfp_many_results(self, list_sfc_port_chains):
1014         # what OpenStack is assumed to return to the VIM connector
1015         list_sfc_port_chains.return_value = {
1016             "port_chains": [
1017                 {
1018                     "port_pair_groups": ["7d8e3bf8-82d6-11e7-a032-8ff028839d25"],
1019                     "flow_classifiers": ["1333c2f4-82d7-11e7-a5df-9327f33d104e"],
1020                     "description": "",
1021                     "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
1022                     "chain_parameters": {"correlation": "nsh"},
1023                     "chain_id": 40,
1024                     "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
1025                     "id": "821bc9be-82d7-11e7-8ce3-23a08a27ab47",
1026                     "name": "osm_sfp1",
1027                 },
1028                 {
1029                     "port_pair_groups": ["7d8e3bf8-82d6-11e7-a032-8ff028839d25"],
1030                     "flow_classifiers": ["1333c2f4-82d7-11e7-a5df-9327f33d104e"],
1031                     "description": "",
1032                     "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
1033                     "chain_parameters": {"correlation": "nsh"},
1034                     "chain_id": 50,
1035                     "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
1036                     "id": "5d002f38-82de-11e7-a770-f303f11ce66a",
1037                     "name": "osm_sfp2",
1038                 },
1039             ]
1040         }
1041
1042         # call the VIM connector
1043         self.assertRaises(
1044             vimconn.VimConnConflictException,
1045             self.vimconn.get_sfp,
1046             "5d002f38-82de-11e7-a770-f303f11ce66a",
1047         )
1048
1049         # assert that VIM connector called OpenStack with the expected filter
1050         list_sfc_port_chains.assert_called_with(
1051             id="5d002f38-82de-11e7-a770-f303f11ce66a"
1052         )
1053
1054     @mock.patch.object(Client, "list_sfc_port_chains")
1055     def test_get_sfp_no_results(self, list_sfc_port_chains):
1056         # what OpenStack is assumed to return to the VIM connector
1057         list_sfc_port_chains.return_value = {"port_chains": []}
1058
1059         # call the VIM connector
1060         self.assertRaises(
1061             vimconn.VimConnNotFoundException,
1062             self.vimconn.get_sfp,
1063             "5d002f38-82de-11e7-a770-f303f11ce66a",
1064         )
1065
1066         # assert that VIM connector called OpenStack with the expected filter
1067         list_sfc_port_chains.assert_called_with(
1068             id="5d002f38-82de-11e7-a770-f303f11ce66a"
1069         )
1070
1071     @mock.patch.object(Client, "delete_sfc_flow_classifier")
1072     def test_delete_classification(self, delete_sfc_flow_classifier):
1073         result = self.vimconn.delete_classification(
1074             "638f957c-82df-11e7-b7c8-132706021464"
1075         )
1076         delete_sfc_flow_classifier.assert_called_with(
1077             "638f957c-82df-11e7-b7c8-132706021464"
1078         )
1079         self.assertEqual(result, "638f957c-82df-11e7-b7c8-132706021464")
1080
1081     @mock.patch.object(Client, "delete_sfc_port_pair")
1082     def test_delete_sfi(self, delete_sfc_port_pair):
1083         result = self.vimconn.delete_sfi("638f957c-82df-11e7-b7c8-132706021464")
1084         delete_sfc_port_pair.assert_called_with("638f957c-82df-11e7-b7c8-132706021464")
1085         self.assertEqual(result, "638f957c-82df-11e7-b7c8-132706021464")
1086
1087     @mock.patch.object(Client, "delete_sfc_port_pair_group")
1088     def test_delete_sf(self, delete_sfc_port_pair_group):
1089         result = self.vimconn.delete_sf("638f957c-82df-11e7-b7c8-132706021464")
1090         delete_sfc_port_pair_group.assert_called_with(
1091             "638f957c-82df-11e7-b7c8-132706021464"
1092         )
1093         self.assertEqual(result, "638f957c-82df-11e7-b7c8-132706021464")
1094
1095     @mock.patch.object(Client, "delete_sfc_port_chain")
1096     def test_delete_sfp(self, delete_sfc_port_chain):
1097         result = self.vimconn.delete_sfp("638f957c-82df-11e7-b7c8-132706021464")
1098         delete_sfc_port_chain.assert_called_with("638f957c-82df-11e7-b7c8-132706021464")
1099         self.assertEqual(result, "638f957c-82df-11e7-b7c8-132706021464")
1100
1101
1102 class Status:
1103     def __init__(self, s):
1104         self.status = s
1105
1106     def __str__(self):
1107         return self.status
1108
1109
1110 class CopyingMock(MagicMock):
1111     def __call__(self, *args, **kwargs):
1112         args = deepcopy(args)
1113         kwargs = deepcopy(kwargs)
1114         return super(CopyingMock, self).__call__(*args, **kwargs)
1115
1116
1117 class TestNewVmInstance(unittest.TestCase):
1118     @patch("logging.getLogger", autospec=True)
1119     def setUp(self, mock_logger):
1120         # Instantiate dummy VIM connector so we can test it
1121         # It throws exception because of dummy parameters,
1122         # We are disabling the logging of exception not to print them to console.
1123         mock_logger = logging.getLogger()
1124         mock_logger.disabled = True
1125         self.vimconn = vimconnector(
1126             "123",
1127             "openstackvim",
1128             "456",
1129             "789",
1130             "http://dummy.url",
1131             None,
1132             "user",
1133             "pass",
1134         )
1135         self.vimconn.neutron = CopyingMock()
1136         self.vimconn.nova = CopyingMock()
1137         self.vimconn.cinder = CopyingMock()
1138         self.server = MagicMock(object, autospec=True)
1139         self.server.tenant_id = "408b73-r9cc-5a6a-a270-82cc4811bd4a"
1140         self.server.id = "908b73-e9cc-5a6a-t270-82cc4811bd4a"
1141         self.vimconn.config["security_groups"] = "default"
1142         self.vimconn.config["keypair"] = "my_keypair"
1143         self.vimconn.security_groups_id = "12345"
1144         self.vimconn.nova.api_version.get_string.return_value = "2.32"
1145         self.vimconn.logger = CopyingMock()
1146
1147     @patch.object(vimconnector, "_get_ids_from_name")
1148     def test_prepare_port_dict_security_security_groups_exists_in_config(
1149         self, mock_get_ids
1150     ):
1151         """In VIM config security_groups exists, net port_security is True
1152         no_port_security_extension does not exist.
1153         """
1154         self.vimconn.config = {"security_groups": "example_security_group"}
1155         net = {"port_security": True}
1156         port_dict = {}
1157         result_dict = {"security_groups": "12345"}
1158
1159         self.vimconn._prepare_port_dict_security_groups(net, port_dict)
1160         self.assertDictEqual(result_dict, port_dict)
1161         mock_get_ids.assert_not_called()
1162
1163     @patch.object(vimconnector, "_get_ids_from_name")
1164     def test_prepare_port_dict_security_security_groups_exists_in_config_no_security_groups_id(
1165         self, mock_get_ids
1166     ):
1167         """In VIM config Security_groups exists, net port_security is True, vim security_groups_id does not exist,
1168         no_port_security_extension does not exist.
1169         """
1170         self.vimconn.config = {"security_groups": "example_security_group"}
1171         self.vimconn.security_groups_id = None
1172         net = {"port_security": True}
1173         port_dict = {}
1174         result_dict = {"security_groups": None}
1175
1176         self.vimconn._prepare_port_dict_security_groups(net, port_dict)
1177         self.assertDictEqual(result_dict, port_dict)
1178         mock_get_ids.assert_called()
1179
1180     @patch.object(vimconnector, "_get_ids_from_name")
1181     def test_prepare_port_dict_security_security_groups_exists_security_extension_true_in_config(
1182         self, mock_get_ids
1183     ):
1184         """In VIM config security_groups exists, net port_security is True, in VIM security_groups_id exists,
1185         no_port_security_extension set to True.
1186         """
1187         self.vimconn.config = {
1188             "security_groups": "example_security_group",
1189             "no_port_security_extension": True,
1190         }
1191         net = {"port_security": True}
1192         port_dict = {}
1193         result_dict = {}
1194
1195         self.vimconn._prepare_port_dict_security_groups(net, port_dict)
1196         self.assertDictEqual(result_dict, port_dict)
1197         mock_get_ids.assert_not_called()
1198
1199     @patch.object(vimconnector, "_get_ids_from_name")
1200     def test_prepare_port_dict_security_no_security_groups_in_config(
1201         self, mock_get_ids
1202     ):
1203         """In VIM config security_group does not exist, net port_security True, in VIM security_groups_id exists,
1204         no_port_security_extension does not exist."""
1205         self.vimconn.config = {}
1206         net = {"port_security": True}
1207         port_dict = {}
1208         result_dict = {}
1209
1210         self.vimconn._prepare_port_dict_security_groups(net, port_dict)
1211         self.assertDictEqual(result_dict, port_dict)
1212         mock_get_ids.assert_not_called()
1213
1214     @patch.object(vimconnector, "_get_ids_from_name")
1215     def test_prepare_port_dict_security_no_security_groups_security_extension_true_in_config(
1216         self, mock_get_ids
1217     ):
1218         """Security_group does not exist, net port_security is True, in VIM security_groups_id exists,
1219         no_port_security_extension set to True."""
1220         self.vimconn.config = {"no_port_security_extension": True}
1221         net = {"port_security": True}
1222         port_dict = {}
1223         result_dict = {}
1224
1225         self.vimconn._prepare_port_dict_security_groups(net, port_dict)
1226         self.assertDictEqual(result_dict, port_dict)
1227         mock_get_ids.assert_not_called()
1228
1229     @patch.object(vimconnector, "_get_ids_from_name")
1230     def test_prepare_port_dict_security_security_groups_exists_net_port_security_false(
1231         self, mock_get_ids
1232     ):
1233         """In VIM config security_group exists, net port_security False, security_groups_id exists,
1234         no_port_security_extension does not exist."""
1235         self.vimconn.config = {"security_groups": "example_security_group"}
1236         net = {"port_security": False}
1237         port_dict = {}
1238         result_dict = {}
1239
1240         self.vimconn._prepare_port_dict_security_groups(net, port_dict)
1241         self.assertDictEqual(result_dict, port_dict)
1242         mock_get_ids.assert_not_called()
1243
1244     @patch.object(vimconnector, "_get_ids_from_name")
1245     def test_prepare_port_dict_security_net_port_security_false_port_security_extension_true(
1246         self, mock_get_ids
1247     ):
1248         """In VIM config security_group exists, net port_security False, security_groups_id exists,
1249         no_port_security_extension set to True."""
1250         self.vimconn.config = {
1251             "security_groups": "example_security_group",
1252             "no_port_security_extension": True,
1253         }
1254         net = {"port_security": False}
1255         port_dict = {}
1256         result_dict = {}
1257
1258         self.vimconn._prepare_port_dict_security_groups(net, port_dict)
1259         self.assertDictEqual(result_dict, port_dict)
1260         mock_get_ids.assert_not_called()
1261
1262     def test_prepare_port_dict_binding_net_type_virtual(self):
1263         """net type is virtual."""
1264         net = {"type": "virtual"}
1265         port_dict = {}
1266         result_dict = {}
1267         self.vimconn._prepare_port_dict_binding(net, port_dict)
1268         self.assertDictEqual(result_dict, port_dict)
1269
1270     def test_prepare_port_dict_binding_net_type_vf(self):
1271         """net type is VF, vim_type is not VIO."""
1272         net = {"type": "VF"}
1273         self.vimconn.vim_type = None
1274         port_dict = {}
1275         result_dict = {"binding:vnic_type": "direct"}
1276         self.vimconn._prepare_port_dict_binding(net, port_dict)
1277         self.assertDictEqual(port_dict, result_dict)
1278
1279     def test_prepare_port_dict_binding_net_type_sriov_vim_type_vio(self):
1280         """net type is SR-IOV, vim_type is VIO."""
1281         net = {"type": "SR-IOV"}
1282         self.vimconn.vim_type = "VIO"
1283         port_dict = {}
1284         result_dict = {
1285             "binding:vnic_type": "direct",
1286             "port_security_enabled": False,
1287             "provider_security_groups": [],
1288             "security_groups": [],
1289         }
1290         self.vimconn._prepare_port_dict_binding(net, port_dict)
1291         self.assertDictEqual(port_dict, result_dict)
1292
1293     def test_prepare_port_dict_binding_net_type_passthrough(self):
1294         """net type is pci-passthrough."""
1295         net = {"type": "PCI-PASSTHROUGH"}
1296         port_dict = {}
1297         result_dict = {
1298             "binding:vnic_type": "direct-physical",
1299         }
1300         self.vimconn._prepare_port_dict_binding(net, port_dict)
1301         self.assertDictEqual(port_dict, result_dict)
1302
1303     def test_prepare_port_dict_binding_no_net_type(self):
1304         """net type is missing."""
1305         net = {}
1306         port_dict = {}
1307         with self.assertRaises(VimConnException) as err:
1308             self.vimconn._prepare_port_dict_binding(net, port_dict)
1309         self.assertEqual(str(err.exception), "Type is missing in the network details.")
1310
1311     def test_set_fixed_ip(self):
1312         """new_port has fixed ip."""
1313         net = {}
1314         new_port = {
1315             "port": {
1316                 "fixed_ips": [{"ip_address": "10.1.2.3"}, {"ip_address": "20.1.2.3"}]
1317             }
1318         }
1319         result = {"ip": "10.1.2.3"}
1320         self.vimconn._set_fixed_ip(new_port, net)
1321         self.assertDictEqual(net, result)
1322
1323     def test_set_fixed_ip_no_fixed_ip(self):
1324         """new_port does not have fixed ip."""
1325         net = {}
1326         new_port = {"port": {}}
1327         result = {"ip": None}
1328         self.vimconn._set_fixed_ip(new_port, net)
1329         self.assertDictEqual(net, result)
1330
1331     def test_set_fixed_ip_raise_exception(self):
1332         """new_port does not have port details."""
1333         net = {}
1334         new_port = {}
1335         with self.assertRaises(Exception) as err:
1336             self.vimconn._set_fixed_ip(new_port, net)
1337         self.assertEqual(type(err.exception), KeyError)
1338
1339     def test_prepare_port_dict_mac_ip_addr(self):
1340         """mac address and ip address exist."""
1341         net = {
1342             "mac_address": mac_address,
1343             "ip_address": "10.0.1.5",
1344         }
1345         port_dict = {}
1346         result_dict = {
1347             "mac_address": mac_address,
1348             "fixed_ips": [{"ip_address": "10.0.1.5"}],
1349         }
1350         self.vimconn._prepare_port_dict_mac_ip_addr(net, port_dict)
1351         self.assertDictEqual(port_dict, result_dict)
1352
1353     def test_prepare_port_dict_mac_ip_addr_no_mac_and_ip(self):
1354         """mac address and ip address does not exist."""
1355         net = {}
1356         port_dict = {}
1357         result_dict = {}
1358         self.vimconn._prepare_port_dict_mac_ip_addr(net, port_dict)
1359         self.assertDictEqual(port_dict, result_dict)
1360
1361     def test_create_new_port(self):
1362         """new port has id and mac address."""
1363         new_port = {
1364             "port": {
1365                 "id": port_id,
1366                 "mac_address": mac_address,
1367             },
1368         }
1369         self.vimconn.neutron.create_port.return_value = new_port
1370         net, port_dict, created_items = {}, {}, {}
1371         expected_result = new_port
1372         expected_net = {
1373             "mac_adress": mac_address,
1374             "vim_id": port_id,
1375         }
1376         expected_created_items = {f"port:{port_id}": True}
1377         result = self.vimconn._create_new_port(port_dict, created_items, net)
1378         self.assertDictEqual(result, expected_result)
1379         self.assertEqual(net, expected_net)
1380         self.assertEqual(created_items, expected_created_items)
1381         self.vimconn.neutron.create_port.assert_called_once_with({"port": port_dict})
1382
1383     def test_create_new_port_without_mac_or_id(self):
1384         """new port does not have mac address or ID."""
1385         new_port = {}
1386         self.vimconn.neutron.create_port.return_value = new_port
1387         net, port_dict, created_items = {}, {}, {}
1388         with self.assertRaises(KeyError):
1389             self.vimconn._create_new_port(port_dict, created_items, net)
1390         self.vimconn.neutron.create_port.assert_called_once_with({"port": port_dict})
1391
1392     def test_create_new_port_neutron_create_port_raises_exception(self):
1393         """Neutron create port raises exception."""
1394         self.vimconn.neutron.create_port.side_effect = VimConnException(
1395             "New port is not created."
1396         )
1397         net, port_dict, created_items = {}, {}, {}
1398         with self.assertRaises(VimConnException):
1399             self.vimconn._create_new_port(port_dict, created_items, net)
1400         self.vimconn.neutron.create_port.assert_called_once_with({"port": port_dict})
1401
1402     @patch.object(vimconnector, "_prepare_port_dict_security_groups")
1403     @patch.object(vimconnector, "_prepare_port_dict_binding")
1404     @patch.object(vimconnector, "_prepare_port_dict_mac_ip_addr")
1405     @patch.object(vimconnector, "_create_new_port")
1406     @patch.object(vimconnector, "_set_fixed_ip")
1407     def test_create_port(
1408         self,
1409         mock_set_fixed_ip,
1410         mock_create_new_port,
1411         mock_prepare_port_dict_mac_ip_addr,
1412         mock_prepare_port_dict_binding,
1413         mock_prepare_port_dict_security_groups,
1414     ):
1415         """Net has name, type, net-id."""
1416
1417         net = {
1418             "net_id": net_id,
1419             "name": "management",
1420             "type": "virtual",
1421         }
1422         created_items = {}
1423         new_port = {
1424             "port": {
1425                 "id": net_id,
1426                 "mac_address": mac_address,
1427                 "name": "management",
1428                 "fixed_ips": [{"ip_address": ip_addr1}],
1429             },
1430         }
1431         mock_create_new_port.return_value = new_port
1432         expected_port = {
1433             "port-id": net_id,
1434             "tag": "management",
1435         }
1436         port_dict = {
1437             "network_id": net_id,
1438             "name": "management",
1439             "admin_state_up": True,
1440         }
1441
1442         new_port_result, port_result = self.vimconn._create_port(
1443             net, name, created_items
1444         )
1445
1446         self.assertDictEqual(new_port_result, new_port)
1447         self.assertDictEqual(port_result, expected_port)
1448
1449         mock_prepare_port_dict_security_groups.assert_called_once_with(net, port_dict)
1450         mock_prepare_port_dict_binding.assert_called_once_with(net, port_dict)
1451         mock_prepare_port_dict_mac_ip_addr.assert_called_once_with(net, port_dict)
1452         mock_create_new_port.assert_called_once_with(port_dict, created_items, net)
1453         mock_set_fixed_ip.assert_called_once_with(new_port, net)
1454
1455     @patch.object(vimconnector, "_prepare_port_dict_security_groups")
1456     @patch.object(vimconnector, "_prepare_port_dict_binding")
1457     @patch.object(vimconnector, "_prepare_port_dict_mac_ip_addr")
1458     @patch.object(vimconnector, "_create_new_port")
1459     @patch.object(vimconnector, "_set_fixed_ip")
1460     def test_create_port_no_port_name(
1461         self,
1462         mock_set_fixed_ip,
1463         mock_create_new_port,
1464         mock_prepare_port_dict_mac_ip_addr,
1465         mock_prepare_port_dict_binding,
1466         mock_prepare_port_dict_security_groups,
1467     ):
1468         """Net has no name."""
1469         net = {
1470             "net_id": net_id,
1471             "type": "virtual",
1472         }
1473         created_items = {}
1474         new_port = {
1475             "port": {
1476                 "id": net_id,
1477                 "mac_address": mac_address,
1478                 "name": name,
1479                 "fixed_ips": [{"ip_address": ip_addr1}],
1480             },
1481         }
1482         mock_create_new_port.return_value = new_port
1483         expected_port = {
1484             "port-id": net_id,
1485             "tag": name,
1486         }
1487         port_dict = {
1488             "network_id": net_id,
1489             "admin_state_up": True,
1490             "name": name,
1491         }
1492
1493         new_port_result, port_result = self.vimconn._create_port(
1494             net, name, created_items
1495         )
1496
1497         self.assertDictEqual(new_port_result, new_port)
1498         self.assertDictEqual(port_result, expected_port)
1499
1500         mock_prepare_port_dict_security_groups.assert_called_once_with(net, port_dict)
1501         mock_prepare_port_dict_binding.assert_called_once_with(net, port_dict)
1502         mock_prepare_port_dict_mac_ip_addr.assert_called_once_with(net, port_dict)
1503         mock_create_new_port.assert_called_once_with(port_dict, created_items, net)
1504         mock_set_fixed_ip.assert_called_once_with(new_port, net)
1505
1506     @patch.object(vimconnector, "_prepare_port_dict_security_groups")
1507     @patch.object(vimconnector, "_prepare_port_dict_binding")
1508     @patch.object(vimconnector, "_prepare_port_dict_mac_ip_addr")
1509     @patch.object(vimconnector, "_create_new_port")
1510     @patch.object(vimconnector, "_set_fixed_ip")
1511     def test_create_port_nova_api_version_smaller_than_232(
1512         self,
1513         mock_set_fixed_ip,
1514         mock_create_new_port,
1515         mock_prepare_port_dict_mac_ip_addr,
1516         mock_prepare_port_dict_binding,
1517         mock_prepare_port_dict_security_groups,
1518     ):
1519         """Nova api version is smaller than 2.32."""
1520         self.vimconn.nova.api_version.get_string.return_value = "2.30"
1521         net = {
1522             "net_id": net_id,
1523             "type": "virtual",
1524         }
1525         created_items = {}
1526         new_port = {
1527             "port": {
1528                 "id": net_id,
1529                 "mac_address": mac_address,
1530                 "name": name,
1531                 "fixed_ips": [{"ip_address": ip_addr1}],
1532             },
1533         }
1534         mock_create_new_port.return_value = new_port
1535         expected_port = {
1536             "port-id": net_id,
1537         }
1538         port_dict = {
1539             "network_id": net_id,
1540             "admin_state_up": True,
1541             "name": name,
1542         }
1543
1544         new_port_result, port_result = self.vimconn._create_port(
1545             net, name, created_items
1546         )
1547
1548         self.assertDictEqual(new_port_result, new_port)
1549         self.assertDictEqual(port_result, expected_port)
1550
1551         mock_prepare_port_dict_security_groups.assert_called_once_with(net, port_dict)
1552         mock_prepare_port_dict_binding.assert_called_once_with(net, port_dict)
1553         mock_prepare_port_dict_mac_ip_addr.assert_called_once_with(net, port_dict)
1554         mock_create_new_port.assert_called_once_with(port_dict, created_items, net)
1555         mock_set_fixed_ip.assert_called_once_with(new_port, net)
1556
1557     @patch.object(vimconnector, "_prepare_port_dict_security_groups")
1558     @patch.object(vimconnector, "_prepare_port_dict_binding")
1559     @patch.object(vimconnector, "_prepare_port_dict_mac_ip_addr")
1560     @patch.object(vimconnector, "_create_new_port")
1561     @patch.object(vimconnector, "_set_fixed_ip")
1562     def test_create_port_create_new_port_raise_exception(
1563         self,
1564         mock_set_fixed_ip,
1565         mock_create_new_port,
1566         mock_prepare_port_dict_mac_ip_addr,
1567         mock_prepare_port_dict_binding,
1568         mock_prepare_port_dict_security_groups,
1569     ):
1570         """_create_new_port method raises exception."""
1571         net = {
1572             "net_id": net_id,
1573             "type": "virtual",
1574         }
1575         created_items = {}
1576         mock_create_new_port.side_effect = Exception
1577         port_dict = {
1578             "network_id": net_id,
1579             "admin_state_up": True,
1580             "name": name,
1581         }
1582
1583         with self.assertRaises(Exception):
1584             self.vimconn._create_port(net, name, created_items)
1585
1586         mock_prepare_port_dict_security_groups.assert_called_once_with(net, port_dict)
1587         mock_prepare_port_dict_binding.assert_called_once_with(net, port_dict)
1588         mock_prepare_port_dict_mac_ip_addr.assert_called_once_with(net, port_dict)
1589         mock_create_new_port.assert_called_once_with(port_dict, created_items, net)
1590         mock_set_fixed_ip.assert_not_called()
1591
1592     @patch.object(vimconnector, "_prepare_port_dict_security_groups")
1593     @patch.object(vimconnector, "_prepare_port_dict_binding")
1594     @patch.object(vimconnector, "_prepare_port_dict_mac_ip_addr")
1595     @patch.object(vimconnector, "_create_new_port")
1596     @patch.object(vimconnector, "_set_fixed_ip")
1597     def test_create_port_create_sec_groups_raises_exception(
1598         self,
1599         mock_set_fixed_ip,
1600         mock_create_new_port,
1601         mock_prepare_port_dict_mac_ip_addr,
1602         mock_prepare_port_dict_binding,
1603         mock_prepare_port_dict_security_groups,
1604     ):
1605         """_prepare_port_dict_security_groups method raises exception."""
1606         net = {
1607             "net_id": net_id,
1608             "type": "virtual",
1609         }
1610         created_items = {}
1611         mock_prepare_port_dict_security_groups.side_effect = Exception
1612         port_dict = {
1613             "network_id": net_id,
1614             "admin_state_up": True,
1615             "name": name,
1616         }
1617
1618         with self.assertRaises(Exception):
1619             self.vimconn._create_port(net, name, created_items)
1620
1621         mock_prepare_port_dict_security_groups.assert_called_once_with(net, port_dict)
1622
1623         mock_prepare_port_dict_binding.assert_not_called()
1624         mock_prepare_port_dict_mac_ip_addr.assert_not_called()
1625         mock_create_new_port.assert_not_called()
1626         mock_set_fixed_ip.assert_not_called()
1627
1628     @patch.object(vimconnector, "_prepare_port_dict_security_groups")
1629     @patch.object(vimconnector, "_prepare_port_dict_binding")
1630     @patch.object(vimconnector, "_prepare_port_dict_mac_ip_addr")
1631     @patch.object(vimconnector, "_create_new_port")
1632     @patch.object(vimconnector, "_set_fixed_ip")
1633     def test_create_port_create_port_dict_binding_raise_exception(
1634         self,
1635         mock_set_fixed_ip,
1636         mock_create_new_port,
1637         mock_prepare_port_dict_mac_ip_addr,
1638         mock_prepare_port_dict_binding,
1639         mock_prepare_port_dict_security_groups,
1640     ):
1641         """_prepare_port_dict_binding method raises exception."""
1642
1643         net = {
1644             "net_id": net_id,
1645             "type": "virtual",
1646         }
1647         created_items = {}
1648         mock_prepare_port_dict_binding.side_effect = Exception
1649         port_dict = {
1650             "network_id": net_id,
1651             "admin_state_up": True,
1652             "name": name,
1653         }
1654
1655         with self.assertRaises(Exception):
1656             self.vimconn._create_port(net, name, created_items)
1657
1658         mock_prepare_port_dict_security_groups.assert_called_once_with(net, port_dict)
1659
1660         mock_prepare_port_dict_binding.assert_called_once_with(net, port_dict)
1661
1662         mock_prepare_port_dict_mac_ip_addr.assert_not_called()
1663         mock_create_new_port.assert_not_called()
1664         mock_set_fixed_ip.assert_not_called()
1665
1666     @patch.object(vimconnector, "_prepare_port_dict_security_groups")
1667     @patch.object(vimconnector, "_prepare_port_dict_binding")
1668     @patch.object(vimconnector, "_prepare_port_dict_mac_ip_addr")
1669     @patch.object(vimconnector, "_create_new_port")
1670     @patch.object(vimconnector, "_set_fixed_ip")
1671     def test_create_port_create_port_mac_ip_addr_raise_exception(
1672         self,
1673         mock_set_fixed_ip,
1674         mock_create_new_port,
1675         mock_prepare_port_dict_mac_ip_addr,
1676         mock_prepare_port_dict_binding,
1677         mock_prepare_port_dict_security_groups,
1678     ):
1679         """prepare_port_dict_mac_ip_addr method raises exception."""
1680         net = {
1681             "net_id": net_id,
1682             "type": "virtual",
1683         }
1684         created_items = {}
1685         mock_prepare_port_dict_mac_ip_addr.side_effect = Exception
1686         port_dict = {
1687             "network_id": net_id,
1688             "admin_state_up": True,
1689             "name": name,
1690         }
1691
1692         with self.assertRaises(Exception):
1693             self.vimconn._create_port(net, name, created_items)
1694
1695         mock_prepare_port_dict_security_groups.assert_called_once_with(net, port_dict)
1696         mock_prepare_port_dict_binding.assert_called_once_with(net, port_dict)
1697         mock_prepare_port_dict_mac_ip_addr.assert_called_once_with(net, port_dict)
1698
1699         mock_create_new_port.assert_not_called()
1700         mock_set_fixed_ip.assert_not_called()
1701
1702     @patch.object(vimconnector, "_prepare_port_dict_security_groups")
1703     @patch.object(vimconnector, "_prepare_port_dict_binding")
1704     @patch.object(vimconnector, "_prepare_port_dict_mac_ip_addr")
1705     @patch.object(vimconnector, "_create_new_port")
1706     @patch.object(vimconnector, "_set_fixed_ip")
1707     def test_create_port_create_port_set_fixed_ip_raise_exception(
1708         self,
1709         mock_set_fixed_ip,
1710         mock_create_new_port,
1711         mock_prepare_port_dict_mac_ip_addr,
1712         mock_prepare_port_dict_binding,
1713         mock_prepare_port_dict_security_groups,
1714     ):
1715         """_set_fixed_ip method raises exception."""
1716         net = {
1717             "net_id": net_id,
1718             "type": "virtual",
1719         }
1720         created_items = {}
1721         mock_set_fixed_ip.side_effect = VimConnException(
1722             "Port detail is missing in new_port."
1723         )
1724         port_dict = {
1725             "network_id": net_id,
1726             "admin_state_up": True,
1727             "name": name,
1728         }
1729         new_port = {
1730             "port": {
1731                 "id": net_id,
1732                 "mac_address": mac_address,
1733                 "name": name,
1734                 "fixed_ips": [{"ip_address": ip_addr1}],
1735             },
1736         }
1737         mock_create_new_port.return_value = new_port
1738
1739         with self.assertRaises(VimConnException):
1740             self.vimconn._create_port(net, name, created_items)
1741
1742         mock_prepare_port_dict_security_groups.assert_called_once_with(net, port_dict)
1743         mock_prepare_port_dict_binding.assert_called_once_with(net, port_dict)
1744         mock_prepare_port_dict_mac_ip_addr.assert_called_once_with(net, port_dict)
1745         mock_create_new_port.assert_called_once_with(port_dict, created_items, net)
1746         mock_set_fixed_ip.assert_called_once_with(new_port, net)
1747
1748     @patch.object(vimconnector, "_reload_connection")
1749     @patch.object(vimconnector, "_create_port")
1750     def test_prepare_network_for_vm_instance_no_net_id(
1751         self, mock_create_port, mock_reload_connection
1752     ):
1753         """Nets do not have net_id"""
1754         mock_reload_connection.side_effect = None
1755         created_items = {}
1756         net_list = [
1757             {
1758                 "use": "mgmt",
1759                 "port_security": False,
1760                 "exit_on_floating_ip_error": False,
1761                 "port_security_disable_strategy": "full",
1762             },
1763             {
1764                 "port_security": True,
1765                 "exit_on_floating_ip_error": False,
1766                 "floating_ip": True,
1767             },
1768         ]
1769         net_list_vim = []
1770         external_network, no_secured_ports = [], []
1771         expected_external_network, expected_no_secured_ports = [], []
1772         expected_net_list_vim = []
1773
1774         self.vimconn._prepare_network_for_vminstance(
1775             name,
1776             net_list,
1777             created_items,
1778             net_list_vim,
1779             external_network,
1780             no_secured_ports,
1781         )
1782         self.assertEqual(expected_net_list_vim, net_list_vim)
1783         self.assertEqual(external_network, expected_external_network)
1784         self.assertEqual(expected_no_secured_ports, no_secured_ports)
1785
1786         mock_create_port.assert_not_called()
1787
1788     @patch.object(vimconnector, "_reload_connection")
1789     @patch.object(vimconnector, "_create_port")
1790     def test_prepare_network_for_vm_instance_empty_net_list(
1791         self, mock_create_port, mock_reload_connection
1792     ):
1793         """Net list is empty."""
1794         mock_reload_connection.side_effect = None
1795         created_items = {}
1796         net_list_vim = []
1797         external_network, no_secured_ports = [], []
1798         expected_external_network, expected_no_secured_ports = [], []
1799         expected_net_list_vim = []
1800
1801         self.vimconn._prepare_network_for_vminstance(
1802             name,
1803             net_list,
1804             created_items,
1805             net_list_vim,
1806             external_network,
1807             no_secured_ports,
1808         )
1809         self.assertEqual(expected_net_list_vim, net_list_vim)
1810         self.assertEqual(external_network, expected_external_network)
1811         self.assertEqual(expected_no_secured_ports, no_secured_ports)
1812
1813         mock_create_port.assert_not_called()
1814
1815     @patch.object(vimconnector, "_reload_connection")
1816     @patch.object(vimconnector, "_create_port")
1817     def test_prepare_network_for_vm_instance_use_floating_ip_false_mgmt_net(
1818         self, mock_create_port, mock_reload_connection
1819     ):
1820         """Nets have net-id, floating_ip False, mgmt network."""
1821         mock_reload_connection.side_effect = None
1822         created_items = {}
1823         net_list = [
1824             {
1825                 "net_id": net2_id,
1826                 "floating_ip": False,
1827                 "use": "mgmt",
1828             }
1829         ]
1830         net_list_vim = []
1831         mock_create_port.side_effect = [
1832             (
1833                 {
1834                     "port": {
1835                         "id": port2_id,
1836                         "mac_address": mac_address,
1837                         "name": name,
1838                     },
1839                 },
1840                 {"port-dict": port2_id},
1841             ),
1842         ]
1843         external_network, no_secured_ports = [], []
1844         expected_external_network, expected_no_secured_ports = [], []
1845         expected_net_list_vim = [{"port-dict": port2_id}]
1846         self.vimconn._prepare_network_for_vminstance(
1847             name,
1848             net_list,
1849             created_items,
1850             net_list_vim,
1851             external_network,
1852             no_secured_ports,
1853         )
1854         self.assertEqual(expected_net_list_vim, net_list_vim)
1855         self.assertEqual(external_network, expected_external_network)
1856         self.assertEqual(expected_no_secured_ports, no_secured_ports)
1857
1858         mock_create_port.assert_called_once_with(
1859             {
1860                 "net_id": net2_id,
1861                 "floating_ip": False,
1862                 "use": "mgmt",
1863             },
1864             name,
1865             created_items,
1866         )
1867
1868     @patch.object(vimconnector, "_reload_connection")
1869     def test_prepare_network_for_vm_instance_mgmt_net_net_port_security_and_floating_ip_true(
1870         self, mock_reload_connection
1871     ):
1872         """Nets have net-id, use_floating_ip False in VIM config, mgmt network, net floating_ip is True."""
1873         self.vimconn.config["use_floating_ip"] = False
1874         mock_create_port = CopyingMock()
1875         mock_reload_connection.side_effect = None
1876         created_items = {}
1877         net_list = [
1878             {
1879                 "net_id": net2_id,
1880                 "floating_ip": True,
1881                 "use": "mgmt",
1882             }
1883         ]
1884         net_list_vim = []
1885         mock_create_port.side_effect = [
1886             (
1887                 {
1888                     "port": {
1889                         "id": port2_id,
1890                         "mac_address": mac_address,
1891                         "name": name,
1892                     },
1893                 },
1894                 {"port-dict": port2_id},
1895             ),
1896         ]
1897         external_network, no_secured_ports = [], []
1898         expected_external_network = [
1899             {
1900                 "net_id": net2_id,
1901                 "floating_ip": True,
1902                 "use": "mgmt",
1903                 "exit_on_floating_ip_error": True,
1904             },
1905         ]
1906         expected_no_secured_ports = []
1907         expected_net_list_vim = [{"port-dict": port2_id}]
1908         with patch.object(vimconnector, "_create_port", mock_create_port):
1909             self.vimconn._prepare_network_for_vminstance(
1910                 name,
1911                 net_list,
1912                 created_items,
1913                 net_list_vim,
1914                 external_network,
1915                 no_secured_ports,
1916             )
1917         self.assertEqual(expected_net_list_vim, net_list_vim)
1918         self.assertEqual(external_network, expected_external_network)
1919         self.assertEqual(expected_no_secured_ports, no_secured_ports)
1920
1921         mock_create_port.assert_called_once_with(
1922             {
1923                 "net_id": net2_id,
1924                 "floating_ip": True,
1925                 "use": "mgmt",
1926             },
1927             name,
1928             created_items,
1929         )
1930
1931     @patch.object(vimconnector, "_reload_connection")
1932     def test_prepare_network_for_vm_instance_use_floating_ip_true_mgmt_net_port_security_false(
1933         self, mock_reload_connection
1934     ):
1935         """Nets have net-id, use_floating_ip is True in VIM config, mgmt network, net port security is False."""
1936         mock_create_port = CopyingMock()
1937         self.vimconn.config["use_floating_ip"] = True
1938         self.vimconn.config["no_port_security_extension"] = False
1939         mock_reload_connection.side_effect = None
1940         created_items = {}
1941
1942         net_list = [
1943             {
1944                 "net_id": net2_id,
1945                 "use": "mgmt",
1946                 "port_security": False,
1947                 "exit_on_floating_ip_error": False,
1948                 "port_security_disable_strategy": "full",
1949             }
1950         ]
1951         net_list_vim = []
1952         mock_create_port.side_effect = [
1953             (
1954                 {
1955                     "port": {
1956                         "id": port2_id,
1957                         "mac_address": mac_address,
1958                         "name": name,
1959                     },
1960                 },
1961                 {"port-dict": port2_id},
1962             ),
1963         ]
1964         external_network, no_secured_ports = [], []
1965         expected_external_network = [
1966             {
1967                 "net_id": net2_id,
1968                 "use": "mgmt",
1969                 "port_security": False,
1970                 "exit_on_floating_ip_error": False,
1971                 "port_security_disable_strategy": "full",
1972                 "floating_ip": True,
1973             },
1974         ]
1975         expected_no_secured_ports = [(port2_id, "full")]
1976         expected_net_list_vim = [{"port-dict": port2_id}]
1977         with patch.object(vimconnector, "_create_port", mock_create_port):
1978             self.vimconn._prepare_network_for_vminstance(
1979                 name,
1980                 net_list,
1981                 created_items,
1982                 net_list_vim,
1983                 external_network,
1984                 no_secured_ports,
1985             )
1986
1987         mock_create_port.assert_called_once_with(
1988             {
1989                 "net_id": net2_id,
1990                 "use": "mgmt",
1991                 "port_security": False,
1992                 "exit_on_floating_ip_error": False,
1993                 "port_security_disable_strategy": "full",
1994             },
1995             name,
1996             created_items,
1997         )
1998         self.assertEqual(expected_net_list_vim, net_list_vim)
1999         self.assertEqual(external_network, expected_external_network)
2000         self.assertEqual(expected_no_secured_ports, no_secured_ports)
2001
2002     @patch.object(vimconnector, "_reload_connection")
2003     def test_prepare_network_for_vm_instance_use_fip_true_non_mgmt_net_port_security_false(
2004         self, mock_reload_connection
2005     ):
2006         """Nets have net-id, use_floating_ip True in VIM config, non-mgmt network, port security is False."""
2007         mock_create_port = CopyingMock()
2008         self.vimconn.config["use_floating_ip"] = True
2009         self.vimconn.config["no_port_security_extension"] = False
2010         mock_reload_connection.side_effect = None
2011         created_items = {}
2012
2013         net_list = [
2014             {
2015                 "net_id": net2_id,
2016                 "use": "other",
2017                 "port_security": False,
2018                 "port_security_disable_strategy": "full",
2019             }
2020         ]
2021         net_list_vim = []
2022         mock_create_port.side_effect = [
2023             (
2024                 {
2025                     "port": {
2026                         "id": port2_id,
2027                         "mac_address": mac_address,
2028                         "name": name,
2029                     },
2030                 },
2031                 {"port-dict": port2_id},
2032             ),
2033         ]
2034         external_network, no_secured_ports = [], []
2035         expected_external_network = []
2036         expected_no_secured_ports = [(port2_id, "full")]
2037         expected_net_list_vim = [{"port-dict": port2_id}]
2038         with patch.object(vimconnector, "_create_port", mock_create_port):
2039             self.vimconn._prepare_network_for_vminstance(
2040                 name,
2041                 net_list,
2042                 created_items,
2043                 net_list_vim,
2044                 external_network,
2045                 no_secured_ports,
2046             )
2047
2048         mock_create_port.assert_called_once_with(
2049             {
2050                 "net_id": net2_id,
2051                 "use": "other",
2052                 "port_security": False,
2053                 "port_security_disable_strategy": "full",
2054             },
2055             name,
2056             created_items,
2057         )
2058         self.assertEqual(expected_net_list_vim, net_list_vim)
2059         self.assertEqual(external_network, expected_external_network)
2060         self.assertEqual(expected_no_secured_ports, no_secured_ports)
2061
2062     @patch.object(vimconnector, "_reload_connection")
2063     def test_prepare_network_for_vm_instance_use_fip_true_non_mgmt_net_port_security_true(
2064         self, mock_reload_connection
2065     ):
2066         """Nets have net-id, use_floating_ip is True in VIM config, non-mgmt network, net port security is True."""
2067         mock_create_port = CopyingMock()
2068         self.vimconn.config["use_floating_ip"] = True
2069         self.vimconn.config["no_port_security_extension"] = True
2070         mock_reload_connection.side_effect = None
2071         created_items = {}
2072
2073         net_list = [
2074             {
2075                 "net_id": net2_id,
2076                 "use": "other",
2077                 "port_security": True,
2078                 "port_security_disable_strategy": "full",
2079             }
2080         ]
2081         net_list_vim = []
2082         mock_create_port.side_effect = [
2083             (
2084                 {
2085                     "port": {
2086                         "id": port2_id,
2087                         "mac_address": mac_address,
2088                         "name": name,
2089                     },
2090                 },
2091                 {"port-dict": port2_id},
2092             ),
2093         ]
2094         external_network, no_secured_ports = [], []
2095         expected_external_network = []
2096         expected_no_secured_ports = []
2097         expected_net_list_vim = [{"port-dict": port2_id}]
2098         with patch.object(vimconnector, "_create_port", mock_create_port):
2099             self.vimconn._prepare_network_for_vminstance(
2100                 name,
2101                 net_list,
2102                 created_items,
2103                 net_list_vim,
2104                 external_network,
2105                 no_secured_ports,
2106             )
2107
2108         mock_create_port.assert_called_once_with(
2109             {
2110                 "net_id": net2_id,
2111                 "use": "other",
2112                 "port_security": True,
2113                 "port_security_disable_strategy": "full",
2114             },
2115             name,
2116             created_items,
2117         )
2118         self.assertEqual(expected_net_list_vim, net_list_vim)
2119         self.assertEqual(external_network, expected_external_network)
2120         self.assertEqual(expected_no_secured_ports, no_secured_ports)
2121
2122     @patch.object(vimconnector, "_reload_connection")
2123     def test_prepare_network_for_vm_instance_create_port_raise_exception(
2124         self, mock_reload_connection
2125     ):
2126         """_create_port method raise exception."""
2127         mock_create_port = CopyingMock()
2128         self.vimconn.config["use_floating_ip"] = True
2129         self.vimconn.config["no_port_security_extension"] = True
2130         mock_reload_connection.side_effect = None
2131         created_items = {}
2132
2133         net_list = [
2134             {
2135                 "net_id": net2_id,
2136                 "use": "other",
2137                 "port_security": True,
2138                 "port_security_disable_strategy": "full",
2139             }
2140         ]
2141         net_list_vim = []
2142         mock_create_port.side_effect = KeyError
2143         external_network, no_secured_ports = [], []
2144         expected_external_network = []
2145         expected_no_secured_ports = []
2146         expected_net_list_vim = []
2147         with patch.object(vimconnector, "_create_port", mock_create_port):
2148             with self.assertRaises(Exception) as err:
2149                 self.vimconn._prepare_network_for_vminstance(
2150                     name,
2151                     net_list,
2152                     created_items,
2153                     net_list_vim,
2154                     external_network,
2155                     no_secured_ports,
2156                 )
2157
2158         self.assertEqual(type(err.exception), KeyError)
2159
2160         mock_create_port.assert_called_once_with(
2161             {
2162                 "net_id": net2_id,
2163                 "use": "other",
2164                 "port_security": True,
2165                 "port_security_disable_strategy": "full",
2166             },
2167             name,
2168             created_items,
2169         )
2170         self.assertEqual(expected_net_list_vim, net_list_vim)
2171         self.assertEqual(external_network, expected_external_network)
2172         self.assertEqual(expected_no_secured_ports, no_secured_ports)
2173
2174     @patch.object(vimconnector, "_reload_connection")
2175     def test_prepare_network_for_vm_instance_reload_connection_raise_exception(
2176         self, mock_reload_connection
2177     ):
2178         """_reload_connection method raises exception."""
2179         mock_create_port = CopyingMock()
2180         mock_reload_connection.side_effect = VimConnConnectionException(
2181             "Connection failed."
2182         )
2183         self.vimconn.config["use_floating_ip"] = True
2184         self.vimconn.config["no_port_security_extension"] = True
2185         created_items = {}
2186
2187         net_list = [
2188             {
2189                 "net_id": net2_id,
2190                 "use": "other",
2191                 "port_security": True,
2192                 "port_security_disable_strategy": "full",
2193             }
2194         ]
2195         net_list_vim = []
2196         mock_create_port.side_effect = None
2197         external_network, no_secured_ports = [], []
2198         expected_external_network = []
2199         expected_no_secured_ports = []
2200         expected_net_list_vim = []
2201         with patch.object(vimconnector, "_create_port", mock_create_port):
2202             with self.assertRaises(Exception) as err:
2203                 self.vimconn._prepare_network_for_vminstance(
2204                     name,
2205                     net_list,
2206                     created_items,
2207                     net_list_vim,
2208                     external_network,
2209                     no_secured_ports,
2210                 )
2211
2212         self.assertEqual(type(err.exception), VimConnConnectionException)
2213         self.assertEqual(str(err.exception), "Connection failed.")
2214         mock_reload_connection.assert_called_once()
2215         mock_create_port.assert_not_called()
2216         self.assertEqual(expected_net_list_vim, net_list_vim)
2217         self.assertEqual(external_network, expected_external_network)
2218         self.assertEqual(expected_no_secured_ports, no_secured_ports)
2219
2220     def test_prepare_persistent_root_volumes_vim_using_volume_id(self):
2221         """Existing persistent root volume with vim_volume_id."""
2222         vm_av_zone = ["nova"]
2223         base_disk_index = ord("a")
2224         disk = {"vim_volume_id": volume_id}
2225         block_device_mapping = {}
2226         existing_vim_volumes = []
2227         created_items = {}
2228         expected_boot_vol_id = None
2229         expected_block_device_mapping = {"vda": volume_id}
2230         expected_existing_vim_volumes = [{"id": volume_id}]
2231         boot_volume_id = self.vimconn._prepare_persistent_root_volumes(
2232             name,
2233             vm_av_zone,
2234             disk,
2235             base_disk_index,
2236             block_device_mapping,
2237             existing_vim_volumes,
2238             created_items,
2239         )
2240         self.assertEqual(boot_volume_id, expected_boot_vol_id)
2241         self.assertDictEqual(block_device_mapping, expected_block_device_mapping)
2242         self.assertEqual(existing_vim_volumes, expected_existing_vim_volumes)
2243         self.vimconn.cinder.volumes.create.assert_not_called()
2244
2245     @patch.object(vimconnector, "update_block_device_mapping")
2246     def test_prepare_persistent_non_root_volumes_vim_using_volume_id(
2247         self, mock_update_block_device_mapping
2248     ):
2249         """Existing persistent non root volume with vim_volume_id."""
2250         vm_av_zone = ["nova"]
2251         base_disk_index = ord("b")
2252         disk = {"vim_volume_id": volume_id}
2253         block_device_mapping = {}
2254         existing_vim_volumes = []
2255         created_items = {}
2256         expected_block_device_mapping = {"vdb": volume_id}
2257         expected_existing_vim_volumes = [{"id": volume_id}]
2258         self.vimconn._prepare_non_root_persistent_volumes(
2259             name,
2260             disk,
2261             vm_av_zone,
2262             block_device_mapping,
2263             base_disk_index,
2264             existing_vim_volumes,
2265             created_items,
2266         )
2267         self.assertDictEqual(block_device_mapping, expected_block_device_mapping)
2268         self.assertEqual(existing_vim_volumes, expected_existing_vim_volumes)
2269         self.vimconn.cinder.volumes.create.assert_not_called()
2270         mock_update_block_device_mapping.assert_not_called()
2271
2272     @patch.object(vimconnector, "update_block_device_mapping")
2273     def test_prepare_persistent_root_volumes_using_vim_id(
2274         self, mock_update_block_device_mapping
2275     ):
2276         """Existing persistent root volume with vim_id."""
2277         vm_av_zone = ["nova"]
2278         base_disk_index = ord("a")
2279         disk = {"vim_id": volume_id}
2280         block_device_mapping = {}
2281         existing_vim_volumes = []
2282         created_items = {}
2283         expected_boot_vol_id = None
2284         expected_block_device_mapping = {"vda": volume_id}
2285         expected_existing_vim_volumes = [{"id": volume_id}]
2286         boot_volume_id = self.vimconn._prepare_persistent_root_volumes(
2287             name,
2288             vm_av_zone,
2289             disk,
2290             base_disk_index,
2291             block_device_mapping,
2292             existing_vim_volumes,
2293             created_items,
2294         )
2295         self.assertEqual(boot_volume_id, expected_boot_vol_id)
2296         self.assertDictEqual(block_device_mapping, expected_block_device_mapping)
2297         self.assertEqual(existing_vim_volumes, expected_existing_vim_volumes)
2298         self.vimconn.cinder.volumes.create.assert_not_called()
2299         mock_update_block_device_mapping.assert_not_called()
2300
2301     @patch.object(vimconnector, "update_block_device_mapping")
2302     def test_prepare_persistent_non_root_volumes_using_vim_id(
2303         self, mock_update_block_device_mapping
2304     ):
2305         """Existing persistent root volume with vim_id."""
2306         vm_av_zone = ["nova"]
2307         base_disk_index = ord("b")
2308         disk = {"vim_id": volume_id}
2309         block_device_mapping = {}
2310         existing_vim_volumes = []
2311         created_items = {}
2312
2313         expected_block_device_mapping = {"vdb": volume_id}
2314         expected_existing_vim_volumes = [{"id": volume_id}]
2315         self.vimconn._prepare_non_root_persistent_volumes(
2316             name,
2317             disk,
2318             vm_av_zone,
2319             block_device_mapping,
2320             base_disk_index,
2321             existing_vim_volumes,
2322             created_items,
2323         )
2324
2325         self.assertDictEqual(block_device_mapping, expected_block_device_mapping)
2326         self.assertEqual(existing_vim_volumes, expected_existing_vim_volumes)
2327         self.vimconn.cinder.volumes.create.assert_not_called()
2328         mock_update_block_device_mapping.assert_not_called()
2329
2330     @patch.object(vimconnector, "update_block_device_mapping")
2331     def test_prepare_persistent_root_volumes_create(
2332         self, mock_update_block_device_mapping
2333     ):
2334         """Create persistent root volume."""
2335         self.vimconn.cinder.volumes.create.return_value.id = volume_id2
2336         vm_av_zone = ["nova"]
2337         base_disk_index = ord("a")
2338         disk = {"size": 10, "image_id": image_id}
2339         block_device_mapping = {}
2340         existing_vim_volumes = []
2341         created_items = {}
2342         expected_boot_vol_id = volume_id2
2343         boot_volume_id = self.vimconn._prepare_persistent_root_volumes(
2344             name,
2345             vm_av_zone,
2346             disk,
2347             base_disk_index,
2348             block_device_mapping,
2349             existing_vim_volumes,
2350             created_items,
2351         )
2352         self.assertEqual(boot_volume_id, expected_boot_vol_id)
2353         self.vimconn.cinder.volumes.create.assert_called_once_with(
2354             size=10,
2355             name="basicvmvda",
2356             imageRef=image_id,
2357             availability_zone=["nova"],
2358         )
2359         mock_update_block_device_mapping.assert_called_once()
2360         _call_mock_update_block_device_mapping = (
2361             mock_update_block_device_mapping.call_args_list
2362         )
2363         self.assertEqual(
2364             _call_mock_update_block_device_mapping[0].kwargs["block_device_mapping"],
2365             block_device_mapping,
2366         )
2367         self.assertEqual(
2368             _call_mock_update_block_device_mapping[0].kwargs["base_disk_index"], 97
2369         )
2370         self.assertEqual(_call_mock_update_block_device_mapping[0].kwargs["disk"], disk)
2371         self.assertEqual(
2372             _call_mock_update_block_device_mapping[0].kwargs["created_items"], {}
2373         )
2374
2375     @patch.object(vimconnector, "update_block_device_mapping")
2376     def test_prepare_persistent_root_volumes_create_with_keep(
2377         self, mock_update_block_device_mapping
2378     ):
2379         """Create persistent root volume, disk has keep parameter."""
2380         self.vimconn.cinder.volumes.create.return_value.id = volume_id2
2381         vm_av_zone = ["nova"]
2382         base_disk_index = ord("a")
2383         disk = {"size": 10, "image_id": image_id, "keep": True}
2384         block_device_mapping = {}
2385         existing_vim_volumes = []
2386         created_items = {}
2387         expected_boot_vol_id = volume_id2
2388         expected_existing_vim_volumes = []
2389         boot_volume_id = self.vimconn._prepare_persistent_root_volumes(
2390             name,
2391             vm_av_zone,
2392             disk,
2393             base_disk_index,
2394             block_device_mapping,
2395             existing_vim_volumes,
2396             created_items,
2397         )
2398         self.assertEqual(boot_volume_id, expected_boot_vol_id)
2399         self.assertEqual(existing_vim_volumes, expected_existing_vim_volumes)
2400         self.vimconn.cinder.volumes.create.assert_called_once_with(
2401             size=10,
2402             name="basicvmvda",
2403             imageRef=image_id,
2404             availability_zone=["nova"],
2405         )
2406         mock_update_block_device_mapping.assert_called_once()
2407         _call_mock_update_block_device_mapping = (
2408             mock_update_block_device_mapping.call_args_list
2409         )
2410         self.assertEqual(
2411             _call_mock_update_block_device_mapping[0].kwargs["block_device_mapping"],
2412             block_device_mapping,
2413         )
2414         self.assertEqual(
2415             _call_mock_update_block_device_mapping[0].kwargs["base_disk_index"], 97
2416         )
2417         self.assertEqual(_call_mock_update_block_device_mapping[0].kwargs["disk"], disk)
2418         self.assertEqual(
2419             _call_mock_update_block_device_mapping[0].kwargs["created_items"], {}
2420         )
2421
2422     @patch.object(vimconnector, "update_block_device_mapping")
2423     def test_prepare_persistent_non_root_volumes_create(
2424         self, mock_update_block_device_mapping
2425     ):
2426         """Create persistent non-root volume."""
2427         self.vimconn.cinder = CopyingMock()
2428         self.vimconn.cinder.volumes.create.return_value.id = volume_id2
2429         vm_av_zone = ["nova"]
2430         base_disk_index = ord("a")
2431         disk = {"size": 10}
2432         block_device_mapping = {}
2433         existing_vim_volumes = []
2434         created_items = {}
2435         expected_existing_vim_volumes = []
2436         self.vimconn._prepare_non_root_persistent_volumes(
2437             name,
2438             disk,
2439             vm_av_zone,
2440             block_device_mapping,
2441             base_disk_index,
2442             existing_vim_volumes,
2443             created_items,
2444         )
2445
2446         self.assertEqual(existing_vim_volumes, expected_existing_vim_volumes)
2447         self.vimconn.cinder.volumes.create.assert_called_once_with(
2448             size=10, name="basicvmvda", availability_zone=["nova"]
2449         )
2450         mock_update_block_device_mapping.assert_called_once()
2451         _call_mock_update_block_device_mapping = (
2452             mock_update_block_device_mapping.call_args_list
2453         )
2454         self.assertEqual(
2455             _call_mock_update_block_device_mapping[0].kwargs["block_device_mapping"],
2456             block_device_mapping,
2457         )
2458         self.assertEqual(
2459             _call_mock_update_block_device_mapping[0].kwargs["base_disk_index"], 97
2460         )
2461         self.assertEqual(_call_mock_update_block_device_mapping[0].kwargs["disk"], disk)
2462         self.assertEqual(
2463             _call_mock_update_block_device_mapping[0].kwargs["created_items"], {}
2464         )
2465
2466     @patch.object(vimconnector, "update_block_device_mapping")
2467     def test_prepare_persistent_non_root_volumes_create_with_keep(
2468         self, mock_update_block_device_mapping
2469     ):
2470         """Create persistent non-root volume."""
2471         self.vimconn.cinder = CopyingMock()
2472         self.vimconn.cinder.volumes.create.return_value.id = volume_id2
2473         vm_av_zone = ["nova"]
2474         base_disk_index = ord("a")
2475         disk = {"size": 10, "keep": True}
2476         block_device_mapping = {}
2477         existing_vim_volumes = []
2478         created_items = {}
2479         expected_existing_vim_volumes = []
2480         self.vimconn._prepare_non_root_persistent_volumes(
2481             name,
2482             disk,
2483             vm_av_zone,
2484             block_device_mapping,
2485             base_disk_index,
2486             existing_vim_volumes,
2487             created_items,
2488         )
2489
2490         self.assertEqual(existing_vim_volumes, expected_existing_vim_volumes)
2491         self.vimconn.cinder.volumes.create.assert_called_once_with(
2492             size=10, name="basicvmvda", availability_zone=["nova"]
2493         )
2494         mock_update_block_device_mapping.assert_called_once()
2495         _call_mock_update_block_device_mapping = (
2496             mock_update_block_device_mapping.call_args_list
2497         )
2498         self.assertEqual(
2499             _call_mock_update_block_device_mapping[0].kwargs["block_device_mapping"],
2500             block_device_mapping,
2501         )
2502         self.assertEqual(
2503             _call_mock_update_block_device_mapping[0].kwargs["base_disk_index"], 97
2504         )
2505         self.assertEqual(_call_mock_update_block_device_mapping[0].kwargs["disk"], disk)
2506         self.assertEqual(
2507             _call_mock_update_block_device_mapping[0].kwargs["created_items"], {}
2508         )
2509
2510     @patch.object(vimconnector, "update_block_device_mapping")
2511     def test_prepare_persistent_root_volumes_create_raise_exception(
2512         self, mock_update_block_device_mapping
2513     ):
2514         """Create persistent root volume raise exception."""
2515         self.vimconn.cinder.volumes.create.side_effect = Exception
2516         vm_av_zone = ["nova"]
2517         base_disk_index = ord("a")
2518         disk = {"size": 10, "image_id": image_id}
2519         block_device_mapping = {}
2520         existing_vim_volumes = []
2521         created_items = {}
2522
2523         with self.assertRaises(Exception):
2524             result = self.vimconn._prepare_persistent_root_volumes(
2525                 name,
2526                 vm_av_zone,
2527                 disk,
2528                 base_disk_index,
2529                 block_device_mapping,
2530                 existing_vim_volumes,
2531                 created_items,
2532             )
2533
2534             self.assertEqual(result, None)
2535
2536         self.vimconn.cinder.volumes.create.assert_called_once_with(
2537             size=10,
2538             name="basicvmvda",
2539             imageRef=image_id,
2540             availability_zone=["nova"],
2541         )
2542         self.assertEqual(existing_vim_volumes, [])
2543         self.assertEqual(block_device_mapping, {})
2544         self.assertEqual(created_items, {})
2545         mock_update_block_device_mapping.assert_not_called()
2546
2547     @patch.object(vimconnector, "update_block_device_mapping")
2548     def test_prepare_persistent_non_root_volumes_create_raise_exception(
2549         self, mock_update_block_device_mapping
2550     ):
2551         """Create persistent non-root volume raise exception."""
2552         self.vimconn.cinder.volumes.create.side_effect = Exception
2553         vm_av_zone = ["nova"]
2554         base_disk_index = ord("b")
2555         disk = {"size": 10}
2556         block_device_mapping = {}
2557         existing_vim_volumes = []
2558         created_items = {}
2559
2560         with self.assertRaises(Exception):
2561             self.vimconn._prepare_non_root_persistent_volumes(
2562                 name,
2563                 disk,
2564                 vm_av_zone,
2565                 block_device_mapping,
2566                 base_disk_index,
2567                 existing_vim_volumes,
2568                 created_items,
2569             )
2570
2571         self.vimconn.cinder.volumes.create.assert_called_once_with(
2572             size=10, name="basicvmvdb", availability_zone=["nova"]
2573         )
2574         self.assertEqual(existing_vim_volumes, [])
2575         self.assertEqual(block_device_mapping, {})
2576         self.assertEqual(created_items, {})
2577         mock_update_block_device_mapping.assert_not_called()
2578
2579     @patch("time.sleep")
2580     def test_wait_for_created_volumes_availability_volume_status_available(
2581         self, mock_sleep
2582     ):
2583         """Created volume status is available."""
2584         elapsed_time = 5
2585         created_items = {f"volume:{volume_id2}": True}
2586         self.vimconn.cinder.volumes.get.return_value.status = "available"
2587
2588         result = self.vimconn._wait_for_created_volumes_availability(
2589             elapsed_time, created_items
2590         )
2591         self.assertEqual(result, elapsed_time)
2592         self.vimconn.cinder.volumes.get.assert_called_with(volume_id2)
2593         mock_sleep.assert_not_called()
2594
2595     @patch("time.sleep")
2596     def test_wait_for_existing_volumes_availability_volume_status_available(
2597         self, mock_sleep
2598     ):
2599         """Existing volume status is available."""
2600         elapsed_time = 5
2601         existing_vim_volumes = [{"id": volume_id2}]
2602         self.vimconn.cinder.volumes.get.return_value.status = "available"
2603
2604         result = self.vimconn._wait_for_existing_volumes_availability(
2605             elapsed_time, existing_vim_volumes
2606         )
2607         self.assertEqual(result, elapsed_time)
2608         self.vimconn.cinder.volumes.get.assert_called_with(volume_id2)
2609         mock_sleep.assert_not_called()
2610
2611     @patch("time.sleep")
2612     def test_wait_for_created_volumes_availability_status_processing_multiple_volumes(
2613         self, mock_sleep
2614     ):
2615         """Created volume status is processing."""
2616         elapsed_time = 5
2617         created_items = {
2618             f"volume:{volume_id2}": True,
2619             f"volume:{volume_id3}": True,
2620         }
2621         self.vimconn.cinder.volumes.get.side_effect = [
2622             Status("processing"),
2623             Status("available"),
2624             Status("available"),
2625         ]
2626
2627         result = self.vimconn._wait_for_created_volumes_availability(
2628             elapsed_time, created_items
2629         )
2630         self.assertEqual(result, 10)
2631         _call_mock_get_volumes = self.vimconn.cinder.volumes.get.call_args_list
2632         self.assertEqual(_call_mock_get_volumes[0][0], (volume_id2,))
2633         self.assertEqual(_call_mock_get_volumes[1][0], (volume_id2,))
2634         self.assertEqual(_call_mock_get_volumes[2][0], (volume_id3,))
2635         mock_sleep.assert_called_with(5)
2636         self.assertEqual(1, mock_sleep.call_count)
2637
2638     @patch("time.sleep")
2639     def test_wait_for_existing_volumes_availability_status_processing_multiple_volumes(
2640         self, mock_sleep
2641     ):
2642         """Existing volume status is processing."""
2643         elapsed_time = 5
2644         existing_vim_volumes = [
2645             {"id": volume_id2},
2646             {"id": "44e0e83-b9uu-4akk-t234-p9cc4811bd4a"},
2647         ]
2648         self.vimconn.cinder.volumes.get.side_effect = [
2649             Status("processing"),
2650             Status("available"),
2651             Status("available"),
2652         ]
2653
2654         result = self.vimconn._wait_for_existing_volumes_availability(
2655             elapsed_time, existing_vim_volumes
2656         )
2657         self.assertEqual(result, 10)
2658         _call_mock_get_volumes = self.vimconn.cinder.volumes.get.call_args_list
2659         self.assertEqual(_call_mock_get_volumes[0][0], (volume_id2,))
2660         self.assertEqual(_call_mock_get_volumes[1][0], (volume_id2,))
2661         self.assertEqual(
2662             _call_mock_get_volumes[2][0], ("44e0e83-b9uu-4akk-t234-p9cc4811bd4a",)
2663         )
2664         mock_sleep.assert_called_with(5)
2665         self.assertEqual(1, mock_sleep.call_count)
2666
2667     @patch("time.sleep")
2668     def test_wait_for_created_volumes_availability_volume_status_processing_timeout(
2669         self, mock_sleep
2670     ):
2671         """Created volume status is processing, elapsed time greater than timeout (1800)."""
2672         elapsed_time = 1805
2673         created_items = {f"volume:{volume_id2}": True}
2674         self.vimconn.cinder.volumes.get.side_effect = [
2675             Status("processing"),
2676             Status("processing"),
2677         ]
2678         with patch("time.sleep", mock_sleep):
2679             result = self.vimconn._wait_for_created_volumes_availability(
2680                 elapsed_time, created_items
2681             )
2682             self.assertEqual(result, 1805)
2683         self.vimconn.cinder.volumes.get.assert_not_called()
2684         mock_sleep.assert_not_called()
2685
2686     @patch("time.sleep")
2687     def test_wait_for_existing_volumes_availability_volume_status_processing_timeout(
2688         self, mock_sleep
2689     ):
2690         """Exsiting volume status is processing, elapsed time greater than timeout (1800)."""
2691         elapsed_time = 1805
2692         existing_vim_volumes = [{"id": volume_id2}]
2693         self.vimconn.cinder.volumes.get.side_effect = [
2694             Status("processing"),
2695             Status("processing"),
2696         ]
2697
2698         result = self.vimconn._wait_for_existing_volumes_availability(
2699             elapsed_time, existing_vim_volumes
2700         )
2701         self.assertEqual(result, 1805)
2702         self.vimconn.cinder.volumes.get.assert_not_called()
2703         mock_sleep.assert_not_called()
2704
2705     @patch("time.sleep")
2706     def test_wait_for_created_volumes_availability_cinder_raise_exception(
2707         self, mock_sleep
2708     ):
2709         """Cinder get volumes raises exception for created volumes."""
2710         elapsed_time = 1000
2711         created_items = {f"volume:{volume_id2}": True}
2712         self.vimconn.cinder.volumes.get.side_effect = Exception
2713         with self.assertRaises(Exception):
2714             result = self.vimconn._wait_for_created_volumes_availability(
2715                 elapsed_time, created_items
2716             )
2717             self.assertEqual(result, 1000)
2718         self.vimconn.cinder.volumes.get.assert_called_with(volume_id2)
2719         mock_sleep.assert_not_called()
2720
2721     @patch("time.sleep")
2722     def test_wait_for_existing_volumes_availability_cinder_raise_exception(
2723         self, mock_sleep
2724     ):
2725         """Cinder get volumes raises exception for existing volumes."""
2726         elapsed_time = 1000
2727         existing_vim_volumes = [{"id": volume_id2}]
2728         self.vimconn.cinder.volumes.get.side_effect = Exception
2729         with self.assertRaises(Exception):
2730             result = self.vimconn._wait_for_existing_volumes_availability(
2731                 elapsed_time, existing_vim_volumes
2732             )
2733             self.assertEqual(result, 1000)
2734         self.vimconn.cinder.volumes.get.assert_called_with(volume_id2)
2735         mock_sleep.assert_not_called()
2736
2737     @patch("time.sleep")
2738     def test_wait_for_created_volumes_availability_no_volume_in_created_items(
2739         self, mock_sleep
2740     ):
2741         """Created_items dict does not have volume-id."""
2742         elapsed_time = 10
2743         created_items = {}
2744
2745         self.vimconn.cinder.volumes.get.side_effect = [None]
2746
2747         result = self.vimconn._wait_for_created_volumes_availability(
2748             elapsed_time, created_items
2749         )
2750         self.assertEqual(result, 10)
2751         self.vimconn.cinder.volumes.get.assert_not_called()
2752         mock_sleep.assert_not_called()
2753
2754     @patch("time.sleep")
2755     def test_wait_for_existing_volumes_availability_no_volume_in_existing_vim_volumes(
2756         self, mock_sleep
2757     ):
2758         """Existing_vim_volumes list does not have volume."""
2759         elapsed_time = 10
2760         existing_vim_volumes = []
2761
2762         self.vimconn.cinder.volumes.get.side_effect = [None]
2763
2764         result = self.vimconn._wait_for_existing_volumes_availability(
2765             elapsed_time, existing_vim_volumes
2766         )
2767         self.assertEqual(result, 10)
2768         self.vimconn.cinder.volumes.get.assert_not_called()
2769         mock_sleep.assert_not_called()
2770
2771     @patch.object(vimconnector, "_prepare_persistent_root_volumes")
2772     @patch.object(vimconnector, "_prepare_non_root_persistent_volumes")
2773     @patch.object(vimconnector, "_wait_for_created_volumes_availability")
2774     @patch.object(vimconnector, "_wait_for_existing_volumes_availability")
2775     def test_prepare_disk_for_vm_instance(
2776         self,
2777         mock_existing_vol_availability,
2778         mock_created_vol_availability,
2779         mock_non_root_volumes,
2780         mock_root_volumes,
2781     ):
2782         """Prepare disks for VM instance successfully."""
2783         existing_vim_volumes = []
2784         created_items = {}
2785         block_device_mapping = {}
2786         vm_av_zone = ["nova"]
2787
2788         mock_root_volumes.return_value = root_vol_id
2789         mock_created_vol_availability.return_value = 10
2790         mock_existing_vol_availability.return_value = 15
2791         self.vimconn.cinder = CopyingMock()
2792         self.vimconn._prepare_disk_for_vminstance(
2793             name,
2794             existing_vim_volumes,
2795             created_items,
2796             vm_av_zone,
2797             block_device_mapping,
2798             disk_list2,
2799         )
2800         self.vimconn.cinder.volumes.set_bootable.assert_called_once_with(
2801             root_vol_id, True
2802         )
2803         mock_created_vol_availability.assert_called_once_with(0, created_items)
2804         mock_existing_vol_availability.assert_called_once_with(10, existing_vim_volumes)
2805         self.assertEqual(mock_root_volumes.call_count, 1)
2806         self.assertEqual(mock_non_root_volumes.call_count, 1)
2807         mock_root_volumes.assert_called_once_with(
2808             name="basicvm",
2809             vm_av_zone=["nova"],
2810             disk={"size": 10, "image_id": image_id},
2811             base_disk_index=97,
2812             block_device_mapping={},
2813             existing_vim_volumes=[],
2814             created_items={},
2815         )
2816         mock_non_root_volumes.assert_called_once_with(
2817             name="basicvm",
2818             disk={"size": 20},
2819             vm_av_zone=["nova"],
2820             base_disk_index=98,
2821             block_device_mapping={},
2822             existing_vim_volumes=[],
2823             created_items={},
2824         )
2825
2826     @patch.object(vimconnector, "_prepare_persistent_root_volumes")
2827     @patch.object(vimconnector, "_prepare_non_root_persistent_volumes")
2828     @patch.object(vimconnector, "_wait_for_created_volumes_availability")
2829     @patch.object(vimconnector, "_wait_for_existing_volumes_availability")
2830     def test_prepare_disk_for_vm_instance_timeout_exceeded(
2831         self,
2832         mock_existing_vol_availability,
2833         mock_created_vol_availability,
2834         mock_non_root_volumes,
2835         mock_root_volumes,
2836     ):
2837         """Timeout exceeded while waiting for disks."""
2838         existing_vim_volumes = []
2839         created_items = {}
2840         vm_av_zone = ["nova"]
2841         block_device_mapping = {}
2842
2843         mock_root_volumes.return_value = root_vol_id
2844         mock_created_vol_availability.return_value = 1700
2845         mock_existing_vol_availability.return_value = 1900
2846
2847         with self.assertRaises(VimConnException) as err:
2848             self.vimconn._prepare_disk_for_vminstance(
2849                 name,
2850                 existing_vim_volumes,
2851                 created_items,
2852                 vm_av_zone,
2853                 block_device_mapping,
2854                 disk_list2,
2855             )
2856         self.assertEqual(
2857             str(err.exception), "Timeout creating volumes for instance basicvm"
2858         )
2859         self.vimconn.cinder.volumes.set_bootable.assert_not_called()
2860         mock_created_vol_availability.assert_called_once_with(0, created_items)
2861         mock_existing_vol_availability.assert_called_once_with(
2862             1700, existing_vim_volumes
2863         )
2864         self.assertEqual(mock_root_volumes.call_count, 1)
2865         self.assertEqual(mock_non_root_volumes.call_count, 1)
2866         mock_root_volumes.assert_called_once_with(
2867             name="basicvm",
2868             vm_av_zone=["nova"],
2869             disk={"size": 10, "image_id": image_id},
2870             base_disk_index=97,
2871             block_device_mapping={},
2872             existing_vim_volumes=[],
2873             created_items={},
2874         )
2875         mock_non_root_volumes.assert_called_once_with(
2876             name="basicvm",
2877             disk={"size": 20},
2878             vm_av_zone=["nova"],
2879             base_disk_index=98,
2880             block_device_mapping={},
2881             existing_vim_volumes=[],
2882             created_items={},
2883         )
2884
2885     @patch.object(vimconnector, "_prepare_persistent_root_volumes")
2886     @patch.object(vimconnector, "_prepare_non_root_persistent_volumes")
2887     @patch.object(vimconnector, "_wait_for_created_volumes_availability")
2888     @patch.object(vimconnector, "_wait_for_existing_volumes_availability")
2889     def test_prepare_disk_for_vm_instance_empty_disk_list(
2890         self,
2891         mock_existing_vol_availability,
2892         mock_created_vol_availability,
2893         mock_non_root_volumes,
2894         mock_root_volumes,
2895     ):
2896         """Disk list is empty."""
2897         existing_vim_volumes = []
2898         created_items = {}
2899         block_device_mapping = {}
2900         vm_av_zone = ["nova"]
2901         mock_created_vol_availability.return_value = 2
2902         mock_existing_vol_availability.return_value = 3
2903
2904         self.vimconn._prepare_disk_for_vminstance(
2905             name,
2906             existing_vim_volumes,
2907             created_items,
2908             vm_av_zone,
2909             block_device_mapping,
2910             disk_list,
2911         )
2912         self.vimconn.cinder.volumes.set_bootable.assert_not_called()
2913         mock_created_vol_availability.assert_called_once_with(0, created_items)
2914         mock_existing_vol_availability.assert_called_once_with(2, existing_vim_volumes)
2915         mock_root_volumes.assert_not_called()
2916         mock_non_root_volumes.assert_not_called()
2917
2918     @patch.object(vimconnector, "_prepare_persistent_root_volumes")
2919     @patch.object(vimconnector, "_prepare_non_root_persistent_volumes")
2920     @patch.object(vimconnector, "_wait_for_created_volumes_availability")
2921     @patch.object(vimconnector, "_wait_for_existing_volumes_availability")
2922     def test_prepare_disk_for_vm_instance_persistent_root_volume_error(
2923         self,
2924         mock_existing_vol_availability,
2925         mock_created_vol_availability,
2926         mock_non_root_volumes,
2927         mock_root_volumes,
2928     ):
2929         """Persistent root volumes preparation raises error."""
2930         existing_vim_volumes = []
2931         created_items = {}
2932         vm_av_zone = ["nova"]
2933         block_device_mapping = {}
2934
2935         mock_root_volumes.side_effect = Exception()
2936         mock_created_vol_availability.return_value = 10
2937         mock_existing_vol_availability.return_value = 15
2938
2939         with self.assertRaises(Exception):
2940             self.vimconn._prepare_disk_for_vminstance(
2941                 name,
2942                 existing_vim_volumes,
2943                 created_items,
2944                 vm_av_zone,
2945                 block_device_mapping,
2946                 disk_list2,
2947             )
2948         self.vimconn.cinder.volumes.set_bootable.assert_not_called()
2949         mock_created_vol_availability.assert_not_called()
2950         mock_existing_vol_availability.assert_not_called()
2951         mock_root_volumes.assert_called_once_with(
2952             name="basicvm",
2953             vm_av_zone=["nova"],
2954             disk={"size": 10, "image_id": image_id},
2955             base_disk_index=97,
2956             block_device_mapping={},
2957             existing_vim_volumes=[],
2958             created_items={},
2959         )
2960         mock_non_root_volumes.assert_not_called()
2961
2962     @patch.object(vimconnector, "_prepare_persistent_root_volumes")
2963     @patch.object(vimconnector, "_prepare_non_root_persistent_volumes")
2964     @patch.object(vimconnector, "_wait_for_created_volumes_availability")
2965     @patch.object(vimconnector, "_wait_for_existing_volumes_availability")
2966     def test_prepare_disk_for_vm_instance_non_root_volume_error(
2967         self,
2968         mock_existing_vol_availability,
2969         mock_created_vol_availability,
2970         mock_non_root_volumes,
2971         mock_root_volumes,
2972     ):
2973         """Non-root volumes preparation raises error."""
2974         existing_vim_volumes = []
2975         created_items = {}
2976         vm_av_zone = ["nova"]
2977         block_device_mapping = {}
2978
2979         mock_root_volumes.return_value = root_vol_id
2980         mock_non_root_volumes.side_effect = Exception
2981
2982         with self.assertRaises(Exception):
2983             self.vimconn._prepare_disk_for_vminstance(
2984                 name,
2985                 existing_vim_volumes,
2986                 created_items,
2987                 vm_av_zone,
2988                 block_device_mapping,
2989                 disk_list2,
2990             )
2991         self.vimconn.cinder.volumes.set_bootable.assert_not_called()
2992         mock_created_vol_availability.assert_not_called()
2993         mock_existing_vol_availability.assert_not_called()
2994         self.assertEqual(mock_root_volumes.call_count, 1)
2995         self.assertEqual(mock_non_root_volumes.call_count, 1)
2996         mock_root_volumes.assert_called_once_with(
2997             name="basicvm",
2998             vm_av_zone=["nova"],
2999             disk={"size": 10, "image_id": image_id},
3000             base_disk_index=97,
3001             block_device_mapping={},
3002             existing_vim_volumes=[],
3003             created_items={},
3004         )
3005         mock_non_root_volumes.assert_called_once_with(
3006             name="basicvm",
3007             disk={"size": 20},
3008             vm_av_zone=["nova"],
3009             base_disk_index=98,
3010             block_device_mapping={},
3011             existing_vim_volumes=[],
3012             created_items={},
3013         )
3014
3015     def test_find_external_network_for_floating_ip_no_external_network(self):
3016         """External network could not be found."""
3017         self.vimconn.neutron.list_networks.return_value = {
3018             "networks": [
3019                 {"id": "408b73-r9cc-5a6a-a270-82cc4811bd4a", "router:external": False}
3020             ]
3021         }
3022         with self.assertRaises(VimConnException) as err:
3023             self.vimconn._find_the_external_network_for_floating_ip()
3024         self.assertEqual(
3025             str(err.exception),
3026             "Cannot create floating_ip automatically since no external network is present",
3027         )
3028
3029     def test_find_external_network_for_floating_one_external_network(self):
3030         """One external network has been found."""
3031         self.vimconn.neutron.list_networks.return_value = {
3032             "networks": [
3033                 {"id": "408b73-r9cc-5a6a-a270-82cc4811bd4a", "router:external": True}
3034             ]
3035         }
3036         expected_result = "408b73-r9cc-5a6a-a270-82cc4811bd4a"
3037         result = self.vimconn._find_the_external_network_for_floating_ip()
3038         self.assertEqual(result, expected_result)
3039
3040     def test_find_external_network_for_floating_neutron_raises_exception(self):
3041         """Neutron list networks raises exception."""
3042         self.vimconn.neutron.list_networks.side_effect = Exception
3043         with self.assertRaises(Exception):
3044             self.vimconn._find_the_external_network_for_floating_ip()
3045
3046     def test_find_external_network_for_floating_several_external_network(self):
3047         """Several exernal networks has been found."""
3048         self.vimconn.neutron.list_networks.return_value = {
3049             "networks": [
3050                 {"id": "408b73-r9cc-5a6a-a270-82cc4811bd4a", "router:external": True},
3051                 {"id": "608b73-y9cc-5a6a-a270-12cc4811bd4a", "router:external": True},
3052             ]
3053         }
3054         with self.assertRaises(VimConnException) as err:
3055             self.vimconn._find_the_external_network_for_floating_ip()
3056         self.assertEqual(
3057             str(err.exception),
3058             "Cannot create floating_ip automatically since multiple external networks are present",
3059         )
3060
3061     def test_neutron_create_float_ip(self):
3062         """Floating ip creation is successful."""
3063         param = {"net_id": "408b73-r9cc-5a6a-a270-p2cc4811bd9a"}
3064         created_items = {}
3065         self.vimconn.neutron.create_floatingip.return_value = {
3066             "floatingip": {"id": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
3067         }
3068         expected_created_items = {
3069             "floating_ip:308b73-t9cc-1a6a-a270-12cc4811bd4a": True
3070         }
3071         self.vimconn._neutron_create_float_ip(param, created_items)
3072         self.assertEqual(created_items, expected_created_items)
3073
3074     def test_neutron_create_float_ip_exception_occured(self):
3075         """Floating ip could not be created."""
3076         param = {
3077             "floatingip": {
3078                 "floating_network_id": "408b73-r9cc-5a6a-a270-p2cc4811bd9a",
3079                 "tenant_id": "308b73-19cc-8a6a-a270-02cc4811bd9a",
3080             }
3081         }
3082         created_items = {}
3083         self.vimconn.neutron = CopyingMock()
3084         self.vimconn.neutron.create_floatingip.side_effect = Exception(
3085             "Neutron floating ip create exception occured."
3086         )
3087         with self.assertRaises(VimConnException) as err:
3088             self.vimconn._neutron_create_float_ip(param, created_items)
3089         self.assertEqual(created_items, {})
3090         self.assertEqual(
3091             str(err.exception),
3092             "Exception: Cannot create new floating_ip Neutron floating ip create exception occured.",
3093         )
3094
3095     @patch.object(vimconnector, "_neutron_create_float_ip")
3096     @patch.object(vimconnector, "_find_the_external_network_for_floating_ip")
3097     def test_create_floating_ip_pool_id_available(
3098         self, mock_find_ext_network, mock_create_float_ip
3099     ):
3100         """Floating ip creation, ip pool is available."""
3101         floating_network = {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
3102         created_items = {}
3103         expected_param = {
3104             "floatingip": {
3105                 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
3106                 "tenant_id": "408b73-r9cc-5a6a-a270-82cc4811bd4a",
3107             }
3108         }
3109         self.vimconn._create_floating_ip(floating_network, self.server, created_items)
3110         mock_find_ext_network.assert_not_called()
3111         mock_create_float_ip.assert_called_once_with(expected_param, {})
3112
3113     @patch.object(vimconnector, "_neutron_create_float_ip")
3114     @patch.object(vimconnector, "_find_the_external_network_for_floating_ip")
3115     def test_create_floating_ip_finding_pool_id(
3116         self, mock_find_ext_network, mock_create_float_ip
3117     ):
3118         """Floating ip creation, pool id need to be found."""
3119         floating_network = {"floating_ip": True}
3120         created_items = {}
3121         mock_find_ext_network.return_value = "308b73-t9cc-1a6a-a270-12cc4811bd4a"
3122         expected_param = {
3123             "floatingip": {
3124                 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
3125                 "tenant_id": "408b73-r9cc-5a6a-a270-82cc4811bd4a",
3126             }
3127         }
3128         self.vimconn._create_floating_ip(floating_network, self.server, created_items)
3129         mock_find_ext_network.assert_called_once()
3130         mock_create_float_ip.assert_called_once_with(expected_param, {})
3131
3132     @patch.object(vimconnector, "_neutron_create_float_ip")
3133     @patch.object(vimconnector, "_find_the_external_network_for_floating_ip")
3134     def test_create_floating_ip_neutron_create_floating_ip_exception(
3135         self, mock_find_ext_network, mock_create_float_ip
3136     ):
3137         """Neutron creat floating ip raises error."""
3138         floating_network = {"floating_ip": True}
3139         created_items = {}
3140         mock_create_float_ip.side_effect = VimConnException(
3141             "Can not create floating ip."
3142         )
3143         mock_find_ext_network.return_value = "308b73-t9cc-1a6a-a270-12cc4811bd4a"
3144         expected_param = {
3145             "floatingip": {
3146                 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
3147                 "tenant_id": "408b73-r9cc-5a6a-a270-82cc4811bd4a",
3148             }
3149         }
3150
3151         with self.assertRaises(VimConnException) as err:
3152             self.vimconn._create_floating_ip(
3153                 floating_network, self.server, created_items
3154             )
3155         self.assertEqual(str(err.exception), "Can not create floating ip.")
3156         mock_find_ext_network.assert_called_once()
3157         mock_create_float_ip.assert_called_once_with(expected_param, {})
3158
3159     @patch.object(vimconnector, "_neutron_create_float_ip")
3160     @patch.object(vimconnector, "_find_the_external_network_for_floating_ip")
3161     def test_create_floating_ip_can_not_find_pool_id(
3162         self, mock_find_ext_network, mock_create_float_ip
3163     ):
3164         """Floating ip creation, pool id could not be found."""
3165         floating_network = {"floating_ip": True}
3166         created_items = {}
3167         mock_find_ext_network.side_effect = VimConnException(
3168             "Cannot create floating_ip automatically since no external network is present"
3169         )
3170         with self.assertRaises(VimConnException) as err:
3171             self.vimconn._create_floating_ip(
3172                 floating_network, self.server, created_items
3173             )
3174         self.assertEqual(
3175             str(err.exception),
3176             "Cannot create floating_ip automatically since no external network is present",
3177         )
3178         mock_find_ext_network.assert_called_once()
3179         mock_create_float_ip.assert_not_called()
3180
3181     def test_find_floating_ip_get_free_floating_ip(self):
3182         """Get free floating ips successfully."""
3183         floating_ips = [
3184             {
3185                 "tenant_id": "408b73-r9cc-5a6a-a270-82cc4811bd4a",
3186                 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
3187                 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
3188             }
3189         ]
3190         floating_network = {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
3191         expected_result = "508b73-o9cc-5a6a-a270-72cc4811bd8"
3192
3193         result = self.vimconn._find_floating_ip(
3194             self.server, floating_ips, floating_network
3195         )
3196         self.assertEqual(result, expected_result)
3197
3198     def test_find_floating_ip_different_floating_network_id(self):
3199         """Floating network id is different with floating_ip of floating network."""
3200         floating_ips = [
3201             {
3202                 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
3203                 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
3204             }
3205         ]
3206         floating_network = {"floating_ip": "508b73-t9cc-1a6a-a270-12cc4811bd4a"}
3207
3208         result = self.vimconn._find_floating_ip(
3209             self.server, floating_ips, floating_network
3210         )
3211         self.assertEqual(result, None)
3212
3213     def test_find_floating_ip_different_fip_tenant(self):
3214         """Items in floating_ips has port_id, tenant_is is not same with server tenant id."""
3215         floating_ips = [
3216             {
3217                 "port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3218                 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
3219                 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
3220                 "tenant_id": self.server.id,
3221             }
3222         ]
3223         floating_network = {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
3224         mock_create_floating_ip = CopyingMock()
3225         with patch.object(vimconnector, "_create_floating_ip", mock_create_floating_ip):
3226             result = self.vimconn._find_floating_ip(
3227                 self.server, floating_ips, floating_network
3228             )
3229             self.assertEqual(result, None)
3230
3231     @patch("time.sleep")
3232     def test_assign_floating_ip(self, mock_sleep):
3233         """Assign floating ip successfully."""
3234         free_floating_ip = "508b73-o9cc-5a6a-a270-72cc4811bd8"
3235         floating_network = {"vim_id": floating_network_vim_id}
3236         fip = {
3237             "port_id": floating_network_vim_id,
3238             "floating_network_id": "p08b73-e9cc-5a6a-t270-82cc4811bd4a",
3239             "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
3240             "tenant_id": "k08b73-e9cc-5a6a-t270-82cc4811bd4a",
3241         }
3242         self.vimconn.neutron.update_floatingip.side_effect = None
3243         self.vimconn.neutron.show_floatingip.return_value = fip
3244         expected_result = fip
3245
3246         result = self.vimconn._assign_floating_ip(free_floating_ip, floating_network)
3247         self.assertEqual(result, expected_result)
3248         self.vimconn.neutron.update_floatingip.assert_called_once_with(
3249             free_floating_ip,
3250             {"floatingip": {"port_id": floating_network_vim_id}},
3251         )
3252         mock_sleep.assert_called_once_with(5)
3253         self.vimconn.neutron.show_floatingip.assert_called_once_with(free_floating_ip)
3254
3255     @patch("time.sleep")
3256     def test_assign_floating_ip_update_floating_ip_exception(self, mock_sleep):
3257         """Neutron update floating ip raises exception."""
3258         free_floating_ip = "508b73-o9cc-5a6a-a270-72cc4811bd8"
3259         floating_network = {"vim_id": floating_network_vim_id}
3260         self.vimconn.neutron = CopyingMock()
3261         self.vimconn.neutron.update_floatingip.side_effect = Exception(
3262             "Floating ip is not updated."
3263         )
3264
3265         with self.assertRaises(Exception) as err:
3266             result = self.vimconn._assign_floating_ip(
3267                 free_floating_ip, floating_network
3268             )
3269             self.assertEqual(result, None)
3270         self.assertEqual(str(err.exception), "Floating ip is not updated.")
3271
3272         self.vimconn.neutron.update_floatingip.assert_called_once_with(
3273             free_floating_ip,
3274             {"floatingip": {"port_id": floating_network_vim_id}},
3275         )
3276         mock_sleep.assert_not_called()
3277         self.vimconn.neutron.show_floatingip.assert_not_called()
3278
3279     @patch("time.sleep")
3280     def test_assign_floating_ip_show_floating_ip_exception(self, mock_sleep):
3281         """Neutron show floating ip raises exception."""
3282         free_floating_ip = "508b73-o9cc-5a6a-a270-72cc4811bd8"
3283         floating_network = {"vim_id": floating_network_vim_id}
3284         self.vimconn.neutron.update_floatingip.side_effect = None
3285         self.vimconn.neutron.show_floatingip.side_effect = Exception(
3286             "Floating ip could not be shown."
3287         )
3288
3289         with self.assertRaises(Exception) as err:
3290             result = self.vimconn._assign_floating_ip(
3291                 free_floating_ip, floating_network
3292             )
3293             self.assertEqual(result, None)
3294             self.assertEqual(str(err.exception), "Floating ip could not be shown.")
3295         self.vimconn.neutron.update_floatingip.assert_called_once_with(
3296             free_floating_ip,
3297             {"floatingip": {"port_id": floating_network_vim_id}},
3298         )
3299         mock_sleep.assert_called_once_with(5)
3300         self.vimconn.neutron.show_floatingip.assert_called_once_with(free_floating_ip)
3301
3302     @patch("random.shuffle")
3303     @patch.object(vimconnector, "_find_floating_ip")
3304     def test_get_free_floating_ip(self, mock_find_floating_ip, mock_shuffle):
3305         """Get free floating ip successfully."""
3306         floating_network = {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
3307         floating_ips = [
3308             {
3309                 "port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3310                 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
3311                 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
3312                 "tenant_id": "208b73-e9cc-5a6a-t270-82cc4811bd4a",
3313             },
3314             {
3315                 "port_id": "508b73-r9cc-5a6a-5270-o2cc4811bd4a",
3316                 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
3317                 "id": "208b73-o9cc-5a6a-a270-52cc4811bd8",
3318                 "tenant_id": "208b73-e9cc-5a6a-t270-82cc4811bd4a",
3319             },
3320         ]
3321         self.vimconn.neutron.list_floatingips.return_value = {
3322             "floatingips": floating_ips
3323         }
3324         mock_find_floating_ip.return_value = "508b73-o9cc-5a6a-a270-72cc4811bd8"
3325         expected_result = "508b73-o9cc-5a6a-a270-72cc4811bd8"
3326
3327         result = self.vimconn._get_free_floating_ip(self.server, floating_network)
3328         self.assertEqual(result, expected_result)
3329         mock_shuffle.assert_called_once_with(floating_ips)
3330         mock_find_floating_ip.assert_called_once_with(
3331             self.server, floating_ips, floating_network
3332         )
3333
3334     @patch("random.shuffle")
3335     @patch.object(vimconnector, "_find_floating_ip")
3336     def test_get_free_floating_ip_list_floating_ip_exception(
3337         self, mock_find_floating_ip, mock_shuffle
3338     ):
3339         """Neutron list floating IPs raises exception."""
3340         floating_network = {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
3341         self.vimconn.neutron = CopyingMock()
3342         self.vimconn.neutron.list_floatingips.side_effect = Exception(
3343             "Floating ips could not be listed."
3344         )
3345         with self.assertRaises(Exception) as err:
3346             result = self.vimconn._get_free_floating_ip(self.server, floating_network)
3347             self.assertEqual(result, None)
3348             self.assertEqual(str(err.exception), "Floating ips could not be listed.")
3349         mock_shuffle.assert_not_called()
3350         mock_find_floating_ip.assert_not_called()
3351
3352     @patch("random.shuffle")
3353     @patch.object(vimconnector, "_find_floating_ip")
3354     def test_get_free_floating_ip_find_floating_ip_exception(
3355         self, mock_find_floating_ip, mock_shuffle
3356     ):
3357         """_find_floating_ip method raises exception."""
3358         floating_network = {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
3359         floating_ips = [
3360             {
3361                 "port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3362                 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
3363                 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
3364                 "tenant_id": "208b73-e9cc-5a6a-t270-82cc4811bd4a",
3365             },
3366             {
3367                 "port_id": "508b73-r9cc-5a6a-5270-o2cc4811bd4a",
3368                 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
3369                 "id": "208b73-o9cc-5a6a-a270-52cc4811bd8",
3370                 "tenant_id": "208b73-e9cc-5a6a-t270-82cc4811bd4a",
3371             },
3372         ]
3373         self.vimconn.neutron = CopyingMock()
3374         self.vimconn.neutron.list_floatingips.return_value = {
3375             "floatingips": floating_ips
3376         }
3377         mock_find_floating_ip.side_effect = Exception(
3378             "Free floating ip could not be found."
3379         )
3380
3381         with self.assertRaises(Exception) as err:
3382             result = self.vimconn._get_free_floating_ip(self.server, floating_network)
3383             self.assertEqual(result, None)
3384             self.assertEqual(str(err.exception), "Free floating ip could not be found.")
3385         mock_shuffle.assert_called_once_with(floating_ips)
3386         mock_find_floating_ip.assert_called_once_with(
3387             self.server, floating_ips, floating_network
3388         )
3389
3390     @patch.object(vimconnector, "_create_floating_ip")
3391     @patch.object(vimconnector, "_get_free_floating_ip")
3392     @patch.object(vimconnector, "_assign_floating_ip")
3393     def test_prepare_external_network_for_vm_instance(
3394         self,
3395         mock_assign_floating_ip,
3396         mock_get_free_floating_ip,
3397         mock_create_floating_ip,
3398     ):
3399         """Prepare external network successfully."""
3400         external_network = [
3401             {
3402                 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3403                 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3404             },
3405         ]
3406         created_items = {}
3407         vm_start_time = time_return_value
3408         mock_get_free_floating_ip.side_effect = ["y08b73-o9cc-1a6a-a270-12cc4811bd4u"]
3409         mock_assign_floating_ip.return_value = {
3410             "floatingip": {"port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a"}
3411         }
3412         self.vimconn.neutron = CopyingMock()
3413         self.vimconn.nova = CopyingMock()
3414         self.vimconn.neutron.show_floatingip.return_value = {
3415             "floatingip": {"port_id": ""}
3416         }
3417
3418         self.vimconn._prepare_external_network_for_vminstance(
3419             external_network, self.server, created_items, vm_start_time
3420         )
3421
3422         self.assertEqual(mock_get_free_floating_ip.call_count, 1)
3423         mock_get_free_floating_ip.assert_called_once_with(
3424             self.server,
3425             {
3426                 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3427                 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3428             },
3429         )
3430         self.vimconn.neutron.show_floatingip.assert_called_once_with(
3431             "y08b73-o9cc-1a6a-a270-12cc4811bd4u"
3432         )
3433         self.vimconn.nova.servers.get.assert_not_called()
3434         mock_create_floating_ip.assert_not_called()
3435         mock_assign_floating_ip.assert_called_once_with(
3436             "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3437             {
3438                 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3439                 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3440             },
3441         )
3442
3443     @patch("time.time")
3444     @patch("time.sleep")
3445     @patch.object(vimconnector, "_create_floating_ip")
3446     @patch.object(vimconnector, "_get_free_floating_ip")
3447     @patch.object(vimconnector, "_assign_floating_ip")
3448     def test_prepare_external_network_for_vm_instance_no_free_floating_ip(
3449         self,
3450         mock_assign_floating_ip,
3451         mock_get_free_floating_ip,
3452         mock_create_floating_ip,
3453         mock_sleep,
3454         mock_time,
3455     ):
3456         """There is not any free floating ip."""
3457         floating_network = {
3458             "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3459             "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3460         }
3461         external_network = [floating_network]
3462
3463         created_items = {}
3464         vm_start_time = time_return_value
3465         mock_get_free_floating_ip.return_value = None
3466         mock_assign_floating_ip.return_value = {}
3467         self.vimconn.nova.servers.get.return_value.status = "ERROR"
3468         self.vimconn.neutron.show_floatingip.return_value = {}
3469
3470         with self.assertRaises(KeyError):
3471             self.vimconn._prepare_external_network_for_vminstance(
3472                 external_network, self.server, created_items, vm_start_time
3473             )
3474
3475         self.assertEqual(mock_get_free_floating_ip.call_count, 4)
3476         mock_get_free_floating_ip.assert_called_with(
3477             self.server,
3478             {
3479                 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3480                 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3481             },
3482         )
3483         self.vimconn.neutron.show_floatingip.assert_called_with(None)
3484         mock_sleep.assert_not_called()
3485         mock_time.assert_not_called()
3486         self.assertEqual(self.vimconn.nova.servers.get.call_count, 4)
3487         mock_create_floating_ip.assert_called_with(
3488             floating_network, self.server, created_items
3489         )
3490         self.assertEqual(mock_create_floating_ip.call_count, 4)
3491         mock_assign_floating_ip.assert_not_called()
3492         self.vimconn.nova.servers.get.assert_called_with(self.server.id)
3493
3494     @patch("time.time")
3495     @patch("time.sleep")
3496     @patch.object(vimconnector, "_create_floating_ip")
3497     @patch.object(vimconnector, "_get_free_floating_ip")
3498     @patch.object(vimconnector, "_assign_floating_ip")
3499     def test_prepare_external_network_for_vm_instance_no_free_fip_can_not_create_fip_exit_on_error_false(
3500         self,
3501         mock_assign_floating_ip,
3502         mock_get_free_floating_ip,
3503         mock_create_floating_ip,
3504         mock_sleep,
3505         mock_time,
3506     ):
3507         """There is not any free floating ip, create_floating ip method raise exception
3508         exit_on_floating_ip_error set to False."""
3509         floating_network = {
3510             "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3511             "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3512             "exit_on_floating_ip_error": False,
3513         }
3514         external_network = [floating_network]
3515
3516         created_items = {}
3517         vm_start_time = time_return_value
3518         mock_get_free_floating_ip.return_value = None
3519         mock_assign_floating_ip.return_value = {}
3520         mock_create_floating_ip.side_effect = VimConnException(
3521             "Can not create floating ip."
3522         )
3523         self.vimconn.nova.servers.get.return_value.status = "ERROR"
3524         self.vimconn.neutron.show_floatingip.return_value = {}
3525
3526         self.vimconn._prepare_external_network_for_vminstance(
3527             external_network, self.server, created_items, vm_start_time
3528         )
3529         self.assertEqual(mock_get_free_floating_ip.call_count, 1)
3530         mock_get_free_floating_ip.assert_called_with(
3531             self.server,
3532             {
3533                 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3534                 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3535                 "exit_on_floating_ip_error": False,
3536             },
3537         )
3538         self.vimconn.neutron.show_floatingip.assert_not_called()
3539         mock_sleep.assert_not_called()
3540         mock_time.assert_not_called()
3541         self.vimconn.nova.servers.get.assert_not_called()
3542         mock_create_floating_ip.assert_called_with(
3543             floating_network, self.server, created_items
3544         )
3545         self.assertEqual(mock_create_floating_ip.call_count, 1)
3546         mock_assign_floating_ip.assert_not_called()
3547
3548     @patch("time.time")
3549     @patch("time.sleep")
3550     @patch.object(vimconnector, "_create_floating_ip")
3551     @patch.object(vimconnector, "_get_free_floating_ip")
3552     @patch.object(vimconnector, "_assign_floating_ip")
3553     def test_prepare_external_network_for_vm_instance_no_free_fip_can_not_create_fip_exit_on_error_true(
3554         self,
3555         mock_assign_floating_ip,
3556         mock_get_free_floating_ip,
3557         mock_create_floating_ip,
3558         mock_sleep,
3559         mock_time,
3560     ):
3561         """There is not any free floating ip, create_floating ip method raise exception
3562         exit_on_floating_ip_error set to False."""
3563         floating_network = {
3564             "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3565             "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3566             "exit_on_floating_ip_error": True,
3567         }
3568         external_network = [floating_network]
3569
3570         created_items = {}
3571         vm_start_time = time_return_value
3572         mock_get_free_floating_ip.return_value = None
3573         mock_assign_floating_ip.return_value = {}
3574         mock_create_floating_ip.side_effect = VimConnException(
3575             "Can not create floating ip."
3576         )
3577         self.vimconn.nova.servers.get.return_value.status = "ERROR"
3578         self.vimconn.neutron.show_floatingip.return_value = {}
3579         with self.assertRaises(VimConnException):
3580             self.vimconn._prepare_external_network_for_vminstance(
3581                 external_network, self.server, created_items, vm_start_time
3582             )
3583         self.assertEqual(mock_get_free_floating_ip.call_count, 1)
3584         mock_get_free_floating_ip.assert_called_with(
3585             self.server,
3586             {
3587                 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3588                 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3589                 "exit_on_floating_ip_error": True,
3590             },
3591         )
3592         self.vimconn.neutron.show_floatingip.assert_not_called()
3593         mock_sleep.assert_not_called()
3594         mock_time.assert_not_called()
3595         self.vimconn.nova.servers.get.assert_not_called()
3596         mock_create_floating_ip.assert_called_with(
3597             floating_network, self.server, created_items
3598         )
3599         self.assertEqual(mock_create_floating_ip.call_count, 1)
3600         mock_assign_floating_ip.assert_not_called()
3601
3602     @patch.object(vimconnector, "_create_floating_ip")
3603     @patch.object(vimconnector, "_get_free_floating_ip")
3604     @patch.object(vimconnector, "_assign_floating_ip")
3605     def test_prepare_external_network_for_vm_instance_fip_has_port_id(
3606         self,
3607         mock_assign_floating_ip,
3608         mock_get_free_floating_ip,
3609         mock_create_floating_ip,
3610     ):
3611         """Neutron show floating ip return the fip with port_id and floating network vim_id
3612         is different from port_id."""
3613         floating_network = {
3614             "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3615             "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3616         }
3617         external_network = [floating_network]
3618         created_items = {}
3619         vm_start_time = 150
3620         mock_get_free_floating_ip.side_effect = [
3621             "t08b73-o9cc-1a6a-a270-12cc4811bd4u",
3622             "r08b73-o9cc-1a6a-a270-12cc4811bd4u",
3623             "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3624         ]
3625         mock_assign_floating_ip.side_effect = [
3626             {"floatingip": {"port_id": "k08b73-r9cc-5a6a-a270-82cc4811bd4a"}},
3627             {"floatingip": {"port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a"}},
3628         ]
3629         self.vimconn.neutron = CopyingMock()
3630         self.vimconn.nova = CopyingMock()
3631         self.vimconn.neutron.show_floatingip.side_effect = [
3632             {"floatingip": {"port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a"}},
3633             {"floatingip": {"port_id": ""}},
3634             {"floatingip": {"port_id": ""}},
3635         ]
3636         self.vimconn._prepare_external_network_for_vminstance(
3637             external_network, self.server, created_items, vm_start_time
3638         )
3639         self.assertEqual(mock_get_free_floating_ip.call_count, 3)
3640         _call_mock_get_free_floating_ip = mock_get_free_floating_ip.call_args_list
3641         self.assertEqual(
3642             _call_mock_get_free_floating_ip[0][0],
3643             (
3644                 self.server,
3645                 floating_network,
3646             ),
3647         )
3648         self.assertEqual(
3649             _call_mock_get_free_floating_ip[1][0],
3650             (
3651                 self.server,
3652                 floating_network,
3653             ),
3654         )
3655         self.assertEqual(
3656             _call_mock_get_free_floating_ip[2][0],
3657             (
3658                 self.server,
3659                 floating_network,
3660             ),
3661         )
3662         self.assertEqual(self.vimconn.neutron.show_floatingip.call_count, 3)
3663         self.vimconn.nova.servers.get.assert_not_called()
3664         mock_create_floating_ip.assert_not_called()
3665         self.assertEqual(mock_assign_floating_ip.call_count, 2)
3666         _call_mock_assign_floating_ip = mock_assign_floating_ip.call_args_list
3667         self.assertEqual(
3668             _call_mock_assign_floating_ip[0][0],
3669             ("r08b73-o9cc-1a6a-a270-12cc4811bd4u", floating_network),
3670         )
3671         self.assertEqual(
3672             _call_mock_assign_floating_ip[1][0],
3673             ("y08b73-o9cc-1a6a-a270-12cc4811bd4u", floating_network),
3674         )
3675
3676     @patch("time.time")
3677     @patch("time.sleep")
3678     @patch.object(vimconnector, "_create_floating_ip")
3679     @patch.object(vimconnector, "_get_free_floating_ip")
3680     @patch.object(vimconnector, "_assign_floating_ip")
3681     def test_prepare_external_network_for_vm_instance_neutron_show_fip_exception_vm_status_in_error(
3682         self,
3683         mock_assign_floating_ip,
3684         mock_get_free_floating_ip,
3685         mock_create_floating_ip,
3686         mock_sleep,
3687         mock_time,
3688     ):
3689         """Neutron show floating ip gives exception, exit_on_floating_ip_error set to True,
3690         VM status is in error."""
3691         floating_network = {
3692             "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3693             "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3694             "exit_on_floating_ip_error": True,
3695         }
3696         external_network = [floating_network]
3697         created_items = {}
3698         vm_start_time = time_return_value
3699
3700         mock_time.side_effect = [156570150, 156570800, 156571200]
3701
3702         self.vimconn.nova.servers.get.return_value.status = "ERROR"
3703         self.vimconn.neutron.show_floatingip.side_effect = [
3704             Exception("Floating ip could not be shown.")
3705         ] * 4
3706         with self.assertRaises(Exception) as err:
3707             self.vimconn._prepare_external_network_for_vminstance(
3708                 external_network, self.server, created_items, vm_start_time
3709             )
3710             self.assertEqual(
3711                 str(err.exception),
3712                 "Cannot create floating_ip: Exception Floating ip could not be shown.",
3713             )
3714
3715         self.assertEqual(mock_get_free_floating_ip.call_count, 4)
3716         _call_mock_get_free_floating_ip = mock_get_free_floating_ip.call_args_list
3717         self.assertEqual(
3718             _call_mock_get_free_floating_ip[0][0],
3719             (
3720                 self.server,
3721                 floating_network,
3722             ),
3723         )
3724         self.assertEqual(
3725             _call_mock_get_free_floating_ip[1][0],
3726             (
3727                 self.server,
3728                 floating_network,
3729             ),
3730         )
3731         self.assertEqual(
3732             _call_mock_get_free_floating_ip[2][0],
3733             (
3734                 self.server,
3735                 floating_network,
3736             ),
3737         )
3738         self.assertEqual(
3739             _call_mock_get_free_floating_ip[3][0],
3740             (
3741                 self.server,
3742                 floating_network,
3743             ),
3744         )
3745
3746         self.assertEqual(self.vimconn.neutron.show_floatingip.call_count, 4)
3747         self.vimconn.nova.servers.get.assert_called_with(self.server.id)
3748         mock_create_floating_ip.assert_not_called()
3749         mock_assign_floating_ip.assert_not_called()
3750         mock_time.assert_not_called()
3751         mock_sleep.assert_not_called()
3752
3753     @patch("time.time")
3754     @patch("time.sleep")
3755     @patch.object(vimconnector, "_create_floating_ip")
3756     @patch.object(vimconnector, "_get_free_floating_ip")
3757     @patch.object(vimconnector, "_assign_floating_ip")
3758     def test_prepare_external_network_for_vm_instance_neutron_show_fip_exception_vm_status_in_active(
3759         self,
3760         mock_assign_floating_ip,
3761         mock_get_free_floating_ip,
3762         mock_create_floating_ip,
3763         mock_sleep,
3764         mock_time,
3765     ):
3766         """Neutron show floating ip gives exception, exit_on_floating_ip_error is set to False,
3767         VM status is in active."""
3768         floating_network = {
3769             "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3770             "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3771             "exit_on_floating_ip_error": False,
3772         }
3773         external_network = [floating_network]
3774         created_items = {}
3775         vm_start_time = time_return_value
3776
3777         mock_time.side_effect = [156570150, 156570800, 156571200]
3778
3779         self.vimconn.nova.servers.get.return_value.status = "ACTIVE"
3780         self.vimconn.neutron.show_floatingip.side_effect = [
3781             Exception("Floating ip could not be shown.")
3782         ] * 4
3783
3784         self.vimconn._prepare_external_network_for_vminstance(
3785             external_network, self.server, created_items, vm_start_time
3786         )
3787         # self.assertEqual(str(err.exception), "Cannot create floating_ip")
3788
3789         self.assertEqual(mock_get_free_floating_ip.call_count, 4)
3790         _call_mock_get_free_floating_ip = mock_get_free_floating_ip.call_args_list
3791         self.assertEqual(
3792             _call_mock_get_free_floating_ip[0][0],
3793             (
3794                 self.server,
3795                 floating_network,
3796             ),
3797         )
3798         self.assertEqual(
3799             _call_mock_get_free_floating_ip[1][0],
3800             (
3801                 self.server,
3802                 floating_network,
3803             ),
3804         )
3805         self.assertEqual(
3806             _call_mock_get_free_floating_ip[2][0],
3807             (
3808                 self.server,
3809                 floating_network,
3810             ),
3811         )
3812         self.assertEqual(
3813             _call_mock_get_free_floating_ip[3][0],
3814             (
3815                 self.server,
3816                 floating_network,
3817             ),
3818         )
3819
3820         self.assertEqual(self.vimconn.neutron.show_floatingip.call_count, 4)
3821         self.vimconn.nova.servers.get.assert_called_with(self.server.id)
3822         mock_create_floating_ip.assert_not_called()
3823         mock_assign_floating_ip.assert_not_called()
3824         mock_time.assert_not_called()
3825         mock_sleep.assert_not_called()
3826
3827     @patch("time.time")
3828     @patch("time.sleep")
3829     @patch.object(vimconnector, "_create_floating_ip")
3830     @patch.object(vimconnector, "_get_free_floating_ip")
3831     @patch.object(vimconnector, "_assign_floating_ip")
3832     def test_prepare_external_network_for_vm_instance_neutron_show_fip_exception_exit_on_error(
3833         self,
3834         mock_assign_floating_ip,
3835         mock_get_free_floating_ip,
3836         mock_create_floating_ip,
3837         mock_sleep,
3838         mock_time,
3839     ):
3840         """Neutron show floating ip gives exception, but exit_on_floating_ip_error is set to True.
3841         VM status is not ACTIVE or ERROR, server timeout happened."""
3842         floating_network = {
3843             "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3844             "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3845             "exit_on_floating_ip_error": True,
3846         }
3847         external_network = [floating_network]
3848         created_items = {}
3849         vm_start_time = time_return_value
3850         mock_get_free_floating_ip.side_effect = None
3851         mock_time.side_effect = [156571790, 156571795, 156571800, 156571805]
3852         self.vimconn.nova.servers.get.return_value.status = "OTHER"
3853         self.vimconn.neutron.show_floatingip.side_effect = [
3854             Exception("Floating ip could not be shown.")
3855         ] * 5
3856
3857         with self.assertRaises(VimConnException) as err:
3858             self.vimconn._prepare_external_network_for_vminstance(
3859                 external_network, self.server, created_items, vm_start_time
3860             )
3861         self.assertEqual(
3862             str(err.exception),
3863             "Cannot create floating_ip: Exception Floating ip could not be shown.",
3864         )
3865
3866         self.assertEqual(mock_get_free_floating_ip.call_count, 3)
3867         _call_mock_get_free_floating_ip = mock_get_free_floating_ip.call_args_list
3868         self.assertEqual(
3869             _call_mock_get_free_floating_ip[0][0],
3870             (
3871                 self.server,
3872                 floating_network,
3873             ),
3874         )
3875         self.assertEqual(
3876             _call_mock_get_free_floating_ip[1][0],
3877             (
3878                 self.server,
3879                 floating_network,
3880             ),
3881         )
3882         self.assertEqual(
3883             _call_mock_get_free_floating_ip[2][0],
3884             (
3885                 self.server,
3886                 floating_network,
3887             ),
3888         )
3889
3890         self.assertEqual(self.vimconn.neutron.show_floatingip.call_count, 3)
3891         self.vimconn.nova.servers.get.assert_called_with(self.server.id)
3892         mock_create_floating_ip.assert_not_called()
3893         mock_assign_floating_ip.assert_not_called()
3894         self.assertEqual(mock_time.call_count, 3)
3895         self.assertEqual(mock_sleep.call_count, 2)
3896
3897     @patch("time.time")
3898     @patch("time.sleep")
3899     @patch.object(vimconnector, "_create_floating_ip")
3900     @patch.object(vimconnector, "_get_free_floating_ip")
3901     @patch.object(vimconnector, "_assign_floating_ip")
3902     def test_prepare_external_network_for_vm_instance_assign_floating_ip_exception_exit_on_error(
3903         self,
3904         mock_assign_floating_ip,
3905         mock_get_free_floating_ip,
3906         mock_create_floating_ip,
3907         mock_sleep,
3908         mock_time,
3909     ):
3910         """Assign floating ip method gives exception, exit_on_floating_ip_error is set to True.
3911         VM status is in ERROR."""
3912         floating_network = {
3913             "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3914             "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3915             "exit_on_floating_ip_error": True,
3916         }
3917         external_network = [floating_network]
3918         created_items = {}
3919         vm_start_time = time_return_value
3920
3921         mock_get_free_floating_ip.side_effect = [
3922             "y08b73-o9cc-1a6a-a270-12cc4811bd4u"
3923         ] * 4
3924
3925         mock_time.side_effect = [156571790, 156571795, 156571800, 156571805]
3926
3927         mock_assign_floating_ip.side_effect = [
3928             Exception("Floating ip could not be assigned.")
3929         ] * 4
3930
3931         self.vimconn.nova.servers.get.return_value.status = "ERROR"
3932         self.vimconn.neutron.show_floatingip.side_effect = [
3933             {"floatingip": {"port_id": ""}}
3934         ] * 4
3935
3936         with self.assertRaises(VimConnException) as err:
3937             self.vimconn._prepare_external_network_for_vminstance(
3938                 external_network, self.server, created_items, vm_start_time
3939             )
3940         self.assertEqual(
3941             str(err.exception),
3942             "Cannot create floating_ip: Exception Floating ip could not be assigned.",
3943         )
3944
3945         self.assertEqual(mock_get_free_floating_ip.call_count, 4)
3946         _call_mock_get_free_floating_ip = mock_get_free_floating_ip.call_args_list
3947         self.assertEqual(
3948             _call_mock_get_free_floating_ip[0][0],
3949             (
3950                 self.server,
3951                 floating_network,
3952             ),
3953         )
3954         self.assertEqual(
3955             _call_mock_get_free_floating_ip[1][0],
3956             (
3957                 self.server,
3958                 floating_network,
3959             ),
3960         )
3961         self.assertEqual(
3962             _call_mock_get_free_floating_ip[2][0],
3963             (
3964                 self.server,
3965                 floating_network,
3966             ),
3967         )
3968
3969         self.assertEqual(self.vimconn.neutron.show_floatingip.call_count, 4)
3970         self.vimconn.neutron.show_floatingip.assert_called_with(
3971             "y08b73-o9cc-1a6a-a270-12cc4811bd4u"
3972         )
3973         self.assertEqual(self.vimconn.nova.servers.get.call_count, 4)
3974         self.vimconn.nova.servers.get.assert_called_with(self.server.id)
3975         mock_time.assert_not_called()
3976         mock_sleep.assert_not_called()
3977         mock_create_floating_ip.assert_not_called()
3978
3979     @patch("time.time")
3980     @patch("time.sleep")
3981     @patch.object(vimconnector, "_create_floating_ip")
3982     @patch.object(vimconnector, "_get_free_floating_ip")
3983     @patch.object(vimconnector, "_assign_floating_ip")
3984     def test_prepare_external_network_for_vm_instance_empty_external_network_list(
3985         self,
3986         mock_assign_floating_ip,
3987         mock_get_free_floating_ip,
3988         mock_create_floating_ip,
3989         mock_sleep,
3990         mock_time,
3991     ):
3992         """External network list is empty."""
3993         external_network = []
3994         created_items = {}
3995         vm_start_time = time_return_value
3996
3997         self.vimconn._prepare_external_network_for_vminstance(
3998             external_network, self.server, created_items, vm_start_time
3999         )
4000         mock_create_floating_ip.assert_not_called()
4001         mock_time.assert_not_called()
4002         mock_sleep.assert_not_called()
4003         mock_assign_floating_ip.assert_not_called()
4004         mock_get_free_floating_ip.assert_not_called()
4005         self.vimconn.neutron.show.show_floatingip.assert_not_called()
4006         self.vimconn.nova.servers.get.assert_not_called()
4007
4008     @patch.object(vimconnector, "_vimconnector__wait_for_vm")
4009     def test_update_port_security_for_vm_instance(self, mock_wait_for_vm):
4010         """no_secured_ports has port and the port has allow-address-pairs."""
4011         no_secured_ports = [(port2_id, "allow-address-pairs")]
4012
4013         self.vimconn._update_port_security_for_vminstance(no_secured_ports, self.server)
4014
4015         mock_wait_for_vm.assert_called_once_with(self.server.id, "ACTIVE")
4016
4017         self.vimconn.neutron.update_port.assert_called_once_with(
4018             port2_id,
4019             {"port": {"allowed_address_pairs": [{"ip_address": "0.0.0.0/0"}]}},
4020         )
4021
4022     @patch.object(vimconnector, "_vimconnector__wait_for_vm")
4023     def test_update_port_security_for_vm_instance_no_allowed_address_pairs(
4024         self, mock_wait_for_vm
4025     ):
4026         """no_secured_ports has port and the port does not have allow-address-pairs."""
4027         no_secured_ports = [(port2_id, "something")]
4028
4029         self.vimconn._update_port_security_for_vminstance(no_secured_ports, self.server)
4030
4031         mock_wait_for_vm.assert_called_once_with(self.server.id, "ACTIVE")
4032
4033         self.vimconn.neutron.update_port.assert_called_once_with(
4034             port2_id,
4035             {"port": {"port_security_enabled": False, "security_groups": None}},
4036         )
4037
4038     @patch.object(vimconnector, "_vimconnector__wait_for_vm")
4039     def test_update_port_security_for_vm_instance_wait_for_vm_raise_exception(
4040         self, mock_wait_for_vm
4041     ):
4042         """__wait_for_vm raises timeout exception."""
4043         no_secured_ports = [(port2_id, "something")]
4044
4045         mock_wait_for_vm.side_effect = VimConnException("Timeout waiting for instance.")
4046
4047         with self.assertRaises(VimConnException) as err:
4048             self.vimconn._update_port_security_for_vminstance(
4049                 no_secured_ports, self.server
4050             )
4051         self.assertEqual(str(err.exception), "Timeout waiting for instance.")
4052
4053         mock_wait_for_vm.assert_called_once_with(self.server.id, "ACTIVE")
4054
4055         self.vimconn.neutron.update_port.assert_not_called()
4056
4057     @patch.object(vimconnector, "_vimconnector__wait_for_vm")
4058     def test_update_port_security_for_vm_instance_neutron_update_port_raise_exception(
4059         self, mock_wait_for_vm
4060     ):
4061         """neutron_update_port method raises exception."""
4062         no_secured_ports = [(port2_id, "something")]
4063
4064         self.vimconn.neutron.update_port.side_effect = Exception(
4065             "Port security could not be updated."
4066         )
4067
4068         with self.assertRaises(VimConnException) as err:
4069             self.vimconn._update_port_security_for_vminstance(
4070                 no_secured_ports, self.server
4071             )
4072         self.assertEqual(
4073             str(err.exception),
4074             "It was not possible to disable port security for port 17472685-f67f-49fd-8722-eabb7692fc22",
4075         )
4076         mock_wait_for_vm.assert_called_once_with(self.server.id, "ACTIVE")
4077
4078         self.vimconn.neutron.update_port.assert_called_once_with(
4079             port2_id,
4080             {"port": {"port_security_enabled": False, "security_groups": None}},
4081         )
4082
4083     @patch.object(vimconnector, "_vimconnector__wait_for_vm")
4084     def test_update_port_security_for_vm_instance_empty_port_list(
4085         self, mock_wait_for_vm
4086     ):
4087         """no_secured_ports list does not have any ports."""
4088         no_secured_ports = []
4089
4090         self.vimconn._update_port_security_for_vminstance(no_secured_ports, self.server)
4091
4092         mock_wait_for_vm.assert_not_called()
4093
4094         self.vimconn.neutron.update_port.assert_not_called()
4095
4096     @patch("time.time")
4097     @patch.object(vimconnector, "remove_keep_tag_from_persistent_volumes")
4098     @patch.object(vimconnector, "_reload_connection")
4099     @patch.object(vimconnector, "_prepare_network_for_vminstance")
4100     @patch.object(vimconnector, "_create_user_data")
4101     @patch.object(vimconnector, "_get_vm_availability_zone")
4102     @patch.object(vimconnector, "_prepare_disk_for_vminstance")
4103     @patch.object(vimconnector, "_update_port_security_for_vminstance")
4104     @patch.object(vimconnector, "_prepare_external_network_for_vminstance")
4105     @patch.object(vimconnector, "delete_vminstance")
4106     @patch.object(vimconnector, "_format_exception")
4107     def test_new_vm_instance(
4108         self,
4109         mock_format_exception,
4110         mock_delete_vm_instance,
4111         mock_prepare_external_network,
4112         mock_update_port_security,
4113         mock_prepare_disk_for_vm_instance,
4114         mock_get_vm_availability_zone,
4115         mock_create_user_data,
4116         mock_prepare_network_for_vm_instance,
4117         mock_reload_connection,
4118         mock_remove_keep_flag_from_persistent_volumes,
4119         mock_time,
4120     ):
4121         """New VM instance creation is successful."""
4122
4123         mock_create_user_data.return_value = True, "userdata"
4124
4125         mock_get_vm_availability_zone.return_value = "nova"
4126
4127         self.vimconn.nova.servers.create.return_value = self.server
4128
4129         mock_time.return_value = time_return_value
4130
4131         expected_result = self.server.id, {}
4132
4133         result = self.vimconn.new_vminstance(
4134             name,
4135             description,
4136             start,
4137             image_id,
4138             flavor_id,
4139             affinity_group_list,
4140             net_list,
4141             cloud_config,
4142             disk_list2,
4143             availability_zone_index,
4144             availability_zone_list,
4145         )
4146         self.assertEqual(result, expected_result)
4147
4148         mock_reload_connection.assert_called_once()
4149         mock_prepare_network_for_vm_instance.assert_called_once_with(
4150             name=name,
4151             net_list=net_list,
4152             created_items={},
4153             net_list_vim=[],
4154             external_network=[],
4155             no_secured_ports=[],
4156         )
4157         mock_create_user_data.assert_called_once_with(cloud_config)
4158         mock_get_vm_availability_zone.assert_called_once_with(
4159             availability_zone_index, availability_zone_list
4160         )
4161         mock_prepare_disk_for_vm_instance.assert_called_once_with(
4162             name=name,
4163             existing_vim_volumes=[],
4164             created_items={},
4165             vm_av_zone="nova",
4166             block_device_mapping={},
4167             disk_list=disk_list2,
4168         )
4169         self.vimconn.nova.servers.create.assert_called_once_with(
4170             name=name,
4171             image=image_id,
4172             flavor=flavor_id,
4173             nics=[],
4174             security_groups="default",
4175             availability_zone="nova",
4176             key_name="my_keypair",
4177             userdata="userdata",
4178             config_drive=True,
4179             block_device_mapping={},
4180             scheduler_hints={},
4181         )
4182         mock_time.assert_called_once()
4183         mock_update_port_security.assert_called_once_with([], self.server)
4184         mock_prepare_external_network.assert_called_once_with(
4185             external_network=[],
4186             server=self.server,
4187             created_items={},
4188             vm_start_time=time_return_value,
4189         )
4190         mock_remove_keep_flag_from_persistent_volumes.assert_not_called()
4191         mock_delete_vm_instance.assert_not_called()
4192         mock_format_exception.assert_not_called()
4193
4194     @patch("time.time")
4195     @patch.object(vimconnector, "remove_keep_tag_from_persistent_volumes")
4196     @patch.object(vimconnector, "_reload_connection")
4197     @patch.object(vimconnector, "_prepare_network_for_vminstance")
4198     @patch.object(vimconnector, "_create_user_data")
4199     @patch.object(vimconnector, "_get_vm_availability_zone")
4200     @patch.object(vimconnector, "_prepare_disk_for_vminstance")
4201     @patch.object(vimconnector, "_update_port_security_for_vminstance")
4202     @patch.object(vimconnector, "_prepare_external_network_for_vminstance")
4203     @patch.object(vimconnector, "delete_vminstance")
4204     @patch.object(vimconnector, "_format_exception")
4205     def test_new_vm_instance_create_user_data_fails(
4206         self,
4207         mock_format_exception,
4208         mock_delete_vm_instance,
4209         mock_prepare_external_network,
4210         mock_update_port_security,
4211         mock_prepare_disk_for_vm_instance,
4212         mock_get_vm_availability_zone,
4213         mock_create_user_data,
4214         mock_prepare_network_for_vm_instance,
4215         mock_reload_connection,
4216         mock_remove_keep_flag_from_persistent_volumes,
4217         mock_time,
4218     ):
4219         """New VM instance creation failed because of user data creation failure."""
4220
4221         mock_create_user_data.side_effect = Exception(
4222             "User data could not be retrieved."
4223         )
4224
4225         mock_get_vm_availability_zone.return_value = "nova"
4226
4227         mock_remove_keep_flag_from_persistent_volumes.return_value = {}
4228
4229         self.vimconn.nova.servers.create.return_value = self.server
4230
4231         mock_time.return_value = time_return_value
4232
4233         self.vimconn.new_vminstance(
4234             name,
4235             description,
4236             start,
4237             image_id,
4238             flavor_id,
4239             affinity_group_list,
4240             net_list,
4241             cloud_config,
4242             disk_list,
4243             availability_zone_index,
4244             availability_zone_list,
4245         )
4246
4247         mock_reload_connection.assert_called_once()
4248         mock_prepare_network_for_vm_instance.assert_called_once_with(
4249             name=name,
4250             net_list=net_list,
4251             created_items={},
4252             net_list_vim=[],
4253             external_network=[],
4254             no_secured_ports=[],
4255         )
4256         mock_create_user_data.assert_called_once_with(cloud_config)
4257         mock_get_vm_availability_zone.assert_not_called()
4258         mock_prepare_disk_for_vm_instance.assert_not_called()
4259         self.vimconn.nova.servers.create.assert_not_called()
4260         mock_time.assert_not_called()
4261         mock_update_port_security.assert_not_called()
4262         mock_prepare_external_network.assert_not_called()
4263         mock_remove_keep_flag_from_persistent_volumes.assert_called_once_with({})
4264         mock_delete_vm_instance.assert_called_once_with(None, {})
4265         mock_format_exception.assert_called_once()
4266         arg = mock_format_exception.call_args[0][0]
4267         self.assertEqual(str(arg), "User data could not be retrieved.")
4268
4269     @patch("time.time")
4270     @patch.object(vimconnector, "remove_keep_tag_from_persistent_volumes")
4271     @patch.object(vimconnector, "_reload_connection")
4272     @patch.object(vimconnector, "_prepare_network_for_vminstance")
4273     @patch.object(vimconnector, "_create_user_data")
4274     @patch.object(vimconnector, "_get_vm_availability_zone")
4275     @patch.object(vimconnector, "_prepare_disk_for_vminstance")
4276     @patch.object(vimconnector, "_update_port_security_for_vminstance")
4277     @patch.object(vimconnector, "_prepare_external_network_for_vminstance")
4278     @patch.object(vimconnector, "delete_vminstance")
4279     @patch.object(vimconnector, "_format_exception")
4280     def test_new_vm_instance_external_network_exception(
4281         self,
4282         mock_format_exception,
4283         mock_delete_vm_instance,
4284         mock_prepare_external_network,
4285         mock_update_port_security,
4286         mock_prepare_disk_for_vm_instance,
4287         mock_get_vm_availability_zone,
4288         mock_create_user_data,
4289         mock_prepare_network_for_vm_instance,
4290         mock_reload_connection,
4291         mock_remove_keep_flag_from_persistent_volumes,
4292         mock_time,
4293     ):
4294         """New VM instance creation, external network connection has failed as floating
4295         ip could not be created."""
4296
4297         mock_create_user_data.return_value = True, "userdata"
4298
4299         mock_get_vm_availability_zone.return_value = "nova"
4300
4301         self.vimconn.nova.servers.create.return_value = self.server
4302
4303         mock_time.return_value = time_return_value
4304
4305         mock_remove_keep_flag_from_persistent_volumes.return_value = {}
4306
4307         mock_prepare_external_network.side_effect = VimConnException(
4308             "Can not create floating ip."
4309         )
4310
4311         self.vimconn.new_vminstance(
4312             name,
4313             description,
4314             start,
4315             image_id,
4316             flavor_id,
4317             affinity_group_list,
4318             net_list,
4319             cloud_config,
4320             disk_list2,
4321             availability_zone_index,
4322             availability_zone_list,
4323         )
4324
4325         mock_reload_connection.assert_called_once()
4326         mock_prepare_network_for_vm_instance.assert_called_once_with(
4327             name=name,
4328             net_list=net_list,
4329             created_items={},
4330             net_list_vim=[],
4331             external_network=[],
4332             no_secured_ports=[],
4333         )
4334         mock_create_user_data.assert_called_once_with(cloud_config)
4335         mock_get_vm_availability_zone.assert_called_once_with(
4336             availability_zone_index, availability_zone_list
4337         )
4338         mock_prepare_disk_for_vm_instance.assert_called_once_with(
4339             name=name,
4340             existing_vim_volumes=[],
4341             created_items={},
4342             vm_av_zone="nova",
4343             block_device_mapping={},
4344             disk_list=disk_list2,
4345         )
4346         self.vimconn.nova.servers.create.assert_called_once_with(
4347             name=name,
4348             image=image_id,
4349             flavor=flavor_id,
4350             nics=[],
4351             security_groups="default",
4352             availability_zone="nova",
4353             key_name="my_keypair",
4354             userdata="userdata",
4355             config_drive=True,
4356             block_device_mapping={},
4357             scheduler_hints={},
4358         )
4359         mock_time.assert_called_once()
4360         mock_update_port_security.assert_called_once_with([], self.server)
4361         mock_prepare_external_network.assert_called_once_with(
4362             external_network=[],
4363             server=self.server,
4364             created_items={},
4365             vm_start_time=time_return_value,
4366         )
4367         mock_remove_keep_flag_from_persistent_volumes.assert_called_once_with({})
4368         mock_delete_vm_instance.assert_called_once_with(self.server.id, {})
4369         mock_format_exception.assert_called_once()
4370         arg = mock_format_exception.call_args[0][0]
4371         self.assertEqual(str(arg), "Can not create floating ip.")
4372
4373     @patch("time.time")
4374     @patch.object(vimconnector, "remove_keep_tag_from_persistent_volumes")
4375     @patch.object(vimconnector, "_reload_connection")
4376     @patch.object(vimconnector, "_prepare_network_for_vminstance")
4377     @patch.object(vimconnector, "_create_user_data")
4378     @patch.object(vimconnector, "_get_vm_availability_zone")
4379     @patch.object(vimconnector, "_prepare_disk_for_vminstance")
4380     @patch.object(vimconnector, "_update_port_security_for_vminstance")
4381     @patch.object(vimconnector, "_prepare_external_network_for_vminstance")
4382     @patch.object(vimconnector, "delete_vminstance")
4383     @patch.object(vimconnector, "_format_exception")
4384     def test_new_vm_instance_with_affinity_group(
4385         self,
4386         mock_format_exception,
4387         mock_delete_vm_instance,
4388         mock_prepare_external_network,
4389         mock_update_port_security,
4390         mock_prepare_disk_for_vm_instance,
4391         mock_get_vm_availability_zone,
4392         mock_create_user_data,
4393         mock_prepare_network_for_vm_instance,
4394         mock_reload_connection,
4395         mock_remove_keep_flag_from_persistent_volumes,
4396         mock_time,
4397     ):
4398         """New VM creation with affinity group."""
4399         affinity_group_list = [
4400             {"affinity_group_id": "38b73-e9cc-5a6a-t270-82cc4811bd4a"}
4401         ]
4402         mock_create_user_data.return_value = True, "userdata"
4403         mock_get_vm_availability_zone.return_value = "nova"
4404         self.vimconn.nova.servers.create.return_value = self.server
4405         mock_time.return_value = time_return_value
4406         expected_result = self.server.id, {}
4407
4408         result = self.vimconn.new_vminstance(
4409             name,
4410             description,
4411             start,
4412             image_id,
4413             flavor_id,
4414             affinity_group_list,
4415             net_list,
4416             cloud_config,
4417             disk_list2,
4418             availability_zone_index,
4419             availability_zone_list,
4420         )
4421         self.assertEqual(result, expected_result)
4422
4423         mock_reload_connection.assert_called_once()
4424         mock_prepare_network_for_vm_instance.assert_called_once_with(
4425             name=name,
4426             net_list=net_list,
4427             created_items={},
4428             net_list_vim=[],
4429             external_network=[],
4430             no_secured_ports=[],
4431         )
4432         mock_create_user_data.assert_called_once_with(cloud_config)
4433         mock_get_vm_availability_zone.assert_called_once_with(
4434             availability_zone_index, availability_zone_list
4435         )
4436         mock_prepare_disk_for_vm_instance.assert_called_once_with(
4437             name=name,
4438             existing_vim_volumes=[],
4439             created_items={},
4440             vm_av_zone="nova",
4441             block_device_mapping={},
4442             disk_list=disk_list2,
4443         )
4444         self.vimconn.nova.servers.create.assert_called_once_with(
4445             name=name,
4446             image=image_id,
4447             flavor=flavor_id,
4448             nics=[],
4449             security_groups="default",
4450             availability_zone="nova",
4451             key_name="my_keypair",
4452             userdata="userdata",
4453             config_drive=True,
4454             block_device_mapping={},
4455             scheduler_hints={"group": "38b73-e9cc-5a6a-t270-82cc4811bd4a"},
4456         )
4457         mock_time.assert_called_once()
4458         mock_update_port_security.assert_called_once_with([], self.server)
4459         mock_prepare_external_network.assert_called_once_with(
4460             external_network=[],
4461             server=self.server,
4462             created_items={},
4463             vm_start_time=time_return_value,
4464         )
4465         mock_remove_keep_flag_from_persistent_volumes.assert_not_called()
4466         mock_delete_vm_instance.assert_not_called()
4467         mock_format_exception.assert_not_called()
4468
4469     @patch("time.time")
4470     @patch.object(vimconnector, "remove_keep_tag_from_persistent_volumes")
4471     @patch.object(vimconnector, "_reload_connection")
4472     @patch.object(vimconnector, "_prepare_network_for_vminstance")
4473     @patch.object(vimconnector, "_create_user_data")
4474     @patch.object(vimconnector, "_get_vm_availability_zone")
4475     @patch.object(vimconnector, "_prepare_disk_for_vminstance")
4476     @patch.object(vimconnector, "_update_port_security_for_vminstance")
4477     @patch.object(vimconnector, "_prepare_external_network_for_vminstance")
4478     @patch.object(vimconnector, "delete_vminstance")
4479     @patch.object(vimconnector, "_format_exception")
4480     def test_new_vm_instance_nova_server_create_failed(
4481         self,
4482         mock_format_exception,
4483         mock_delete_vm_instance,
4484         mock_prepare_external_network,
4485         mock_update_port_security,
4486         mock_prepare_disk_for_vm_instance,
4487         mock_get_vm_availability_zone,
4488         mock_create_user_data,
4489         mock_prepare_network_for_vm_instance,
4490         mock_reload_connection,
4491         mock_remove_keep_flag_from_persistent_volumes,
4492         mock_time,
4493     ):
4494         """New VM(server) creation failed."""
4495
4496         mock_create_user_data.return_value = True, "userdata"
4497
4498         mock_get_vm_availability_zone.return_value = "nova"
4499
4500         self.vimconn.nova.servers.create.side_effect = Exception(
4501             "Server could not be created."
4502         )
4503
4504         mock_time.return_value = time_return_value
4505
4506         mock_remove_keep_flag_from_persistent_volumes.return_value = {}
4507
4508         self.vimconn.new_vminstance(
4509             name,
4510             description,
4511             start,
4512             image_id,
4513             flavor_id,
4514             affinity_group_list,
4515             net_list,
4516             cloud_config,
4517             disk_list2,
4518             availability_zone_index,
4519             availability_zone_list,
4520         )
4521
4522         mock_reload_connection.assert_called_once()
4523         mock_prepare_network_for_vm_instance.assert_called_once_with(
4524             name=name,
4525             net_list=net_list,
4526             created_items={},
4527             net_list_vim=[],
4528             external_network=[],
4529             no_secured_ports=[],
4530         )
4531         mock_create_user_data.assert_called_once_with(cloud_config)
4532         mock_get_vm_availability_zone.assert_called_once_with(
4533             availability_zone_index, availability_zone_list
4534         )
4535         mock_prepare_disk_for_vm_instance.assert_called_once_with(
4536             name=name,
4537             existing_vim_volumes=[],
4538             created_items={},
4539             vm_av_zone="nova",
4540             block_device_mapping={},
4541             disk_list=disk_list2,
4542         )
4543
4544         self.vimconn.nova.servers.create.assert_called_once_with(
4545             name=name,
4546             image=image_id,
4547             flavor=flavor_id,
4548             nics=[],
4549             security_groups="default",
4550             availability_zone="nova",
4551             key_name="my_keypair",
4552             userdata="userdata",
4553             config_drive=True,
4554             block_device_mapping={},
4555             scheduler_hints={},
4556         )
4557         mock_time.assert_not_called()
4558         mock_update_port_security.assert_not_called()
4559         mock_prepare_external_network.assert_not_called()
4560         mock_remove_keep_flag_from_persistent_volumes.assert_called_once_with({})
4561         mock_delete_vm_instance.assert_called_once_with(None, {})
4562         mock_format_exception.assert_called_once()
4563         arg = mock_format_exception.call_args[0][0]
4564         self.assertEqual(str(arg), "Server could not be created.")
4565
4566     @patch("time.time")
4567     @patch.object(vimconnector, "remove_keep_tag_from_persistent_volumes")
4568     @patch.object(vimconnector, "_reload_connection")
4569     @patch.object(vimconnector, "_prepare_network_for_vminstance")
4570     @patch.object(vimconnector, "_create_user_data")
4571     @patch.object(vimconnector, "_get_vm_availability_zone")
4572     @patch.object(vimconnector, "_prepare_disk_for_vminstance")
4573     @patch.object(vimconnector, "_update_port_security_for_vminstance")
4574     @patch.object(vimconnector, "_prepare_external_network_for_vminstance")
4575     @patch.object(vimconnector, "delete_vminstance")
4576     @patch.object(vimconnector, "_format_exception")
4577     def test_new_vm_instance_connection_exception(
4578         self,
4579         mock_format_exception,
4580         mock_delete_vm_instance,
4581         mock_prepare_external_network,
4582         mock_update_port_security,
4583         mock_prepare_disk_for_vm_instance,
4584         mock_get_vm_availability_zone,
4585         mock_create_user_data,
4586         mock_prepare_network_for_vm_instance,
4587         mock_reload_connection,
4588         mock_remove_keep_flag_from_persistent_volumes,
4589         mock_time,
4590     ):
4591         """Connection to Cloud API has failed."""
4592         mock_reload_connection.side_effect = Exception("Can not connect to Cloud APIs.")
4593         mock_create_user_data.return_value = True, "userdata"
4594         mock_get_vm_availability_zone.return_value = "nova"
4595         self.vimconn.nova.servers.create.return_value = self.server
4596         mock_time.return_value = time_return_value
4597         mock_remove_keep_flag_from_persistent_volumes.return_value = {}
4598
4599         self.vimconn.new_vminstance(
4600             name,
4601             description,
4602             start,
4603             image_id,
4604             flavor_id,
4605             affinity_group_list,
4606             net_list,
4607             cloud_config,
4608             disk_list,
4609             availability_zone_index,
4610             availability_zone_list,
4611         )
4612         mock_format_exception.assert_called_once()
4613         arg = mock_format_exception.call_args[0][0]
4614         self.assertEqual(str(arg), "Can not connect to Cloud APIs.")
4615         mock_reload_connection.assert_called_once()
4616         mock_prepare_network_for_vm_instance.assert_not_called()
4617         mock_create_user_data.assert_not_called()
4618         mock_get_vm_availability_zone.assert_not_called()
4619         mock_prepare_disk_for_vm_instance.assert_not_called()
4620         self.vimconn.nova.servers.create.assert_not_called()
4621         mock_time.assert_not_called()
4622         mock_update_port_security.assert_not_called()
4623         mock_prepare_external_network.assert_not_called()
4624         mock_remove_keep_flag_from_persistent_volumes.assert_called_once_with({})
4625         mock_delete_vm_instance.assert_called_once_with(None, {})
4626
4627     @patch.object(vimconnector, "_delete_ports_by_id_wth_neutron")
4628     def test_delete_vm_ports_attached_to_network_empty_created_items(
4629         self, mock_delete_ports_by_id_wth_neutron
4630     ):
4631         """Created_items is emtpty."""
4632         created_items = {}
4633         self.vimconn._delete_vm_ports_attached_to_network(created_items)
4634         self.vimconn.neutron.list_ports.assert_not_called()
4635         self.vimconn.neutron.delete_port.assert_not_called()
4636         mock_delete_ports_by_id_wth_neutron.assert_not_called()
4637
4638     @patch.object(vimconnector, "_delete_ports_by_id_wth_neutron")
4639     def test_delete_vm_ports_attached_to_network(
4640         self, mock_delete_ports_by_id_wth_neutron
4641     ):
4642         created_items = {
4643             "floating_ip:308b73-t9cc-1a6a-a270-12cc4811bd4a": True,
4644             f"volume:{volume_id2}": True,
4645             f"volume:{volume_id}": True,
4646             f"port:{port_id}": True,
4647         }
4648         self.vimconn._delete_vm_ports_attached_to_network(created_items)
4649         mock_delete_ports_by_id_wth_neutron.assert_called_once_with(f"{port_id}")
4650         self.vimconn.logger.error.assert_not_called()
4651
4652     @patch.object(vimconnector, "_delete_ports_by_id_wth_neutron")
4653     def test_delete_vm_ports_attached_to_network_wthout_port(
4654         self, mock_delete_ports_by_id_wth_neutron
4655     ):
4656         """Created_items does not have port."""
4657         created_items = {
4658             f"floating_ip:{floating_network_vim_id}": True,
4659             f"volume:{volume_id2}": True,
4660             f"volume:{volume_id}": True,
4661         }
4662         self.vimconn._delete_vm_ports_attached_to_network(created_items)
4663         mock_delete_ports_by_id_wth_neutron.assert_not_called()
4664         self.vimconn.logger.error.assert_not_called()
4665
4666     @patch.object(vimconnector, "_delete_ports_by_id_wth_neutron")
4667     def test_delete_vm_ports_attached_to_network_delete_port_raise_vimconnexception(
4668         self, mock_delete_ports_by_id_wth_neutron
4669     ):
4670         """_delete_ports_by_id_wth_neutron raises vimconnexception."""
4671         created_items = deepcopy(created_items_all_true)
4672         mock_delete_ports_by_id_wth_neutron.side_effect = VimConnException(
4673             "Can not delete port"
4674         )
4675         self.vimconn._delete_vm_ports_attached_to_network(created_items)
4676         mock_delete_ports_by_id_wth_neutron.assert_called_once_with(f"{port_id}")
4677         self.vimconn.logger.error.assert_called_once_with(
4678             "Error deleting port: VimConnException: Can not delete port"
4679         )
4680
4681     @patch.object(vimconnector, "_delete_ports_by_id_wth_neutron")
4682     def test_delete_vm_ports_attached_to_network_delete_port_raise_nvexception(
4683         self, mock_delete_ports_by_id_wth_neutron
4684     ):
4685         """_delete_ports_by_id_wth_neutron raises nvExceptions.ClientException."""
4686         created_items = deepcopy(created_items_all_true)
4687         mock_delete_ports_by_id_wth_neutron.side_effect = nvExceptions.ClientException(
4688             "Connection aborted."
4689         )
4690         self.vimconn._delete_vm_ports_attached_to_network(created_items)
4691         mock_delete_ports_by_id_wth_neutron.assert_called_once_with(f"{port_id}")
4692         self.vimconn.logger.error.assert_called_once_with(
4693             "Error deleting port: ClientException: Unknown Error (HTTP Connection aborted.)"
4694         )
4695
4696     @patch.object(vimconnector, "_delete_ports_by_id_wth_neutron")
4697     def test_delete_vm_ports_attached_to_network_delete_port_invalid_port_item(
4698         self, mock_delete_ports_by_id_wth_neutron
4699     ):
4700         """port item is invalid."""
4701         created_items = {
4702             f"floating_ip:{floating_network_vim_id}": True,
4703             f"volume:{volume_id2}": True,
4704             f"volume:{volume_id}": True,
4705             f"port:{port_id}:": True,
4706         }
4707         mock_delete_ports_by_id_wth_neutron.side_effect = VimConnException(
4708             "Port is not valid."
4709         )
4710         self.vimconn._delete_vm_ports_attached_to_network(created_items)
4711         mock_delete_ports_by_id_wth_neutron.assert_called_once_with(f"{port_id}:")
4712         self.vimconn.logger.error.assert_called_once_with(
4713             "Error deleting port: VimConnException: Port is not valid."
4714         )
4715
4716     @patch.object(vimconnector, "_delete_ports_by_id_wth_neutron")
4717     def test_delete_vm_ports_attached_to_network_delete_port_already_deleted(
4718         self, mock_delete_ports_by_id_wth_neutron
4719     ):
4720         """port is already deleted."""
4721         created_items = {
4722             f"floating_ip:{floating_network_vim_id}": True,
4723             f"volume:{volume_id2}": True,
4724             f"volume:{volume_id}": None,
4725             f"port:{port_id}": None,
4726         }
4727         self.vimconn._delete_vm_ports_attached_to_network(created_items)
4728         mock_delete_ports_by_id_wth_neutron.assert_not_called()
4729         self.vimconn.logger.error.assert_not_called()
4730
4731     def test_delete_floating_ip_by_id(self):
4732         created_items = {
4733             f"floating_ip:{floating_network_vim_id}": True,
4734             f"port:{port_id}": True,
4735         }
4736         expected_created_items = {
4737             f"floating_ip:{floating_network_vim_id}": None,
4738             f"port:{port_id}": True,
4739         }
4740         k_id = floating_network_vim_id
4741         k = f"floating_ip:{floating_network_vim_id}"
4742         self.vimconn._delete_floating_ip_by_id(k, k_id, created_items)
4743         self.vimconn.neutron.delete_floatingip.assert_called_once_with(k_id)
4744         self.assertEqual(created_items, expected_created_items)
4745
4746     def test_delete_floating_ip_by_id_floating_ip_already_deleted(self):
4747         """floating ip is already deleted."""
4748         created_items = {
4749             f"floating_ip:{floating_network_vim_id}": None,
4750             f"port:{port_id}": True,
4751         }
4752         k_id = floating_network_vim_id
4753         k = f"floating_ip:{floating_network_vim_id}"
4754         self.vimconn._delete_floating_ip_by_id(k, k_id, created_items)
4755         self.vimconn.neutron.delete_floatingip.assert_called_once_with(k_id)
4756         self.assertEqual(
4757             created_items,
4758             {
4759                 f"floating_ip:{floating_network_vim_id}": None,
4760                 f"port:{port_id}": True,
4761             },
4762         )
4763
4764     def test_delete_floating_ip_by_id_floating_ip_raises_nvexception(self):
4765         """netron delete floating ip raises nvExceptions.ClientException."""
4766         created_items = {
4767             f"floating_ip:{floating_network_vim_id}": True,
4768             f"port:{port_id}": True,
4769         }
4770         k_id = floating_network_vim_id
4771         k = f"floating_ip:{floating_network_vim_id}"
4772         self.vimconn.neutron.delete_floatingip.side_effect = (
4773             nvExceptions.ClientException("Client exception occured.")
4774         )
4775         self.vimconn._delete_floating_ip_by_id(k, k_id, created_items)
4776         self.vimconn.neutron.delete_floatingip.assert_called_once_with(k_id)
4777         self.assertEqual(
4778             created_items,
4779             {
4780                 f"floating_ip:{floating_network_vim_id}": True,
4781                 f"port:{port_id}": True,
4782             },
4783         )
4784         self.vimconn.logger.error.assert_called_once_with(
4785             "Error deleting floating ip: ClientException: Unknown Error (HTTP Client exception occured.)"
4786         )
4787
4788     def test_delete_floating_ip_by_id_floating_ip_raises_vimconnexception(self):
4789         """netron delete floating ip raises VimConnNotFoundException."""
4790         created_items = {
4791             f"floating_ip:{floating_network_vim_id}": True,
4792             f"port:{port_id}": True,
4793         }
4794         k_id = floating_network_vim_id
4795         k = f"floating_ip:{floating_network_vim_id}"
4796         self.vimconn.neutron.delete_floatingip.side_effect = VimConnNotFoundException(
4797             "Port id could not found."
4798         )
4799         self.vimconn._delete_floating_ip_by_id(k, k_id, created_items)
4800         self.vimconn.neutron.delete_floatingip.assert_called_once_with(k_id)
4801         self.assertEqual(
4802             created_items,
4803             {
4804                 f"floating_ip:{floating_network_vim_id}": True,
4805                 f"port:{port_id}": True,
4806             },
4807         )
4808         self.vimconn.logger.error.assert_called_once_with(
4809             "Error deleting floating ip: VimConnNotFoundException: Port id could not found."
4810         )
4811
4812     def test_delete_floating_ip_by_id_floating_ip_invalid_k_item(self):
4813         """invalid floating ip item."""
4814         created_items = {
4815             f"floating_ip:{floating_network_vim_id}": True,
4816             f"port:{port_id}": True,
4817         }
4818         expected_created_items = {
4819             f"floating_ip:{floating_network_vim_id}::": None,
4820             f"floating_ip:{floating_network_vim_id}": True,
4821             f"port:{port_id}": True,
4822         }
4823         k_id = floating_network_vim_id
4824         k = f"floating_ip:{floating_network_vim_id}::"
4825         self.vimconn._delete_floating_ip_by_id(k, k_id, created_items)
4826         self.vimconn.neutron.delete_floatingip.assert_called_once_with(k_id)
4827         self.assertEqual(created_items, expected_created_items)
4828
4829     def test_delete_volumes_by_id_with_cinder_volume_status_available(self):
4830         """volume status is available."""
4831         created_items = {
4832             f"floating_ip:{floating_network_vim_id}": True,
4833             f"volume:{volume_id2}": True,
4834             f"volume:{volume_id}": True,
4835             f"port:{port_id}": None,
4836         }
4837         expected_created_items = {
4838             f"floating_ip:{floating_network_vim_id}": True,
4839             f"volume:{volume_id2}": True,
4840             f"volume:{volume_id}": None,
4841             f"port:{port_id}": None,
4842         }
4843         volumes_to_hold = []
4844         k = f"volume:{volume_id}"
4845         k_id = volume_id
4846         self.vimconn.cinder.volumes.get.return_value.status = "available"
4847         result = self.vimconn._delete_volumes_by_id_wth_cinder(
4848             k, k_id, volumes_to_hold, created_items
4849         )
4850         self.assertEqual(result, None)
4851         self.vimconn.cinder.volumes.get.assert_called_once_with(k_id)
4852         self.vimconn.cinder.volumes.delete.assert_called_once_with(k_id)
4853         self.vimconn.logger.error.assert_not_called()
4854         self.assertEqual(created_items, expected_created_items)
4855
4856     def test_delete_volumes_by_id_with_cinder_volume_already_deleted(self):
4857         """volume is already deleted."""
4858         created_items = {
4859             f"floating_ip:{floating_network_vim_id}": True,
4860             f"volume:{volume_id2}": True,
4861             f"volume:{volume_id}": None,
4862             f"port:{port_id}": None,
4863         }
4864         expected_created_items = {
4865             f"floating_ip:{floating_network_vim_id}": True,
4866             f"volume:{volume_id2}": True,
4867             f"volume:{volume_id}": None,
4868             f"port:{port_id}": None,
4869         }
4870         volumes_to_hold = []
4871         k = f"volume:{volume_id}"
4872         k_id = volume_id
4873         self.vimconn.cinder.volumes.get.return_value.status = "available"
4874         result = self.vimconn._delete_volumes_by_id_wth_cinder(
4875             k, k_id, volumes_to_hold, created_items
4876         )
4877         self.assertEqual(result, None)
4878         self.vimconn.cinder.volumes.get.assert_called_once_with(k_id)
4879         self.vimconn.cinder.volumes.delete.assert_called_once_with(k_id)
4880         self.vimconn.logger.error.assert_not_called()
4881         self.assertEqual(created_items, expected_created_items)
4882
4883     def test_delete_volumes_by_id_with_cinder_get_volume_raise_exception(self):
4884         """cinder get volume raises exception."""
4885         created_items = {
4886             f"floating_ip:{floating_network_vim_id}": True,
4887             f"volume:{volume_id2}": True,
4888             f"volume:{volume_id}": True,
4889             f"port:{port_id}": None,
4890         }
4891         expected_created_items = {
4892             f"floating_ip:{floating_network_vim_id}": True,
4893             f"volume:{volume_id2}": True,
4894             f"volume:{volume_id}": True,
4895             f"port:{port_id}": None,
4896         }
4897         volumes_to_hold = []
4898         k = f"volume:{volume_id}"
4899         k_id = volume_id
4900         self.vimconn.cinder.volumes.get.side_effect = Exception(
4901             "Can not get volume status."
4902         )
4903         result = self.vimconn._delete_volumes_by_id_wth_cinder(
4904             k, k_id, volumes_to_hold, created_items
4905         )
4906         self.assertEqual(result, None)
4907         self.vimconn.cinder.volumes.get.assert_called_once_with(k_id)
4908         self.vimconn.cinder.volumes.delete.assert_not_called()
4909         self.vimconn.logger.error.assert_called_once_with(
4910             "Error deleting volume: Exception: Can not get volume status."
4911         )
4912         self.assertEqual(created_items, expected_created_items)
4913
4914     def test_delete_volumes_by_id_with_cinder_delete_volume_raise_exception(self):
4915         """cinder delete volume raises exception."""
4916         created_items = {
4917             f"floating_ip:{floating_network_vim_id}": True,
4918             f"volume:{volume_id2}": True,
4919             f"volume:{volume_id}": True,
4920             f"port:{port_id}": None,
4921         }
4922         expected_created_items = {
4923             f"floating_ip:{floating_network_vim_id}": True,
4924             f"volume:{volume_id2}": True,
4925             f"volume:{volume_id}": True,
4926             f"port:{port_id}": None,
4927         }
4928         volumes_to_hold = []
4929         k = f"volume:{volume_id}"
4930         k_id = volume_id
4931         self.vimconn.cinder.volumes.get.return_value.status = "available"
4932         self.vimconn.cinder.volumes.delete.side_effect = nvExceptions.ClientException(
4933             "Connection aborted."
4934         )
4935         result = self.vimconn._delete_volumes_by_id_wth_cinder(
4936             k, k_id, volumes_to_hold, created_items
4937         )
4938         self.assertEqual(result, None)
4939         self.vimconn.cinder.volumes.get.assert_called_once_with(k_id)
4940         self.vimconn.cinder.volumes.delete.assert_called_once_with(k_id)
4941         self.vimconn.logger.error.assert_called_once_with(
4942             "Error deleting volume: ClientException: Unknown Error (HTTP Connection aborted.)"
4943         )
4944         self.assertEqual(created_items, expected_created_items)
4945
4946     def test_delete_volumes_by_id_with_cinder_volume_to_be_hold(self):
4947         """volume_to_hold has item."""
4948         created_items = {
4949             f"floating_ip:{floating_network_vim_id}": True,
4950             f"volume:{volume_id2}": True,
4951             f"volume:{volume_id}": True,
4952             f"port:{port_id}": None,
4953         }
4954         expected_created_items = {
4955             f"floating_ip:{floating_network_vim_id}": True,
4956             f"volume:{volume_id2}": True,
4957             f"volume:{volume_id}": True,
4958             f"port:{port_id}": None,
4959         }
4960         volumes_to_hold = [volume_id]
4961         k = f"volume:{volume_id}"
4962         k_id = volume_id
4963         result = self.vimconn._delete_volumes_by_id_wth_cinder(
4964             k, k_id, volumes_to_hold, created_items
4965         )
4966         self.assertEqual(result, None)
4967         self.vimconn.cinder.volumes.get.assert_not_called()
4968         self.vimconn.cinder.volumes.delete.assert_not_called()
4969         self.vimconn.logger.error.assert_not_called()
4970         self.assertEqual(created_items, expected_created_items)
4971
4972     def test_delete_volumes_by_id_with_cinder_volume_status_not_available(self):
4973         """volume status is not available."""
4974         created_items = {
4975             f"floating_ip:{floating_network_vim_id}": True,
4976             f"volume:{volume_id2}": True,
4977             f"volume:{volume_id}": True,
4978             f"port:{port_id}": None,
4979         }
4980         expected_created_items = {
4981             f"floating_ip:{floating_network_vim_id}": True,
4982             f"volume:{volume_id2}": True,
4983             f"volume:{volume_id}": True,
4984             f"port:{port_id}": None,
4985         }
4986         volumes_to_hold = []
4987         k = f"volume:{volume_id}"
4988         k_id = volume_id
4989         self.vimconn.cinder.volumes.get.return_value.status = "unavailable"
4990         result = self.vimconn._delete_volumes_by_id_wth_cinder(
4991             k, k_id, volumes_to_hold, created_items
4992         )
4993         self.assertEqual(result, True)
4994         self.vimconn.cinder.volumes.get.assert_called_once_with(k_id)
4995         self.vimconn.cinder.volumes.delete.assert_not_called()
4996         self.vimconn.logger.error.assert_not_called()
4997         self.assertEqual(created_items, expected_created_items)
4998
4999     def test_delete_ports_by_id_by_neutron(self):
5000         """neutron delete ports."""
5001         k_id = port_id
5002         self.vimconn.neutron.list_ports.return_value = {
5003             "ports": [{"id": port_id}, {"id": port2_id}]
5004         }
5005
5006         self.vimconn._delete_ports_by_id_wth_neutron(k_id)
5007         self.vimconn.neutron.list_ports.assert_called_once()
5008         self.vimconn.neutron.delete_port.assert_called_once_with(k_id)
5009         self.vimconn.logger.error.assert_not_called()
5010
5011     def test_delete_ports_by_id_by_neutron_id_not_in_port_list(self):
5012         """port id not in the port list."""
5013         k_id = volume_id
5014         self.vimconn.neutron.list_ports.return_value = {
5015             "ports": [{"id": port_id}, {"id": port2_id}]
5016         }
5017
5018         self.vimconn._delete_ports_by_id_wth_neutron(k_id)
5019         self.vimconn.neutron.list_ports.assert_called_once()
5020         self.vimconn.neutron.delete_port.assert_not_called()
5021         self.vimconn.logger.error.assert_not_called()
5022
5023     def test_delete_ports_by_id_by_neutron_list_port_raise_exception(self):
5024         """neutron list port raises exception."""
5025         k_id = port_id
5026         self.vimconn.neutron.list_ports.side_effect = nvExceptions.ClientException(
5027             "Connection aborted."
5028         )
5029         self.vimconn._delete_ports_by_id_wth_neutron(k_id)
5030         self.vimconn.neutron.list_ports.assert_called_once()
5031         self.vimconn.neutron.delete_port.assert_not_called()
5032         self.vimconn.logger.error.assert_called_once_with(
5033             "Error deleting port: ClientException: Unknown Error (HTTP Connection aborted.)"
5034         )
5035
5036     def test_delete_ports_by_id_by_neutron_delete_port_raise_exception(self):
5037         """neutron delete port raises exception."""
5038         k_id = port_id
5039         self.vimconn.neutron.list_ports.return_value = {
5040             "ports": [{"id": port_id}, {"id": port2_id}]
5041         }
5042         self.vimconn.neutron.delete_port.side_effect = nvExceptions.ClientException(
5043             "Connection aborted."
5044         )
5045         self.vimconn._delete_ports_by_id_wth_neutron(k_id)
5046         self.vimconn.neutron.list_ports.assert_called_once()
5047         self.vimconn.neutron.delete_port.assert_called_once_with(k_id)
5048         self.vimconn.logger.error.assert_called_once_with(
5049             "Error deleting port: ClientException: Unknown Error (HTTP Connection aborted.)"
5050         )
5051
5052     def test_get_item_name_id(self):
5053         """Get name and id successfully."""
5054         k = f"some:{port_id}"
5055         result = self.vimconn._get_item_name_id(k)
5056         self.assertEqual(result, ("some", f"{port_id}"))
5057
5058     def test_get_item_name_id_wthout_semicolon(self):
5059         """Does not have seperator."""
5060         k = f"some{port_id}"
5061         result = self.vimconn._get_item_name_id(k)
5062         self.assertEqual(result, (f"some{port_id}", ""))
5063
5064     def test_get_item_name_id_empty_string(self):
5065         """Empty string."""
5066         k = ""
5067         result = self.vimconn._get_item_name_id(k)
5068         self.assertEqual(result, ("", ""))
5069
5070     def test_get_item_name_id_k_is_none(self):
5071         """item is None."""
5072         k = None
5073         with self.assertRaises(AttributeError):
5074             self.vimconn._get_item_name_id(k)
5075
5076     @patch.object(vimconnector, "_get_item_name_id")
5077     @patch.object(vimconnector, "_delete_volumes_by_id_wth_cinder")
5078     @patch.object(vimconnector, "_delete_floating_ip_by_id")
5079     def test_delete_created_items(
5080         self,
5081         mock_delete_floating_ip_by_id,
5082         mock_delete_volumes_by_id_wth_cinder,
5083         mock_get_item_name_id,
5084     ):
5085         """Created items has floating ip and volume."""
5086         created_items = {
5087             f"floating_ip:{floating_network_vim_id}": True,
5088             f"volume:{volume_id}": True,
5089             f"port:{port_id}": None,
5090         }
5091         mock_get_item_name_id.side_effect = [
5092             ("floating_ip", f"{floating_network_vim_id}"),
5093             ("volume", f"{volume_id}"),
5094         ]
5095         mock_delete_volumes_by_id_wth_cinder.return_value = True
5096         volumes_to_hold = []
5097         keep_waiting = False
5098         result = self.vimconn._delete_created_items(
5099             created_items, volumes_to_hold, keep_waiting
5100         )
5101         self.assertEqual(result, True)
5102         self.assertEqual(mock_get_item_name_id.call_count, 2)
5103         mock_delete_volumes_by_id_wth_cinder.assert_called_once_with(
5104             f"volume:{volume_id}", f"{volume_id}", [], created_items
5105         )
5106         mock_delete_floating_ip_by_id.assert_called_once_with(
5107             f"floating_ip:{floating_network_vim_id}",
5108             f"{floating_network_vim_id}",
5109             created_items,
5110         )
5111         self.vimconn.logger.error.assert_not_called()
5112
5113     @patch.object(vimconnector, "_get_item_name_id")
5114     @patch.object(vimconnector, "_delete_volumes_by_id_wth_cinder")
5115     @patch.object(vimconnector, "_delete_floating_ip_by_id")
5116     def test_delete_created_items_wth_volumes_to_hold(
5117         self,
5118         mock_delete_floating_ip_by_id,
5119         mock_delete_volumes_by_id_wth_cinder,
5120         mock_get_item_name_id,
5121     ):
5122         """Created items has floating ip and volume and volumes_to_hold has items."""
5123         created_items = {
5124             f"floating_ip:{floating_network_vim_id}": True,
5125             f"volume:{volume_id}": True,
5126             f"port:{port_id}": None,
5127         }
5128         mock_get_item_name_id.side_effect = [
5129             ("floating_ip", f"{floating_network_vim_id}"),
5130             ("volume", f"{volume_id}"),
5131         ]
5132         mock_delete_volumes_by_id_wth_cinder.return_value = True
5133         volumes_to_hold = [f"{volume_id}", f"{volume_id2}"]
5134         keep_waiting = False
5135         result = self.vimconn._delete_created_items(
5136             created_items, volumes_to_hold, keep_waiting
5137         )
5138         self.assertEqual(result, True)
5139         self.assertEqual(mock_get_item_name_id.call_count, 2)
5140         mock_delete_volumes_by_id_wth_cinder.assert_called_once_with(
5141             f"volume:{volume_id}", f"{volume_id}", volumes_to_hold, created_items
5142         )
5143         mock_delete_floating_ip_by_id.assert_called_once_with(
5144             f"floating_ip:{floating_network_vim_id}",
5145             f"{floating_network_vim_id}",
5146             created_items,
5147         )
5148         self.vimconn.logger.error.assert_not_called()
5149
5150     @patch.object(vimconnector, "_get_item_name_id")
5151     @patch.object(vimconnector, "_delete_volumes_by_id_wth_cinder")
5152     @patch.object(vimconnector, "_delete_floating_ip_by_id")
5153     def test_delete_created_items_wth_keep_waiting_true(
5154         self,
5155         mock_delete_floating_ip_by_id,
5156         mock_delete_volumes_by_id_wth_cinder,
5157         mock_get_item_name_id,
5158     ):
5159         """Keep waiting initial value is True."""
5160         created_items = {
5161             f"floating_ip:{floating_network_vim_id}": True,
5162             f"volume:{volume_id}": True,
5163             f"port:{port_id}": None,
5164         }
5165         mock_get_item_name_id.side_effect = [
5166             ("floating_ip", f"{floating_network_vim_id}"),
5167             ("volume", f"{volume_id}"),
5168         ]
5169         mock_delete_volumes_by_id_wth_cinder.return_value = False
5170         volumes_to_hold = [f"{volume_id}", f"{volume_id2}"]
5171         keep_waiting = True
5172         result = self.vimconn._delete_created_items(
5173             created_items, volumes_to_hold, keep_waiting
5174         )
5175         self.assertEqual(result, True)
5176         self.assertEqual(mock_get_item_name_id.call_count, 2)
5177         mock_delete_volumes_by_id_wth_cinder.assert_called_once_with(
5178             f"volume:{volume_id}", f"{volume_id}", volumes_to_hold, created_items
5179         )
5180         mock_delete_floating_ip_by_id.assert_called_once_with(
5181             f"floating_ip:{floating_network_vim_id}",
5182             f"{floating_network_vim_id}",
5183             created_items,
5184         )
5185         self.vimconn.logger.error.assert_not_called()
5186
5187     @patch.object(vimconnector, "_get_item_name_id")
5188     @patch.object(vimconnector, "_delete_volumes_by_id_wth_cinder")
5189     @patch.object(vimconnector, "_delete_floating_ip_by_id")
5190     def test_delete_created_items_delete_vol_raises(
5191         self,
5192         mock_delete_floating_ip_by_id,
5193         mock_delete_volumes_by_id_wth_cinder,
5194         mock_get_item_name_id,
5195     ):
5196         """Delete volume raises exception."""
5197         created_items = {
5198             f"floating_ip:{floating_network_vim_id}": True,
5199             f"volume:{volume_id}": True,
5200             f"port:{port_id}": None,
5201         }
5202         mock_get_item_name_id.side_effect = [
5203             ("floating_ip", f"{floating_network_vim_id}"),
5204             ("volume", f"{volume_id}"),
5205         ]
5206         mock_delete_volumes_by_id_wth_cinder.side_effect = ConnectionError(
5207             "Connection failed."
5208         )
5209         volumes_to_hold = []
5210         keep_waiting = False
5211         result = self.vimconn._delete_created_items(
5212             created_items, volumes_to_hold, keep_waiting
5213         )
5214         self.assertEqual(result, False)
5215         self.assertEqual(mock_get_item_name_id.call_count, 2)
5216         mock_delete_volumes_by_id_wth_cinder.assert_called_once_with(
5217             f"volume:{volume_id}", f"{volume_id}", [], created_items
5218         )
5219         mock_delete_floating_ip_by_id.assert_called_once_with(
5220             f"floating_ip:{floating_network_vim_id}",
5221             f"{floating_network_vim_id}",
5222             created_items,
5223         )
5224         self.vimconn.logger.error.assert_called_once_with(
5225             "Error deleting volume:ac408b73-b9cc-4a6a-a270-82cc4811bd4a: Connection failed."
5226         )
5227
5228     @patch.object(vimconnector, "_get_item_name_id")
5229     @patch.object(vimconnector, "_delete_volumes_by_id_wth_cinder")
5230     @patch.object(vimconnector, "_delete_floating_ip_by_id")
5231     def test_delete_created_items_delete_fip_raises(
5232         self,
5233         mock_delete_floating_ip_by_id,
5234         mock_delete_volumes_by_id_wth_cinder,
5235         mock_get_item_name_id,
5236     ):
5237         """Delete floating ip raises exception."""
5238         created_items = {
5239             f"floating_ip:{floating_network_vim_id}": True,
5240             f"volume:{volume_id}": True,
5241             f"port:{port_id}": None,
5242         }
5243         mock_get_item_name_id.side_effect = [
5244             ("floating_ip", f"{floating_network_vim_id}"),
5245             ("volume", f"{volume_id}"),
5246         ]
5247         mock_delete_volumes_by_id_wth_cinder.return_value = False
5248         mock_delete_floating_ip_by_id.side_effect = ConnectionError(
5249             "Connection failed."
5250         )
5251         volumes_to_hold = []
5252         keep_waiting = True
5253         result = self.vimconn._delete_created_items(
5254             created_items, volumes_to_hold, keep_waiting
5255         )
5256         self.assertEqual(result, True)
5257         self.assertEqual(mock_get_item_name_id.call_count, 2)
5258         mock_delete_volumes_by_id_wth_cinder.assert_called_once_with(
5259             f"volume:{volume_id}", f"{volume_id}", [], created_items
5260         )
5261         mock_delete_floating_ip_by_id.assert_called_once_with(
5262             f"floating_ip:{floating_network_vim_id}",
5263             f"{floating_network_vim_id}",
5264             created_items,
5265         )
5266         self.vimconn.logger.error.assert_called_once_with(
5267             "Error deleting floating_ip:108b73-e9cc-5a6a-t270-82cc4811bd4a: Connection failed."
5268         )
5269
5270     @patch.object(vimconnector, "_get_item_name_id")
5271     @patch.object(vimconnector, "_delete_volumes_by_id_wth_cinder")
5272     @patch.object(vimconnector, "_delete_floating_ip_by_id")
5273     def test_delete_created_items_get_item_name_raises(
5274         self,
5275         mock_delete_floating_ip_by_id,
5276         mock_delete_volumes_by_id_wth_cinder,
5277         mock_get_item_name_id,
5278     ):
5279         """Get item, name raises exception."""
5280         created_items = {
5281             3: True,
5282             f"volume{volume_id}": True,
5283             f"port:{port_id}": None,
5284         }
5285         mock_get_item_name_id.side_effect = [
5286             TypeError("Invalid Type"),
5287             AttributeError("Invalid attribute"),
5288         ]
5289         volumes_to_hold = []
5290         keep_waiting = False
5291         result = self.vimconn._delete_created_items(
5292             created_items, volumes_to_hold, keep_waiting
5293         )
5294         self.assertEqual(result, False)
5295         self.assertEqual(mock_get_item_name_id.call_count, 2)
5296         mock_delete_volumes_by_id_wth_cinder.assert_not_called()
5297         mock_delete_floating_ip_by_id.assert_not_called()
5298         _call_logger = self.vimconn.logger.error.call_args_list
5299         self.assertEqual(_call_logger[0][0], ("Error deleting 3: Invalid Type",))
5300         self.assertEqual(
5301             _call_logger[1][0],
5302             (f"Error deleting volume{volume_id}: Invalid attribute",),
5303         )
5304
5305     @patch.object(vimconnector, "_get_item_name_id")
5306     @patch.object(vimconnector, "_delete_volumes_by_id_wth_cinder")
5307     @patch.object(vimconnector, "_delete_floating_ip_by_id")
5308     def test_delete_created_items_no_fip_wth_port(
5309         self,
5310         mock_delete_floating_ip_by_id,
5311         mock_delete_volumes_by_id_wth_cinder,
5312         mock_get_item_name_id,
5313     ):
5314         """Created items has port, does not have floating ip."""
5315         created_items = {
5316             f"volume:{volume_id}": True,
5317             f"port:{port_id}": True,
5318         }
5319         mock_get_item_name_id.side_effect = [
5320             ("volume", f"{volume_id}"),
5321             ("port", f"{port_id}"),
5322         ]
5323         mock_delete_volumes_by_id_wth_cinder.return_value = False
5324         volumes_to_hold = []
5325         keep_waiting = False
5326         result = self.vimconn._delete_created_items(
5327             created_items, volumes_to_hold, keep_waiting
5328         )
5329         self.assertEqual(result, False)
5330         self.assertEqual(mock_get_item_name_id.call_count, 2)
5331         mock_delete_volumes_by_id_wth_cinder.assert_called_once_with(
5332             f"volume:{volume_id}", f"{volume_id}", [], created_items
5333         )
5334         mock_delete_floating_ip_by_id.assert_not_called()
5335         self.vimconn.logger.error.assert_not_called()
5336
5337     @patch.object(vimconnector, "_get_item_name_id")
5338     @patch.object(vimconnector, "_delete_volumes_by_id_wth_cinder")
5339     @patch.object(vimconnector, "_delete_floating_ip_by_id")
5340     def test_delete_created_items_no_volume(
5341         self,
5342         mock_delete_floating_ip_by_id,
5343         mock_delete_volumes_by_id_wth_cinder,
5344         mock_get_item_name_id,
5345     ):
5346         """Created items does not have volume."""
5347         created_items = {
5348             f"floating_ip:{floating_network_vim_id}": True,
5349             f"port:{port_id}": None,
5350         }
5351         mock_get_item_name_id.side_effect = [
5352             ("floating_ip", f"{floating_network_vim_id}")
5353         ]
5354         volumes_to_hold = []
5355         keep_waiting = False
5356         result = self.vimconn._delete_created_items(
5357             created_items, volumes_to_hold, keep_waiting
5358         )
5359         self.assertEqual(result, False)
5360         self.assertEqual(mock_get_item_name_id.call_count, 1)
5361         mock_delete_volumes_by_id_wth_cinder.assert_not_called()
5362         mock_delete_floating_ip_by_id.assert_called_once_with(
5363             f"floating_ip:{floating_network_vim_id}",
5364             f"{floating_network_vim_id}",
5365             created_items,
5366         )
5367         self.vimconn.logger.error.assert_not_called()
5368
5369     @patch.object(vimconnector, "_get_item_name_id")
5370     @patch.object(vimconnector, "_delete_volumes_by_id_wth_cinder")
5371     @patch.object(vimconnector, "_delete_floating_ip_by_id")
5372     def test_delete_created_items_already_deleted(
5373         self,
5374         mock_delete_floating_ip_by_id,
5375         mock_delete_volumes_by_id_wth_cinder,
5376         mock_get_item_name_id,
5377     ):
5378         """All created items are alerady deleted."""
5379         created_items = {
5380             f"floating_ip:{floating_network_vim_id}": None,
5381             f"volume:{volume_id}": None,
5382             f"port:{port_id}": None,
5383         }
5384         volumes_to_hold = []
5385         keep_waiting = False
5386         result = self.vimconn._delete_created_items(
5387             created_items, volumes_to_hold, keep_waiting
5388         )
5389         self.assertEqual(result, False)
5390         mock_get_item_name_id.assert_not_called()
5391         mock_delete_volumes_by_id_wth_cinder.assert_not_called()
5392         mock_delete_floating_ip_by_id.assert_not_called()
5393         self.vimconn.logger.error.assert_not_called()
5394
5395     @patch("time.sleep")
5396     @patch.object(vimconnector, "_extract_items_wth_keep_flag_from_created_items")
5397     @patch.object(vimconnector, "_format_exception")
5398     @patch.object(vimconnector, "_reload_connection")
5399     @patch.object(vimconnector, "_delete_vm_ports_attached_to_network")
5400     @patch.object(vimconnector, "_delete_created_items")
5401     def test_delete_vminstance_successfully(
5402         self,
5403         mock_delete_created_items,
5404         mock_delete_vm_ports_attached_to_network,
5405         mock_reload_connection,
5406         mock_format_exception,
5407         mock_extract_items_wth_keep_flag_from_created_items,
5408         mock_sleep,
5409     ):
5410         vm_id = f"{virtual_mac_id}"
5411         created_items = deepcopy(created_items_all_true)
5412         mock_extract_items_wth_keep_flag_from_created_items.return_value = created_items
5413         volumes_to_hold = [f"{volume_id}", f"{volume_id2}"]
5414         mock_delete_created_items.return_value = False
5415         self.vimconn.delete_vminstance(vm_id, created_items, volumes_to_hold)
5416         mock_reload_connection.assert_called_once()
5417         mock_delete_vm_ports_attached_to_network.assert_called_once_with(created_items)
5418         self.vimconn.nova.servers.delete.assert_called_once_with(vm_id)
5419         mock_delete_created_items.assert_called_once_with(
5420             created_items, volumes_to_hold, False
5421         )
5422         mock_sleep.assert_not_called()
5423         mock_format_exception.assert_not_called()
5424         mock_extract_items_wth_keep_flag_from_created_items.assert_called_once_with(
5425             created_items
5426         )
5427
5428     @patch("time.sleep")
5429     @patch.object(vimconnector, "_extract_items_wth_keep_flag_from_created_items")
5430     @patch.object(vimconnector, "_format_exception")
5431     @patch.object(vimconnector, "_reload_connection")
5432     @patch.object(vimconnector, "_delete_vm_ports_attached_to_network")
5433     @patch.object(vimconnector, "_delete_created_items")
5434     def test_delete_vminstance_created_items_has_keep_flag(
5435         self,
5436         mock_delete_created_items,
5437         mock_delete_vm_ports_attached_to_network,
5438         mock_reload_connection,
5439         mock_format_exception,
5440         mock_extract_items_wth_keep_flag_from_created_items,
5441         mock_sleep,
5442     ):
5443         """Created_items includes items which has keep flag."""
5444         vm_id = f"{virtual_mac_id}"
5445         initial_created_items = {
5446             f"port{port_id}": True,
5447             f"floating_ip{floating_network_vim_id}": None,
5448             f"volume{volume_id}keep": True,
5449             f"volume{volume_id2}keep": True,
5450         }
5451         created_items = {
5452             f"port{port_id}": True,
5453             f"floating_ip{floating_network_vim_id}": None,
5454         }
5455         mock_extract_items_wth_keep_flag_from_created_items.return_value = created_items
5456         volumes_to_hold = []
5457         mock_delete_created_items.return_value = False
5458         self.vimconn.delete_vminstance(vm_id, initial_created_items, volumes_to_hold)
5459         mock_reload_connection.assert_called_once()
5460         mock_delete_vm_ports_attached_to_network.assert_called_once_with(created_items)
5461         self.vimconn.nova.servers.delete.assert_called_once_with(vm_id)
5462         mock_delete_created_items.assert_called_once_with(
5463             created_items, volumes_to_hold, False
5464         )
5465         mock_sleep.assert_not_called()
5466         mock_format_exception.assert_not_called()
5467         mock_extract_items_wth_keep_flag_from_created_items.assert_called_once_with(
5468             initial_created_items
5469         )
5470
5471     @patch("time.sleep")
5472     @patch.object(vimconnector, "_extract_items_wth_keep_flag_from_created_items")
5473     @patch.object(vimconnector, "_format_exception")
5474     @patch.object(vimconnector, "_reload_connection")
5475     @patch.object(vimconnector, "_delete_vm_ports_attached_to_network")
5476     @patch.object(vimconnector, "_delete_created_items")
5477     def test_delete_vminstance_extract_items_wth_keep_raises(
5478         self,
5479         mock_delete_created_items,
5480         mock_delete_vm_ports_attached_to_network,
5481         mock_reload_connection,
5482         mock_format_exception,
5483         mock_extract_items_wth_keep_flag_from_created_items,
5484         mock_sleep,
5485     ):
5486         """extract_items_wth_keep_flag_from_created_items raises AttributeError."""
5487         vm_id = f"{virtual_mac_id}"
5488         initial_created_items = {
5489             f"port{port_id}": True,
5490             f"floating_ip{floating_network_vim_id}": None,
5491             f"volume{volume_id}keep": True,
5492             f"volume{volume_id2}keep": True,
5493         }
5494
5495         mock_extract_items_wth_keep_flag_from_created_items.side_effect = AttributeError
5496         volumes_to_hold = []
5497         mock_delete_created_items.return_value = False
5498         with self.assertRaises(AttributeError):
5499             self.vimconn.delete_vminstance(
5500                 vm_id, initial_created_items, volumes_to_hold
5501             )
5502         mock_reload_connection.assert_not_called()
5503         mock_delete_vm_ports_attached_to_network.assert_not_called()
5504         self.vimconn.nova.servers.delete.assert_not_called()
5505         mock_delete_created_items.assert_not_called()
5506         mock_sleep.assert_not_called()
5507         mock_format_exception.assert_not_called()
5508         mock_extract_items_wth_keep_flag_from_created_items.assert_called_once_with(
5509             initial_created_items
5510         )
5511
5512     @patch("time.sleep")
5513     @patch.object(vimconnector, "_extract_items_wth_keep_flag_from_created_items")
5514     @patch.object(vimconnector, "_format_exception")
5515     @patch.object(vimconnector, "_reload_connection")
5516     @patch.object(vimconnector, "_delete_vm_ports_attached_to_network")
5517     @patch.object(vimconnector, "_delete_created_items")
5518     def test_delete_vminstance_delete_created_items_raises(
5519         self,
5520         mock_delete_created_items,
5521         mock_delete_vm_ports_attached_to_network,
5522         mock_reload_connection,
5523         mock_format_exception,
5524         mock_extract_items_wth_keep_flag_from_created_items,
5525         mock_sleep,
5526     ):
5527         """Delete creted items raises exception."""
5528         vm_id = f"{virtual_mac_id}"
5529         created_items = deepcopy(created_items_all_true)
5530         mock_extract_items_wth_keep_flag_from_created_items.return_value = created_items
5531         mock_sleep = MagicMock()
5532         volumes_to_hold = []
5533         err = ConnectionError("ClientException occured.")
5534         mock_delete_created_items.side_effect = err
5535         with self.assertRaises(ConnectionError) as err:
5536             self.vimconn.delete_vminstance(vm_id, created_items, volumes_to_hold)
5537             self.assertEqual(str(err), "ClientException occured.")
5538         mock_reload_connection.assert_called_once()
5539         mock_delete_vm_ports_attached_to_network.assert_called_once_with(created_items)
5540         self.vimconn.nova.servers.delete.assert_called_once_with(vm_id)
5541         mock_delete_created_items.assert_called_once()
5542         mock_sleep.assert_not_called()
5543         mock_extract_items_wth_keep_flag_from_created_items.assert_called_once_with(
5544             created_items
5545         )
5546
5547     @patch("time.sleep")
5548     @patch.object(vimconnector, "_extract_items_wth_keep_flag_from_created_items")
5549     @patch.object(vimconnector, "_format_exception")
5550     @patch.object(vimconnector, "_reload_connection")
5551     @patch.object(vimconnector, "_delete_vm_ports_attached_to_network")
5552     @patch.object(vimconnector, "_delete_created_items")
5553     def test_delete_vminstance_delete_vm_ports_raises(
5554         self,
5555         mock_delete_created_items,
5556         mock_delete_vm_ports_attached_to_network,
5557         mock_reload_connection,
5558         mock_format_exception,
5559         mock_extract_items_wth_keep_flag_from_created_items,
5560         mock_sleep,
5561     ):
5562         """Delete vm ports raises exception."""
5563         vm_id = f"{virtual_mac_id}"
5564         created_items = deepcopy(created_items_all_true)
5565         mock_extract_items_wth_keep_flag_from_created_items.return_value = created_items
5566         volumes_to_hold = [f"{volume_id}", f"{volume_id2}"]
5567         err = ConnectionError("ClientException occured.")
5568         mock_delete_vm_ports_attached_to_network.side_effect = err
5569         mock_delete_created_items.side_effect = err
5570         with self.assertRaises(ConnectionError) as err:
5571             self.vimconn.delete_vminstance(vm_id, created_items, volumes_to_hold)
5572             self.assertEqual(str(err), "ClientException occured.")
5573         mock_reload_connection.assert_called_once()
5574         mock_delete_vm_ports_attached_to_network.assert_called_once_with(created_items)
5575         self.vimconn.nova.servers.delete.assert_not_called()
5576         mock_delete_created_items.assert_not_called()
5577         mock_sleep.assert_not_called()
5578         mock_extract_items_wth_keep_flag_from_created_items.assert_called_once_with(
5579             created_items
5580         )
5581
5582     @patch("time.sleep")
5583     @patch.object(vimconnector, "_extract_items_wth_keep_flag_from_created_items")
5584     @patch.object(vimconnector, "_format_exception")
5585     @patch.object(vimconnector, "_reload_connection")
5586     @patch.object(vimconnector, "_delete_vm_ports_attached_to_network")
5587     @patch.object(vimconnector, "_delete_created_items")
5588     def test_delete_vminstance_nova_server_delete_raises(
5589         self,
5590         mock_delete_created_items,
5591         mock_delete_vm_ports_attached_to_network,
5592         mock_reload_connection,
5593         mock_format_exception,
5594         mock_extract_items_wth_keep_flag_from_created_items,
5595         mock_sleep,
5596     ):
5597         """Nova server delete raises exception."""
5598         vm_id = f"{virtual_mac_id}"
5599         created_items = deepcopy(created_items_all_true)
5600         mock_extract_items_wth_keep_flag_from_created_items.return_value = created_items
5601         volumes_to_hold = [f"{volume_id}", f"{volume_id2}"]
5602         err = VimConnConnectionException("ClientException occured.")
5603         self.vimconn.nova.servers.delete.side_effect = err
5604         mock_delete_created_items.side_effect = err
5605         with self.assertRaises(VimConnConnectionException) as err:
5606             self.vimconn.delete_vminstance(vm_id, created_items, volumes_to_hold)
5607             self.assertEqual(str(err), "ClientException occured.")
5608         mock_reload_connection.assert_called_once()
5609         mock_delete_vm_ports_attached_to_network.assert_called_once_with(created_items)
5610         self.vimconn.nova.servers.delete.assert_called_once_with(vm_id)
5611         mock_delete_created_items.assert_not_called()
5612         mock_sleep.assert_not_called()
5613         mock_extract_items_wth_keep_flag_from_created_items.assert_called_once_with(
5614             created_items
5615         )
5616
5617     @patch("time.sleep")
5618     @patch.object(vimconnector, "_extract_items_wth_keep_flag_from_created_items")
5619     @patch.object(vimconnector, "_format_exception")
5620     @patch.object(vimconnector, "_reload_connection")
5621     @patch.object(vimconnector, "_delete_vm_ports_attached_to_network")
5622     @patch.object(vimconnector, "_delete_created_items")
5623     def test_delete_vminstance_reload_connection_raises(
5624         self,
5625         mock_delete_created_items,
5626         mock_delete_vm_ports_attached_to_network,
5627         mock_reload_connection,
5628         mock_format_exception,
5629         mock_extract_items_wth_keep_flag_from_created_items,
5630         mock_sleep,
5631     ):
5632         """Reload connection raises exception."""
5633         vm_id = f"{virtual_mac_id}"
5634         created_items = deepcopy(created_items_all_true)
5635         mock_extract_items_wth_keep_flag_from_created_items.return_value = created_items
5636         mock_sleep = MagicMock()
5637         volumes_to_hold = [f"{volume_id}", f"{volume_id2}"]
5638         err = ConnectionError("ClientException occured.")
5639         mock_delete_created_items.return_value = False
5640         mock_reload_connection.side_effect = err
5641         with self.assertRaises(ConnectionError) as err:
5642             self.vimconn.delete_vminstance(vm_id, created_items, volumes_to_hold)
5643             self.assertEqual(str(err), "ClientException occured.")
5644         mock_reload_connection.assert_called_once()
5645         mock_delete_vm_ports_attached_to_network.assert_not_called()
5646         self.vimconn.nova.servers.delete.assert_not_called()
5647         mock_delete_created_items.assert_not_called()
5648         mock_sleep.assert_not_called()
5649         mock_extract_items_wth_keep_flag_from_created_items.assert_called_once_with(
5650             created_items
5651         )
5652
5653     @patch("time.sleep")
5654     @patch.object(vimconnector, "_extract_items_wth_keep_flag_from_created_items")
5655     @patch.object(vimconnector, "_format_exception")
5656     @patch.object(vimconnector, "_reload_connection")
5657     @patch.object(vimconnector, "_delete_vm_ports_attached_to_network")
5658     @patch.object(vimconnector, "_delete_created_items")
5659     def test_delete_vminstance_created_item_vol_to_hold_are_none(
5660         self,
5661         mock_delete_created_items,
5662         mock_delete_vm_ports_attached_to_network,
5663         mock_reload_connection,
5664         mock_format_exception,
5665         mock_extract_items_wth_keep_flag_from_created_items,
5666         mock_sleep,
5667     ):
5668         """created_items and volumes_to_hold are None."""
5669         vm_id = f"{virtual_mac_id}"
5670         created_items = None
5671         volumes_to_hold = None
5672         mock_extract_items_wth_keep_flag_from_created_items.return_value = {}
5673         mock_delete_created_items.return_value = False
5674         self.vimconn.delete_vminstance(vm_id, created_items, volumes_to_hold)
5675         mock_reload_connection.assert_called_once()
5676         mock_delete_vm_ports_attached_to_network.assert_not_called()
5677         self.vimconn.nova.servers.delete.assert_called_once_with(vm_id)
5678         mock_delete_created_items.assert_called_once_with({}, [], False)
5679         mock_sleep.assert_not_called()
5680         mock_format_exception.assert_not_called()
5681         mock_extract_items_wth_keep_flag_from_created_items.assert_called_once_with({})
5682
5683     @patch("time.sleep")
5684     @patch.object(vimconnector, "_extract_items_wth_keep_flag_from_created_items")
5685     @patch.object(vimconnector, "_format_exception")
5686     @patch.object(vimconnector, "_reload_connection")
5687     @patch.object(vimconnector, "_delete_vm_ports_attached_to_network")
5688     @patch.object(vimconnector, "_delete_created_items")
5689     def test_delete_vminstance_vm_id_is_none(
5690         self,
5691         mock_delete_created_items,
5692         mock_delete_vm_ports_attached_to_network,
5693         mock_reload_connection,
5694         mock_format_exception,
5695         mock_extract_items_wth_keep_flag_from_created_items,
5696         mock_sleep,
5697     ):
5698         """vm_id is None."""
5699         vm_id = None
5700         created_items = deepcopy(created_items_all_true)
5701         mock_extract_items_wth_keep_flag_from_created_items.return_value = created_items
5702         volumes_to_hold = [f"{volume_id}", f"{volume_id2}"]
5703         mock_delete_created_items.side_effect = [True, True, False]
5704         self.vimconn.delete_vminstance(vm_id, created_items, volumes_to_hold)
5705         mock_reload_connection.assert_called_once()
5706         mock_delete_vm_ports_attached_to_network.assert_called_once_with(created_items)
5707         self.vimconn.nova.servers.delete.assert_not_called()
5708         self.assertEqual(mock_delete_created_items.call_count, 3)
5709         self.assertEqual(mock_sleep.call_count, 2)
5710         mock_format_exception.assert_not_called()
5711         mock_extract_items_wth_keep_flag_from_created_items.assert_called_once_with(
5712             created_items
5713         )
5714
5715     @patch("time.sleep")
5716     @patch.object(vimconnector, "_extract_items_wth_keep_flag_from_created_items")
5717     @patch.object(vimconnector, "_format_exception")
5718     @patch.object(vimconnector, "_reload_connection")
5719     @patch.object(vimconnector, "_delete_vm_ports_attached_to_network")
5720     @patch.object(vimconnector, "_delete_created_items")
5721     def test_delete_vminstance_delete_created_items_return_true(
5722         self,
5723         mock_delete_created_items,
5724         mock_delete_vm_ports_attached_to_network,
5725         mock_reload_connection,
5726         mock_format_exception,
5727         mock_extract_items_wth_keep_flag_from_created_items,
5728         mock_sleep,
5729     ):
5730         """Delete created items always return True."""
5731         vm_id = None
5732         created_items = deepcopy(created_items_all_true)
5733         mock_extract_items_wth_keep_flag_from_created_items.return_value = created_items
5734         volumes_to_hold = [f"{volume_id}", f"{volume_id2}"]
5735         mock_delete_created_items.side_effect = [True] * 1800
5736         self.vimconn.delete_vminstance(vm_id, created_items, volumes_to_hold)
5737         mock_reload_connection.assert_called_once()
5738         mock_delete_vm_ports_attached_to_network.assert_called_once_with(created_items)
5739         self.vimconn.nova.servers.delete.assert_not_called()
5740         self.assertEqual(mock_delete_created_items.call_count, 1800)
5741         self.assertEqual(mock_sleep.call_count, 1800)
5742         mock_format_exception.assert_not_called()
5743         mock_extract_items_wth_keep_flag_from_created_items.assert_called_once_with(
5744             created_items
5745         )
5746
5747     def test_remove_keep_tag_from_persistent_volumes_keep_flag_exists(self):
5748         """Keep flag exists in created items."""
5749         created_items = {
5750             f"port:{port_id}": True,
5751             f"floating_ip:{floating_network_vim_id}": True,
5752             f"volume:{volume_id}:keep": True,
5753             f"volume:{volume_id2}:keep": True,
5754         }
5755         expected_result = {
5756             f"port:{port_id}": True,
5757             f"floating_ip:{floating_network_vim_id}": True,
5758             f"volume:{volume_id}": True,
5759             f"volume:{volume_id2}": True,
5760         }
5761         result = self.vimconn.remove_keep_tag_from_persistent_volumes(created_items)
5762         self.assertDictEqual(result, expected_result)
5763
5764     def test_remove_keep_tag_from_persistent_volumes_without_keep_flag(self):
5765         """Keep flag does not exist in created items."""
5766         created_items = {
5767             f"port:{port_id}": True,
5768             f"floating_ip:{floating_network_vim_id}": True,
5769             f"volume:{volume_id}": True,
5770             f"volume:{volume_id2}": True,
5771         }
5772         result = self.vimconn.remove_keep_tag_from_persistent_volumes(created_items)
5773         self.assertDictEqual(result, created_items)
5774
5775     def test_update_block_device_mapping_empty_volume(self):
5776         """"""
5777         volume = ""
5778         block_device_mapping = {}
5779         base_disk_index = 100
5780         disk = {}
5781         created_items = {}
5782         with self.assertRaises(VimConnException) as err:
5783             self.vimconn.update_block_device_mapping(
5784                 volume, block_device_mapping, base_disk_index, disk, created_items
5785             )
5786             self.assertEqual(str(err), "Volume is empty.")
5787         self.assertEqual(block_device_mapping, {})
5788         self.assertEqual(created_items, {})
5789
5790     def test_update_block_device_mapping_invalid_volume(self):
5791         """"""
5792         volume = "Volume-A"
5793         block_device_mapping = {}
5794         base_disk_index = 100
5795         disk = {}
5796         created_items = {}
5797         with self.assertRaises(VimConnException) as err:
5798             self.vimconn.update_block_device_mapping(
5799                 volume, block_device_mapping, base_disk_index, disk, created_items
5800             )
5801             self.assertEqual(
5802                 str(err), "Created volume is not valid, does not have id attribute."
5803             )
5804         self.assertEqual(block_device_mapping, {})
5805         self.assertEqual(created_items, {})
5806
5807     def test_update_block_device_mapping(self):
5808         """"""
5809         volume = MagicMock(autospec=True)
5810         volume.id = volume_id
5811         block_device_mapping = {}
5812         base_disk_index = 100
5813         disk = {}
5814         created_items = {}
5815         self.vimconn.update_block_device_mapping(
5816             volume, block_device_mapping, base_disk_index, disk, created_items
5817         )
5818         self.assertEqual(
5819             block_device_mapping, {"vdd": "ac408b73-b9cc-4a6a-a270-82cc4811bd4a"}
5820         )
5821         self.assertEqual(
5822             created_items, {"volume:ac408b73-b9cc-4a6a-a270-82cc4811bd4a": True}
5823         )
5824
5825     def test_update_block_device_mapping_with_keep_flag(self):
5826         """"""
5827         volume = MagicMock(autospec=True)
5828         volume.id = volume_id
5829         block_device_mapping = {}
5830         base_disk_index = 100
5831         disk = {"size": 10, "keep": True}
5832         created_items = {}
5833         self.vimconn.update_block_device_mapping(
5834             volume, block_device_mapping, base_disk_index, disk, created_items
5835         )
5836         self.assertEqual(
5837             block_device_mapping, {"vdd": "ac408b73-b9cc-4a6a-a270-82cc4811bd4a"}
5838         )
5839         self.assertEqual(
5840             created_items, {"volume:ac408b73-b9cc-4a6a-a270-82cc4811bd4a:keep": True}
5841         )
5842
5843     def test_extract_items_with_keep_flag_item_has_keep_flag(self):
5844         created_items = deepcopy(created_items_all_true)
5845         created_items[f"volume:{volume_id2}:keep"] = True
5846         result = self.vimconn._extract_items_wth_keep_flag_from_created_items(
5847             created_items
5848         )
5849         self.assertEqual(result, deepcopy(created_items_all_true))
5850
5851     def test_extract_items_with_keep_flag_no_item_wth_keep_flag(self):
5852         created_items = deepcopy(created_items_all_true)
5853         result = self.vimconn._extract_items_wth_keep_flag_from_created_items(
5854             created_items
5855         )
5856         self.assertEqual(result, deepcopy(created_items_all_true))
5857
5858     def test_extract_items_with_keep_flag_all_items_are_already_deleted(self):
5859         created_items = {
5860             f"port:{port_id}": None,
5861             f"floating_ip:{floating_network_vim_id}": None,
5862             f"volume:{volume_id}:keep": None,
5863             f"volume:{volume_id2}:keep": None,
5864         }
5865         expected_result = {
5866             f"port:{port_id}": None,
5867             f"floating_ip:{floating_network_vim_id}": None,
5868         }
5869         result = self.vimconn._extract_items_wth_keep_flag_from_created_items(
5870             created_items
5871         )
5872         self.assertEqual(result, expected_result)
5873
5874     def test_extract_items_with_keep_flag_without_semicolon(self):
5875         created_items = {
5876             f"port{port_id}": True,
5877             f"floating_ip{floating_network_vim_id}": None,
5878             f"volume{volume_id}keep": True,
5879             f"volume{volume_id2}keep": True,
5880         }
5881         result = self.vimconn._extract_items_wth_keep_flag_from_created_items(
5882             created_items
5883         )
5884         self.assertEqual(result, {})
5885
5886     def test_extract_items_with_keep_flag_invalid_type_created_items(self):
5887         created_items = [{f"port{port_id}": True}, {f"volume{volume_id2}keep": True}]
5888         with self.assertRaises(AttributeError):
5889             self.vimconn._extract_items_wth_keep_flag_from_created_items(created_items)
5890
5891
5892 if __name__ == "__main__":
5893     unittest.main()