feat: --merge-reports to support coverage

Author: AriPerkkio

packages/coverage-istanbul/src/provider.ts

@@ -1,4 +1,5 @@
 import { existsSync, promises as fs, writeFileSync } from 'node:fs'
+import { basename, dirname } from 'node:path'
 import { resolve } from 'pathe'
 import type { AfterSuiteRunMeta, CoverageIstanbulOptions, CoverageProvider, ReportContext, ResolvedCoverageOptions, Vitest } from 'vitest'
 import { coverageConfigDefaults, defaultExclude, defaultInclude } from 'vitest/config'
@@ -202,6 +203,18 @@ export class IstanbulCoverageProvider extends BaseCoverageProvider implements Co
       coverageMap.merge(await transformCoverage(uncoveredCoverage))
     }
 
+    await this.generateReports(coverageMap, allTestsRun)
+
+    // In watch mode we need to preserve the previous results if cleanOnRerun is disabled
+    const keepResults = !this.options.cleanOnRerun && this.ctx.config.watch
+
+    if (!keepResults) {
+      this.coverageFiles = new Map()
+      await fs.rm(this.coverageFilesDirectory, { recursive: true })
+    }
+  }
+
+  async generateReports(coverageMap: CoverageMap, allTestsRun: boolean | undefined) {
     const context = libReport.createContext({
       dir: this.options.reportsDirectory,
       coverageMap,
@@ -248,17 +261,40 @@ export class IstanbulCoverageProvider extends BaseCoverageProvider implements Co
         })
       }
     }
+  }
 
-    // In watch mode we need to preserve the previous results if cleanOnRerun is disabled
-    const keepResults = !this.options.cleanOnRerun && this.ctx.config.watch
+  async mergeReports(path: string) {
+    const directory = resolve(path, 'coverage')
+    const files = await fs.readdir(directory)
+    const coverageMap = libCoverage.createCoverageMap({})
 
-    if (!keepResults) {
-      this.coverageFiles = new Map()
-      await fs.rm(this.coverageFilesDirectory, { recursive: true })
+    for (const file of files) {
+      const report = await fs.readFile(resolve(directory, file), 'utf8')
+      coverageMap.merge(JSON.parse(report))
+    }
+
+    await this.generateReports(coverageMap, true)
+  }
+
+  async createBlobReport(coverageMap: CoverageMap, options: Options['reporter'][number][1]) {
+    const outputFile = 'outputFile' in options && options.outputFile as string
+    const dir = outputFile ? dirname(outputFile) : '.vitest-reports/coverage'
+    let file = outputFile && basename(outputFile)
+
+    if (!file) {
+      const shard = this.ctx.config.shard
+      file = shard
+        ? `.coverage-blob-${shard.index}-${shard.count}.json`
+        : '.coverage-blob.json'
     }
+
+    const context = libReport.createContext({ dir, coverageMap })
+    reports.create('json', { file }).execute(context)
+
+    this.ctx.logger.log(`coverage blob report written to ${resolve(dir, file)}`)
   }
 
-  async getCoverageMapForUncoveredFiles(coveredFiles: string[]) {
+  private async getCoverageMapForUncoveredFiles(coveredFiles: string[]) {
     const allFiles = await this.testExclude.glob(this.ctx.config.root)
     let includedFiles = allFiles.map(file => resolve(this.ctx.config.root, file))
 

packages/coverage-v8/src/provider.ts

@@ -1,6 +1,7 @@
 import { existsSync, promises as fs, writeFileSync } from 'node:fs'
 import type { Profiler } from 'node:inspector'
 import { fileURLToPath, pathToFileURL } from 'node:url'
+import { basename, dirname } from 'node:path'
 import v8ToIstanbul from 'v8-to-istanbul'
 import { mergeProcessCovs } from '@bcoe/v8-coverage'
 import libReport from 'istanbul-lib-report'
@@ -193,6 +194,18 @@ export class V8CoverageProvider extends BaseCoverageProvider implements Coverage
       coverageMap.merge(await transformCoverage(converted))
     }
 
+    await this.generateReports(coverageMap, allTestsRun)
+
+    // In watch mode we need to preserve the previous results if cleanOnRerun is disabled
+    const keepResults = !this.options.cleanOnRerun && this.ctx.config.watch
+
+    if (!keepResults) {
+      this.coverageFiles = new Map()
+      await fs.rm(this.coverageFilesDirectory, { recursive: true })
+    }
+  }
+
+  async generateReports(coverageMap: CoverageMap, allTestsRun: boolean | undefined) {
     const context = libReport.createContext({
       dir: this.options.reportsDirectory,
       coverageMap,
@@ -203,6 +216,11 @@ export class V8CoverageProvider extends BaseCoverageProvider implements Coverage
       this.ctx.logger.log(c.blue(' % ') + c.dim('Coverage report from ') + c.yellow(this.name))
 
     for (const reporter of this.options.reporter) {
+      if (reporter[0] === 'blob') {
+        await this.createBlobReport(coverageMap, reporter[1])
+        continue
+      }
+
       // Type assertion required for custom reporters
       reports.create(reporter[0] as Parameters<typeof reports.create>[0], {
         skipFull: this.options.skipFull,
@@ -239,14 +257,37 @@ export class V8CoverageProvider extends BaseCoverageProvider implements Coverage
         })
       }
     }
+  }
+
+  async mergeReports(path: string) {
+    const directory = resolve(path, 'coverage')
+    const files = await fs.readdir(directory)
+    const coverageMap = libCoverage.createCoverageMap({})
+
+    for (const file of files) {
+      const report = await fs.readFile(resolve(directory, file), 'utf8')
+      coverageMap.merge(JSON.parse(report))
+    }
 
-    // In watch mode we need to preserve the previous results if cleanOnRerun is disabled
-    const keepResults = !this.options.cleanOnRerun && this.ctx.config.watch
+    await this.generateReports(coverageMap, true)
+  }
 
-    if (!keepResults) {
-      this.coverageFiles = new Map()
-      await fs.rm(this.coverageFilesDirectory, { recursive: true })
+  async createBlobReport(coverageMap: CoverageMap, options: Options['reporter'][number][1]) {
+    const outputFile = 'outputFile' in options && options.outputFile as string
+    const dir = outputFile ? dirname(outputFile) : '.vitest-reports/coverage'
+    let file = outputFile && basename(outputFile)
+
+    if (!file) {
+      const shard = this.ctx.config.shard
+      file = shard
+        ? `.coverage-blob-${shard.index}-${shard.count}.json`
+        : '.coverage-blob.json'
     }
+
+    const context = libReport.createContext({ dir, coverageMap })
+    reports.create('json', { file }).execute(context)
+
+    this.ctx.logger.log(`coverage blob report written to ${resolve(dir, file)}`)
   }
 
   private async getUntestedFiles(testedFiles: string[]): Promise<RawCoverage> {

packages/vitest/src/node/core.ts

@@ -439,6 +439,8 @@ export class Vitest {
       process.exitCode = 1
 
     await this.report('onFinished', files, errors)
+    await this.initCoverageProvider()
+    await this.coverageProvider?.mergeReports?.(this.config.mergeReports)
   }
 
   async start(filters?: string[]) {

packages/vitest/src/node/reporters/blob.ts

@@ -1,4 +1,4 @@
-import { mkdir, readFile, readdir, writeFile } from 'node:fs/promises'
+import { mkdir, readFile, readdir, stat, writeFile } from 'node:fs/promises'
 import { existsSync } from 'node:fs'
 import { parse, stringify } from 'flatted'
 import { dirname, resolve } from 'pathe'
@@ -61,14 +61,17 @@ export async function readBlobs(blobsDirectory: string, projectsArray: Workspace
   const resolvedDir = resolve(process.cwd(), blobsDirectory)
   const blobsFiles = await readdir(resolvedDir)
   const promises = blobsFiles.map(async (file) => {
-    const content = await readFile(resolve(resolvedDir, file), 'utf-8')
+    const filename = resolve(resolvedDir, file)
+    const stats = await stat(filename)
+    if (!stats.isFile())
+      return null
+
+    const content = await readFile(filename, 'utf-8')
     const [version, files, errors, moduleKeys] = parse(content) as MergeReport
     return { version, files, errors, moduleKeys }
   })
-  const blobs = await Promise.all(promises)
-
-  if (!blobs.length)
-    throw new Error(`vitest.mergeReports() requires at least one blob file paths in the config`)
+  const results = await Promise.all(promises)
+  const blobs = results.filter((result): result is NonNullable<typeof result> => result != null)
 
   // fake module graph - it is used to check if module is imported, but we don't use values inside
   const projects = Object.fromEntries(projectsArray.map(p => [p.getName(), p]))

packages/vitest/src/types/coverage.ts

@@ -1,5 +1,5 @@
 import type { TransformResult as ViteTransformResult } from 'vite'
-import type { ReportOptions } from 'istanbul-reports'
+import type { ReportOptions as IstanbulReportOptions } from 'istanbul-reports'
 import type { Vitest } from '../node'
 import type { Arrayable } from './general'
 import type { AfterSuiteRunMeta } from './worker'
@@ -17,6 +17,8 @@ export interface CoverageProvider {
 
   reportCoverage: (reportContext?: ReportContext) => void | Promise<void>
 
+  mergeReports?: (path: string) => void | Promise<void>
+
   onFileTransform?: (
     sourceCode: string,
     id: string,
@@ -52,6 +54,10 @@ export interface CoverageProviderModule {
   stopCoverage?: () => unknown | Promise<unknown>
 }
 
+interface ReportOptions extends IstanbulReportOptions {
+  blob: { outputFile?: string }
+}
+
 export type CoverageReporter = keyof ReportOptions | (string & {})
 
 type CoverageReporterWithOptions<ReporterName extends CoverageReporter = CoverageReporter> =