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 import os
  25 from os import path
  26 import unittest
  27 from unittest import mock
  28
  29 from lxml import etree as lxmlElementTree
  30 from osm_ro_plugin.vimconn import (
  31     VimConnException,
  32     VimConnNotFoundException,
  33     VimConnUnexpectedResponse,
  34 )
  35 from osm_rovim_vmware.vimconn_vmware import vimconnector
  36 from pyvcloud.vcd.client import Client
  37 from pyvcloud.vcd.org import Org
  38 from pyvcloud.vcd.vapp import VApp
  39 from pyvcloud.vcd.vdc import VDC
  40 import tests.test_vimconn_vmware_xml_response as xml_resp
  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         )