worker-runner.js

import path from "path";
import * as circus from "jest-circus";
import { pathToFileURL } from "url";

import "./global-setup.js";

/** @typedef {import("@jest/test-result").Test} Test */

// Node.js workers (worker_therads) don't support
// process.chdir, that we use multiple times in our tests.
// We can "polyfill" it for process.cwd() usage, but it
// won't affect path.* and fs.* functions.
{
  const startCwd = process.cwd();
  let cwd = startCwd;
  process.cwd = () => cwd;
  process.chdir = dir => {
    cwd = path.resolve(cwd, dir);
  };
}

export default async function ({ test, port }) {
  port.postMessage("start");

  const stats = { passes: 0, failures: 0, pending: 0 };
  const results = [];
  const { tests, hasFocusedTests } = await loadTests(test.path);

  await runTestBlock(tests, hasFocusedTests, results, stats);

  return toTestResult(stats, results, test.path);
}

async function loadTests(testFile) {
  circus.resetState();
  await import(pathToFileURL(testFile));
  const { rootDescribeBlock, hasFocusedTests } = circus.getState();
  return { tests: rootDescribeBlock, hasFocusedTests };
}

async function runTestBlock(
  block,
  hasFocusedTests,
  results,
  stats,
  ancestors = []
) {
  await runHooks("beforeAll", block, results, stats, ancestors);

  for (const child of block.children) {
    const { type, mode, fn, name } = child;
    const nextAncestors = ancestors.concat(name);

    if (
      mode === "skip" ||
      (hasFocusedTests && type === "test" && mode !== "only")
    ) {
      stats.pending++;
      results.push({ ancestors, title: name, error: null, skipped: true });
    } else if (type === "describeBlock") {
      await runTestBlock(child, hasFocusedTests, results, stats, nextAncestors);
    } else if (type === "test") {
      await runHooks("beforeEach", block, results, stats, nextAncestors, true);
      await callAsync(fn).then(
        () => {
          stats.passes++;
          results.push({ ancestors, title: name, error: null, skipped: false });
        },
        error => {
          stats.failures++;
          results.push({ ancestors, title: name, error, skipped: false });
        }
      );
      await runHooks("afterEach", block, results, stats, nextAncestors, true);
    }
  }

  await runHooks("afterAll", block, results, stats, ancestors);

  return results;
}

async function runHooks(hook, block, results, stats, ancestors, runInParents) {
  for (const { type, fn } of block.hooks) {
    if (type === hook) {
      await callAsync(fn).catch(error => {
        stats.failures++;
        results.push({ ancestors, title: `(${hook})`, error, skipped: false });
      });
    }
  }

  if (block.parent && runInParents) {
    await runHooks(hook, block.parent, results, stats, ancestors, true);
  }
}

function callAsync(fn) {
  if (fn.length >= 1) {
    return new Promise((resolve, reject) => {
      fn((err, result) => {
        if (err) {
          reject(err);
        } else {
          resolve(result);
        }
      });
    });
  } else {
    return Promise.resolve().then(fn);
  }
}

/**
 *
 * @param {*} stats
 * @param {*} tests
 * @param {*} path
 * @returns {import("@jest/test-result").TestResult}
 */
function toTestResult(stats, tests, path) {
  return {
    coverage: globalThis.__coverage__,
    console: null,
    failureMessage: tests
      .filter(t => t.error)
      .map(failureToString)
      .join("\n"),
    numFailingTests: stats.failures,
    numPassingTests: stats.passes,
    numPendingTests: stats.pending,
    perfStats: {
      end: +new Date(stats.end),
      start: +new Date(stats.start),
    },
    skipped: false,
    snapshot: {
      added: 0,
      fileDeleted: false,
      matched: 0,
      unchecked: 0,
      unmatched: 0,
      updated: 0,
    },
    sourceMaps: {},
    testExecError: null,
    testFilePath: path,
    testResults: tests.map(test => {
      return {
        ancestorTitles: test.ancestors,
        duration: test.duration / 1000,
        failureMessages: test.error ? [failureToString(test)] : [],
        fullName: test.title,
        numPassingAsserts: test.error ? 1 : 0,
        status: test.skipped ? "pending" : test.error ? "failed" : "passed",
        title: test.title,
      };
    }),
  };
}

function failureToString(test) {
  return (
    test.ancestors.concat(test.title).join(" > ") +
    "\n" +
    test.error.toString().replace(/^/gm, "\t") +
    "\n"
  );
}