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

package/list/utils/management.cattle.io.cluster.utils.ts

@@ -0,0 +1,128 @@
+import MgmtCluster from '@shell/models/management.cattle.io.cluster';
+import { filterHiddenLocalCluster, filterOnlyKubernetesClusters, paginationFilterClusters } from '@shell/utils/cluster';
+import { VuexStore } from '@shell/types/store/vuex';
+import { FilterArgs, PaginationArgs, PaginationFilterEquality, PaginationParamFilter } from '@shell/types/store/pagination.types';
+import { sameContents } from '@shell/utils/array';
+import { PagTableFetchPageSecondaryResourcesOpts, PagTableFetchSecondaryResourcesOpts } from '@shell/types/components/paginatedResourceTable';
+import { CAPI } from '@shell/config/types';
+import { ActionFindPageArgs } from '@shell/types/store/dashboard-store.types';
+
+interface CommonConfig {
+  $store: VuexStore
+}
+
+/**
+ * Utils to support listing management.cattle.io.clusters
+ */
+class ManagementClusterUtils {
+  /**
+     * Filter out hidden clusters from list of all clusters
+     */
+  filterRowsLocal(rows: MgmtCluster[], { $store }: CommonConfig): MgmtCluster[] {
+    return filterHiddenLocalCluster(filterOnlyKubernetesClusters(rows || [], $store), $store);
+  }
+
+  /**
+   * Filter out hidden clusters via api
+   */
+  filterRowsApi(pagination: PaginationArgs, { $store }: CommonConfig): PaginationArgs {
+    if (!pagination.filters) {
+      pagination.filters = [];
+    }
+
+    const existingFilters = pagination.filters;
+    const requiredFilters = paginationFilterClusters($store, false);
+
+    for (let i = 0; i < requiredFilters.length; i++) {
+      let found = false;
+      const required = requiredFilters[i];
+
+      for (let j = 0; j < existingFilters.length; j++) {
+        const existing = existingFilters[j];
+
+        if (
+          required.fields.length === existing.fields.length &&
+            sameContents(required.fields.map((e) => e.field), existing.fields.map((e) => e.field))
+        ) {
+          Object.assign(existing, required);
+          found = true;
+          break;
+        }
+      }
+
+      if (!found) {
+        pagination.filters.push(required);
+      }
+    }
+
+    return pagination;
+  }
+
+  /**
+   * Fetch resources used to support vai off world
+   *
+   * Of type PagTableFetchSecondaryResources
+   */
+  fetchSecondaryResources(opts: PagTableFetchSecondaryResourcesOpts, { $store }: CommonConfig): Promise<any>[] {
+    if (opts.canPaginate) {
+      return [];
+    }
+
+    const promises = [];
+
+    if ( $store.getters['management/canList'](CAPI.RANCHER_CLUSTER) ) {
+      promises.push($store.dispatch('management/findAll', { type: CAPI.RANCHER_CLUSTER }));
+    }
+
+    return promises;
+  }
+
+  /**
+   * Fetch resources used to support vai on and the current page
+   */
+  async fetchPageSecondaryResources({
+    canPaginate, force, page, pagResult
+  }: PagTableFetchPageSecondaryResourcesOpts, { $store }: CommonConfig): Promise<Promise<any>[]> {
+    if (!canPaginate || !page?.length) {
+      return [];
+    }
+
+    const promises = [];
+
+    if ( $store.getters['management/canList'](CAPI.RANCHER_CLUSTER) ) {
+      const opt: ActionFindPageArgs = {
+        force,
+        pagination: new FilterArgs({
+          filters: new PaginationParamFilter({
+            fields: [{
+              value:    page.map((r: any) => r.provClusterId).join(','),
+              equality: PaginationFilterEquality.IN,
+              field:    'id',
+            }],
+          })
+        })
+      };
+
+      // Prov clusters
+      promises.push($store.dispatch(`management/findPage`, { type: CAPI.RANCHER_CLUSTER, opt }));
+    }
+
+    return promises;
+  }
+
+  forgetSecondaryResources({ context }: { context?: string } = {}, { $store }: CommonConfig) {
+    const canList = $store.getters['management/canList'](CAPI.RANCHER_CLUSTER);
+    const canPaginate = $store.getters['management/paginationEnabled']({
+      id: CAPI.RANCHER_CLUSTER,
+      context
+    });
+
+    if (canList && canPaginate) {
+      $store.dispatch('management/forgetType', CAPI.RANCHER_CLUSTER);
+    }
+  }
+}
+
+const instance = new ManagementClusterUtils();
+
+export default instance;

package/mixins/__tests__/chart.test.ts

@@ -214,6 +214,72 @@ describe('chartMixin', () => {
         id:   'custom-ns/custom-name'
       });
     });
+
+    it('should fall back to matchingInstalledApps when version namespace lookup fails', async() => {
+      const installedApp = {
+        id:   'other-ns/custom-name',
+        spec: { chart: { metadata: { version: '0.9.0' } } }
+      };
+
+      const mockStore = {
+        dispatch: jest.fn((action, payload) => {
+          if (action === 'cluster/find') {
+            return Promise.reject(new Error('not found'));
+          }
+
+          return Promise.resolve();
+        }),
+        getters: {
+          currentCluster: () => {},
+          isRancher:      () => true,
+          'catalog/repo': () => {
+            return () => 'repo';
+          },
+          'catalog/chart': () => {
+            return {
+              id:                    'chart-id',
+              versions:              [{ version: '1.0.0' }],
+              matchingInstalledApps: [installedApp]
+            };
+          },
+          'catalog/version': () => ({
+            version:     '1.0.0',
+            annotations: {
+              [CATALOG_ANNOTATIONS.NAMESPACE]:    'custom-ns',
+              [CATALOG_ANNOTATIONS.RELEASE_NAME]: 'custom-name',
+            }
+          }),
+          'prefs/get': () => {},
+          'i18n/t':    () => jest.fn()
+        }
+      };
+
+      const DummyComponent = {
+        mixins:   [ChartMixin],
+        template: '<div></div>',
+      };
+
+      const wrapper = mount(
+        DummyComponent,
+        {
+          global: {
+            mocks: {
+              $store: mockStore,
+              $route: {
+                query: {
+                  chart:       'chart_name',
+                  versionName: '1.0.0'
+                }
+              }
+            }
+          }
+        });
+
+      await wrapper.vm.fetchChart();
+
+      expect(wrapper.vm.existing).toStrictEqual(installedApp);
+      expect(wrapper.vm.mode).toStrictEqual('edit');
+    });
   });
 
   describe('action', () => {
@@ -366,6 +432,52 @@ describe('chartMixin', () => {
     });
   });
 
+  describe('isChartTargeted', () => {
+    const DummyComponent = {
+      mixins:   [ChartMixin],
+      template: '<div></div>',
+    };
+
+    const mockStore = {
+      dispatch: jest.fn(() => Promise.resolve()),
+      getters:  { 'i18n/t': (key: string) => key }
+    };
+
+    it('should return truthy when version annotations have both namespace and release-name', () => {
+      const wrapper = mount(DummyComponent, {
+        data: () => ({
+          version: {
+            annotations: {
+              [CATALOG_ANNOTATIONS.NAMESPACE]:    'custom-ns',
+              [CATALOG_ANNOTATIONS.RELEASE_NAME]: 'custom-name',
+            }
+          }
+        }),
+        global: { mocks: { $store: mockStore } }
+      });
+
+      expect(wrapper.vm.isChartTargeted).toBeTruthy();
+    });
+
+    it('should return falsy when version annotations are missing', () => {
+      const wrapper = mount(DummyComponent, {
+        data:   () => ({ version: { annotations: {} } }),
+        global: { mocks: { $store: mockStore } }
+      });
+
+      expect(wrapper.vm.isChartTargeted).toBeFalsy();
+    });
+
+    it('should return falsy when version is null', () => {
+      const wrapper = mount(DummyComponent, {
+        data:   () => ({ version: null }),
+        global: { mocks: { $store: mockStore } }
+      });
+
+      expect(wrapper.vm.isChartTargeted).toBeFalsy();
+    });
+  });
+
   describe('mappedVersions', () => {
     it('should return versions sorted by semver (descending)', () => {
       const versions = [

package/mixins/brand.js

@@ -183,7 +183,8 @@ export default {
     },
     setBodyClass() {
       const body = document.getElementsByTagName('body')[0];
-      const cssClass = `overflow-hidden dashboard-body`;
+      const isStandalone = this.$route?.meta?.standalone;
+      const cssClass = isStandalone ? 'dashboard-body' : 'overflow-hidden dashboard-body';
       let bodyClass = `theme-${ this.theme } ${ cssClass }`;
 
       if ( this.brand ) {

package/mixins/chart.js

@@ -13,7 +13,7 @@ import { CAPI, CATALOG } from '@shell/config/types';
 import { isPrerelease } from '@shell/utils/version';
 import { compareChartVersions } from '@shell/utils/chart';
 import difference from 'lodash/difference';
-import { LINUX, APP_UPGRADE_STATUS } from '@shell/store/catalog';
+import { APP_UPGRADE_STATUS, isRancherRepo, getPermittedOSs } from '@shell/store/catalog';
 import { clone } from '@shell/utils/object';
 import { merge } from 'lodash';
 
@@ -84,7 +84,8 @@ export default {
           keywords:        version.keywords
         };
 
-        const permittedSystems = (version?.annotations?.[CATALOG_ANNOTATIONS.PERMITTED_OS] || LINUX).split(',');
+        const isRancher = isRancherRepo(this.repo, this.chart);
+        const permittedSystems = getPermittedOSs(version?.annotations, isRancher);
 
         if (permittedSystems.length > 0 && difference(OSs, permittedSystems).length > 0) {
           nue.disabled = true;
@@ -271,7 +272,7 @@ export default {
     },
 
     isChartTargeted() {
-      return this.chart?.targetNamespace && this.chart?.targetName;
+      return this.version?.annotations?.[CATALOG_ANNOTATIONS.NAMESPACE] && this.version?.annotations?.[CATALOG_ANNOTATIONS.RELEASE_NAME];
     },
 
     hasQuestions() {
@@ -386,8 +387,8 @@ export default {
         // Use those values to check for a catalog app resource.
         // If found, set the form to edit mode. If not, set the
         // form to create mode.
-        // This is a hard blocker - installing a new instance is NOT allowed.
 
+        // This is a hard blocker - installing a new instance is NOT allowed.
         this.canInstallNew = false;
 
         try {
@@ -410,11 +411,10 @@ export default {
         if ( targetNamespace && targetName ) {
           // If the app name and namespace values are not provided in the
           // query, fall back on target values defined in the Helm chart itself.
-
           // Ask to install a special chart with fixed namespace/name
           // or edit it if there's an existing install.
-          // This is a hard blocker - installing a new instance is NOT allowed.
 
+          // This is a hard blocker - installing a new instance is NOT allowed.
           this.canInstallNew = false;
 
           try {
@@ -424,8 +424,12 @@ export default {
             });
             this.mode = _EDIT;
           } catch (e) {
-            this.mode = _CREATE;
-            this.existing = null;
+            // Version targets a different namespace than where the app is installed.
+            // Fall back to matching installed apps (e.g. chart detail page).
+            const matching = this.chart?.matchingInstalledApps || [];
+
+            this.existing = matching[0] || null;
+            this.mode = this.existing ? _EDIT : _CREATE;
           }
         } else {
           // Regular chart (not targeted) - check if there are installed instances.

package/mixins/resource-fetch-api-pagination.js

@@ -1,5 +1,5 @@
 import { NAMESPACE_FILTER_NAMESPACED_YES, NAMESPACE_FILTER_NAMESPACED_NO, NAMESPACE_FILTER_ALL } from '@shell/utils/namespace-filter';
-import { NAMESPACE } from '@shell/config/types';
+import { MANAGEMENT, NAMESPACE } from '@shell/config/types';
 import { ALL_NAMESPACES } from '@shell/store/prefs';
 import { mapGetters } from 'vuex';
 import { ResourceListComponentName } from '../components/ResourceList/resource-list.config';
@@ -248,7 +248,7 @@ export default {
     namespaceFilters: {
       immediate: true,
       async handler(neu, old) {
-        if (!this.canPaginate || !this.isNamespaced) {
+        if (!this.canPaginate || !this.isNamespaced || !this.currentProduct?.showNamespaceFilter) {
           return;
         }
 
@@ -283,7 +283,7 @@ export default {
           allNamespaces:                 this.$store.getters[`${ this.currentProduct?.inStore }/all`](NAMESPACE),
           selection:                     neu,
           isAllNamespaces:               this.isAllNamespaces,
-          isLocalCluster:                this.$store.getters['currentCluster'].isLocal,
+          isLocalCluster:                this.$store.getters['currentCluster']?.isLocal,
           showReservedRancherNamespaces: this.showDynamicRancherNamespaces,
           productHidesSystemNamespaces:  this.productHidesSystemNamespaces,
         });
@@ -354,15 +354,51 @@ export default {
 
   async beforeUnmount() {
     if (this.havePaginated) {
+      const store = this.overrideInStore || this.inStore;
       // of type @STEVE_WATCH_PARAMS
       const watchArgs = {
         type: this.resource,
         mode: STEVE_WATCH_MODE.RESOURCE_CHANGES,
       };
 
-      await this.$store.dispatch(`${ this.overrideInStore || this.inStore }/forgetType`, this.resource, (watchParams) => {
-        return watchParams.type === watchArgs.type && watchParams.mode === watchArgs.type.mode;
+      // Ensure that a resource remains in the store... and it's the same reference as before
+      // We'll do this for the mgmt cluster if there's a currentCluster set, otherwise we become unstuck
+      // (on nav we ensure currentCluster exists, but beforeUnmount fires afterwards, removing the cluster from pages that are using it)
+      const retainResource = this.resource === MANAGEMENT.CLUSTER && this.currentCluster ? this.currentCluster : null;
+
+      // Forget (unwatch, clear from store) the list's resource
+      await this.$store.dispatch(`${ store }/forgetType`, {
+        type:           this.resource,
+        compareWatches: (watchParams) => {
+          return watchParams.type === watchArgs.type && watchParams.mode === watchArgs.mode;
+        },
+        unwatch: true,
+        forget:  !retainResource
       });
+
+      if (!!retainResource) {
+        // The end state should be just like we've dispatched `${store}/find`
+
+        try {
+          // Clone to ensure we can load each property of A into B without worrying about them being the same reference
+          const clone = await this.$store.dispatch(`${ store }/clone`, { resource: retainResource });
+
+          // Load the resource. It's already in the store but this makes sure any legacy state (like havePage) is reset
+          await this.$store.dispatch(`${ store }/load`, {
+            data:                clone,
+            existing:            retainResource,
+            invalidatePageCache: true,
+          });
+
+          // Watch the resource.
+          await this.$store.dispatch(`${ store }/watch`, {
+            type: this.resource,
+            id:   retainResource.id,
+          });
+        } catch (error) {
+          console.error('Error occurred whilst trying to retain the management cluster in cache and correctly watched', error); // eslint-disable-line no-console
+        }
+      }
     }
   }
 };

package/models/__tests__/ext.cattle.io.kubeconfig.test.ts

@@ -1,5 +1,5 @@
 import Kubeconfig from '@shell/models/ext.cattle.io.kubeconfig';
-import { CAPI, MANAGEMENT } from '@shell/config/types';
+import { MANAGEMENT } from '@shell/config/types';
 
 // SteveModel is JS, so we need to type the constructor
 const KubeconfigModel = Kubeconfig as unknown as new (data: object) => Kubeconfig;
@@ -19,8 +19,9 @@ describe('class Kubeconfig', () => {
     // Mock $rootGetters before any getters are accessed
     // Cast to any since $rootGetters is inherited from JS SteveModel
     jest.spyOn(kubeconfig as any, '$rootGetters', 'get').mockReturnValue({
-      'i18n/t':         mockT,
-      'management/all': () => [],
+      'i18n/t':          mockT,
+      'management/all':  () => [],
+      'management/byId': () => null,
       ...rootGetters
     });
 
@@ -70,11 +71,12 @@ describe('class Kubeconfig', () => {
   });
 
   describe('referencedClusters', () => {
-    const mockProvCluster = {
-      mgmt:           { id: 'c-m-abc123' },
-      status:         { clusterName: 'c-m-abc123' },
-      nameDisplay:    'my-cluster',
-      detailLocation: { name: 'c-cluster-product-resource-id', params: { cluster: 'my-cluster' } }
+    const mockProvCluster = { detailLocation: { name: 'c-cluster-product-resource-id', params: { cluster: 'my-cluster' } } };
+
+    const mockMgmtClusterWithProv = {
+      id:          'c-m-abc123',
+      nameDisplay: 'my-cluster',
+      provCluster: mockProvCluster
     };
 
     const mockMgmtCluster = {
@@ -99,12 +101,12 @@ describe('class Kubeconfig', () => {
           spec:     { clusters: ['c-m-abc123'] }
         },
         {
-          'management/all': (type: string) => {
-            if (type === CAPI.RANCHER_CLUSTER) {
-              return [mockProvCluster];
+          'management/byId': (type: string, id: string) => {
+            if (type === MANAGEMENT.CLUSTER && id === 'c-m-abc123') {
+              return mockMgmtClusterWithProv;
             }
 
-            return [];
+            return null;
           }
         }
       );
@@ -124,12 +126,12 @@ describe('class Kubeconfig', () => {
           spec:     { clusters: ['c-m-def456'] }
         },
         {
-          'management/all': (type: string) => {
-            if (type === MANAGEMENT.CLUSTER) {
-              return [mockMgmtCluster];
+          'management/byId': (type: string, id: string) => {
+            if (type === MANAGEMENT.CLUSTER && id === 'c-m-def456') {
+              return mockMgmtCluster;
             }
 
-            return [];
+            return null;
           }
         }
       );
@@ -157,11 +159,12 @@ describe('class Kubeconfig', () => {
       expect(mockT).toHaveBeenCalledWith('"ext.cattle.io.kubeconfig".deleted', { name: 'c-m-deleted' });
     });
 
-    it('should prefer provisioning cluster over management cluster', () => {
-      const mgmtClusterSameId = {
+    it('should prefer provisioning cluster over management cluster for location', () => {
+      const mgmtClusterBothLocs = {
         id:             'c-m-abc123',
-        nameDisplay:    'mgmt-version',
-        detailLocation: { name: 'mgmt-location' }
+        nameDisplay:    'my-cluster',
+        detailLocation: { name: 'mgmt-location' },
+        provCluster:    { detailLocation: { name: 'prov-location' } }
       };
 
       const kubeconfig = createKubeconfig(
@@ -170,15 +173,12 @@ describe('class Kubeconfig', () => {
           spec:     { clusters: ['c-m-abc123'] }
         },
         {
-          'management/all': (type: string) => {
-            if (type === CAPI.RANCHER_CLUSTER) {
-              return [mockProvCluster];
-            }
-            if (type === MANAGEMENT.CLUSTER) {
-              return [mgmtClusterSameId];
+          'management/byId': (type: string, id: string) => {
+            if (type === MANAGEMENT.CLUSTER && id === 'c-m-abc123') {
+              return mgmtClusterBothLocs;
             }
 
-            return [];
+            return null;
           }
         }
       );
@@ -186,7 +186,7 @@ describe('class Kubeconfig', () => {
       expect(kubeconfig.referencedClusters).toStrictEqual([
         {
           label:    'my-cluster',
-          location: mockProvCluster.detailLocation
+          location: { name: 'prov-location' }
         }
       ]);
     });
@@ -195,7 +195,7 @@ describe('class Kubeconfig', () => {
   describe('sortedReferencedClusters', () => {
     it('should sort existing clusters before deleted clusters', () => {
       const existingCluster = {
-        mgmt:           { id: 'c-m-exists' },
+        id:             'c-m-exists',
         nameDisplay:    'existing-cluster',
         detailLocation: { name: 'location' }
       };
@@ -206,12 +206,12 @@ describe('class Kubeconfig', () => {
           spec:     { clusters: ['deleted-1', 'c-m-exists', 'deleted-2'] }
         },
         {
-          'management/all': (type: string) => {
-            if (type === CAPI.RANCHER_CLUSTER) {
-              return [existingCluster];
+          'management/byId': (type: string, id: string) => {
+            if (type === MANAGEMENT.CLUSTER && id === 'c-m-exists') {
+              return existingCluster;
             }
 
-            return [];
+            return null;
           }
         }
       );
@@ -225,17 +225,17 @@ describe('class Kubeconfig', () => {
     });
 
     it('should sort existing clusters alphabetically', () => {
-      const clusters = [
-        {
-          mgmt: { id: 'c-m-zebra' }, nameDisplay: 'zebra', detailLocation: { name: 'z' }
+      const clusters: Record<string, any> = {
+        'c-m-zebra': {
+          id: 'c-m-zebra', nameDisplay: 'zebra', detailLocation: { name: 'z' }
         },
-        {
-          mgmt: { id: 'c-m-alpha' }, nameDisplay: 'alpha', detailLocation: { name: 'a' }
+        'c-m-alpha': {
+          id: 'c-m-alpha', nameDisplay: 'alpha', detailLocation: { name: 'a' }
         },
-        {
-          mgmt: { id: 'c-m-beta' }, nameDisplay: 'beta', detailLocation: { name: 'b' }
+        'c-m-beta': {
+          id: 'c-m-beta', nameDisplay: 'beta', detailLocation: { name: 'b' }
         }
-      ];
+      };
 
       const kubeconfig = createKubeconfig(
         {
@@ -243,12 +243,12 @@ describe('class Kubeconfig', () => {
           spec:     { clusters: ['c-m-zebra', 'c-m-alpha', 'c-m-beta'] }
         },
         {
-          'management/all': (type: string) => {
-            if (type === CAPI.RANCHER_CLUSTER) {
-              return clusters;
+          'management/byId': (type: string, id: string) => {
+            if (type === MANAGEMENT.CLUSTER) {
+              return clusters[id] || null;
             }
 
-            return [];
+            return null;
           }
         }
       );
@@ -259,17 +259,17 @@ describe('class Kubeconfig', () => {
     });
 
     it('should sort numerically when names contain numbers', () => {
-      const clusters = [
-        {
-          mgmt: { id: 'c-m-2' }, nameDisplay: 'cluster2', detailLocation: { name: 'c2' }
+      const clusters: Record<string, any> = {
+        'c-m-2': {
+          id: 'c-m-2', nameDisplay: 'cluster2', detailLocation: { name: 'c2' }
         },
-        {
-          mgmt: { id: 'c-m-10' }, nameDisplay: 'cluster10', detailLocation: { name: 'c10' }
+        'c-m-10': {
+          id: 'c-m-10', nameDisplay: 'cluster10', detailLocation: { name: 'c10' }
         },
-        {
-          mgmt: { id: 'c-m-1' }, nameDisplay: 'cluster1', detailLocation: { name: 'c1' }
+        'c-m-1': {
+          id: 'c-m-1', nameDisplay: 'cluster1', detailLocation: { name: 'c1' }
         }
-      ];
+      };
 
       const kubeconfig = createKubeconfig(
         {
@@ -277,12 +277,12 @@ describe('class Kubeconfig', () => {
           spec:     { clusters: ['c-m-2', 'c-m-10', 'c-m-1'] }
         },
         {
-          'management/all': (type: string) => {
-            if (type === CAPI.RANCHER_CLUSTER) {
-              return clusters;
+          'management/byId': (type: string, id: string) => {
+            if (type === MANAGEMENT.CLUSTER) {
+              return clusters[id] || null;
             }
 
-            return [];
+            return null;
           }
         }
       );
@@ -295,14 +295,14 @@ describe('class Kubeconfig', () => {
 
   describe('referencedClustersSortable', () => {
     it('should return comma-separated lowercase labels', () => {
-      const clusters = [
-        {
-          mgmt: { id: 'c-m-1' }, nameDisplay: 'Alpha', detailLocation: { name: 'a' }
+      const clusters: Record<string, any> = {
+        'c-m-1': {
+          id: 'c-m-1', nameDisplay: 'Alpha', detailLocation: { name: 'a' }
         },
-        {
-          mgmt: { id: 'c-m-2' }, nameDisplay: 'Beta', detailLocation: { name: 'b' }
+        'c-m-2': {
+          id: 'c-m-2', nameDisplay: 'Beta', detailLocation: { name: 'b' }
         }
-      ];
+      };
 
       const kubeconfig = createKubeconfig(
         {
@@ -310,12 +310,12 @@ describe('class Kubeconfig', () => {
           spec:     { clusters: ['c-m-1', 'c-m-2'] }
         },
         {
-          'management/all': (type: string) => {
-            if (type === CAPI.RANCHER_CLUSTER) {
-              return clusters;
+          'management/byId': (type: string, id: string) => {
+            if (type === MANAGEMENT.CLUSTER) {
+              return clusters[id] || null;
             }
 
-            return [];
+            return null;
           }
         }
       );

package/models/__tests__/management.cattle.io.cluster.test.ts

@@ -7,7 +7,7 @@ jest.mock('@shell/utils/clipboard', () => {
 describe('class MgmtCluster', () => {
   describe('provisioner', () => {
     const testCases = [
-      [{ provider: 'rke', driver: 'imported' }, 'imported'],
+      [{ provider: 'rke2', driver: 'imported' }, 'rke2'],
       [{ provider: 'k3s', driver: 'K3S' }, 'K3S'],
       [{ provider: 'aks', driver: 'AKS' }, 'AKS'],
       [{}, 'imported'],