osm_ro/tests/test_vimconn_vmware.py

   1 # -*- coding: utf-8 -*-
   2
   3 ##
   4 # Copyright 2016-2017 VMware Inc.
   5 # This file is part of ETSI OSM
   6 # All Rights Reserved.
   7 #
   8 # Licensed under the Apache License, Version 2.0 (the "License"); you may
   9 # not use this file except in compliance with the License. You may obtain
  10 # a copy of the License at
  11 #
  12 #         http://www.apache.org/licenses/LICENSE-2.0
  13 #
  14 # Unless required by applicable law or agreed to in writing, software
  15 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  16 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  17 # License for the specific language governing permissions and limitations
  18 # under the License.
  19 #
  20 # For those usages not covered by the Apache License, Version 2.0 please
  21 # contact:  osslegalrouting@vmware.com
  22 ##
  23
  24
  25 from osm_ro.vimconn_vmware import vimconnector
  26 from osm_ro.vimconn import vimconnUnexpectedResponse,vimconnNotFoundException
  27 from pyvcloud.vcloudair import VCA,VCS
  28 from pyvcloud.vapp import VAPP
  29 from pyvcloud import Http
  30 from pyvcloud.schema.vcd.v1_5.schemas.vcloud import vdcType,networkType,catalogType, \
  31                                                     vAppType,taskType
  32 import unittest
  33 import mock
  34 import test_vimconn_vmware_xml_response as xml_resp
  35
  36 class TestVimconn_VMware(unittest.TestCase):
  37     def setUp(self):
  38         config = { "admin_password": "admin",
  39                   "admin_username":"user",
  40                   "nsx_user": "nsx",
  41                   "nsx_password": "nsx",
  42                   "nsx_manager":"https://test-nsx" }
  43
  44         self.vca = VCA(host='test',
  45                        username='user',
  46                        service_type='standalone',
  47                        version='5.9',
  48                        verify=False,
  49                        log=False)
  50
  51         self.session = VCS('https://test/api/session',
  52                                                'test',
  53                                                'test',
  54                                                  None,
  55                           'https://test/api/org/a93c',
  56                           'https://test/api/org/a93c',
  57                                         version='5.9')
  58
  59         self.vim = vimconnector(uuid='12354',
  60                                  name='test',
  61                          tenant_id='abc1234',
  62                           tenant_name='test',
  63                           url='https://test',
  64                                config=config)
  65
  66
  67     @mock.patch.object(vimconnector,'get_vdc_details')
  68     @mock.patch.object(vimconnector,'connect')
  69     @mock.patch.object(VCA,'get_networks')
  70     def test_get_network_not_found(self,get_networks, connect, get_vdc_details):
  71         vdc_xml_resp = xml_resp.vdc_xml_response
  72         # created vdc object
  73         vdc = vdcType.parseString(vdc_xml_resp,True)
  74         # assumed return value from VIM connector
  75         get_vdc_details.return_value = vdc
  76         self.vim.vca = self.vim.connect()
  77         network_xml_resp = xml_resp.network_xml_response
  78         networks = networkType.parseString(network_xml_resp, True)
  79         (self.vim.vca).get_networks.return_value = [networks]
  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,'get_vdc_details')
  84     @mock.patch.object(vimconnector,'connect')
  85     @mock.patch.object(VCA,'get_networks')
  86     def test_get_network(self,get_networks, connect, get_vdc_details):
  87         net_id = '5c04dc6d-6096-47c6-b72b-68f19013d491'
  88         vdc_xml_resp = xml_resp.vdc_xml_response
  89         # created vdc object
  90         vdc = vdcType.parseString(vdc_xml_resp,True)
  91         # created network object
  92         network_xml_resp = xml_resp.network_xml_response
  93         networks = networkType.parseString(network_xml_resp, True)
  94         # assumed return value from VIM connector
  95         get_vdc_details.return_value = vdc
  96         self.vim.vca = self.vim.connect()
  97         # assumed return value from VIM connector
  98         (self.vim.vca).get_networks.return_value = [networks]
  99         # call to VIM connector method with network_id
 100         result = self.vim.get_network(net_id)
 101         # assert verified expected and return result from VIM connector
 102         self.assertEqual(net_id, result['id'])
 103
 104     @mock.patch.object(vimconnector,'get_vdc_details')
 105     @mock.patch.object(vimconnector,'connect')
 106     @mock.patch.object(VCA,'get_networks')
 107     def test_get_network_list_not_found(self,get_networks, connect, get_vdc_details):
 108         vdc_xml_resp = xml_resp.vdc_xml_response
 109         # created vdc object
 110         vdc = vdcType.parseString(vdc_xml_resp,True)
 111         # assumed return value from VIM connector
 112         get_vdc_details.return_value = vdc
 113         self.vim.vca = self.vim.connect()
 114
 115         network_xml_resp = xml_resp.network_xml_response
 116         networks = networkType.parseString(network_xml_resp, True)
 117         (self.vim.vca).get_networks.return_value = [networks]
 118         # call to VIM connector method with network_id
 119         result = self.vim.get_network_list({'id':'45hdfg-345nb-345'})
 120
 121         # assert verified expected and return result from VIM connector
 122         self.assertEqual(list(), result)
 123
 124     @mock.patch.object(vimconnector,'get_vdc_details')
 125     @mock.patch.object(vimconnector,'connect')
 126     @mock.patch.object(VCA,'get_networks')
 127     def test_get_network_list(self,get_networks, connect, get_vdc_details):
 128         vdc_xml_resp = xml_resp.vdc_xml_response
 129         net_id = '5c04dc6d-6096-47c6-b72b-68f19013d491'
 130         vdc = vdcType.parseString(vdc_xml_resp,True)
 131         # created network object
 132         network_xml_resp = xml_resp.network_xml_response
 133         networks = networkType.parseString(network_xml_resp, True)
 134         # assumed return value from VIM connector
 135         get_vdc_details.return_value = vdc
 136         self.vim.vca = self.vim.connect()
 137         # assumed return value from VIM connector
 138         (self.vim.vca).get_networks.return_value = [networks]
 139
 140         # call to VIM connector method with network_id
 141         result = self.vim.get_network_list({'id': net_id})
 142         # assert verified expected and return result from VIM connector
 143         for item in result:
 144             self.assertEqual(item.get('id'), net_id)
 145             self.assertEqual(item.get('status'), 'ACTIVE')
 146             self.assertEqual(item.get('shared'), False)
 147
 148     @mock.patch.object(vimconnector,'create_network_rest')
 149     def test_new_network(self, create_network_rest):
 150         create_net_xml_resp = xml_resp.create_network_xml_response
 151         net_name = 'Test_network'
 152         net_type = 'bridge'
 153         # assumed return value from VIM connector
 154         create_network_rest.return_value = create_net_xml_resp
 155         # call to VIM connector method with network_id
 156         result = self.vim.new_network(net_name, net_type)
 157         # assert verified expected and return result from VIM connector
 158         self.assertEqual(result, 'df1956fa-da04-419e-a6a2-427b6f83788f')
 159
 160     @mock.patch.object(vimconnector, 'create_network_rest')
 161     def test_new_network_not_created(self, create_network_rest):
 162         # assumed return value from VIM connector
 163         create_network_rest.return_value = """<?xml version="1.0" encoding="UTF-8"?>
 164                                               <OrgVdcNetwork></OrgVdcNetwork>"""
 165
 166         # assert verified expected and return result from VIM connector
 167         self.assertRaises(vimconnUnexpectedResponse,self.vim.new_network,
 168                                                               'test_net',
 169                                                                 'bridge')
 170
 171     @mock.patch.object(vimconnector, 'connect')
 172     @mock.patch.object(vimconnector, 'get_network_action')
 173     @mock.patch.object(vimconnector, 'connect_as_admin')
 174     @mock.patch.object(vimconnector, 'delete_network_action')
 175     def test_delete_network(self, delete_network_action, connect_as_admin, get_network_action, connect):
 176         delete_net_xml_resp = xml_resp.delete_network_xml_response
 177         # assumed return value from VIM connector
 178         connect.return_value = self.vca
 179         self.vim.vca = self.vim.connect()
 180         get_network_action.return_value = delete_net_xml_resp
 181         connect_as_admin.return_value = self.vca
 182         delete_network_action.return_value = True
 183         # call to VIM connector method with network_id
 184         result = self.vim.delete_network('0a55e5d1-43a2-4688-bc92-cb304046bf87')
 185         # assert verified expected and return result from VIM connector
 186         self.assertEqual(result, '0a55e5d1-43a2-4688-bc92-cb304046bf87')
 187
 188     @mock.patch.object(vimconnector, 'get_vcd_network')
 189     def test_delete_network_not_found(self, get_vcd_network):
 190         # assumed return value from VIM connector
 191         get_vcd_network.return_value = False
 192         # assert verified expected and return result from VIM connector
 193         self.assertRaises(vimconnNotFoundException,self.vim.delete_network,
 194                                     '2a23e5d1-42a2-0648-bc92-cb508046bf87')
 195
 196     def test_get_flavor(self):
 197         flavor_data = {'a646eb8a-95bd-4e81-8321-5413ee72b62e': {'disk': 10,
 198                                                                 'vcpus': 1,
 199                                                                'ram': 1024}}
 200         vimconnector.flavorlist = flavor_data
 201         result = self.vim.get_flavor('a646eb8a-95bd-4e81-8321-5413ee72b62e')
 202         # assert verified expected and return result from VIM connector
 203         self.assertEqual(result, flavor_data['a646eb8a-95bd-4e81-8321-5413ee72b62e'])
 204
 205     def test_get_flavor_not_found(self):
 206         vimconnector.flavorlist = {}
 207         # assert verified expected and return result from VIM connector
 208         self.assertRaises(vimconnNotFoundException,self.vim.get_flavor,
 209                                 'a646eb8a-95bd-4e81-8321-5413ee72b62e')
 210
 211     def test_new_flavor(self):
 212         flavor_data = {'disk': 10, 'vcpus': 1, 'ram': 1024}
 213         result = self.vim.new_flavor(flavor_data)
 214         # assert verified expected and return result from VIM connector
 215         self.assertIsNotNone(result)
 216
 217     def test_delete_flavor(self):
 218         flavor_data = {'2cb3dffb-5c51-4355-8406-28553ead28ac': {'disk': 10,
 219                                                                 'vcpus': 1,
 220                                                                'ram': 1024}}
 221         vimconnector.flavorlist = flavor_data
 222         # return value from VIM connector
 223         result = self.vim.delete_flavor('2cb3dffb-5c51-4355-8406-28553ead28ac')
 224         # assert verified expected and return result from VIM connector
 225         self.assertEqual(result, '2cb3dffb-5c51-4355-8406-28553ead28ac')
 226
 227     @mock.patch.object(vimconnector,'connect_as_admin')
 228     @mock.patch.object(vimconnector,'connect')
 229     @mock.patch.object(Http,'get')
 230     @mock.patch.object(VCS,'get_vcloud_headers')
 231     def test_delete_image_not_found(self, get_vcloud_headers, get, connect, connect_as_admin):
 232         # assumed return value from VIM connector
 233         connect.return_value = self.vca
 234         self.vim.vca = self.vim.connect()
 235         # assumed return value from VIM connector
 236         connect_as_admin.return_value = self.vca
 237         self.vca.host = connect_as_admin.return_value.host
 238         self.vca.vcloud_session = self.session
 239         get_vcloud_headers.return_value = {'Accept':'application/*+xml;version=5.9',
 240                        'x-vcloud-authorization': '638bfee6cb5f435abc3480f480817254'}
 241         get_vcloud_headers.return_value = self.vca.vcloud_session.get_vcloud_headers()
 242         # assert verified expected and return result from VIM connector
 243         self.assertRaises(vimconnNotFoundException, self.vim.delete_image, 'invali3453')
 244
 245     @mock.patch.object(vimconnector,'connect')
 246     @mock.patch.object(VCA,'get_catalogs')
 247     def test_get_image_list(self, get_catalogs, connect):
 248         catalog1 = xml_resp.catalog1_xml_response
 249         catalog2 = xml_resp.catalog2_xml_response
 250
 251         catalogs = [catalogType.parseString(cat, True) for cat in catalog1, catalog2]
 252         connect.return_value = self.vca
 253         self.vim.vca = self.vim.connect()
 254         # assumed return value from VIM connector
 255         self.vim.vca.get_catalogs.return_value = catalogs
 256         result = self.vim.get_image_list({'id': '32ccb082-4a65-41f6-bcd6-38942e8a3829'})
 257         # assert verified expected and return result from VIM connector
 258         for item in result:
 259             self.assertEqual(item['id'], '32ccb082-4a65-41f6-bcd6-38942e8a3829')
 260
 261     @mock.patch.object(vimconnector,'get_vapp_details_rest')
 262     @mock.patch.object(vimconnector,'get_vdc_details')
 263     def test_get_vminstance(self, get_vdc_details, get_vapp_details_rest):
 264         vapp_info = {'status': '4',
 265                    'acquireMksTicket': {'href': 'https://localhost/api/vApp/vm-47d12505-5968-4e16-95a7-18743edb0c8b/screen/action/acquireMksTicket',
 266                    'type': 'application/vnd.vmware.vcloud.mksTicket+xml', 'rel': 'screen:acquireMksTicket'},
 267                    'vm_virtual_hardware': {'disk_edit_href': 'https://localhost/api/vApp/vm-47d12505-5968-4e16-95a7-18743edb0c8b/virtualHardwareSection/disks', 'disk_size': '40960'},
 268                    'name': 'Test1_vm-69a18104-8413-4cb8-bad7-b5afaec6f9fa',
 269                    'created': '2017-09-21T01:15:31.627-07:00',
 270                     'IsEnabled': 'true',
 271                    'EndAddress': '12.16.24.199',
 272                    'interfaces': [{'MACAddress': '00:50:56:01:12:a2',
 273                                    'NetworkConnectionIndex': '0',
 274                                    'network': 'testing_T6nODiW4-68f68d93-0350-4d86-b40b-6e74dedf994d',
 275                                    'IpAddressAllocationMode': 'DHCP',
 276                                    'IsConnected': 'true',
 277                                    'IpAddress': '12.16.24.200'}],
 278                    'ovfDescriptorUploaded': 'true',
 279                    'nestedHypervisorEnabled': 'false',
 280                    'Gateway': '12.16.24.1',
 281                    'acquireTicket': {'href': 'https://localhost/api/vApp/vm-47d12505-5968-4e16-95a7-18743edb0c8b/screen/action/acquireTicket',
 282                    'rel': 'screen:acquireTicket'},
 283                    'vmuuid': '47d12505-5968-4e16-95a7-18743edb0c8b',
 284                    'Netmask': '255.255.255.0',
 285                    'StartAddress': '12.16.24.100',
 286                    'primarynetwork': '0',
 287                    'networkname': 'External-Network-1074',
 288                    'IsInherited': 'false',
 289                    'deployed': 'true'}
 290         # created vdc object
 291         vdc_xml_resp = xml_resp.vdc_xml_response
 292         vdc = vdcType.parseString(vdc_xml_resp,True)
 293         # assumed return value from VIM connector
 294         get_vdc_details.return_value = vdc
 295         get_vapp_details_rest.return_value = vapp_info
 296
 297         result = self.vim.get_vminstance('47d12505-5968-4e16-95a7-18743edb0c8b')
 298         # assert verified expected and return result from VIM connector
 299         self.assertEqual(result['status'], 'ACTIVE')
 300         self.assertEqual(result['hostId'], '47d12505-5968-4e16-95a7-18743edb0c8b')
 301
 302     @mock.patch.object(VCA,'get_vapp')
 303     @mock.patch.object(vimconnector,'connect')
 304     @mock.patch.object(vimconnector,'get_namebyvappid')
 305     @mock.patch.object(vimconnector,'get_vdc_details')
 306     def test_delete_vminstance(self, get_vdc_details, get_namebyvappid, connect, vapp):
 307         vm_id = '4f6a9b49-e92d-4935-87a1-0e4dc9c3a069'
 308         vm_name = 'Test1_vm-69a18104-8413-4cb8-bad7-b5afaec6f9fa'
 309         # created vdc object
 310         vdc_xml_resp = xml_resp.vdc_xml_response
 311         vdc = vdcType.parseString(vdc_xml_resp,True)
 312         # assumed return value from VIM connector
 313         connect.return_value = self.vca
 314         self.vim.vca = self.vim.connect()
 315         get_namebyvappid.return_name = vm_name
 316         vapp.return_value = None
 317         # call to VIM connector method
 318         result = self.vim.delete_vminstance(vm_id)
 319         # assert verified expected and return result from VIM connector
 320         self.assertEqual(result, vm_id)
 321
 322     @mock.patch.object(vimconnector,'get_network_id_by_name')
 323     @mock.patch.object(vimconnector,'get_vm_pci_details')
 324     @mock.patch.object(VCA,'get_vapp')
 325     @mock.patch.object(vimconnector,'connect')
 326     @mock.patch.object(vimconnector,'get_namebyvappid')
 327     @mock.patch.object(vimconnector,'get_vdc_details')
 328     def test_refresh_vms_status(self, get_vdc_details, get_namebyvappid, connect,
 329                                                     get_vapp, get_vm_pci_details,
 330                                                          get_network_id_by_name):
 331         headers = {'Accept':'application/*+xml;version=5.9',
 332                        'x-vcloud-authorization': '638bfee6cb5f435abc3480f480817254'}
 333         vm_id = '05e6047b-6938-4275-8940-22d1ea7245b8'
 334
 335         vapp_resp = xml_resp.vapp_xml_response
 336         # created vdc object
 337         vdc_xml_resp = xml_resp.vdc_xml_response
 338         vdc = vdcType.parseString(vdc_xml_resp,True)
 339         # assumed return value from VIM connector
 340         get_vdc_details.return_value = vdc
 341         connect.return_value = self.vca
 342
 343         self.vim.vca = self.vim.connect()
 344         get_namebyvappid.return_value = 'Test1_vm-69a18104-8413-4cb8-bad7-b5afaec6f9fa'
 345         get_vm_pci_details.return_value = {'host_name': 'test-esx-1.corp.local', 'host_ip': '12.19.24.31'}
 346         get_vapp.return_value = VAPP(vAppType.parseString(vapp_resp, True), headers, False)
 347         get_network_id_by_name.return_value = '47d12505-5968-4e16-95a7-18743edb0c8b'
 348         # call to VIM connector method
 349         result = self.vim.refresh_vms_status([vm_id])
 350         for attr in result[vm_id]:
 351             if attr == 'status':
 352                 # assert verified expected and return result from VIM connector
 353                 self.assertEqual(result[vm_id][attr], 'ACTIVE')
 354
 355     @mock.patch.object(vimconnector,'get_vcd_network')
 356     def test_refresh_nets_status(self, get_vcd_network):
 357         net_id = 'c2d0f28f-d38b-4588-aecc-88af3d4af58b'
 358         network_dict = {'status': '1','isShared': 'false','IpScope': '',
 359                         'EndAddress':'12.19.21.15',
 360                         'name': 'testing_gwyRXlvWYL1-9ebb6d7b-5c74-472f-be77-963ed050d44d',
 361                         'Dns1': '12.19.21.10', 'IpRanges': '',
 362                         'Gateway': '12.19.21.23', 'Netmask': '255.255.255.0',
 363                         'RetainNetInfoAcrossDeployments': 'false',
 364                         'IpScopes': '', 'IsEnabled': 'true', 'DnsSuffix': 'corp.local',
 365                         'StartAddress': '12.19.21.11', 'IpRange': '',
 366                         'Configuration': '', 'FenceMode': 'bridged',
 367                         'IsInherited': 'true', 'uuid': 'c2d0f28f-d38b-4588-aecc-88af3d4af58b'}
 368         # assumed return value from VIM connector
 369         get_vcd_network.return_value = network_dict
 370         result = self.vim.refresh_nets_status([net_id])
 371         # assert verified expected and return result from VIM connector
 372         for attr in result[net_id]:
 373             if attr == 'status':
 374                 self.assertEqual(result[net_id][attr], 'ACTIVE')
 375
 376     @mock.patch.object(VCA,'block_until_completed')
 377     @mock.patch.object(VCA,'get_vapp')
 378     @mock.patch.object(vimconnector,'connect')
 379     @mock.patch.object(vimconnector,'get_namebyvappid')
 380     @mock.patch.object(vimconnector,'get_vdc_details')
 381     def test_action_vminstance(self, get_vdc_details, get_namebyvappid, connect, get_vapp, block):
 382         task_resp = xml_resp.task_xml
 383         vm_id = '05e6047b-6938-4275-8940-22d1ea7245b8'
 384         # created vdc object
 385         vdc_xml_resp = xml_resp.vdc_xml_response
 386         vdc = vdcType.parseString(vdc_xml_resp,True)
 387         # assumed return value from VIM connector
 388         get_vdc_details.return_value = vdc
 389         get_namebyvappid.return_value = 'Test1_vm-69a18104-8413-4cb8-bad7-b5afaec6f9fa'
 390         connect.return_value = self.vca
 391         self.vim.vca = self.vim.connect()
 392         get_vapp.return_value.undeploy.return_value = taskType.parseString(task_resp, True)
 393         block.return_value = True
 394         # call to VIM connector method
 395         result = self.vim.action_vminstance(vm_id,{'shutdown': None})
 396         # assert verified expected and return result from VIM connector
 397         self.assertEqual(result, None)