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