feat: coverage.includes works in projects (#593)

Co-authored-by: Copilot <[email protected]>

Author: 9aoy

e2e/projects/coverage.test.ts

@@ -38,8 +38,31 @@ describe('test projects coverage', () => {
       ),
     ).toBeTruthy();
 
+    expect(
+      logs.find((log) => log.includes('App1.ts') && log.includes('|')),
+    ).toBeFalsy();
+
     expect(
       fs.existsSync(join(__dirname, 'fixtures/coverage/index.html')),
     ).toBeTruthy();
   }, 15000);
+
+  it('should run projects correctly with coverage.include', async () => {
+    const { cli, expectExecSuccess } = await runRstestCli({
+      command: 'rstest',
+      args: ['run', '--globals', '-c', 'rstest.coverage.include.config.ts'],
+      options: {
+        nodeOptions: {
+          cwd: join(__dirname, 'fixtures'),
+        },
+      },
+    });
+
+    await expectExecSuccess();
+    const logs = cli.stdout.split('\n').filter(Boolean);
+
+    expect(
+      logs.find((log) => log.includes('App1.ts') && log.includes('|')),
+    ).toBeTruthy();
+  }, 15000);
 });

e2e/projects/fixtures/packages/client/src/App1.tsx

@@ -0,0 +1,10 @@
+const App = () => {
+  return (
+    <div className="content">
+      <h1>Rsbuild with React</h1>
+      <p>Start building amazing things with Rsbuild.</p>
+    </div>
+  );
+};
+
+export default App;

e2e/projects/fixtures/rstest.coverage.config.ts

@@ -2,9 +2,8 @@ import { defineConfig } from '@rstest/core';
 
 export default defineConfig({
   projects: ['packages/*'],
-  globals: true,
   coverage: {
     enabled: true,
+    reporters: ['text', 'html'],
   },
-  setupFiles: ['./setup.ts'],
 });

e2e/projects/fixtures/rstest.coverage.include.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from '@rstest/core';
+
+export default defineConfig({
+  projects: ['packages/*'],
+  coverage: {
+    enabled: true,
+    reporters: ['text'],
+    include: ['src/**/*'],
+  },
+});

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

@@ -2,4 +2,7 @@ import { defineConfig } from '@rstest/core';
 
 export default defineConfig({
   setupFiles: ['./rstest.setup.ts'],
+  coverage: {
+    reporters: ['text'],
+  },
 });

packages/core/src/core/runTests.ts

@@ -271,12 +271,7 @@ export async function runTests(context: Rstest): Promise<void> {
     if (coverageProvider) {
       const { generateCoverage } = await import('../coverage/generate');
 
-      await generateCoverage(
-        context.normalizedConfig.coverage,
-        context.rootPath,
-        results,
-        coverageProvider,
-      );
+      await generateCoverage(context, results, coverageProvider);
     }
   };
 

packages/core/src/coverage/generate.ts

@@ -1,6 +1,6 @@
 import { normalize } from 'pathe';
 import { glob, isDynamicPattern } from 'tinyglobby';
-import type { TestFileResult } from '../types';
+import type { RstestContext, TestFileResult } from '../types';
 import type {
   CoverageMap,
   CoverageOptions,
@@ -45,11 +45,15 @@ const getIncludedFiles = async (
 };
 
 export async function generateCoverage(
-  coverage: CoverageOptions,
-  rootPath: string,
+  context: RstestContext,
   results: TestFileResult[],
   coverageProvider: CoverageProvider,
 ): Promise<void> {
+  const {
+    rootPath,
+    normalizedConfig: { coverage },
+    projects,
+  } = context;
   try {
     const finalCoverageMap = coverageProvider.createCoverageMap();
 
@@ -61,24 +65,46 @@ export async function generateCoverage(
     }
 
     if (coverage.include?.length) {
-      const allFiles = await getIncludedFiles(coverage, rootPath);
+      const coveredFiles = finalCoverageMap.files();
 
-      // should be better to filter files before swc coverage is processed
-      finalCoverageMap.filter((file) => allFiles.includes(normalize(file)));
+      let isTimeout = false;
 
-      const coveredFiles = finalCoverageMap.files();
+      const timeoutId = setTimeout(() => {
+        isTimeout = true;
+        logger.info('Generating coverage for untested files...');
+      }, 1000);
+
+      const allFiles = (
+        await Promise.all(
+          projects.map(async (p) => {
+            const includedFiles = await getIncludedFiles(coverage, p.rootPath);
+
+            const uncoveredFiles = includedFiles.filter(
+              (file) => !coveredFiles.includes(normalize(file)),
+            );
 
-      const uncoveredFiles = allFiles.filter(
-        (file) => !coveredFiles.includes(normalize(file)),
-      );
+            if (uncoveredFiles.length) {
+              await generateCoverageForUntestedFiles(
+                p.environmentName,
+                uncoveredFiles,
+                finalCoverageMap,
+                coverageProvider,
+              );
+            }
 
-      if (uncoveredFiles.length) {
-        await generateCoverageForUntestedFiles(
-          uncoveredFiles,
-          finalCoverageMap,
-          coverageProvider,
-        );
+            return includedFiles;
+          }),
+        )
+      ).flat();
+
+      clearTimeout(timeoutId);
+
+      if (isTimeout) {
+        logger.info('Coverage for untested files generated.');
       }
+
+      // should be better to filter files before swc coverage is processed
+      finalCoverageMap.filter((file) => allFiles.includes(normalize(file)));
     }
 
     // Generate coverage reports
@@ -104,21 +130,22 @@ export async function generateCoverage(
 }
 
 async function generateCoverageForUntestedFiles(
+  environmentName: string,
   uncoveredFiles: string[],
   coverageMap: CoverageMap,
   coverageProvider: CoverageProvider,
 ): Promise<void> {
-  logger.debug('Generating coverage for untested files...');
-
   if (!coverageProvider.generateCoverageForUntestedFiles) {
     logger.warn(
       'Current coverage provider does not support generating coverage for untested files.',
     );
     return;
   }
 
-  const coverages =
-    await coverageProvider.generateCoverageForUntestedFiles(uncoveredFiles);
+  const coverages = await coverageProvider.generateCoverageForUntestedFiles({
+    environmentName,
+    files: uncoveredFiles,
+  });
 
   coverages.forEach((coverageData) => {
     coverageMap.addFileCoverage(coverageData);

packages/core/src/types/coverage.ts

@@ -129,9 +129,10 @@ export declare class CoverageProvider {
   /**
    * Generate coverage for untested files
    */
-  generateCoverageForUntestedFiles(
-    untestedFiles: string[],
-  ): Promise<FileCoverageData[]>;
+  generateCoverageForUntestedFiles(params: {
+    environmentName: string;
+    files: string[];
+  }): Promise<FileCoverageData[]>;
 
   /**
    * Generate coverage reports

packages/coverage-istanbul/src/plugin.ts

@@ -1,20 +1,24 @@
 import { createRequire } from 'node:module';
 import type { NormalizedCoverageOptions, RsbuildPlugin } from '@rstest/core';
 
-let transformCoverageFn:
-  | ((code: string, filename: string) => Promise<{ code: string; map?: any }>)
-  | undefined;
+type TransformCoverageFn = (
+  code: string,
+  filename: string,
+) => Promise<{ code: string; map?: any }>;
 
-const transformCoverage: NonNullable<typeof transformCoverageFn> = async (
-  code,
-  filename,
-) => {
-  if (!transformCoverageFn) {
+const transformCoverageFns: Record<string, TransformCoverageFn> = {};
+
+const transformCoverage = async (
+  environmentName: string,
+  code: string,
+  filename: string,
+): ReturnType<TransformCoverageFn> => {
+  if (!transformCoverageFns[environmentName]) {
     throw new Error(
-      'Can not transform coverage since swc transform function is not registered',
+      `Can not transform coverage since swc transform function for ${environmentName} is not registered`,
     );
   }
-  return transformCoverageFn(code, filename);
+  return transformCoverageFns[environmentName](code, filename);
 };
 
 export { transformCoverage };
@@ -50,14 +54,17 @@ export const pluginCoverage: (
     });
 
     api.modifyBundlerChain({
-      handler: (chain, { rspack, CHAIN_ID }) => {
+      handler: (chain, { rspack, CHAIN_ID, environment }) => {
         const { rspackExperiments: _rspackExperiments, ...swcOptions } =
           chain.module
             .rule(CHAIN_ID.RULE.JS)
             .use(CHAIN_ID.USE.SWC)
             .get('options') || {};
 
-        transformCoverageFn = async (code: string, filename: string) =>
+        transformCoverageFns[environment.name] = async (
+          code: string,
+          filename: string,
+        ) =>
           rspack.experiments.swc.transform(code, {
             ...swcOptions,
             filename,
@@ -67,7 +74,7 @@ export const pluginCoverage: (
     });
 
     api.onExit(() => {
-      transformCoverageFn = undefined;
+      Object.assign(transformCoverageFns, {});
     });
   },
 });

packages/coverage-istanbul/src/provider.ts

@@ -26,9 +26,13 @@ export class CoverageProvider implements RstestCoverageProvider {
     }
   }
 
-  async generateCoverageForUntestedFiles(
-    uncoveredFiles: string[],
-  ): Promise<FileCoverageData[]> {
+  async generateCoverageForUntestedFiles({
+    environmentName,
+    files,
+  }: {
+    environmentName: string;
+    files: string[];
+  }): Promise<FileCoverageData[]> {
     const { transformCoverage } = await import('./plugin');
 
     const { readInitialCoverage } = await import('istanbul-lib-instrument');
@@ -41,10 +45,14 @@ export class CoverageProvider implements RstestCoverageProvider {
     const { readFile } = await import('node:fs/promises');
 
     return await Promise.all(
-      uncoveredFiles.map(async (file) => {
+      files.map(async (file) => {
         try {
           const content = await readFile(file, 'utf-8');
-          const { code } = await transformCoverage(content, file);
+          const { code } = await transformCoverage(
+            environmentName,
+            content,
+            file,
+          );
           // replace _coverageSchema: "${swc_value}" to _coverageSchema: ${MAGIC_VALUE}
           const { coverageData } =
             readInitialCoverage(