feat(coverage): v8 to track node:child_process and node:worker_threads contexts

AriPerkkio · AriPerkkio · commit fa35cd558c77 · 2026-03-26T15:49:21.000+02:00
diff --git a/packages/coverage-v8/package.json b/packages/coverage-v8/package.json
@@ -32,6 +32,10 @@
       "types": "./dist/browser.d.ts",
       "default": "./dist/browser.js"
     },
+    "./intercept-new-run-context": {
+      "types": "./dist/intercept-new-run-context.d.ts",
+      "default": "./dist/intercept-new-run-context.js"
+    },
     "./*": "./*"
   },
   "main": "./dist/index.js",
@@ -57,13 +61,15 @@
     "@bcoe/v8-coverage": "^1.0.2",
     "@vitest/utils": "workspace:*",
     "ast-v8-to-istanbul": "^1.0.0",
+    "get-port-please": "catalog:",
     "istanbul-lib-coverage": "catalog:",
     "istanbul-lib-report": "catalog:",
     "istanbul-reports": "catalog:",
     "magicast": "catalog:",
     "obug": "catalog:",
     "std-env": "catalog:",
-    "tinyrainbow": "catalog:"
+    "tinyrainbow": "catalog:",
+    "ws": "catalog:"
   },
   "devDependencies": {
     "@types/istanbul-lib-coverage": "catalog:",
diff --git a/packages/coverage-v8/rollup.config.js b/packages/coverage-v8/rollup.config.js
@@ -10,9 +10,10 @@ const require = createRequire(import.meta.url)
 const pkg = require('./package.json')
 
 const entries = {
-  index: 'src/index.ts',
-  browser: 'src/browser.ts',
-  provider: 'src/provider.ts',
+  'index': 'src/index.ts',
+  'browser': 'src/browser.ts',
+  'provider': 'src/provider.ts',
+  'intercept-new-run-context': 'src/intercept-new-run-context.ts',
 }
 
 const external = [
diff --git a/packages/coverage-v8/src/index.ts b/packages/coverage-v8/src/index.ts
@@ -3,21 +3,41 @@ import type { CoverageProviderModule } from 'vitest/node'
 import type { ScriptCoverageWithOffset, V8CoverageProvider } from './provider'
 import inspector from 'node:inspector/promises'
 import { fileURLToPath } from 'node:url'
+import { getPort } from 'get-port-please'
 import { normalize } from 'pathe'
 import { provider } from 'std-env'
+import { WebSocketServer } from 'ws'
 import { loadProvider } from './load-provider'
 
-const session = new inspector.Session()
+let session: inspector.Session | null = null
 let enabled = false
 
-const mod: CoverageProviderModule = {
-  async startCoverage({ isolate }) {
+const mod: CoverageProviderModule & { wss: WebSocketServer | undefined; extendedContextCoverage: Profiler.ScriptCoverage[] } = {
+  wss: undefined,
+  extendedContextCoverage: [],
+
+  async startCoverage({ isolate, trackProcessAndWorker }) {
     if (isolate === false && enabled) {
       return
     }
 
     enabled = true
 
+    if (trackProcessAndWorker) {
+      const port = await getPort()
+      this.wss = new WebSocketServer({ port })
+
+      this.wss.on('connection', socket => socket.on('message', (raw) => {
+        const result: ScriptCoverageWithOffset[] = JSON.parse(raw.toString())
+        this.extendedContextCoverage.push(...(result || []))
+      }))
+
+      process.env.NODE_OPTIONS ||= ''
+      process.env.NODE_OPTIONS += ' --import @vitest/coverage-v8/intercept-new-run-context'
+      process.env.VITEST_WS_PORT = `${port}`
+    }
+
+    session ||= new inspector.Session()
     session.connect()
     await session.post('Profiler.enable')
     await session.post('Profiler.startPreciseCoverage', { callCount: true, detailed: true })
@@ -28,11 +48,16 @@ const mod: CoverageProviderModule = {
       return { result: [] }
     }
 
+    if (!session) {
+      throw new Error('V8 provider missing inspector session.')
+    }
+
+    this.wss?.clients.forEach(client => client.send('take-coverage'))
     const coverage = await session.post('Profiler.takePreciseCoverage')
     const result: ScriptCoverageWithOffset[] = []
 
     // Reduce amount of data sent over rpc by doing some early result filtering
-    for (const entry of coverage.result) {
+    for (const entry of [...coverage.result, ...this.extendedContextCoverage.splice(0)]) {
       if (filterResult(entry)) {
         result.push({
           ...entry,
@@ -49,9 +74,14 @@ const mod: CoverageProviderModule = {
       return
     }
 
+    if (!session) {
+      throw new Error('V8 provider missing inspector session.')
+    }
+
     await session.post('Profiler.stopPreciseCoverage')
     await session.post('Profiler.disable')
     session.disconnect()
+    this.wss?.close()
   },
 
   async getProvider(): Promise<V8CoverageProvider> {
diff --git a/packages/coverage-v8/src/intercept-new-run-context.ts b/packages/coverage-v8/src/intercept-new-run-context.ts
@@ -0,0 +1,52 @@
+import type { ScriptCoverageWithOffset } from './provider'
+import { WebSocket } from 'ws'
+import provider from './index'
+
+// eslint-disable-next-line antfu/no-top-level-await -- This should be blocking module loading
+await initialize().catch((error) => {
+  console.error('[vitest-coverage] Error initializing process/thread intercepting:', error)
+  throw error
+})
+
+async function initialize() {
+  let reportedCoverage = false
+
+  const ws = new WebSocket(`ws://localhost:${Number(process.env.VITEST_WS_PORT)}`)
+
+  // @ts-expect-error -- untyped
+  ws.on('open', () => ws._socket?.unref?.())
+
+  await provider.startCoverage?.({
+    isolate: true,
+
+    // Environment options that were set by parent should inherit, no need to add more ws servers
+    trackProcessAndWorker: false,
+  })
+
+  onMessage(message => message === 'take-coverage' && takeCoverage())
+  process.on('beforeExit', takeCoverage)
+
+  async function takeCoverage() {
+    if (reportedCoverage) {
+      return
+    }
+
+    reportedCoverage = true
+
+    const coverage = await provider.takeCoverage?.({
+    // Start offset should be 0 as these run outside of Vite
+      moduleExecutionInfo: undefined,
+    }) as { result: ScriptCoverageWithOffset[] }
+
+    // TODO: Now where do we get source maps
+    ws.send(JSON.stringify(coverage.result))
+
+    await provider.stopCoverage?.({ isolate: true })
+
+    ws.close()
+  }
+
+  async function onMessage(callback: (message: unknown) => void) {
+    ws.on('message', raw => callback(raw.toString()))
+  }
+}
diff --git a/packages/vitest/src/defaults.ts b/packages/vitest/src/defaults.ts
@@ -53,6 +53,7 @@ export const coverageConfigDefaults: Required<Pick<CoverageOptions, FieldsWithDe
     branches: [50, 80],
     lines: [50, 80],
   },
+  trackProcessAndWorker: false,
 }
 
 export const fakeTimersDefaults: NonNullable<UserConfig['fakeTimers']> = {
diff --git a/packages/vitest/src/integrations/coverage.ts b/packages/vitest/src/integrations/coverage.ts
@@ -10,7 +10,10 @@ export async function startCoverageInsideWorker(
   const coverageModule = await resolveCoverageProviderModule(options, loader)
 
   if (coverageModule) {
-    return coverageModule.startCoverage?.(runtimeOptions)
+    return coverageModule.startCoverage?.({
+      ...runtimeOptions,
+      trackProcessAndWorker: options?.trackProcessAndWorker ?? false,
+    })
   }
 
   return null
diff --git a/packages/vitest/src/node/config/serializeConfig.ts b/packages/vitest/src/node/config/serializeConfig.ts
@@ -58,6 +58,7 @@ export function serializeConfig(project: TestProject): SerializedConfig {
           ? coverage.customProviderModule
           : undefined,
         htmlDir: coverage.htmlDir,
+        trackProcessAndWorker: coverage.trackProcessAndWorker ?? false,
       }
     })(config.coverage),
     fakeTimers: config.fakeTimers,
diff --git a/packages/vitest/src/node/types/coverage.ts b/packages/vitest/src/node/types/coverage.ts
@@ -264,6 +264,14 @@ export interface CoverageOptions {
    */
   processingConcurrency?: number
 
+  /**
+   * Track coverage of the `node:child_process` and `node:worker_threads` spawned during test run.
+   * Supported only by `v8` provider.
+   *
+   * @default false
+   */
+  trackProcessAndWorker?: boolean
+
   /**
    * Set to array of class method names to ignore for coverage
    *
diff --git a/packages/vitest/src/runtime/config.ts b/packages/vitest/src/runtime/config.ts
@@ -155,6 +155,7 @@ export interface SerializedCoverageConfig {
   htmlDir: string | undefined
   enabled: boolean
   customProviderModule: string | undefined
+  trackProcessAndWorker: boolean
 }
 
 export type RuntimeConfig = Pick<
diff --git a/packages/vitest/src/utils/coverage.ts b/packages/vitest/src/utils/coverage.ts
@@ -15,7 +15,7 @@ export interface RuntimeCoverageProviderModule {
   /**
    * Executed before tests are run in the worker thread.
    */
-  startCoverage?: (runtimeOptions: { isolate: boolean }) => unknown | Promise<unknown>
+  startCoverage?: (runtimeOptions: { isolate: boolean; trackProcessAndWorker?: boolean }) => unknown | Promise<unknown>
 
   /**
    * Executed on after each run in the worker thread. Possible to return a payload passed to the provider
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
@@ -67,6 +67,7 @@ catalog:
   cac: ^6.7.14
   chai: ^6.2.2
   flatted: ^3.4.2
+  get-port-please: ^3.2.0
   istanbul-lib-coverage: ^3.2.2
   istanbul-lib-report: ^3.0.1
   istanbul-lib-source-maps: ^5.0.6
diff --git a/test/coverage-test/fixtures/src/start-fork-and-thread.ts b/test/coverage-test/fixtures/src/start-fork-and-thread.ts
@@ -0,0 +1,29 @@
+import { fork } from 'node:child_process';
+import { resolve } from 'node:path';
+import { Worker } from 'node:worker_threads';
+
+const filename = resolve(import.meta.dirname, 'worker-or-process.ts');
+
+export async function runFork() {
+  const child = fork(filename);
+  const onExit = new Promise((resolve) => child.on('exit', resolve));
+
+  const onResponse = new Promise<{ result: number }>((resolve) => child.on('message', resolve));
+  const response = await onResponse;
+
+  await onExit;
+
+  return response.result;
+}
+
+export async function runThread() {
+  const worker = new Worker(filename);
+  const onExit = new Promise((resolve) => worker.on('exit', resolve));
+
+  const onResponse = new Promise<{ result: number }>((resolve) => worker.on('message', resolve));
+  const response = await onResponse;
+
+  await onExit;
+
+  return response.result;
+}
diff --git a/test/coverage-test/fixtures/src/worker-or-process.ts b/test/coverage-test/fixtures/src/worker-or-process.ts
@@ -0,0 +1,27 @@
+import { isMainThread, parentPort } from "node:worker_threads";
+import { subtract } from "./math.ts";
+
+interface Options {
+  left: number;
+  right: number;
+}
+
+/**
+ * Comment that adds padding
+ */
+function execute(options: Options) {
+  return subtract(options.left, options.right);
+}
+
+const result = execute({ left: 10, right: 5 });
+
+// v8 ignore else -- testing coverage hints too
+if (isMainThread && process.send) {
+  process.send({ result });
+}
+else if (parentPort) {
+  parentPort.postMessage({ result });
+}
+else {
+  throw new Error("Where is this running?")
+}
diff --git a/test/coverage-test/fixtures/test/child-process.test.ts b/test/coverage-test/fixtures/test/child-process.test.ts
@@ -0,0 +1,7 @@
+import { test , expect } from "vitest"
+import { runFork } from "../src/start-fork-and-thread";
+
+test("child process", async () => {
+  const result = await runFork();
+  expect(result).toBe(5);
+})
diff --git a/test/coverage-test/fixtures/test/worker-thread.test.ts b/test/coverage-test/fixtures/test/worker-thread.test.ts
@@ -0,0 +1,7 @@
+import { test , expect } from "vitest"
+import { runThread } from "../src/start-fork-and-thread";
+
+test("worker thread", async () => {
+  const result = await runThread();
+  expect(result).toBe(5);
+})
diff --git a/test/coverage-test/test/extended-run-context.v8.test.ts b/test/coverage-test/test/extended-run-context.v8.test.ts
@@ -0,0 +1,28 @@
+import { expect } from 'vitest'
+import { readCoverageMap, runVitest, test } from '../utils'
+
+test('{ trackProcessAndWorker: true } includes files from child process', async () => {
+  await runVitest({
+    include: ['fixtures/test/child-process.test.ts'],
+    coverage: {
+      trackProcessAndWorker: true,
+      reporter: ['json', 'html'],
+    },
+  })
+  const coverageMap = await readCoverageMap()
+  const files = coverageMap.files()
+
+  expect(files).toMatchInlineSnapshot(`
+    [
+      "<process-cwd>/fixtures/src/math.ts",
+      "<process-cwd>/fixtures/src/start-fork-and-thread.ts",
+      "<process-cwd>/fixtures/src/worker-or-process.ts",
+    ]
+  `)
+})
+
+test.todo('{ trackProcessAndWorker: true } includes files from worker thread')
+test.todo('{ trackProcessAndWorker: false } does not include files from child process or worker thread')
+
+test.todo('{ trackProcessAndWorker: true } includes files from process inside process')
+test.todo('{ trackProcessAndWorker: true } includes files from worker inside worker')

Original file line number	Diff line number	Diff line change
`@@ -53,6 +53,7 @@ export const coverageConfigDefaults: Required<Pick<CoverageOptions, FieldsWithDe`
`53`	`53`	`branches: [50, 80],`
`54`	`54`	`lines: [50, 80],`
`55`	`55`	`},`
	`56`	`+ trackProcessAndWorker: false,`
`56`	`57`	`}`
`57`	`58`
`58`	`59`	`export const fakeTimersDefaults: NonNullable<UserConfig['fakeTimers']> = {`
Original file line number	Diff line number	Diff line change
`@@ -58,6 +58,7 @@ export function serializeConfig(project: TestProject): SerializedConfig {`
`58`	`58`	`? coverage.customProviderModule`
`59`	`59`	`: undefined,`
`60`	`60`	`htmlDir: coverage.htmlDir,`
	`61`	`+ trackProcessAndWorker: coverage.trackProcessAndWorker ?? false,`
`61`	`62`	`}`
`62`	`63`	`})(config.coverage),`
`63`	`64`	`fakeTimers: config.fakeTimers,`
Original file line number	Diff line number	Diff line change
`@@ -155,6 +155,7 @@ export interface SerializedCoverageConfig {`
`155`	`155`	`htmlDir: string \| undefined`
`156`	`156`	`enabled: boolean`
`157`	`157`	`customProviderModule: string \| undefined`
	`158`	`+ trackProcessAndWorker: boolean`
`158`	`159`	`}`
`159`	`160`
`160`	`161`	`export type RuntimeConfig = Pick<`