Support workerIdleMemoryLimit=0 to always restart worker child processes between test files (#15740)

Co-authored-by: Christoph Nakazawa <[email protected]>

Author: ide

CHANGELOG.md

@@ -3,6 +3,7 @@
 ### Features
 
 - `[jest-config]` Allow `testMatch` to take a string value
+- `[jest-worker]` Let `workerIdleMemoryLimit` accept 0 to always restart worker child processes
 
 ### Fixes
 

packages/jest-config/src/__tests__/stringToBytes.test.ts

@@ -8,6 +8,10 @@
 import stringToBytes from '../stringToBytes';
 
 describe('numeric input', () => {
+  test('0 should be 0', () => {
+    expect(stringToBytes(0)).toBe(0);
+  });
+
   test('> 1 represents bytes', () => {
     expect(stringToBytes(50.8)).toBe(50);
   });
@@ -33,6 +37,10 @@ describe('numeric input', () => {
 
 describe('string input', () => {
   describe('numeric passthrough', () => {
+    test('0 should be 0', () => {
+      expect(stringToBytes('0')).toBe(0);
+    });
+
     test('> 1 represents bytes', () => {
       expect(stringToBytes('50.8')).toBe(50);
     });
@@ -55,10 +63,8 @@ describe('string input', () => {
   });
 
   describe('parsing', () => {
-    test('0% should throw an error', () => {
-      expect(() => stringToBytes('0%', 51)).toThrow(
-        'Unexpected numerical input',
-      );
+    test('0%', () => {
+      expect(stringToBytes('0%', 51)).toBe(0);
     });
 
     test('30%', () => {

packages/jest-config/src/stringToBytes.ts

@@ -68,7 +68,9 @@ function stringToBytes(
   }
 
   if (typeof input === 'number') {
-    if (input <= 1 && input > 0) {
+    if (input === 0) {
+      return 0;
+    } else if (input <= 1 && input > 0) {
       if (percentageReference) {
         return Math.floor(input * percentageReference);
       } else {

packages/jest-core/src/testSchedulerHelper.ts

@@ -48,7 +48,7 @@ export function shouldRunInBand(
 
   return (
     // When specifying a memory limit, workers should be used
-    !workerIdleMemoryLimit &&
+    workerIdleMemoryLimit === undefined &&
     (oneWorkerOrLess ||
       oneTestOrLess ||
       (tests.length <= 20 && timings.length > 0 && areFastTests))

packages/jest-worker/src/types.ts

@@ -175,6 +175,10 @@ export type WorkerOptions = {
    * a job is complete. So you could have a resource limit of 500MB but an idle
    * limit of 50MB. The latter will only trigger if after a job has completed the
    * memory usage hasn't returned back down under 50MB.
+   *
+   * Special case: setting this to 0 will restart the worker process after each
+   * job completes, providing complete process isolation between test files
+   * regardless of memory usage.
    */
   idleMemoryLimit?: number;
   /**

packages/jest-worker/src/workers/ChildProcessWorker.ts

@@ -90,7 +90,7 @@ export default class ChildProcessWorker
     this._stdout = null;
     this._stderr = null;
     this._childIdleMemoryUsage = null;
-    this._childIdleMemoryUsageLimit = options.idleMemoryLimit || null;
+    this._childIdleMemoryUsageLimit = options.idleMemoryLimit ?? null;
 
     this._childWorkerPath =
       options.childWorkerPath || require.resolve('./processChild');
@@ -342,13 +342,16 @@ export default class ChildProcessWorker
         this._childIdleMemoryUsage &&
         this._childIdleMemoryUsage > limit
       ) {
-        this.state = WorkerStates.RESTARTING;
-
-        this.killChild();
+        this._restart();
       }
     }
   }
 
+  private _restart(): void {
+    this.state = WorkerStates.RESTARTING;
+    this.killChild();
+  }
+
   private _onExit(exitCode: number | null, signal: NodeJS.Signals | null) {
     this._workerReadyPromise = undefined;
     this._resolveWorkerReady = undefined;
@@ -440,11 +443,16 @@ export default class ChildProcessWorker
       this._request = null;
 
       if (
-        this._childIdleMemoryUsageLimit &&
+        this._childIdleMemoryUsageLimit !== null &&
         this._child.connected &&
         hasRequest
       ) {
-        this.checkMemoryUsage();
+        if (this._childIdleMemoryUsageLimit === 0) {
+          // Special case: `idleMemoryLimit` of `0` means always restart.
+          this._restart();
+        } else {
+          this.checkMemoryUsage();
+        }
       }
 
       return onProcessEnd(...args);
@@ -542,17 +550,17 @@ export default class ChildProcessWorker
    * Gets updated memory usage and restarts if required
    */
   checkMemoryUsage(): void {
-    if (this._childIdleMemoryUsageLimit) {
+    if (this._childIdleMemoryUsageLimit === null) {
+      console.warn(
+        'Memory usage of workers can only be checked if a limit is set',
+      );
+    } else {
       this._memoryUsageCheck = true;
       this._child.send([CHILD_MESSAGE_MEM_USAGE], err => {
         if (err) {
           console.error('Unable to check memory usage', err);
         }
       });
-    } else {
-      console.warn(
-        'Memory usage of workers can only be checked if a limit is set',
-      );
     }
   }
 

packages/jest-worker/src/workers/__tests__/ChildProcessWorker.test.ts

@@ -19,6 +19,7 @@ import {
   PARENT_MESSAGE_MEM_USAGE,
   PARENT_MESSAGE_OK,
   type WorkerOptions,
+  WorkerStates,
 } from '../../types';
 
 jest.useFakeTimers();
@@ -674,3 +675,39 @@ it('should check for memory limits and restart if above absolute limit', async (
   expect(totalmem).not.toHaveBeenCalled();
   expect(forkInterface.kill).toHaveBeenCalledTimes(1);
 });
+
+it('should restart immediately when limit is 0 without checking memory', () => {
+  const worker = new Worker({
+    forkOptions: {},
+    idleMemoryLimit: 0,
+    maxRetries: 3,
+    workerPath: '/tmp/foo',
+  } as WorkerOptions);
+
+  const onProcessStart = jest.fn();
+  const onProcessEnd = jest.fn();
+  const onCustomMessage = jest.fn();
+
+  worker.send(
+    [CHILD_MESSAGE_CALL, false, 'test', []] as ChildMessageCall,
+    onProcessStart,
+    onProcessEnd,
+    onCustomMessage,
+  );
+
+  expect(onProcessStart).toHaveBeenCalledTimes(1);
+  expect(onProcessEnd).not.toHaveBeenCalled();
+  expect(onCustomMessage).not.toHaveBeenCalled();
+
+  forkInterface.emit('message', [PARENT_MESSAGE_OK]);
+  expect(onProcessEnd).toHaveBeenCalledTimes(1);
+  expect(onCustomMessage).not.toHaveBeenCalled();
+
+  expect(totalmem).not.toHaveBeenCalled();
+  expect(forkInterface.send).not.toHaveBeenCalledWith(
+    [CHILD_MESSAGE_MEM_USAGE],
+    expect.any(Function),
+  );
+  expect(worker.state).toBe(WorkerStates.RESTARTING);
+  expect(forkInterface.kill).toHaveBeenCalledTimes(1);
+});

website/versioned_docs/version-29.7/Configuration.md

@@ -2463,6 +2463,7 @@ Specifies the memory limit for workers before they are recycled and is primarily
 
 After the worker has executed a test the memory usage of it is checked. If it exceeds the value specified the worker is killed and restarted. The limit can be specified in a number of different ways and whatever the result is `Math.floor` is used to turn it into an integer value:
 
+- `0` - Always restart the worker between tests.
 - `<= 1` - The value is assumed to be a percentage of system memory. So 0.5 sets the memory limit of the worker to half of the total system memory
 - `\> 1` - Assumed to be a fixed byte value. Because of the previous rule if you wanted a value of 1 byte (I don't know why) you could use `1.1`.
 - With units