@rancher/shell 3.0.8-rc.8 → 3.0.8

package/types/store/__tests__/pagination.types.spec.ts

@@ -0,0 +1,137 @@
+import { PaginationFilterEquality, PaginationFilterField } from '@shell/types/store/pagination.types';
+
+describe('pagination-types', () => {
+  describe('class: PaginationFilterField', () => {
+    describe('constructor', () => {
+      it('should set properties correctly with default values', () => {
+        const field = 'testField';
+        const value = 'testValue';
+        const filterField = new PaginationFilterField({ field, value });
+
+        expect(filterField.field).toBe(field);
+        expect(filterField.value).toBe(value);
+        expect(filterField.equals).toBe(true);
+        expect(filterField.exact).toBe(true);
+        expect(filterField.exists).toBe(false);
+        expect(filterField.equality).toBe(PaginationFilterEquality.EQUALS);
+      });
+
+      it('should handle deprecated `equals` and `exact` to set `equality`', () => {
+      // equals: true, exact: true
+        let ff = new PaginationFilterField({
+          field: 'f', value: 'v', equals: true, exact: true
+        });
+
+        expect(ff.equality).toBe(PaginationFilterEquality.EQUALS);
+
+        // equals: true, exact: false
+        ff = new PaginationFilterField({
+          field: 'f', value: 'v', equals: true, exact: false
+        });
+        expect(ff.equality).toBe(PaginationFilterEquality.CONTAINS);
+
+        // equals: false, exact: true
+        ff = new PaginationFilterField({
+          field: 'f', value: 'v', equals: false, exact: true
+        });
+        expect(ff.equality).toBe(PaginationFilterEquality.NOT_EQUALS);
+
+        // equals: false, exact: false
+        ff = new PaginationFilterField({
+          field: 'f', value: 'v', equals: false, exact: false
+        });
+        expect(ff.equality).toBe(PaginationFilterEquality.NOT_CONTAINS);
+      });
+
+      it('should prioritize `equality` over `equals` and `exact`', () => {
+        const filterField = new PaginationFilterField({
+          field:    'f',
+          value:    'v',
+          equals:   false,
+          exact:    false,
+          equality: PaginationFilterEquality.GREATER_THAN
+        });
+
+        expect(filterField.equality).toBe(PaginationFilterEquality.GREATER_THAN);
+      });
+
+      it('should throw an error if no equality can be determined', () => {
+        expect(() => new PaginationFilterField({
+          field:  'f',
+          value:  'v',
+          equals: null,
+          exact:  null
+        })).toThrow('A pagination filter must have either equals or equality set');
+      });
+
+      it('should set `exists` property', () => {
+        const filterField = new PaginationFilterField({ field: 'f', exists: true });
+
+        expect(filterField.exists).toBe(true);
+      });
+    });
+
+    describe('safeEquality', () => {
+      it('should return EQUALS for equals=true, exact=true', () => {
+        const equality = PaginationFilterField.safeEquality({ equals: true, exact: true });
+
+        expect(equality).toBe(PaginationFilterEquality.EQUALS);
+      });
+
+      it('should return CONTAINS for equals=true, exact=false', () => {
+        const equality = PaginationFilterField.safeEquality({ equals: true, exact: false });
+
+        expect(equality).toBe(PaginationFilterEquality.CONTAINS);
+      });
+
+      it('should return NOT_EQUALS for equals=false, exact=true', () => {
+        const equality = PaginationFilterField.safeEquality({ equals: false, exact: true });
+
+        expect(equality).toBe(PaginationFilterEquality.NOT_EQUALS);
+      });
+
+      it('should return NOT_CONTAINS for equals=false, exact=false', () => {
+        const equality = PaginationFilterField.safeEquality({ equals: false, exact: false });
+
+        expect(equality).toBe(PaginationFilterEquality.NOT_CONTAINS);
+      });
+
+      it('should return equality if it is provided', () => {
+        const equality = PaginationFilterField.safeEquality({ equality: PaginationFilterEquality.IN });
+
+        expect(equality).toBe(PaginationFilterEquality.IN);
+      });
+
+      it('should prioritize equality over equals/exact', () => {
+        const equality = PaginationFilterField.safeEquality({
+          equals:   true,
+          exact:    false,
+          equality: PaginationFilterEquality.LESS_THAN
+        });
+
+        expect(equality).toBe(PaginationFilterEquality.LESS_THAN);
+      });
+
+      it('should return undefined if no equality can be determined', () => {
+        const equality = PaginationFilterField.safeEquality({});
+
+        expect(equality).toBeUndefined();
+      });
+
+      it('should work with an instance of PaginationFilterField', () => {
+        const ff = new PaginationFilterField({
+          field:    'f',
+          value:    'v',
+          equals:   false,
+          exact:    false,
+          equality: PaginationFilterEquality.GREATER_THAN
+        });
+
+        // safeEquality will prioritize the `equality` property on the instance
+        const equality = PaginationFilterField.safeEquality(ff);
+
+        expect(equality).toBe(PaginationFilterEquality.GREATER_THAN);
+      });
+    });
+  });
+});

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/vue-shim.d.ts

@@ -1,7 +1,9 @@
 /* eslint-disable */
-import type ShellApi from '@shell/plugins/internal-api/shell/shell.api';
 import { VuexStore } from '@shell/types/store/vuex';
 
+// Include the types for the APIs
+/// <reference path="../apis/vue-shim.d.ts" />
+
 export {};
 
 declare module 'vue' {
@@ -14,7 +16,6 @@ declare module 'vue' {
       (key: string, args?: Record<string, any>, raw?: boolean): string;
       (options: { k: string; raw?: boolean; tag?: string | Record<string, any>; escapehtml?: boolean }): string;
     },
-    $store: VuexStore,
-    $shell: ShellApi,
+    $store: VuexStore
   }
-}
+}

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