def existing_vm(request):
""" Fixture will be using for set\unset retirement date for existing vm instead of
creation a new one
"""
list_of_existing_providers = providers.existing_providers()
if list_of_existing_providers:
test_provider = providers.get_crud(list_of_existing_providers[0])
else:
test_provider = providers.setup_a_provider()
all_vms = test_provider.mgmt.list_vm()
need_to_create_vm = True
for virtual_machine in all_vms:
if test_provider.mgmt.is_vm_running(virtual_machine):
need_vm = VM.factory(virtual_machine, test_provider)
need_to_create_vm = False
break
if need_to_create_vm:
machine_name = 'test_retire_prov_{}'.format(fauxfactory.gen_alpha(length=8).lower())
need_vm = VM.factory(machine_name, test_provider)
need_vm.create_on_provider(find_in_cfme=True, allow_skip="default")
@request.addfinalizer
def _delete_vm():
if need_to_create_vm:
test_provider.mgmt.delete_vm(need_vm.name)
return need_vm
def finalize():
policy_for_testing.assign_events()
with update(policy_for_testing):
policy_for_testing.scope = (
"fill_field(VM and Instance : Name, INCLUDES, {})".format(vm_name))
with update(compliance_policy):
compliance_policy.scope = (
"fill_field(VM and Instance : Name, INCLUDES, {})".format(vm_name))
VM.factory(clone_vm_name, provider).cleanup_on_provider()
def vm_name(provider):
# also tries to delete the VM that gets made with this name
vm_name = random_vm_name('scat')
yield vm_name
scat_vm = "{}0001".format(vm_name)
if scat_vm in provider.mgmt.list_vm():
vm_name_to_cleanup = "{}0001".format(vm_name)
else:
vm_name_to_cleanup = vm_name
VM.factory(vm_name_to_cleanup, provider).cleanup_on_provider()
def _get_vm(request, provider, template_name, vm_name):
if provider.one_of(RHEVMProvider):
kwargs = {"cluster": provider.data["default_cluster"]}
elif provider.one_of(OpenStackProvider):
kwargs = {}
if 'small_template' in provider.data.templates:
kwargs = {"flavour_name": provider.data.provisioning.get('instance_type')}
elif provider.one_of(SCVMMProvider):
kwargs = {
"host_group": provider.data.get("provisioning", {}).get("host_group", "All Hosts")}
else:
kwargs = {}
try:
deploy_template(
provider.key,
vm_name,
template_name=template_name,
allow_skip="default",
power_on=True,
**kwargs
)
except TimedOutError as e:
logger.exception(e)
try:
VM.factory(vm_name, provider).cleanup_on_provider()
except TimedOutError:
logger.warning("Could not delete VM %s!", vm_name)
finally:
# If this happened, we should skip all tests from this provider in this module
pytest.skip("{} is quite likely overloaded! Check its status!\n{}: {}".format(
provider.key, type(e).__name__, str(e)))
request.addfinalizer(lambda: VM.factory(vm_name, provider).cleanup_on_provider())
# Make it appear in the provider
provider.refresh_provider_relationships()
# Get the REST API object
api = wait_for(
get_vm_object,
func_args=[provider.appliance, vm_name],
message="VM object {} appears in CFME".format(vm_name),
fail_condition=None,
num_sec=600,
delay=15,
)[0]
return VMWrapper(provider, vm_name, api)
def vm_name(request, initialize_provider, full_template):
name = "test_alerts_{}".format(fauxfactory.gen_alpha())
@request.addfinalizer
def _cleanup_vm():
try:
if initialize_provider.mgmt.does_vm_exist(name):
initialize_provider.mgmt.delete_vm(name)
initialize_provider.refresh_provider_relationships()
except Exception as e:
logger.exception(e)
vm_obj = VM.factory(name, initialize_provider, template_name=full_template["name"])
vm_obj.create_on_provider(allow_skip="default")
initialize_provider.mgmt.start_vm(vm_obj.name)
initialize_provider.mgmt.wait_vm_running(vm_obj.name)
# In order to have seamless SSH connection
vm_ip, _ = wait_for(
lambda: initialize_provider.mgmt.current_ip_address(vm_obj.name),
num_sec=300, delay=5, fail_condition={None}, message="wait for testing VM IP address.")
wait_for(
net_check, [ports.SSH, vm_ip], {"force": True},
num_sec=300, delay=5, message="testing VM's SSH available")
if not vm_obj.exists:
initialize_provider.refresh_provider_relationships()
vm_obj.wait_to_appear()
if initialize_provider.type in CANDU_PROVIDER_TYPES:
vm_obj.wait_candu_data_available(timeout=20 * 60)
return name
def tagged_vm(new_tag, setup_provider_modscope, provider):
ownership_vm = provider.data['ownership_vm']
tag_vm = VM.factory(ownership_vm, provider)
tag_vm.add_tag(new_tag)
yield tag_vm
login.login_admin()
tag_vm.remove_tag(new_tag)
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: VM.factory(vm_name, provider).cleanup_on_provider())
provisioning_data = {
'catalog': {
'vm_name': vm_name,
'provision_type': 'ISO',
'iso_file': {'name': iso_file}},
'environment': {
'host_name': {'name': host},
'datastore_name': {'name': datastore}},
'customize': {
'custom_template': {'name': iso_kickstart},
'root_password': iso_root_password},
'network': {
'vlan': vlan}}
do_vm_provisioning(appliance, iso_template, provider, vm_name, provisioning_data, request,
smtp_test, num_sec=1500)
def test_no_template_power_control(provider, setup_provider_funcscope, soft_assert):
""" Ensures that no power button is displayed for templates.
Prerequisities:
* An infra provider that has some templates.
Steps:
* Open the view of all templates of the provider
* Verify the Power toolbar button is not visible
* Select some template using the checkbox
* Verify the Power toolbar button is not visible
* Click on some template to get into the details page
* Verify the Power toolbar button is not visible
"""
provider.load_all_provider_templates()
toolbar.select('Grid View')
soft_assert(not toolbar.exists("Power"), "Power displayed in template grid view!")
# Ensure selecting a template doesn't cause power menu to appear
templates = list(get_all_vms(True))
template_name = random.choice(templates)
selected_template = VM.factory(template_name, provider, template=True)
# Check the power button with checking the quadicon
quadicon = selected_template.find_quadicon(do_not_navigate=True, mark=True, refresh=False)
soft_assert(not toolbar.exists("Power"), "Power displayed when template quadicon checked!")
# Ensure there isn't a power button on the details page
pytest.sel.click(quadicon)
soft_assert(not toolbar.exists("Power"), "Power displayed in template details!")
def _provisioner(template, provisioning_data, delayed=None):
vm = InfraVm(name=vm_name, provider=provider, template_name=template)
view = navigate_to(vm, 'Provision')
view.form.fill_with(provisioning_data, on_change=view.form.submit_button)
base_view = vm.appliance.browser.create_view(BaseLoggedInPage)
base_view.flash.assert_no_error()
request.addfinalizer(lambda: VM.factory(vm_name, provider).cleanup_on_provider())
request_description = 'Provision from [{}] to [{}]'.format(template, vm_name)
provision_request = appliance.collections.requests.instantiate(
description=request_description)
if delayed is not None:
total_seconds = (delayed - datetime.utcnow()).total_seconds()
try:
wait_for(provision_request.is_finished,
fail_func=provision_request.update, num_sec=total_seconds, delay=5)
pytest.fail("The provisioning was not postponed")
except TimedOutError:
pass
logger.info('Waiting for vm %s to appear on provider %s', vm_name, provider.key)
wait_for(
provider.mgmt.does_vm_exist, [vm_name],
fail_func=provider.refresh_provider_relationships,
handle_exception=True, num_sec=600
)
# nav to requests page happens on successful provision
logger.info('Waiting for cfme provision request for vm %s', vm_name)
provision_request.wait_for_request()
msg = "Provisioning failed with the message {}".format(provision_request.rest.message)
assert provision_request.is_succeeded(), msg
return vm
def test_vm(setup_provider_modscope, provider, vm_name):
"""Fixture to provision appliance to the provider being tested if necessary"""
vm = VM.factory(vm_name, provider, template_name=provider.data['full_template']['name'])
if not provider.mgmt.does_vm_exist(vm_name):
vm.create_on_provider(find_in_cfme=True, allow_skip="default")
return vm
def test_no_template_power_control(provider, soft_assert):
""" Ensures that no power button is displayed for templates.
Prerequisities:
* An infra provider that has some templates.
Steps:
* Open the view of all templates of the provider
* Verify the Power toolbar button is not visible
* Select some template using the checkbox
* Verify the Power toolbar button is not visible
* Click on some template to get into the details page
* Verify the Power toolbar button is not visible
"""
view = navigate_to(provider, 'ProviderTemplates')
view.toolbar.view_selector.select('Grid View')
soft_assert(not view.toolbar.power.is_enabled, "Power displayed in template grid view!")
# Ensure selecting a template doesn't cause power menu to appear
templates = list(get_all_vms(True))
template_name = random.choice(templates)
selected_template = VM.factory(template_name, provider, template=True)
# Check the power button with checking the quadicon
view = navigate_to(selected_template, 'AllForProvider', use_resetter=False)
entity = view.entities.get_entity(name=selected_template.name, surf_pages=True)
entity.check()
soft_assert(not view.toolbar.power.is_enabled,
"Power displayed when template quadicon checked!")
# Ensure there isn't a power button on the details page
entity.click()
soft_assert(not view.toolbar.power.is_enabled, "Power displayed in template details!")
def tagged_vm(tag, has_no_providers_modscope, setup_provider_modscope, provider):
ownership_vm = provider.data.cap_and_util.capandu_vm
tag_vm = VM.factory(ownership_vm, provider)
tag_vm.add_tag(tag=tag)
yield tag_vm
tag_vm.appliance.server.login_admin()
tag_vm.remove_tag(tag=tag)
def provision_vm(provider, template):
vm_name = random_vm_name(context="snpst")
vm = VM.factory(vm_name, provider, template_name=template.name)
if not provider.mgmt.does_vm_exist(vm_name):
vm.create_on_provider(find_in_cfme=True, allow_skip="default")
return vm
def _provisioner(template, provisioning_data, delayed=None):
pytest.sel.force_navigate('infrastructure_provision_vms', context={
'provider': provider,
'template_name': template,
})
vm_name = provisioning_data["vm_name"]
fill(provisioning_form, provisioning_data, action=provisioning_form.submit_button)
flash.assert_no_errors()
request.addfinalizer(lambda: cleanup_vm(vm_name, provider))
if delayed is not None:
total_seconds = (delayed - datetime.utcnow()).total_seconds()
row_description = 'Provision from [{}] to [{}]'.format(template, vm_name)
cells = {'Description': row_description}
try:
row, __ = wait_for(requests.wait_for_request, [cells],
fail_func=requests.reload, num_sec=total_seconds, delay=5)
pytest.fail("The provisioning was not postponed")
except TimedOutError:
pass
logger.info('Waiting for vm %s to appear on provider %s', vm_name, provider.key)
wait_for(provider.mgmt.does_vm_exist, [vm_name], handle_exception=True, num_sec=600)
# nav to requests page happens on successful provision
logger.info('Waiting for cfme provision request for vm %s', vm_name)
row_description = 'Provision from [{}] to [{}]'.format(template, vm_name)
cells = {'Description': row_description}
row, __ = wait_for(requests.wait_for_request, [cells],
fail_func=requests.reload, num_sec=900, delay=20)
assert row.last_message.text == 'Vm Provisioned Successfully'
return VM.factory(vm_name, provider)
def depot_machine_ip():
""" Deploy vm for depot test
This fixture uses for deploy vm on provider from yaml and then receive it's ip
After test run vm deletes from provider
"""
depot_machine_name = "test_long_log_depot_{}".format(fauxfactory.gen_alphanumeric())
data = conf.cfme_data.get("log_db_operations", {})
depot_provider_key = data["log_db_depot_template"]["provider"]
depot_template_name = data["log_db_depot_template"]["template_name"]
prov_crud = get_crud(depot_provider_key)
deploy_template(depot_provider_key,
depot_machine_name,
template_name=depot_template_name)
yield prov_crud.mgmt.get_ip_address(depot_machine_name)
VM.factory(depot_machine_name, prov_crud).cleanup_on_provider()
def vm_ownership(enable_candu, clean_setup_provider, provider, appliance):
# In these tests, Metering report is filtered on VM owner.So,VMs have to be
# assigned ownership.
vm_name = provider.data['cap_and_util']['chargeback_vm']
if not provider.mgmt.does_vm_exist(vm_name):
pytest.skip("Skipping test, {} VM does not exist".format(vm_name))
provider.mgmt.start_vm(vm_name)
provider.mgmt.wait_vm_running(vm_name)
group_collection = appliance.collections.groups
cb_group = group_collection.instantiate(description='EvmGroup-user')
user = appliance.collections.users.create(
name=fauxfactory.gen_alphanumeric(),
credential=Credential(principal='uid' + '{}'.format(fauxfactory.gen_alphanumeric()),
secret='secret'),
email='*****@*****.**',
groups=cb_group,
cost_center='Workload',
value_assign='Database')
vm = VM.factory(vm_name, provider)
try:
vm.set_ownership(user=user.name)
logger.info('Assigned VM OWNERSHIP for {} running on {}'.format(vm_name, provider.name))
yield user.name
finally:
vm.unset_ownership()
user.delete()
def ssa_vm(request, local_setup_provider, provider, vm_analysis_provisioning_data,
appliance, analysis_type):
""" Fixture to provision instance on the provider """
vm_name = 'test-ssa-{}-{}'.format(fauxfactory.gen_alphanumeric(), analysis_type)
vm = VM.factory(vm_name, provider, template_name=vm_analysis_provisioning_data.image)
request.addfinalizer(lambda: cleanup_vm(vm_name, provider))
provision_data = vm_analysis_provisioning_data.copy()
del provision_data['image']
vm.create_on_provider(find_in_cfme=True, **provision_data)
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=vm_analysis_provisioning_data['username'],
password=vm_analysis_provisioning_data['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 = VM.CfmeRelationship(vm)
server_name = appliance.server.name
cfme_rel.set_relationship(str(server_name), configuration.server_id())
yield vm
# Close the SSH client if we have one
if getattr(vm, 'ssh', None):
vm.ssh.close()
def vm_obj(provider, setup_provider_modscope, small_template_modscope):
"""Creates new VM or instance"""
vm_name = random_vm_name('attrs')
new_vm = VM.factory(vm_name, provider, template_name=small_template_modscope.name)
yield new_vm
new_vm.cleanup_on_provider()
def new_vm(request, provider):
vm = VM.factory(random_vm_name('timelines', max_length=16), provider)
logger.debug('Fixture new_vm set up! Name: %r', vm.name)
logger.info('Will create %r on Provider: %r', vm.name, vm.provider.name)
vm.create_on_provider(find_in_cfme=False, timeout=500)
yield vm
logger.debug('Fixture new_vm teardown! Name: %r Provider: %r', vm.name, vm.provider.name)
vm.provider.mgmt.delete_vm(vm.name)
def vm_crud(provider, setup_provider_modscope, small_template_modscope):
vm = VM.factory(
'test_events_{}'.format(fauxfactory.gen_alpha(length=8).lower()),
provider,
template_name=small_template_modscope)
yield vm
if vm.does_vm_exist_on_provider():
vm.delete_from_provider()
def new_vm(provider, setup_provider, small_template_modscope):
"""Fixture to provision and delete vm on the provider"""
vm_name = 'test_service_{}'.format(fauxfactory.gen_alphanumeric())
vm = VM.factory(vm_name, provider, small_template_modscope.name)
vm.create_on_provider(find_in_cfme=True, timeout=700, allow_skip="default")
yield vm
vm.cleanup_on_provider()
provider.refresh_provider_relationships()
def test_vm(setup_provider_modscope, provider, vm_name, request):
"""Fixture to provision appliance to the provider being tested if necessary"""
vm = VM.factory(vm_name, provider, template_name=provider.data["small_template"])
if not provider.mgmt.does_vm_exist(vm_name):
vm.create_on_provider(find_in_cfme=True, allow_skip="default")
request.addfinalizer(vm.delete_from_provider)
return vm
def _get_vm_obj_if_exists_on_provider(provider, vm_name):
vm = VM.factory(vm_name, provider)
if not vm.does_vm_exist_on_provider():
raise ValueError(
"Unable to ensure VM state: "
"VM '{}' does not exist on provider '{}'".format(vm_name, provider.key)
)
return vm
def testing_vm(request, vm_name, setup_provider, provider, provisioning):
vm_obj = VM.factory(vm_name, provider, provisioning["template"])
def _finalize():
vm_obj.delete_from_provider()
request.addfinalizer(_finalize)
vm_obj.create_on_provider(find_in_cfme=True, allow_skip="default")
return vm_obj
def test_group_ownership_on_user_or_group_role(request, user3, setup_infra_provider):
set_vm_to_group = VM.factory('cu-9-5', setup_infra_provider)
set_vm_to_group.set_ownership(group=user3.group.description)
with user3:
assert(set_vm_to_group.exists, "vm not found")
set_vm_to_group.unset_ownership()
with user3:
assert(not set_vm_to_group.exists, "vm exists")
def small_vm(provider, small_template_modscope):
vm = VM.factory(random_vm_name(context='reconfig'), provider, small_template_modscope.name)
vm.create_on_provider(find_in_cfme=True, allow_skip="default")
vm.refresh_relationships()
yield vm
vm.delete_from_provider()
def new_vm(request, a_provider):
vm = VM.factory(random_vm_name("timelines", max_length=16), a_provider)
request.addfinalizer(vm.delete_from_provider)
if not a_provider.mgmt.does_vm_exist(vm.name):
logger.info("deploying %s on provider %s", vm.name, a_provider.key)
vm.create_on_provider(allow_skip="default", find_in_cfme=True)
return vm
def new_vm(setup_provider_modscope, provider, request):
"""Fixture to provision appliance to the provider being tested if necessary"""
vm_name = random_vm_name(context='migrate')
vm = VM.factory(vm_name, provider, template_name=provider.data['small_template'])
if not provider.mgmt.does_vm_exist(vm_name):
vm.create_on_provider(find_in_cfme=True, allow_skip="default")
request.addfinalizer(vm.cleanup_on_provider)
return vm
def test_group_ownership_on_user_only_role(request, user2, setup_provider, provider):
ownership_vm = provider.data['ownership_vm']
group_ownership_vm = VM.factory(ownership_vm, provider)
group_ownership_vm.set_ownership(group=user2.group.description)
with user2:
assert (group_ownership_vm.exists, "vm not found")
group_ownership_vm.unset_ownership()
with user2:
assert (not group_ownership_vm.exists, "vm exists")
def test_no_dvd_ruins_refresh(provider, small_template):
host_group = provider.data["provisioning"]["host_group"]
with provider.mgmt.with_vm(
small_template, vm_name="test_no_dvd_{}".format(fauxfactory.gen_alpha()),
host_group=host_group) as vm_name:
provider.mgmt.disconnect_dvd_drives(vm_name)
vm = VM.factory(vm_name, provider)
provider.refresh_provider_relationships()
vm.wait_to_appear()
def vm_crud(provider):
vm = VM.factory(random_vm_name(context='ownrs'), provider)
vm.create_on_provider(find_in_cfme=True, allow_skip="default")
yield vm
try:
vm.delete_from_provider()
except Exception:
logger.exception('Exception deleting test vm "%s" on %s', vm.name,
provider.name)
def test_user_ownership_crud(request, user1, setup_provider, provider):
ownership_vm = provider.data['ownership_vm']
user_ownership_vm = VM.factory(ownership_vm, provider)
# Set the ownership and checking it
user_ownership_vm.set_ownership(user=user1.name)
with user1:
assert user_ownership_vm.exists, "vm not found"
user_ownership_vm.unset_ownership()
with user1:
assert not user_ownership_vm.exists, "vm exists"
def test_vm(setup_provider_modscope, provider, vm_name, request):
"""Fixture to provision appliance to the provider being tested if necessary"""
vm = VM.factory(vm_name,
provider,
template_name=provider.data['full_template']['name'])
if not provider.mgmt.does_vm_exist(vm_name):
vm.create_on_provider(find_in_cfme=True, allow_skip="default")
request.addfinalizer(vm.delete_from_provider)
return vm
def launch_vm_console(self, catalog_item):
navigate_to(self, 'VM Console')
# TODO need to remove 0001 from the line below and find correct place/way to put it in code
vm_obj = VM.factory(catalog_item.provisioning_data['catalog']['vm_name'] + '0001',
catalog_item.provider, template_name=catalog_item.catalog_name)
wait_for(
func=lambda: vm_obj.vm_console, num_sec=30, delay=2, handle_exception=True,
message="waiting for VM Console window to open"
)
return vm_obj
def test_group_ownership_on_user_or_group_role(request, user3, setup_provider,
provider):
ownership_vm = provider.data['ownership_vm']
group_ownership_vm = VM.factory(ownership_vm, provider)
group_ownership_vm.set_ownership(group=user3.group.description)
with user3:
assert group_ownership_vm.exists, "vm not found"
group_ownership_vm.unset_ownership()
with user3:
assert not group_ownership_vm.exists, "vm exists"
def test_vm(request, provider, vm_name, setup_provider_modscope):
"""Fixture to provision appliance to the provider being tested if necessary"""
pytest.sel.force_navigate('infrastructure_providers')
vm = VM.factory(vm_name, provider)
request.addfinalizer(vm.delete_from_provider)
if not provider.mgmt.does_vm_exist(vm_name):
vm.create_on_provider(find_in_cfme=True, allow_skip="default")
return vm
def compliance_vm(request, provider):
try:
ip_addr = urlparse(store.base_url).hostname
appl_name = provider.mgmt.get_vm_name_from_ip(ip_addr)
appliance = Appliance(provider.key, appl_name)
logger.info(
"The tested appliance (%s) is already on this provider (%s) so reusing it.",
appl_name, provider.key)
try:
appliance.configure_fleecing()
except (EOFError, ApplianceException) as e:
# If something was happening, restart and wait for the UI to reappear to prevent errors
appliance.ipapp.reboot()
pytest.skip(
"Error during appliance configuration. Skipping:\n{}: {}".
format(type(e).__name__, str(e)))
vm = VM.factory(appl_name, provider)
except exceptions.VMNotFoundViaIP:
logger.info("Provisioning a new appliance on provider %s.",
provider.key)
appliance = provision_appliance(vm_name_prefix=PREFIX + "host_",
version=str(version.current_version()),
provider_name=provider.key)
request.addfinalizer(lambda: diaper(appliance.destroy))
try:
appliance.configure(setup_fleece=True)
except (EOFError,
ApplianceException) as e: # Add known exceptions as needed.
pytest.skip(
"Error during appliance configuration. Skipping:\n{}: {}".
format(type(e).__name__, str(e)))
vm = VM.factory(appliance.vm_name, provider)
if provider.type in {"rhevm"}:
request.addfinalizer(appliance.remove_rhev_direct_lun_disk)
# Do the final touches
with appliance.ipapp(browser_steal=True) as appl:
appl.set_session_timeout(86400)
provider.refresh_provider_relationships()
vm.wait_to_appear()
vm.load_details()
wait_for_ssa_enabled()
yield vm
def myservice(appliance, provider, catalog_item, request):
"""Tests my service
Metadata:
test_flag: provision
"""
vm_name = catalog_item.prov_data["catalog"]["vm_name"] + '0001'
service_catalogs = ServiceCatalogs(appliance, catalog_item.catalog, catalog_item.name)
service_catalogs.order()
logger.info('Waiting for cfme provision request for service %s', catalog_item.name)
request_description = catalog_item.name
service_request = appliance.collections.requests.instantiate(request_description,
partial_check=True)
service_request.wait_for_request()
assert service_request.is_succeeded(),\
("Request failed with the message {}".format(service_request.rest.message))
yield catalog_item.name, vm_name
VM.factory(vm_name, provider).cleanup_on_provider()
def testing_vm(request, vm_name, setup_provider, provider, provisioning):
vm_obj = VM.factory(vm_name, provider, provisioning["template"])
def _finalize():
try:
vm_obj.delete_from_provider()
except Exception:
logger.warn('Failed deleting VM from provider: %s', vm_name)
request.addfinalizer(_finalize)
vm_obj.create_on_provider(find_in_cfme=True, allow_skip="default")
return vm_obj
def retire_vm(small_template, provider):
"""Fixture for creating a generic vm/instance
Args:
small_template: small template fixture, template on provider
provider: provider crud object from fixture
"""
vm = VM.factory(random_vm_name('retire'), provider, template_name=small_template.name)
vm.create_on_provider(find_in_cfme=True, allow_skip="default", timeout=1200)
yield vm
vm.cleanup_on_provider()
def new_vm(setup_provider_modscope, provider, request):
"""Fixture to provision appliance to the provider being tested if necessary"""
vm_name = random_vm_name(context='migrate')
vm = VM.factory(vm_name,
provider,
template_name=provider.data['small_template'])
if not provider.mgmt.does_vm_exist(vm_name):
vm.create_on_provider(find_in_cfme=True, allow_skip="default")
request.addfinalizer(vm.cleanup_on_provider)
return vm
def test_group_ownership_on_user_only_role(request, user2, setup_provider,
provider):
ownership_vm = provider.data['ownership_vm']
group_ownership_vm = VM.factory(ownership_vm, provider)
group_ownership_vm.set_ownership(group=user2.group.description)
with user2:
assert not check_vm_exists(
group_ownership_vm), "vm exists! but shouldn't exist"
group_ownership_vm.set_ownership(user=user2.name)
with user2:
assert group_ownership_vm.exists, "vm exists"
def test_form_button_validation(request, user1, setup_provider, provider):
ownership_vm = provider.data['ownership_vm']
user_ownership_vm = VM.factory(ownership_vm, provider)
# Reset button test
user_ownership_vm.set_ownership(user=user1.name, click_reset=True)
# Cancel button test
user_ownership_vm.set_ownership(user=user1.name, click_cancel=True)
# Save button test
user_ownership_vm.set_ownership(user=user1.name)
# Unset the ownership
user_ownership_vm.unset_ownership()
def retire_ec2_s3_vm(provider):
"""Fixture for creating an S3 backed paravirtual instance, template is a public ec2 AMI
Args:
provider: provider crud object from fixture
"""
vm = VM.factory(random_vm_name('retire'), provider,
template_name='amzn-ami-pv-2015.03.rc-1.x86_64-s3')
vm.create_on_provider(find_in_cfme=True, allow_skip="default", timeout=1200)
yield vm
vm.cleanup_on_provider()
def testing_vm(request, setup_provider, provider):
vm = VM.factory("test_ae_hd_{}".format(fauxfactory.gen_alphanumeric()),
provider,
template_name=provider.data['full_template']['name'])
try:
vm.create_on_provider(find_in_cfme=True, allow_skip="default")
yield vm
finally:
vm.delete_from_provider()
if vm.exists:
vm.delete()
def vm(request, provider, setup_provider, small_template):
vm_obj = VM.factory(
'test_retire_prov_{}'.format(fauxfactory.gen_alpha(length=8).lower()),
provider, template_name=small_template)
@request.addfinalizer
def _delete_vm():
if provider.mgmt.does_vm_exist(vm_obj.name):
provider.mgmt.delete_vm(vm_obj.name)
vm_obj.create_on_provider(find_in_cfme=True, allow_skip="default")
return vm_obj
def compliance_vm(configure_fleecing, provider, full_template_modscope):
name = "{}-{}".format("test-compliance", fauxfactory.gen_alpha(4))
vm = VM.factory(name, provider, template_name=full_template_modscope.name)
vm.create_on_provider(allow_skip="default")
provider.mgmt.start_vm(vm.name)
provider.mgmt.wait_vm_running(vm.name)
if not vm.exists:
vm.wait_to_appear(timeout=900)
yield vm
vm.cleanup_on_provider()
provider.refresh_provider_relationships()
def vm_obj(provider, setup_provider_modscope, small_template_modscope):
"""Creates new VM or instance"""
vm_name = random_vm_name('attrs')
new_vm = VM.factory(vm_name, provider, template_name=small_template_modscope.name)
yield new_vm
if provider.mgmt.does_vm_exist(new_vm.name):
try:
provider.mgmt.delete_vm(new_vm.name)
except Exception:
logger.warning('Failed to delete vm `{}`.'.format(new_vm.name))
def test_vm(virtualcenter_provider):
"""Fixture to provision appliance to the provider being tested if necessary"""
vm_name = random_vm_name('distpwr')
vm = VM.factory(vm_name, virtualcenter_provider)
if not virtualcenter_provider.mgmt.does_vm_exist(vm_name):
logger.info("deploying %r on provider %r", vm_name, virtualcenter_provider.key)
vm.create_on_provider(find_in_cfme=True, allow_skip="default")
else:
logger.info("recycling deployed vm %r on provider %r", vm_name, virtualcenter_provider.key)
yield vm
vm.cleanup_on_provider()
def fleecing_vm(request, compliance_vm, provider, analysis_profile):
logger.info("Provisioning an appliance for fleecing on %s", provider.key)
# TODO: When we get something smaller, use it!
appliance = provision_appliance(vm_name_prefix=PREFIX + "for_fleece_",
version=str(version.current_version()),
provider_name=provider.key)
request.addfinalizer(lambda: diaper(appliance.destroy))
logger.info("Appliance %s provisioned", appliance.vm_name)
vm = VM.factory(appliance.vm_name, provider)
provider.refresh_provider_relationships()
vm.wait_to_appear()
return vm
def vm_obj(request, provider, setup_provider, small_template, vm_name):
vm_obj = VM.factory(vm_name, provider, template_name=small_template.name)
@request.addfinalizer
def _delete_vm():
try:
provider.mgmt.delete_vm(vm_obj.name)
except Exception:
logger.warning("Failed to delete vm `{}`.".format(vm_obj.name))
vm_obj.create_on_provider(timeout=2400, find_in_cfme=True, allow_skip="default")
return vm_obj
def vm_crud(provider, setup_provider_modscope, small_template_modscope):
template = small_template_modscope
base_name = 'test-events-' if provider.one_of(
GCEProvider) else 'test_events_'
vm_name = base_name + fauxfactory.gen_alpha(length=8).lower()
vm = VM.factory(vm_name, provider, template_name=template.name)
yield vm
if vm.does_vm_exist_on_provider():
vm.cleanup_on_provider()
def test_delete_instance(setup_provider, provider):
""" Tests delete instance
Metadata:
test_flag: delete_object
"""
instance_name = provider.data['remove_test']['instance']
test_instance = VM.factory(instance_name, provider)
test_instance.delete()
test_instance.wait_for_delete()
provider.refresh_provider_relationships()
test_instance.wait_to_appear()
def test_delete_template_appear_after_refresh(setup_provider, provider):
""" Tests delete template
Metadata:
test_flag: delete_object
"""
template = provider.data['remove_test']['template']
test_template = VM.factory(template, provider, template=True)
test_template.delete()
test_template.wait_for_delete()
provider.refresh_provider_relationships()
test_template.wait_to_appear()
def provision_vm(request, provider):
"""Function to provision appliance to the provider being tested"""
vm_name = "test_rest_db_" + fauxfactory.gen_alphanumeric()
vm = VM.factory(vm_name, provider)
request.addfinalizer(vm.cleanup_on_provider)
if not provider.mgmt.does_vm_exist(vm_name):
logger.info("deploying %s on provider %s", vm_name, provider.key)
vm.create_on_provider(allow_skip="default")
else:
logger.info("recycling deployed vm %s on provider %s", vm_name, provider.key)
vm.provider.refresh_provider_relationships()
return vm
def test_delete_vm_appear_after_refresh(setup_provider, provider):
""" Tests delete vm
Metadata:
test_flag: delete_object
"""
vm = provider.data['remove_test']['vm']
test_vm = VM.factory(vm, provider)
test_vm.delete()
test_vm.wait_for_delete()
provider.refresh_provider_relationships()
test_vm.wait_to_appear()
def test_vm(small_template, provider):
vm = VM.factory(random_vm_name('retire'),
provider,
template_name=small_template)
vm.create_on_provider(find_in_cfme=True, allow_skip="default")
yield vm
try:
if provider.mgmt.does_vm_exist(vm.name):
provider.mgmt.delete_vm(vm.name)
except Exception:
logger.warning('Failed to delete vm from provider: {}'.format(vm.name))
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: VM.factory(vm_name, provider).cleanup_on_provider())
provisioning_data = {
'catalog': {
'vm_name': vm_name,
'provision_type': 'ISO',
'iso_file': {
'name': iso_file
}
},
'environment': {
'host_name': {
'name': host
},
'datastore_name': {
'name': datastore
}
},
'customize': {
'custom_template': {
'name': iso_kickstart
},
'root_password': iso_root_password
},
'network': {
'vlan': vlan
}
}
do_vm_provisioning(appliance,
iso_template,
provider,
vm_name,
provisioning_data,
request,
smtp_test,
num_sec=1500)
def test_delete_image(setup_provider, provider, set_grid, request):
""" Tests delete image
Metadata:
test_flag: delete_object
"""
image_name = provider.data['remove_test']['image']
test_image = VM.factory(image_name, provider, template=True)
test_image.delete()
test_image.wait_for_delete()
provider.refresh_provider_relationships()
test_image.wait_to_appear()
request.addfinalizer(reset)
def vm_obj(request, provider, setup_provider, console_template, vm_name):
"""VM creation/deletion fixture.
Create a VM on the provider with the given template, and return the vm_obj.
Clean up VM when test is done.
"""
vm_obj = VM.factory(vm_name, provider, template_name=console_template.name)
vm_obj.create_on_provider(timeout=2400,
find_in_cfme=True,
allow_skip="default")
yield vm_obj
vm_obj.cleanup_on_provider()
