@rstest/core 0.7.3 → 0.7.5

package/dist/globalSetupWorker.d.ts

@@ -0,0 +1,9 @@
+export declare const runGlobalTeardown: () => Promise<{
+    success: boolean;
+    error?: string;
+}>;
+
+declare function runInPool(options: any): Promise<any>;
+export default runInPool;
+
+export { }

package/dist/globalSetupWorker.js

@@ -0,0 +1,115 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import { __webpack_require__ } from "./rslib-runtime.js";
+import { formatTestError } from "./913.js";
+import "./693.js";
+const source_map_support = __webpack_require__("../../node_modules/.pnpm/source-map-support@0.5.21/node_modules/source-map-support/source-map-support.js");
+const picocolors = __webpack_require__("../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js");
+var picocolors_default = /*#__PURE__*/ __webpack_require__.n(picocolors);
+let teardownCallbacks = [];
+let initialEnv = {};
+let envChanges = {};
+function trackEnvChanges() {
+    initialEnv = {
+        ...process.env
+    };
+}
+function captureEnvChanges() {
+    const changes = {};
+    for(const key in process.env)if (process.env[key] !== initialEnv[key]) changes[key] = process.env[key];
+    for(const key in initialEnv)if (!(key in process.env) && void 0 !== initialEnv[key]) changes[key] = void 0;
+    return changes;
+}
+const runGlobalSetup = async (data)=>{
+    try {
+        if (0 === data.entries.length) return {
+            success: true,
+            hasTeardown: false
+        };
+        (0, source_map_support.install)({
+            environment: 'node',
+            handleUncaughtExceptions: false,
+            retrieveSourceMap: (source)=>{
+                if (data.sourceMaps[source]) return {
+                    url: source,
+                    map: JSON.parse(data.sourceMaps[source])
+                };
+                return null;
+            }
+        });
+        trackEnvChanges();
+        for (const entry of data.entries){
+            const { distPath, testPath } = entry;
+            const setupCodeContent = data.assetFiles[distPath];
+            const { loadModule } = data.outputModule ? await import("./0~923.js").then((mod)=>({
+                    EsmMode: mod.loadEsModule_EsmMode,
+                    asModule: mod.asModule,
+                    loadModule: mod.loadModule
+                })) : await import("./0~835.js").then((mod)=>({
+                    cacheableLoadModule: mod.cacheableLoadModule,
+                    loadModule: mod.loadModule
+                }));
+            const module = await loadModule({
+                codeContent: setupCodeContent,
+                distPath,
+                testPath,
+                rstestContext: {
+                    global,
+                    console: global.console,
+                    Error
+                },
+                assetFiles: data.assetFiles,
+                interopDefault: data.interopDefault
+            });
+            let teardownCallback;
+            if (module && 'object' == typeof module) {
+                if (module.setup && 'function' == typeof module.setup) {
+                    await module.setup();
+                    if (module.teardown && 'function' == typeof module.teardown) teardownCallback = module.teardown;
+                } else if (module.default && 'function' == typeof module.default) teardownCallback = await module.default();
+            }
+            if (teardownCallback) teardownCallbacks.push(teardownCallback);
+        }
+        envChanges = captureEnvChanges();
+        return {
+            success: true,
+            hasTeardown: teardownCallbacks.length > 0,
+            teardownCount: teardownCallbacks.length,
+            envChanges: envChanges
+        };
+    } catch (error) {
+        return {
+            success: false,
+            hasTeardown: false,
+            errors: formatTestError(error)
+        };
+    }
+};
+async function runInPool(options) {
+    switch(options.type){
+        case 'setup':
+            return runGlobalSetup(options);
+        case 'teardown':
+            return runGlobalTeardown();
+    }
+}
+const runGlobalTeardown = async ()=>{
+    try {
+        const callbacks = [
+            ...teardownCallbacks
+        ];
+        teardownCallbacks = [];
+        for (const teardown of callbacks.reverse())await teardown();
+        return {
+            success: true
+        };
+    } catch (error) {
+        const message = error instanceof Error && error.stack ? error.stack : String(error);
+        console.error(picocolors_default().red(`Error during global teardown: ${message}`));
+        return {
+            success: false
+        };
+    }
+};
+export default runInPool;
+export { runGlobalTeardown };

package/dist/index.d.ts

@@ -20,11 +20,7 @@ declare type AfterAllListener = (ctx: SuiteContext) => MaybePromise<void>;
 
 export declare const afterEach: Rstest['afterEach'];
 
-declare type AfterEachListener = (params: {
-    task: {
-        result: Readonly<TestResult>;
-    };
-}) => MaybePromise<void>;
+declare type AfterEachListener = (ctx: TestContext) => MaybePromise<void>;
 
 export declare const assert: Rstest['assert'];
 
@@ -259,7 +255,7 @@ declare type BeforeAllListener = (ctx: SuiteContext) => MaybePromise<void | Afte
 
 export declare const beforeEach: Rstest['beforeEach'];
 
-declare type BeforeEachListener = () => MaybePromise<void | AfterEachListener>;
+declare type BeforeEachListener = (ctx: TestContext) => MaybePromise<void | AfterEachListener>;
 
 declare interface BranchMapping {
     loc: Range_2;
@@ -364,6 +360,59 @@ declare interface Constructable {
     	new (...args: any[]): any;
 }
 
+/**
+ * Base class for writing content
+ */
+declare class ContentWriter {
+    /**
+     * returns the colorized version of a string. Typically,
+     * content writers that write to files will return the
+     * same string and ones writing to a tty will wrap it in
+     * appropriate escape sequences.
+     */
+    colorize(str: string, clazz?: string): string;
+    /**
+     * writes a string appended with a newline to the destination
+     */
+    println(str: string): void;
+    /**
+     * closes this content writer. Should be called after all writes are complete.
+     */
+    close(): void;
+}
+
+declare interface Context {
+    data: any;
+    dir: string;
+    sourceFinder(filepath: string): string;
+    watermarks: Watermarks;
+    writer: FileWriter;
+    /**
+     * returns the coverage class given a coverage
+     * types and a percentage value.
+     */
+    classForPercent(type: keyof Watermarks, value: number): string;
+    /**
+     * returns the source code for the specified file path or throws if
+     * the source could not be found.
+     */
+    getSource(filepath: string): string;
+    getTree(summarizer?: Summarizers): Tree;
+    /**
+     * returns a full visitor given a partial one.
+     */
+    getVisitor<N extends Node_2 = Node_2>(visitor: Partial<Visitor<N>>): Visitor<N>;
+    /**
+     * returns a FileWriter implementation for reporting use. Also available
+     * as the `writer` property on the context.
+     */
+    getWriter(): FileWriter;
+    /**
+     * returns an XML writer for the supplied content writer
+     */
+    getXmlWriter(contentWriter: ContentWriter): XmlWriter;
+}
+
 declare class CounterMap<K> extends DefaultMap<K, number> {
     	constructor();
     	// compat for jest-image-snapshot https://github.com/vitest-dev/vitest/issues/7322
@@ -433,9 +482,19 @@ export declare type CoverageOptions = {
     provider?: 'istanbul';
     /**
      * The reporters to use for coverage collection.
+     * Supports built-in istanbul reporters and custom reporters (e.g., '@canyonjs/report-html').
      * @default ['text', 'html', 'clover', 'json']
+     * @example
+     * // Built-in reporters
+     * reporters: ['text', 'html', ['json', { file: 'coverage.json' }]]
+     *
+     * // Custom reporters
+     * reporters: ['@canyonjs/report-html', ['custom-reporter', { outputDir: './reports' }]]
+     *
+     * // Mixed usage
+     * reporters: ['text', '@canyonjs/report-html', ['html', { subdir: 'html-report' }]]
      */
-    reporters?: (keyof ReportOptions | ReportWithOptions)[];
+    reporters?: SupportedReporter[];
     /**
      * The directory to store coverage reports.
      * @default './coverage'
@@ -551,6 +610,9 @@ declare interface CustomMatcher {
     	toBeOneOf: <T>(sample: Array<T>) => any;
 }
 
+/** Custom reporter configuration for non-istanbul reporters */
+declare type CustomReporter = string | [string, Record<string, unknown>];
+
 declare interface DecodedSourceMap extends SourceMapV3 {
     mappings: SourceMapSegment[][];
 }
@@ -591,12 +653,13 @@ declare class DefaultReporter implements Reporter {
     onTestCaseResult(): void;
     onUserConsoleLog(log: UserConsoleLog): void;
     onExit(): Promise<void>;
-    onTestRunEnd({ results, testResults, duration, getSourcemap, snapshotSummary, filterRerunTestPaths, }: {
+    onTestRunEnd({ results, testResults, duration, getSourcemap, snapshotSummary, filterRerunTestPaths, unhandledErrors, }: {
         results: TestFileResult[];
         testResults: TestResult[];
         duration: Duration;
         snapshotSummary: SnapshotSummary;
         getSourcemap: GetSourcemap;
+        unhandledErrors?: Error[];
         filterRerunTestPaths?: string[];
     }): Promise<void>;
 }
@@ -848,6 +911,29 @@ declare interface FileOptions {
     file: string;
 }
 
+/**
+ * utility for writing files under a specific directory
+ */
+declare class FileWriter {
+    constructor(baseDir: string);
+    static startCapture(): void;
+    static stopCapture(): void;
+    static getOutput(): string;
+    static resetOutput(): void;
+    /**
+     * returns a FileWriter that is rooted at the supplied subdirectory
+     */
+    writeForDir(subdir: string): FileWriter;
+    /**
+     * copies a file from a source directory to a destination name
+     */
+    copyFile(source: string, dest: string, header?: string): void;
+    /**
+     * returns a content writer for writing content to the supplied file.
+     */
+    writeFile(file: string | null): ContentWriter;
+}
+
 declare type Fixture<T, K extends keyof T, ExtraContext = object> = ((...args: any) => any) extends T[K] ? T[K] extends any ? FixtureFn<T, K, Omit<ExtraContext, Exclude<keyof T, K>>> : never : T[K] | (T[K] extends any ? FixtureFn<T, K, Omit<ExtraContext, Exclude<keyof T, K>>> : never);
 
 declare type FixtureFn<T, K extends keyof T, ExtraContext> = (context: Omit<T, K> & ExtraContext, use: Use<T[K]>) => Promise<void>;
@@ -1477,6 +1563,8 @@ declare interface MatcherState_2 extends MatcherState {
 
 declare type MaybePromise<T> = T | Promise<T>;
 
+export declare const mergeProjectConfig: (...configs: ProjectConfig[]) => ProjectConfig;
+
 export declare const mergeRstestConfig: (...configs: RstestConfig[]) => RstestConfig;
 
 export declare interface Mock<T extends FunctionLike = FunctionLike> extends MockInstance_2<T> {
@@ -1939,10 +2027,11 @@ declare interface Node_2 {
     visit(visitor: Visitor, state: any): void;
 }
 
-declare type NormalizedConfig = Required<Omit<RstestConfig, OptionalKeys | 'pool' | 'projects' | 'coverage' | 'setupFiles' | 'exclude'>> & Partial<Pick<RstestConfig, OptionalKeys>> & {
+declare type NormalizedConfig = Required<Omit<RstestConfig, OptionalKeys | 'pool' | 'projects' | 'coverage' | 'setupFiles' | 'globalSetup' | 'exclude'>> & Partial<Pick<RstestConfig, OptionalKeys>> & {
     pool: RstestPoolOptions;
     coverage: NormalizedCoverageOptions;
     setupFiles: string[];
+    globalSetup: string[];
     exclude: {
         patterns: string[];
         override?: boolean;
@@ -1967,8 +2056,9 @@ declare type NormalizedProcedure<T extends Procedure> = (...args: Parameters<T>)
 
 declare type NormalizedProcedure_2<T extends Procedure_2> = (...args: Parameters<T>) => ReturnType<T>;
 
-declare type NormalizedProjectConfig = Required<Omit<NormalizedConfig, OptionalKeys | 'projects' | 'reporters' | 'pool' | 'setupFiles'>> & Pick<NormalizedConfig, OptionalKeys> & {
+declare type NormalizedProjectConfig = Required<Omit<NormalizedConfig, OptionalKeys | 'projects' | 'reporters' | 'pool' | 'setupFiles' | 'globalSetup'>> & Pick<NormalizedConfig, OptionalKeys> & {
     setupFiles: string[];
+    globalSetup: string[];
 };
 
 declare interface OldPlugin {
@@ -1978,19 +2068,11 @@ declare interface OldPlugin {
 
 export declare const onTestFailed: Rstest['onTestFailed'];
 
-declare type OnTestFailedHandler = (params: {
-    task: {
-        result: Readonly<TestResult>;
-    };
-}) => MaybePromise<void>;
+declare type OnTestFailedHandler = (ctx: TestContext) => MaybePromise<void>;
 
 export declare const onTestFinished: Rstest['onTestFinished'];
 
-declare type OnTestFinishedHandler = (params: {
-    task: {
-        result: Readonly<TestResult>;
-    };
-}) => MaybePromise<void>;
+declare type OnTestFinishedHandler = (ctx: TestContext) => MaybePromise<void>;
 
 declare type OptionalKeys = 'testNamePattern' | 'plugins' | 'source' | 'resolve' | 'output' | 'performance' | 'tools' | 'dev' | 'onConsoleLog' | 'chaiConfig' | 'resolveSnapshotPath';
 
@@ -2074,6 +2156,7 @@ declare type ProjectContext = {
     outputModule: boolean;
     configFilePath?: string;
     normalizedConfig: NormalizedProjectConfig;
+    _globalSetups: boolean;
 };
 
 declare interface ProjectOptions {
@@ -2110,6 +2193,15 @@ declare interface RawSnapshotInfo {
 
 declare type Refs = Array<unknown>;
 
+declare class ReportBase {
+    constructor(options?: Partial<ReportBaseOptions>);
+    execute(context: Context): void;
+}
+
+declare interface ReportBaseOptions {
+    summarizer: Summarizers;
+}
+
 export declare interface Reporter {
     /**
      * Called before test file run.
@@ -2144,11 +2236,12 @@ export declare interface Reporter {
     /**
      * Called after all tests have finished running.
      */
-    onTestRunEnd?: ({ results, testResults, duration, getSourcemap, snapshotSummary, }: {
+    onTestRunEnd?: ({ results, testResults, duration, getSourcemap, snapshotSummary, unhandledErrors, }: {
         results: TestFileResult[];
         testResults: TestResult[];
         duration: Duration;
         getSourcemap: GetSourcemap;
+        unhandledErrors?: Error[];
         snapshotSummary: SnapshotSummary;
         filterRerunTestPaths?: string[];
     }) => MaybePromise<void>;
@@ -2258,6 +2351,12 @@ export declare interface RstestConfig {
      * Path to setup files. They will be run before each test file.
      */
     setupFiles?: string[] | string;
+    /**
+     * Path to global setup files, relative to project root.
+     * A global setup file can either export named functions `setup` and `teardown`
+     * or a `default` function that returns a teardown function.
+     */
+    globalSetup?: string[] | string;
     /**
      * Retry the test specific number of times if it fails.
      * @default 0
@@ -2828,6 +2927,11 @@ declare type SuiteContext = {
     filepath: TestPath;
 };
 
+declare type Summarizers = "flat" | "nested" | "pkg" | "defaultSummarizer";
+
+/** Union type for all supported reporter types */
+declare type SupportedReporter = keyof ReportOptions | ReportWithOptions | ReportBase | CustomReporter;
+
 declare interface SyncExpectationResult {
     	pass: boolean;
     	message: () => string;
@@ -2925,6 +3029,15 @@ export declare type TestCaseInfo = {
 };
 
 declare type TestContext = {
+    /**
+     * Metadata of the current test
+     */
+    task: {
+        /** Test name provided by user */
+        name: string;
+        /** Result of the current test, undefined if the test is not run yet */
+        result?: TestResult;
+    };
     expect: Expect;
     onTestFinished: RunnerAPI['onTestFinished'];
     onTestFailed: RunnerAPI['onTestFailed'];
@@ -3065,6 +3178,11 @@ declare class TraceMap implements SourceMap {
     constructor(map: Ro<SourceMapInput>, mapUrl?: string | null);
 }
 
+declare interface Tree<N extends Node_2 = Node_2> {
+    getRoot(): N;
+    visit(visitor: Partial<Visitor<N>>, state: any): void;
+}
+
 declare interface UncheckedSnapshot {
     	filePath: string;
     	keys: Array<string>;
@@ -3097,10 +3215,39 @@ declare type VitestAssertion<
 	T
 > = { [K in keyof A] : A[K] extends Chai.Assertion ? Assertion_2<T> : A[K] extends (...args: any[]) => any ? A[K] : VitestAssertion<A[K], T> } & ((type: string, message?: string) => Assertion_2);
 
+declare type Watermark = [number, number];
+
+declare interface Watermarks {
+    statements: Watermark;
+    functions: Watermark;
+    branches: Watermark;
+    lines: Watermark;
+}
+
 declare type WithAsymmetricMatcher<T> = T | AsymmetricMatcher<unknown>;
 
 declare type XInput = {
     x_google_ignoreList?: SourceMapV3['ignoreList'];
 };
 
+declare interface XmlWriter {
+    indent(str: string): string;
+    /**
+     * writes the opening XML tag with the supplied attributes
+     */
+    openTag(name: string, attrs?: any): void;
+    /**
+     * closes an open XML tag.
+     */
+    closeTag(name: string): void;
+    /**
+     * writes a tag and its value opening and closing it at the same time
+     */
+    inlineTag(name: string, attrs?: any, content?: string): void;
+    /**
+     * closes all open tags and ends the document
+     */
+    closeAll(): void;
+}
+
 export { }

package/dist/index.js

@@ -1,3 +1,3 @@
 import 'module';
 /*#__PURE__*/ import.meta.url;
-export { afterAll, afterEach, assert, beforeAll, beforeEach, createRstest, defineConfig, defineProject, describe, expect, initCli, it, loadConfig, mergeRstestConfig, onTestFailed, onTestFinished, rs, rstest, runCLI, test } from "./131.js";
+export { afterAll, afterEach, assert, beforeAll, beforeEach, createRstest, defineConfig, defineProject, describe, expect, initCli, it, loadConfig, mergeProjectConfig, mergeRstestConfig, onTestFailed, onTestFinished, rs, rstest, runCLI, test } from "./131.js";