tsmockit 1.1.2 → 1.3.0

package/Mock/Mock.d.ts

@@ -3,7 +3,7 @@ export declare class Mock<T> {
     private memberSignatureMaps;
     private object;
     get Object(): T;
-    Setup(member: (func: T) => any, returns?: any): void;
+    Setup(member: (func: T) => any, returns?: any, exactSignatureMatch?: boolean): void;
     TimesMemberCalled(member: (func: T) => any): number;
     Verify(member: (func: T) => any, times: Times | number): void;
     private getReturnsValueForProperty;

package/Mock/Mock.js

@@ -14,10 +14,11 @@ var Mock = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
-    Mock.prototype.Setup = function (member, returns) {
+    Mock.prototype.Setup = function (member, returns, exactSignatureMatch) {
         var _this = this;
         if (returns === void 0) { returns = null; }
-        var memberSignatureMap = SignatureService_1.SignatureService.GetMemberSignatureMap(member, returns);
+        if (exactSignatureMatch === void 0) { exactSignatureMatch = false; }
+        var memberSignatureMap = SignatureService_1.SignatureService.GetMemberSignatureMap(member, returns, exactSignatureMatch);
         this.updateMemberSignatureMaps(memberSignatureMap);
         var memberName = SignatureService_1.SignatureService.GetMemberNameFromSignature(memberSignatureMap.signature);
         if (SignatureService_1.SignatureService.MemberSignatureIsProperty(memberSignatureMap.signature)) {
@@ -25,13 +26,12 @@ var Mock = /** @class */ (function () {
         }
         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.getReturnsForFunction(memberSignatureMap, args, exactSignatureMatch)) === null || _a === void 0 ? void 0 : _a();
             });
         }
     };
@@ -53,19 +53,15 @@ var Mock = /** @class */ (function () {
         }
         return value;
     };
-    Mock.prototype.getReturnsForFunction = function (memberSignatureMap, args) {
-        var returnFunction;
+    Mock.prototype.getReturnsForFunction = function (memberSignatureMap, args, exactSignatureMatch) {
         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;
-            });
-        }
-        return returnFunction;
+        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;
     };
     Mock.prototype.updateMemberSignatureMaps = function (memberSignatureMap) {
         var existingSignatureMap = this.memberSignatureMaps.find(function (m) { return m.signature === memberSignatureMap.signature; });
@@ -88,19 +84,10 @@ var Mock = /** @class */ (function () {
         }
     };
     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 (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;
 }());

package/Mock/SignatureService.d.ts

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

package/Mock/SignatureService.js

@@ -5,7 +5,8 @@ var Constants_1 = require("./Constants");
 var SignatureService = /** @class */ (function () {
     function SignatureService() {
     }
-    SignatureService.GetMemberSignatureMap = function (value, returns) {
+    SignatureService.GetMemberSignatureMap = function (value, returns, exactSignatureMatch) {
+        if (exactSignatureMatch === void 0) { exactSignatureMatch = false; }
         var memberSignature = '';
         memberSignature =
             this.getOperationMemberSignature(value, memberSignature) ||
@@ -14,7 +15,7 @@ var SignatureService = /** @class */ (function () {
             SignatureService.getStateForMemberSignature(memberSignature, value);
         return {
             signature: memberSignature,
-            functionMaps: [{ state: state, returns: returns ? returns : null, timesCalled: 0 }]
+            functionMaps: [{ default: !exactSignatureMatch, state: state, returns: returns ? returns : null, timesCalled: 0 }]
         };
     };
     SignatureService.MemberSignatureIsProperty = function (memberSignatureString) {

package/Mock/TypeLiterals.d.ts

@@ -1,4 +1,5 @@
 export declare type FunctionMap = {
+    default: boolean;
     state: string;
     returns: Function;
     timesCalled: number;

package/Mock/module.d.ts

@@ -0,0 +1,2 @@
+export * from './Mock';
+export * from './Times';

package/Mock/module.js

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

package/README.md

@@ -2,7 +2,6 @@
 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)
-![Code Coverage](https://img.shields.io/badge/Code%20Coverage-99%25-success?style=flat)
 ![Language grade: JavaScript](https://img.shields.io/lgtm/grade/javascript/g/bayes343/tsmockit.svg?logo=lgtm&logoWidth=18)
 
 
@@ -20,7 +19,8 @@ class Mock<T>
 ```typescript
 Setup(
   member: (func: T) => any,
-  returns: any = null
+  returns: any = null,
+  exactSignatureMatch = false // will default to true and replace the signature matching convention as of v2.0.0.
 ): void
 ```
 ```typescript
@@ -49,7 +49,12 @@ static EmitKeyEventAtElement(
 ): void
 ```
 ```typescript
-static async TimeLapsedCondition(condition: () => boolean, interval = 10): Promise<boolean>
+static async Expect<T>(
+  selector: () => T,
+  assertion: (m: jasmine.Matchers<T>) => void,
+  interval = 0,
+  getTimeFunc = () => Date.now()
+): Promise<void>
 ```
 
 ## Usage
@@ -140,6 +145,9 @@ mockIStereo.Setup(s => s.SetStation(2), 'Station set to 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.
+
+***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.

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/TestHelpers.d.ts

@@ -1,5 +1,33 @@
+/// <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

@@ -2,21 +2,39 @@
 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) {
-        var event = document.createEvent('Event');
-        event.initEvent(eventType);
-        element.dispatchEvent(event);
+        (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) {
-        var event = document.createEvent('Event');
-        event['keyCode'] = key;
-        event['key'] = key;
-        event.initEvent(keyEvent);
-        element.dispatchEvent(event);
+        (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 () {
@@ -45,6 +63,20 @@ var TestHelpers = /** @class */ (function () {
             });
         });
     };
+    /**
+     * 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;

package/Utility/module.d.ts

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

package/Utility/module.js

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

package/package.json

@@ -14,9 +14,9 @@
     "dependency injection"
   ],
   "license": "MIT",
-  "version": "1.1.2",
+  "version": "1.3.0",
   "description": "Generic mocking library for TypeScript",
   "private": false,
   "main": "./public_api.js",
   "types": "./public_api.d.ts"
-}
+}

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