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()))