@angular/build 21.0.0-next.3 → 21.0.0-next.5

package/src/builders/unit-test/builder.js

@@ -98,11 +98,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.execute = execute;
 const architect_1 = require("@angular-devkit/architect");
 const node_assert_1 = __importDefault(require("node:assert"));
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
 const virtual_module_plugin_1 = require("../../tools/esbuild/virtual-module-plugin");
 const error_1 = require("../../utils/error");
+const test_files_1 = require("../../utils/test-files");
 const application_1 = require("../application");
 const results_1 = require("../application/results");
 const options_1 = require("./options");
+const dependency_checker_1 = require("./runners/dependency-checker");
+const test_discovery_1 = require("./test-discovery");
 async function loadTestRunner(runnerName) {
     // Harden against directory traversal
     if (!/^[a-zA-Z0-9-]+$/.test(runnerName)) {
@@ -148,7 +153,8 @@ function prepareBuildExtensions(virtualFiles, projectSourceRoot, extensions) {
     }
     return extensions;
 }
-async function* runBuildAndTest(executor, applicationBuildOptions, context, extensions) {
+async function* runBuildAndTest(executor, applicationBuildOptions, context, dumpDirectory, extensions) {
+    let consecutiveErrorCount = 0;
     for await (const buildResult of (0, application_1.buildApplicationInternal)(applicationBuildOptions, context, extensions)) {
         if (buildResult.kind === results_1.ResultKind.Failure) {
             yield { success: false };
@@ -159,65 +165,165 @@ async function* runBuildAndTest(executor, applicationBuildOptions, context, exte
             node_assert_1.default.fail('A full and/or incremental build result is required from the application builder.');
         }
         (0, node_assert_1.default)(buildResult.files, 'Builder did not provide result files.');
+        if (dumpDirectory) {
+            if (buildResult.kind === results_1.ResultKind.Full) {
+                // Full build, so clean the directory
+                await (0, promises_1.rm)(dumpDirectory, { recursive: true, force: true });
+            }
+            else {
+                // Incremental build, so delete removed files
+                for (const file of buildResult.removed) {
+                    await (0, promises_1.rm)(node_path_1.default.join(dumpDirectory, file.path), { force: true });
+                }
+            }
+            await (0, test_files_1.writeTestFiles)(buildResult.files, dumpDirectory);
+            context.logger.info(`Build output files successfully dumped to '${dumpDirectory}'.`);
+        }
         // Pass the build artifacts to the executor
-        yield* executor.execute(buildResult);
+        try {
+            yield* executor.execute(buildResult);
+            // Successful execution resets the failure counter
+            consecutiveErrorCount = 0;
+        }
+        catch (e) {
+            (0, error_1.assertIsError)(e);
+            context.logger.error(`An exception occurred during test execution:\n${e.stack ?? e.message}`);
+            yield { success: false };
+            consecutiveErrorCount++;
+        }
+        if (consecutiveErrorCount >= 3) {
+            context.logger.error('Test runner process has failed multiple times in a row. Please fix the configuration and restart the process.');
+            return;
+        }
     }
 }
 /**
  * @experimental Direct usage of this function is considered experimental.
  */
 async function* execute(options, context, extensions) {
-    const env_1 = { stack: [], error: void 0, hasError: false };
+    // Determine project name from builder context target
+    const projectName = context.target?.project;
+    if (!projectName) {
+        context.logger.error(`The builder requires a target to be specified.`);
+        return;
+    }
+    context.logger.warn(`NOTE: The "unit-test" builder is currently EXPERIMENTAL and not ready for production use.`);
+    // Initialize the test runner and normalize options
+    let runner;
+    let normalizedOptions;
     try {
-        // Determine project name from builder context target
-        const projectName = context.target?.project;
-        if (!projectName) {
-            context.logger.error(`The builder requires a target to be specified.`);
-            return;
+        normalizedOptions = await (0, options_1.normalizeOptions)(context, projectName, options);
+        runner = await loadTestRunner(normalizedOptions.runnerName);
+        await runner.validateDependencies?.(normalizedOptions);
+    }
+    catch (e) {
+        (0, error_1.assertIsError)(e);
+        if (e instanceof dependency_checker_1.MissingDependenciesError) {
+            context.logger.error(e.message);
         }
-        context.logger.warn(`NOTE: The "unit-test" builder is currently EXPERIMENTAL and not ready for production use.`);
-        const normalizedOptions = await (0, options_1.normalizeOptions)(context, projectName, options);
-        const runner = await loadTestRunner(normalizedOptions.runnerName);
-        const executor = __addDisposableResource(env_1, await runner.createExecutor(context, normalizedOptions), true);
-        if (runner.isStandalone) {
-            yield* executor.execute({
-                kind: results_1.ResultKind.Full,
-                files: {},
-            });
-            return;
+        else {
+            context.logger.error(`An exception occurred during initialization of the test runner:\n${e.stack ?? e.message}`);
         }
-        // Get base build options from the buildTarget
-        let buildTargetOptions;
+        yield { success: false };
+        return;
+    }
+    if (normalizedOptions.listTests) {
+        const testFiles = await (0, test_discovery_1.findTests)(normalizedOptions.include, normalizedOptions.exclude ?? [], normalizedOptions.workspaceRoot, normalizedOptions.projectSourceRoot);
+        context.logger.info('Discovered test files:');
+        for (const file of testFiles) {
+            context.logger.info(`  ${node_path_1.default.relative(normalizedOptions.workspaceRoot, file)}`);
+        }
+        yield { success: true };
+        return;
+    }
+    if (runner.isStandalone) {
         try {
-            buildTargetOptions = (await context.validateOptions(await context.getTargetOptions(normalizedOptions.buildTarget), await context.getBuilderNameForTarget(normalizedOptions.buildTarget)));
+            const env_1 = { stack: [], error: void 0, hasError: false };
+            try {
+                const executor = __addDisposableResource(env_1, await runner.createExecutor(context, normalizedOptions, undefined), true);
+                yield* executor.execute({
+                    kind: results_1.ResultKind.Full,
+                    files: {},
+                });
+            }
+            catch (e_1) {
+                env_1.error = e_1;
+                env_1.hasError = true;
+            }
+            finally {
+                const result_1 = __disposeResources(env_1);
+                if (result_1)
+                    await result_1;
+            }
         }
         catch (e) {
             (0, error_1.assertIsError)(e);
-            context.logger.error(`Could not load build target options for "${(0, architect_1.targetStringFromTarget)(normalizedOptions.buildTarget)}".\n` +
-                `Please check your 'angular.json' configuration.\n` +
-                `Error: ${e.message}`);
-            return;
+            context.logger.error(`An exception occurred during standalone test execution:\n${e.stack ?? e.message}`);
+            yield { success: false };
         }
-        // Get runner-specific build options from the hook
-        const { buildOptions: runnerBuildOptions, virtualFiles } = await runner.getBuildOptions(normalizedOptions, buildTargetOptions);
-        const finalExtensions = prepareBuildExtensions(virtualFiles, normalizedOptions.projectSourceRoot, extensions);
-        // Prepare and run the application build
-        const applicationBuildOptions = {
-            ...buildTargetOptions,
-            ...runnerBuildOptions,
-            watch: normalizedOptions.watch,
-            tsConfig: normalizedOptions.tsConfig,
-            progress: normalizedOptions.buildProgress ?? buildTargetOptions.progress,
-        };
-        yield* runBuildAndTest(executor, applicationBuildOptions, context, finalExtensions);
+        return;
+    }
+    // Get base build options from the buildTarget
+    let buildTargetOptions;
+    try {
+        buildTargetOptions = (await context.validateOptions(await context.getTargetOptions(normalizedOptions.buildTarget), await context.getBuilderNameForTarget(normalizedOptions.buildTarget)));
+    }
+    catch (e) {
+        (0, error_1.assertIsError)(e);
+        context.logger.error(`Could not load build target options for "${(0, architect_1.targetStringFromTarget)(normalizedOptions.buildTarget)}".\n` +
+            `Please check your 'angular.json' configuration.\n` +
+            `Error: ${e.message}`);
+        yield { success: false };
+        return;
+    }
+    // Get runner-specific build options
+    let runnerBuildOptions;
+    let virtualFiles;
+    let testEntryPointMappings;
+    try {
+        ({
+            buildOptions: runnerBuildOptions,
+            virtualFiles,
+            testEntryPointMappings,
+        } = await runner.getBuildOptions(normalizedOptions, buildTargetOptions));
     }
-    catch (e_1) {
-        env_1.error = e_1;
-        env_1.hasError = true;
+    catch (e) {
+        (0, error_1.assertIsError)(e);
+        context.logger.error(`An exception occurred while getting runner-specific build options:\n${e.stack ?? e.message}`);
+        yield { success: false };
+        return;
     }
-    finally {
-        const result_1 = __disposeResources(env_1);
-        if (result_1)
-            await result_1;
+    try {
+        const env_2 = { stack: [], error: void 0, hasError: false };
+        try {
+            const executor = __addDisposableResource(env_2, await runner.createExecutor(context, normalizedOptions, testEntryPointMappings), true);
+            const finalExtensions = prepareBuildExtensions(virtualFiles, normalizedOptions.projectSourceRoot, extensions);
+            // Prepare and run the application build
+            const applicationBuildOptions = {
+                ...buildTargetOptions,
+                ...runnerBuildOptions,
+                watch: normalizedOptions.watch,
+                tsConfig: normalizedOptions.tsConfig,
+                progress: normalizedOptions.buildProgress ?? buildTargetOptions.progress,
+            };
+            const dumpDirectory = normalizedOptions.dumpVirtualFiles
+                ? node_path_1.default.join(normalizedOptions.cacheOptions.path, 'unit-test', 'output-files')
+                : undefined;
+            yield* runBuildAndTest(executor, applicationBuildOptions, context, dumpDirectory, finalExtensions);
+        }
+        catch (e_2) {
+            env_2.error = e_2;
+            env_2.hasError = true;
+        }
+        finally {
+            const result_2 = __disposeResources(env_2);
+            if (result_2)
+                await result_2;
+        }
+    }
+    catch (e) {
+        (0, error_1.assertIsError)(e);
+        context.logger.error(`An exception occurred while creating the test executor:\n${e.stack ?? e.message}`);
+        yield { success: false };
     }
 }

package/src/builders/unit-test/options.d.ts

@@ -16,6 +16,7 @@ export declare function normalizeOptions(context: BuilderContext, projectName: s
     buildTarget: import("@angular-devkit/architect").Target;
     include: string[];
     exclude: string[] | undefined;
+    filter: string | undefined;
     runnerName: import("./schema").Runner;
     codeCoverage: {
         exclude: string[] | undefined;
@@ -23,11 +24,14 @@ export declare function normalizeOptions(context: BuilderContext, projectName: s
     } | undefined;
     tsConfig: string;
     buildProgress: boolean | undefined;
-    reporters: string[] | undefined;
+    reporters: [string, Record<string, unknown>][] | undefined;
+    outputFile: string | undefined;
     browsers: string[] | undefined;
     watch: boolean;
     debug: boolean;
     providersFile: string | undefined;
     setupFiles: string[];
+    dumpVirtualFiles: boolean | undefined;
+    listTests: boolean | undefined;
 }>;
 export declare function injectTestingPolyfills(polyfills?: string[]): string[];

package/src/builders/unit-test/options.js

@@ -17,6 +17,11 @@ const node_path_1 = __importDefault(require("node:path"));
 const normalize_cache_1 = require("../../utils/normalize-cache");
 const project_metadata_1 = require("../../utils/project-metadata");
 const tty_1 = require("../../utils/tty");
+function normalizeReporterOption(reporters) {
+    return reporters?.map((entry) => typeof entry === 'string'
+        ? [entry, {}]
+        : entry);
+}
 async function normalizeOptions(context, projectName, options) {
     // Setup base paths based on workspace root and project information
     const workspaceRoot = context.workspaceRoot;
@@ -28,7 +33,7 @@ async function normalizeOptions(context, projectName, options) {
     // Target specifier defaults to the current project's build target using a development configuration
     const buildTargetSpecifier = options.buildTarget ?? `::development`;
     const buildTarget = (0, architect_1.targetFromTargetString)(buildTargetSpecifier, projectName, 'build');
-    const { tsConfig, runner, reporters, browsers, progress } = options;
+    const { tsConfig, runner, browsers, progress, filter } = options;
     return {
         // Project/workspace information
         workspaceRoot,
@@ -39,18 +44,18 @@ async function normalizeOptions(context, projectName, options) {
         buildTarget,
         include: options.include ?? ['**/*.spec.ts'],
         exclude: options.exclude,
+        filter,
         runnerName: runner,
         codeCoverage: options.codeCoverage
             ? {
                 exclude: options.codeCoverageExclude,
-                reporters: options.codeCoverageReporters?.map((entry) => typeof entry === 'string'
-                    ? [entry, {}]
-                    : entry),
+                reporters: normalizeReporterOption(options.codeCoverageReporters),
             }
             : undefined,
         tsConfig,
         buildProgress: progress,
-        reporters,
+        reporters: normalizeReporterOption(options.reporters),
+        outputFile: options.outputFile,
         browsers,
         watch: options.watch ?? (0, tty_1.isTTY)(),
         debug: options.debug ?? false,
@@ -58,6 +63,8 @@ async function normalizeOptions(context, projectName, options) {
         setupFiles: options.setupFiles
             ? options.setupFiles.map((setupFile) => node_path_1.default.join(workspaceRoot, setupFile))
             : [],
+        dumpVirtualFiles: options.dumpVirtualFiles,
+        listTests: options.listTests,
     };
 }
 function injectTestingPolyfills(polyfills = []) {

package/src/builders/unit-test/runners/api.d.ts

@@ -9,9 +9,25 @@ import type { BuilderContext, BuilderOutput } from '@angular-devkit/architect';
 import type { ApplicationBuilderInternalOptions } from '../../application/options';
 import type { FullResult, IncrementalResult } from '../../application/results';
 import type { NormalizedUnitTestBuilderOptions } from '../options';
+/**
+ * Represents the options for a test runner.
+ */
 export interface RunnerOptions {
+    /**
+     * Partial options for the application builder.
+     * These will be merged with the options from the build target.
+     */
     buildOptions: Partial<ApplicationBuilderInternalOptions>;
+    /**
+     * A record of virtual files to be added to the build.
+     * The key is the file path and the value is the file content.
+     */
     virtualFiles?: Record<string, string>;
+    /**
+     * A map of test entry points to their corresponding test files.
+     * This is used to avoid re-discovering the test files in the executor.
+     */
+    testEntryPointMappings?: Map<string, string>;
 }
 /**
  * Represents a stateful test execution session.
@@ -34,6 +50,7 @@ export interface TestExecutor {
 export interface TestRunner {
     readonly name: string;
     readonly isStandalone?: boolean;
+    validateDependencies?(options: NormalizedUnitTestBuilderOptions): void | Promise<void>;
     getBuildOptions(options: NormalizedUnitTestBuilderOptions, baseBuildOptions: Partial<ApplicationBuilderInternalOptions>): RunnerOptions | Promise<RunnerOptions>;
     /**
      * Creates a stateful executor for a test session.
@@ -41,7 +58,8 @@ export interface TestRunner {
      *
      * @param context The Architect builder context.
      * @param options The normalized unit test options.
+     * @param testEntryPointMappings A map of test entry points to their corresponding test files.
      * @returns A TestExecutor instance that will handle the test runs.
      */
-    createExecutor(context: BuilderContext, options: NormalizedUnitTestBuilderOptions): Promise<TestExecutor>;
+    createExecutor(context: BuilderContext, options: NormalizedUnitTestBuilderOptions, testEntryPointMappings: Map<string, string> | undefined): Promise<TestExecutor>;
 }

package/src/builders/unit-test/runners/dependency-checker.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+/**
+ * A custom error class to represent missing dependency errors.
+ * This is used to avoid printing a stack trace for this expected error.
+ */
+export declare class MissingDependenciesError extends Error {
+    constructor(message: string);
+}
+export declare class DependencyChecker {
+    private readonly resolver;
+    private readonly missingDependencies;
+    constructor(projectSourceRoot: string);
+    /**
+     * Checks if a package is installed.
+     * @param packageName The name of the package to check.
+     * @returns True if the package is found, false otherwise.
+     */
+    private isInstalled;
+    /**
+     * Verifies that a package is installed and adds it to a list of missing
+     * dependencies if it is not.
+     * @param packageName The name of the package to check.
+     */
+    check(packageName: string): void;
+    /**
+     * Verifies that at least one of a list of packages is installed. If none are
+     * installed, a custom error message is added to the list of errors.
+     * @param packageNames An array of package names to check.
+     * @param customErrorMessage The error message to use if none of the packages are found.
+     */
+    checkAny(packageNames: string[], customErrorMessage: string): void;
+    /**
+     * Throws a `MissingDependenciesError` if any dependencies were found to be missing.
+     * The error message is a formatted list of all missing packages.
+     */
+    report(): void;
+}

package/src/builders/unit-test/runners/dependency-checker.js

@@ -0,0 +1,82 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DependencyChecker = exports.MissingDependenciesError = void 0;
+const node_module_1 = require("node:module");
+/**
+ * A custom error class to represent missing dependency errors.
+ * This is used to avoid printing a stack trace for this expected error.
+ */
+class MissingDependenciesError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'MissingDependenciesError';
+    }
+}
+exports.MissingDependenciesError = MissingDependenciesError;
+class DependencyChecker {
+    resolver;
+    missingDependencies = new Set();
+    constructor(projectSourceRoot) {
+        this.resolver = (0, node_module_1.createRequire)(projectSourceRoot + '/').resolve;
+    }
+    /**
+     * Checks if a package is installed.
+     * @param packageName The name of the package to check.
+     * @returns True if the package is found, false otherwise.
+     */
+    isInstalled(packageName) {
+        try {
+            this.resolver(packageName);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Verifies that a package is installed and adds it to a list of missing
+     * dependencies if it is not.
+     * @param packageName The name of the package to check.
+     */
+    check(packageName) {
+        if (!this.isInstalled(packageName)) {
+            this.missingDependencies.add(packageName);
+        }
+    }
+    /**
+     * Verifies that at least one of a list of packages is installed. If none are
+     * installed, a custom error message is added to the list of errors.
+     * @param packageNames An array of package names to check.
+     * @param customErrorMessage The error message to use if none of the packages are found.
+     */
+    checkAny(packageNames, customErrorMessage) {
+        if (packageNames.every((name) => !this.isInstalled(name))) {
+            // This is a custom error, so we add it directly.
+            // Using a Set avoids duplicate custom messages.
+            this.missingDependencies.add(customErrorMessage);
+        }
+    }
+    /**
+     * Throws a `MissingDependenciesError` if any dependencies were found to be missing.
+     * The error message is a formatted list of all missing packages.
+     */
+    report() {
+        if (this.missingDependencies.size === 0) {
+            return;
+        }
+        let message = 'The following packages are required but were not found:\n';
+        for (const name of this.missingDependencies) {
+            message += `  - ${name}\n`;
+        }
+        message += 'Please install the missing packages and rerun the test command.';
+        throw new MissingDependenciesError(message);
+    }
+}
+exports.DependencyChecker = DependencyChecker;

package/src/builders/unit-test/runners/karma/executor.js

@@ -79,12 +79,36 @@ class KarmaExecutor {
             codeCoverage: !!unitTestOptions.codeCoverage,
             codeCoverageExclude: unitTestOptions.codeCoverage?.exclude,
             fileReplacements: buildTargetOptions.fileReplacements,
-            reporters: unitTestOptions.reporters,
+            reporters: unitTestOptions.reporters?.map((reporter) => {
+                // Karma only supports string reporters.
+                if (Object.keys(reporter[1]).length > 0) {
+                    context.logger.warn(`The "karma" test runner does not support options for the "${reporter[0]}" reporter. The options will be ignored.`);
+                }
+                return reporter[0];
+            }),
             webWorkerTsConfig: buildTargetOptions.webWorkerTsConfig,
             aot: buildTargetOptions.aot,
         };
+        const transformOptions = {
+            karmaOptions: (options) => {
+                if (unitTestOptions.filter) {
+                    let filter = unitTestOptions.filter;
+                    if (filter[0] === '/' && filter.at(-1) === '/') {
+                        this.context.logger.warn('The `--filter` option is always a regular expression.' +
+                            'Leading and trailing `/` are not required and will be ignored.');
+                    }
+                    else {
+                        filter = `/${filter}/`;
+                    }
+                    options.client ??= {};
+                    options.client.args ??= [];
+                    options.client.args.push('--grep', filter);
+                }
+                return options;
+            },
+        };
         const { execute } = await Promise.resolve().then(() => __importStar(require('../../../karma')));
-        yield* execute(karmaOptions, context);
+        yield* execute(karmaOptions, context, transformOptions);
     }
     async [Symbol.asyncDispose]() {
         // The Karma builder handles its own teardown

package/src/builders/unit-test/runners/karma/index.js

@@ -7,6 +7,7 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+const dependency_checker_1 = require("../dependency-checker");
 const executor_1 = require("./executor");
 /**
  * A declarative definition of the Karma test runner.
@@ -14,6 +15,22 @@ const executor_1 = require("./executor");
 const KarmaTestRunner = {
     name: 'karma',
     isStandalone: true,
+    validateDependencies(options) {
+        const checker = new dependency_checker_1.DependencyChecker(options.projectSourceRoot);
+        checker.check('karma');
+        checker.check('karma-jasmine');
+        // Check for browser launchers
+        if (options.browsers?.length) {
+            for (const browser of options.browsers) {
+                const launcherName = `karma-${browser.toLowerCase().split('headless')[0]}-launcher`;
+                checker.check(launcherName);
+            }
+        }
+        if (options.codeCoverage) {
+            checker.check('karma-coverage');
+        }
+        checker.report();
+    },
     getBuildOptions() {
         return {
             buildOptions: {},

package/src/builders/unit-test/runners/vitest/browser-provider.d.ts

@@ -5,7 +5,8 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.dev/license
  */
-export declare function setupBrowserConfiguration(browsers: string[] | undefined, debug: boolean, projectSourceRoot: string): {
+export interface BrowserConfiguration {
     browser?: import('vitest/node').BrowserConfigOptions;
     errors?: string[];
-};
+}
+export declare function setupBrowserConfiguration(browsers: string[] | undefined, debug: boolean, projectSourceRoot: string): BrowserConfiguration;

package/src/builders/unit-test/runners/vitest/build-options.js

@@ -16,7 +16,8 @@ const path_1 = require("../../../../utils/path");
 const schema_1 = require("../../../application/schema");
 const options_1 = require("../../options");
 const test_discovery_1 = require("../../test-discovery");
-function createTestBedInitVirtualFile(providersFile, projectSourceRoot) {
+function createTestBedInitVirtualFile(providersFile, projectSourceRoot, polyfills = []) {
+    const usesZoneJS = polyfills.includes('zone.js');
     let providersImport = 'const providers = [];';
     if (providersFile) {
         const relativePath = node_path_1.default.relative(projectSourceRoot, providersFile);
@@ -26,7 +27,7 @@ function createTestBedInitVirtualFile(providersFile, projectSourceRoot) {
     }
     return `
     // Initialize the Angular testing environment
-    import { NgModule } from '@angular/core';
+    import { NgModule${usesZoneJS ? ', provideZoneChangeDetection' : ''} } from '@angular/core';
     import { getTestBed, ɵgetCleanupHook as getCleanupHook } from '@angular/core/testing';
     import { BrowserTestingModule, platformBrowserTesting } from '@angular/platform-browser/testing';
     ${providersImport}
@@ -34,7 +35,7 @@ function createTestBedInitVirtualFile(providersFile, projectSourceRoot) {
     beforeEach(getCleanupHook(false));
     afterEach(getCleanupHook(true));
     @NgModule({
-      providers,
+      providers: [${usesZoneJS ? 'provideZoneChangeDetection(), ' : ''}...providers],
     })
     export class TestModule {}
     getTestBed().initTestEnvironment([BrowserTestingModule, TestModule], platformBrowserTesting(), {
@@ -91,11 +92,12 @@ async function getVitestBuildOptions(options, baseBuildOptions) {
         externalDependencies: ['vitest', '@vitest/browser/context'],
     };
     buildOptions.polyfills = (0, options_1.injectTestingPolyfills)(buildOptions.polyfills);
-    const testBedInitContents = createTestBedInitVirtualFile(providersFile, projectSourceRoot);
+    const testBedInitContents = createTestBedInitVirtualFile(providersFile, projectSourceRoot, buildOptions.polyfills);
     return {
         buildOptions,
         virtualFiles: {
             'angular:test-bed-init': testBedInitContents,
         },
+        testEntryPointMappings: entryPoints,
     };
 }

package/src/builders/unit-test/runners/vitest/executor.d.ts

@@ -13,13 +13,12 @@ export declare class VitestExecutor implements TestExecutor {
     private vitest;
     private readonly projectName;
     private readonly options;
-    private buildResultFiles;
-    private testFileToEntryPoint;
-    private entryPointToTestFile;
-    constructor(projectName: string, options: NormalizedUnitTestBuilderOptions);
+    private readonly buildResultFiles;
+    private readonly testFileToEntryPoint;
+    private readonly entryPointToTestFile;
+    constructor(projectName: string, options: NormalizedUnitTestBuilderOptions, testEntryPointMappings: Map<string, string> | undefined);
     execute(buildResult: FullResult | IncrementalResult): AsyncIterable<BuilderOutput>;
     [Symbol.asyncDispose](): Promise<void>;
     private prepareSetupFiles;
-    private createVitestPlugins;
     private initializeVitest;
 }