@rancher/shell 3.0.9-rc.2 → 3.0.9-rc.4

package/list/ext.cattle.io.kubeconfig.vue

@@ -0,0 +1,118 @@
+<script setup lang="ts">
+import { computed } from 'vue';
+import { useStore } from 'vuex';
+import PaginatedResourceTable from '@shell/components/PaginatedResourceTable.vue';
+import { CAPI, MANAGEMENT } from '@shell/config/types';
+import { ActionFindPageArgs } from '@shell/types/store/dashboard-store.types';
+import { FilterArgs, PaginationFilterField, PaginationParamFilter } from '@shell/types/store/pagination.types';
+import { PagTableFetchPageSecondaryResourcesOpts, PagTableFetchSecondaryResourcesOpts, PagTableFetchSecondaryResourcesReturns } from '@shell/types/components/paginatedResourceTable';
+
+defineProps({
+  schema: {
+    type:     Object,
+    required: true
+  },
+
+  useQueryParamsForSimpleFiltering: {
+    type:    Boolean,
+    default: false
+  }
+});
+
+const store = useStore();
+
+const canViewProvClusters = computed<boolean>(() => {
+  return !!store.getters['management/canList'](CAPI.RANCHER_CLUSTER);
+});
+
+const canViewMgmtClusters = computed<boolean>(() => {
+  return !!store.getters['management/canList'](MANAGEMENT.CLUSTER);
+});
+
+/**
+ * Fetch all clusters when not using pagination
+ */
+async function fetchSecondaryResources({ canPaginate }: PagTableFetchSecondaryResourcesOpts): PagTableFetchSecondaryResourcesReturns {
+  if (canPaginate) {
+    return;
+  }
+
+  const promises = [];
+
+  if (canViewProvClusters.value) {
+    promises.push(store.dispatch('management/findAll', { type: CAPI.RANCHER_CLUSTER }));
+  }
+
+  if (canViewMgmtClusters.value) {
+    promises.push(store.dispatch('management/findAll', { type: MANAGEMENT.CLUSTER }));
+  }
+
+  await Promise.all(promises);
+}
+
+/**
+ * Fetch only the clusters referenced by kubeconfigs on the current page
+ *
+ * NOTE: For the time being this isn't validated because ext.cattle.io.kubeconfig is not one of the indexed resources. I'm putting this in for future support since secondary resources are needed.
+ */
+async function fetchPageSecondaryResources({ force, page }: PagTableFetchPageSecondaryResourcesOpts) {
+  if (!page?.length) {
+    return;
+  }
+
+  const uniqueClusterIds = new Set<string>();
+
+  page.forEach((kubeconfig: any) => {
+    const ids = kubeconfig.spec?.clusters || [];
+
+    ids.forEach((id: string) => uniqueClusterIds.add(id));
+  });
+
+  if (uniqueClusterIds.size === 0) {
+    return;
+  }
+
+  const clusterIdArray = Array.from(uniqueClusterIds);
+
+  if (canViewProvClusters.value) {
+    const opt: ActionFindPageArgs = {
+      force,
+      pagination: new FilterArgs({
+        filters: PaginationParamFilter.createMultipleFields(
+          clusterIdArray.map((id) => new PaginationFilterField({
+            field: 'status.clusterName', // Verified it's one of the attribute fields listed in the schema, according to steve-pagination-utils that means it should be filterable
+            value: id
+          }))
+        )
+      })
+    };
+
+    store.dispatch('management/findPage', { type: CAPI.RANCHER_CLUSTER, opt });
+  }
+
+  if (canViewMgmtClusters.value) {
+    const opt: ActionFindPageArgs = {
+      force,
+      pagination: new FilterArgs({
+        filters: PaginationParamFilter.createMultipleFields(
+          clusterIdArray.map((id) => new PaginationFilterField({
+            field: 'metadata.name', // Verified it's one of the attribute fields listed in the schema, according to steve-pagination-utils that means it should be filterable
+            value: id
+          }))
+        )
+      })
+    };
+
+    store.dispatch('management/findPage', { type: MANAGEMENT.CLUSTER, opt });
+  }
+}
+</script>
+
+<template>
+  <PaginatedResourceTable
+    :schema="schema"
+    :use-query-params-for-simple-filtering="useQueryParamsForSimpleFiltering"
+    :fetch-secondary-resources="fetchSecondaryResources"
+    :fetch-page-secondary-resources="fetchPageSecondaryResources"
+  />
+</template>

package/mixins/__tests__/chart.test.ts

@@ -322,5 +322,152 @@ describe('chartMixin', () => {
         icon: 'icon-upgrade-alt',
       });
     });
+
+    it('should return "upgrade" action when upgrading from a pre-release to a stable version with "up" build metadata', () => {
+      const wrapper = mount(DummyComponent, {
+        data: () => ({
+          existing: { spec: { chart: { metadata: { version: '108.0.0+up0.25.0-rc.4' } } } },
+          version:  { version: '108.0.0+up0.25.0' }
+        }),
+        global: {
+          mocks: {
+            $store: mockStore,
+            $route: { query: {} }
+          }
+        }
+      });
+
+      expect(wrapper.vm.action).toStrictEqual({
+        name: 'upgrade',
+        tKey: 'upgrade',
+        icon: 'icon-upgrade-alt',
+      });
+    });
+
+    it('should return "upgrade" action when upgrading with build metadata change', () => {
+      const wrapper = mount(DummyComponent, {
+        data: () => ({
+          existing: { spec: { chart: { metadata: { version: '1.0.0+1' } } } },
+          version:  { version: '1.0.0+2' }
+        }),
+        global: {
+          mocks: {
+            $store: mockStore,
+            $route: { query: {} }
+          }
+        }
+      });
+
+      expect(wrapper.vm.action).toStrictEqual({
+        name: 'upgrade',
+        tKey: 'upgrade',
+        icon: 'icon-upgrade-alt',
+      });
+    });
+  });
+
+  describe('mappedVersions', () => {
+    it('should return versions sorted by semver (descending)', () => {
+      const versions = [
+        { version: '0.1.0', created: '2026-01-01' },
+        { version: '0.2.0-rc1', created: '2026-01-01' },
+        { version: '0.2.0', created: '2026-01-01' },
+        { version: '1.2.3', created: '2026-01-01' },
+        { version: '1.2.3-dev', created: '2026-01-01' },
+        { version: '10.0.0', created: '2026-01-01' },
+        { version: '2.0.0', created: '2026-01-01' },
+        { version: '2.0.0-rc2', created: '2026-01-01' },
+        { version: '2.0.0-rc1', created: '2026-01-01' },
+        { version: '2.0.0-beta.1', created: '2026-01-01' },
+        { version: '2.0.0-alpha', created: '2026-01-01' },
+        { version: '3.0.0-rc.3', created: '2026-01-01' },
+        { version: '3.0.0-rc.2', created: '2026-01-01' },
+        { version: '3.0.0-rc.10', created: '2026-01-01' },
+        { version: '108.0.0+up0.25.0-rc.4', created: '2026-01-01' },
+        { version: '108.0.0+up0.25.0', created: '2026-01-01' },
+        { version: '1.0.0-alpha.beta', created: '2026-01-01' },
+        { version: '1.0.0-alpha.1', created: '2026-01-01' },
+        { version: '1.0.0-alpha.2', created: '2026-01-01' },
+        { version: '1.0.0-alpha', created: '2026-01-01' },
+        { version: '1.0.0-beta.11', created: '2026-01-01' },
+        { version: '1.0.0-beta.2', created: '2026-01-01' },
+        { version: '1.0.0-beta', created: '2026-01-01' },
+        { version: '1.0.0+build.1', created: '2026-01-01' },
+        { version: '1.0.0+build.2', created: '2026-01-01' },
+        { version: '1.0.0+up1.0.0', created: '2026-01-01' },
+        { version: '1.0.0+upFoo', created: '2026-01-01' },
+        { version: '108.0.0+up0.25.0-rc.5', created: '2026-01-01' },
+        { version: '108.0.0+up0.25.1', created: '2026-01-01' },
+        { version: '0.0.1', created: '2026-01-01' }
+      ];
+
+      const mockStore = {
+        dispatch: jest.fn(() => Promise.resolve()),
+        getters:  {
+          currentCluster:  () => {},
+          isRancher:       () => true,
+          'catalog/repo':  () => () => 'repo',
+          'catalog/chart': () => ({ versions }),
+          'prefs/get':     () => (key: string) => true,
+          'i18n/t':        () => jest.fn()
+        }
+      };
+
+      const DummyComponent = {
+        mixins:   [ChartMixin],
+        template: '<div></div>',
+      };
+
+      const wrapper = mount(
+        DummyComponent,
+        {
+          data() {
+            return { chart: { versions } };
+          },
+          global: {
+            mocks: {
+              $store: mockStore,
+              $route: { query: { version: '10.0.0' } }
+            }
+          }
+        });
+
+      // mappedVersions is a computed property, so we access it directly
+      const result = wrapper.vm.mappedVersions;
+      const resultVersions = result.map((v: any) => v.version);
+
+      expect(resultVersions).toStrictEqual([
+        '108.0.0+up0.25.1',
+        '108.0.0+up0.25.0',
+        '108.0.0+up0.25.0-rc.5',
+        '108.0.0+up0.25.0-rc.4',
+        '10.0.0',
+        '3.0.0-rc.10',
+        '3.0.0-rc.3',
+        '3.0.0-rc.2',
+        '2.0.0',
+        '2.0.0-rc2',
+        '2.0.0-rc1',
+        '2.0.0-beta.1',
+        '2.0.0-alpha',
+        '1.2.3',
+        '1.2.3-dev',
+        '1.0.0+up1.0.0',
+        '1.0.0+upFoo',
+        '1.0.0+build.2',
+        '1.0.0+build.1',
+        '1.0.0-beta.11',
+        '1.0.0-beta.2',
+        '1.0.0-beta',
+        '1.0.0-alpha.beta',
+        '1.0.0-alpha.2',
+        '1.0.0-alpha.1',
+        '1.0.0-alpha',
+        '0.2.0',
+        '0.2.0-rc1',
+        '0.1.0',
+        '0.0.1'
+      ]);
+    });
   });
 });

package/mixins/chart.js

@@ -10,7 +10,8 @@ import { NAME as MANAGER } from '@shell/config/product/manager';
 import { OPA_GATE_KEEPER_ID } from '@shell/pages/c/_cluster/gatekeeper/index.vue';
 import { formatSi, parseSi } from '@shell/utils/units';
 import { CAPI, CATALOG } from '@shell/config/types';
-import { isPrerelease, compare, isUpgradeFromPreToStable } from '@shell/utils/version';
+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 { clone } from '@shell/utils/object';
@@ -51,7 +52,12 @@ export default {
     },
 
     mappedVersions() {
-      const versions = this.chart?.versions || [];
+      const versions = (this.chart?.versions || []).slice();
+
+      versions.sort((a, b) => {
+        return compareChartVersions(b.version, a.version);
+      });
+
       const selectedVersion = this.targetVersion;
       const OSs = this.currentCluster?.workerOSs;
       const out = [];
@@ -240,13 +246,9 @@ export default {
         };
       }
 
-      if (isUpgradeFromPreToStable(this.currentVersion, this.targetVersion)) {
-        return {
-          name: 'upgrade', tKey: 'upgrade', icon: 'icon-upgrade-alt'
-        };
-      }
+      const diff = compareChartVersions(this.currentVersion, this.targetVersion);
 
-      if (compare(this.currentVersion, this.targetVersion) < 0) {
+      if (diff < 0) {
         return {
           name: 'upgrade', tKey: 'upgrade', icon: 'icon-upgrade-alt'
         };

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

@@ -0,0 +1,364 @@
+import Kubeconfig from '@shell/models/ext.cattle.io.kubeconfig';
+import { CAPI, 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;
+
+describe('class Kubeconfig', () => {
+  const mockT = jest.fn((key: string, opts?: { name: string }) => {
+    if (key === '"ext.cattle.io.kubeconfig".deleted') {
+      return `${ opts?.name } (deleted)`;
+    }
+
+    return key;
+  });
+
+  const createKubeconfig = (data: object, rootGetters: object = {}) => {
+    const kubeconfig = new KubeconfigModel(data);
+
+    // 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': () => [],
+      ...rootGetters
+    });
+
+    return kubeconfig;
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('expiresAt', () => {
+    it('should return null when ttl is not set', () => {
+      const kubeconfig = createKubeconfig({
+        metadata: { creationTimestamp: '2024-01-01T00:00:00Z' },
+        spec:     {}
+      });
+
+      expect(kubeconfig.expiresAt).toBeNull();
+    });
+
+    it('should return null when creationTimestamp is not set', () => {
+      const kubeconfig = createKubeconfig({
+        metadata: {},
+        spec:     { ttl: 3600 }
+      });
+
+      expect(kubeconfig.expiresAt).toBeNull();
+    });
+
+    it('should calculate expiry correctly', () => {
+      const kubeconfig = createKubeconfig({
+        metadata: { creationTimestamp: '2024-01-01T00:00:00Z' },
+        spec:     { ttl: 3600 } // 1 hour in seconds
+      });
+
+      expect(kubeconfig.expiresAt).toBe('2024-01-01T01:00:00.000Z');
+    });
+
+    it('should handle large ttl values', () => {
+      const kubeconfig = createKubeconfig({
+        metadata: { creationTimestamp: '2024-01-01T00:00:00Z' },
+        spec:     { ttl: 86400 } // 24 hours in seconds
+      });
+
+      expect(kubeconfig.expiresAt).toBe('2024-01-02T00:00:00.000Z');
+    });
+  });
+
+  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 mockMgmtCluster = {
+      id:             'c-m-def456',
+      nameDisplay:    'mgmt-cluster',
+      detailLocation: { name: 'c-cluster-product-resource-id', params: { cluster: 'mgmt-cluster' } }
+    };
+
+    it('should return empty array when no clusters are specified', () => {
+      const kubeconfig = createKubeconfig({
+        metadata: {},
+        spec:     {}
+      });
+
+      expect(kubeconfig.referencedClusters).toStrictEqual([]);
+    });
+
+    it('should map provisioning cluster by mgmt id', () => {
+      const kubeconfig = createKubeconfig(
+        {
+          metadata: {},
+          spec:     { clusters: ['c-m-abc123'] }
+        },
+        {
+          'management/all': (type: string) => {
+            if (type === CAPI.RANCHER_CLUSTER) {
+              return [mockProvCluster];
+            }
+
+            return [];
+          }
+        }
+      );
+
+      expect(kubeconfig.referencedClusters).toStrictEqual([
+        {
+          label:    'my-cluster',
+          location: mockProvCluster.detailLocation
+        }
+      ]);
+    });
+
+    it('should map management cluster when no provisioning cluster found', () => {
+      const kubeconfig = createKubeconfig(
+        {
+          metadata: {},
+          spec:     { clusters: ['c-m-def456'] }
+        },
+        {
+          'management/all': (type: string) => {
+            if (type === MANAGEMENT.CLUSTER) {
+              return [mockMgmtCluster];
+            }
+
+            return [];
+          }
+        }
+      );
+
+      expect(kubeconfig.referencedClusters).toStrictEqual([
+        {
+          label:    'mgmt-cluster',
+          location: mockMgmtCluster.detailLocation
+        }
+      ]);
+    });
+
+    it('should return deleted label when cluster not found', () => {
+      const kubeconfig = createKubeconfig({
+        metadata: {},
+        spec:     { clusters: ['c-m-deleted'] }
+      });
+
+      expect(kubeconfig.referencedClusters).toStrictEqual([
+        {
+          label:    'c-m-deleted (deleted)',
+          location: null
+        }
+      ]);
+      expect(mockT).toHaveBeenCalledWith('"ext.cattle.io.kubeconfig".deleted', { name: 'c-m-deleted' });
+    });
+
+    it('should prefer provisioning cluster over management cluster', () => {
+      const mgmtClusterSameId = {
+        id:             'c-m-abc123',
+        nameDisplay:    'mgmt-version',
+        detailLocation: { name: 'mgmt-location' }
+      };
+
+      const kubeconfig = createKubeconfig(
+        {
+          metadata: {},
+          spec:     { clusters: ['c-m-abc123'] }
+        },
+        {
+          'management/all': (type: string) => {
+            if (type === CAPI.RANCHER_CLUSTER) {
+              return [mockProvCluster];
+            }
+            if (type === MANAGEMENT.CLUSTER) {
+              return [mgmtClusterSameId];
+            }
+
+            return [];
+          }
+        }
+      );
+
+      expect(kubeconfig.referencedClusters).toStrictEqual([
+        {
+          label:    'my-cluster',
+          location: mockProvCluster.detailLocation
+        }
+      ]);
+    });
+  });
+
+  describe('sortedReferencedClusters', () => {
+    it('should sort existing clusters before deleted clusters', () => {
+      const existingCluster = {
+        mgmt:           { id: 'c-m-exists' },
+        nameDisplay:    'existing-cluster',
+        detailLocation: { name: 'location' }
+      };
+
+      const kubeconfig = createKubeconfig(
+        {
+          metadata: {},
+          spec:     { clusters: ['deleted-1', 'c-m-exists', 'deleted-2'] }
+        },
+        {
+          'management/all': (type: string) => {
+            if (type === CAPI.RANCHER_CLUSTER) {
+              return [existingCluster];
+            }
+
+            return [];
+          }
+        }
+      );
+
+      const sorted = kubeconfig.sortedReferencedClusters;
+
+      expect(sorted[0].label).toBe('existing-cluster');
+      expect(sorted[0].location).not.toBeNull();
+      expect(sorted[1].location).toBeNull();
+      expect(sorted[2].location).toBeNull();
+    });
+
+    it('should sort existing clusters alphabetically', () => {
+      const clusters = [
+        {
+          mgmt: { id: 'c-m-zebra' }, nameDisplay: 'zebra', detailLocation: { name: 'z' }
+        },
+        {
+          mgmt: { id: 'c-m-alpha' }, nameDisplay: 'alpha', detailLocation: { name: 'a' }
+        },
+        {
+          mgmt: { id: 'c-m-beta' }, nameDisplay: 'beta', detailLocation: { name: 'b' }
+        }
+      ];
+
+      const kubeconfig = createKubeconfig(
+        {
+          metadata: {},
+          spec:     { clusters: ['c-m-zebra', 'c-m-alpha', 'c-m-beta'] }
+        },
+        {
+          'management/all': (type: string) => {
+            if (type === CAPI.RANCHER_CLUSTER) {
+              return clusters;
+            }
+
+            return [];
+          }
+        }
+      );
+
+      const sorted = kubeconfig.sortedReferencedClusters;
+
+      expect(sorted.map((c) => c.label)).toStrictEqual(['alpha', 'beta', 'zebra']);
+    });
+
+    it('should sort numerically when names contain numbers', () => {
+      const clusters = [
+        {
+          mgmt: { id: 'c-m-2' }, nameDisplay: 'cluster2', detailLocation: { name: 'c2' }
+        },
+        {
+          mgmt: { id: 'c-m-10' }, nameDisplay: 'cluster10', detailLocation: { name: 'c10' }
+        },
+        {
+          mgmt: { id: 'c-m-1' }, nameDisplay: 'cluster1', detailLocation: { name: 'c1' }
+        }
+      ];
+
+      const kubeconfig = createKubeconfig(
+        {
+          metadata: {},
+          spec:     { clusters: ['c-m-2', 'c-m-10', 'c-m-1'] }
+        },
+        {
+          'management/all': (type: string) => {
+            if (type === CAPI.RANCHER_CLUSTER) {
+              return clusters;
+            }
+
+            return [];
+          }
+        }
+      );
+
+      const sorted = kubeconfig.sortedReferencedClusters;
+
+      expect(sorted.map((c) => c.label)).toStrictEqual(['cluster1', 'cluster2', 'cluster10']);
+    });
+  });
+
+  describe('referencedClustersSortable', () => {
+    it('should return comma-separated lowercase labels', () => {
+      const clusters = [
+        {
+          mgmt: { id: 'c-m-1' }, nameDisplay: 'Alpha', detailLocation: { name: 'a' }
+        },
+        {
+          mgmt: { id: 'c-m-2' }, nameDisplay: 'Beta', detailLocation: { name: 'b' }
+        }
+      ];
+
+      const kubeconfig = createKubeconfig(
+        {
+          metadata: {},
+          spec:     { clusters: ['c-m-1', 'c-m-2'] }
+        },
+        {
+          'management/all': (type: string) => {
+            if (type === CAPI.RANCHER_CLUSTER) {
+              return clusters;
+            }
+
+            return [];
+          }
+        }
+      );
+
+      expect(kubeconfig.referencedClustersSortable).toBe('alpha,beta');
+    });
+
+    it('should return empty string when no clusters', () => {
+      const kubeconfig = createKubeconfig({
+        metadata: {},
+        spec:     {}
+      });
+
+      expect(kubeconfig.referencedClustersSortable).toBe('');
+    });
+  });
+
+  describe('_availableActions', () => {
+    it('should filter out goToEdit, goToEditYaml, cloneYaml, and download actions', () => {
+      const kubeconfig = createKubeconfig({
+        metadata: {},
+        spec:     {}
+      });
+
+      const mockActions = [
+        { action: 'goToClone' },
+        { action: 'divider' },
+        { action: 'goToEdit' },
+        { action: 'goToEditYaml' },
+        { action: 'cloneYaml' },
+        { action: 'download' },
+        { action: 'promptRemove' }
+      ];
+
+      jest.spyOn(Object.getPrototypeOf(Object.getPrototypeOf(kubeconfig)), '_availableActions', 'get')
+        .mockReturnValue(mockActions);
+
+      const actions = kubeconfig._availableActions;
+
+      expect(actions).toStrictEqual([
+        { action: 'goToClone' },
+        { action: 'promptRemove' }
+      ]);
+    });
+  });
+});