@rancher/shell 3.0.12-rc.2 → 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.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'],

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';
@@ -167,11 +189,12 @@ describe('class MgmtNode', () => {
         id: nodeId
       }, {
         ...baseCtx,
-        getters: {
-          all: () => [{
-            mgmtClusterId,
-            nodes
-          }]
+        rootGetters: {
+          ...baseCtx.rootGetters,
+          'management/byId': () => ({
+            id:          mgmtClusterId,
+            provCluster: { nodes }
+          })
         }
       });
 

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

@@ -66,14 +66,15 @@ describe('class MgmtNodePool', () => {
       const { spec, nodes } = data;
       const mgmtNode = new MgmtNodePool({
         spec,
-        id: nodeId
+        metadata: {},
+        id:       nodeId
       }, {
         ...baseCtx,
         getters: {
-          all: () => [{
-            mgmtClusterId,
+          byId: () => ({
+            id: mgmtClusterId,
             nodes
-          }]
+          })
         }
       });
 

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

@@ -1,29 +1,39 @@
 import ProvCluster from '@shell/models/provisioning.cattle.io.cluster';
+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());
   })
 }));
+
+jest.mock('@shell/utils/clipboard', () => {
+  return { copyTextToClipboard: jest.fn(() => Promise.resolve({})) };
+});
+
 describe('class ProvCluster', () => {
   const gkeClusterWithPrivateEndpoint = {
     clusterName: 'test',
     provisioner: 'GKE',
     spec:        { },
-    mgmt:        { spec: { gkeConfig: { privateClusterConfig: { enablePrivateEndpoint: true } } } }
+    mgmt:        new MgmtCluster({ spec: { gkeConfig: { privateClusterConfig: { enablePrivateEndpoint: true } } } }),
   };
 
   const eksClusterWithPrivateEndpoint = {
     clusterName: 'test',
     provisioner: 'EKS',
     spec:        { },
-    mgmt:        { spec: { eksConfig: { privateAccess: true } } }
+    mgmt:        new MgmtCluster({ spec: { eksConfig: { privateAccess: true } } }),
   };
 
   const aksClusterWithPrivateEndpoint = {
     clusterName: 'test',
     provisioner: 'AKS',
     spec:        { },
-    mgmt:        { spec: { aksConfig: { privateCluster: true } } }
+    mgmt:        new MgmtCluster({ spec: { aksConfig: { privateCluster: true } } }),
   };
 
   // Related to https://github.com/rancher/dashboard/issues/9402
@@ -41,10 +51,14 @@ describe('class ProvCluster', () => {
     it.each(testCases)('should return the isHostedKubernetesProvider and isPrivateHostedProvider values properly based on the props data', (clusterData: Object, expected: Boolean) => {
       const cluster = new ProvCluster({ spec: clusterData.spec });
 
+      jest.spyOn(clusterData.mgmt, 'provCluster', 'get').mockReturnValue(
+        clusterData
+      );
+
       jest.spyOn(cluster, 'mgmt', 'get').mockReturnValue(
         clusterData.mgmt
       );
-      jest.spyOn(cluster, 'provisioner', 'get').mockReturnValue(
+      jest.spyOn(clusterData.mgmt, 'provisioner', 'get').mockReturnValue(
         clusterData.provisioner
       );
 
@@ -54,6 +68,7 @@ describe('class ProvCluster', () => {
       resetMocks();
     });
   });
+
   describe('isImported', () => {
     const testCases = [
       {
@@ -114,7 +129,8 @@ describe('class ProvCluster', () => {
         clusterData: {
           isLocal:                    false,
           isHostedKubernetesProvider: true,
-          providerConfig:             { imported: true }
+          providerConfig:             { imported: true },
+          mgmt:                       { status: { provider: '', driver: 'EKS' } }
         },
         expected: true
       },
@@ -123,7 +139,8 @@ describe('class ProvCluster', () => {
         clusterData: {
           isLocal:                    false,
           isHostedKubernetesProvider: true,
-          providerConfig:             { imported: false }
+          providerConfig:             { imported: false },
+          mgmt:                       { status: { provider: '', driver: 'EKS' } }
         },
         expected: false
       },
@@ -150,23 +167,27 @@ describe('class ProvCluster', () => {
     };
 
     it.each(testCases)('$description', ({ clusterData, expected }) => {
+      const mgmtCluster = new MgmtCluster(clusterData.mgmt || {});
       const cluster = new ProvCluster({});
 
       // Mock getters
       jest.spyOn(cluster, 'mgmt', 'get').mockReturnValue(
-        clusterData.mgmt
+        mgmtCluster
+      );
+      jest.spyOn(mgmtCluster, 'provCluster', 'get').mockReturnValue(
+        cluster
       );
       if (clusterData.isLocal !== undefined) {
-        jest.spyOn(cluster, 'isLocal', 'get').mockReturnValue(clusterData.isLocal);
+        jest.spyOn(mgmtCluster, 'isLocal', 'get').mockReturnValue(clusterData.isLocal);
       }
       if (clusterData.isHostedKubernetesProvider !== undefined) {
-        jest.spyOn(cluster, 'isHostedKubernetesProvider', 'get').mockReturnValue(clusterData.isHostedKubernetesProvider);
+        jest.spyOn(mgmtCluster, 'isHostedKubernetesProvider', 'get').mockReturnValue(clusterData.isHostedKubernetesProvider);
       }
       if (clusterData.providerConfig !== undefined) {
         jest.spyOn(cluster, 'providerConfig', 'get').mockReturnValue(clusterData.providerConfig);
       }
       if (clusterData.provisioner !== undefined) {
-        jest.spyOn(cluster, 'provisioner', 'get').mockReturnValue(clusterData.provisioner);
+        jest.spyOn(mgmtCluster, 'provisioner', 'get').mockReturnValue(clusterData.provisioner);
       }
 
       expect(cluster.isImported).toBe(expected);
@@ -268,7 +289,10 @@ describe('class ProvCluster', () => {
 
     it.each(testCases)('should return the hasError value properly based on the "status.conditions" props data for testcase %p', (testName: string, conditions: Array, expected: Boolean) => {
       const ctx = { rootGetters: { 'management/byId': jest.fn() } };
-      const cluster = new ProvCluster({ status: { conditions } }, ctx);
+      const mgmtCluster = new MgmtCluster({ status: { conditions } }, ctx);
+      const cluster = new ProvCluster({}, ctx);
+
+      jest.spyOn(cluster, 'mgmt', 'get').mockReturnValue(mgmtCluster);
 
       expect(cluster.hasError).toBe(expected);
       resetMocks();
@@ -371,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();
+    });
+  });
 });