test(@angular/build): verify coverage ignore comments are preserved during compilation

The underlying Vitest coverage engine depends on specific developer comments like `/* istanbul ignore next */` or `/* v8 ignore next */` being present in the executing code to accurately isolate unmeasured blocks.

This commit adds strict behavioral tests to assert that the Angular CLI's in-memory compilation pipeline (via esbuild) properly preserves these structural comments and forwards them reliably to Vitest's coverage processing engine.

Author: clydin

packages/angular/build/src/builders/unit-test/tests/behavior/coverage-ignore-comments_spec.ts

@@ -0,0 +1,270 @@
+/**
+ * @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
+ */
+
+import { execute } from '../../index';
+import {
+  BASE_OPTIONS,
+  describeBuilder,
+  UNIT_TEST_BUILDER_INFO,
+  setupApplicationTarget,
+} from '../setup';
+
+describeBuilder(execute, UNIT_TEST_BUILDER_INFO, (harness) => {
+  describe('Behavior: "coverage ignore comments"', () => {
+    beforeEach(async () => {
+      setupApplicationTarget(harness);
+    });
+
+    function getSpecContent(extraTest = '') {
+      return `
+import { TestBed } from '@angular/core/testing';
+import { AppComponent } from './app.component';
+
+describe('AppComponent', () => {
+  beforeEach(async () => {
+    await TestBed.configureTestingModule({
+      imports: [AppComponent],
+    }).compileComponents();
+  });
+
+  it('should create the app', () => {
+    const fixture = TestBed.createComponent(AppComponent);
+    const app = fixture.componentInstance;
+    expect(app).toBeTruthy();
+  });
+
+  it('should render title', async () => {
+    const fixture = TestBed.createComponent(AppComponent);
+    await fixture.whenStable();
+    const compiled = fixture.nativeElement as HTMLElement;
+    expect(compiled.querySelector('h1')?.textContent).toContain('hello');
+  });
+
+  ${extraTest}
+});
+`;
+    }
+
+    for (const type of ['istanbul', 'v8']) {
+      it(`should respect ${type} ignore next comments when computing coverage`, async () => {
+        harness.useTarget('test', {
+          ...BASE_OPTIONS,
+          coverage: true,
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          coverageReporters: ['json'] as any,
+        });
+
+        harness.writeFile(
+          'src/app/app.component.ts',
+          `
+          import { Component } from '@angular/core';
+
+          @Component({
+            selector: 'app-root',
+            template: '<h1>hello</h1>',
+            standalone: true,
+          })
+          export class AppComponent {
+            title = 'app';
+            
+            /* ${type} ignore next */
+            untestedFunction() {
+              return false;
+            }
+          }
+          `,
+        );
+
+        harness.writeFile('src/app/app.component.spec.ts', getSpecContent());
+
+        const { result } = await harness.executeOnce();
+        expect(result?.success).toBeTrue();
+        harness.expectFile('coverage/test/coverage-final.json').toExist();
+
+        const coverageMap = JSON.parse(harness.readFile('coverage/test/coverage-final.json'));
+        const appComponentPath = Object.keys(coverageMap).find((p) => p.includes('app.component.ts'));
+        expect(appComponentPath).toBeDefined();
+
+        const appComponentCoverage = coverageMap[appComponentPath!];
+
+        const statementCounts = Object.values(appComponentCoverage.s) as number[];
+        const hasUncoveredStatements = statementCounts.some((count) => count === 0);
+        expect(hasUncoveredStatements)
+          .withContext('There should be no uncovered statements as the uncalled function was ignored')
+          .toBeFalse();
+      });
+    }
+
+    // Note: V8 does not support 'ignore if' semantic comments; it only supports generic line/block ignores.
+    it('should respect istanbul ignore if comments when computing coverage', async () => {
+      harness.useTarget('test', {
+        ...BASE_OPTIONS,
+        coverage: true,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        coverageReporters: ['json'] as any,
+      });
+
+      harness.writeFile(
+        'src/app/app.component.ts',
+        `
+        import { Component } from '@angular/core';
+
+        @Component({
+          selector: 'app-root',
+          template: '<h1>hello</h1>',
+          standalone: true,
+        })
+        export class AppComponent {
+          checkValue(val: boolean) {
+            /* istanbul ignore if */
+            if (val) {
+              return true;
+            }
+            return false;
+          }
+        }
+        `,
+      );
+
+      harness.writeFile(
+        'src/app/app.component.spec.ts',
+        getSpecContent(`
+  it('should exercise the function but not the if block', () => {
+    const fixture = TestBed.createComponent(AppComponent);
+    const app = fixture.componentInstance;
+    app.checkValue(false);
+  });
+`),
+      );
+
+      const { result } = await harness.executeOnce();
+      expect(result?.success).toBeTrue();
+      harness.expectFile('coverage/test/coverage-final.json').toExist();
+
+      const coverageMap = JSON.parse(harness.readFile('coverage/test/coverage-final.json'));
+      const appComponentPath = Object.keys(coverageMap).find((p) => p.includes('app.component.ts'));
+      expect(appComponentPath).toBeDefined();
+
+      const appComponentCoverage = coverageMap[appComponentPath!];
+
+      const statementCounts = Object.values(appComponentCoverage.s) as number[];
+      const hasUncoveredStatements = statementCounts.some((count) => count === 0);
+      expect(hasUncoveredStatements)
+        .withContext('There should be no uncovered statements as the uncalled branch was ignored')
+        .toBeFalse();
+    });
+
+    it('should respect istanbul ignore else comments when computing coverage', async () => {
+      harness.useTarget('test', {
+        ...BASE_OPTIONS,
+        coverage: true,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        coverageReporters: ['json'] as any,
+      });
+
+      harness.writeFile(
+        'src/app/app.component.ts',
+        `
+        import { Component } from '@angular/core';
+
+        @Component({
+          selector: 'app-root',
+          template: '<h1>hello</h1>',
+          standalone: true,
+        })
+        export class AppComponent {
+          checkValue(val: boolean) {
+            /* istanbul ignore else */
+            if (val) {
+              return true;
+            } else {
+              return false;
+            }
+          }
+        }
+        `,
+      );
+
+      harness.writeFile(
+        'src/app/app.component.spec.ts',
+        getSpecContent(`
+  it('should exercise the function and the if block', () => {
+    const fixture = TestBed.createComponent(AppComponent);
+    const app = fixture.componentInstance;
+    app.checkValue(true);
+  });
+`),
+      );
+
+      const { result } = await harness.executeOnce();
+      expect(result?.success).toBeTrue();
+      harness.expectFile('coverage/test/coverage-final.json').toExist();
+
+      const coverageMap = JSON.parse(harness.readFile('coverage/test/coverage-final.json'));
+      const appComponentPath = Object.keys(coverageMap).find((p) => p.includes('app.component.ts'));
+      expect(appComponentPath).toBeDefined();
+
+      const appComponentCoverage = coverageMap[appComponentPath!];
+
+      const statementCounts = Object.values(appComponentCoverage.s) as number[];
+      const hasUncoveredStatements = statementCounts.some((count) => count === 0);
+      expect(hasUncoveredStatements)
+        .withContext('There should be no uncovered statements as the uncalled branch was ignored')
+        .toBeFalse();
+    });
+
+    it('should respect v8 ignore start/stop comments when computing coverage', async () => {
+      harness.useTarget('test', {
+        ...BASE_OPTIONS,
+        coverage: true,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        coverageReporters: ['json'] as any,
+      });
+
+      harness.writeFile(
+        'src/app/app.component.ts',
+        `
+        import { Component } from '@angular/core';
+
+        @Component({
+          selector: 'app-root',
+          template: '<h1>hello</h1>',
+          standalone: true,
+        })
+        export class AppComponent {
+          title = 'app';
+
+          /* v8 ignore start */
+          untestedFunction() {
+            return false;
+          }
+          /* v8 ignore stop */
+        }
+        `,
+      );
+
+      harness.writeFile('src/app/app.component.spec.ts', getSpecContent());
+
+      const { result } = await harness.executeOnce();
+      expect(result?.success).toBeTrue();
+      harness.expectFile('coverage/test/coverage-final.json').toExist();
+
+      const coverageMap = JSON.parse(harness.readFile('coverage/test/coverage-final.json'));
+      const appComponentPath = Object.keys(coverageMap).find((p) => p.includes('app.component.ts'));
+      expect(appComponentPath).toBeDefined();
+
+      const appComponentCoverage = coverageMap[appComponentPath!];
+
+      const statementCounts = Object.values(appComponentCoverage.s) as number[];
+      const hasUncoveredStatements = statementCounts.some((count) => count === 0);
+      expect(hasUncoveredStatements)
+        .withContext('There should be no uncovered statements as the uncalled function was ignored')
+        .toBeFalse();
+    });
+  });
+});