@rstest/core 0.0.1

package/dist-types/worker.d.ts

@@ -0,0 +1,646 @@
+import type { addSerializer } from '@vitest/snapshot';
+import type { Assertion as Assertion_2 } from '@vitest/expect';
+import type { ExpectStatic as ExpectStatic_2 } from '@vitest/expect';
+import type { MatcherState as MatcherState_2 } from '@vitest/expect';
+import type { RsbuildConfig } from '@rsbuild/core';
+import type { SnapshotManager } from '@vitest/snapshot/manager';
+import type { SnapshotResult } from '@vitest/snapshot';
+import type { SnapshotState } from '@vitest/snapshot';
+import type { SnapshotSummary } from '@vitest/snapshot';
+import type { SnapshotUpdateState } from '@vitest/snapshot';
+import type { Tester } from '@vitest/expect';
+
+declare type AfterAllListener = (ctx: SuiteContext) => MaybePromise<void>;
+
+declare type AfterEachListener = () => MaybePromise<void>;
+
+declare interface Assertion<T = any> extends Assertion_2<T> {
+    matchSnapshot: SnapshotMatcher<T>;
+    toMatchSnapshot: SnapshotMatcher<T>;
+    toMatchInlineSnapshot: InlineSnapshotMatcher<T>;
+    /**
+     * Checks that an error thrown by a function matches a previously recorded snapshot.
+     *
+     * @param message - Optional custom error message.
+     *
+     * @example
+     * expect(functionWithError).toThrowErrorMatchingSnapshot();
+     */
+    toThrowErrorMatchingSnapshot: (message?: string) => void;
+    /**
+     * Checks that an error thrown by a function matches an inline snapshot within the test file.
+     * Useful for keeping snapshots close to the test code.
+     *
+     * @param snapshot - Optional inline snapshot string to match.
+     * @param message - Optional custom error message.
+     *
+     * @example
+     * const throwError = () => { throw new Error('Error occurred') };
+     * expect(throwError).toThrowErrorMatchingInlineSnapshot(`"Error occurred"`);
+     */
+    toThrowErrorMatchingInlineSnapshot: (snapshot?: string, message?: string) => void;
+    /**
+     * Compares the received value to a snapshot saved in a specified file.
+     * Useful for cases where snapshot content is large or needs to be shared across tests.
+     *
+     * @param filepath - Path to the snapshot file.
+     * @param message - Optional custom error message.
+     *
+     * @example
+     * await expect(largeData).toMatchFileSnapshot('path/to/snapshot.json');
+     */
+    toMatchFileSnapshot: (filepath: string, message?: string) => Promise<void>;
+    /**
+     * Verifies that a promise resolves.
+     *
+     * @example
+     * await expect(someAsyncFunc).resolves.toBe(42);
+     */
+    resolves: PromisifyAssertion<T>;
+    /**
+     * Verifies that a promise rejects.
+     *
+     * @example
+     * await expect(someAsyncFunc).rejects.toThrow('error');
+     */
+    rejects: PromisifyAssertion<T>;
+}
+
+declare type BeforeAllListener = (ctx: SuiteContext) => MaybePromise<void | AfterAllListener>;
+
+declare type BeforeEachListener = () => MaybePromise<void | AfterEachListener>;
+
+declare type BuiltInReporterNames = keyof typeof reportersMap;
+
+declare type BuiltinReporterOptions = {
+    default: DefaultReporterOptions;
+};
+
+declare interface DecodedSourceMap extends SourceMapV3 {
+    mappings: SourceMapSegment[][];
+}
+
+declare type DecodedSourceMapXInput = DecodedSourceMap & XInput;
+
+declare class DefaultReporter implements Reporter {
+    private rootPath;
+    private config;
+    private options;
+    private statusRenderer;
+    constructor({ rootPath, options, config, }: {
+        rootPath: string;
+        config: NormalizedConfig;
+        options: DefaultReporterOptions;
+    });
+    onTestFileStart(test: TestFileInfo): void;
+    onTestFileResult(test: TestFileResult): void;
+    onTestCaseResult(_result: TestResult): void;
+    onUserConsoleLog(log: UserConsoleLog): void;
+    onExit(): Promise<void>;
+    onTestRunEnd({ results, testResults, duration, getSourcemap, snapshotSummary, }: {
+        results: TestFileResult[];
+        testResults: TestResult[];
+        duration: Duration;
+        snapshotSummary: SnapshotSummary;
+        getSourcemap: GetSourcemap;
+    }): Promise<void>;
+}
+
+declare type DefaultReporterOptions = {
+    /**
+     * prints out summary of all tests
+     * @default true
+     */
+    summary?: boolean;
+};
+
+/** The test file output path */
+declare type DistPath = string;
+
+declare type Duration = {
+    totalTime: number;
+    buildTime: number;
+    testTime: number;
+};
+
+declare interface EncodedSourceMap extends SourceMapV3 {
+    mappings: string;
+}
+
+declare type EncodedSourceMapXInput = EncodedSourceMap & XInput;
+
+declare type EntryInfo = {
+    distPath: DistPath;
+    testPath: TestPath;
+    files?: string[];
+};
+
+declare interface ExpectPollOptions {
+    /**
+     * @default 50
+     */
+    interval?: number;
+    /**
+     * @default 1000
+     */
+    timeout?: number;
+    message?: string;
+}
+
+declare interface ExpectStatic extends ExpectStatic_2 {
+    <T>(actual: T, message?: string): Assertion<T>;
+    unreachable: (message?: string) => never;
+    soft: <T>(actual: T, message?: string) => Assertion<T>;
+    poll: <T>(actual: () => T, options?: ExpectPollOptions) => Omit<PromisifyAssertion<Awaited<T>>, 'rejects' | 'resolves' | 'toThrow' | 'toThrowError' | 'throw' | 'throws' | 'matchSnapshot' | 'toMatchSnapshot' | 'toMatchInlineSnapshot' | 'toThrowErrorMatchingSnapshot' | 'toThrowErrorMatchingInlineSnapshot'>;
+    addEqualityTesters: (testers: Array<Tester>) => void;
+    assertions: (expected: number) => void;
+    hasAssertions: () => void;
+    addSnapshotSerializer: typeof addSerializer;
+    getState: () => MatcherState;
+    setState: (state: Partial<MatcherState>) => void;
+}
+
+declare type FixtureFn<T, K extends keyof T, ExtraContext> = (context: Omit<T, K> & ExtraContext, use: Use<T[K]>) => Promise<void>;
+
+declare interface FixtureOptions {
+    /**
+     * Whether to automatically set up current fixture, even though it's not being used in tests.
+     */
+    auto?: boolean;
+}
+
+declare type FormattedError = {
+    message: string;
+    name?: string;
+    stack?: string;
+    diff?: string;
+};
+
+declare type GeneratedColumn = number;
+
+declare type GetSourcemap = (sourcePath: string) => SourceMapInput | null;
+
+declare interface InlineSnapshotMatcher<T> {
+    <U extends {
+        [P in keyof T]: any;
+    }>(properties: Partial<U>, snapshot?: string, message?: string): void;
+    (message?: string): void;
+}
+
+declare interface MatcherState extends MatcherState_2 {
+    environment: string;
+    snapshotState: SnapshotState;
+}
+
+declare type MaybePromise<T> = T | Promise<T>;
+
+declare type NamesIndex = number;
+
+declare type NormalizedConfig = Required<Omit<RstestConfig, OptionalKeys | 'pool'>> & {
+    [key in OptionalKeys]?: RstestConfig[key];
+} & {
+    pool: RstestPoolOptions;
+};
+
+declare type NormalizedFixture = {
+    isFn: boolean;
+    deps?: string[];
+    value: FixtureFn<any, any, any> | any;
+    options?: FixtureOptions;
+};
+
+declare type NormalizedFixtures = Record<string, NormalizedFixture>;
+
+declare type OptionalKeys = 'setupFiles' | 'testNamePattern' | 'plugins' | 'source' | 'resolve' | 'output' | 'tools' | 'onConsoleLog';
+
+declare type Promisify<O> = {
+    [K in keyof O]: O[K] extends (...args: infer A) => infer R ? Promisify<O[K]> & ((...args: A) => Promise<R>) : O[K];
+};
+
+declare type PromisifyAssertion<T> = Promisify<Assertion<T>>;
+
+declare interface Reporter {
+    /**
+     * Called before test file run.
+     */
+    onTestFileStart?: (test: TestFileInfo) => void;
+    /**
+     * Called when the test file has finished running.
+     */
+    onTestFileResult?: (test: TestFileResult) => void;
+    /**
+     * Called when the test has finished running or was just skipped.
+     */
+    onTestCaseResult?: (result: TestResult) => void;
+    /**
+     * Called after all tests have finished running.
+     */
+    onTestRunEnd?: ({ results, testResults, duration, getSourcemap, snapshotSummary, }: {
+        results: TestFileResult[];
+        testResults: TestResult[];
+        duration: Duration;
+        getSourcemap: GetSourcemap;
+        snapshotSummary: SnapshotSummary;
+    }) => MaybePromise<void>;
+    /**
+     * Called when console log is calling.
+     */
+    onUserConsoleLog?: (log: UserConsoleLog) => void;
+    /**
+     * Called when rstest exit abnormally
+     */
+    onExit?: () => void;
+}
+
+declare const reportersMap: {
+    default: typeof DefaultReporter;
+};
+
+declare type ReporterWithOptions<Name extends BuiltInReporterNames = BuiltInReporterNames> = Name extends keyof BuiltinReporterOptions ? [Name, Partial<BuiltinReporterOptions[Name]>] : [Name, Record<string, unknown>];
+
+declare type RstestCommand = 'watch' | 'run' | 'list';
+
+declare interface RstestConfig {
+    /**
+     * Project root
+     *
+     * @default process.cwd()
+     */
+    root?: string;
+    /**
+     * Project name
+     *
+     * @default rstest
+     */
+    name?: string;
+    /**
+     * A list of glob patterns that match your test files.
+     *
+     * @default ['**\/*.{test,spec}.?(c|m)[jt]s?(x)']
+     */
+    include?: string[];
+    /**
+     * A list of glob patterns that should be excluded from your test files.
+     *
+     * @default ['**\/node_modules/**', '**\/dist/**']
+     */
+    exclude?: string[];
+    /**
+     * A list of glob patterns that match your in-source test files
+     *
+     * @default []
+     */
+    includeSource?: string[];
+    /**
+     * Path to setup files. They will be run before each test file.
+     */
+    setupFiles?: string[] | string;
+    /**
+     * Retry the test specific number of times if it fails.
+     * @default 0
+     */
+    retry?: number;
+    /**
+     * Allows the test suite to pass when no files are found.
+     *
+     * @default false
+     */
+    passWithNoTests?: boolean;
+    /**
+     * Pool used to run tests in.
+     */
+    pool?: RstestPoolType | RstestPoolOptions;
+    /**
+     * Run tests in an isolated environment
+     *
+     * @default true
+     */
+    isolate?: boolean;
+    /**
+     * Provide global APIs
+     *
+     * @default false
+     */
+    globals?: boolean;
+    /**
+     * The environment that will be used for testing
+     *
+     * TODO: support more test environments
+     * @default 'node'
+     */
+    testEnvironment?: 'node';
+    /**
+     * print console traces when calling any console method.
+     *
+     * @default false
+     */
+    printConsoleTrace?: boolean;
+    /**
+     * Disable console intercept. `onConsoleLog` & `printConsoleTrace` configuration will not take effect.
+     *
+     * @default false
+     */
+    disableConsoleIntercept?: boolean;
+    /**
+     * Update snapshot files. Will update all changed snapshots and delete obsolete ones.
+     *
+     * @default false
+     */
+    update?: boolean;
+    /**
+     * Custom reporter for output.
+     * @default ['default']
+     */
+    reporters?: Reporter | BuiltInReporterNames | (Reporter | BuiltInReporterNames | [BuiltInReporterNames] | ReporterWithOptions)[];
+    /**
+     * Run only tests with a name that matches the regex.
+     */
+    testNamePattern?: string | RegExp;
+    /**
+     * Timeout of a test in milliseconds.
+     * @default 5000
+     */
+    testTimeout?: number;
+    /**
+     * Automatically clear mock calls, instances, contexts and results before every test.
+     * @default false
+     */
+    clearMocks?: boolean;
+    /**
+     * Automatically reset mock state before every test.
+     * @default false
+     */
+    resetMocks?: boolean;
+    /**
+     * Automatically restore mock state and implementation before every test.
+     * @default false
+     */
+    restoreMocks?: boolean;
+    /**
+     * The number of milliseconds after which a test or suite is considered slow and reported as such in the results.
+     * @default 300
+     */
+    slowTestThreshold?: number;
+    /**
+     * Restores all global variables that were changed with `rstest.stubGlobal` before every test.
+     * @default false
+     */
+    unstubGlobals?: boolean;
+    /**
+     * Restores all `process.env` values that were changed with `rstest.stubEnv` before every test.
+     * @default false
+     */
+    unstubEnvs?: boolean;
+    /**
+     * Maximum number of concurrent tests
+     * @default 5
+     */
+    maxConcurrency?: number;
+    /**
+     * Custom handler for console log in tests
+     */
+    onConsoleLog?: (content: string) => boolean | void;
+    plugins?: RsbuildConfig['plugins'];
+    source?: Pick<NonNullable<RsbuildConfig['source']>, 'define' | 'tsconfigPath' | 'decorators' | 'include' | 'exclude'>;
+    output?: Pick<NonNullable<RsbuildConfig['output']>, 'cssModules'>;
+    resolve?: RsbuildConfig['resolve'];
+    tools?: Pick<NonNullable<RsbuildConfig['tools']>, 'rspack' | 'swc' | 'bundlerChain'>;
+}
+
+declare type RstestContext = {
+    /** The Rstest core version. */
+    version: string;
+    /** The root path of current project. */
+    rootPath: string;
+    /** The original Rstest config passed from the createRstest method. */
+    originalConfig: Readonly<RstestConfig>;
+    /** The normalized Rstest config. */
+    normalizedConfig: NormalizedConfig;
+    /**
+     * The command type.
+     *
+     * - dev: `rstest dev`
+     * - run: `rstest run`
+     */
+    command: RstestCommand;
+    reporters: Reporter[];
+    snapshotManager: SnapshotManager;
+};
+
+declare type RstestExpect = ExpectStatic;
+
+declare type RstestPoolOptions = {
+    /** Pool used to run tests in. */
+    type: RstestPoolType;
+    /** Maximum number or percentage of workers to run tests in. */
+    maxWorkers?: number | string;
+    /** Minimum number or percentage of workers to run tests in. */
+    minWorkers?: number | string;
+    /** Pass additional arguments to node process in the child processes. */
+    execArgv?: string[];
+};
+
+declare type RstestPoolType = 'forks';
+
+declare const runInPool: (options: RunWorkerOptions["options"]) => Promise<{
+    tests: Test[];
+    testPath: string;
+} | TestFileResult>;
+export default runInPool;
+
+declare type RuntimeConfig = Pick<RstestContext['normalizedConfig'], 'testTimeout' | 'testNamePattern' | 'globals' | 'passWithNoTests' | 'retry' | 'clearMocks' | 'resetMocks' | 'restoreMocks' | 'unstubEnvs' | 'unstubGlobals' | 'maxConcurrency' | 'printConsoleTrace' | 'disableConsoleIntercept' | 'testEnvironment'>;
+
+/** Runtime to Server */
+declare type RuntimeRPC = {
+    onTestFileStart: (test: TestFileInfo) => Promise<void>;
+    onTestFileResult: (test: TestFileResult) => Promise<void>;
+    onTestCaseResult: (result: TestResult) => Promise<void>;
+    onConsoleLog: (log: UserConsoleLog) => void;
+};
+
+declare type RunWorkerOptions = {
+    options: {
+        entryInfo: EntryInfo;
+        setupEntries: EntryInfo[];
+        assetFiles: Record<string, string>;
+        sourceMaps: Record<string, SourceMapInput>;
+        context: WorkerContext;
+        updateSnapshot: SnapshotUpdateState;
+        type: 'run' | 'collect';
+    };
+    rpcMethods: RuntimeRPC;
+};
+
+declare interface SnapshotMatcher<T> {
+    <U extends {
+        [P in keyof T]: any;
+    }>(snapshot: Partial<U>, message?: string): void;
+    (message?: string): void;
+}
+
+declare type SourceColumn = number;
+
+declare type SourceLine = number;
+
+declare abstract class SourceMap {
+    version: SourceMapV3['version'];
+    file: SourceMapV3['file'];
+    names: SourceMapV3['names'];
+    sourceRoot: SourceMapV3['sourceRoot'];
+    sources: SourceMapV3['sources'];
+    sourcesContent: SourceMapV3['sourcesContent'];
+    resolvedSources: SourceMapV3['sources'];
+    ignoreList: SourceMapV3['ignoreList'];
+}
+
+declare type SourceMapInput = string | EncodedSourceMapXInput | DecodedSourceMapXInput | TraceMap;
+
+declare type SourceMapSegment = [GeneratedColumn] | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn] | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn, NamesIndex];
+
+declare interface SourceMapV3 {
+    file?: string | null;
+    names: string[];
+    sourceRoot?: string;
+    sources: (string | null)[];
+    sourcesContent?: (string | null)[];
+    version: 3;
+    ignoreList?: number[];
+}
+
+declare type SourcesIndex = number;
+
+declare type SuiteContext = {
+    filepath: TestPath;
+};
+
+declare interface TaskResult {
+    /**
+     * State of the task. Inherits the `task.mode` during collection.
+     * When the task has finished, it will be changed to `pass` or `fail`.
+     * - **pass**: task ran successfully
+     * - **fail**: task failed
+     */
+    state: TaskState;
+    /**
+     * Errors that occurred during the task execution. It is possible to have several errors
+     * if `expect.soft()` failed multiple times or `retry` was triggered.
+     */
+    errors?: FormattedError[];
+}
+
+declare type TaskState = 'pass' | 'fail';
+
+declare type Test = TestSuite | TestCase;
+
+declare type TestCase = {
+    testPath: TestPath;
+    name: string;
+    originalFn?: (context: TestContext) => void | Promise<void>;
+    fn?: (context: TestContext) => void | Promise<void>;
+    runMode: TestRunMode;
+    timeout?: number;
+    fails?: boolean;
+    each?: boolean;
+    fixtures?: NormalizedFixtures;
+    concurrent?: boolean;
+    sequential?: boolean;
+    inTestEach?: boolean;
+    context: TestContext;
+    only?: boolean;
+    onFinished?: any[];
+    type: 'case';
+    parentNames?: string[];
+    /**
+     * Store promises (from async expects) to wait for them before finishing the test
+     */
+    promises?: Promise<any>[];
+    /**
+     * Result of the task. if `expect.soft()` failed multiple times or `retry` was triggered.
+     */
+    result?: TaskResult;
+};
+
+declare type TestContext = {
+    expect: RstestExpect;
+};
+
+declare type TestFileInfo = {
+    testPath: TestPath;
+};
+
+declare type TestFileResult = TestResult & {
+    results: TestResult[];
+    snapshotResult?: SnapshotResult;
+};
+
+/** The test file original path */
+declare type TestPath = string;
+
+declare type TestResult = {
+    status: TestResultStatus;
+    name: string;
+    testPath: TestPath;
+    parentNames?: string[];
+    duration?: number;
+    errors?: FormattedError[];
+};
+
+declare type TestResultStatus = 'skip' | 'pass' | 'fail' | 'todo';
+
+declare type TestRunMode = 'run' | 'skip' | 'todo' | 'only';
+
+declare type TestSuite = {
+    name: string;
+    parentNames?: string[];
+    runMode: TestRunMode;
+    each?: boolean;
+    inTestEach?: boolean;
+    concurrent?: boolean;
+    sequential?: boolean;
+    testPath: TestPath;
+    /** nested cases and suite could in a suite */
+    tests: Array<TestSuite | TestCase>;
+    type: 'suite';
+    afterAllListeners?: AfterAllListener[];
+    beforeAllListeners?: BeforeAllListener[];
+    afterEachListeners?: AfterEachListener[];
+    beforeEachListeners?: BeforeEachListener[];
+};
+
+declare class TraceMap implements SourceMap {
+    version: SourceMapV3['version'];
+    file: SourceMapV3['file'];
+    names: SourceMapV3['names'];
+    sourceRoot: SourceMapV3['sourceRoot'];
+    sources: SourceMapV3['sources'];
+    sourcesContent: SourceMapV3['sourcesContent'];
+    ignoreList: SourceMapV3['ignoreList'];
+    resolvedSources: string[];
+    private _encoded;
+    private _decoded;
+    private _decodedMemo;
+    private _bySources;
+    private _bySourceMemos;
+    constructor(map: SourceMapInput, mapUrl?: string | null);
+}
+
+declare type Use<T> = (value: T) => Promise<void>;
+
+declare interface UserConsoleLog {
+    content: string;
+    name: string;
+    trace?: string;
+    testPath: TestPath;
+    type: 'stdout' | 'stderr';
+}
+
+declare type WorkerContext = {
+    rootPath: RstestContext['rootPath'];
+    runtimeConfig: RuntimeConfig;
+};
+
+declare type XInput = {
+    x_google_ignoreList?: SourceMapV3['ignoreList'];
+};
+
+export { }

package/globals.d.ts

@@ -0,0 +1,13 @@
+declare global {
+  const test: typeof import('@rstest/core')['test'];
+  const describe: typeof import('@rstest/core')['describe'];
+  const it: typeof import('@rstest/core')['it'];
+  const expect: typeof import('@rstest/core')['expect'];
+  const assert: typeof import('@rstest/core')['assert'];
+  const beforeAll: typeof import('@rstest/core')['beforeAll'];
+  const afterAll: typeof import('@rstest/core')['afterAll'];
+  const beforeEach: typeof import('@rstest/core')['beforeEach'];
+  const afterEach: typeof import('@rstest/core')['afterEach'];
+  const rstest: typeof import('@rstest/core')['rstest'];
+}
+export {};

package/importMeta.d.ts

@@ -0,0 +1,3 @@
+interface ImportMeta {
+  readonly rstest?: typeof import('@rstest/core');
+}