@rancher/shell 3.0.5-rc.6 → 3.0.5-rc.8

package/types/store/pagination.types.ts

@@ -64,12 +64,14 @@ export class PaginationFilterField {
   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;
+  value?: string;
   /**
    * Equality field within the object to filter by for example the `=` or `!=` of x=y
    */
-  equals: boolean;
+  equals?: boolean;
   /**
    * Match the field exactly. False for partial matches
    *
@@ -77,18 +79,26 @@ export class PaginationFilterField {
    * Exact: true. "p" no, "pod", no, "pod1" yes
    * Exact: false. "p" yes, "pod", yes, "pod1" yes
    */
-  exact: boolean;
+  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;
 
   constructor(
     {
-      field, value, equals = true, exact = true
+      field, value = '', equals = true, exact = true, exists = false
     }:
-    { field?: string; value: string; equals?: boolean; exact?: boolean;}
+    { field?: string; value?: string; equals?: boolean; exact?: boolean; exists?:boolean;}
   ) {
     this.field = field;
     this.value = value;
     this.equals = equals;
     this.exact = exact;
+    this.exists = exists;
   }
 }
 
@@ -228,7 +238,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 }): PaginationParam {
+  static createSingleField(field: { field?: string; value?: string; equals?: boolean; exact?: boolean, exists?: boolean }): PaginationParam {
     return new PaginationParamFilter({ fields: [new PaginationFilterField(field)] });
   }
 

package/types/uiplugins.ts

@@ -0,0 +1,73 @@
+export type VersionCompatibility = {
+    isVersionCompatible: boolean;
+    versionIncompatibilityData: any;
+  };
+
+export type ChartVersion = {
+    name: string;
+    version: string;
+    description: string;
+    icon: string;
+    apiVersion: string;
+    appVersion: string;
+    annotations: {
+      [key: string]: string;
+    };
+    type: string;
+    urls: string[];
+    created: string;
+    digest: string;
+    key: string;
+    repoType: string;
+    repoName: string;
+  };
+
+export type Version = ChartVersion & VersionCompatibility;
+
+export type Chart = {
+    key: string;
+    type: string;
+    id: string;
+    certified: string;
+    sideLabel?: string;
+    repoType: string;
+    repoName: string;
+    repoNameDisplay: string;
+    certifiedSort: number;
+    icon: string;
+    color?: string;
+    chartType: string;
+    chartName: string;
+    chartNameDisplay: string;
+    chartDescription: string;
+    repoKey: string;
+    versions: ChartVersion[];
+    categories: any[];
+    deprecated: boolean;
+    experimental: boolean;
+    hidden: boolean;
+    targetNamespace: string;
+    scope: string;
+    provides: any[];
+    windowsIncompatible: boolean;
+    deploysOnWindows: boolean;
+  };
+
+export type Plugin = {
+    name: string;
+    label: string;
+    description: string;
+    id: string;
+    versions: Version[];
+    installed: boolean;
+    builtin: boolean;
+    experimental: boolean;
+    certified: boolean;
+    chart: Chart;
+    incompatibilityMessage: string;
+    installableVersions: ChartVersion[];
+    displayVersion: string;
+    pluginVersionLabel: string;
+    icon?: string;
+    helmError: boolean;
+  };

package/utils/__tests__/back-off.test.ts

@@ -0,0 +1,354 @@
+// Import the BackOff instance from your code.
+// Assuming the file is named `backoff.ts` and the default export is the BackOff instance.
+import backOff from '../back-off';
+
+describe('backOff', () => {
+  // Use Jest's fake timers to control `setTimeout`. This is crucial for testing delays.
+  jest.useFakeTimers();
+
+  // Mock console.log to prevent test logs from cluttering the console output.
+  let consoleLogMock: jest.SpyInstance;
+  let consoleErrorMock: jest.SpyInstance;
+
+  beforeEach(() => {
+    // Before each test, reset the BackOff state.
+    backOff.resetAll();
+
+    // Create new mocks for each test to ensure a clean slate.
+    consoleLogMock = jest.spyOn(console, 'log').mockImplementation(() => {});
+    consoleErrorMock = jest.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    // Restore the original console functions after each test.
+    consoleLogMock.mockRestore();
+    consoleErrorMock.mockRestore();
+  });
+
+  // --- Test Suite for `execute` method ---
+
+  it('should execute the function immediately the first time without a delay', async() => {
+    const delayedFn = jest.fn();
+
+    // Call the function for the first time.
+    await backOff.execute({
+      id: 'test1', description: 'Test 1', delayedFn
+    });
+
+    // The function should have been called immediately, since the fake timer hasn't advanced.
+    expect(delayedFn).toHaveBeenCalledTimes(0);
+    expect(backOff.getBackOff('test1')).toBeDefined();
+  });
+
+  it('should back off and delay the second execution', async() => {
+    const delayedFn = jest.fn();
+    const id = 'backoff-test';
+
+    // First call, which should run immediately.
+    await backOff.execute({
+      id, description: 'Backoff Test', delayedFn,
+    });
+
+    jest.advanceTimersByTime(1);
+
+    // Expect the first call to be immediate.
+    expect(delayedFn).toHaveBeenCalledTimes(1);
+
+    // Call it a second time. This should initiate a backoff delay.
+    await backOff.execute({
+      id, description: 'Backoff Test', delayedFn
+    });
+
+    // The function should not have been called a second time yet.
+    expect(delayedFn).toHaveBeenCalledTimes(1);
+
+    // Advance the timer by less than the first backoff delay (250ms).
+    jest.advanceTimersByTime(200);
+    expect(delayedFn).toHaveBeenCalledTimes(1);
+
+    // Now, advance the timer by the required delay to trigger the second call.
+    jest.advanceTimersByTime(50);
+
+    // The function should have been called a second time.
+    await Promise.resolve();
+    expect(delayedFn).toHaveBeenCalledTimes(2);
+
+    // Verify the backoff entry was created correctly.
+    const backOffEntry = backOff.getBackOff(id);
+
+    expect(backOffEntry.try).toBe(2);
+  });
+
+  it('should implement exponential backoff on subsequent calls', async() => {
+    const delayedFn = jest.fn();
+    const id = 'exp-backoff';
+
+    // First call (immediate)
+    await backOff.execute({
+      id, description: 'Exponential Backoff Test', delayedFn
+    });
+
+    jest.advanceTimersByTime(1);
+    expect(delayedFn).toHaveBeenCalledTimes(1);
+
+    // Second call (should have a delay of 1^2 * 250 = 250ms)
+    await backOff.execute({
+      id, description: 'Exponential Backoff Test', delayedFn
+    });
+    jest.advanceTimersByTime(250);
+    await Promise.resolve();
+    expect(delayedFn).toHaveBeenCalledTimes(2);
+
+    // Third call (should have a delay of 2^2 * 250 = 1000ms)
+    await backOff.execute({
+      id, description: 'Exponential Backoff Test', delayedFn
+    });
+    jest.advanceTimersByTime(1000);
+    await Promise.resolve();
+    expect(delayedFn).toHaveBeenCalledTimes(3);
+
+    // Fourth call (should have a delay of 3^2 * 250 = 2250ms)
+    await backOff.execute({
+      id, description: 'Exponential Backoff Test', delayedFn
+    });
+    jest.advanceTimersByTime(2250);
+    await Promise.resolve();
+    expect(delayedFn).toHaveBeenCalledTimes(4);
+  });
+
+  it('should skip execution if a previous backoff process is already running', async() => {
+    const delayedFn = jest.fn();
+    const id = 'skip-test';
+
+    await backOff.execute({
+      id, description: 'Skip Test', delayedFn
+    });
+    expect(delayedFn).toHaveBeenCalledTimes(0);
+
+    // Second call, will be ignored
+    await backOff.execute({
+      id, description: 'Skip Test', delayedFn
+    });
+
+    expect(delayedFn).toHaveBeenCalledTimes(0);
+
+    // We should only have 1 call so far.
+    jest.advanceTimersByTime(1);
+    await Promise.resolve();
+    expect(delayedFn).toHaveBeenCalledTimes(1);
+
+    // A third call while the first is still pending.
+    // This call should be ignored and the delayedFn should not be executed.
+    await backOff.execute({
+      id, description: 'Skip Test', delayedFn
+    });
+
+    expect(delayedFn).toHaveBeenCalledTimes(1);
+
+    jest.advanceTimersByTime(300);
+    await Promise.resolve();
+    expect(delayedFn).toHaveBeenCalledTimes(2);
+
+    // Advance timers to complete the pending second call.
+    jest.advanceTimersByTime(1000);
+    await Promise.resolve();
+    // Now there should be 2 calls, not 3.
+    expect(delayedFn).toHaveBeenCalledTimes(2);
+  });
+
+  it('should not execute if the number of retries is exceeded', async() => {
+    const delayedFn = jest.fn();
+    const id = 'retries-test';
+
+    // Set retries to 2.
+    const retries = 2;
+
+    // Call 1 (immediate)
+    await backOff.execute({
+      id, description: 'Retries Test', retries, delayedFn
+    });
+    jest.advanceTimersByTime(1);
+    await Promise.resolve();
+    expect(delayedFn).toHaveBeenCalledTimes(1);
+
+    // Call 2 (after 250ms delay)
+    await backOff.execute({
+      id, description: 'Retries Test', retries, delayedFn
+    });
+    jest.advanceTimersByTime(250);
+    await Promise.resolve();
+    expect(delayedFn).toHaveBeenCalledTimes(2);
+
+    // Call 3 (should be ignored because it exceeds the `retries` limit of 2)
+    await backOff.execute({
+      id, description: 'Retries Test', retries, delayedFn
+    });
+    jest.advanceTimersByTime(250);
+    await Promise.resolve();
+
+    expect(delayedFn).toHaveBeenCalledTimes(2);
+  });
+
+  it('should skip execution if `canFn` returns false', async() => {
+    const delayedFn = jest.fn();
+    const canFn = jest.fn().mockResolvedValue(false);
+
+    await backOff.execute({
+      id: 'canfn-test', description: 'canFn Test', canFn, delayedFn
+    });
+
+    jest.advanceTimersByTime(250);
+    await Promise.resolve();
+
+    expect(delayedFn).not.toHaveBeenCalled();
+  });
+
+  it('should not clear backoff entry if the delayedFn throws an error', async() => {
+    const id = 'error-test';
+    const delayedFn = jest.fn().mockRejectedValue(new Error('Test Error'));
+
+    // Call the function for the first time.
+    await backOff.execute({
+      id, description: 'Error Test', delayedFn
+    });
+
+    // Wait for the immediate call to finish.
+    jest.advanceTimersByTime(1);
+    await Promise.resolve();
+    await Promise.resolve();
+    await Promise.resolve();
+
+    // The entry should be removed after success/failure.
+    expect(backOff.getBackOff(id).timeoutId).toBeUndefined();
+
+    // Call again to trigger a backoff delay and an error.
+    await backOff.execute({
+      id, description: 'Error Test', delayedFn
+    });
+
+    // Advance timers to trigger the delayed function.
+    jest.advanceTimersByTime(250);
+    await Promise.resolve();
+    await Promise.resolve();
+    await Promise.resolve();
+
+    // The timeoutId should be cleared, but the `try` count should be preserved on the next call.
+    expect(backOff.getBackOff(id).timeoutId).toBeUndefined();
+
+    // Check if the next call will still back off.
+    const newDelayedFn = jest.fn();
+
+    await backOff.execute({
+      id, description: 'Error Test', delayedFn: newDelayedFn
+    });
+    expect(newDelayedFn).not.toHaveBeenCalled(); // The next call should still be delayed
+  });
+
+  it('should save metadata', async() => {
+    const delayedFn = jest.fn();
+    const id = 'exp-backoff';
+    const metadata = { a: true };
+
+    // First call (immediate)
+    await backOff.execute({
+      id, description: 'Exponential Backoff Test', delayedFn, metadata
+    });
+
+    expect(backOff.getBackOff(id)).toBeDefined();
+    expect(backOff.getBackOff(id).metadata).toStrictEqual(metadata);
+  });
+
+  // --- Test Suite for Reset methods ---
+
+  it('should reset a specific backoff process', async() => {
+    const delayedFn = jest.fn();
+    const id = 'reset-test';
+
+    // Start a backoff process.
+    await backOff.execute({
+      id, description: 'Reset Test', delayedFn
+    });
+
+    expect(backOff.getBackOff(id)).toBeDefined();
+
+    // Reset the process.
+    backOff.reset(id);
+
+    // The entry should be deleted from the map.
+    expect(backOff.getBackOff(id)).toBeUndefined();
+
+    // Now, a new execution should not be delayed.
+    await backOff.execute({
+      id, description: 'Reset Test', delayedFn
+    });
+
+    jest.advanceTimersByTime(250);
+    await Promise.resolve();
+    expect(delayedFn).toHaveBeenCalledTimes(1);
+  });
+
+  it('should reset all backoff processes', async() => {
+    const delayedFn1 = jest.fn();
+    const delayedFn2 = jest.fn();
+
+    await backOff.execute({
+      id: 'all-1', description: 'All 1', delayedFn: delayedFn1
+    });
+    await backOff.execute({
+      id: 'all-1', description: 'All 1', delayedFn: delayedFn1
+    });
+
+    await backOff.execute({
+      id: 'all-2', description: 'All 2', delayedFn: delayedFn2
+    });
+    await backOff.execute({
+      id: 'all-2', description: 'All 2', delayedFn: delayedFn2
+    });
+
+    expect(backOff.getBackOff('all-1')).toBeDefined();
+    expect(backOff.getBackOff('all-2')).toBeDefined();
+
+    // Reset all processes.
+    backOff.resetAll();
+
+    expect(backOff.getBackOff('all-1')).toBeUndefined();
+    expect(backOff.getBackOff('all-2')).toBeUndefined();
+  });
+
+  it('should reset only processes with a specific prefix', async() => {
+    const delayedFn = jest.fn();
+
+    await backOff.execute({
+      id: 'prefix-test-1', description: 'Prefix Test 1', delayedFn
+    });
+    await backOff.execute({
+      id: 'prefix-test-1', description: 'Prefix Test 1', delayedFn
+    });
+
+    await backOff.execute({
+      id: 'prefix-test-2', description: 'Prefix Test 2', delayedFn
+    });
+    await backOff.execute({
+      id: 'prefix-test-2', description: 'Prefix Test 2', delayedFn
+    });
+
+    await backOff.execute({
+      id: 'other-test-1', description: 'Other Test 1', delayedFn
+    });
+    await backOff.execute({
+      id: 'other-test-1', description: 'Other Test 1', delayedFn
+    });
+
+    expect(backOff.getBackOff('prefix-test-1')).toBeDefined();
+    expect(backOff.getBackOff('prefix-test-2')).toBeDefined();
+    expect(backOff.getBackOff('other-test-1')).toBeDefined();
+
+    // Reset only the "prefix-test" processes.
+    backOff.resetPrefix('prefix-test');
+
+    expect(backOff.getBackOff('prefix-test-1')).toBeUndefined();
+    expect(backOff.getBackOff('prefix-test-2')).toBeUndefined();
+    // The other process should still exist.
+    expect(backOff.getBackOff('other-test-1')).toBeDefined();
+  });
+});