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 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()