def _form_data_mapping(selector,
second_provider,
provider,
source_list=None,
target_list=None):
source_data = second_provider.data.get(selector, [])
target_data = provider.data.get(selector, [])
if selector is 'clusters':
source = source_data if source_data else None
target = target_data if target_data else None
skip_test = not source or not target
else:
if selector is 'datastores':
source = [d.name for d in source_data if d.type == source_list]
target = [d.name for d in target_data if d.type == target_list]
else:
source = [v for v in source_data if v == source_list]
target = [v for v in target_data if v == target_list]
skip_test = not (source_data and target_data and source and target)
if skip_test:
pytest.skip(
"No data for source or target {} in providers.".format(selector))
else:
_source, _target = partial_match(source[0]), partial_match(target[0])
return {'sources': [_source], 'target': [_target]}
def _form_data_mapping(selector, second_provider, provider, source_list=None, target_list=None):
source_data = second_provider.data.get(selector, [])
target_data = provider.data.get(selector, [])
if selector is 'clusters':
source = source_data if source_data else None
target = target_data if target_data else None
skip_test = not source or not target
else:
if selector is 'datastores':
source = [d.name for d in source_data if d.type == source_list]
target = [d.name for d in target_data if d.type == target_list]
else:
source = [v for v in source_data if v == source_list]
target = [v for v in target_data if v == target_list]
skip_test = not (source_data and target_data and source and target)
if skip_test:
pytest.skip("No data for source or target {} in providers.".format(selector))
else:
_source, _target = partial_match(source[0]), partial_match(target[0])
return {
'sources': [_source],
'target': [_target]
}
def test_cloud_catalog_item(appliance, setup_provider, provider, dialog, catalog, request,
provisioning):
"""Tests cloud catalog item
Metadata:
test_flag: provision
"""
# azure accepts only 15 chars vm name
vm_name = 'test{}'.format(fauxfactory.gen_string('alphanumeric', 5))
# GCE accepts only lowercase letters in VM name
vm_name = vm_name.lower()
request.addfinalizer(lambda: cleanup_vm(vm_name + "_0001", provider))
image = provisioning['image']['name']
item_name = fauxfactory.gen_alphanumeric()
provisioning_data = {
'catalog': {'vm_name': vm_name,
},
'properties': {'instance_type': partial_match(provisioning['instance_type']),
},
'environment': {'security_groups': partial_match(provisioning['security_group']),
}
}
if provider.type == "azure":
env_updates = dict(
cloud_network=partial_match(provisioning['virtual_private_cloud']),
cloud_subnet=provisioning['cloud_subnet'],
resource_groups=provisioning['resource_group'],
)
provisioning_data['environment'].update(env_updates)
provisioning_data.update({
'customize': {
'admin_username': provisioning['customize_username'],
'root_password': provisioning['customize_password']}})
else:
provisioning_data['properties']['guest_keypair'] = provisioning['guest_keypair']
provisioning_data['properties']['boot_disk_size'] = provisioning['boot_disk_size']
env_updates = dict(
availability_zone=provisioning['availability_zone'],
cloud_tenant=provisioning['cloud_tenant'],
cloud_network=provisioning['cloud_network'])
provisioning_data['environment'].update(env_updates)
catalog_item = CatalogItem(item_type=provisioning['item_type'],
name=item_name,
description="my catalog",
display_in=True,
catalog=catalog,
dialog=dialog,
catalog_name=image,
provider=provider,
prov_data=provisioning_data)
catalog_item.create()
service_catalogs = ServiceCatalogs(appliance, catalog_item.catalog, catalog_item.name)
service_catalogs.order()
logger.info('Waiting for cfme provision request for service %s', item_name)
request_description = item_name
provision_request = appliance.collections.requests.instantiate(request_description,
partial_check=True)
provision_request.wait_for_request()
assert provision_request.is_succeeded()
def create_catalog_item(provider, provisioning, vm_name, dialog, catalog, console_template=None):
catalog_item_type = provider.catalog_name
provision_type, template, host, datastore, iso_file, vlan = map(provisioning.get,
('provision_type', 'template', 'host', 'datastore', 'iso_file', 'vlan'))
if console_template:
logger.info("Console template name : {}".format(console_template.name))
template = console_template.name
item_name = dialog.label
if provider.one_of(InfraProvider):
catalog_name = template
provisioning_data = {
'catalog': {'vm_name': vm_name,
'provision_type': provision_type},
'environment': {'host_name': {'name': host},
'datastore_name': {'name': datastore}},
'network': {'vlan': partial_match(vlan)},
}
elif provider.one_of(CloudProvider):
catalog_name = provisioning['image']['name']
provisioning_data = {
'catalog': {'vm_name': vm_name},
'properties': {'instance_type': partial_match(provisioning['instance_type']),
'guest_keypair': provisioning['guest_keypair'],
'boot_disk_size': provisioning.get('boot_disk_size', None)},
'environment': {'availability_zone': provisioning['availability_zone'],
'cloud_network': provisioning['cloud_network']}
}
catalog_item = CatalogItem(item_type=catalog_item_type, name=item_name,
description="my catalog", display_in=True, catalog=catalog,
dialog=dialog, catalog_name=catalog_name,
provider=provider, prov_data=provisioning_data)
return catalog_item
def create_catalog_item(appliance, provider, provisioning, vm_name, dialog, catalog,
console_test=False):
provision_type, template, host, datastore, iso_file, vlan = map(provisioning.get,
('provision_type', 'template', 'host', 'datastore', 'iso_file', 'vlan'))
if console_test:
template = console_template(provider).name
logger.info("Console template name : {}".format(template))
item_name = dialog.label
if provider.one_of(InfraProvider):
catalog_name = template
provisioning_data = {
'catalog': {'catalog_name': {'name': catalog_name, 'provider': provider.name},
'vm_name': vm_name,
'provision_type': provision_type},
'environment': {'host_name': {'name': host},
'datastore_name': {'name': datastore}},
'network': {'vlan': partial_match(vlan)},
}
elif provider.one_of(CloudProvider):
catalog_name = provisioning['image']['name']
provisioning_data = {
'catalog': {'catalog_name': {'name': catalog_name, 'provider': provider.name},
'vm_name': vm_name},
'properties': {'instance_type': partial_match(provisioning['instance_type']),
'guest_keypair': provisioning['guest_keypair'],
'boot_disk_size': provisioning.get('boot_disk_size', None)},
'environment': {'availability_zone': provisioning['availability_zone'],
'cloud_network': provisioning['cloud_network']}
}
catalog_item = appliance.collections.catalog_items.create(
provider.catalog_item_type, name=item_name,
description="my catalog", display_in=True, catalog=catalog,
dialog=dialog, prov_data=provisioning_data
)
return catalog_item
def _form_data_cluster_mapping(second_provider, provider):
# since we have only one cluster on providers
source_cluster = second_provider.data.get('clusters', [False])[0]
target_cluster = provider.data.get('clusters', [False])[0]
if not source_cluster or not target_cluster:
pytest.skip("No data for source or target cluster in providers.")
return {
'sources': [partial_match(source_cluster)],
'target': [partial_match(target_cluster)]
}
def _form_data_cluster_mapping(second_provider, provider):
# since we have only one cluster on providers
source_cluster = second_provider.data.get('clusters', [False])[0]
target_cluster = provider.data.get('clusters', [False])[0]
if not source_cluster or not target_cluster:
pytest.skip("No data for source or target cluster in providers.")
return {
'sources': [partial_match(source_cluster)],
'target': [partial_match(target_cluster)]
}
def _form_data_cluster_mapping(nvc_prov, rhvm_prov):
# since we have only one cluster on providers
source_cluster = nvc_prov.data.get('clusters')[0]
target_cluster = rhvm_prov.data.get('clusters')[0]
if not source_cluster or not target_cluster:
pytest.skip("No data for source or target cluster in providers.")
return {
'sources': [partial_match(source_cluster)],
'target': [partial_match(target_cluster)]
}
def _form_data_network_mapping(second_provider, provider, source_network_name, target_network_name):
source_vlans_list = second_provider.data.get('vlans', [])
target_vlans_list = provider.data.get('vlans', [])
# assuming there will be only 1 network matching given name
source_network = [v for v in source_vlans_list if v == source_network_name]
target_network = [v for v in target_vlans_list if v == target_network_name]
if not source_vlans_list or not target_vlans_list or not source_network or not target_network:
pytest.skip("No data for source or target cluster in providers.")
return {
'sources': [partial_match(source_network[0])],
'target': [partial_match(target_network[0])]
}
def _form_data_datastore_mapping(second_provider, provider, source_type, target_type):
source_datastores_list = second_provider.data.get('datastores', [])
target_datastores_list = provider.data.get('datastores', [])
# assuming, we just have 1 datastore of each type
source_datastore = [d.name for d in source_datastores_list if d.type == source_type]
target_datastore = [d.name for d in target_datastores_list if d.type == target_type]
if (not source_datastores_list or not target_datastores_list or
not source_datastore or not target_datastore):
pytest.skip("No data for source or target datastore in providers.")
return {
'sources': [partial_match(source_datastore[0])],
'target': [partial_match(target_datastore[0])]
}
def _form_data_network_mapping(second_provider, provider, source_network_name,
target_network_name):
source_vlans_list = second_provider.data.get('vlans', [])
target_vlans_list = provider.data.get('vlans', [])
# assuming there will be only 1 network matching given name
source_network = [v for v in source_vlans_list if v == source_network_name]
target_network = [v for v in target_vlans_list if v == target_network_name]
if not source_vlans_list or not target_vlans_list or not source_network or not target_network:
pytest.skip("No data for source or target cluster in providers.")
return {
'sources': [partial_match(source_network[0])],
'target': [partial_match(target_network[0])]
}
def _form_data_network_mapping(nvc_prov, rhvm_prov, source_network_name, target_network_name):
source_vlans_list = nvc_prov.data.get('vlans')
target_vlans_list = rhvm_prov.data.get('vlans')
if not source_vlans_list or not target_vlans_list:
pytest.skip("No data for source or target cluster in providers.")
# assuming there will be only 1 network matching given name
source_network = [v for v in source_vlans_list if v == source_network_name][0]
target_network = [v for v in target_vlans_list if v == target_network_name][0]
return {
'sources': [partial_match(source_network)],
'target': [partial_match(target_network)]
}
def _form_data_datastore_mapping(nvc_prov, rhvm_prov, source_type, target_type):
source_datastores_list = nvc_prov.data.get('datastores')
target_datastores_list = rhvm_prov.data.get('datastores')
if not source_datastores_list or not target_datastores_list:
pytest.skip("No data for source or target cluster in providers.")
# assuming, we just have 1 datastore of each type
source_datastore = [d.name for d in source_datastores_list if d.type == source_type][0]
target_datastore = [d.name for d in target_datastores_list if d.type == target_type][0]
return {
'sources': [partial_match(source_datastore)],
'target': [partial_match(target_datastore)]
}
def prov_data(provider, vm_name, template_name):
if provider.one_of(OpenStackProvider):
return {
"catalog": {'vm_name': vm_name, 'catalog_name': {'name': template_name}},
"environment": {'automatic_placement': True},
"properties": {'instance_type': partial_match('m1.large')}
}
def test_iso_provision_from_template(appliance, provider, vm_name, datastore_init,
request, smtp_test):
"""Tests ISO provisioning
Metadata:
test_flag: iso, provision
suite: infra_provisioning
"""
# generate_tests makes sure these have values
iso_template, host, datastore, iso_file, iso_kickstart,\
iso_root_password, iso_image_type, vlan = map(provider.data['provisioning'].get,
('pxe_template', 'host', 'datastore', 'iso_file', 'iso_kickstart',
'iso_root_password', 'iso_image_type', 'vlan'))
request.addfinalizer(lambda:
appliance.collections.infra_vms.instantiate(vm_name, provider)
.cleanup_on_provider())
provisioning_data = {
'catalog': {
'vm_name': vm_name,
'provision_type': 'ISO',
'iso_file': {'name': iso_file}},
'environment': {
'host_name': {'name': host},
'datastore_name': {'name': datastore}},
'customize': {
'custom_template': {'name': iso_kickstart},
'root_password': iso_root_password},
'network': {
'vlan': partial_match(vlan)}}
do_vm_provisioning(appliance, iso_template, provider, vm_name, provisioning_data, request,
smtp_test, num_sec=1500)
def test_tenant_quota_enforce_via_service_cloud(
request, appliance, provider, setup_provider, set_roottenant_quota,
extra_msg, custom_prov_data, prov_data, template_name, catalog_item):
"""Test Tenant Quota in UI"""
catalog_item.provisioning_data.update(custom_prov_data)
catalog_item.provisioning_data['catalog']['vm_name'] = catalog_item.vm_name
catalog_item.provisioning_data.update(
{'properties': {
'instance_type': partial_match('m1.large')
}})
catalog_item.create()
service_catalogs = ServiceCatalogs(appliance, catalog_item.catalog,
catalog_item.name)
service_catalogs.order()
# nav to requests page to check quota validation
request_description = 'Provisioning Service [{0}] from [{0}]'.format(
catalog_item.name)
provision_request = appliance.collections.requests.instantiate(
request_description)
provision_request.wait_for_request(method='ui')
assert provision_request.row.reason.text == "Quota Exceeded"
@request.addfinalizer
def delete():
provision_request.remove_request()
catalog_item.delete()
def test_tenant_quota_enforce_via_lifecycle_cloud(request, appliance, provider,
setup_provider,
set_roottenant_quota,
extra_msg, custom_prov_data,
approve, prov_data, vm_name,
template_name):
"""Test Tenant Quota in UI"""
prov_data.update(custom_prov_data)
prov_data['catalog']['vm_name'] = vm_name
prov_data.update({
'request': {
'email':
'test_{}@example.com'.format(fauxfactory.gen_alphanumeric())
},
'properties': {
'instance_type': partial_match('m1.large')
}
})
instance = Instance.factory(vm_name, provider, template_name)
instance.create(**prov_data)
# nav to requests page to check quota validation
request_description = 'Provision from [{}] to [{}{}]'.format(
template_name, vm_name, extra_msg)
provision_request = appliance.collections.requests.instantiate(
request_description)
if approve:
provision_request.approve_request(method='ui', reason="Approved")
provision_request.wait_for_request(method='ui')
assert provision_request.row.reason.text == "Quota Exceeded"
request.addfinalizer(provision_request.remove_request)
def catalog_item(setup_provider, provider, vm_name, dialog, catalog, provisioning):
iso_template, host, datastore, iso_file, iso_kickstart,\
iso_root_password, iso_image_type, vlan = map(provisioning.get, ('pxe_template', 'host',
'datastore', 'iso_file', 'iso_kickstart',
'iso_root_password', 'iso_image_type', 'vlan'))
provisioning_data = {
'catalog': {'vm_name': vm_name,
'provision_type': 'ISO',
'iso_file': {'name': iso_file},
},
'environment': {'host_name': {'name': host},
'datastore_name': {'name': datastore},
},
'customize': {'custom_template': {'name': iso_kickstart},
'root_password': iso_root_password,
},
'network': {'vlan': partial_match(vlan),
},
}
item_name = fauxfactory.gen_alphanumeric()
catalog_item = CatalogItem(item_type="RHEV", name=item_name,
description="my catalog", display_in=True, catalog=catalog,
dialog=dialog, catalog_name=iso_template,
provider=provider, prov_data=provisioning_data)
yield catalog_item
def new_instance(provider):
prov_data = provider.data['provisioning']
prov_form_data = {
'request': {'email': fauxfactory.gen_email(),
'first_name': fauxfactory.gen_alpha(),
'last_name': fauxfactory.gen_alpha()},
'catalog': {'num_vms': '1',
'vm_name': fauxfactory.gen_alpha()},
'environment': {'cloud_network': prov_data['cloud_network']},
'properties': {'instance_type': partial_match(prov_data['instance_type'])},
}
instance_name = prov_form_data['catalog']['vm_name']
try:
instance = provider.appliance.collections.cloud_instances.create(
instance_name,
provider,
prov_form_data, find_in_cfme=True
)
except KeyError:
# some yaml value wasn't found
pytest.skip('Unable to find an image map in provider "{}" provisioning data: {}'
.format(provider, prov_data))
yield instance
try:
instance.power_control_from_provider(instance.TERMINATE)
except:
pass
def vm_default_args(self):
"""Represents dictionary used for Vm/Instance provision with minimum required default args
"""
provisioning = self.provider.data['provisioning']
inst_args = {
'request': {
'email': '*****@*****.**'
},
'catalog': {
'vm_name': self.name
},
'environment': {
'availability_zone': provisioning.get('availability_zone'),
'cloud_network': provisioning.get('cloud_network'),
'cloud_subnet': provisioning.get('cloud_subnet'),
'resource_groups': provisioning.get('resource_group')
},
'properties': {
'instance_type':
partial_match(provisioning.get('instance_type')),
'guest_keypair': provisioning.get('guest_keypair')
}
}
return inst_args
def create_catalog_item(provider, provisioning, vm_name, dialog, catalog, console_template=None):
template, host, datastore, iso_file, catalog_item_type, vlan = map(provisioning.get,
('template', 'host', 'datastore', 'iso_file', 'catalog_item_type', 'vlan'))
if console_template:
logger.info("Console template name : {}".format(console_template.name))
template = console_template.name
item_name = dialog.label
provisioning_data = {
'catalog': {'vm_name': vm_name,
},
'environment': {'host_name': {'name': host},
'datastore_name': {'name': datastore},
},
'network': {'vlan': partial_match(vlan),
},
}
if provider.type == 'rhevm':
provisioning_data['catalog']['provision_type'] = 'Native Clone'
elif provider.type == 'virtualcenter':
provisioning_data['catalog']['provision_type'] = 'VMware'
catalog_item = CatalogItem(item_type=catalog_item_type, name=item_name,
description="my catalog", display_in=True, catalog=catalog,
dialog=dialog, catalog_name=template,
provider=provider, prov_data=provisioning_data)
return catalog_item
def prov_data(provisioning, provider):
data = {
'request': {
'email': fauxfactory.gen_email(),
'first_name': fauxfactory.gen_alphanumeric(),
'last_name': fauxfactory.gen_alphanumeric(),
'manager_name': fauxfactory.gen_alphanumeric(20, start="manager ")
},
'network': {
'vlan': partial_match(provisioning.get('vlan'))
},
'environment': {
'datastore_name': {
'name': provisioning['datastore']
},
'host_name': {
'name': provisioning['host']
}
},
'catalog': {},
'hardware': {},
'schedule': {},
'purpose': {},
}
if provider.one_of(RHEVMProvider):
data['catalog']['provision_type'] = 'Native Clone'
elif provider.one_of(VMwareProvider):
data['catalog']['provision_type'] = 'VMware'
# Otherwise just leave it alone
return data
def test_run_host_analysis(setup_provider_modscope, provider, host_type, host_name, register_event,
soft_assert, host_with_credentials):
""" Run host SmartState analysis
Metadata:
test_flag: host_analysis
"""
register_event(target_type='Host', target_name=host_name, event_type='request_host_scan')
register_event(target_type='Host', target_name=host_name, event_type='host_scan_complete')
# Initiate analysis
host_with_credentials.run_smartstate_analysis(wait_for_task_result=True)
# Check results of the analysis
view = navigate_to(host_with_credentials, 'Details')
drift_history = view.entities.summary('Relationships').get_text_of('Drift History')
soft_assert(drift_history != '0', 'No drift history change found')
if provider.type == "rhevm":
soft_assert(view.entities.summary('Configuration').get_text_of('Services') != '0',
'No services found in host detail')
if host_type in ('rhel', 'rhev'):
soft_assert(view.entities.summary('Configuration').get_text_of('Packages') != '0',
'No packages found in host detail')
soft_assert(view.entities.summary('Configuration').get_text_of('Files') != '0',
'No files found in host detail')
elif host_type in ('esx', 'esxi'):
soft_assert(view.entities.summary('Configuration').get_text_of('Advanced Settings') != '0',
'No advanced settings found in host detail')
view.security_accordion.navigation.select(partial_match('Firewall Rules'))
# Page get updated if rules value is not 0, and title is update
soft_assert("(Firewall Rules)" in view.title.text, (
"No firewall rules found in host detail"))
def catalog_item(appliance, provider, dialog, catalog, provisioning):
iso_template, host, datastore, iso_file, iso_kickstart,\
iso_root_password, iso_image_type, vlan = map(provisioning.get, ('pxe_template', 'host',
'datastore', 'iso_file', 'iso_kickstart',
'iso_root_password', 'iso_image_type', 'vlan'))
provisioning_data = {
'catalog': {'catalog_name': {'name': iso_template, 'provider': provider.name},
'vm_name': random_vm_name('iso_service'),
'provision_type': 'ISO',
'iso_file': {'name': iso_file}},
'environment': {'host_name': {'name': host},
'datastore_name': {'name': datastore}},
'customize': {'custom_template': {'name': iso_kickstart},
'root_password': iso_root_password},
'network': {'vlan': partial_match(vlan)},
}
item_name = fauxfactory.gen_alphanumeric()
return appliance.collections.catalog_items.create(
appliance.collections.catalog_items.RHV,
name=item_name,
description="my catalog", display_in=True, catalog=catalog,
dialog=dialog,
prov_data=provisioning_data
)
def catalog_item(appliance, setup_provider, provider, vm_name, dialog, catalog, provisioning):
iso_template, host, datastore, iso_file, iso_kickstart,\
iso_root_password, iso_image_type, vlan = map(provisioning.get, ('pxe_template', 'host',
'datastore', 'iso_file', 'iso_kickstart',
'iso_root_password', 'iso_image_type', 'vlan'))
provisioning_data = {
'catalog': {'catalog_name': {'name': iso_template, 'provider': provider.name},
'vm_name': vm_name,
'provision_type': 'ISO',
'iso_file': {'name': iso_file}},
'environment': {'host_name': {'name': host},
'datastore_name': {'name': datastore}},
'customize': {'custom_template': {'name': iso_kickstart},
'root_password': iso_root_password},
'network': {'vlan': partial_match(vlan)},
}
item_name = fauxfactory.gen_alphanumeric()
return appliance.collections.catalog_items.create(
appliance.collections.catalog_items.RHV,
name=item_name,
description="my catalog", display_in=True, catalog=catalog,
dialog=dialog,
prov_data=provisioning_data
)
def map_tags(appliance, provider, request):
tag = appliance.collections.map_tags.create(entity_type=partial_match(
provider.name.title()),
label='test',
category='Testing')
yield tag
request.addfinalizer(lambda: tag.delete())
def catalog_item(provider, vm_name, dialog, catalog, provisioning, setup_pxe_servers_vm_prov):
# generate_tests makes sure these have values
pxe_template, host, datastore, pxe_server, pxe_image, pxe_kickstart, pxe_root_password,\
pxe_image_type, pxe_vlan, catalog_item_type = map(
provisioning.get, (
'pxe_template', 'host', 'datastore', 'pxe_server', 'pxe_image', 'pxe_kickstart',
'pxe_root_password', 'pxe_image_type', 'vlan', 'catalog_item_type'
)
)
provisioning_data = {
'catalog': {'provision_type': 'PXE',
'pxe_server': pxe_server,
'pxe_image': {'name': pxe_image},
'vm_name': vm_name,
},
'environment': {'datastore_name': {'name': datastore},
'host_name': {'name': host},
},
'customize': {'root_password': pxe_root_password,
'custom_template': {'name': pxe_kickstart},
},
'network': {'vlan': partial_match(pxe_vlan),
},
}
item_name = fauxfactory.gen_alphanumeric()
catalog_item = CatalogItem(item_type=catalog_item_type, name=item_name,
description="my catalog", display_in=True, catalog=catalog,
dialog=dialog, catalog_name=pxe_template,
provider=provider, prov_data=provisioning_data)
yield catalog_item
def new_instance(provider, zero_disk_flavor):
flavor_name = zero_disk_flavor.name
prov_data = provider.data['provisioning']
prov_form_data = {
'request': {'email': fauxfactory.gen_email(),
'first_name': fauxfactory.gen_alpha(),
'last_name': fauxfactory.gen_alpha()},
'catalog': {'num_vms': '1',
'vm_name': fauxfactory.gen_alpha()},
'environment': {'cloud_network': prov_data['cloud_network'],
'cloud_tenant': prov_data['cloud_tenant']},
'properties': {'instance_type': partial_match(flavor_name)},
}
instance_name = prov_form_data['catalog']['vm_name']
try:
instance = provider.appliance.collections.cloud_instances.create(
instance_name,
provider,
prov_form_data, find_in_cfme=True
)
except KeyError:
# some yaml value wasn't found
pytest.skip('Unable to find an image map in provider "{}" provisioning data: {}'
.format(provider, prov_data))
yield instance
instance.cleanup_on_provider()
def new_instance(provider, zero_disk_flavor):
flavor_name = zero_disk_flavor.name
prov_data = provider.data['provisioning']
prov_form_data = {
'request': {'email': fauxfactory.gen_email(),
'first_name': fauxfactory.gen_alpha(),
'last_name': fauxfactory.gen_alpha()},
'catalog': {'num_vms': '1',
'vm_name': fauxfactory.gen_alpha()},
'environment': {'cloud_network': prov_data['cloud_network'],
'cloud_tenant': prov_data['cloud_tenant']},
'properties': {'instance_type': partial_match(flavor_name)},
}
instance_name = prov_form_data['catalog']['vm_name']
try:
instance = provider.appliance.collections.cloud_instances.create(
instance_name,
provider,
prov_form_data, find_in_cfme=True
)
except KeyError:
# some yaml value wasn't found
pytest.skip('Unable to find an image map in provider "{}" provisioning data: {}'
.format(provider, prov_data))
yield instance
instance.cleanup_on_provider()
def catalog_item(appliance, provider, provisioning, tagcontrol_dialog, catalog):
template, host, datastore, iso_file, vlan = map(provisioning.get,
('template', 'host', 'datastore', 'iso_file', 'vlan'))
provisioning_data = {
'catalog': {'catalog_name': {'name': template, 'provider': provider.name},
'vm_name': random_vm_name('service')},
'environment': {'host_name': {'name': host},
'datastore_name': {'name': datastore}},
'network': {'vlan': partial_match(vlan)},
}
if provider.type == 'rhevm':
provisioning_data['catalog']['provision_type'] = 'Native Clone'
elif provider.type == 'virtualcenter':
provisioning_data['catalog']['provision_type'] = 'VMware'
item_name = fauxfactory.gen_alphanumeric()
catalog_item = appliance.collections.catalog_items.create(
provider.catalog_item_type,
name=item_name,
description="my catalog",
display_in=True,
catalog=catalog,
dialog=tagcontrol_dialog,
prov_data=provisioning_data)
return catalog_item
def prov_data(provider, vm_name, template_name):
if provider.one_of(OpenStackProvider):
return {
"catalog": {'vm_name': vm_name, 'catalog_name': {'name': template_name}},
"environment": {'automatic_placement': True},
"properties": {'instance_type': partial_match('m1.large')}
}
def test_infrastructure_provider_left_panel_titles(
setup_provider, provider, option, soft_assert, vm
):
"""
Polarion:
assignee: pvala
casecomponent: Infra
caseimportance: low
initialEstimate: 1/18h
testSteps:
1. Add an infrastructure provider and navigate to it's Details page.
2. Select Properties on the panel and check all items, whether they have their titles.
3. Select Relationships on the panel and check all items,
whether they have their titles.
expectedResults:
1.
2. Properties panel must have all items and clicking on each item should display
the correct page.
3. Relationships panel must have all items and clicking on each item should display
the correct page.
"""
view = navigate_to(provider, "Details")
accordion = getattr(view.entities.sidebar, option)
for panel in ALL_OPTIONS[option]:
accordion.tree.select(partial_match(panel))
test_view = provider.create_view(ALL_OPTIONS[option][panel])
soft_assert(test_view.is_displayed, f"{test_view} not displayed.")
def prov_data(provider, vm_name, template_name):
if provider.one_of(RHEVMProvider):
return {
"catalog": {
'vm_name': vm_name,
'catalog_name': {
'name': template_name
}
},
"environment": {
'automatic_placement': True
},
"network": {
'vlan': partial_match('ovirtmgmt')
},
}
else:
return {
"catalog": {
'vm_name': vm_name,
'catalog_name': {
'name': template_name
}
},
"environment": {
'automatic_placement': True
},
}
def catalog_item(setup_provider, provider, vm_name, dialog, catalog, provisioning):
iso_template, host, datastore, iso_file, iso_kickstart,\
iso_root_password, iso_image_type, vlan = map(provisioning.get, ('pxe_template', 'host',
'datastore', 'iso_file', 'iso_kickstart',
'iso_root_password', 'iso_image_type', 'vlan'))
provisioning_data = {
'catalog': {'vm_name': vm_name,
'provision_type': 'ISO',
'iso_file': {'name': iso_file},
},
'environment': {'host_name': {'name': host},
'datastore_name': {'name': datastore},
},
'customize': {'custom_template': {'name': iso_kickstart},
'root_password': iso_root_password,
},
'network': {'vlan': partial_match(vlan),
},
}
item_name = fauxfactory.gen_alphanumeric()
catalog_item = CatalogItem(item_type="RHEV", name=item_name,
description="my catalog", display_in=True, catalog=catalog,
dialog=dialog, catalog_name=iso_template,
provider=provider, prov_data=provisioning_data)
yield catalog_item
def test_run_host_analysis(setup_provider_modscope, provider, host_type, host_name, register_event,
soft_assert, host_with_credentials):
""" Run host SmartState analysis
Metadata:
test_flag: host_analysis
"""
register_event(target_type='Host', target_name=host_name, event_type='request_host_scan')
register_event(target_type='Host', target_name=host_name, event_type='host_scan_complete')
# Initiate analysis
host_with_credentials.run_smartstate_analysis(wait_for_task_result=True)
# Check results of the analysis
view = navigate_to(host_with_credentials, 'Details')
drift_history = view.entities.summary('Relationships').get_text_of('Drift History')
soft_assert(drift_history != '0', 'No drift history change found')
if provider.type == "rhevm":
soft_assert(view.entities.summary('Configuration').get_text_of('Services') != '0',
'No services found in host detail')
if host_type in ('rhel', 'rhev'):
soft_assert(view.entities.summary('Configuration').get_text_of('Packages') != '0',
'No packages found in host detail')
soft_assert(view.entities.summary('Configuration').get_text_of('Files') != '0',
'No files found in host detail')
elif host_type in ('esx', 'esxi'):
soft_assert(view.entities.summary('Configuration').get_text_of('Advanced Settings') != '0',
'No advanced settings found in host detail')
view.security_accordion.navigation.select(partial_match('Firewall Rules'))
# Page get updated if rules value is not 0, and title is update
soft_assert("(Firewall Rules)" in view.title.text, (
"No firewall rules found in host detail"))
def catalog_item(appliance, provider, dialog, catalog, provisioning,
setup_pxe_servers_vm_prov):
# generate_tests makes sure these have values
pxe_template, host, datastore, pxe_server, pxe_image, pxe_kickstart, pxe_root_password,\
pxe_image_type, pxe_vlan = map(
provisioning.get, (
'pxe_template', 'host', 'datastore', 'pxe_server', 'pxe_image', 'pxe_kickstart',
'pxe_root_password', 'pxe_image_type', 'vlan'
)
)
provisioning_data = {
'catalog': {'catalog_name': {'name': pxe_template, 'provider': provider.name},
'provision_type': 'PXE',
'pxe_server': pxe_server,
'pxe_image': {'name': pxe_image},
'vm_name': random_vm_name('pxe_service')},
'environment': {'datastore_name': {'name': datastore},
'host_name': {'name': host}},
'customize': {'root_password': pxe_root_password,
'custom_template': {'name': pxe_kickstart}},
'network': {'vlan': partial_match(pxe_vlan)},
}
item_name = fauxfactory.gen_alphanumeric()
return appliance.collections.catalog_items.create(
provider.catalog_item_type,
name=item_name,
description="my catalog", display_in=True, catalog=catalog,
dialog=dialog, prov_data=provisioning_data)
def catalog_item(appliance, provider, provisioning, tagcontrol_dialog, catalog):
template, host, datastore, iso_file, vlan = map(provisioning.get,
('template', 'host', 'datastore', 'iso_file', 'vlan'))
provisioning_data = {
'catalog': {'catalog_name': {'name': template, 'provider': provider.name},
'vm_name': random_vm_name('service')},
'environment': {'host_name': {'name': host},
'datastore_name': {'name': datastore}},
'network': {'vlan': partial_match(vlan)},
}
if provider.type == 'rhevm':
provisioning_data['catalog']['provision_type'] = 'Native Clone'
elif provider.type == 'virtualcenter':
provisioning_data['catalog']['provision_type'] = 'VMware'
item_name = fauxfactory.gen_alphanumeric()
catalog_item = appliance.collections.catalog_items.create(
provider.catalog_item_type,
name=item_name,
description="my catalog",
display_in=True,
catalog=catalog,
dialog=tagcontrol_dialog,
prov_data=provisioning_data)
return catalog_item
def prov_data(provisioning, provider):
# TODO Perhaps merge this with stuff with test_cloud_init_provisioning.test_provision_cloud_init
data = dict(
provisioning, **{
'request': {
'email': fauxfactory.gen_email(),
'first_name': fauxfactory.gen_alphanumeric(),
'last_name': fauxfactory.gen_alphanumeric(),
'manager_name': fauxfactory.gen_alphanumeric(20,
start="manager ")
},
'catalog': {},
'hardware': {},
'schedule': {},
'purpose': {},
})
mgmt_system = provider.mgmt
if provider.one_of(InfraProvider):
data['network'] = {'vlan': partial_match(provisioning.get('vlan'))}
data['environment'] = {
'datastore_name': {
'name': provisioning['datastore']
},
'host_name': {
'name': provisioning['host']
}
}
elif provider.one_of(AzureProvider):
data['environment'] = {'public_ip_address': "New"}
elif provider.one_of(OpenStackProvider):
ip_pool = provider.data['public_network']
floating_ip = mgmt_system.get_first_floating_ip(pool=ip_pool)
provider.refresh_provider_relationships()
data['environment'] = {'public_ip_address': floating_ip}
props = data.setdefault('properties', {})
props['instance_type'] = partial_match(provisioning['ci-flavor-name'])
if provider.one_of(RHEVMProvider):
data['catalog']['provision_type'] = 'Native Clone'
elif provider.one_of(VMwareProvider):
data['catalog']['provision_type'] = 'VMware'
# Otherwise just leave it alone
return data
def test_partial_match_wrapping():
value = ' foobar '
wrapped = partial_match(value)
assert dir(wrapped) == dir(value)
assert wrapped.item is value
assert wrapped.strip() == value.strip()
def generated_request(appliance, provider, provisioning, template_name, vm_name):
"""Creates a provision request, that is not automatically approved, and returns the search data.
After finishing the test, request should be automatically deleted.
Slightly modified code from :py:module:`cfme.tests.infrastructure.test_provisioning`
"""
if provider.one_of(RHEVMProvider) and provisioning.get('vlan') is None:
pytest.skip('rhevm requires a vlan value in provisioning info')
first_name = fauxfactory.gen_alphanumeric()
last_name = fauxfactory.gen_alphanumeric()
notes = fauxfactory.gen_alphanumeric()
e_mail = "{}@{}.test".format(first_name, last_name)
host, datastore = map(provisioning.get, ('host', 'datastore'))
vm = appliance.collections.infra_vms.instantiate(name=vm_name,
provider=provider,
template_name=template_name)
view = navigate_to(vm.parent, 'Provision')
provisioning_data = {
'request': {
'email': e_mail,
'first_name': first_name,
'last_name': last_name,
'notes': notes},
'catalog': {
'vm_name': vm_name,
'num_vms': '10'},
'environment':
{'host_name': {'name': host},
'datastore_name': {'name': datastore}},
'network':
{'vlan': partial_match(provisioning['vlan'] if provisioning.get('vlan') else None)}
}
# Same thing, different names. :\
if provider.one_of(RHEVMProvider):
provisioning_data['catalog']['provision_type'] = 'Native Clone'
elif provider.one_of(VMwareProvider):
provisioning_data['catalog']['provision_type'] = 'VMware'
# template and provider names for template selection
provisioning_data['template_name'] = template_name
provisioning_data['provider_name'] = provider.name
view.form.fill_with(provisioning_data, on_change=view.form.submit_button)
request_cells = {
"Description": "Provision from [{}] to [{}###]".format(template_name, vm_name),
}
provision_request = appliance.collections.requests.instantiate(cells=request_cells)
yield provision_request
browser().get(appliance.url)
appliance.server.login_admin()
provision_request.remove_request()
def test_pxe_provision_from_template(appliance, provider, vm_name, smtp_test,
setup_provider, request,
setup_pxe_servers_vm_prov):
"""Tests provisioning via PXE
Metadata:
test_flag: pxe, provision
suite: infra_provisioning
"""
# generate_tests makes sure these have values
(pxe_template, host, datastore, pxe_server, pxe_image, pxe_kickstart,
pxe_root_password, pxe_image_type, pxe_vlan) = map(
provider.data['provisioning'].get,
('pxe_template', 'host', 'datastore', 'pxe_server', 'pxe_image',
'pxe_kickstart', 'pxe_root_password', 'pxe_image_type', 'vlan'))
request.addfinalizer(lambda: appliance.collections.infra_vms.instantiate(
vm_name, provider).cleanup_on_provider())
provisioning_data = {
'catalog': {
'vm_name': vm_name,
'provision_type': 'PXE',
'pxe_server': pxe_server,
'pxe_image': {
'name': pxe_image
}
},
'environment': {
'host_name': {
'name': host
},
'datastore_name': {
'name': datastore
}
},
'customize': {
'custom_template': {
'name': pxe_kickstart
},
'root_password': pxe_root_password
},
'network': {
'vlan': partial_match(pxe_vlan)
}
}
do_vm_provisioning(appliance,
pxe_template,
provider,
vm_name,
provisioning_data,
request,
smtp_test,
num_sec=3600)
def _form_data_datastore_mapping(second_provider, provider, source_type,
target_type):
source_datastores_list = second_provider.data.get('datastores', [])
target_datastores_list = provider.data.get('datastores', [])
# assuming, we just have 1 datastore of each type
source_datastore = [
d.name for d in source_datastores_list if d.type == source_type
]
target_datastore = [
d.name for d in target_datastores_list if d.type == target_type
]
if (not source_datastores_list or not target_datastores_list
or not source_datastore or not target_datastore):
pytest.skip("No data for source or target datastore in providers.")
return {
'sources': [partial_match(source_datastore[0])],
'target': [partial_match(target_datastore[0])]
}
def test_iso_provision_from_template(appliance, provider, vm_name, datastore_init, request):
"""Tests ISO provisioning
Metadata:
test_flag: iso, provision
suite: infra_provisioning
Polarion:
assignee: jhenner
caseimportance: high
casecomponent: Provisioning
initialEstimate: 1/4h
"""
# generate_tests makes sure these have values
(iso_template,
host,
datastore,
iso_file,
iso_kickstart,
iso_root_password,
iso_image_type,
vlan,
addr_mode) = tuple(map(provider.data['provisioning'].get,
('pxe_template',
'host',
'datastore',
'iso_file',
'iso_kickstart',
'iso_root_password',
'iso_image_type',
'vlan',
'iso_address_mode')))
request.addfinalizer(lambda:
appliance.collections.infra_vms.instantiate(vm_name, provider)
.cleanup_on_provider())
provisioning_data = {
'catalog': {
'vm_name': vm_name,
'provision_type': 'ISO',
'iso_file': {'name': iso_file}},
'environment': {
'host_name': {'name': host},
'datastore_name': {'name': datastore}},
'customize': {
'custom_template': {'name': iso_kickstart},
'root_password': iso_root_password,
'address_mode': addr_mode},
'network': {
'vlan': partial_match(vlan)},
'schedule': {
'power_on': False}}
do_vm_provisioning(appliance, iso_template, provider, vm_name, provisioning_data, request,
num_sec=1800)
def generated_request(appliance,
a_provider, provider_data, provisioning, template_name, vm_name):
"""Creates a provision request, that is not automatically approved, and returns the search data.
After finishing the test, request should be automatically deleted.
Slightly modified code from :py:module:`cfme.tests.infrastructure.test_provisioning`
"""
first_name = fauxfactory.gen_alphanumeric()
last_name = fauxfactory.gen_alphanumeric()
notes = fauxfactory.gen_alphanumeric()
e_mail = "{}@{}.test".format(first_name, last_name)
host, datastore = map(provisioning.get, ('host', 'datastore'))
vm = Vm(name=vm_name, provider=a_provider, template_name=template_name)
view = navigate_to(vm, 'Provision')
provisioning_data = {
'request': {
'email': e_mail,
'first_name': first_name,
'last_name': last_name,
'notes': notes},
'catalog': {
'vm_name': vm_name,
'num_vms': '10'},
'environment':
{'host_name': {'name': host},
'datastore_name': {'name': datastore}},
}
# Same thing, different names. :\
if provider_data["type"] == 'rhevm':
provisioning_data['catalog']['provision_type'] = 'Native Clone'
elif provider_data["type"] == 'virtualcenter':
provisioning_data['catalog']['provision_type'] = 'VMware'
try:
provisioning_data['network'] = {'vlan': partial_match(provisioning['vlan'])}
except KeyError:
# provisioning['vlan'] is required for rhevm provisioning
if provider_data["type"] == 'rhevm':
raise pytest.fail('rhevm requires a vlan value in provisioning info')
view.form.fill_with(provisioning_data, on_change=view.form.submit_button)
request_cells = {
"Description": "Provision from [{}] to [{}###]".format(template_name, vm_name),
}
provision_request = appliance.collections.requests.instantiate(cells=request_cells)
yield provision_request
browser().get(store.base_url)
appliance.server.login_admin()
provision_request.remove_request()
def prov_data(vm_name, provisioning):
return {
"catalog": {
'vm_name': vm_name
},
"environment": {
'automatic_placement': True
},
"network": {
'vlan': partial_match(provisioning['vlan'])
}
}
def prov_data(provider, vm_name, template_name):
if provider.one_of(RHEVMProvider):
return {
"catalog": {'vm_name': vm_name, 'catalog_name': {'name': template_name}},
"environment": {'automatic_placement': True},
"network": {'vlan': partial_match('ovirtmgmt')},
}
else:
return {
"catalog": {'vm_name': vm_name, 'catalog_name': {'name': template_name}},
"environment": {'automatic_placement': True},
}
def provisioning_data(provisioning, provider):
return {
'catalog': {
'catalog_name': {'name': provisioning.template, 'provider': provider.name},
'vm_name': random_vm_name('service')
},
'environment': {
'host_name': {'name': provisioning.host},
'datastore_name': {'name': provisioning.datastore}
},
'network': {'vlan': partial_match(provisioning.vlan)},
}
def test_pxe_provision_from_template(appliance, provider, vm_name, setup_provider,
request, setup_pxe_servers_vm_prov):
"""Tests provisioning via PXE
Metadata:
test_flag: pxe, provision
suite: infra_provisioning
Polarion:
assignee: jhenner
casecomponent: Provisioning
initialEstimate: 1/6h
testtype: integration
upstream: yes
"""
# generate_tests makes sure these have values
(
pxe_template, host, datastore,
pxe_server, pxe_image, pxe_kickstart,
pxe_root_password, pxe_image_type, pxe_vlan
) = map(
provider.data['provisioning'].get,
(
'pxe_template', 'host', 'datastore',
'pxe_server', 'pxe_image', 'pxe_kickstart',
'pxe_root_password', 'pxe_image_type', 'vlan'
)
)
request.addfinalizer(
lambda: appliance.collections.infra_vms.instantiate(vm_name, provider)
.cleanup_on_provider())
provisioning_data = {
'catalog': {
'vm_name': vm_name,
'provision_type': 'PXE',
'pxe_server': pxe_server,
'pxe_image': {'name': pxe_image}},
'environment': {
'host_name': {'name': host},
'datastore_name': {'name': datastore}},
'customize': {
'custom_template': {'name': pxe_kickstart},
'root_password': pxe_root_password},
'network': {
'vlan': partial_match(pxe_vlan)}}
do_vm_provisioning(appliance, pxe_template, provider, vm_name, provisioning_data, request,
num_sec=3600)
def prov_data(appliance, provisioning):
"""Keeping it as a fixture because we need to call 'provisioning' from this fixture as well as
using this same fixture in various tests.
"""
instance_type = "d2s_v3" if appliance.version < "5.10" else "d2s_v3".capitalize()
return {
"catalog": {"vm_name": random_vm_name(context="quota")},
"environment": {"automatic_placement": True},
"properties": {"instance_type": partial_match(instance_type)},
"customize": {
"admin_username": provisioning["customize_username"],
"root_password": provisioning["customize_password"],
},
}
def component_generator(selector, source_provider, provider, source_type=None, target_type=None):
"""
Component generator method to generate a dict of source and target
components(clusters/datastores/networks).
Gets the provider data based on selector from cfme_data.yaml and creates
InfraMapping.component(source_list, target_list) object
Test is skipped if no source or target data is found
Args:
selector: can be clusters/datastores/vlans
source_provider: vmware provider to migrate from
provider: rhev or osp provider or target provider to migrate to
source_type: string source datastores/networks on vmware provider to migrate from.
Ex: if source_type is "iscsi". Provider data is checked for datastore with type
iscsi and that datastores name is used.
target_type: string target datastores/networks to migrate to
returns : InfraMapping.component(source_list, target_list) object
"""
if selector not in ['clusters', 'datastores', 'vlans']:
raise ValueError("Please specify cluster, datastore or network(vlans) selector!")
source_data = source_provider.data.get(selector, [])
target_data = provider.data.get(selector, [])
if not (source_data and target_data):
pytest.skip("No source and target data")
if selector == "clusters":
sources = source_data or None
targets = target_data or None
component = InfraMapping.ClusterComponent(
[partial_match(sources[0])], [partial_match(targets[0])]
)
elif selector == "datastores":
# Ignoring target_type for osp and setting new value
if provider.one_of(OpenStackProvider):
target_type = "volume"
sources = [d.name for d in source_data if d.type == source_type]
targets = [d.name for d in target_data if d.type == target_type]
component = InfraMapping.DatastoreComponent(
[partial_match(sources[0])], [partial_match(targets[0])]
)
else:
sources = [v for v in source_data if v == source_type]
targets = [v for v in target_data if v == target_type]
component = InfraMapping.NetworkComponent(
[partial_match(sources[0])], [partial_match(targets[0])]
)
skip_test = not (sources and targets and component)
if skip_test:
pytest.skip("No data for source or target {} in providers.".format(selector))
return component
def test_provision_vm_to_virtual_network(appliance, setup_provider, provider,
request, provisioning, network):
""" Tests provisioning a vm from a template to a virtual network
Metadata:
test_flag: provision
Polarion:
assignee: mmojzis
casecomponent: Provisioning
initialEstimate: 1/4h
"""
vm_name = random_vm_name('provd')
def _cleanup():
vm = appliance.collections.infra_vms.instantiate(vm_name, provider)
vm.cleanup_on_provider()
request.addfinalizer(_cleanup)
template = provisioning['template']
provisioning_data = {
'catalog': {
'vm_name': vm_name
},
'environment': {
'vm_name': vm_name,
'automatic_placement': True
},
'network': {
'vlan': partial_match(network.name)
}
}
wait_for(
do_vm_provisioning,
[appliance, template, provider, vm_name, provisioning_data, request],
{'num_sec': 900},
handle_exception=True,
delay=50,
num_sec=900,
fail_func=appliance.server.browser.refresh,
message='Cannot do provision for vm {}.'.format(vm_name)
)
def test_pxe_provision_from_template(appliance, provider, vm_name, smtp_test, setup_provider,
request, setup_pxe_servers_vm_prov):
"""Tests provisioning via PXE
Metadata:
test_flag: pxe, provision
suite: infra_provisioning
"""
# generate_tests makes sure these have values
(
pxe_template, host, datastore,
pxe_server, pxe_image, pxe_kickstart,
pxe_root_password, pxe_image_type, pxe_vlan
) = map(
provider.data['provisioning'].get,
(
'pxe_template', 'host', 'datastore',
'pxe_server', 'pxe_image', 'pxe_kickstart',
'pxe_root_password', 'pxe_image_type', 'vlan'
)
)
request.addfinalizer(lambda: VM.factory(vm_name, provider).cleanup_on_provider())
provisioning_data = {
'catalog': {
'vm_name': vm_name,
'provision_type': 'PXE',
'pxe_server': pxe_server,
'pxe_image': {'name': pxe_image}},
'environment': {
'host_name': {'name': host},
'datastore_name': {'name': datastore}},
'customize': {
'custom_template': {'name': pxe_kickstart},
'root_password': pxe_root_password},
'network': {
'vlan': partial_match(pxe_vlan)}}
do_vm_provisioning(appliance, pxe_template, provider, vm_name, provisioning_data, request,
smtp_test, num_sec=3600)
def test_iso_provision_from_template(appliance, provider, vm_name, datastore_init, request):
"""Tests ISO provisioning
Metadata:
test_flag: iso, provision
suite: infra_provisioning
Polarion:
assignee: jhenner
caseimportance: high
casecomponent: Provisioning
initialEstimate: 1/4h
"""
# generate_tests makes sure these have values
iso_template, host, datastore, iso_file, iso_kickstart,\
iso_root_password, iso_image_type, vlan, addr_mode = map(provider.data['provisioning'].get,
('pxe_template', 'host', 'datastore', 'iso_file', 'iso_kickstart',
'iso_root_password', 'iso_image_type', 'vlan', 'iso_address_mode'))
request.addfinalizer(lambda:
appliance.collections.infra_vms.instantiate(vm_name, provider)
.cleanup_on_provider())
provisioning_data = {
'catalog': {
'vm_name': vm_name,
'provision_type': 'ISO',
'iso_file': {'name': iso_file}},
'environment': {
'host_name': {'name': host},
'datastore_name': {'name': datastore}},
'customize': {
'custom_template': {'name': iso_kickstart},
'root_password': iso_root_password,
'address_mode': addr_mode},
'network': {
'vlan': partial_match(vlan)},
'schedule': {
'power_on': False}}
do_vm_provisioning(appliance, iso_template, provider, vm_name, provisioning_data, request,
num_sec=1800)
def vm_default_args(self):
"""Represents dictionary used for Vm/Instance provision with minimum required default args
"""
provisioning = self.provider.data['provisioning']
inst_args = {
'request': {'email': '*****@*****.**'},
'catalog': {
'vm_name': self.name},
'environment': {
'availability_zone': provisioning.get('availability_zone'),
'cloud_network': provisioning.get('cloud_network'),
'cloud_subnet': provisioning.get('cloud_subnet'),
'resource_groups': provisioning.get('resource_group')
},
'properties': {
'instance_type': partial_match(provisioning.get('instance_type')),
'guest_keypair': provisioning.get('guest_keypair')
}
}
return inst_args
def test_tenant_quota_enforce_via_lifecycle_cloud(request, appliance, provider, setup_provider,
set_roottenant_quota, extra_msg, custom_prov_data,
approve, prov_data, vm_name, template_name):
"""Test Tenant Quota in UI"""
prov_data.update(custom_prov_data)
prov_data['catalog']['vm_name'] = vm_name
prov_data.update({
'request': {'email': 'test_{}@example.com'.format(fauxfactory.gen_alphanumeric())},
'properties': {'instance_type': partial_match('m1.large')}})
instance = Instance.factory(vm_name, provider, template_name)
instance.create(**prov_data)
# nav to requests page to check quota validation
request_description = 'Provision from [{}] to [{}{}]'.format(template_name, vm_name, extra_msg)
provision_request = appliance.collections.requests.instantiate(request_description)
if approve:
provision_request.approve_request(method='ui', reason="Approved")
provision_request.wait_for_request(method='ui')
assert provision_request.row.reason.text == "Quota Exceeded"
request.addfinalizer(provision_request.remove_request)
def test_provision_vm_to_virtual_network(appliance, setup_provider, provider,
request, provisioning, network):
""" Tests provisioning a vm from a template to a virtual network
Metadata:
test_flag: provision
"""
vm_name = random_vm_name('provd')
def _cleanup():
try:
provider.mgmt.get_vm(vm_name).cleanup()
except NotFoundError:
pass
request.addfinalizer(_cleanup)
template = provisioning['template']
provisioning_data = {
'catalog': {
'vm_name': vm_name
},
'environment': {
'vm_name': vm_name,
'automatic_placement': True
},
'network': {
'vlan': partial_match(network.name)
}
}
wait_for(
do_vm_provisioning,
[appliance, template, provider, vm_name, provisioning_data, request],
{'num_sec': 900, 'smtp_test': False},
handle_exception=True,
delay=50,
num_sec=900,
fail_func=appliance.server.browser.refresh,
message='Cannot do provision for vm {}.'.format(vm_name)
)
def test_tenant_quota_enforce_via_service_cloud(request, appliance, provider, setup_provider,
set_roottenant_quota, extra_msg, custom_prov_data,
prov_data, template_name, catalog_item):
"""Test Tenant Quota in UI"""
catalog_item.provisioning_data.update(custom_prov_data)
catalog_item.provisioning_data['catalog']['vm_name'] = catalog_item.vm_name
catalog_item.provisioning_data.update({'properties': {
'instance_type': partial_match('m1.large')}})
catalog_item.create()
service_catalogs = ServiceCatalogs(appliance, catalog_item.catalog,
catalog_item.name)
service_catalogs.order()
# nav to requests page to check quota validation
request_description = 'Provisioning Service [{0}] from [{0}]'.format(catalog_item.name)
provision_request = appliance.collections.requests.instantiate(request_description)
provision_request.wait_for_request(method='ui')
assert provision_request.row.reason.text == "Quota Exceeded"
@request.addfinalizer
def delete():
provision_request.remove_request()
catalog_item.delete()
def prov_data(provisioning, provider):
data = {
'request': {
'email': "{}@{}.test".format(fauxfactory.gen_alphanumeric(),
fauxfactory.gen_alphanumeric()),
'first_name': fauxfactory.gen_alphanumeric(),
'last_name': fauxfactory.gen_alphanumeric(),
'manager_name': '{} {}'.format(fauxfactory.gen_alphanumeric(),
fauxfactory.gen_alphanumeric())},
'network': {'vlan': partial_match(provisioning.get('vlan'))},
'environment': {'datastore_name': {'name': provisioning['datastore']},
'host_name': {'name': provisioning['host']}},
'catalog': {},
'hardware': {},
'schedule': {},
'purpose': {},
}
if provider.one_of(RHEVMProvider):
data['catalog']['provision_type'] = 'Native Clone'
elif provider.one_of(VMwareProvider):
data['catalog']['provision_type'] = 'VMware'
# Otherwise just leave it alone
return data
def test_infra_provision_from_template(appliance, setup_provider, provider, vm_name, smtp_test,
request, provisioning, auto):
""" Tests provisioning from a template
Metadata:
test_flag: provision
suite: infra_provisioning
rbac:
roles:
default:
evmgroup-super_administrator:
evmgroup-administrator:
evmgroup-operator: NoSuchElementException
evmgroup-auditor: NoSuchElementException
"""
template = provisioning['template']
request.addfinalizer(lambda: VM.factory(vm_name, provider).cleanup_on_provider())
provisioning_data = {
'catalog': {
'vm_name': vm_name
},
'environment': {
'vm_name': vm_name,
'host_name': {'name': provisioning['host']} if not auto else None,
'datastore_name': {'name': provisioning['datastore']} if not auto else None,
'automatic_placement': True if auto else None
},
'network': {
'vlan': partial_match(provisioning['vlan'])
}
}
do_vm_provisioning(appliance, template, provider, vm_name, provisioning_data, request,
smtp_test, num_sec=900)
