@rspack/test-tools 0.6.3 → 0.6.4

package/dist/processor/error.js

@@ -0,0 +1,142 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorTaskProcessor = void 0;
+const simple_1 = require("./simple");
+const path_1 = __importDefault(require("path"));
+const pretty_format_1 = __importDefault(require("pretty-format"));
+const webpack_merge_1 = __importDefault(require("webpack-merge"));
+const CWD_PATTERN = new RegExp(path_1.default.join(process.cwd(), "../../").replace(/\\/g, "/"), "gm");
+const ERROR_STACK_PATTERN = /(?:\n\s+at\s.*)+/gm;
+function cleanError(err) {
+    const result = {};
+    for (const key of Object.getOwnPropertyNames(err)) {
+        result[key] = err[key];
+    }
+    if (result.message) {
+        result.message = err.message.replace(ERROR_STACK_PATTERN, "");
+    }
+    if (result.stack) {
+        result.stack = result.stack.replace(ERROR_STACK_PATTERN, "");
+    }
+    return result;
+}
+function serialize(received) {
+    return (0, pretty_format_1.default)(received, prettyFormatOptions)
+        .replace(CWD_PATTERN, "<cwd>")
+        .trim();
+}
+const prettyFormatOptions = {
+    escapeRegex: false,
+    printFunctionName: false,
+    plugins: [
+        {
+            test(val) {
+                return typeof val === "string";
+            },
+            print(val) {
+                return `"${val
+                    .replace(/\\/gm, "/")
+                    .replace(/"/gm, '\\"')
+                    .replace(/\r?\n/gm, "\\n")}"`;
+            }
+        }
+    ]
+};
+class ErrorTaskProcessor extends simple_1.SimpleTaskProcessor {
+    constructor(_errorOptions) {
+        super({
+            options: (context) => {
+                let options = {
+                    context: path_1.default.resolve(__dirname, "../../tests/fixtures/errors"),
+                    mode: "none",
+                    devtool: false,
+                    optimization: {
+                        minimize: false
+                    }
+                };
+                if (typeof _errorOptions.options === "function") {
+                    options = (0, webpack_merge_1.default)(options, _errorOptions.options(options, context));
+                }
+                if (options.mode === "production") {
+                    if (options.optimization)
+                        options.optimization.minimize = true;
+                    else
+                        options.optimization = { minimize: true };
+                }
+                return options;
+            },
+            build: _errorOptions.build,
+            compilerType: _errorOptions.compilerType,
+            name: _errorOptions.name
+        });
+        this._errorOptions = _errorOptions;
+    }
+    async compiler(context) {
+        await super.compiler(context);
+        const compiler = this.getCompiler(context).getCompiler();
+        if (compiler) {
+            compiler.outputFileSystem = {
+                // CHANGE: rspack outputFileSystem `mkdirp` uses option `{ recursive: true }`, webpack's second parameter is alway a callback
+                mkdir(dir, maybeOptionOrCallback, maybeCallback) {
+                    if (typeof maybeOptionOrCallback === "function") {
+                        maybeOptionOrCallback();
+                    }
+                    else if (typeof maybeCallback === "function") {
+                        maybeCallback();
+                    }
+                },
+                writeFile(file, content, callback) {
+                    callback();
+                },
+                stat(file, callback) {
+                    callback(new Error("ENOENT"));
+                },
+                mkdirSync() { },
+                writeFileSync() { }
+            };
+        }
+    }
+    async run(env, context) {
+        // do nothing
+    }
+    async check(env, context) {
+        var _a, _b;
+        const compiler = this.getCompiler(context);
+        const stats = compiler.getStats();
+        expect(typeof stats).toBe("object");
+        const statsResult = stats.toJson({ errorDetails: false });
+        expect(typeof statsResult).toBe("object");
+        const { errors, warnings } = statsResult;
+        expect(Array.isArray(errors)).toBe(true);
+        expect(Array.isArray(warnings)).toBe(true);
+        await ((_b = (_a = this._errorOptions).check) === null || _b === void 0 ? void 0 : _b.call(_a, {
+            errors: errors,
+            warnings: warnings
+        }));
+    }
+    static addSnapshotSerializer() {
+        expect.addSnapshotSerializer({
+            test(received) {
+                return received.errors || received.warnings;
+            },
+            print(received) {
+                return serialize({
+                    errors: received.errors.map(e => cleanError(e)),
+                    warnings: received.warnings.map(e => cleanError(e))
+                });
+            }
+        });
+        expect.addSnapshotSerializer({
+            test(received) {
+                return received.message;
+            },
+            print(received) {
+                return serialize(cleanError(received));
+            }
+        });
+    }
+}
+exports.ErrorTaskProcessor = ErrorTaskProcessor;

package/dist/processor/hook.d.ts

@@ -0,0 +1,41 @@
+/// <reference types="node" />
+import { ECompilerType, ITestContext, ITestEnv, TCompilerOptions } from "../type";
+import { TTestContextOptions, TestContext } from "../test/context";
+import { ISnapshotProcessorOptions, SnapshotProcessor } from "./snapshot";
+export declare class HookCasesContext extends TestContext {
+    protected src: string;
+    protected testName: string;
+    protected options: TTestContextOptions;
+    protected promises: Promise<void>[];
+    protected count: number;
+    protected snapshots: Record<string | number, Array<[string | Buffer, string]>>;
+    protected snapshotsList: Array<string | number>;
+    constructor(src: string, testName: string, options: TTestContextOptions);
+    /**
+     * Snapshot function arguments and return value.
+     * Generated snapshot is located in the same directory with the test source.
+     * @example
+     * compiler.hooks.compilation("name", context.snapped((...args) => { ... }))
+     */
+    snapped(cb: (...args: unknown[]) => Promise<unknown>, prefix?: string): (this: any, ...args: unknown[]) => Promise<unknown>;
+    /**
+     * @internal
+     */
+    _addSnapshot(content: unknown, name: string, group: string | number): void;
+    /**
+     * @internal
+     */
+    collectSnapshots(options?: {
+        diff: {};
+    }): Promise<void>;
+}
+interface IHookProcessorOptions<T extends ECompilerType> extends ISnapshotProcessorOptions<T> {
+    options?: (context: ITestContext) => TCompilerOptions<T>;
+}
+export declare class HookTaskProcessor extends SnapshotProcessor<ECompilerType.Rspack> {
+    protected hookOptions: IHookProcessorOptions<ECompilerType.Rspack>;
+    constructor(hookOptions: IHookProcessorOptions<ECompilerType.Rspack>);
+    config(context: ITestContext): Promise<void>;
+    check(env: ITestEnv, context: HookCasesContext): Promise<void>;
+}
+export {};

package/dist/processor/hook.js

@@ -0,0 +1,189 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HookTaskProcessor = exports.HookCasesContext = void 0;
+const path_1 = __importDefault(require("path"));
+const webpack_sources_1 = require("webpack-sources");
+const core_1 = require("@rspack/core");
+const pretty_format_1 = require("pretty-format");
+const jest_snapshot_1 = require("jest-snapshot");
+const context_1 = require("../test/context");
+const snapshot_1 = require("./snapshot");
+const pathSerializer = require("jest-serializer-path");
+const normalizePaths = pathSerializer.normalizePaths;
+const srcDir = path_1.default.resolve(__dirname, "../../tests/fixtures");
+const distDir = path_1.default.resolve(__dirname, "../../tests/js/hook");
+const sourceSerializer = {
+    test(val) {
+        return val instanceof webpack_sources_1.Source;
+    },
+    print(val) {
+        return val.source();
+    }
+};
+const internalSerializer = {
+    test(val) {
+        return val instanceof core_1.Compiler || val instanceof core_1.Compilation;
+    },
+    print(val) {
+        return JSON.stringify(`${val.constructor.name}(internal ignored)`);
+    }
+};
+const testPathSerializer = {
+    test(val) {
+        return typeof val === "string";
+    },
+    print(val) {
+        return JSON.stringify(normalizePaths(
+        // @ts-ignore
+        val
+            .split(srcDir)
+            .join("<HOOK_SRC_DIR>")
+            .split(distDir)
+            .join("<HOOK_DIST_DIR>")));
+    }
+};
+const escapeRegex = true;
+const printFunctionName = false;
+const normalizeNewlines = (str) => str.replace(/\r\n|\r/g, "\n");
+const serialize = (val, indent = 2, formatOverrides = {}) => normalizeNewlines((0, pretty_format_1.format)(val, {
+    escapeRegex,
+    indent,
+    plugins: [
+        ...(0, jest_snapshot_1.getSerializers)(),
+        sourceSerializer,
+        internalSerializer,
+        testPathSerializer
+    ],
+    printFunctionName,
+    ...formatOverrides
+}));
+class HookCasesContext extends context_1.TestContext {
+    constructor(src, testName, options) {
+        super(options);
+        this.src = src;
+        this.testName = testName;
+        this.options = options;
+        this.promises = [];
+        this.count = 0;
+        this.snapshots = {};
+        this.snapshotsList = [];
+        this.snapped = this.snapped.bind(this);
+    }
+    /**
+     * Snapshot function arguments and return value.
+     * Generated snapshot is located in the same directory with the test source.
+     * @example
+     * compiler.hooks.compilation("name", context.snapped((...args) => { ... }))
+     */
+    snapped(cb, prefix = "") {
+        // eslint-disable-next-line
+        let context = this;
+        return function SNAPPED_HOOK(...args) {
+            let group = prefix ? prefix : context.count++;
+            context._addSnapshot(args, "input", group);
+            let output = cb.apply(this, args);
+            if (output && typeof output.then === "function") {
+                let resolve;
+                context.promises.push(new Promise(r => (resolve = r)));
+                return output
+                    .then((o) => {
+                    context._addSnapshot(o, "output (Promise resolved)", group);
+                    return o;
+                })
+                    .catch((o) => {
+                    context._addSnapshot(o, "output (Promise rejected)", group);
+                    return o;
+                })
+                    .finally(resolve);
+            }
+            context._addSnapshot(output, "output", group);
+            return output;
+        };
+    }
+    /**
+     * @internal
+     */
+    _addSnapshot(content, name, group) {
+        content = Buffer.isBuffer(content)
+            ? content
+            : serialize(content, undefined, {
+                escapeString: true,
+                printBasicPrototype: true
+            }).replace(/\r\n/g, "\n");
+        (this.snapshots[group] = this.snapshots[group] || []).push([
+            content,
+            name
+        ]);
+        if (!this.snapshotsList.includes(group)) {
+            this.snapshotsList.push(group);
+        }
+    }
+    /**
+     * @internal
+     */
+    async collectSnapshots(options = {
+        diff: {}
+    }) {
+        await Promise.allSettled(this.promises);
+        if (!this.snapshotsList.length)
+            return;
+        let snapshots = this.snapshotsList.reduce((acc, group, index) => {
+            let block = this.snapshots[group || index].reduce((acc, [content, name]) => {
+                name = `## ${name || `test: ${index}`}\n\n`;
+                let block = "```javascript\n" + content + "\n```\n";
+                return (acc += name + block + "\n");
+            }, "");
+            group = Number.isInteger(group) ? `Group: ${index}` : group;
+            group = `# ${group}\n\n`;
+            return (acc += group + block);
+        }, "");
+        // @ts-ignore
+        expect(snapshots).toMatchFileSnapshot(path_1.default.join(this.src, "hooks.snap.txt"), options);
+    }
+}
+exports.HookCasesContext = HookCasesContext;
+class HookTaskProcessor extends snapshot_1.SnapshotProcessor {
+    constructor(hookOptions) {
+        super({
+            defaultOptions: context => {
+                return {
+                    context: context.getSource(),
+                    mode: "production",
+                    target: "async-node",
+                    devtool: false,
+                    cache: false,
+                    entry: "./hook",
+                    output: {
+                        path: context.getDist()
+                    },
+                    optimization: {
+                        minimize: false
+                    },
+                    experiments: {
+                        rspackFuture: {
+                            newTreeshaking: true
+                        }
+                    }
+                };
+            },
+            ...hookOptions,
+            runable: true
+        });
+        this.hookOptions = hookOptions;
+    }
+    async config(context) {
+        await super.config(context);
+        const compiler = this.getCompiler(context);
+        if (typeof this.hookOptions.options === "function") {
+            compiler.mergeOptions(this.hookOptions.options(context));
+        }
+    }
+    async check(env, context) {
+        await context.collectSnapshots();
+        await super.check(env, context);
+    }
+}
+exports.HookTaskProcessor = HookTaskProcessor;

package/dist/processor/hot-step.d.ts

@@ -1,6 +1,7 @@
 import { ITestContext, ITestEnv } from "../type";
 import { StatsCompilation } from "@rspack/core";
 import { IRspackHotProcessorOptions, RspackHotProcessor } from "./hot";
+import { THotStepRuntimeData } from "../runner";
 export interface IRspackHotStepProcessorOptions extends IRspackHotProcessorOptions {
 }
 export declare class RspackHotStepProcessor extends RspackHotProcessor {
@@ -10,5 +11,5 @@ export declare class RspackHotStepProcessor extends RspackHotProcessor {
     constructor(_hotOptions: IRspackHotProcessorOptions);
     run(env: ITestEnv, context: ITestContext): Promise<void>;
     check(env: ITestEnv, context: ITestContext): Promise<void>;
-    protected matchStepSnapshot(context: ITestContext, step: number, stats: StatsCompilation): void;
+    protected matchStepSnapshot(context: ITestContext, step: number, stats: StatsCompilation, runtime?: THotStepRuntimeData): void;
 }

package/dist/processor/hot-step.js

@@ -7,6 +7,7 @@ exports.RspackHotStepProcessor = void 0;
 const path_1 = __importDefault(require("path"));
 const hot_1 = require("./hot");
 const fs_extra_1 = __importDefault(require("fs-extra"));
+const helper_1 = require("../helper");
 const escapeLocalName = (str) => str.split(/[-<>:"/|?*.]/).join("_");
 const SELF_HANDLER = (file, options) => {
     var _a, _b, _c;
@@ -39,17 +40,17 @@ class RspackHotStepProcessor extends hot_1.RspackHotProcessor {
         this.entries = {};
     }
     async run(env, context) {
-        context.setValue(this._options.name, "hotUpdateStepChecker", (hotUpdateContext, stats) => {
+        context.setValue(this._options.name, "hotUpdateStepChecker", (hotUpdateContext, stats, runtime) => {
             const statsJson = stats.toJson({ assets: true, chunks: true });
             for (let entry of ((stats === null || stats === void 0 ? void 0 : stats.compilation.chunks) || []).filter(i => i.hasRuntime())) {
                 if (!this.entries[entry.id]) {
                     this.entries[entry.id] = entry.runtime;
                 }
             }
-            this.matchStepSnapshot(context, hotUpdateContext.updateIndex, statsJson);
+            this.matchStepSnapshot(context, hotUpdateContext.updateIndex, statsJson, runtime);
             this.hashes.push(stats.hash);
         });
-        context.setValue(this._options.name, "hotUpdateStepErrorChecker", (_, stats) => {
+        context.setValue(this._options.name, "hotUpdateStepErrorChecker", (_, stats, runtime) => {
             this.hashes.push(stats.hash);
         });
         await super.run(env, context);
@@ -76,11 +77,8 @@ class RspackHotStepProcessor extends hot_1.RspackHotProcessor {
         if (matchFailed) {
             throw matchFailed;
         }
-        else {
-            await super.check(env, context);
-        }
     }
-    matchStepSnapshot(context, step, stats) {
+    matchStepSnapshot(context, step, stats, runtime) {
         const compiler = this.getCompiler(context);
         const compilerOptions = compiler.getOptions();
         const getModuleHandler = GET_MODULE_HANDLER[compilerOptions.target];
@@ -90,7 +88,7 @@ class RspackHotStepProcessor extends hot_1.RspackHotProcessor {
         const title = `Case ${this._options.name}: Step ${step}`;
         const hotUpdateFile = [];
         const hotUpdateManifest = [];
-        const changedFiles = require(context.getSource("changed-file.js")).map((i) => path_1.default.relative(context.getSource(), i));
+        const changedFiles = require(context.getSource("changed-file.js")).map((i) => (0, helper_1.escapeSep)(path_1.default.relative(context.getSource(), i)));
         const hashes = {
             [lastHash || "LAST_HASH"]: "LAST_HASH",
             [stats.hash]: "CURRENT_HASH"
@@ -161,6 +159,16 @@ class RspackHotStepProcessor extends hot_1.RspackHotProcessor {
         fileList.sort();
         hotUpdateManifest.sort((a, b) => (a.name > b.name ? 1 : -1));
         hotUpdateFile.sort((a, b) => (a.name > b.name ? 1 : -1));
+        if (runtime === null || runtime === void 0 ? void 0 : runtime.javascript) {
+            runtime.javascript.outdatedModules.sort();
+            runtime.javascript.updatedModules.sort();
+            runtime.javascript.updatedRuntime.sort();
+            runtime.javascript.acceptedModules.sort();
+            runtime.javascript.disposedModules.sort();
+            for (let value of Object.values(runtime.javascript.outdatedDependencies)) {
+                value.sort();
+            }
+        }
         let content = `
 # ${title}
 
@@ -197,20 +205,64 @@ ${i.runtime.map(i => `- ${i}`).join("\n")}
 \`\`\`js
 ${i.content}
 \`\`\`
-
 `)
             .join("\n\n")}
 
-		`.trim();
+
+${runtime
+            ? `
+## Runtime
+### Status
+
+\`\`\`txt
+${runtime.statusPath.join(" => ")}
+\`\`\`
+
+${runtime.javascript
+                ? `
+
+### JavaScript
+
+#### Outdated
+
+Outdated Modules:
+${runtime.javascript.outdatedModules.map(i => `- ${i}`).join("\n")}
+
+
+Outdated Dependencies:
+\`\`\`json
+${JSON.stringify(runtime.javascript.outdatedDependencies || {}, null, 2)}
+\`\`\`
+
+#### Updated
+
+Updated Modules:
+${runtime.javascript.updatedModules.map(i => `- ${i}`).join("\n")}
+
+Updated Runtime:
+${runtime.javascript.updatedRuntime.map(i => `- \`${i}\``).join("\n")}
+
+
+#### Callback
+
+Accepted Callback:
+${runtime.javascript.acceptedModules.map(i => `- ${i}`).join("\n")}
+
+Disposed Callback:
+${runtime.javascript.disposedModules.map(i => `- ${i}`).join("\n")}
+`
+                : ""}
+
+`
+            : ""}
+
+				`.trim();
         if (!fs_extra_1.default.existsSync(snapshotPath) || global.updateSnapshot) {
             fs_extra_1.default.ensureDirSync(path_1.default.dirname(snapshotPath));
             fs_extra_1.default.writeFileSync(snapshotPath, content, "utf-8");
             return;
         }
-        const snapshotContent = fs_extra_1.default
-            .readFileSync(snapshotPath, "utf-8")
-            .replace(/\r\n/g, "\n")
-            .trim();
+        const snapshotContent = (0, helper_1.escapeEOL)(fs_extra_1.default.readFileSync(snapshotPath, "utf-8"));
         expect(content).toBe(snapshotContent);
     }
 }

package/dist/processor/index.d.ts

@@ -13,3 +13,5 @@ export * from "./stats-api";
 export * from "./snapshot";
 export * from "./builtin";
 export * from "./hot-step";
+export * from "./hook";
+export * from "./error";

package/dist/processor/index.js

@@ -29,3 +29,5 @@ __exportStar(require("./stats-api"), exports);
 __exportStar(require("./snapshot"), exports);
 __exportStar(require("./builtin"), exports);
 __exportStar(require("./hot-step"), exports);
+__exportStar(require("./hook"), exports);
+__exportStar(require("./error"), exports);

package/dist/processor/normal.d.ts

@@ -9,7 +9,5 @@ export interface IRspackNormalProcessorOptions {
 export declare class RspackNormalProcessor extends BasicTaskProcessor<ECompilerType.Rspack> {
     protected _normalOptions: IRspackNormalProcessorOptions;
     constructor(_normalOptions: IRspackNormalProcessorOptions);
-    before(context: ITestContext): Promise<void>;
-    after(context: ITestContext): Promise<void>;
     static defaultOptions({ compilerOptions, root }: IRspackNormalProcessorOptions): (context: ITestContext) => TCompilerOptions<ECompilerType.Rspack>;
 }

package/dist/processor/normal.js

@@ -8,7 +8,6 @@ const type_1 = require("../type");
 const basic_1 = require("./basic");
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
-const CWD = process.cwd();
 class RspackNormalProcessor extends basic_1.BasicTaskProcessor {
     constructor(_normalOptions) {
         super({
@@ -24,13 +23,6 @@ class RspackNormalProcessor extends basic_1.BasicTaskProcessor {
         });
         this._normalOptions = _normalOptions;
     }
-    async before(context) {
-        //TODO: remove this
-        process.chdir(path_1.default.resolve(__dirname, "../../../rspack"));
-    }
-    async after(context) {
-        process.chdir(CWD);
-    }
     static defaultOptions({ compilerOptions, root }) {
         return (context) => {
             var _a, _b, _c;
@@ -90,8 +82,7 @@ class RspackNormalProcessor extends basic_1.BasicTaskProcessor {
                     ...compilerOptions.cache
                 },
                 output: {
-                    // CHANGE: rspack does not support `pathinfo` yet.
-                    // pathinfo: "verbose",
+                    pathinfo: "verbose",
                     path: context.getDist(),
                     filename: (compilerOptions === null || compilerOptions === void 0 ? void 0 : compilerOptions.module) ? "bundle.mjs" : "bundle.js"
                 },

package/dist/processor/simple.js

@@ -40,12 +40,8 @@ class SimpleTaskProcessor {
         const compiler = this.getCompiler(context);
         await compiler.close();
     }
-    async beforeAll(context) {
-        throw new Error("Not support");
-    }
-    async afterAll(context) {
-        throw new Error("Not support");
-    }
+    async beforeAll(context) { }
+    async afterAll(context) { }
     getCompiler(context) {
         return context.getCompiler(this._options.name, this._options.compilerType);
     }

package/dist/processor/snapshot.js

@@ -7,6 +7,7 @@ exports.SnapshotProcessor = void 0;
 const basic_1 = require("./basic");
 const path_1 = __importDefault(require("path"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
+const helper_1 = require("../helper");
 class SnapshotProcessor extends basic_1.BasicTaskProcessor {
     constructor(_snapshotOptions) {
         super(_snapshotOptions);
@@ -40,17 +41,16 @@ class SnapshotProcessor extends basic_1.BasicTaskProcessor {
                 .toString()}\n\`\`\``;
         });
         fileContents.sort();
-        const content = fileContents.join("\n\n").replace(/\r\n/g, "\n").trim();
-        const snapshotPath = path_1.default.resolve(context.getSource(), `./snapshot/${this._snapshotOptions.snapshot}`);
+        const content = (0, helper_1.escapeEOL)(fileContents.join("\n\n"));
+        const snapshotPath = path_1.default.isAbsolute(this._snapshotOptions.snapshot)
+            ? this._snapshotOptions.snapshot
+            : path_1.default.resolve(context.getSource(), `./snapshot/${this._snapshotOptions.snapshot}`);
         if (!fs_extra_1.default.existsSync(snapshotPath) || global.updateSnapshot) {
             fs_extra_1.default.ensureDirSync(path_1.default.dirname(snapshotPath));
             fs_extra_1.default.writeFileSync(snapshotPath, content, "utf-8");
             return;
         }
-        const snapshotContent = fs_extra_1.default
-            .readFileSync(snapshotPath, "utf-8")
-            .replace(/\r\n/g, "\n")
-            .trim();
+        const snapshotContent = (0, helper_1.escapeEOL)(fs_extra_1.default.readFileSync(snapshotPath, "utf-8"));
         expect(content).toBe(snapshotContent);
     }
 }

package/dist/processor/stats-api.d.ts

@@ -14,7 +14,5 @@ export declare class StatsAPITaskProcessor<T extends ECompilerType> extends Simp
     compiler(context: ITestContext): Promise<void>;
     run(env: ITestEnv, context: ITestContext): Promise<void>;
     check(env: ITestEnv, context: ITestContext): Promise<void>;
-    before(context: ITestContext): Promise<void>;
-    after(context: ITestContext): Promise<void>;
     static addSnapshotSerializer(): void;
 }

package/dist/processor/stats-api.js

@@ -1,15 +1,9 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StatsAPITaskProcessor = void 0;
 const simple_1 = require("./simple");
 const memfs_1 = require("memfs");
-const path_1 = __importDefault(require("path"));
 const serializer = require("jest-serializer-path");
-const FAKE_CWD = path_1.default.resolve(__dirname, "../../../rspack");
-const CWD = process.cwd();
 class StatsAPITaskProcessor extends simple_1.SimpleTaskProcessor {
     constructor(_statsAPIOptions) {
         super({
@@ -28,7 +22,7 @@ class StatsAPITaskProcessor extends simple_1.SimpleTaskProcessor {
         }
     }
     async run(env, context) {
-        throw new Error("Not support");
+        // do nothing
     }
     async check(env, context) {
         var _a, _b;
@@ -37,12 +31,6 @@ class StatsAPITaskProcessor extends simple_1.SimpleTaskProcessor {
         expect(typeof stats).toBe("object");
         await ((_b = (_a = this._statsAPIOptions).check) === null || _b === void 0 ? void 0 : _b.call(_a, stats, compiler.getCompiler()));
     }
-    async before(context) {
-        process.chdir(this._statsAPIOptions.cwd || FAKE_CWD);
-    }
-    async after(context) {
-        process.chdir(CWD);
-    }
     static addSnapshotSerializer() {
         expect.addSnapshotSerializer(serializer);
     }