@rancher/shell 3.0.12-rc.2 → 3.0.12-rc.4

package/types/store/dashboard-store.types.ts

@@ -2,21 +2,68 @@ import { KubeLabelSelector } from '@shell/types/kube/kube-api';
 import { PaginationArgs, StorePagination } from '@shell/types/store/pagination.types';
 
 /**
- * Properties on all findX actions
+ * @internal
+ * Core properties on all findX actions
  */
-export type ActionCoreFindArgs = {
+export type ActionCoreFindOptions = {
+  /**
+   * Use this to override URL instead of looking up the URL for the type/id
+   */
   url?: string,
+  /**
+   * Force the request to go to the server instead of checking for a cached value first
+   */
   force?: boolean,
 }
 
 /**
+ * @internal
+ * Args used for find action
+ */
+export interface ActionFindArgs extends ActionCoreFindOptions {
+  /**
+   * Watch for changes
+   *
+   * false = no, all other values = yes
+   */
+  watch?: boolean,
+  /**
+   * @internal
+   * Whether to invalidate the page cache (default: false)
+   */
+  invalidatePageCache?: boolean,
+  /**
+   * XHR request verbs `get`, `post`, `put`, `delete` (default: get)
+   */
+  method?: string,
+  /**
+   * Used if we want to specify custom headers for the request
+   */
+  headers?: object,
+  /**
+   * Use this to override URL instead of looking up the URL for the type/id
+   */
+  url?: string,
+}
+
+/**
+ * @internal
  * Args used for findAll action
  */
-export interface ActionFindAllArgs extends ActionCoreFindArgs {
+export interface ActionFindAllArgs extends ActionCoreFindOptions {
+  /**
+   * Watch for changes
+   *
+   * false = no, all other values = yes
+   */
   watch?: boolean,
+  /**
+   * Array of namespaces to filter by (used in url path, not part of pagination params)
+   */
   namespaced?: string[],
   /**
-   * Should resources be fetched in increments?
+   * @internal
+   * Properties that determine and control if resources should be fetched in increments
    */
   incremental?: {
     /**
@@ -38,24 +85,32 @@ export interface ActionFindAllArgs extends ActionCoreFindArgs {
      */
     pageByNumber: boolean,
   },
+  /**
+   * @internal
+   * Flag to indicate if this request is coming from a list with manual refresh, which may require different handling in the store
+   */
   hasManualRefresh?: boolean,
+  /**
+   * Number of records to return per page
+   */
   limit?: number,
   /**
-   * Iterate over all pages and return all resources.
-   *
-   * This is done via the native kube pagination api, not steve
+   * @internal
+   * Iterate over all pages and return all resources. This is done via the native kube pagination api, not Steve
    */
   depaginate?: boolean,
   /**
+   * @internal
    * Specifies the name to use if we should save the count returned in the paginated request
    */
   saveCountAs?: string,
 }
 
 /**
+ * @internal
  * Args used for findPage action
  */
-export interface ActionFindPageArgs extends ActionCoreFindArgs {
+export interface ActionFindPageArgs extends ActionCoreFindOptions {
   /**
    * Set of pagination settings that creates the url.
    *
@@ -73,6 +128,7 @@ export interface ActionFindPageArgs extends ActionCoreFindArgs {
    */
   watch?: boolean,
   /**
+   * @internal
    * Does this request stem from a list with manual refresh?
    */
   hasManualRefresh?: boolean,
@@ -81,6 +137,10 @@ export interface ActionFindPageArgs extends ActionCoreFindArgs {
    */
   transient?: boolean,
 
+  /**
+   * @internal
+   * Specifies the name to use if we should save the count returned in the paginated request
+   */
   saveCountAs?: string,
 
   /**
@@ -97,6 +157,14 @@ export interface ActionFindPageArgs extends ActionCoreFindArgs {
 }
 
 /**
+ * @internal
+ * Response to the find action
+ * resource object returned by the API, or null if not found
+ */
+export type ActionFindResponse<T = any> = T;
+
+/**
+ * @internal
  * Response to a transient (not stored in cache) findPage action
  */
 export type ActionFindPageTransientResponse<T = any> = {
@@ -105,6 +173,7 @@ export type ActionFindPageTransientResponse<T = any> = {
 };
 
 /**
+ * @internal
  * Response to the findPage action
  *
  * If the request was transient (not stored in cache) this will be an object contain all the details of the request
@@ -114,20 +183,48 @@ export type ActionFindPageTransientResponse<T = any> = {
 export type ActionFindPageResponse<T = any> = ActionFindPageTransientResponse | T[];
 
 /**
- * Args used for findPage action
+ * Args used for findMatching action
  */
-export interface ActionFindMatchingArgs extends ActionCoreFindArgs {
+export interface ActionFindMatchingArgs extends ActionCoreFindOptions {
+  /**
+   * Represents the label selector to filter by
+   * @example
+   * ```
+   * {
+   *   matchLabels: {
+   *     app: 'my-app',
+   *     tier: 'frontend'
+   *   },
+   *   matchExpressions: [
+   *     {
+   *       key: 'environment',
+   *       operator: 'In',
+   *       values: ['production', 'staging']
+   *     }
+   *   ]
+   * }
+   * ```
+   */
   labelSelector: KubeLabelSelector,
+  /**
+   * The single namespace to filter by (used in url path, not part of pagination params)
+   */
   namespaced?: string,
+  /**
+   * @internal
+   * Iterate over all pages and return all resources.
+   */
   depaginate?: boolean
 }
 
 /**
+ * @internal
  * Response to the findMatching action
  */
 export type ActionFindMatchingResponse<T = any> = ActionFindPageResponse<T>
 
 /**
+ * @internal
  * Args used for findLabelSelector action
  */
-export type ActionFindLabelSelectorArgs = ActionFindPageArgs | ActionFindMatchingArgs;
+export type ActionFindLabelSelectorArgs = Omit<ActionFindPageArgs, 'pagination' | 'namespace'> | ActionFindMatchingArgs;

package/types/store/pagination.types.ts

@@ -44,13 +44,16 @@ export interface PaginationSort {
    * Name of field within the object to sort by
    */
   field: string,
+  /**
+   * Sort direction. `true` for ascending, `false` for descending
+   */
   asc: boolean
 }
 
 /**
  * Equalities that can be used with a `filter` query param
  *
- * filter=<field><equality><values>
+ * `filter=<field><equality><values>`
  *
  * For example
  * - filter=a=b
@@ -143,14 +146,14 @@ type FilterFieldCtorArgs = {
 /**
  * Filter the pagination result by these specific fields
  *
- * In format of <field><equality><value>
+ * In format of `<field><equality><value>`
  *
  * For example
  *
  * - metadata.name=test
  * - metadata.namespace!=system
  *
- * These are sub items for @PaginationParam, for example filter=<PaginationFilterField>
+ * These are sub items for {@link PaginationParam}, for example `filter=<PaginationFilterField>`
  *
  * For more information regarding the API see https://github.com/rancher/steve?tab=readme-ov-file#query-parameters
  */

package/utils/__tests__/alertmanagerconfig.test.ts

@@ -0,0 +1,117 @@
+import { Buffer } from 'buffer';
+import { areRoutesSupportedFormat, canCreate, createDefaultRouteName } from '@shell/utils/alertmanagerconfig';
+
+function makeSecret(yaml: string | null): { data: Record<string, string> } {
+  if (yaml === null) {
+    return { data: {} };
+  }
+
+  return { data: { 'alertmanager.yaml': Buffer.from(yaml).toString('base64') } };
+}
+
+describe('alertmanagerconfig utils', () => {
+  describe('createDefaultRouteName', () => {
+    it.each([
+      {
+        desc:     'index 0',
+        index:    0,
+        expected: 'route-0',
+      },
+      {
+        desc:     'index 1',
+        index:    1,
+        expected: 'route-1',
+      },
+      {
+        desc:     'index 99',
+        index:    99,
+        expected: 'route-99',
+      },
+    ])('returns $expected for $desc', ({ index, expected }) => {
+      expect(createDefaultRouteName(index)).toStrictEqual(expected);
+    });
+  });
+
+  describe('areRoutesSupportedFormat', () => {
+    it('returns true when secret has no data', () => {
+      const secret = makeSecret(null);
+
+      expect(areRoutesSupportedFormat(secret)).toStrictEqual(true);
+    });
+
+    it('returns true when config has no routes', () => {
+      const secret = makeSecret('receivers: []\nroute: {}');
+
+      expect(areRoutesSupportedFormat(secret)).toStrictEqual(true);
+    });
+
+    it('returns true when all routes are non-empty', () => {
+      const yaml = `
+receivers: []
+route:
+  routes:
+    - receiver: team-a
+      match:
+        severity: critical
+`;
+      const secret = makeSecret(yaml);
+
+      expect(areRoutesSupportedFormat(secret)).toStrictEqual(true);
+    });
+
+    it('returns false when any route is an empty object', () => {
+      const yaml = `
+receivers: []
+route:
+  routes:
+    - {}
+`;
+      const secret = makeSecret(yaml);
+
+      expect(areRoutesSupportedFormat(secret)).toStrictEqual(false);
+    });
+
+    it('returns false when the yaml is invalid', () => {
+      const secret = { data: { 'alertmanager.yaml': Buffer.from(': invalid: yaml: {').toString('base64') } };
+
+      expect(areRoutesSupportedFormat(secret)).toStrictEqual(false);
+    });
+
+    it('returns true when routes array is empty', () => {
+      const yaml = `
+route:
+  routes: []
+`;
+      const secret = makeSecret(yaml);
+
+      expect(areRoutesSupportedFormat(secret)).toStrictEqual(true);
+    });
+
+    it('returns false when one of multiple routes is empty', () => {
+      const yaml = `
+receivers: []
+route:
+  routes:
+    - receiver: team-a
+    - {}
+`;
+      const secret = makeSecret(yaml);
+
+      expect(areRoutesSupportedFormat(secret)).toStrictEqual(false);
+    });
+  });
+
+  describe('canCreate', () => {
+    it('returns true when secret type is creatable', () => {
+      const rootGetters = { 'type-map/optionsFor': () => ({ isCreatable: true }) };
+
+      expect(canCreate(rootGetters)).toStrictEqual(true);
+    });
+
+    it('returns false when secret type is not creatable', () => {
+      const rootGetters = { 'type-map/optionsFor': () => ({ isCreatable: false }) };
+
+      expect(canCreate(rootGetters)).toStrictEqual(false);
+    });
+  });
+});

package/utils/__tests__/async.test.ts

@@ -0,0 +1,87 @@
+import { waitFor, wait } from '@shell/utils/async';
+
+describe('wait', () => {
+  it('resolves after the specified delay', async() => {
+    jest.useFakeTimers();
+
+    const p = wait(1000);
+
+    jest.advanceTimersByTime(1000);
+    await expect(p).resolves.toBeUndefined();
+
+    jest.useRealTimers();
+  });
+
+  it('does not resolve before the delay elapses', async() => {
+    jest.useFakeTimers();
+
+    let resolved = false;
+    const p = wait(500).then(() => {
+      resolved = true;
+    });
+
+    jest.advanceTimersByTime(499);
+    expect(resolved).toBe(false);
+
+    jest.advanceTimersByTime(1);
+    await p;
+    expect(resolved).toBe(true);
+
+    jest.useRealTimers();
+  });
+});
+
+describe('waitFor', () => {
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  it('resolves immediately when testFn returns true on first call', async() => {
+    jest.useFakeTimers();
+    const testFn = jest.fn().mockReturnValue(true);
+
+    const p = waitFor(testFn, 'ready');
+
+    await expect(p).resolves.toBeDefined();
+    expect(testFn).toHaveBeenCalledTimes(1);
+  });
+
+  it('resolves after testFn eventually returns true', async() => {
+    jest.useFakeTimers();
+    let count = 0;
+    const testFn = jest.fn().mockImplementation(() => {
+      count++;
+
+      return count >= 3;
+    });
+
+    const p = waitFor(testFn, 'ready', 10000, 500);
+
+    // first call returns false (immediate check), then intervals fire
+    jest.advanceTimersByTime(500); // interval 1 → count=2, false
+    jest.advanceTimersByTime(500); // interval 2 → count=3, true
+    await p;
+
+    expect(testFn).toHaveBeenCalledTimes(3);
+  });
+
+  it('rejects with msg when timeout elapses', async() => {
+    jest.useFakeTimers();
+    const testFn = jest.fn().mockReturnValue(false);
+
+    const p = waitFor(testFn, 'some condition', 1000, 500);
+
+    jest.advanceTimersByTime(1001);
+    await expect(p).rejects.toThrow('Failed waiting for: some condition');
+  });
+
+  it('rejects with generic message when no msg provided and timeout elapses', async() => {
+    jest.useFakeTimers();
+    const testFn = jest.fn().mockReturnValue(false);
+
+    const p = waitFor(testFn, '', 2000, 500);
+
+    jest.advanceTimersByTime(2001);
+    await expect(p).rejects.toThrow('waitFor timed out after 2 seconds');
+  });
+});