def test_vm(request, provider_init, provider_crud, provider_mgmt, vm_name):
"""Fixture to provision appliance to the provider being tested if necessary"""
vm = Vm(vm_name, provider_crud)
if not provider_mgmt.does_vm_exist(vm_name):
vm.create_on_provider()
return vm
def test_vm_genealogy(
setup_provider, vm_name, provider_crud, provisioning, soft_assert, provider_mgmt, request):
"""Tests vm geneaology
Metadata:
test_flag: geneaology, provision
"""
original_template = provisioning["template"]
original_vm = Vm(vm_name, provider_crud, template_name=original_template)
original_vm.create_on_provider()
request.addfinalizer(
lambda: provider_mgmt.delete_vm(original_vm.name)
if provider_mgmt.does_vm_exist(original_vm.name) else None)
provider_mgmt.wait_vm_steady(original_vm.name)
first_template = original_vm.publish_to_template("{}x".format(vm_name))
soft_assert(isinstance(first_template, Template), "first_template is not a template!")
request.addfinalizer(
lambda: provider_mgmt.delete_vm(first_template.name)
if first_template.name in provider_mgmt.list_template() else None)
second_vm = Vm(
"{}x".format(first_template.name), provider_crud, template_name=first_template.name)
second_vm.create_on_provider()
request.addfinalizer(
lambda: provider_mgmt.delete_vm(second_vm.name)
if provider_mgmt.does_vm_exist(second_vm.name) else None)
soft_assert(isinstance(second_vm, Vm), "second_vm is a template!")
second_vm_ancestors = second_vm.genealogy.ancestors
# IT SEEMS IT "BREAKS" THE CHAIN WHEN THE VM IS CLONED TO A TEMPLATE
# soft_assert(original_vm.name in second_vm_ancestors, "{} is not in {}'s ancestors".format(
# original_vm.name, second_vm.name))
soft_assert(first_template.name in second_vm_ancestors, "{} is not in {}'s ancestors".format(
first_template.name, second_vm.name))
def test_vm(request, provider_init, provider_crud, provider_mgmt, provider_data, vm_name):
"""Fixture to provision appliance to the provider being tested if necessary"""
vm = Vm(vm_name, provider_crud, 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 testing_vm(request, vm_name, provider_init, provider_crud, provider_mgmt, provisioning):
vm_obj = Vm(vm_name, provider_crud, 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 vm(request, vm_template_name, vm_name, provider):
logger.info("Starting vm fixture")
vm = Vm(vm_name, provider, template_name=vm_template_name)
if not provider.mgmt.does_vm_exist(vm_name):
vm.create_on_provider(allow_skip="default")
request.addfinalizer(vm.delete_from_provider)
return vm
def test_vm(setup_provider_modscope, provider, vm_name):
"""Fixture to provision appliance to the provider being tested if necessary"""
vm = Vm(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_vm(request, provider_crud, provider_mgmt, vm_name):
'''Fixture to provision appliance to the provider being tested if necessary'''
vm = Vm(vm_name, provider_crud)
request.addfinalizer(vm.delete_from_provider)
if not provider_mgmt.does_vm_exist(vm_name):
vm.create_on_provider()
return vm
def vm(request, vm_template_name, vm_name, provider_crud, provider_mgmt):
logger.info("Starting vm fixture")
vm = Vm(vm_name, provider_crud, template_name=vm_template_name)
if not provider_mgmt.does_vm_exist(vm_name):
vm.create_on_provider(allow_skip="default")
request.addfinalizer(vm.delete_from_provider)
return vm
def testing_vm(request, vm_name, setup_provider, provider, provisioning):
vm_obj = Vm(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_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(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 test_vm(request, provider_crud, provider_mgmt, vm_name, provider_init):
"""Fixture to provision appliance to the provider being tested if necessary"""
pytest.sel.force_navigate('infrastructure_providers')
vm = Vm(vm_name, provider_crud)
request.addfinalizer(vm.delete_from_provider)
if not provider_mgmt.does_vm_exist(vm_name):
vm.create_on_provider()
return vm
def testing_vm(request, vm_name, provider_init, provider_crud, provider_mgmt, provisioning):
vm_obj = Vm(vm_name, provider_crud, provisioning["template"])
def _finalize():
vm_obj.delete_from_provider()
if vm_obj.does_vm_exist_in_cfme():
vm_obj.remove_from_cfme()
request.addfinalizer(_finalize)
vm_obj.create_on_provider()
provider_crud.refresh_provider_relationships()
wait_for(vm_obj.does_vm_exist_in_cfme, num_sec=450, delay=10)
return vm_obj
def test_vm(request, provider, vm_name):
"""Fixture to provision appliance to the provider being tested if necessary"""
vm = Vm(vm_name, provider)
request.addfinalizer(vm.delete_from_provider)
if not provider.mgmt.does_vm_exist(vm_name):
logger.info("deploying {} on provider {}".format(vm_name, provider.key))
vm.create_on_provider(allow_skip="default")
else:
logger.info("recycling deployed vm {} on provider {}".format(vm_name, provider.key))
vm.provider_crud.refresh_provider_relationships()
vm.wait_to_appear()
return vm
def testing_vm(request, provisioning, provider):
setup_provider(provider.key)
vm = Vm(name="test_ae_hd_{}".format(fauxfactory.gen_alphanumeric()),
provider_crud=provider,
template_name=provisioning["template"])
def _finalize():
vm.delete_from_provider()
if vm.does_vm_exist_in_cfme():
vm.remove_from_cfme()
request.addfinalizer(_finalize)
vm.create_on_provider(find_in_cfme=True, allow_skip="default")
return vm
def testing_vm(request, provisioning, provider_crud, provider_key):
setup_provider(provider_key)
vm = Vm(
name="test_ae_hd_{}".format(fauxfactory.gen_alphanumeric()),
provider_crud=provider_crud,
template_name=provisioning["template"]
)
def _finalize():
vm.delete_from_provider()
if vm.does_vm_exist_in_cfme():
vm.remove_from_cfme()
request.addfinalizer(_finalize)
vm.create_on_provider(find_in_cfme=True, allow_skip="default")
return vm
def testing_vm(request, provisioning, provider_crud, provider_key):
setup_provider(provider_key)
vm = Vm(
name="test_ae_hd_{}".format(generate_random_string()),
provider_crud=provider_crud,
template_name=provisioning["template"]
)
def _finalize():
vm.delete_from_provider()
if vm.does_vm_exist_in_cfme():
vm.remove_from_cfme()
request.addfinalizer(_finalize)
vm.create_on_provider()
return vm
def provision_vm(request, provider_crud, provider_mgmt):
"""Function to provision appliance to the provider being tested"""
vm_name = "test_rest_db_" + fauxfactory.gen_alphanumeric()
vm = Vm(vm_name, provider_crud)
request.addfinalizer(vm.delete_from_provider)
if not provider_mgmt.does_vm_exist(vm_name):
logger.info("deploying {} on provider {}".format(vm_name, provider_crud.key))
vm.create_on_provider(allow_skip="default")
else:
logger.info("recycling deployed vm {} on provider {}".format(vm_name, provider_crud.key))
vm.provider_crud.refresh_provider_relationships()
vm.wait_to_appear()
return vm
def provision_vm(request, provider_crud, provider_mgmt):
"""Function to provision appliance to the provider being tested"""
vm_name = "test_rest_db_" + fauxfactory.gen_alphanumeric()
vm = Vm(vm_name, provider_crud)
request.addfinalizer(vm.delete_from_provider)
if not provider_mgmt.does_vm_exist(vm_name):
logger.info("deploying {} on provider {}".format(
vm_name, provider_crud.key))
vm.create_on_provider(allow_skip="default")
else:
logger.info("recycling deployed vm {} on provider {}".format(
vm_name, provider_crud.key))
vm.provider_crud.refresh_provider_relationships()
vm.wait_to_appear()
return vm
def test_vm(request, provider_crud, provider_mgmt, vm_name):
"""Fixture to provision appliance to the provider being tested if necessary"""
vm = Vm(vm_name, provider_crud)
logger.info("provider_key: {}".format(provider_crud.key))
def _cleanup():
vm.delete_from_provider()
if_scvmm_refresh_provider(provider_crud)
request.addfinalizer(_cleanup)
if not provider_mgmt.does_vm_exist(vm_name):
logger.info("deploying {} on provider {}".format(vm_name, provider_crud.key))
vm.create_on_provider()
else:
logger.info("recycling deployed vm {} on provider {}".format(vm_name, provider_crud.key))
vm.provider_crud.refresh_provider_relationships()
vm.wait_to_appear()
return vm
def vmware_vm(request, vmware_provider):
vm = Vm("test_control_{}".format(fauxfactory.gen_alpha().lower()), vmware_provider)
vm.create_on_provider(find_in_cfme=True)
request.addfinalizer(vm.delete_from_provider)
return vm
def vmware_vm(request, vmware_provider):
vm = Vm("test_control_{}".format(fauxfactory.gen_alpha().lower()),
vmware_provider)
vm.create_on_provider(find_in_cfme=True)
request.addfinalizer(vm.delete_from_provider)
return vm
