RO-VIM-vmware/osm_rovim_vmware/tests/test_vimconn_vmware.py

   1 # -*- coding: utf-8 -*-
   2
   3 ##
   4 # Copyright 2016-2017 VMware Inc.
   5 # This file is part of ETSI OSM
   6 # All Rights Reserved.
   7 #
   8 # Licensed under the Apache License, Version 2.0 (the "License"); you may
   9 # not use this file except in compliance with the License. You may obtain
  10 # a copy of the License at
  11 #
  12 #         http://www.apache.org/licenses/LICENSE-2.0
  13 #
  14 # Unless required by applicable law or agreed to in writing, software
  15 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  16 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  17 # License for the specific language governing permissions and limitations
  18 # under the License.
  19 #
  20 # For those usages not covered by the Apache License, Version 2.0 please
  21 # contact:  osslegalrouting@vmware.com
  22 ##
  23
  24
  25 import os
  26 from os import path
  27 import unittest
  28 from unittest import mock
  29
  30 from lxml import etree as lxmlElementTree
  31 from osm_ro_plugin.vimconn import (
  32     VimConnException,
  33     VimConnNotFoundException,
  34     VimConnUnexpectedResponse,
  35 )
  36 from osm_rovim_vmware.vimconn_vmware import vimconnector
  37 from pyvcloud.vcd.client import Client
  38 from pyvcloud.vcd.org import Org
  39 from pyvcloud.vcd.vapp import VApp
  40 from pyvcloud.vcd.vdc import VDC
  41 import tests.test_vimconn_vmware_xml_response as xml_resp
  42
  43 __author__ = "Prakash Kasar"
  44
  45
  46 class TestVimconn_VMware(unittest.TestCase):
  47     def setUp(self):
  48         config = {
  49             "admin_password": "admin",
  50             "admin_username": "user",
  51             "nsx_user": "nsx",
  52             "nsx_password": "nsx",
  53             "nsx_manager": "https://test-nsx",
  54         }
  55
  56         self.client = Client("test", verify_ssl_certs=False)
  57
  58         # get vcd org object
  59         org_resp = xml_resp.org_xml_response
  60         get_org = lxmlElementTree.fromstring(org_resp)
  61         self.org = Org(self.client, resource=get_org)
  62
  63         self.vim = vimconnector(
  64             uuid="12354",
  65             name="test",
  66             tenant_id="abc1234",
  67             tenant_name="test",
  68             url="https://test",
  69             config=config,
  70         )
  71
  72     @mock.patch.object(vimconnector, "get_vdc_details")
  73     @mock.patch.object(vimconnector, "connect")
  74     @mock.patch.object(vimconnector, "perform_request")
  75     def test_get_network_not_found(self, perform_request, connect, get_vdc_details):
  76         """
  77         Testcase to get network with invalid network id
  78         """
  79         # created vdc object
  80         vdc_xml_resp = xml_resp.vdc_xml_response
  81         vdc = lxmlElementTree.fromstring(vdc_xml_resp)
  82
  83         # assumed return value from VIM connector
  84         get_vdc_details.return_value = self.org, vdc
  85         self.vim.client = self.vim.connect()
  86         perform_request.return_value.status_code = 200
  87         perform_request.return_value.content = xml_resp.vdc_xml_response
  88
  89         # call to VIM connector method with invalid id
  90         self.assertRaises(VimConnNotFoundException, self.vim.get_network, "mgmt-net")
  91
  92     @mock.patch.object(vimconnector, "perform_request")
  93     @mock.patch.object(vimconnector, "get_vdc_details")
  94     @mock.patch.object(vimconnector, "connect")
  95     def test_get_network(self, connect, get_vdc_details, perform_request):
  96         """
  97         Testcase to get network with valid network id
  98         """
  99         net_id = "5c04dc6d-6096-47c6-b72b-68f19013d491"
 100         # created vdc object
 101         vdc_xml_resp = xml_resp.vdc_xml_response
 102         vdc = lxmlElementTree.fromstring(vdc_xml_resp)
 103
 104         # assumed return value from VIM connector
 105         get_vdc_details.return_value = self.org, vdc
 106         self.vim.client = self.vim.connect()
 107         perform_request.side_effect = [
 108             mock.Mock(status_code=200, content=xml_resp.vdc_xml_response),
 109             mock.Mock(status_code=200, content=xml_resp.network_xml_response),
 110         ]
 111         # call to VIM connector method with network_id
 112         result = self.vim.get_network(net_id)
 113
 114         # assert verified expected and return result from VIM connector
 115         self.assertEqual(net_id, result["id"])
 116
 117     @mock.patch.object(vimconnector, "perform_request")
 118     @mock.patch.object(vimconnector, "get_vdc_details")
 119     @mock.patch.object(vimconnector, "connect")
 120     def test_get_network_list_not_found(
 121         self, connect, get_vdc_details, perform_request
 122     ):
 123         """
 124         Testcase to get list of available networks by invalid network id
 125         """
 126         vdc_xml_resp = xml_resp.vdc_xml_response
 127         network_xml_resp = xml_resp.network_xml_response
 128         # created vdc object
 129         vdc = lxmlElementTree.fromstring(vdc_xml_resp)
 130
 131         # assumed return value from VIM connector
 132         get_vdc_details.return_value = self.org, vdc
 133         self.vim.client = self.vim.connect()
 134         perform_request.return_value.status_code = 200
 135         perform_request.return_value.content = network_xml_resp
 136
 137         # call to VIM connector method with network_id
 138         result = self.vim.get_network_list({"id": "45hdfg-345nb-345"})
 139
 140         # assert verified expected and return result from VIM connector
 141         self.assertEqual(list(), result)
 142
 143     @mock.patch.object(vimconnector, "perform_request")
 144     @mock.patch.object(vimconnector, "get_vdc_details")
 145     @mock.patch.object(vimconnector, "connect")
 146     def test_get_network_list(self, connect, get_vdc_details, perform_request):
 147         """
 148         Testcase to get list of available networks by valid network id
 149         """
 150         # import pdb;pdb.set_trace() ## Not working
 151         vdc_xml_resp = xml_resp.vdc_xml_response
 152         net_id = "5c04dc6d-6096-47c6-b72b-68f19013d491"
 153         # created vdc object
 154         vdc = lxmlElementTree.fromstring(vdc_xml_resp)
 155         # created network object
 156         network_xml_resp = xml_resp.network_xml_response
 157         # assumed return value from VIM connector
 158         get_vdc_details.return_value = self.org, vdc
 159         self.vim.client = self.vim.connect()
 160         perform_request.side_effect = [
 161             mock.Mock(status_code=200, content=xml_resp.vdc_xml_response),
 162             mock.Mock(status_code=200, content=network_xml_resp),
 163         ]
 164         perform_request.reset_mock()
 165         perform_request()
 166
 167         # call to VIM connector method with network_id
 168         result = self.vim.get_network_list({"id": net_id})
 169
 170         # assert verified expected and return result from VIM connector
 171         for item in result:
 172             self.assertEqual(item.get("id"), net_id)
 173             self.assertEqual(item.get("status"), "ACTIVE")
 174             self.assertEqual(item.get("shared"), False)
 175
 176     @mock.patch.object(vimconnector, "create_network_rest")
 177     def test_new_network(self, create_network_rest):
 178         """
 179         Testcase to create new network by passing network name and type
 180         """
 181         # create network reposnse
 182         create_net_xml_resp = xml_resp.create_network_xml_response
 183         net_name = "Test_network"
 184         net_type = "bridge"
 185         # assumed return value from VIM connector
 186         create_network_rest.return_value = create_net_xml_resp
 187         # call to VIM connector method with network name and type
 188         result = self.vim.new_network(net_name, net_type)
 189
 190         # assert verified expected and return result from VIM connector
 191         self.assertEqual(result, ("df1956fa-da04-419e-a6a2-427b6f83788f", {}))
 192
 193     @mock.patch.object(vimconnector, "create_network_rest")
 194     def test_new_network_not_created(self, create_network_rest):
 195         """
 196         Testcase to create new network by assigning empty xml data
 197         """
 198         # assumed return value from VIM connector
 199         create_network_rest.return_value = """<?xml version="1.0" encoding="UTF-8"?>
 200                                               <OrgVdcNetwork></OrgVdcNetwork>"""
 201
 202         # assert verified expected and return result from VIM connector
 203         self.assertRaises(
 204             VimConnUnexpectedResponse, self.vim.new_network, "test_net", "bridge"
 205         )
 206
 207     @mock.patch.object(vimconnector, "connect")
 208     @mock.patch.object(vimconnector, "get_network_action")
 209     @mock.patch.object(vimconnector, "delete_network_action")
 210     def test_delete_network(self, delete_network_action, get_network_action, connect):
 211         """
 212         Testcase to delete network by network id
 213         """
 214         net_uuid = "0a55e5d1-43a2-4688-bc92-cb304046bf87"
 215         # delete network response
 216         delete_net_xml_resp = xml_resp.delete_network_xml_response
 217
 218         # assumed return value from VIM connector
 219         self.vim.client = self.vim.connect()
 220         get_network_action.return_value = delete_net_xml_resp
 221         delete_network_action.return_value = True
 222         # call to VIM connector method with network_id
 223         result = self.vim.delete_network(net_uuid)
 224
 225         # assert verified expected and return result from VIM connector
 226         self.assertEqual(result, net_uuid)
 227
 228     @mock.patch.object(vimconnector, "get_vcd_network")
 229     def test_delete_network_not_found(self, get_vcd_network):
 230         """
 231         Testcase to delete network by invalid network id
 232         """
 233         # assumed return value from VIM connector
 234         get_vcd_network.return_value = False
 235         # assert verified expected and return result from VIM connector
 236         self.assertRaises(
 237             VimConnNotFoundException,
 238             self.vim.delete_network,
 239             "2a23e5d1-42a2-0648-bc92-cb508046bf87",
 240         )
 241
 242     def test_get_flavor(self):
 243         """
 244         Testcase to get flavor data
 245         """
 246         flavor_data = {
 247             "a646eb8a-95bd-4e81-8321-5413ee72b62e": {
 248                 "disk": 10,
 249                 "vcpus": 1,
 250                 "ram": 1024,
 251             }
 252         }
 253         vimconnector.flavorlist = flavor_data
 254         result = self.vim.get_flavor("a646eb8a-95bd-4e81-8321-5413ee72b62e")
 255
 256         # assert verified expected and return result from VIM connector
 257         self.assertEqual(result, flavor_data["a646eb8a-95bd-4e81-8321-5413ee72b62e"])
 258
 259     def test_get_flavor_not_found(self):
 260         """
 261         Testcase to get flavor data with invalid id
 262         """
 263         vimconnector.flavorlist = {}
 264         # assert verified expected and return result from VIM connector
 265         self.assertRaises(
 266             VimConnNotFoundException,
 267             self.vim.get_flavor,
 268             "a646eb8a-95bd-4e81-8321-5413ee72b62e",
 269         )
 270
 271     def test_new_flavor(self):
 272         """
 273         Testcase to create new flavor data
 274         """
 275         flavor_data = {"disk": 10, "vcpus": 1, "ram": 1024}
 276         result = self.vim.new_flavor(flavor_data)
 277         # assert verified expected and return result from VIM connector
 278         self.assertIsNotNone(result)
 279
 280     def test_delete_flavor(self):
 281         """
 282         Testcase to delete flavor data
 283         """
 284         flavor_data = {
 285             "2cb3dffb-5c51-4355-8406-28553ead28ac": {
 286                 "disk": 10,
 287                 "vcpus": 1,
 288                 "ram": 1024,
 289             }
 290         }
 291         vimconnector.flavorlist = flavor_data
 292         # return value from VIM connector
 293         result = self.vim.delete_flavor("2cb3dffb-5c51-4355-8406-28553ead28ac")
 294
 295         # assert verified expected and return result from VIM connector
 296         self.assertEqual(result, "2cb3dffb-5c51-4355-8406-28553ead28ac")
 297
 298     @mock.patch.object(vimconnector, "connect_as_admin")
 299     @mock.patch.object(vimconnector, "perform_request")
 300     def test_delete_image_not_found(self, perform_request, connect_as_admin):
 301         """
 302         Testcase to delete image by invalid image id
 303         """
 304         # creating conn object
 305         self.vim.client = self.vim.connect_as_admin()
 306
 307         # assumed return value from VIM connector
 308         perform_request.side_effect = [
 309             mock.Mock(status_code=200, content=xml_resp.delete_catalog_xml_response),
 310             mock.Mock(
 311                 status_code=201, content=xml_resp.delete_catalog_item_xml_response
 312             ),
 313         ]
 314
 315         # assert verified expected and return result from VIM connector
 316         self.assertRaises(VimConnNotFoundException, self.vim.delete_image, "invali3453")
 317
 318     @mock.patch.object(vimconnector, "get_vdc_details")
 319     @mock.patch.object(vimconnector, "connect")
 320     @mock.patch.object(Org, "list_catalogs")
 321     def test_get_image_list(self, list_catalogs, connect, get_vdc_details):
 322         """
 323         Testcase to get image list by valid image id
 324         """
 325         # created vdc object
 326         vdc_xml_resp = xml_resp.vdc_xml_response
 327         vdc = lxmlElementTree.fromstring(vdc_xml_resp)
 328         self.vim.client = self.vim.connect()
 329
 330         # assumed return value from VIM connector
 331         get_vdc_details.return_value = self.org, vdc
 332         list_catalogs.return_value = [
 333             {
 334                 "isShared": "false",
 335                 "numberOfVAppTemplates": "1",
 336                 "orgName": "Org3",
 337                 "isPublished": "false",
 338                 "ownerName": "system",
 339                 "numberOfMedia": "0",
 340                 "creationDate": "2017-10-15T02:03:59.403-07:00",
 341                 "id": "34925a30-0f4a-4018-9759-0d6799063b51",
 342                 "name": "Ubuntu_1nic",
 343             },
 344             {
 345                 "isShared": "false",
 346                 "numberOfVAppTemplates": "1",
 347                 "orgName": "Org3",
 348                 "isPublished": "false",
 349                 "ownerName": "orgadmin",
 350                 "numberOfMedia": "1",
 351                 "creationDate": "2018-02-15T02:16:58.300-08:00",
 352                 "id": "4b94b67e-c2c6-49ec-b46c-3f35ba45ca4a",
 353                 "name": "cirros034",
 354             },
 355             {
 356                 "isShared": "true",
 357                 "numberOfVAppTemplates": "1",
 358                 "orgName": "Org3",
 359                 "isPublished": "true",
 360                 "ownerName": "system",
 361                 "numberOfMedia": "0",
 362                 "creationDate": "2018-01-26T02:09:12.387-08:00",
 363                 "id": "b139ed82-7ca4-49fb-9882-5f841f59c890",
 364                 "name": "Ubuntu_plugtest-1",
 365             },
 366             {
 367                 "isShared": "true",
 368                 "numberOfVAppTemplates": "1",
 369                 "orgName": "Org2",
 370                 "isPublished": "false",
 371                 "ownerName": "system",
 372                 "numberOfMedia": "0",
 373                 "creationDate": "2017-06-18T21:33:16.430-07:00",
 374                 "id": "b31e6973-86d2-404b-a522-b16846d099dc",
 375                 "name": "Ubuntu_Cat",
 376             },
 377             {
 378                 "isShared": "false",
 379                 "numberOfVAppTemplates": "1",
 380                 "orgName": "Org3",
 381                 "isPublished": "false",
 382                 "ownerName": "orgadmin",
 383                 "numberOfMedia": "0",
 384                 "creationDate": "2018-02-15T22:26:28.910-08:00",
 385                 "id": "c3b56180-f980-4256-9109-a93168d73ff2",
 386                 "name": "de4ffcf2ad21f1a5d0714d6b868e2645",
 387             },
 388             {
 389                 "isShared": "false",
 390                 "numberOfVAppTemplates": "0",
 391                 "orgName": "Org3",
 392                 "isPublished": "false",
 393                 "ownerName": "system",
 394                 "numberOfMedia": "0",
 395                 "creationDate": "2017-08-23T05:54:56.780-07:00",
 396                 "id": "d0eb0b02-718d-42e0-b889-56575000b52d",
 397                 "name": "Test_Cirros",
 398             },
 399             {
 400                 "isShared": "false",
 401                 "numberOfVAppTemplates": "0",
 402                 "orgName": "Org3",
 403                 "isPublished": "false",
 404                 "ownerName": "system",
 405                 "numberOfMedia": "0",
 406                 "creationDate": "2017-03-08T21:25:05.923-08:00",
 407                 "id": "d3fa3df2-b311-4571-9138-4c66541d7f46",
 408                 "name": "cirros_10",
 409             },
 410             {
 411                 "isShared": "false",
 412                 "numberOfVAppTemplates": "0",
 413                 "orgName": "Org3",
 414                 "isPublished": "false",
 415                 "ownerName": "system",
 416                 "numberOfMedia": "0",
 417                 "creationDate": "2017-07-12T22:45:20.537-07:00",
 418                 "id": "d64b2617-ea4b-4b90-910b-102c99dd2031",
 419                 "name": "Ubuntu16",
 420             },
 421             {
 422                 "isShared": "true",
 423                 "numberOfVAppTemplates": "1",
 424                 "orgName": "Org3",
 425                 "isPublished": "true",
 426                 "ownerName": "system",
 427                 "numberOfMedia": "1",
 428                 "creationDate": "2017-10-14T23:52:37.260-07:00",
 429                 "id": "e8d953db-8dc9-46d5-9cab-329774cd2ad9",
 430                 "name": "Ubuntu_no_nic",
 431             },
 432         ]
 433
 434         result = self.vim.get_image_list({"id": "4b94b67e-c2c6-49ec-b46c-3f35ba45ca4a"})
 435
 436         # assert verified expected and return result from VIM connector
 437         for item in result:
 438             self.assertEqual(item["id"], "4b94b67e-c2c6-49ec-b46c-3f35ba45ca4a")
 439
 440     @mock.patch.object(vimconnector, "get_vapp_details_rest")
 441     @mock.patch.object(vimconnector, "get_vdc_details")
 442     def test_get_vminstance(self, get_vdc_details, get_vapp_details_rest):
 443         """
 444         Testcase to get vminstance by valid vm id
 445         """
 446         vapp_info = {
 447             "status": "4",
 448             "acquireMksTicket": {
 449                 "href": "https://localhost/api/vApp/vm-47d12505-5968-4e16-95a7"
 450                 "-18743edb0c8b/screen/action/acquireMksTicket",
 451                 "type": "application/vnd.vmware.vcloud.mksTicket+xml",
 452                 "rel": "screen:acquireMksTicket",
 453             },
 454             "vm_virtual_hardware": {
 455                 "disk_edit_href": "https://localhost/api/vApp/vm-47d12505-5968"
 456                 "-4e16-95a7-18743edb0c8b/virtualHardwareSection/disks",
 457                 "disk_size": "40960",
 458             },
 459             "name": "Test1_vm-69a18104-8413-4cb8-bad7-b5afaec6f9fa",
 460             "created": "2017-09-21T01:15:31.627-07:00",
 461             "IsEnabled": "true",
 462             "EndAddress": "12.16.24.199",
 463             "interfaces": [
 464                 {
 465                     "MACAddress": "00:50:56:01:12:a2",
 466                     "NetworkConnectionIndex": "0",
 467                     "network": "testing_T6nODiW4-68f68d93-0350-4d86-b40b-6e74dedf994d",
 468                     "IpAddressAllocationMode": "DHCP",
 469                     "IsConnected": "true",
 470                     "IpAddress": "12.16.24.200",
 471                 }
 472             ],
 473             "ovfDescriptorUploaded": "true",
 474             "nestedHypervisorEnabled": "false",
 475             "Gateway": "12.16.24.1",
 476             "acquireTicket": {
 477                 "href": "https://localhost/api/vApp/vm-47d12505-5968-4e16"
 478                 "-95a7-18743edb0c8b/screen/action/acquireTicket",
 479                 "rel": "screen:acquireTicket",
 480             },
 481             "vmuuid": "47d12505-5968-4e16-95a7-18743edb0c8b",
 482             "Netmask": "255.255.255.0",
 483             "StartAddress": "12.16.24.100",
 484             "primarynetwork": "0",
 485             "networkname": "External-Network-1074",
 486             "IsInherited": "false",
 487             "deployed": "true",
 488         }
 489         # created vdc object
 490         vdc_xml_resp = xml_resp.vdc_xml_response
 491         vdc = lxmlElementTree.fromstring(vdc_xml_resp)
 492         # assumed return value from VIM connector
 493         get_vdc_details.return_value = self.org, vdc
 494         get_vapp_details_rest.return_value = vapp_info
 495
 496         result = self.vim.get_vminstance("47d12505-5968-4e16-95a7-18743edb0c8b")
 497         # assert verified expected and return result from VIM connector
 498         self.assertEqual(result["status"], "ACTIVE")
 499         self.assertEqual(result["hostId"], "47d12505-5968-4e16-95a7-18743edb0c8b")
 500
 501     @mock.patch.object(vimconnector, "connect")
 502     @mock.patch.object(vimconnector, "get_namebyvappid")
 503     @mock.patch.object(vimconnector, "get_vdc_details")
 504     @mock.patch.object(VDC, "get_vapp")
 505     @mock.patch.object(VApp, "power_off")
 506     @mock.patch.object(VApp, "undeploy")
 507     @mock.patch.object(VDC, "delete_vapp")
 508     @mock.patch.object(Client, "get_task_monitor")
 509     def x_test_delete_vminstance(
 510         self,
 511         get_task_monitor,
 512         delete_vapp,
 513         undeploy,
 514         poweroff,
 515         get_vapp,
 516         get_vdc_details,
 517         get_namebyvappid,
 518         connect,
 519     ):
 520         """
 521         Testcase to delete vminstance by valid vm id
 522         """
 523         vm_id = "4f6a9b49-e92d-4935-87a1-0e4dc9c3a069"
 524         vm_name = "Test1_vm-69a18104-8413-4cb8-bad7-b5afaec6f9fa"
 525         # created vdc object
 526         vdc_xml_resp = xml_resp.vdc_xml_response
 527         vdc = lxmlElementTree.fromstring(vdc_xml_resp)
 528
 529         # assumed return value from VIM connector
 530         self.vim.client = self.vim.connect()
 531         get_vdc_details.return_value = self.org, vdc
 532         get_namebyvappid.return_name = vm_name
 533
 534         vapp_resp = xml_resp.vapp_xml_response
 535         vapp = lxmlElementTree.fromstring(vapp_resp)
 536         get_vapp.return_value = vapp
 537
 538         power_off_resp = xml_resp.poweroff_task_xml
 539         power_off = lxmlElementTree.fromstring(power_off_resp)
 540         poweroff.return_value = power_off
 541
 542         status_resp = xml_resp.status_task_xml
 543         status = lxmlElementTree.fromstring(status_resp)
 544         self.vim.connect.return_value.get_task_monitor.return_value.wait_for_success.return_value = (
 545             status
 546         )
 547
 548         # call to VIM connector method
 549         result = self.vim.delete_vminstance(vm_id)
 550
 551         # assert verified expected and return result from VIM connector
 552         self.assertEqual(result, vm_id)
 553
 554     @mock.patch.object(vimconnector, "get_network_id_by_name")
 555     @mock.patch.object(vimconnector, "get_vm_pci_details")
 556     @mock.patch.object(VDC, "get_vapp")
 557     @mock.patch.object(vimconnector, "connect")
 558     @mock.patch.object(vimconnector, "get_namebyvappid")
 559     @mock.patch.object(vimconnector, "get_vdc_details")
 560     @mock.patch.object(vimconnector, "perform_request")
 561     @mock.patch.object(VApp, "get_all_vms")
 562     def test_refresh_vms_status(
 563         self,
 564         get_all_vms,
 565         perform_request,
 566         get_vdc_details,
 567         get_namebyvappid,
 568         connect,
 569         get_vapp,
 570         get_vm_pci_details,
 571         get_network_id_by_name,
 572     ):
 573         """
 574         Testcase to refresh vms status by valid vm id
 575         """
 576         vm_id = "53a529b2-10d8-4d56-a7ad-8182acdbe71c"
 577
 578         # created vdc object
 579         vdc_xml_resp = xml_resp.vdc_xml_response
 580         vdc = lxmlElementTree.fromstring(vdc_xml_resp)
 581         # assumed return value from VIM connector
 582         self.vim.client = self.vim.connect()
 583         get_vdc_details.return_value = self.org, vdc
 584
 585         get_namebyvappid.return_value = "Test1_vm-69a18104-8413-4cb8-bad7-b5afaec6f9fa"
 586         get_vm_pci_details.return_value = {
 587             "host_name": "test-esx-1.corp.local",
 588             "host_ip": "12.19.24.31",
 589         }
 590         vapp_resp = xml_resp.vapp_xml_response
 591         vapp = lxmlElementTree.fromstring(vapp_resp)
 592         get_vapp.return_value = vapp
 593         get_network_id_by_name.return_value = "47d12505-5968-4e16-95a7-18743edb0c8b"
 594
 595         vm_resp = xml_resp.vm_xml_response
 596         vm_list = lxmlElementTree.fromstring(vm_resp)
 597         get_all_vms.return_value = vm_list
 598
 599         perform_request.return_value.status_code = 200
 600         perform_request.return_value.content = vm_resp
 601         # call to VIM connector method
 602         result = self.vim.refresh_vms_status([vm_id])
 603         for attr in result[vm_id]:
 604             if attr == "status":
 605                 # assert verified expected and return result from VIM connector
 606                 self.assertEqual(result[vm_id][attr], "ACTIVE")
 607
 608     @mock.patch.object(vimconnector, "get_vcd_network")
 609     def test_refresh_nets_status(self, get_vcd_network):
 610         net_id = "c2d0f28f-d38b-4588-aecc-88af3d4af58b"
 611         network_dict = {
 612             "status": "1",
 613             "isShared": "false",
 614             "IpScope": "",
 615             "EndAddress": "12.19.21.15",
 616             "name": "testing_gwyRXlvWYL1-9ebb6d7b-5c74-472f-be77-963ed050d44d",
 617             "Dns1": "12.19.21.10",
 618             "IpRanges": "",
 619             "Gateway": "12.19.21.23",
 620             "Netmask": "255.255.255.0",
 621             "RetainNetInfoAcrossDeployments": "false",
 622             "IpScopes": "",
 623             "IsEnabled": "true",
 624             "DnsSuffix": "corp.local",
 625             "StartAddress": "12.19.21.11",
 626             "IpRange": "",
 627             "Configuration": "",
 628             "FenceMode": "bridged",
 629             "IsInherited": "true",
 630             "uuid": "c2d0f28f-d38b-4588-aecc-88af3d4af58b",
 631         }
 632         # assumed return value from VIM connector
 633         get_vcd_network.return_value = network_dict
 634         result = self.vim.refresh_nets_status([net_id])
 635         # assert verified expected and return result from VIM connector
 636         for attr in result[net_id]:
 637             if attr == "status":
 638                 self.assertEqual(result[net_id][attr], "ACTIVE")
 639
 640     @mock.patch.object(VDC, "get_vapp")
 641     @mock.patch.object(vimconnector, "connect")
 642     @mock.patch.object(vimconnector, "get_namebyvappid")
 643     @mock.patch.object(vimconnector, "get_vdc_details")
 644     def test_action_vminstance(
 645         self, get_vdc_details, get_namebyvappid, connect, get_vapp
 646     ):
 647         """
 648         Testcase for action vm instance by vm id
 649         """
 650         # task_resp = xml_resp.poweroff_task_xml
 651         vm_id = "05e6047b-6938-4275-8940-22d1ea7245b8"
 652         # created vdc object
 653         vdc_xml_resp = xml_resp.vdc_xml_response
 654         vdc = lxmlElementTree.fromstring(vdc_xml_resp)
 655         # assumed return value from VIM connector
 656         get_vdc_details.return_value = self.org, vdc
 657         get_namebyvappid.return_value = "Test1_vm-69a18104-8413-4cb8-bad7-b5afaec6f9fa"
 658         self.vim.client = self.vim.connect()
 659         power_off_resp = xml_resp.poweroff_task_xml
 660         power_off = lxmlElementTree.fromstring(power_off_resp)
 661         get_vapp.return_value.undeploy.return_value = power_off
 662
 663         status_resp = xml_resp.status_task_xml
 664         status = lxmlElementTree.fromstring(status_resp)
 665         self.vim.connect.return_value.get_task_monitor.return_value.wait_for_success.return_value = (
 666             status
 667         )
 668
 669         # call to VIM connector method
 670         result = self.vim.action_vminstance(vm_id, {"shutdown": None})
 671
 672         # assert verified expected and return result from VIM connector
 673         self.assertEqual(result, vm_id)
 674
 675     @mock.patch.object(vimconnector, "get_org")
 676     def test_get_tenant_list(self, get_org):
 677         """
 678         Test case for get tenant list
 679         """
 680         org_dict = {
 681             "catalogs": {
 682                 "4c4fdb5d-0c7d-4fee-9efd-cb061f327a01": "80d8488f67ba1de98b7f485fba6abbd2",
 683                 "1b98ca02-b0a6-4ca7-babe-eadc0ae59677": "Ubuntu",
 684                 "e7f27dfe-14b7-49e1-918e-173bda02683a": "834bdd1f28fd15dcbe830456ec58fbca",
 685                 "9441ee69-0486-4438-ac62-8d8082c51302": "centos",
 686                 "e660cce0-47a6-4315-a5b9-97a39299a374": "cirros01",
 687                 "0fd96c61-c3d1-4abf-9a34-0dff8fb65743": "cirros034",
 688                 "1c703be3-9bd2-46a2-854c-3e678d5cdda8": "Ubuntu_plugtest-1",
 689                 "bc4e342b-f84c-41bd-a93a-480f35bacf69": "Cirros",
 690                 "8a206fb5-3ef9-4571-9bcc-137615f4d930": "255eb079a62ac155e7f942489f14b0c4",
 691             },
 692             "vdcs": {
 693                 "e6436c6a-d922-4b39-9c1c-b48e766fce5e": "osm",
 694                 "3852f762-18ae-4833-a229-42684b6e7373": "cloud-1-vdc",
 695             },
 696             "networks": {
 697                 "e203cacd-9320-4422-9be0-12c7def3ab56": "testing_lNejr37B-38e4ca67-1e26-486f-ad2f-f14bb099e068",
 698                 "a6623349-2bef-4367-9fda-d33f9ab927f8": "Vlan_3151",
 699                 "adf780cb-358c-47c2-858d-ae5778ccaf17": "testing_xwBultc-99b8a2ae-c091-4dd3-bbf7-762a51612385",
 700                 "721f9efc-11fe-4c13-936d-252ba0ed93c8": "testing_tLljy8WB5e-a898cb28-e75b-4867-a22e-f2bad285c144",
 701                 "1512d97a-929d-4b06-b8af-cf5ac42a2aee": "Managment",
 702                 "d9167301-28af-4b89-b9e0-09f612e962fa": "testing_prMW1VThk-063cb428-eaee-44b8-9d0d-df5fb77a5b4d",
 703                 "004ae853-f899-43fd-8981-7513a3b40d6b": "testing_RTtKVi09rld-fab00b16-7996-49af-8249-369c6bbfa02d",
 704             },
 705         }
 706         tenant_name = "osm"
 707         get_org.return_value = org_dict
 708
 709         # call to VIM connector method
 710         results = self.vim.get_tenant_list({"name": tenant_name})
 711         # assert verified expected and return result from VIM connector
 712         for result in results:
 713             self.assertEqual(tenant_name, result["name"])
 714
 715     @mock.patch.object(vimconnector, "get_org")
 716     def test_get_tenant_list_negative(self, get_org):
 717         """
 718         Test case for get tenant list negative
 719         """
 720         org_dict = {"vdcs": {}}
 721         tenant_name = "testosm"
 722         get_org.return_value = org_dict
 723
 724         # call to VIM connector method
 725         results = self.vim.get_tenant_list({"name": tenant_name})
 726         # assert verified expected and return result from VIM connector
 727         self.assertEqual(results, [])
 728
 729     @mock.patch.object(vimconnector, "create_vdc")
 730     def test_new_tenant(self, create_vdc):
 731         """
 732         Test case for create new tenant
 733         """
 734         tenant_name = "test"
 735         vdc = {
 736             "a493aa2c-3104-4d63-969b-fc9e72304c9f": "https://localhost/api/task/e658d84c-007d-4fd8-9590-3a8f93cc0de4"
 737         }
 738         create_vdc.return_value = vdc
 739
 740         # call to VIM connector method
 741         result = self.vim.new_tenant(tenant_name)
 742         # assert verified expected and return result from VIM connector
 743         self.assertEqual("a493aa2c-3104-4d63-969b-fc9e72304c9f", result)
 744
 745     @mock.patch.object(vimconnector, "create_vdc")
 746     def test_new_tenant_negative(self, create_vdc):
 747         """
 748         Test case for create new tenant
 749         """
 750         tenant_name = "test"
 751         create_vdc.return_value = None
 752
 753         # assert verified expected and return result from VIM connector
 754         self.assertRaises(VimConnException, self.vim.new_tenant, tenant_name)
 755
 756     @mock.patch.object(vimconnector, "connect_as_admin")
 757     @mock.patch.object(vimconnector, "connect")
 758     @mock.patch.object(vimconnector, "perform_request")
 759     def test_delete_tenant(self, perform_request, connect, connect_as_admin):
 760         """
 761         Test case to delete tenant
 762         """
 763         tenant_id = "753227f5-d6c6-4478-9546-acc5cfff21e9"
 764         delete_tenant_resp = xml_resp.delete_tenant
 765
 766         self.vim.client = self.vim.connect()
 767         perform_request.side_effect = [
 768             mock.Mock(status_code=200, content=delete_tenant_resp),
 769             mock.Mock(status_code=202, content=None),
 770         ]
 771
 772         # call to VIM connector method
 773         result = self.vim.delete_tenant(tenant_id)
 774         # assert verified expected and return result from VIM connector
 775         self.assertEqual(tenant_id, result)
 776
 777     @mock.patch.object(vimconnector, "connect_as_admin")
 778     @mock.patch.object(vimconnector, "connect")
 779     @mock.patch.object(vimconnector, "perform_request")
 780     def test_delete_tenant_negative(self, perform_request, connect, connect_as_admin):
 781         """
 782         Test case to delete tenant
 783         """
 784         tenant_id = "ten45klsjdf"
 785
 786         self.vim.client = self.vim.connect()
 787         perform_request.return_value.status_code = 201
 788
 789         # assert verified expected and return result from VIM connector
 790         self.assertRaises(VimConnNotFoundException, self.vim.delete_tenant, tenant_id)
 791
 792     @mock.patch.object(vimconnector, "get_vdc_details")
 793     @mock.patch.object(Org, "list_catalogs")
 794     @mock.patch.object(vimconnector, "get_vcd_network")
 795     @mock.patch.object(Org, "get_vdc")
 796     @mock.patch.object(Org, "get_catalog_item")
 797     @mock.patch.object(vimconnector, "connect")
 798     @mock.patch.object(vimconnector, "perform_request")
 799     @mock.patch.object(Client, "get_task_monitor")
 800     @mock.patch.object(VDC, "get_vapp")
 801     @mock.patch.object(vimconnector, "get_network_list")
 802     @mock.patch.object(vimconnector, "power_on_vapp")
 803     def test_new_vminstance(
 804         self,
 805         power_on,
 806         get_network_list,
 807         get_vapp,
 808         get_task_monitor,
 809         perform_request,
 810         connect,
 811         get_catalog_item,
 812         get_vdc,
 813         get_vcd_network,
 814         list_catalogs,
 815         get_vdc_details,
 816     ):
 817         """
 818         Test case for new vm instance
 819         """
 820         image_id = "34925a30-0f4a-4018-9759-0d6799063b51"
 821         vimconnector.flavorlist = {
 822             "123347db-536b-4936-8b62-1fcdc721865d": {
 823                 "vcpus": 1,
 824                 "disk": 10,
 825                 "ram": 1024,
 826             }
 827         }
 828
 829         flavor_id = "123347db-536b-4936-8b62-1fcdc721865d"
 830         net_list = [
 831             {
 832                 "use": "bridge",
 833                 "name": "eth0",
 834                 "floating_ip": False,
 835                 "vpci": "0000:00:11.0",
 836                 "port_security": True,
 837                 "type": "virtual",
 838                 "net_id": "69c713cb-3eec-452c-9a32-0e95c8ffe567",
 839             }
 840         ]
 841
 842         cat_list = [
 843             {
 844                 "isShared": "false",
 845                 "numberOfVAppTemplates": "1",
 846                 "orgName": "Org3",
 847                 "isPublished": "false",
 848                 "ownerName": "system",
 849                 "numberOfMedia": "0",
 850                 "creationDate": "2017-10-15T02:03:59.403-07:00",
 851                 "id": "34925a30-0f4a-4018-9759-0d6799063b51",
 852                 "name": "Ubuntu_1nic",
 853             }
 854         ]
 855
 856         network_dict = {
 857             "status": "1",
 858             "isShared": "false",
 859             "IpScope": "",
 860             "EndAddress": "192.169.241.150",
 861             "name": "testing_6n5mJwUyx-ad9d62fc-8223-4dbe-88c4-9f16458ebeec",
 862             "Dns1": "192.169.241.102",
 863             "IpRanges": "",
 864             "Gateway": "192.169.241.253",
 865             "Netmask": "255.255.255.0",
 866             "RetainNetInfoAcrossDeployments": "false",
 867             "IpScopes": "",
 868             "IsEnabled": "true",
 869             "DnsSuffix": "corp.local",
 870             "StartAddress": "192.169.241.115",
 871             "IpRange": "",
 872             "Configuration": "",
 873             "FenceMode": "bridged",
 874             "IsInherited": "true",
 875             "uuid": "69c713cb-3eec-452c-9a32-0e95c8ffe567",
 876         }
 877
 878         network_list = [
 879             {
 880                 "status": "ACTIVE",
 881                 "name": "default",
 882                 "admin_state_up": True,
 883                 "shared": False,
 884                 "tenant_id": "2584137f-6541-4c04-a2a2-e56bfca14c69",
 885                 "type": "bridge",
 886                 "id": "1fd6421e-929a-4576-bc19-a0c48aea1969",
 887             }
 888         ]
 889
 890         # created vdc object
 891         vdc_xml_resp = xml_resp.vdc_xml_response
 892         vdc = lxmlElementTree.fromstring(vdc_xml_resp)
 893
 894         catalog_list = lxmlElementTree.fromstring(xml_resp.catalog_list_xml)
 895         # assumed return value from VIM connector
 896         get_vdc_details.return_value = self.org, vdc
 897         list_catalogs.return_value = cat_list
 898         get_vcd_network.return_value = network_dict
 899         get_vdc.return_value = vdc
 900         get_catalog_item.return_value = catalog_list
 901         self.vim.client = self.vim.connect()
 902         perform_request.side_effect = [
 903             mock.Mock(status_code=200, content=xml_resp.catalogItem_xml),
 904             mock.Mock(status_code=200, content=xml_resp.vapp_template_xml),
 905             mock.Mock(status_code=201, content=xml_resp.deployed_vapp_xml),
 906         ]
 907
 908         status_resp = xml_resp.status_task_xml
 909         status = lxmlElementTree.fromstring(status_resp)
 910         self.vim.connect.return_value.get_task_monitor.return_value.wait_for_success.return_value = (
 911             status
 912         )
 913         vapp_resp = xml_resp.vapp_xml_response
 914         vapp = lxmlElementTree.fromstring(vapp_resp)
 915         get_vapp.return_value = vapp
 916         get_network_list.return_value = network_list
 917         power_on_resp = xml_resp.poweroff_task_xml
 918         poweron = lxmlElementTree.fromstring(power_on_resp)
 919         power_on.return_value = poweron
 920
 921         # call to VIM connector method
 922         result = self.vim.new_vminstance(
 923             name="Test1_vm", image_id=image_id, flavor_id=flavor_id, net_list=net_list
 924         )
 925         # assert verified expected and return result from VIM connector
 926         self.assertIsNotNone(result)
 927
 928     @mock.patch.object(vimconnector, "get_vdc_details")
 929     @mock.patch.object(Org, "list_catalogs")
 930     @mock.patch.object(vimconnector, "get_vcd_network")
 931     @mock.patch.object(Org, "get_vdc")
 932     @mock.patch.object(Org, "get_catalog_item")
 933     @mock.patch.object(vimconnector, "connect")
 934     @mock.patch.object(vimconnector, "perform_request")
 935     @mock.patch.object(Client, "get_task_monitor")
 936     @mock.patch.object(VDC, "get_vapp")
 937     @mock.patch.object(vimconnector, "get_network_list")
 938     @mock.patch.object(vimconnector, "power_on_vapp")
 939     def test_new_vminstance_negative(
 940         self,
 941         power_on,
 942         get_network_list,
 943         get_vapp,
 944         get_task_monitor,
 945         perform_request,
 946         connect,
 947         get_catalog_item,
 948         get_vdc,
 949         get_vcd_network,
 950         list_catalogs,
 951         get_vdc_details,
 952     ):
 953         """
 954         Test case for new vm instance
 955         """
 956         image_id = "34925a30-0f4a-4018-9759-0d6799063b51"
 957         vimconnector.flavorlist = {
 958             "123347db-536b-4936-8b62-1fcdc721865d": {
 959                 "vcpus": 1,
 960                 "disk": 10,
 961                 "ram": 1024,
 962             }
 963         }
 964         flavor_id = "123347db-536b-4936-8b62-1fcdc721865d"
 965         net_list = [
 966             {
 967                 "use": "bridge",
 968                 "name": "eth0",
 969                 "floating_ip": False,
 970                 "vpci": "0000:00:11.0",
 971                 "port_security": True,
 972                 "type": "virtual",
 973                 "net_id": "69c713cb-3eec-452c-9a32-0e95c8ffe567",
 974             }
 975         ]
 976
 977         cat_list = [
 978             {
 979                 "isShared": "false",
 980                 "numberOfVAppTemplates": "1",
 981                 "orgName": "Org3",
 982                 "isPublished": "false",
 983                 "ownerName": "system",
 984                 "numberOfMedia": "0",
 985                 "creationDate": "2017-10-15T02:03:59.403-07:00",
 986                 "id": "34925a30-0f4a-4018-9759-0d6799063b51",
 987                 "name": "Ubuntu_1nic",
 988             }
 989         ]
 990
 991         network_dict = {
 992             "status": "1",
 993             "isShared": "false",
 994             "IpScope": "",
 995             "EndAddress": "192.169.241.150",
 996             "name": "testing_6n5mJwUyx-ad9d62fc-8223-4dbe-88c4-9f16458ebeec",
 997             "Dns1": "192.169.241.102",
 998             "IpRanges": "",
 999             "Gateway": "192.169.241.253",
1000             "Netmask": "255.255.255.0",
1001             "RetainNetInfoAcrossDeployments": "false",
1002             "IpScopes": "",
1003             "IsEnabled": "true",
1004             "DnsSuffix": "corp.local",
1005             "StartAddress": "192.169.241.115",
1006             "IpRange": "",
1007             "Configuration": "",
1008             "FenceMode": "bridged",
1009             "IsInherited": "true",
1010             "uuid": "69c713cb-3eec-452c-9a32-0e95c8ffe567",
1011         }
1012
1013         # created vdc object
1014         vdc_xml_resp = xml_resp.vdc_xml_response
1015         vdc = lxmlElementTree.fromstring(vdc_xml_resp)
1016
1017         catalog_list = lxmlElementTree.fromstring(xml_resp.catalog_list_xml)
1018         # assumed return value from VIM connector
1019         get_vdc_details.return_value = self.org, vdc
1020         list_catalogs.return_value = cat_list
1021         get_vcd_network.return_value = network_dict
1022         get_vdc.return_value = vdc
1023         get_catalog_item.return_value = catalog_list
1024         self.vim.client = self.vim.connect()
1025         perform_request.side_effect = [
1026             mock.Mock(status_code=200, content=xml_resp.catalogItem_xml),
1027             mock.Mock(status_code=200, content=xml_resp.vapp_template_xml),
1028             mock.Mock(status_code=400, content="Bad request error"),
1029         ]
1030
1031         # call to VIM connector method
1032         self.assertRaises(
1033             VimConnUnexpectedResponse,
1034             self.vim.new_vminstance,
1035             name="Test1_vm",
1036             image_id=image_id,
1037             flavor_id=flavor_id,
1038             net_list=net_list,
1039         )
1040
1041     @mock.patch.object(vimconnector, "get_catalogid")
1042     @mock.patch.object(vimconnector, "upload_vimimage")
1043     @mock.patch.object(Org, "create_catalog")
1044     @mock.patch.object(Org, "list_catalogs")
1045     @mock.patch.object(vimconnector, "get_vdc_details")
1046     @mock.patch.object(path, "isfile")
1047     @mock.patch.object(os, "access")
1048     def test_new_image(
1049         self,
1050         access,
1051         isfile,
1052         get_vdc_details,
1053         list_catalogs,
1054         create_catalog,
1055         upload_vimimage,
1056         get_catalogid,
1057     ):
1058         """
1059         Test case for create new image
1060         """
1061         path = "/tmp/cirros/cirros.ovf"
1062         cat_list = [
1063             {
1064                 "isShared": "false",
1065                 "numberOfVAppTemplates": "1",
1066                 "orgName": "Org3",
1067                 "isPublished": "false",
1068                 "ownerName": "system",
1069                 "numberOfMedia": "0",
1070                 "creationDate": "2017-10-15T02:03:59.403-07:00",
1071                 "id": "9759-0d6799063b51",
1072                 "name": "cirros",
1073             }
1074         ]
1075         # created vdc object
1076         vdc_xml_resp = xml_resp.vdc_xml_response
1077         vdc = lxmlElementTree.fromstring(vdc_xml_resp)
1078
1079         catalog = lxmlElementTree.fromstring(xml_resp.catalog1_xml_response)
1080
1081         # assumed return value from VIM connector
1082         isfile.return_value = True
1083         access.return_value = True
1084         get_vdc_details.return_value = self.org, vdc
1085         list_catalogs.return_value = cat_list
1086         create_catalog.return_value = catalog
1087         upload_vimimage.return_value = True
1088         get_catalogid.return_value = "9759-0d6799063b51"
1089         result = self.vim.new_image({"name": "TestImage", "location": path})
1090
1091         # assert verified expected and return result from VIM connector
1092         self.assertIsNotNone(result)
1093
1094     @mock.patch.object(vimconnector, "get_catalogid")
1095     @mock.patch.object(vimconnector, "upload_vimimage")
1096     @mock.patch.object(Org, "create_catalog")
1097     @mock.patch.object(Org, "list_catalogs")
1098     @mock.patch.object(vimconnector, "get_vdc_details")
1099     def test_new_image_negative(
1100         self,
1101         get_vdc_details,
1102         list_catalogs,
1103         create_catalog,
1104         upload_vimimage,
1105         get_catalogid,
1106     ):
1107         """
1108         Test case for create new image with negative scenario
1109         """
1110         path = "/tmp/cirros/cirros.ovf"
1111         cat_list = [
1112             {
1113                 "isShared": "false",
1114                 "numberOfVAppTemplates": "1",
1115                 "orgName": "Org1",
1116                 "ownerName": "system",
1117                 "numberOfMedia": "0",
1118                 "creationDate": "2017-10-15",
1119                 "id": "34925a30-0f4a-4018-9759-0d6799063b51",
1120                 "name": "test",
1121             }
1122         ]
1123         # created vdc object
1124         vdc_xml_resp = xml_resp.vdc_xml_response
1125         vdc = lxmlElementTree.fromstring(vdc_xml_resp)
1126
1127         catalog = lxmlElementTree.fromstring(xml_resp.catalog1_xml_response)
1128
1129         # assumed return value from VIM connector
1130         get_vdc_details.return_value = self.org, vdc
1131         list_catalogs.return_value = cat_list
1132         create_catalog.return_value = catalog
1133         upload_vimimage.return_value = False
1134         get_catalogid.return_value = "34925a30-0f4a-4018-9759-0d6799063b51"
1135
1136         # assert verified expected and return result from VIM connector
1137         self.assertRaises(
1138             VimConnException,
1139             self.vim.new_image,
1140             {"name": "TestImage", "location": path},
1141         )
1142
1143     @mock.patch.object(vimconnector, "connect_as_admin")
1144     @mock.patch.object(vimconnector, "perform_request")
1145     def test_delete_image(self, perform_request, connect_as_admin):
1146         """
1147         Testcase to delete image by image id
1148         """
1149         image_id = "f3bf3733-465b-419f-b675-52f91d18edbb"
1150         # creating conn object
1151         self.vim.client = self.vim.connect_as_admin()
1152
1153         # assumed return value from VIM connector
1154         perform_request.side_effect = [
1155             mock.Mock(status_code=200, content=xml_resp.delete_catalog_xml_response),
1156             mock.Mock(
1157                 status_code=200, content=xml_resp.delete_catalog_item_xml_response
1158             ),
1159             mock.Mock(status_code=204, content=""),
1160             mock.Mock(status_code=204, content=""),
1161         ]
1162
1163         # call to vim connctor method
1164         result = self.vim.delete_image(image_id)
1165         # assert verified expected and return result from VIM connector
1166         self.assertEqual(image_id, result)
1167
1168     @mock.patch.object(vimconnector, "get_catalogid")
1169     @mock.patch.object(vimconnector, "upload_vimimage")
1170     @mock.patch.object(Org, "create_catalog")
1171     @mock.patch.object(Org, "list_catalogs")
1172     @mock.patch.object(vimconnector, "get_vdc_details")
1173     @mock.patch.object(path, "isfile")
1174     @mock.patch.object(os, "access")
1175     def test_get_image_id_from_path(
1176         self,
1177         access,
1178         isfile,
1179         get_vdc_details,
1180         list_catalogs,
1181         create_catalog,
1182         upload_vimimage,
1183         get_catalogid,
1184     ):
1185         """
1186         Test case to get image id from image path
1187         """
1188         path = "/tmp/ubuntu/ubuntu.ovf"
1189         cat_list = [
1190             {
1191                 "isShared": "false",
1192                 "numberOfVAppTemplates": "1",
1193                 "orgName": "Org3",
1194                 "isPublished": "false",
1195                 "ownerName": "system",
1196                 "numberOfMedia": "0",
1197                 "creationDate": "2017-10-15T02:03:59.403-07:00",
1198                 "id": "7208-0f6777052c30",
1199                 "name": "ubuntu",
1200             }
1201         ]
1202
1203         # created vdc object
1204         vdc_xml_resp = xml_resp.vdc_xml_response
1205         vdc = lxmlElementTree.fromstring(vdc_xml_resp)
1206
1207         catalog = lxmlElementTree.fromstring(xml_resp.catalog1_xml_response)
1208
1209         # assumed return value from VIM connector
1210         isfile.return_value = True
1211         access.return_value = True
1212         get_vdc_details.return_value = self.org, vdc
1213         list_catalogs.return_value = cat_list
1214         create_catalog.return_value = catalog
1215         upload_vimimage.return_value = True
1216         get_catalogid.return_value = "7208-0f6777052c30"
1217         result = self.vim.get_image_id_from_path(path=path)
1218
1219         # assert verified expected and return result from VIM connector
1220         self.assertIsNotNone(result)
1221
1222     @mock.patch.object(vimconnector, "get_catalogid")
1223     @mock.patch.object(vimconnector, "upload_vimimage")
1224     @mock.patch.object(Org, "create_catalog")
1225     @mock.patch.object(Org, "list_catalogs")
1226     @mock.patch.object(vimconnector, "get_vdc_details")
1227     @mock.patch.object(path, "isfile")
1228     @mock.patch.object(os, "access")
1229     def test_get_image_id_from_path_negative(
1230         self,
1231         access,
1232         isfile,
1233         get_vdc_details,
1234         list_catalogs,
1235         create_catalog,
1236         upload_vimimage,
1237         get_catalogid,
1238     ):
1239         """
1240         Test case to get image id from image path with negative scenario
1241         """
1242         path = "/tmp/ubuntu/ubuntu.ovf"
1243         cat_list = [
1244             {
1245                 "isShared": "false",
1246                 "numberOfVAppTemplates": "1",
1247                 "orgName": "Org3",
1248                 "isPublished": "false",
1249                 "ownerName": "system",
1250                 "numberOfMedia": "0",
1251                 "creationDate": "2017-10-15T02:03:59.403-07:00",
1252                 "id": "7208-0f6777052c30",
1253                 "name": "ubuntu",
1254             }
1255         ]
1256
1257         # created vdc object
1258         vdc_xml_resp = xml_resp.vdc_xml_response
1259         vdc = lxmlElementTree.fromstring(vdc_xml_resp)
1260
1261         catalog = lxmlElementTree.fromstring(xml_resp.catalog1_xml_response)
1262
1263         # assumed return value from VIM connector
1264         isfile.return_value = True
1265         access.return_value = True
1266         get_vdc_details.return_value = self.org, vdc
1267         list_catalogs.return_value = cat_list
1268         create_catalog.return_value = catalog
1269         upload_vimimage.return_value = False
1270         get_catalogid.return_value = "7208-0f6777052c30"
1271         self.assertRaises(VimConnException, self.vim.get_image_id_from_path, path)
1272
1273     @mock.patch.object(vimconnector, "get_vdc_details")
1274     @mock.patch.object(vimconnector, "connect")
1275     @mock.patch.object(Org, "list_catalogs")
1276     def test_get_image_list_negative(self, list_catalogs, connect, get_vdc_details):
1277         """
1278         Testcase to get image list by invalid image id
1279         """
1280         # created vdc object
1281         vdc_xml_resp = xml_resp.vdc_xml_response
1282         vdc = lxmlElementTree.fromstring(vdc_xml_resp)
1283         self.vim.client = self.vim.connect()
1284
1285         # assumed return value from VIM connector
1286         get_vdc_details.return_value = self.org, vdc
1287         list_catalogs.return_value = [
1288             {
1289                 "isShared": "false",
1290                 "numberOfVAppTemplates": "1",
1291                 "orgName": "Org3",
1292                 "isPublished": "false",
1293                 "ownerName": "system",
1294                 "numberOfMedia": "0",
1295                 "creationDate": "2017-10-15T02:03:59.403-07:00",
1296                 "id": "34925a30-0f4a-4018-9759-0d6799063b51",
1297                 "name": "Ubuntu_1nic",
1298             },
1299             {
1300                 "isShared": "false",
1301                 "numberOfVAppTemplates": "1",
1302                 "orgName": "Org3",
1303                 "isPublished": "false",
1304                 "ownerName": "orgadmin",
1305                 "numberOfMedia": "1",
1306                 "creationDate": "2018-02-15T02:16:58.300-08:00",
1307                 "id": "4b94b67e-c2c6-49ec-b46c-3f35ba45ca4a",
1308                 "name": "cirros034",
1309             },
1310         ]
1311
1312         # call to vim connector method with invalid image id
1313         self.vim.get_image_list({"id": "b46c-3f35ba45ca4a"})
1314
1315     @mock.patch.object(vimconnector, "get_vapp_details_rest")
1316     @mock.patch.object(vimconnector, "get_vdc_details")
1317     def test_get_vminstance_negative(self, get_vdc_details, get_vapp_details_rest):
1318         """
1319         Testcase to get vminstance by invalid vm id
1320         """
1321
1322         invalid_vmid = "18743edb0c8b-sdfsf-fg"
1323         # created vdc object
1324         vdc_xml_resp = xml_resp.vdc_xml_response
1325         vdc = lxmlElementTree.fromstring(vdc_xml_resp)
1326         # assumed return value from VIM connector
1327         get_vdc_details.return_value = self.org, vdc
1328         get_vapp_details_rest.return_value = False
1329
1330         # assert verified expected and return result from VIM connector
1331         self.assertRaises(
1332             VimConnNotFoundException, self.vim.get_vminstance, invalid_vmid
1333         )
1334
1335     @mock.patch.object(vimconnector, "connect")
1336     @mock.patch.object(vimconnector, "get_namebyvappid")
1337     @mock.patch.object(vimconnector, "get_vdc_details")
1338     @mock.patch.object(VDC, "get_vapp")
1339     def test_delete_vminstance_negative(
1340         self, get_vapp, get_vdc_details, get_namebyvappid, connect
1341     ):
1342         """
1343         Testcase to delete vminstance by invalid vm id
1344         """
1345         vm_id = "sdfrtt4935-87a1-0e4dc9c3a069"
1346         vm_name = "Test1_vm-69a18104-8413-4cb8-bad7-b5afaec6f9fa"
1347         # created vdc object
1348         vdc_xml_resp = xml_resp.vdc_xml_response
1349         vdc = lxmlElementTree.fromstring(vdc_xml_resp)
1350
1351         # assumed return value from VIM connector
1352         self.vim.client = self.vim.connect()
1353         get_vdc_details.return_value = self.org, vdc
1354         get_namebyvappid.return_name = vm_name
1355
1356         get_vapp.return_value = None
1357
1358         # call to VIM connector method
1359         self.assertRaises(VimConnException, self.vim.delete_vminstance, vm_id)
1360
1361     @mock.patch.object(vimconnector, "get_vcd_network")
1362     def test_refresh_nets_status_negative(self, get_vcd_network):
1363         """
1364         Testcase for refresh nets status by invalid vm id
1365         """
1366         net_id = "sjkldf-456mfd-345"
1367
1368         # assumed return value from VIM connector
1369         get_vcd_network.return_value = None
1370         result = self.vim.refresh_nets_status([net_id])
1371
1372         # assert verified expected and return result from VIM connector
1373         for attr in result[net_id]:
1374             if attr == "status":
1375                 self.assertEqual(result[net_id][attr], "DELETED")
1376
1377     @mock.patch.object(vimconnector, "connect")
1378     @mock.patch.object(vimconnector, "get_namebyvappid")
1379     @mock.patch.object(vimconnector, "get_vdc_details")
1380     def test_action_vminstance_negative(
1381         self, get_vdc_details, get_namebyvappid, connect
1382     ):
1383         """
1384         Testcase for action vm instance by invalid action
1385         """
1386         vm_id = "8413-4cb8-bad7-b5afaec6f9fa"
1387         # created vdc object
1388         vdc_xml_resp = xml_resp.vdc_xml_response
1389         vdc = lxmlElementTree.fromstring(vdc_xml_resp)
1390         # assumed return value from VIM connector
1391         get_vdc_details.return_value = self.org, vdc
1392         get_namebyvappid.return_value = "Test1_vm-69a18104-8413-4cb8-bad7-b5afaec6f9fa"
1393         self.vim.client = self.vim.connect()
1394
1395         # call to VIM connector method
1396         self.assertRaises(
1397             VimConnException, self.vim.action_vminstance, vm_id, {"invalid": None}
1398         )