@rancher/shell 3.0.7 → 3.0.8-rc.10

package/utils/__tests__/cluster.test.ts

@@ -1,4 +1,5 @@
-import { abbreviateClusterName } from '@shell/utils/cluster';
+import { abbreviateClusterName, _addonConfigPreserveFilter, addonConfigPreserve } from '@shell/utils/cluster';
+import { diff } from '@shell/utils/object';
 
 describe('fx: abbreviateClusterName', () => {
   it.each([
@@ -55,3 +56,380 @@ describe('fx: abbreviateClusterName', () => {
     expect(result).toStrictEqual(expected);
   });
 });
+
+describe('fx: _addonConfigPreserveFilter', () => {
+  it('should return an empty object if there are no differences between default values', () => {
+    const oldDefaults = { replicaCount: 1 };
+    const newDefaults = { replicaCount: 1 };
+    const userVals = { replicaCount: 3 };
+    const diffs = diff(oldDefaults, newDefaults);
+    const expected = {};
+
+    expect(_addonConfigPreserveFilter(diffs, userVals)).toStrictEqual(expected);
+  });
+
+  it('should return an empty object if no user values are provided', () => {
+    const oldDefaults = { replicaCount: 1 };
+    const newDefaults = { replicaCount: 2 };
+    const userVals = {};
+    const diffs = diff(oldDefaults, newDefaults);
+    const expected = {};
+
+    expect(_addonConfigPreserveFilter(diffs, userVals)).toStrictEqual(expected);
+  });
+
+  it('should filter out diffs for fields not customized by the user', () => {
+    const oldDefaults = {
+      replicaCount: 1,
+      persistence:  false
+    };
+    const newDefaults = {
+      replicaCount: 2,
+      persistence:  true
+    };
+    const userVals = { replicaCount: 3 };
+    const diffs = diff(oldDefaults, newDefaults);
+    const expected = { replicaCount: 2 };
+
+    expect(_addonConfigPreserveFilter(diffs, userVals)).toStrictEqual(expected);
+  });
+
+  it('should include diffs for fields customized by the user', () => {
+    const oldDefaults = { replicaCount: 1 };
+    const newDefaults = { replicaCount: 2 };
+    const userVals = { replicaCount: 3 };
+    const diffs = diff(oldDefaults, newDefaults);
+    const expected = { replicaCount: 2 };
+
+    expect(_addonConfigPreserveFilter(diffs, userVals)).toStrictEqual(expected);
+  });
+
+  it('should handle nested objects: include diff if user customized nested property', () => {
+    const oldDefaults = { service: { port: 80 } };
+    const newDefaults = { service: { port: 8080 } };
+    const userVals = { service: { port: 9000 } };
+    const diffs = diff(oldDefaults, newDefaults);
+    const expected = { service: { port: 8080 } };
+
+    expect(_addonConfigPreserveFilter(diffs, userVals)).toStrictEqual(expected);
+  });
+
+  it('should handle nested objects: exclude diff if user did not customize nested property', () => {
+    const oldDefaults = { service: { port: 80, type: 'ClusterIP' } };
+    const newDefaults = { service: { port: 8080, type: 'ClusterIP' } };
+    const userVals = { service: { type: 'NodePort' } };
+    const diffs = diff(oldDefaults, newDefaults);
+    const expected = {};
+
+    expect(_addonConfigPreserveFilter(diffs, userVals)).toStrictEqual(expected);
+  });
+
+  it('should handle nested objects: include diff if user customized a removed nested object', () => {
+    const oldDefaults = { service: { port: 80 } };
+    const newDefaults = {};
+    const userVals = { service: { port: 9000 } };
+    const diffs = diff(oldDefaults, newDefaults);
+    const expected = { service: { port: null } };
+
+    expect(_addonConfigPreserveFilter(diffs, userVals)).toStrictEqual(expected);
+  });
+
+  it('should handle nested objects: exclude diff if a new property is added to default nested object and user did not customize it', () => {
+    const oldDefaults = { service: { port: 80 } };
+    const newDefaults = { service: { port: 80, type: 'ClusterIP' } };
+    const userVals = { service: { port: 80 } };
+    const diffs = diff(oldDefaults, newDefaults);
+    const expected = {};
+
+    expect(_addonConfigPreserveFilter(diffs, userVals)).toStrictEqual(expected);
+  });
+
+  it('should handle arrays of primitives: include diff if user customized array and default array changed', () => {
+    const oldDefaults = { ingress: { hosts: ['host1.com', 'host2.com'] } };
+    const newDefaults = { ingress: { hosts: ['host1.com', 'host3.com'] } };
+    const userVals = { ingress: { hosts: ['user.host.com'] } };
+    const diffs = diff(oldDefaults, newDefaults);
+    const expected = { ingress: { hosts: ['host1.com', 'host3.com'] } };
+
+    expect(_addonConfigPreserveFilter(diffs, userVals)).toStrictEqual(expected);
+  });
+
+  it('should handle arrays of primitives: exclude diff if user did not customize array', () => {
+    const oldDefaults = { ingress: { hosts: ['host1.com', 'host2.com'] } };
+    const newDefaults = { ingress: { hosts: ['host1.com', 'host3.com'] } };
+    const userVals = { ingress: { enabled: true } };
+    const diffs = diff(oldDefaults, newDefaults);
+    const expected = {};
+
+    expect(_addonConfigPreserveFilter(diffs, userVals)).toStrictEqual(expected);
+  });
+
+  it('should handle arrays of objects: include diff if user customized array and default array changed', () => {
+    const oldDefaults = { service: { ports: [{ name: 'http', port: 80 }] } };
+    const newDefaults = { service: { ports: [{ name: 'http', port: 80 }, { name: 'https', port: 443 }] } };
+    const userVals = { service: { ports: [{ name: 'http', port: 8080 }] } };
+    const diffs = diff(oldDefaults, newDefaults);
+    const expected = { service: { ports: [{ name: 'http', port: 80 }, { name: 'https', port: 443 }] } };
+
+    expect(_addonConfigPreserveFilter(diffs, userVals)).toStrictEqual(expected);
+  });
+
+  it('should handle arrays of objects: exclude diff if user did not customize array', () => {
+    const oldDefaults = { service: { ports: [{ name: 'http', port: 80 }] } };
+    const newDefaults = { service: { ports: [{ name: 'http', port: 80 }, { name: 'https', port: 443 }] } };
+    const userVals = { service: { type: 'ClusterIP' } };
+    const diffs = diff(oldDefaults, newDefaults);
+    const expected = {};
+
+    expect(_addonConfigPreserveFilter(diffs, userVals)).toStrictEqual(expected);
+  });
+
+  it('should handle properties added/removed: include diff if user customized a removed property', () => {
+    const oldDefaults = { oldProperty: 'defaultValue' };
+    const newDefaults = {};
+    const userVals = { oldProperty: 'customValue' };
+    const diffs = diff(oldDefaults, newDefaults);
+    const expected = { oldProperty: null };
+
+    expect(_addonConfigPreserveFilter(diffs, userVals)).toStrictEqual(expected);
+  });
+
+  it('should handle properties added/removed: exclude diff if user did not customize an added property', () => {
+    const oldDefaults = {};
+    const newDefaults = { newProperty: 'defaultValue' };
+    const userVals = { otherProp: 'value' };
+    const diffs = diff(oldDefaults, newDefaults);
+    const expected = {};
+
+    expect(_addonConfigPreserveFilter(diffs, userVals)).toStrictEqual(expected);
+  });
+
+  it('should handle complex nested structures with multiple changes', () => {
+    const oldDefaults = {
+      replicaCount: 1,
+      image:        {
+        repository: 'nginx',
+        tag:        'stable'
+      },
+      service: {
+        type: 'ClusterIP',
+        port: 80
+      },
+      ingress: {
+        enabled: false,
+        hosts:   ['chart-example.local']
+      }
+    };
+    const newDefaults = {
+      replicaCount: 2,
+      image:        {
+        repository: 'nginx',
+        tag:        'mainline'
+      },
+      service: {
+        type: 'ClusterIP',
+        port: 80
+      },
+      ingress: {
+        enabled: true,
+        hosts:   ['chart-example.local', 'new.chart-example.local'],
+        tls:     true
+      }
+    };
+    const userVals = {
+      replicaCount: 3,
+      ingress:      { hosts: ['my.custom.host'] }
+    };
+    const diffs = diff(oldDefaults, newDefaults);
+    const expected = {
+      replicaCount: 2,
+      ingress:      { hosts: ['chart-example.local', 'new.chart-example.local'] }
+    };
+
+    expect(_addonConfigPreserveFilter(diffs, userVals)).toStrictEqual(expected);
+  });
+});
+
+describe('fx: addonConfigPreserve', () => {
+  const ADDON_NAME = 'rke2-my-addon';
+  const mockOldVersionCharts = {
+    [ADDON_NAME]: {
+      repo:    'repo',
+      version: '1.0.0'
+    }
+  };
+
+  const mockNewVersionCharts = {
+    [ADDON_NAME]: {
+      repo:    'repo',
+      version: '1.1.0'
+    }
+  };
+
+  const mockOldVersionInfo = {
+    values: {
+      replicas: 1,
+      service:  { type: 'ClusterIP' }
+    }
+  };
+
+  const mockNewVersionInfo = {
+    values: {
+      replicas:    2, // changed
+      service:     { type: 'ClusterIP' },
+      persistence: true // new
+    }
+  };
+
+  let mockStore: any;
+  let addonConfigDiffs: any;
+  let userChartValues: any;
+  let context: any;
+
+  beforeEach(() => {
+    mockStore = {
+      dispatch: jest.fn((action, payload) => {
+        if (action === 'catalog/getVersionInfo') {
+          if (payload.versionName === '1.0.0') {
+            return Promise.resolve(mockOldVersionInfo);
+          }
+          if (payload.versionName === '1.1.0') {
+            return Promise.resolve(mockNewVersionInfo);
+          }
+        }
+
+        return Promise.resolve({});
+      })
+    };
+    addonConfigDiffs = {};
+    userChartValues = {};
+    context = {
+      addonConfigDiffs,
+      addonNames: [ADDON_NAME],
+      $store:     mockStore,
+      userChartValues,
+    };
+  });
+
+  it('should identify no relevant changes if user has no custom values', async() => {
+    // No user overrides means no relevant differences.
+    context.userChartValues = {};
+    await addonConfigPreserve(context, mockOldVersionCharts, mockNewVersionCharts);
+
+    expect(context.addonConfigDiffs[ADDON_NAME]).toStrictEqual({});
+    expect(context.userChartValues[`${ ADDON_NAME }-1.1.0`]).toBeUndefined();
+  });
+
+  it('should identify no relevant changes if user custom values are for different fields', async() => {
+    // User overrides for non-differing fields should not be considered relevant.
+    context.userChartValues = { [`${ ADDON_NAME }-1.0.0`]: { service: { type: 'NodePort' } } };
+    await addonConfigPreserve(context, mockOldVersionCharts, mockNewVersionCharts);
+
+    expect(context.addonConfigDiffs[ADDON_NAME]).toStrictEqual({});
+    // Since diffs are empty, user values should be preserved
+    expect(context.userChartValues[`${ ADDON_NAME }-1.1.0`]).toStrictEqual({ service: { type: 'NodePort' } });
+  });
+
+  it('should identify relevant changes if user has customized a changed field', async() => {
+    // A user override on a changed default should be flagged as a relevant difference.
+    context.userChartValues = { [`${ ADDON_NAME }-1.0.0`]: { replicas: 3 } };
+    await addonConfigPreserve(context, mockOldVersionCharts, mockNewVersionCharts);
+
+    expect(context.addonConfigDiffs[ADDON_NAME]).toStrictEqual({ replicas: 2 });
+    // Since diffs are NOT empty, user values should NOT be preserved
+    expect(context.userChartValues[`${ ADDON_NAME }-1.1.0`]).toBeUndefined();
+  });
+
+  it('should not identify relevant changes for new fields not customized by user', async() => {
+    // New fields in the addon default values are not relevant if not customized by the user.
+    context.userChartValues = { [`${ ADDON_NAME }-1.0.0`]: {} };
+    await addonConfigPreserve(context, mockOldVersionCharts, mockNewVersionCharts);
+
+    // The only diff is `replicas`, which user didn't touch. `persistence` is new but also not touched.
+    // So final diffs should be empty.
+    expect(context.addonConfigDiffs[ADDON_NAME]).toStrictEqual({});
+    expect(context.userChartValues[`${ ADDON_NAME }-1.1.0`]).toStrictEqual({});
+  });
+
+  it('should preserve user values if there are no relevant differences', async() => {
+    // User values should be carried over to the new version if no relevant diffs are found.
+    context.userChartValues = { [`${ ADDON_NAME }-1.0.0`]: { service: { type: 'NodePort' } } };
+    await addonConfigPreserve(context, mockOldVersionCharts, mockNewVersionCharts);
+
+    expect(context.addonConfigDiffs[ADDON_NAME]).toStrictEqual({});
+    expect(context.userChartValues[`${ ADDON_NAME }-1.1.0`]).toStrictEqual({ service: { type: 'NodePort' } });
+  });
+
+  it('should not preserve user values if there are relevant differences', async() => {
+    // User values should not be carried over if relevant diffs are found.
+    context.userChartValues = { [`${ ADDON_NAME }-1.0.0`]: { replicas: 3 } };
+    await addonConfigPreserve(context, mockOldVersionCharts, mockNewVersionCharts);
+
+    expect(context.addonConfigDiffs[ADDON_NAME]).toStrictEqual({ replicas: 2 });
+    expect(context.userChartValues[`${ ADDON_NAME }-1.1.0`]).toBeUndefined();
+  });
+
+  it('should handle catalog API errors gracefully', async() => {
+    // Errors from fetching chart info should be caught and handled.
+    const error = new Error('catalog fetch failed');
+
+    jest.spyOn(context.$store, 'dispatch').mockImplementation().mockRejectedValue(error);
+    const errorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
+
+    await addonConfigPreserve(context, mockOldVersionCharts, mockNewVersionCharts);
+
+    expect(context.addonConfigDiffs[ADDON_NAME]).toBeUndefined();
+    expect(errorSpy).toHaveBeenCalledWith(`Failed to get chart version info for diff for chart ${ ADDON_NAME }`, error);
+    errorSpy.mockRestore();
+  });
+
+  it('should do nothing if oldCharts is not provided', async() => {
+    await addonConfigPreserve(context, {}, mockNewVersionCharts);
+    expect(context.addonConfigDiffs).toStrictEqual({});
+    expect(mockStore.dispatch).not.toHaveBeenCalled();
+  });
+
+  it('should do nothing if newCharts is not provided', async() => {
+    await addonConfigPreserve(context, mockOldVersionCharts, {});
+    expect(context.addonConfigDiffs).toStrictEqual({});
+    expect(mockStore.dispatch).not.toHaveBeenCalled();
+  });
+
+  it('should do nothing if addon version is the same', async() => {
+    const mockNewVersionSame = {
+      [ADDON_NAME]: {
+        repo:    'repo',
+        version: '1.0.0'
+      }
+    };
+
+    await addonConfigPreserve(context, mockOldVersionCharts, mockNewVersionSame);
+    expect(context.addonConfigDiffs[ADDON_NAME]).toBeUndefined();
+    expect(mockStore.dispatch).not.toHaveBeenCalled();
+  });
+
+  it('should handle multiple addons', async() => {
+    const ADDON2_NAME = 'rke2-my-addon2';
+    const ADDON3_NAME = 'rke2-my-addon3'; // same version
+
+    const oldCharts = {
+      ...mockOldVersionCharts,
+      [ADDON2_NAME]: { repo: 'repo', version: '1.0.0' },
+      [ADDON3_NAME]: { repo: 'repo', version: '1.0.0' },
+    };
+    const newCharts = {
+      ...mockNewVersionCharts,
+      [ADDON2_NAME]: { repo: 'repo', version: '1.1.0' }, // changed version, but no user values
+      [ADDON3_NAME]: { repo: 'repo', version: '1.0.0' }, // same version
+    };
+
+    context.addonNames = [ADDON_NAME, ADDON2_NAME, ADDON3_NAME];
+    context.userChartValues = { [`${ ADDON_NAME }-1.0.0`]: { replicas: 3 } };
+
+    await addonConfigPreserve(context, oldCharts, newCharts);
+
+    expect(context.addonConfigDiffs[ADDON_NAME]).toStrictEqual({ replicas: 2 });
+    expect(context.addonConfigDiffs[ADDON2_NAME]).toStrictEqual({});
+    expect(context.addonConfigDiffs[ADDON3_NAME]).toBeUndefined();
+  });
+});

package/utils/__tests__/object.test.ts

@@ -182,6 +182,25 @@ describe('fx: diff', () => {
 
     expect(result).toStrictEqual(expected);
   });
+  it('should return an object with property "baz" different than "null" if using the flag "preventNull" as true', () => {
+    const from = {
+      foo: 'bar',
+      baz: 'bang',
+    };
+    const to = {
+      foo:  'bar',
+      bang: 'baz'
+    };
+
+    const result = diff(from, to, true);
+    const expected = {
+      // the property "baz" having value !== null covers test case for https://github.com/rancher/dashboard/issues/15710
+      baz:  'bang',
+      bang: 'baz'
+    };
+
+    expect(result).toStrictEqual(expected);
+  });
   it('should return an object and dot characters in object should still be respected', () => {
     const from = {};
     const to = { foo: { 'bar.baz': 'bang' } };

package/utils/__tests__/provider.test.ts

@@ -0,0 +1,98 @@
+import { getHostedProviders, isHostedProvider } from '../provider';
+import { ClusterProvisionerContext, IClusterProvisioner } from '@shell/core/types';
+
+const DEFAULT_CONTEXT = {
+  dispatch: {},
+  getters:  {},
+  axios:    {},
+  t:        (args: any) => args.join(' '),
+};
+
+const MOCK_PROVIDERS: IClusterProvisioner[] = [
+  { id: 'AKS', group: 'hosted' } as IClusterProvisioner,
+  { id: 'EKS', group: 'hosted' } as IClusterProvisioner,
+  { id: 'GKE', group: 'hosted' } as IClusterProvisioner,
+  { id: 'alibaba', group: 'hosted' } as IClusterProvisioner,
+  { id: 'other', group: 'other' } as IClusterProvisioner,
+];
+
+describe('utils/provider', () => {
+  describe('getHostedProviders', () => {
+    it('should return an empty array when context.$extension is undefined', () => {
+      const context = { ...DEFAULT_CONTEXT } as ClusterProvisionerContext;
+      const result = getHostedProviders(context);
+
+      expect(result).toStrictEqual([]);
+    });
+
+    it('should return hosted providers when context.$extension is defined', () => {
+      const context = {
+        ...DEFAULT_CONTEXT,
+        $extension: { getProviders: jest.fn().mockReturnValue(MOCK_PROVIDERS) }
+      } as unknown as ClusterProvisionerContext;
+
+      const result = getHostedProviders(context);
+
+      expect(result).toStrictEqual([
+        { id: 'AKS', group: 'hosted' },
+        { id: 'EKS', group: 'hosted' },
+        { id: 'GKE', group: 'hosted' },
+        { id: 'alibaba', group: 'hosted' },
+      ]);
+      expect(context.$extension.getProviders).toHaveBeenCalledWith(context);
+    });
+
+    it('should return an empty array if getProviders returns null', () => {
+      const context = {
+        ...DEFAULT_CONTEXT,
+        $extension: { getProviders: jest.fn().mockReturnValue(null) }
+      } as unknown as ClusterProvisionerContext;
+
+      const result = getHostedProviders(context);
+
+      expect(result).toStrictEqual([]);
+    });
+
+    it('should return an empty array if getProviders returns undefined', () => {
+      const context = {
+        ...DEFAULT_CONTEXT,
+        $extension: { getProviders: jest.fn().mockReturnValue(undefined) }
+      } as unknown as ClusterProvisionerContext;
+
+      const result = getHostedProviders(context);
+
+      expect(result).toStrictEqual([]);
+    });
+  });
+
+  describe('isHostedProvider', () => {
+    it('should return false if provisioner is not provided', () => {
+      const context = {
+        ...DEFAULT_CONTEXT,
+        $extension: { getProviders: jest.fn().mockReturnValue(MOCK_PROVIDERS) }
+      } as ClusterProvisionerContext;
+
+      expect(isHostedProvider(context, '')).toBe(false);
+      expect(isHostedProvider(context, undefined as any)).toBe(false);
+      expect(isHostedProvider(context, null as any)).toBe(false);
+    });
+
+    it('should return true only if provisioner is in the list of hosted providers', () => {
+      const context = {
+        ...DEFAULT_CONTEXT,
+        $extension: { getProviders: jest.fn().mockReturnValue(MOCK_PROVIDERS) }
+      } as ClusterProvisionerContext;
+
+      expect(isHostedProvider(context, 'AKS')).toBe(true);
+      expect(isHostedProvider(context, 'eks')).toBe(true);
+      expect(isHostedProvider(context, 'different')).toBe(false); // case-insensitive check
+      expect(isHostedProvider(context, 'other')).toBe(false); // case-insensitive check
+    });
+
+    it('should return false if there are no hosted providers', () => {
+      const context = { ...DEFAULT_CONTEXT, $extension: { getProviders: jest.fn().mockReturnValue([]) } } as ClusterProvisionerContext;
+
+      expect(isHostedProvider(context, 'prov1')).toBe(false);
+    });
+  });
+});