projen 0.103.26 → 0.103.27

package/lib/javascript/node-native-test-runner.d.ts

@@ -0,0 +1,234 @@
+import type { IConstruct } from "constructs";
+import { Component } from "../component";
+import type { Project } from "../project";
+import type { NodeConfigSchemaNodeOptions, NodeConfigSchemaTest } from "./node-config";
+import { NodeConfigFile } from "./node-config-file";
+import { NodeProject } from "./node-project";
+/**
+ * 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.
+ */
+export declare enum NodeTestUpdateSnapshot {
+    /**
+     * Always update snapshots in "test" task.
+     */
+    ALWAYS = "always",
+    /**
+     * Never update snapshots in "test" task and create a separate "test:update" task.
+     */
+    NEVER = "never"
+}
+export type ReporterKind = "dot" | "junit" | "lcov" | "spec" | "tap";
+/**
+ * Where a reporter's output is written.
+ *
+ * @see https://nodejs.org/api/test.html#test-reporters
+ */
+export declare class Destination {
+    /**
+     * The underlying value: `"stdout"`, `"stderr"`, or a file path.
+     */
+    readonly value: string;
+    /**
+     * Write to standard output.
+     */
+    static readonly STDOUT: Destination;
+    /**
+     * Write to standard error.
+     */
+    static readonly STDERR: Destination;
+    /**
+     * Write to a file at the given path.
+     * @param path path of the file to write to
+     */
+    static file(path: string): Destination;
+    private constructor();
+}
+/**
+ * A single reporter/destination pair for the Node.js native test runner.
+ *
+ * @see https://nodejs.org/api/test.html#test-reporters
+ */
+export interface NodeReporter {
+    /**
+     * The name/kind of the reporter.
+     */
+    readonly name: ReporterKind;
+    /**
+     * Where the reporter's output is written.
+     *
+     * @see https://github.com/nodejs/node/blob/4215cc35e25c44f9f4fea5a4541afc862db7ef0a/test/parallel/test-runner-reporters.js#L46-L77
+     * @default Destination.STDOUT
+     */
+    readonly destination: Destination;
+}
+/**
+ * Options for Node.js' built-in test runner (`node --test`).
+ */
+export interface NodeNativeTestRunnerOptions {
+    /**
+     * The directory where coverage files are output, if coverage collection
+     * is enabled.
+     *
+     * @default "coverage"
+     */
+    readonly coverageDirectory?: string;
+    /**
+     * 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.
+     *
+     * @default - ALWAYS
+     */
+    readonly updateSnapshot?: NodeTestUpdateSnapshot;
+    /**
+     * Additional options to pass to the `node --test` CLI invocation.
+     *
+     * Each element is passed as a single argument, exactly as given: no shell
+     * parses these, so a flag and its value need separate elements
+     * (`["--foo", "bar"]`, not `["--foo bar"]`).
+     *
+     * @default - no extra options
+     */
+    readonly extraCliOptions?: string[];
+    /**
+     * Preserve the default reporters (`spec`, `lcov`, `junit`) when additional
+     * reporters are added.
+     *
+     * @default true
+     */
+    readonly preserveDefaultReporters?: boolean;
+    /**
+     * Additional reporters to configure (e.g. `{ name: "tap", destination:
+     * Destination.file("test-reports/tap.txt") }`).
+     *
+     * These are added on top of the default reporters (`spec`, `lcov`, `junit`),
+     * which are controlled via `collectCoverage`. Use
+     * `NodeNativeTestRunner.addReporter`/`removeReporter`/`listReporters` to
+     * manage reporters after construction.
+     *
+     * @default - no additional reporters
+     */
+    readonly reporters?: NodeReporter[];
+    /**
+     * Path to the JSON configuration file for the test runner.
+     *
+     * @default "node.config.json"
+     */
+    readonly configFilePath?: string;
+    /**
+     * Glob patterns matching the files that contain tests. By default it
+     * combines Node.js' own default test file discovery with Jest conventions.
+     *
+     * @default - combines Node.js' own default test file discovery with Jest conventions
+     */
+    readonly testMatch?: string[];
+    /**
+     * Indicates whether the coverage information should be collected while
+     * executing the test, via `--experimental-test-coverage`.
+     *
+     * @default true
+     */
+    readonly collectCoverage?: boolean;
+    /**
+     * An array of glob patterns that are matched against all file paths before
+     * executing coverage collection. If a file path matches any of the
+     * patterns, coverage information will be skipped for it.
+     *
+     * @default ["**\/test/**", "**\/__tests__/**"]
+     */
+    readonly coveragePathIgnorePatterns?: string[];
+    /**
+     * This option allows the use of a custom global setup module which
+     * exports a function that is triggered once before all test suites.
+     * Written as `test-global-setup` in the generated Node.js configuration
+     * file.
+     *
+     * @default - undefined
+     */
+    readonly globalSetup?: string;
+    /**
+     * Enable module mocking support via `--experimental-test-module-mocks`.
+     *
+     * @default false
+     */
+    readonly moduleMocks?: boolean;
+    /**
+     * Whether to enable transformation of TypeScript-only syntax (e.g. enums, namespaces).
+     *
+     * Uses `amaro` (the TypeScript transformer used internally by Node.js) as an
+     * external loader via `--import=amaro/transform`. Adds a dependency on the
+     * `amaro` package and enables `--enable-source-maps` to preserve accurate
+     * stack traces.
+     *
+     * @see https://github.com/nodejs/amaro
+     * @default false
+     */
+    readonly transformTypes?: boolean;
+    /**
+     * Additional entries for the `nodeOptions` section of the generated
+     * configuration file (e.g. `enableSourceMaps`, `disableWarning`).
+     *
+     * @default - no additional node options
+     */
+    readonly nodeOptions?: NodeConfigSchemaNodeOptions;
+    /**
+     * Additional entries for the `test` section of the generated
+     * configuration file (e.g. `testConcurrency`, `testTimeout`).
+     *
+     * @default - no additional options
+     */
+    readonly testConfig?: NodeConfigSchemaTest;
+}
+/**
+ * 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.
+ */
+export declare class NodeNativeTestRunner extends Component {
+    /**
+     * Returns the singleton NodeNativeTestRunner component of a project or undefined
+     * if there is none.
+     */
+    static of(project: Project): NodeNativeTestRunner | undefined;
+    readonly project: NodeProject;
+    private readonly coverageDirectory?;
+    private readonly updateSnapshot;
+    private readonly reporters;
+    /**
+     * The generated Node.js configuration file.
+     */
+    readonly configFile: NodeConfigFile;
+    private readonly testReportsDir;
+    private readonly testMatch;
+    constructor(scope: IConstruct, options?: NodeNativeTestRunnerOptions);
+    /**
+     * Adds a test match pattern.
+     * @param pattern glob pattern to match for tests
+     */
+    addTestMatch(pattern: string): void;
+    /**
+     * Removes a test match pattern, if configured.
+     * @param pattern glob pattern to remove
+     */
+    removeTestMatch(pattern: string): void;
+    /**
+     * 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: ReporterKind, destination?: Destination): void;
+    /**
+     * Removes a reporter, if configured.
+     * @param name The name/kind of the reporter to remove.
+     */
+    removeReporter(name: ReporterKind): void;
+    /**
+     * Lists the configured reporters, in the order they were added.
+     */
+    listReporters(): NodeReporter[];
+}

package/lib/javascript/node-native-test-runner.js

@@ -0,0 +1,368 @@
+"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.103.27" };
+    /**
+     * 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.103.27" };
+    /**
+     * 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"]}