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