tsmockit 1.3.0 → 2.0.0

package/Mock/Any.d.ts

@@ -0,0 +1,2 @@
+export declare const ANY_VALUE = "ANYTHING";
+export declare function Any<T>(): T;

package/Mock/Any.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Any = exports.ANY_VALUE = void 0;
+exports.ANY_VALUE = 'ANYTHING';
+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

@@ -3,12 +3,15 @@ export declare class Mock<T> {
     private memberSignatureMaps;
     private object;
     get Object(): T;
-    Setup(member: (func: T) => any, returns?: any, exactSignatureMatch?: boolean): void;
+    Setup(member: (func: T) => any, returns?: any): void;
+    SetupOnce(member: (func: T) => any, returns?: any): void;
+    SetupSequence(setups: [(func: T) => any, any][]): void;
     TimesMemberCalled(member: (func: T) => any): number;
     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,6 +2,7 @@
 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();
@@ -14,15 +15,45 @@ var Mock = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
-    Mock.prototype.Setup = function (member, returns, exactSignatureMatch) {
+    Mock.prototype.Setup = function (member, returns) {
+        if (returns === void 0) { returns = null; }
+        this.setup(member, returns);
+    };
+    Mock.prototype.SetupOnce = function (member, returns) {
+        if (returns === void 0) { returns = null; }
+        this.setup(member, returns, true);
+    };
+    Mock.prototype.SetupSequence = function (setups) {
+        var _this = this;
+        setups.forEach(function (setup) {
+            _this.SetupOnce(setup[0], setup[1]);
+        });
+    };
+    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;
+    };
+    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; }
-        if (exactSignatureMatch === void 0) { exactSignatureMatch = false; }
-        var memberSignatureMap = SignatureService_1.SignatureService.GetMemberSignatureMap(member, returns, exactSignatureMatch);
+        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 () {
@@ -31,37 +62,40 @@ var Mock = /** @class */ (function () {
                 for (var _i = 0; _i < arguments.length; _i++) {
                     args[_i] = arguments[_i];
                 }
-                return (_a = _this.getReturnsForFunction(memberSignatureMap, args, exactSignatureMatch)) === null || _a === void 0 ? void 0 : _a();
+                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.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.Verify = function (member, times) {
-        var timesCalled = this.TimesMemberCalled(member);
-        expect(timesCalled).toEqual(times);
+    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.getReturnsValueForProperty = function (memberSignatureMap) {
-        var value = null;
+    Mock.prototype.getFunctionMapsFromSignature = function (memberSignatureMap, args) {
         var existingMemberSignatureMap = this.memberSignatureMaps.find(function (s) { return s.signature === memberSignatureMap.signature; });
-        if (existingMemberSignatureMap) {
-            value = existingMemberSignatureMap.functionMaps[0] ? existingMemberSignatureMap.functionMaps[0].returns : null;
+        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 value;
-    };
-    Mock.prototype.getReturnsForFunction = function (memberSignatureMap, args, exactSignatureMatch) {
-        var existingMemberSignatureMap = this.memberSignatureMaps.find(function (s) { return s.signature === memberSignatureMap.signature; });
-        var exactFunctionMap = existingMemberSignatureMap === null || existingMemberSignatureMap === void 0 ? void 0 : existingMemberSignatureMap.functionMaps.find(function (m) { return JSON.stringify(m.state) === JSON.stringify(args); });
-        var defaultFunctionMap = exactSignatureMatch ? undefined : existingMemberSignatureMap === null || existingMemberSignatureMap === void 0 ? void 0 : existingMemberSignatureMap.functionMaps.find(function (m) { return m.default; });
-        var functionMap = exactFunctionMap || defaultFunctionMap;
-        return functionMap ? (function () {
-            functionMap.timesCalled++;
-            return functionMap.returns;
-        }) : undefined;
+        return { functionMapForArgs: functionMapForArgs, signatureFunctionMaps: signatureFunctionMaps };
     };
     Mock.prototype.updateMemberSignatureMaps = function (memberSignatureMap) {
         var existingSignatureMap = this.memberSignatureMaps.find(function (m) { return m.signature === memberSignatureMap.signature; });
@@ -75,7 +109,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);
         }
@@ -83,12 +117,6 @@ var Mock = /** @class */ (function () {
             existingSignatureMap.functionMaps.push(newFunctionMap);
         }
     };
-    Mock.prototype.getFunctionMapFromSignatureMap = function (memberSignature) {
-        var existingMember = this.memberSignatureMaps.find(function (m) { return m.signature === memberSignature.signature; });
-        var functionMapToFind = memberSignature.functionMaps[0];
-        return (existingMember === null || existingMember === void 0 ? void 0 : existingMember.functionMaps.find(function (m) { return JSON.stringify(m.state) === JSON.stringify(functionMapToFind.state); })) ||
-            (existingMember === null || existingMember === void 0 ? void 0 : existingMember.functionMaps.find(function (m) { return m.default; }));
-    };
     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, exactSignatureMatch?: boolean): 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,12 +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, exactSignatureMatch) {
-        if (exactSignatureMatch === void 0) { exactSignatureMatch = false; }
+    SignatureService.GetMemberSignatureMap = function (value, returns, singleUse) {
+        if (singleUse === void 0) { singleUse = false; }
         var memberSignature = '';
         memberSignature =
             this.getOperationMemberSignature(value, memberSignature) ||
@@ -15,7 +16,13 @@ var SignatureService = /** @class */ (function () {
             SignatureService.getStateForMemberSignature(memberSignature, value);
         return {
             signature: memberSignature,
-            functionMaps: [{ default: !exactSignatureMatch, 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) {
@@ -25,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]) {
@@ -65,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

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

package/Mock/module.js

@@ -1,6 +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,65 +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,
-  exactSignatureMatch = false // will default to true and replace the signature matching convention as of v2.0.0.
-): void
-```
-```typescript
-TimesMemberCalled(
-  member: (func: T) => any
-): number
-```
-```typescript
-Verify(
-  member: (func: T) => any,
-  times: Times | number
-): void
-```
-
-```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.
+// https://github.com/bayes343/tsmockit/blob/master/src/Mock/tests/Mock-Car-Example.spec.ts
 
-```ts
 interface IEngine {
   Start(): void;
   Stop(): void;
@@ -114,40 +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
-
-***This convention will be replaced by passing `false` to the `exactSignatureMatch` param when calling `Setup` in version 2.0.0.***
-
-You'll often want a mock to return the same response regardless of input parameters.  The following convention accommodates this:
-
-- If a method is called and no exact setup is available, the first `Setup` called without overriding `exactSignatureMatch` to `true` will be used.
+## 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/module.d.ts

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

package/Utility/module.js

@@ -4,5 +4,4 @@ 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);
-(0, tslib_1.__exportStar)(require("./TestHelpers"), exports);
 //# sourceMappingURL=module.js.map

package/package.json

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

package/Mock/TypeLiterals.d.ts

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

package/Utility/TestHelpers.d.ts

@@ -1,33 +0,0 @@
-/// <reference types="jasmine" />
-/**
- * @deprecated This class will be removed in v2 - Import its functions directly as of 1.3.0
- */
-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,83 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TestHelpers = void 0;
-var tslib_1 = require("tslib");
-var EmitEventAtElement_1 = require("./EmitEventAtElement");
-var EmitKeyEventAtElement_1 = require("./EmitKeyEventAtElement");
-var Expect_1 = require("./Expect");
-/**
- * @deprecated This class will be removed in v2 - Import its functions directly as of 1.3.0
- */
-var TestHelpers = /** @class */ (function () {
-    function TestHelpers() {
-    }
-    /**
-     * Emit an event at a given element
-     * @param element
-     * @param eventType
-     */
-    TestHelpers.EmitEventAtElement = function (element, eventType) {
-        (0, EmitEventAtElement_1.EmitEventAtElement)(element, eventType);
-    };
-    /**
-     * Emit a key event at a given element
-     * @param element
-     * @param key
-     * @param keyEvent
-     */
-    TestHelpers.EmitKeyEventAtElement = function (element, key, keyEvent) {
-        (0, EmitKeyEventAtElement_1.EmitKeyEventAtElement)(element, key, keyEvent);
-    };
-    /**
-     * 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*/, (0, Expect_1.Expect)(selector, assertion, interval, getTimeFunc)];
-            });
-        });
-    };
-    return TestHelpers;
-}());
-exports.TestHelpers = TestHelpers;
-//# sourceMappingURL=TestHelpers.js.map