@rancher/shell 3.0.8 → 3.0.9-rc.2

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

@@ -1,5 +1,3 @@
-// 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', () => {
@@ -10,345 +8,466 @@ describe('backOff', () => {
   let consoleLogMock: jest.SpyInstance;
   let consoleErrorMock: jest.SpyInstance;
 
-  beforeEach(() => {
+  const beforeEachFn = () => {
     // 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(() => {
+  const afterEachFn = () => {
     // Restore the original console functions after each test.
     consoleLogMock.mockRestore();
     consoleErrorMock.mockRestore();
-  });
+  };
+
+  describe('execute', () => {
+    beforeEach(beforeEachFn);
+
+    afterEach(afterEachFn);
 
-  // --- Test Suite for `execute` method ---
+    it('should execute the function immediately the first time without a delay', async() => {
+      const delayedFn = jest.fn();
 
-  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
+      });
 
-    // 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();
     });
 
-    // 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';
 
-  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,
+      });
 
-    // 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);
 
-    jest.advanceTimersByTime(1);
+      // Call it a second time. This should initiate a backoff delay.
+      await backOff.execute({
+        id, description: 'Backoff Test', delayedFn
+      });
 
-    // Expect the first call to be immediate.
-    expect(delayedFn).toHaveBeenCalledTimes(1);
+      // The function should not have been called a second time yet.
+      expect(delayedFn).toHaveBeenCalledTimes(1);
 
-    // Call it a second time. This should initiate a backoff delay.
-    await backOff.execute({
-      id, description: 'Backoff Test', delayedFn
+      // 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);
     });
 
-    // The function should not have been called a second time yet.
-    expect(delayedFn).toHaveBeenCalledTimes(1);
+    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);
+    });
 
-    // Advance the timer by less than the first backoff delay (250ms).
-    jest.advanceTimersByTime(200);
-    expect(delayedFn).toHaveBeenCalledTimes(1);
+    it('should skip execution if a previous backoff process is already running', async() => {
+      const delayedFn = jest.fn();
+      const id = 'skip-test';
 
-    // Now, advance the timer by the required delay to trigger the second call.
-    jest.advanceTimersByTime(50);
+      await backOff.execute({
+        id, description: 'Skip Test', delayedFn
+      });
+      expect(delayedFn).toHaveBeenCalledTimes(0);
 
-    // The function should have been called a second time.
-    await Promise.resolve();
-    expect(delayedFn).toHaveBeenCalledTimes(2);
+      // Second call, will be ignored
+      await backOff.execute({
+        id, description: 'Skip Test', delayedFn
+      });
 
-    // Verify the backoff entry was created correctly.
-    const backOffEntry = backOff.getBackOff(id);
+      expect(delayedFn).toHaveBeenCalledTimes(0);
 
-    expect(backOffEntry.try).toBe(2);
-  });
+      // We should only have 1 call so far.
+      jest.advanceTimersByTime(1);
+      await Promise.resolve();
+      expect(delayedFn).toHaveBeenCalledTimes(1);
 
-  it('should implement exponential backoff on subsequent calls', async() => {
-    const delayedFn = jest.fn();
-    const id = 'exp-backoff';
+      // 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
+      });
 
-    // First call (immediate)
-    await backOff.execute({
-      id, description: 'Exponential Backoff Test', delayedFn
-    });
+      expect(delayedFn).toHaveBeenCalledTimes(1);
 
-    jest.advanceTimersByTime(1);
-    expect(delayedFn).toHaveBeenCalledTimes(1);
+      jest.advanceTimersByTime(300);
+      await Promise.resolve();
+      expect(delayedFn).toHaveBeenCalledTimes(2);
 
-    // Second call (should have a delay of 1^2 * 250 = 250ms)
-    await backOff.execute({
-      id, description: 'Exponential Backoff Test', delayedFn
+      // 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);
     });
-    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
+    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);
     });
-    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 `canFn` returns false', async() => {
+      const delayedFn = jest.fn();
+      const canFn = jest.fn().mockResolvedValue(false);
 
-  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: 'canfn-test', description: 'canFn Test', canFn, delayedFn
+      });
 
-    await backOff.execute({
-      id, description: 'Skip Test', delayedFn
-    });
-    expect(delayedFn).toHaveBeenCalledTimes(0);
+      jest.advanceTimersByTime(250);
+      await Promise.resolve();
 
-    // Second call, will be ignored
-    await backOff.execute({
-      id, description: 'Skip Test', delayedFn
+      expect(delayedFn).not.toHaveBeenCalled();
     });
 
-    expect(delayedFn).toHaveBeenCalledTimes(0);
+    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'));
 
-    // We should only have 1 call so far.
-    jest.advanceTimersByTime(1);
-    await Promise.resolve();
-    expect(delayedFn).toHaveBeenCalledTimes(1);
+      // Call the function for the first time.
+      await backOff.execute({
+        id, description: 'Error Test', delayedFn
+      });
 
-    // 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(backOff.getBackOff(id).execute?.timeoutId).toBeDefined();
 
-    expect(delayedFn).toHaveBeenCalledTimes(1);
+      // Wait for the immediate call to finish.
+      jest.advanceTimersByTime(1);
+      await Promise.resolve();
+      await Promise.resolve();
+      await Promise.resolve();
 
-    jest.advanceTimersByTime(300);
-    await Promise.resolve();
-    expect(delayedFn).toHaveBeenCalledTimes(2);
+      // The entry should be removed after success/failure.
+      expect(backOff.getBackOff(id).execute?.timeoutId).toBeUndefined();
 
-    // 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);
-  });
+      // Call again to trigger a backoff delay and an error.
+      await backOff.execute({
+        id, description: 'Error Test', delayedFn
+      });
 
-  it('should not execute if the number of retries is exceeded', async() => {
-    const delayedFn = jest.fn();
-    const id = 'retries-test';
+      expect(backOff.getBackOff(id).execute?.timeoutId).toBeDefined();
 
-    // Set retries to 2.
-    const retries = 2;
+      // Advance timers to trigger the delayed function.
+      jest.advanceTimersByTime(250);
+      await Promise.resolve();
+      await Promise.resolve();
+      await Promise.resolve();
 
-    // Call 1 (immediate)
-    await backOff.execute({
-      id, description: 'Retries Test', retries, delayedFn
-    });
-    jest.advanceTimersByTime(1);
-    await Promise.resolve();
-    expect(delayedFn).toHaveBeenCalledTimes(1);
+      // The timeoutId should be cleared, but the `try` count should be preserved on the next call.
+      expect(backOff.getBackOff(id).execute?.timeoutId).toBeUndefined();
 
-    // Call 2 (after 250ms delay)
-    await backOff.execute({
-      id, description: 'Retries Test', retries, delayedFn
-    });
-    jest.advanceTimersByTime(250);
-    await Promise.resolve();
-    expect(delayedFn).toHaveBeenCalledTimes(2);
+      // Check if the next call will still back off.
+      const newDelayedFn = jest.fn();
 
-    // Call 3 (should be ignored because it exceeds the `retries` limit of 2)
-    await backOff.execute({
-      id, description: 'Retries Test', retries, delayedFn
+      await backOff.execute({
+        id, description: 'Error Test', delayedFn: newDelayedFn
+      });
+      expect(newDelayedFn).not.toHaveBeenCalled(); // The next call should still be delayed
     });
-    jest.advanceTimersByTime(250);
-    await Promise.resolve();
 
-    expect(delayedFn).toHaveBeenCalledTimes(2);
-  });
+    it('should save metadata', async() => {
+      const delayedFn = jest.fn();
+      const id = 'exp-backoff';
+      const metadata = { a: true };
 
-  it('should skip execution if `canFn` returns false', async() => {
-    const delayedFn = jest.fn();
-    const canFn = jest.fn().mockResolvedValue(false);
+      // First call (immediate)
+      await backOff.execute({
+        id, description: 'Exponential Backoff Test', delayedFn, metadata
+      });
 
-    await backOff.execute({
-      id: 'canfn-test', description: 'canFn Test', canFn, delayedFn
+      expect(backOff.getBackOff(id)).toBeDefined();
+      expect(backOff.getBackOff(id).metadata).toStrictEqual(metadata);
     });
+  });
 
-    jest.advanceTimersByTime(250);
-    await Promise.resolve();
+  describe('reset', () => {
+    beforeEach(beforeEachFn);
 
-    expect(delayedFn).not.toHaveBeenCalled();
-  });
+    afterEach(afterEachFn);
 
-  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'));
+    it('should reset a specific backoff process', async() => {
+      const delayedFn = jest.fn();
+      const id = 'reset-test';
 
-    // Call the function for the first time.
-    await backOff.execute({
-      id, description: 'Error Test', delayedFn
-    });
+      // Start a backoff process.
+      await backOff.execute({
+        id, description: 'Reset Test', delayedFn
+      });
+
+      expect(backOff.getBackOff(id)).toBeDefined();
 
-    // Wait for the immediate call to finish.
-    jest.advanceTimersByTime(1);
-    await Promise.resolve();
-    await Promise.resolve();
-    await Promise.resolve();
+      // Reset the process.
+      backOff.reset(id);
 
-    // The entry should be removed after success/failure.
-    expect(backOff.getBackOff(id).timeoutId).toBeUndefined();
+      // The entry should be deleted from the map.
+      expect(backOff.getBackOff(id)).toBeUndefined();
 
-    // Call again to trigger a backoff delay and an error.
-    await backOff.execute({
-      id, description: 'Error Test', delayedFn
+      // 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);
     });
 
-    // Advance timers to trigger the delayed function.
-    jest.advanceTimersByTime(250);
-    await Promise.resolve();
-    await Promise.resolve();
-    await Promise.resolve();
+    it('should reset all backoff processes', async() => {
+      const delayedFn1 = jest.fn();
+      const delayedFn2 = jest.fn();
 
-    // The timeoutId should be cleared, but the `try` count should be preserved on the next call.
-    expect(backOff.getBackOff(id).timeoutId).toBeUndefined();
+      await backOff.execute({
+        id: 'all-1', description: 'All 1', delayedFn: delayedFn1
+      });
+      await backOff.execute({
+        id: 'all-1', description: 'All 1', delayedFn: delayedFn1
+      });
 
-    // Check if the next call will still back off.
-    const newDelayedFn = jest.fn();
+      await backOff.execute({
+        id: 'all-2', description: 'All 2', delayedFn: delayedFn2
+      });
+      await backOff.execute({
+        id: 'all-2', description: 'All 2', delayedFn: delayedFn2
+      });
 
-    await backOff.execute({
-      id, description: 'Error Test', delayedFn: newDelayedFn
-    });
-    expect(newDelayedFn).not.toHaveBeenCalled(); // The next call should still be delayed
-  });
+      expect(backOff.getBackOff('all-1')).toBeDefined();
+      expect(backOff.getBackOff('all-2')).toBeDefined();
 
-  it('should save metadata', async() => {
-    const delayedFn = jest.fn();
-    const id = 'exp-backoff';
-    const metadata = { a: true };
+      // Reset all processes.
+      backOff.resetAll();
 
-    // First call (immediate)
-    await backOff.execute({
-      id, description: 'Exponential Backoff Test', delayedFn, metadata
+      expect(backOff.getBackOff('all-1')).toBeUndefined();
+      expect(backOff.getBackOff('all-2')).toBeUndefined();
     });
 
-    expect(backOff.getBackOff(id)).toBeDefined();
-    expect(backOff.getBackOff(id).metadata).toStrictEqual(metadata);
+    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();
+    });
   });
 
-  // --- Test Suite for Reset methods ---
+  describe('recurse', () => {
+    beforeEach(beforeEachFn);
 
-  it('should reset a specific backoff process', async() => {
-    const delayedFn = jest.fn();
-    const id = 'reset-test';
+    afterEach(afterEachFn);
 
-    // Start a backoff process.
-    await backOff.execute({
-      id, description: 'Reset Test', delayedFn
-    });
+    const handlePromises = async() => {
+      for (let i = 0; i < 10; i++) {
+        await Promise.resolve();
+      }
+    };
 
-    expect(backOff.getBackOff(id)).toBeDefined();
+    const iterationLoop = async(wait: number) => {
+      await handlePromises();
 
-    // Reset the process.
-    backOff.reset(id);
+      jest.advanceTimersByTime(wait);
 
-    // The entry should be deleted from the map.
-    expect(backOff.getBackOff(id)).toBeUndefined();
+      await handlePromises();
+    };
 
-    // Now, a new execution should not be delayed.
-    await backOff.execute({
-      id, description: 'Reset Test', delayedFn
-    });
+    it('should execute the function immediately', async() => {
+      const delayedFn = jest.fn().mockResolvedValue('success');
+      const id = 'recurse-test';
 
-    jest.advanceTimersByTime(250);
-    await Promise.resolve();
-    expect(delayedFn).toHaveBeenCalledTimes(1);
-  });
+      const promise = backOff.recurse({
+        id, description: 'Recurse Test', delayedFn, continueOnError: async() => false
+      });
 
-  it('should reset all backoff processes', async() => {
-    const delayedFn1 = jest.fn();
-    const delayedFn2 = jest.fn();
+      await iterationLoop(1);
 
-    await backOff.execute({
-      id: 'all-1', description: 'All 1', delayedFn: delayedFn1
-    });
-    await backOff.execute({
-      id: 'all-1', description: 'All 1', delayedFn: delayedFn1
-    });
+      const result = await promise;
 
-    await backOff.execute({
-      id: 'all-2', description: 'All 2', delayedFn: delayedFn2
-    });
-    await backOff.execute({
-      id: 'all-2', description: 'All 2', delayedFn: delayedFn2
+      expect(delayedFn).toHaveBeenCalledTimes(1);
+      expect(result).toBe('success');
     });
 
-    expect(backOff.getBackOff('all-1')).toBeDefined();
-    expect(backOff.getBackOff('all-2')).toBeDefined();
+    it('should retry on failure if continueOnError returns true', async() => {
+      const delayedFn = jest.fn()
+        .mockRejectedValueOnce(new Error('Fail 1'))
+        .mockResolvedValue('success');
+      const id = 'recurse-retry';
+      const continueOnError = jest.fn().mockResolvedValue(true);
 
-    // Reset all processes.
-    backOff.resetAll();
+      const promise = backOff.recurse({
+        id, description: 'Recurse Retry', delayedFn, continueOnError
+      });
 
-    expect(backOff.getBackOff('all-1')).toBeUndefined();
-    expect(backOff.getBackOff('all-2')).toBeUndefined();
-  });
+      // First attempt (i=0)
+      await iterationLoop(1);
 
-  it('should reset only processes with a specific prefix', async() => {
-    const delayedFn = jest.fn();
+      // Second attempt (i=1), delay 250ms
+      await iterationLoop(250);
 
-    await backOff.execute({
-      id: 'prefix-test-1', description: 'Prefix Test 1', delayedFn
-    });
-    await backOff.execute({
-      id: 'prefix-test-1', description: 'Prefix Test 1', delayedFn
-    });
+      const result = await promise;
 
-    await backOff.execute({
-      id: 'prefix-test-2', description: 'Prefix Test 2', delayedFn
-    });
-    await backOff.execute({
-      id: 'prefix-test-2', description: 'Prefix Test 2', delayedFn
+      expect(delayedFn).toHaveBeenCalledTimes(2);
+      expect(result).toBe('success');
     });
 
-    await backOff.execute({
-      id: 'other-test-1', description: 'Other Test 1', delayedFn
+    it('should stop retrying if continueOnError returns false', async() => {
+      const delayedFn = jest.fn().mockRejectedValue(new Error('Fail'));
+      const id = 'recurse-stop';
+      const continueOnError = jest.fn().mockResolvedValue(false);
+
+      const promise = backOff.recurse({
+        id, description: 'Recurse Stop', delayedFn, continueOnError
+      });
+
+      await iterationLoop(1);
+
+      await expect(promise).rejects.toThrow('Failed call');
+      expect(delayedFn).toHaveBeenCalledTimes(1);
     });
-    await backOff.execute({
-      id: 'other-test-1', description: 'Other Test 1', delayedFn
+
+    it('should stop retrying if max retries reached', async() => {
+      const delayedFn = jest.fn().mockRejectedValue(new Error('Fail'));
+      const id = 'recurse-max';
+      const continueOnError = jest.fn().mockResolvedValue(true);
+      const retries = 2;
+
+      const promise = backOff.recurse({
+        id, description: 'Recurse Max', delayedFn, continueOnError, retries
+      });
+
+      // Try 1
+      await iterationLoop(1);
+
+      // Try 2
+      await iterationLoop(250);
+
+      const result = await promise;
+
+      expect(result).toBeUndefined();
+      expect(delayedFn).toHaveBeenCalledTimes(2);
     });
 
-    expect(backOff.getBackOff('prefix-test-1')).toBeDefined();
-    expect(backOff.getBackOff('prefix-test-2')).toBeDefined();
-    expect(backOff.getBackOff('other-test-1')).toBeDefined();
+    it('should skip if canFn returns false', async() => {
+      const delayedFn = jest.fn();
+      const id = 'recurse-canfn';
+      const canFn = jest.fn().mockResolvedValue(false);
 
-    // Reset only the "prefix-test" processes.
-    backOff.resetPrefix('prefix-test');
+      const promise = backOff.recurse({
+        id, description: 'Recurse CanFn', delayedFn, continueOnError: async() => false, canFn
+      });
 
-    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();
+      await expect(promise).rejects.toThrow('Skipping (canFn test failed)');
+      expect(delayedFn).not.toHaveBeenCalled();
+    });
   });
 });