feat: support coverage.reporters option

e2e/test-coverage/fixtures/rstest.skipFull.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from '@rstest/core';
+
+export default defineConfig({
+  coverage: {
+    enabled: true,
+    provider: 'istanbul',
+    reporters: [['text', { skipFull: true }]],
+  },
+});

e2e/test-coverage/fixtures/test/string.test.ts

@@ -1,11 +1,5 @@
 import { describe, expect, it } from '@rstest/core';
-import {
-  capitalize,
-  countWords,
-  isPalindrome,
-  reverseString,
-  truncate,
-} from '../src/string';
+import { capitalize, countWords, isPalindrome, truncate } from '../src/string';
 
 describe('String Utils', () => {
   describe('capitalize', () => {
@@ -22,20 +16,6 @@ describe('String Utils', () => {
     });
   });
 
-  describe('reverseString', () => {
-    it('should reverse string', () => {
-      expect(reverseString('hello')).toBe('olleh');
-    });
-
-    it('should handle empty string', () => {
-      expect(reverseString('')).toBe('');
-    });
-
-    it('should handle palindrome', () => {
-      expect(reverseString('racecar')).toBe('racecar');
-    });
-  });
-
   describe('isPalindrome', () => {
     it('should return true for palindrome', () => {
       expect(isPalindrome('racecar')).toBe(true);

e2e/test-coverage/index.test.ts

@@ -4,7 +4,7 @@ import fs from 'fs-extra';
 import { runRstestCli } from '../scripts';
 
 it('coverage-istanbul', async () => {
-  const { expectExecSuccess } = await runRstestCli({
+  const { expectExecSuccess, expectLog, cli } = await runRstestCli({
     command: 'rstest',
     args: ['run'],
     options: {
@@ -16,7 +16,91 @@ it('coverage-istanbul', async () => {
 
   await expectExecSuccess();
 
+  const logs = cli.stdout.split('\n').filter(Boolean);
+
+  expectLog('Coverage enabled with istanbul', logs);
+
+  // test coverage
+  expect(
+    logs.find(
+      (log) =>
+        log.includes('index.ts') &&
+        log.replaceAll(' ', '').includes('100|100|100|100'),
+    ),
+  ).toBeTruthy();
+  expect(
+    logs.find(
+      (log) =>
+        log.includes('string.ts') &&
+        log.replaceAll(' ', '').includes('93.75|100|83.33|92.85|7'),
+    ),
+  ).toBeTruthy();
+  // TODO: should not include test files
+  expect(
+    logs.find(
+      (log) =>
+        log.includes('All files') &&
+        log.replaceAll(' ', '').includes('99.43|100|98.68|99.41'),
+    ),
+  ).toBeTruthy();
+
+  // text reporter
+  expectLog('% Stmts', logs);
+
+  // html reporter
+  expect(
+    fs.existsSync(join(__dirname, 'fixtures/coverage/index.html')),
+  ).toBeTruthy();
+
+  // clover reporter
+  expect(
+    fs.existsSync(join(__dirname, 'fixtures/coverage/clover.xml')),
+  ).toBeTruthy();
+
+  // json reporter
   expect(
     fs.existsSync(join(__dirname, 'fixtures/coverage/coverage-final.json')),
   ).toBeTruthy();
 });
+
+it('coverage-istanbul with custom options', async () => {
+  const { expectExecSuccess, expectLog, cli } = await runRstestCli({
+    command: 'rstest',
+    args: ['run', '-c', 'rstest.skipFull.config.ts'],
+    options: {
+      nodeOptions: {
+        cwd: join(__dirname, 'fixtures'),
+      },
+    },
+  });
+
+  await expectExecSuccess();
+
+  const logs = cli.stdout.split('\n').filter(Boolean);
+
+  expectLog('Coverage enabled with istanbul', logs);
+
+  // test coverage
+  expect(
+    logs.find(
+      (log) =>
+        log.includes('index.ts') &&
+        log.replaceAll(' ', '').includes('100|100|100|100'),
+    ),
+  ).toBeFalsy();
+  expect(
+    logs.find(
+      (log) =>
+        log.includes('string.ts') &&
+        log.replaceAll(' ', '').includes('93.75|100|83.33|92.85|7'),
+    ),
+  ).toBeTruthy();
+
+  // text reporter
+  expectLog('% Stmts', logs);
+
+  // TODO: should clean and not generate html reporter
+  expect(
+    fs.existsSync(join(__dirname, 'fixtures/coverage/index.html')),
+  ).toBeTruthy();
+});

packages/core/package.json

@@ -68,6 +68,7 @@
     "@rstest/tsconfig": "workspace:*",
     "@sinonjs/fake-timers": "^14.0.0",
     "@types/babel__code-frame": "^7.0.6",
+    "@types/istanbul-reports": "^3.0.4",
     "@types/jsdom": "^21.1.7",
     "@types/sinonjs__fake-timers": "^8.1.5",
     "@types/source-map-support": "^0.5.10",

packages/core/src/config.ts

@@ -113,6 +113,8 @@ const createDefaultConfig = (): NormalizedConfig => ({
   disableConsoleIntercept: false,
   coverage: {
     enabled: false,
+    provider: 'istanbul',
+    reporters: ['text', 'html', 'clover', 'json'],
   },
 });
 
@@ -125,6 +127,10 @@ export const withDefaultConfig = (config: RstestConfig): NormalizedConfig => {
     TEMP_RSTEST_OUTPUT_DIR_GLOB,
   ]);
   merged.reporters = config.reporters ?? merged.reporters;
+
+  merged.coverage ??= {};
+  merged.coverage.reporters =
+    config.coverage?.reporters ?? merged.coverage?.reporters;
   merged.pool =
     typeof config.pool === 'string'
       ? {

packages/core/src/core/runTests.ts

@@ -104,6 +104,13 @@ export async function runTests(context: Rstest): Promise<void> {
       )
     : null;
 
+  if (coverageProvider) {
+    logger.log(
+      ` ${color.gray('Coverage enabled with')} %s\n`,
+      color.yellow(context.normalizedConfig.coverage.provider),
+    );
+  }
+
   type Mode = 'all' | 'on-demand';
 
   const run = async ({

packages/core/src/index.ts

@@ -1,12 +1,22 @@
-import type { CoverageOptions, CoverageProvider, RstestConfig } from './types';
+import type {
+  CoverageOptions,
+  CoverageProvider,
+  NormalizedCoverageOptions,
+  RstestConfig,
+} from './types';
 
 export type { RsbuildPlugin } from '@rsbuild/core';
 
 export { runCLI } from './cli';
 export { mergeRstestConfig } from './config';
 export * from './runtime/api/public';
 
-export type { CoverageOptions, CoverageProvider, RstestConfig };
+export type {
+  NormalizedCoverageOptions,
+  CoverageOptions,
+  CoverageProvider,
+  RstestConfig,
+};
 
 export type RstestConfigAsyncFn = () => Promise<RstestConfig>;
 

packages/core/src/types/coverage.ts

@@ -1,3 +1,10 @@
+import type { ReportOptions } from 'istanbul-reports';
+
+type ReportWithOptions<Name extends keyof ReportOptions = keyof ReportOptions> =
+  Name extends keyof ReportOptions
+    ? [Name, Partial<ReportOptions[Name]>]
+    : [Name, Record<string, unknown>];
+
 export type CoverageOptions = {
   /**
    * Enable coverage collection.
@@ -10,9 +17,18 @@ export type CoverageOptions = {
    * @default 'istanbul'
    */
   provider?: 'istanbul';
+
+  /**
+   * The reporters to use for coverage collection.
+   * @default ['text', 'html', 'clover', 'json']
+   */
+  reporters?: (keyof ReportOptions | ReportWithOptions)[];
+
   // TODO: support clean
 };
 
+export type NormalizedCoverageOptions = Required<CoverageOptions>;
+
 interface CoverageMap {
   files(): string[];
   merge(other: any): void;

packages/coverage-istanbul/src/provider.ts

@@ -1,4 +1,7 @@
-import type { CoverageProvider as RstestCoverageProvider } from '@rstest/core';
+import type {
+  NormalizedCoverageOptions,
+  CoverageProvider as RstestCoverageProvider,
+} from '@rstest/core';
 import istanbulLibCoverage from 'istanbul-lib-coverage';
 import { createContext } from 'istanbul-lib-report';
 import reports from 'istanbul-reports';
@@ -19,6 +22,8 @@ declare global {
 export class CoverageProvider implements RstestCoverageProvider {
   private coverageMap: ReturnType<typeof createCoverageMap> | null = null;
 
+  constructor(private options: NormalizedCoverageOptions) {}
+
   init(): void {
     // Initialize global coverage object
     if (typeof globalThis !== 'undefined') {
@@ -62,15 +67,14 @@ export class CoverageProvider implements RstestCoverageProvider {
         defaultSummarizer: 'nested',
         coverageMap: createCoverageMap(coverageMap.toJSON()),
       });
-      const reportersList = ['html', 'json'] as const;
+      const reportersList = this.options.reporters;
       for (const reporter of reportersList) {
-        const report = reports.create(reporter, {
-          // Add any specific options for the reporter here
-        });
+        const [reporterName, reporterOptions] = Array.isArray(reporter)
+          ? reporter
+          : [reporter, {}];
+        const report = reports.create(reporterName, reporterOptions);
         report.execute(context);
       }
-
-      console.log('Coverage reports generated in ./coverage directory');
     } catch (error) {
       console.error('Failed to generate coverage reports:', error);
     }