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 __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_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_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_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_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_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_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 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])
