mockt/dist/types/index.d.ts

Joyful mocking library for Typescript and Javascript

declare abstract class Matcher<T> {
    abstract matches(value: T): boolean;
}

declare class AndMatcher<T> extends Matcher<T> {
    private matchers;
    constructor(...matchers: Matcher<T>[]);
    matches(value: T): boolean;
    toString(): string;
}
declare function and<T>(...matchers: (Matcher<T> | T)[]): T;

declare class AnyArray extends Matcher<any> {
    matches(value: any): boolean;
    toString(): string;
}
declare function anyArray(): any;

declare class AnyFunctionMatcher extends Matcher<any> {
    matches(value: any): boolean;
    toString(): string;
}
declare function anyFunction(): any;

declare class AnyMatcher<T> extends Matcher<T> {
    matches(value: T): boolean;
    toString(): string;
}
declare function any<T>(): T;

declare class AnyNumber extends Matcher<any> {
    matches(value: any): boolean;
    toString(): string;
}
declare function anyNumber(): any;

declare class AnyObjectMatcher extends Matcher<any> {
    matches(value: any): boolean;
    toString(): string;
}
declare function anyObject(): any;

declare class AnyString extends Matcher<any> {
    matches(value: any): boolean;
    toString(): string;
}
declare function anyString(): any;

declare class ClassMatcher<T> extends Matcher<T> {
    private expectedClass;
    constructor(expectedClass: abstract new (...args: any[]) => T);
    matches(value: any): boolean;
    toString(): string;
}
declare function ofClass<T>(expectedClass: abstract new (...args: any[]) => T): T;

declare class EqualsMatcher<T> extends Matcher<T> {
    private expected;
    constructor(expected: T);
    matches(value: T): boolean;
    toString(): string;
}
declare function eq<T>(expected: T): T;

declare class IdenticalMatcher<T> extends Matcher<T> {
    private expected;
    constructor(expected: T);
    matches(value: T): boolean;
    toString(): string;
}
declare function is<T>(expected: T): T;

declare class IsNilMatcher<T> extends Matcher<T> {
    matches(value: T): boolean;
    toString(): string;
}
declare function isNil<T>(): T;

declare class IsNullMatcher<T> extends Matcher<T> {
    matches(value: T): boolean;
    toString(): string;
}
declare function isNull<T>(): T;

declare class LessMatcher extends Matcher<number> {
    private max;
    constructor(max: number);
    matches(value: number): boolean;
    toString(): string;
}
declare function less(max: number): number;

declare class MoreMatcher extends Matcher<number> {
    private min;
    constructor(min: number);
    matches(value: number): boolean;
    toString(): string;
}
declare function more(min: number): number;

declare class NotMatcher<T> extends Matcher<T> {
    private inner;
    constructor(inner: Matcher<T>);
    matches(value: T): boolean;
    toString(): string;
}
declare function not<T>(matcher: Matcher<T> | T): T;
declare function neq<T>(expected: T): T;

declare class NotNilMatcher<T> extends Matcher<T> {
    matches(value: T): boolean;
    toString(): string;
}
declare function notNil<T>(): T;

declare class NotNullMatcher<T> extends Matcher<T> {
    matches(value: T): boolean;
    toString(): string;
}
declare function notNull<T>(): T;

declare class OrMatcher<T> extends Matcher<T> {
    private matchers;
    constructor(...matchers: Matcher<T>[]);
    matches(value: T): boolean;
    toString(): string;
}
declare function or<T>(...matchers: (Matcher<T> | T)[]): T;

declare class RangeMatcher extends Matcher<number> {
    private from;
    private to;
    constructor(from: number, to: number);
    matches(value: number): boolean;
    toString(): string;
}
declare function range(from: number, to: number): number;

declare abstract class MethodStub<R> {
    readonly name: string;
    readonly matchers: Matcher<any>[];
    protected constructor(name: string, matchers: Matcher<any>[]);
    matches(args: any[]): boolean;
    hasSameMatchers(other: MethodStub<any>): boolean;
    abstract execute(args: any[]): R;
}

declare class MethodStubBuilder<R, ResolveType = void> extends Function {
    private mock;
    private methodName;
    private matchers;
    private addMethodStub;
    private defineMockMethodStub;
    private isFirstStub;
    constructor(mock: any, methodName: string, matchers: Matcher<any>[], addMethodStub: (stub: MethodStub<R>, appendAnswer?: boolean) => void, defineMockMethodStub: (methodName: string, force?: boolean) => void);
    private doAddMethodStub;
    returns(param?: R, ...rest: R[]): this;
    throws(error?: Error): this;
    resolves(param?: ResolveType, ...rest: ResolveType[]): this;
    rejects(error?: Error): this;
    calls(func: (...args: any[]) => R): this;
    private __call;
}

declare class Invocation {
    readonly index: number;
    readonly name: string;
    readonly args: any[];
    readonly globalIndex: number;
    constructor(index: number, name: string, args: any[]);
    matches(matchers: Matcher<any>[]): boolean;
    toString(): string;
}

declare class InvocationTracker {
    private invocations;
    add(name: string, args: any[]): void;
    getMatchingInvocations(name: string, matchers: Matcher<any>[]): Invocation[];
    getInvocationsByName(name: string): Invocation[];
    getAllInvocations(): Invocation[];
    reset(): void;
}

declare class MultipleInvocationsVerificator {
    private invocationTracker;
    private invocationsToVerify;
    private readonly proxy;
    constructor(invocationTracker: InvocationTracker);
    called(): void;
    never(): void;
    calledInOrder(): void;
    private failIfEmptyInvocationsToVerify;
    protected getAllCallsMessage(): string;
    private methodVerifier;
}

declare function capture<T extends object>(instance: T): CaptureType<T>;
declare function captureFirst<T extends object>(instance: T): CaptureType<T>;
declare function captureLast<T extends object>(instance: T): CaptureType<T>;
declare function captureAll<T extends object>(instance: T): MultiCaptureType<T>;
type CaptureType<T> = {
    [K in keyof T]: T[K] extends ((...args: infer A) => any) ? [...A] : void;
} & {
    setProperty<K extends keyof T>(name: K): T[K][];
};
type MultiCaptureType<T> = {
    [K in keyof T]: T[K] extends ((...args: infer A) => any) ? [...A][] : void;
} & {
    setProperty<K extends keyof T>(name: K): T[K][][];
};

declare function mockt<T>(clazz?: (new (...args: any[]) => T)): T;
declare function mockt<T>(clazz?: any): T;

declare function reset(...instances: any): void;

declare function resetCalls(...instances: any): void;

declare function spy<T extends object>(instance: T): T;

declare class UnknownResponse extends Function {
    constructor(propertyName: string, invocationTracker: InvocationTracker);
}

declare function verify<T>(instance: T): SimpleInvocationVerificatorType<T>;
declare function verifyOnce<T>(instance: T): SimpleInvocationVerificatorType<T>;
declare function verifyNever<T>(instance: T): SimpleInvocationVerificatorType<T>;
declare function verifyTimes<T>(times: number, instance: T): SimpleInvocationVerificatorType<T>;
declare function verifyAtLeast<T>(times: number, instance: T): SimpleInvocationVerificatorType<T>;
declare function verifyAtMost<T>(times: number, instance: T): SimpleInvocationVerificatorType<T>;
type SimpleInvocationVerificatorType<T> = {
    [K in keyof T]: T[K] extends (((...args: infer A) => any) | Function) ? (...args: A) => void : Function;
} & {
    getProperty(name: keyof T): void;
    setProperty(name: keyof T, value: any): void;
};

declare function verifyMulti<T>(instance: T): MultipleInvocationVerificatorType<T>;
type MultipleInvocationVerificatorType<T> = {
    [K in keyof T]: T[K] extends (((...args: infer A) => any) | Function) ? (...args: A) => MultipleInvocationVerificatorType<T> : MultipleInvocationVerificatorType<T>;
} & {
    getProperty(name: keyof T): MultipleInvocationVerificatorType<T>;
    setProperty(name: keyof T, value: any): MultipleInvocationVerificatorType<T>;
    called(): void;
    calledInOrder(): void;
    never(): void;
};

declare function verifySequence(): SequenceVerificatorType;
type SequenceVerificatorCallType<T> = {
    [K in keyof T]: T[K] extends (((...args: infer A) => any) | Function) ? (...args: A) => SequenceVerificatorType : SequenceVerificatorType;
} & {
    getProperty(name: keyof T): SequenceVerificatorType;
    setProperty(name: keyof T, value: any): SequenceVerificatorType;
};
type SequenceVerificatorType = {
    call<T>(instance: T): SequenceVerificatorCallType<T>;
};

declare function when<T>(instance: T): MockStubbing<T>;
type MethodStubBuilderType<R, ResolveType = void> = {
    returns(param?: R, ...rest: R[]): MethodStubBuilderType<R, ResolveType>;
    throws(error?: Error): MethodStubBuilderType<R, ResolveType>;
    resolves(param?: ResolveType, ...rest: ResolveType[]): MethodStubBuilderType<R, ResolveType>;
    rejects(error?: Error): MethodStubBuilderType<R, ResolveType>;
    calls(func: (...args: any[]) => R): MethodStubBuilderType<R, ResolveType>;
};
type BehaviorSetter<R> = [
    R
] extends [Promise<infer ResolveType>] ? MethodStubBuilderType<R, ResolveType> : MethodStubBuilderType<R>;
type FunctionToChangeBehavior<A extends any[], R> = (...args: A) => BehaviorSetter<R>;
type MockStubbing<T> = {
    [K in keyof T]: T[K] extends (((...args: infer A) => infer R) | Function) ? FunctionToChangeBehavior<A, R> : BehaviorSetter<T[K]>;
};

export { AndMatcher, AnyArray, AnyFunctionMatcher, AnyMatcher, AnyNumber, AnyObjectMatcher, AnyString, type BehaviorSetter, type CaptureType, ClassMatcher, EqualsMatcher, type FunctionToChangeBehavior, IdenticalMatcher, IsNilMatcher, IsNullMatcher, LessMatcher, Matcher, MethodStubBuilder, type MethodStubBuilderType, type MockStubbing, MoreMatcher, type MultiCaptureType, type MultipleInvocationVerificatorType, MultipleInvocationsVerificator, NotMatcher, NotNilMatcher, NotNullMatcher, OrMatcher, RangeMatcher, type SequenceVerificatorCallType, type SequenceVerificatorType, type SimpleInvocationVerificatorType, UnknownResponse, and, any, anyArray, anyFunction, anyNumber, anyObject, anyString, capture, captureAll, captureFirst, captureLast, eq, is, isNil, isNull, less, mockt, more, neq, not, notNil, notNull, ofClass, or, range, reset, resetCalls, spy, verify, verifyAtLeast, verifyAtMost, verifyMulti, verifyNever, verifyOnce, verifySequence, verifyTimes, when };