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

package/types/store/pagination.types.ts

@@ -13,6 +13,8 @@ import { KubeLabelSelector } from '@shell/types/kube/kube-api';
 // The two important / complex params are currently
 // - `filter` https://github.com/rancher/steve?tab=readme-ov-file#filter
 //   - represented by `PaginationParamFilter extends PaginationParam`
+//   - a filter has filter fields which are made up of a field name, equality and value/s
+//     - filter=<field><equality><value>
 //   - Examples
 //     - filter=metadata.name=123
 //     - filter=metadata.name=123,metadata.name=456 (name is 123 OR 456)
@@ -45,14 +47,111 @@ export interface PaginationSort {
   asc: boolean
 }
 
+/**
+ * Equalities that can be used with a `filter` query param
+ *
+ * filter=<field><equality><values>
+ *
+ * For example
+ * - filter=a=b
+ * - filter=a!=b
+ * - filter=a NOT IN (b,c,d)
+ */
+export const enum PaginationFilterEquality {
+  /**
+   * Field is in a collection of values
+   */
+  IN = ' IN ', // eslint-disable-line no-unused-vars
+  /**
+   * Field is not in a collection of values
+   */
+  NOT_IN = ' NOTIN ', // eslint-disable-line no-unused-vars
+  /**
+   * Field matches a value
+   */
+  EQUALS= '=', // eslint-disable-line no-unused-vars
+  /**
+   * Field does not match a value
+   */
+  NOT_EQUALS= '!=', // eslint-disable-line no-unused-vars
+  /**
+   * Unknown
+   */
+  STRICT_EQUALS = '==', // eslint-disable-line no-unused-vars
+  /**
+   * Field must partially match a value
+   */
+  CONTAINS= '~', // eslint-disable-line no-unused-vars
+  /**
+   * Field must not partially match a value
+   */
+  NOT_CONTAINS= '!~', // eslint-disable-line no-unused-vars
+  /**
+   * Field must be greater than a value
+   */
+  GREATER_THAN= 'gt', // eslint-disable-line no-unused-vars
+  /**
+   * Field must be less than a value
+   */
+  LESS_THAN= 'lt', // eslint-disable-line no-unused-vars
+}
+
+/**
+ * Ctor args for a @PaginationFilterField
+ */
+type FilterFieldCtorArgs = {
+  /**
+   * Name of field within the object to filter by for example the x of x=y
+   *
+   * This can be optional for some (projectsornamespaces)
+   */
+  field?: string;
+    /**
+   * Value of field within the object to filter by for example the y of x=y
+   *
+   * This can be empty if `exists` is true
+   */
+  value?: string;
+  /**
+   * Equality field within the object to filter by for example the `=` or `!=` of x=y
+   *
+   * @deprecated Please use `equality` instead of equals and exact
+   */
+  equals?: boolean;
+  /**
+   * Match the field exactly. False for partial matches
+   *
+   * Value: pod1
+   * Exact: true. "p" no, "pod", no, "pod1" yes
+   * Exact: false. "p" yes, "pod", yes, "pod1" yes
+   *
+   * @deprecated Please use `equality` instead of equals and exact
+   */
+  exact?: boolean,
+  /**
+   * Check if the field/property exists, regardless of value
+   *
+   * If this is false it does not flip the expectation, just doesn't add the field
+   */
+  exists?: boolean,
+  /**
+   * Equality symbol used to compare the field with the value
+   */
+  equality?: PaginationFilterEquality
+}
+
 /**
  * Filter the pagination result by these specific fields
  *
+ * In format of <field><equality><value>
+ *
  * For example
  *
  * - metadata.name=test
  * - metadata.namespace!=system
  *
+ * These are sub items for @PaginationParam, for example filter=<PaginationFilterField>
+ *
  * For more information regarding the API see https://github.com/rancher/steve?tab=readme-ov-file#query-parameters
  */
 export class PaginationFilterField {
@@ -70,6 +169,8 @@ export class PaginationFilterField {
   value?: string;
   /**
    * Equality field within the object to filter by for example the `=` or `!=` of x=y
+   *
+   * @deprecated Please use `equality` instead of equals and exact
    */
   equals?: boolean;
   /**
@@ -78,9 +179,14 @@ export class PaginationFilterField {
    * Value: pod1
    * Exact: true. "p" no, "pod", no, "pod1" yes
    * Exact: false. "p" yes, "pod", yes, "pod1" yes
+   *
+   * @deprecated Please use `equality` instead of equals and exact
    */
   exact?: boolean;
-
+  /**
+   * Equality symbol used to compare the field with the value
+   */
+  equality?: PaginationFilterEquality;
   /**
    * Check if the field/property exists, regardless of value
    *
@@ -88,17 +194,51 @@ export class PaginationFilterField {
    */
   exists?: boolean;
 
-  constructor(
-    {
-      field, value = '', equals = true, exact = true, exists = false
-    }:
-    { field?: string; value?: string; equals?: boolean; exact?: boolean; exists?:boolean;}
-  ) {
+  constructor(args: FilterFieldCtorArgs) {
+    const {
+      field, value = '', equals = true, exact = true, equality = undefined, exists = false
+    } = args;
+
     this.field = field;
     this.value = value;
     this.equals = equals;
     this.exact = exact;
     this.exists = exists;
+
+    const _equality = PaginationFilterField.safeEquality({
+      field, value, equals, exact, equality, exists
+    });
+
+    if (_equality) {
+      this.equality = _equality;
+    } else {
+      throw new Error('A pagination filter must have either equals or equality set');
+    }
+  }
+
+  /**
+   * Determine equality for this field.
+   *
+   * Mainly to ensure legacy objects using deprecated fields instead of new equality field fall back on something sensible
+   */
+  static safeEquality(args: FilterFieldCtorArgs | PaginationFilterField): PaginationFilterEquality | undefined {
+    if (args.equality) {
+      return args.equality;
+    }
+
+    if (args.equals === true) {
+      if (args.exact === true) {
+        return PaginationFilterEquality.EQUALS;
+      } else {
+        return PaginationFilterEquality.CONTAINS;
+      }
+    } else if (args.equals === false) {
+      if (args.exact === true) {
+        return PaginationFilterEquality.NOT_EQUALS;
+      } else {
+        return PaginationFilterEquality.NOT_CONTAINS;
+      }
+    }
   }
 }
 
@@ -202,7 +342,15 @@ export abstract class PaginationParam {
 }
 
 /**
- * This is a convenience class for the `filter` param which works some magic, adds defaults and converts to the required PaginationParam format
+ * This is a convenience class for the `filter` param which works some magic, adds defaults and converts to the required PaginationParam format.
+ *
+ * for example
+ *
+ * - filter=???
+ *
+ * including `fields` this could be
+ *
+ * - filter=a=b
  *
  * See description for {@link PaginationParam} for how multiple of these can be combined together to AND or OR together
  *
@@ -238,7 +386,7 @@ export class PaginationParamFilter extends PaginationParam {
   /**
    * Convenience method when you just want an instance of {@link PaginationParamFilter} with a simple `filter=x=y` param
    */
-  static createSingleField(field: { field?: string; value?: string; equals?: boolean; exact?: boolean, exists?: boolean }): PaginationParam {
+  static createSingleField(field: FilterFieldCtorArgs): PaginationParam {
     return new PaginationParamFilter({ fields: [new PaginationFilterField(field)] });
   }
 

package/types/store/subscribe-events.types.ts

@@ -12,10 +12,17 @@ export interface STEVE_WATCH_EVENT_PARAMS_COMMON {
   params: STEVE_WATCH_PARAMS,
 }
 
+/**
+ * Args for @STEVE_WATCH_EVENT_LISTENER_CALLBACK
+ */
+export type STEVE_WATCH_EVENT_LISTENER_CALLBACK_PARAMS = {
+  forceWatch?: boolean,
+}
+
 /**
  * Executes when a watch event has a listener and it's triggered
  */
-export type STEVE_WATCH_EVENT_LISTENER_CALLBACK = () => void
+export type STEVE_WATCH_EVENT_LISTENER_CALLBACK = (params: STEVE_WATCH_EVENT_LISTENER_CALLBACK_PARAMS) => void
 
 /**
  * Common params used when a watcher adds a listener to a watch

package/types/store/subscribe.types.ts

@@ -30,5 +30,6 @@ export interface STEVE_WATCH_PARAMS {
   namespace?: string,
   stop?: boolean,
   force?: boolean,
+  forceWatch?: boolean,
   mode?: STEVE_WATCH_MODE
 }

package/types/window-manager.ts

@@ -0,0 +1,24 @@
+import { BOTTOM, CENTER, LEFT, RIGHT } from '@shell/utils/position';
+
+// Defines the possible layouts where the window manager can be used.
+export const enum Layout {
+  default = 'default', // eslint-disable-line no-unused-vars
+  home = 'home', // eslint-disable-line no-unused-vars
+  plain = 'plain', // eslint-disable-line no-unused-vars
+}
+
+export type Position = typeof BOTTOM | typeof LEFT | typeof RIGHT | typeof CENTER;
+
+export interface Tab {
+  id: string,
+  icon: string,
+  label: string,
+  component?: string,
+  extensionId?: string,
+  position: Position,
+  layouts: Layout[],
+  showHeader: boolean,
+  containerHeight: number | null,
+  containerWidth: number | null,
+  attrs?: Record<string, any>,
+}

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