prostub 1.0.0

package/index.d.ts

@@ -0,0 +1,201 @@
+interface Type<T extends object> {
+    new (...args: never[]): T;
+    prototype: T;
+}
+
+declare const mock$1: unique symbol;
+declare const stub$1: unique symbol;
+
+interface InvocationRecord<TArgs extends Array<unknown>, TReturn> {
+    args: TArgs;
+    returnValue?: TReturn;
+    invocationTime: Date;
+    exception?: unknown;
+}
+interface AssignmentRecord<TValue> {
+    newValue: TValue;
+    assignmentTime: Date;
+}
+interface ReadRecord<TValue> {
+    value: TValue;
+    readTime: Date;
+}
+interface FunctionStub<TThis extends object, TKey extends keyof TThis, TArgs extends Array<unknown>, TReturn> {
+    [stub$1]: {
+        invoke: (thisArg: TThis, propertyName: TKey, ...args: TArgs) => TReturn;
+        type: "function";
+        metadata: FunctionStubMetadata<TArgs, TReturn>;
+    };
+}
+interface PropertyStubMetadata<TValue> {
+    reads: Array<ReadRecord<TValue>>;
+    assignments: Array<AssignmentRecord<TValue>>;
+}
+type FunctionStubMetadata<TArgs extends Array<unknown>, TReturn> = {
+    calls: Array<InvocationRecord<TArgs, TReturn>>;
+};
+interface PropertyStub<TThis extends object, TKey extends keyof TThis> {
+    [stub$1]: {
+        type: "property";
+        get(thisArg: TThis, propertyName: TKey): TThis[TKey];
+        set(thisArg: TThis, propertyName: TKey, newValue: TThis[TKey]): void;
+        metadata: {
+            reads: Array<ReadRecord<TThis[TKey]>>;
+            assignments: Array<AssignmentRecord<TThis[TKey]>>;
+        };
+    };
+}
+type Stubbable<T extends object> = {
+    -readonly [K in keyof T]: Stub<T, K>;
+};
+type Stub<TThis extends object, TKey extends keyof TThis> = TThis[TKey] extends (...args: infer TArgs) => infer TReturn ? FunctionStub<TThis, TKey, TArgs, TReturn> : PropertyStub<TThis, TKey>;
+
+declare function mock<const TObject extends object>(clazz: Type<TObject>): TObject & {
+    [mock$1]: {
+        stubs: { -readonly [TKey in keyof TObject]?: Stub<TObject, TKey>; };
+    };
+} & {
+    [mock$1]: {
+        stubs: TObject & {
+            [mock$1]: {
+                stubs: { -readonly [TKey_1 in keyof TObject]?: Stub<TObject, TKey_1>; };
+            };
+        } extends infer T extends object ? { -readonly [TKey in keyof T]?: Stub<T, TKey> | undefined; } : never;
+    };
+};
+
+declare function spy<const TObject extends object>(realObject: TObject): TObject & {
+    [mock$1]: {
+        stubs: {
+            -readonly [TKey in keyof TObject]?: Stub<TObject, TKey>;
+        };
+    };
+};
+
+declare function stub<const TObject extends object>(mockOrSpy: TObject & {
+    [mock$1]: {
+        stubs: {
+            -readonly [TKey in keyof TObject]?: Stub<TObject, TKey>;
+        };
+    };
+}): Stubbable<TObject>;
+
+declare function answer<const TObject extends object, const TKey extends keyof TObject, const TArgs extends Array<unknown>, const TReturn>(answerFunction: (this: TObject, ...args: TArgs) => TReturn): FunctionStub<TObject, TKey, TArgs, TReturn>;
+
+declare function callThrough<const TObject extends object, const TKey extends keyof TObject, const TArgs extends Array<unknown>, const TReturn>(): FunctionStub<TObject, TKey, TArgs, TReturn>;
+
+declare function delegateTo<const TObject extends object, const TKey extends keyof TObject, const TArgs extends Array<unknown>, const TReturn>(delegateFunction: (this: TObject, ...args: TArgs) => TReturn): FunctionStub<TObject, TKey, TArgs, TReturn>;
+
+declare function returnFixed<const TObject extends object, const TKey extends keyof TObject, const TArgs extends Array<unknown>, const TReturn>(returnValue: TReturn): FunctionStub<TObject, TKey, TArgs, TReturn>;
+
+declare function returnSerial<const TObject extends object, const TKey extends keyof TObject, const TArgs extends Array<unknown>, const TReturn>(...values: Array<TReturn>): FunctionStub<TObject, TKey, TArgs, TReturn>;
+
+declare function noop<const TObject extends object, const TKey extends keyof TObject, const TArgs extends Array<unknown>>(): FunctionStub<TObject, TKey, TArgs, void>;
+
+declare function throwOnCall<const TObject extends object, const TKey extends keyof TObject, const TArgs extends Array<unknown>>(errorFactory: () => Error): FunctionStub<TObject, TKey, TArgs, never>;
+
+type ArgumentPredicate<TArgs extends Array<unknown>> = TArgs extends [infer TFirst, ...infer TRest] ? [
+    ((arg: TFirst) => boolean),
+    ...ArgumentPredicate<TRest>
+] : TArgs extends [infer TSingle] ? [
+    (arg: TSingle) => boolean
+] : TArgs extends [] ? [
+] : never;
+
+declare class OngoingFunctionStub<const TThis extends object, const TKey extends keyof TThis, const TArgs extends Array<unknown>, const TReturn> implements FunctionStub<TThis, TKey, TArgs, TReturn> {
+    #private;
+    get [stub$1](): {
+        invoke: (thisArg: TThis, propertyName: TKey, ...args: TArgs) => TReturn;
+        type: "function";
+        metadata: FunctionStubMetadata<TArgs, TReturn>;
+    };
+    constructor(argumentPredicates: ArgumentPredicate<TArgs>, stub: FunctionStub<TThis, TKey, TArgs, TReturn>, parentStub?: OngoingFunctionStub<TThis, TKey, TArgs, TReturn>);
+    when(...argumentPredicates: ArgumentPredicate<TArgs>): OngoingFunctionStubBuilder<TThis, TKey, TArgs, TReturn>;
+}
+declare class OngoingFunctionStubBuilder<const TThis extends object, const TKey extends keyof TThis, const TArgs extends Array<unknown>, const TReturn> implements FunctionStub<TThis, TKey, TArgs, TReturn> {
+    #private;
+    get [stub$1](): {
+        invoke: (_thisArg: TThis, _propertyName: TKey, ..._args: TArgs) => never;
+        type: "function";
+        metadata: {
+            calls: never[];
+        };
+    };
+    constructor(argumentPredicates: ArgumentPredicate<TArgs>, parentStub?: OngoingFunctionStub<TThis, TKey, TArgs, TReturn>);
+    then(stub: FunctionStub<TThis, TKey, TArgs, TReturn>): OngoingFunctionStub<TThis, TKey, TArgs, TReturn>;
+}
+declare function when<const TObject extends object, const TKey extends keyof TObject, const TArgs extends Array<unknown>, const TReturn>(...argumentPredicates: ArgumentPredicate<TArgs>): OngoingFunctionStubBuilder<TObject, TKey, TArgs, TReturn>;
+
+declare function defaultValue<const TObject extends object, const TKey extends keyof TObject>(value: TObject[TKey]): PropertyStub<TObject, TKey>;
+
+declare function fixedValue<const TThis extends object, const TKey extends keyof TThis>(value: TThis[TKey]): PropertyStub<TThis, TKey>;
+
+declare function trackValue<const TObject extends object, const TKey extends keyof TObject>(): PropertyStub<TObject, TKey>;
+
+declare class AssignmentVerification<const TValue> {
+    #private;
+    constructor(assignmentRecord: AssignmentRecord<TValue>);
+    wasBefore(otherAssignment: AssignmentVerification<TValue>): void;
+    wasAfter(otherAssignment: AssignmentVerification<TValue>): void;
+    hasValue(validator: (result: TValue) => boolean): void;
+}
+
+declare class ReadVerification<const TValue> {
+    #private;
+    constructor(read: ReadRecord<TValue>);
+    wasBefore(otherRead: ReadVerification<TValue>): void;
+    wasAfter(otherRead: ReadVerification<TValue>): void;
+    hadValue(validator: (result: TValue) => boolean): void;
+}
+
+declare class PropertyVerification<const TValue> {
+    #private;
+    constructor(propertyStubMetadata: PropertyStubMetadata<TValue>);
+    wasReadNTimes(expectedGetCallCount?: number): void;
+    wasRead(): void;
+    wasNotAssigned(): void;
+    wasNotRead(): void;
+    wasAssignedNTimes(expectedSetCallCount?: number): void;
+    wasAssigned(): void;
+    nthAssignment(index: number): AssignmentVerification<TValue>;
+    firstAssignment(): AssignmentVerification<TValue>;
+    lastAssignment(): AssignmentVerification<TValue>;
+    firstRead(): ReadVerification<TValue>;
+    lastRead(): ReadVerification<TValue>;
+    nthRead(index: number): ReadVerification<TValue>;
+}
+
+declare class InvocationVerification<const TArgs extends Array<unknown>, TReturn> {
+    #private;
+    constructor(call: InvocationRecord<TArgs, TReturn>);
+    wasBefore(otherInvocation: InvocationVerification<TArgs, TReturn>): void;
+    wasAfter(otherInvocation: InvocationVerification<TArgs, TReturn>): void;
+    returned(validator: (result: TReturn) => boolean): void;
+    threw(validator: (error: unknown) => boolean): void;
+}
+
+declare class FunctionVerification<const TArgs extends Array<unknown>, TReturn> {
+    #private;
+    constructor(functionStubMetadata: FunctionStubMetadata<TArgs, TReturn>);
+    wasCalled(): void;
+    wasNotCalled(): void;
+    wasCalledTimes(expectedCallCount: number): void;
+    nthInvocation(invocationIndex: number): InvocationVerification<TArgs, TReturn>;
+    firstInvocation(): InvocationVerification<TArgs, TReturn>;
+    lastInvocation(): InvocationVerification<TArgs, TReturn>;
+    invocationMatching(predicate: (...args: TArgs) => boolean): InvocationVerification<TArgs, TReturn>;
+}
+
+type Verifiable<T> = {
+    readonly [TKey in keyof T]: T[TKey] extends (...args: infer TArgs) => infer TReturn ? FunctionVerification<TArgs, TReturn> : PropertyVerification<T[TKey]>;
+};
+
+declare function verify<const TObject extends object>(mockOrSpy: TObject & {
+    [mock$1]: {
+        stubs: {
+            -readonly [TKey in keyof TObject]?: Stub<TObject, TKey>;
+        };
+    };
+}): Verifiable<TObject>;
+
+export { answer, callThrough, defaultValue, delegateTo, fixedValue, mock, noop, returnFixed, returnSerial, spy, stub, throwOnCall, trackValue, verify, when };

package/index.js

@@ -0,0 +1,571 @@
+const mock$1 = Symbol("mock");
+const stub$1 = Symbol("stub");
+
+function spy(realObject) {
+    const stubs = {};
+    return new Proxy(realObject, {
+        set(target, propertyName, newValue, _receiver) {
+            if (!stubs.hasOwnProperty(propertyName)) {
+                throw new Error(`No stub defined for property "${String(propertyName)}".`);
+            }
+            const stubMetadata = stubs[propertyName][stub$1];
+            if (stubMetadata.type !== "property") {
+                throw new Error(`Cannot set value of non-property stub "${String(propertyName)}".`);
+            }
+            stubMetadata.set(target, propertyName, newValue); // Cast to any is needed as TObject[TKey] does not work due to TS limitations
+            return true;
+        },
+        get(target, propertyName, _receiver) {
+            if (propertyName === mock$1) {
+                return { stubs };
+            }
+            if (!stubs.hasOwnProperty(propertyName)) {
+                throw new Error(`No stub defined for property "${String(propertyName)}".`);
+            }
+            const stubMetadata = stubs[propertyName][stub$1];
+            if (stubMetadata.type === "function") {
+                const returnValue = function (...args) {
+                    return stubMetadata.invoke(realObject, propertyName, ...args);
+                };
+                return returnValue;
+            }
+            else {
+                return stubMetadata.get(target, propertyName);
+            }
+        },
+        has(target, propertyName) {
+            return propertyName === mock$1 || Reflect.has(target, propertyName);
+        }
+    });
+}
+
+function mock(clazz) {
+    const instance = Object.create(clazz.prototype);
+    return spy(instance);
+}
+
+function stub(mockOrSpy) {
+    const stubs = mockOrSpy[mock$1].stubs;
+    return new Proxy({}, {
+        set(_target, propertyName, newValue, _receiver) {
+            if (typeof newValue !== "object" || newValue === null || !Reflect.has(newValue, stub$1)) {
+                throw new Error(`Stub value for property "${String(propertyName)}" must be a stub created by a stub factory function.`);
+            }
+            if (stubs.hasOwnProperty(propertyName)) {
+                throw new Error(`Stub for property "${String(propertyName)}" is already defined.`);
+            }
+            stubs[propertyName] = newValue;
+            return true;
+        },
+        get(_target, propertyName, _receiver) {
+            throw new Error(`Cannot get stub for property "${String(propertyName)}". Stubs can only be set, not retrieved.`);
+        }
+    });
+}
+
+function runCatching(fn, thisArg, ...args) {
+    try {
+        const result = fn.apply(thisArg, args);
+        return { result: "success", returnValue: result };
+    }
+    catch (error) {
+        return { result: "error", error };
+    }
+}
+
+function answer(answerFunction) {
+    const metadata = {
+        calls: []
+    };
+    return {
+        [stub$1]: {
+            invoke: function (thisArg, _propertyName, ...args) {
+                const result = runCatching(answerFunction, thisArg, ...args);
+                metadata.calls.push({
+                    args,
+                    ...(result.result === "success" ? { returnValue: result.returnValue } : { exception: result.error }),
+                    invocationTime: new Date()
+                });
+                if (result.result === "error") {
+                    throw result.error;
+                }
+                return result.returnValue;
+            },
+            type: "function",
+            metadata,
+        }
+    };
+}
+
+function callThrough() {
+    const metadata = {
+        calls: []
+    };
+    return {
+        [stub$1]: {
+            invoke: function (thisArg, propertyName, ...args) {
+                const result = runCatching((...args) => thisArg[propertyName](...args), thisArg, ...args);
+                metadata.calls.push({
+                    args,
+                    ...(result.result === "success" ? { returnValue: result.returnValue } : { exception: result.error }),
+                    invocationTime: new Date()
+                });
+                if (result.result === "error") {
+                    throw result.error;
+                }
+                return result.returnValue;
+            },
+            type: "function",
+            metadata,
+        }
+    };
+}
+
+function delegateTo(delegateFunction) {
+    const metadata = {
+        calls: []
+    };
+    return {
+        [stub$1]: {
+            invoke: function (thisArg, _propertyName, ...args) {
+                metadata.calls.push({
+                    args,
+                    returnValue: delegateFunction.apply(thisArg, args),
+                    invocationTime: new Date()
+                });
+                return delegateFunction.apply(thisArg, args);
+            },
+            type: "function",
+            metadata,
+        }
+    };
+}
+
+function returnFixed(returnValue) {
+    const metadata = {
+        calls: []
+    };
+    return {
+        [stub$1]: {
+            invoke: function (_thisArg, _propertyName, ...args) {
+                metadata.calls.push({
+                    args,
+                    returnValue,
+                    invocationTime: new Date()
+                });
+                return returnValue;
+            },
+            type: "function",
+            metadata,
+        }
+    };
+}
+
+function returnSerial(...values) {
+    const metadata = {
+        calls: []
+    };
+    return {
+        [stub$1]: {
+            type: "function",
+            metadata,
+            invoke: function (_thisArg, _propertyName, ...args) {
+                const index = metadata.calls.length;
+                if (index === values.length) {
+                    const error = new Error(`No more return values left in returnSerial stub (called ${index + 1} times, but only ${values.length} values were provided)`);
+                    metadata.calls.push({
+                        args,
+                        invocationTime: new Date(),
+                        exception: error,
+                    });
+                    throw error;
+                }
+                const returnValue = values[index];
+                metadata.calls.push({
+                    args,
+                    returnValue,
+                    invocationTime: new Date()
+                });
+                return returnValue;
+            }
+        }
+    };
+}
+
+function noop() {
+    const metadata = {
+        calls: []
+    };
+    return {
+        [stub$1]: {
+            invoke: function (_thisArg, _propertyName, ...args) {
+                metadata.calls.push({
+                    args,
+                    invocationTime: new Date()
+                });
+            },
+            type: "function",
+            metadata,
+        }
+    };
+}
+
+function throwOnCall(errorFactory) {
+    const metadata = {
+        calls: []
+    };
+    return {
+        [stub$1]: {
+            invoke: function (_thisArg, _propertyName, ...args) {
+                const error = errorFactory();
+                metadata.calls.push({
+                    args,
+                    exception: error,
+                    invocationTime: new Date()
+                });
+                throw error;
+            },
+            type: "function",
+            metadata,
+        }
+    };
+}
+
+class OngoingFunctionStub {
+    get [stub$1]() {
+        return {
+            invoke: (thisArg, propertyName, ...args) => this.#invoke(thisArg, propertyName, ...args),
+            type: "function",
+            metadata: {
+                calls: [
+                    ...(this.#parentStub ? this.#parentStub[stub$1].metadata.calls : []),
+                    ...this.#stub[stub$1].metadata.calls
+                ]
+            }
+        };
+    }
+    #argumentPredicates;
+    #stub;
+    #parentStub;
+    constructor(argumentPredicates, stub, parentStub) {
+        this.#argumentPredicates = argumentPredicates;
+        this.#stub = stub;
+        this.#parentStub = parentStub;
+    }
+    when(...argumentPredicates) {
+        return new OngoingFunctionStubBuilder(argumentPredicates, this);
+    }
+    #invoke(thisArg, propertyName, ...args) {
+        if (this.#parentStub && this.#parentStub.#matchesArguments(args)) {
+            return this.#parentStub.#invoke(thisArg, propertyName, ...args);
+        }
+        else if (this.#matchesArguments(args)) {
+            return this.#stub[stub$1].invoke(thisArg, propertyName, ...args);
+        }
+        else {
+            throw new Error("No matching stub found for the given arguments.");
+        }
+    }
+    #matchesArguments(args) {
+        return args.every((arg, index) => this.#argumentPredicates[index](arg));
+    }
+}
+class OngoingFunctionStubBuilder {
+    get [stub$1]() {
+        return {
+            invoke: (_thisArg, _propertyName, ..._args) => {
+                throw new Error("Cannot invoke a stub builder. Please complete the stub definition using 'then' before invoking.");
+            },
+            type: "function",
+            metadata: {
+                calls: []
+            }
+        };
+    }
+    #argumentPredicates;
+    #parentStub;
+    constructor(argumentPredicates, parentStub) {
+        this.#argumentPredicates = argumentPredicates;
+        this.#parentStub = parentStub;
+    }
+    then(stub) {
+        return new OngoingFunctionStub(this.#argumentPredicates, stub, this.#parentStub);
+    }
+}
+function when(...argumentPredicates) {
+    return new OngoingFunctionStubBuilder(argumentPredicates);
+}
+
+function defaultValue(value) {
+    const metadata = {
+        reads: [],
+        assignments: []
+    };
+    let currentValue = value;
+    return {
+        [stub$1]: {
+            type: "property",
+            get(_thisArg, _propertyName) {
+                metadata.reads.push({
+                    value: currentValue,
+                    readTime: new Date()
+                });
+                return currentValue;
+            },
+            set(_thisArg, _propertyName, newValue) {
+                metadata.assignments.push({
+                    newValue,
+                    assignmentTime: new Date()
+                });
+                currentValue = newValue;
+            },
+            metadata
+        }
+    };
+}
+
+function fixedValue(value) {
+    const metadata = {
+        reads: [],
+        assignments: []
+    };
+    return {
+        [stub$1]: {
+            type: "property",
+            get(_thisArg, _propertyName) {
+                metadata.reads.push({
+                    value,
+                    readTime: new Date()
+                });
+                return value;
+            },
+            set(_thisArg, _propertyName, _newValue) {
+                metadata.assignments.push({
+                    newValue: _newValue,
+                    assignmentTime: new Date()
+                });
+                throw new Error("Cannot set value of a fixedValue property stub.");
+            },
+            metadata
+        }
+    };
+}
+
+function trackValue() {
+    const metadata = {
+        reads: [],
+        assignments: [],
+    };
+    return {
+        [stub$1]: {
+            type: "property",
+            get(thisArg, propertyName) {
+                const currentValue = thisArg[propertyName];
+                metadata.reads.push({
+                    value: currentValue,
+                    readTime: new Date(),
+                });
+                return currentValue;
+            },
+            set(thisArg, propertyName, newValue) {
+                thisArg[propertyName] = newValue;
+                metadata.assignments.push({
+                    newValue,
+                    assignmentTime: new Date(),
+                });
+            },
+            metadata
+        }
+    };
+}
+
+class AssignmentVerification {
+    #assignmentRecord;
+    constructor(assignmentRecord) {
+        this.#assignmentRecord = assignmentRecord;
+    }
+    wasBefore(otherAssignment) {
+        if (this.#assignmentRecord.assignmentTime >= otherAssignment.#assignmentRecord.assignmentTime) {
+            throw new Error(`Expected assignment at ${this.#assignmentRecord.assignmentTime.toISOString()} to be before assignment at ${otherAssignment.#assignmentRecord.assignmentTime.toISOString()}, but it was not.`);
+        }
+    }
+    wasAfter(otherAssignment) {
+        if (this.#assignmentRecord.assignmentTime <= otherAssignment.#assignmentRecord.assignmentTime) {
+            throw new Error(`Expected assignment at ${this.#assignmentRecord.assignmentTime.toISOString()} to be after assignment at ${otherAssignment.#assignmentRecord.assignmentTime.toISOString()}, but it was not.`);
+        }
+    }
+    hasValue(validator) {
+        if (!validator(this.#assignmentRecord.newValue)) {
+            throw new Error(`The assigned value did not satisfy the provided validator.`);
+        }
+    }
+}
+
+class ReadVerification {
+    #readRecord;
+    constructor(read) {
+        this.#readRecord = read;
+    }
+    wasBefore(otherRead) {
+        if (this.#readRecord.readTime >= otherRead.#readRecord.readTime) {
+            throw new Error(`Expected read at ${this.#readRecord.readTime.toISOString()} to be before read at ${otherRead.#readRecord.readTime.toISOString()}, but it was not.`);
+        }
+    }
+    wasAfter(otherRead) {
+        if (this.#readRecord.readTime <= otherRead.#readRecord.readTime) {
+            throw new Error(`Expected read at ${this.#readRecord.readTime.toISOString()} to be after read at ${otherRead.#readRecord.readTime.toISOString()}, but it was not.`);
+        }
+    }
+    hadValue(validator) {
+        if (!validator(this.#readRecord.value)) {
+            throw new Error(`The read value did not satisfy the provided validator.`);
+        }
+    }
+}
+
+class PropertyVerification {
+    #propertyStubMetadata;
+    constructor(propertyStubMetadata) {
+        this.#propertyStubMetadata = propertyStubMetadata;
+    }
+    wasReadNTimes(expectedGetCallCount = 1) {
+        const actualGetCallCount = this.#propertyStubMetadata.reads.length;
+        if (actualGetCallCount !== expectedGetCallCount) {
+            throw new Error(`Expected property getter to be called ${expectedGetCallCount} times, but was called ${actualGetCallCount} times.`);
+        }
+    }
+    wasRead() {
+        this.wasReadNTimes(1);
+    }
+    wasNotAssigned() {
+        this.wasAssignedNTimes(0);
+    }
+    wasNotRead() {
+        this.wasReadNTimes(0);
+    }
+    wasAssignedNTimes(expectedSetCallCount = 1) {
+        const actualSetCallCount = this.#propertyStubMetadata.assignments.length;
+        if (actualSetCallCount !== expectedSetCallCount) {
+            throw new Error(`Expected property setter to be called ${expectedSetCallCount} times, but was called ${actualSetCallCount} times.`);
+        }
+    }
+    wasAssigned() {
+        this.wasAssignedNTimes(1);
+    }
+    nthAssignment(index) {
+        if (index < 0 || index >= this.#propertyStubMetadata.assignments.length) {
+            throw new Error(`Assignment index ${index} is out of bounds. There are only ${this.#propertyStubMetadata.assignments.length} assignments.`);
+        }
+        return new AssignmentVerification(this.#propertyStubMetadata.assignments[index]);
+    }
+    firstAssignment() {
+        return this.nthAssignment(0);
+    }
+    lastAssignment() {
+        return this.nthAssignment(this.#propertyStubMetadata.assignments.length - 1);
+    }
+    firstRead() {
+        return this.nthRead(0);
+    }
+    lastRead() {
+        return this.nthRead(this.#propertyStubMetadata.reads.length - 1);
+    }
+    nthRead(index) {
+        if (index < 0 || index >= this.#propertyStubMetadata.reads.length) {
+            throw new Error(`Read index ${index} is out of bounds. There are only ${this.#propertyStubMetadata.reads.length} reads.`);
+        }
+        return new ReadVerification(this.#propertyStubMetadata.reads[index]);
+    }
+}
+
+class InvocationVerification {
+    #call;
+    constructor(call) {
+        this.#call = call;
+    }
+    wasBefore(otherInvocation) {
+        if (this.#call.invocationTime >= otherInvocation.#call.invocationTime) {
+            throw new Error(`Expected invocation at ${this.#call.invocationTime.toISOString()} to be before invocation at ${otherInvocation.#call.invocationTime.toISOString()}, but it was not.`);
+        }
+    }
+    wasAfter(otherInvocation) {
+        if (this.#call.invocationTime <= otherInvocation.#call.invocationTime) {
+            throw new Error(`Expected invocation at ${this.#call.invocationTime.toISOString()} to be after invocation at ${otherInvocation.#call.invocationTime.toISOString()}, but it was not.`);
+        }
+    }
+    returned(validator) {
+        if (this.#call.exception) {
+            throw new Error(`Expected invocation to return a value, but it threw an exception.`);
+        }
+        if (!validator(this.#call.returnValue)) {
+            throw new Error(`The returned value did not satisfy the provided validator.`);
+        }
+    }
+    threw(validator) {
+        if (!this.#call.exception) {
+            throw new Error(`Expected invocation to throw an exception, but it did not.`);
+        }
+        if (!validator(this.#call.exception)) {
+            throw new Error(`The thrown exception did not satisfy the provided validator.`);
+        }
+    }
+}
+
+class FunctionVerification {
+    #functionStubMetadata;
+    constructor(functionStubMetadata) {
+        this.#functionStubMetadata = functionStubMetadata;
+    }
+    wasCalled() {
+        this.wasCalledTimes(1);
+    }
+    wasNotCalled() {
+        this.wasCalledTimes(0);
+    }
+    wasCalledTimes(expectedCallCount) {
+        const actualCallCount = this.#functionStubMetadata.calls.length;
+        if (actualCallCount !== expectedCallCount) {
+            throw new Error(`Expected function to be called ${expectedCallCount} times, but was called ${actualCallCount} times.`);
+        }
+    }
+    nthInvocation(invocationIndex) {
+        if (invocationIndex < 0 || invocationIndex >= this.#functionStubMetadata.calls.length) {
+            throw new Error(`Invocation index ${invocationIndex} is out of bounds. There are only ${this.#functionStubMetadata.calls.length} invocations.`);
+        }
+        const call = this.#functionStubMetadata.calls[invocationIndex];
+        return new InvocationVerification(call);
+    }
+    firstInvocation() {
+        return this.nthInvocation(0);
+    }
+    lastInvocation() {
+        return this.nthInvocation(this.#functionStubMetadata.calls.length - 1);
+    }
+    invocationMatching(predicate) {
+        const call = this.#functionStubMetadata.calls.find(call => predicate(...call.args));
+        if (!call) {
+            throw new Error(`No invocation found matching the provided predicate.`);
+        }
+        return new InvocationVerification(call);
+    }
+}
+
+function verify(mockOrSpy) {
+    return new Proxy({}, {
+        get(_target, propertyName, _receiver) {
+            if (!mockOrSpy[mock$1].stubs.hasOwnProperty(propertyName)) {
+                throw new Error(`No stub defined for property "${String(propertyName)}".`);
+            }
+            const stub = mockOrSpy[mock$1].stubs[propertyName];
+            const stubMetadata = stub[stub$1];
+            if (stubMetadata.type === "function") {
+                return new FunctionVerification(stubMetadata.metadata);
+            }
+            else {
+                return new PropertyVerification(stubMetadata.metadata);
+            }
+        }
+    });
+}
+
+export { answer, callThrough, defaultValue, delegateTo, fixedValue, mock, noop, returnFixed, returnSerial, spy, stub, throwOnCall, trackValue, verify, when };

package/package.json

@@ -0,0 +1,15 @@
+{
+    "name": "prostub",
+    "version": "1.0.0",
+    "description": "A TypeScript library for creating mocks.",
+    "license": "MIT",
+    "peerDependencies": {
+        "tslib": "^2.8.1"
+    },
+    "type": "module",
+    "main": "index.mjs",
+    "types": "index.d.ts",
+    "scripts": {
+        "test": "echo \"If you read this, all tests succeeded in the pipeline. Refer to the source-code repository to verify.\""
+    }
+}