test: run webpack multi compiler test cases with test tools (#11787)

Author: LingyuCoder

packages/rspack-test-tools/etc/test-tools.api.md

@@ -121,6 +121,9 @@ export function createHotNormalCase(name: string, src: string, dist: string): vo
 // @public (undocumented)
 export function createHotStepCase(name: string, src: string, dist: string, target: TCompilerOptions<ECompilerType.Rspack>["target"]): void;
 
+// @public (undocumented)
+export function createMultiCompilerCase(name: string, src: string, dist: string, testConfig: string): void;
+
 // @public (undocumented)
 export function createNativeWatcher(name: string, src: string, dist: string, temp: string): void;
 

packages/rspack-test-tools/src/case/index.ts

@@ -15,6 +15,7 @@ export {
 	createHotIncrementalCase,
 	createWatchIncrementalCase
 } from "./incremental";
+export { createMultiCompilerCase } from "./multi-compiler";
 export { createNativeWatcher } from "./native-watcher";
 export { createHotNormalCase, createNormalCase } from "./normal";
 export { createSerialCase } from "./serial";

packages/rspack-test-tools/src/case/multi-compiler.ts

@@ -0,0 +1,150 @@
+import path from "node:path";
+import type { OutputFileSystem, WatchFileSystem } from "@rspack/core";
+import { createFsFromVolume, Volume } from "memfs";
+import { BasicCaseCreator } from "../test/creator";
+import type {
+	ECompilerType,
+	ITestContext,
+	ITestEnv,
+	ITestProcessor,
+	TCompilation,
+	TCompiler,
+	TCompilerOptions,
+	TCompilerStats,
+	TCompilerStatsCompilation
+} from "../type";
+import { getCompiler } from "./common";
+
+function createMultiCompilerProcessor(
+	name: string,
+	caseConfig: TMultiCompilerCaseConfig
+) {
+	return {
+		config: async (context: ITestContext) => {
+			const compiler = getCompiler(context, name);
+			const options = Object.assign(
+				[
+					{
+						name: "a",
+						context: path.join(__dirname, "fixtures"),
+						entry: "./a.js"
+					},
+					{
+						name: "b",
+						context: path.join(__dirname, "fixtures"),
+						entry: "./b.js"
+					}
+				],
+				caseConfig.options?.(context) || {}
+			);
+			compiler.setOptions(options);
+		},
+		compiler: async (context: ITestContext) => {
+			const compiler = getCompiler(context, name);
+			if (caseConfig.compilerCallback) {
+				compiler.createCompilerWithCallback(caseConfig.compilerCallback);
+			} else {
+				compiler.createCompiler();
+			}
+			const c = compiler.getCompiler()!;
+			c.outputFileSystem = createFsFromVolume(new Volume()) as OutputFileSystem;
+			c.watchFileSystem = {
+				watch() {
+					// watch should return a watcher instance
+					// watcher instance should have close, pause and getInfo methods
+					return {
+						close: () => {},
+						pause: () => {},
+						getInfo: () => {
+							return {
+								changes: new Set(),
+								removals: new Set(),
+								fileTimeInfoEntries: new Map(),
+								directoryTimeInfoEntries: new Map()
+							};
+						}
+					};
+				}
+			} as unknown as WatchFileSystem;
+			await caseConfig.compiler?.(context, c);
+		},
+		build: async (context: ITestContext) => {
+			const compiler = getCompiler(context, name);
+			if (typeof caseConfig.build === "function") {
+				await caseConfig.build?.(context, compiler.getCompiler()!);
+			} else {
+				await compiler.build();
+			}
+		},
+		run: async (env: ITestEnv, context: ITestContext) => {},
+		check: async (env: ITestEnv, context: ITestContext) => {}
+	} as ITestProcessor;
+}
+
+const creator = new BasicCaseCreator({
+	clean: true,
+	describe: false,
+	steps: ({ name, caseConfig }) => {
+		return [
+			createMultiCompilerProcessor(name, caseConfig as TMultiCompilerCaseConfig)
+		];
+	},
+	concurrent: false
+});
+
+export function createMultiCompilerCase(
+	name: string,
+	src: string,
+	dist: string,
+	testConfig: string
+) {
+	let caseConfigList:
+		| TMultiCompilerCaseConfig
+		| TMultiCompilerCaseConfig[] = require(testConfig);
+	if (!Array.isArray(caseConfigList)) {
+		caseConfigList = [caseConfigList];
+	}
+	for (let i = 0; i < caseConfigList.length; i++) {
+		const caseConfig = caseConfigList[i];
+		if (caseConfig.skip) {
+			it.skip(`${name}[${i}]`, () => {});
+			continue;
+		}
+		creator.create(`${name}[${i}]`, src, dist, undefined, {
+			caseConfig,
+			description: () => caseConfig.description
+		});
+	}
+}
+
+export type TMultiCompilerCaseConfig = {
+	description: string;
+	error?: boolean;
+	skip?: boolean;
+	options?: (context: ITestContext) => TCompilerOptions<ECompilerType.Rspack>;
+	compiler?: (
+		context: ITestContext,
+		compiler: TCompiler<ECompilerType.Rspack>
+	) => Promise<void>;
+	build?: (
+		context: ITestContext,
+		compiler: TCompiler<ECompilerType.Rspack>
+	) => Promise<void>;
+	check?: ({
+		context,
+		stats,
+		files,
+		compiler,
+		compilation
+	}: {
+		context: ITestContext;
+		stats?: TCompilerStatsCompilation<ECompilerType.Rspack>;
+		files?: Record<string, string>;
+		compiler: TCompiler<ECompilerType.Rspack>;
+		compilation?: TCompilation<ECompilerType.Rspack>;
+	}) => Promise<void>;
+	compilerCallback?: (
+		error: Error | null,
+		stats: TCompilerStats<ECompilerType.Rspack> | null
+	) => void;
+};

packages/rspack/etc/core.api.md

@@ -6345,6 +6345,7 @@ declare namespace rspackExports {
         LoaderOptionsPlugin,
         LoaderTargetPlugin,
         OutputFileSystem,
+        WatchFileSystem,
         web,
         node,
         electron,
@@ -9004,7 +9005,7 @@ type WatchFiles = {
 };
 
 // @public (undocumented)
-interface WatchFileSystem {
+export interface WatchFileSystem {
     // (undocumented)
     watch(files: Iterable<string> & {
         added?: Iterable<String>;

packages/rspack/src/exports.ts

@@ -130,7 +130,7 @@ export { default as EntryOptionPlugin } from "./lib/EntryOptionPlugin";
 export { EnvironmentPlugin } from "./lib/EnvironmentPlugin";
 export { LoaderOptionsPlugin } from "./lib/LoaderOptionsPlugin";
 export { LoaderTargetPlugin } from "./lib/LoaderTargetPlugin";
-export type { OutputFileSystem } from "./util/fs";
+export type { OutputFileSystem, WatchFileSystem } from "./util/fs";
 
 import {
 	EsmLibraryPlugin,

tests/rspack-test/MultiCompiler.test.js

@@ -0,0 +1,14 @@
+const path = require("path");
+const { createMultiCompilerCase, describeByWalk } = require("@rspack/test-tools");
+const srcDir = path.resolve(__dirname, "./fixtures");
+
+describeByWalk(
+	__filename,
+	(name, testConfig, dist) => {
+		createMultiCompilerCase(name, srcDir, dist, testConfig);
+	},
+	{
+		level: 1,
+		type: "file"
+	}
+);