strong-mock 9.0.1 → 9.2.0

package/dist/matchers/deep-equals.d.ts

@@ -1,16 +0,0 @@
-import type { TypeMatcher } from './matcher';
-/**
- * Compare values using deep equality.
- *
- * @param expected
- * @param strict By default, this matcher will treat a missing key in an object
- *   and a key with the value `undefined` as not equal. It will also consider
- *   non `Object` instances with different constructors as not equal. Setting
- *   this to `false` will consider the objects in both cases as equal.
- *
- * @see {@link It.containsObject} or {@link It.isArray} if you want to nest matchers.
- * @see {@link It.is} if you want to use strict equality.
- */
-export declare const deepEquals: <T>(expected: T, { strict, }?: {
-    strict?: boolean;
-}) => TypeMatcher<T>;

package/dist/matchers/is-any.d.ts

@@ -1,11 +0,0 @@
-import type { TypeMatcher } from './matcher';
-/**
- * Match any value, including `undefined` and `null`.
- *
- * @example
- * const fn = mock<(x: number, y: string) => number>();
- * when(() => fn(It.isAny(), It.isAny())).thenReturn(1);
- *
- * fn(23, 'foobar') === 1
- */
-export declare const isAny: () => TypeMatcher<any>;

package/dist/matchers/is-array.d.ts

@@ -1,22 +0,0 @@
-import type { TypeMatcher } from './matcher';
-/**
- * Match an array.
- *
- * Supports nested matchers.
- *
- * @param containing If given, the matched array has to contain ALL of these
- *   elements in ANY order.
- *
- * @example
- * const fn = mock<(arr: number[]) => number>();
- * when(() => fn(It.isArray())).thenReturn(1);
- * when(() => fn(It.isArray([2, 3]))).thenReturn(2);
- *
- * fn({ length: 1, 0: 42 }) // throws
- * fn([]) === 1
- * fn([3, 2, 1]) === 2
- *
- * @example
- * It.isArray([It.isString({ containing: 'foobar' })])
- */
-export declare const isArray: <T extends unknown[]>(containing?: T) => TypeMatcher<T>;

package/dist/matchers/is-number.d.ts

@@ -1,12 +0,0 @@
-import type { TypeMatcher } from './matcher';
-/**
- * Match any number.
- *
- * @example
- * const fn = mock<(x: number) => number>();
- * when(() => fn(It.isNumber())).returns(42);
- *
- * fn(20.5) === 42
- * fn(NaN) // throws
- */
-export declare const isNumber: () => TypeMatcher<number>;

package/dist/matchers/is-plain-object.d.ts

@@ -1,17 +0,0 @@
-import type { Property } from '../proxy';
-import type { TypeMatcher } from './matcher';
-type ObjectType = Record<Property, unknown>;
-/**
- * Matches any plain object e.g. object literals or objects created with `Object.create()`.
- *
- * Classes, arrays, maps, sets etc. are not considered plain objects.
- * You can use {@link containsObject} or {@link matches} to match those.
- *
- * @example
- * const fn = mock<({ foo: string }) => number>();
- * when(() => fn(It.isPlainObject())).thenReturn(42);
- *
- * fn({ foo: 'bar' }) // returns 42
- */
-export declare const isPlainObject: <T extends ObjectType>() => TypeMatcher<T>;
-export {};

package/dist/matchers/is-string.d.ts

@@ -1,15 +0,0 @@
-import type { TypeMatcher } from './matcher';
-/**
- * Match any string.
- *
- * @param matching An optional string or RegExp to match the string against.
- *   If it's a string, a case-sensitive search will be performed.
- *
- * @example
- * const fn = mock<(x: string, y: string) => number>();
- * when(() => fn(It.isString(), It.isString('bar'))).returns(42);
- *
- * fn('foo', 'baz') // throws
- * fn('foo', 'bar') === 42
- */
-export declare const isString: (matching?: string | RegExp) => TypeMatcher<string>;

package/dist/matchers/is.d.ts

@@ -1,9 +0,0 @@
-import type { TypeMatcher } from './matcher';
-/**
- * Compare values using `Object.is`.
- *
- * @link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
- *
- * @see It.deepEquals A matcher that uses deep equality.
- */
-export declare const is: <T = unknown>(expected: T) => TypeMatcher<T>;

package/dist/matchers/it.d.ts

@@ -1,10 +0,0 @@
-export { deepEquals } from './deep-equals';
-export { is } from './is';
-export { isAny } from './is-any';
-export { isArray } from './is-array';
-export { isNumber } from './is-number';
-export { isPlainObject } from './is-plain-object';
-export { containsObject } from './contains-object';
-export { isString } from './is-string';
-export { matches } from './matcher';
-export { willCapture } from './will-capture';

package/dist/matchers/matcher.d.ts

@@ -1,93 +0,0 @@
-export declare const MATCHER_SYMBOL: unique symbol;
-export type MatcherDiffer = (actual: any) => {
-    actual: any;
-    expected: any;
-};
-export type MatcherOptions = {
-    /**
-     * Will be called when printing the diff between an expectation and the
-     * (mismatching) received arguments.
-     *
-     * With this function you can pretty print the `actual` and `expected` values
-     * according to your matcher's logic.
-     *
-     * @param actual The actual value received by this matcher, same as the one
-     *   in `matches`.
-     *
-     * @example
-     * const neverMatcher = It.matches(() => false, {
-     *   getDiff: (actual) => ({ actual, expected: 'never' })
-     * });
-     *
-     * when(() => fn(neverMatcher)).thenReturn(42);
-     *
-     * fn(42);
-     * // - Expected
-     * // + Received
-     * //
-     * //   - 'never'
-     * //   + 42
-     */
-    getDiff: MatcherDiffer;
-    /**
-     * Will be called when printing arguments for an unexpected or unmet expectation.
-     *
-     * @example
-     * const neverMatcher = It.matches(() => false, {
-     *   toString: () => 'never'
-     * });
-     * when(() => fn(neverMatcher)).thenReturn(42);
-     *
-     * fn(42);
-     * // Unmet expectations:
-     * // when(() => fn(never)).thenReturn(42)
-     */
-    toString: () => string;
-};
-/**
- * You MUST use {@link It.matches} to create this branded type.
- */
-export interface Matcher extends MatcherOptions {
-    [MATCHER_SYMBOL]: boolean;
-    /**
-     * Will be called with the received value and should return whether it matches
-     * the expectation.
-     */
-    matches: (actual: any) => boolean;
-}
-/**
- * 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 is an argument is a custom matcher.
- */
-export declare function isMatcher(f: unknown): f is Matcher;
-export declare const getMatcherDiffs: (matchers: Matcher[], args: unknown[]) => {
-    actual: unknown[];
-    expected: unknown[];
-};
-/**
- * Create a custom matcher.
- *
- * @param predicate Will receive the actual value and return whether it matches the expectation.
- * @param options
- * @param options.toString An optional function that should return a string that will be
- *   used when the matcher needs to be printed in an error message. By default,
- *   it stringifies `predicate`.
- * @param options.getDiff An optional function that will be called when printing the
- *   diff for a failed expectation. It will only be called if there's a mismatch
- *   between the expected and received values i.e. `predicate(actual)` fails.
- *   By default, the `toString` method will be used to format the expected value,
- *   while the received value will be returned as-is.
- *
- * @example
- * // Create a matcher for positive numbers.
- * const fn = mock<(x: number) => number>();
- * when(() => fn(It.matches(x => x >= 0))).thenReturn(42);
- *
- * fn(2) === 42
- * fn(-1) // throws
- */
-export declare const matches: <T>(predicate: (actual: T) => boolean, options?: Partial<MatcherOptions>) => TypeMatcher<T>;

package/dist/matchers/will-capture.d.ts

@@ -1,21 +0,0 @@
-import type { TypeMatcher } from './matcher';
-/**
- * Matches anything and stores the received value.
- *
- * This should not be needed for most cases, but can be useful if you need
- * access to a complex argument outside the expectation e.g. to test a
- * callback.
- *
- * @param name If given, this name will be printed in error messages.
- *
- * @example
- * const fn = mock<(cb: (value: number) => number) => void>();
- * const matcher = It.willCapture();
- * when(() => fn(matcher)).thenReturn();
- *
- * fn(x => x + 1);
- * matcher.value?.(3) === 4
- */
-export declare const willCapture: <T = unknown>(name?: string) => TypeMatcher<T> & {
-    value: T | undefined;
-};

package/dist/mock/defaults.d.ts

@@ -1,11 +0,0 @@
-import type { MockOptions } from './options';
-export type StrongMockDefaults = Required<MockOptions>;
-export declare let currentDefaults: StrongMockDefaults;
-/**
- * Override strong-mock's defaults.
- *
- * @param newDefaults These will be applied to the library defaults. Multiple
- *   calls don't stack e.g. calling this with `{}` will clear any previously
- *   applied defaults.
- */
-export declare const setDefaults: (newDefaults: MockOptions) => void;

package/dist/mock/map.d.ts

@@ -1,16 +0,0 @@
-import type { ExpectationRepository } from '../expectation/repository/expectation-repository';
-import type { ExpectationBuilder } from '../when/expectation-builder';
-import type { StrongMockDefaults } from './defaults';
-import type { Mock } from './mock';
-export declare const setActiveMock: (mock: Mock<any>) => void;
-export declare const clearActiveMock: () => void;
-export declare const getActiveMock: () => Mock<any>;
-type MockState = {
-    repository: ExpectationRepository;
-    builder: ExpectationBuilder;
-    options: StrongMockDefaults;
-};
-export declare const getMockState: (mock: Mock<any>) => MockState;
-export declare const setMockState: (mock: Mock<any>, state: MockState) => void;
-export declare const getAllMocks: () => [Mock<any>, MockState][];
-export {};

package/dist/mock/mock.d.ts

@@ -1,24 +0,0 @@
-import type { MockOptions } from './options';
-export type Mock<T> = T;
-/**
- * Create a type safe mock.
- *
- * @see {@link when} Set expectations on the mock using `when`.
- *
- * @param options Configure the options for this specific mock, overriding any
- *   defaults that were set with {@link setDefaults}.
- * @param options.unexpectedProperty Controls what happens when an unexpected
- *   property is accessed.
- * @param options.concreteMatcher The matcher that will be used when one isn't
- *   specified explicitly.
- * @param options.exactParams Controls whether the number of received arguments
- *   has to match the expectation.
- *
- * @example
- * const fn = mock<() => number>();
- *
- * when(() => fn()).thenReturn(23);
- *
- * fn() === 23;
- */
-export declare const mock: <T>({ unexpectedProperty, concreteMatcher, exactParams, }?: MockOptions) => Mock<T>;

package/dist/mock/mode.d.ts

@@ -1,6 +0,0 @@
-export declare enum Mode {
-    EXPECT = 0,
-    CALL = 1
-}
-export declare const setMode: (mode: Mode) => void;
-export declare const getMode: () => Mode;

package/dist/mock/options.d.ts

@@ -1,99 +0,0 @@
-import type { Matcher } from '../matchers/matcher';
-export type ConcreteMatcher = <T>(expected: T) => Matcher;
-export declare enum UnexpectedProperty {
-    /**
-     * Throw an error immediately.
-     *
-     * @example
-     * // Will throw "Didn't expect foo to be accessed".
-     * const { foo } = service;
-     *
-     * // Will throw "Didn't expect foo to be accessed",
-     * // without printing the arguments.
-     * foo(42);
-     */
-    THROW = 0,
-    /**
-     * Return a function that will throw if called. This can be useful if your
-     * code destructures a function but never calls it.
-     *
-     * It will also improve error messages for unexpected calls because arguments
-     * will be captured instead of throwing immediately on the property access.
-     *
-     * The function will be returned even if the property is not supposed to be a
-     * function. This could cause weird behavior at runtime, when your code expects
-     * e.g. a number and gets a function instead.
-     *
-     * @example
-     * // This will NOT throw.
-     * const { foo } = service;
-     *
-     * // This will NOT throw, and might produce unexpected results.
-     * foo > 0
-     *
-     * // Will throw "Didn't expect foo(42) to be called".
-     * foo(42);
-     */
-    CALL_THROW = 1
-}
-export interface MockOptions {
-    /**
-     * Controls what should be returned for a property with no expectations.
-     *
-     * A property with no expectations is a property that has no `when`
-     * expectations set on it. It can also be a property that ran out of `when`
-     * expectations.
-     *
-     * The default is to return a function that will throw when called.
-     *
-     * @example
-     * const foo = mock<{ bar: () => number }>();
-     * foo.bar() // unexpected property access
-     *
-     * @example
-     * const foo = mock<{ bar: () => number }>();
-     * when(() => foo.bar()).thenReturn(42);
-     * foo.bar() === 42
-     * foo.bar() // unexpected property access
-     */
-    unexpectedProperty?: UnexpectedProperty;
-    /**
-     * If `true`, the number of received arguments in a function/method call has to
-     * match the number of arguments set in the expectation.
-     *
-     * If `false`, extra parameters are considered optional and checked by the
-     * TypeScript compiler instead.
-     *
-     * You may want to set this to `true` if you're not using TypeScript,
-     * or if you want to be extra strict.
-     *
-     * @example
-     * const fn = mock<(value?: number) => number>({ exactParams: true });
-     * when(() => fn()).thenReturn(42);
-     *
-     * fn(100) // throws with exactParams, returns 42 without
-     */
-    exactParams?: boolean;
-    /**
-     * The matcher that will be used when one isn't specified explicitly.
-     *
-     * The most common use case is replacing the default {@link It.deepEquals}
-     * matcher with {@link It.is}, but you can also use {@link It.matches} to
-     * create a custom matcher.
-     *
-     * @param expected The concrete expected value received from the
-     *   {@link when} expectation.
-     *
-     * @example
-     * const fn = mock<(value: number[]) => boolean>({
-     *   concreteMatcher: It.is
-     * });
-     *
-     * const expected = [1, 2, 3];
-     * when(() => fn(expected).thenReturn(true);
-     *
-     * fn([1, 2, 3]); // throws because different array instance
-     * fn(expected); // OK
-     */
-    concreteMatcher?: ConcreteMatcher;
-}

package/dist/mock/stub.d.ts

@@ -1,5 +0,0 @@
-import type { ExpectationRepository } from '../expectation/repository/expectation-repository';
-import type { ExpectationBuilder } from '../when/expectation-builder';
-import type { Mock } from './mock';
-import { Mode } from './mode';
-export declare const createStub: <T>(repo: ExpectationRepository, builder: ExpectationBuilder, getCurrentMode: () => Mode) => Mock<T>;

package/dist/print.d.ts

@@ -1,10 +0,0 @@
-import type { Expectation } from './expectation/expectation';
-import type { ReturnValue } from './expectation/repository/return-value';
-import type { Property } from './proxy';
-export declare const printProperty: (property: Property) => string;
-export declare const printValue: (arg: unknown) => string;
-export declare const printCall: (property: Property, args?: any[]) => string;
-export declare const printReturns: ({ isError, isPromise, value }: ReturnValue, min: number, max: number) => string;
-export declare const printWhen: (property: Property, args: any[] | undefined) => string;
-export declare const printExpectation: (property: Property, args: any[] | undefined, returnValue: ReturnValue, min: number, max: number) => string;
-export declare const printRemainingExpectations: (expectations: Expectation[]) => string;

package/dist/proxy.d.ts

@@ -1,48 +0,0 @@
-import type { Mock } from './mock/mock';
-export type Property = string | symbol;
-export interface ProxyTraps {
-    /**
-     * Called when accessing any property on an object, except for
-     * `.call`, `.apply` and `.bind`.
-     */
-    property: (property: Property) => unknown;
-    /**
-     * Called when calling a function.
-     *
-     * @example
-     * ```
-     * fn(...args)
-     * ```
-     *
-     * @example
-     * ```
-     * fn.call(this, ...args)
-     * ```
-     *
-     * @example
-     * ```
-     * fn.apply(this, [...args])
-     * ```
-     *
-     * @example
-     * ```
-     * Reflect.apply(fn, this, [...args])
-     * ```
-     */
-    apply: (args: unknown[]) => unknown;
-    /**
-     * Called when getting the proxy's own enumerable keys.
-     *
-     * @example
-     * ```
-     * Object.keys(proxy);
-     * ```
-     *
-     * @example
-     * ```
-     * const foo = { ...proxy };
-     * ```
-     */
-    ownKeys: () => Property[];
-}
-export declare const createProxy: <T>(traps: ProxyTraps) => Mock<T>;

package/dist/return/invocation-count.d.ts

@@ -1,44 +0,0 @@
-import type { Expectation } from '../expectation/expectation';
-export interface InvocationCount {
-    /**
-     * Expect a call to be made at least `min` times and at most `max` times.
-     */
-    between: (min: number, max: number) => void;
-    /**
-     * Expect a call to be made exactly `exact` times.
-     *
-     * Shortcut for `between(exact, exact)`.
-     */
-    times: (exact: number) => void;
-    /**
-     * Expect a call to be made any number of times, including never.
-     *
-     * Shortcut for `between(0, Infinity)`.
-     */
-    anyTimes: () => void;
-    /**
-     * Expect a call to be made at least `min` times.
-     *
-     * Shortcut for `between(min, Infinity)`.
-     */
-    atLeast: (min: number) => void;
-    /**
-     * Expect a call to be made at most `max` times.
-     *
-     * Shortcut for `between(0, max)`.
-     */
-    atMost: (max: number) => void;
-    /**
-     * Expect a call to be made exactly once.
-     *
-     * Shortcut for `times(1)`.
-     */
-    once: () => void;
-    /**
-     * Expect a call to be made exactly twice.
-     *
-     * Shortcut for `times(2)`.
-     */
-    twice: () => void;
-}
-export declare const createInvocationCount: (expectation: Expectation) => InvocationCount;

package/dist/return/returns.d.ts

@@ -1,61 +0,0 @@
-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 +0,0 @@
-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 +0,0 @@
-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/expectation-builder.d.ts

@@ -1,26 +0,0 @@
-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;
-}