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

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__/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([]);
+    });
+  });
+});

package/models/__tests__/fleet.cattle.io.bundle.test.ts

@@ -0,0 +1,169 @@
+import FleetBundle from '@shell/models/fleet.cattle.io.bundle.js';
+
+describe('class FleetBundle', () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe('targetClusters', () => {
+    function createFleetBundle(targets: any[], clusters: any[], workspaceId = 'fleet-default', groups: any[] = []) {
+      const workspace = {
+        id:            workspaceId,
+        clusters,
+        clusterGroups: groups,
+      };
+
+      jest.spyOn(FleetBundle.prototype, '$getters', 'get').mockReturnValue({ byId: () => workspace });
+
+      return new FleetBundle({
+        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 bundle = createFleetBundle(targets, clusters);
+
+      expect(bundle.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 bundle = createFleetBundle([{ clusterName: 'exact-match' }], clusters);
+
+      expect(bundle.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 bundle = createFleetBundle([{ clusterName: 'non-existent' }], clusters);
+
+      expect(bundle.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 bundle = createFleetBundle(targets, clusters);
+
+      expect(bundle.targetClusters).toStrictEqual([clusters[0], clusters[1]]);
+    });
+
+    it('should return empty array when workspace has no clusters', () => {
+      const bundle = createFleetBundle([{ clusterName: 'any-name' }], []);
+
+      expect(bundle.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 bundle = createFleetBundle([{ clusterName: 'c-m-abc123' }], clusters);
+
+      expect(bundle.targetClusters).toStrictEqual([clusters[0]]);
+    });
+
+    it('should not match by nameDisplay when nameDisplay is undefined and target uses a different name', () => {
+      const clusters = [
+        {
+          id:          'fleet-default/c-m-abc123',
+          metadata:    { name: 'c-m-abc123' },
+          nameDisplay: undefined,
+        }
+      ];
+
+      const bundle = createFleetBundle([{ clusterName: 'some-other-name' }], clusters);
+
+      expect(bundle.targetClusters).toStrictEqual([]);
+    });
+
+    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 bundle = createFleetBundle([], [], 'fleet-local', groups);
+
+      expect(bundle.targetClusters).toStrictEqual(localTargetClusters);
+    });
+
+    it('should return empty array when workspace is fleet-local and default group is missing', () => {
+      const bundle = createFleetBundle([], [], 'fleet-local', []);
+
+      expect(bundle.targetClusters).toStrictEqual([]);
+    });
+  });
+});

package/models/__tests__/fleet.cattle.io.helmop.test.ts

@@ -1,8 +1,17 @@
 import HelmOp from '@shell/models/fleet.cattle.io.helmop.js';
+import { SUSE_APP_COLLECTION_REPO_URL } from '@shell/utils/fleet-appco';
+
+const mockIsRancherPrime = jest.fn(() => true);
+
+jest.mock('@shell/config/version', () => ({ isRancherPrime: () => mockIsRancherPrime() }));
 
 describe('class HelmOp', () => {
   let instance;
 
+  beforeEach(() => {
+    mockIsRancherPrime.mockReturnValue(true);
+  });
+
   describe('source getter', () => {
     it('should return correct source for SOURCE_TYPE.REPO (HTTPS)', () => {
       instance = new HelmOp({
@@ -221,4 +230,79 @@ describe('class HelmOp', () => {
       expect(sourceSub.display).toBe('');
     });
   });
+
+  describe('isSuseAppCollectionFromUI', () => {
+    it('should return true when annotation is set', () => {
+      instance = new HelmOp({ metadata: { annotations: { 'catalog.cattle.io/suse-application-collection': 'true' } }, spec: { helm: {} } });
+
+      expect(instance.isSuseAppCollectionFromUI).toBe(true);
+    });
+
+    it('should return false when annotation is missing', () => {
+      instance = new HelmOp({ metadata: { annotations: {} }, spec: { helm: {} } });
+
+      expect(instance.isSuseAppCollectionFromUI).toBe(false);
+    });
+  });
+
+  describe('isSuseAppCollection', () => {
+    it('should return true even when not Rancher Prime if annotation is set', () => {
+      mockIsRancherPrime.mockReturnValue(false);
+      instance = new HelmOp({
+        metadata: { annotations: { 'catalog.cattle.io/suse-application-collection': 'true' } },
+        spec:     { helm: {} }
+      });
+
+      expect(instance.isSuseAppCollection).toBe(true);
+    });
+
+    it('should return true when annotation is set and Rancher Prime', () => {
+      instance = new HelmOp({
+        metadata: { annotations: { 'catalog.cattle.io/suse-application-collection': 'true' } },
+        spec:     { helm: {} }
+      });
+
+      expect(instance.isSuseAppCollection).toBe(true);
+    });
+
+    it('should return true when repo URL starts with SUSE_APP_COLLECTION_REPO_URL', () => {
+      instance = new HelmOp({
+        metadata: {},
+        spec:     { helm: { repo: `${ SUSE_APP_COLLECTION_REPO_URL }/my-chart` } }
+      });
+
+      expect(instance.isSuseAppCollection).toBe(true);
+    });
+
+    it('should return false when no annotation and different repo URL', () => {
+      instance = new HelmOp({
+        metadata: {},
+        spec:     { helm: { repo: 'oci://other-registry.io/charts' } }
+      });
+
+      expect(instance.isSuseAppCollection).toBe(false);
+    });
+  });
+
+  describe('applicationType', () => {
+    it('should return "SUSE AppCo" when isSuseAppCollectionFromUI is true', () => {
+      instance = new HelmOp({
+        metadata: { annotations: { 'catalog.cattle.io/suse-application-collection': 'true' } },
+        spec:     { helm: {} },
+        kind:     'HelmOp'
+      });
+
+      expect(instance.applicationType).toStrictEqual('SUSE AppCo');
+    });
+
+    it('should return kind when not SUSE App Collection from UI', () => {
+      instance = new HelmOp({
+        metadata: {},
+        spec:     { helm: {} },
+        kind:     'HelmOp'
+      });
+
+      expect(instance.applicationType).toStrictEqual('HelmOp');
+    });
+  });
 });

package/models/__tests__/management.cattle.io.node.ts

@@ -94,6 +94,28 @@ describe('class MgmtNode', () => {
     });
   });
 
+  describe('pool', () => {
+    it('should return undefined if nodePoolName is not set', () => {
+      const mgmtNode = new MgmtNode({ spec: {} });
+
+      expect(mgmtNode.pool).toBeUndefined();
+    });
+
+    it('should return the node pool when nodePoolName is set', () => {
+      const nodePool = { id: 'fleet-local/np1' };
+      const mgmtNodeCtx = {
+        rootGetters: {
+          'i18n/t':          t,
+          'management/byId': jest.fn(() => nodePool)
+        }
+      };
+      const mgmtNode = new MgmtNode({ spec: { nodePoolName: 'fleet-local:np1' } }, mgmtNodeCtx);
+
+      expect(mgmtNode.pool).toStrictEqual(nodePool);
+      expect(mgmtNodeCtx.rootGetters['management/byId']).toHaveBeenCalledWith('management.cattle.io.nodepool', 'fleet-local/np1');
+    });
+  });
+
   describe('canScaleDown', () => {
     const mgmtClusterId = 'test';
     const nodeId = 'test/id';

package/models/__tests__/namespace.test.ts

@@ -150,6 +150,42 @@ describe('class Namespace', () => {
   it.todo('should disableAutoInjection');
   it.todo('should check if confirmRemove');
 
+  describe('move action availability', () => {
+    const SteveModelProto = Object.getPrototypeOf(Namespace.prototype);
+
+    const makeNamespace = ({ canUpdate }: { canUpdate: boolean }) => {
+      const namespace = new Namespace({});
+
+      jest.spyOn(namespace, '$rootGetters', 'get').mockReturnValue({
+        isRancher:       true,
+        isSingleProduct: false,
+        'i18n/t':        (key: string) => key,
+      });
+      Object.defineProperty(namespace, 'istioInstalled', { get: () => false, configurable: true });
+      Object.defineProperty(namespace, 'canUpdate', { get: () => canUpdate, configurable: true });
+      jest.spyOn(SteveModelProto, '_availableActions', 'get').mockReturnValue([]);
+
+      return namespace;
+    };
+
+    it('should include the move action when user can update the namespace', () => {
+      const namespace = makeNamespace({ canUpdate: true });
+
+      const moveAction = namespace.availableActions.find((a: any) => a.action === 'move');
+
+      expect(moveAction).toBeDefined();
+      expect(moveAction.enabled).toBe(true);
+    });
+
+    it('should exclude the move action when user cannot update the namespace', () => {
+      const namespace = makeNamespace({ canUpdate: false });
+
+      const moveAction = namespace.availableActions.find((a: any) => a.action === 'move');
+
+      expect(moveAction).toBeUndefined();
+    });
+  });
+
   describe('handling listLocation', () => {
     it.each([
       ['c-cluster-product-projectsnamespaces', true],