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

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],

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

@@ -4,6 +4,9 @@ import MgmtCluster from '@shell/models/management.cattle.io.cluster';
 jest.mock('@shell/utils/provider', () => ({
   isHostedProvider: jest.fn().mockImplementation((context, provider) => {
     return ['GKE', 'EKS', 'AKS'].includes(provider);
+  }),
+  isCAPIProvider: jest.fn().mockImplementation((context, provider) => {
+    return ['capa', 'capv'].includes(provider.toLowerCase());
   })
 }));
 
@@ -392,4 +395,50 @@ describe('class ProvCluster', () => {
       jest.clearAllMocks();
     });
   });
+
+  describe('isCapiWithoutExtension', () => {
+    const testCases = [
+      {
+        description:    'should return undefined when mgmt is undefined',
+        isCapiHybrid:   undefined,
+        isCAPIProvider: undefined,
+        expected:       undefined,
+      },
+      {
+        description:    'should return false when not a CAPI cluster',
+        isCapiHybrid:   false,
+        isCAPIProvider: false,
+        expected:       false,
+      },
+      {
+        description:    'should return false when CAPI cluster and a registered CAPI provider extension exists',
+        isCapiHybrid:   true,
+        isCAPIProvider: true,
+        expected:       false,
+      },
+      {
+        description:    'should return true when CAPI cluster but no registered CAPI provider extension',
+        isCapiHybrid:   true,
+        isCAPIProvider: false,
+        expected:       true,
+      },
+    ];
+
+    it.each(testCases)('$description', ({ isCapiHybrid, isCAPIProvider, expected }) => {
+      const cluster = new ProvCluster({});
+
+      if (isCapiHybrid === undefined) {
+        jest.spyOn(cluster, 'mgmt', 'get').mockReturnValue(undefined);
+      } else {
+        const mgmtCluster = new MgmtCluster({});
+
+        jest.spyOn(mgmtCluster, 'isCapiHybrid', 'get').mockReturnValue(isCapiHybrid);
+        jest.spyOn(mgmtCluster, 'isCAPIProvider', 'get').mockReturnValue(isCAPIProvider);
+        jest.spyOn(cluster, 'mgmt', 'get').mockReturnValue(mgmtCluster);
+      }
+
+      expect(cluster.isCapiWithoutExtension).toStrictEqual(expected);
+      jest.clearAllMocks();
+    });
+  });
 });