def _custom_click_handler(self, wait_ajax):
"""Handler called from pytest_selenium"""
if self.is_dimmed and not self._force:
logger.info("Not clicking {} because it is dimmed".format(repr(self)))
return
sel.wait_for_element(self, timeout=5)
return sel.click(self, no_custom_handler=True, wait_ajax=wait_ajax)
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 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 update(self, updates, cancel=False, validate_credentials=False):
"""Updates the manager through UI
args:
updates (dict): Data to change.
cancel (bool): Whether to cancel out of the update. The cancel is done
after all the new information has been filled in the UI.
validate_credentials (bool): Whether to validate credentials - if True and the
credentials are invalid, an error will be raised.
Note:
utils.update use is recommended over use of this method.
"""
navigate_to(self, 'Edit')
# Workaround - without this, update was failing on downstream appliance
sel.wait_for_ajax()
sel.wait_for_element(properties_form.name_text)
fill(properties_form, self._form_mapping(**updates))
fill(credential_form, updates.get('credentials', None), validate=validate_credentials)
self._submit(cancel, edit_manager_btn)
name = updates['name'] or self.name
if not cancel:
flash.assert_message_match('{} Provider "{}" was updated'.format(self.type, name))
self.__dict__.update(**updates)
def create(self):
sel.force_navigate('catalog_item_new',
context={'provider_type': self.item_type})
sel.wait_for_element(basic_info_form.name_text)
catalog = fakeobject_or_object(self.catalog, "name", "<Unassigned>")
dialog = fakeobject_or_object(self.dialog, "name", "<No Dialog>")
fill(basic_info_form, {'name_text': self.name,
'description_text': self.description,
'display_checkbox': self.display_in,
'select_catalog': catalog.name,
'select_dialog': dialog.name,
'select_orch_template': self.orch_template,
'select_provider': self.provider_type,
'select_config_template': self.config_template})
if self.item_type != "Orchestration" and self.item_type != "AnsibleTower":
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 and self.provisioning_data is not None:
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)
request_form.fill(self.provisioning_data)
sel.click(template_select_form.add_button)
def _custom_click_handler(self, wait_ajax):
"""Handler called from pytest_selenium"""
if self.is_dimmed and not self._force:
logger.error("Could not click %s because it was dimmed", repr(self))
return
sel.wait_for_element(self, timeout=5)
return sel.click(self, no_custom_handler=True, wait_ajax=wait_ajax)
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 set_retirement_date(self, when, warn=None):
"""Sets the retirement date for this Vm object.
It incorporates some magic to make it work reliably since the retirement form is not very
pretty and it can't be just "done".
Args:
when: When to retire. :py:class:`str` in format mm/dd/yy of
:py:class:`datetime.datetime` or :py:class:`utils.timeutil.parsetime`.
warn: When to warn, fills the select in the form in case the ``when`` is specified.
"""
self.load_details()
lcl_btn("Set Retirement Date")
if callable(self.retire_form.date_retire):
# It is the old functiton
sel.wait_for_element("#miq_date_1")
else:
sel.wait_for_element(self.retire_form.date_retire)
if when is None:
try:
wait_for(lambda: sel.is_displayed(retire_remove_button), num_sec=5, delay=0.2)
sel.click(retire_remove_button)
wait_for(lambda: not sel.is_displayed(retire_remove_button), num_sec=10, delay=0.2)
sel.click(form_buttons.save)
except TimedOutError:
pass
else:
if sel.is_displayed(retire_remove_button):
sel.click(retire_remove_button)
wait_for(lambda: not sel.is_displayed(retire_remove_button), num_sec=15, delay=0.2)
fill(self.retire_form.date_retire, when)
wait_for(lambda: sel.is_displayed(retire_remove_button), num_sec=15, delay=0.2)
if warn is not None:
fill(self.retire_form.warn, warn)
sel.click(form_buttons.save)
def update(self, updates):
navigate_to(self, 'Edit')
# Workaround - form is appearing after short delay
sel.wait_for_element(self.tenant_form.description)
fill(self.tenant_form, updates, action=self.save_changes)
flash.assert_success_message(
'Project "{}" was saved'.format(updates.get('name', self.name)))
def _retrieve_ext_auth_user_groups(self):
navigate_to(self, 'Add')
fill(self.group_form, {'lookup_ldap_groups_chk': True,
'user_to_look_up': self.user_to_lookup,
},)
sel.wait_for_element(form_buttons.retrieve)
sel.click(form_buttons.retrieve)
def _repo_nav_fn(context):
repo = context['repository']
if current_version() >= '5.4':
quadicon = Quadicon(repo.name, "repository")
sel.click(quadicon.locate())
else:
sel.click(_repo_row(repo.name)[1])
sel.wait_for_element(repo._detail_page_identifying_loc)
def _retrieve_ldap_user_groups(self):
navigate_to(self, 'Add')
fill(self.group_form, {'lookup_ldap_groups_chk': True,
'user_to_look_up': self.user_to_lookup,
'username': self.ldap_credentials.principal,
'password': self.ldap_credentials.secret,
},)
sel.wait_for_element(form_buttons.retrieve)
sel.click(form_buttons.retrieve)
def create(self):
sel.force_navigate('catalog_new')
sel.wait_for_element(form.name_text)
web_ui.fill(form, {'name_text': self.name,
'description_text': self.description,
'button_multiselect': self.items},
action=form.add_button)
flash_str = 'Catalog "{}" was saved'
flash.assert_success_message(flash_str.format(self.name))
def create(self):
# Create has sequential forms, the first is only the provider type
navigate_to(self, 'Add')
# For element not found exception (To be removed)
sel.sleep(5)
sel.select("//select[@id='st_prov_type']",
self.provider_type or self.item_type or 'Generic')
sel.wait_for_element(basic_info_form.name_text)
catalog = fakeobject_or_object(self.catalog, "name", "Unassigned")
dialog = fakeobject_or_object(self.dialog, "name", "No Dialog")
# Need to provide the (optional) provider name to the form, not the object
provider_name = None
provider_required_types = ['AnsibleTower', 'Orchestration']
if self.item_type in provider_required_types \
or self.provider_type in provider_required_types:
provider_name = self.provider.name
# For tests where orchestration template is None
orch_template = None
if self.orch_template:
orch_template = self.orch_template.template_name
fill(basic_info_form, {'name_text': self.name,
'description_text': self.description,
'display_checkbox': self.display_in,
'select_catalog': catalog.name,
'select_dialog': dialog.name,
'select_orch_template': orch_template,
'select_provider': provider_name,
'select_config_template': self.config_template})
if not (self.item_type in provider_required_types):
sel.click(basic_info_form.field_entry_point)
if version.current_version() < "5.7":
dynamic_tree.click_path("Datastore", self.domain, "Service", "Provisioning",
"StateMachines", "ServiceProvision_Template", "default")
else:
entry_tree.click_path("Datastore", self.domain, "Service", "Provisioning",
"StateMachines", "ServiceProvision_Template", "default")
sel.click(basic_info_form.apply_btn)
if version.current_version() >= "5.7" and self.item_type == "AnsibleTower":
sel.click(basic_info_form.retirement_entry_point)
entry_tree.click_path("Datastore", self.domain, "Service", "Retirement",
"StateMachines", "ServiceRetirement", "Generic")
sel.click(basic_info_form.apply_btn)
if self.catalog_name is not None \
and self.provisioning_data is not None \
and not isinstance(self.provider, NoneType):
tabstrip.select_tab("Request Info")
tabstrip.select_tab("Catalog")
template = template_select_form.template_table.find_row_by_cells({
'Name': self.catalog_name,
'Provider': self.provider.name
})
sel.click(template)
request_form.fill(self.provisioning_data)
sel.click(template_select_form.add_button)
def update(self, updates):
sel.force_navigate("cfg_tenant_project_edit", context={"tenant": self})
# Workaround - without this, update was failing sometimes
sel.wait_for_ajax()
# Workaround - form is appearing after short delay
sel.wait_for_element(self.tenant_form.description)
fill(self.tenant_form, updates, action=self.save_changes)
flash.assert_success_message(
'Project "{}" was saved'.format(updates.get('name', self.name)))
def add_element(self, *element_data):
for each_element in element_data:
plus_btn("Add a new Element to this Box")
sel.wait_for_element(element_form.ele_label)
# Workaround to refresh the fields, select other values (text area box and checkbox)and
# then select "text box"
fill(element_form, {'choose_type': "Text Area Box"})
fill(element_form, {'choose_type': "Check Box"})
fill(element_form, each_element)
self.element_type(each_element)
def _find_and_click_sm(context):
"""Incorporates searching through the page listing and clicking in the table. Also ensures
waiting for the transition as there is no ajax hook."""
sm_name = _get_sm_name(context["storage_manager"])
for page in paginator.pages():
if sel.is_displayed("#no_records_div"):
break
if list_page.managers_table.click_cell("name", sm_name):
sel.wait_for_element("#textual_div") # No ajax wait there :(
return
raise StorageManagerNotFound("Storage manager with name '{}' not found!".format(sm_name))
def delete(cancel=False):
"""Delete currently opened request
Args:
cancel: Whether to cancel the deletion.
"""
sel.wait_for_element(buttons.delete)
sel.click(buttons.delete, wait_ajax=False)
sel.handle_alert(cancel)
sel.wait_for_ajax()
flash.assert_no_errors()
def add_button_group(self):
sel.force_navigate('catalog_item', context={'catalog': self.catalog,
'catalog_item': self})
cfg_btn("Add a new Button Group", invokes_alert=True)
sel.wait_for_element(button_group_form.btn_group_text)
fill(button_group_form, {'btn_group_text': "group_text",
'btn_group_hvr_text': "descr"})
select = DHTMLSelect("div#button_div")
select.select_by_value(1)
sel.click(button_group_form.add_button)
flash.assert_success_message('Buttons Group "descr" was added')
def approve(reason, cancel=False):
"""Approve currently opened request
Args:
reason: Reason for approving the request.
cancel: Whether to cancel the approval.
"""
sel.wait_for_element(buttons.approve)
sel.click(buttons.approve)
fill(fields.reason, reason)
sel.click(buttons.submit if not cancel else buttons.cancel)
flash.assert_no_errors()
def systems(self):
"""Returns 'ConfigSystem' objects that are active under this profile"""
self.navigate()
# ajax wait doesn't work here
_header_loc = "//div[contains(@class, 'dhtmlxInfoBarLabel')"\
" and contains(normalize-space(text()), 'Configured Systems')]"
sel.wait_for_element(_header_loc)
# Unassigned config profile has no tabstrip
if "unassigned" not in self.name.lower():
tabs.select_tab("Configured Systems")
if sel.is_displayed(list_table):
return [ConfigSystem(row['description'].text, self) for row in list_table.rows()]
return list()
def get_saved_reports(self):
navigate_to(self, 'Saved')
results = []
try:
for page in paginator.pages():
sel.wait_for_element(records_table)
for row in records_table.rows():
results.append(
CustomSavedReport(self, sel.text(row.run_at).encode("utf-8"), self.is_candu)
)
except sel.NoSuchElementException:
pass
return results
def get_saved_reports(self):
sel.force_navigate("report_custom_saved", context={"report": self})
results = []
try:
for page in paginator.pages():
sel.wait_for_element(records_table)
for row in records_table.rows():
results.append(
CustomSavedReport(self, sel.text(row.run_at).encode("utf-8"))
)
except sel.NoSuchElementException:
pass
return results
def add_button_group(self):
navigate_to(self, 'Details')
cfg_btn("Add a new Button Group", invokes_alert=True)
sel.wait_for_element(button_group_form.btn_group_text)
fill(button_group_form, {'btn_group_text': "group_text",
'btn_group_hvr_text': "descr"})
if current_version() > "5.5":
select = AngularSelect("button_image")
select.select_by_visible_text("Button Image 1")
else:
select = DHTMLSelect("div#button_div")
select.select_by_value(1)
sel.click(button_group_form.add_button)
flash.assert_success_message('Buttons Group "descr" was added')
def add_button(self):
sel.force_navigate('catalog_item', context={'catalog': self.catalog,
'catalog_item': self})
cfg_btn('Add a new Button', invokes_alert=True)
sel.wait_for_element(button_form.btn_text)
fill(button_form, {'btn_text': "btn_text",
'btn_hvr_text': "btn_descr"})
select = DHTMLSelect("div#button_div")
select.select_by_value(2)
fill(button_form, {'select_dialog': self.dialog,
'system_process': "Request",
'request': "InspectMe"})
sel.click(button_form.add_button)
flash.assert_success_message('Button "btn_descr" was added')
def add_button_group(self):
sel.force_navigate('catalog_item', context={'catalog': self.catalog,
'catalog_item': self})
cfg_btn("Add a new Button Group", invokes_alert=True)
sel.wait_for_element(button_group_form.btn_group_text)
fill(button_group_form, {'btn_group_text': "group_text",
'btn_group_hvr_text': "descr"})
if current_version() > "5.5":
select = AngularSelect("button_image")
select.select_by_visible_text("Button Image 1")
else:
select = DHTMLSelect("div#button_div")
select.select_by_value(1)
sel.click(button_group_form.add_button)
flash.assert_success_message('Buttons Group "descr" was added')
def force_login_user(*args, **kwargs):
"""
Force login to CFME using valid username and password; log out if already logged in.
Args:
args: A list of arguments to supply to the :py:meth:`login` method.
kwargs: A dict of keyword arguments to supply to the :py:meth:`login` method.
Warning:
Use only with valid credentials.
"""
if logged_in():
logout()
login(*args, **kwargs)
sel.wait_for_element(page.user_dropdown)
def set_quota(self, **kwargs):
navigate_to(self, 'ManageQuotas')
# Workaround - form is appearing after short delay
sel.wait_for_element(self.quota_form.cpu_txt)
fill(self.quota_form, {'cpu_cb': kwargs.get('cpu_cb'),
'cpu_txt': kwargs.get('cpu'),
'memory_cb': kwargs.get('memory_cb'),
'memory_txt': kwargs.get('memory'),
'storage_cb': kwargs.get('storage_cb'),
'storage_txt': kwargs.get('storage'),
'vm_cb': kwargs.get('vm_cb'),
'vm_txt': kwargs.get('vm'),
'template_cb': kwargs.get('template_cb'),
'template_txt': kwargs.get('template')},
action=self.save_changes)
flash.assert_success_message('Quotas for Tenant "{}" were saved'.format(self.name))
def set_quota(self, **kwargs):
navigate_to(self, 'ManageQuotas')
# Workaround - form is appearing after short delay
sel.wait_for_element(self.quota_form.cpu_txt)
fill(self.quota_form, {'cpu_cb': kwargs.get('cpu_cb'),
'cpu_txt': kwargs.get('cpu'),
'memory_cb': kwargs.get('memory_cb'),
'memory_txt': kwargs.get('memory'),
'storage_cb': kwargs.get('storage_cb'),
'storage_txt': kwargs.get('storage'),
'vm_cb': kwargs.get('vm_cb'),
'vm_txt': kwargs.get('vm'),
'template_cb': kwargs.get('template_cb'),
'template_txt': kwargs.get('template')},
action=self.save_changes)
flash.assert_success_message('Quotas for Tenant "{}" were saved'.format(self.name))
def get_detail(properties):
navigate_to(current_appliance().server, 'About')
if current_version() < '5.7':
return InfoBlock.text(*properties).encode(
"utf-8").strip()
else:
locator = '//div[@class="product-versions-pf"]//li'
sel.wait_for_element(locator)
for element in sel.elements(locator):
logger.debug('Checking for detail match for "{}" in "{}"'.format(properties,
element.text))
match = re.match("{}\s(?P<value>.*)".format(properties), element.text)
if match:
return match.group('value')
else:
raise ElementOrBlockNotFound('Could not match about detail {}'.format(properties))
def systems(self):
"""Returns 'ConfigSystem' objects that are active under this profile"""
self.navigate()
# ajax wait doesn't work here
_header_loc = "//div[contains(@class, 'dhtmlxInfoBarLabel')"\
" and contains(normalize-space(text()), 'Configured Systems')]"
sel.wait_for_element(_header_loc)
# Unassigned config profile has no tabstrip
if "unassigned" not in self.name.lower():
tabs.select_tab("Configured Systems")
if sel.is_displayed(list_table):
return [
ConfigSystem(row['description'].text, self)
for row in list_table.rows()
]
return list()
def add_button(self):
navigate_to(self, 'Details')
cfg_btn('Add a new Button', invokes_alert=True)
sel.wait_for_element(button_form.btn_text)
fill(button_form, {'btn_text': "btn_text",
'btn_hvr_text': "btn_descr"})
if current_version() > "5.5":
select = AngularSelect("button_image")
select.select_by_visible_text("Button Image 1")
else:
select = DHTMLSelect("div#button_div")
select.select_by_value(2)
fill(button_form, {'select_dialog': self.dialog,
'system_process': "Request",
'request': "InspectMe"})
sel.click(button_form.add_button)
flash.assert_success_message('Button "btn_descr" was added')
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 set_quota(self, **kwargs):
sel.force_navigate("cfg_tenant_project", context={"tenant": self})
tb.select("Configuration", "Manage Quotas")
# Workaround - form is appearing after short delay
sel.wait_for_element(self.quota_form.cpu_txt)
fill(self.quota_form, {'cpu_cb': kwargs.get('cpu_cb'),
'cpu_txt': kwargs.get('cpu'),
'memory_cb': kwargs.get('memory_cb'),
'memory_txt': kwargs.get('memory'),
'storage_cb': kwargs.get('storage_cb'),
'storage_txt': kwargs.get('storage'),
'vm_cb': kwargs.get('vm_cb'),
'vm_txt': kwargs.get('vm'),
'template_cb': kwargs.get('template_cb'),
'template_txt': kwargs.get('template')},
action=self.save_changes)
flash.assert_success_message('Quotas for Tenant "{}" were saved'.format(self.name))
def test_ssa_users(provider, instance, soft_assert):
""" Tests SSA fetches correct results for users list
Metadata:
test_flag: vm_analysis
"""
username = fauxfactory.gen_alphanumeric()
expected = None
# In windows case we can't add new users (yet)
# So we simply check that user list doesn't cause any Rails errors
if instance.system_type != WINDOWS:
# Add a new user
instance.ssh.run_command("userdel {0} || useradd {0}".format(username))
expected = instance.ssh.run_command(
"cat /etc/passwd | wc -l").output.strip('\n')
instance.smartstate_scan()
wait_for(lambda: is_vm_analysis_finished(instance.name),
delay=15,
timeout="10m",
fail_func=lambda: tb.select('Reload'))
# Check that all data has been fetched
current = instance.get_detail(properties=('Security', 'Users'))
if instance.system_type != WINDOWS:
assert current == expected
# Make sure created user is in the list
sel.click(InfoBlock("Security", "Users"))
template = '//div[@id="list_grid"]/div[@class="{}"]/table/tbody'
users = version.pick({
version.LOWEST:
SplitTable(header_data=(template.format("xhdr"), 1),
body_data=(template.format("objbox"), 0)),
"5.5":
Table('//table'),
})
for page in paginator.pages():
sel.wait_for_element(users)
if users.find_row('Name', username):
return
if instance.system_type != WINDOWS:
pytest.fail("User {0} was not found".format(username))
def get_detail(properties):
navigate_to(current_appliance().server, 'About')
if current_version() < '5.7':
properties = ['Session Information', properties]
return InfoBlock.text(*properties).encode("utf-8").strip()
else:
locator = '//div[@class="product-versions-pf"]//li'
sel.wait_for_element(locator)
for element in sel.elements(locator):
logger.debug('Checking for detail match for "{}" in "{}"'.format(
properties, element.text))
match = re.match("{}\s(?P<value>.*)".format(properties),
element.text)
if match:
return match.group('value')
else:
raise ElementOrBlockNotFound(
'Could not match about detail {}'.format(properties))
def add_button(self):
sel.force_navigate('catalog_item', context={'catalog': self.catalog,
'catalog_item': self})
cfg_btn('Add a new Button', invokes_alert=True)
sel.wait_for_element(button_form.btn_text)
fill(button_form, {'btn_text': "btn_text",
'btn_hvr_text': "btn_descr"})
if current_version() > "5.5":
select = AngularSelect("button_image")
select.select_by_visible_text("Button Image 1")
else:
select = DHTMLSelect("div#button_div")
select.select_by_value(2)
fill(button_form, {'select_dialog': self.dialog,
'system_process': "Request",
'request': "InspectMe"})
sel.click(button_form.add_button)
flash.assert_success_message('Button "btn_descr" was added')
def set_retirement_date(self, when, warn=None):
"""Sets the retirement date for this Vm object.
It incorporates some magic to make it work reliably since the retirement form is not very
pretty and it can't be just "done".
Args:
when: When to retire. :py:class:`str` in format mm/dd/yyyy of
:py:class:`datetime.datetime` or :py:class:`utils.timeutil.parsetime`.
warn: When to warn, fills the select in the form in case the ``when`` is specified.
"""
# TODO: refactor for retirement nav destinations and widget form fill when child classes
self.load_details()
lcl_btn("Set Retirement Date")
if callable(self.retire_form.date_retire):
# It is the old functiton
sel.wait_for_element("#miq_date_1")
else:
sel.wait_for_element(self.retire_form.date_retire)
if when is None:
try:
wait_for(lambda: sel.is_displayed(retire_remove_button),
num_sec=5,
delay=0.2)
sel.click(retire_remove_button)
wait_for(lambda: not sel.is_displayed(retire_remove_button),
num_sec=10,
delay=0.2)
sel.click(form_buttons.save)
except TimedOutError:
pass
else:
if sel.is_displayed(retire_remove_button):
sel.click(retire_remove_button)
wait_for(lambda: not sel.is_displayed(retire_remove_button),
num_sec=15,
delay=0.2)
fill(self.retire_form.date_retire, when)
wait_for(lambda: sel.is_displayed(retire_remove_button),
num_sec=15,
delay=0.2)
if warn is not None:
fill(self.retire_form.warn, warn)
sel.click(form_buttons.save)
def systems(self):
"""Returns 'ConfigSystem' objects that are active under this profile"""
navigate_to(self, 'Details')
# ajax wait doesn't work here
_title_loc = "//span[contains(@id, 'explorer_title_text') " \
"and contains(normalize-space(text()), 'Configured Systems')]"
sel.wait_for_element(_title_loc)
# Unassigned config profile has no tabstrip
if "unassigned" not in self.name.lower():
tabs.select_tab("Configured Systems")
if sel.is_displayed(page.list_table_config_systems):
row_key = 'hostname'
return [
ConfigSystem(row[row_key].text, self)
for row in page.list_table_config_systems.rows()
]
return list()
def test_ssa_groups(provider, instance, soft_assert):
""" Tests SSA fetches correct results for groups
Metadata:
test_flag: vm_analysis
"""
group = fauxfactory.gen_alphanumeric()
expected = None
if instance.system_type != WINDOWS:
# Add a new group
instance.ssh.run_command("groupdel {0} || groupadd {0}".format(group))
expected = instance.ssh.run_command(
"cat /etc/group | wc -l").output.strip('\n')
instance.smartstate_scan()
wait_for(lambda: is_vm_analysis_finished(instance.name),
delay=15,
timeout="10m",
fail_func=lambda: tb.select('Reload'))
# Check that all data has been fetched
current = instance.get_detail(properties=('Security', 'Groups'))
if instance.system_type != WINDOWS:
assert current == expected
# Make sure created group is in the list
sel.click(InfoBlock("Security", "Groups"))
template = '//div[@id="list_grid"]/div[@class="{}"]/table/tbody'
groups = version.pick({
version.LOWEST:
SplitTable(header_data=(template.format("xhdr"), 1),
body_data=(template.format("objbox"), 0)),
"5.5":
Table('//table'),
})
for page in paginator.pages():
sel.wait_for_element(groups)
if groups.find_row('Name', group):
return
if instance.system_type != WINDOWS:
pytest.fail("Group {0} was not found".format(group))
def edit_request(cells):
"""Context manager that opens the request for editing and saves or cancels depending on success.
Args:
cells: Search data for the requests table.
"""
if not go_to_request(cells):
raise Exception("The requst specified by {} not found!".format(str(cells)))
sel.wait_for_element(buttons.edit) # It is glitching here ...
sel.click(buttons.edit)
from cfme.provisioning import provisioning_form
try:
yield provisioning_form
except Exception as e:
logger.exception(e)
sel.click(buttons.cancel)
raise
else:
sel.click(provisioning_form.submit_copy_button)
flash.assert_no_errors()
def systems(self):
"""Returns 'ConfigSystem' objects that are active under this profile"""
self.navigate()
# ajax wait doesn't work here
_title_loc = version.pick({'5.4':
"//div[contains(@class, 'dhtmlxInfoBarLabel')"
" and contains(normalize-space(text()), 'Configured Systems')]",
'5.5': "//span[contains(@id, 'explorer_title_text')"
" and contains(normalize-space(text()), 'Configured Systems')]"})
sel.wait_for_element(_title_loc)
# Unassigned config profile has no tabstrip
if "unassigned" not in self.name.lower():
tabs.select_tab("Configured Systems")
if sel.is_displayed(page.list_table_config_systems):
row_key = version.pick({version.LOWEST: 'host name', '5.5': 'hostname'})
return [ConfigSystem(row[row_key].text, self) for row in
page.list_table_config_systems.rows()]
return list()
def create(self):
navigate_to(self, 'Add')
fill(label_form, {
'label': self.label,
'description_text': self.description,
'submit_button': self.submit,
'cancel_button': self.cancel
})
plus_btn("Add a new Tab to this Dialog")
sel.wait_for_element(tab_form.tab_label)
fill(tab_form, {'tab_label': self.tab_label,
'tab_desc': self.tab_desc})
plus_btn("Add a new Box to this Tab")
sel.wait_for_element(box_form.box_label)
fill(box_form, {'box_label': self.box_label,
'box_desc': self.box_desc})
if isinstance(self.element_data, (list, tuple)):
self.add_element(*self.element_data)
else:
self.add_element(self.element_data)
sel.click(form_buttons.add)
flash.assert_success_message('Dialog "{}" was added'.format(self.label))
def update(self, updates, cancel=False, validate_credentials=False):
"""Updates the manager through UI
args:
updates (dict): Data to change.
cancel (bool): Whether to cancel out of the update. The cancel is done
after all the new information has been filled in the UI.
validate_credentials (bool): Whether to validate credentials - if True and the
credentials are invalid, an error will be raised.
Note:
utils.update use is recommended over use of this method.
"""
sel.force_navigate('infrastructure_config_manager_edit', context={'manager': self})
# Workaround - without this, update was failing on downstream appliance
sel.wait_for_ajax()
sel.wait_for_element(properties_form.name_text)
fill(properties_form, self._form_mapping(**updates))
fill(credential_form, updates.get('credentials', None), validate=validate_credentials)
self._submit(cancel, edit_manager_btn)
name = updates['name'] or self.name
if not cancel:
flash.assert_message_match('{} Provider "{}" was updated'.format(self.type, name))
def create(self):
sel.force_navigate('service_dialog_new')
fill(
label_form, {
'label': self.label,
'description_text': self.description,
'submit_button': self.submit,
'cancel_button': self.cancel
})
if (self.tab_label is not None):
btn_marker = version.pick({
'default': "Add a New Tab to this Dialog",
'5.3': "Add a new Tab to this Dialog"
})
plus_btn(btn_marker)
sel.wait_for_element(tab_form.tab_label)
fill(tab_form, {
'tab_label': self.tab_label,
'tab_desc': self.tab_desc
})
if (self.box_label is not None):
btn_marker = version.pick({
'default': "Add a New Box to this Tab",
'5.3': "Add a new Box to this Tab"
})
plus_btn(btn_marker)
sel.wait_for_element(box_form.box_label)
fill(box_form, {
'box_label': self.box_label,
'box_desc': self.box_desc
})
if (self.ele_label is not None):
btn_marker = version.pick({
'default': "Add a New Element to this Box",
'5.3': "Add a new Element to this Box"
})
plus_btn(btn_marker)
sel.wait_for_element(element_form.ele_label)
fill(
element_form, {
'ele_label': self.ele_label,
'ele_name': self.ele_name,
'ele_desc': self.ele_desc,
'choose_type': self.choose_type,
'default_text_box': self.default_text_box
})
form_buttons.add()
flash.assert_no_errors()
def create(self, *element_data):
sel.force_navigate('service_dialog_new')
fill(
label_form, {
'label': self.label,
'description_text': self.description,
'submit_button': self.submit,
'cancel_button': self.cancel
})
plus_btn({
version.LOWEST: "Add a New Tab to this Dialog",
"5.3": "Add a new Tab to this Dialog"
})
sel.wait_for_element(tab_form.tab_label)
fill(tab_form, {
'tab_label': self.tab_label,
'tab_desc': self.tab_desc
})
plus_btn({
version.LOWEST: "Add a New Box to this Tab",
"5.3": "Add a new Box to this Tab"
})
sel.wait_for_element(box_form.box_label)
fill(box_form, {
'box_label': self.box_label,
'box_desc': self.box_desc
})
for each_element in element_data:
plus_btn({
version.LOWEST: "Add a New Element to this Box",
"5.3": "Add a new Element to this Box"
})
sel.wait_for_element(element_form.ele_label)
# Workaround to refresh the fields, select other values (text area box and checkbox)and
# then select "text box"
fill(element_form, {'choose_type': "Text Area Box"})
fill(element_form, {'choose_type': "Check Box"})
fill(element_form, each_element)
self.element_type(each_element)
sel.click(form_buttons.add)
flash.assert_no_errors()
def _all_servicedialogs_add_new(context):
service_dialog_tree.click_path('All Dialogs')
cfg_btn('Add a new Dialog')
sel.wait_for_element(label_form.label)
def _new_button(_context):
cfg_btn('Add a new Button')
sel.wait_for_element(button_form.btn_text)
def _all_servicedialogs_add_new(context):
cfg_btn('Add a new Dialog')
sel.wait_for_element(label_form.label)
def step(self):
accordion.tree("Dashboards", "All Dashboards", "All Groups",
self.obj.group)
toolbar.select("Configuration", "Add a new Dashboard")
sel.wait_for_element(Dashboard.form.name)
def step(self):
cfg_btn('Add a new Dialog')
sel.wait_for_element(label_form.label)
def _new_button_group(_context):
cfg_btn('Add a new Button Group')
sel.wait_for_element(button_group_form.btn_group_text)
