def assert_key_from_product(self, name, prd_element, repo=None):
"""Assert the key association after deletion from product tab."""
self.click(prd_element)
if repo is not None:
self.click(tab_locators['prd.tab_repos'])
strategy, value = locators['repo.select']
self.click((strategy, value % repo))
self.click(locators['repo.gpg_key_edit'])
element = Select(
self.find_element(locators['repo.gpg_key_update'])
).first_selected_option.text
if element != '':
raise UIError(
'GPGKey "{0}" is still assoc with selected repo'
.format(name)
)
else:
self.click(tab_locators['prd.tab_details'])
self.click(locators['prd.gpg_key_edit'])
element = Select(
self.find_element(locators['prd.gpg_key_update'])
).first_selected_option.text
if element != '':
raise UIError(
'GPG key "{0}" is still assoc with product'
.format(name)
)
return None
def validate_task_navigation(self,
task_state,
task_result,
task_name=None):
"""Find specific task by state and result on Task Status widget and
then click on it. After application navigate on Tasks page, check
whether proper search string is inherited into search box and that
search is actually executed afterwards. Then check whether expected
task is found and present in the list
"""
expected_search_value = 'state={}&result={}'.format(
task_state, task_result)
self.navigate_to_entity()
self.click(locators['dashboard.task.search_criteria'] %
(task_state, task_result))
if self.wait_until_element(locators['task.page_title']) is None:
raise UIError('Redirection to Tasks page does not work properly')
if expected_search_value:
actual_value = self.wait_until_element(
common_locators['search']).get_attribute('value')
if actual_value != expected_search_value:
raise UIError('Search box contains invalid data')
if task_name:
found_task_name = self.wait_until_element(
locators['task.select_name'] % task_name).text
if found_task_name is None:
raise UIError('Expected task was not found in the list')
return True
def add_filter(self,
cv_name,
filter_name,
content_type,
filter_type,
description=None):
"""Creates content-view filter of given 'type'(include/exclude) and
'content-type'(package/package-group/errata)
"""
self.search_and_click(cv_name)
self.click(tab_locators['contentviews.tab_yum_content'])
self.click(locators['contentviews.content_filters'])
self.click(locators['contentviews.new_filter'])
self.assign_value(common_locators['name'], filter_name)
if content_type:
self.select(locators['contentviews.content_type'], content_type)
else:
raise UIError('Could not create filter without content type')
if filter_type:
self.select(locators['contentviews.type'], filter_type)
else:
raise UIError('Could not create filter without specifying filter '
'type')
if description:
self.assign_value(common_locators['description'], description)
self.click(common_locators['create'])
def set_power_status(self, resource_name, vm_name, power_on=None):
"""Perform power on or power off for VM's
:param bool power_on: True - for On, False - for Off
"""
status = None
locator_status = locators['resource.power_status']
element = self.search_vm(resource_name, vm_name)
if element is None:
raise UIError(
'Could not find Virtual machine "{0}"'.format(vm_name))
button = self.find_element(
locators['resource.vm_power_button']
)
if power_on is True:
if 'On' not in button.text:
raise UIError(
'Could not start VM {0}. VM is running'.format(vm_name)
)
self.click(button)
self.search_vm(resource_name, vm_name)
status = self.wait_until_element(locator_status).text
elif power_on is False:
if 'Off' not in button.text:
raise UIError(
'Could not stop VM {0}. VM is not running'.format(vm_name)
)
self.click(button, wait_for_ajax=False)
self.handle_alert(True)
self.search_vm(resource_name, vm_name)
status = self.wait_until_element(locator_status).text
return status
def validate_error_navigation(self,
task_name,
expected_result=None,
summary_message=None):
"""Find specific task on Latest Warning/Error Tasks widget and then
click on it. After application navigate on expected task details page,
check whether correct result information and error message is displayed
in summary section
"""
self.navigate_to_entity()
self.click(locators['dashboard.lwe_task.name'] % task_name)
task_tab_element = self.wait_until_element(
tab_locators['task.tab_task'])
if task_tab_element is None:
raise UIError(
'Redirection to task details page does not work properly')
self.click(task_tab_element)
if expected_result:
actual_result = self.wait_until_element(
locators['task.selected.result']).text.strip()
if actual_result != expected_result:
raise UIError('Task finished with unexpected result')
if summary_message:
actual_value = self.wait_until_element(
locators['task.selected.summary']).text
if actual_value != summary_message:
raise UIError('Task summary message has wrong value')
return True
def validate_hcs_navigation(self,
criteria_name,
expected_search_value=None,
host_name=None):
"""Find specific criteria on Host Configuration Status widget and then
click on it. After application navigate on Hosts page, check whether
proper search string is inherited into search box and that search is
actually executed afterwards. Then check whether expected host is found
and present in the list
"""
self.navigate_to_entity()
self.click(locators['dashboard.hcs.search_criteria'] % criteria_name)
if self.wait_until_element(locators['host.page_title']) is None:
raise UIError('Redirection to Hosts page does not work properly')
if expected_search_value:
actual_value = self.wait_until_element(
common_locators['search']).get_attribute('value')
if actual_value != expected_search_value:
raise UIError('Search box contains invalid data')
if host_name:
found_host_name = self.wait_until_element(
locators['host.select_name'] % host_name).text
if found_host_name is None:
raise UIError('Expected host was not found in the list')
return True
def create(self,
name,
env,
limit=None,
description=None,
content_view=None):
"""Creates new activation key from UI."""
self.click(locators['ak.new'])
if self.wait_until_element(common_locators['name']):
self.text_field_update(common_locators['name'], name)
if limit:
self.set_limit(limit)
if description:
self.text_field_update(common_locators['description'],
description)
if env:
strategy, value = locators['ak.env']
self.click((strategy, value % env))
else:
raise UIError(
'Could not create new activation key "{0}", without env'.
format(name))
if content_view:
self.select(locators['ak.content_view'], content_view)
else:
self.select(locators['ak.content_view'], DEFAULT_CV)
self.click(common_locators['create'])
else:
raise UIError(
'Could not create new activation key "{0}"'.format(name))
def create(self, name, upload_key=False, key_path=None, key_content=None):
"""Creates a gpg key from UI."""
self.click(locators['gpgkey.new'])
if self.wait_until_element(common_locators['name']):
self.find_element(
common_locators['name']).send_keys(name)
if upload_key:
self.click(locators['gpgkey.upload'])
self.find_element(
locators['gpgkey.file_path']).send_keys(key_path)
elif key_content:
self.click(locators['gpgkey.content'])
self.find_element(
locators['gpgkey.content']).send_keys(key_content)
else:
raise UIError(
u'Could not create new gpgkey "{0}" without contents'
.format(name)
)
self.click(common_locators['create'])
self.wait_until_element_is_not_visible(locators['gpgkey.new_form'])
else:
raise UIError(
'Could not create new gpg key "{0}"'.format(name)
)
def edit_erratum_id_filter(self,
cv_name,
filter_name,
errata_types=None,
open_filter=True):
"""Edit Erratum by ID Filter"""
allowed_errata_types = FILTER_ERRATA_TYPE.values()
if open_filter:
self.go_to_filter_page(cv_name, filter_name)
self.click(tab_locators.contentviews.tab_add)
if errata_types is not None:
if not errata_types:
raise UIError(
'errata types is empty, minimum required: one errata type')
if not set(errata_types).issubset(allowed_errata_types):
raise UIError('some types in errata_types are not allowed')
# because of the behaviour of the UI to disable the last checked
# element.
# will check all selected errata types first, after then uncheck
# the not selected ones.
# 1 - check first the types that are in the errata_types
for errata_type in errata_types:
self.assign_value(
locators.contentviews.erratum_type_checkbox % errata_type,
True)
# we are sure now that any check box not in the errata_types
# is enabled and clickable
# 2 - uncheck the types that are not in the selection
for errata_type in set(allowed_errata_types).difference(
errata_types):
self.assign_value(
locators.contentviews.erratum_type_checkbox % errata_type,
False)
def add_remove_repos(self,
cv_name,
repo_names,
add_repo=True,
repo_type='yum'):
"""Add or Remove repository to/from selected content-view.
When 'add_repo' Flag is set then add_repository will be performed,
otherwise remove_repository
"""
element = self.search(cv_name)
if not element:
raise UIError(
'Could not find the selected CV "{0}"'.format(cv_name))
element.click()
self.wait_for_ajax()
if repo_type == 'yum':
self.click(tab_locators['contentviews.tab_content'])
self.click(locators['contentviews.content_repo'])
elif repo_type == 'docker':
self.click(tab_locators['contentviews.tab_docker_content'])
elif repo_type == 'ostree':
self.click(tab_locators['contentviews.tab_ostree_content'])
strategy, value = locators['contentviews.select_repo']
for repo_name in repo_names:
if add_repo:
self.click(tab_locators['contentviews.tab_repo_add'])
else:
self.click(tab_locators['contentviews.tab_repo_remove'])
self.text_field_update(locators['contentviews.repo_search'],
repo_name)
element = self.wait_until_element((strategy, value % repo_name))
if not element:
raise UIError(
'Could not find repo "{0}" to add into CV'.format(
repo_name))
element.click()
self.wait_for_ajax()
if add_repo:
self.click(locators['contentviews.add_repo'])
self.click(tab_locators['contentviews.tab_repo_remove'])
element = self.wait_until_element(
(strategy, value % repo_name))
if element is None:
raise UINoSuchElementError(
"Adding repo {0} failed".format(repo_name))
else:
self.click(locators['contentviews.remove_repo'])
self.click(tab_locators['contentviews.tab_repo_add'])
element = self.wait_until_element(
(strategy, value % repo_name))
if element is None:
raise UINoSuchElementError(
"Removing repo {0} fails".format(repo_name))
def add_remove_repos(
self, cv_name, repo_names, add_repo=True, repo_type='yum'):
"""Add or Remove repository to/from selected content-view.
When 'add_repo' Flag is set then add_repository will be performed,
otherwise remove_repository
"""
self.search_and_click(cv_name)
if repo_type == 'yum':
self.click(tab_locators['contentviews.tab_yum_content'])
self.click(locators['contentviews.content_repo'])
elif repo_type == 'docker':
self.click(tab_locators['contentviews.tab_docker_content'])
self.click(locators['contentviews.docker_repo'])
elif repo_type == 'ostree':
self.click(tab_locators['contentviews.tab_ostree_content'])
locator = locators['contentviews.select_repo']
for repo_name in repo_names:
if add_repo:
self.click(tab_locators['contentviews.tab_repo_add'])
else:
self.click(tab_locators['contentviews.tab_repo_remove'])
self.assign_value(
locators['contentviews.repo_search'], repo_name)
self.click(common_locators['kt_search_button'])
if not self.wait_until_element(locator % repo_name):
raise UIError(
'Could not find repo "{0}" to add into CV'
.format(repo_name)
)
self.click(locator % repo_name)
if add_repo:
self.click(locators['contentviews.add_repo'])
if not self.wait_until_element(
common_locators['alert.success_sub_form']):
raise UIError(
'Failed to add repo "{0}" to CV'.format(repo_name)
)
self.click(tab_locators['contentviews.tab_repo_remove'])
element = self.wait_until_element(locator % repo_name)
if element is None:
raise UINoSuchElementError(
"Adding repo {0} failed".format(repo_name))
else:
self.click(locators['contentviews.remove_repo'])
if not self.wait_until_element(
common_locators['alert.success_sub_form']):
raise UIError(
'Failed to remove repo "{0}" from CV'.format(repo_name)
)
self.click(tab_locators['contentviews.tab_repo_add'])
element = self.wait_until_element(locator % repo_name)
if element is None:
raise UINoSuchElementError(
"Removing repo {0} fails".format(repo_name))
def fetch_fact_value(self, hostname, element):
"""Fetch the value of selected fact from discovered hosts page"""
host = self.search(hostname)
if not host:
raise UIError(
'Could not find the selected discovered host "{0}"'.format(
hostname))
if not self.find_element(element):
raise UIError('Could not find element from discovered host page')
web_element = self.find_element(element)
element_value = web_element.text
return element_value
def add_permission(self, role_name, resource_type=None,
permission_list=None, override=None,
override_check=None, unlimited=None,
organization=None, location=None):
"""Add new permission to Role Filter"""
self.search(role_name)
self.click(locators['roles.dropdown'] % role_name)
self.click(locators['roles.add_permission'])
if resource_type:
self.assign_value(
locators['roles.select_resource_type'], resource_type)
if permission_list:
self.configure_entity(
permission_list, FILTER['filter_permission'])
# Verify whether 'Override' checkbox is present on the page or not.
# Putting it here as we can do it only during create procedure, not
# after
if override_check is True:
if self.wait_until_element(
locators['roles.override']).is_selected():
raise UIError('Override checkbox has unexpected state')
# For non-overridable filters, checkbox should be absent at all
elif override_check is False:
self.wait_until_element_is_not_visible(locators['roles.override'])
if override:
self.assign_value(locators['roles.override'], override)
if unlimited:
self.assign_value(locators['roles.unlimited'], unlimited)
if organization:
self.click(tab_locators['roles.tab_org'])
self.configure_entity(organization, FILTER['filter_org'])
if location:
self.click(tab_locators['roles.tab_location'])
self.configure_entity(location, FILTER['filter_loc'])
self.click(common_locators['submit'])
def set_power_status(self, resource_name, cont_name, power_on):
"""Perform power on or power off for container
:param bool power_on: True - for On, False - for Off
"""
status = None
locator_on = (locators['container.power_on'][0],
locators['container.power_on'][1] % cont_name)
locator_off = (locators['container.power_off'][0],
locators['container.power_off'][1] % cont_name)
locator_status = (locators['container.power_status'][0],
locators['container.power_status'][1] % cont_name)
element = self.search(resource_name, cont_name)
if element is None:
raise UIError('Could not find container "{0}"'.format(cont_name))
self.wait_for_ajax()
if power_on is True:
self.click(locator_on)
self.search(resource_name, cont_name)
if self.wait_until_element(locator_off):
status = self.wait_until_element(locator_status).text
elif power_on is False:
self.click(locator_off, wait_for_ajax=False)
self.handle_alert(True)
self.search(resource_name, cont_name)
if self.wait_until_element(locator_on):
status = self.wait_until_element(locator_status).text
return status
def add_filter(self, filter_type, filter_value, auto_complete=None):
"""Add necessary amount of filters ('autocomplete' fields)
At that moment we support next filters:
'Content Views'
'Products'
'Repositories' (second radiobutton)
Specify exact string that you want to be chosen from suggestions box in
auto_complete parameter. For example, you input 'MyRepo' into field and
see 'MyRepo01' and 'MyRepo02' in suggestion box, so it is necessary to
pass corresponding value into mentioned parameter (like auto_complete=
'MyRepo01')
"""
self.select_filter_type(filter_type)
if filter_type == 'Repositories':
self.click(locators['contentsearch.repositories_auto_radio'])
self.field_update('contentsearch.{0}'.format(self.ft_locator),
filter_value)
strategy, value = locators['contentsearch.autocomplete_field']
self.wait_until_element((strategy, value % filter_value))
if auto_complete is not None:
self.click((strategy, value % auto_complete))
self.wait_for_ajax()
add_button = self.wait_until_element_is_clickable(
locators['contentsearch.add_{0}_filter'.format(self.ft_locator)])
if add_button is None:
raise UIError(
'There is no "{0}" entity in the system'.format(filter_value))
add_button.click()
def filters_get_permissions(self, role_name, resource_types):
"""Fetch permissions for provided resource types from role filters.
:param role_name: String with role name.
:param resource_types: List with resource types names.
:return: Dict with resource name as a key and list of strings with
permissions names as a values.
"""
self.search(role_name)
self.click(locators['roles.filters_button'] % role_name)
# make sure The role filter page is loaded
self.wait_until_element(locators['role_filters.title'])
permissions = {}
# create a copy of unique resources types
resource_types = list(set(resource_types))
self._get_page_resources_permissions(resource_types, permissions)
next_ = self.find_element(locators['role_filters.pagination_next'])
while resource_types and next_:
self.click(next_)
self._get_page_resources_permissions(resource_types, permissions)
next_ = self.find_element(locators['role_filters.pagination_next'])
missing_resource_types = set(resource_types).difference(
set(permissions.keys()))
if missing_resource_types:
raise UIError(
'Not all resource types where found: {0} are missing'
.format(', '.join(missing_resource_types))
)
return permissions
def update(self,
name,
custom_really=None,
new_name=None,
template_path=None,
template_type=None,
os_list=None,
new_os_list=None,
clone=False):
"""Updates a given template."""
element = self.search(name)
if element is None:
raise UIError(u'Could not update the template "{0}"'.format(name))
self.click(element)
if new_name:
self.field_update('provision.template_name', new_name)
if template_path:
self.find_element(
locators['provision.template_template']).send_keys(
template_path)
self.handle_alert(custom_really)
if template_type:
self.click(tab_locators['provision.tab_type'])
self.select(locators['provision.template_type'], template_type)
if clone:
self.click(locators['provision.template_clone'])
self.field_update('provision.template_name', new_name)
self.configure_entity(
os_list,
FILTER['template_os'],
tab_locator=tab_locators['provision.tab_association'],
new_entity_list=new_os_list)
self.click(common_locators['submit'])
def get_os_entities(self, os_name, entity_name=None):
"""Assert OS name, minor, major_version, os_family, template, media,
and partition table to validate results.
"""
name_loc = locators['operatingsys.name']
major_ver_loc = locators['operatingsys.major_version']
minor_ver_loc = locators['operatingsys.minor_version']
os_family_loc = locators['operatingsys.fetch_family']
self.search_and_click(os_name)
if self.wait_until_element(locators['operatingsys.name']):
result = dict([('name', None), ('major', None), ('minor', None),
('os_family', None), ('ptable', None),
('template', None), ('medium', None)])
result['name'] = self.find_element(name_loc).get_attribute('value')
result['major'] = self.find_element(major_ver_loc).get_attribute(
'value')
result['minor'] = self.find_element(minor_ver_loc).get_attribute(
'value')
result['os_family'] = self.find_element(os_family_loc).text
if entity_name == 'ptable':
self.click(tab_locators['operatingsys.tab_ptable'])
result['ptable'] = self.get_selected_entities()
elif entity_name == 'medium':
self.click(tab_locators['operatingsys.tab_medium'])
result['medium'] = self.get_selected_entities()
elif entity_name == 'template':
self.click(tab_locators['operatingsys.tab_templates'])
result['template'] = self.find_element(
locators['operatingsys.fetch_template']).text
return result
else:
raise UIError(u'Could not find the OS name "{0}"'.format(os_name))
def test_positive_delete_multiple(self):
"""Delete multiple discovered hosts from 'Select Action'
drop down
@id: 556fb306-512f-46a4-8a0f-af8013161efe
@Setup: Host should already be discovered
@Assert: Selected host should be removed successfully
@CaseLevel: System
"""
with Session(self.browser) as session:
session.nav.go_to_select_org(self.org_name)
with LibvirtGuest() as pxe_1_host:
host_1_name = pxe_1_host.guest_name
self._assertdiscoveredhost(host_1_name)
with LibvirtGuest() as pxe_2_host:
host_2_name = pxe_2_host.guest_name
self._assertdiscoveredhost(host_2_name)
for hostname in [host_1_name, host_2_name]:
host = self.discoveredhosts.search(hostname)
if not host:
raise UIError(
'Could not find the selected discovered host '
'"{0}"'.format(hostname)
)
self.discoveredhosts.navigate_to_entity()
# To delete multiple discovered hosts
self.discoveredhosts.multi_delete()
for hostname in [host_1_name, host_2_name]:
self.assertIsNone(
self.discoveredhosts.search(hostname))
def test_positive_add_domain(self):
"""Create new subnet and associate domain with it
:id: adbc7189-b451-49df-aa10-2ae732832dfe
:expectedresults: Subnet is created with domain associated
:CaseLevel: Integration
"""
name = gen_string('alpha')
domain = entities.Domain(
organization=[self.organization]
).create()
with Session(self.browser) as session:
make_subnet(
session,
org=self.organization.name,
subnet_name=name,
subnet_network=gen_ipaddr(ip3=True),
subnet_mask=gen_netmask(),
domains=[domain.name],
)
self.subnet.search_and_click(name)
self.subnet.click(tab_locators['subnet.tab_domain'])
element = self.subnet.wait_until_element(
common_locators['entity_deselect'] % domain.name)
checkbox_element = self.subnet.wait_until_element(
common_locators['entity_checkbox'] % domain.name)
# Depending upon the number of domains either, checkbox or
# selection list appears.
if element is None and checkbox_element is None:
raise UIError('Neither checkbox or select list is present')
if checkbox_element:
self.assertTrue(checkbox_element.is_selected())
def delete(self, name, really=True):
"""Unregisters and completely deletes content host. Custom helper is
needed as deletion works through unregistering menu, by selecting
appropriate radio button."""
self.logger.debug(u'Deleting entity %s', name)
self.search_and_click(name)
self.click(locators['contenthost.unregister'])
self.click(locators['contenthost.confirm_deletion'])
if really:
self.click(common_locators['confirm_remove'])
else:
self.click(common_locators['cancel'])
# Make sure that element is really removed from UI
self.button_timeout = 3
self.result_timeout = 1
try:
for _ in range(3):
searched = self.search(name)
if bool(searched) != really:
break
self.browser.refresh()
if bool(searched) == really:
raise UIError(
u'Delete functionality works improperly for "{0}" entity'
.format(name))
finally:
self.button_timeout = 15
self.result_timeout = 15
def execute_package_action(self, name, action_name, action_value,
timeout=120):
"""Execute remote package action on a content host
:param name: content host name to remotely execute package action on
:param action_name: remote action to execute. Can be one of 5: 'Package
Install', 'Package Update', 'Package Remove', 'Group Install' or
'Group Remove'
:param action_value: Package or package group group name to remotely
install/upgrade/remove (depending on `action_name`)
:param timeout: Timeout in seconds for remote action task to finish
:raise: UIError if remote task finished by timeout
:return: Returns a string containing task status
"""
self.click(self.search(name))
self.click(tab_locators['contenthost.tab_packages'])
self.click(tab_locators['contenthost.tab_packages.actions'])
self.assign_value(
locators['contenthost.remote_actions'], action_name)
self.assign_value(
locators['contenthost.package_name_input'], action_value)
self.click(locators['contenthost.perform_remote_action'])
result = self.wait_until_element(
locators['contenthost.remote_action_finished'],
timeout=timeout,
)
if result is None:
raise UIError('Timeout waiting for package action to finish')
return result.get_attribute('type')
def select_package_version_value(self,
version_type,
value1=None,
value2=None):
"""Select package version and set values: versions are: 'All' 'Equal
To' 'Greater Than' 'Less Than' 'Range'.
'value1' should contain version value for types: 'Equal To' 'Greater
Than' 'Less Than'.
'value2' should only be used with type 'Range' to define range of
versions.
"""
if version_type == 'Equal To':
self.assign_value(locators['contentviews.equal_value'], value1)
elif version_type == 'Greater Than':
self.assign_value(locators['contentviews.greater_min_value'],
value1)
elif version_type == 'Less Than':
self.assign_value(locators['contentviews.less_max_value'], value1)
elif version_type == 'Range':
self.assign_value(locators['contentviews.greater_min_value'],
value1)
self.assign_value(locators['contentviews.less_max_value'], value2)
else:
raise UIError('Could not find valid version type')
def create(self, name, path, os_family=None):
"""Creates new Installation media."""
self.click(locators['medium.new'])
if self.wait_until_element(locators['medium.name']):
self.find_element(locators['medium.name']).send_keys(name)
if self.wait_until_element(locators['medium.path']):
self.find_element(locators['medium.path']).send_keys(path)
self._configure_medium(os_family)
self.click(common_locators['submit'])
else:
raise UIError(
'Could not create new installation media without path')
else:
raise UIError(
'Could not create new installation media "{0}"'.format(name))
def check_package_details(self, name, parameter_list=None):
"""Check whether package detail section contains expected values or
raise exception otherwise.
All values should be passed in absolute correspondence to UI. For
example, we have 'Description' or 'Checksum Type' fields, so next
parameter list should be passed::
[
['Description', 'Expected description'],
['Checksum Type', 'sha256'],
]
"""
self.click(self.search(name))
for parameter_name, parameter_value in parameter_list:
param_locator = '.'.join((
'package',
(parameter_name.lower()).replace(' ', '_')
))
actual_text = self.wait_until_element(locators[param_locator]).text
if actual_text != parameter_value:
raise UIError(
'Actual text for "{0}" parameter is "{1}", but it is'
' expected to have "{2}"'.format(
parameter_name, actual_text, parameter_value)
)
def set_value(self, name, value):
"""Set the value of the corresponding field in UI"""
locator_attr = '{0}_locator'.format(name)
locator = getattr(self, locator_attr, None)
if locator is None and name not in self.group_fields_locators:
raise UIError('Field name: {0} not supported'.format(name))
value = self._clean_value(name, value)
if name in self.selector_fields:
self.page.configure_entity(value, locator)
elif name in self.group_fields_locators:
field_index = 0
group_fields_locators = self.group_fields_locators[name]
add_node_locator = group_fields_locators['_add_node']
for group_field in value:
if group_field is not None:
for field_key, field_value in group_field.items():
field_locator = group_fields_locators.get(field_key)
available_fields = self.page.find_elements(
field_locator)
if len(available_fields) - 1 < field_index:
self.page.click(add_node_locator)
available_fields = self.page.find_elements(
field_locator)
self._assign_locator_value(
available_fields[field_index], field_value)
field_index += 1
else:
self._assign_locator_value(locator, value)
def update(self, name, new_name=None, description=None, limit=None):
"""Updates an existing Host Collection."""
element = self.search(name)
if element is None:
raise UIError(
u'Could not find host collection "{0}" to update'.format(name))
element.click()
self.wait_for_ajax()
if new_name:
self.edit_entity(
locators['hostcollection.edit_name'],
locators['hostcollection.edit_name_text'],
new_name,
locators['hostcollection.save_name'],
)
if description:
self.edit_entity(locators['hostcollection.edit_description'],
locators['hostcollection.edit_description_text'],
description,
locators['hostcollection.save_description'])
if limit:
self.click(locators['hostcollection.edit_limit'])
self.set_limit(limit)
if self.wait_until_element(
locators['hostcollection.save_limit']).is_enabled():
self.click(locators['hostcollection.save_limit'])
else:
raise ValueError(
'Please update content host limit with valid integer '
'value')
def update(self, name, new_name=None, new_url=None, new_repo_checksum=None,
new_gpg_key=None, http=False, new_upstream_name=None):
"""Updates repositories from UI."""
repo_element = self.search(name)
if repo_element is None:
raise UIError(
u'Unable to find the repository "{0}" for update.'.format(name)
)
repo_element.click()
self.wait_for_ajax()
if new_name:
self.click(locators['repo.name_edit'])
self.text_field_update(locators['repo.name_update'], new_name)
self.click(common_locators['save'])
if new_url:
self.click(locators['repo.url_edit'])
self.text_field_update(locators['repo.url_update'], new_url)
self.click(common_locators['save'])
if new_repo_checksum:
self.click(locators['repo.checksum_edit'])
self.select(locators['repo.checksum_update'], new_repo_checksum)
self.click(common_locators['save'])
if new_gpg_key:
self.click(locators['repo.gpg_key_edit'])
self.select(locators['repo.gpg_key_update'], new_gpg_key)
self.click(common_locators['save'])
if http:
self.click(locators['repo.via_http_edit'])
self.click(locators['repo.via_http_update'])
self.click(common_locators['save'])
if new_upstream_name:
self.click(locators['repo.upstream_edit'])
self.text_field_update(
locators['repo.upstream_update'], new_upstream_name)
self.click(common_locators['save'])
def go_to_select_loc(self, loc):
"""Selects the specified location.
:param str loc: The location to select.
:return: Returns the location.
:rtype: str
"""
self.logger.debug(u'Selecting Location: %s', loc)
strategy, value = menu_locators['loc.select_loc']
self.menu_click(
menu_locators['menu.any_context'],
menu_locators['loc.nav_current_loc'],
(strategy, value % (loc, loc)),
)
self.perform_action_chain_move(menu_locators['menu.current_text'])
loc_dropdown = loc
if len(loc) > 30:
loc_dropdown = loc[:27] + '...'
if self.wait_until_element(
menu_locators['menu.fetch_loc']).text != loc_dropdown:
raise UIError(u'Error Selecting Location: %s' % loc)
# close dropdown
self.click(menu_locators['menu.current_text'])
# get to left corner of the browser instance to not have impact on
# further actions
self.perform_action_chain_move_by_offset(-150, -150)
return loc
def delete(self, name=DEFAULT_SUBSCRIPTION_NAME, really=True):
"""Deletes Manifest/subscriptions via UI."""
self.navigate_to_entity()
if not self.wait_until_element(locators.subs.upload, timeout=1):
self.click(locators.subs.manage_manifest)
self.click(locators['subs.delete_manifest'])
if really:
self.click(common_locators['confirm_remove'])
timeout = 300
if bz_bug_is_open(1339696):
timeout = 900
self.wait_until_element(common_locators['alert.success'], timeout)
else:
self.click(common_locators['cancel'])
# if no subscriptions are present, user is automatically redirected to
# manifest upload page, meaning search will fail with
# UINoSuchElementError as searchbox can't be found there
searched = None
try:
searched = self.search(name)
except UINoSuchElementError:
pass
if bool(searched) == really:
raise UIError(
'An error occurred while attempting to delete {}'.format(name))
