feat: support check coverage thresholds (#560)

Author: 9aoy

e2e/scripts/index.ts

@@ -110,10 +110,15 @@ export async function runRstestCli({
   };
 
   const expectLog = (
-    msg: string,
+    msg: string | RegExp,
     logs: string[] = cli.stdout.split('\n').filter(Boolean),
   ) => {
-    const matchedLog = logs.find((log) => log.includes(msg));
+    const matchedLog = logs.find((log) => {
+      if (typeof msg === 'string') {
+        return log.includes(msg);
+      }
+      return log.match(msg);
+    });
 
     if (!matchedLog) {
       throw new Error(`Can't find log(${msg}) in:\n${logs.join('\n')}`);

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

@@ -0,0 +1,13 @@
+import { defineConfig } from '@rstest/core';
+
+export default defineConfig({
+  coverage: {
+    enabled: true,
+    provider: 'istanbul',
+    reporters: [],
+    thresholds: {
+      statements: 100,
+    },
+  },
+  setupFiles: ['./rstest.setup.ts'],
+});

e2e/test-coverage/index.test.ts

@@ -124,4 +124,28 @@ describe('test coverage-istanbul', () => {
       fs.existsSync(join(__dirname, 'fixtures/test-temp-coverage/index.html')),
     ).toBeTruthy();
   });
+
+  it('coverage-istanbul with thresholds check', async () => {
+    const { expectLog, cli } = await runRstestCli({
+      command: 'rstest',
+      args: ['run', '-c', 'rstest.thresholds.config.ts'],
+      options: {
+        nodeOptions: {
+          cwd: join(__dirname, 'fixtures'),
+        },
+      },
+    });
+
+    await cli.exec;
+    const exitCode = cli.exec.process?.exitCode;
+
+    expect(exitCode).toBe(1);
+
+    const logs = cli.stdout.split('\n').filter(Boolean);
+
+    expectLog(
+      /Coverage for statements .* does not meet global threshold/,
+      logs,
+    );
+  });
 });

packages/core/src/core/runTests.ts

@@ -286,6 +286,21 @@ export async function runTests(context: Rstest): Promise<void> {
           context.normalizedConfig.coverage,
         );
 
+        if (context.normalizedConfig.coverage.thresholds) {
+          const { checkThresholds } = await import(
+            '../coverage/checkThresholds'
+          );
+          const thresholdResult = checkThresholds(
+            finalCoverageMap,
+            context.normalizedConfig.coverage.thresholds,
+          );
+          if (!thresholdResult.success) {
+            process.exitCode = 1;
+            logger.log('');
+            logger.log(thresholdResult.message);
+          }
+        }
+
         // Cleanup
         coverageProvider.cleanup();
       } catch (error) {

packages/core/src/coverage/checkThresholds.ts

@@ -0,0 +1,40 @@
+import type {
+  CoverageMap,
+  CoverageSummary,
+  CoverageThresholds,
+} from '../types/coverage';
+import { color } from '../utils';
+
+export function checkThresholds(
+  coverageMap: CoverageMap,
+  thresholds?: CoverageThresholds,
+): { success: boolean; message: string } {
+  if (!thresholds) {
+    return { success: true, message: '' };
+  }
+  const summary = coverageMap.getCoverageSummary();
+  const failedThresholds: string[] = [];
+
+  const check = (
+    name: keyof CoverageSummary,
+    type: string,
+    actual: number,
+    expected?: number,
+  ) => {
+    if (expected !== undefined && actual < expected) {
+      failedThresholds.push(
+        `Coverage for ${name} ${color.red(`${actual}%`)} does not meet ${type} threshold ${color.yellow(`${expected}%`)}`,
+      );
+    }
+  };
+  // Check global thresholds
+  check('statements', 'global', summary.statements.pct, thresholds.statements);
+  check('functions', 'global', summary.functions.pct, thresholds.functions);
+  check('branches', 'global', summary.branches.pct, thresholds.branches);
+  check('lines', 'global', summary.lines.pct, thresholds.lines);
+
+  return {
+    success: failedThresholds.length === 0,
+    message: failedThresholds.join('\n'),
+  };
+}

packages/core/src/types/coverage.ts

@@ -1,11 +1,26 @@
-import type { CoverageMap } from 'istanbul-lib-coverage';
+import type { CoverageMap, CoverageSummary } from 'istanbul-lib-coverage';
 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>];
 
+type Thresholds = {
+  /** Thresholds for statements */
+  statements?: number;
+  /** Thresholds for functions */
+  functions?: number;
+  /** Thresholds for branches */
+  branches?: number;
+  /** Thresholds for lines */
+  lines?: number;
+};
+
+export type { CoverageMap, CoverageSummary };
+
+export type CoverageThresholds = Thresholds;
+
 export type CoverageOptions = {
   /**
    * Enable coverage collection.
@@ -51,9 +66,20 @@ export type CoverageOptions = {
    * @default true
    */
   clean?: boolean;
+
+  /**
+   * Coverage thresholds
+   *
+   * @default undefined
+   */
+  thresholds?: CoverageThresholds;
 };
 
-export type NormalizedCoverageOptions = Required<CoverageOptions>;
+export type NormalizedCoverageOptions = Required<
+  Omit<CoverageOptions, 'thresholds'>
+> & {
+  thresholds?: CoverageThresholds;
+};
 
 export declare class CoverageProvider {
   constructor(options: CoverageOptions);