def assert_namespaces(self):
namespaces_ui = self._namespaces_ui()
namespaces_rest = self.kiali_client.namespace_list()
namespaces_oc = self.openshift_client.namespace_list()
logger.debug('Namespaces UI:{}'.format(namespaces_ui))
logger.debug('Namespaces REST:{}'.format(namespaces_rest))
logger.debug('Namespaces OC:{}'.format(namespaces_oc))
assert is_equal(namespaces_ui, namespaces_rest)
assert is_equal(namespaces_rest, namespaces_oc)
def is_equal(self, other, advanced_check=True):
# basic check
if not isinstance(other, ServiceDetails):
return False
if self.name != other.name:
return False
if self.created_at and other.created_at and self.created_at != other.created_at:
return False
if self.service_type and other.service_type and self.service_type != other.service_type:
return False
if self.resource_version and other.resource_version and \
self.resource_version != other.resource_version:
return False
if self.ip != other.ip:
return False
if self.labels != other.labels:
return False
if not is_equal(self.endpoints, other.endpoints):
return False
# https://github.com/kiali/kiali/issues/1382
# if self.selectors != other.selectors:
# return False
# advanced check
if not advanced_check:
return True
# if self.istio_sidecar != other.istio_sidecar:
# return False
if self.health != other.health:
return False
if self.service_status and other.service_status and \
not self.service_status.is_equal(other.service_status):
return False
if self.icon != other.icon:
return False
return True
def test_menu(browser, kiali_client):
# load root page
page = RootPage(browser)
# test available menus
_response = kiali_client.get_response('getStatus')
_products = _response['externalServices']
options_defined = [item.text for item in MainMenuEnum]
if not _get_jaeger_url(_products):
options_defined.remove(MainMenuEnum.DISTRIBUTED_TRACING.value)
options_listed = page.main_menu.items
logger.debug('menus[defined:{}, listed:{}]'.format(options_defined,
options_listed))
assert is_equal(options_defined, options_listed), \
('Menus mismatch: defined:{}, listed:{}'.format(options_defined, options_listed))
# navigate to menus
for _menu in options_listed:
if str(_menu) == MainMenuEnum.DISTRIBUTED_TRACING.text:
assert _get_jaeger_url(_products) \
in page.main_menu.get_link(_menu).get_attribute('href')
assert '_blank' == page.main_menu.get_link(_menu).get_attribute(
'target')
continue
logger.debug('Testing menu: {}'.format(_menu))
page.main_menu.select(_menu)
assert page.main_menu.selected == _menu
def assert_filter_options(self):
# test available options
options_defined = [item.text for item in self.FILTER_ENUM]
options_listed = self.page.filter.filters
logger.debug('Options[defined:{}, defined:{}]'.format(
options_defined, options_listed))
assert is_equal(options_defined, options_listed)
def is_equal(self, other):
if not isinstance(other, ApplicationHealth):
return False
if not is_equal(self.deployment_statuses, other.deployment_statuses):
return False
if not self.requests.is_equal(other.requests):
return False
return True
def test_user_menu(browser):
# load root page
page = RootPage(browser)
options_defined = [item.text for item in UserMenuEnum]
options_listed = page.navbar.user_menu.options
logger.debug('Menus[defined:{}, listed:{}]'.format(options_defined, options_listed))
assert is_equal(options_defined, options_listed), \
('User menu mismatch: defined:{}, listed:{}'.format(options_defined, options_listed))
def test_help_menu(browser):
# load root page
page = RootPage(browser)
# test available menus
options_defined = [item.text for item in HelpMenuEnum]
options_listed = page.navbar.help_menu.options
logger.debug('help menus[defined:{}, listed:{}]'.format(options_defined, options_listed))
assert is_equal(options_defined, options_listed), \
('Help menus mismatch: defined:{}, listed:{}'.format(options_defined, options_listed))
def test_duration(browser):
# get page instance
page = GraphPage(browser)
# test options
options_defined = [item.text for item in TimeIntervalUIText]
duration = page.duration
options_listed = duration.options
logger.debug('Options[defined:{}, listed:{}]'.format(
options_defined, options_listed))
assert is_equal(options_defined, options_listed), \
('Options mismatch: defined:{}, listed:{}'.format(options_defined, options_listed))
def test_refresh_interval(browser):
# get page instance
page = GraphPage(browser)
# test options
options_defined = [item.text for item in GraphRefreshInterval]
interval = page.interval
options_listed = interval.options
logger.debug('Options[defined:{}, listed:{}]'.format(
options_defined, options_listed))
assert is_equal(options_defined, options_listed), \
('Options mismatch: defined:{}, listed:{}'.format(options_defined, options_listed))
def test_about(browser, kiali_client):
# load root page
page = RootPage(browser)
_about = page.navbar.about()
assert _about.application_logo
versions_ui = _about.versions
_about.close()
_response = kiali_client.get_response('getStatus')
_products = _response['externalServices']
if (any(d['name'] == ApplicationVersionEnum.ISTIO.text
for d in _products)):
version_enum = ApplicationVersionEnum
else:
version_enum = ApplicationVersionUpstreamEnum
versions_defined = [item.text for item in version_enum]
logger.debug('Versions information in UI:{}'.format(versions_ui))
logger.debug('Application version keys: defined:{}, available:{}'.format(
versions_defined, versions_ui.keys()))
assert is_equal(versions_defined, versions_ui.keys())
# compare each versions
# get version details from REST API
# kiali core version
_core_rest = '{}{}'.format(
_response['status']['Kiali version'],
' ({})'.format(_response['status']['Kiali commit hash'])
if _response['status']['Kiali commit hash'] != 'unknown' else '')
# skip in case of code coverage run where the version is not set correctly during the build
if "ENABLE_CODE_COVERAGE" not in os.environ or os.environ[
"ENABLE_CODE_COVERAGE"] != "true":
assert versions_ui[version_enum.KIALI_CORE.text] == _core_rest
# versions mismatch between console on UI
# TODO: check with manual test team and enable this
# _console_rest = '{} ({})'.format(
# _response['status']['Kiali version'], _response['status']['Kiali version'])
# assert versions_ui[ApplicationVersionEnum.KIALI_UI.text] == _console_rest
# test other product versions
assert versions_ui[version_enum.ISTIO.text] == _get_version(
_products, version_enum.ISTIO.text)
# check Prometheus version
assert versions_ui[version_enum.PROMETHEUS.text] == _get_version(
_products, 'Prometheus')
# check Kubernetes version
assert versions_ui[version_enum.KUBERNETES.text] == _get_version(
_products, 'Kubernetes')
def test_filter(browser):
# get page instance
page = GraphPage(browser)
# test available filters
options_defined = [item.text for item in GraphPageFilter]
options_listed = page.filter.items
logger.debug('options[defined:{}, listed:{}]'.format(
options_defined, options_listed))
assert is_equal(options_defined, options_listed), \
('Options mismatch: defined:{}, listed:{}'.format(options_defined, options_listed))
# enable disable each filter
for filter_name in options_listed:
_filter_test(page, filter_name)
def is_equal(self, other, advanced_check=True):
# basic check
if not isinstance(other, Rule):
return False
if self.name != other.name:
return False
if self.namespace != other.namespace:
return False
# advanced check
if not advanced_check:
return True
if not is_equal(self.actions, other.actions):
return False
return True
def test_menu(browser):
# load root page
page = RootPage(browser)
# test available menus
options_defined = [item.text for item in MainMenuEnum]
options_listed = page.main_menu.items
logger.debug('menus[defined:{}, listed:{}]'.format(options_defined,
options_listed))
assert is_equal(options_defined, options_listed), \
('Menus mismatch: defined:{}, listed:{}'.format(options_defined, options_listed))
# navigate to menus
for _menu in options_listed:
logger.debug('Testing menu: {}'.format(_menu))
page.main_menu.select(_menu)
assert page.main_menu.selected == _menu
def test_type(browser):
# get page instance
page = GraphPage(browser)
namespace = BOOKINFO
page.namespace.check(namespace)
# test options
options_defined = [item.text for item in GraphType]
p_type = page.type
side_panel = page.side_panel
options_listed = p_type.options
assert is_equal(options_defined, options_listed), \
('Options mismatch: defined:{}, listed:{}'.format(options_defined, options_listed))
for option in options_defined:
p_type.select(option)
assert namespace == side_panel.get_namespace()
assert not side_panel.get_workload()
assert not side_panel.get_service()
def apply_filters(self, filters, force_clear_all=True):
"""
Apply supplied filter in to UI and assert with supplied and applied filters
Parameters
----------
filters : list
A list for filter. filter should be a dict.
filter = {'name': 'Namespace', 'value': 'bookinfo'}
Take filter name from pre defined enum
force_clear_all : boolean
Default True.
If this value is True, all existing applied filters will be removed.
otherwise, will be adjusted with pre filter.
on both case final outcome will be same.
"""
_pre_filters = []
# clear all filters
if force_clear_all:
self.page.filter.clear_all()
assert len(self.page.filter.active_filters) == 0
else:
_pre_filters.extend(self.page.filter.active_filters)
# apply filter
for _filter in filters:
if _filter not in _pre_filters:
self.page.filter.apply(filter_name=_filter['name'],
value=_filter['value'])
if _filter in _pre_filters:
_pre_filters.remove(_filter)
# remove filters not in list
for _filter in _pre_filters:
self.page.filter.remove(filter_name=_filter['name'],
value=_filter['value'])
# validate applied filters
_active_filters = self.page.filter.active_filters
logger.debug('Filters[applied:{}, active:{}]'.format(
filters, _active_filters))
assert is_equal(filters, _active_filters)
def assert_pagination_feature(self):
pagination = self.page.pagination
# test options
options_defined = [item.value for item in PaginationPerPage]
options_listed = pagination.items_per_page_options
logger.debug('options[defined:{}, listed:{}]'.format(
options_defined, options_listed))
assert is_equal(options_defined, options_listed), \
('Options mismatch: defined:{}, listed:{}'.format(options_defined, options_listed))
# test page next, previous, first, last, to page
total_pages = pagination.total_pages
if total_pages > 1:
# last page
pagination.move_to_last_page()
assert pagination.current_page == total_pages
# first page
pagination.move_to_first_page()
assert pagination.current_page == 1
# next page
pagination.move_to_next_page()
assert pagination.current_page == 2
# previous page
pagination.move_to_previous_page()
assert pagination.current_page == 1
# to page
pagination.move_to_page(2)
assert pagination.current_page == 2
# navigate to all pages
for to_page in range(1, total_pages + 1):
pagination.move_to_page(to_page)
assert pagination.current_page == to_page
# test items per page and options
for per_page in options_listed:
if pagination.total_items > per_page:
pagination.set_items_per_page(per_page)
assert len(self.page.content.items) == per_page
assert pagination.items_per_page == per_page
# test total items
assert pagination.total_items == len(self.page.content.all_items)
def test_about(browser, kiali_client):
# load root page
page = RootPage(browser)
_about = page.navbar.about()
assert _about.application_name == 'Kiali'
versions_ui = _about.versions
logger.debug('Versions information in UI:{}'.format(versions_ui))
versions_defined = [item.text for item in ApplicationVersionEnum]
logger.debug('Application version keys: defined:{}, available:{}'.format(
versions_defined, versions_ui.keys()))
assert is_equal(versions_defined, versions_ui.keys())
# compare each versions
# get version details from REST API
_response = kiali_client.status()
# kiali core version
_core_rest = '{} ({})'.format(
_response['status']['Kiali core version'],
_response['status']['Kiali core commit hash'])
assert versions_ui[ApplicationVersionEnum.KIALI_CORE.text] == _core_rest
# versions mismatch between console on UI
# TODO: check with manual test team and enable this
# _console_rest = '{} ({})'.format(
# _response['status']['Kiali core version'], _response['status']['Kiali console version'])
# assert versions_ui[ApplicationVersionEnum.KIALI_UI.text] == _console_rest
# test other product versions
_products = _response['externalServices']
# check istio version
assert versions_ui[ApplicationVersionEnum.ISTIO.text] == _get_version(
_products, 'Istio')
# check Prometheus version
assert versions_ui[ApplicationVersionEnum.PROMETHEUS.text] == _get_version(
_products, 'Prometheus')
# check Kubernetes version
assert versions_ui[ApplicationVersionEnum.KUBERNETES.text] == _get_version(
_products, 'Kubernetes')
def is_equal(self, other):
return isinstance(other, Action)\
and self.handler == other.handler\
and is_equal(self.instances, other.instances)
def test_masthead_status(openshift_client, browser):
# load root page
page = RootPage(browser)
oc_apps = openshift_client.get_failing_applications(ISTIO_SYSTEM)
ui_statuses = page.navbar.get_masthead_tooltip()
assert is_equal(oc_apps, list(ui_statuses.keys()))
