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

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

@@ -0,0 +1,131 @@
+import Feature from '@shell/models/management.cattle.io.feature.js';
+import Resource from '@shell/plugins/dashboard-store/resource-class';
+
+describe('class Feature', () => {
+  const ctx = {
+    dispatch:    jest.fn(),
+    rootGetters: { 'i18n/t': (key: string) => key },
+    getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
+  };
+
+  // The parent Resource._availableActions getter depends on runtime config we don't have
+  // in tests — stub it out so we can assert on Feature's own additions.
+  beforeEach(() => {
+    jest.spyOn(Resource.prototype, '_availableActions', 'get').mockReturnValue([]);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe('enabled getter', () => {
+    it.each([
+      [true, true],
+      [false, false],
+    ])('should return lockedValue (%s) when status.lockedValue is not null', (lockedValue, expected) => {
+      const feature = new Feature({
+        spec:   { value: false },
+        status: { lockedValue, default: false }
+      }, ctx);
+
+      expect(feature.enabled).toBe(expected);
+    });
+
+    it('should return spec.value when lockedValue is null and spec.value is set', () => {
+      const feature = new Feature({
+        spec:   { value: true },
+        status: { lockedValue: null, default: false }
+      }, ctx);
+
+      expect(feature.enabled).toBe(true);
+    });
+
+    it('should fall back to status.default when lockedValue is null and spec.value is null', () => {
+      const feature = new Feature({
+        spec:   { value: null },
+        status: { lockedValue: null, default: true }
+      }, ctx);
+
+      expect(feature.enabled).toBe(true);
+    });
+
+    it('should not throw when status is missing (malformed feature flag)', () => {
+      const feature = new Feature({ spec: { value: true } }, ctx);
+
+      expect(() => feature.enabled).not.toThrow();
+      expect(feature.enabled).toBe(true);
+    });
+  });
+
+  describe('restartRequired getter', () => {
+    it('should return false when status.dynamic is true', () => {
+      const feature = new Feature({ spec: {}, status: { dynamic: true, lockedValue: null } }, ctx);
+
+      expect(feature.restartRequired).toBe(false);
+    });
+
+    it('should return true when status.dynamic is false', () => {
+      const feature = new Feature({ spec: {}, status: { dynamic: false, lockedValue: null } }, ctx);
+
+      expect(feature.restartRequired).toBe(true);
+    });
+
+    it('should return true when status is missing (malformed feature flag)', () => {
+      const feature = new Feature({ spec: {} }, ctx);
+
+      expect(() => feature.restartRequired).not.toThrow();
+      expect(feature.restartRequired).toBe(true);
+    });
+  });
+
+  describe('_availableActions getter', () => {
+    it('should disable the toggle action when lockedValue is not null', () => {
+      const feature = new Feature({
+        spec:   { value: false },
+        status: {
+          lockedValue: true, default: false, dynamic: true
+        },
+      }, ctx);
+
+      jest.spyOn(feature, 'canUpdate', 'get').mockReturnValue(true);
+
+      const actions = feature._availableActions;
+
+      expect(actions[0].action).toBe('toggleFeatureFlag');
+      expect(actions[0].enabled).toBe(false);
+    });
+
+    it('should enable the toggle action when lockedValue is null and user canUpdate', () => {
+      const feature = new Feature({
+        spec:   { value: false },
+        status: {
+          lockedValue: null, default: false, dynamic: true
+        },
+        id: 'some-feature',
+      }, ctx);
+
+      jest.spyOn(feature, 'canUpdate', 'get').mockReturnValue(true);
+
+      const actions = feature._availableActions;
+
+      expect(actions[0].action).toBe('toggleFeatureFlag');
+      expect(actions[0].enabled).toBe(true);
+    });
+
+    it('should not throw and should disable the toggle action when status is missing (malformed feature flag)', () => {
+      const feature = new Feature({
+        spec: { value: false },
+        id:   'some-feature',
+      }, ctx);
+
+      jest.spyOn(feature, 'canUpdate', 'get').mockReturnValue(true);
+
+      expect(() => feature._availableActions).not.toThrow();
+
+      const actions = feature._availableActions;
+
+      expect(actions[0].action).toBe('toggleFeatureFlag');
+      expect(actions[0].enabled).toBeFalsy();
+    });
+  });
+});

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

@@ -167,11 +167,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__/monitoring.coreos.com.alertmanagerconfig.test.ts

@@ -0,0 +1,98 @@
+import AlertmanagerConfig from '@shell/models/monitoring.coreos.com.alertmanagerconfig';
+
+const base = {
+  apiVersion: 'monitoring.coreos.com/v1alpha1',
+  kind:       'AlertmanagerConfig',
+  metadata:   { name: 'test', namespace: 'default' },
+};
+
+const build = (data: Record<string, any>) => new AlertmanagerConfig(data) as any;
+
+describe('class AlertmanagerConfig', () => {
+  describe('applyDefaults', () => {
+    it('on a fresh resource, seeds the route with defaults and no match/matchRe', () => {
+      const amc = build({ ...base });
+
+      amc.applyDefaults();
+
+      expect(amc.spec.receivers).toStrictEqual([]);
+      expect(amc.spec.route).toStrictEqual({
+        groupBy:        [],
+        groupWait:      '30s',
+        groupInterval:  '5m',
+        repeatInterval: '4h',
+        matchers:       [],
+      });
+    });
+
+    it('backfills route defaults on a resource loaded without a route', () => {
+      const amc = build({
+        ...base,
+        spec: { receivers: [{ name: 'existing' }] },
+      });
+
+      amc.applyDefaults();
+
+      expect(amc.spec.route).toBeDefined();
+      expect(amc.spec.route.receiver).toBeUndefined();
+      expect(amc.spec.route.matchers).toStrictEqual([]);
+    });
+
+    it('preserves existing matchers on load', () => {
+      const matchers = [{
+        name: 'severity', value: 'warning', matchType: '='
+      }];
+      const amc = build({
+        ...base,
+        spec: {
+          receivers: [{ name: 'existing' }],
+          route:     { receiver: 'existing', matchers },
+        },
+      });
+
+      amc.applyDefaults();
+
+      expect(amc.spec.route.matchers).toStrictEqual(matchers);
+    });
+  });
+
+  describe('cleanForSave', () => {
+    it('drops spec.route when no receiver is set — this is what fixes #17347 on 109+ charts', () => {
+      const amc = build({ ...base });
+
+      const out = amc.cleanForSave({
+        ...base,
+        spec: {
+          receivers: [],
+          route:     {
+            groupBy:        [],
+            groupWait:      '30s',
+            groupInterval:  '5m',
+            repeatInterval: '4h',
+            matchers:       [],
+          },
+        },
+      }, true);
+
+      expect(out.spec.route).toBeUndefined();
+      expect(out.spec.receivers).toStrictEqual([]);
+    });
+
+    it('keeps spec.route when a receiver is set', () => {
+      const amc = build({ ...base });
+
+      const out = amc.cleanForSave({
+        ...base,
+        spec: {
+          receivers: [{ name: 'existing' }],
+          route:     {
+            receiver: 'existing', groupBy: [], matchers: []
+          },
+        },
+      }, false);
+
+      expect(out.spec.route).toBeDefined();
+      expect(out.spec.route.receiver).toBe('existing');
+    });
+  });
+});

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

@@ -1,29 +1,36 @@
 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);
   })
 }));
+
+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 +48,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 +65,7 @@ describe('class ProvCluster', () => {
       resetMocks();
     });
   });
+
   describe('isImported', () => {
     const testCases = [
       {
@@ -114,7 +126,8 @@ describe('class ProvCluster', () => {
         clusterData: {
           isLocal:                    false,
           isHostedKubernetesProvider: true,
-          providerConfig:             { imported: true }
+          providerConfig:             { imported: true },
+          mgmt:                       { status: { provider: '', driver: 'EKS' } }
         },
         expected: true
       },
@@ -123,7 +136,8 @@ describe('class ProvCluster', () => {
         clusterData: {
           isLocal:                    false,
           isHostedKubernetesProvider: true,
-          providerConfig:             { imported: false }
+          providerConfig:             { imported: false },
+          mgmt:                       { status: { provider: '', driver: 'EKS' } }
         },
         expected: false
       },
@@ -150,23 +164,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 +286,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();