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_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_0000_setup(self):
"""Add Firewall Rules in the gateway.
Invokes the add_firewall_rule of the gateway.
"""
TestFirewallRules._org_client = Environment.get_client_in_default_org(
TestFirewallRules._test_runner_role)
TestFirewallRules._system_client = Environment.get_sys_admin_client()
TestFirewallRules._config = Environment.get_config()
gateway = Environment.get_test_gateway(TestFirewallRules._org_client)
TestFirewallRules._gateway_obj = Gateway(
TestFirewallRules._org_client,
TestFirewallRules._name,
href=gateway.get('href'))
TestFirewallRules._external_network = Environment. \
get_test_external_network(TestFirewallRules._system_client)
TestFirewallRules._gateway_obj.add_firewall_rule(
TestFirewallRules._firewall_rule_name)
firewall_rules_resource = \
TestFirewallRules._gateway_obj.get_firewall_rules()
# Verify
matchFound = False
for firewallRule in firewall_rules_resource.firewallRules.firewallRule:
if firewallRule['name'] == TestFirewallRules._firewall_rule_name:
TestFirewallRules._rule_id = firewallRule.id
matchFound = True
break
self.assertTrue(matchFound)
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 test_0057_vapp_network_disconnect(self):
"""Test vapp.disconnect_org_vdc_network().
This test passes if the connect and disconnect to orgvdc network
operations are successful.
"""
try:
logger = Environment.get_default_logger()
client = Environment.get_client_in_default_org(
CommonRoles.ORGANIZATION_ADMINISTRATOR)
network_name = Environment.get_default_orgvdc_network_name()
vapp_name = TestVApp._customized_vapp_name
vapp = Environment.get_vapp_in_test_vdc(client=client,
vapp_name=vapp_name)
logger.debug('Disconnecting vApp ' + vapp_name + ' to orgvdc network ' +
network_name)
vapp.reload()
task = vapp.disconnect_org_vdc_network(network_name)
result = client.get_task_monitor().wait_for_success(task)
self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value)
finally:
client.logout()
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_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_0000_setup(self):
"""Add Firewall Rules in the gateway.
Invokes the add_firewall_rule of the gateway.
"""
TestFirewallRules._org_client = Environment.get_client_in_default_org(
TestFirewallRules._test_runner_role)
TestFirewallRules._system_client = Environment.get_sys_admin_client()
TestFirewallRules._config = Environment.get_config()
gateway = Environment.get_test_gateway(TestFirewallRules._org_client)
TestFirewallRules._gateway_obj = Gateway(
TestFirewallRules._org_client,
TestFirewallRules._name,
href=gateway.get('href'))
TestFirewallRules._external_network = Environment. \
get_test_external_network(TestFirewallRules._system_client)
TestFirewallRules._gateway_obj.add_firewall_rule(
TestFirewallRules._firewall_rule_name)
firewall_rules_resource = \
TestFirewallRules._gateway_obj.get_firewall_rules()
# Verify
matchFound = False
for firewallRule in firewall_rules_resource.firewallRules.firewallRule:
if firewallRule['name'] == TestFirewallRules._firewall_rule_name:
TestFirewallRules._rule_id = firewallRule.id
matchFound = True
break
self.assertTrue(matchFound)
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_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_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_0020_find_existing_entities_with_org_user(self):
"""Find entities with low-privilege org user."""
self._client = Environment.get_client_in_default_org(
CommonRoles.VAPP_USER)
q1 = self._client.get_typed_query(
ResourceType.CATALOG.value,
query_result_format=QueryResultFormat.ID_RECORDS)
q1_records = list(q1.execute())
self.assertTrue(len(q1_records) > 0,
msg="Find at least one catalog item")
def test_0020_find_existing_entities_with_org_user(self):
"""Find entities with low-privilege org user."""
self._client = Environment.get_client_in_default_org(
CommonRoles.VAPP_USER)
q1 = self._client.get_typed_query(
ResourceType.CATALOG.value,
query_result_format=QueryResultFormat.ID_RECORDS)
q1_records = list(q1.execute())
self.assertTrue(len(q1_records) > 0,
msg="Find at least one catalog item")
def test_0040_check_all_resource_types(self):
"""Verify that we can search on any resource type without error."""
self._client = Environment.get_client_in_default_org(
CommonRoles.ORGANIZATION_ADMINISTRATOR)
resource_types = [r.value for r in ResourceType]
# Some types of course won't exist but the search should not fail.
for resource_type in resource_types:
q1 = self._client.get_typed_query(
resource_type,
query_result_format=QueryResultFormat.ID_RECORDS)
q1_records = list(q1.execute())
self.assertTrue(
len(q1_records) >= 0, "Should get a list, even if tempty")
def test_0040_find_unsupported_type(self):
"""Verify we raise appropriate exception if user can't see entities."""
self._client = Environment.get_client_in_default_org(
CommonRoles.VAPP_USER)
for format in self._result_formats:
try:
q1 = self._client.get_typed_query(
ResourceType.ORGANIZATION.value,
query_result_format=QueryResultFormat.ID_RECORDS)
q1.execute()
self.fail('User (vApp user) should not be able to fetch any '
'orgs.')
except OperationNotSupportedException as e:
pass
def test_0040_find_unsupported_type(self):
"""Verify we raise appropriate exception if user can't see entities."""
self._client = Environment.get_client_in_default_org(
CommonRoles.VAPP_USER)
for format in self._result_formats:
try:
q1 = self._client.get_typed_query(
ResourceType.ORGANIZATION.value,
query_result_format=QueryResultFormat.ID_RECORDS)
q1.execute()
self.fail('User (vApp user) should not be able to fetch any '
'orgs.')
except OperationNotSupportedException as e:
pass
def test_0000_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()
TestVM._client = Environment.get_client_in_default_org(
TestVM._test_runner_role)
TestVM._sys_admin_client = Environment.get_sys_admin_client()
vdc = Environment.get_test_vdc(TestVM._client)
TestVM._media_resource = Environment.get_test_media_resource()
logger.debug('Creating vApp ' + TestVM._test_vapp_name + '.')
TestVM._test_vapp_href = create_customized_vapp_from_template(
client=TestVM._client,
vdc=vdc,
name=TestVM._test_vapp_name,
catalog_name=Environment.get_default_catalog_name(),
template_name=Environment.get_default_template_name(),
memory_size=TestVM._test_vapp_first_vm_memory_size,
num_cpu=TestVM._test_vapp_first_vm_num_cpu,
disk_size=TestVM._test_vapp_first_vm_first_disk_size,
vm_name=TestVM._test_vapp_first_vm_name,
nw_adapter_type=TestVM._test_vapp_first_vm_network_adapter_type)
self.assertIsNotNone(TestVM._test_vapp_href)
vapp = VApp(TestVM._client, href=TestVM._test_vapp_href)
TestVM._test_vapp = vapp
vm_resource = vapp.get_vm(TestVM._test_vapp_first_vm_name)
TestVM._test_vapp_first_vm_href = vm_resource.get('href')
self.assertIsNotNone(TestVM._test_vapp_first_vm_href)
logger.debug('Creating empty vApp.')
TestVM._empty_vapp_href = \
create_empty_vapp(client=TestVM._client,
vdc=vdc,
name=TestVM._empty_vapp_name,
description=TestVM._empty_vapp_description)
TestVM._empty_vapp_owner_name = Environment. \
get_username_for_role_in_test_org(TestVM._test_runner_role)
#Create independent disk
TestVM._idisk = vdc.create_disk(name=self._idisk_name,
size=self._idisk_size,
description=self._idisk_description)
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])
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])
def test_0000_setup(self):
"""Setup the org vdc required for the other tests in this module.
Create one org vdc as per the configuration stated above. Test the
method Org.create_org_vdc().
This test passes if the vdc href is not None.
"""
logger = Environment.get_default_logger()
TestOrgVDC._client = Environment.get_sys_admin_client()
TestOrgVDC._org_admin_client = Environment.get_client_in_default_org(
CommonRoles.ORGANIZATION_ADMINISTRATOR)
org = Environment.get_test_org(TestOrgVDC._client)
vdc_name = TestOrgVDC._new_vdc_name
pvdc_name = Environment.get_test_pvdc_name()
storage_profiles = [{
'name': '*',
'enabled': True,
'units': 'MB',
'limit': 0,
'default': True
}]
vdc_resource = org.create_org_vdc(
vdc_name,
pvdc_name,
storage_profiles=storage_profiles,
uses_fast_provisioning=True,
is_thin_provision=True)
TestOrgVDC._client.get_task_monitor().wait_for_success(
task=vdc_resource.Tasks.Task[0])
logger.debug('Created ovdc ' + vdc_name + '.')
# The following contraption is required to get the non admin href of
# the ovdc. vdc_resource contains the admin version of the href since
# we created the ovdc as a sys admin.
org = Environment.get_test_org(TestOrgVDC._org_admin_client)
org.reload()
for vdc in org.list_vdcs():
if vdc.get('name').lower() == vdc_name.lower():
TestOrgVDC._new_vdc_href = vdc.get('href')
TestOrgVDC._vdc1 = VDC(TestOrgVDC._org_admin_client,
href=TestOrgVDC._new_vdc_href)
self.assertIsNotNone(TestOrgVDC._new_vdc_href)
#Create Independent disk
TestOrgVDC._idisk_id = TestOrgVDC._vdc1.\
create_disk(name=self._idisk_name,
size=self._idisk_size,
description=self._idisk_description).get('id')[16:]
self.assertIsNotNone(TestOrgVDC._idisk_id)
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._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_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._pvdc_name = Environment.get_test_pvdc_name()
TestVApp._config = Environment.get_config()
TestVApp._default_org_name = TestVApp._config['vcd'][
'default_org_name']
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)
TestVApp._create_org_vdc()
self.assertIsNotNone(TestVApp._empty_vapp_href)
self.assertIsNotNone(TestVApp._customized_vapp_href)
def test_0030_find_non_existing(self):
"""Verify we return nothing if no entities exist."""
self._client = Environment.get_client_in_default_org(
CommonRoles.VAPP_USER)
for format in self._result_formats:
# Use the generator directly.
q1 = self._client.get_typed_query(
ResourceType.ORGANIZATION.value,
query_result_format=QueryResultFormat.ID_RECORDS)
count = 0
for item in q1.execute():
count += 1
self.assertEqual(0, count, "Should not find orgs via generator")
# Try a list.
q1_records = list(q1.execute())
self.assertEqual(0, len(q1_records),
"Should not find any orgs via list")
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_0030_find_non_existing(self):
"""Verify we return nothing if no entities exist."""
self._client = Environment.get_client_in_default_org(
CommonRoles.VAPP_USER)
for format in self._result_formats:
q1 = self._client.get_typed_query(
ResourceType.CATALOG.value,
query_result_format=QueryResultFormat.ID_RECORDS,
qfilter='name==invalid_catalog_name')
count = 0
for item in q1.execute():
count += 1
self.assertEqual(0, count, "Should not find invalid catalog via "
"generator.")
# Try a list.
q1_records = list(q1.execute())
self.assertEqual(0, len(q1_records),
"Should not find invalid catalog via list.")
def test_0040_change_idisk_owner(self):
"""Test the method vdc.change_disk_owner().
Invoke the method for the third independent disk, to make vapp_user the
owner of the disk. Revert back the ownership to the original owner once
the test is over.
This test passes if the disk states its owner as vapp_user after the
method call.
"""
org_admin_client = Environment.get_client_in_default_org(
CommonRoles.ORGANIZATION_ADMINISTRATOR)
org = Environment.get_test_org(org_admin_client)
vdc = Environment.get_test_vdc(org_admin_client)
try:
username = Environment.get_username_for_role_in_test_org(
CommonRoles.VAPP_USER)
user_resource = org.get_user(username)
vdc.change_disk_owner(
disk_id=TestDisk._idisk3_id,
user_href=user_resource.get('href'))
disk_resource = vdc.get_disk(disk_id=TestDisk._idisk3_id)
new_owner_name = disk_resource.Owner.User.get('name')
self.assertEqual(new_owner_name, username)
# Revert ownership to original owner
username = Environment.get_username_for_role_in_test_org(
TestDisk._test_runner_role)
user_resource = org.get_user(username)
vdc.change_disk_owner(
disk_id=TestDisk._idisk3_id,
user_href=user_resource.get('href'))
disk_resource = vdc.get_disk(disk_id=TestDisk._idisk3_id)
new_owner_name = disk_resource.Owner.User.get('name')
self.assertEqual(new_owner_name, username)
finally:
org_admin_client.logout()
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. In case the
vApps exist, re-use them.
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)
vdc = Environment.get_test_vdc(TestVApp._client)
try:
vapp_resource = vdc.get_vapp(TestVApp._empty_vapp_name)
logger.debug('Reusing empty vApp')
TestVApp._empty_vapp_href = vapp_resource.get('href')
TestVApp._empty_vapp_owner_name = \
vapp_resource.Owner.User.get('name')
except EntityNotFoundException as e:
TestVApp._empty_vapp_href = self._create_empty_vapp(
TestVApp._client, vdc)
TestVApp._empty_vapp_owner_name = Environment.\
get_username_for_role_in_test_org(TestVApp._test_runner_role)
try:
vapp_resource = vdc.get_vapp(TestVApp._customized_vapp_name)
logger.debug('Reusing customized vApp')
TestVApp._customized_vapp_href = vapp_resource.get('href')
TestVApp._customized_vapp_owner_name = \
vapp_resource.Owner.User.get('name')
except EntityNotFoundException as e:
TestVApp._customized_vapp_href = \
self._create_customized_vapp_from_template(
TestVApp._client,
vdc)
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_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_0060_check_result_formats(self):
"""Verify we get expected results for all result formats."""
self._client = Environment.get_client_in_default_org(
CommonRoles.ORGANIZATION_ADMINISTRATOR)
for format in self._result_formats:
# Ensure format works with generator.
q1 = self._client.get_typed_query(ResourceType.USER.value,
query_result_format=format)
count = 0
for result in q1.execute():
count += 1
self.assertTrue(
count >= 4,
"Expect at least 4 users from generator: {0}".format(format))
# Ensure format works with list built over generator.
q2 = self._client.get_typed_query(ResourceType.USER.value,
query_result_format=format)
q2_result = list(q2.execute())
self.assertTrue(
len(q2_result) >= 4,
"Expect at least 4 users from list: {0}".format(format))
def test_0080_change_catalog_ownership(self):
"""Test the method org.change_catalog_owner().
Change the ownership of the catalog to org administrator and back to
the original owner.
This test passes if the catalog owner change operation succeeds without
raising any errors. And the new owner is able to access the catalog.
"""
logger = Environment.get_default_logger()
org_admin_client = Environment.get_client_in_default_org(
CommonRoles.ORGANIZATION_ADMINISTRATOR)
org = Environment.get_test_org(org_admin_client)
catalog_name = TestCatalog._test_catalog_name
original_owner_username = \
Environment.get_username_for_role_in_test_org(
TestCatalog._test_runner_role)
org_admin_username = Environment.get_username_for_role_in_test_org(
CommonRoles.ORGANIZATION_ADMINISTRATOR)
try:
logger.debug('Changing owner of catalog:' + catalog_name + ' to ' +
org_admin_username)
org.change_catalog_owner(catalog_name, org_admin_username)
catalog_admin_resource = org.get_catalog(catalog_name,
is_admin_operation=True)
self.assertEqual(catalog_admin_resource.Owner.User.get('name'),
org_admin_username)
logger.debug('Changing owner of catalog ' + catalog_name +
' back to ' + original_owner_username)
org.change_catalog_owner(catalog_name, original_owner_username)
catalog_admin_resource = org.get_catalog(catalog_name,
is_admin_operation=True)
self.assertEqual(catalog_admin_resource.Owner.User.get('name'),
original_owner_username)
finally:
org_admin_client.logout()
def test_0080_change_catalog_ownership(self):
"""Test the method org.change_catalog_owner().
Change the ownership of the catalog to org administrator and back to
the original owner.
This test passes if the catalog owner change operation succeeds without
raising any errors. And the new owner is able to access the catalog.
"""
logger = Environment.get_default_logger()
org_admin_client = Environment.get_client_in_default_org(
CommonRoles.ORGANIZATION_ADMINISTRATOR)
org = Environment.get_test_org(org_admin_client)
catalog_name = TestCatalog._test_catalog_name
original_owner_username = \
Environment.get_username_for_role_in_test_org(
TestCatalog._test_runner_role)
org_admin_username = Environment.get_username_for_role_in_test_org(
CommonRoles.ORGANIZATION_ADMINISTRATOR)
try:
logger.debug('Changing owner of catalog:' + catalog_name +
' to ' + org_admin_username)
org.change_catalog_owner(catalog_name, org_admin_username)
catalog_admin_resource = org.get_catalog(catalog_name,
is_admin_operation=True)
self.assertEqual(catalog_admin_resource.Owner.User.get('name'),
org_admin_username)
logger.debug('Changing owner of catalog ' + catalog_name +
' back to ' + original_owner_username)
org.change_catalog_owner(catalog_name, original_owner_username)
catalog_admin_resource = org.get_catalog(catalog_name,
is_admin_operation=True)
self.assertEqual(catalog_admin_resource.Owner.User.get('name'),
original_owner_username)
finally:
org_admin_client.logout()
def test_0000_setup(self):
"""Setup a catalog for the tests in this module.
Create a catalog. Test org.create_catalog() function.
This test passes if the catalog is created successfully.
"""
logger = Environment.get_default_logger()
TestCatalog._client = Environment.get_client_in_default_org(
TestCatalog._test_runner_role)
org = Environment.get_test_org(TestCatalog._client)
try:
catalog_resource = org.get_catalog(TestCatalog._test_catalog_name)
logger.debug('Reusing test catalog.')
except EntityNotFoundException as e:
catalog_resource = org.create_catalog(
TestCatalog._test_catalog_name,
TestCatalog._test_catalog_description)
TestCatalog._client.get_task_monitor().wait_for_success(
task=catalog_resource.Tasks.Task[0])
TestCatalog._test_catalog_href = catalog_resource.get('href')
self.assertIsNotNone(TestCatalog._test_catalog_href)
def test_0055_attach_network_to_vm(self):
try:
client = Environment.get_client_in_default_org(CommonRoles.ORGANIZATION_ADMINISTRATOR)
vdc = Environment.get_test_vdc(TestVApp._client)
vapp_resource = vdc.get_vapp(TestVApp._customized_vapp_name)
vms = vapp_resource.xpath(
'//vcloud:VApp/vcloud:Children/vcloud:Vm', namespaces=NSMAP)
self.assertTrue(len(vms) >= 1)
first_vm = vms[0]
vm_name = first_vm.get('name')
self.assertEqual(vm_name, TestVApp._customized_vapp_vm_name)
vapp = Environment.get_vapp_in_test_vdc(client=TestVApp._client,
vapp_name=TestVApp._customized_vapp_name)
network_name = Environment.get_default_orgvdc_network_name()
task = vapp.attach_network_to_vm(vm_name, network_name, 0)
result = client.get_task_monitor().wait_for_success(task)
self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value)
finally:
client.logout()
def test_0000_setup(self):
"""Setup a catalog for the tests in this module.
Create a catalog. Test org.create_catalog() function.
This test passes if the catalog is created successfully.
"""
logger = Environment.get_default_logger()
TestCatalog._client = Environment.get_client_in_default_org(
TestCatalog._test_runner_role)
org = Environment.get_test_org(TestCatalog._client)
try:
catalog_resource = org.get_catalog(TestCatalog._test_catalog_name)
logger.debug('Reusing test catalog.')
except EntityNotFoundException as e:
catalog_resource = org.create_catalog(
TestCatalog._test_catalog_name,
TestCatalog._test_catalog_description)
TestCatalog._client.get_task_monitor().wait_for_success(
task=catalog_resource.Tasks.Task[0])
TestCatalog._test_catalog_href = catalog_resource.get('href')
self.assertIsNotNone(TestCatalog._test_catalog_href)
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_0000_setup(self):
"""Setup the org vdc required for the other tests in this module.
"""
TestOrgVDC._config = Environment.get_config()
logger = Environment.get_default_logger()
TestOrgVDC._client = Environment.get_client_in_default_org(
CommonRoles.ORGANIZATION_ADMINISTRATOR)
TestOrgVDC._runner = CliRunner()
default_org = TestOrgVDC._config['vcd']['default_org_name']
TestOrgVDC._login(self)
TestOrgVDC._runner.invoke(org, ['use', default_org])
TestOrgVDC._vdc_resource = Environment.get_test_vdc(
TestOrgVDC._client).get_resource()
TestOrgVDC._vdc1 = VDC(TestOrgVDC._client,
href=TestOrgVDC._vdc_resource.get('href'))
# Create Independent disk
TestOrgVDC._idisk_id = \
create_independent_disk(client=TestOrgVDC._client,
vdc=TestOrgVDC._vdc1,
name=self._idisk_name,
size=self._idisk_size,
description=self._idisk_description)
self.assertIsNotNone(TestOrgVDC._idisk_id)
def test_0090_change_vapp_owner(self):
"""Test the method vapp.change_owner().
This test passes if the owner of the vApp is successfuly changed to the
desired user.
"""
try:
logger = Environment.get_default_logger()
org_admin_client = Environment.get_client_in_default_org(
CommonRoles.ORGANIZATION_ADMINISTRATOR)
vapp_name = TestVApp._empty_vapp_name
vapp = Environment.get_vapp_in_test_vdc(client=org_admin_client,
vapp_name=vapp_name)
vapp_user_name = Environment.get_username_for_role_in_test_org(
CommonRoles.VAPP_USER)
vapp_user_href = Environment.get_user_href_in_test_org(
vapp_user_name)
logger.debug('Changing owner of vApp ' + vapp_name + ' to ' +
vapp_user_name)
vapp.change_owner(vapp_user_href)
vapp.reload()
self.assertEqual(vapp.get_resource().Owner.User.get('name'),
vapp_user_name)
logger.debug('Changing owner of vApp ' + vapp_name + ' back to ' +
TestVApp._empty_vapp_owner_name)
original_owner_href = Environment.get_user_href_in_test_org(
TestVApp._empty_vapp_owner_name)
vapp.change_owner(original_owner_href)
vapp.reload()
self.assertEqual(vapp.get_resource().Owner.User.get('name'),
TestVApp._empty_vapp_owner_name)
finally:
org_admin_client.logout()
def test_9998_teardown(self):
"""Test the method delete_catalog_item() and delete_catalog().
Invoke the methods for templates and catalogs created by setup. This
test should be run as org admin, since a failure in any of the
previous tests might leave the catalog stranded with an user other
than the one who created the catalog in first place.
This test passes if none of the delete operations generate any
exceptions.
"""
try:
org_admin_client = Environment.get_client_in_default_org(
CommonRoles.ORGANIZATION_ADMINISTRATOR)
org = Environment.get_test_org(org_admin_client)
logger = Environment.get_default_logger()
catalog_name = TestCatalog._test_catalog_name
items_to_delete = [
TestCatalog._test_template_name,
TestCatalog._test_template_with_chunk_size_name
]
for item in items_to_delete:
logger.debug('Deleting catalog item : ' + item)
try:
org.delete_catalog_item(catalog_name, item)
except EntityNotFoundException as e:
logger.debug('Catalog item:' + item + ' not found!')
try:
logger.debug('Deleting catalog : ' + catalog_name)
org.delete_catalog(catalog_name)
except EntityNotFoundException as e:
logger.debug('Catalog :' + catalog_name + ' not found!')
finally:
org_admin_client.logout()
def test_9998_teardown(self):
"""Test the method delete_catalog_item() and delete_catalog().
Invoke the methods for templates and catalogs created by setup. This
test should be run as org admin, since a failure in any of the previous
tests might leave the catalog stranded with an user other than the one
who created the catalog in first place.
This test passes if none of the delete operations generate any
exceptions.
"""
try:
org_admin_client = Environment.get_client_in_default_org(
CommonRoles.ORGANIZATION_ADMINISTRATOR)
org = Environment.get_test_org(org_admin_client)
logger = Environment.get_default_logger()
catalog_name = TestCatalog._test_catalog_name
items_to_delete = [
TestCatalog._test_template_name,
TestCatalog._test_template_with_chunk_size_name
]
for item in items_to_delete:
logger.debug('Deleting catalog item : ' + item)
try:
org.delete_catalog_item(catalog_name, item)
except EntityNotFoundException as e:
logger.debug('Catalog item:' + item + ' not found!')
try:
logger.debug('Deleting catalog : ' + catalog_name)
org.delete_catalog(catalog_name)
except EntityNotFoundException as e:
logger.debug('Catalog :' + catalog_name + ' not found!')
finally:
org_admin_client.logout()
def test_0090_change_vapp_owner(self):
"""Test the method vapp.change_owner().
This test passes if the owner of the vApp is successfuly changed to the
desired user.
"""
try:
logger = Environment.get_default_logger()
org_admin_client = Environment.get_client_in_default_org(
CommonRoles.ORGANIZATION_ADMINISTRATOR)
vapp_name = TestVApp._empty_vapp_name
vapp = Environment.get_vapp_in_test_vdc(
client=org_admin_client, vapp_name=vapp_name)
vapp_user_name = Environment.get_username_for_role_in_test_org(
CommonRoles.VAPP_USER)
vapp_user_href = Environment.get_user_href_in_test_org(
vapp_user_name)
logger.debug('Changing owner of vApp ' + vapp_name + ' to ' +
vapp_user_name)
vapp.change_owner(vapp_user_href)
vapp.reload()
self.assertEqual(vapp.get_resource().Owner.User.get('name'),
vapp_user_name)
logger.debug('Changing owner of vApp ' + vapp_name + ' back to ' +
TestVApp._empty_vapp_owner_name)
original_owner_href = Environment.get_user_href_in_test_org(
TestVApp._empty_vapp_owner_name)
vapp.change_owner(original_owner_href)
vapp.reload()
self.assertEqual(vapp.get_resource().Owner.User.get('name'),
TestVApp._empty_vapp_owner_name)
finally:
org_admin_client.logout()
def test_0060_check_result_formats(self):
"""Verify we get expected results for all result formats."""
self._client = Environment.get_client_in_default_org(
CommonRoles.ORGANIZATION_ADMINISTRATOR)
for format in self._result_formats:
# Ensure format works with generator.
q1 = self._client.get_typed_query(
ResourceType.USER.value,
query_result_format=format)
count = 0
for result in q1.execute():
count += 1
self.assertTrue(
count >= 4,
"Expect at least 4 users from generator: {0}".format(format))
# Ensure format works with list built over generator.
q2 = self._client.get_typed_query(
ResourceType.USER.value,
query_result_format=format)
q2_result = list(q2.execute())
self.assertTrue(
len(q2_result) >= 4,
"Expect at least 4 users from list: {0}".format(format))
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._api_version = TestGateway._config['vcd']['api_version']
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: self._ip_address_for_config_ip_setting
}
}
ext_net_to_subnet_with_ip_range = {
ext_net_resource.get('name'): {
subnet_addr: [self._ip_address_for_ip_range]
}
}
ext_net_to_rate_limit = {ext_net_resource.get('name'): {100: 100}}
if float(TestGateway._api_version) <= float(
ApiVersion.VERSION_30.value):
TestGateway._gateway = \
TestGateway._vdc.create_gateway_api_version_30(
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)
elif float(TestGateway._api_version) == float(
ApiVersion.VERSION_31.value):
TestGateway._gateway = \
TestGateway._vdc.create_gateway_api_version_31(
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)
elif float(TestGateway._api_version) >= float(
ApiVersion.VERSION_32.value):
TestGateway._gateway = \
TestGateway._vdc.create_gateway_api_version_32(
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)
TestGateway._extension = Extension(TestGateway._client)
TestGateway._extension.get_resource()
link = find_link(TestGateway._extension.resource, RelationType.DOWN,
EntityType.SYSTEM_SETTINGS.value)
settings = TestGateway._client.get_resource(link.href)
syslog_server_settings = settings.GeneralSettings.SyslogServerSettings
if hasattr(syslog_server_settings,
'{' + NSMAP['vcloud'] + '}SyslogServerIp1'):
return
syslog_server_settings.append(
E.SyslogServerIp1(TestGateway._syslog_server_ip1))
TestGateway._client.put_resource(link.href, settings,
EntityType.SYSTEM_SETTINGS.value)
TestGateway._extension.reload()
settings = TestGateway._client.get_resource(link.href)
self.assertTrue(
hasattr(syslog_server_settings, '{' + NSMAP['vcloud'] +
'}SyslogServerIp1'))
def test_0060_vdc_metadata(self):
"""Test the methods related to metadata manipulation in vdc.py.
This test passes if all the metadata operations are successful.
"""
vapp_author_client = None
sys_admin_client = None
try:
logger = Environment.get_default_logger()
vapp_author_client = Environment.get_client_in_default_org(
CommonRoles.VAPP_AUTHOR)
vdc_vapp_author_view = VDC(client=vapp_author_client,
href=TestOrgVDC._new_vdc_href)
sys_admin_client = Environment.get_sys_admin_client()
vdc_sys_admin_view = VDC(client=sys_admin_client,
href=TestOrgVDC._new_vdc_href)
# try to add new metadata as vapp author
try:
logger.debug(f'Adding metadata [key={TestOrgVDC._metadata_key}'
', value={TestOrgVDC._metadata_value}]) as vApp '
'author')
vdc_vapp_author_view.set_metadata(
key=TestOrgVDC._metadata_key,
value=TestOrgVDC._metadata_value)
self.assertFail('vApp author shouldn\'t have been able to '
'add new metadta entry.')
except OperationNotSupportedException as e:
pass
# add new metadata as sys admin
logger.debug(f'Adding metadata [key={TestOrgVDC._metadata_key},'
'value={TestOrgVDC._metadata_value}]) as Sys admin.')
task = vdc_sys_admin_view.set_metadata(
key=TestOrgVDC._metadata_key,
value=TestOrgVDC._metadata_value)
result = sys_admin_client.get_task_monitor().wait_for_success(task)
self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value)
# retrieve metadata as vapp author
logger.debug(f'Retriving metadata with key='
'{TestOrgVDC._metadata_key} as vApp author.')
metadata_value = vdc_vapp_author_view.get_metadata_value(
key=TestOrgVDC._metadata_key)
self.assertEqual(extract_metadata_value(metadata_value),
TestOrgVDC._metadata_value)
# try to retrieve non existent metadata entry
try:
logger.debug(f'Retriving metadata with invalid key='
'{TestOrgVDC._non_existent_metadata_key} as vApp '
'author')
metadata_value = vdc_vapp_author_view.get_metadata_value(
key=TestOrgVDC._non_existent_metadata_key)
self.assertFail('Shouldn\'t have been able to retrieve metadta'
' entry with bad key.')
except AccessForbiddenException as e:
pass
# try to update metadata value as vapp author
try:
logger.debug(f'Trying to update metadata with key='
'{TestOrgVDC._metadata_key} to value='
'{TestOrgVDC._metadata_new_value} as vApp '
'author.')
vdc_vapp_author_view.set_metadata(
key=TestOrgVDC._metadata_key,
value=TestOrgVDC._metadata_new_value)
self.assertFail('Shouldn\'t have been able to update metadta'
' entry as vApp author.')
except OperationNotSupportedException as e:
pass
# update metadata value as sys admin
logger.debug(f'Updtaing metadata with key='
'{TestOrgVDC._metadata_key} to value='
'{TestOrgVDC._metadata_new_value} as Sys Admin.')
task = vdc_sys_admin_view.set_metadata(
key=TestOrgVDC._metadata_key,
value=TestOrgVDC._metadata_new_value)
sys_admin_client.get_task_monitor().wait_for_success(task)
metadata_value = vdc_sys_admin_view.get_metadata_value(
key=TestOrgVDC._metadata_key)
self.assertEqual(extract_metadata_value(metadata_value),
TestOrgVDC._metadata_new_value)
# try to remove metadata as vapp author
try:
logger.debug(f'Trying to remove metadata with key='
'{TestOrgVDC._metadata_key} as vApp author.')
task = vdc_vapp_author_view.remove_metadata(
key=TestOrgVDC._metadata_key)
self.assertFail('Shouldn\'t have been able to remove metadta '
'entry as vApp author.')
except OperationNotSupportedException as e:
pass
# remove metadata entry as sys admin
logger.debug(f'Removing metadata with '
'key={TestOrgVDC._metadata_key},as Sys Admin.')
task = vdc_sys_admin_view.remove_metadata(
key=TestOrgVDC._metadata_key)
result = sys_admin_client.get_task_monitor().wait_for_success(task)
self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value)
finally:
if sys_admin_client is not None:
sys_admin_client.logout()
if vapp_author_client is not None:
vapp_author_client.logout()
