@rspack-debug/test-tools 1.3.14

package/dist/test/context.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestContext = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const compiler_1 = require("../compiler");
+class TestContext {
+    constructor(config) {
+        this.config = config;
+        this.errors = new Map();
+        this.compilers = new Map();
+        this.store = new Map();
+        this.runners = new Map();
+        this.runnerFactory = null;
+    }
+    getSource(sub) {
+        if (sub) {
+            return node_path_1.default.resolve(this.config.src, sub);
+        }
+        return this.config.src;
+    }
+    getDist(sub) {
+        if (sub) {
+            return node_path_1.default.resolve(this.config.dist, sub);
+        }
+        return this.config.dist;
+    }
+    getTemp(sub) {
+        if (!this.config.temp)
+            return null;
+        if (sub) {
+            return node_path_1.default.resolve(this.config.temp, sub);
+        }
+        return this.config.temp;
+    }
+    getCompiler(name, type) {
+        let compiler = this.compilers.get(name);
+        if (!compiler) {
+            if (!type) {
+                throw new Error("Compiler does not exists");
+            }
+            compiler = new compiler_1.TestCompilerManager(type, this.config.compilerFactories);
+            this.compilers.set(name, compiler);
+        }
+        return compiler;
+    }
+    getRunnerFactory(name) {
+        if (!this.runnerFactory &&
+            typeof this.config.runnerFactory === "function") {
+            this.runnerFactory = new this.config.runnerFactory(name, this);
+        }
+        return this.runnerFactory;
+    }
+    getRunner(key) {
+        return this.runners.get(key) || null;
+    }
+    setRunner(key, runner) {
+        this.runners.set(key, runner);
+    }
+    getTestConfig() {
+        return this.config.testConfig || {};
+    }
+    setValue(name, key, value) {
+        if (!this.store.has(name)) {
+            this.store.set(name, {});
+        }
+        const scope = this.store.get(name);
+        scope[key] = value;
+    }
+    getValue(name, key) {
+        if (!this.store.has(name)) {
+            this.store.set(name, {});
+        }
+        const scope = this.store.get(name);
+        return scope[key];
+    }
+    hasError(name) {
+        if (name) {
+            return this.getError(name).length > 0;
+        }
+        return !!Array.from(this.errors.values()).reduce((res, arr) => res + arr.length, 0);
+    }
+    emitError(name, err) {
+        const errors = this.errors.get(name) || [];
+        errors.push(typeof err === "string" ? new Error(err) : err);
+        this.errors.set(name, errors);
+    }
+    getNames() {
+        return Array.from(this.compilers.keys());
+    }
+    getError(name) {
+        if (name) {
+            return this.errors.get(name) || [];
+        }
+        return Array.prototype.concat(...this.errors.values());
+    }
+    clearError(name) {
+        if (name) {
+            this.errors.delete(name);
+        }
+        else {
+            this.errors.clear();
+        }
+    }
+}
+exports.TestContext = TestContext;

package/dist/test/creator.d.ts

@@ -0,0 +1,46 @@
+import type { ECompilerType, ITestContext, ITestEnv, ITestProcessor, ITester, TRunnerFactory, TTestConfig } from "../type";
+declare global {
+    var testFilter: string | undefined;
+}
+interface IConcurrentTestEnv {
+    clear: () => void;
+    run: () => Promise<void>;
+}
+export interface IBasicCaseCreatorOptions<T extends ECompilerType> {
+    clean?: boolean;
+    describe?: boolean;
+    timeout?: number;
+    contextValue?: Record<string, unknown>;
+    steps: (creatorConfig: IBasicCaseCreatorOptions<T> & {
+        name: string;
+        src: string;
+        dist: string;
+        temp: string | void;
+    }) => ITestProcessor[];
+    testConfig?: (testConfig: TTestConfig<T>) => void;
+    description?: (name: string, step: number) => string;
+    runner?: new (name: string, context: ITestContext) => TRunnerFactory<ECompilerType>;
+    [key: string]: unknown;
+    concurrent?: boolean | number;
+}
+export declare class BasicCaseCreator<T extends ECompilerType> {
+    protected _options: IBasicCaseCreatorOptions<T>;
+    protected currentConcurrent: number;
+    protected tasks: [string, () => void][];
+    constructor(_options: IBasicCaseCreatorOptions<T>);
+    create(name: string, src: string, dist: string, temp?: string): ITester | undefined;
+    protected shouldRun(name: string): boolean;
+    protected describeConcurrent(name: string, tester: ITester, testConfig: TTestConfig<T>): void;
+    protected describe(name: string, tester: ITester, testConfig: TTestConfig<T>): void;
+    protected createConcurrentEnv(): ITestEnv & IConcurrentTestEnv;
+    protected createEnv(testConfig: TTestConfig<T>): ITestEnv;
+    protected clean(folders: string[]): void;
+    protected skip(name: string, reason: string | boolean): void;
+    protected readTestConfig(src: string): TTestConfig<T>;
+    protected checkSkipped(src: string, testConfig: TTestConfig<T>): boolean | string;
+    protected createTester(name: string, src: string, dist: string, temp: string | void, testConfig: TTestConfig<T>): ITester;
+    protected tryRunTask(): void;
+    protected getMaxConcurrent(): number;
+    protected registerConcurrentTask(name: string, starter: () => void): () => void;
+}
+export {};

package/dist/test/creator.js

@@ -0,0 +1,310 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasicCaseCreator = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const rimraf_1 = require("rimraf");
+const createLazyTestEnv_1 = __importDefault(require("../helper/legacy/createLazyTestEnv"));
+const tester_1 = require("./tester");
+const DEFAULT_MAX_CONCURRENT = 5;
+class BasicCaseCreator {
+    constructor(_options) {
+        this._options = _options;
+        this.currentConcurrent = 0;
+        this.tasks = [];
+    }
+    create(name, src, dist, temp) {
+        const testConfig = this.readTestConfig(src);
+        if (typeof this._options.testConfig === "function") {
+            this._options.testConfig(testConfig);
+        }
+        const skipped = this.checkSkipped(src, testConfig);
+        if (skipped) {
+            this.skip(name, skipped);
+            return;
+        }
+        if (this._options.clean) {
+            this.clean([dist, temp || ""].filter(Boolean));
+        }
+        const run = this.shouldRun(name);
+        const tester = this.createTester(name, src, dist, temp, testConfig);
+        const concurrent = testConfig.concurrent ?? this._options.concurrent ?? false;
+        if (this._options.describe) {
+            if (run) {
+                if (concurrent) {
+                    describe(name, () => this.describeConcurrent(name, tester, testConfig));
+                }
+                else {
+                    describe(name, () => this.describe(name, tester, testConfig));
+                }
+            }
+            else {
+                describe.skip(name, () => {
+                    it.skip("skipped", () => { });
+                });
+            }
+        }
+        else {
+            if (run) {
+                if (concurrent) {
+                    this.describeConcurrent(name, tester, testConfig);
+                }
+                else {
+                    this.describe(name, tester, testConfig);
+                }
+            }
+            else {
+                it.skip("skipped", () => { });
+            }
+        }
+        return tester;
+    }
+    shouldRun(name) {
+        // TODO: more flexible filter
+        if (typeof global.testFilter !== "string" || !global.testFilter) {
+            return true;
+        }
+        return name.includes(global.testFilter);
+    }
+    describeConcurrent(name, tester, testConfig) {
+        beforeAll(async () => {
+            await tester.prepare();
+        });
+        let starter = null;
+        let chain = new Promise((resolve, reject) => {
+            starter = resolve;
+        });
+        const ender = this.registerConcurrentTask(name, starter);
+        const env = this.createConcurrentEnv();
+        for (let index = 0; index < tester.total; index++) {
+            let stepSignalResolve = null;
+            const stepSignal = new Promise((resolve, reject) => {
+                stepSignalResolve = resolve;
+            }).catch(e => {
+                // prevent unhandled rejection
+            });
+            const description = typeof this._options.description === "function"
+                ? this._options.description(name, index)
+                : index
+                    ? `step [${index}] should pass`
+                    : "should pass";
+            it(description, cb => {
+                stepSignal.then((e) => {
+                    cb(e);
+                });
+            }, this._options.timeout || 180000);
+            chain = chain.then(async () => {
+                try {
+                    env.clear();
+                    await tester.compile();
+                    await tester.check(env);
+                    await env.run();
+                    const context = tester.getContext();
+                    if (!tester.next() && context.hasError()) {
+                        const errors = context
+                            .getError()
+                            .map(i => `${i.stack}`.split("\n").join("\t\n"))
+                            .join("\n\n");
+                        throw new Error(`Case "${name}" failed at step ${tester.step + 1}:\n${errors}`);
+                    }
+                    stepSignalResolve();
+                }
+                catch (e) {
+                    stepSignalResolve(e);
+                    return Promise.reject();
+                }
+            }, e => {
+                // bailout
+                stepSignalResolve();
+                return Promise.reject();
+            });
+        }
+        chain
+            .catch(e => {
+            // bailout error
+            // prevent unhandled rejection
+        })
+            .finally(() => {
+            ender();
+        });
+        afterAll(async () => {
+            await tester.resume();
+        });
+    }
+    describe(name, tester, testConfig) {
+        beforeAll(async () => {
+            await tester.prepare();
+        });
+        let bailout = false;
+        for (let index = 0; index < tester.total; index++) {
+            const description = typeof this._options.description === "function"
+                ? this._options.description(name, index)
+                : `step ${index ? `[${index}]` : ""} should pass`;
+            it(description, async () => {
+                if (bailout) {
+                    throw `Case "${name}" step ${index + 1} bailout because ${tester.step + 1} failed`;
+                }
+                await tester.compile();
+                await tester.check(env);
+                const context = tester.getContext();
+                if (!tester.next() && context.hasError()) {
+                    bailout = true;
+                    const errors = context
+                        .getError()
+                        .map(i => `${i.stack}`.split("\n").join("\t\n"))
+                        .join("\n\n");
+                    throw new Error(`Case "${name}" failed at step ${tester.step + 1}:\n${errors}`);
+                }
+            }, this._options.timeout || 30000);
+            const env = this.createEnv(testConfig);
+        }
+        afterAll(async () => {
+            await tester.resume();
+        });
+    }
+    createConcurrentEnv() {
+        const tasks = [];
+        const beforeTasks = [];
+        const afterTasks = [];
+        return {
+            clear: () => {
+                tasks.length = 0;
+                beforeTasks.length = 0;
+                afterTasks.length = 0;
+            },
+            run: async () => {
+                const runFn = async (fn) => {
+                    if (fn.length) {
+                        await new Promise((resolve, reject) => {
+                            fn(e => {
+                                if (e) {
+                                    reject(e);
+                                }
+                                else {
+                                    resolve();
+                                }
+                            });
+                        });
+                    }
+                    else {
+                        const res = fn();
+                        if (typeof res?.then === "function") {
+                            await res;
+                        }
+                    }
+                };
+                for (const [description, fn] of tasks) {
+                    for (const before of beforeTasks) {
+                        await runFn(before);
+                    }
+                    try {
+                        await runFn(fn);
+                    }
+                    catch (e) {
+                        throw new Error(`Error: ${description} failed\n${e.stack}`);
+                    }
+                    for (const after of afterTasks) {
+                        await runFn(after);
+                    }
+                }
+            },
+            expect,
+            it: (description, fn) => {
+                expect(typeof description === "string");
+                expect(typeof fn === "function");
+                tasks.push([description, fn]);
+            },
+            beforeEach: (fn) => {
+                expect(typeof fn === "function");
+                beforeTasks.push(fn);
+            },
+            afterEach: (fn) => {
+                expect(typeof fn === "function");
+                afterTasks.push(fn);
+            },
+            jest
+        };
+    }
+    createEnv(testConfig) {
+        if (typeof this._options.runner === "function" && !testConfig.noTest) {
+            return (0, createLazyTestEnv_1.default)(10000);
+        }
+        return {
+            expect,
+            it,
+            beforeEach,
+            afterEach,
+            jest
+        };
+    }
+    clean(folders) {
+        for (const f of folders) {
+            (0, rimraf_1.rimrafSync)(f);
+            node_fs_1.default.mkdirSync(f, { recursive: true });
+        }
+    }
+    skip(name, reason) {
+        describe.skip(name, () => {
+            it(typeof reason === "string" ? `filtered by ${reason}` : "filtered", () => { });
+        });
+    }
+    readTestConfig(src) {
+        const testConfigFile = node_path_1.default.join(src, "test.config.js");
+        return node_fs_1.default.existsSync(testConfigFile) ? require(testConfigFile) : {};
+    }
+    checkSkipped(src, testConfig) {
+        const filterPath = node_path_1.default.join(src, "test.filter.js");
+        // no test.filter.js, should not skip
+        if (!node_fs_1.default.existsSync(filterPath)) {
+            return false;
+        }
+        // test.filter.js exists, skip if it returns false|string|array
+        const filtered = require(filterPath)(this._options, testConfig);
+        if (typeof filtered === "string" || Array.isArray(filtered)) {
+            return true;
+        }
+        return !filtered;
+    }
+    createTester(name, src, dist, temp, testConfig) {
+        return new tester_1.Tester({
+            name,
+            src,
+            dist,
+            testConfig,
+            contextValue: this._options.contextValue,
+            runnerFactory: this._options.runner,
+            steps: this._options.steps({
+                ...this._options,
+                name,
+                src,
+                dist,
+                temp
+            })
+        });
+    }
+    tryRunTask() {
+        while (this.tasks.length !== 0 &&
+            this.currentConcurrent < this.getMaxConcurrent()) {
+            const [_name, starter] = this.tasks.shift();
+            this.currentConcurrent++;
+            starter();
+        }
+    }
+    getMaxConcurrent() {
+        return typeof this._options.concurrent === "number"
+            ? this._options.concurrent
+            : DEFAULT_MAX_CONCURRENT;
+    }
+    registerConcurrentTask(name, starter) {
+        this.tasks.push([name, starter]);
+        this.tryRunTask();
+        return () => {
+            this.currentConcurrent--;
+            this.tryRunTask();
+        };
+    }
+}
+exports.BasicCaseCreator = BasicCaseCreator;

package/dist/test/simple.d.ts

@@ -0,0 +1,5 @@
+import type { ITestContext, ITestEnv, ITestProcessor } from "../type";
+export declare function getSimpleProcessorRunner(src: string, dist: string, options?: {
+    env?: () => ITestEnv;
+    context?: (src: string, dist: string) => ITestContext;
+}): (name: string, processor: ITestProcessor) => Promise<void>;

package/dist/test/simple.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSimpleProcessorRunner = getSimpleProcessorRunner;
+const context_1 = require("./context");
+const CONTEXT_MAP = new Map();
+function getSimpleProcessorRunner(src, dist, options = {}) {
+    const createEnv = options.env || (() => ({ expect, it, beforeEach, afterEach, jest }));
+    const createContext = options.context ||
+        ((src, dist) => new context_1.TestContext({ src, dist }));
+    const key = `src: ${src}, dist: ${dist}`;
+    if (!CONTEXT_MAP.has(key)) {
+        const context = createContext(src, dist);
+        const runner = async function run(name, processor) {
+            try {
+                await processor.beforeAll?.(context);
+                await processor.before?.(context);
+                await processor.config?.(context);
+                await processor.compiler?.(context);
+                await processor.build?.(context);
+            }
+            catch (e) {
+                context.emitError(name, e);
+            }
+            finally {
+                if (!context.hasError()) {
+                    await processor.run?.(createEnv(), context);
+                }
+                await processor.check?.(createEnv(), context);
+                await processor.after?.(context);
+                await processor.afterAll?.(context);
+            }
+            if (context.hasError()) {
+                const errors = context
+                    .getError()
+                    .map(i => `${i.stack}`.split("\n").join("\t\n"))
+                    .join("\n\n");
+                throw new Error(`Case "${name}" failed:\n${errors}`);
+            }
+        };
+        CONTEXT_MAP.set(key, runner);
+    }
+    return CONTEXT_MAP.get(key);
+}

package/dist/test/tester.d.ts

@@ -0,0 +1,17 @@
+import type { ITestContext, ITestEnv, ITester, ITesterConfig } from "../type";
+export declare class Tester implements ITester {
+    private config;
+    private context;
+    private steps;
+    step: number;
+    total: number;
+    constructor(config: ITesterConfig);
+    getContext(): ITestContext;
+    prepare(): Promise<void>;
+    compile(): Promise<void>;
+    check(env: ITestEnv): Promise<void>;
+    next(): boolean;
+    resume(): Promise<void>;
+    private runStepMethods;
+    private runCheckStepMethods;
+}

package/dist/test/tester.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tester = void 0;
+const context_1 = require("./context");
+class Tester {
+    constructor(config) {
+        this.config = config;
+        this.steps = [];
+        this.step = 0;
+        this.total = 0;
+        this.context = new context_1.TestContext(config);
+        this.steps = config.steps || [];
+        this.step = 0;
+        this.total = config.steps?.length || 0;
+        if (config.contextValue) {
+            for (const [key, value] of Array.from(Object.entries(config.contextValue))) {
+                this.context.setValue(config.name, key, value);
+            }
+        }
+    }
+    getContext() {
+        return this.context;
+    }
+    async prepare() {
+        for (const i of this.steps) {
+            if (typeof i.beforeAll === "function") {
+                await i.beforeAll(this.context);
+            }
+        }
+    }
+    async compile() {
+        const currentStep = this.steps[this.step];
+        if (!currentStep)
+            return;
+        await this.runStepMethods(currentStep, [
+            "before",
+            "config",
+            "compiler",
+            "build"
+        ]);
+    }
+    async check(env) {
+        const currentStep = this.steps[this.step];
+        if (!currentStep)
+            return;
+        await this.runCheckStepMethods(currentStep, env, this.context.hasError() ? ["check"] : ["run", "check"]);
+        await this.runStepMethods(currentStep, ["after"], true);
+    }
+    next() {
+        if (this.context.hasError()) {
+            return false;
+        }
+        if (this.steps[this.step + 1]) {
+            this.step++;
+            return true;
+        }
+        return false;
+    }
+    async resume() {
+        for (const i of this.steps) {
+            if (typeof i.afterAll === "function") {
+                await i.afterAll(this.context);
+            }
+        }
+    }
+    async runStepMethods(step, methods, force = false) {
+        for (const i of methods) {
+            if (!force && this.context.hasError())
+                return;
+            if (typeof step[i] === "function") {
+                try {
+                    await step[i](this.context);
+                }
+                catch (e) {
+                    this.context.emitError(this.config.name, e);
+                }
+            }
+        }
+    }
+    async runCheckStepMethods(step, env, methods) {
+        for (const i of methods) {
+            if (typeof step[i] === "function") {
+                await step[i](env, this.context);
+            }
+        }
+    }
+}
+exports.Tester = Tester;