tsmockit 1.2.0 → 2.0.1

package/Mock/Any.d.ts

@@ -0,0 +1,6 @@
+export declare const ANY_VALUE = "ANYTHING";
+/**
+ * Returns a value Mock understands to represent "ANYTHING" casted to "T"
+ * @returns
+ */
+export declare function Any<T>(): T;

package/Mock/Any.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Any = exports.ANY_VALUE = void 0;
+exports.ANY_VALUE = 'ANYTHING';
+/**
+ * Returns a value Mock understands to represent "ANYTHING" casted to "T"
+ * @returns
+ */
+function Any() {
+    return exports.ANY_VALUE;
+}
+exports.Any = Any;
+//# sourceMappingURL=Any.js.map

package/Mock/Constants.d.ts

@@ -2,4 +2,5 @@ export declare const Regex: {
     Operation: RegExp;
     Property: RegExp;
     Params: RegExp;
+    AnyValue: RegExp;
 };

package/Mock/Constants.js

@@ -4,6 +4,7 @@ exports.Regex = void 0;
 exports.Regex = {
     Operation: /\s[\w\d_]*\.([\w\d$_]*)\(([\w\W\d$_]*)\)/,
     Property: /\s[\w\d_]*\.([\w\d$_]*)/,
-    Params: /({.*?}|[^,]+)/g
+    Params: /({.*?}|[^,]+)/g,
+    AnyValue: /\((0, (.*?).Any)\)\(\)/g
 };
 //# sourceMappingURL=Constants.js.map

package/Mock/FunctionMap.d.ts

@@ -0,0 +1,7 @@
+export declare type FunctionMap = {
+    state: string | string[];
+    returns: Function;
+    timesCalled: number;
+    singleUse: boolean;
+    originalSignature: string | undefined;
+};

package/Mock/{TypeLiterals.js → FunctionMap.js}

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=TypeLiterals.js.map
+//# sourceMappingURL=FunctionMap.js.map

package/Mock/Mock.d.ts

@@ -2,13 +2,43 @@ import { Times } from './Times';
 export declare class Mock<T> {
     private memberSignatureMaps;
     private object;
+    /**
+     * The mock object of the given type "T" to inject as a substitute to a concrete implementation
+     */
     get Object(): T;
+    /**
+     * Configure what the mock object will return when a given member is accessed
+     * @param member
+     * @param returns
+     */
     Setup(member: (func: T) => any, returns?: any): void;
+    /**
+     * Configure a setup that will only resolve on the first time the member is registered
+     * @param member
+     * @param returns
+     */
+    SetupOnce(member: (func: T) => any, returns?: any): void;
+    /**
+     * Configure a set of setups that will only resolve on the first time the member is registered
+     * @param setups
+     */
+    SetupSequence(setups: [(func: T) => any, any][]): void;
+    /**
+     * Return the number of times a given member was referenced
+     * @param member
+     * @returns
+     */
     TimesMemberCalled(member: (func: T) => any): number;
+    /**
+     * Make an assertion that a given member was referenced a given number of times
+     * @param member
+     * @param times
+     */
     Verify(member: (func: T) => any, times: Times | number): void;
-    private getReturnsValueForProperty;
-    private getReturnsForFunction;
+    private setup;
+    private getReturnValueForProperty;
+    private getReturnForFunction;
+    private getFunctionMapsFromSignature;
     private updateMemberSignatureMaps;
     private updateSignatureMapFunctions;
-    private getFunctionMapFromSignatureMap;
 }

package/Mock/Mock.js

@@ -2,70 +2,127 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Mock = void 0;
 var SignatureService_1 = require("./SignatureService");
+var Any_1 = require("./Any");
 var Mock = /** @class */ (function () {
     function Mock() {
         this.memberSignatureMaps = new Array();
         this.object = {};
     }
     Object.defineProperty(Mock.prototype, "Object", {
+        /**
+         * The mock object of the given type "T" to inject as a substitute to a concrete implementation
+         */
         get: function () {
             return this.object;
         },
         enumerable: false,
         configurable: true
     });
+    /**
+     * Configure what the mock object will return when a given member is accessed
+     * @param member
+     * @param returns
+     */
     Mock.prototype.Setup = function (member, returns) {
+        if (returns === void 0) { returns = null; }
+        this.setup(member, returns);
+    };
+    /**
+     * Configure a setup that will only resolve on the first time the member is registered
+     * @param member
+     * @param returns
+     */
+    Mock.prototype.SetupOnce = function (member, returns) {
+        if (returns === void 0) { returns = null; }
+        this.setup(member, returns, true);
+    };
+    /**
+     * Configure a set of setups that will only resolve on the first time the member is registered
+     * @param setups
+     */
+    Mock.prototype.SetupSequence = function (setups) {
+        var _this = this;
+        setups.forEach(function (setup) {
+            _this.SetupOnce(setup[0], setup[1]);
+        });
+    };
+    /**
+     * Return the number of times a given member was referenced
+     * @param member
+     * @returns
+     */
+    Mock.prototype.TimesMemberCalled = function (member) {
+        var _a;
+        var memberSignatureMap = SignatureService_1.SignatureService.GetMemberSignatureMap(member);
+        var functionMap = this.getFunctionMapsFromSignature(memberSignatureMap, (_a = memberSignatureMap.functionMaps[0]) === null || _a === void 0 ? void 0 : _a.state).functionMapForArgs;
+        return (functionMap === null || functionMap === void 0 ? void 0 : functionMap.timesCalled) || 0;
+    };
+    /**
+     * Make an assertion that a given member was referenced a given number of times
+     * @param member
+     * @param times
+     */
+    Mock.prototype.Verify = function (member, times) {
+        var timesCalled = this.TimesMemberCalled(member);
+        var signature = SignatureService_1.SignatureService.GetMemberSignatureMap(member).signature;
+        var memberSignatureMap = this.memberSignatureMaps.find(function (m) { return m.signature === signature; });
+        if (timesCalled !== times) {
+            // eslint-disable-next-line no-console
+            console.log("Actual calls made for, \"" + signature + ":", memberSignatureMap === null || memberSignatureMap === void 0 ? void 0 : memberSignatureMap.functionMaps.map(function (m) { return m.originalSignature + " x " + m.timesCalled; }));
+        }
+        expect(timesCalled).toEqual(times, timesCalled !== times ? '' : undefined);
+    };
+    Mock.prototype.setup = function (member, returns, singleUse) {
         var _this = this;
         if (returns === void 0) { returns = null; }
-        var memberSignatureMap = SignatureService_1.SignatureService.GetMemberSignatureMap(member, returns);
+        if (singleUse === void 0) { singleUse = false; }
+        var memberSignatureMap = SignatureService_1.SignatureService.GetMemberSignatureMap(member, returns, singleUse);
         this.updateMemberSignatureMaps(memberSignatureMap);
         var memberName = SignatureService_1.SignatureService.GetMemberNameFromSignature(memberSignatureMap.signature);
         if (SignatureService_1.SignatureService.MemberSignatureIsProperty(memberSignatureMap.signature)) {
-            this.object[memberName] = this.getReturnsValueForProperty(memberSignatureMap);
+            this.object[memberName] = this.getReturnValueForProperty(memberSignatureMap);
         }
         else {
             this.object[memberName] = (function () {
+                var _a;
                 var args = [];
                 for (var _i = 0; _i < arguments.length; _i++) {
                     args[_i] = arguments[_i];
                 }
-                var returnFunction = _this.getReturnsForFunction(memberSignatureMap, args);
-                return returnFunction ? returnFunction() :
-                    (function () { return console.error('Unable to resolve setup function'); })();
+                return (_a = _this.getReturnForFunction(memberSignatureMap, args)) === null || _a === void 0 ? void 0 : _a();
             });
         }
     };
-    Mock.prototype.TimesMemberCalled = function (member) {
-        var memberSignature = SignatureService_1.SignatureService.GetMemberSignatureMap(member);
-        var functionMap = this.getFunctionMapFromSignatureMap(memberSignature);
-        var timesCalled = functionMap ? functionMap.timesCalled : 0;
-        return timesCalled;
-    };
-    Mock.prototype.Verify = function (member, times) {
-        var timesCalled = this.TimesMemberCalled(member);
-        expect(timesCalled).toEqual(times);
+    Mock.prototype.getReturnValueForProperty = function (memberSignatureMap) {
+        var _a, _b;
+        return ((_b = (_a = this.memberSignatureMaps.find(function (s) { return s.signature === memberSignatureMap.signature; })) === null || _a === void 0 ? void 0 : _a.functionMaps[0]) === null || _b === void 0 ? void 0 : _b.returns) || null;
     };
-    Mock.prototype.getReturnsValueForProperty = function (memberSignatureMap) {
-        var value = null;
-        var existingMemberSignatureMap = this.memberSignatureMaps.find(function (s) { return s.signature === memberSignatureMap.signature; });
-        if (existingMemberSignatureMap) {
-            value = existingMemberSignatureMap.functionMaps[0] ? existingMemberSignatureMap.functionMaps[0].returns : null;
-        }
-        return value;
+    Mock.prototype.getReturnForFunction = function (memberSignatureMap, args) {
+        var _a = this.getFunctionMapsFromSignature(memberSignatureMap, args), functionMapForArgs = _a.functionMapForArgs, signatureFunctionMaps = _a.signatureFunctionMaps;
+        return functionMapForArgs ? (function () {
+            functionMapForArgs.timesCalled++;
+            if (signatureFunctionMaps && functionMapForArgs.singleUse) {
+                var indexToDelete = signatureFunctionMaps.indexOf(functionMapForArgs);
+                signatureFunctionMaps.splice(indexToDelete, 1);
+            }
+            return functionMapForArgs.returns;
+        }) : undefined;
     };
-    Mock.prototype.getReturnsForFunction = function (memberSignatureMap, args) {
-        var returnFunction;
+    Mock.prototype.getFunctionMapsFromSignature = function (memberSignatureMap, args) {
         var existingMemberSignatureMap = this.memberSignatureMaps.find(function (s) { return s.signature === memberSignatureMap.signature; });
-        var defaultFunctionMap = memberSignatureMap.functionMaps[0];
-        if (existingMemberSignatureMap && defaultFunctionMap) {
-            var exactFunctionMap = existingMemberSignatureMap.functionMaps.find(function (m) { return JSON.stringify(m.state) === JSON.stringify(args); });
-            var functionMap_1 = exactFunctionMap ? exactFunctionMap : defaultFunctionMap;
-            returnFunction = (function () {
-                functionMap_1.timesCalled++;
-                return functionMap_1.returns;
+        var signatureFunctionMaps = existingMemberSignatureMap === null || existingMemberSignatureMap === void 0 ? void 0 : existingMemberSignatureMap.functionMaps;
+        var functionMapForArgs = signatureFunctionMaps === null || signatureFunctionMaps === void 0 ? void 0 : signatureFunctionMaps.find(function (m) { return JSON.stringify(m.state) === JSON.stringify(args); });
+        var functionMapsUsingAny = signatureFunctionMaps === null || signatureFunctionMaps === void 0 ? void 0 : signatureFunctionMaps.filter(function (m) { return m.state.includes(Any_1.ANY_VALUE); });
+        if (!functionMapForArgs && (functionMapsUsingAny === null || functionMapsUsingAny === void 0 ? void 0 : functionMapsUsingAny.length)) {
+            functionMapsUsingAny.forEach(function (element) {
+                if (!functionMapForArgs) {
+                    var anyTransposedState_1 = new Array();
+                    args.forEach(function (a, i) { return anyTransposedState_1[i] = element.state[i] === Any_1.ANY_VALUE ? Any_1.ANY_VALUE : a; });
+                    functionMapForArgs = signatureFunctionMaps === null || signatureFunctionMaps === void 0 ? void 0 : signatureFunctionMaps.find(function (m) { return JSON.stringify(m.state) === JSON.stringify(anyTransposedState_1); });
+                }
             });
         }
-        return returnFunction;
+        return { functionMapForArgs: functionMapForArgs, signatureFunctionMaps: signatureFunctionMaps };
     };
     Mock.prototype.updateMemberSignatureMaps = function (memberSignatureMap) {
         var existingSignatureMap = this.memberSignatureMaps.find(function (m) { return m.signature === memberSignatureMap.signature; });
@@ -79,7 +136,7 @@ var Mock = /** @class */ (function () {
     };
     Mock.prototype.updateSignatureMapFunctions = function (existingSignatureMap, newFunctionMap) {
         var existingFunctionMap = existingSignatureMap.functionMaps.find(function (fm) { return JSON.stringify(fm.state) === JSON.stringify(newFunctionMap.state); });
-        if (existingFunctionMap) {
+        if (existingFunctionMap && !newFunctionMap.singleUse) {
             var functionMaps = existingSignatureMap.functionMaps;
             functionMaps.splice(functionMaps.indexOf(existingFunctionMap), 1, newFunctionMap);
         }
@@ -87,21 +144,6 @@ var Mock = /** @class */ (function () {
             existingSignatureMap.functionMaps.push(newFunctionMap);
         }
     };
-    Mock.prototype.getFunctionMapFromSignatureMap = function (memberSignature) {
-        var functionMap;
-        var existingMember = this.memberSignatureMaps.find(function (m) { return m.signature === memberSignature.signature; });
-        var functionMapToFind = memberSignature.functionMaps[0];
-        if (existingMember && functionMapToFind) {
-            var functionMapCount = existingMember.functionMaps ? existingMember.functionMaps.length : 0;
-            if (functionMapCount === 1) {
-                functionMap = existingMember.functionMaps[0];
-            }
-            else {
-                functionMap = existingMember.functionMaps.find(function (m) { return JSON.stringify(m.state) === JSON.stringify(functionMapToFind.state); });
-            }
-        }
-        return functionMap;
-    };
     return Mock;
 }());
 exports.Mock = Mock;

package/Mock/SignatureMap.d.ts

@@ -0,0 +1,5 @@
+import { FunctionMap } from './FunctionMap';
+export declare type SignatureMap = {
+    signature: string;
+    functionMaps: Array<FunctionMap>;
+};

package/Mock/SignatureMap.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=SignatureMap.js.map

package/Mock/SignatureService.d.ts

@@ -1,8 +1,9 @@
-import { SignatureMap } from './TypeLiterals';
+import { SignatureMap } from './SignatureMap';
 export declare class SignatureService {
-    static GetMemberSignatureMap(value: (obj: any) => any, returns?: any): SignatureMap;
+    static GetMemberSignatureMap(value: (obj: any) => any, returns?: any, singleUse?: boolean): SignatureMap;
     static MemberSignatureIsProperty(memberSignatureString: string): boolean;
     static GetMemberNameFromSignature(memberSignatureString: string): string;
+    private static getOriginalSignature;
     private static getPropertyMemberSignature;
     private static getOperationMemberSignature;
     private static getStateForMemberSignature;

package/Mock/SignatureService.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SignatureService = void 0;
+var Any_1 = require("./Any");
 var Constants_1 = require("./Constants");
 var SignatureService = /** @class */ (function () {
     function SignatureService() {
     }
-    SignatureService.GetMemberSignatureMap = function (value, returns) {
+    SignatureService.GetMemberSignatureMap = function (value, returns, singleUse) {
+        if (singleUse === void 0) { singleUse = false; }
         var memberSignature = '';
         memberSignature =
             this.getOperationMemberSignature(value, memberSignature) ||
@@ -14,7 +16,13 @@ var SignatureService = /** @class */ (function () {
             SignatureService.getStateForMemberSignature(memberSignature, value);
         return {
             signature: memberSignature,
-            functionMaps: [{ state: state, returns: returns ? returns : null, timesCalled: 0 }]
+            functionMaps: [{
+                    state: state,
+                    returns: returns,
+                    timesCalled: 0,
+                    singleUse: singleUse,
+                    originalSignature: this.getOriginalSignature(value)
+                }]
         };
     };
     SignatureService.MemberSignatureIsProperty = function (memberSignatureString) {
@@ -24,6 +32,13 @@ var SignatureService = /** @class */ (function () {
         return SignatureService.MemberSignatureIsProperty(memberSignatureString) ?
             memberSignatureString : memberSignatureString.split('(')[0];
     };
+    SignatureService.getOriginalSignature = function (value) {
+        var originalSignature = value.toString();
+        originalSignature = (originalSignature === null || originalSignature === void 0 ? void 0 : originalSignature.indexOf('i.')) ? originalSignature.split('i.')[1] : originalSignature;
+        originalSignature = (originalSignature === null || originalSignature === void 0 ? void 0 : originalSignature.indexOf(';')) ? originalSignature.split(';')[0] : originalSignature;
+        return originalSignature === null || originalSignature === void 0 ? void 0 : originalSignature.trim();
+    };
+    ;
     SignatureService.getPropertyMemberSignature = function (value, memberSignature) {
         var propertyMemberMatches = SignatureService.getMatchesForRegex(value, Constants_1.Regex.Property);
         if (propertyMemberMatches && propertyMemberMatches[1]) {
@@ -64,7 +79,9 @@ var SignatureService = /** @class */ (function () {
         return matches;
     };
     SignatureService.getParamString = function (operationNameMatches) {
-        var paramStrings = operationNameMatches[2].match(Constants_1.Regex.Params);
+        var paramStrings = operationNameMatches[2]
+            .replace(Constants_1.Regex.AnyValue, Any_1.ANY_VALUE)
+            .match(Constants_1.Regex.Params);
         var params = '';
         for (var index = 0; index < (paramStrings ? paramStrings.length : 0); index++) {
             params += ((index > 0 ? ', ' : '') + "p" + index);

package/Mock/module.d.ts

@@ -0,0 +1,3 @@
+export * from './Mock';
+export * from './Times';
+export { Any } from './Any';

package/Mock/module.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Any = void 0;
+var tslib_1 = require("tslib");
+(0, tslib_1.__exportStar)(require("./Mock"), exports);
+(0, tslib_1.__exportStar)(require("./Times"), exports);
+var Any_1 = require("./Any");
+Object.defineProperty(exports, "Any", { enumerable: true, get: function () { return Any_1.Any; } });
+//# sourceMappingURL=module.js.map

package/README.md

@@ -4,64 +4,18 @@ Generic mocking library for TypeScript
 [![CI](https://github.com/bayes343/tsmockit/actions/workflows/ci.yml/badge.svg)](https://github.com/bayes343/tsmockit/actions/workflows/ci.yml)
 ![Language grade: JavaScript](https://img.shields.io/lgtm/grade/javascript/g/bayes343/tsmockit.svg?logo=lgtm&logoWidth=18)
 
-
 Helpful links:
 - [GitHub](https://github.com/bayes343/tsmockit)
 - [npm](https://www.npmjs.com/package/tsmockit)
+- [Docs](https://bayes343.github.io/tsmockit/modules.html)
 
-This library exposes a generic class, `Mock<T>`, which allows you to mock dependencies and verify usage in an intuitive and type safe manner.
+This library exposes a generic class, `Mock<T>`, which allows you to mock dependencies and verify usage in an intuitive and type safe manner.  Its API is based on the C# "moq" library.
 
-Public interface:
+The below example demonstrates some of the features of this library. Please explore the "docs" linked above for further details.
 
 ```typescript
-class Mock<T>
-```
-```typescript
-Setup(
-  member: (func: T) => any,
-  returns: any = null
-): void
-```
-```typescript
-TimesMemberCalled(
-  member: (func: T) => any
-): number
-```
-```typescript
-Verify(
-  member: (func: T) => any,
-  times: Times | number
-): void
-```
+// https://github.com/bayes343/tsmockit/blob/master/src/Mock/tests/Mock-Car-Example.spec.ts
 
-```typescript
-class TestHelpers
-```
-```typescript
-static EmitEventAtElement(element: HTMLElement, eventType: string): void
-```
-```typescript
-static EmitKeyEventAtElement(
-  element: HTMLInputElement,
-  key: string,
-  keyEvent: 'keydown' | 'keypress' | 'keyup' | 'input'
-): void
-```
-```typescript
-static async Expect<T>(
-  selector: () => T,
-  assertion: (m: jasmine.Matchers<T>) => void,
-  interval = 0,
-  getTimeFunc = () => Date.now()
-): Promise<void>
-```
-
-## Usage
-
-### Scenario
-Consider this dependency injection scenario.
-
-```ts
 interface IEngine {
   Start(): void;
   Stop(): void;
@@ -113,37 +67,62 @@ class Car {
     return this.stereo.SetStation(frequency);
   }
 }
-```
-
-The `Car` class above uses dependency injection for its engine, odometer, and stereo dependencies.
-
-It's a best practice to use dependency injection over 'newing' up concretions inside a class instance.  This allows true unit testing as well as widely opening the door to future extendability.
-
-### Example
-Here's how you would use `tsmockit` to mock the above dependencies and test the `Car` class.
-
-```ts
-// Instantiate mocks
-const mockIEngine = new Mock<IEngine>();
-const mockIOdometer = new Mock<IOdometer>();
-const mockIStereo = new Mock<IStereo>();
-
-// Instantiate car, passing mock 'Objects' as its dependencies
-const car = new Car(mockIEngine.Object, mockIOdometer.Object, mockIStereo.Object);
-
-// 'Setup' the mock odometer to return 100
-mockIOdometer.Setup(o => o.GetMileage(), 100);
-
-// Assert that the Car's mileage property returns 100 and that our mock GetMileage method is called exactly once
-expect(car.Mileage).toEqual(100);
-mockIOdometer.Verify(o => o.GetMileage(), 1);
 
-// Setup mock stereo to return different strings for different arguments
-mockIStereo.Setup(s => s.SetStation(1), 'Station set to 1');
-mockIStereo.Setup(s => s.SetStation(2), 'Station set to 2');
+describe('Car', () => {
+  let car: Car;
+  const mockIEngine = new Mock<IEngine>();
+  const mockIOdometer = new Mock<IOdometer>();
+  const mockIStereo = new Mock<IStereo>();
+
+  beforeEach(() => {
+    car = new Car(mockIEngine.Object, mockIOdometer.Object, mockIStereo.Object);
+  });
+
+  it('should call Engine.Start when StartEngine is called', () => {
+    mockIEngine.Setup(e => e.Start());
+    car.StartEngine();
+    mockIEngine.Verify(e => e.Start(), Times.Once);
+  });
+
+  it('should call Engine.Stop when StopEngine is called', () => {
+    mockIEngine.Setup(e => e.Stop());
+    car.StopEngine();
+    mockIEngine.Verify(e => e.Stop(), Times.Once);
+  });
+
+  it('should return the result of Odometer.GetMileage on referencing the Mileage property', () => {
+    mockIOdometer.Setup(o => o.GetMileage(), 100);
+
+    const mileage = car.Mileage;
+
+    expect(mileage).toEqual(100);
+    mockIOdometer.Verify(o => o.GetMileage(), Times.Once);
+  });
+
+  it('should call Stereo.SetStation on calling ChangeRadioStation returning the string from Stereo', () => {
+    mockIStereo.Setup(s => s.SetStation(Any<number>()), 'Station set'); // default fallback setup when a more specific setup isn't available
+    mockIStereo.Setup(s => s.SetStation(3), 'Station 3');
+
+    expect(car.ChangeRadioStation(3)).toEqual('Station 3');
+    expect(car.ChangeRadioStation(0)).toEqual('Station set');
+    expect(car.ChangeRadioStation(2)).toEqual('Station set');
+
+    mockIStereo.Verify(s => s.SetStation(3), Times.Once);
+    mockIStereo.Verify(s => s.SetStation(Any<number>()), 2);
+  });
+});
 ```
 
-## Conventions
-You'll often want a mock to return the same response regardless of input parameters.  This library accommodates this through these conventions:
-- If only one 'Setup' is made for a given method, the return value will be used for any combination of parameters (i.e. parameter values other than those specified in the setup).
-- If a method is called and no exact setup is available, the first 'Setup' will be returned.  In other words, if you have multiple setups for a method and this method is called using parameters that none of those setups accounted for, the return value will be the one specified in the first setup.
+## Version 2 notes
+
+- Any\<T\>
+  - A helper function which allows clients to create "Setups" on methods to be used disregarding all, or some, of the exact values the method is called with.
+    ```typescript
+    mockIStereo.Setup(s => s.SetStation(Any<number>()), 'Station set');
+    ```
+- SetupOnce
+  - Creates a setup the same as the regular `Setup` method except for once the setup is used, it will de-register itself.
+  - One use could be an inferred guarantee that a given method on a dependency is not being called more than you expect. Using `SetupOnce` for a setup that should only be used once, will have the inherent effect of leading to a runtime error at test time on the second execution.
+- SetupSequence
+  - Creates several, "one time" setups for a given method.
+  - You'll occasionally want the first execution of a given method on a dependency to return "x" but then "y" on the following execution.  Use `SetupSequence` to achieve this.

package/Utility/EmitEventAtElement.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Emit an event at a given element
+ * @param element
+ * @param eventType
+ */
+export declare function EmitEventAtElement(element: HTMLElement, eventType: string): void;

package/Utility/EmitEventAtElement.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmitEventAtElement = void 0;
+/**
+ * Emit an event at a given element
+ * @param element
+ * @param eventType
+ */
+function EmitEventAtElement(element, eventType) {
+    var event = document.createEvent('Event');
+    event.initEvent(eventType);
+    element.dispatchEvent(event);
+}
+exports.EmitEventAtElement = EmitEventAtElement;
+//# sourceMappingURL=EmitEventAtElement.js.map

package/Utility/EmitKeyEventAtElement.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Emit a key event at a given element
+ * @param element
+ * @param key
+ * @param keyEvent
+ */
+export declare function EmitKeyEventAtElement(element: HTMLInputElement, key: string, keyEvent: 'keydown' | 'keypress' | 'keyup' | 'input'): void;

package/Utility/EmitKeyEventAtElement.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmitKeyEventAtElement = void 0;
+/**
+ * Emit a key event at a given element
+ * @param element
+ * @param key
+ * @param keyEvent
+ */
+function EmitKeyEventAtElement(element, key, keyEvent) {
+    var event = document.createEvent('Event');
+    event['keyCode'] = key;
+    event['key'] = key;
+    event.initEvent(keyEvent);
+    element.dispatchEvent(event);
+}
+exports.EmitKeyEventAtElement = EmitKeyEventAtElement;
+//# sourceMappingURL=EmitKeyEventAtElement.js.map

package/Utility/Expect.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="jasmine" />
+/**
+ * Performs an asynchronous assertion, allowing up to one second to pass before failing
+ * @param selector A function that returns the subject of the assertion once it is expected to pass.
+ * @param assertion A function that is given the result of the selector function for normal jasmine assertions.
+ */
+export declare function Expect<T>(selector: () => T, assertion: (m: jasmine.Matchers<T>) => void, interval?: number, getTimeFunc?: () => number): Promise<void>;

package/Utility/Expect.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Expect = void 0;
+/**
+ * Performs an asynchronous assertion, allowing up to one second to pass before failing
+ * @param selector A function that returns the subject of the assertion once it is expected to pass.
+ * @param assertion A function that is given the result of the selector function for normal jasmine assertions.
+ */
+function Expect(selector, assertion, interval, getTimeFunc) {
+    if (interval === void 0) { interval = 0; }
+    if (getTimeFunc === void 0) { getTimeFunc = function () { return Date.now(); }; }
+    return new Promise(function (resolve) {
+        var startTime = getTimeFunc();
+        var timedOut = function () { return getTimeFunc() - startTime > 1000; };
+        var execute = function () {
+            var selection = selector();
+            if (selection || timedOut()) {
+                assertion(expect(selection));
+                resolve();
+            }
+            else {
+                setTimeout(function () { return execute(); }, interval);
+            }
+        };
+        execute();
+    });
+}
+exports.Expect = Expect;
+//# sourceMappingURL=Expect.js.map

package/Utility/module.d.ts

@@ -0,0 +1,3 @@
+export * from './EmitEventAtElement';
+export * from './EmitKeyEventAtElement';
+export * from './Expect';

package/Utility/module.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+(0, tslib_1.__exportStar)(require("./EmitEventAtElement"), exports);
+(0, tslib_1.__exportStar)(require("./EmitKeyEventAtElement"), exports);
+(0, tslib_1.__exportStar)(require("./Expect"), exports);
+//# sourceMappingURL=module.js.map

package/package.json

@@ -14,7 +14,7 @@
     "dependency injection"
   ],
   "license": "MIT",
-  "version": "1.2.0",
+  "version": "2.0.1",
   "description": "Generic mocking library for TypeScript",
   "private": false,
   "main": "./public_api.js",

package/public_api.d.ts

@@ -1,3 +1,2 @@
-export * from './Mock/Mock';
-export * from './Mock/Times';
-export * from './Utility/TestHelpers';
+export * from './Mock/module';
+export * from './Utility/module';

package/public_api.js

@@ -1,10 +1,6 @@
 "use strict";
-/*
- * Public API Surface of tsmockit
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 var tslib_1 = require("tslib");
-(0, tslib_1.__exportStar)(require("./Mock/Mock"), exports);
-(0, tslib_1.__exportStar)(require("./Mock/Times"), exports);
-(0, tslib_1.__exportStar)(require("./Utility/TestHelpers"), exports);
+(0, tslib_1.__exportStar)(require("./Mock/module"), exports);
+(0, tslib_1.__exportStar)(require("./Utility/module"), exports);
 //# sourceMappingURL=public_api.js.map

package/Mock/TypeLiterals.d.ts

@@ -1,9 +0,0 @@
-export declare type FunctionMap = {
-    state: string;
-    returns: Function;
-    timesCalled: number;
-};
-export declare type SignatureMap = {
-    signature: string;
-    functionMaps: Array<FunctionMap>;
-};

package/Utility/TestHelpers.d.ts

@@ -1,30 +0,0 @@
-/// <reference types="jasmine" />
-export declare class TestHelpers {
-    /**
-     * Emit an event at a given element
-     * @param element
-     * @param eventType
-     */
-    static EmitEventAtElement(element: HTMLElement, eventType: string): void;
-    /**
-     * Emit a key event at a given element
-     * @param element
-     * @param key
-     * @param keyEvent
-     */
-    static EmitKeyEventAtElement(element: HTMLInputElement, key: string, keyEvent: 'keydown' | 'keypress' | 'keyup' | 'input'): void;
-    /**
-     * Wait up to 1 second for a given condition to be true
-     * @deprecated Will be removed in version 2 - Use "Expect" instead
-     * @param condition
-     * @param interval
-     * @returns true if condition is met before 1 second limit, false otherwise
-     */
-    static TimeLapsedCondition(condition: () => boolean, interval?: number): Promise<boolean>;
-    /**
-     * Performs an asynchronous assertion, allowing up to one second to pass before failing
-     * @param selector A function that returns the subject of the assertion once it is expected to pass.
-     * @param assertion A function that is given the result of the selector function for normal jasmine assertions.
-     */
-    static Expect<T>(selector: () => T, assertion: (m: jasmine.Matchers<T>) => void, interval?: number, getTimeFunc?: () => number): Promise<void>;
-}

package/Utility/TestHelpers.js

@@ -1,97 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TestHelpers = void 0;
-var tslib_1 = require("tslib");
-var TestHelpers = /** @class */ (function () {
-    function TestHelpers() {
-    }
-    /**
-     * Emit an event at a given element
-     * @param element
-     * @param eventType
-     */
-    TestHelpers.EmitEventAtElement = function (element, eventType) {
-        var event = document.createEvent('Event');
-        event.initEvent(eventType);
-        element.dispatchEvent(event);
-    };
-    /**
-     * Emit a key event at a given element
-     * @param element
-     * @param key
-     * @param keyEvent
-     */
-    TestHelpers.EmitKeyEventAtElement = function (element, key, keyEvent) {
-        var event = document.createEvent('Event');
-        event['keyCode'] = key;
-        event['key'] = key;
-        event.initEvent(keyEvent);
-        element.dispatchEvent(event);
-    };
-    /**
-     * Wait up to 1 second for a given condition to be true
-     * @deprecated Will be removed in version 2 - Use "Expect" instead
-     * @param condition
-     * @param interval
-     * @returns true if condition is met before 1 second limit, false otherwise
-     */
-    TestHelpers.TimeLapsedCondition = function (condition, interval) {
-        if (interval === void 0) { interval = 10; }
-        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
-            var _this = this;
-            return (0, tslib_1.__generator)(this, function (_a) {
-                return [2 /*return*/, new Promise(function (resolve) {
-                        var assertionPassed = false;
-                        var elapsedTime = 0;
-                        var enabled = (function () {
-                            return !assertionPassed && elapsedTime < 1000;
-                        });
-                        var executer = setInterval(function () { return (0, tslib_1.__awaiter)(_this, void 0, void 0, function () {
-                            return (0, tslib_1.__generator)(this, function (_a) {
-                                elapsedTime += interval;
-                                if (enabled()) {
-                                    assertionPassed = condition();
-                                }
-                                else {
-                                    clearInterval(executer);
-                                    resolve(assertionPassed);
-                                }
-                                return [2 /*return*/];
-                            });
-                        }); }, interval);
-                    })];
-            });
-        });
-    };
-    /**
-     * Performs an asynchronous assertion, allowing up to one second to pass before failing
-     * @param selector A function that returns the subject of the assertion once it is expected to pass.
-     * @param assertion A function that is given the result of the selector function for normal jasmine assertions.
-     */
-    TestHelpers.Expect = function (selector, assertion, interval, getTimeFunc) {
-        if (interval === void 0) { interval = 0; }
-        if (getTimeFunc === void 0) { getTimeFunc = function () { return Date.now(); }; }
-        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
-            return (0, tslib_1.__generator)(this, function (_a) {
-                return [2 /*return*/, new Promise(function (resolve) {
-                        var startTime = getTimeFunc();
-                        var timedOut = function () { return getTimeFunc() - startTime > 1000; };
-                        var execute = function () {
-                            var selection = selector();
-                            if (selection || timedOut()) {
-                                assertion(expect(selection));
-                                resolve();
-                            }
-                            else {
-                                setTimeout(function () { return execute(); }, interval);
-                            }
-                        };
-                        execute();
-                    })];
-            });
-        });
-    };
-    return TestHelpers;
-}());
-exports.TestHelpers = TestHelpers;
-//# sourceMappingURL=TestHelpers.js.map