def test_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: cleanup_vm(vm_name, 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': provisioning['vlan']}}
do_vm_provisioning(appliance, template, provider, vm_name, provisioning_data, request,
smtp_test, num_sec=900)
def test_project_quota_enforce_via_lifecycle_infra(appliance, provider,
new_user, set_project_quota,
extra_msg, custom_prov_data,
approve, prov_data, vm_name,
template_name):
"""Test project quota via lifecycle method
Polarion:
assignee: ghubale
casecomponent: Configuration
initialEstimate: 1/4h
tags: quota
"""
with new_user:
recursive_update(prov_data, custom_prov_data)
do_vm_provisioning(appliance,
template_name=template_name,
provider=provider,
vm_name=vm_name,
provisioning_data=prov_data,
wait=False,
request=None)
# nav to requests page to check quota validation
request_description = 'Provision from [{template}] to [{vm}{msg}]'.format(
template=template_name, vm=vm_name, msg=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"
def test_project_quota_enforce_via_lifecycle_infra(appliance, provider, setup_provider, new_user,
set_project_quota, extra_msg, custom_prov_data,
approve, prov_data, vm_name, template_name):
"""Test project quota via lifecycle method
Metadata:
test_flag: quota
Polarion:
assignee: ghubale
casecomponent: Configuration
initialEstimate: 1/4h
"""
with new_user:
recursive_update(prov_data, custom_prov_data)
do_vm_provisioning(appliance, template_name=template_name, provider=provider,
vm_name=vm_name, provisioning_data=prov_data, wait=False, request=None)
# 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"
def test_iso_provision_from_template(provider_key, provider_crud, provider_type, provider_mgmt,
provisioning, vm_name, smtp_test, provider_init, request):
"""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(provisioning.get, ('pxe_template', 'host',
'datastore', 'iso_file', 'iso_kickstart',
'iso_root_password', 'iso_image_type', 'vlan'))
request.addfinalizer(lambda: cleanup_vm(vm_name, provider_key, provider_mgmt))
provisioning_data = {
'vm_name': vm_name,
'host_name': {'name': [host]},
'datastore_name': {'name': [datastore]},
'provision_type': 'ISO',
'iso_file': {'name': [iso_file]},
'custom_template': {'name': [iso_kickstart]},
'root_password': iso_root_password,
'vlan': vlan,
}
do_vm_provisioning(iso_template, provider_crud, vm_name, provisioning_data, request,
provider_mgmt, provider_key, smtp_test, num_sec=1500)
def test_user_quota_diff_groups(request, appliance, provider, setup_provider, new_user,
set_parent_tenant_quota, extra_msg, custom_prov_data, approve,
prov_data, vm_name, template_name):
"""prerequisite: Provider should be added
steps:
1. Provision VM with more than assigned quota
Polarion:
assignee: ghubale
initialEstimate: 1/4h
casecomponent: Quota
"""
with new_user:
recursive_update(prov_data, custom_prov_data)
logger.info("Successfully updated VM provisioning data")
do_vm_provisioning(appliance, template_name=template_name, provider=provider,
vm_name=vm_name, provisioning_data=prov_data, wait=False, request=None)
# 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"
def test_project_quota_enforce_via_lifecycle_infra(appliance, provider,
setup_provider, new_user,
set_project_quota,
extra_msg, custom_prov_data,
approve, prov_data, vm_name,
template_name):
"""Test project quota via lifecycle method
Metadata:
test_flag: quota
"""
with new_user:
recursive_update(prov_data, custom_prov_data)
do_vm_provisioning(appliance,
template_name=template_name,
provider=provider,
vm_name=vm_name,
provisioning_data=prov_data,
smtp_test=False,
wait=False,
request=None)
# 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"
def test_quota_tagging_infra_via_lifecycle(request, appliance, provider,
set_entity_quota_tag,
custom_prov_data, vm_name,
template_name, prov_data):
"""
Polarion:
assignee: ghubale
casecomponent: Quota
caseimportance: medium
initialEstimate: 1/6h
tags: quota
"""
recursive_update(prov_data, custom_prov_data)
do_vm_provisioning(appliance,
template_name=template_name,
provider=provider,
vm_name=vm_name,
provisioning_data=prov_data,
wait=False,
request=None)
# nav to requests page to check quota validation
request_description = 'Provision from [{template}] to [{vm}]'.format(
template=template_name, vm=vm_name)
provision_request = appliance.collections.requests.instantiate(
request_description)
provision_request.wait_for_request(method='ui')
request.addfinalizer(provision_request.remove_request)
assert provision_request.row.reason.text == "Quota Exceeded"
def test_user_quota_diff_groups(request, appliance, provider, setup_provider, new_user,
set_parent_tenant_quota, extra_msg, custom_prov_data, approve,
prov_data, vm_name, template_name):
"""prerequisite: Provider should be added
steps:
1. Provision VM with more than assigned quota
Polarion:
assignee: None
initialEstimate: None
"""
with new_user:
recursive_update(prov_data, custom_prov_data)
logger.info("Successfully updated VM provisioning data")
do_vm_provisioning(appliance, template_name=template_name, provider=provider,
vm_name=vm_name, provisioning_data=prov_data, wait=False, request=None)
# 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"
def test_k6t_vm_crud(request, appliance, provider, provisioning,
custom_prov_data):
"""
Polarion:
assignee: rhcf3_machine
initialEstimate: 1/4h
casecomponent: Infra
"""
vm_name = random_vm_name('k6tvm')
prov_data = {'catalog': {'vm_name': vm_name}}
provider.refresh_provider_relationships()
prov_data.update(custom_prov_data)
template = provisioning['template']
do_vm_provisioning(appliance,
template,
provider,
vm_name,
prov_data,
request,
wait=False)
logger.info('Waiting for cfme provision request for vm %s', vm_name)
request_description = 'Provision from [{}] to [{}]'.format(
template, vm_name)
provision_request = appliance.collections.requests.instantiate(
request_description)
provision_request.wait_for_request(method='ui', num_sec=300)
assert provision_request.is_succeeded(method='ui'), \
("Provisioning failed with the message {}".format(provision_request.row.last_message.text))
def test_iso_provision_from_template(appliance, provider, vm_name, smtp_test, datastore_init,
request, setup_provider):
"""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: cleanup_vm(vm_name, 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': vlan}}
do_vm_provisioning(appliance, iso_template, provider, vm_name, provisioning_data, request,
smtp_test, num_sec=1500)
def test_pxe_provision_from_template(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: cleanup_vm(vm_name, provider))
provisioning_data = {
'vm_name': vm_name,
'host_name': {'name': [host]},
'datastore_name': {'name': [datastore]},
'provision_type': 'PXE',
'pxe_server': pxe_server,
'pxe_image': {'name': [pxe_image]},
'custom_template': {'name': [pxe_kickstart]},
'root_password': pxe_root_password,
'vlan': pxe_vlan,
}
do_vm_provisioning(pxe_template, provider, vm_name, provisioning_data, request, smtp_test,
num_sec=2100)
def test_quota(appliance, provider, custom_prov_data, vm_name, admin_email,
entities, template_name, prov_data):
"""This test case checks quota limit using the automate's predefine method 'quota source'
Polarion:
assignee: ghubale
casecomponent: Quota
caseimportance: medium
initialEstimate: 1/6h
tags: quota
"""
recursive_update(prov_data, custom_prov_data)
do_vm_provisioning(appliance,
template_name=template_name,
provider=provider,
vm_name=vm_name,
provisioning_data=prov_data,
wait=False,
request=None)
# nav to requests page to check quota validation
request_description = 'Provision from [{template}] to [{vm}]'.format(
template=template_name, vm=vm_name)
provision_request = appliance.collections.requests.instantiate(
request_description)
provision_request.wait_for_request(method='ui')
assert provision_request.row.reason.text == "Quota Exceeded"
def test_tenant_quota_enforce_via_lifecycle_infra(
appliance, provider, setup_provider, set_roottenant_quota, extra_msg,
custom_prov_data, approve, prov_data, vm_name, template_name):
"""Test Tenant Quota in UI and SSUI
Metadata:
test_flag: quota
"""
prov_data.update(custom_prov_data)
prov_data['catalog']['vm_name'] = vm_name
do_vm_provisioning(appliance,
template_name=template_name,
provider=provider,
vm_name=vm_name,
provisioning_data=prov_data,
smtp_test=False,
wait=False,
request=None)
# 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"
def test_pxe_provision_from_template(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: cleanup_vm(vm_name, provider))
provisioning_data = {
'vm_name': vm_name,
'host_name': {'name': [host]},
'datastore_name': {'name': [datastore]},
'provision_type': 'PXE',
'pxe_server': pxe_server,
'pxe_image': {'name': [pxe_image]},
'custom_template': {'name': [pxe_kickstart]},
'root_password': pxe_root_password,
'vlan': pxe_vlan,
}
do_vm_provisioning(pxe_template, provider, vm_name, provisioning_data, request, smtp_test,
num_sec=2100)
def test_child_tenant_quota_enforce_via_lifecycle_infra(appliance, provider, new_user,
set_child_tenant_quota, extra_msg,
custom_prov_data, approve, prov_data,
vm_name, template_name):
"""Test child tenant feature via lifecycle method.
Polarion:
assignee: ghubale
casecomponent: Infra
caseimportance: medium
initialEstimate: 1/6h
tags: quota
"""
with new_user:
recursive_update(prov_data, custom_prov_data)
do_vm_provisioning(appliance, template_name=template_name, provider=provider,
vm_name=vm_name, provisioning_data=prov_data, wait=False, request=None)
# nav to requests page to check quota validation
request_description = 'Provision from [{template}] to [{vm}{msg}]'.format(
template=template_name, vm=vm_name, msg=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"
def test_provision_from_template(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: cleanup_vm(vm_name, 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': provisioning['vlan']}}
do_vm_provisioning(template, provider, vm_name, provisioning_data, request, smtp_test,
num_sec=900)
def test_child_tenant_quota_enforce_via_lifecycle_infra(
appliance, provider, setup_provider, new_user, set_child_tenant_quota,
extra_msg, custom_prov_data, approve, prov_data, vm_name,
template_name):
"""Test child tenant feature via lifecycle method.
Metadata:
test_flag: quota
Polarion:
assignee: ghubale
casecomponent: infra
initialEstimate: 1/6h
"""
with new_user:
recursive_update(prov_data, custom_prov_data)
do_vm_provisioning(appliance,
template_name=template_name,
provider=provider,
vm_name=vm_name,
provisioning_data=prov_data,
wait=False,
request=None)
# 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"
def test_quota_tagging(appliance, provider, setup_provider,
set_entity_quota_tag, custom_prov_data, vm_name,
template_name, prov_data):
"""Tests quota tagging
Metadata:
test_flag: quota
"""
recursive_update(prov_data, custom_prov_data)
do_vm_provisioning(appliance,
template_name=template_name,
provider=provider,
vm_name=vm_name,
provisioning_data=prov_data,
smtp_test=False,
wait=False,
request=None)
# nav to requests page to check quota validation
request_description = 'Provision from [{}] to [{}]'.format(
template_name, vm_name)
provision_request = appliance.collections.requests.instantiate(
request_description)
provision_request.wait_for_request(method='ui')
assert provision_request.row.reason.text == "Quota Exceeded"
def test_iso_provision_from_template(appliance, provider, vm_name, smtp_test, datastore_init,
request, setup_provider):
"""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: cleanup_vm(vm_name, 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': vlan}}
do_vm_provisioning(appliance, iso_template, provider, vm_name, provisioning_data, request,
smtp_test, num_sec=1500)
def test_tenant_quota_enforce_via_lifecycle_infra(appliance, provider, set_roottenant_quota,
extra_msg, custom_prov_data, approve, prov_data,
vm_name, template_name):
"""Test Tenant Quota in UI and SSUI
Polarion:
assignee: ghubale
casecomponent: Infra
caseimportance: high
initialEstimate: 1/8h
tags: quota
"""
prov_data.update(custom_prov_data)
prov_data['catalog']['vm_name'] = vm_name
do_vm_provisioning(appliance, template_name=template_name, provider=provider, vm_name=vm_name,
provisioning_data=prov_data, wait=False, request=None)
# nav to requests page to check quota validation
request_description = 'Provision from [{template}] to [{vm}{msg}]'.format(
template=template_name, vm=vm_name, msg=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"
def test_tenant_quota_enforce_via_lifecycle_infra(appliance, provider,
set_roottenant_quota,
extra_msg, custom_prov_data,
approve, prov_data, vm_name,
template_name):
"""Test Tenant Quota in UI and SSUI
Polarion:
assignee: ghubale
casecomponent: Infra
caseimportance: high
initialEstimate: 1/8h
tags: quota
"""
prov_data.update(custom_prov_data)
prov_data['catalog']['vm_name'] = vm_name
do_vm_provisioning(appliance,
template_name=template_name,
provider=provider,
vm_name=vm_name,
provisioning_data=prov_data,
wait=False,
request=None)
# nav to requests page to check quota validation
request_description = 'Provision from [{template}] to [{vm}{msg}]'.format(
template=template_name, vm=vm_name, msg=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"
def test_provision_from_template(provider_init, provider_key, provider_crud, provider_type,
provider_mgmt, provisioning, vm_name, smtp_test, request):
""" Tests provisioning from a template
Metadata:
test_flag: provision
suite: infra_provisioning
"""
# generate_tests makes sure these have values
template, host, datastore = map(provisioning.get, ('template', 'host', 'datastore'))
request.addfinalizer(lambda: cleanup_vm(vm_name, provider_key, provider_mgmt))
provisioning_data = {
'vm_name': vm_name,
'host_name': {'name': [host]},
'datastore_name': {'name': [datastore]}
}
# Same thing, different names. :\
if provider_type == 'rhevm':
provisioning_data['provision_type'] = 'Native Clone'
elif provider_type == 'virtualcenter':
provisioning_data['provision_type'] = 'VMware'
try:
provisioning_data['vlan'] = provisioning['vlan']
except KeyError:
# provisioning['vlan'] is required for rhevm provisioning
if provider_type == 'rhevm':
raise pytest.fail('rhevm requires a vlan value in provisioning info')
do_vm_provisioning(template, provider_crud, vm_name, provisioning_data, request,
provider_mgmt, provider_key, smtp_test, num_sec=900)
def test_user_quota_diff_groups(appliance, provider, new_user,
set_parent_tenant_quota, extra_msg,
custom_prov_data, approve, prov_data, vm_name,
template_name):
"""
Polarion:
assignee: ghubale
initialEstimate: 1/4h
casecomponent: Quota
caseimportance: high
tags: quota
"""
with new_user:
recursive_update(prov_data, custom_prov_data)
logger.info("Successfully updated VM provisioning data")
do_vm_provisioning(appliance,
template_name=template_name,
provider=provider,
vm_name=vm_name,
provisioning_data=prov_data,
wait=False,
request=None)
# nav to requests page to check quota validation
request_description = 'Provision from [{template}] to [{vm}{msg}]'.format(
template=template_name, vm=vm_name, msg=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"
def test_provision_cloud_init(setup_provider, provider, setup_ci_template,
vm_name, smtp_test, request, provisioning):
"""Tests cloud init provisioning
Metadata:
test_flag: cloud_init, provision
suite: infra_provisioning
"""
# generate_tests makes sure these have values
template = provisioning.get('ci-image',
None) or provisioning['image']['name']
host, datastore = map(provisioning.get, ('host', 'datastore'))
mgmt_system = provider.get_mgmt_system()
request.addfinalizer(lambda: cleanup_vm(vm_name, provider))
provisioning_data = {
'vm_name': vm_name,
'host_name': {
'name': [host]
},
'datastore_name': {
'name': [datastore]
},
'provision_type': 'Native Clone',
'custom_template': {
'name': [provisioning['ci-template']]
},
}
try:
provisioning_data['vlan'] = provisioning['vlan']
except KeyError:
# provisioning['vlan'] is required for rhevm provisioning
if provider.type == 'rhevm':
raise pytest.fail(
'rhevm requires a vlan value in provisioning info')
do_vm_provisioning(template,
provider,
vm_name,
provisioning_data,
request,
smtp_test,
num_sec=900)
connect_ip, tc = wait_for(mgmt_system.get_ip_address, [vm_name],
num_sec=300,
handle_exception=True)
# Check that we can at least get the uptime via ssh this should only be possible
# if the username and password have been set via the cloud-init script so
# is a valid check
sshclient = ssh.SSHClient(hostname=connect_ip,
username=provisioning['ci-username'],
password=provisioning['ci-pass'])
wait_for(sshclient.uptime, num_sec=200, handle_exception=True)
def test_quota_exceed_mail_with_more_info_link(configure_mail, appliance,
provider, set_roottenant_quota,
custom_prov_data, prov_data,
extra_msg, vm_name,
template_name):
"""
Bugzilla:
1579031
1759123
Polarion:
assignee: ghubale
initialEstimate: 1/12h
caseimportance: high
caseposneg: positive
testtype: functional
startsin: 5.9
casecomponent: Infra
tags: quota
setup:
1. Copy instance ManageIQ/Configuration/Email/Default to custom domain
2. Enter values for fields: approver, default_recipient, from and signature
testSteps:
1. Provide valid mail address while provisioning Vm to exceed quota
expectedResults:
1. Quota exceed mail should be sent
"""
approver, default_recipient, from_user = configure_mail
mail_to = fauxfactory.gen_email()
prov_data.update(custom_prov_data)
prov_data['catalog']['vm_name'] = vm_name
with LogValidator(
"/var/www/miq/vmdb/log/automation.log",
matched_patterns=
[
f'"to"=>"{default_recipient}", "from"=>"{from_user}".*.Virtual Machine Request from '
f'{mail_to} was Denied."',
f'"to"=>"{mail_to}", "from"=>"{from_user}".*.Your Virtual Machine Request was Approved,'
f' pending Quota Validation.".*'
],
).waiting(timeout=120):
do_vm_provisioning(appliance,
template_name=template_name,
provider=provider,
vm_name=vm_name,
provisioning_data=prov_data,
wait=False,
request=None,
email=mail_to)
# nav to requests page to check quota validation
request_description = f'Provision from [{template_name}] to [{vm_name}{extra_msg}]'
provision_request = appliance.collections.requests.instantiate(
request_description)
provision_request.wait_for_request(method='ui')
assert provision_request.row.reason.text == "Quota Exceeded"
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 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 test_provision_from_template(rbac_role, configure_ldap_auth_mode,
setup_provider, provider, vm_name, smtp_test,
request, provisioning):
""" 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
"""
# generate_tests makes sure these have values
template, host, datastore = map(provisioning.get,
('template', 'host', 'datastore'))
request.addfinalizer(lambda: cleanup_vm(vm_name, provider))
provisioning_data = {
'vm_name': vm_name,
'host_name': {
'name': [host]
},
'datastore_name': {
'name': [datastore]
}
}
# Same thing, different names. :\
if provider.type == 'rhevm':
provisioning_data['provision_type'] = 'Native Clone'
elif provider.type == 'virtualcenter':
provisioning_data['provision_type'] = 'VMware'
try:
provisioning_data['vlan'] = provisioning['vlan']
except KeyError:
# provisioning['vlan'] is required for rhevm provisioning
if provider.type == 'rhevm':
raise pytest.fail(
'rhevm requires a vlan value in provisioning info')
do_vm_provisioning(template,
provider,
vm_name,
provisioning_data,
request,
smtp_test,
num_sec=900)
def test_quota_tagging(appliance, provider, setup_provider, set_entity_quota_tag,
custom_prov_data, vm_name, template_name, prov_data):
prov_data.update(custom_prov_data)
prov_data['catalog']['vm_name'] = vm_name
do_vm_provisioning(appliance, template_name=template_name, provider=provider, vm_name=vm_name,
provisioning_data=prov_data, smtp_test=False, wait=False, request=None)
# nav to requests page to check quota validation
request_description = 'Provision from [{}] to [{}]'.format(template_name, vm_name)
provision_request = appliance.collections.requests.instantiate(request_description)
provision_request.wait_for_request(method='ui')
assert provision_request.row.reason.text == "Quota Exceeded"
def test_quota(appliance, provider, setup_provider, custom_prov_data, vm_name, admin_email,
entities, template_name, prov_data):
"""This test case checks quota limit using the automate's predefine method 'quota source'"""
recursive_update(prov_data, custom_prov_data)
do_vm_provisioning(appliance, template_name=template_name, provider=provider, vm_name=vm_name,
provisioning_data=prov_data, smtp_test=False, wait=False, request=None)
# nav to requests page to check quota validation
request_description = 'Provision from [{}] to [{}]'.format(template_name, vm_name)
provision_request = appliance.collections.requests.instantiate(request_description)
provision_request.wait_for_request(method='ui')
assert provision_request.row.reason.text == "Quota Exceeded"
def test_quota_tagging_infra_via_lifecycle(request, appliance, provider, setup_provider,
set_entity_quota_tag, custom_prov_data,
vm_name, template_name, prov_data):
recursive_update(prov_data, custom_prov_data)
do_vm_provisioning(appliance, template_name=template_name, provider=provider, vm_name=vm_name,
provisioning_data=prov_data, wait=False, request=None)
# nav to requests page to check quota validation
request_description = 'Provision from [{}] to [{}]'.format(template_name, vm_name)
provision_request = appliance.collections.requests.instantiate(request_description)
provision_request.wait_for_request(method='ui')
request.addfinalizer(provision_request.remove_request)
assert provision_request.row.reason.text == "Quota Exceeded"
def test_quota_tagging_infra_via_lifecycle(request, appliance, provider, setup_provider,
set_entity_quota_tag, custom_prov_data,
vm_name, template_name, prov_data):
recursive_update(prov_data, custom_prov_data)
do_vm_provisioning(appliance, template_name=template_name, provider=provider, vm_name=vm_name,
provisioning_data=prov_data, smtp_test=False, wait=False, request=None)
# nav to requests page to check quota validation
request_description = 'Provision from [{}] to [{}]'.format(template_name, vm_name)
provision_request = appliance.collections.requests.instantiate(request_description)
provision_request.wait_for_request(method='ui')
request.addfinalizer(provision_request.remove_request)
assert provision_request.row.reason.text == "Quota Exceeded"
def _provisioner(appliance,
template,
provisioning_data,
vm_name,
delayed=None):
do_vm_provisioning(appliance,
template_name=template,
provider=provider,
vm_name=vm_name,
provisioning_data=provisioning_data,
request=None,
smtp_test=None,
wait=False)
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 test_iso_provision_from_template(
provider_key, provider_crud, provider_type, provider_mgmt, provisioning, vm_name, smtp_test, provider_init, request
):
"""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(
provisioning.get,
(
"pxe_template",
"host",
"datastore",
"iso_file",
"iso_kickstart",
"iso_root_password",
"iso_image_type",
"vlan",
),
)
request.addfinalizer(lambda: cleanup_vm(vm_name, provider_key, provider_mgmt))
provisioning_data = {
"vm_name": vm_name,
"host_name": {"name": [host]},
"datastore_name": {"name": [datastore]},
"provision_type": "ISO",
"iso_file": {"name": [iso_file]},
"custom_template": {"name": [iso_kickstart]},
"root_password": iso_root_password,
"vlan": vlan,
}
do_vm_provisioning(
iso_template,
provider_crud,
vm_name,
provisioning_data,
request,
provider_mgmt,
provider_key,
smtp_test,
num_sec=1500,
)
def test_tenant_quota_enforce_via_lifecycle_infra(appliance, provider, setup_provider,
set_roottenant_quota, extra_msg, custom_prov_data,
approve, prov_data, vm_name, template_name):
"""Test Tenant Quota in UI and SSUI"""
prov_data.update(custom_prov_data)
prov_data['catalog']['vm_name'] = vm_name
do_vm_provisioning(appliance, template_name=template_name, provider=provider, vm_name=vm_name,
provisioning_data=prov_data, smtp_test=False, wait=False, request=None)
# 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"
def test_provision_cloud_init(provider_init, provider_key, provider_crud, provider_type,
setup_ci_template,
provider_mgmt, provisioning, vm_name, smtp_test, request):
"""Tests cloud init provisioning
Metadata:
test_flag: cloud_init, provision
suite: infra_provisioning
"""
# generate_tests makes sure these have values
template = provisioning.get('ci-image', None) or provisioning['image']['name']
host, datastore = map(provisioning.get, ('host', 'datastore'))
mgmt_system = provider_crud.get_mgmt_system()
request.addfinalizer(lambda: cleanup_vm(vm_name, provider_key, provider_mgmt))
provisioning_data = {
'vm_name': vm_name,
'host_name': {'name': [host]},
'datastore_name': {'name': [datastore]},
'provision_type': 'Native Clone',
'custom_template': {'name': [provisioning['ci-template']]},
}
try:
provisioning_data['vlan'] = provisioning['vlan']
except KeyError:
# provisioning['vlan'] is required for rhevm provisioning
if provider_type == 'rhevm':
raise pytest.fail('rhevm requires a vlan value in provisioning info')
do_vm_provisioning(template, provider_crud, vm_name, provisioning_data, request,
provider_mgmt, provider_key, smtp_test, num_sec=900)
connect_ip, tc = wait_for(mgmt_system.get_ip_address, [vm_name], num_sec=300,
handle_exception=True)
# Check that we can at least get the uptime via ssh this should only be possible
# if the username and password have been set via the cloud-init script so
# is a valid check
sshclient = ssh.SSHClient(hostname=connect_ip, username=provisioning['ci-username'],
password=provisioning['ci-pass'])
wait_for(sshclient.uptime, num_sec=200, handle_exception=True)
def test_k6t_vm_crud(request, appliance, provider, provisioning, custom_prov_data):
"""
Polarion:
assignee: rhcf3_machine
initialEstimate: 1/4h
casecomponent: Infra
"""
vm_name = random_vm_name('k6tvm')
prov_data = {'catalog': {'vm_name': vm_name}}
provider.refresh_provider_relationships()
prov_data.update(custom_prov_data)
template = provisioning['template']
do_vm_provisioning(appliance, template, provider, vm_name, prov_data, request, wait=False)
logger.info('Waiting for cfme provision request for vm %s', vm_name)
request_description = 'Provision from [{}] to [{}]'.format(template, vm_name)
provision_request = appliance.collections.requests.instantiate(request_description)
provision_request.wait_for_request(method='ui', num_sec=300)
assert provision_request.is_succeeded(method='ui'), \
("Provisioning failed with the message {}".format(provision_request.row.last_message.text))
def test_iso_provision_from_template(provider, provisioning, vm_name,
smtp_test, datastore_init, request,
setup_provider):
"""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(provisioning.get, ('pxe_template', 'host',
'datastore', 'iso_file', 'iso_kickstart',
'iso_root_password', 'iso_image_type', 'vlan'))
request.addfinalizer(lambda: cleanup_vm(vm_name, provider))
provisioning_data = {
'vm_name': vm_name,
'host_name': {
'name': [host]
},
'datastore_name': {
'name': [datastore]
},
'provision_type': 'ISO',
'iso_file': {
'name': [iso_file]
},
'custom_template': {
'name': [iso_kickstart]
},
'root_password': iso_root_password,
'vlan': vlan,
}
do_vm_provisioning(iso_template,
provider,
vm_name,
provisioning_data,
request,
smtp_test,
num_sec=1500)
def test_provision_from_template(rbac_role, 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: cleanup_vm(vm_name, provider))
provisioning_data = {
'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
}
# Same thing, different names. :\
if provider.type == 'rhevm':
provisioning_data['provision_type'] = 'Native Clone'
elif provider.type == 'virtualcenter':
provisioning_data['provision_type'] = 'VMware'
try:
provisioning_data['vlan'] = provisioning['vlan']
except KeyError:
# provisioning['vlan'] is required for rhevm provisioning
if provider.type == 'rhevm':
raise pytest.fail('rhevm requires a vlan value in provisioning info')
do_vm_provisioning(template, provider, vm_name, provisioning_data, request, smtp_test,
num_sec=900)
def test_provision_from_template(rbac_role, configure_ldap_auth_mode, setup_provider, provider,
provisioning, vm_name, smtp_test, request):
""" 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
"""
# generate_tests makes sure these have values
template, host, datastore = map(provisioning.get, ('template', 'host', 'datastore'))
request.addfinalizer(lambda: cleanup_vm(vm_name, provider))
provisioning_data = {
'vm_name': vm_name,
'host_name': {'name': [host]},
'datastore_name': {'name': [datastore]}
}
# Same thing, different names. :\
if provider.type == 'rhevm':
provisioning_data['provision_type'] = 'Native Clone'
elif provider.type == 'virtualcenter':
provisioning_data['provision_type'] = 'VMware'
try:
provisioning_data['vlan'] = provisioning['vlan']
except KeyError:
# provisioning['vlan'] is required for rhevm provisioning
if provider.type == 'rhevm':
raise pytest.fail('rhevm requires a vlan value in provisioning info')
do_vm_provisioning(template, provider, vm_name, provisioning_data, request, smtp_test,
num_sec=900)
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: cleanup_vm(vm_name, 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': pxe_vlan}}
do_vm_provisioning(appliance, pxe_template, provider, vm_name, provisioning_data, request,
smtp_test, num_sec=3600)
def test_provision_cloud_init(appliance, setup_provider, provider, setup_ci_template,
vm_name, smtp_test, request, provisioning):
"""Tests cloud init provisioning
Metadata:
test_flag: cloud_init, provision
suite: infra_provisioning
"""
# generate_tests makes sure these have values
template = provisioning.get('ci-image') or provisioning['image']['name']
host, datastore, vlan = map(provisioning.get, ('host', 'datastore', 'vlan'))
mgmt_system = provider.get_mgmt_system()
request.addfinalizer(lambda: cleanup_vm(vm_name, provider))
provisioning_data = {
'catalog': {
'provision_type': 'Native Clone',
'vm_name': vm_name},
'environment': {
'host_name': {'name': host},
'datastore_name': {'name': datastore}},
'network': {
'vlan': vlan},
'customize': {
'custom_template': {'name': [provisioning['ci-template']]}}
}
do_vm_provisioning(appliance, template, provider, vm_name, provisioning_data, request,
smtp_test, num_sec=900)
connect_ip, tc = wait_for(mgmt_system.get_ip_address, [vm_name], num_sec=300,
handle_exception=True)
# Check that we can at least get the uptime via ssh this should only be possible
# if the username and password have been set via the cloud-init script so
# is a valid check
with ssh.SSHClient(hostname=connect_ip, username=provisioning['ci-username'],
password=provisioning['ci-pass']) as ssh_client:
wait_for(ssh_client.uptime, num_sec=200, handle_exception=True)
def test_provision_cloud_init(appliance, setup_provider, provider, setup_ci_template,
vm_name, smtp_test, request, provisioning):
"""Tests cloud init provisioning
Metadata:
test_flag: cloud_init, provision
suite: infra_provisioning
"""
# generate_tests makes sure these have values
template = provisioning.get('ci-image') or provisioning['image']['name']
host, datastore, vlan = map(provisioning.get, ('host', 'datastore', 'vlan'))
mgmt_system = provider.get_mgmt_system()
request.addfinalizer(lambda: cleanup_vm(vm_name, provider))
provisioning_data = {
'catalog': {
'provision_type': 'Native Clone',
'vm_name': vm_name},
'environment': {
'host_name': {'name': host},
'datastore_name': {'name': datastore}},
'network': {
'vlan': vlan},
'customize': {
'custom_template': {'name': [provisioning['ci-template']]}}
}
do_vm_provisioning(appliance, template, provider, vm_name, provisioning_data, request,
smtp_test, num_sec=900)
connect_ip, tc = wait_for(mgmt_system.get_ip_address, [vm_name], num_sec=300,
handle_exception=True)
# Check that we can at least get the uptime via ssh this should only be possible
# if the username and password have been set via the cloud-init script so
# is a valid check
with ssh.SSHClient(hostname=connect_ip, username=provisioning['ci-username'],
password=provisioning['ci-pass']) as ssh_client:
wait_for(ssh_client.uptime, num_sec=200, handle_exception=True)
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 test_quota(appliance, provider, custom_prov_data, vm_name, admin_email, entities, template_name,
prov_data):
"""This test case checks quota limit using the automate's predefine method 'quota source'
Polarion:
assignee: ghubale
casecomponent: Quota
caseimportance: medium
initialEstimate: 1/6h
tags: quota
"""
recursive_update(prov_data, custom_prov_data)
do_vm_provisioning(appliance, template_name=template_name, provider=provider, vm_name=vm_name,
provisioning_data=prov_data, wait=False, request=None)
# nav to requests page to check quota validation
request_description = 'Provision from [{template}] to [{vm}]'.format(template=template_name,
vm=vm_name)
provision_request = appliance.collections.requests.instantiate(request_description)
provision_request.wait_for_request(method='ui')
assert provision_request.row.reason.text == "Quota Exceeded"
def test_provision_from_template(
rbac_role, configure_ldap_auth_mode, setup_provider, provider, vm_name, smtp_test, request, provisioning
):
""" 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
"""
# generate_tests makes sure these have values
template, host, datastore = map(provisioning.get, ("template", "host", "datastore"))
request.addfinalizer(lambda: cleanup_vm(vm_name, provider))
provisioning_data = {"vm_name": vm_name, "host_name": {"name": [host]}, "datastore_name": {"name": [datastore]}}
# Same thing, different names. :\
if provider.type == "rhevm":
provisioning_data["provision_type"] = "Native Clone"
elif provider.type == "virtualcenter":
provisioning_data["provision_type"] = "VMware"
try:
provisioning_data["vlan"] = provisioning["vlan"]
except KeyError:
# provisioning['vlan'] is required for rhevm provisioning
if provider.type == "rhevm":
raise pytest.fail("rhevm requires a vlan value in provisioning info")
do_vm_provisioning(template, provider, vm_name, provisioning_data, request, smtp_test, num_sec=900)
def test_quota_tagging_infra_via_lifecycle(request, appliance, provider,
set_entity_quota_tag, custom_prov_data,
vm_name, template_name, prov_data):
"""
Polarion:
assignee: ghubale
casecomponent: Quota
caseimportance: medium
initialEstimate: 1/6h
tags: quota
"""
recursive_update(prov_data, custom_prov_data)
do_vm_provisioning(appliance, template_name=template_name, provider=provider, vm_name=vm_name,
provisioning_data=prov_data, wait=False, request=None)
# nav to requests page to check quota validation
request_description = 'Provision from [{template}] to [{vm}]'.format(template=template_name,
vm=vm_name)
provision_request = appliance.collections.requests.instantiate(request_description)
provision_request.wait_for_request(method='ui')
request.addfinalizer(provision_request.remove_request)
assert provision_request.row.reason.text == "Quota Exceeded"
def test_child_tenant_quota_enforce_via_lifecycle_infra(appliance, provider, setup_provider,
new_user, set_child_tenant_quota, extra_msg,
custom_prov_data, approve, prov_data,
vm_name, template_name):
"""Test child tenant feature via lifecycle method.
Metadata:
test_flag: quota
"""
with new_user:
recursive_update(prov_data, custom_prov_data)
do_vm_provisioning(appliance, template_name=template_name, provider=provider,
vm_name=vm_name, provisioning_data=prov_data, smtp_test=False,
wait=False, request=None)
# 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"
def test_provision_approval(
setup_provider, provider, provisioning, vm_name, smtp_test, request, edit):
""" Tests provisioning approval. Tests couple of things.
* Approve manually
* Approve by editing the request to conform
Prerequisities:
* A provider that can provision.
* Automate role enabled
* User with e-mail set so you can receive and view them
Steps:
* Create a provisioning request that does not get automatically approved (eg. ``num_vms``
bigger than 1)
* Wait for an e-mail to come, informing you that the auto-approval was unsuccessful.
* Depending on whether you want to do manual approval or edit approval, do:
* MANUAL: manually approve the request in UI
* EDIT: Edit the request in UI so it conforms the rules for auto-approval.
* Wait for an e-mail with approval
* Wait until the request finishes
* Wait until an email, informing about finished provisioning, comes.
Metadata:
test_flag: provision
suite: infra_provisioning
"""
# generate_tests makes sure these have values
template, host, datastore = map(provisioning.get, ('template', 'host', 'datastore'))
# It will provision two of them
vm_names = [vm_name + "001", vm_name + "002"]
request.addfinalizer(
lambda: [cleanup_vm(vmname, provider) for vmname in vm_names])
provisioning_data = {
'vm_name': vm_name,
'host_name': {'name': [host]},
'datastore_name': {'name': [datastore]},
'num_vms': "2",
}
# Same thing, different names. :\
if provider.type == 'rhevm':
provisioning_data['provision_type'] = 'Native Clone'
elif provider.type == 'virtualcenter':
provisioning_data['provision_type'] = 'VMware'
try:
provisioning_data['vlan'] = provisioning['vlan']
except KeyError:
# provisioning['vlan'] is required for rhevm provisioning
if provider.type == 'rhevm':
raise pytest.fail('rhevm requires a vlan value in provisioning info')
do_vm_provisioning(template, provider, vm_name, provisioning_data, request, smtp_test,
wait=False)
wait_for(
lambda:
len(filter(
lambda mail:
"your request for a new vms was not autoapproved" in normalize_text(mail["subject"]),
smtp_test.get_emails())) > 0,
num_sec=90, delay=5)
wait_for(
lambda:
len(filter(
lambda mail:
"virtual machine request was not approved" in normalize_text(mail["subject"]),
smtp_test.get_emails())) > 0,
num_sec=90, delay=5)
cells = {'Description': 'Provision from [{}] to [{}###]'.format(template, vm_name)}
wait_for(lambda: requests.go_to_request(cells), num_sec=80, delay=5)
if edit:
# Automatic approval after editing the request to conform
with requests.edit_request(cells) as form:
fill(form.num_vms, "1")
new_vm_name = vm_name + "_xx"
fill(form.vm_name, new_vm_name)
vm_names = [new_vm_name] # Will be just one now
cells = {'Description': 'Provision from [{}] to [{}]'.format(template, new_vm_name)}
check = "vm provisioned successfully"
request.addfinalizer(
lambda: cleanup_vm(new_vm_name, provider))
else:
# Manual approval
requests.approve_request(cells, "Approved")
vm_names = [vm_name + "001", vm_name + "002"] # There will be two VMs
request.addfinalizer(
lambda: [cleanup_vm(vmname, provider) for vmname in vm_names])
check = "request complete"
wait_for(
lambda:
len(filter(
lambda mail:
"your virtual machine configuration was approved" in normalize_text(mail["subject"]),
smtp_test.get_emails())) > 0,
num_sec=120, delay=5)
# Wait for the VM to appear on the provider backend before proceeding to ensure proper cleanup
logger.info(
'Waiting for vms "{}" to appear on provider {}'.format(
", ".join(vm_names), provider.key))
wait_for(
lambda: all(map(provider.mgmt.does_vm_exist, vm_names)),
handle_exception=True, num_sec=600)
row, __ = wait_for(requests.wait_for_request, [cells],
fail_func=requests.reload, num_sec=1500, delay=20)
assert normalize_text(row.last_message.text) == check
# Wait for e-mails to appear
def verify():
return (
len(filter(
lambda mail:
"your virtual machine request has completed vm {}".format(normalize_text(vm_name))
in normalize_text(mail["subject"]),
smtp_test.get_emails())) == len(vm_names)
)
wait_for(verify, message="email receive check", delay=5)
def _ssa_single_vm():
template_name = vm_analysis_provisioning_data['image']
vm_name = 'test-ssa-{}-{}'.format(fauxfactory.gen_alphanumeric(), analysis_type)
collection = provider.appliance.provider_based_collection(provider)
vm = collection.instantiate(vm_name,
provider,
template_name=vm_analysis_provisioning_data.image)
provision_data = vm_analysis_provisioning_data.copy()
del provision_data['image']
if "test_ssa_compliance" in request._pyfuncitem.name:
provisioning_data = {"catalog": {'vm_name': vm_name},
"environment": {'automatic_placement': True}}
do_vm_provisioning(vm_name=vm_name, appliance=appliance, provider=provider,
provisioning_data=provisioning_data, template_name=template_name,
request=request, smtp_test=False, num_sec=2500)
else:
deploy_template(vm.provider.key, vm_name, template_name, timeout=2500)
vm.wait_to_appear(timeout=900, load_details=False)
request.addfinalizer(lambda: vm.delete_from_provider())
if provider.one_of(OpenStackProvider):
public_net = provider.data['public_network']
vm.provider.mgmt.assign_floating_ip(vm.name, public_net)
logger.info("VM %s provisioned, waiting for IP address to be assigned", vm_name)
@wait_for_decorator(timeout="20m", delay=5)
def get_ip_address():
logger.info("Power state for {} vm: {}, is_vm_stopped: {}".format(
vm_name, provider.mgmt.vm_status(vm_name), provider.mgmt.is_vm_stopped(vm_name)))
if provider.mgmt.is_vm_stopped(vm_name):
provider.mgmt.start_vm(vm_name)
ip = provider.mgmt.current_ip_address(vm_name)
logger.info("Fetched IP for %s: %s", vm_name, ip)
return ip is not None
connect_ip = provider.mgmt.get_ip_address(vm_name)
assert connect_ip is not None
# Check that we can at least get the uptime via ssh this should only be possible
# if the username and password have been set via the cloud-init script so
# is a valid check
if vm_analysis_provisioning_data['fs-type'] not in ['ntfs', 'fat32']:
logger.info("Waiting for %s to be available via SSH", connect_ip)
ssh_client = ssh.SSHClient(
hostname=connect_ip,
username=credentials[vm_analysis_provisioning_data.credentials]['username'],
password=credentials[vm_analysis_provisioning_data.credentials]['password'],
port=22)
wait_for(ssh_client.uptime, num_sec=3600, handle_exception=True)
vm.ssh = ssh_client
vm.system_type = detect_system_type(vm)
logger.info("Detected system type: %s", vm.system_type)
vm.image = vm_analysis_provisioning_data['image']
vm.connect_ip = connect_ip
# TODO: if rhev and iscsi, it need direct_lun
if provider.type == 'rhevm':
logger.info("Setting a relationship between VM and appliance")
cfme_rel = InfraVm.CfmeRelationship(vm)
cfme_rel.set_relationship(appliance.server.name, appliance.server_id())
# Close the SSH client if we have one
request.addfinalizer(lambda: vm.ssh.close() if getattr(vm, 'ssh', None) else None)
return vm
def test_provision_approval(appliance, setup_provider, provider, vm_name, smtp_test, request,
edit, provisioning):
""" Tests provisioning approval. Tests couple of things.
* Approve manually
* Approve by editing the request to conform
Prerequisities:
* A provider that can provision.
* Automate role enabled
* User with e-mail set so you can receive and view them
Steps:
* Create a provisioning request that does not get automatically approved (eg. ``num_vms``
bigger than 1)
* Wait for an e-mail to come, informing you that the auto-approval was unsuccessful.
* Depending on whether you want to do manual approval or edit approval, do:
* MANUAL: manually approve the request in UI
* EDIT: Edit the request in UI so it conforms the rules for auto-approval.
* Wait for an e-mail with approval
* Wait until the request finishes
* Wait until an email, informing about finished provisioning, comes.
Metadata:
test_flag: provision
suite: infra_provisioning
"""
# generate_tests makes sure these have values
template, host, datastore = map(provisioning.get, ('template', 'host', 'datastore'))
# It will provision two of them
vm_names = [vm_name + "001", vm_name + "002"]
request.addfinalizer(
lambda: [VM.factory(name, provider).cleanup_on_provider() for name in vm_names])
provisioning_data = {
'catalog': {
'vm_name': vm_name,
'num_vms': '2'
},
'environment': {
'host_name': {'name': host},
'datastore_name': {'name': datastore}
},
'network': {
'vlan': partial_match(provisioning['vlan'])
}
}
do_vm_provisioning(appliance, template, provider, vm_name, provisioning_data, request,
smtp_test, wait=False)
wait_for(
lambda:
len(filter(
lambda mail:
"your request for a new vms was not autoapproved" in normalize_text(mail["subject"]),
smtp_test.get_emails())) == 1,
num_sec=90, delay=5)
wait_for(
lambda:
len(filter(
lambda mail:
"virtual machine request was not approved" in normalize_text(mail["subject"]),
smtp_test.get_emails())) == 1,
num_sec=90, delay=5)
smtp_test.clear_database()
cells = {'Description': 'Provision from [{}] to [{}###]'.format(template, vm_name)}
provision_request = appliance.collections.requests.instantiate(cells=cells)
navigate_to(provision_request, 'Details')
if edit:
# Automatic approval after editing the request to conform
new_vm_name = vm_name + "-xx"
modifications = {
'catalog': {'num_vms': "1", 'vm_name': new_vm_name},
'Description': 'Provision from [{}] to [{}]'.format(template, new_vm_name)}
provision_request.edit_request(values=modifications)
vm_names = [new_vm_name] # Will be just one now
request.addfinalizer(
lambda: VM.factory(new_vm_name, provider).cleanup_on_provider()
)
else:
# Manual approval
provision_request.approve_request(method='ui', reason="Approved")
vm_names = [vm_name + "001", vm_name + "002"] # There will be two VMs
request.addfinalizer(
lambda: [VM.factory(name, provider).cleanup_on_provider() for name in vm_names])
wait_for(
lambda:
len(filter(
lambda mail:
"your virtual machine configuration was approved" in normalize_text(mail["subject"]),
smtp_test.get_emails())) == 1,
num_sec=120, delay=5)
smtp_test.clear_database()
# Wait for the VM to appear on the provider backend before proceeding to ensure proper cleanup
logger.info('Waiting for vms %s to appear on provider %s', ", ".join(vm_names), provider.key)
wait_for(
lambda: all(map(provider.mgmt.does_vm_exist, vm_names)),
handle_exception=True, num_sec=600)
provision_request.wait_for_request(method='ui')
msg = "Provisioning failed with the message {}".format(provision_request.row.last_message.text)
assert provision_request.is_succeeded(method='ui'), msg
# Wait for e-mails to appear
def verify():
return (
len(filter(
lambda mail:
"your virtual machine request has completed vm {}".format(normalize_text(vm_name))
in normalize_text(mail["subject"]),
smtp_test.get_emails())) == len(vm_names)
)
wait_for(verify, message="email receive check", delay=5)
def _ssa_single_vm():
template_name = vm_analysis_provisioning_data['image']
vm_name = f'test-ssa-{fauxfactory.gen_alphanumeric()}-{analysis_type}'
collection = provider.appliance.provider_based_collection(provider)
vm = collection.instantiate(
vm_name,
provider,
template_name=vm_analysis_provisioning_data.image)
provision_data = vm_analysis_provisioning_data.copy()
del provision_data['image']
if "test_ssa_compliance" in request._pyfuncitem.name or provider.one_of(
RHEVMProvider):
provisioning_data = {
"catalog": {
'vm_name': vm_name
},
"environment": {
'automatic_placement': True
}
}
if provider.one_of(RHEVMProvider):
provisioning_data.update({
"network": {
'vlan': partial_match(provision_data['vlan'])
}
})
do_vm_provisioning(vm_name=vm_name,
appliance=appliance,
provider=provider,
provisioning_data=provisioning_data,
template_name=template_name,
request=request,
num_sec=2500)
else:
deploy_template(vm.provider.key,
vm_name,
template_name,
timeout=2500)
vm.wait_to_appear(timeout=900, load_details=False)
request.addfinalizer(lambda: vm.cleanup_on_provider())
if provider.one_of(OpenStackProvider):
public_net = provider.data['public_network']
vm.mgmt.assign_floating_ip(public_net)
logger.info("VM %s provisioned, waiting for IP address to be assigned",
vm_name)
vm.mgmt.ensure_state(VmState.RUNNING)
try:
connect_ip, _ = wait_for(find_pingable,
func_args=[vm.mgmt],
timeout="10m",
delay=5,
fail_condition=None)
except TimedOutError:
pytest.fail('Timed out waiting for pingable address on SSA VM')
# Check that we can at least get the uptime via ssh this should only be possible
# if the username and password have been set via the cloud-init script so
# is a valid check
if vm_analysis_provisioning_data['fs-type'] not in ['ntfs', 'fat32']:
logger.info("Waiting for %s to be available via SSH", connect_ip)
ssh_client = ssh.SSHClient(
hostname=connect_ip,
username=credentials[
vm_analysis_provisioning_data.credentials]['username'],
password=credentials[
vm_analysis_provisioning_data.credentials]['password'],
port=22)
wait_for(ssh_client.uptime, num_sec=3600, handle_exception=True)
vm.ssh = ssh_client
vm.system_type = detect_system_type(vm)
logger.info("Detected system type: %s", vm.system_type)
vm.image = vm_analysis_provisioning_data['image']
vm.connect_ip = connect_ip
# TODO: if rhev and iscsi, it need direct_lun
if provider.type == 'rhevm':
logger.info("Setting a relationship between VM and appliance")
cfme_rel = InfraVm.CfmeRelationship(vm)
cfme_rel.set_relationship(appliance.server.name,
appliance.server_id())
# Close the SSH client if we have one
request.addfinalizer(lambda: vm.ssh.close()
if getattr(vm, 'ssh', None) else None)
return vm
def test_provision_approval(appliance, setup_provider, provider, vm_name,
smtp_test, request, edit, provisioning):
""" Tests provisioning approval. Tests couple of things.
* Approve manually
* Approve by editing the request to conform
Prerequisities:
* A provider that can provision.
* Automate role enabled
* User with e-mail set so you can receive and view them
Steps:
* Create a provisioning request that does not get automatically approved (eg. ``num_vms``
bigger than 1)
* Wait for an e-mail to come, informing you that the auto-approval was unsuccessful.
* Depending on whether you want to do manual approval or edit approval, do:
* MANUAL: manually approve the request in UI
* EDIT: Edit the request in UI so it conforms the rules for auto-approval.
* Wait for an e-mail with approval
* Wait until the request finishes
* Wait until an email, informing about finished provisioning, comes.
Metadata:
test_flag: provision
suite: infra_provisioning
"""
# generate_tests makes sure these have values
template, host, datastore = map(provisioning.get,
('template', 'host', 'datastore'))
# It will provision two of them
vm_names = [vm_name + "001", vm_name + "002"]
request.addfinalizer(lambda: [
appliance.collections.infra_vms.instantiate(name, provider).
delete_from_provider() for name in vm_names
])
provisioning_data = {
'catalog': {
'vm_name': vm_name,
'num_vms': '2'
},
'environment': {
'host_name': {
'name': host
},
'datastore_name': {
'name': datastore
}
},
'network': {
'vlan': partial_match(provisioning['vlan'])
}
}
do_vm_provisioning(appliance,
template,
provider,
vm_name,
provisioning_data,
request,
smtp_test,
wait=False)
wait_for(lambda: len(
filter(
lambda mail: "your request for a new vms was not autoapproved" in
normalize_text(mail["subject"]), smtp_test.get_emails())) == 1,
num_sec=90,
delay=5)
wait_for(lambda: len(
filter(
lambda mail: "virtual machine request was not approved" in
normalize_text(mail["subject"]), smtp_test.get_emails())) == 1,
num_sec=90,
delay=5)
smtp_test.clear_database()
cells = {
'Description':
'Provision from [{}] to [{}###]'.format(template, vm_name)
}
provision_request = appliance.collections.requests.instantiate(cells=cells)
navigate_to(provision_request, 'Details')
if edit:
# Automatic approval after editing the request to conform
new_vm_name = vm_name + "-xx"
modifications = {
'catalog': {
'num_vms': "1",
'vm_name': new_vm_name
},
'Description':
'Provision from [{}] to [{}]'.format(template, new_vm_name)
}
provision_request.edit_request(values=modifications)
vm_names = [new_vm_name] # Will be just one now
request.addfinalizer(
lambda: appliance.collections.infra_vms.instantiate(
new_vm_name, provider).delete_from_provider())
else:
# Manual approval
provision_request.approve_request(method='ui', reason="Approved")
vm_names = [vm_name + "001", vm_name + "002"] # There will be two VMs
request.addfinalizer(lambda: [
appliance.collections.infra_vms.instantiate(name, provider).
delete_from_provider() for name in vm_names
])
wait_for(lambda: len(
filter(
lambda mail: "your virtual machine configuration was approved" in
normalize_text(mail["subject"]), smtp_test.get_emails())) == 1,
num_sec=120,
delay=5)
smtp_test.clear_database()
# Wait for the VM to appear on the provider backend before proceeding to ensure proper cleanup
logger.info('Waiting for vms %s to appear on provider %s',
", ".join(vm_names), provider.key)
wait_for(lambda: all(map(provider.mgmt.does_vm_exist, vm_names)),
handle_exception=True,
num_sec=600)
provision_request.wait_for_request(method='ui')
msg = "Provisioning failed with the message {}".format(
provision_request.row.last_message.text)
assert provision_request.is_succeeded(method='ui'), msg
# Wait for e-mails to appear
def verify():
return (len(
filter(
lambda mail: "your virtual machine request has completed vm {}"
.format(normalize_text(vm_name)) in normalize_text(mail[
"subject"]), smtp_test.get_emails())) == len(vm_names))
wait_for(verify, message="email receive check", delay=5)
def instance(request, local_setup_provider, provider, vm_name, vm_analysis_data):
""" Fixture to provision instance on the provider """
template = vm_analysis_data.get('image', None)
host_name, datastore_name = map(vm_analysis_data.get, ('host', 'datastore'))
mgmt_system = provider.get_mgmt_system()
provisioning_data = {
'vm_name': vm_name,
'host_name': {'name': [host_name]},
'datastore_name': {'name': [datastore_name]},
}
try:
provisioning_data['vlan'] = vm_analysis_data['vlan']
except KeyError:
# provisioning['vlan'] is required for rhevm provisioning
if provider.type == 'rhevm':
raise pytest.fail('rhevm requires a vlan value in provisioning info')
vm = VM.factory(vm_name, provider)
connect_ip = None
if provider.type == "openstack":
image = vm_analysis_data['image']
vm = VM.factory(vm_name, provider, image)
request.addfinalizer(vm.delete_from_provider)
connect_ip = mgmt_system.get_first_floating_ip()
provider.refresh_provider_relationships(method='ui')
inst_args = {
'email': '*****@*****.**',
'first_name': 'Image',
'last_name': 'Provisioner',
'template_name': image,
'notes': ('Testing provisioning from image {} to vm {} on provider {}'.format(
image, vm_name, provider.key)),
'instance_type': vm_analysis_data['instance_type'],
'availability_zone': vm_analysis_data['availability_zone'],
'security_groups': [vm_analysis_data['security_group']],
'cloud_network': vm_analysis_data['cloud_network'],
'public_ip_address': connect_ip,
}
vm.create(**inst_args)
else:
request.addfinalizer(lambda: cleanup_vm(vm_name, provider))
do_vm_provisioning(template, provider, vm_name, provisioning_data, request, None,
num_sec=6000)
logger.info("VM %s provisioned, waiting for IP address to be assigned", vm_name)
@pytest.wait_for(timeout="20m", delay=5)
def get_ip_address():
logger.info("Power state for {} vm: {}, is_vm_stopped: {}".format(
vm_name, mgmt_system.vm_status(vm_name), mgmt_system.is_vm_stopped(vm_name)))
if mgmt_system.is_vm_stopped(vm_name):
mgmt_system.start_vm(vm_name)
ip = mgmt_system.current_ip_address(vm_name)
logger.info("Fetched IP for %s: %s", vm_name, ip)
return ip is not None
connect_ip = mgmt_system.get_ip_address(vm_name)
assert connect_ip is not None
# Check that we can at least get the uptime via ssh this should only be possible
# if the username and password have been set via the cloud-init script so
# is a valid check
if vm_analysis_data['fs-type'] not in ['ntfs', 'fat32']:
logger.info("Waiting for %s to be available via SSH", connect_ip)
ssh_client = ssh.SSHClient(hostname=connect_ip, username=vm_analysis_data['username'],
password=vm_analysis_data['password'], port=22)
wait_for(ssh_client.uptime, num_sec=3600, handle_exception=False)
vm.ssh = ssh_client
vm.system_type = detect_system_type(vm)
logger.info("Detected system type: %s", vm.system_type)
vm.image = vm_analysis_data['image']
vm.connect_ip = connect_ip
if provider.type == 'rhevm':
logger.info("Setting a relationship between VM and appliance")
from cfme.infrastructure.virtual_machines import Vm
cfme_rel = Vm.CfmeRelationship(vm)
cfme_rel.set_relationship(str(configuration.server_name()), configuration.server_id())
return vm
def test_user_requester_for_lifecycle_provision(request, appliance, provider,
setup_provider, new_users,
generic_catalog_item,
infra_validate_request,
service_validate_request,
provisioning):
"""
Polarion:
assignee: ghubale
casecomponent: Automate
caseimportance: high
initialEstimate: 1/6h
tags: automate
Bugzilla:
1671563
1720273
1728706
"""
script = """
user = $evm.root['user']
$evm.log(:info, "This is the user: #{user.userid}")
$evm.log("info", "Listing Root Object Attributes:")
$evm.root.attributes.sort.each { |k, v| $evm.log("info", "\t#{k}: #{v}") }
$evm.log("info", "===========================================")
"""
infra_validate_request.update(updates={"script": script})
service_validate_request.update(updates={"script": script})
with new_users[0]:
# Log in with first user and order service catalog
result = LogValidator(
"/var/www/miq/vmdb/log/automation.log",
matched_patterns=[
".*This is the user: {name}.*".format(
name=new_users[0].credential.principal)
],
)
result.start_monitoring()
service_catalogs = ServiceCatalogs(
appliance,
catalog=generic_catalog_item.catalog,
name=generic_catalog_item.name)
provision_request = service_catalogs.order()
provision_request.wait_for_request()
assert result.validate(wait="60s")
with new_users[1]:
# Log in with second user and provision instance via lifecycle
result = LogValidator(
"/var/www/miq/vmdb/log/automation.log",
matched_patterns=[
".*This is the user: {name}.*".format(
name=new_users[1].credential.principal)
],
)
result.start_monitoring()
prov_data = {
"catalog": {
'vm_name': random_vm_name(context='provision')
},
"environment": {
'automatic_placement': True
},
}
do_vm_provisioning(appliance,
template_name=provisioning["template"],
provider=provider,
vm_name=prov_data['catalog']['vm_name'],
provisioning_data=prov_data,
wait=False,
request=None)
request_description = 'Provision from [{template}] to [{vm}{msg}]'.format(
template=provisioning["template"],
vm=prov_data['catalog']['vm_name'],
msg='')
provision_request = appliance.collections.requests.instantiate(
request_description)
provision_request.wait_for_request(method='ui')
request.addfinalizer(provision_request.remove_request)
assert result.validate(wait="60s")
def _ssa_single_vm():
template_name = vm_analysis_provisioning_data['image']
vm_name = 'test-ssa-{}-{}'.format(fauxfactory.gen_alphanumeric(), analysis_type)
collection = provider.appliance.provider_based_collection(provider)
vm = collection.instantiate(vm_name,
provider,
template_name=vm_analysis_provisioning_data.image)
provision_data = vm_analysis_provisioning_data.copy()
del provision_data['image']
if "test_ssa_compliance" in request._pyfuncitem.name or provider.one_of(RHEVMProvider):
provisioning_data = {"catalog": {'vm_name': vm_name},
"environment": {'automatic_placement': True}}
if provider.one_of(RHEVMProvider):
provisioning_data.update(
{"network": {'vlan': partial_match(provision_data['vlan'])}}
)
do_vm_provisioning(vm_name=vm_name, appliance=appliance, provider=provider,
provisioning_data=provisioning_data, template_name=template_name,
request=request, num_sec=2500)
else:
deploy_template(vm.provider.key, vm_name, template_name, timeout=2500)
vm.wait_to_appear(timeout=900, load_details=False)
request.addfinalizer(lambda: vm.cleanup_on_provider())
if provider.one_of(OpenStackProvider):
public_net = provider.data['public_network']
vm.mgmt.assign_floating_ip(public_net)
logger.info("VM %s provisioned, waiting for IP address to be assigned", vm_name)
vm.mgmt.ensure_state(VmState.RUNNING)
@wait_for_decorator(timeout="10m", delay=5)
def get_ip_address():
ip = vm.mgmt.ip
logger.info("Fetched IP for %s: %s", vm_name, ip)
return ip is not None
connect_ip = vm.mgmt.ip
assert connect_ip is not None
# Check that we can at least get the uptime via ssh this should only be possible
# if the username and password have been set via the cloud-init script so
# is a valid check
if vm_analysis_provisioning_data['fs-type'] not in ['ntfs', 'fat32']:
logger.info("Waiting for %s to be available via SSH", connect_ip)
ssh_client = ssh.SSHClient(
hostname=connect_ip,
username=credentials[vm_analysis_provisioning_data.credentials]['username'],
password=credentials[vm_analysis_provisioning_data.credentials]['password'],
port=22)
wait_for(ssh_client.uptime, num_sec=3600, handle_exception=True)
vm.ssh = ssh_client
vm.system_type = detect_system_type(vm)
logger.info("Detected system type: %s", vm.system_type)
vm.image = vm_analysis_provisioning_data['image']
vm.connect_ip = connect_ip
# TODO: if rhev and iscsi, it need direct_lun
if provider.type == 'rhevm':
logger.info("Setting a relationship between VM and appliance")
cfme_rel = InfraVm.CfmeRelationship(vm)
cfme_rel.set_relationship(appliance.server.name, appliance.server_id())
# Close the SSH client if we have one
request.addfinalizer(lambda: vm.ssh.close() if getattr(vm, 'ssh', None) else None)
return vm
