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_pxe_provision_from_template(provider_key, provider_crud, provider_type, provider_mgmt,
provisioning, vm_name, smtp_test, provider_init, request):
"""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(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_key, provider_mgmt))
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_crud, vm_name, provisioning_data, request,
provider_mgmt, provider_key, smtp_test, num_sec=2100)
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_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_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_provision_approval(provider_init, provider_key, provider_crud, provider_type,
provider_mgmt, provisioning, vm_name, smtp_test, request):
""" Tests provisioning approval
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_key, provider_mgmt) 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_crud, vm_name, provisioning_data, request,
provider_mgmt, provider_key, 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)
requests.approve_request(cells, "Approved")
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=90, 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_crud.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) == "request complete"
# 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())) == 2
)
wait_for(verify, message="email receive check", delay=5)
