def sync_custom_repos(self, product, repos):
"""Syncs Repositories from Custom Product.
Selects multiple custom repos to Synchronize from UI,
by first expanding the product.
:param str product: The product which repositories belongs to.
:param list repos: The list of repositories to sync.
"""
strategy, value = locators["sync.prd_expander"]
strategy1, value1 = locators["sync.repo_checkbox"]
prd_exp = self.wait_until_element((strategy, value % product))
if prd_exp:
prd_exp.click()
else:
raise UINoSuchElementError(
"Could not find the product expander: '%s'" % product)
for repo in repos:
repo_select = self.wait_until_element((strategy1, value1 % repo))
if repo_select:
repo_select.click()
else:
raise UINoSuchElementError("Could not find the repo: '%s'" %
repo)
self.wait_until_element(locators["sync.sync_now"]).click()
self.wait_for_ajax()
return self.assert_sync(repos)
def menu_click(self,
top_menu_locator,
sub_menu_locator,
tertiary_menu_locator=None,
entity=None):
menu_element = self.wait_until_element(top_menu_locator)
if menu_element is None:
raise UINoSuchElementError(
u'top_menu_locator not found: {0}'.format(top_menu_locator))
ActionChains(self.browser).move_to_element(menu_element).perform()
submenu_element = self.wait_until_element(sub_menu_locator)
if submenu_element is None:
raise UINoSuchElementError(
u'sub_menu_locator not found: {0}'.format(sub_menu_locator))
elif submenu_element and not tertiary_menu_locator:
submenu_element.click()
elif submenu_element and tertiary_menu_locator:
ActionChains(
self.browser).move_to_element(submenu_element).perform()
if entity:
strategy, value = tertiary_menu_locator
tertiary_element = self.wait_until_element(
(strategy, value % entity))
else:
tertiary_element = self.wait_until_element(
tertiary_menu_locator)
if tertiary_element is None:
raise UINoSuchElementError(
u'Tertiary_menu_locator not found: {0}'.format(
tertiary_menu_locator))
self.browser.execute_script(
"arguments[0].click();",
tertiary_element,
)
def add_remove_cv(self, composite_cv, cv_names, is_add=True):
"""Add or Remove content-views to/from selected composite view.
When 'is_add' Flag is set then add_contentView will be performed,
otherwise remove_contentView
"""
self.search_and_click(composite_cv)
if self.wait_until_element(
tab_locators['contentviews.tab_content_views']):
self.click(tab_locators['contentviews.tab_content_views'])
else:
raise UINoSuchElementError(
'Could not find ContentView tab, please make sure '
'selected view is composite')
for cv_name in cv_names:
if is_add:
self.click(tab_locators['contentviews.tab_cv_add'])
else:
self.click(tab_locators['contentviews.tab_cv_remove'])
locator = locators['contentviews.select_cv']
self.click(locator % cv_name)
if is_add:
self.click(locators['contentviews.add_cv'])
self.click(tab_locators['contentviews.tab_cv_remove'])
element = self.wait_until_element(locator % cv_name)
if element is None:
raise UINoSuchElementError(
"Adding CV {0} failed".format(cv_name))
else:
self.click(locators['contentviews.remove_cv'])
self.click(tab_locators['contentviews.tab_cv_add'])
element = self.wait_until_element(locator % cv_name)
if element is None:
raise UINoSuchElementError(
"Removing CV {0} fails".format(cv_name))
def add_remove_repos(self, cv_name, repo_names, add_repo=True):
"""
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 element:
element.click()
self.wait_for_ajax()
self.find_element(tab_locators["contentviews.tab_content"]).click()
self.find_element(locators["contentviews.content_repo"]).click()
self.wait_for_ajax()
strategy, value = locators["contentviews.select_repo"]
for repo_name in repo_names:
if add_repo:
self.find_element(
tab_locators["contentviews.tab_repo_add"]).click()
else:
self.find_element(
tab_locators["contentviews.tab_repo_remove"]).click()
self.text_field_update(locators["contentviews.repo_search"],
repo_name)
element = self.wait_until_element(
(strategy, value % repo_name))
if element:
element.click()
self.wait_for_ajax()
if add_repo:
self.wait_until_element(
locators["contentviews.add_repo"]).click()
self.wait_until_element(
tab_locators["contentviews.tab_repo_remove"]
).click()
element = self.wait_until_element(
(strategy, value % repo_name))
if element is None:
raise UINoSuchElementError(
"Adding repo {0} failed".format(repo_name))
else:
self.wait_until_element(
locators["contentviews.remove_repo"]).click()
self.wait_for_ajax()
self.find_element(
tab_locators["contentviews.tab_repo_add"]).click()
self.wait_for_ajax()
element = self.wait_until_element(
(strategy, value % repo_name))
if element is None:
raise UINoSuchElementError(
"Removing repo {0} fails".format(repo_name))
else:
raise Exception("Couldn't find repo '%s'"
"to add into CV" % repo_name)
else:
raise Exception("Couldn't find the selected CV '%s'" % cv_name)
def sync_rh_repos(self, repos_tree):
"""Syncs RedHat repositories.
Selects Red Hat Repos to Synchronize from UI.
:param repos_tree: Repositories to choose which is a List of dictionary
:return: Returns True if the sync was successful.
:rtype: bool
"""
strategy, value = locators["sync.prd_expander"]
strategy1, value1 = locators["sync.verarch_expander"]
strategy2, value2 = locators["sync.repo_checkbox"]
repos = []
# create_repos_tree returns data needed to be passed to this function.
for prd in repos_tree:
prd_exp = self.wait_until_element((strategy, value % PRDS[prd]))
if prd_exp:
prd_exp.click()
for reposet in repos_tree[prd]:
for repo in repos_tree[prd][reposet]:
repo_values = repos_tree[prd][reposet][repo]
repo_name = repo_values['repo_name']
repo_arch = repo_values['repo_arch']
repo_ver = repo_values['repo_ver']
repos.append(repo_name)
ver_exp = self.wait_until_element(
(strategy1, value1 % repo_ver))
if ver_exp:
ver_exp.click()
self.wait_for_ajax()
else:
raise UINoSuchElementError(
"Could not find the version expander: '%s'" %
repo_ver)
arch_exp = self.wait_until_element(
(strategy1, value1 % repo_arch))
if arch_exp:
arch_exp.click()
self.wait_for_ajax()
else:
raise UINoSuchElementError(
"Could not find the arch expander: '%s'" %
repo_arch)
repo_select = self.wait_until_element(
(strategy2, value2 % repo_name))
if repo_select:
repo_select.click()
self.wait_for_ajax()
else:
raise UINoSuchElementError(
"Could not find the repository name: '%s'" %
repo_name)
self.wait_until_element(locators["sync.sync_now"]).click()
self.wait_for_ajax()
# Let's assert without navigating away from sync status page to avoid
# complexities
return self.assert_sync(repos)
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_yum_content_repo_name(self, cv_name):
"""Fetch associated yum repository info from selected content view."""
# find content_view
cv = self.search(cv_name)
if cv is None:
raise UINoSuchElementError('Could not find CV %s', cv_name)
cv.click()
self.wait_for_ajax()
self.click(tab_locators['contentviews.tab_content'])
self.click(locators['contentviews.yum_repositories'])
if self.wait_until_element(locators['contentviews.repo_name']):
return self.find_element(locators['contentviews.repo_name']).text
else:
raise UINoSuchElementError(
'Could not get text attribute of repository locator')
def remove(self, org_name, really):
"""Remove Organization in UI."""
searched = self.search(org_name)
if searched is None:
raise UINoSuchElementError(
'Could not search the entity {0}'.format(org_name))
strategy, value = locators["org.dropdown"]
self.wait_until_element((strategy, value % org_name)).click()
strategy1, value1 = locators['org.delete']
element = self.wait_until_element((strategy1, value1 % org_name))
if element is None:
raise UINoSuchElementError(
'Could not select entity {0} for deletion.'.format(org_name))
element.click()
self.handle_alert(really)
def fetch_content_count(self, repo_name, content_type):
"""Fetch content count for specific repo and content type.
:param repo_name: Name of repository that should be fetched.
:param content_type: Type of repository content. Supported values are:
* packages
* errata
* package_groups
* puppet
:returns: Content count.
:rtype: int
:raises: ``ValueError`` if passed ``content_type`` is not supported.
:raises robottelo.ui.base.UINoSuchElementError: If content is not
found.
"""
self.search_and_click(repo_name)
if content_type == 'packages':
locator = locators['repo.fetch_packages']
elif content_type == 'errata':
locator = locators['repo.fetch_errata']
elif content_type == 'package_groups':
locator = locators['repo.fetch_package_groups']
elif content_type == 'puppet':
locator = locators['repo.fetch_puppet_modules']
else:
raise ValueError("Please provide supported content_type value")
number = self.find_element(locator)
if number:
return int(number.text)
else:
raise UINoSuchElementError("Content count not found")
def update(self, name, new_name=None, new_description=None):
"""Updates an existing content view"""
element = self.search(name)
if element is None:
raise UINoSuchElementError(
'Could not update the content view {0}'.format(name))
element.click()
self.wait_for_ajax()
self.click(tab_locators['contentviews.tab_details'])
if new_name:
self.edit_entity(
locators['contentviews.edit_name'],
locators['contentviews.edit_name_text'],
new_name,
locators['contentviews.save_name'],
)
if new_description:
self.edit_entity(
locators['contentviews.edit_description'],
locators['contentviews.edit_description_text'],
new_description,
locators['contentviews.save_description']
)
def enable_repos(self, name, repos, enable=True):
"""Enables repository via product_content tab of the activation_key."""
element = self.search_key(name)
strategy, value = locators["ak.prd_content.edit_repo"]
strategy1, value1 = locators["ak.prd_content.select_repo"]
if element is None:
raise UINoSuchElementError(
"Couldn't find the selected activation key {0}".format(name))
element.click()
self.wait_for_ajax()
self.wait_until_element(tab_locators["ak.tab_prd_content"]).click()
self.wait_for_ajax()
for repo in repos:
repo_edit = self.wait_until_element((strategy, value % repo))
if repo_edit is None:
raise Exception("Couldn't find the repo: {0}".format(repo))
repo_edit.click()
self.wait_for_ajax()
repo_select = self.wait_until_element((strategy1, value1 % repo))
if enable:
Select(repo_select).select_by_visible_text("Override to Yes")
else:
Select(repo_select).select_by_visible_text("Override to No")
self.wait_until_element(common_locators['save']).click()
self.wait_for_ajax()
def create(self, name, parent=None, users=None, proxies=None,
subnets=None, resources=None, medias=None, templates=None,
domains=None, envs=None, hostgroups=None, organizations=None,
select=True):
"""Creates new Location from UI."""
self.wait_until_element(locators["location.new"]).click()
if self.wait_until_element(locators["location.name"]) is None:
raise UINoSuchElementError('Could not create new location.')
self.field_update("location.name", name)
if parent:
Select(self.find_element(
locators["location.parent"])).select_by_visible_text(parent)
self.wait_until_element(common_locators["submit"]).click()
edit_locator = self.wait_until_element(
locators["location.proceed_to_edit"])
if edit_locator:
edit_locator.click()
self._configure_location(
users=users, proxies=proxies,
subnets=subnets, resources=resources,
medias=medias, templates=templates,
domains=domains, envs=envs,
hostgroups=hostgroups,
organizations=organizations,
select=select,
)
self.wait_until_element(common_locators["submit"]).click()
self.wait_for_ajax()
def update(self, tab_locator, param_name, value_type, param_value):
"""Updates the value of selected parameter under settings
@param tab_locator: Selenium locator to select appropriate tab.
@param param_name: A valid parameter name.
@param value_type: Valid value type either 'input' or 'dropdown'
@param param_value: Value of selected parameter
@raise OptionError: Raise an exception when value type is different
than 'input' and 'dropdown'.
@raise UINoSuchElementError: Raise an exception when UI element is
not found
"""
if self.wait_until_element(tab_locator) is None:
raise UINoSuchElementError(
"Couldn't find the tab with name: '%s'" % tab_locator)
self.click(tab_locator)
strategy, value = locators['settings.edit_param']
self.click((strategy, value % param_name))
if value_type == 'dropdown':
self.select(locators['settings.select_value'], param_value)
elif value_type == 'input':
self.wait_until_element(locators['settings.input_value'])
self.field_update('settings.input_value', param_value)
else:
raise OptionError('Please input appropriate value type')
self.wait_for_ajax()
self.click(locators['settings.save'])
def clone(self,
name,
custom_really=None,
clone_name=None,
template_path=None,
template_type=None,
os_list=None):
"""Clones a given template."""
self.search(name)
clone = self.wait_until_element(locators["provision.template_clone"])
if not clone:
raise UINoSuchElementError(
"Could not locate the clone button for template '{0}'".format(
name))
clone.click()
self.field_update("provision.template_name", clone_name)
if template_path:
self.find_element(
locators["provision.template_template"]).send_keys(
template_path)
self.handle_alert(custom_really)
if template_type:
self.wait_until_element(tab_locators["provision.tab_type"]).click()
element = self.find_element(locators["provision.template_type"])
Select(element).select_by_visible_text(template_type)
self.configure_entity(
os_list,
FILTER['template_os'],
tab_locator=tab_locators["provision.tab_association"])
self.find_element(common_locators["submit"]).click()
self.wait_for_ajax()
def clone(self,
name,
custom_really=None,
clone_name=None,
template_path=None,
template_type=None,
os_list=None):
"""Clones a given template."""
self.search(name)
self.click(locators['provision.template_clone'])
if self.wait_until_element(
locators['provision.template_name']) is None:
raise UINoSuchElementError(
u'Could not clone provisioning template "{0}"'.format(name))
self.field_update('provision.template_name', clone_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)
self.configure_entity(
os_list,
FILTER['template_os'],
tab_locator=tab_locators['provision.tab_association'])
self.click(common_locators['submit'])
def logout(self):
"""Logout user from UI"""
# Scroll to top
self.browser.execute_script('window.scroll(0, 0)')
if self.wait_until_element(locators['login.gravatar']) is None:
raise UINoSuchElementError(
'could not find login.gravatar to sign out')
Navigator(self.browser).go_to_sign_out()
def create(self, resource_name, name, command, parameter_list):
"""Creates a docker container. All values should be passed in absolute
correspondence to UI. Parameters names created in self-descriptive
manner. Of course, we can easily expand list of parameters and create
custom flows for specific situations. Here are some examples of
parameter_list values from each main tab::
[
{'main_tab_name': 'Preliminary', 'sub_tab_name': 'Location',
'name': ['Default Location']},
{'main_tab_name': 'Image', 'sub_tab_name': 'Content View',
'name': 'Lifecycle Environment', 'value': self.lce.name},
{'main_tab_name': 'Image', 'sub_tab_name': 'Docker Hub',
'name': 'Docker Hub Tag', 'value': 'latest'},
{'main_tab_name': 'Configuration', 'name': 'Memory',
'value': '512m'},
{'main_tab_name': 'Environment', 'name': 'TTY', 'value': True},
]
"""
self.assign_value(locators['container.resource_name'], resource_name)
for parameter in parameter_list:
if parameter['main_tab_name'] == 'Preliminary':
if parameter['sub_tab_name'] == 'Organization':
self._configure_orgs(parameter['name'], True)
elif parameter['sub_tab_name'] == 'Location':
self._configure_locations(parameter['name'], True)
self.click(locators['container.next_section'])
current_tab = self._form_locator_name('Content View Tab')
for parameter in parameter_list:
if parameter['main_tab_name'] == 'Image':
current_tab = self._form_locator_name(
parameter['sub_tab_name'] + ' Tab')
self.click(locators[current_tab])
self.assign_value(
locators[self._form_locator_name(parameter['name'])],
parameter['value'])
self.click(locators[current_tab + '_next'])
self.assign_value(locators['container.name'], name)
self.assign_value(locators['container.command'], command)
for parameter in parameter_list:
if parameter['main_tab_name'] == 'Configuration':
self.assign_value(
locators[self._form_locator_name(parameter['name'])],
parameter['value'])
self.click(locators['container.next_section'])
self.browser.refresh()
for parameter in parameter_list:
if parameter['main_tab_name'] == 'Environment':
self.assign_value(
locators[self._form_locator_name(parameter['name'])],
parameter['value'])
self.click(locators['container.next_section'])
strategy, value = locators['container.created_container_name']
element = self.wait_until_element((strategy, value % name))
if element is None:
raise UINoSuchElementError(
'Container with name {0} was not created successfully'.format(
name))
def create(self, name):
"""Creates the config-groups."""
self.click(locators['config_groups.new'])
if self.wait_until_element(locators['config_groups.name']):
self.find_element(locators['config_groups.name']).send_keys(name)
self.click(common_locators['submit'])
else:
raise UINoSuchElementError(
'Could not text box to add config_group name')
def create(self, name=None, server=None, ldaps=False, port=None,
server_type=None, login_name=None, first_name=None,
surname=None, mail=None, photo=None, account_user=None,
account_passwd=None, account_basedn=None,
account_grpbasedn=None, ldap_filter=False, otf_register=True,
orgs=None, org_select=None, locations=None, loc_select=None):
"""Create new ldap auth source from UI."""
if not self.wait_until_element(locators['ldapsource.new']):
return
self.click(locators['ldapsource.new'])
if self.wait_until_element(locators['ldapserver.name']):
self.assign_value(locators['ldapserver.name'], name)
self.assign_value(locators['ldapserver.server'], server)
if ldaps:
self.click(locators['ldapserver.ldaps'])
if port:
self.assign_value(locators['ldapserver.port'], port)
self.select(locators['ldapserver.server_type'], server_type)
self.click(tab_locators['ldapserver.tab_account'])
if self.wait_until_element(locators['ldapserver.acc_user']) is None:
raise UINoSuchElementError(u'Could not select the attributes Tab.')
self.assign_value(locators['ldapserver.acc_user'], account_user)
self.assign_value(locators['ldapserver.acc_passwd'], account_passwd)
self.assign_value(locators['ldapserver.basedn'], account_basedn)
self.assign_value(
locators['ldapserver.group_basedn'], account_grpbasedn)
if ldap_filter:
self.click(locators['ldapserver.ldap_filter'])
if otf_register:
self.click(locators['ldapserver.otf_register'])
self.click(tab_locators['ldapserver.tab_attributes'])
if self.wait_until_element(locators['ldapserver.loginname']) is None:
raise UINoSuchElementError(u'Could not select the account Tab.')
self.assign_value(locators['ldapserver.loginname'], login_name)
self.assign_value(locators['ldapserver.firstname'], first_name)
self.assign_value(locators['ldapserver.surname'], surname)
self.assign_value(locators['ldapserver.mail'], mail)
if locations:
self._configure_locations(locations, loc_select)
if orgs:
self._configure_orgs(orgs, org_select)
if photo:
self.assign_value(locators['ldapserver.photo'], photo)
self.click(common_locators['submit'])
def delete(self, name):
"""Deletes an existing environment. We don't have confirmation dialog
for current operation, so it is necessary to use custom method
"""
element = self.search(name)
if not element:
raise UINoSuchElementError(
'Could not find the %s lifecycle environment.' % name)
element.click()
self.click(locators['content_env.remove'])
def delete(self, name):
"""Deletes an existing environment."""
strategy = locators["content_env.select_name"][0]
value = locators["content_env.select_name"][1]
element = self.wait_until_element((strategy, value % name))
if element is None:
raise UINoSuchElementError(
'Could not find the selected environment {0}'.format(name))
element.click()
self.wait_until_element(locators["content_env.remove"]).click()
def create(self, name):
"""
Creates the config-groups.
"""
self.wait_until_element(locators["config_groups.new"]).click()
if self.wait_until_element(locators["config_groups.name"]):
self.find_element(locators["config_groups.name"]).send_keys(name)
self.find_element(common_locators["submit"]).click()
self.wait_for_ajax()
else:
raise UINoSuchElementError(
"Could not text box to add config_group name")
def get_saved_value(self, tab_locator, param_name):
"""Fetch the updated value to assert"""
self.navigate_to_entity()
if self.wait_until_element(tab_locator):
self.click(tab_locator)
strategy, value = locators['settings.edit_param']
element = self.wait_until_element((strategy, value % param_name))
if element:
return element.text
else:
raise UINoSuchElementError(
"Couldn't find element to fetch the param's value")
def assert_sync(self, repos, product=None):
"""Asserts sync status of the Repositories.
Asserts the sync of Repositories, loops over while cancel is visible,
during the syncing process.
:param list repos: List of repositories names to assert sync status.
:param str product: product is required only when syncing via
repository page.
:return: Returns True if sync is successful.
:rtype: bool
"""
repos_result = []
strategy1, value1 = locators["sync.fetch_result"]
strategy2, value2 = locators["sync.cancel"]
strategy3, value3 = locators["sync.prd_expander"]
if product:
prd_exp = self.wait_until_element((strategy3, value3 % product))
if not prd_exp:
raise UINoSuchElementError(
"Could not find the product expander: '{0}'".format(
product))
prd_exp.click()
for repo in repos:
timeout = time.time() + 60 * 10
sync_cancel = self.wait_until_element(
(strategy2, value2 % repo),
timeout=6,
poll_frequency=2,
)
# Waits until sync "cancel" is visible on the UI or times out
# after 10 mins
while sync_cancel:
if time.time() > timeout:
break
sync_cancel = self.wait_until_element(
(strategy2, value2 % repo),
timeout=6,
poll_frequency=2,
)
result = self.wait_until_element((strategy1, value1 % repo),
5).text
# Updates the result of every sync repo to the repos_result list.
repos_result.append(result)
# Checks whether every item(sync result) in the list is
# "Syncing Complete."
# This function returns False if it encounters any of the below:
# "Error Syncing", "Queued", "None", "Never Synced" or "Cancel".
if all([str(r) == "Syncing Complete." for r in repos_result]):
return True
else:
return 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
"""
self.search_and_click(cv_name)
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'])
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(locator % repo_name)
if add_repo:
self.click(locators['contentviews.add_repo'])
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'])
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 update(self, tab_locator, param_name, value_type, param_value):
"""
Updates the value of selected parameter under settings
@param tab_locator: Selenium locator to select appropriate tab.
@param param_name: A valid parameter name.
@param value_type: Valid value type either 'input' or 'dropdown'
@param param_value: Value of selected parameter
@raise OptionError: Raise an exception when value type is different
than 'input' and 'dropdown'.
@raise UINoSuchElementError: Raise an exception when UI element is
not found
"""
if self.wait_until_element(tab_locator):
self.find_element(tab_locator).click()
strategy, value = locators["settings.edit_param"]
element = self.wait_until_element((strategy,
value % param_name))
if element:
element.click()
if value_type == "dropdown":
Select(self.find_element
(locators["settings.select_value"])
).select_by_value(param_value)
elif value_type == "input":
self.field_update("settings.input_value", param_value)
else:
raise OptionError(
"Please input appropriate value type")
self.wait_for_ajax()
self.wait_until_element(locators["settings.save"]).click()
self.wait_for_ajax()
else:
raise UINoSuchElementError(
"Couldn't find edit button to update selected param")
else:
raise UINoSuchElementError(
"Couldn't find the tab with name: '%s'" % tab_locator)
def get_cv_table_value(self, cv_name, column_name):
"""Get value for specific table cell
:param str cv_name: Name of content view to be fetched
:param str column_name: Name of table column that needs to be fetched
:return str: Cell value text
"""
element = self.search(cv_name)
if element is None:
raise UINoSuchElementError(
'Unable to find necessary cv "{0}".'.format(cv_name))
return self.wait_until_element(common_locators['kt_table_cell_value'] %
(cv_name, column_name)).text
def validate_version_deleted(self, cv_name, version):
"""Ensures the version is deleted from selected CV"""
element = self.search(cv_name)
if element is None:
raise UINoSuchElementError('Could not find CV %s', cv_name)
element.click()
self.wait_for_ajax()
strategy, value = locators['contentviews.version_name']
removed_version = self.find_element((strategy, value % version))
if removed_version:
raise UIError(
'Selected version "{0}" was not deleted successfully'.format(
version))
def update(self, old_name, new_name):
"""Updates existing compute profile entity"""
element = self.search(old_name)
if element is None:
raise UINoSuchElementError(
'Could not find compute profile {0}'.format(old_name))
if element:
strategy, value = locators['profile.dropdown']
self.click((strategy, value % old_name))
strategy, value = locators['profile.rename']
self.click((strategy, value % old_name))
self.field_update('profile.name', new_name)
self.click(common_locators['submit'])
