@rstest/core 0.7.9 → 0.8.1

package/dist/browser-runtime/index.d.ts

@@ -299,20 +299,14 @@ declare type BrowserModeConfig = {
      * Browser provider to use for running tests.
      *
      * Currently only 'playwright' is supported.
-     *
-     * @default 'playwright'
      */
-    provider?: 'playwright';
+    provider: 'playwright';
     /**
      * Which browser to use for testing.
      *
-     * - `chromium` - Google Chrome, Microsoft Edge
-     * - `firefox` - Mozilla Firefox
-     * - `webkit` - Safari
-     *
      * @default 'chromium'
      */
-    browser?: 'chromium' | 'firefox' | 'webkit';
+    browser?: BrowserName;
     /**
      * Run browser in headless mode.
      *
@@ -325,12 +319,28 @@ declare type BrowserModeConfig = {
      * If not specified, a random available port will be used.
      */
     port?: number;
+    /**
+     * Whether to exit if the specified port is already in use.
+     *
+     * @default false
+     */
+    strictPort?: boolean;
 };
 
+/**
+ * Supported browser types for browser mode testing.
+ *
+ * - `chromium` - Google Chrome, Microsoft Edge
+ * - `firefox` - Mozilla Firefox
+ * - `webkit` - Safari
+ */
+declare type BrowserName = 'chromium' | 'firefox' | 'webkit';
+
 declare type BuiltInReporterNames = keyof typeof reportersMap;
 
 declare type BuiltinReporterOptions = {
     default: DefaultReporterOptions;
+    verbose: VerboseReporterOptions;
 };
 
 declare type ChaiConfig = Partial<Omit<typeof config, 'useProxy' | 'proxyExcludedKeys' | 'deepEqual'>>;
@@ -339,6 +349,8 @@ declare interface CloverOptions extends FileOptions, ProjectOptions {}
 
 declare interface CoberturaOptions extends FileOptions, ProjectOptions {}
 
+declare type Constructor<T = any> = new (...args: any[]) => T;
+
 /**
  * Base class for writing content
  */
@@ -588,6 +600,12 @@ declare class DefaultReporter implements Reporter {
         options: DefaultReporterOptions;
         testState: RstestTestState;
     });
+    /**
+     * Lazily create StatusRenderer on first test file start.
+     * This avoids intercepting stdout/stderr before tests actually begin,
+     * ensuring early errors (like missing Playwright browsers) remain visible.
+     */
+    private ensureStatusRenderer;
     onTestFileStart(): void;
     onTestFileResult(test: TestFileResult): void;
     onTestCaseResult(): void;
@@ -615,6 +633,11 @@ declare type DefaultReporterOptions = {
      * @default process.stdout/process.stderr
      */
     logger?: Options['logger'];
+    /**
+     * prints out project name in test file title
+     * show project name by default when running multiple projects
+     */
+    showProjectName?: boolean;
 };
 
 export declare const describe: Rstest['describe'];
@@ -702,9 +725,9 @@ declare interface ExpectStatic_2 extends Chai.ExpectStatic, Matchers, Asymmetric
     	not: AsymmetricMatchersContaining;
 }
 
-declare type ExtendConfig = Omit<RstestConfig, 'projects'>;
+declare type ExtendConfig = Omit<LooseRstestConfig, 'projects'>;
 
-declare type ExtendConfigFn = (userConfig: Readonly<RstestConfig>) => MaybePromise<ExtendConfig>;
+declare type ExtendConfigFn = (userConfig: Readonly<LooseRstestConfig>) => MaybePromise<ExtendConfig>;
 
 /**
  * Names of clock methods that may be faked by install.
@@ -1362,6 +1385,10 @@ declare interface Location_3 {
     column: number;
 }
 
+declare type LooseRstestConfig = Omit<RstestConfig, 'reporters'> & {
+    reporters?: any;
+};
+
 declare function matcherHint(matcherName: string, received?: string, expected?: string, options?: MatcherHintOptions): string;
 
 declare interface MatcherHintOptions {
@@ -1412,8 +1439,18 @@ declare interface MatcherState_2 extends MatcherState {
     snapshotState: SnapshotState;
 }
 
+declare type MaybeMockedDeep<T> = T extends Constructor ? MockedClass<T> : T extends MockProcedure ? MockedFunctionDeep<T> : T extends object ? MockedObjectDeep<T> : T;
+
+declare type MaybePartiallyMocked<T> = T extends Constructor ? MockedClass<T> : T extends MockProcedure ? MockedFunction<T> : T extends object ? MockedObject<T> : T;
+
+declare type MaybePartiallyMockedDeep<T> = T extends Constructor ? MockedClass<T> : T extends MockProcedure ? MockedFunctionDeep<T> : T extends object ? MockedObjectDeep<T> : T;
+
 declare type MaybePromise<T> = T | Promise<T>;
 
+declare type Methods<T> = {
+    [K in keyof T]: T[K] extends MockProcedure ? K : never;
+}[keyof T];
+
 export declare interface Mock<T extends FunctionLike = FunctionLike> extends MockInstance_2<T> {
     new (...args: Parameters<T>): ReturnType<T>;
     (...args: Parameters<T>): ReturnType<T>;
@@ -1453,6 +1490,31 @@ declare type MockContext<T extends FunctionLike = FunctionLike> = {
     settledResults: MockSettledResult<Awaited<ReturnType<T>>>[];
 };
 
+export declare type Mocked<T> = T extends Constructor ? MockedClass<T> : T extends MockProcedure ? MockedFunction<T> : T extends object ? MockedObject<T> : T;
+
+declare type MockedClass<T extends Constructor> = Mock<(...args: ConstructorParameters<T>) => InstanceType<T>> & {
+    new (...args: ConstructorParameters<T>): InstanceType<T>;
+    prototype: InstanceType<T>;
+};
+
+declare type MockedFunction<T extends MockProcedure> = Mock<T> & {
+    [K in keyof T]: T[K];
+};
+
+declare type MockedFunctionDeep<T extends MockProcedure> = Mock<T> & MockedObjectDeep<T>;
+
+declare type MockedObject<T> = {
+    [K in Methods<T>]: T[K] extends MockProcedure ? MockedFunction<T[K]> : T[K];
+} & {
+    [K in Properties<T>]: T[K];
+};
+
+declare type MockedObjectDeep<T> = {
+    [K in Methods<T>]: T[K] extends MockProcedure ? MockedFunctionDeep<T[K]> : T[K];
+} & {
+    [K in Properties<T>]: MaybeMockedDeep<T[K]>;
+};
+
 declare type MockFactory<T = unknown> = () => MaybePromise<Partial<T>>;
 
 declare type MockFn = <T extends FunctionLike = FunctionLike>(fn?: T) => Mock<T>;
@@ -1526,6 +1588,37 @@ declare interface MockInstance_2<T extends FunctionLike = FunctionLike> {
     mockRejectedValueOnce(error: unknown): this;
 }
 
+/**
+ * Options for rs.mock module mocking.
+ * Supports `{ spy: true }` or `{ mock: true }`.
+ */
+declare type MockModuleOptions = {
+    /**
+     * If `true`, the module will be auto-mocked but the original implementations
+     * will be preserved - all exports will be wrapped in spy functions that track calls.
+     */
+    spy: true;
+} | {
+    /**
+     * If `true`, the module will be auto-mocked with all exports replaced by mock functions.
+     * Original implementations will NOT be preserved.
+     */
+    mock: true;
+};
+
+/**
+ * Options for mockObject
+ */
+declare interface MockOptions {
+    /**
+     * If `true`, the original implementation will be kept.
+     * All methods will call the original implementation, but you can still track the calls.
+     */
+    spy?: boolean;
+}
+
+declare type MockProcedure = (...args: any[]) => any;
+
 declare type MockResult<T> = MockResultReturn<T> | MockResultThrow | MockResultIncomplete;
 
 declare interface MockResultIncomplete {
@@ -1571,9 +1664,10 @@ declare interface Node_2 {
 declare type NormalizedBrowserModeConfig = {
     enabled: boolean;
     provider: 'playwright';
-    browser: 'chromium' | 'firefox' | 'webkit';
+    browser: BrowserName;
     headless: boolean;
     port?: number;
+    strictPort: boolean;
 };
 
 declare type NormalizedConfig = Required<Omit<RstestConfig, OptionalKeys | 'pool' | 'projects' | 'coverage' | 'setupFiles' | 'globalSetup' | 'exclude' | 'testEnvironment' | 'browser'>> & Partial<Pick<RstestConfig, OptionalKeys>> & {
@@ -1618,7 +1712,7 @@ export declare const onTestFinished: Rstest['onTestFinished'];
 
 declare type OnTestFinishedHandler = (ctx: TestContext) => MaybePromise<void>;
 
-declare type OptionalKeys = 'testNamePattern' | 'plugins' | 'source' | 'resolve' | 'output' | 'performance' | 'tools' | 'dev' | 'onConsoleLog' | 'chaiConfig' | 'resolveSnapshotPath' | 'extends';
+declare type OptionalKeys = 'testNamePattern' | 'plugins' | 'source' | 'resolve' | 'output' | 'performance' | 'tools' | 'dev' | 'onConsoleLog' | 'chaiConfig' | 'hideSkippedTestFiles' | 'resolveSnapshotPath' | 'extends';
 
 declare interface Options {
     logger: {
@@ -1645,7 +1739,7 @@ declare function printWithType<T>(name: string, value: T, print: (value: T) => s
 
 declare type Procedure = (...args: any[]) => any;
 
-declare type ProjectConfig = Omit<RstestConfig, 'projects' | 'reporters' | 'pool' | 'isolate' | 'coverage' | 'resolveSnapshotPath' | 'onConsoleLog' | 'hideSkippedTests' | 'bail'>;
+declare type ProjectConfig = Omit<RstestConfig, 'projects' | 'reporters' | 'pool' | 'isolate' | 'coverage' | 'resolveSnapshotPath' | 'onConsoleLog' | 'hideSkippedTests' | 'hideSkippedTestFiles' | 'bail'>;
 
 declare type ProjectContext = {
     name: string;
@@ -1673,6 +1767,10 @@ declare type PromisifyAssertion<T> = Promisify<Assertion_2<T>>;
 
 declare type PromisifyAssertion_2<T> = Promisify_2<Assertion<T>>;
 
+declare type Properties<T> = {
+    [K in keyof T]: T[K] extends MockProcedure ? never : K;
+}[keyof T];
+
 declare interface Range_2 {
     start: Location_3;
     end: Location_3;
@@ -1930,6 +2028,12 @@ declare interface RstestConfig {
      * @default false
      */
     hideSkippedTests?: boolean;
+    /**
+     * Hide skipped test files logs.
+     *
+     * @default false
+     */
+    hideSkippedTestFiles?: boolean;
     /**
      * Run only tests with a name that matches the regex.
      */
@@ -2092,6 +2196,74 @@ declare interface RstestUtilities {
      * Determines if the given function is a mocked function.
      */
     isMockFunction: (fn: any) => fn is MockInstance_2;
+    /**
+     * Deeply mocks properties and methods of a given object
+     * in the same way as `rstest.mock()` mocks module exports.
+     *
+     * @example
+     * ```ts
+     * const original = {
+     *   simple: () => 'value',
+     *   nested: {
+     *     method: () => 'real'
+     *   },
+     *   prop: 'foo',
+     * }
+     *
+     * const mocked = rstest.mockObject(original)
+     * expect(mocked.simple()).toBe(undefined)
+     * expect(mocked.nested.method()).toBe(undefined)
+     * expect(mocked.prop).toBe('foo')
+     *
+     * mocked.simple.mockReturnValue('mocked')
+     * expect(mocked.simple()).toBe('mocked')
+     *
+     * // With spy option to keep original implementations
+     * const spied = rstest.mockObject(original, { spy: true })
+     * expect(spied.simple()).toBe('value')
+     * expect(spied.simple).toHaveBeenCalled()
+     * ```
+     *
+     * @param value - The object to be mocked
+     * @param options - Mock options
+     * @returns A deeply mocked version of the input object
+     */
+    mockObject: <T>(value: T, options?: MockOptions) => MaybeMockedDeep<T>;
+    /**
+     * Type helper for TypeScript. Just returns the object that was passed.
+     *
+     * When `partial` is `true` it will expect a `Partial<T>` as a return value.
+     * By default, this will only make TypeScript believe that the first level values are mocked.
+     * You can pass down `{ deep: true }` as a second argument to tell TypeScript
+     * that the whole object is mocked, if it actually is.
+     *
+     * @example
+     * ```ts
+     * import example from './example.js'
+     *
+     * rstest.mock('./example.js')
+     *
+     * test('1 + 1 equals 10', async () => {
+     *   rstest.mocked(example.calc).mockReturnValue(10)
+     *   expect(example.calc(1, '+', 1)).toBe(10)
+     * })
+     * ```
+     * @param item - Anything that can be mocked
+     * @returns The same item with mocked type
+     */
+    mocked: (<T>(item: T, deep?: false) => Mocked<T>) & (<T>(item: T, deep: true) => MaybeMockedDeep<T>) & (<T>(item: T, options: {
+        partial?: false;
+        deep?: false;
+    }) => Mocked<T>) & (<T>(item: T, options: {
+        partial?: false;
+        deep: true;
+    }) => MaybeMockedDeep<T>) & (<T>(item: T, options: {
+        partial: true;
+        deep?: false;
+    }) => MaybePartiallyMocked<T>) & (<T>(item: T, options: {
+        partial: true;
+        deep: true;
+    }) => MaybePartiallyMockedDeep<T>);
     /**
      * Calls `.mockClear()` on all spies.
      */
@@ -2105,21 +2277,37 @@ declare interface RstestUtilities {
      */
     restoreAllMocks: () => RstestUtilities;
     /**
-     * Mock a module
+     * Mock a module.
+     *
+     * When called with a factory function, the module will be replaced with the return value of the factory.
+     * When called with `{ spy: true }`, the module will be auto-mocked but the original implementations
+     * will be preserved - all exports will be wrapped in spy functions that track calls.
+     *
+     * @example
+     * ```ts
+     * // Replace module with factory
+     * rs.mock('./module', () => ({ fn: rs.fn() }))
+     *
+     * // Auto-mock with spy mode - keeps original implementations
+     * rs.mock('./module', { spy: true })
+     * ```
      */
-    mock<T = unknown>(moduleName: string | Promise<T>, moduleFactory?: MockFactory<T>): void;
+    mock<T = unknown>(moduleName: string | Promise<T>, factoryOrOptions?: MockFactory<T> | MockModuleOptions): void;
     /**
-     * Mock a module
+     * Mock a module (CommonJS require)
      */
-    mockRequire: <T = unknown>(moduleName: string, moduleFactory?: () => T) => void;
+    mockRequire: <T = unknown>(moduleName: string, factoryOrOptions?: (() => T) | MockModuleOptions) => void;
     /**
      * Mock a module, not hoisted.
+     *
+     * When called with `{ spy: true }`, the module will be auto-mocked but the original implementations
+     * will be preserved - all exports will be wrapped in spy functions that track calls.
      */
-    doMock<T = unknown>(moduleName: string | Promise<T>, moduleFactory?: MockFactory<T>): void;
+    doMock<T = unknown>(moduleName: string | Promise<T>, factoryOrOptions?: MockFactory<T> | MockModuleOptions): void;
     /**
-     * Mock a module, not hoisted.
+     * Mock a module, not hoisted (CommonJS require).
      */
-    doMockRequire: <T = unknown>(moduleName: string, moduleFactory?: () => T) => void;
+    doMockRequire: <T = unknown>(moduleName: string, factoryOrOptions?: (() => T) | MockModuleOptions) => void;
     /**
      * Hoisted mock function.
      */
@@ -2731,9 +2919,18 @@ declare interface UserConsoleLog {
 }
 
 declare class VerboseReporter extends DefaultReporter {
+    private verboseOptions;
+    constructor({ rootPath, options, config, testState, }: {
+        rootPath: string;
+        config: NormalizedConfig;
+        options: VerboseReporterOptions;
+        testState: RstestTestState;
+    });
     onTestFileResult(test: TestFileResult): void;
 }
 
+declare type VerboseReporterOptions = Omit<DefaultReporterOptions, 'summary'>;
+
 declare interface Visitor<N extends Node_2 = Node_2> {
     onStart(root: N, state: any): void;
     onSummary(root: N, state: any): void;