fix(@angular/build): only compile included test files in unit-test builder

When running the `unit-test` builder with `--include`, TypeScript compilation previously compiled all test files matched by the tsconfig file, causing compilation errors in unrelated test files to fail the test run.

This change introduces a `rootFiles` option that restricts the TypeScript program's root files to only the test files to be executed (plus setup files and providers), while preserving ambient `.d.ts` declaration files discovered by `readConfiguration`.

Fixes #34089

Author: alan-agius4

packages/angular/build/src/builders/application/options.ts

@@ -138,6 +138,12 @@ interface InternalOptions {
    * there. Used exclusively for tests and shouldn't be used for other kinds of builds.
    */
   disableCodeSplitting?: boolean;
+
+  /**
+   * An array of root files to compile. When provided, only these files (and ambient declaration files)
+   * will be included in the TypeScript compilation root names.
+   */
+  rootFiles?: string[];
 }
 
 /** Full set of options for `application` builder. */
@@ -447,6 +453,7 @@ export async function normalizeOptions(
     verbose,
     watch,
     progress = true,
+    rootFiles,
     externalPackages,
     namedChunks,
     budgets,
@@ -494,6 +501,7 @@ export async function normalizeOptions(
     workspaceRoot,
     entryPoints,
     disableCodeSplitting,
+    rootFiles: rootFiles?.map((file: string) => path.resolve(workspaceRoot, file)),
     optimizationOptions,
     outputOptions,
     outExtension,

packages/angular/build/src/builders/karma/application_builder.ts

@@ -157,14 +157,10 @@ async function setupBuildOptions(
   projectSourceRoot: string,
   outputPath: string,
 ): Promise<{ buildOptions: BuildOptions; mainName: string }> {
-  const entryPoints = await collectEntrypoints(options, context, projectSourceRoot);
+  const { entryPoints, testFiles } = await collectEntrypoints(options, context, projectSourceRoot);
 
   const mainName = 'test_main';
-  if (options.main) {
-    entryPoints.set(mainName, options.main);
-  } else {
-    entryPoints.set(mainName, 'angular:test-bed-init');
-  }
+  entryPoints.set(mainName, options.main || 'angular:test-bed-init');
 
   const instrumentForCoverage = options.codeCoverage
     ? createInstrumentationFilter(
@@ -181,6 +177,7 @@ async function setupBuildOptions(
   const buildOptions: BuildOptions = {
     assets: options.assets,
     entryPoints,
+    rootFiles: options.main ? [...testFiles, options.main] : testFiles,
     tsConfig: options.tsConfig,
     outputPath,
     preserveSymlinks: options.preserveSymlinks,

packages/angular/build/src/builders/karma/utils.ts

@@ -50,7 +50,7 @@ export async function collectEntrypoints(
   options: NormalizedKarmaBuilderOptions,
   context: BuilderContext,
   projectSourceRoot: string,
-): Promise<Map<string, string>> {
+): Promise<{ entryPoints: Map<string, string>; testFiles: string[] }> {
   // Glob for files to test.
   const testFiles = await findTests(
     options.include,
@@ -59,7 +59,12 @@ export async function collectEntrypoints(
     projectSourceRoot,
   );
 
-  return getTestEntrypoints(testFiles, { projectSourceRoot, workspaceRoot: context.workspaceRoot });
+  const entryPoints = getTestEntrypoints(testFiles, {
+    projectSourceRoot,
+    workspaceRoot: context.workspaceRoot,
+  });
+
+  return { entryPoints, testFiles };
 }
 
 export function hasChunkOrWorkerFiles(files: readonly ResultFile[]): boolean {

packages/angular/build/src/builders/unit-test/runners/vitest/build-options.ts

@@ -198,7 +198,15 @@ export async function getVitestBuildOptions(
   options: NormalizedUnitTestBuilderOptions,
   baseBuildOptions: Partial<ApplicationBuilderInternalOptions>,
 ): Promise<RunnerOptions> {
-  const { workspaceRoot, projectSourceRoot, include, exclude = [], watch, providersFile } = options;
+  const {
+    workspaceRoot,
+    projectSourceRoot,
+    include,
+    exclude = [],
+    watch,
+    providersFile,
+    setupFiles,
+  } = options;
 
   // Find test files
   const testFiles = await findTests(include, exclude, workspaceRoot, projectSourceRoot);
@@ -217,8 +225,15 @@ export async function getVitestBuildOptions(
     removeTestExtension: true,
   });
 
-  if (options.setupFiles?.length) {
-    const setupEntryPoints = getTestEntrypoints(options.setupFiles, {
+  const rootFiles = [...testFiles];
+  if (providersFile) {
+    rootFiles.push(providersFile);
+  }
+
+  if (setupFiles?.length) {
+    rootFiles.push(...setupFiles);
+
+    const setupEntryPoints = getTestEntrypoints(setupFiles, {
       projectSourceRoot,
       workspaceRoot,
       removeTestExtension: false,
@@ -258,6 +273,7 @@ export async function getVitestBuildOptions(
     optimization: false,
     namedChunks: false,
     entryPoints,
+    rootFiles,
     // Vitest's Node-based module loading emulation (vite-node) is not fully spec compliant and lacks
     // live ESM bindings across chunk boundaries. This can cause uninitialized exports or break mocking.
     // Disabling code splitting avoids shared chunks, but increases build and coverage memory/time.

packages/angular/build/src/builders/unit-test/tests/options/include_spec.ts

@@ -83,5 +83,32 @@ describeBuilder(execute, UNIT_TEST_BUILDER_INFO, (harness) => {
         expect(result?.success).toBeTrue();
       });
     });
+
+    it('should ignore TypeScript compilation errors in non-included test files', async () => {
+      await harness.writeFiles({
+        'src/app/services/test.service.spec.ts': `
+          describe('TestService', () => {
+            it('should succeed', () => {
+              expect(true).toBe(true);
+            });
+          });`,
+        'src/app/broken.service.spec.ts': `
+          // This test has a TypeScript type error that would fail compilation if compiled
+          const invalidNumber: number = 'not a number';
+          describe('BrokenService', () => {
+            it('should fail compilation', () => {
+              expect(invalidNumber).toBe(1);
+            });
+          });`,
+      });
+
+      harness.useTarget('test', {
+        ...BASE_OPTIONS,
+        include: ['src/app/services/test.service.spec.ts'],
+      });
+
+      const { result } = await harness.executeOnce();
+      expect(result?.success).toBeTrue();
+    });
   });
 });

packages/angular/build/src/tools/angular/compilation/compiler-options.ts

@@ -20,6 +20,7 @@ export interface CompilerOptionOverrides {
   instrumentForCoverage?: boolean;
   includeTestMetadata?: boolean;
   customConditions?: string[];
+  rootFiles?: string[];
 }
 
 export function transformCompilerOptions(

packages/angular/build/src/tools/angular/compilation/typescript-compilation.ts

@@ -9,7 +9,7 @@
 import type * as ng from '@angular/compiler-cli';
 import type { PartialMessage } from 'esbuild';
 import ts from 'typescript';
-import { toPosixPath } from '../../../utils/path';
+import { canonicalizePath, toPosixPath } from '../../../utils/path';
 import { profileAsync, profileSync } from '../../esbuild/profiling';
 import { AngularCompilation, DiagnosticModes } from './angular-compilation';
 import { type CompilerOptionOverrides, transformCompilerOptions } from './compiler-options';
@@ -39,7 +39,7 @@ export abstract class TypeScriptCompilation extends AngularCompilation {
 
     const {
       options: originalCompilerOptions,
-      rootNames,
+      rootNames: originalRootNames,
       errors,
     } = profileSync('NG_READ_CONFIG', () =>
       readConfiguration(tsconfig, {
@@ -60,6 +60,19 @@ export abstract class TypeScriptCompilation extends AngularCompilation {
       }),
     );
 
+    let rootNames = originalRootNames;
+    if (compilerOptionOverrides?.rootFiles) {
+      const rootFilesSet = new Set(
+        compilerOptionOverrides.rootFiles.map((file) => canonicalizePath(toPosixPath(file))),
+      );
+      for (const file of originalRootNames) {
+        if (/\.d\.[cm]?ts$/.test(file)) {
+          rootFilesSet.add(canonicalizePath(toPosixPath(file)));
+        }
+      }
+      rootNames = [...rootFilesSet];
+    }
+
     const { compilerOptions, warnings } = transformCompilerOptions(
       ts,
       originalCompilerOptions,

packages/angular/build/src/tools/esbuild/angular/compiler-plugin.ts

@@ -57,6 +57,7 @@ export interface CompilerPluginOptions {
   externalRuntimeStyles?: boolean;
   instrumentForCoverage?: (request: string) => boolean;
   templateUpdates?: Map<string, string>;
+  rootFiles?: string[];
 }
 
 // eslint-disable-next-line max-lines-per-function
@@ -325,17 +326,21 @@ export function createCompilerPlugin(
               instrumentForCoverage: !!pluginOptions.instrumentForCoverage,
               includeTestMetadata: !!pluginOptions.includeTestMetadata,
               customConditions: build.initialOptions.conditions,
+              rootFiles: pluginOptions.rootFiles,
             },
           );
+
           if (initializationResult.warnings?.length) {
             setupWarnings?.push(...initializationResult.warnings);
           }
+
           angularCompilationContext.setCompilerOptions(initializationResult.compilerOptions);
           shouldTsIgnoreJs = !initializationResult.compilerOptions.allowJs;
           useTypeScriptTranspilation =
             !!initializationResult.compilerOptions['_useTypeScriptTranspilation'];
           referencedFiles = initializationResult.referencedFiles;
           externalStylesheets = initializationResult.externalStylesheets;
+
           if (initializationResult.templateUpdates) {
             // Propagate any template updates
             initializationResult.templateUpdates.forEach((value, key) =>

packages/angular/build/src/tools/esbuild/compiler-plugin-options.ts

@@ -28,6 +28,7 @@ export function createCompilerPluginOptions(
     externalRuntimeStyles,
     instrumentForCoverage,
     optimizationOptions,
+    rootFiles,
   } = options;
   const incremental = !!options.watch;
 
@@ -45,5 +46,6 @@ export function createCompilerPluginOptions(
     instrumentForCoverage,
     templateUpdates,
     includeTestMetadata: !optimizationOptions.scripts,
+    rootFiles,
   };
 }