def test_providers_summary(soft_assert, setup_a_provider): """Checks some informations about the provider. Does not check memory/frequency as there is presence of units and rounding.""" path = ["Configuration Management", "Providers", "Providers Summary"] report = CannedSavedReport.new(path) for provider in report.data.rows: if any(ptype in provider["MS Type"] for ptype in {"ec2", "openstack"}): # Skip cloud continue provider_fake_obj = Provider(name=provider["Name"]) sel.force_navigate("infrastructure_provider", context={"provider": provider_fake_obj}) hostname = version.pick({ version.LOWEST: ("Hostname", "Hostname"), "5.5": ("Host Name", "Hostname")}) soft_assert( provider_props(hostname[0]) == provider[hostname[1]], "Hostname does not match at {}".format(provider["Name"])) if version.current_version() < "5.4": # In 5.4, hostname and IP address are shared under Hostname (above) soft_assert( provider_props("IP Address") == provider["IP Address"], "IP Address does not match at {}".format(provider["Name"])) soft_assert( provider_props("Aggregate Host CPU Cores") == provider["Total Number of Logical CPUs"], "Logical CPU count does not match at {}".format(provider["Name"])) soft_assert( provider_props("Aggregate Host CPUs") == provider["Total Number of Physical CPUs"], "Physical CPU count does not match at {}".format(provider["Name"]))
def create(self): domain = "ManageIQ (Locked)" sel.force_navigate('catalog_item_new', context={'provider_type': self.item_type}) sel.wait_for_element(basic_info_form.name_text) fill(basic_info_form, {'name_text': self.name, 'description_text': self.description, 'display_checkbox': self.display_in, 'select_catalog': self.catalog, 'select_dialog': self.dialog}) if self.item_type != "Orchestration": sel.click(basic_info_form.field_entry_point) dynamic_tree.click_path("Datastore", domain, "Service", "Provisioning", "StateMachines", "ServiceProvision_Template", "default") sel.click(basic_info_form.apply_btn) tabstrip.select_tab("Request Info") # Address BZ1321631 tabstrip.select_tab("Environment") tabstrip.select_tab("Catalog") template = template_select_form.template_table.find_row_by_cells({ 'Name': self.catalog_name, 'Provider': self.provider }) sel.click(template) web_ui.fill(request_form, { 'instance_name': self.vm_name, 'instance_type': self.instance_type, 'guest_keypair': self.guest_keypair, 'availability_zone': self.availability_zone, 'cloud_tenant': self.cloud_tenant, 'cloud_network': self.cloud_network, 'security_groups': self.security_groups[0], # not supporting multiselect now, # just take first value }) sel.click(template_select_form.add_button) flash.assert_success_message('Service Catalog Item "{}" was added'.format(self.name))
def test_grid_defaultview(request, setup_a_provider, key): name = re.split(r"\/", key) default_view = get_default_view(name[0]) set_grid_view(name[0]) sel.force_navigate(name[1]) assert tb.is_active('Grid View'), "Grid Default view setting failed" reset_default_view(name[0], default_view)
def discover(rhevm=False, vmware=False, scvmm=False, cancel=False, start_ip=None, end_ip=None): """ Discover infrastructure providers. Note: only starts discovery, doesn't wait for it to finish. Args: rhvem: Whether to scan for RHEVM providers vmware: Whether to scan for VMware providers scvmm: Whether to scan for SCVMM providers cancel: Whether to cancel out of the discover UI. """ sel.force_navigate('infrastructure_provider_discover') form_data = {} if rhevm: form_data.update({'rhevm_chk': True}) if vmware: form_data.update({'vmware_chk': True}) if scvmm: form_data.update({'scvmm_chk': True}) if start_ip: for idx, octet in enumerate(start_ip.split('.')): key = 'from_%i' % idx form_data.update({key: octet}) if end_ip: end_octet = end_ip.split('.')[-1] form_data.update({'to_3': end_octet}) fill(discover_form, form_data, action=form_buttons.cancel if cancel else discover_form.start_button, action_always=True)
def create(self): sel.force_navigate('catalog_item_new', context={'provider_type': self.item_type}) sel.wait_for_element(basic_info_form.name_text) fill(basic_info_form, {'name_text': self.name, 'description_text': self.description, 'display_checkbox': self.display_in, 'select_catalog': self.catalog, 'select_dialog': self.dialog, 'select_orch_template': self.orch_template, 'select_provider': self.provider_type}) if current_version() >= "5.4": sel.click(basic_info_form.field_entry_point) dynamic_tree.click_path("Datastore", self.domain, "Service", "Provisioning", "StateMachines", "ServiceProvision_Template", "default") sel.click(basic_info_form.apply_btn) if(self.catalog_name is not None): tabstrip.select_tab("Request Info") template = template_select_form.template_table.find_row_by_cells({ 'Name': self.catalog_name, 'Provider': self.provider }) sel.click(template) request_form.fill(self.provisioning_data) sel.click(template_select_form.add_button)
def discover(rhevm=False, vmware=False, cancel=False, start_ip=None, end_ip=None): """ Discover infrastructure providers. Note: only starts discovery, doesn't wait for it to finish. Args: rhvem: Whether to scan for RHEVM providers vmware: Whether to scan for VMware providers cancel: Whether to cancel out of the discover UI. """ sel.force_navigate('infrastructure_provider_discover') if cancel: # normalize so that the form filler only clicks either start or cancel cancel = True else: cancel = None form_data = {'start_button': not cancel, 'cancel_button': cancel} if rhevm: form_data.update({'rhevm_chk': True}) if vmware: form_data.update({'vmware_chk': True}) if start_ip: for idx, octet in enumerate(start_ip.split('.')): key = 'from_%i' % idx form_data.update({key: octet}) if end_ip: end_octet = end_ip.split('.')[-1] form_data.update({'to_3': end_octet}) fill(discover_form, form_data)
def queue_canned_report(*path): """Queue report from selection of pre-prepared reports. Args: *path: Path in tree after All Reports Returns: Value of Run At in the table so the run can be then checked. """ sel.force_navigate("report_canned_info", context={"path": path}) toolbar.select("Queue") flash.assert_no_errors() tabstrip.select_tab("Saved Reports") def _get_state(): try: first_row = list(records_table.rows())[0] except IndexError: return False return sel.text(first_row.status).strip().lower() == "finished" wait_for( _get_state, delay=1, message="wait for report generation finished", fail_func=reload_view ) return sel.text(list(records_table.rows())[0].run_at).encode("utf-8")
def validate(self): """ Validates that the detail page matches the Providers information. This method logs into the provider using the mgmt_system interface and collects a set of statistics to be matched against the UI. The details page is then refreshed continuously until the matching of all items is complete. A error will be raised if the match is not complete within a certain defined time period. """ if not self._on_detail_page(): sel.force_navigate('infrastructure_provider', context={'provider': self}) stats_to_match = ['num_template', 'num_vm', 'num_datastore', 'num_host', 'num_cluster'] client = self.get_mgmt_system() # Bail out here if the stats match. if self._do_stats_match(client, stats_to_match): client.disconnect() return refresh_timer = RefreshTimer() # Otherwise refresh relationships and hand off to wait_for tb.select("Configuration", "Refresh Relationships and Power States", invokes_alert=True) sel.handle_alert() ec, tc = wait_for(self._do_stats_match, [client, stats_to_match, refresh_timer], message="do_stats_match", fail_func=sel.refresh, num_sec=1000, delay=10) client.disconnect()
def exists(self): sel.force_navigate('infrastructure_providers') for page in paginator.pages(): if sel.is_displayed(Quadicon(self.name, 'infra_prov')): return True else: return False
def edit_schema(self, add_fields=None, remove_fields=None): sel.force_navigate("automate_explorer_schema_edit", context={'tree_item': self}) for remove_field in remove_fields or []: f = remove_field.get_form() fill(f, {}, action=f.remove_entry_button, action_always=True) for add_field in add_fields or []: sel.click(self.schema_edit_page.add_field_btn) f = add_field.get_form(blank=True) fill(f, {'name_text': add_field.name, 'type_select': add_field.type_, 'data_type_select': add_field.data_type, 'default_value_text': add_field.default_value, 'description_text': add_field.description, 'sub_cb': add_field.sub, 'collect_text': add_field.collect, 'message_text': add_field.message, 'on_entry_text': add_field.on_entry, 'on_exit_text': add_field.on_exit, 'max_retries_text': add_field.max_retries, 'max_time_text': add_field.max_time}, action=f.add_entry_button) sel.click(form_buttons.save) flash.assert_success_message('Schema for Automate Class "{}" was saved'.format(self.name))
def create(self): sel.force_navigate('catalog_item_new', context={'provider_type': self.item_type}) sel.wait_for_element(basic_info_form.name_text) fill(basic_info_form, {'name_text': self.name, 'description_text': self.description, 'display_checkbox': self.display_in, 'select_catalog': self.catalog, 'select_dialog': self.dialog}) tabstrip.select_tab("Request Info") template = template_select_form.template_table.find_row_by_cells({ 'Name': self.catalog_name, 'Provider': self.provider }) sel.click(template) web_ui.fill(request_form, { 'instance_name': self.vm_name, 'instance_type': self.instance_type, 'guest_keypair': self.guest_keypair, 'availability_zone': self.availability_zone, 'cloud_tenant': self.cloud_tenant, 'cloud_network': self.cloud_network, 'security_groups': self.security_groups[0], # not supporting multiselect now, # just take first value }) sel.click(template_select_form.add_button) flash.assert_success_message('Service Catalog Item "%s" was added' % self.name)
def test_appliance_replicate_database_disconnection_with_backlog(request, provider): """Tests a database disconnection with backlog Metadata: test_flag: replication """ appl1, appl2 = get_replication_appliances() def finalize(): appl1.destroy() appl2.destroy() request.addfinalizer(finalize) appl1.ipapp.browser_steal = True with appl1.ipapp: configure_db_replication(appl2.address) # Replication is up and running, now stop the DB on the replication parent provider.create() stop_db_process(appl2.address) sleep(60) start_db_process(appl2.address) sel.force_navigate("cfg_diagnostics_region_replication") wait_for(lambda: conf.get_replication_status(navigate=False), fail_condition=False, num_sec=360, delay=10, fail_func=sel.refresh, message="get_replication_status") assert conf.get_replication_status() wait_for_a_provider() appl2.ipapp.browser_steal = True with appl2.ipapp: wait_for_a_provider() assert provider.exists
def exists(self): try: sel.force_navigate('automate_explorer_tree_path', context={'tree_item': self}) except exceptions.CandidateNotFound: return False else: return True
def update(self, updates): sel.force_navigate('catalog_item_edit', context={'catalog': self.catalog, 'catalog_item': self}) fill(basic_info_form, {'name_text': updates.get('name', None), 'description_text': updates.get('description', None)}, action=basic_info_form.edit_button) flash.assert_success_message('Service Catalog Item "%s" was saved' % self.name)
def test_appliance_replicate_sync_role_change_with_backlog(request, provider): """Tests that a role change is replicated with backlog Metadata: test_flag: replication """ appl1, appl2 = get_replication_appliances() def finalize(): appl1.destroy() appl2.destroy() request.addfinalizer(finalize) appl1.ipapp.browser_steal = True with appl1.ipapp: configure_db_replication(appl2.address) # Replication is up and running, now disable DB sync role provider.create() conf.set_server_roles(database_synchronization=False) sel.force_navigate("cfg_diagnostics_region_replication") wait_for(lambda: conf.get_replication_status(navigate=False), fail_condition=True, num_sec=360, delay=10, fail_func=sel.refresh, message="get_replication_status") conf.set_server_roles(database_synchronization=True) sel.force_navigate("cfg_diagnostics_region_replication") wait_for(lambda: conf.get_replication_status(navigate=False), fail_condition=False, num_sec=360, delay=10, fail_func=sel.refresh, message="get_replication_status") assert conf.get_replication_status() wait_for_a_provider() appl2.ipapp.browser_steal = True with appl2.ipapp: wait_for_a_provider() assert provider.exists
def test_servicevmsandinstances_defaultfilters(setup_first_provider): filters = [['Services', 'Workloads', 'VMs & Instances', 'Platform / Openstack']] df = st.DefaultFilter(name='Platform / Openstack') df.update({'filters': [(k, True) for k in filters]}) sel.force_navigate( 'service_vms_instances_filter_folder', context={'folder_name': 'Global Filters'}) assert sel.is_displayed_text(df.name), "Default Filter settings Failed!"
def test_list_defaultview(request, setup_a_provider, key): name = re.split(r"\/", key) default_view = get_default_view(name[0]) set_list_view(name[0]) sel.force_navigate(name[1]) assert tb.is_vms_list_view(), "List Default view setting failed" reset_default_view(name[0], default_view)
def manage_folder(group, folder=None): """Context manager to use when modifying the folder contents. Args: group: User group. folder: Which folder to manage. If None, top-level will be managed. Returns: Context-managed :py:class:`cfme.intelligence.reports.ui_elements.FolderManager` inst. """ sel.force_navigate("report_menus_group", context={"group": group}) if folder is None: reports_tree.click_path("Top Level") else: reports_tree.click_path("Top Level", folder) try: yield manager except FolderManager._BailOut: logger.info("Discarding editation modifications on {}".format(str(repr(manager)))) manager.discard() except: # In case of any exception, nothing will be saved manager.discard() raise # And reraise the exception else: # If no exception happens, save! manager.commit() form_buttons.save()
def test_servicetemplateandimages_defaultfilters(setup_first_provider): filters = [['Services', 'Workloads', 'Templates & Images', 'Platform / Microsoft']] df = st.DefaultFilter(name='Platform / Microsoft') df.update({'filters': [(k, True) for k in filters]}) sel.force_navigate( 'service_templates_images_filter_folder', context={'folder_name': 'Global Filters'}) assert sel.is_displayed_text(df.name), "Default Filter settings Failed!"
def validate(self, db=True): """ Validates that the detail page matches the Providers information. This method logs into the provider using the mgmt_system interface and collects a set of statistics to be matched against the UI. The details page is then refreshed continuously until the matching of all items is complete. A error will be raised if the match is not complete within a certain defined time period. """ client = self.get_mgmt_system() # If we're not using db, make sure we are on the provider detail page if not db: sel.force_navigate('clouds_provider', context={'provider': self}) # Initial bullet check if self._do_stats_match(client, self.STATS_TO_MATCH, db=db): client.disconnect() return else: # Set off a Refresh Relationships sel.force_navigate('clouds_provider', context={'provider': self}) tb.select("Configuration", "Refresh Relationships and Power States", invokes_alert=True) sel.handle_alert() refresh_timer = RefreshTimer(time_for_refresh=300) wait_for(self._do_stats_match, [client, self.STATS_TO_MATCH, refresh_timer], {'db': db}, message="do_stats_match_db", num_sec=1000, delay=60) client.disconnect()
def get_unassigned_policy_profiles(self): """ Return a set of Policy Profiles which are available but not assigned. Returns: :py:class:`set` of :py:class:`str` of Policy Profile names """ sel.force_navigate('clouds_provider_policy_assignment', context={'provider': self}) return self._unassigned_policy_profiles
def edit_tags(self, tag, value): sel.force_navigate('service_edit_tags', context={'service_name': self.service_name}) fill(edit_tags_form, {'select_tag': tag, 'select_value': value}, action=form_buttons.save) flash.assert_success_message('Tag edits were successfully saved')
def get_all_vms(do_not_navigate=False): """Returns list of all vms""" if not do_not_navigate: sel.force_navigate('infra_vms') vms = set([]) # This is really stupid, but I cannot come up with better getting of the attributes :( if not paginator.page_controls_exist(): for title in sel.elements(QUADICON_TITLE_LOCATOR): title_value = sel.get_attribute(title, "title") if not title_value: title_value = sel.get_attribute(title, "data-original-title") vms.add(title_value) return vms paginator.results_per_page(1000) for page in paginator.pages(): try: for page in paginator.pages(): for title in sel.elements(QUADICON_TITLE_LOCATOR): title_value = sel.get_attribute(title, "title") if not title_value: title_value = sel.get_attribute(title, "data-original-title") vms.add(title_value) except sel.NoSuchElementException: pass return vms
def discover(credential, cancel=False, d_type="Amazon"): """ Discover cloud providers. Note: only starts discovery, doesn't wait for it to finish. Args: credential (cfme.Credential): Amazon discovery credentials. cancel (boolean): Whether to cancel out of the discover UI. """ sel.force_navigate("clouds_provider_discover") form_data = {"discover_select": d_type} if credential: form_data.update( { "username": credential.principal, "password": credential.secret, "password_verify": credential.verify_secret, } ) fill( discover_form, form_data, action=form_buttons.cancel if cancel else discover_form.start_button, action_always=True, )
def set_grid_view(name): bg = ButtonGroup(name) sel.force_navigate("my_settings_default_views") default_view = bg.active if(default_view != 'Grid View'): bg.choose('Grid View') sel.click(form_buttons.save)
def get_unassigned_policy_profiles(self): """ Return a set of Policy Profiles which are available but not assigned. Returns: :py:class:`set` of :py:class:`str` of Policy Profile names """ sel.force_navigate("infrastructure_provider_policy_assignment", context={"provider": self}) return self._unassigned_policy_profiles
def test_data_integrity_for_topology(test_data): """ This test verifies that every status box value under Containers Overview is identical to the number present on its page. Steps: * Go to Containers / Overview * All cells should contain the correct relevant information # of nodes # of providers # ... """ section_values = {} sel.force_navigate('container_dashboard') # We should wait ~2 seconds for the StatusBox population # (until we find a better solution) time.sleep(2) status_box = StatusBox(test_data[2]) section_values[test_data[0]] = int(status_box.value()) sel.force_navigate(test_data[1]) if section_values[test_data[0]] > 0: if test_data[0] is Provider: assert len(map(lambda i: i, Quadicon.all())) == section_values[test_data[0]] else: assert len(map(lambda r: r, test_data[3].rows()) ) == section_values[test_data[0]] else: assert sel.is_displayed_text('No Records Found.')
def set_ownership(self, owner, group): sel.force_navigate('service_set_ownership', context={'service_name': self.service_name}) fill(set_ownership_form, {'select_owner': owner, 'select_group': group}, action=form_buttons.save) flash.assert_success_message('Ownership saved for selected Service')
def test_provision_from_template(request, setup_provider, provider_crud, provisioning, vm_name): """ Tests instance provision from template Metadata: test_flag: provision """ image = provisioning['image']['name'] note = ('Testing provisioning from image %s to vm %s on provider %s' % (image, vm_name, provider_crud.key)) instance = instance_factory(vm_name, provider_crud, image) request.addfinalizer(instance.delete_from_provider) inst_args = { 'email': '*****@*****.**', 'first_name': 'Image', 'last_name': 'Provisioner', 'notes': note, 'instance_type': provisioning['instance_type'], 'availability_zone': provisioning['availability_zone'], 'security_groups': [provisioning['security_group']], 'guest_keypair': provisioning['guest_keypair'] } if isinstance(provider_crud, OpenStackProvider): inst_args['cloud_network'] = provisioning['cloud_network'] sel.force_navigate("clouds_instances_by_provider") instance.create(**inst_args)
def check_vm_add(self, add_vm_name): sel.force_navigate('service', context={'service_name': self.service_name}) quadicon = Quadicon(add_vm_name, "vm") sel.click(quadicon) flash.assert_no_errors()
def infra_provider_quad(self): sel.force_navigate("my_settings_visual") return self.infra_provider_quad
def cloud_provider_quad(self): sel.force_navigate("my_settings_visual") return self.cloud_provider_quad
def template_quad(self, value): sel.force_navigate("my_settings_visual") fill(self.quadicons_form.template_quad, str(value)) sel.click(form_buttons.save)
def template_quad(self): sel.force_navigate("my_settings_visual") return self.template_quad
def vm_quad(self): sel.force_navigate("my_settings_visual") return self.vm_quad
def datastore_quad(self): sel.force_navigate("my_settings_visual") return self.datastore_quad
def infra_provider_quad(self, value): sel.force_navigate("my_settings_visual") fill(self.quadicons_form.infra_provider_quad, str(value)) sel.click(form_buttons.save)
def login_page(self): sel.force_navigate("my_settings_visual") return int(self.startpage_form.login_page.first_selected_option_text)
def report_view_limit(self): sel.force_navigate("my_settings_visual") return int(self.item_form.reports.first_selected_option_text)
def login_page(self, value): sel.force_navigate("my_settings_visual") fill(self.startpage_form.login_page, str(value)) sel.click(form_buttons.save)
def reset_default_view(name, default_view): bg = ButtonGroup(name) sel.force_navigate("my_settings_default_views") if bg.active != default_view: bg.choose(default_view) sel.click(form_buttons.save)
def report_view_limit(self, value): sel.force_navigate("my_settings_visual") fill(self.item_form.reports, str(value)) sel.click(form_buttons.save)
def create(self, cancel=False): sel.force_navigate("reports_widgets_rss_feed_add") fill(self.form, self.__dict__, action=form_buttons.cancel if cancel else form_buttons.add) flash.assert_no_errors()
def update(self, updates): sel.force_navigate("reports_dashboard_edit", context={"dashboard": self}) fill(self.form, updates, action=form_buttons.save) flash.assert_no_errors()
def test_can_open_advanced_search(): sel.force_navigate("infra_vms") search.ensure_advanced_search_open()
def update(self, updates): sel.force_navigate("reports_widgets_rss_feed_edit", context={"widget": self}) fill(self.form, updates, action=form_buttons.save) flash.assert_no_errors()
def cleanup(): sel.force_navigate("infra_vms") search.load_filter(filter_name) search.delete_filter()
def go_to_detail(self): if self.on_widget_page: toolbar.select("Reload current display") else: sel.force_navigate(type(self).DETAIL_PAGE, context={"widget": self})
def reset(): sel.force_navigate("clouds_images") toolbar.select('List View')
def test_can_do_advanced_search(): sel.force_navigate("infra_vms") assert search.is_advanced_search_possible( ), "Cannot do advanced search here!"
def set_grid(): sel.force_navigate("clouds_images") toolbar.select('Grid View')
def reset_grid_stack(): sel.force_navigate("clouds_stacks") toolbar.select('List View')
def tag(self, tag, **kwargs): """Tags the system by given tag""" sel.force_navigate('infrastructure_host', context={'host': self}) mixins.add_tag(tag, **kwargs)
def set_grid_stack(): sel.force_navigate("clouds_stacks") toolbar.select('Grid View')
def navigate(self): return sel.force_navigate("saved_report_canned", context={ "path": self.path, "datetime": self.datetime })
def untag(self, tag): """Removes the selected tag off the system""" sel.force_navigate('infrastructure_host', context={'host': self}) mixins.remove_tag(tag)
def test_provision_with_additional_volume(request, setup_provider, provisioning, provider, vm_name, soft_assert, copy_domains, domain): """ Tests provisioning with setting specific image from AE and then also making it create and attach an additional 3G volume. Metadata: test_flag: provision, volumes """ image = provisioning['image']['name'] note = ('Testing provisioning from image %s to vm %s on provider %s' % (image, vm_name, provider.key)) # Set up automate cls = automate.Class(name="Methods", namespace=automate.Namespace.make_path( "Cloud", "VM", "Provisioning", "StateMachines", parent=domain)) method = automate.Method(name="openstack_CustomizeRequest", cls=cls) try: image_id = provider.mgmt.get_template_id( provider.data["small_template"]) except KeyError: pytest.skip("No small_template in provider adta!") with update(method): method.data = dedent('''\ $evm.root["miq_provision"].set_option( :clone_options, { :image_ref => nil, :block_device_mapping_v2 => [{ :boot_index => 0, :uuid => "%s", :device_name => "vda", :source_type => "image", :destination_type => "volume", :volume_size => 3, :delete_on_termination => false }] } ) ''' % (image_id, )) def _finish_method(): with update(method): method.data = """prov = $evm.root["miq_provision"]""" request.addfinalizer(_finish_method) instance = Instance.factory(vm_name, provider, image) request.addfinalizer(instance.delete_from_provider) inst_args = { 'email': '*****@*****.**', 'first_name': 'Image', 'last_name': 'Provisioner', 'notes': note, 'instance_type': provisioning['instance_type'], 'availability_zone': provisioning['availability_zone'], 'security_groups': [provisioning['security_group']], 'guest_keypair': provisioning['guest_keypair'] } if isinstance(provider, OpenStackProvider): inst_args['cloud_network'] = provisioning['cloud_network'] sel.force_navigate("clouds_instances_by_provider") instance.create(**inst_args) prov_instance = provider.mgmt._find_instance_by_name(vm_name) try: assert hasattr(prov_instance, 'os-extended-volumes:volumes_attached') volumes_attached = getattr(prov_instance, 'os-extended-volumes:volumes_attached') assert len(volumes_attached) == 1 volume_id = volumes_attached[0]["id"] assert provider.mgmt.volume_exists(volume_id) volume = provider.mgmt.get_volume(volume_id) assert volume.size == 3 finally: instance.delete_from_provider() wait_for(lambda: not instance.does_vm_exist_on_provider(), num_sec=180, delay=5) if "volume_id" in locals(): # To handle the case of 1st or 2nd assert if provider.mgmt.volume_exists(volume_id): provider.mgmt.delete_volume(volume_id)
def power_off(self): sel.force_navigate('infrastructure_host', context={'host': self}) pow_btn('Power Off') sel.handle_alert()
def test_provision_with_boot_volume(request, setup_provider, provider, provisioning, vm_name, soft_assert, domain, copy_domains): """ Tests provisioning from a template and attaching one booting volume. Metadata: test_flag: provision, volumes """ image = provisioning['image']['name'] note = ('Testing provisioning from image %s to vm %s on provider %s' % (image, vm_name, provider.key)) with provider.mgmt.with_volume( 1, imageRef=provider.mgmt.get_template_id(image)) as volume: # Set up automate cls = automate.Class(name="Methods", namespace=automate.Namespace.make_path( "Cloud", "VM", "Provisioning", "StateMachines", parent=domain)) method = automate.Method(name="openstack_CustomizeRequest", cls=cls) with update(method): method.data = dedent('''\ $evm.root["miq_provision"].set_option( :clone_options, { :image_ref => nil, :block_device_mapping_v2 => [{ :boot_index => 0, :uuid => "%s", :device_name => "vda", :source_type => "volume", :destination_type => "volume", :delete_on_termination => false }] } ) ''' % (volume, )) def _finish_method(): with update(method): method.data = """prov = $evm.root["miq_provision"]""" request.addfinalizer(_finish_method) instance = Instance.factory(vm_name, provider, image) request.addfinalizer(instance.delete_from_provider) inst_args = { 'email': '*****@*****.**', 'first_name': 'Image', 'last_name': 'Provisioner', 'notes': note, 'instance_type': provisioning['instance_type'], 'availability_zone': provisioning['availability_zone'], 'security_groups': [provisioning['security_group']], 'guest_keypair': provisioning['guest_keypair'] } if isinstance(provider, OpenStackProvider): inst_args['cloud_network'] = provisioning['cloud_network'] sel.force_navigate("clouds_instances_by_provider") instance.create(**inst_args) soft_assert(vm_name in provider.mgmt.volume_attachments(volume)) soft_assert(provider.mgmt.volume_attachments(volume)[vm_name] == "vda") instance.delete_from_provider( ) # To make it possible to delete the volume wait_for(lambda: not instance.does_vm_exist_on_provider(), num_sec=180, delay=5)
def update(self, updates): sel.force_navigate("report_custom_edit", context={"report": self}) fill(report_form, updates, action=form_buttons.save) flash.assert_no_errors()