projen
Version:
CDK for software projects
368 lines • 50.3 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.NodeNativeTestRunner = exports.Destination = exports.NodeTestUpdateSnapshot = void 0;
const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
const path_1 = require("path");
const component_1 = require("../component");
const node_config_file_1 = require("./node-config-file");
const node_project_1 = require("./node-project");
const util_1 = require("../util");
const constructs_1 = require("../util/constructs");
const DEFAULT_COVERAGE_DIR = "coverage";
const DEFAULT_TEST_REPORTS_DIR = "test-reports";
const DEFAULT_NODE_TEST_MATCH_EXTENSIONS = "cjs,mjs,js,jsx,cts,mts,ts,tsx";
/**
* Default glob patterns used to discover test files for Node's built-in test
* runner, combining Node.js' own default test file discovery with common
* Jest conventions, so that projects moving from Jest keep matching their
* existing test files.
*
* Node's test runner glob matching follows `glob(7)` and does not support
* extglobs (e.g. `@(...)`, `+(...)`, `?(...)`), so, unlike Jest's own
* defaults, each alternative is spelled out explicitly instead of relying on
* extended glob groups.
*
* @see https://nodejs.org/api/test.html#running-tests-from-the-command-line
*/
const DEFAULT_NODE_TEST_MATCH = [
// Node.js' own defaults: files inside a "test" directory, or named/prefixed/suffixed "test"
`**/test/**/*.{${DEFAULT_NODE_TEST_MATCH_EXTENSIONS}}`,
`**/test.{${DEFAULT_NODE_TEST_MATCH_EXTENSIONS}}`,
`**/test-*.{${DEFAULT_NODE_TEST_MATCH_EXTENSIONS}}`,
`**/*.test.{${DEFAULT_NODE_TEST_MATCH_EXTENSIONS}}`,
`**/*-test.{${DEFAULT_NODE_TEST_MATCH_EXTENSIONS}}`,
`**/*_test.{${DEFAULT_NODE_TEST_MATCH_EXTENSIONS}}`,
// Jest conventions: files inside a "__tests__" directory, or named/suffixed "spec"
`**/__tests__/**/*.{${DEFAULT_NODE_TEST_MATCH_EXTENSIONS}}`,
`**/spec.{${DEFAULT_NODE_TEST_MATCH_EXTENSIONS}}`,
`**/*.spec.{${DEFAULT_NODE_TEST_MATCH_EXTENSIONS}}`,
];
/**
* Whether to update snapshots in task "test" (which is executed in task
* "build" and build workflows), or create a separate task "test:update" for
* updating snapshots.
*/
var NodeTestUpdateSnapshot;
(function (NodeTestUpdateSnapshot) {
/**
* Always update snapshots in "test" task.
*/
NodeTestUpdateSnapshot["ALWAYS"] = "always";
/**
* Never update snapshots in "test" task and create a separate "test:update" task.
*/
NodeTestUpdateSnapshot["NEVER"] = "never";
})(NodeTestUpdateSnapshot || (exports.NodeTestUpdateSnapshot = NodeTestUpdateSnapshot = {}));
/**
* Glob patterns matching the files that contain tests.
*/
class TestMatch {
_patterns = new Set();
_defaultValue;
constructor(defaultValue) {
this._defaultValue = defaultValue;
}
add(pattern) {
this._patterns.add(pattern);
}
remove(pattern) {
this._patterns.delete(pattern);
}
/**
* Resolved lazily so patterns added or removed after construction are
* still reflected.
*/
deferred() {
return this._patterns.size > 0
? Array.from(this._patterns)
: this._defaultValue;
}
}
/**
* Where a reporter's output is written.
*
* @see https://nodejs.org/api/test.html#test-reporters
*/
class Destination {
value;
static [JSII_RTTI_SYMBOL_1] = { fqn: "projen.javascript.Destination", version: "0.104.8" };
/**
* Write to standard output.
*/
static STDOUT = new Destination("stdout");
/**
* Write to standard error.
*/
static STDERR = new Destination("stderr");
/**
* Write to a file at the given path.
* @param path path of the file to write to
*/
static file(path) {
return new Destination(path);
}
constructor(
/**
* The underlying value: `"stdout"`, `"stderr"`, or a file path.
*/
value) {
this.value = value;
}
}
exports.Destination = Destination;
/**
* The set of reporters configured for a `NodeNativeTestRunner`.
*
* Provides the `test.testReporter` and `test.testReporterDestination` values
* of the generated Node.js configuration file.
*/
class NodeReporters {
project;
_reporters = new Map();
constructor(project) {
this.project = project;
}
/**
* Adds a reporter, or updates its destination if one with the same name
* is already configured.
* @param name The name/kind of the reporter, e.g. `spec`, `junit`, `lcov`.
* @param destination Where the reporter's output is written.
* @default Destination.STDOUT
*/
add(name, destination = Destination.STDOUT) {
this._reporters.set(name, destination);
if (destination !== Destination.STDOUT &&
destination !== Destination.STDERR) {
this.ensureDestinationDirectory(destination);
}
}
/**
* Removes a reporter, if configured.
* @param name The name/kind of the reporter to remove.
*/
remove(name) {
this._reporters.delete(name);
}
/**
* Lists the configured reporters, in the order they were added.
*/
list() {
return Array.from(this._reporters, ([name, destination]) => ({
name,
destination,
}));
}
/**
* Ensures the directory of a reporter's file destination exists before the
* test runner is invoked, and excludes it from the project's `.gitignore`
* and package (e.g. `.npmignore`) files.
*/
ensureDestinationDirectory(destination) {
const dir = path_1.posix.dirname(destination.value);
if (dir === ".") {
return;
}
// the reporter does not create its output directory, so it must exist
// before the test runner is invoked.
this.project.testTask.prependExec(`mkdir -p ${dir}`);
const dirPattern = path_1.posix.join("/", dir, "/");
this.project.addGitIgnore(dirPattern);
this.project.addPackageIgnore(dirPattern);
}
}
/**
* Configures Node's built-in test runner (`node --test`).
*
* Owns the generated Node.js configuration file, the "test", "test:update"
* and "test:watch" tasks, and the reporters and test match patterns they use.
*/
class NodeNativeTestRunner extends component_1.Component {
static [JSII_RTTI_SYMBOL_1] = { fqn: "projen.javascript.NodeNativeTestRunner", version: "0.104.8" };
/**
* Returns the singleton NodeNativeTestRunner component of a project or undefined
* if there is none.
*/
static of(project) {
const isNodeNativeTestRunner = (c) => c instanceof NodeNativeTestRunner;
return project.components.find(isNodeNativeTestRunner);
}
project;
coverageDirectory;
updateSnapshot;
reporters;
/**
* The generated Node.js configuration file.
*/
configFile;
testReportsDir = DEFAULT_TEST_REPORTS_DIR;
testMatch;
constructor(scope, options = {}) {
super(scope);
this.project = (0, constructs_1.closestProjectMustBe)(scope, node_project_1.NodeProject, new.target.name);
// Node's snapshot files are generated, not authored.
this.project.root.annotateGenerated("*.snap");
this.project.root.annotateGenerated("*.snapshot");
this.updateSnapshot =
options.updateSnapshot ?? NodeTestUpdateSnapshot.ALWAYS;
this.reporters = new NodeReporters(this.project);
const preserveDefaultReporters = options.preserveDefaultReporters ?? true;
this.testMatch = new TestMatch(DEFAULT_NODE_TEST_MATCH);
if (options.testMatch && options.testMatch.length > 0) {
options.testMatch.forEach((pattern) => this.testMatch.add(pattern));
}
const collectCoverage = options.collectCoverage ?? true;
const coverageDirectory = options.coverageDirectory ?? DEFAULT_COVERAGE_DIR;
this.coverageDirectory = collectCoverage ? coverageDirectory : undefined;
if (this.coverageDirectory) {
const coverageDirectoryPath = path_1.posix.join("/", this.coverageDirectory, "/");
this.project.addGitIgnore(coverageDirectoryPath);
this.project.addPackageIgnore(coverageDirectoryPath);
}
if (preserveDefaultReporters && collectCoverage) {
this.reporters.add("spec", Destination.STDOUT);
this.reporters.add("lcov", Destination.file(`${coverageDirectory}/lcov.info`));
this.reporters.add("junit", Destination.file(`${this.testReportsDir}/junit.xml`));
}
for (const { name, destination } of options.reporters ?? []) {
this.reporters.add(name, destination);
}
const defaultTest = {
test: true,
testGlobalSetup: options.globalSetup,
...(collectCoverage
? {
experimentalTestCoverage: true,
testCoverageExclude: options.coveragePathIgnorePatterns ?? [
"**/test/**",
"**/__tests__/**",
],
}
: {}),
experimentalTestModuleMocks: options.moduleMocks,
// lazily resolved at synthesis time, so that reporters added or
// removed via `reporters` after construction are reflected in the
// generated file.
testReporter: (() => this.reporters.list().map((r) => r.name)),
testReporterDestination: (() => this.reporters.list().map((r) => r.destination.value)),
};
const test = (0, util_1.deepMerge)([defaultTest, options.testConfig ?? {}], { destructive: true });
let nodeOptions = { ...options.nodeOptions };
const extraCliOptions = options.extraCliOptions ?? [];
if (options.transformTypes ?? false) {
this.project.addDevDeps("amaro");
const imports = nodeOptions.import ?? [];
if (!imports.includes("amaro/transform")) {
imports.unshift("amaro/transform");
}
nodeOptions = {
...nodeOptions,
enableSourceMaps: true,
import: imports,
};
}
this.configFile = new node_config_file_1.NodeConfigFile(this.project, {
filePath: options.configFilePath,
test,
nodeOptions,
});
this.project.npmignore?.addPatterns(`/${this.configFile.file.path}`);
// Test match patterns are positional arguments and must come after every
// flag: once Node sees the first positional argument it stops parsing
// flags, so any flag appended after them (e.g. `--watch`) is ignored.
const command = [
"node",
`--experimental-config-file=${this.configFile.file.path}`,
...extraCliOptions,
];
// `testMatch` is a live collection (`add`/`remove` can still be called
// after construction), so its resolution is deferred with `lazyExecArgs`
// rather than read eagerly here.
const testMatchArgs = () => this.testMatch.deferred();
if (this.updateSnapshot === NodeTestUpdateSnapshot.ALWAYS) {
this.project.testTask.execArgs(lazyExecArgs(() => [
...command,
"--test-update-snapshots",
...testMatchArgs(),
]), { receiveArgs: true });
}
else {
const testUpdate = this.project.tasks.tryFind("test:update");
if (!testUpdate) {
this.project.addTask("test:update", {
description: "Update test snapshots",
execArgs: lazyExecArgs(() => [
...command,
"--test-update-snapshots",
...testMatchArgs(),
]),
receiveArgs: true,
});
}
this.project.testTask.execArgs(lazyExecArgs(() => [...command, ...testMatchArgs()]), { receiveArgs: true });
}
const testWatch = this.project.tasks.tryFind("test:watch");
if (!testWatch) {
this.project.addTask("test:watch", {
description: "Run tests in watch mode",
execArgs: lazyExecArgs(() => [
...command,
"--watch",
...testMatchArgs(),
]),
});
}
}
/**
* Adds a test match pattern.
* @param pattern glob pattern to match for tests
*/
addTestMatch(pattern) {
this.testMatch.add(pattern);
}
/**
* Removes a test match pattern, if configured.
* @param pattern glob pattern to remove
*/
removeTestMatch(pattern) {
this.testMatch.remove(pattern);
}
/**
* Adds a reporter, or updates its destination if one with the same name
* is already configured.
* @param name The name/kind of the reporter, e.g. `spec`, `junit`, `lcov`.
* @param destination Where the reporter's output is written.
* @default Destination.STDOUT
*/
addReporter(name, destination) {
this.reporters.add(name, destination);
}
/**
* Removes a reporter, if configured.
* @param name The name/kind of the reporter to remove.
*/
removeReporter(name) {
this.reporters.remove(name);
}
/**
* Lists the configured reporters, in the order they were added.
*/
listReporters() {
return this.reporters.list();
}
}
exports.NodeNativeTestRunner = NodeNativeTestRunner;
/**
* Defers resolution of a `TaskStep`'s `execArgs` to synthesis time, when the
* tasks manifest is rendered.
*
* `TaskStep.execArgs` is typed as a plain `string[]`, but the manifest is
* written through the generic `resolve()` walker (see
* `ProjenTaskRunner.tasksManifest`) - the same mechanism `JsonFile`/`ObjectFile`
* use for lazy values elsewhere (e.g. `NodeReporters.list`, `TestMatch`).
* That walker calls any function it finds, so a callback deferred here runs
* once, at that point, in place of a plain array.
*/
function lazyExecArgs(fn) {
return fn;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node-native-test-runner.js","sourceRoot":"","sources":["../../src/javascript/node-native-test-runner.ts"],"names":[],"mappings":"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","sourcesContent":["import { posix } from \"path\";\nimport type { IConstruct } from \"constructs\";\nimport { Component } from \"../component\";\nimport type { Project } from \"../project\";\nimport type {\n  NodeConfigSchemaNodeOptions,\n  NodeConfigSchemaTest,\n} from \"./node-config\";\nimport { NodeConfigFile } from \"./node-config-file\";\nimport { NodeProject } from \"./node-project\";\nimport { deepMerge } from \"../util\";\nimport { closestProjectMustBe } from \"../util/constructs\";\n\nconst DEFAULT_COVERAGE_DIR = \"coverage\";\n\nconst DEFAULT_TEST_REPORTS_DIR = \"test-reports\";\n\nconst DEFAULT_NODE_TEST_MATCH_EXTENSIONS = \"cjs,mjs,js,jsx,cts,mts,ts,tsx\";\n\n/**\n * Default glob patterns used to discover test files for Node's built-in test\n * runner, combining Node.js' own default test file discovery with common\n * Jest conventions, so that projects moving from Jest keep matching their\n * existing test files.\n *\n * Node's test runner glob matching follows `glob(7)` and does not support\n * extglobs (e.g. `@(...)`, `+(...)`, `?(...)`), so, unlike Jest's own\n * defaults, each alternative is spelled out explicitly instead of relying on\n * extended glob groups.\n *\n * @see https://nodejs.org/api/test.html#running-tests-from-the-command-line\n */\nconst DEFAULT_NODE_TEST_MATCH: string[] = [\n  // Node.js' own defaults: files inside a \"test\" directory, or named/prefixed/suffixed \"test\"\n  `**/test/**/*.{${DEFAULT_NODE_TEST_MATCH_EXTENSIONS}}`,\n  `**/test.{${DEFAULT_NODE_TEST_MATCH_EXTENSIONS}}`,\n  `**/test-*.{${DEFAULT_NODE_TEST_MATCH_EXTENSIONS}}`,\n  `**/*.test.{${DEFAULT_NODE_TEST_MATCH_EXTENSIONS}}`,\n  `**/*-test.{${DEFAULT_NODE_TEST_MATCH_EXTENSIONS}}`,\n  `**/*_test.{${DEFAULT_NODE_TEST_MATCH_EXTENSIONS}}`,\n  // Jest conventions: files inside a \"__tests__\" directory, or named/suffixed \"spec\"\n  `**/__tests__/**/*.{${DEFAULT_NODE_TEST_MATCH_EXTENSIONS}}`,\n  `**/spec.{${DEFAULT_NODE_TEST_MATCH_EXTENSIONS}}`,\n  `**/*.spec.{${DEFAULT_NODE_TEST_MATCH_EXTENSIONS}}`,\n];\n\n/**\n * Whether to update snapshots in task \"test\" (which is executed in task\n * \"build\" and build workflows), or create a separate task \"test:update\" for\n * updating snapshots.\n */\nexport enum NodeTestUpdateSnapshot {\n  /**\n   * Always update snapshots in \"test\" task.\n   */\n  ALWAYS = \"always\",\n\n  /**\n   * Never update snapshots in \"test\" task and create a separate \"test:update\" task.\n   */\n  NEVER = \"never\",\n}\n\n/**\n * Glob patterns matching the files that contain tests.\n */\nclass TestMatch {\n  private readonly _patterns = new Set<string>();\n  private readonly _defaultValue: string[];\n\n  constructor(defaultValue: string[]) {\n    this._defaultValue = defaultValue;\n  }\n\n  public add(pattern: string) {\n    this._patterns.add(pattern);\n  }\n\n  public remove(pattern: string) {\n    this._patterns.delete(pattern);\n  }\n\n  /**\n   * Resolved lazily so patterns added or removed after construction are\n   * still reflected.\n   */\n  public deferred(): string[] {\n    return this._patterns.size > 0\n      ? Array.from(this._patterns)\n      : this._defaultValue;\n  }\n}\n\nexport type ReporterKind = \"dot\" | \"junit\" | \"lcov\" | \"spec\" | \"tap\";\n\n/**\n * Where a reporter's output is written.\n *\n * @see https://nodejs.org/api/test.html#test-reporters\n */\nexport class Destination {\n  /**\n   * Write to standard output.\n   */\n  public static readonly STDOUT = new Destination(\"stdout\");\n\n  /**\n   * Write to standard error.\n   */\n  public static readonly STDERR = new Destination(\"stderr\");\n\n  /**\n   * Write to a file at the given path.\n   * @param path path of the file to write to\n   */\n  public static file(path: string): Destination {\n    return new Destination(path);\n  }\n\n  private constructor(\n    /**\n     * The underlying value: `\"stdout\"`, `\"stderr\"`, or a file path.\n     */\n    public readonly value: string,\n  ) {}\n}\n\n/**\n * A single reporter/destination pair for the Node.js native test runner.\n *\n * @see https://nodejs.org/api/test.html#test-reporters\n */\nexport interface NodeReporter {\n  /**\n   * The name/kind of the reporter.\n   */\n  readonly name: ReporterKind;\n  /**\n   * Where the reporter's output is written.\n   *\n   * @see https://github.com/nodejs/node/blob/4215cc35e25c44f9f4fea5a4541afc862db7ef0a/test/parallel/test-runner-reporters.js#L46-L77\n   * @default Destination.STDOUT\n   */\n  readonly destination: Destination;\n}\n\n/**\n * The set of reporters configured for a `NodeNativeTestRunner`.\n *\n * Provides the `test.testReporter` and `test.testReporterDestination` values\n * of the generated Node.js configuration file.\n */\nclass NodeReporters {\n  private readonly _reporters: Map<ReporterKind, Destination> = new Map();\n\n  constructor(private readonly project: NodeProject) {}\n\n  /**\n   * Adds a reporter, or updates its destination if one with the same name\n   * is already configured.\n   * @param name The name/kind of the reporter, e.g. `spec`, `junit`, `lcov`.\n   * @param destination Where the reporter's output is written.\n   * @default Destination.STDOUT\n   */\n  public add(\n    name: ReporterKind,\n    destination: Destination = Destination.STDOUT,\n  ): void {\n    this._reporters.set(name, destination);\n\n    if (\n      destination !== Destination.STDOUT &&\n      destination !== Destination.STDERR\n    ) {\n      this.ensureDestinationDirectory(destination);\n    }\n  }\n\n  /**\n   * Removes a reporter, if configured.\n   * @param name The name/kind of the reporter to remove.\n   */\n  public remove(name: ReporterKind): void {\n    this._reporters.delete(name);\n  }\n\n  /**\n   * Lists the configured reporters, in the order they were added.\n   */\n  public list(): NodeReporter[] {\n    return Array.from(this._reporters, ([name, destination]) => ({\n      name,\n      destination,\n    }));\n  }\n\n  /**\n   * Ensures the directory of a reporter's file destination exists before the\n   * test runner is invoked, and excludes it from the project's `.gitignore`\n   * and package (e.g. `.npmignore`) files.\n   */\n  private ensureDestinationDirectory(destination: Destination): void {\n    const dir = posix.dirname(destination.value);\n    if (dir === \".\") {\n      return;\n    }\n    // the reporter does not create its output directory, so it must exist\n    // before the test runner is invoked.\n    this.project.testTask.prependExec(`mkdir -p ${dir}`);\n\n    const dirPattern = posix.join(\"/\", dir, \"/\");\n    this.project.addGitIgnore(dirPattern);\n    this.project.addPackageIgnore(dirPattern);\n  }\n}\n\n/**\n * Options for Node.js' built-in test runner (`node --test`).\n */\nexport interface NodeNativeTestRunnerOptions {\n  /**\n   * The directory where coverage files are output, if coverage collection\n   * is enabled.\n   *\n   * @default \"coverage\"\n   */\n  readonly coverageDirectory?: string;\n\n  /**\n   * Whether to update snapshots in task \"test\" (which is executed in task\n   * \"build\" and build workflows), or create a separate task \"test:update\"\n   * for updating snapshots.\n   *\n   * @default - ALWAYS\n   */\n  readonly updateSnapshot?: NodeTestUpdateSnapshot;\n\n  /**\n   * Additional options to pass to the `node --test` CLI invocation.\n   *\n   * Each element is passed as a single argument, exactly as given: no shell\n   * parses these, so a flag and its value need separate elements\n   * (`[\"--foo\", \"bar\"]`, not `[\"--foo bar\"]`).\n   *\n   * @default - no extra options\n   */\n  readonly extraCliOptions?: string[];\n\n  /**\n   * Preserve the default reporters (`spec`, `lcov`, `junit`) when additional\n   * reporters are added.\n   *\n   * @default true\n   */\n  readonly preserveDefaultReporters?: boolean;\n\n  /**\n   * Additional reporters to configure (e.g. `{ name: \"tap\", destination:\n   * Destination.file(\"test-reports/tap.txt\") }`).\n   *\n   * These are added on top of the default reporters (`spec`, `lcov`, `junit`),\n   * which are controlled via `collectCoverage`. Use\n   * `NodeNativeTestRunner.addReporter`/`removeReporter`/`listReporters` to\n   * manage reporters after construction.\n   *\n   * @default - no additional reporters\n   */\n  readonly reporters?: NodeReporter[];\n\n  /**\n   * Path to the JSON configuration file for the test runner.\n   *\n   * @default \"node.config.json\"\n   */\n  readonly configFilePath?: string;\n\n  /**\n   * Glob patterns matching the files that contain tests. By default it\n   * combines Node.js' own default test file discovery with Jest conventions.\n   *\n   * @default - combines Node.js' own default test file discovery with Jest conventions\n   */\n  readonly testMatch?: string[];\n\n  /**\n   * Indicates whether the coverage information should be collected while\n   * executing the test, via `--experimental-test-coverage`.\n   *\n   * @default true\n   */\n  readonly collectCoverage?: boolean;\n\n  /**\n   * An array of glob patterns that are matched against all file paths before\n   * executing coverage collection. If a file path matches any of the\n   * patterns, coverage information will be skipped for it.\n   *\n   * @default [\"**\\/test/**\", \"**\\/__tests__/**\"]\n   */\n  readonly coveragePathIgnorePatterns?: string[];\n\n  /**\n   * This option allows the use of a custom global setup module which\n   * exports a function that is triggered once before all test suites.\n   * Written as `test-global-setup` in the generated Node.js configuration\n   * file.\n   *\n   * @default - undefined\n   */\n  readonly globalSetup?: string;\n\n  /**\n   * Enable module mocking support via `--experimental-test-module-mocks`.\n   *\n   * @default false\n   */\n  readonly moduleMocks?: boolean;\n\n  /**\n   * Whether to enable transformation of TypeScript-only syntax (e.g. enums, namespaces).\n   *\n   * Uses `amaro` (the TypeScript transformer used internally by Node.js) as an\n   * external loader via `--import=amaro/transform`. Adds a dependency on the\n   * `amaro` package and enables `--enable-source-maps` to preserve accurate\n   * stack traces.\n   *\n   * @see https://github.com/nodejs/amaro\n   * @default false\n   */\n  readonly transformTypes?: boolean;\n\n  /**\n   * Additional entries for the `nodeOptions` section of the generated\n   * configuration file (e.g. `enableSourceMaps`, `disableWarning`).\n   *\n   * @default - no additional node options\n   */\n  readonly nodeOptions?: NodeConfigSchemaNodeOptions;\n\n  /**\n   * Additional entries for the `test` section of the generated\n   * configuration file (e.g. `testConcurrency`, `testTimeout`).\n   *\n   * @default - no additional options\n   */\n  readonly testConfig?: NodeConfigSchemaTest;\n}\n\n/**\n * Configures Node's built-in test runner (`node --test`).\n *\n * Owns the generated Node.js configuration file, the \"test\", \"test:update\"\n * and \"test:watch\" tasks, and the reporters and test match patterns they use.\n */\nexport class NodeNativeTestRunner extends Component {\n  /**\n   * Returns the singleton NodeNativeTestRunner component of a project or undefined\n   * if there is none.\n   */\n  public static of(project: Project): NodeNativeTestRunner | undefined {\n    const isNodeNativeTestRunner = (c: Component): c is NodeNativeTestRunner =>\n      c instanceof NodeNativeTestRunner;\n    return project.components.find(isNodeNativeTestRunner);\n  }\n\n  public readonly project: NodeProject;\n\n  private readonly coverageDirectory?: string;\n\n  private readonly updateSnapshot: NodeTestUpdateSnapshot;\n\n  private readonly reporters: NodeReporters;\n\n  /**\n   * The generated Node.js configuration file.\n   */\n  public readonly configFile: NodeConfigFile;\n\n  private readonly testReportsDir: string = DEFAULT_TEST_REPORTS_DIR;\n\n  private readonly testMatch: TestMatch;\n\n  constructor(scope: IConstruct, options: NodeNativeTestRunnerOptions = {}) {\n    super(scope);\n    this.project = closestProjectMustBe(scope, NodeProject, new.target.name);\n\n    // Node's snapshot files are generated, not authored.\n    this.project.root.annotateGenerated(\"*.snap\");\n    this.project.root.annotateGenerated(\"*.snapshot\");\n\n    this.updateSnapshot =\n      options.updateSnapshot ?? NodeTestUpdateSnapshot.ALWAYS;\n\n    this.reporters = new NodeReporters(this.project);\n    const preserveDefaultReporters = options.preserveDefaultReporters ?? true;\n\n    this.testMatch = new TestMatch(DEFAULT_NODE_TEST_MATCH);\n\n    if (options.testMatch && options.testMatch.length > 0) {\n      options.testMatch.forEach((pattern) => this.testMatch.add(pattern));\n    }\n\n    const collectCoverage = options.collectCoverage ?? true;\n    const coverageDirectory = options.coverageDirectory ?? DEFAULT_COVERAGE_DIR;\n    this.coverageDirectory = collectCoverage ? coverageDirectory : undefined;\n\n    if (this.coverageDirectory) {\n      const coverageDirectoryPath = posix.join(\n        \"/\",\n        this.coverageDirectory,\n        \"/\",\n      );\n      this.project.addGitIgnore(coverageDirectoryPath);\n      this.project.addPackageIgnore(coverageDirectoryPath);\n    }\n\n    if (preserveDefaultReporters && collectCoverage) {\n      this.reporters.add(\"spec\", Destination.STDOUT);\n      this.reporters.add(\n        \"lcov\",\n        Destination.file(`${coverageDirectory}/lcov.info`),\n      );\n      this.reporters.add(\n        \"junit\",\n        Destination.file(`${this.testReportsDir}/junit.xml`),\n      );\n    }\n\n    for (const { name, destination } of options.reporters ?? []) {\n      this.reporters.add(name, destination);\n    }\n\n    const defaultTest: NodeConfigSchemaTest = {\n      test: true,\n      testGlobalSetup: options.globalSetup,\n      ...(collectCoverage\n        ? {\n            experimentalTestCoverage: true,\n            testCoverageExclude: options.coveragePathIgnorePatterns ?? [\n              \"**/test/**\",\n              \"**/__tests__/**\",\n            ],\n          }\n        : {}),\n      experimentalTestModuleMocks: options.moduleMocks,\n      // lazily resolved at synthesis time, so that reporters added or\n      // removed via `reporters` after construction are reflected in the\n      // generated file.\n      testReporter: (() => this.reporters.list().map((r) => r.name)) as any,\n      testReporterDestination: (() =>\n        this.reporters.list().map((r) => r.destination.value)) as any,\n    };\n    const test: NodeConfigSchemaTest = deepMerge(\n      [defaultTest, options.testConfig ?? {}],\n      { destructive: true },\n    );\n\n    let nodeOptions: NodeConfigSchemaNodeOptions = { ...options.nodeOptions };\n    const extraCliOptions = options.extraCliOptions ?? [];\n\n    if (options.transformTypes ?? false) {\n      this.project.addDevDeps(\"amaro\");\n      const imports = nodeOptions.import ?? [];\n      if (!imports.includes(\"amaro/transform\")) {\n        imports.unshift(\"amaro/transform\");\n      }\n      nodeOptions = {\n        ...nodeOptions,\n        enableSourceMaps: true,\n        import: imports,\n      };\n    }\n\n    this.configFile = new NodeConfigFile(this.project, {\n      filePath: options.configFilePath,\n      test,\n      nodeOptions,\n    });\n    this.project.npmignore?.addPatterns(`/${this.configFile.file.path}`);\n\n    // Test match patterns are positional arguments and must come after every\n    // flag: once Node sees the first positional argument it stops parsing\n    // flags, so any flag appended after them (e.g. `--watch`) is ignored.\n    const command: string[] = [\n      \"node\",\n      `--experimental-config-file=${this.configFile.file.path}`,\n      ...extraCliOptions,\n    ];\n\n    // `testMatch` is a live collection (`add`/`remove` can still be called\n    // after construction), so its resolution is deferred with `lazyExecArgs`\n    // rather than read eagerly here.\n    const testMatchArgs = () => this.testMatch.deferred();\n\n    if (this.updateSnapshot === NodeTestUpdateSnapshot.ALWAYS) {\n      this.project.testTask.execArgs(\n        lazyExecArgs(() => [\n          ...command,\n          \"--test-update-snapshots\",\n          ...testMatchArgs(),\n        ]),\n        { receiveArgs: true },\n      );\n    } else {\n      const testUpdate = this.project.tasks.tryFind(\"test:update\");\n      if (!testUpdate) {\n        this.project.addTask(\"test:update\", {\n          description: \"Update test snapshots\",\n          execArgs: lazyExecArgs(() => [\n            ...command,\n            \"--test-update-snapshots\",\n            ...testMatchArgs(),\n          ]),\n          receiveArgs: true,\n        });\n      }\n\n      this.project.testTask.execArgs(\n        lazyExecArgs(() => [...command, ...testMatchArgs()]),\n        { receiveArgs: true },\n      );\n    }\n\n    const testWatch = this.project.tasks.tryFind(\"test:watch\");\n    if (!testWatch) {\n      this.project.addTask(\"test:watch\", {\n        description: \"Run tests in watch mode\",\n        execArgs: lazyExecArgs(() => [\n          ...command,\n          \"--watch\",\n          ...testMatchArgs(),\n        ]),\n      });\n    }\n  }\n\n  /**\n   * Adds a test match pattern.\n   * @param pattern glob pattern to match for tests\n   */\n  public addTestMatch(pattern: string) {\n    this.testMatch.add(pattern);\n  }\n\n  /**\n   * Removes a test match pattern, if configured.\n   * @param pattern glob pattern to remove\n   */\n  public removeTestMatch(pattern: string) {\n    this.testMatch.remove(pattern);\n  }\n\n  /**\n   * Adds a reporter, or updates its destination if one with the same name\n   * is already configured.\n   * @param name The name/kind of the reporter, e.g. `spec`, `junit`, `lcov`.\n   * @param destination Where the reporter's output is written.\n   * @default Destination.STDOUT\n   */\n  public addReporter(name: ReporterKind, destination?: Destination) {\n    this.reporters.add(name, destination);\n  }\n\n  /**\n   * Removes a reporter, if configured.\n   * @param name The name/kind of the reporter to remove.\n   */\n  public removeReporter(name: ReporterKind) {\n    this.reporters.remove(name);\n  }\n\n  /**\n   * Lists the configured reporters, in the order they were added.\n   */\n  public listReporters(): NodeReporter[] {\n    return this.reporters.list();\n  }\n}\n\n/**\n * Defers resolution of a `TaskStep`'s `execArgs` to synthesis time, when the\n * tasks manifest is rendered.\n *\n * `TaskStep.execArgs` is typed as a plain `string[]`, but the manifest is\n * written through the generic `resolve()` walker (see\n * `ProjenTaskRunner.tasksManifest`) - the same mechanism `JsonFile`/`ObjectFile`\n * use for lazy values elsewhere (e.g. `NodeReporters.list`, `TestMatch`).\n * That walker calls any function it finds, so a callback deferred here runs\n * once, at that point, in place of a plain array.\n */\nfunction lazyExecArgs(fn: () => string[]): string[] {\n  return fn as any;\n}\n"]}