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

package/models/__tests__/catalog.cattle.io.clusterrepo.test.ts

@@ -17,6 +17,7 @@ describe('clusterRepo', () => {
     jest.spyOn(model, 'save').mockImplementation().mockResolvedValue(true);
     jest.spyOn(model, 'waitForState').mockImplementation().mockResolvedValue(true);
     jest.spyOn(model, '$dispatch', 'get').mockReturnValue(jest.fn());
+    jest.spyOn(model, 't', 'get').mockReturnValue((key: string) => key);
   });
 
   describe('refresh', () => {
@@ -59,6 +60,62 @@ describe('clusterRepo', () => {
     });
   });
 
+  describe('defaultRefreshIntervalHours', () => {
+    it('returns 24 for OCI repos', () => {
+      model.spec.url = 'oci://example.com/chart';
+      model.spec.insecurePlainHttp = false;
+      expect(model.defaultRefreshIntervalHours).toStrictEqual(24);
+    });
+
+    it('returns 1 for git repos', () => {
+      model.spec = { gitRepo: 'https://github.com/example/charts' };
+      expect(model.defaultRefreshIntervalHours).toStrictEqual(1);
+    });
+
+    it('returns 1 for helm repos', () => {
+      model.spec = { url: 'https://charts.example.com' };
+      expect(model.defaultRefreshIntervalHours).toStrictEqual(1);
+    });
+  });
+
+  describe('defaultRefreshInterval', () => {
+    it('returns seconds for OCI repos (24 hours)', () => {
+      model.spec.url = 'oci://example.com/chart';
+      model.spec.insecurePlainHttp = false;
+      expect(model.defaultRefreshInterval).toStrictEqual(86400);
+    });
+
+    it('returns seconds for non-OCI repos (1 hour)', () => {
+      model.spec = { gitRepo: 'https://github.com/example/charts' };
+      expect(model.defaultRefreshInterval).toStrictEqual(3600);
+    });
+  });
+
+  describe('refreshIntervalDisplay', () => {
+    it.each([
+      -1,
+      -100,
+    ])('returns "Disabled" when value is %p', (val) => {
+      model.spec.refreshInterval = val;
+      expect(model.refreshIntervalDisplay).toStrictEqual('generic.disabled');
+    });
+
+    it('returns formatted duration for positive values', () => {
+      model.spec.refreshInterval = 3661;
+      expect(model.refreshIntervalDisplay).toStrictEqual('1h 1m 1s');
+    });
+
+    it('returns default formatted duration when not set', () => {
+      model.spec = { url: 'https://charts.example.com' };
+      expect(model.refreshIntervalDisplay).toStrictEqual('1h');
+    });
+
+    it('returns default formatted duration for OCI when not set', () => {
+      model.spec = { url: 'oci://example.com/chart', insecurePlainHttp: false };
+      expect(model.refreshIntervalDisplay).toStrictEqual('1d');
+    });
+  });
+
   describe('refreshBulk', () => {
     it('calls refresh(false) on all items and then dispatches a single catalog/load with all repoKeys', async() => {
       const mockItem1 = {

package/models/__tests__/compliance.cattle.io.clusterscan.test.ts

@@ -0,0 +1,144 @@
+import ClusterScan from '@shell/models/compliance.cattle.io.clusterscan';
+
+/**
+ * Build a ClusterScan model wired to a mocked store `dispatch`.
+ * `$dispatch` resolves to `this.$ctx.dispatch`, so injecting it via the
+ * constructor context is enough to exercise `_resolveExportMetadata`.
+ */
+const makeScan = (dispatch: jest.Mock) => new ClusterScan({}, {
+  getters:     {},
+  rootGetters: {},
+  dispatch,
+} as any) as any;
+
+const benchmarkWithConfigMap = {
+  spec: {
+    customBenchmarkConfigMapName:      'metadata-cm',
+    customBenchmarkConfigMapNamespace: 'compliance',
+  },
+};
+
+describe('class: ClusterScan', () => {
+  describe('method: _resolveExportMetadata', () => {
+    it('returns empty metadata and decorations when the benchmark is undefined', async() => {
+      const dispatch = jest.fn();
+      const scan = makeScan(dispatch);
+
+      const result = await scan._resolveExportMetadata(undefined);
+
+      expect(result).toStrictEqual({ metadata: {}, decorations: {} });
+      expect(dispatch).not.toHaveBeenCalled();
+    });
+
+    it('returns empty when the ConfigMap name is missing', async() => {
+      const dispatch = jest.fn();
+      const scan = makeScan(dispatch);
+
+      const result = await scan._resolveExportMetadata({ spec: { customBenchmarkConfigMapNamespace: 'compliance' } });
+
+      expect(result).toStrictEqual({ metadata: {}, decorations: {} });
+      expect(dispatch).not.toHaveBeenCalled();
+    });
+
+    it('returns empty when the ConfigMap namespace is missing', async() => {
+      const dispatch = jest.fn();
+      const scan = makeScan(dispatch);
+
+      const result = await scan._resolveExportMetadata({ spec: { customBenchmarkConfigMapName: 'metadata-cm' } });
+
+      expect(result).toStrictEqual({ metadata: {}, decorations: {} });
+      expect(dispatch).not.toHaveBeenCalled();
+    });
+
+    it('fetches the ConfigMap by namespace/name from the configmap type', async() => {
+      const dispatch = jest.fn().mockResolvedValue({ data: {} });
+      const scan = makeScan(dispatch);
+
+      await scan._resolveExportMetadata(benchmarkWithConfigMap);
+
+      expect(dispatch).toHaveBeenCalledWith('find', { type: 'configmap', id: 'compliance/metadata-cm' });
+    });
+
+    it('returns empty when the ConfigMap has no metadata.yaml data key', async() => {
+      const dispatch = jest.fn().mockResolvedValue({ data: { 'other.yaml': 'title: x' } });
+      const scan = makeScan(dispatch);
+
+      const result = await scan._resolveExportMetadata(benchmarkWithConfigMap);
+
+      expect(result).toStrictEqual({ metadata: {}, decorations: {} });
+    });
+
+    it('returns empty when the ConfigMap itself is not found', async() => {
+      const dispatch = jest.fn().mockResolvedValue(undefined);
+      const scan = makeScan(dispatch);
+
+      const result = await scan._resolveExportMetadata(benchmarkWithConfigMap);
+
+      expect(result).toStrictEqual({ metadata: {}, decorations: {} });
+    });
+
+    it('splits top-level fields into metadata and the checks map into decorations', async() => {
+      const yaml = [
+        'title: CIS Kubernetes Benchmark',
+        'description: A CIS profile',
+        'referenceType: cis',
+        'checks:',
+        '  "5.1.1":',
+        '    ruleId: CIS-5.1.1-rule',
+        '    severity: high',
+        '    idents:',
+        '      - system: https://www.cisecurity.org/controls/',
+        '        value: CIS-CSC-3',
+        '  "5.1.2":',
+        '    ruleId: CIS-5.1.2-rule',
+      ].join('\n');
+      const dispatch = jest.fn().mockResolvedValue({ data: { 'metadata.yaml': yaml } });
+      const scan = makeScan(dispatch);
+
+      const result = await scan._resolveExportMetadata(benchmarkWithConfigMap);
+
+      expect(result.metadata).toStrictEqual({
+        title:         'CIS Kubernetes Benchmark',
+        description:   'A CIS profile',
+        referenceType: 'cis',
+      });
+      expect(result.decorations).toStrictEqual({
+        '5.1.1': {
+          ruleId:   'CIS-5.1.1-rule',
+          severity: 'high',
+          idents:   [{ system: 'https://www.cisecurity.org/controls/', value: 'CIS-CSC-3' }],
+        },
+        '5.1.2': { ruleId: 'CIS-5.1.2-rule' },
+      });
+    });
+
+    it('returns empty decorations when metadata.yaml has no checks map', async() => {
+      const yaml = ['title: STIG', 'source: disa'].join('\n');
+      const dispatch = jest.fn().mockResolvedValue({ data: { 'metadata.yaml': yaml } });
+      const scan = makeScan(dispatch);
+
+      const result = await scan._resolveExportMetadata(benchmarkWithConfigMap);
+
+      expect(result.metadata).toStrictEqual({ title: 'STIG', source: 'disa' });
+      expect(result.decorations).toStrictEqual({});
+    });
+
+    it('returns empty when the ConfigMap lookup rejects', async() => {
+      const dispatch = jest.fn().mockRejectedValue(new Error('not found'));
+      const scan = makeScan(dispatch);
+
+      const result = await scan._resolveExportMetadata(benchmarkWithConfigMap);
+
+      expect(result).toStrictEqual({ metadata: {}, decorations: {} });
+    });
+
+    it('returns empty when metadata.yaml is malformed YAML', async() => {
+      const dispatch = jest.fn().mockResolvedValue({ data: { 'metadata.yaml': 'title: "unterminated' } });
+      const scan = makeScan(dispatch);
+
+      const result = await scan._resolveExportMetadata(benchmarkWithConfigMap);
+
+      expect(result).toStrictEqual({ metadata: {}, decorations: {} });
+    });
+  });
+});

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__/fleet-application.test.ts

@@ -0,0 +1,175 @@
+import FleetApplication from '@shell/models/fleet-application.js';
+
+describe('class FleetApplication', () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe('applicationType', () => {
+    it('should return the kind property', () => {
+      const instance = new FleetApplication({ kind: 'GitRepo' });
+
+      expect(instance.applicationType).toStrictEqual('GitRepo');
+    });
+  });
+
+  describe('targetClusters', () => {
+    function createFleetApplication(targets: any[] | undefined, clusters: any[], workspaceId = 'fleet-default', groups: any[] = []) {
+      const workspace = {
+        id:            workspaceId,
+        clusters,
+        clusterGroups: groups,
+      };
+
+      jest.spyOn(FleetApplication.prototype, '$getters', 'get').mockReturnValue({ byId: () => workspace });
+
+      return new FleetApplication({
+        metadata: { namespace: workspaceId },
+        spec:     { targets },
+      });
+    }
+
+    it.each([
+      [
+        'metadata.name',
+        [{ clusterName: 'c-m-abc123' }],
+        [{
+          id: 'fleet-default/c-m-abc123', metadata: { name: 'c-m-abc123' }, nameDisplay: 'my-cluster'
+        }],
+        [{
+          id: 'fleet-default/c-m-abc123', metadata: { name: 'c-m-abc123' }, nameDisplay: 'my-cluster'
+        }],
+      ],
+      [
+        'nameDisplay when metadata.name does not match',
+        [{ clusterName: 'my-display-name' }],
+        [{
+          id: 'fleet-default/c-m-abc123', metadata: { name: 'c-m-abc123' }, nameDisplay: 'my-display-name'
+        }],
+        [{
+          id: 'fleet-default/c-m-abc123', metadata: { name: 'c-m-abc123' }, nameDisplay: 'my-display-name'
+        }],
+      ],
+    ])('should find cluster by %s', (_label, targets, clusters, expected) => {
+      const app = createFleetApplication(targets, clusters);
+
+      expect(app.targetClusters).toStrictEqual(expected);
+    });
+
+    it('should prefer metadata.name match over nameDisplay match', () => {
+      const clusters = [
+        {
+          id:          'fleet-default/exact-match',
+          metadata:    { name: 'exact-match' },
+          nameDisplay: 'display-a',
+        },
+        {
+          id:          'fleet-default/c-m-other',
+          metadata:    { name: 'c-m-other' },
+          nameDisplay: 'exact-match',
+        }
+      ];
+
+      const app = createFleetApplication([{ clusterName: 'exact-match' }], clusters);
+
+      expect(app.targetClusters).toStrictEqual([clusters[0]]);
+    });
+
+    it('should return empty array when no cluster matches by name or nameDisplay', () => {
+      const clusters = [
+        {
+          id:          'fleet-default/c-m-abc123',
+          metadata:    { name: 'c-m-abc123' },
+          nameDisplay: 'my-cluster',
+        }
+      ];
+
+      const app = createFleetApplication([{ clusterName: 'non-existent' }], clusters);
+
+      expect(app.targetClusters).toStrictEqual([]);
+    });
+
+    it('should handle multiple targets with mixed name and nameDisplay matches', () => {
+      const clusters = [
+        {
+          id:          'fleet-default/c-m-abc123',
+          metadata:    { name: 'c-m-abc123' },
+          nameDisplay: 'cluster-alpha',
+        },
+        {
+          id:          'fleet-default/c-m-def456',
+          metadata:    { name: 'c-m-def456' },
+          nameDisplay: 'cluster-beta',
+        }
+      ];
+
+      const targets = [
+        { clusterName: 'c-m-abc123' },
+        { clusterName: 'cluster-beta' },
+      ];
+
+      const app = createFleetApplication(targets, clusters);
+
+      expect(app.targetClusters).toStrictEqual([clusters[0], clusters[1]]);
+    });
+
+    it('should return empty array when targets is empty', () => {
+      const app = createFleetApplication([], []);
+
+      expect(app.targetClusters).toStrictEqual([]);
+    });
+
+    it('should return empty array when targets is undefined', () => {
+      const app = createFleetApplication(undefined, []);
+
+      expect(app.targetClusters).toStrictEqual([]);
+    });
+
+    it('should return empty array when workspace has no clusters', () => {
+      const app = createFleetApplication([{ clusterName: 'any-name' }], []);
+
+      expect(app.targetClusters).toStrictEqual([]);
+    });
+
+    it('should handle cluster with undefined nameDisplay gracefully', () => {
+      const clusters = [
+        {
+          id:          'fleet-default/c-m-abc123',
+          metadata:    { name: 'c-m-abc123' },
+          nameDisplay: undefined,
+        }
+      ];
+
+      const app = createFleetApplication([{ clusterName: 'c-m-abc123' }], clusters);
+
+      expect(app.targetClusters).toStrictEqual([clusters[0]]);
+    });
+
+    it('should return local cluster targets when workspace is fleet-local', () => {
+      const localTargetClusters = [
+        {
+          id:          'fleet-local/local',
+          metadata:    { name: 'local' },
+          nameDisplay: 'local',
+        }
+      ];
+
+      const groups = [
+        {
+          id:             'fleet-local/default',
+          targetClusters: localTargetClusters,
+        }
+      ];
+
+      const app = createFleetApplication([], [], 'fleet-local', groups);
+
+      expect(app.targetClusters).toStrictEqual(localTargetClusters);
+    });
+
+    it('should return empty array when workspace is fleet-local and default group is missing', () => {
+      const app = createFleetApplication([], [], 'fleet-local', []);
+
+      expect(app.targetClusters).toStrictEqual([]);
+    });
+  });
+});