@rancher/shell 3.0.8-rc.1 → 3.0.8-rc.10

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);
+    });
+  });
+});

package/utils/__tests__/selector-typed.test.ts

@@ -0,0 +1,263 @@
+import { labelSelectorToSelector } from '@shell/utils/selector-typed';
+import { KubeLabelSelector } from '@shell/types/kube/kube-api';
+
+describe('selector-typed', () => {
+  describe('labelSelectorToSelector', () => {
+    describe('empty label selectors', () => {
+      it('should return empty string for undefined label selector', () => {
+        const result = labelSelectorToSelector(undefined);
+
+        expect(result).toBe('');
+      });
+
+      it('should return empty string for label selector with no matchLabels and no matchExpressions', () => {
+        const labelSelector: KubeLabelSelector = {};
+        const result = labelSelectorToSelector(labelSelector);
+
+        expect(result).toBe('');
+      });
+
+      it('should return empty string for label selector with empty matchLabels', () => {
+        const labelSelector: KubeLabelSelector = { matchLabels: {} };
+        const result = labelSelectorToSelector(labelSelector);
+
+        expect(result).toBe('');
+      });
+
+      it('should return empty string for label selector with empty matchExpressions', () => {
+        const labelSelector: KubeLabelSelector = { matchExpressions: [] };
+        const result = labelSelectorToSelector(labelSelector);
+
+        expect(result).toBe('');
+      });
+
+      it('should return empty string for label selector with both empty matchLabels and matchExpressions', () => {
+        const labelSelector: KubeLabelSelector = {
+          matchLabels:      {},
+          matchExpressions: []
+        };
+        const result = labelSelectorToSelector(labelSelector);
+
+        expect(result).toBe('');
+      });
+    });
+
+    describe('matchLabels conversion', () => {
+      it('should convert single matchLabel to selector string', () => {
+        const labelSelector: KubeLabelSelector = { matchLabels: { app: 'nginx' } };
+        const result = labelSelectorToSelector(labelSelector);
+
+        expect(result).toBe('app=nginx');
+      });
+
+      it('should convert multiple matchLabels to comma-separated selector string', () => {
+        const labelSelector: KubeLabelSelector = {
+          matchLabels: {
+            app:     'nginx',
+            version: 'v1.0',
+            env:     'production'
+          }
+        };
+        const result = labelSelectorToSelector(labelSelector);
+
+        expect(result).toBe('app=nginx,version=v1.0,env=production');
+      });
+
+      it('should handle matchLabels with special characters', () => {
+        const labelSelector: KubeLabelSelector = { matchLabels: { 'app.kubernetes.io/name': 'my-app' } };
+        const result = labelSelectorToSelector(labelSelector);
+
+        expect(result).toBe('app.kubernetes.io/name=my-app');
+      });
+
+      it('should handle matchLabels with numeric values', () => {
+        const labelSelector: KubeLabelSelector = { matchLabels: { tier: '3' } };
+        const result = labelSelectorToSelector(labelSelector);
+
+        expect(result).toBe('tier=3');
+      });
+    });
+
+    describe('matchExpressions conversion with In operator', () => {
+      it('should convert matchExpression with In operator and single value to equality selector', () => {
+        const labelSelector: KubeLabelSelector = {
+          matchExpressions: [
+            {
+              key:      'app',
+              operator: 'In',
+              values:   ['nginx']
+            }
+          ]
+        };
+        const result = labelSelectorToSelector(labelSelector);
+
+        expect(result).toBe('app=nginx');
+      });
+
+      it('should convert matchExpression with In operator and multiple values to in() selector', () => {
+        const labelSelector: KubeLabelSelector = {
+          matchExpressions: [
+            {
+              key:      'env',
+              operator: 'In',
+              values:   ['dev', 'staging', 'prod']
+            }
+          ]
+        };
+        const result = labelSelectorToSelector(labelSelector);
+
+        expect(result).toBe('env in (dev,staging,prod)');
+      });
+
+      it('should convert multiple matchExpressions with In operator', () => {
+        const labelSelector: KubeLabelSelector = {
+          matchExpressions: [
+            {
+              key:      'app',
+              operator: 'In',
+              values:   ['nginx']
+            },
+            {
+              key:      'env',
+              operator: 'In',
+              values:   ['dev', 'staging']
+            }
+          ]
+        };
+        const result = labelSelectorToSelector(labelSelector);
+
+        expect(result).toBe('app=nginx,env in (dev,staging)');
+      });
+
+      it('should handle matchExpression with empty values array for In operator', () => {
+        const labelSelector: KubeLabelSelector = {
+          matchExpressions: [
+            {
+              key:      'app',
+              operator: 'In',
+              values:   []
+            }
+          ]
+        };
+        const result = labelSelectorToSelector(labelSelector);
+
+        // With empty values array, it should create an in() with no values
+        expect(result).toBe('app in ()');
+      });
+    });
+
+    describe('combined matchLabels and matchExpressions', () => {
+      it('should combine matchLabels and matchExpressions with single values', () => {
+        const labelSelector: KubeLabelSelector = {
+          matchLabels:      { tier: 'frontend' },
+          matchExpressions: [
+            {
+              key:      'env',
+              operator: 'In',
+              values:   ['prod']
+            }
+          ]
+        };
+        const result = labelSelectorToSelector(labelSelector);
+
+        expect(result).toBe('tier=frontend,env=prod');
+      });
+
+      it('should combine multiple matchLabels and matchExpressions', () => {
+        const labelSelector: KubeLabelSelector = {
+          matchLabels: {
+            tier:    'frontend',
+            version: 'v2'
+          },
+          matchExpressions: [
+            {
+              key:      'env',
+              operator: 'In',
+              values:   ['dev', 'staging']
+            },
+            {
+              key:      'region',
+              operator: 'In',
+              values:   ['us-west-1']
+            }
+          ]
+        };
+        const result = labelSelectorToSelector(labelSelector);
+
+        expect(result).toBe('tier=frontend,version=v2,env in (dev,staging),region=us-west-1');
+      });
+
+      it('should combine matchLabels with multiple matchExpressions using in() notation', () => {
+        const labelSelector: KubeLabelSelector = {
+          matchLabels:      { 'app.kubernetes.io/name': 'myapp' },
+          matchExpressions: [
+            {
+              key:      'env',
+              operator: 'In',
+              values:   ['dev', 'test', 'prod']
+            }
+          ]
+        };
+        const result = labelSelectorToSelector(labelSelector);
+
+        expect(result).toBe('app.kubernetes.io/name=myapp,env in (dev,test,prod)');
+      });
+    });
+
+    describe('unsupported operators', () => {
+      it('should throw error for NotIn operator', () => {
+        const labelSelector: KubeLabelSelector = {
+          matchExpressions: [
+            {
+              key:      'env',
+              operator: 'NotIn',
+              values:   ['prod']
+            }
+          ]
+        };
+
+        expect(() => labelSelectorToSelector(labelSelector)).toThrow('Unsupported matchExpression found when converting to selector string.');
+      });
+    });
+
+    describe('edge cases', () => {
+      it('should handle matchExpression with In operator but undefined values', () => {
+        const labelSelector: KubeLabelSelector = {
+          matchExpressions: [
+            {
+              key:      'app',
+              operator: 'In',
+              values:   undefined
+            }
+          ]
+        };
+
+        // When values is undefined, the function throws an error
+        expect(() => labelSelectorToSelector(labelSelector)).toThrow('Unsupported matchExpression found when converting to selector string.');
+      });
+
+      it('should preserve order of matchLabels and matchExpressions', () => {
+        const labelSelector: KubeLabelSelector = {
+          matchLabels: {
+            first:  'value1',
+            second: 'value2'
+          },
+          matchExpressions: [
+            {
+              key:      'third',
+              operator: 'In',
+              values:   ['value3']
+            }
+          ]
+        };
+        const result = labelSelectorToSelector(labelSelector);
+
+        // matchLabels come before matchExpressions
+        expect(result).toContain('first=value1');
+        expect(result).toContain('second=value2');
+        expect(result).toContain('third=value3');
+        expect(result.indexOf('first')).toBeLessThan(result.indexOf('third'));
+      });
+    });
+  });
+});

package/utils/__tests__/version.test.ts

@@ -1,4 +1,4 @@
-import { isDevBuild } from '@shell/utils/version';
+import { isDevBuild, isUpgradeFromPreToStable } from '@shell/utils/version';
 
 describe('fx: isDevBuild', () => {
   it.each([
@@ -16,3 +16,21 @@ describe('fx: isDevBuild', () => {
     }
   );
 });
+
+describe('fx: isUpgradeFromPreToStable', () => {
+  it('should be true when going from pre-release to stable of same version', () => {
+    expect(isUpgradeFromPreToStable('1.0.0-rc1', '1.0.0')).toBe(true);
+  });
+
+  it('should be false when going from stable to pre-release', () => {
+    expect(isUpgradeFromPreToStable('1.0.0', '1.0.0-rc1')).toBe(false );
+  });
+
+  it('should be false for stable to stable', () => {
+    expect(isUpgradeFromPreToStable('1.0.0', '1.1.0')).toBe(false);
+  });
+
+  it('should be false for pre-release to pre-release', () => {
+    expect(isUpgradeFromPreToStable('1.0.0-rc1', '1.0.0-rc2')).toBe(false);
+  });
+});

package/utils/autoscaler-utils.ts

@@ -0,0 +1,7 @@
+import { AUTOSCALER } from '@shell/store/features';
+
+export function isAutoscalerFeatureFlagEnabled(store: any): boolean {
+  const rootGetters = store.rootGetters || store.getters;
+
+  return rootGetters['features/get'](AUTOSCALER);
+}

package/utils/back-off.ts

@@ -137,9 +137,9 @@ class BackOff {
 
       // First step is immediate (0.001s)
       // Second and others are exponential
-      // 1,      2,     3,  4,     5,  6,      7,   8,      9
-      // 1,      4,     9, 16,    25, 36,     49,  64,     81
-      // 0.25s, 1s, 2.25s, 4s, 6.25s, 9s, 12.25s, 16s, 20.25s
+      // Try:         1,     2,   3,     4,    5,      6,    7,       8,    9
+      // Multiple:    1,     4,   9,     16,   25,     36,   49,      64,   81
+      // Actual Time: 0.25s, 1s,  2.25s, 4s,   6.25s,  9s,   12.25s,  16s,  20.25s
       const delay = backOffTry === 0 ? 1 : Math.pow(backOffTry, 2) * 250;
 
       this.log('info', id, `Delaying call (attempt ${ backOffTry + 1 }, delayed by ${ delay }ms)`, description);

package/utils/brand.ts

@@ -0,0 +1,29 @@
+/**
+ * Brand/Theme metadata
+ */
+export interface BrandMeta {
+  // Does the banner have a stylesheet?
+  hasStylesheet?: string;
+  banner?: {
+    // Text alignment for the banner text overlayed on the banner image
+    textAlign?: string;
+  }
+}
+
+/**
+ * Get the brand/theme meta information for the specified brand
+ *
+ * @param brand - The brand identifier
+ * @returns Brand meta information or empty object if none available
+ */
+export function getBrandMeta(brand: string): BrandMeta {
+  let brandMeta: BrandMeta = {};
+
+  if (brand) {
+    try {
+      brandMeta = require(`~shell/assets/brand/${ brand }/metadata.json`);
+    } catch {}
+  }
+
+  return brandMeta;
+}

package/utils/chart.js

@@ -0,0 +1,18 @@
+import { compatibleVersionsFor } from '@shell/store/catalog';
+
+/**
+ * Get the latest chart version that is compatible with the cluster's OS and user's pre-release preference.
+ * @param {Object} chart - The chart object.
+ * @param {Array<string>} workerOSs - The list of worker OSs for the cluster.
+ * @param {boolean} showPrerelease - Whether to include pre-release versions.
+ * @returns {Object} The latest compatible chart version object.
+ */
+export function getLatestCompatibleVersion(chart, workerOSs, showPrerelease) {
+  if (!chart?.versions?.length) {
+    return {};
+  }
+
+  const compatible = compatibleVersionsFor(chart, workerOSs, showPrerelease);
+
+  return (compatible.length ? compatible[0] : chart.versions[0]) || {};
+}

package/utils/color.js

@@ -13,7 +13,7 @@ Primary color classes from _light.scss
 
 */
 
-const Color = require('color');
+import Color from 'color';
 
 export function createCssVars(color, theme = 'light', name = 'primary') {
   const contrastOpts = theme === 'light' ? LIGHT_CONTRAST_COLORS : DARK_CONTRAST_COLORS;