strong-mock 8.0.1 → 9.0.0-beta.1

package/dist/return/returns.d.ts

@@ -1,87 +1,61 @@
-import type { ExpectationRepository } from '../expectation/repository/expectation-repository';
-import type { PendingExpectation } from '../when/pending-expectation';
-import type { InvocationCount } from './invocation-count';
-export type PromiseStub<R, P> = {
-    /**
-     * Set the return value for the current call.
-     *
-     * @param value This needs to be of the same type as the value returned
-     *   by the call inside `when`.
-     *
-     * @example
-     * when(() => fn()).thenReturn(Promise.resolve(23));
-     *
-     * @example
-     * when(() => fn()).thenReturn(Promise.reject({ foo: 'bar' });
-     */
-    thenReturn(value: P): InvocationCount;
-    /**
-     * Set the return value for the current call.
-     *
-     * @param promiseValue This needs to be of the same type as the value inside
-     *   the promise returned by the `when` callback.
-     *
-     * @example
-     * when(() => fn()).thenResolve('foo');
-     */
-    thenResolve(promiseValue: R): InvocationCount;
-    /**
-     * Make the current call reject with the given error.
-     *
-     * @param error An `Error` instance. You can pass just a message, and
-     *   it will be wrapped in an `Error` instance. If you want to reject with
-     *   a non error then use the {@link thenReturn} method.
-     *
-     * @example
-     * when(() => fn()).thenReject(new Error('oops'));
-     */
-    thenReject(error: Error): InvocationCount;
-    /**
-     * Make the current call reject with an error with the given message.
-     *
-     * @param message Will be wrapped in `new Error()`. If you want to reject
-     *   with a custom error then pass it here instead of the message. If you
-     *   want to reject with a non error then use `thenReturn`.
-     *
-     * @example
-     * when(() => fn()).thenReject('oops');
-     */
-    thenReject(message: string): InvocationCount;
-    /**
-     * Make the current call reject with `new Error()`.
-     */
-    thenReject(): InvocationCount;
-};
-export type NonPromiseStub<R> = {
-    /**
-     * Set the return value for the current call.
-     *
-     * @param returnValue This needs to be of the same type as the value returned
-     *   by the `when` callback.
-     */
-    thenReturn(returnValue: R): InvocationCount;
-    /**
-     * Make the current call throw the given error.
-     *
-     * @param error The error instance. If you want to throw a simple `Error`
-     *   you can pass just the message.
-     */
-    thenThrow(error: Error): InvocationCount;
-    /**
-     * Make the current call throw an error with the given message.
-     *
-     * @param message Will be wrapped in `new Error()`. If you want to throw
-     *   a custom error pass it here instead of the message.
-     */
-    thenThrow(message: string): InvocationCount;
-    /**
-     * Make the current call throw `new Error()`.
-     */
-    thenThrow(): InvocationCount;
-};
-export declare const createReturns: (pendingExpectation: PendingExpectation, repository: ExpectationRepository) => {
-    thenReturn: (returnValue: any) => InvocationCount;
-    thenThrow: (errorOrMessage?: Error | string) => InvocationCount;
-    thenResolve: (promiseValue: any) => InvocationCount;
-    thenReject: (errorOrMessage?: Error | string) => InvocationCount;
-};
+import type { ExpectationRepository } from '../expectation/repository/expectation-repository';
+import type { ExpectationBuilder } from '../when/expectation-builder';
+import type { InvocationCount } from './invocation-count';
+export type PromiseStub<R, P> = {
+    /**
+     * Set the return value for the current call.
+     *
+     * @param value This needs to be of the same type as the value returned
+     *   by the call inside `when`.
+     *
+     * @example
+     * when(() => fn()).thenReturn(Promise.resolve(23));
+     *
+     * @example
+     * when(() => fn()).thenReturn(Promise.reject({ foo: 'bar' });
+     */
+    thenReturn: (value: P) => InvocationCount;
+    /**
+     * Set the return value for the current call.
+     *
+     * @param promiseValue This needs to be of the same type as the value inside
+     *   the promise returned by the `when` callback.
+     *
+     * @example
+     * when(() => fn()).thenResolve('foo');
+     */
+    thenResolve: (promiseValue: R) => InvocationCount;
+    /**
+     * Make the current call reject with the given error.
+     *
+     * @param error An `Error` instance. You can pass just a message, and
+     *   it will be wrapped in an `Error` instance. If you want to reject with
+     *   a non error then use the {@link thenReturn} method.
+     *
+     * @example
+     * when(() => fn()).thenReject(new Error('oops'));
+     */
+    thenReject: ((error: Error) => InvocationCount) & ((message: string) => InvocationCount) & (() => InvocationCount);
+};
+export type NonPromiseStub<R> = {
+    /**
+     * Set the return value for the current call.
+     *
+     * @param returnValue This needs to be of the same type as the value returned
+     *   by the `when` callback.
+     */
+    thenReturn: (returnValue: R) => InvocationCount;
+    /**
+     * Make the current call throw the given error.
+     *
+     * @param error The error instance. If you want to throw a simple `Error`
+     *   you can pass just the message.
+     */
+    thenThrow: ((error: Error) => InvocationCount) & ((message: string) => InvocationCount) & (() => InvocationCount);
+};
+export declare const createReturns: (builder: ExpectationBuilder, repository: ExpectationRepository) => {
+    thenReturn: (returnValue: any) => InvocationCount;
+    thenThrow: (errorOrMessage?: Error | string) => InvocationCount;
+    thenResolve: (promiseValue: any) => InvocationCount;
+    thenReject: (errorOrMessage?: Error | string) => InvocationCount;
+};

package/dist/verify/reset.d.ts

@@ -1,20 +1,20 @@
-import type { Mock } from '../mock/mock';
-/**
- * Remove any remaining expectations on the given mock.
- *
- * @example
- * const fn = mock<() => number>();
- *
- * when(() => fn()).thenReturn(23);
- *
- * reset(fn);
- *
- * fn(); // throws
- */
-export declare const reset: (mock: Mock<any>) => void;
-/**
- * Reset all existing mocks.
- *
- * @see reset
- */
-export declare const resetAll: () => void;
+import type { Mock } from '../mock/mock';
+/**
+ * Remove any remaining expectations on the given mock.
+ *
+ * @example
+ * const fn = mock<() => number>();
+ *
+ * when(() => fn()).thenReturn(23);
+ *
+ * reset(fn);
+ *
+ * fn(); // throws
+ */
+export declare const reset: (mock: Mock<any>) => void;
+/**
+ * Reset all existing mocks.
+ *
+ * @see reset
+ */
+export declare const resetAll: () => void;

package/dist/verify/verify.d.ts

@@ -1,27 +1,27 @@
-import type { ExpectationRepository } from '../expectation/repository/expectation-repository';
-import type { Mock } from '../mock/mock';
-export declare const verifyRepo: (repository: ExpectationRepository) => void;
-/**
- * Verify that all expectations on the given mock have been met.
- *
- * @throws Will throw if there are remaining expectations that were set
- * using `when` and that weren't met.
- *
- * @throws Will throw if any unexpected calls happened. Normally those
- * calls throw on their own, but the error might be caught by the code
- * being tested.
- *
- * @example
- * const fn = mock<() => number>();
- *
- * when(() => fn()).thenReturn(23);
- *
- * verify(fn); // throws
- */
-export declare const verify: <T>(mock: T) => void;
-/**
- * Verify all existing mocks.
- *
- * @see verify
- */
-export declare const verifyAll: () => void;
+import type { ExpectationRepository } from '../expectation/repository/expectation-repository';
+import type { Mock } from '../mock/mock';
+export declare const verifyRepo: (repository: ExpectationRepository) => void;
+/**
+ * Verify that all expectations on the given mock have been met.
+ *
+ * @throws Will throw if there are remaining expectations that were set
+ * using `when` and that weren't met.
+ *
+ * @throws Will throw if any unexpected calls happened. Normally those
+ * calls throw on their own, but the error might be caught by the code
+ * being tested.
+ *
+ * @example
+ * const fn = mock<() => number>();
+ *
+ * when(() => fn()).thenReturn(23);
+ *
+ * verify(fn); // throws
+ */
+export declare const verify: <T>(mock: Mock<T>) => void;
+/**
+ * Verify all existing mocks.
+ *
+ * @see verify
+ */
+export declare const verifyAll: () => void;

package/dist/when/{pending-expectation.d.ts → expectation-builder.d.ts}

@@ -1,31 +1,26 @@
-import type { Expectation } from '../expectation/expectation';
-import type { ReturnValue } from '../expectation/repository/return-value';
-import type { ConcreteMatcher } from '../mock/options';
-import type { Property } from '../proxy';
-/**
- * An expectation has to be built incrementally, starting first with the property
- * being accessed inside {@link createStub}, then any arguments passed to it, and ending
- * it with the returned value from {@link createReturns}.
- */
-export interface PendingExpectation {
-    setProperty(prop: Property): void;
-    setArgs(args: any[] | undefined): void;
-    finish(returnValue: ReturnValue): Expectation;
-    /**
-     * Used by `pretty-format`.
-     */
-    toJSON(): string;
-}
-export type ExpectationFactory = (property: Property, args: any[] | undefined, returnValue: ReturnValue, concreteMatcher: ConcreteMatcher, exactParams: boolean) => Expectation;
-export declare class PendingExpectationWithFactory implements PendingExpectation {
-    private createExpectation;
-    private concreteMatcher;
-    private exactParams;
-    private args;
-    private property;
-    constructor(createExpectation: ExpectationFactory, concreteMatcher: ConcreteMatcher, exactParams: boolean);
-    setProperty(value: Property): void;
-    setArgs(value: any[] | undefined): void;
-    finish(returnValue: ReturnValue): Expectation;
-    toJSON(): string;
-}
+import type { Expectation } from '../expectation/expectation';
+import type { ReturnValue } from '../expectation/repository/return-value';
+import type { ConcreteMatcher } from '../mock/options';
+import type { Property } from '../proxy';
+/**
+ * An expectation has to be built incrementally, starting first with the property
+ * being accessed inside {@link createStub}, then any arguments passed to it, and ending
+ * it with the returned value from {@link createReturns}.
+ */
+export interface ExpectationBuilder {
+    setProperty: (prop: Property) => void;
+    setArgs: (args: unknown[] | undefined) => void;
+    finish: (returnValue: ReturnValue) => Expectation;
+}
+export type ExpectationFactory = (property: Property, args: any[] | undefined, returnValue: ReturnValue, concreteMatcher: ConcreteMatcher, exactParams: boolean) => Expectation;
+export declare class ExpectationBuilderWithFactory implements ExpectationBuilder {
+    private createExpectation;
+    private concreteMatcher;
+    private exactParams;
+    private args;
+    private property;
+    constructor(createExpectation: ExpectationFactory, concreteMatcher: ConcreteMatcher, exactParams: boolean);
+    setProperty(value: Property): void;
+    setArgs(value: unknown[] | undefined): void;
+    finish(returnValue: ReturnValue): Expectation;
+}

package/dist/when/when.d.ts

@@ -1,32 +1,32 @@
-import type { NonPromiseStub, PromiseStub } from '../return/returns';
-interface When {
-    <R>(expectation: () => Promise<R>): PromiseStub<R, Promise<R>>;
-    <R>(expectation: () => R): NonPromiseStub<R>;
-}
-/**
- * Set an expectation on a mock.
- *
- * The expectation must be finished by setting a return value, even if the value
- * is `undefined`.
- *
- * If a call happens that was not expected then the mock will throw an error.
- * By default, the call is expected to only be made once. Use the invocation
- * count helpers to expect a call multiple times.
- *
- * @param expectation A callback to set the expectation on your mock. The
- *   callback must return the value from the mock to properly infer types.
- *
- * @example
- * const fn = mock<() => void>();
- * when(() => fn()).thenReturn(undefined);
- *
- * @example
- * const fn = mock<() => number>();
- * when(() => fn()).thenReturn(42).atMost(3);
- *
- * @example
- * const fn = mock<(x: number) => Promise<number>();
- * when(() => fn(23)).thenResolve(42);
- */
-export declare const when: When;
-export {};
+import type { NonPromiseStub, PromiseStub } from '../return/returns';
+interface When {
+    <R>(expectation: () => Promise<R>): PromiseStub<R, Promise<R>>;
+    <R>(expectation: () => R): NonPromiseStub<R>;
+}
+/**
+ * Set an expectation on a mock.
+ *
+ * The expectation must be finished by setting a return value, even if the value
+ * is `undefined`.
+ *
+ * If a call happens that was not expected then the mock will throw an error.
+ * By default, the call is expected to only be made once. Use the invocation
+ * count helpers to expect a call multiple times.
+ *
+ * @param expectation A callback to set the expectation on your mock. The
+ *   callback must return the value from the mock to properly infer types.
+ *
+ * @example
+ * const fn = mock<() => void>();
+ * when(() => fn()).thenReturn(undefined);
+ *
+ * @example
+ * const fn = mock<() => number>();
+ * when(() => fn()).thenReturn(42).atMost(3);
+ *
+ * @example
+ * const fn = mock<(x: number) => Promise<number>();
+ * when(() => fn(23)).thenResolve(42);
+ */
+export declare const when: When;
+export {};

package/package.json

@@ -1,13 +1,16 @@
 {
   "name": "strong-mock",
-  "version": "8.0.1",
-  "description": "Simple type safe mocking library",
+  "version": "9.0.0-beta.1",
+  "description": "Type safe mocking library for TypeScript",
   "keywords": [
     "tdd",
+    "test",
     "mock",
+    "expectation",
+    "stub",
     "interface",
-    "typescript",
-    "test"
+    "type",
+    "typescript"
   ],
   "repository": {
     "type": "git",
@@ -21,25 +24,26 @@
     "dist"
   ],
   "dependencies": {
-    "jest-matcher-utils": "~29.3.0",
-    "lodash": "~4.17.0"
+    "jest-diff": "~29.4.3",
+    "jest-matcher-utils": "~29.7.0",
+    "lodash": "~4.17.0",
+    "strip-ansi": "~6.0.0"
   },
   "devDependencies": {
-    "@nighttrax/eslint-config-ts": "~11.0.0",
-    "@tdd-buffet/jest-config": "~5.0.1",
-    "@tdd-buffet/tsconfig": "~1.0.0",
-    "@types/jest": "~29.2.0",
-    "@types/node": "~18.11.0",
-    "@types/lodash": "~4.14.0",
+    "@nighttrax/eslint-config-ts": "~12.0.0-alpha.0",
+    "@tdd-buffet/jest-config": "~6.0.0",
+    "@tdd-buffet/tsconfig": "~1.0.5",
+    "@types/jest": "~29.5.0",
+    "@types/node": "~20.12.0",
+    "@types/lodash": "~4.17.0",
     "doctoc": "~2.2.0",
-    "eslint": "~8.32.0",
-    "jest": "~29.3.0",
+    "eslint": "~8.57.0",
+    "jest": "~29.7.0",
     "microbundle": "~0.15.0",
     "standard-version": "~9.5.0",
-    "strip-ansi": "~6.0.0",
     "strong-mock": "~6.0.0",
-    "tslib": "~2.4.0",
-    "typescript": "~4.9.0"
+    "tslib": "~2.6.0",
+    "typescript": "~5.4.0"
   },
   "scripts": {
     "docs": "doctoc --title '**Table of Contents**' README.md",

package/dist/errors.d.ts

@@ -1,28 +0,0 @@
-import type { Expectation } from './expectation/expectation';
-import type { CallMap } from './expectation/repository/expectation-repository';
-import type { Property } from './proxy';
-import type { PendingExpectation } from './when/pending-expectation';
-export declare class UnfinishedExpectation extends Error {
-    constructor(pendingExpectation: PendingExpectation);
-}
-export declare class MissingWhen extends Error {
-    constructor();
-}
-export declare class UnexpectedAccess extends Error {
-    constructor(property: Property, expectations: Expectation[]);
-}
-export declare class UnexpectedCall extends Error {
-    constructor(property: Property, args: any[], expectations: Expectation[]);
-}
-export declare class NotAMock extends Error {
-    constructor();
-}
-export declare class UnmetExpectations extends Error {
-    constructor(expectations: Expectation[]);
-}
-export declare class UnexpectedCalls extends Error {
-    constructor(unexpectedCalls: CallMap, expectations: Expectation[]);
-}
-export declare class NestedWhen extends Error {
-    constructor(parentProp: Property, childProp: Property);
-}

package/dist/expectation/it.d.ts

@@ -1,29 +0,0 @@
-import type { Matcher, TypeMatcher } from './matcher';
-type DeepPartial<T> = T extends object ? {
-    [K in keyof T]?: DeepPartial<T[K]>;
-} : T;
-/**
- * Contains argument matchers that can be used to ignore arguments in an
- * expectation or to match complex arguments.
- */
-export declare const It: {
-    matches: <T>(cb: (actual: T) => boolean, { toJSON }?: {
-        toJSON?: (() => string) | undefined;
-    }) => TypeMatcher<T>;
-    deepEquals: <T_1>(expected: T_1, { strict }?: {
-        strict?: boolean | undefined;
-    }) => TypeMatcher<T_1>;
-    is: <T_2 = unknown>(expected: T_2) => TypeMatcher<T_2>;
-    isAny: () => TypeMatcher<any>;
-    isObject: <T_3 extends object, K extends DeepPartial<T_3>>(partial?: K | undefined) => TypeMatcher<T_3>;
-    isNumber: () => TypeMatcher<number>;
-    isString: ({ matching, containing, }?: {
-        matching?: RegExp | undefined;
-        containing?: string | undefined;
-    }) => TypeMatcher<string>;
-    isArray: <T_4 extends any[]>(containing?: T_4 | undefined) => TypeMatcher<T_4>;
-    willCapture: <T_5 = unknown>(name?: string) => T_5 & Matcher & {
-        value: T_5 | undefined;
-    };
-};
-export {};

package/dist/expectation/matcher.d.ts

@@ -1,21 +0,0 @@
-export declare const MATCHER_SYMBOL: unique symbol;
-export type Matcher = {
-    /**
-     * Will be called with a value to match against.
-     */
-    matches: (arg: any) => boolean;
-    [MATCHER_SYMBOL]: boolean;
-    /**
-     * Used by `pretty-format`.
-     */
-    toJSON(): string;
-};
-/**
- * This takes the shape of T to satisfy call sites, but strong-mock will only
- * care about the matcher type.
- */
-export type TypeMatcher<T> = T & Matcher;
-/**
- * Used to test if an expectation on an argument is a custom matcher.
- */
-export declare function isMatcher(f: unknown): f is Matcher;