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_find_existing_with_admin(self):
"""Find entities with admin account with optional filter parameters."""
self._client = Environment.get_sys_admin_client()
resource_type_cc = 'organization'
# Fetch all orgs.
q1 = self._client.get_typed_query(
resource_type_cc,
query_result_format=QueryResultFormat.ID_RECORDS,
qfilter=None)
q1_records = list(q1.execute())
self.assertTrue(
len(q1_records) > 0,
msg="Find at least one organization")
name0 = q1_records[0].get('name')
# Find the org again using an equality filter.
eq_filter = ('name', name0)
q2 = self._client.get_typed_query(
resource_type_cc,
query_result_format=QueryResultFormat.ID_RECORDS,
equality_filter=eq_filter)
q2_records = list(q2.execute())
self.assertEqual(
1, len(q2_records),
msg="Find org with equality filter")
# Find the org again using a query filter string
q3 = self._client.get_typed_query(
resource_type_cc,
query_result_format=QueryResultFormat.ID_RECORDS,
qfilter="name=={0}".format(name0))
q3_records = list(q3.execute())
self.assertEqual(1, len(q3_records),
msg="Find org with query filter")
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_0000_setup(self):
"""Add the sub allocated ip pools to gateway.
This sub allocated ip pools required by the Nat Rule
Invokes the add_sub_allocated_ip_pools of the gateway.
"""
TestNatRule._client = Environment.get_sys_admin_client()
TestNatRule._config = Environment.get_config()
gateway = Environment. \
get_test_gateway(TestNatRule._client)
gateway_obj = Gateway(TestNatRule._client,
TestNatRule._name,
href=gateway.get('href'))
ip_allocations = gateway_obj.list_configure_ip_settings()
ip_allocation = ip_allocations[0]
ext_network = ip_allocation.get('external_network')
config = TestNatRule._config['external_network']
gateway_sub_allocated_ip_range = \
config['gateway_sub_allocated_ip_range']
ip_range_list = [gateway_sub_allocated_ip_range]
task = gateway_obj.add_sub_allocated_ip_pools(ext_network,
ip_range_list)
result = TestNatRule._client.get_task_monitor().wait_for_success(
task=task)
self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value)
gateway_obj = Gateway(TestNatRule._client,
TestNatRule._name,
href=gateway.get('href'))
subnet_participation = self.__get_subnet_participation(
gateway_obj.get_resource(), ext_network)
ip_ranges = gateway_obj.get_sub_allocate_ip_ranges_element(
subnet_participation)
self.__validate_ip_range(ip_ranges, gateway_sub_allocated_ip_range)
def test_0000_setup(self):
"""Load configuration and create a click runner to invoke CLI."""
self._config = Environment.get_config()
GatewayTest._logger = Environment.get_default_logger()
GatewayTest._runner = CliRunner()
default_org = self._config['vcd']['default_org_name']
self._login()
GatewayTest._runner.invoke(org, ['use', default_org])
GatewayTest._api_version = self._config['vcd']['api_version']
GatewayTest._ext_network_name = self._get_first_external_network()
self.client = Environment.get_sys_admin_client()
platform = Platform(self.client)
ext_net_resource = platform.get_external_network(
GatewayTest._ext_network_name)
self.assertTrue(len(ext_net_resource) > 0)
ip_scopes = ext_net_resource.xpath(
'vcloud:Configuration/vcloud:IpScopes/vcloud:IpScope',
namespaces=NSMAP)
first_ipscope = ip_scopes[0]
GatewayTest._gateway_ip = first_ipscope.Gateway.text
prefix_len = netmask_to_cidr_prefix_len(GatewayTest._gateway_ip,
first_ipscope.Netmask.text)
GatewayTest._subnet_addr = GatewayTest._gateway_ip + '/' + str(
prefix_len)
def test_0000_setup(self):
self._config = Environment.get_config()
TestFirewallRule._logger = Environment.get_default_logger()
TestFirewallRule._client = Environment.get_sys_admin_client()
TestFirewallRule._runner = CliRunner()
default_org = self._config['vcd']['default_org_name']
TestFirewallRule._ext_nw = self._config['external_network']['name']
self._login()
TestFirewallRule._runner.invoke(org, ['use', default_org])
result = TestFirewallRule._runner.invoke(
gateway,
args=[
'services', 'firewall', 'create', TestFirewallRule.__name,
'--name', TestFirewallRule.__firewall_rule_name, '--action',
'accept', '--type', 'User', '--enabled', '--logging-enabled'
])
self.assertEqual(0, result.exit_code)
gateway_res = Environment.get_test_gateway(TestFirewallRule._client)
gateway_obj = Gateway(TestFirewallRule._client,
href=gateway_res.get('href'))
firewall_rules = gateway_obj.get_firewall_rules()
for rule in firewall_rules.firewallRules.firewallRule:
if rule.name == TestFirewallRule.__firewall_rule_name:
TestFirewallRule._rule_id = rule.id
break
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_0000_setup(self):
self._config = Environment.get_config()
TestFirewallRule._logger = Environment.get_default_logger()
TestFirewallRule._client = Environment.get_sys_admin_client()
TestFirewallRule._runner = CliRunner()
default_org = self._config['vcd']['default_org_name']
TestFirewallRule._ext_nw = self._config['external_network']['name']
self._login()
TestFirewallRule._runner.invoke(org, ['use', default_org])
result = TestFirewallRule._runner.invoke(
gateway,
args=[
'services', 'firewall', 'create', TestFirewallRule.__name,
'--name', TestFirewallRule.__firewall_rule_name, '--action',
'accept', '--type', 'User', '--enabled', '--logging-enabled'
])
self.assertEqual(0, result.exit_code)
gateway_res = Environment.get_test_gateway(TestFirewallRule._client)
gateway_obj = Gateway(
TestFirewallRule._client, href=gateway_res.get('href'))
firewall_rules = gateway_obj.get_firewall_rules()
for rule in firewall_rules.firewallRules.firewallRule:
if rule.name == TestFirewallRule.__firewall_rule_name:
TestFirewallRule._rule_id = rule.id
break
def test_0000_setup(self):
self._config = Environment.get_config()
TestVappNat._logger = Environment.get_default_logger()
TestVappNat._client = Environment.get_sys_admin_client()
TestVappNat._runner = CliRunner()
default_org = self._config['vcd']['default_org_name']
self._login()
TestVappNat._runner.invoke(org, ['use', default_org])
vapp = Environment.get_test_vapp_with_network(TestVappNat._client)
vapp.reload()
task = vapp.connect_vapp_network_to_ovdc_network(
network_name=TestVappNat._vapp_network_name,
orgvdc_network_name=TestVappNat._org_vdc_network_name)
result = TestVappNat._client.get_task_monitor().wait_for_success(task)
self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value)
vm_resource = vapp.get_vm(TestVappNat._vm_name)
vm = VM(TestVappNat._client, resource=vm_resource)
task = vm.add_nic(NetworkAdapterType.E1000.value, True, True,
TestVappNat._vapp_network_name,
IpAddressMode.MANUAL.value,
TestVappNat._allocate_ip_address)
result = TestVappNat._client.get_task_monitor().wait_for_success(task)
self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value)
list_vm_interface = vapp.list_vm_interface(
TestVappNat._vapp_network_name)
for vm_interface in list_vm_interface:
TestVappNat._vm_id = str(vm_interface['Local_id'])
TestVappNat._vm_nic_id = str(vm_interface['VmNicId'])
def test_0000_setup(self):
"""Add the sub allocated ip pools to gateway.
This sub allocated ip pools required by the Nat Rule
Invokes the add_sub_allocated_ip_pools of the gateway.
"""
TestNatRule._client = Environment.get_sys_admin_client()
TestNatRule._config = Environment.get_config()
gateway = Environment. \
get_test_gateway(TestNatRule._client)
gateway_obj = Gateway(TestNatRule._client,
TestNatRule._name,
href=gateway.get('href'))
ip_allocations = gateway_obj.list_configure_ip_settings()
ip_allocation = ip_allocations[0]
ext_network = ip_allocation.get('external_network')
config = TestNatRule._config['external_network']
gateway_sub_allocated_ip_range = \
config['gateway_sub_allocated_ip_range']
ip_range_list = [gateway_sub_allocated_ip_range]
task = gateway_obj.add_sub_allocated_ip_pools(ext_network,
ip_range_list)
result = TestNatRule._client.get_task_monitor().wait_for_success(
task=task)
self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value)
gateway_obj = Gateway(TestNatRule._client,
TestNatRule._name,
href=gateway.get('href'))
subnet_participation = self.__get_subnet_participation(
gateway_obj.get_resource(), ext_network)
ip_ranges = gateway_obj.get_sub_allocate_ip_ranges_element(
subnet_participation)
self.__validate_ip_range(ip_ranges, gateway_sub_allocated_ip_range)
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)
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)
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)
def test_0010_find_existing_with_admin(self):
"""Find entities with admin account with optional filter parameters."""
self._client = Environment.get_sys_admin_client()
resource_type_cc = 'organization'
# Fetch all orgs.
q1 = self._client.get_typed_query(
resource_type_cc,
query_result_format=QueryResultFormat.ID_RECORDS,
qfilter=None)
q1_records = list(q1.execute())
self.assertTrue(len(q1_records) > 0,
msg="Find at least one organization")
name0 = q1_records[0].get('name')
# Find the org again using an equality filter.
eq_filter = ('name', name0)
q2 = self._client.get_typed_query(
resource_type_cc,
query_result_format=QueryResultFormat.ID_RECORDS,
equality_filter=eq_filter)
q2_records = list(q2.execute())
self.assertEqual(1,
len(q2_records),
msg="Find org with equality filter")
# Find the org again using a query filter string
q3 = self._client.get_typed_query(
resource_type_cc,
query_result_format=QueryResultFormat.ID_RECORDS,
qfilter="name=={0}".format(name0))
q3_records = list(q3.execute())
self.assertEqual(1, len(q3_records), msg="Find org with query filter")
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):
# TODO(): need more pipeline work before this test can actually be run
TestPVDC._client = Environment.get_sys_admin_client()
TestPVDC._config = Environment.get_config()
TestPVDC._vcenter_host_name = self._config['vc']['vcenter_host_name']
TestPVDC._pvdc_name = self._config['pvdc']['pvdc_name']
TestPVDC._resource_pool_names = \
self._config['pvdc']['resource_pool_names']
def test_0000_setup(self):
TestVappFirewall._client = Environment.get_sys_admin_client()
vapp = Environment.get_test_vapp_with_network(TestVappFirewall._client)
vapp.reload()
task = vapp.connect_vapp_network_to_ovdc_network(
network_name=TestVappFirewall._network_name,
orgvdc_network_name=TestVappFirewall._org_vdc_network_name)
result = TestVappFirewall._client.get_task_monitor().wait_for_success(
task)
self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value)
def test_0000_setup(self):
self._config = Environment.get_config()
TestVappDhcp._logger = Environment.get_default_logger()
TestVappDhcp._client = Environment.get_sys_admin_client()
TestVappDhcp._runner = CliRunner()
default_org = self._config['vcd']['default_org_name']
self._login()
TestVappDhcp._runner.invoke(org, ['use', default_org])
vapp = Environment.get_test_vapp_with_network(TestVappDhcp._client)
self.assertIsNotNone(vapp)
def test_0000_setup(self):
TestVappFirewall._client = Environment.get_sys_admin_client()
vapp = Environment.get_test_vapp_with_network(TestVappFirewall._client)
vapp.reload()
TestVappFirewall._network_name = \
Environment.get_default_orgvdc_network_name()
task = vapp.connect_org_vdc_network(
TestVappFirewall._network_name,
fence_mode=FenceMode.NAT_ROUTED.value)
result = TestVappFirewall._client.get_task_monitor().wait_for_success(
task)
self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value)
def test_cleanup(self):
"""Get the test Org and delete it"""
client = Environment.get_sys_admin_client()
test_org = Environment.get_test_org(client)
print("Deleting test org: {0}".format(test_org.get_name()))
sys_admin_resource = client.get_admin()
system = System(client, admin_resource=sys_admin_resource)
task = system.delete_org(test_org.get_name(), True, True)
# Track the task to completion.
task = client.get_task_monitor().wait_for_success(task)
self.assertEqual(task.get('status'), TaskStatus.SUCCESS.value)
def test_0000_setup(self):
TestCaCertificates._client = Environment.get_sys_admin_client()
TestCaCertificates._config = Environment.get_config()
TestCaCertificates._org = Environment.get_test_org(
TestCaCertificates._client)
test_gateway = Environment.get_test_gateway(TestCaCertificates._client)
gateway_obj1 = Gateway(TestCaCertificates._client, GatewayConstants.name,
href=test_gateway.get('href'))
TestCaCertificates.gateway_obj = gateway_obj1
TestCaCertificates._runner = CliRunner()
default_org = self._config['vcd']['default_org_name']
self._login()
TestCaCertificates._runner.invoke(org, ['use', default_org])
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.
"""
logger = Environment.get_default_logger()
TestGateway._client = Environment.get_sys_admin_client()
vdc = Environment.get_test_vdc(TestGateway._client)
platform = Platform(TestGateway._client)
external_networks = platform.list_external_networks()
self.assertTrue(len(external_networks) > 0)
external_network = external_networks[0]
ext_net_resource = TestGateway._client.get_resource(
external_network.get('href'))
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
subnet_addr = gateway_ip + '/' + str(first_ipscope.SubnetPrefixLength)
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 = 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):
"""
Create one external network as per the configuration stated aboveself.
Choose first unused port group which is not a VxLAN. Unused port groups
have network names set to '--'. VxLAN port groups have name starting
with 'vxw-'.
Test the method Platform.create_external_network().
This test passes if external network is created successfully.
"""
logger = Environment.get_default_logger()
TestExtNet._sys_admin_client = Environment.get_sys_admin_client()
TestExtNet._config = Environment.get_config()
platform = Platform(TestExtNet._sys_admin_client)
vc_name = TestExtNet._config['vc']['vcenter_host_name']
name_filter = ('vcName', vc_name)
query = TestExtNet._sys_admin_client.get_typed_query(
ResourceType.PORT_GROUP.value,
query_result_format=QueryResultFormat.RECORDS,
equality_filter=name_filter)
for record in list(query.execute()):
if record.get('networkName') == '--':
if not record.get('name').startswith('vxw-'):
TestExtNet._port_group = record.get('name')
break
self.assertIsNotNone(self._port_group,
'None of the port groups are free.')
ext_net = platform.create_external_network(
name=TestExtNet._name,
vim_server_name=vc_name,
port_group_names=[TestExtNet._port_group],
gateway_ip=TestExtNet._gateway,
netmask=TestExtNet._netmask,
ip_ranges=[TestExtNet._ip_range],
description=TestExtNet._description,
primary_dns_ip=TestExtNet._dns1,
secondary_dns_ip=TestExtNet._dns2,
dns_suffix=TestExtNet._dns_suffix)
task = ext_net.find('vcloud:Tasks', NSMAP).Task[0]
TestExtNet._sys_admin_client.get_task_monitor().wait_for_success(
task=task)
logger.debug('Created external network ' + TestExtNet._name + '.')
def test_0000_setup(self):
TestCertificates._client = Environment.get_sys_admin_client()
TestCertificates._config = Environment.get_config()
TestCertificates._org = Environment.get_test_org(
TestCertificates._client)
test_gateway = Environment.get_test_gateway(TestCertificates._client)
gateway_obj1 = Gateway(TestCertificates._client,
GatewayConstants.name,
href=test_gateway.get('href'))
TestCertificates.gateway_obj = gateway_obj1
TestCertificates._runner = CliRunner()
default_org = self._config['vcd']['default_org_name']
self._login()
TestCertificates._runner.invoke(org, ['use', default_org])
def test_0000_setup(self):
# TODO(): need more pipeline work before this test can actually be run
TestVC._client = Environment.get_sys_admin_client()
TestVC._config = Environment.get_config()
TestVC._vcenter_host_name = self._config['vc']['vcenter_host_name']
TestVC._vcenter_invalid = 'xyz'
TestVC._vcServerName = self._config['vc']['vcServerName']
TestVC._vcServerHost = self._config['vc']['vcServerHost']
TestVC._vcAdminUser = self._config['vc']['vcAdminUser']
TestVC._vcAdminPwd = self._config['vc']['vcAdminPwd']
TestVC._NSXServerName = self._config['vc']['NSXServerName']
TestVC._NSXHost = self._config['vc']['NSXHost']
TestVC._NSXAdminUser = self._config['vc']['NSXAdminUser']
TestVC._NSXAdminPwd = self._config['vc']['NSXAdminPwd']
TestVC._isEnabled = False
def test_0000_setup(self):
# TODO(): need more pipeline work before this test can actually be run
TestVC._client = Environment.get_sys_admin_client()
TestVC._config = Environment.get_config()
TestVC._vcenter_host_name = self._config['vc']['vcenter_host_name']
TestVC._vcenter_invalid = 'xyz'
TestVC._vcServerName = self._config['vc']['vcServerName']
TestVC._vcServerHost = self._config['vc']['vcServerHost']
TestVC._vcAdminUser = self._config['vc']['vcAdminUser']
TestVC._vcAdminPwd = self._config['vc']['vcAdminPwd']
TestVC._NSXServerName = self._config['vc']['NSXServerName']
TestVC._NSXHost = self._config['vc']['NSXHost']
TestVC._NSXAdminUser = self._config['vc']['NSXAdminUser']
TestVC._NSXAdminPwd = self._config['vc']['NSXAdminPwd']
TestVC._isEnabled = False
def test_0000_setup(self):
"""Add one orgvdc, one gateways and one routed orgvdc networks.
"""
TestIpSecVpn._client = Environment.get_sys_admin_client()
TestIpSecVpn._config = Environment.get_config()
TestIpSecVpn._org = Environment.get_test_org(TestIpSecVpn._client)
TestIpSecVpn._pvdc_name = Environment.get_test_pvdc_name()
TestIpSecVpn._ext_config = TestIpSecVpn._config['external_network']
TestIpSecVpn._ext_net_name = TestIpSecVpn._ext_config['name']
# Create another vdc, gateway and routed network
self.__create_ovdc()
self.__create_advanced_gateway()
self.__create_routed_ovdc_network()
def test_0041_detach_port_group(self):
"""Detach port group from an external network.
Invoke the command 'external detach-port-group' in network.
"""
ExtNetTest._client = Environment.get_sys_admin_client()
port_group_helper = PortgroupHelper(ExtNetTest._client)
vc_name = self._config['vc2']['vcenter_host_name']
pg_name = port_group_helper. \
get_ext_net_used_portgroup_name(vc_name, self._name)
result = self._runner.invoke(external,
args=[
'detach-port-group', self._name,
'--vc-name', vc_name, '--port-group',
pg_name
])
self.assertEqual(0, result.exit_code)
def test_0050_check_all_resource_types(self):
"""Verify that we can search on any resource type without error."""
self._client = Environment.get_sys_admin_client()
api_version = float(self._client.get_api_version())
# only admin version visible to sys admin in /api/query
allowed_exceptions = [
ResourceType.ALLOCATED_EXTERNAL_ADDRESS,
ResourceType.CATALOG_ITEM,
ResourceType.DISK,
ResourceType.GROUP,
ResourceType.ORG_NETWORK,
ResourceType.ORG_VDC_STORAGE_PROFILE,
ResourceType.USER,
ResourceType.VAPP_NETWORK,
ResourceType.VM_DISK_RELATION]
if api_version < 30.0:
# links added in api v30.0
allowed_exceptions.append(ResourceType.CATALOG)
allowed_exceptions.append(ResourceType.MEDIA)
allowed_exceptions.append(ResourceType.ORG_VDC)
allowed_exceptions.append(ResourceType.VAPP)
allowed_exceptions.append(ResourceType.VAPP_TEMPLATE)
allowed_exceptions.append(ResourceType.VM)
else:
# features deprecated in api v30.0
allowed_exceptions.append(
ResourceType.ADMIN_ORG_NETWORK)
allowed_exceptions.append(
ResourceType.ADMIN_ALLOCATED_EXTERNAL_ADDRESS)
if api_version < 31.0:
# feature introduced in api v31.0
allowed_exceptions.append(ResourceType.NSXT_MANAGER)
resource_types = [r.value for r in ResourceType
if r not in allowed_exceptions]
# All typed queries apart from the allowed_exceptions shouldn't 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 empty")
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_0000_setup(self):
"""Setup a Org required for other tests in this module.
Create an Org as per the configuration stated above. Tests
System.create_org() method.
This test passes if org href is not None.
"""
TestOrg._client = Environment.get_sys_admin_client()
sys_admin_resource = TestOrg._client.get_admin()
system = System(TestOrg._client, admin_resource=sys_admin_resource)
result = system.create_org(TestOrg._new_org_name,
TestOrg._new_org_full_name,
TestOrg._new_org_enabled)
TestOrg._new_org_admin_href = result.get('href')
self.assertIsNotNone(TestOrg._new_org_admin_href)
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):
self._config = Environment.get_config()
TestVappFirewall._logger = Environment.get_default_logger()
TestVappFirewall._client = Environment.get_sys_admin_client()
TestVappFirewall._runner = CliRunner()
default_org = self._config['vcd']['default_org_name']
self._login()
TestVappFirewall._runner.invoke(org, ['use', default_org])
vapp = Environment.get_test_vapp_with_network(TestVappFirewall._client)
vapp.reload()
task = vapp.connect_vapp_network_to_ovdc_network(
network_name=TestVappFirewall._vapp_network_name,
orgvdc_network_name=TestVappFirewall._org_vdc_network_name)
result = TestVappFirewall._client.get_task_monitor().wait_for_success(
task)
self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value)
def test_0040_attach_port_group(self):
"""Attach a portgroup to an external network.
Invoke the command 'external attach-port-group' in network.
"""
ExtNetTest._client = Environment.get_sys_admin_client()
port_group_helper = PortgroupHelper(ExtNetTest._client)
vc_name = self._config['vc2']['vcenter_host_name']
pg_name = port_group_helper. \
get_available_portgroup_name(vc_name, ExtNetTest._portgroupType)
result = self._runner.invoke(external,
args=[
'attach-port-group', self._name,
'--vc-name', vc_name, '--port-group',
pg_name
])
self.assertEqual(0, result.exit_code)
def test_0000_setup(self):
"""Add one orgvdc, one gateways and one routed orgvdc networks.
"""
TestIpSecVpn._client = Environment.get_sys_admin_client()
TestIpSecVpn._logger = Environment.get_default_logger()
TestIpSecVpn._config = Environment.get_config()
TestIpSecVpn._org = Environment.get_test_org(TestIpSecVpn._client)
TestIpSecVpn._pvdc_name = Environment.get_test_pvdc_name()
TestIpSecVpn._ext_config = TestIpSecVpn._config['external_network']
TestIpSecVpn._ext_net_name = TestIpSecVpn._ext_config['name']
# Create another vdc, gateway and routed network
self.__create_ovdc()
self.__create_advanced_gateway()
self.__create_routed_ovdc_network()
test_gateway = Environment.get_test_gateway(TestIpSecVpn._client)
gateway_obj1 = Gateway(TestIpSecVpn._client,
GatewayConstants.name,
href=test_gateway.get('href'))
gateway_obj2 = TestIpSecVpn._gateway_obj
TestIpSecVpn._local_ip = self.__get_ip_address(
gateway=gateway_obj1, ext_net_name=TestIpSecVpn._ext_net_name)
TestIpSecVpn._peer_ip = self.__get_ip_address(
gateway=gateway_obj2, ext_net_name=TestIpSecVpn._ext_net_name)
TestIpSecVpn._runner = CliRunner()
default_org = self._config['vcd']['default_org_name']
self._login()
TestIpSecVpn._runner.invoke(org, ['use', default_org])
from vcd_cli.gateway import gateway
result = TestIpSecVpn._runner.invoke(
gateway,
args=[
'services', 'ipsec-vpn', 'create', TestIpSecVpn._name,
'--name', TestIpSecVpn._ipsec_vpn_name, '--local-id',
TestIpSecVpn._local_id, '--peer-id', TestIpSecVpn._peer_id,
'--local-ip', TestIpSecVpn._local_ip, '--peer-ip',
TestIpSecVpn._peer_ip, '--local-subnet',
TestIpSecVpn._local_subnet, '--peer-subnet',
TestIpSecVpn._peer_subnet, '--pre-shared-key',
TestIpSecVpn._psk, '--enable'
])
self.assertEqual(0, result.exit_code)
def test_0041_detach_port_group(self):
"""Detach port group from an external network.
Invoke the command 'external detach-port-group' in network.
"""
if ExtNetTest._vc2_host_ip is None or ExtNetTest._vc2_host_ip == '':
return
ExtNetTest._client = Environment.get_sys_admin_client()
port_group_helper = PortgroupHelper(ExtNetTest._client)
vc_name = self._config['vc2']['vcenter_host_name']
pg_name = port_group_helper. \
get_ext_net_used_portgroup_name(vc_name, self._name)
result = self._runner.invoke(
external,
args=[
'detach-port-group', self._name, '--vc', vc_name,
'--port-group', pg_name
])
self.assertEqual(0, result.exit_code)
def test_0026_add_dhcp_pool(self):
"""Add DHCP pool in the gateway.
Invokes the add_dhcp_pool of the gateway.
"""
gateway_obj = Gateway(
TestGateway._client, self._name,
Environment.get_test_gateway(
Environment.get_sys_admin_client()).get('href'))
gateway_obj.add_dhcp_pool(TestGateway._pool_ip_range)
dhcp_resource = gateway_obj.get_dhcp()
# Verify
matchFound = False
for ipPool in dhcp_resource.ipPools.ipPool:
if ipPool.ipRange.text == TestGateway._pool_ip_range:
matchFound = True
break
self.assertTrue(matchFound)
def test_0100_add_dhcp_pool(self):
"""Add DHCP pool in the gateway.
Invokes the add_dhcp_pool of the gateway.
"""
gateway_obj = Gateway(
TestGateway._client, self._name,
Environment.get_test_gateway(Environment.get_sys_admin_client())
.get('href'))
gateway_obj.add_dhcp_pool(TestGateway._pool_ip_range)
dhcp_resource = gateway_obj.get_dhcp()
# Verify
matchFound = False
for ipPool in dhcp_resource.ipPools.ipPool:
if ipPool.ipRange.text == TestGateway._pool_ip_range:
matchFound = True
break
self.assertTrue(matchFound)
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)
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)
def test_cleanup(self):
"""Get the test Org and delete it."""
client = None
try:
logger = Environment.get_default_logger()
client = Environment.get_sys_admin_client()
test_org = Environment.get_test_org(client)
logger.debug('Deleting test org: {0}'.format(test_org.get_name()))
sys_admin_resource = client.get_admin()
system = System(client, admin_resource=sys_admin_resource)
task = system.delete_org(test_org.get_name(), True, True)
# Track the task to completion.
result = client.get_task_monitor().wait_for_success(task)
self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value)
finally:
if client is not None:
client.logout()
def test_0000_setup(self):
"""Add one orgvdc, one gateways and one routed orgvdc networks.
"""
TestIpSecVpn._client = Environment.get_sys_admin_client()
TestIpSecVpn._logger = Environment.get_default_logger()
TestIpSecVpn._config = Environment.get_config()
TestIpSecVpn._org = Environment.get_test_org(TestIpSecVpn._client)
TestIpSecVpn._pvdc_name = Environment.get_test_pvdc_name()
TestIpSecVpn._ext_config = TestIpSecVpn._config['external_network']
TestIpSecVpn._ext_net_name = TestIpSecVpn._ext_config['name']
# Create another vdc, gateway and routed network
self.__create_ovdc()
self.__create_advanced_gateway()
self.__create_routed_ovdc_network()
test_gateway = Environment.get_test_gateway(TestIpSecVpn._client)
gateway_obj1 = Gateway(TestIpSecVpn._client, GatewayConstants.name,
href=test_gateway.get('href'))
gateway_obj2 = TestIpSecVpn._gateway_obj
TestIpSecVpn._local_ip = self.__get_ip_address(
gateway=gateway_obj1, ext_net_name=TestIpSecVpn._ext_net_name)
TestIpSecVpn._peer_ip = self.__get_ip_address(
gateway=gateway_obj2, ext_net_name=TestIpSecVpn._ext_net_name)
TestIpSecVpn._runner = CliRunner()
default_org = self._config['vcd']['default_org_name']
self._login()
TestIpSecVpn._runner.invoke(org, ['use', default_org])
result = TestIpSecVpn._runner.invoke(
gateway,
args=[
'services', 'ipsec-vpn', 'create', TestIpSecVpn._name,
'--name', TestIpSecVpn._ipsec_vpn_name,
'--local-id', TestIpSecVpn._local_id,
'--peer-id', TestIpSecVpn._peer_id,
'--local-ip', TestIpSecVpn._local_ip,
'--peer-ip', TestIpSecVpn._peer_ip,
'--local-subnet', TestIpSecVpn._local_subnet,
'--peer-subnet', TestIpSecVpn._peer_subnet,
'--pre-shared-key', TestIpSecVpn._psk, '--enable'])
self.assertEqual(0, result.exit_code)
def test_cleanup(self):
"""Get the test Org and delete it."""
client = None
try:
logger = Environment.get_default_logger()
client = Environment.get_sys_admin_client()
test_org = Environment.get_test_org(client)
logger.debug('Deleting test org: {0}'.format(test_org.get_name()))
sys_admin_resource = client.get_admin()
system = System(client, admin_resource=sys_admin_resource)
task = system.delete_org(test_org.get_name(), True, True)
# Track the task to completion.
result = client.get_task_monitor().wait_for_success(task)
self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value)
finally:
if client is not None:
client.logout()
def test_0000_setup(self):
"""
Create one external network as per the configuration stated aboveself.
Choose first unused port group which is not a VxLAN. Unused port groups
have network names set to '--'. VxLAN port groups have name starting
with 'vxw-'.
Test the method Platform.create_external_network().
This test passes if external network is created successfully.
"""
logger = Environment.get_default_logger()
TestExtNet._sys_admin_client = Environment.get_sys_admin_client()
TestExtNet._config = Environment.get_config()
TestExtNet._common_ext_net_name = TestExtNet._config[
'external_network']['name']
platform = Platform(TestExtNet._sys_admin_client)
vc_name = TestExtNet._config['vc']['vcenter_host_name']
TestExtNet._vc2_host_ip = TestExtNet._config['vc2']['vcenter_host_ip']
portgrouphelper = PortgroupHelper(TestExtNet._sys_admin_client)
pg_name = portgrouphelper.get_available_portgroup_name(
vc_name, TestExtNet._portgroupType)
ext_net = platform.create_external_network(
name=TestExtNet._name,
vim_server_name=vc_name,
port_group_names=[pg_name],
gateway_ip=TestExtNet._gateway,
netmask=TestExtNet._netmask,
ip_ranges=[TestExtNet._ip_range],
description=TestExtNet._description,
primary_dns_ip=TestExtNet._dns1,
secondary_dns_ip=TestExtNet._dns2,
dns_suffix=TestExtNet._dns_suffix)
task = ext_net['{' + NSMAP['vcloud'] + '}Tasks'].Task[0]
TestExtNet._sys_admin_client.get_task_monitor().wait_for_success(
task=task)
logger.debug('Created external network ' + TestExtNet._name + '.')
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()
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.reload()
for vdc in org.list_vdcs():
if vdc.get('name').lower() == vdc_name.lower():
TestOrgVDC._new_vdc_href = vdc.get('href')
self.assertIsNotNone(TestOrgVDC._new_vdc_href)
def test_0000_setup(self):
"""
Create one external network as per the configuration stated aboveself.
Choose first unused port group which is not a VxLAN. Unused port groups
have network names set to '--'. VxLAN port groups have name starting
with 'vxw-'.
Test the method Platform.create_external_network().
This test passes if external network is created successfully.
"""
logger = Environment.get_default_logger()
TestExtNet._sys_admin_client = Environment.get_sys_admin_client()
TestExtNet._config = Environment.get_config()
TestExtNet._common_ext_net_name = TestExtNet._config[
'external_network']['name']
platform = Platform(TestExtNet._sys_admin_client)
vc_name = TestExtNet._config['vc']['vcenter_host_name']
TestExtNet._vc2_host_ip = TestExtNet._config['vc2']['vcenter_host_ip']
portgrouphelper = PortgroupHelper(TestExtNet._sys_admin_client)
pg_name = portgrouphelper.get_available_portgroup_name(
vc_name, TestExtNet._portgroupType)
ext_net = platform.create_external_network(
name=TestExtNet._name,
vim_server_name=vc_name,
port_group_names=[pg_name],
gateway_ip=TestExtNet._gateway,
netmask=TestExtNet._netmask,
ip_ranges=[TestExtNet._ip_range],
description=TestExtNet._description,
primary_dns_ip=TestExtNet._dns1,
secondary_dns_ip=TestExtNet._dns2,
dns_suffix=TestExtNet._dns_suffix)
task = ext_net['{' + NSMAP['vcloud'] + '}Tasks'].Task[0]
TestExtNet._sys_admin_client.get_task_monitor().wait_for_success(
task=task)
logger.debug('Created external network ' + TestExtNet._name + '.')
def test_0025_set_server_version(self):
"""Login can set any API version supported by server
"""
# Use a pyvcloud client to find out the supported versions.
client = Environment.get_sys_admin_client()
server_versions = client.get_supported_versions_list()
client.logout()
# Use the aforesaid versions and login/logout to each.
for server_version in server_versions:
self._logger.debug(
"Login using server API version {0}".format(server_version))
login_args = [
self._host, self._org, self._admin_user, "-i", "--password",
self._admin_pass, "-w", "--version", server_version
]
result = self._runner.invoke(login, args=login_args)
self.assertEqual(0, result.exit_code)
self.assertTrue("logged in" in result.output)
self._logout()
def test_0025_set_server_version(self):
"""Login can set any API version supported by server
"""
# Use a pyvcloud client to find out the supported versions.
client = Environment.get_sys_admin_client()
server_versions = client.get_supported_versions_list()
client.logout()
# Use the aforesaid versions and login/logout to each.
for server_version in server_versions:
self._logger.debug(
"Login using server API version {0}".format(server_version))
login_args = [
self._host, self._org, self._admin_user, "-i", "--password",
self._admin_pass, "-w", "--version", server_version
]
result = self._runner.invoke(login, args=login_args)
self.assertEqual(0, result.exit_code)
self.assertTrue("logged in" in result.output)
self._logout()
def test_0000_setup(self):
"""Setup a Org required for other tests in this module.
Create an Org as per the configuration stated above. Tests
System.create_org() method.
This test passes if org href is not None.
"""
TestUser._client = Environment.get_sys_admin_client()
sys_admin_resource = TestUser._client.get_admin()
system = System(TestUser._client, admin_resource=sys_admin_resource)
result = system.create_org(TestUser._new_org_name,
TestUser._new_org_full_name,
TestUser._new_org_enabled)
TestUser._new_org_admin_href = result.get('href')
TestUser._org = Org(TestUser._client,
href=TestUser._new_org_admin_href)
self.assertIsNotNone(TestUser._new_org_admin_href)
def test_0105_add_dhcp_binding(self):
"""Add DHCP Binding in the gateway.
Invokes the add_dhcp_binding of the gateway.
"""
gateway_obj = Gateway(
TestGateway._client, self._name,
Environment.get_test_gateway(Environment.get_sys_admin_client())
.get('href'))
gateway_obj.add_dhcp_binding(TestGateway._mac_address,
TestGateway._host_name,
TestGateway._binding_ip_address)
dhcp_resource = gateway_obj.get_dhcp()
# Verify
matchFound = False
for static_binding in dhcp_resource.staticBindings.staticBinding:
if static_binding.macAddress.text == TestGateway._mac_address:
matchFound = True
break
self.assertTrue(matchFound)
def test_0000_setup(self):
self._config = Environment.get_config()
TestVappFirewall._logger = Environment.get_default_logger()
TestVappFirewall._client = Environment.get_sys_admin_client()
TestVappFirewall._runner = CliRunner()
default_org = self._config['vcd']['default_org_name']
self._login()
TestVappFirewall._runner.invoke(org, ['use', default_org])
vapp = Environment.get_test_vapp_with_network(TestVappFirewall._client)
vapp.reload()
TestVappFirewall._vapp_network_name = \
Environment.get_default_orgvdc_network_name()
task = vapp.connect_org_vdc_network(
TestVappFirewall._vapp_network_name,
fence_mode=FenceMode.NAT_ROUTED.value)
result = TestVappFirewall._client.get_task_monitor().wait_for_success(
task)
self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value)
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_0000_setup(self):
"""Add DHCP pool in the gateway.
Invokes the add_dhcp_pool of the gateway.
"""
TestDhcp._client = Environment.get_sys_admin_client()
TestDhcp._config = Environment.get_config()
gateway = Environment. \
get_test_gateway(TestDhcp._client)
gateway_obj = Gateway(TestDhcp._client,
TestDhcp._name,
href=gateway.get('href'))
gateway_obj.add_dhcp_pool(TestDhcp._pool_ip_range)
dhcp_resource = gateway_obj.get_dhcp()
# Verify
matchFound = False
for ipPool in dhcp_resource.ipPools.ipPool:
if ipPool.ipRange.text == TestDhcp._pool_ip_range:
matchFound = True
break
self.assertTrue(matchFound)
def test_0000_setup(self):
"""Setup an api extension service required by the other tests.
Register two services as per the configuration stated above. Tests
APIExtension.add_extension() method.
This test passes if service hrefs are not None.
"""
logger = Environment.get_default_logger()
TestApiExtension._client = Environment.get_sys_admin_client()
api_extension = APIExtension(TestApiExtension._client)
# Create two services with same name but diffent namespaces
logger.debug('Registering service (name:' +
TestApiExtension._service_name + ', namespace:' +
TestApiExtension._service1_namespace + ').')
registered_extension = api_extension.add_extension(
name=TestApiExtension._service_name,
namespace=TestApiExtension._service1_namespace,
routing_key=TestApiExtension._service_routing_key,
exchange=TestApiExtension._service_exchange,
patterns=TestApiExtension._service_patterns)
TestApiExtension._service1_href = registered_extension.get('href')
self.assertIsNotNone(TestApiExtension._service1_href)
logger.debug('Registering service (name:' +
TestApiExtension._service_name + ', namespace:' +
TestApiExtension._service2_namespace + ').')
registered_extension = api_extension.add_extension(
name=TestApiExtension._service_name,
namespace=TestApiExtension._service2_namespace,
routing_key=TestApiExtension._service_routing_key,
exchange=TestApiExtension._service_exchange,
patterns=TestApiExtension._service_patterns)
TestApiExtension._service2_href = registered_extension.get('href')
self.assertIsNotNone(TestApiExtension._service2_href)
def test_0000_setup(self):
"""Add Static Route in the gateway.
Invokes the add_static_route of the gateway.
"""
TestStaticRoute._client = Environment.get_sys_admin_client()
TestStaticRoute._config = Environment.get_config()
gateway = Environment. \
get_test_gateway(TestStaticRoute._client)
gateway_obj = Gateway(TestStaticRoute._client,
TestStaticRoute._name,
href=gateway.get('href'))
gateway_obj.add_static_route(TestStaticRoute._network,
TestStaticRoute._next_hop)
static_route = gateway_obj.get_static_routes()
#Verify
match_found = False
for route in static_route.staticRoutes.route:
if route.nextHop == TestStaticRoute._next_hop and \
route.network == TestStaticRoute._network:
TestStaticRoute._network_id = route.network
match_found = True
break
self.assertTrue(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])
def test_0010_create(self):
"""Create an external network as per configuration stated above.
Choose first unused port group which is not a VxLAN. Unused port groups
have network names set to '--'. VxLAN port groups have name starting
with 'vxw-'.
Invoke the command 'external create' in network.
"""
vc_name = self._config['vc']['vcenter_host_name']
name_filter = ('vcName', vc_name)
sys_admin_client = Environment.get_sys_admin_client()
query = sys_admin_client.get_typed_query(
ResourceType.PORT_GROUP.value,
query_result_format=QueryResultFormat.RECORDS,
equality_filter=name_filter)
for record in list(query.execute()):
if record.get('networkName') == '--':
if not record.get('name').startswith('vxw-'):
self._port_group = record.get('name')
break
self.assertIsNotNone(self._port_group,
'None of the port groups are free.')
result = self._runner.invoke(
external,
args=[
'create', self._name, '--vc', vc_name, '--port-group',
self._port_group, '--gateway', self._gateway, '--netmask',
self._netmask, '--ip-range', self._ip_range, '--description',
self._description, '--dns1', self._dns1, '--dns2', self._dns2,
'--dns-suffix', self._dns_suffix
])
self.assertEqual(0, result.exit_code)
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()
TestPVDC._sys_admin_client = Environment.get_sys_admin_client()
org = Environment.get_test_org(TestPVDC._sys_admin_client)
platform = Platform(TestPVDC._sys_admin_client)
vdc_name = TestPVDC._new_vdc_name
pvdc_name = Environment.get_test_pvdc_name()
provider_vdc = platform.get_ref_by_name(ResourceType.PROVIDER_VDC,
pvdc_name)
pvdc_ext_href = get_admin_extension_href(provider_vdc.get('href'))
pvdc_ext_resource = TestPVDC._sys_admin_client.get_resource(
pvdc_ext_href)
vc_name = pvdc_ext_resource.VimServer.get('name')
res_pools_in_pvdc = TestPVDC._sys_admin_client.get_linked_resource(
resource=pvdc_ext_resource,
rel=RelationType.DOWN,
media_type=EntityType.VMW_PROVIDER_VDC_RESOURCE_POOL_SET.value)
if hasattr(res_pools_in_pvdc,
'{' + NSMAP['vmext'] + '}VMWProviderVdcResourcePool'):
src_respool = res_pools_in_pvdc.VMWProviderVdcResourcePool[0]
name_filter = ('vcName', vc_name)
query = TestPVDC._sys_admin_client.get_typed_query(
ResourceType.RESOURCE_POOL.value,
query_result_format=QueryResultFormat.RECORDS,
equality_filter=name_filter)
res_pools_in_use = {}
for res_pool in list(query.execute()):
res_pools_in_use[res_pool.get('moref')] = res_pool.get('name')
source_respool_name = res_pools_in_use[
src_respool.ResourcePoolVimObjectRef.MoRef]
TestPVDC._source_resource_pool = source_respool_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)
TestPVDC._sys_admin_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.reload()
for vdc in org.list_vdcs():
if vdc.get('name').lower() == vdc_name.lower():
TestPVDC._new_vdc_href = vdc.get('href')
self.assertIsNotNone(TestPVDC._new_vdc_href)
def test_0000_setup(self):
TestCertificates._client = Environment.get_sys_admin_client()
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_0000_setup(self):
TestVappDhcp._client = Environment.get_sys_admin_client()
vapp = Environment.get_test_vapp_with_network(TestVappDhcp._client)
self.assertIsNotNone(vapp)
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()
