@rancher/shell 3.0.12-rc.1 → 3.0.12-rc.3

package/pages/c/_cluster/auth/user.retention/index.vue

@@ -1,6 +1,9 @@
 <script lang="ts" setup>
-import { ref, reactive, watch, onMounted } from 'vue';
+import {
+  ref, reactive, watch, onMounted, computed
+} from 'vue';
 import { useRouter, onBeforeRouteUpdate } from 'vue-router';
+import { useForm } from 'vee-validate';
 
 import UserRetentionHeader from '@shell/components/user.retention/user-retention-header.vue';
 import Footer from '@shell/components/form/Footer.vue';
@@ -20,8 +23,15 @@ import { ToggleSwitch } from '@components/Form/ToggleSwitch';
 
 import dayjs from 'dayjs';
 
+type UserRetentionSettingId =
+  | typeof SETTING.DISABLE_INACTIVE_USER_AFTER
+  | typeof SETTING.DELETE_INACTIVE_USER_AFTER
+  | typeof SETTING.USER_RETENTION_CRON
+  | typeof SETTING.USER_RETENTION_DRY_RUN
+  | typeof SETTING.USER_LAST_LOGIN_DEFAULT;
+
 const store = useStore();
-const userRetentionSettings = reactive<{[id: string]: string | null }>({
+const userRetentionSettings = reactive<Record<UserRetentionSettingId, string | null>>({
   [SETTING.DISABLE_INACTIVE_USER_AFTER]: null,
   [SETTING.DELETE_INACTIVE_USER_AFTER]:  null,
   [SETTING.USER_RETENTION_CRON]:         null,
@@ -38,18 +48,28 @@ const {
   validateDeleteInactiveUserAfterDuration,
   validateDeleteInactiveUserAfter,
   validateDurationAgainstAuthUserSession,
-  setValidation,
-  removeValidation,
-  addValidation,
-  isFormValid,
 } = useUserRetentionValidation(disableAfterPeriod, deleteAfterPeriod, authUserSessionTtlMinutes);
+
+const { errors, validate: validateForm, validateField } = useForm({
+  validationSchema: {
+    [SETTING.DISABLE_INACTIVE_USER_AFTER]: (value: string) => validateDisableInactiveUserAfterDuration(value) ??
+      validateDurationAgainstAuthUserSession(value) ??
+      true,
+    [SETTING.DELETE_INACTIVE_USER_AFTER]: (value: string) => validateDeleteInactiveUserAfterDuration(value) ??
+      validateDurationAgainstAuthUserSession(value) ??
+      validateDeleteInactiveUserAfter(value) ??
+      true,
+    [SETTING.USER_RETENTION_CRON]: (value: string) => validateUserRetentionCron(value) ?? true,
+  },
+});
+
 let settings: { [id: string]: Setting } = {};
 
 /**
  * Watches the disable after period and removes the value if the checkbox is
  * not selected. Lookup the value when the checkbox is selected.
  */
-watch(disableAfterPeriod, (newVal) => {
+watch(disableAfterPeriod, async(newVal) => {
   if (!newVal) {
     userRetentionSettings[SETTING.DISABLE_INACTIVE_USER_AFTER] = null;
 
@@ -57,13 +77,14 @@ watch(disableAfterPeriod, (newVal) => {
   }
 
   userRetentionSettings[SETTING.DISABLE_INACTIVE_USER_AFTER] = settings[SETTING.DISABLE_INACTIVE_USER_AFTER].value;
+  await validateField(SETTING.DISABLE_INACTIVE_USER_AFTER);
 });
 
 /**
  * Watches the delete after period and removes the value if the checkbox is
  * not selected. Lookup the value when the checkbox is selected.
  */
-watch(deleteAfterPeriod, (newVal) => {
+watch(deleteAfterPeriod, async(newVal) => {
   if (!newVal) {
     userRetentionSettings[SETTING.DELETE_INACTIVE_USER_AFTER] = null;
 
@@ -71,6 +92,8 @@ watch(deleteAfterPeriod, (newVal) => {
   }
 
   userRetentionSettings[SETTING.DELETE_INACTIVE_USER_AFTER] = settings[SETTING.DELETE_INACTIVE_USER_AFTER].value;
+  await validateField(SETTING.DELETE_INACTIVE_USER_AFTER);
+  await validateField(SETTING.USER_RETENTION_CRON);
 });
 
 /**
@@ -84,18 +107,19 @@ watch([disableAfterPeriod, deleteAfterPeriod], ([newDisableAfterPeriod, newDelet
       userRetentionSettings[key] = null;
     });
 
-    removeValidation(SETTING.USER_RETENTION_CRON);
-
     return;
   }
 
-  ids.filter((id) => ![SETTING.DISABLE_INACTIVE_USER_AFTER, SETTING.DELETE_INACTIVE_USER_AFTER].includes(id))
-    .forEach(assignSettings);
+  const skippedIds: readonly UserRetentionSettingId[] = [
+    SETTING.DISABLE_INACTIVE_USER_AFTER,
+    SETTING.DELETE_INACTIVE_USER_AFTER,
+  ];
 
-  addValidation(SETTING.USER_RETENTION_CRON);
+  ids.filter((id) => !skippedIds.includes(id))
+    .forEach(assignSettings);
 });
 
-const assignSettings = (key: string) => {
+const assignSettings = (key: UserRetentionSettingId) => {
   if (settings[key].id === SETTING.USER_LAST_LOGIN_DEFAULT && settings[key].value && typeof settings[key].value === 'string') {
     const value = settings[key].value as string;
 
@@ -111,7 +135,7 @@ const fetchSetting = async(id: string) => {
   return await store.dispatch('management/find', { type: MANAGEMENT.SETTING, id });
 };
 
-const ids = Object.keys(userRetentionSettings);
+const ids = Object.keys(userRetentionSettings) as UserRetentionSettingId[];
 const settingPromises = ids.map((id) => fetchSetting(id));
 
 onMounted(async() => {
@@ -136,6 +160,14 @@ onMounted(async() => {
 const { t } = useI18n(store);
 const error = ref<string | null>(null);
 const save = async(btnCB: (arg: boolean) => void) => {
+  const { valid } = await validateForm();
+
+  if (!valid) {
+    btnCB(false);
+
+    return;
+  }
+
   try {
     error.value = null;
     ids.forEach((key) => {
@@ -164,6 +196,10 @@ const save = async(btnCB: (arg: boolean) => void) => {
   }
 };
 
+const isFormInvalid = computed(() => {
+  return Object.keys(errors.value).length > 0;
+});
+
 const router = useRouter();
 const routeBack = () => {
   router.back();
@@ -199,12 +235,11 @@ onBeforeRouteUpdate((_to: unknown, _from: unknown) => {
           <labeled-input
             v-model:value="userRetentionSettings[SETTING.DISABLE_INACTIVE_USER_AFTER]"
             data-testid="disableAfterPeriodInput"
+            :name="SETTING.DISABLE_INACTIVE_USER_AFTER"
             :tooltip="t('user.retention.edit.form.disableAfter.input.tooltip')"
             class="input-field"
             :label="t('user.retention.edit.form.disableAfter.input.label')"
             :disabled="!disableAfterPeriod"
-            :rules="[validateDisableInactiveUserAfterDuration, validateDurationAgainstAuthUserSession]"
-            @update:validation="e => setValidation(SETTING.DISABLE_INACTIVE_USER_AFTER, e)"
           />
         </div>
         <div class="input-fieldset">
@@ -216,13 +251,12 @@ onBeforeRouteUpdate((_to: unknown, _from: unknown) => {
           <labeled-input
             v-model:value="userRetentionSettings[SETTING.DELETE_INACTIVE_USER_AFTER]"
             data-testid="deleteAfterPeriodInput"
+            :name="SETTING.DELETE_INACTIVE_USER_AFTER"
             :tooltip="t('user.retention.edit.form.deleteAfter.input.tooltip')"
             class="input-field"
             :label="t('user.retention.edit.form.deleteAfter.input.label')"
             :sub-label="t('user.retention.edit.form.deleteAfter.input.subLabel')"
             :disabled="!deleteAfterPeriod"
-            :rules="[validateDeleteInactiveUserAfterDuration, validateDurationAgainstAuthUserSession, validateDeleteInactiveUserAfter]"
-            @update:validation="e => setValidation(SETTING.DELETE_INACTIVE_USER_AFTER, e)"
           />
         </div>
         <template
@@ -232,14 +266,13 @@ onBeforeRouteUpdate((_to: unknown, _from: unknown) => {
             <labeled-input
               v-model:value="userRetentionSettings[SETTING.USER_RETENTION_CRON]"
               data-testid="userRetentionCron"
+              :name="SETTING.USER_RETENTION_CRON"
               class="input-field"
               required
               type="cron"
               :tooltip="t('user.retention.edit.form.cron.subLabel')"
-              :rules="[validateUserRetentionCron]"
               :label="t('user.retention.edit.form.cron.label')"
               :require-dirty="false"
-              @update:validation="e => setValidation(SETTING.USER_RETENTION_CRON, e)"
             />
           </div>
           <div class="input-fieldset condensed pt-12">
@@ -268,7 +301,7 @@ onBeforeRouteUpdate((_to: unknown, _from: unknown) => {
     <Footer
       class="footer-user-retention"
       mode="edit"
-      :disable-save="!isFormValid"
+      :disable-save="isFormInvalid"
       @save="save"
       @done="routeBack"
     />

package/pages/c/_cluster/explorer/__tests__/index.test.ts

@@ -1,12 +1,11 @@
-import { clone } from '@shell/utils/object';
+import { mergeWithReplace } from '@shell/utils/object';
 import Dashboard from '@shell/pages/c/_cluster/explorer/index.vue';
 import { shallowMount } from '@vue/test-utils';
 import { STATES_ENUM } from '@shell/plugins/dashboard-store/resource-class';
-import { NODE_ARCHITECTURE } from '@shell/config/labels-annotations';
 import { WORKLOAD_TYPES } from '@shell/config/types';
 
 describe('page: cluster dashboard', () => {
-  const mountOptions = {
+  const createMountOptions = () => ({
     global: {
       stubs: {
         'router-link': true,
@@ -17,12 +16,11 @@ describe('page: cluster dashboard', () => {
           dispatch: jest.fn(),
           getters:  {
             currentCluster: {
-              id:                         'cluster',
-              metadata:                   { creationTimestamp: Date.now() },
-              status:                     { provider: 'foo' },
-              kubernetesVersionBase:      '0.0.0',
-              kubernetesVersionExtension: 'k3s',
+              id:       'cluster',
+              metadata: { creationTimestamp: Date.now() },
+              status:   { provider: 'foo' },
             },
+            'management/byId':   jest.fn(),
             'cluster/inError':   () => false,
             'cluster/schemaFor': jest.fn(),
             'cluster/canList':   jest.fn(),
@@ -36,7 +34,7 @@ describe('page: cluster dashboard', () => {
         }
       },
     }
-  };
+  });
 
   describe.each([
     'etcd',
@@ -49,7 +47,7 @@ describe('page: cluster dashboard', () => {
       [STATES_ENUM.HEALTHY, 'icon-checkmark', `${ componentId }foo`, [{ status: 'True' }]],
       [STATES_ENUM.UNHEALTHY, 'icon-warning', `${ componentId }foo`, [{ status: 'False' }]],
     ])('should show %p status', (status, iconClass, name, conditions) => {
-      const options = clone(mountOptions);
+      const options = createMountOptions();
 
       options.global.mocks.$store.getters.currentCluster.status = {
         provider:          'provider',
@@ -100,7 +98,7 @@ describe('page: cluster dashboard', () => {
     ]]
   ])('%p cluster - %p agent health box :', (_, agentId, isLocal, agentResources, statuses) => {
     it.each(statuses)('should NOT show %p status due to missing canList permissions', (status, iconClass, isLoaded, disconnected, error, conditions, readyReplicas, unavailableReplicas) => {
-      const options = clone(mountOptions);
+      const options = createMountOptions();
 
       options.global.mocks.$store.getters.currentCluster.isLocal = isLocal;
 
@@ -168,7 +166,7 @@ describe('page: cluster dashboard', () => {
     it.each(statuses)('should show %p status', async(status, iconClass, clickable, isLoaded, disconnected, error, conditions, readyReplicas, unavailableReplicas) => {
       let agentRoute = null;
 
-      const options = clone(mountOptions);
+      const options = createMountOptions();
 
       options.global.mocks.$store.getters.currentCluster.isLocal = isLocal;
 
@@ -221,7 +219,7 @@ describe('page: cluster dashboard', () => {
   });
 
   it('local cluster - cattle agent health box - should be hidden', () => {
-    const options = clone(mountOptions);
+    const options = createMountOptions();
 
     options.global.mocks.$store.getters.currentCluster.isLocal = true;
 
@@ -241,18 +239,18 @@ describe('page: cluster dashboard', () => {
 
   describe('cluster details', () => {
     it.each([
-      ['clusterProvider', 'other', []],
-      ['kubernetesVersion', 'glance.version', []],
-      ['created', 'glance.created', []],
-      ['architecture', 'mixed', [{ labels: { [NODE_ARCHITECTURE]: 'amd64' } }, { labels: { [NODE_ARCHITECTURE]: 'intel' } }]],
-      ['architecture', 'mixed', [{ labels: { [NODE_ARCHITECTURE]: 'amd64' } }, { labels: { } }]],
-      ['architecture', 'amd64', [{ labels: { [NODE_ARCHITECTURE]: 'amd64' } }]],
-      ['architecture', 'unknown', [{ labels: { } }]],
-      ['architecture', 'glance.architecture', [{ metadata: { state: { transitioning: true } } }]],
-    ])('should show %p label %p', (label, text, nodes) => {
-      const options = clone(mountOptions);
-
-      options.global.mocks.$store.getters['cluster/all'] = () => nodes;
+      ['clusterProvider', 'abc', { provisionerDisplay: 'abc' }],
+      ['kubernetesVersion', 'glance.version', null],
+      ['created', 'glance.created', null],
+      ['architecture', 'mixed', { architecture: { label: 'mixed' } }],
+      ['architecture', 'amd64', { architecture: { label: 'amd64' } }],
+      ['architecture', 'glance.architecture', { architecture: { label: null } }],
+    ])('should show %p label %p', (label, text, mgmtCluster) => {
+      const options = createMountOptions();
+
+      const currentCluster = options.global.mocks.$store.getters['currentCluster'];
+
+      options.global.mocks.$store.getters['currentCluster'] = mgmtCluster ? mergeWithReplace(currentCluster, mgmtCluster) : currentCluster; // eslint-disable-line jest/no-if
 
       const wrapper = shallowMount(Dashboard, options);
 

package/pages/c/_cluster/explorer/index.vue

@@ -17,7 +17,6 @@ import {
   CATALOG,
   SECRET
 } from '@shell/config/types';
-import { NODE_ARCHITECTURE } from '@shell/config/labels-annotations';
 import { setPromiseResult } from '@shell/utils/promise';
 import AlertTable from '@shell/components/AlertTable';
 import { Banner } from '@components/Banner';
@@ -220,51 +219,11 @@ export default {
     },
 
     displayProvider() {
-      const other = 'other';
-
-      let provider = this.currentCluster?.status?.provider || this.currentCluster?.status?.driver.toLowerCase() || other;
-
-      if (provider === 'rke.windows') {
-        provider = 'rkeWindows';
-      }
-
-      if (!this.$store.getters['i18n/exists'](`cluster.provider.${ provider }`)) {
-        provider = 'other';
-      }
-
-      return this.t(`cluster.provider.${ provider }`);
-    },
-
-    nodesArchitecture() {
-      const obj = {};
-
-      this.nodes?.forEach((node) => {
-        if (!node.metadata?.state?.transitioning) {
-          const architecture = node.labels?.[NODE_ARCHITECTURE];
-
-          const key = architecture || this.t('cluster.architecture.label.unknown');
-
-          obj[key] = (obj[key] || 0) + 1;
-        }
-      });
-
-      return obj;
+      return this.currentCluster?.provisionerDisplay;
     },
 
     architecture() {
-      const keys = Object.keys(this.nodesArchitecture);
-
-      switch (keys.length) {
-      case 0:
-        return { label: this.t('generic.provisioning') };
-      case 1:
-        return { label: keys[0] };
-      default:
-        return {
-          label:   this.t('cluster.architecture.label.mixed'),
-          tooltip: keys.reduce((acc, k) => `${ acc }${ k }: ${ this.nodesArchitecture[k] }<br>`, '')
-        };
-      }
+      return this.currentCluster?.architecture;
     },
 
     isHarvesterCluster() {
@@ -395,6 +354,7 @@ export default {
 
     metricAggregations() {
       const metrics = this.nodeMetrics.filter((nodeMetrics) => {
+        // This should use cluster/byId getter
         const node = this.nodes.find((nd) => nd.id === nodeMetrics.id);
 
         return node;
@@ -464,9 +424,6 @@ export default {
         }
       };
     },
-    hasNodes() {
-      return this.nodes?.length > 0;
-    },
     kubernetesVersion() {
       const base = this.currentCluster?.kubernetesVersionBase || '';
       const extension = this.currentCluster?.kubernetesVersionExtension || '';
@@ -584,8 +541,7 @@ export default {
 
     async goToHarvesterCluster() {
       try {
-        const provClusters = await this.$store.dispatch('management/findAll', { type: CAPI.RANCHER_CLUSTER });
-        const provCluster = provClusters.find((p) => p.mgmt.id === this.currentCluster.id);
+        const provCluster = await this.$store.dispatch('management/find', { type: CAPI.RANCHER_CLUSTER, id: this.currentCluster.provClusterId });
 
         await provCluster.goToHarvesterCluster();
       } catch {
@@ -653,7 +609,7 @@ export default {
         <span>{{ kubernetesVersion }}</span>
       </div>
       <div
-        v-if="hasNodes"
+        v-if="architecture"
         data-testid="architecture__label"
       >
         <label>{{ t('glance.architecture') }}: </label>

package/pages/c/_cluster/istio/__tests__/istio.index.test.ts

@@ -0,0 +1,194 @@
+import { nextTick } from 'vue';
+import { shallowMount } from '@vue/test-utils';
+import IstioOverview from '@shell/pages/c/_cluster/istio/index.vue';
+import { SERVICE } from '@shell/config/types';
+import Loading from '@shell/components/Loading';
+
+const createMockService = (name: string, namespace: string, label: string, proxyUrlReturn: string) => ({
+  id:       `${ namespace }/${ name }`,
+  type:     'service',
+  metadata: {
+    name,
+    namespace,
+    labels: { app: label },
+  },
+  proxyUrl: jest.fn(() => proxyUrlReturn),
+});
+
+describe('page: IstioOverview', () => {
+  const createWrapper = (overrides: Record<string, any> = {}) => {
+    const mockDispatch = jest.fn();
+    const mockSchemaFor = jest.fn();
+    const mockResolve = jest.fn(() => ({ href: '/c/_/monitoring' }));
+
+    const defaultMocks = {
+      $fetchState: { pending: false },
+      $store:      {
+        dispatch: mockDispatch,
+        getters:  {
+          'prefs/theme':       'dark',
+          'i18n/t':            (key: string) => key,
+          'cluster/schemaFor': mockSchemaFor,
+        },
+      },
+      $route:  { params: { cluster: '_' } },
+      $router: { resolve: mockResolve },
+    };
+
+    const wrapper = shallowMount(IstioOverview, {
+      global: {
+        mocks:      { ...defaultMocks, ...(overrides.mocks || {}) },
+        directives: { 'clean-html': () => {} },
+        stubs:      { t: true, ...(overrides.stubs || {}) },
+      },
+    });
+
+    return {
+      wrapper, mockDispatch, mockSchemaFor, mockResolve
+    };
+  };
+
+  describe('fetch', () => {
+    it('dispatches findLabelSelector for kiali with correct label selector', async() => {
+      const { wrapper, mockDispatch, mockSchemaFor } = createWrapper();
+
+      mockSchemaFor.mockReturnValue({});
+      mockDispatch.mockResolvedValue({ data: [] });
+
+      await (IstioOverview as any).fetch.call(wrapper.vm);
+
+      expect(mockDispatch).toHaveBeenCalledWith('cluster/findLabelSelector', {
+        type:     SERVICE,
+        matching: { labelSelector: { matchLabels: { app: 'kiali' } } },
+        opt:      { transient: true },
+      });
+    });
+
+    it('dispatches findLabelSelector for jaeger with correct label selector', async() => {
+      const { wrapper, mockDispatch, mockSchemaFor } = createWrapper();
+
+      mockSchemaFor.mockReturnValue({});
+      mockDispatch.mockResolvedValue({ data: [] });
+
+      await (IstioOverview as any).fetch.call(wrapper.vm);
+
+      expect(mockDispatch).toHaveBeenCalledWith('cluster/findLabelSelector', {
+        type:     SERVICE,
+        matching: { labelSelector: { matchLabels: { app: 'jaeger' } } },
+        opt:      { transient: true },
+      });
+    });
+
+    it('sets kialiService and jaegerService from response data', async() => {
+      const mockKiali = createMockService('kiali', 'istio-system', 'kiali', '/proxy/kiali');
+      const mockJaeger = createMockService('jaeger-query', 'istio-system', 'jaeger', '/proxy/jaeger');
+      const { wrapper, mockDispatch, mockSchemaFor } = createWrapper();
+
+      mockSchemaFor.mockReturnValue({});
+      mockDispatch
+        .mockResolvedValueOnce({ data: [mockKiali] })
+        .mockResolvedValueOnce({ data: [mockJaeger] });
+
+      await (IstioOverview as any).fetch.call(wrapper.vm);
+
+      expect(wrapper.vm.kialiService).toStrictEqual(mockKiali);
+      expect(wrapper.vm.jaegerService).toStrictEqual(mockJaeger);
+    });
+
+    it('skips dispatches when schemaFor returns falsy', async() => {
+      const { wrapper, mockDispatch, mockSchemaFor } = createWrapper();
+
+      mockSchemaFor.mockReturnValue(null);
+
+      await (IstioOverview as any).fetch.call(wrapper.vm);
+
+      expect(mockDispatch).not.toHaveBeenCalledWith('cluster/findLabelSelector', expect.anything());
+      expect(wrapper.vm.kialiService).toBeNull();
+      expect(wrapper.vm.jaegerService).toBeNull();
+    });
+
+    it('sets services to null when response data is empty', async() => {
+      const { wrapper, mockDispatch, mockSchemaFor } = createWrapper();
+
+      mockSchemaFor.mockReturnValue({});
+      mockDispatch.mockResolvedValue({ data: [] });
+
+      await (IstioOverview as any).fetch.call(wrapper.vm);
+
+      expect(wrapper.vm.kialiService).toBeNull();
+      expect(wrapper.vm.jaegerService).toBeNull();
+    });
+  });
+
+  describe('computed properties', () => {
+    it('kialiUrl returns null when kialiService is null', () => {
+      const { wrapper } = createWrapper();
+
+      expect(wrapper.vm.kialiUrl).toBeNull();
+    });
+
+    it('kialiUrl calls proxyUrl with correct arguments when service exists', async() => {
+      const mockKiali = createMockService('kiali', 'istio-system', 'kiali', '/proxy/kiali');
+      const { wrapper } = createWrapper();
+
+      wrapper.setData({ kialiService: mockKiali });
+      await nextTick();
+
+      expect(wrapper.vm.kialiUrl).toStrictEqual('/proxy/kiali');
+      expect(mockKiali.proxyUrl).toHaveBeenCalledWith('http', '20001');
+    });
+
+    it('jaegerUrl returns null when jaegerService is null', () => {
+      const { wrapper } = createWrapper();
+
+      expect(wrapper.vm.jaegerUrl).toBeNull();
+    });
+
+    it('jaegerUrl calls proxyUrl with correct arguments and appends /jaeger/search', async() => {
+      const mockJaeger = createMockService('jaeger-query', 'istio-system', 'jaeger', '/proxy/jaeger');
+      const { wrapper } = createWrapper();
+
+      wrapper.setData({ jaegerService: mockJaeger });
+      await nextTick();
+
+      expect(wrapper.vm.jaegerUrl).toStrictEqual('/proxy/jaeger/jaeger/search');
+      expect(mockJaeger.proxyUrl).toHaveBeenCalledWith('http', '16686');
+    });
+  });
+
+  describe('template rendering', () => {
+    it('shows Loading component when fetchState is pending', () => {
+      const { wrapper } = createWrapper({ mocks: { $fetchState: { pending: true } } });
+
+      expect(wrapper.findComponent(Loading).exists()).toBe(true);
+      expect(wrapper.find('.links').exists()).toBe(false);
+    });
+
+    it('shows disabled state when service URLs are null', () => {
+      const { wrapper } = createWrapper();
+      const containers = wrapper.findAll('.link-container');
+
+      expect(containers).toHaveLength(2);
+      containers.forEach((container) => {
+        expect(container.classes()).toContain('disabled');
+      });
+      expect(wrapper.findAll('.disabled-msg')).toHaveLength(2);
+    });
+
+    it('hides disabled state when services are set', async() => {
+      const mockKiali = createMockService('kiali', 'istio-system', 'kiali', '/proxy/kiali');
+      const mockJaeger = createMockService('jaeger-query', 'istio-system', 'jaeger', '/proxy/jaeger');
+      const { wrapper } = createWrapper();
+
+      wrapper.setData({ kialiService: mockKiali, jaegerService: mockJaeger });
+      await nextTick();
+
+      const containers = wrapper.findAll('.link-container');
+
+      containers.forEach((container) => {
+        expect(container.classes()).not.toContain('disabled');
+      });
+      expect(wrapper.findAll('.disabled-msg')).toHaveLength(0);
+    });
+  });
+});

package/pages/c/_cluster/istio/index.vue

@@ -8,12 +8,27 @@ export default {
   components: { Loading },
 
   async fetch() {
-    try {
-      this.kialiService = await this.$store.dispatch('cluster/find', { type: SERVICE, id: 'istio-system/kiali' });
-    } catch {}
-    try {
-      this.jaegerService = await this.$store.dispatch('cluster/find', { type: SERVICE, id: 'istio-system/tracing' });
-    } catch {}
+    if (this.$store.getters['cluster/schemaFor'](SERVICE)) {
+      try {
+        const kialiResponse = await this.$store.dispatch('cluster/findLabelSelector', {
+          type:     SERVICE,
+          matching: { labelSelector: { matchLabels: { app: 'kiali' } } },
+          opt:      { transient: true }
+        });
+
+        this.kialiService = kialiResponse.data?.[0] || null;
+      } catch {}
+
+      try {
+        const jaegerResponse = await this.$store.dispatch('cluster/findLabelSelector', {
+          type:     SERVICE,
+          matching: { labelSelector: { matchLabels: { app: 'jaeger' } } },
+          opt:      { transient: true }
+        });
+
+        this.jaegerService = jaegerResponse.data?.[0] || null;
+      } catch {}
+    }
   },
 
   data() {

package/pages/c/_cluster/manager/drivers/kontainerDriver/index.vue

@@ -1,6 +1,5 @@
 <script>
 import { NORMAN } from '@shell/config/types';
-import { isAdminUser } from '@shell/store/type-map';
 import ResourceTable from '@shell/components/ResourceTable';
 import AsyncButton from '@shell/components/AsyncButton';
 import Loading from '@shell/components/Loading';
@@ -20,18 +19,19 @@ export default {
   data() {
     return {
       allDrivers:                       null,
-      canRefreshK8sMetadata:            true,
       resource:                         NORMAN.KONTAINER_DRIVER,
       schema:                           this.$store.getters['rancher/schemaFor'](NORMAN.KONTAINER_DRIVER),
       useQueryParamsForSimpleFiltering: false,
       forceUpdateLiveAndDelayed:        10,
-      showDeprecationBanner:            isAdminUser(this.$store.getters),
     };
   },
   computed: {
     rows() {
       return this.allDrivers || [];
     },
+    hasEmberUiDrivers() {
+      return this.rows.some((driver) => driver.active && driver.isEmber);
+    },
   },
   methods: {
     async refreshK8sMetadata(buttonDone) {
@@ -63,7 +63,6 @@ export default {
     >
       <template #extraActions>
         <AsyncButton
-          v-if="canRefreshK8sMetadata"
           mode="refresh"
           :action-label="t('drivers.actions.refresh')"
           :waiting-label="t('drivers.actions.refresh')"
@@ -75,10 +74,9 @@ export default {
       </template>
     </Masthead>
     <Banner
-      v-if="showDeprecationBanner"
+      v-if="hasEmberUiDrivers"
       color="warning"
-      label-key="drivers.kontainer.emberDeprecationMessage"
-      data-testid="kontainer-driver-ember-deprecation-banner"
+      label-key="drivers.kontainer.emberRemovalMessage"
     />
     <ResourceTable
       :schema="schema"