/* * Copyright 2024 The Backstage Authors * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ import { AppHealth, NamespaceAppHealth, NamespaceServiceHealth, NamespaceWorkloadHealth, ServiceHealth, WorkloadHealth, } from '@backstage-community/plugin-kiali-common/func'; import type { App, AppList, AppListQuery, AppQuery, AuthInfo, CanaryUpgradeStatus, CertsInfo, ClusterWorkloadsResponse, ComponentStatus, DashboardModel, DurationInSeconds, GrafanaInfo, GraphDefinition, GraphElementsQuery, IstioConfigDetails, IstioConfigList, IstioConfigsMapQuery, IstiodResourceThresholds, IstioMetricsMap, IstioMetricsOptions, KialiCrippledFeatures, Namespace, OutboundTrafficPolicy, PodLogs, ServerConfig, ServiceDetailsInfo, ServiceList, ServiceListQuery, Span, StatusState, TimeInSeconds, TLSStatus, TracingQuery, ValidationStatus, Workload, WorkloadListItem, WorkloadNamespaceResponse, WorkloadOverview, WorkloadQuery, } from '@backstage-community/plugin-kiali-common/types'; import { Entity } from '@backstage/catalog-model'; import { Content, HeaderTabs, Page } from '@backstage/core-components'; import { EntityProvider } from '@backstage/plugin-catalog-react'; import { TestApiProvider } from '@backstage/test-utils'; import { default as React } from 'react'; import { getEntityRoutes } from '../src/components/Router'; import { serverConfig } from '../src/config'; import { AppDetailsPage } from '../src/pages/AppDetails/AppDetailsPage'; import { AppListPage } from '../src/pages/AppList/AppListPage'; import { IstioConfigDetailsPage } from '../src/pages/IstioConfigDetails/IstioConfigDetailsPage'; import { IstioConfigListPage } from '../src/pages/IstioConfigList/IstioConfigListPage'; import { KialiNoPath } from '../src/pages/Kiali'; import { KialiHeader } from '../src/pages/Kiali/Header/KialiHeader'; import { OverviewPage } from '../src/pages/Overview/OverviewPage'; import { ServiceDetailsPage } from '../src/pages/ServiceDetails/ServiceDetailsPage'; import { ServiceListPage } from '../src/pages/ServiceList/ServiceListPage'; import TrafficGraphPage from '../src/pages/TrafficGraph/TrafficGraphPage'; import { WorkloadDetailsPage } from '../src/pages/WorkloadDetails/WorkloadDetailsPage'; import { WorkloadListPage } from '../src/pages/WorkloadList/WorkloadListPage'; import { KialiApi, kialiApiRef, QueryParams } from '../src/services/Api'; import { KialiProvider } from '../src/store/KialiProvider'; import { filterNsByAnnotation } from '../src/utils/entityFilter'; import { kialiData } from './__fixtures__'; import { mockEntity } from './mockEntity'; export class MockKialiClient implements KialiApi { private entity?: Entity; constructor() { this.entity = undefined; } getGraphElements(_params: GraphElementsQuery): Promise { return kialiData.graph; } setEntity(entity?: Entity): void { this.entity = entity; } setAnnotation(key: string, value: string): void { if (this.entity && this.entity.metadata.annotations) { this.entity.metadata.annotations[key] = value; } } async getClustersWorkloads(): Promise { return { workloads: [], validations: {} }; } async getClustersServices(): Promise { return { services: [], validations: {} }; } async getClustersApps(): Promise { return { applications: [] }; } async getClustersAppHealth(): Promise> { return new Map([]); } async getClustersServiceHealth(): Promise< Map > { return new Map([]); } async getClustersWorkloadHealth(): Promise< Map > { return new Map([]); } async status(): Promise { return kialiData.status; } async getAuthInfo(): Promise { return kialiData.auth; } async getStatus(): Promise { return kialiData.status; } async getNamespaces(): Promise { return filterNsByAnnotation( kialiData.namespaces as Namespace[], this.entity?.metadata.annotations || {}, ); } async getWorkloads( namespace: string, duration: number, ): Promise { const nsl = kialiData.workloads as WorkloadNamespaceResponse[]; // @ts-ignore return nsl[namespace].workloads.map( (w: WorkloadOverview): WorkloadListItem => { return { name: w.name, namespace: namespace, cluster: w.cluster, type: w.type, istioSidecar: w.istioSidecar, isAmbient: w.isAmbient, additionalDetailSample: undefined, appLabel: w.appLabel, versionLabel: w.versionLabel, labels: w.labels, istioReferences: w.istioReferences, notCoveredAuthPolicy: w.notCoveredAuthPolicy, health: WorkloadHealth.fromJson( namespace, w.name, w.health, { rateInterval: duration, hasSidecar: w.istioSidecar, hasAmbient: w.isAmbient, }, serverConfig, ), }; }, ); } async getWorkload( namespace: string, name: string, _: WorkloadQuery, __?: string, ): Promise { const parsedName = name.replace(/-/g, ''); return kialiData.namespacesData[namespace].workloads[parsedName]; } async getIstioConfig( namespace: string, _: string[], __: boolean, ___: string, ____: string, _____?: string, ): Promise { return kialiData.namespacesData[namespace].istioConfigList; } async getServerConfig(): Promise { return kialiData.config; } async getNamespaceAppHealth( namespace: string, duration: DurationInSeconds, cluster?: string, queryTime?: TimeInSeconds, ): Promise { const ret: NamespaceAppHealth = {}; const params: any = { type: 'app', rateInterval: `${String(duration)}s`, queryTime: String(queryTime), clusterName: cluster, }; const data = kialiData.namespacesData[namespace].health[params.type]; Object.keys(data).forEach(k => { ret[k] = AppHealth.fromJson( namespace, k, data[k], { rateInterval: duration, hasSidecar: true, hasAmbient: false, }, serverConfig, ); }); return ret; } async getNamespaceServiceHealth( namespace: string, duration: DurationInSeconds, cluster?: string, queryTime?: TimeInSeconds, ): Promise { const ret: NamespaceServiceHealth = {}; const params: any = { type: 'service', rateInterval: `${String(duration)}s`, queryTime: String(queryTime), clusterName: cluster, }; const data = kialiData.namespacesData[namespace].health[params.type]; Object.keys(data).forEach(k => { ret[k] = ServiceHealth.fromJson( namespace, k, data[k], { rateInterval: duration, hasSidecar: true, hasAmbient: false, }, serverConfig, ); }); return ret; } async getNamespaceWorkloadHealth( namespace: string, duration: DurationInSeconds, cluster?: string, queryTime?: TimeInSeconds, ): Promise { const ret: NamespaceWorkloadHealth = {}; const params: any = { type: 'workload', rateInterval: `${String(duration)}s`, queryTime: String(queryTime), clusterName: cluster, }; const data = kialiData.namespacesData[namespace].health[params.type]; Object.keys(data).forEach(k => { ret[k] = WorkloadHealth.fromJson( namespace, k, data[k], { rateInterval: duration, hasSidecar: true, hasAmbient: false, }, serverConfig, ); }); return ret; } async getNamespaceTls( namespace: string, cluster?: string, ): Promise { const queryParams: any = {}; if (cluster) { queryParams.clusterName = cluster; } return kialiData.namespacesData[namespace].tls; } async getMeshTls(cluster?: string): Promise { const queryParams: any = {}; if (cluster) { queryParams.clusterName = cluster; } return kialiData.meshTls; } async getOutboundTrafficPolicyMode(): Promise { return kialiData.outboundTrafficPolicy; } async getCanaryUpgradeStatus(): Promise { return kialiData.meshCanaryStatus; } async getIstiodResourceThresholds(): Promise { return kialiData.meshIstioResourceThresholds; } async getConfigValidations(cluster?: string): Promise { const queryParams: any = {}; if (cluster) { queryParams.clusterName = cluster; } return kialiData.istioValidations; } async getAllIstioConfigs( objects: string[], validate: boolean, labelSelector: string, workloadSelector: string, cluster?: string, ): Promise { const params: QueryParams = {}; if (objects && objects.length > 0) { params.objects = objects.join(','); } if (validate) { params.validate = validate; } if (labelSelector) { params.labelSelector = labelSelector; } if (workloadSelector) { params.workloadSelector = workloadSelector; } if (cluster) { params.clusterName = cluster; } return kialiData.istioConfig; } async getNamespaceMetrics( namespaces: string, params: IstioMetricsOptions, ): Promise>> { const metricsMap = new Map>(); const namespaceList = namespaces.split(','); namespaceList.forEach(namespace => { const trimmedNs = namespace.trim(); if (kialiData.namespacesData[trimmedNs]) { const metrics = kialiData.namespacesData[trimmedNs].metrics[params.direction][ params.duration as number ]; metricsMap.set(trimmedNs, metrics); } }); return metricsMap; } async getIstioStatus(cluster?: string): Promise { const queryParams: any = {}; if (cluster) { queryParams.clusterName = cluster; } return kialiData.istioStatus; } async getIstioCertsInfo(_: string, __?: string): Promise { return kialiData.istioCertsInfo; } isDevEnv(): boolean { return true; } async getPodLogs( _: string, __: string, container?: string, ___?: number, ____?: number, _duration?: DurationInSeconds, _isProxy?: boolean, _cluster?: string, ): Promise { if (container === 'istio-proxy') { return kialiData.istioLogs; } return kialiData.logs; } setPodEnvoyProxyLogLevel = async ( _namespace: string, _name: string, _level: string, _cluster?: string, ): Promise => { return; }; async getWorkloadSpans( _: string, __: string, ___: TracingQuery, ____?: string, ): Promise { return kialiData.spanLogs; } async getServices( namespace: string, _?: ServiceListQuery, ): Promise { return kialiData.services[namespace]; } async getIstioConfigDetail( namespace: string, objectType: string, object: string, _validate: boolean, _cluster?: string, ): Promise { return kialiData.namespacesData[namespace].istioConfigDetails[objectType][ object ]; } async getServiceDetail( namespace: string, service: string, _validate: boolean, _cluster?: string, rateInterval?: DurationInSeconds, ): Promise { const parsedName = service.replace(/-/g, ''); const info: ServiceDetailsInfo = kialiData.namespacesData[namespace].services[parsedName]; if (info.health) { // Default rate interval in backend = 600s info.health = ServiceHealth.fromJson( namespace, service, info.health, { rateInterval: rateInterval ?? 600, hasSidecar: info.istioSidecar, hasAmbient: info.isAmbient, }, serverConfig, ); } return info; } getApps = async ( namespace: string, _params: AppListQuery, ): Promise => { return kialiData.apps[namespace]; }; getApp = async ( namespace: string, app: string, _params: AppQuery, _cluster?: string, ): Promise => { const parsedName = app.replace(/-/g, ''); return kialiData.namespacesData[namespace].apps[parsedName]; }; getCrippledFeatures = async (): Promise => { return kialiData.crippledFeatures; }; getWorkloadDashboard = async ( namespace: string, _workload: string, _params: IstioMetricsOptions, _cluster?: string, ): Promise => { return kialiData.namespacesData[namespace].dashboard; }; getServiceDashboard = async ( namespace: string, _service: string, _params: IstioMetricsOptions, _cluster?: string, ): Promise => { return kialiData.namespacesData[namespace].dashboard; }; getAppDashboard = async ( namespace: string, _app: string, _params: IstioMetricsOptions, _cluster?: string, ): Promise => { return kialiData.namespacesData[namespace].dashboard; }; getGrafanaInfo = async (): Promise => { return kialiData.grafanaInfo; }; getAppSpans = async ( namespace: string, _app: string, _params: TracingQuery, _cluster?: string, ): Promise => { return kialiData.namespacesData[namespace].spans; }; getServiceSpans = async ( namespace: string, _service: string, _params: TracingQuery, _cluster?: string, ): Promise => { return kialiData.namespacesData[namespace].spans; }; } const getSelected = (route: number) => { const pathname = window.location.pathname.split('/'); const paths = ['workloads', 'applications', 'services', 'istio', 'graph']; if (pathname && paths.includes(pathname[2])) { switch (pathname[2]) { case 'workloads': return ; case 'services': return ; case 'applications': return ; case 'istio': return ; case 'graph': return ; default: return ; } } switch (route) { case 0: return ; case 1: return ; case 2: return ; case 3: return ; case 4: return ; case 5: return ; default: return ; } }; interface Props { children?: React.ReactNode; entity?: Entity; isEntity?: boolean; } export const MockProvider = (props: Props) => { const [selectedTab, setSelectedTab] = React.useState(0); const tabs = [ { label: 'Overview', route: `/kiali#overview` }, { label: 'Workloads', route: `/kiali#workloads` }, { label: 'Services', route: `/kiali#services` }, { label: 'Applications', route: `/kiali#applications` }, { label: 'Istio Config', route: `/kiali#istio` }, { label: 'Traffic Graph', route: `/kiali#graph` }, ]; const content = ( {!props.isEntity && ( <> { setSelectedTab(index); }} tabs={tabs.map(({ label }, index) => ({ id: tabs[index].route, label, }))} /> {getSelected(selectedTab)} )} {props.isEntity && {getEntityRoutes()}} ); const viewIfEntity = props.isEntity && ( {content} ); return ( {viewIfEntity || content} ); };