tsmockit 2.0.5 → 2.0.7

package/Mock/FunctionMap.d.ts

@@ -1,5 +1,5 @@
 export type FunctionMap = {
-    state: string | string[];
+    state: (string | Function)[];
     returns: Function;
     timesCalled: number;
     singleUse: boolean;

package/Mock/Mock.d.ts

@@ -1,4 +1,5 @@
 import { Times } from './Times';
+type Member<T> = (func: T) => any;
 export declare class Mock<T> {
     private memberSignatureMaps;
     private object;
@@ -11,34 +12,37 @@ export declare class Mock<T> {
      * @param member
      * @param returns
      */
-    Setup(member: (func: T) => any, returns?: any): void;
+    Setup(member: Member<T>, 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;
+    SetupOnce(member: Member<T>, 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;
+    SetupSequence(setups: [Member<T>, any][]): void;
     /**
      * Return the number of times a given member was referenced
      * @param member
      * @returns
      */
-    TimesMemberCalled(member: (func: T) => any): number;
+    TimesMemberCalled(member: Member<T>): 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;
+    Verify(member: Member<T>, times: Times | number): void;
     private setup;
     private getReturnValueForProperty;
     private getReturnForFunction;
+    private getPathFromMemberFunctionString;
     private getFunctionMapsFromSignature;
     private updateMemberSignatureMaps;
     private updateSignatureMapFunctions;
+    private getArgumentArray;
 }
+export {};

package/Mock/Mock.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Mock = void 0;
+var OrderBy_1 = require("../Utility/OrderBy");
 var SignatureService_1 = require("./SignatureService");
 var Any_1 = require("./Any");
 var Mock = /** @class */ (function () {
@@ -54,7 +55,8 @@ var Mock = /** @class */ (function () {
     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;
+        var args = (_a = memberSignatureMap.functionMaps[0]) === null || _a === void 0 ? void 0 : _a.state;
+        var functionMap = this.getFunctionMapsFromSignature(memberSignatureMap, this.getArgumentArray(args)).functionMapForArgs;
         return (functionMap === null || functionMap === void 0 ? void 0 : functionMap.timesCalled) || 0;
     };
     /**
@@ -70,7 +72,7 @@ var Mock = /** @class */ (function () {
             // eslint-disable-next-line no-console
             console.log("Actual calls made for, \"".concat(signature, ":"), memberSignatureMap === null || memberSignatureMap === void 0 ? void 0 : memberSignatureMap.functionMaps.map(function (m) { return "".concat(m.originalSignature, " x ").concat(m.timesCalled); }));
         }
-        expect(timesCalled).toEqual(times, timesCalled !== times ? '' : undefined);
+        expect(timesCalled).toEqual(times);
     };
     Mock.prototype.setup = function (member, returns, singleUse) {
         var _this = this;
@@ -89,7 +91,7 @@ var Mock = /** @class */ (function () {
                 for (var _i = 0; _i < arguments.length; _i++) {
                     args[_i] = arguments[_i];
                 }
-                return (_a = _this.getReturnForFunction(memberSignatureMap, args)) === null || _a === void 0 ? void 0 : _a();
+                return (_a = _this.getReturnForFunction(memberSignatureMap, _this.getArgumentArray(args))) === null || _a === void 0 ? void 0 : _a();
             });
         }
     };
@@ -108,10 +110,26 @@ var Mock = /** @class */ (function () {
             return functionMapForArgs.returns;
         }) : undefined;
     };
+    Mock.prototype.getPathFromMemberFunctionString = function (member) {
+        var regex = /[.][a-zA-Z0-9]*/g;
+        var path = '';
+        if (member) {
+            var match = void 0;
+            while ((match = regex.exec(member)) !== null) {
+                var matchValue = path.length ? match[0] : match[0].replace('.', '');
+                path += matchValue;
+            }
+        }
+        return path;
+    };
     Mock.prototype.getFunctionMapsFromSignature = function (memberSignatureMap, args) {
+        var _this = this;
         var existingMemberSignatureMap = this.memberSignatureMaps.find(function (s) { return s.signature === memberSignatureMap.signature; });
         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 functionMapForArgs = (signatureFunctionMaps === null || signatureFunctionMaps === void 0 ? void 0 : signatureFunctionMaps.find(function (m) {
+            return Array.isArray(args) && typeof (args === null || args === void 0 ? void 0 : args[0]) === 'string' && args[0].includes('function') &&
+                _this.getPathFromMemberFunctionString(args[0]) === _this.getPathFromMemberFunctionString(m.originalSignature);
+        })) || (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) {
@@ -136,13 +154,17 @@ 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 && !newFunctionMap.singleUse) {
+        if (existingFunctionMap && !newFunctionMap.singleUse && existingFunctionMap.originalSignature === newFunctionMap.originalSignature) {
             var functionMaps = existingSignatureMap.functionMaps;
             functionMaps.splice(functionMaps.indexOf(existingFunctionMap), 1, newFunctionMap);
         }
         else {
             existingSignatureMap.functionMaps.push(newFunctionMap);
         }
+        existingSignatureMap.functionMaps = (0, OrderBy_1.OrderBy)(existingSignatureMap.functionMaps, [function (f) { return f.singleUse ? 1 : 2; }]);
+    };
+    Mock.prototype.getArgumentArray = function (args) {
+        return args.map(function (a) { return typeof a === 'function' ? a.toString() : a; });
     };
     return Mock;
 }());

package/Mock/SignatureService.js

@@ -12,7 +12,7 @@ var SignatureService = /** @class */ (function () {
         memberSignature =
             this.getOperationMemberSignature(value, memberSignature) ||
                 this.getPropertyMemberSignature(value, memberSignature);
-        var state = this.MemberSignatureIsProperty(memberSignature) ? '' :
+        var state = this.MemberSignatureIsProperty(memberSignature) ? [] :
             SignatureService.getStateForMemberSignature(memberSignature, value);
         return {
             signature: memberSignature,
@@ -34,7 +34,7 @@ var SignatureService = /** @class */ (function () {
     };
     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 = /.[.]/.test(originalSignature) ? originalSignature.split('.').slice(1).join('.') : 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();
     };
@@ -61,7 +61,7 @@ var SignatureService = /** @class */ (function () {
         return memberSignature;
     };
     SignatureService.getStateForMemberSignature = function (memberSignature, value) {
-        var state = '';
+        var state = [];
         var obj = {};
         obj[this.GetMemberNameFromSignature(memberSignature)] = (function () {
             var args = [];

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)
-![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)

package/Utility/OrderBy.d.ts

@@ -0,0 +1 @@
+export declare const OrderBy: <T>(array: T[], funcs: ((item: T) => number | string)[]) => T[];

package/Utility/OrderBy.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderBy = void 0;
+var OrderBy = function (array, funcs) {
+    var newArray = array.slice();
+    newArray.sort(function (a, b) {
+        var result = 0;
+        for (var index = 0; index < funcs.length; index++) {
+            var func = funcs[index];
+            if (func(a) < func(b)) {
+                result = -1;
+                break;
+            }
+            else if (func(a) > func(b)) {
+                result = 1;
+                break;
+            }
+        }
+        return result;
+    });
+    return newArray;
+};
+exports.OrderBy = OrderBy;
+//# sourceMappingURL=OrderBy.js.map

package/package.json

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