def _post_approval(smtp_test, provision_request, vm_type, requester, provider,
approved_vm_names):
# requester includes the trailing space
approved_subject = normalize_text(f"your {vm_type} request was approved")
approved_from = normalize_text(
f"{vm_type} request from {requester}was approved")
wait_for_messages_with_subjects(smtp_test,
{approved_subject, approved_from},
num_sec=90)
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(approved_vm_names), provider.key)
wait_for(lambda: all(map(provider.mgmt.does_vm_exist, approved_vm_names)),
handle_exception=True,
num_sec=600)
provision_request.wait_for_request(method='ui')
msg = f"Provisioning failed with the message {provision_request.row.last_message.text}."
assert provision_request.is_succeeded(method='ui'), msg
# account for multiple vms, specific names
completed_subjects = {
normalize_text(f"your {vm_type} request has completed vm name {name}")
for name in approved_vm_names
}
wait_for_messages_with_subjects(smtp_test, completed_subjects, num_sec=90)
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)
)
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)
)
def _action_deny():
provision_request = appliance.collections.requests.instantiate(
cells=cells)
provision_request.deny_request(method='ui', reason="You stink!")
denied_subject = normalize_text(f"your {vm_type} request was denied")
denied_from = normalize_text(
f"{vm_type} request from {requester}was denied")
wait_for_messages_with_subjects(smtp_test,
[denied_subject, denied_from],
num_sec=90)
def verify():
subject = VersionPicker({
LOWEST: "your virtual machine request has completed vm {}".format(
normalize_text(vm_name)),
"5.10": "your virtual machine request has completed vm name {}".format(
normalize_text(vm_name))
}).pick()
return (
len(filter(
lambda mail: subject in normalize_text(mail["subject"]),
smtp_test.get_emails())) == len(vm_names)
)
def verify():
subject = VersionPicker({
LOWEST: "your virtual machine request has completed vm {}".format(
normalize_text(vm_name)),
"5.10": "your virtual machine request has completed vm name {}".format(
normalize_text(vm_name))
}).pick()
return (
len(filter(
lambda mail: subject in normalize_text(mail["subject"]),
smtp_test.get_emails())) == len(vm_names)
)
def filedump(
self,
description,
contents,
slaveid=None,
mode="w",
contents_base64=False,
display_type="primary",
display_glyph=None,
file_type=None,
dont_write=False,
os_filename=None,
group_id=None,
test_name=None,
test_location=None,
):
if not slaveid:
slaveid = "Master"
test_ident = "{}/{}".format(
self.store[slaveid]["test_location"], self.store[slaveid]["test_name"]
)
artifacts = []
if os_filename is None:
safe_name = re.sub(r"\s+", "_", normalize_text(safe_string(description)))
os_filename = self.ident + "-" + safe_name
os_filename = os.path.join(self.store[slaveid]["artifact_path"], os_filename)
if file_type is not None and "screenshot" in file_type:
os_filename = os_filename + ".png"
elif file_type is not None and (
"_tb" in file_type or "traceback" in file_type or file_type == "log"
):
os_filename = os_filename + ".log"
elif file_type is not None and file_type == "html":
os_filename = os_filename + ".html"
elif file_type is not None and file_type == "video":
os_filename = os_filename + ".ogv"
else:
os_filename = os_filename + ".txt"
artifacts.append(
{
"file_type": file_type,
"display_type": display_type,
"display_glyph": display_glyph,
"description": description,
"os_filename": os_filename,
"group_id": group_id,
}
)
if not dont_write:
if os.path.isfile(os_filename):
os.remove(os_filename)
with open(os_filename, mode) as f:
if contents_base64:
contents = base64.b64decode(contents)
f.write(contents)
return None, {"artifacts": {test_ident: {"files": artifacts}}}
def filedump(
self,
description,
contents,
slaveid=None,
mode="w",
contents_base64=False,
display_type="primary",
display_glyph=None,
file_type=None,
dont_write=False,
os_filename=None,
group_id=None,
test_name=None,
test_location=None,
):
if not slaveid:
slaveid = "Master"
test_ident = "{}/{}".format(self.store[slaveid]["test_location"],
self.store[slaveid]["test_name"])
artifacts = []
if os_filename is None:
safe_name = re.sub(r"\s+", "_",
normalize_text(safe_string(description)))
os_filename = self.ident + "-" + safe_name
os_filename = os.path.join(self.store[slaveid]["artifact_path"],
os_filename)
if file_type is not None and "screenshot" in file_type:
os_filename = os_filename + ".png"
elif file_type is not None and ("_tb" in file_type
or "traceback" in file_type
or file_type == "log"):
os_filename = os_filename + ".log"
elif file_type is not None and file_type == "html":
os_filename = os_filename + ".html"
elif file_type is not None and file_type == "video":
os_filename = os_filename + ".ogv"
else:
os_filename = os_filename + ".txt"
artifacts.append({
"file_type": file_type,
"display_type": display_type,
"display_glyph": display_glyph,
"description": description,
"os_filename": os_filename,
"group_id": group_id,
})
if not dont_write:
if os.path.isfile(os_filename):
os.remove(os_filename)
with open(os_filename, mode) as f:
if contents_base64:
contents = base64.b64decode(contents)
f.write(contents)
return None, {"artifacts": {test_ident: {"files": artifacts}}}
def _check_subjects():
subjects = {
normalize_text(m["subject"])
for m in smtp_test.get_emails()
}
found_subjects_substrings = set()
# Looking for each expected subject in the list of received subjects with partial match
for expected_substring in expected_subjects_substrings:
for subject in subjects:
if expected_substring in subject:
found_subjects_substrings.add(expected_substring)
break
else:
logger.info('No emails with subjects containing "%s" found.',
expected_substring)
if expected_subjects_substrings - found_subjects_substrings:
return False
logger.info('Found all expected emails.')
return True
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 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 test_provision_approval(appliance, provider, vm_name, smtp_test, request,
edit, soft_assert):
""" 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 approval is pending
* 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 with provisioning complete
Metadata:
test_flag: provision
suite: infra_provisioning
Polarion:
assignee: jhenner
caseimportance: high
casecomponent: Provisioning
initialEstimate: 1/8h
"""
# generate_tests makes sure these have values
# template, host, datastore = map(provisioning.get, ('template', 'host', 'datastore'))
# It will provision two of them
# All the subject checks are normalized, because of newlines and capitalization
vm_names = [vm_name + "001", vm_name + "002"]
if provider.one_of(CloudProvider):
requester = ""
vm_type = "instance"
else:
requester = "[email protected] " # include trailing space for clean formatting
vm_type = "virtual machine"
collection = appliance.provider_based_collection(provider)
inst_args = {'catalog': {'vm_name': vm_name, 'num_vms': '2'}}
vm = collection.create(vm_name,
provider,
form_values=inst_args,
wait=False)
try:
wait_for(lambda: len(smtp_test.get_emails()) >= 2, num_sec=90, delay=3)
except TimedOutError:
pytest.fail(
'Did not receive at least 2 emails from provisioning request, received: {}'
.format(smtp_test.get_emails()))
pending_subject = normalize_text(
"your {} request is pending".format(vm_type))
# requester includes the trailing space
pending_from = normalize_text("{} request from {}pending approval".format(
vm_type, requester))
received_pending = [
normalize_text(m["subject"]) for m in smtp_test.get_emails()
]
# Looking for each expected subject in the list of received subjects with partial match
for subject in [pending_subject, pending_from]:
soft_assert(
any(subject in r_sub for r_sub in received_pending),
'Expected subject [{}], not matched in received subjects [{}]'.
format(subject, received_pending))
smtp_test.clear_database()
cells = {
'Description':
'Provision from [{}] to [{}###]'.format(vm.template_name, vm.name)
}
provision_request = appliance.collections.requests.instantiate(cells=cells)
if edit:
# Automatic approval after editing the request to conform
new_vm_name = '{}-xx'.format(vm_name)
modifications = {
'catalog': {
'num_vms': "1",
'vm_name': new_vm_name
},
'Description':
'Provision from [{}] to [{}]'.format(vm.template_name, new_vm_name)
}
provision_request.edit_request(values=modifications)
vm_names = [new_vm_name] # Will be just one now
request.addfinalizer(lambda: collection.instantiate(
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: [
appliance.collections.infra_vms.instantiate(v_name, provider).
cleanup_on_provider() for v_name in vm_names
])
try:
wait_for(lambda: len(smtp_test.get_emails()) >= 2, num_sec=90, delay=3)
except TimedOutError:
pytest.fail(
'Did not receive at least 1 emails from provisioning request, received: {}'
.format(smtp_test.get_emails()))
# requester includes the trailing space
approved_subject = normalize_text(
"your {} request was approved".format(vm_type))
approved_from = normalize_text("{} request from {}was approved".format(
vm_type, requester))
received_approved = [
normalize_text(m["subject"]) for m in smtp_test.get_emails()
]
# Looking for each expected subject in the list of received subjects with partial match
for subject in [approved_subject, approved_from]:
soft_assert(
any(subject in r_sub for r_sub in received_approved),
'Expected subject [{}], not matched in received subjects [{}]'.
format(subject, received_approved))
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
# account for multiple vms, specific names
completed_subjects = [
normalize_text("your {} request has completed vm name {}".format(
vm_type, name)) for name in vm_names
]
expected_subject_count = len(vm_names)
# Wait for e-mails to appear
try:
wait_for(lambda: len(smtp_test.get_emails()) >= expected_subject_count,
message="provisioning request completed emails",
delay=5)
except TimedOutError:
pytest.fail(
'Did not receive enough emails (> {}) from provisioning request, received: {}'
.format(expected_subject_count, smtp_test.get_emails()))
received_complete = [
normalize_text(m['subject']) for m in smtp_test.get_emails()
]
for expected_subject in completed_subjects:
soft_assert(
any(expected_subject in subject for subject in received_complete),
'Expected subject [{}], not matched in received subjects [{}]'.
format(subject, received_complete))
def verify():
return (len(
filter(
lambda mail: normalize_text(subject) in normalize_text(mail[
"subject"]), smtp_test.get_emails())) == len(vm_names))
def _expected_email_arrived():
emails = smtp.get_emails()
messages = (_email_message_with_rcpttos_header(m) for m in emails
if subject in normalize_text(m['subject']))
return all(eml_checker(m) for m in messages)
def test_provision_approval(appliance, provider, vm_name, smtp_test, request,
action, soft_assert):
""" 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 approval is pending
* Depending on whether you want to do:
* approve: manually approve the request in UI
* edit: Edit the request in UI so it conforms the rules for auto-approval.
* deny: Deny the request in UI.
* Wait for an e-mail with approval
* Wait until the request finishes
* Wait until an email with provisioning complete
Metadata:
test_flag: provision
suite: infra_provisioning
Polarion:
assignee: jhenner
caseimportance: high
casecomponent: Provisioning
initialEstimate: 1/8h
Bugzilla:
1472844
1676910
1380197
1818172
"""
# generate_tests makes sure these have values
# template, host, datastore = map(provisioning.get, ('template', 'host', 'datastore'))
# It will provision two of them
# All the subject checks are normalized, because of newlines and capitalization
vm_names = [vm_name + "001", vm_name + "002"]
requester = "[email protected] " # include trailing space for clean formatting
if provider.one_of(CloudProvider):
requester = "" if BZ(1818172).blocks else requester
vm_type = "instance"
else:
vm_type = "virtual machine"
collection = appliance.provider_based_collection(provider)
inst_args = {'catalog': {'vm_name': vm_name, 'num_vms': '2'}}
vm = collection.create(vm_name,
provider,
form_values=inst_args,
wait=False)
pending_subject = normalize_text(f"your {vm_type} request is pending")
# requester includes the trailing space
pending_from = normalize_text(
f"{vm_type} request from {requester}pending approval")
wait_for_messages_with_subjects(smtp_test, {pending_subject, pending_from},
num_sec=90)
smtp_test.clear_database()
cells = {
'Description': f'Provision from [{vm.template_name}] to [{vm.name}###]'
}
def _action_edit():
# Automatic approval after editing the request to conform
new_vm_name = f'{vm_name}-xx'
modifications = {
'catalog': {
'num_vms': "1",
'vm_name': new_vm_name
},
'Description':
f'Provision from [{vm.template_name}] to [{new_vm_name}]'
}
provision_request = appliance.collections.requests.instantiate(
cells=cells)
provision_request.edit_request(values=modifications)
vm_names = [new_vm_name] # Will be just one now
request.addfinalizer(lambda: collection.instantiate(
new_vm_name, provider).cleanup_on_provider())
_post_approval(smtp_test, provision_request, vm_type, requester,
provider, vm_names)
def _action_approve():
# Manual approval
provision_request = appliance.collections.requests.instantiate(
cells=cells)
provision_request.approve_request(method='ui', reason="Approved")
for v_name in vm_names:
request.addfinalizer(lambda:
(appliance.collections.infra_vms.instantiate(
v_name, provider).cleanup_on_provider()))
_post_approval(smtp_test, provision_request, vm_type, requester,
provider, vm_names)
def _action_deny():
provision_request = appliance.collections.requests.instantiate(
cells=cells)
provision_request.deny_request(method='ui', reason="You stink!")
denied_subject = normalize_text(f"your {vm_type} request was denied")
denied_from = normalize_text(
f"{vm_type} request from {requester}was denied")
wait_for_messages_with_subjects(smtp_test,
[denied_subject, denied_from],
num_sec=90)
# Call function doing what is necessary -- Variation of Strategy design pattern.
action_callable = locals().get(f'_action_{action}')
if not action_callable:
raise NotImplementedError(
f'Action {action} is not known to this test.')
action_callable()
def test_provision_approval(appliance, provider, 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
Polarion:
assignee: jhenner
caseimportance: high
casecomponent: Provisioning
initialEstimate: 1/8h
"""
# 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"]
if BZ(1628240).blocks and provider.one_of(CloudProvider):
requester = ""
else:
requester = "[email protected] "
collection = appliance.provider_based_collection(provider)
inst_args = {'catalog': {
'vm_name': vm_name,
'num_vms': '2'
}}
vm = collection.create(vm_name, provider, form_values=inst_args, wait=False)
try:
if provider.one_of(CloudProvider):
vm_type = "instance"
else:
vm_type = "virtual machine"
subject = VersionPicker({
LOWEST: "your request for a new vms was not autoapproved",
"5.10": "your {} request is pending".format(vm_type)
}).pick()
wait_for(
lambda:
len(filter(
lambda mail:
normalize_text(subject) in normalize_text(mail["subject"]),
smtp_test.get_emails())) == 1,
num_sec=90, delay=5)
subject = VersionPicker({
LOWEST: "virtual machine request was not approved",
"5.10": "{} request from {}pending approval".format(vm_type, requester)
}).pick()
wait_for(
lambda:
len(filter(
lambda mail:
normalize_text(subject) in normalize_text(mail["subject"]),
smtp_test.get_emails())) == 1,
num_sec=90, delay=5)
except TimedOutError:
subjects = ",".join([normalize_text(m["subject"]) for m in smtp_test.get_emails()])
logger.error("expected: %s, got emails: %s", subject, subjects)
raise
smtp_test.clear_database()
cells = {'Description': 'Provision from [{}] to [{}###]'.format(vm.template_name, 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 = '{}-xx'.format(vm_name)
modifications = {
'catalog': {'num_vms': "1", 'vm_name': new_vm_name},
'Description': 'Provision from [{}] to [{}]'.format(vm.template_name, new_vm_name)}
provision_request.edit_request(values=modifications)
vm_names = [new_vm_name] # Will be just one now
request.addfinalizer(
lambda: collection.instantiate(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: [appliance.collections.infra_vms.instantiate(name,
provider).cleanup_on_provider()
for name in vm_names]
)
subject = VersionPicker({
LOWEST: "your virtual machine configuration was approved",
"5.10": "your {} request was approved".format(vm_type)
}).pick()
try:
wait_for(
lambda:
len(filter(
lambda mail:
normalize_text(subject) in normalize_text(mail["subject"]),
smtp_test.get_emails())) == 1,
num_sec=120, delay=5)
except TimedOutError:
subjects = ",".join([normalize_text(m["subject"]) for m in smtp_test.get_emails()])
logger.error("expected: %s, got emails: %s", subject, subjects)
raise
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
subject = VersionPicker({
LOWEST: "your virtual machine request has completed vm {}".format(vm_name),
"5.10": "your {} request has completed vm name {}".format(vm_type, vm_name)
}).pick()
# Wait for e-mails to appear
def verify():
return (
len(filter(
lambda mail: normalize_text(subject) in normalize_text(mail["subject"]),
smtp_test.get_emails())) == len(vm_names)
)
try:
wait_for(verify, message="email receive check", delay=5)
except TimedOutError:
subjects = ",".join([normalize_text(m["subject"]) for m in smtp_test.get_emails()])
logger.error("expected: %s, got emails: %s", subject, subjects)
raise
def verify():
return (
len(filter(
lambda mail: normalize_text(subject) in normalize_text(mail["subject"]),
smtp_test.get_emails())) == len(vm_names)
)
def test_provision_approval(appliance, provider, 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
Polarion:
assignee: jhenner
caseimportance: high
initialEstimate: 1/8h
"""
# 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"]
if BZ(1628240).blocks and provider.one_of(CloudProvider):
requester = ""
else:
requester = "[email protected] "
collection = appliance.provider_based_collection(provider)
inst_args = {'catalog': {'vm_name': vm_name, 'num_vms': '2'}}
vm = collection.create(vm_name,
provider,
form_values=inst_args,
wait=False)
try:
if provider.one_of(CloudProvider):
vm_type = "instance"
else:
vm_type = "virtual machine"
subject = VersionPicker({
LOWEST:
"your request for a new vms was not autoapproved",
"5.10":
"your {} request is pending".format(vm_type)
}).pick()
wait_for(lambda: len(
filter(
lambda mail: normalize_text(subject) in normalize_text(mail[
"subject"]), smtp_test.get_emails())) == 1,
num_sec=90,
delay=5)
subject = VersionPicker({
LOWEST:
"virtual machine request was not approved",
"5.10":
"{} request from {}pending approval".format(vm_type, requester)
}).pick()
wait_for(lambda: len(
filter(
lambda mail: normalize_text(subject) in normalize_text(mail[
"subject"]), smtp_test.get_emails())) == 1,
num_sec=90,
delay=5)
except TimedOutError:
subjects = ",".join(
[normalize_text(m["subject"]) for m in smtp_test.get_emails()])
logger.error("expected: %s, got emails: %s", subject, subjects)
raise
smtp_test.clear_database()
cells = {
'Description':
'Provision from [{}] to [{}###]'.format(vm.template_name, 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 = '{}-xx'.format(vm_name)
modifications = {
'catalog': {
'num_vms': "1",
'vm_name': new_vm_name
},
'Description':
'Provision from [{}] to [{}]'.format(vm.template_name, new_vm_name)
}
provision_request.edit_request(values=modifications)
vm_names = [new_vm_name] # Will be just one now
request.addfinalizer(lambda: collection.instantiate(
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: [
appliance.collections.infra_vms.instantiate(name, provider).
cleanup_on_provider() for name in vm_names
])
subject = VersionPicker({
LOWEST:
"your virtual machine configuration was approved",
"5.10":
"your {} request was approved".format(vm_type)
}).pick()
try:
wait_for(lambda: len(
filter(
lambda mail: normalize_text(subject) in normalize_text(mail[
"subject"]), smtp_test.get_emails())) == 1,
num_sec=120,
delay=5)
except TimedOutError:
subjects = ",".join(
[normalize_text(m["subject"]) for m in smtp_test.get_emails()])
logger.error("expected: %s, got emails: %s", subject, subjects)
raise
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
subject = VersionPicker({
LOWEST:
"your virtual machine request has completed vm {}".format(vm_name),
"5.10":
"your {} request has completed vm name {}".format(vm_type, vm_name)
}).pick()
# Wait for e-mails to appear
def verify():
return (len(
filter(
lambda mail: normalize_text(subject) in normalize_text(mail[
"subject"]), smtp_test.get_emails())) == len(vm_names))
try:
wait_for(verify, message="email receive check", delay=5)
except TimedOutError:
subjects = ",".join(
[normalize_text(m["subject"]) for m in smtp_test.get_emails()])
logger.error("expected: %s, got emails: %s", subject, subjects)
raise
