fix(worker): handle circular messages

Author: SimenB

CHANGELOG.md

@@ -48,6 +48,7 @@
 - `[jest-transform]` [**BREAKING**] Refactor API to pass an options bag around rather than multiple boolean options ([#10753](https://github.com/facebook/jest/pull/10753))
 - `[jest-transform]` [**BREAKING**] Refactor API of transformers to pass an options bag rather than separate `config` and other options ([#10834](https://github.com/facebook/jest/pull/10834))
 - `[jest-worker]` [**BREAKING**] Use named exports ([#10623] (https://github.com/facebook/jest/pull/10623))
+- `[jest-worker]` Handle passing messages with circular data ([#10980] (https://github.com/facebook/jest/pull/10980))
 - `[pretty-format]` [**BREAKING**] Convert to ES Modules ([#10515](https://github.com/facebook/jest/pull/10515))
 
 ### Chore & Maintenance

e2e/Utils.ts

@@ -225,7 +225,7 @@ const sortTests = (stdout: string) =>
     .reduce((tests: Array<Array<string>>, line) => {
       if (['RUNS', 'PASS', 'FAIL'].includes(line.slice(0, 4))) {
         tests.push([line.trimRight()]);
-      } else if (line) {
+      } else {
         tests[tests.length - 1].push(line.trimRight());
       }
       return tests;

e2e/__tests__/__snapshots__/circularInequality.test.ts.snap

@@ -0,0 +1,99 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`handles circular inequality properly 1`] = `
+FAIL __tests__/test-1.js
+  ● test
+
+    expect(received).toEqual(expected) // deep equality
+
+    - Expected  - 1
+    + Received  + 3
+
+    - Object {}
+    + Object {
+    +   "ref": [Circular],
+    + }
+
+      3 |   foo.ref = foo;
+      4 |
+    > 5 |   expect(foo).toEqual({});
+        |               ^
+      6 | });
+      7 |
+      8 | it('test 2', () => {
+
+      at Object.toEqual (__tests__/test-1.js:5:15)
+
+  ● test 2
+
+    expect(received).toEqual(expected) // deep equality
+
+    - Expected  - 1
+    + Received  + 3
+
+    - Object {}
+    + Object {
+    +   "ref": [Circular],
+    + }
+
+      10 |   foo.ref = foo;
+      11 |
+    > 12 |   expect(foo).toEqual({});
+         |               ^
+      13 | });
+
+      at Object.toEqual (__tests__/test-1.js:12:15)
+
+
+FAIL __tests__/test-2.js
+  ● test
+
+    expect(received).toEqual(expected) // deep equality
+
+    - Expected  - 1
+    + Received  + 3
+
+    - Object {}
+    + Object {
+    +   "ref": [Circular],
+    + }
+
+      3 |   foo.ref = foo;
+      4 |
+    > 5 |   expect(foo).toEqual({});
+        |               ^
+      6 | });
+      7 |
+      8 | it('test 2', () => {
+
+      at Object.toEqual (__tests__/test-2.js:5:15)
+
+  ● test 2
+
+    expect(received).toEqual(expected) // deep equality
+
+    - Expected  - 1
+    + Received  + 3
+
+    - Object {}
+    + Object {
+    +   "ref": [Circular],
+    + }
+
+      10 |   foo.ref = foo;
+      11 |
+    > 12 |   expect(foo).toEqual({});
+         |               ^
+      13 | });
+
+      at Object.toEqual (__tests__/test-2.js:12:15)
+
+`;
+
+exports[`handles circular inequality properly 2`] = `
+Test Suites: 2 failed, 2 total
+Tests:       4 failed, 4 total
+Snapshots:   0 total
+Time:        <<REPLACED>>
+Ran all test suites.
+`;

e2e/__tests__/circularInequality.test.ts

@@ -0,0 +1,67 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import {tmpdir} from 'os';
+import * as path from 'path';
+import {wrap} from 'jest-snapshot-serializer-raw';
+import {
+  cleanup,
+  createEmptyPackage,
+  extractSortedSummary,
+  writeFiles,
+} from '../Utils';
+import {runContinuous} from '../runJest';
+
+const tempDir = path.resolve(tmpdir(), 'circular-inequality-test');
+
+beforeEach(() => {
+  createEmptyPackage(tempDir);
+});
+
+afterEach(() => {
+  cleanup(tempDir);
+});
+
+test('handles circular inequality properly', async () => {
+  const testFileContent = `
+    it('test', () => {
+      const foo = {};
+      foo.ref = foo;
+
+      expect(foo).toEqual({});
+    });
+
+    it('test 2', () => {
+      const foo = {};
+      foo.ref = foo;
+
+      expect(foo).toEqual({});
+    });
+  `;
+
+  writeFiles(tempDir, {
+    '__tests__/test-1.js': testFileContent,
+    '__tests__/test-2.js': testFileContent,
+  });
+
+  const {end, waitUntil} = runContinuous(
+    tempDir,
+    ['--no-watchman', '--watch-all'],
+    // timeout in case the `waitUntil` below doesn't fire
+    {timeout: 5000},
+  );
+
+  await waitUntil(({stderr}) => {
+    return stderr.includes('Ran all test suites.');
+  });
+
+  const {stderr} = await end();
+
+  const {summary, rest} = extractSortedSummary(stderr);
+  expect(wrap(rest)).toMatchSnapshot();
+  expect(wrap(summary)).toMatchSnapshot();
+});

packages/jest-worker/package.json

@@ -16,7 +16,8 @@
   "dependencies": {
     "@types/node": "*",
     "merge-stream": "^2.0.0",
-    "supports-color": "^8.0.0"
+    "supports-color": "^8.0.0",
+    "telejson": "^5.1.0"
   },
   "devDependencies": {
     "@types/merge-stream": "^1.1.2",

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

@@ -23,6 +23,7 @@ import {
   WorkerInterface,
   WorkerOptions,
 } from '../types';
+import {parse} from './utils';
 
 const SIGNAL_BASE_EXIT_CODE = 128;
 const SIGKILL_EXIT_CODE = SIGNAL_BASE_EXIT_CODE + 9;
@@ -92,6 +93,9 @@ export default class ChildProcessWorker implements WorkerInterface {
       } as NodeJS.ProcessEnv,
       // Suppress --debug / --inspect flags while preserving others (like --harmony).
       execArgv: process.execArgv.filter(v => !/^--(debug|inspect)/.test(v)),
+      // default to advanced serialization in order to match worker threads
+      // @ts-expect-error
+      serialization: 'advanced',
       silent: true,
       ...this._options.forkOptions,
     });
@@ -162,7 +166,7 @@ export default class ChildProcessWorker implements WorkerInterface {
 
     switch (response[0]) {
       case PARENT_MESSAGE_OK:
-        this._onProcessEnd(null, response[1]);
+        this._onProcessEnd(null, parse(response[1]));
         break;
 
       case PARENT_MESSAGE_CLIENT_ERROR:
@@ -195,7 +199,7 @@ export default class ChildProcessWorker implements WorkerInterface {
         this._onProcessEnd(error, null);
         break;
       case PARENT_MESSAGE_CUSTOM:
-        this._onCustomMessage(response[1]);
+        this._onCustomMessage(parse(response[1]));
         break;
       default:
         throw new TypeError('Unexpected response from worker: ' + response[0]);

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

@@ -23,6 +23,7 @@ import {
   WorkerInterface,
   WorkerOptions,
 } from '../types';
+import {parse} from './utils';
 
 export default class ExperimentalWorker implements WorkerInterface {
   private _worker!: Worker;
@@ -141,7 +142,7 @@ export default class ExperimentalWorker implements WorkerInterface {
 
     switch (response[0]) {
       case PARENT_MESSAGE_OK:
-        this._onProcessEnd(null, response[1]);
+        this._onProcessEnd(null, parse(response[1]));
         break;
 
       case PARENT_MESSAGE_CLIENT_ERROR:
@@ -175,7 +176,7 @@ export default class ExperimentalWorker implements WorkerInterface {
         this._onProcessEnd(error, null);
         break;
       case PARENT_MESSAGE_CUSTOM:
-        this._onCustomMessage(response[1]);
+        this._onCustomMessage(parse(response[1]));
         break;
       default:
         throw new TypeError('Unexpected response from worker: ' + response[0]);

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

@@ -70,6 +70,7 @@ it('passes fork options down to child_process.fork, adding the defaults', () =>
     env: {...process.env, FORCE_COLOR: supportsColor.stdout ? '1' : undefined}, // Default option.
     execArgv: ['-p'], // Filtered option.
     execPath: 'hello', // Added option.
+    serialization: 'advanced', // Default option.
     silent: true, // Default option.
   });
 });

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

@@ -6,32 +6,35 @@
  */
 
 import {PARENT_MESSAGE_CUSTOM} from '../types';
+import {serialize} from './utils';
 
-const isWorkerThread = () => {
+const isWorkerThread: boolean = (() => {
   try {
     // `Require` here to support Node v10
-    const {isMainThread, parentPort} = require('worker_threads');
-    return !isMainThread && parentPort;
+    const {
+      isMainThread,
+      parentPort,
+    } = require('worker_threads') as typeof import('worker_threads');
+    return !isMainThread && parentPort != null;
   } catch {
     return false;
   }
-};
+})();
 
-const messageParent = (
+export default function messageParent(
   message: unknown,
-  parentProcess: NodeJS.Process = process,
-): void => {
-  try {
-    if (isWorkerThread()) {
-      // `Require` here to support Node v10
-      const {parentPort} = require('worker_threads');
-      parentPort.postMessage([PARENT_MESSAGE_CUSTOM, message]);
-    } else if (typeof parentProcess.send === 'function') {
-      parentProcess.send([PARENT_MESSAGE_CUSTOM, message]);
-    }
-  } catch {
+  parentProcess = process,
+): void {
+  if (isWorkerThread) {
+    // `Require` here to support Node v10
+    const {
+      parentPort,
+    } = require('worker_threads') as typeof import('worker_threads');
+    // ! is safe due to `null` check in `isWorkerThread`
+    parentPort!.postMessage([PARENT_MESSAGE_CUSTOM, serialize(message)]);
+  } else if (typeof parentProcess.send === 'function') {
+    parentProcess.send([PARENT_MESSAGE_CUSTOM, serialize(message)]);
+  } else {
     throw new Error('"messageParent" can only be used inside a worker');
   }
-};
-
-export default messageParent;
+}

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

@@ -16,6 +16,7 @@ import {
   PARENT_MESSAGE_OK,
   PARENT_MESSAGE_SETUP_ERROR,
 } from '../types';
+import {serialize} from './utils';
 
 let file: string | null = null;
 let setupArgs: Array<unknown> = [];
@@ -64,7 +65,7 @@ function reportSuccess(result: unknown) {
     throw new Error('Child can only be used on a forked process');
   }
 
-  process.send([PARENT_MESSAGE_OK, result]);
+  process.send([PARENT_MESSAGE_OK, serialize(result)]);
 }
 
 function reportClientError(error: Error) {
@@ -86,7 +87,7 @@ function reportError(error: Error, type: PARENT_MESSAGE_ERROR) {
 
   process.send([
     type,
-    error.constructor && error.constructor.name,
+    error.constructor?.name,
     error.message,
     error.stack,
     typeof error === 'object' ? {...error} : error,