safe-mock/src/ArgumentInvocation.js

Type Safe Mocking Library written for Typescript and Javascript

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var primitives = ["String", "Object", "Number"];
function inBraces(joiner) {
    return function (array) {
        return "(" + joiner(array) + ")";
    };
}
function isSpecialObject(arg) {
    var constructorName = arg.constructor.name;
    var notFound = -1;
    return primitives.indexOf(constructorName) === notFound;
}
function printObject(arg) {
    if (isSpecialObject(arg))
        return arg.constructor.name + JSON.stringify(arg);
    return JSON.stringify(arg);
}
function joinArray(expectedCall) {
    return expectedCall
        .map(function (arg) { return printObject(arg); })
        .join(", ");
}
function prettyPrint(expectedCall) {
    return inBraces(joinArray)(expectedCall);
}
var ArgumentInvocation = /** @class */ (function () {
    function ArgumentInvocation(args) {
        this.args = args;
    }
    ArgumentInvocation.prototype.prettyPrint = function () {
        return prettyPrint(this.args);
    };
    ArgumentInvocation.prototype.equivalentTo = function (expectedCall) {
        if (this.args.length !== expectedCall.args.length)
            return false;
        if (this.args.length === 0)
            return true;
        for (var argIndex in this.args) {
            if (ArgumentInvocation.equalArg(this.args[argIndex], expectedCall.args[argIndex]) === false) {
                return false;
            }
        }
        return true;
    };
    ArgumentInvocation.equalArg = function (arg1, arg2) {
        if (arg1 === undefined && arg2 === undefined)
            return true;
        if (arg1 === undefined || arg2 === undefined)
            return false;
        if (arg1 === null && arg2 === null) {
            return true;
        }
        if (arg1 === null || arg2 === null) {
            return false;
        }
        if (arg1.constructor.name !== arg2.constructor.name)
            return false;
        var keys = Object.keys(arg1).concat(Object.keys(arg2));
        if (typeof arg1 === "string" || typeof arg1 === "boolean" || typeof arg1 === "symbol" || typeof arg1 === "number")
            return arg1 == arg2;
        for (var keyIndex in keys) {
            if (ArgumentInvocation.equalArg(arg1[keys[keyIndex]], arg2[keys[keyIndex]]) === false) {
                return false;
            }
        }
        return true;
    };
    return ArgumentInvocation;
}());
exports.default = ArgumentInvocation;