def test_9998_teardown(self): """Delete the vApp created during setup. This test passes if the task for deleting the vApp succeed. """ vapps_to_delete = [] if TestVM._test_vapp_href is not None: vapps_to_delete.append(TestVM._test_vapp_name) vapp = VApp(TestVM._client, href=TestVM._test_vapp_href) if vapp.is_powered_on(): task = vapp.power_off() TestVM._client.get_task_monitor().wait_for_success(task) task = vapp.undeploy() TestVM._client.get_task_monitor().wait_for_success(task) if TestVM._empty_vapp_href is not None: vapps_to_delete.append(TestVM._empty_vapp_name) if TestVM._test_vapp_vmtools_href is not None: vapps_to_delete.append(TestVM._test_vapp_vmtools_name) vapp = VApp(TestVM._client, href=TestVM._test_vapp_vmtools_href) if vapp.is_powered_on(): task = vapp.power_off() TestVM._client.get_task_monitor().wait_for_success(task) task = vapp.undeploy() TestVM._client.get_task_monitor().wait_for_success(task) vdc = Environment.get_test_vdc(TestVM._sys_admin_client) vdc.delete_disk(name=self._idisk_name) vdc = Environment.get_test_vdc(TestVM._client) for vapp_name in vapps_to_delete: task = vdc.delete_vapp(name=vapp_name, force=True) result = TestVM._client.get_task_monitor().wait_for_success(task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value)
def test_0160_move_to(self): org = Environment.get_test_org(TestVApp._client) target_vdc = org.get_vdc(TestVApp._ovdc_name) logger = Environment.get_default_logger() vapp = Environment.get_vapp_in_test_vdc( client=TestVApp._sys_admin_client, vapp_name=TestVApp._customized_vapp_name) logger.debug('Move vApp ' + TestVApp._customized_vapp_name) task = vapp.move_to(target_vdc.get('href')) result = TestVApp._sys_admin_client.get_task_monitor( ).wait_for_success(task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value) target_vdc = org.get_vdc(TestVApp._ovdc_name) target_vdc_obj = VDC(TestVApp._sys_admin_client, href=target_vdc.get('href')) vapp_resource = target_vdc_obj.get_vapp(TestVApp._customized_vapp_name) vapp = VApp(TestVApp._sys_admin_client, resource=vapp_resource) target_vdc = Environment.get_test_vdc(TestVApp._client) logger.debug('Move back vApp ' + TestVApp._customized_vapp_name) task = vapp.move_to(target_vdc.href) result = TestVApp._sys_admin_client.get_task_monitor( ).wait_for_success(task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value)
def test_0070_update_disk(self): """Test the method vapp.update_disk(). Invoke the method for the first independent disk, to update it's name, size and description. Revert the changes back once the test is over. This test passes if the updated disk's name, size and description matches the expected values. """ vdc = Environment.get_test_vdc(TestDisk._client) result = vdc.update_disk(name=self._idisk1_name, new_name=self._idisk1_new_name, new_size=self._idisk1_new_size, new_description=self._idisk1_new_description) task = TestDisk._client.get_task_monitor().wait_for_success( task=result) self.assertEqual(task.get('status'), TaskStatus.SUCCESS.value) disk = vdc.get_disk(name=self._idisk1_new_name) self.assertIsNotNone(disk) self.assertEqual(disk.get('size'), str(self._idisk1_new_size)) self.assertEqual(disk.Description, self._idisk1_new_description) # return disk 1 to original state result = vdc.update_disk(name=self._idisk1_new_name, new_name=self._idisk1_name, new_size=self._idisk1_size, new_description=self._idisk1_description) task = TestDisk._client.get_task_monitor().wait_for_success( task=result) self.assertEqual(task.get('status'), TaskStatus.SUCCESS.value)
def test_0060_detach_disk_from_vm_in_vapp(self): """Test the method vapp.detach_disk_to_vm(). Invoke the method for the second independent disk, to detach it from the default test vm available in the Environment. we need to power down the vm before running this test, and power it back on once the test is over. This test passes if the disk detachment task succeeds. """ org_admin_client = Environment.get_client_in_default_org( CommonRoles.ORGANIZATION_ADMINISTRATOR) vdc = Environment.get_test_vdc(org_admin_client) vapp = Environment.get_default_vapp(org_admin_client) vm_name = Environment.get_default_vm_name() disk = vdc.get_disk(disk_id=TestDisk._idisk2_id) try: # vm needs to be powered off for detach to succeed. self._power_off_vapp(org_admin_client, vapp) vapp.reload() result = vapp.detach_disk_from_vm(disk_href=disk.get('href'), vm_name=vm_name) task = org_admin_client.get_task_monitor().wait_for_success( task=result) self.assertEqual(task.get('status'), TaskStatus.SUCCESS.value) vapp.reload() # power on vapp after detaching disk is successful for sanity of # next test run. self._power_on_vapp(org_admin_client, vapp) finally: org_admin_client.logout()
def test_0150_copy_to(self): logger = Environment.get_default_logger() vapp = Environment.get_vapp_in_test_vdc( client=TestVApp._sys_admin_client, vapp_name=TestVApp._customized_vapp_name) vdc = Environment.get_test_vdc(TestVApp._client) logger.debug('Copy vApp ' + TestVApp._customized_vapp_name) task = vapp.copy_to(vdc.href, TestVApp._vapp_copy_name, None) result = TestVApp._sys_admin_client.get_task_monitor( ).wait_for_success(task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value) vdc = Environment.get_test_vdc(TestVApp._sys_admin_client) task = vdc.delete_vapp(name=TestVApp._vapp_copy_name, force=True) result = TestVApp._sys_admin_client.get_task_monitor( ).wait_for_success(task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value)
def test_9998_tearDown(self): """Delete the vApp created during setup. This test passes if the task for deleting the vApp succeed. """ vapps_to_delete = [] if VmTest._empty_vapp_href is not None: vapps_to_delete.append(VmTest._empty_vapp_name) vapp = VApp(VmTest._client, href=VmTest._test_old_vapp_href) self._power_off_and_undeploy(vapp=vapp) vapp = VApp(VmTest._client, href=VmTest._test_vapp_vmtools_href) self._power_off_and_undeploy(vapp=vapp) vapp = VApp(VmTest._client, href=VmTest._test_vapp_href) self._power_off_and_undeploy(vapp=vapp) vapps_to_delete.append(VmTest._vapp_name) vapps_to_delete.append(VmTest._test_vapp_vmtools_name) vapps_to_delete.append(VAppConstants.name) self._sys_login() vdc = Environment.get_test_vdc(VmTest._client) vdc.delete_disk(name=self._idisk_name) self._logout() self._login() for vapp_name in vapps_to_delete: task = vdc.delete_vapp(name=vapp_name, force=True) result = VmTest._client.get_task_monitor().wait_for_success(task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value)
def test_0000_setup(self): """Load configuration and create a click runner to invoke CLI.""" VAppTest._config = Environment.get_config() VAppTest._logger = Environment.get_default_logger() VAppTest._client = Environment.get_client_in_default_org( CommonRoles.ORGANIZATION_ADMINISTRATOR) VAppTest._sys_admin_client = Environment.get_sys_admin_client() VAppTest._runner = CliRunner() default_org = VAppTest._config['vcd']['default_org_name'] VAppTest._default_org = default_org VAppTest._login(self) VAppTest._runner.invoke(org, ['use', default_org]) VAppTest._test_vdc = Environment.get_test_vdc(VAppTest._client) VAppTest._test_vapp = create_vapp_from_template( VAppTest._client, VAppTest._test_vdc, VAppTest._test_vapp_name, VAppTest._config['vcd']['default_catalog_name'], VAppTest._config['vcd']['default_template_file_name'], power_on=False, deploy=False) VAppTest._catalog_name = VAppTest._config['vcd'][ 'default_catalog_name'] VAppTest._sys_admin_client = Environment.get_sys_admin_client() VAppTest._pvdc_name = Environment.get_test_pvdc_name() default_ovdc = VAppTest._config['vcd']['default_ovdc_name'] VAppTest._default_ovdc = default_ovdc
def test_0050_attach_disk_to_vm_in_vapp(self): """Test the method vapp.attach_disk_to_vm(). Invoke the method for the second independent disk, and attach it to the default test vm available in the Environment. This test passes if the disk attachment task succeeds. """ org_admin_client = Environment.get_client_in_default_org( CommonRoles.ORGANIZATION_ADMINISTRATOR) vdc = Environment.get_test_vdc(org_admin_client) vapp = Environment.get_default_vapp(org_admin_client) vm_name = Environment.get_default_vm_name() disk = vdc.get_disk(disk_id=TestDisk._idisk2_id) try: if vapp.is_suspended(): task = vapp.deploy() org_admin_client.get_task_monitor().wait_for_success(task=task) task = vapp.attach_disk_to_vm(disk_href=disk.get('href'), vm_name=vm_name) result = org_admin_client.get_task_monitor().wait_for_success( task=task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value) finally: org_admin_client.logout()
def __convert_to_subinterface(self, client): vdc = Environment.get_test_vdc(client) org_vdc_routed_nw = vdc.get_routed_orgvdc_network( TestNetwork._routed_org_vdc_network_name) vdc_network = VdcNetwork(client, resource=org_vdc_routed_nw) result = vdc_network.convert_to_sub_interface() task = TestNetwork._client.get_task_monitor().wait_for_success( task=result) self.assertEqual(task.get('status'), TaskStatus.SUCCESS.value) # Verify vdc_network.reload_admin() reloaded_vdc_network = vdc_network.admin_resource self.assertTrue(reloaded_vdc_network.Configuration.SubInterface) # Revert to Internal Interface result = vdc_network.convert_to_internal_interface() task = TestNetwork._client.get_task_monitor().wait_for_success( task=result) self.assertEqual(task.get('status'), TaskStatus.SUCCESS.value) # Verify vdc_network.reload_admin() reloaded_vdc_network = vdc_network.admin_resource self.assertFalse(reloaded_vdc_network.Configuration.SubInterface)
def test_0010_vm_setup(self): """Setup the vms required for the other tests in this module. Create a vApp with just one vm as per the configuration stated above. This test passes if the vApp and vm hrefs are not None. """ logger = Environment.get_default_logger() TestPVDC._org_client = Environment.get_client_in_default_org( TestPVDC._test_runner_role) vdc = Environment.get_test_vdc(TestPVDC._org_client) logger.debug('Creating vApp ' + TestPVDC._test_vapp_name + '.') TestPVDC._test_vapp_href = create_customized_vapp_from_template( client=TestPVDC._org_client, vdc=vdc, name=TestPVDC._test_vapp_name, catalog_name=Environment.get_default_catalog_name(), template_name=Environment.get_default_template_name(), memory_size=TestPVDC._test_vapp_first_vm_memory_size, num_cpu=TestPVDC._test_vapp_first_vm_num_cpu, disk_size=TestPVDC._test_vapp_first_vm_first_disk_size, vm_name=TestPVDC._test_vapp_first_vm_name, nw_adapter_type=TestPVDC._test_vapp_first_vm_network_adapter_type) self.assertIsNotNone(TestPVDC._test_vapp_href) vapp = VApp(TestPVDC._org_client, href=TestPVDC._test_vapp_href) vm_resource = vapp.get_vm(TestPVDC._test_vapp_first_vm_name) TestPVDC._test_vapp_first_vm_href = vm_resource.get('href') self.assertIsNotNone(TestPVDC._test_vapp_first_vm_href)
def test_0190_delete_direct_orgvdc_networks(self): vdc = Environment.get_test_vdc(TestNetwork._client) result = vdc.delete_direct_orgvdc_network( name=TestNetwork._test_direct_network_name, force=True) task = TestNetwork._client.get_task_monitor().wait_for_success( task=result) self.assertEqual(task.get('status'), TaskStatus.SUCCESS.value)
def test_0060_detach_disk_from_vm_in_vapp(self): """Test the method vapp.detach_disk_to_vm(). Invoke the method for the second independent disk, detach it from the first vm of the vApp created during setup. We need to power down the vm before running this test, and power it back on once the test is over. This test passes if the disk detachment task succeeds. """ vdc = Environment.get_test_vdc(TestDisk._client) vapp = VApp(TestDisk._client, href=TestDisk._test_vapp_href) vm_name = TestDisk._test_vapp_first_vm_name disk = vdc.get_disk(disk_id=TestDisk._idisk2_id) # vm needs to be powered off for detach to succeed. is_vapp_powered_on_before_test = vapp.is_powered_on() if is_vapp_powered_on_before_test: task = vapp.power_off() TestDisk._client.get_task_monitor().wait_for_success(task=task) vapp.reload() task = vapp.detach_disk_from_vm( disk_href=disk.get('href'), vm_name=vm_name) TestDisk._client.get_task_monitor().wait_for_success(task=task) vapp.reload() # restore vApp to powered on state (if required) if is_vapp_powered_on_before_test: task = vapp.power_on() TestDisk._client.get_task_monitor().wait_for_success(task=task)
def test_9998_teardown(self): """Test the method vapp.delete_disk(). Invoke the method for all the disks created by setup. Also delete the vApp created suring setup. This test passes if all the tasks for deleting the disks and vApp succeed. """ org_admin_client = Environment.get_client_in_default_org( CommonRoles.ORGANIZATION_ADMINISTRATOR) vdc = Environment.get_test_vdc(org_admin_client) try: disks_to_delete = [ TestDisk._idisk1_id, TestDisk._idisk2_id, TestDisk._idisk3_id ] for disk_id in disks_to_delete: if disk_id is not None: vdc.reload() task = vdc.delete_disk(disk_id=disk_id) org_admin_client.get_task_monitor()\ .wait_for_success(task=task) task = vdc.delete_vapp(name=TestDisk._test_vapp_name, force=True) org_admin_client.get_task_monitor().wait_for_success(task) finally: org_admin_client.logout()
def test_0000_setup(self): """Setup the independent disks for the other tests in this module. Create three independent disks as per the configuration stated above. In case the disks exist, re-use them. This test passes if all the three disk ids are not None. """ logger = Environment.get_default_logger() TestDisk._client = Environment.get_client_in_default_org( TestDisk._test_runner_role) vdc = Environment.get_test_vdc(TestDisk._client) # TODO(): Create a vApp for this test, so that attach and detach of # disk can be run as vapp author user instead of org admin disks = vdc.get_disks() for disk in disks: if TestDisk._idisk1_id is None and \ disk.get('name').lower() == self._idisk1_name: logger.debug('Reusing ' + TestDisk._idisk1_name) TestDisk._idisk1_id = disk.get('id')[16:] elif TestDisk._idisk2_id is None and \ disk.get('name').lower() == self._idisk2_name and \ str(disk.Description).lower() == \ self._idisk2_description.lower(): logger.debug('Reusing ' + TestDisk._idisk2_name) TestDisk._idisk2_id = disk.get('id')[16:] elif TestDisk._idisk3_id is None and \ disk.get('name').lower() == self._idisk3_name: logger.debug('Reusing ' + TestDisk._idisk3_name) TestDisk._idisk3_id = disk.get('id')[16:] if TestDisk._idisk1_id is None: TestDisk._idisk1_id = self._create_disk_helper( client=TestDisk._client, vdc=vdc, disk_name=self._idisk1_name, disk_size=self._idisk1_size, disk_description=self._idisk1_description) if TestDisk._idisk2_id is None: TestDisk._idisk2_id = self._create_disk_helper( client=TestDisk._client, vdc=vdc, disk_name=self._idisk2_name, disk_size=self._idisk2_size, disk_description=self._idisk2_description) if TestDisk._idisk3_id is None: TestDisk._idisk3_id = self._create_disk_helper( client=TestDisk._client, vdc=vdc, disk_name=self._idisk3_name, disk_size=self._idisk3_size, disk_description=self._idisk3_description) self.assertIsNotNone(TestDisk._idisk1_id) self.assertIsNotNone(TestDisk._idisk2_id) self.assertIsNotNone(TestDisk._idisk3_id)
def test_0000_setup(self): """Setup the gateway required for the other tests in this module. Create a gateway as per the configuration stated above. This test passes if the gateway is created successfully. """ TestGateway._client = Environment.get_sys_admin_client() TestGateway._vdc = Environment.get_test_vdc(TestGateway._client) TestGateway._org_client = Environment.get_client_in_default_org( CommonRoles.ORGANIZATION_ADMINISTRATOR) TestGateway._config = Environment.get_config() TestGateway._gateway = Environment.get_test_gateway( TestGateway._client) if TestGateway._gateway is not None: task = TestGateway._vdc.delete_gateway(self._name) result = TestGateway._client.get_task_monitor().wait_for_success( task=task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value) external_network = Environment.get_test_external_network( TestGateway._client) ext_net_resource = external_network.get_resource() ip_scopes = ext_net_resource.xpath( 'vcloud:Configuration/vcloud:IpScopes/vcloud:IpScope', namespaces=NSMAP) first_ipscope = ip_scopes[0] gateway_ip = first_ipscope.Gateway.text prefix_len = netmask_to_cidr_prefix_len(gateway_ip, first_ipscope.Netmask.text) subnet_addr = gateway_ip + '/' + str(prefix_len) ext_net_to_participated_subnet_with_ip_settings = { ext_net_resource.get('name'): { subnet_addr: 'Auto' } } gateway_ip_arr = gateway_ip.split('.') last_ip_digit = int(gateway_ip_arr[-1]) + 1 gateway_ip_arr[-1] = str(last_ip_digit) next_ip = '.'.join(gateway_ip_arr) ext_net_to_subnet_with_ip_range = { ext_net_resource.get('name'): { subnet_addr: [next_ip + '-' + next_ip] } } ext_net_to_rate_limit = {ext_net_resource.get('name'): {100: 100}} TestGateway._gateway = TestGateway._vdc.create_gateway( self._name, [ext_net_resource.get('name')], 'compact', None, True, ext_net_resource.get('name'), gateway_ip, True, False, False, False, True, ext_net_to_participated_subnet_with_ip_settings, True, ext_net_to_subnet_with_ip_range, ext_net_to_rate_limit) result = TestGateway._client.get_task_monitor().wait_for_success( task=TestGateway._gateway.Tasks.Task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value)
def test_1000_delete_routed_orgvdc_networks(self): vdc = Environment.get_test_vdc(TestNetwork._client) result = vdc.delete_routed_orgvdc_network( name=TestNetwork._routed_org_vdc_network_name, force=True) task = TestNetwork._client.get_task_monitor().wait_for_success( task=result) self.assertEqual(task.get('status'), TaskStatus.SUCCESS.value)
def test_0080_delete_routed_orgvdc_networks(self): vdc = Environment.get_test_vdc(TestNetwork._client) result = vdc.delete_routed_orgvdc_network( name=TestNetwork._routed_org_vdc_network_name, force=True) task = TestNetwork._client.get_task_monitor().wait_for_success( task=result) assert task.get('status') == TaskStatus.SUCCESS.value
def test_0010_get_vapp(self): """Test the method vdc.get_vapp(). This test passes if the expected vApp can be successfully retrieved by name. """ vdc = Environment.get_test_vdc(TestVApp._client) vapp_resource = vdc.get_vapp(TestVApp._customized_vapp_name) self.assertIsNotNone(vapp_resource)
def test_0000_setup(self): """Setup the independent disks for the other tests in this module. Create three independent disks as per the configuration stated above. Also create a vApp that will be used in attach/detach independent disk tests. This test passes if all the three disk ids and the vapp href are not None. """ logger = Environment.get_default_logger() TestDisk._client = Environment.get_client_in_default_org( TestDisk._test_runner_role) vdc = Environment.get_test_vdc(TestDisk._client) logger.debug('Creating disk : ' + TestDisk._idisk1_name) TestDisk._idisk1_id = create_independent_disk( client=TestDisk._client, vdc=vdc, name=TestDisk._idisk1_name, size=TestDisk._idisk1_size, description=TestDisk._idisk1_description) logger.debug('Creating disk : ' + TestDisk._idisk2_name) TestDisk._idisk2_id = create_independent_disk( client=TestDisk._client, vdc=vdc, name=TestDisk._idisk2_name, size=TestDisk._idisk2_size, description=TestDisk._idisk2_description) logger.debug('Creating disk : ' + TestDisk._idisk3_name) TestDisk._idisk3_id = create_independent_disk( client=TestDisk._client, vdc=vdc, name=TestDisk._idisk3_name, size=TestDisk._idisk3_size, description=TestDisk._idisk3_description) logger.debug('Creating vApp ' + TestDisk._test_vapp_name + '.') TestDisk._test_vapp_href = create_customized_vapp_from_template( client=TestDisk._client, vdc=vdc, name=TestDisk._test_vapp_name, catalog_name=Environment.get_default_catalog_name(), template_name=Environment.get_default_template_name(), memory_size=TestDisk._test_vapp_first_vm_memory_size, num_cpu=TestDisk._test_vapp_first_vm_num_cpu, disk_size=TestDisk._test_vapp_first_vm_first_disk_size, vm_name=TestDisk._test_vapp_first_vm_name, nw_adapter_type=TestDisk._test_vapp_first_vm_network_adapter_type) self.assertIsNotNone(TestDisk._idisk1_id) self.assertIsNotNone(TestDisk._idisk2_id) self.assertIsNotNone(TestDisk._idisk3_id) self.assertIsNotNone(TestDisk._test_vapp_href)
def test_0000_setup(self): """Setup the independent disks for the other tests in this module. Create three independent disks as per the configuration stated above. In case the disks exist, re-use them. This test passes if all the three disk ids are not None. """ logger = Environment.get_default_logger() TestDisk._client = Environment.get_client_in_default_org( CommonRoles.CATALOG_AUTHOR) vdc = Environment.get_test_vdc(TestDisk._client) disks = vdc.get_disks() for disk in disks: if TestDisk._idisk1_id is None and disk.get('name').lower() \ == self._idisk1_name: logger.debug('Reusing ' + TestDisk._idisk1_name) TestDisk._idisk1_id = disk.get('id')[16:] elif TestDisk._idisk2_id is None and disk.get('name').lower() \ == self._idisk2_name and str(disk.Description).lower() \ == self._idisk2_description.lower(): # NOQA logger.debug('Reusing ' + TestDisk._idisk2_name) TestDisk._idisk2_id = disk.get('id')[16:] elif TestDisk._idisk3_id is None and disk.get('name').lower() \ == self._idisk3_name: # NOQA logger.debug('Reusing ' + TestDisk._idisk3_name) TestDisk._idisk3_id = disk.get('id')[16:] if TestDisk._idisk1_id is None: TestDisk._idisk1_id = self._create_disk_helper( client=TestDisk._client, vdc=vdc, disk_name=self._idisk1_name, disk_size=self._idisk1_size, disk_description=self._idisk1_description) if TestDisk._idisk2_id is None: TestDisk._idisk2_id = self._create_disk_helper( client=TestDisk._client, vdc=vdc, disk_name=self._idisk2_name, disk_size=self._idisk2_size, disk_description=self._idisk2_description) if TestDisk._idisk3_id is None: TestDisk._idisk3_id = self._create_disk_helper( client=TestDisk._client, vdc=vdc, disk_name=self._idisk3_name, disk_size=self._idisk3_size, disk_description=self._idisk3_description) self.assertIsNotNone(TestDisk._idisk1_id) self.assertIsNotNone(TestDisk._idisk2_id) self.assertIsNotNone(TestDisk._idisk3_id)
def test_0070_get_orgvdc_network_admin_href_as_non_admin_user(self): """Test the method vdc.get_orgvdc_network_admin_href_by_name(). This test passes if the href of the network created during setup is retrieved successfully without any errors. """ vdc = Environment.get_test_vdc(TestNetwork._vapp_author_client) href = vdc.get_orgvdc_network_admin_href_by_name( TestNetwork._isolated_orgvdc_network_name) self.assertIsNotNone(href)
def test_0170_detach_disk_from_vm(self): """Detach independent disk from VM.""" vdc = Environment.get_test_vdc(VmTest._client) result = VmTest._runner.invoke(vm, args=[ 'detach-disk', VAppConstants.name, VAppConstants.vm1_name, '--idisk-id', VmTest._idisk_id ]) self.assertEqual(0, result.exit_code)
def test_0090_list_routed_vdc_network_allocated_ip(self): vdc = Environment.get_test_vdc(TestNetwork._client) org_vdc_routed_nw = vdc.get_routed_orgvdc_network( TestNetwork._routed_org_vdc_network_name) vdc_network = VdcNetwork( TestNetwork._client, resource=org_vdc_routed_nw) allocated_ip_addresses = vdc_network.list_allocated_ip_address() self.assertEqual(len(allocated_ip_addresses), 1) ip_address = TestNetwork._routed_orgvdc_network_gateway_ip.split( '/')[0] self.assertEqual(allocated_ip_addresses[0]['IP Address'], ip_address)
def test_9998_teardown(self): """Test the method vdc.delete_vapp(). Invoke the method for all the vApps created by setup. This test passes if all the tasks for deleting the vApps succeed. """ vdc = Environment.get_test_vdc(TestVappDhcp._client) task = vdc.delete_vapp(name=TestVappDhcp._vapp_name, force=True) result = TestVappDhcp._client.get_task_monitor().wait_for_success(task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value)
def test_0120_detach_independent_disk(self): vdc = Environment.get_test_vdc(TestVM._client) idisk = vdc.get_disk(name=TestVM._idisk_name) task = TestVM._test_vapp. \ detach_disk_from_vm(disk_href=idisk.get('href'), vm_name=TestVM._test_vapp_first_vm_name) result = TestVM._client.get_task_monitor().wait_for_success(task=task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value) is_disk_attached = self.__validate_is_attached_disk( is_disk_attached=False) self.assertFalse(is_disk_attached)
def test_0020_create_isolated_orgvdc_network(self): vdc = Environment.get_test_vdc(TestNetwork._client) result = vdc.create_isolated_vdc_network( network_name=TestNetwork._test_isolated_network_name, gateway_ip=TestNetwork._test_isolated_network_gateway_ip, netmask=TestNetwork._test_isolated_network_gateway_netmask, description='Dummy description') task = TestNetwork._client.get_task_monitor().wait_for_success( task=result.Tasks.Task[0]) self.assertEqual(task.get('status'), TaskStatus.SUCCESS.value)
def test_0010_create_direct_orgvdc_network(self): vdc = Environment.get_test_vdc(TestNetwork._client) result = vdc.create_directly_connected_vdc_network( network_name=TestNetwork._test_direct_network_name, parent_network_name=TestNetwork. _test_direct_network_parent_network, description='Dummy description') task = client.get_task_monitor().wait_for_success( task=result.Tasks.Task[0]) self.assertEqual(task.get('status'), TaskStatus.SUCCESS.value)
def test_0060_get_orgvdc_network_record_as_non_admin_user(self): """Test the method vdc.get_orgvdc_network_record_by_name(). This test passes if the record of the network created during setup is retrieved successfully without any errors. """ vdc = Environment.get_test_vdc(TestNetwork._vapp_author_client) network_record = vdc.get_orgvdc_network_record_by_name( TestNetwork._isolated_orgvdc_network_name) self.assertEqual(TestNetwork._isolated_orgvdc_network_name, network_record.get('name'))
def test_0070_list_media(self): """Test the method VDC.list_media_id(). This test passes if it lists vdc medias and its id. """ logger = Environment.get_default_logger() vdc = Environment.get_test_vdc(TestOrgVDC._client) vdc.reload() vdc_resource = vdc.get_resource() vdc = VDC(TestOrgVDC._client, href=vdc_resource.get('href')) media_list = vdc.list_media_id() self.assertTrue(len(media_list) > 0)
def test_0090_list_routed_vdc_network_allocated_ip(self): vdc = Environment.get_test_vdc(TestNetwork._client) org_vdc_routed_nw = vdc.get_routed_orgvdc_network( TestNetwork._routed_org_vdc_network_name) vdc_network = VdcNetwork(TestNetwork._client, resource=org_vdc_routed_nw) allocated_ip_addresses = vdc_network.list_allocated_ip_address() self.assertEqual(len(allocated_ip_addresses), 1) ip_address = TestNetwork._routed_orgvdc_network_gateway_ip.split( '/')[0] self.assertEqual(allocated_ip_addresses[0]['IP Address'], ip_address)
def test_1000_teardown(self): """Test the method System.delete_gateway(). Invoke the method for the gateway created by setup. This test passes if no errors are generated while deleting the gateway. """ vdc = Environment.get_test_vdc(TestGateway._client) task = vdc.delete_gateway(TestGateway._name) result = TestGateway._client.get_task_monitor().wait_for_success( task=task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value)
def test_0098_teardown(self): """Test the method System.delete_gateway(). Invoke the method for the gateway created by setup. This test passes if no errors are generated while deleting the gateway. """ vdc = Environment.get_test_vdc(TestGateway._client) task = vdc.delete_gateway(TestGateway._name) result = TestGateway._client.get_task_monitor().wait_for_success( task=task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value)
def test_0020_get_isolated_orgvdc_network(self): """Test the method vdc.get_isolated_orgvdc_network(). Retrieve the isolated orgvdc network created during setup. This test passes if the network created during setup is retrieved successfully without any errors. """ vdc = Environment.get_test_vdc(TestNetwork._client) network = vdc.get_isolated_orgvdc_network( TestNetwork._isolated_orgvdc_network_name) self.assertEqual(TestNetwork._isolated_orgvdc_network_name, network.get('name'))
def test_0020_get_nonexistent_vapp(self): """Test the method vdc.get_vapp(). This test passes if the non-existent vApp can't be successfully retrieved by name. """ vdc = Environment.get_test_vdc(TestVApp._client) try: vdc.get_vapp(TestVApp._non_existent_vapp_name) self.fail('Should not be able to fetch vApp ' + TestVApp._non_existent_vapp_name) except EntityNotFoundException as e: return
def _list_connected_vapps(self, client): vdc = Environment.get_test_vdc(client) vapp_name = 'test-connected-vapp' + str(uuid1()) vdc.create_vapp( vapp_name, network=TestNetwork._routed_org_vdc_network_name) org_vdc_routed_nw = vdc.get_routed_orgvdc_network( TestNetwork._routed_org_vdc_network_name) vdc_network = VdcNetwork(client, resource=org_vdc_routed_nw) connected_vapps = vdc_network.list_connected_vapps() self.assertEqual(len(connected_vapps), 1) self.assertEqual(connected_vapps[0].get('Name'), vapp_name) # Delete test vApp after test vdc.reload() vdc.delete_vapp(vapp_name)
def test_0005_create_routed_orgvdc_network(self): """Test creation of routed vdc network. Fetches the gateway and invoke VDC.create_gateway method. """ vdc = Environment.get_test_vdc(TestNetwork._client) result = vdc.create_routed_vdc_network( network_name=TestNetwork._routed_org_vdc_network_name, gateway_name=GatewayConstants.name, network_cidr=TestNetwork._routed_orgvdc_network_gateway_ip, description='Dummy description') task = TestNetwork._client.get_task_monitor().wait_for_success( task=result.Tasks.Task[0]) assert task.get('status') == TaskStatus.SUCCESS.value
def test_0030_get_non_existent_isolated_orgvdc_network(self): """Test the method vdc.get_isolated_orgvdc_network(). This test passes if the network retrieval operation fails with a EntityNotFoundException. """ vdc = Environment.get_test_vdc(TestNetwork._client) try: vdc.get_isolated_orgvdc_network( TestNetwork._non_existent_isolated_orgvdc_network_name) self.fail('Should not be able to fetch isolated orgvdc network ' + TestNetwork._non_existent_isolated_orgvdc_network_name) except EntityNotFoundException as e: return
def test_9998_teardown(self): """Test the method vdc.delete_isolated_orgvdc_network(). Invoke the method for the orgvdc network created by setup. This test passes if the task for deleting the network succeeds. """ logger = Environment.get_default_logger() vdc = Environment.get_test_vdc(TestNetwork._client) logger.debug('Deleting isolated orgvdc network : ' + TestNetwork._isolated_orgvdc_network_name) result = vdc.delete_isolated_orgvdc_network( name=TestNetwork._isolated_orgvdc_network_name, force=True) TestNetwork._client.get_task_monitor().wait_for_success(task=result)
def test_0060_list_orgvdc_network_records_as_non_admin_user(self): """Test the method vdc.list_orgvdc_network_records(). This test passes if the record of the network created during setup is present in the retrieved list of networks. """ vdc = Environment.get_test_vdc(TestNetwork._vapp_author_client) records_list = vdc.list_orgvdc_network_records() for network_record in records_list: if network_record[ 'name'] == TestNetwork._isolated_orgvdc_network_name: return self.fail('Retrieved list of orgvdc network records doesn\'t ' + 'contain ' + TestNetwork._isolated_orgvdc_network_name)
def test_9997_teardown(self): """Delete the vApp created during setup. This test passes if the task for deleting the vApp succeed. """ vapps_to_delete = [] if TestPVDC._test_vapp_href is not None: vapps_to_delete.append(TestPVDC._test_vapp_name) vdc = Environment.get_test_vdc(TestPVDC._org_client) for vapp_name in vapps_to_delete: task = vdc.delete_vapp(name=vapp_name, force=True) result = TestPVDC._org_client.get_task_monitor().wait_for_success( task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value)
def test_0010_list_isolated_orgvdc_networks(self): """Test the method vdc.list_orgvdc_isolated_networks(). Fetches all isolated orgvdc networks in the current organization. This test passes if the network created during setup is present in the retrieved list of networks. """ vdc = Environment.get_test_vdc(TestNetwork._client) networks = vdc.list_orgvdc_isolated_networks() for network in networks: if network.get('name') == \ TestNetwork._isolated_orgvdc_network_name: return self.fail('Retrieved list of isolated orgvdc network doesn\'t' 'contain ' + TestNetwork._isolated_orgvdc_network_name)
def test_0040_list_isolated_orgvdc_networks_as_non_admin_user(self): """Test the method vdc.list_orgvdc_isolated_networks(). Tries to fetches all isolated orgvdc networks in the current organization as a non admin user. This test passes if the operation fails with an AccessForbiddenException. """ vdc = Environment.get_test_vdc(TestNetwork._vapp_author_client) try: result = vdc.list_orgvdc_isolated_networks() if len(result) > 0: self.fail('Should not have been able to list isolated orgvdc' 'networks as non admin user.') except AccessForbiddenException as e: return
def test_0076_add_static_ip_pool(self): vdc = Environment.get_test_vdc(TestNetwork._client) org_vdc_routed_nw = vdc.get_routed_orgvdc_network( TestNetwork._routed_org_vdc_network_name) vdcNetwork = VdcNetwork( TestNetwork._client, resource=org_vdc_routed_nw) result = vdcNetwork.add_static_ip_pool_and_dns( [TestNetwork._ip_range], TestNetwork._dns1, TestNetwork._dns2, TestNetwork._dns_suffix) task = TestNetwork._client.get_task_monitor().wait_for_success( task=result) self.assertEqual(task.get('status'), TaskStatus.SUCCESS.value) result = vdcNetwork.add_static_ip_pool_and_dns(None, TestNetwork._dns1, TestNetwork._dns2, TestNetwork._dns_suffix) task = TestNetwork._client.get_task_monitor().wait_for_success( task=result) self.assertEqual(task.get('status'), TaskStatus.SUCCESS.value) result = vdcNetwork.add_static_ip_pool_and_dns(None, TestNetwork._dns1) task = TestNetwork._client.get_task_monitor().wait_for_success( task=result) self.assertEqual(task.get('status'), TaskStatus.SUCCESS.value) result = vdcNetwork.add_static_ip_pool_and_dns(None, None, None, TestNetwork._dns_suffix) task = TestNetwork._client.get_task_monitor().wait_for_success( task=result) self.assertEqual(task.get('status'), TaskStatus.SUCCESS.value) # Verify vdcNetwork.reload() vdc_routed_nw = vdcNetwork.get_resource() ip_scope = vdc_routed_nw.Configuration.IpScopes.IpScope ip_ranges = ip_scope.IpRanges.IpRange match_found = False for ip_range in ip_ranges: if (ip_range.StartAddress + '-' + ip_range.EndAddress) == \ TestNetwork._ip_range: match_found = True self.assertTrue(match_found) self.assertTrue(ip_scope.Dns1, TestNetwork._dns1) self.assertTrue(ip_scope.Dns2, TestNetwork._dns2) self.assertTrue(ip_scope.DnsSuffix, TestNetwork._dns_suffix)
def test_0000_setup(self): """Load configuration and create a click runner to invoke CLI.""" VmTest._config = Environment.get_config() VmTest._logger = Environment.get_default_logger() VmTest._client = Environment.get_client_in_default_org( CommonRoles.ORGANIZATION_ADMINISTRATOR) VmTest._media_resource = Environment.get_test_media_resource() VmTest._runner = CliRunner() default_org = VmTest._config['vcd']['default_org_name'] VmTest._login(self) VmTest._runner.invoke(org, ['use', default_org]) VmTest._test_vdc = Environment.get_test_vdc(VmTest._client) VmTest._test_vapp = Environment.get_test_vapp_with_network( VmTest._client) VmTest._test_vm = VM( VmTest._client, href=VmTest._test_vapp.get_vm(VAppConstants.vm1_name).get('href'))
def test_0050_get_isolated_orgvdc_network_as_non_admin_user(self): """Test the method vdc.get_isolated_orgvdc_network(). Tries to retrieve the isolated orgvdc network created during setup as a non admin user. This test passes if the operation fails with an AccessForbiddenException. """ vdc = Environment.get_test_vdc(TestNetwork._vapp_author_client) try: vdc.get_isolated_orgvdc_network( TestNetwork._isolated_orgvdc_network_name) self.fail('Should not be able to fetch isolated orgvdc network ' + TestNetwork._isolated_orgvdc_network_name + ' as a non' + 'admin user.') except AccessForbiddenException as e: return
def test_0131_list_vapp_details(self): """Test the method list_vapp_details(). This test passes if the expected vApp list can be successfully retrieved. """ org_vdc = Environment.get_test_vdc(TestVApp._sys_admin_client) resource_type = 'adminVApp' vapp_filter = None vapp_list = org_vdc.list_vapp_details(resource_type, vapp_filter) self.assertTrue(len(vapp_list) > 0) vapp_filter = 'name==' + TestVApp._customized_vapp_name vapp_list = org_vdc.list_vapp_details(resource_type, vapp_filter) self.assertTrue(len(vapp_list) > 0) vapp_filter = 'ownerName==' + TestVApp._customized_vapp_owner_name vapp_list = org_vdc.list_vapp_details(resource_type, vapp_filter) self.assertTrue(len(vapp_list) > 0)
def test_9998_teardown(self): """Test the method vdc.delete_vapp(). Invoke the method for all the vApps created by setup. This test passes if all the tasks for deleting the vApps succeed. """ vapps_to_delete = [] if TestVApp._empty_vapp_href is not None: vapps_to_delete.append(TestVApp._empty_vapp_name) if TestVApp._customized_vapp_href is not None: vapps_to_delete.append(TestVApp._customized_vapp_name) vdc = Environment.get_test_vdc(TestVApp._client) for vapp_name in vapps_to_delete: task = vdc.delete_vapp(name=vapp_name, force=True) result = TestVApp._client.get_task_monitor().wait_for_success(task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value)
def test_0080_routed_vdc_network_metadata(self): vdc = Environment.get_test_vdc(TestNetwork._client) org_vdc_routed_nw = vdc.get_routed_orgvdc_network( TestNetwork._routed_org_vdc_network_name) vdc_network = VdcNetwork( TestNetwork._client, resource=org_vdc_routed_nw) # Test data metadata_key = "test-key1" metadata_value = "test-value1" updated_metadata_value = "updated-" + metadata_value # Testing add, update and delete metadata TestNetwork._add_routed_vdc_network_metadata( self, vdc_network, metadata_key, metadata_value) TestNetwork._update_routed_vdc_network_metadata( self, vdc_network, metadata_key, updated_metadata_value) TestNetwork._delete_routed_vcd_network_metadata( self, vdc_network, metadata_key)
def test_0000_setup(self): """Setup the vApps required for the other tests in this module. Create two vApps as per the configuration stated above. This test passes if the two vApp hrefs are not None. """ logger = Environment.get_default_logger() TestVApp._client = Environment.get_client_in_default_org( TestVApp._test_runner_role) TestVApp._sys_admin_client = Environment.get_sys_admin_client() vdc = Environment.get_test_vdc(TestVApp._client) logger.debug('Creating empty vApp.') TestVApp._empty_vapp_href = \ create_empty_vapp(client=TestVApp._client, vdc=vdc, name=TestVApp._empty_vapp_name, description=TestVApp._empty_vapp_description) TestVApp._empty_vapp_owner_name = Environment.\ get_username_for_role_in_test_org(TestVApp._test_runner_role) logger.debug('Creating customized vApp.') TestVApp._customized_vapp_href = create_customized_vapp_from_template( client=TestVApp._client, vdc=vdc, name=TestVApp._customized_vapp_name, catalog_name=Environment.get_default_catalog_name(), template_name=Environment.get_default_template_name(), description=TestVApp._customized_vapp_description, memory_size=TestVApp._customized_vapp_memory_size, num_cpu=TestVApp._customized_vapp_num_cpu, disk_size=TestVApp._customized_vapp_disk_size, vm_name=TestVApp._customized_vapp_vm_name, vm_hostname=TestVApp._customized_vapp_vm_hostname, nw_adapter_type=TestVApp._customized_vapp_vm_network_adapter_type) TestVApp._customized_vapp_owner_name = Environment.\ get_username_for_role_in_test_org(TestVApp._test_runner_role) self.assertIsNotNone(TestVApp._empty_vapp_href) self.assertIsNotNone(TestVApp._customized_vapp_href)
def test_0075_edit_name_description_and_shared_state_for_routed_network( self): vdc = Environment.get_test_vdc(TestNetwork._client) org_vdc_routed_nw = vdc.get_routed_orgvdc_network( TestNetwork._routed_org_vdc_network_name) vdcNetwork = VdcNetwork( TestNetwork._client, resource=org_vdc_routed_nw) result = vdcNetwork.edit_name_description_and_shared_state( TestNetwork._routed_org_vdc_network_new_name, 'Test ' 'Description', True) task = TestNetwork._client.get_task_monitor().wait_for_success( task=result) self.assertEqual(task.get('status'), TaskStatus.SUCCESS.value) # Resetting to original name result = vdcNetwork.edit_name_description_and_shared_state( TestNetwork._routed_org_vdc_network_name, None, False) task = TestNetwork._client.get_task_monitor().wait_for_success( task=result) self.assertEqual(task.get('status'), TaskStatus.SUCCESS.value)
def __convert_to_distributed_interface(self, client): self.__convert_enable_dr_in_gateway_using_sys_client(True) vdc = Environment.get_test_vdc(client) org_vdc_routed_nw = vdc.get_routed_orgvdc_network( TestNetwork._routed_org_vdc_network_name) vdc_network = VdcNetwork(client, resource=org_vdc_routed_nw) result = vdc_network.convert_to_distributed_interface() self.__wait_for_success(client, result) # Verify vdc_network.reload_admin() reloaded_vdc_network = vdc_network.admin_resource self.assertTrue( reloaded_vdc_network.Configuration.DistributedInterface) # Revert result = vdc_network.convert_to_internal_interface() self.__wait_for_success(client, result) # Disable the distributed routing on gateway self.__convert_enable_dr_in_gateway_using_sys_client(False)
def test_0000_setup(self): """Load configuration and create a click runner to invoke CLI.""" VAppTest._config = Environment.get_config() VAppTest._logger = Environment.get_default_logger() VAppTest._client = Environment.get_client_in_default_org( CommonRoles.ORGANIZATION_ADMINISTRATOR) VAppTest._runner = CliRunner() default_org = VAppTest._config['vcd']['default_org_name'] VAppTest._default_org = default_org VAppTest._login(self) VAppTest._runner.invoke(org, ['use', default_org]) VAppTest._test_vdc = Environment.get_test_vdc(VAppTest._client) VAppTest._test_vapp = create_vapp_from_template( VAppTest._client, VAppTest._test_vdc, VAppTest._test_vapp_name, VAppTest._config['vcd']['default_catalog_name'], VAppTest._config['vcd']['default_template_file_name'], power_on=False, deploy=False) VAppTest._catalog_name = VAppTest._config['vcd'][ 'default_catalog_name']
def test_0078_remove_static_ip_pool(self): vdc = Environment.get_test_vdc(TestNetwork._client) org_vdc_routed_nw = vdc.get_routed_orgvdc_network( TestNetwork._routed_org_vdc_network_name) vdcNetwork = VdcNetwork( TestNetwork._client, resource=org_vdc_routed_nw) result = vdcNetwork.remove_static_ip_pool(TestNetwork._new_ip_range) task = TestNetwork._client.get_task_monitor().wait_for_success( task=result) self.assertEqual(task.get('status'), TaskStatus.SUCCESS.value) # Verification vdcNetwork.reload() vdc_routed_nw = vdcNetwork.get_resource() ip_scope = vdc_routed_nw.Configuration.IpScopes.IpScope # IPRanges element will be missing if there was only one IP range if not hasattr(ip_scope, 'IpRanges'): return ip_ranges = ip_scope.IpRanges.IpRange match_found = False for ip_range in ip_ranges: if (ip_range.StartAddress + '-' + ip_range.EndAddress) == \ TestNetwork._new_ip_range: match_found = True self.assertFalse(match_found)
def test_0000_setup(self): """Setup the networks required for the other tests in this module. Create an isolated org vdc network as per the configuration stated above. This test passes if the isolated orgvdc network is created successfully. """ logger = Environment.get_default_logger() TestNetwork._client = Environment.get_client_in_default_org( TestNetwork._test_runner_role) TestNetwork._system_client = Environment.get_sys_admin_client() TestNetwork._vapp_author_client = \ Environment.get_client_in_default_org(CommonRoles.VAPP_AUTHOR) vdc = Environment.get_test_vdc(TestNetwork._client) logger.debug('Creating isolated orgvdc network : ' + TestNetwork._isolated_orgvdc_network_name) result = vdc.create_isolated_vdc_network( network_name=TestNetwork._isolated_orgvdc_network_name, network_cidr=TestNetwork._isolated_orgvdc_network_gateway_ip) TestNetwork._client.get_task_monitor().wait_for_success( task=result.Tasks.Task[0])