@rspack/test-tools 1.5.8 → 1.6.0-beta.1

package/dist/index.js

@@ -18,7 +18,6 @@ __exportStar(require("./case"), exports);
 __exportStar(require("./compare"), exports);
 __exportStar(require("./helper"), exports);
 __exportStar(require("./plugin"), exports);
-__exportStar(require("./reporter"), exports);
 __exportStar(require("./runner"), exports);
 __exportStar(require("./test/context"), exports);
 __exportStar(require("./test/creator"), exports);

package/dist/jest/ignore-snapshot-default-reporter.d.ts

@@ -0,0 +1,2 @@
+export = DefaultReporter;
+import { DefaultReporter } from "@jest/reporters";

package/dist/jest/ignore-snapshot-default-reporter.js

@@ -0,0 +1,57 @@
+"use strict";
+// @ts-nocheck
+const { DefaultReporter } = require("@jest/reporters");
+const chalk = require.cache[require.resolve("@jest/reporters")].require("chalk");
+const jestUtil = require.cache[require.resolve("@jest/reporters")].require("jest-util");
+const ARROW = " \u203A ";
+const DOT = " \u2022 ";
+const FAIL_COLOR = chalk.bold.red;
+const SNAPSHOT_ADDED = chalk.bold.green;
+const SNAPSHOT_UPDATED = chalk.bold.green;
+const SNAPSHOT_OUTDATED = chalk.bold.yellow;
+function getSnapshotStatus(snapshot, afterUpdate) {
+    const statuses = [];
+    if (snapshot.added) {
+        statuses.push(SNAPSHOT_ADDED(`${ARROW + jestUtil.pluralize("snapshot", snapshot.added)} written.`));
+    }
+    if (snapshot.updated) {
+        statuses.push(SNAPSHOT_UPDATED(`${ARROW + jestUtil.pluralize("snapshot", snapshot.updated)} updated.`));
+    }
+    if (snapshot.unmatched) {
+        statuses.push(FAIL_COLOR(`${ARROW + jestUtil.pluralize("snapshot", snapshot.unmatched)} failed.`));
+    }
+    if (snapshot.unchecked) {
+        if (afterUpdate) {
+            statuses.push(SNAPSHOT_UPDATED(`${ARROW + jestUtil.pluralize("snapshot", snapshot.unchecked)} removed.`));
+            for (const key of snapshot.uncheckedKeys) {
+                statuses.push(`  ${DOT}${key}`);
+            }
+        }
+        else {
+            statuses.push(`${SNAPSHOT_OUTDATED(`${ARROW + jestUtil.pluralize("snapshot", snapshot.unchecked)} obsolete`)}.`);
+        }
+    }
+    if (snapshot.fileDeleted) {
+        statuses.push(SNAPSHOT_UPDATED(`${ARROW}snapshot file removed.`));
+    }
+    return statuses;
+}
+const isUpdate = process.argv.includes("-u") || process.argv.includes("--updateSnapshot");
+const isFiltering = process.argv.includes("-t") || process.argv.includes("--testNamePattern");
+const isVerbose = process.argv.includes("--verbose");
+if (!isVerbose && !isUpdate && isFiltering) {
+    class IgnoreSnapshotDefaultReporter extends DefaultReporter {
+        printTestFileFailureMessage(_testPath, _config, result) {
+            if (result.failureMessage) {
+                this.log(result.failureMessage);
+            }
+            const didUpdate = this._globalConfig.updateSnapshot === "all";
+            const snapshotStatuses = getSnapshotStatus(result.snapshot, didUpdate);
+            snapshotStatuses.forEach(this.log);
+        }
+    }
+    module.exports = IgnoreSnapshotDefaultReporter;
+}
+else {
+    module.exports = DefaultReporter;
+}

package/dist/jest/ignore-snapshot-summary-reporter.d.ts

@@ -0,0 +1,2 @@
+export = SummaryReporter;
+import { SummaryReporter } from "@jest/reporters";

package/dist/jest/ignore-snapshot-summary-reporter.js

@@ -0,0 +1,24 @@
+"use strict";
+// @ts-nocheck
+const { SummaryReporter } = require("@jest/reporters");
+const chalk = require.cache[require.resolve("@jest/reporters")].require("chalk");
+const isUpdate = process.argv.includes("-u") || process.argv.includes("--updateSnapshot");
+const isFiltering = process.argv.includes("-t") || process.argv.includes("--testNamePattern");
+const isVerbose = process.argv.includes("--verbose");
+if (!isVerbose && !isUpdate && isFiltering) {
+    class IgnoreSnapshotSummaryReporter extends SummaryReporter {
+        _printSnapshotSummary(snapshots, globalConfig) {
+            if (snapshots.added ||
+                snapshots.filesRemoved ||
+                snapshots.unchecked ||
+                snapshots.unmatched ||
+                snapshots.updated) {
+                this.log(chalk.bold.yellow("Some snapshots are obsoleted, flush with `npm run test -- -u` if necessary.\n"));
+            }
+        }
+    }
+    module.exports = IgnoreSnapshotSummaryReporter;
+}
+else {
+    module.exports = SummaryReporter;
+}

package/dist/jest/patch-node-env.d.ts

@@ -0,0 +1,5 @@
+export = CustomEnvironment;
+declare const CustomEnvironment_base: typeof import("jest-environment-node").default;
+declare class CustomEnvironment extends CustomEnvironment_base {
+    handleTestEvent(event: any, state: any): Promise<void>;
+}

package/dist/jest/patch-node-env.js

@@ -0,0 +1,18 @@
+"use strict";
+// @ts-nocheck
+// Copied from <https://github.com/webpack/webpack/blob/main/test/patch-node-env.js>
+//
+const NodeEnvironment = 
+// For jest@29
+require("jest-environment-node").TestEnvironment ||
+    // For jest@27
+    require("jest-environment-node");
+class CustomEnvironment extends NodeEnvironment {
+    // Workaround for `Symbol('JEST_STATE_SYMBOL')`
+    async handleTestEvent(event, state) {
+        if (!this.global.JEST_STATE_SYMBOL) {
+            this.global.JEST_STATE_SYMBOL = state;
+        }
+    }
+}
+module.exports = CustomEnvironment;

package/dist/jest/slash.d.ts

@@ -0,0 +1,2 @@
+declare function _exports(path: any): any;
+export = _exports;

package/dist/jest/slash.js

@@ -0,0 +1,16 @@
+"use strict";
+// @ts-nocheck
+/**
+ * The following code is copied from
+ * https://github.com/sindresorhus/slash/blob/98b618f5a3bfcb5dd374b204868818845b87bb2f/index.js
+ *
+ * MIT Licensed
+ * Author Sindre Sorhus @sindresorhus
+ */
+module.exports = function slash(path) {
+    const isExtendedLengthPath = path.startsWith("\\\\?\\");
+    if (isExtendedLengthPath) {
+        return path;
+    }
+    return path.replace(/\\/g, "/");
+};

package/dist/runner/node/index.js

@@ -42,6 +42,7 @@ const node_path_1 = __importDefault(require("node:path"));
 const node_url_1 = require("node:url");
 const node_vm_1 = __importStar(require("node:vm"));
 const asModule_1 = __importDefault(require("../../helper/legacy/asModule"));
+const createFakeWorker_1 = __importDefault(require("../../helper/legacy/createFakeWorker"));
 const urlToRelativePath_1 = __importDefault(require("../../helper/legacy/urlToRelativePath"));
 const type_1 = require("../../type");
 const isRelativePath = (p) => /^\.\.?\//.test(p);
@@ -163,8 +164,12 @@ class NodeRunner {
             Symbol,
             Buffer,
             setImmediate,
+            self: this.globalContext,
             __MODE__: this._options.compilerOptions.mode,
             __SNAPSHOT__: node_path_1.default.join(this._options.source, "__snapshot__"),
+            Worker: (0, createFakeWorker_1.default)(this._options.env, {
+                outputDirectory: this._options.dist
+            }),
             ...this._options.env
         };
         return baseModuleScope;
@@ -303,7 +308,7 @@ class NodeRunner {
             };
             this.requireCache[file.path] = m;
             if (!this._options.runInNewContext) {
-                file.content = `Object.assign(global, _globalAssign);\n ${file.content}`;
+                file.content = `Object.assign(global, _globalAssign);${file.content}`;
             }
             const currentModuleScope = this.createModuleScope(this.getRequire(), m, file);
             if (this._options.testConfig.moduleScope) {
@@ -352,6 +357,12 @@ class NodeRunner {
             if (file.content.includes("__STATS__")) {
                 esmContext.__STATS__ = this._options.stats?.();
             }
+            if (file.content.includes("__STATS_I__")) {
+                const statsIndex = this._options.stats?.()?.__index__;
+                if (typeof statsIndex === "number") {
+                    esmContext.__STATS_I__ = statsIndex;
+                }
+            }
             let esm = esmCache.get(file.path);
             if (!esm) {
                 esm = new node_vm_1.SourceTextModule(file.content, {
@@ -385,8 +396,6 @@ class NodeRunner {
                         }), referencingModule.context, true);
                     });
                 }
-                if (esm.instantiate)
-                    esm.instantiate();
                 await esm.evaluate();
                 if (context.esmMode === type_1.EEsmMode.Evaluated) {
                     return esm;

package/dist/runner/web/index.d.ts

@@ -1,14 +1,27 @@
-import { type ECompilerType, EDocumentType, type ITestRunner } from "../../type";
-import type { INodeRunnerOptions, NodeRunner } from "../node";
+import type { ECompilerType, TRunnerFile, TRunnerRequirer } from "../../type";
+import { type INodeRunnerOptions, NodeRunner } from "../node";
 export interface IWebRunnerOptions<T extends ECompilerType = ECompilerType.Rspack> extends INodeRunnerOptions<T> {
-    dom: EDocumentType;
+    location: string;
 }
-export declare class WebRunner<T extends ECompilerType = ECompilerType.Rspack> implements ITestRunner {
+export declare class WebRunner<T extends ECompilerType = ECompilerType.Rspack> extends NodeRunner<T> {
     protected _webOptions: IWebRunnerOptions<T>;
-    protected originMethods: Partial<NodeRunner<T>>;
-    private implement;
+    private dom;
     constructor(_webOptions: IWebRunnerOptions<T>);
     run(file: string): Promise<unknown>;
-    getRequire(): import("../../type").TRunnerRequirer;
     getGlobal(name: string): unknown;
+    protected createResourceLoader(): {
+        fetch(url: string, _: {
+            element: HTMLScriptElement;
+        }): any;
+    };
+    private urlToPath;
+    protected createBaseModuleScope(): import("../../type").IModuleScope;
+    protected getModuleContent(file: TRunnerFile): [
+        {
+            exports: Record<string, unknown>;
+        },
+        string
+    ];
+    protected createJSDOMRequirer(): TRunnerRequirer;
+    protected createRunner(): void;
 }

package/dist/runner/web/index.js

@@ -1,32 +1,307 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebRunner = void 0;
-const type_1 = require("../../type");
-const fake_1 = require("./fake");
-const jsdom_1 = require("./jsdom");
-class WebRunner {
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_url_1 = require("node:url");
+const node_vm_1 = require("node:vm");
+const jsdom_1 = require("jsdom");
+const helper_1 = require("../../helper");
+const EventSourceForNode_1 = __importDefault(require("../../helper/legacy/EventSourceForNode"));
+const urlToRelativePath_1 = __importDefault(require("../../helper/legacy/urlToRelativePath"));
+const node_1 = require("../node");
+const EVAL_LOCATION_REGEX = /<anonymous>:(\d+)/;
+// Compatibility code to suppress iconv-lite warnings
+require("iconv-lite").skipDecodeWarning = true;
+const FAKE_HOSTS = [
+    "https://example.com/public/path",
+    "https://example.com",
+    "https://test.cases/path/",
+    "https://test.cases/server/",
+    "https://test.cases"
+];
+const FAKE_TEST_ROOT_HOST = "https://test.cases/root/";
+class WebRunner extends node_1.NodeRunner {
     constructor(_webOptions) {
+        super(_webOptions);
         this._webOptions = _webOptions;
-        this.originMethods = {};
-        const { dom } = _webOptions;
-        if (dom === type_1.EDocumentType.Fake) {
-            this.implement = new fake_1.FakeDocumentWebRunner(_webOptions);
+        const virtualConsole = new jsdom_1.VirtualConsole({});
+        virtualConsole.sendTo(console, {
+            omitJSDOMErrors: true
+        });
+        this.dom = new jsdom_1.JSDOM(`
+      <!doctype html>
+      <html>
+      <head></head>
+      <body></body>
+      </html>
+    `, {
+            url: this._webOptions.location,
+            resources: this.createResourceLoader(),
+            runScripts: "dangerously",
+            virtualConsole
+        });
+        this.dom.window.console = console;
+        // compat with FakeDocument
+        this.dom.window.eval(`
+      Object.defineProperty(document.head, "_children", {
+        get: function() {
+          return Array.from(document.head.children).map(function(ele) {
+            var type = ele.tagName.toLowerCase();
+            return new Proxy(ele, {
+              get(target, prop, receiver) {
+                if (prop === "_type") {
+                  return target.tagName.toLowerCase();
+                }
+                if (prop === "_href") {
+                  return Reflect.get(target, "href", receiver);
+                }
+                return Reflect.get(target, prop, receiver);
+              },
+            });
+          });
         }
-        else if (dom === type_1.EDocumentType.JSDOM) {
-            this.implement = new jsdom_1.JSDOMWebRunner(_webOptions);
-        }
-        else {
-            throw new Error(`Dom type "${dom}" of web runner is not support yet`);
+      });
+    `);
+        if (this._options.compilerOptions.node !== false) {
+            const vmContext = this.dom.getInternalVMContext();
+            vmContext.global = {};
         }
     }
     run(file) {
-        return this.implement.run(file);
-    }
-    getRequire() {
-        return this.implement.getRequire();
+        if (!file.endsWith(".js") && !file.endsWith(".mjs")) {
+            const cssElement = this.dom.window.document.createElement("link");
+            cssElement.href = file;
+            cssElement.rel = "stylesheet";
+            this.dom.window.document.head.appendChild(cssElement);
+            return Promise.resolve();
+        }
+        return super.run(file);
     }
     getGlobal(name) {
-        return this.implement.getGlobal(name);
+        return this.globalContext[name];
+    }
+    createResourceLoader() {
+        const that = this;
+        class CustomResourceLoader extends jsdom_1.ResourceLoader {
+            fetch(url, _) {
+                const filePath = that.urlToPath(url);
+                let finalCode;
+                if (node_path_1.default.extname(filePath) === ".js") {
+                    const currentDirectory = node_path_1.default.dirname(filePath);
+                    const file = that.getFile(filePath, currentDirectory);
+                    if (!file) {
+                        throw new Error(`File not found: ${filePath}`);
+                    }
+                    const [_m, code] = that.getModuleContent(file);
+                    finalCode = code;
+                }
+                else {
+                    finalCode = node_fs_1.default.readFileSync(filePath);
+                }
+                try {
+                    that.dom.window["__LINK_SHEET__"] ??= {};
+                    that.dom.window["__LINK_SHEET__"][url] = finalCode.toString();
+                    return Promise.resolve(finalCode);
+                }
+                catch (err) {
+                    console.error(err);
+                    if (err.code === "ENOENT") {
+                        return null;
+                    }
+                    throw err;
+                }
+            }
+        }
+        return new CustomResourceLoader();
+    }
+    urlToPath(url) {
+        if (url.startsWith("file://")) {
+            return (0, node_url_1.fileURLToPath)(url);
+        }
+        if (url.startsWith(FAKE_TEST_ROOT_HOST)) {
+            return node_path_1.default.resolve(__TEST_PATH__, `./${url.slice(FAKE_TEST_ROOT_HOST.length)}`);
+        }
+        let dist = url;
+        for (const host of FAKE_HOSTS) {
+            if (url.startsWith(host)) {
+                dist = url.slice(host.length);
+                break;
+            }
+        }
+        return node_path_1.default.resolve(this._webOptions.dist, `./${dist}`).split("?")[0];
+    }
+    createBaseModuleScope() {
+        const moduleScope = super.createBaseModuleScope();
+        moduleScope.EventSource = EventSourceForNode_1.default;
+        moduleScope.fetch = async (url) => {
+            try {
+                const buffer = await new Promise((resolve, reject) => node_fs_1.default.readFile(this.urlToPath(url), (err, b) => err ? reject(err) : resolve(b)));
+                return {
+                    status: 200,
+                    ok: true,
+                    json: async () => JSON.parse(buffer.toString("utf-8"))
+                };
+            }
+            catch (err) {
+                if (err.code === "ENOENT") {
+                    return {
+                        status: 404,
+                        ok: false
+                    };
+                }
+                throw err;
+            }
+        };
+        moduleScope.URL = URL;
+        moduleScope.importScripts = (url) => {
+            this._options.env.expect(url).toMatch(/^https:\/\/test\.cases\/path\//);
+            this.requirers.get("entry")(this._options.dist, (0, urlToRelativePath_1.default)(url));
+        };
+        moduleScope.getComputedStyle = (element) => {
+            const computedStyle = this.dom.window.getComputedStyle(element);
+            const getPropertyValue = computedStyle.getPropertyValue.bind(computedStyle);
+            return {
+                ...computedStyle,
+                getPropertyValue(v) {
+                    return getPropertyValue(v);
+                }
+            };
+        };
+        moduleScope.window = this.dom.window;
+        moduleScope.document = this.dom.window.document;
+        moduleScope.getLinkSheet = (link) => {
+            return this.dom.window["__LINK_SHEET__"][link.href];
+        };
+        return moduleScope;
+    }
+    getModuleContent(file) {
+        const m = {
+            exports: {}
+        };
+        const currentModuleScope = this.createModuleScope(this.getRequire(), m, file);
+        if (this._options.testConfig.moduleScope) {
+            this._options.testConfig.moduleScope(currentModuleScope, this._options.stats, this._options.compilerOptions);
+        }
+        if (file.content.includes("__STATS__")) {
+            currentModuleScope.__STATS__ = this._options.stats?.();
+        }
+        if (file.content.includes("__STATS_I__")) {
+            const statsIndex = this._options.stats?.()?.__index__;
+            if (typeof statsIndex === "number") {
+                currentModuleScope.__STATS_I__ = statsIndex;
+            }
+        }
+        const createLocatedError = (e, file) => {
+            const match = (e.stack || e.message).match(EVAL_LOCATION_REGEX);
+            if (match) {
+                const [, line] = match;
+                const realLine = Number(line) - 34;
+                const codeLines = file.content.split("\n");
+                const lineContents = [
+                    ...codeLines
+                        .slice(Math.max(0, realLine - 3), Math.max(0, realLine - 1))
+                        .map(line => `│  ${line}`),
+                    `│> ${codeLines[realLine - 1]}`,
+                    ...codeLines.slice(realLine, realLine + 2).map(line => `│  ${line}`)
+                ];
+                const message = `Error in JSDOM when running file '${file.path}' at line ${realLine}: ${e.message}\n${lineContents.join("\n")}`;
+                const finalError = new Error(message);
+                finalError.stack = undefined;
+                return finalError;
+            }
+            else {
+                return e;
+            }
+        };
+        const originIt = currentModuleScope.it;
+        currentModuleScope.it = (description, fn) => {
+            originIt(description, async () => {
+                try {
+                    await fn();
+                }
+                catch (err) {
+                    throw createLocatedError(err, file);
+                }
+            });
+        };
+        const scopeKey = (0, helper_1.escapeSep)(file.path);
+        const args = Object.keys(currentModuleScope).filter(arg => !["window", "self", "globalThis", "console"].includes(arg));
+        const argValues = args
+            .map(arg => `window["${scopeKey}"]["${arg}"]`)
+            .join(", ");
+        this.dom.window[scopeKey] = currentModuleScope;
+        this.dom.window["__GLOBAL_SHARED__"] = this.globalContext;
+        this.dom.window["__FILE__"] = file;
+        this.dom.window["__CREATE_LOCATED_ERROR__"] = createLocatedError;
+        return [
+            m,
+            `// hijack document.currentScript for auto public path
+			var $$g$$ = new Proxy(window, {
+				get(target, prop, receiver) {
+					if (prop === "document") {
+						return new Proxy(window.document, {
+							get(target, prop, receiver) {
+								if (prop === "currentScript") {
+									var script = target.createElement("script");
+									script.src = "https://test.cases/path/${(0, helper_1.escapeSep)(file.subPath)}index.js";
+									return script;
+								}
+								return Reflect.get(target, prop, receiver);
+							}
+						});
+					}
+					return Reflect.get(target, prop, receiver);
+				},
+			});
+			var $$self$$ = new Proxy(window, {
+				get(target, prop, receiver) {
+				  if (prop === "__HMR_UPDATED_RUNTIME__") {
+					  return window["__GLOBAL_SHARED__"]["__HMR_UPDATED_RUNTIME__"];
+					}
+					return Reflect.get(target, prop, receiver);
+				},
+				set(target, prop, value, receiver) {
+					if (prop === "__HMR_UPDATED_RUNTIME__") {
+						window["__GLOBAL_SHARED__"]["__HMR_UPDATED_RUNTIME__"] = value;
+					}
+					return Reflect.set(target, prop, value, receiver);
+				}
+			});
+			(function(window, self, globalThis, console, ${args.join(", ")}) {
+				try {
+				  ${file.content}
+				} catch (err) {
+					throw __CREATE_LOCATED_ERROR__(err, __FILE__);
+				}
+			})($$g$$, $$self$$, $$g$$, window["console"], ${argValues});`
+        ];
+    }
+    createJSDOMRequirer() {
+        return (currentDirectory, modulePath, context = {}) => {
+            const file = context.file || this.getFile(modulePath, currentDirectory);
+            if (!file) {
+                return this.requirers.get("miss")(currentDirectory, modulePath);
+            }
+            if (file.path in this.requireCache) {
+                return this.requireCache[file.path].exports;
+            }
+            const [m, code] = this.getModuleContent(file);
+            this.preExecute(code, file);
+            const script = new node_vm_1.Script(code);
+            const vmContext = this.dom.getInternalVMContext();
+            script.runInContext(vmContext);
+            this.postExecute(m, file);
+            this.requireCache[file.path] = m;
+            return m.exports;
+        };
+    }
+    createRunner() {
+        super.createRunner();
+        this.requirers.set("cjs", this.createJSDOMRequirer());
     }
 }
 exports.WebRunner = WebRunner;

package/dist/test/creator.js

@@ -97,17 +97,19 @@ class BasicCaseCreator {
                 : index
                     ? `step [${index}] should pass`
                     : "should pass";
-            it(description, cb => {
-                stepSignal.then((e) => {
-                    cb(e);
-                });
-            }, options.timeout || 180000);
+            it(description, async () => {
+                const e = await stepSignal;
+                if (e) {
+                    throw e;
+                }
+            }, options.timeout || 300000);
             chain = chain.then(async () => {
                 try {
                     env.clear();
                     await tester.compile();
                     await tester.check(env);
                     await env.run();
+                    await tester.after();
                     const context = tester.getContext();
                     if (!tester.next() && context.hasError()) {
                         const errors = context
@@ -170,7 +172,7 @@ class BasicCaseCreator {
                         .join("\n\n");
                     throw new Error(`Case "${name}" failed at step ${tester.step + 1}:\n${errors}`);
                 }
-            }, options.timeout || 30000);
+            }, options.timeout || 60000);
             const env = this.createEnv(testConfig, options);
         }
         afterAll(async () => {
@@ -215,8 +217,11 @@ class BasicCaseCreator {
                     try {
                         await runFn(fn);
                     }
-                    catch (e) {
-                        throw new Error(`Error: ${description} failed\n${e.stack}`);
+                    catch (err) {
+                        const e = err;
+                        const message = `Error: ${description} failed:\n${e.message}`;
+                        e.message = message;
+                        throw e;
                     }
                     for (const after of afterTasks) {
                         await runFn(after);
@@ -237,7 +242,8 @@ class BasicCaseCreator {
                 expect(typeof fn === "function");
                 afterTasks.push(fn);
             },
-            jest
+            jest: global.jest || global.rstest,
+            rstest: global.rstest
         };
     }
     createEnv(testConfig, options) {
@@ -255,7 +261,6 @@ class BasicCaseCreator {
     clean(folders) {
         for (const f of folders) {
             (0, rimraf_1.rimrafSync)(f);
-            node_fs_1.default.mkdirSync(f, { recursive: true });
         }
     }
     skip(name, reason) {

package/dist/test/tester.d.ts

@@ -10,6 +10,7 @@ export declare class Tester implements ITester {
     prepare(): Promise<void>;
     compile(): Promise<void>;
     check(env: ITestEnv): Promise<void>;
+    after(): Promise<void>;
     next(): boolean;
     resume(): Promise<void>;
     private runStepMethods;