referee - npm Package Compare versions

Comparing version 1.1.0 to 1.1.1

lib/referee.js

@@ -42,17 +42,8 @@ ((typeof define === "function" && define.amd && function (m) {
     function interpolateProperties(message, properties) {
-        return _.reduce(_.keys(properties), function (msg, name) {
-            return interpolate(msg, name, referee.format(properties[name]));
+        return _.reduce(_.keys(properties), function (str, name) {
+            var formattedValue = name == "customMessage" ? referee.prepareMessage(properties[name]) : referee.format(properties[name]);
+            return interpolate(str, name, formattedValue);
         }, message || "");
     }
 
-    // Fail an assertion. Interpolates message before calling referee.fail
-    function fail(type, assertion, msg) {
-        delete this.fail;
-        var message = interpolateProperties(interpolatePosArg(
-            referee[type][assertion][msg] || msg,
-            [].slice.call(arguments, 3)
-        ), this);
-        referee.fail("[" + type + "." + assertion + "] " + message);
-    }
-
     // Internal helper. Used throughout to fail assertions if they receive
@@ -82,21 +73,33 @@ // too few arguments. The name is provided for a helpful error message.
 
+            var args = slice.call(arguments, 0),
+                namedValues = {};
+
+            if (typeof messageValues === "function") {
+                var replacedValues = messageValues.apply(this, args);
+                if (typeof(replacedValues) === "object") {
+                    namedValues = replacedValues;
+                } else {
+                    args = replacedValues
+                }
+            }
+
             var ctx = {
-                fail: function () {
+                fail: function (msg) {
                     failed = true;
-                    var failArgs = [type, name].concat(slice.call(arguments));
-                    fail.apply(this, failArgs);
-                    return true;
+                    delete this.fail;
+                    var message = referee[type][name][msg] || msg;
+                    message = interpolatePosArg(message, args);
+                    message = interpolateProperties(message, this);
+                    message = interpolateProperties(message, namedValues);
+                    referee.fail("[" + type + "." + name + "] " + message);
+                    return false;
                 }
             };
 
-            var args = slice.call(arguments, 0);
-
-            if (typeof messageValues === "function") {
-                args = messageValues.apply(this, args);
+            if (!func.apply(ctx, arguments) && !failed) {
+                // when a function returns false and hasn't already failed with a custom message,
+                // fail with default message
+                ctx.fail("message");
             }
 
-            if (!func.apply(ctx, arguments)) {
-                return fail.apply(ctx, [type, name, "message"].concat(args));
-            }
-
             if (!failed) {
@@ -165,3 +168,2 @@ referee.emit.apply(referee, ["pass", fullName].concat(args));
 
-    assert.message = "[assert] Expected ${0} to be truthy";
     referee.count = 0;
@@ -187,19 +189,30 @@
 
-    function msg(message) {
-        if (!message) { return ""; }
+    referee.prepareMessage = function msg(message) {
+        if (!message) {
+            return "";
+        }
         return message + (/[.:!?]$/.test(message) ? " " : ": ");
-    }
+    };
 
-    referee.prepareMessage = msg;
-
     function actualAndExpectedMessageValues(actual, expected, message) {
-        return [actual, expected, msg(message)];
+        return {
+            actual: actual,
+            expected: expected,
+            customMessage: message
+        };
     }
 
     function actualMessageValues(actual, message) {
-        return [actual, msg(message)];
+        return {
+            actual: actual,
+            customMessage: message
+        };
     }
 
     function actualAndTypeOfMessageValues(actual, message) {
-        return [actual, typeof actual, msg(message)];
+        return {
+            actual: actual,
+            actualType: typeof actual,
+            customMessage: message
+        };
     }
@@ -214,4 +227,4 @@
         },
-        assertMessage: "${2}${0} expected to be the same object as ${1}",
-        refuteMessage: "${2}${0} expected not to be the same object as ${1}",
+        assertMessage: "${customMessage}${actual} expected to be the same object as ${expected}",
+        refuteMessage: "${customMessage}${actual} expected not to be the same object as ${expected}",
         expectation: "toBe",
@@ -227,3 +240,3 @@ values: actualAndExpectedMessageValues
         var heading = assert.equals.multiLineStringHeading;
-        message = interpolatePosArg(heading, [message]);
+        var failureText = interpolateProperties(heading, { customMessage: message });
         var actualLines = actual.split("\n");
@@ -241,3 +254,3 @@ var expectedLines = expected.split("\n");
 
-        referee.fail("[assert.equals] " + message + lines.join("\n\n"));
+        referee.fail("[assert.equals] " + failureText + lines.join("\n\n"));
         return false;
@@ -253,4 +266,3 @@ }
                      expected.indexOf("\n") >= 0)) {
-                var message = msg(arguments[2]);
-                return multiLineStringDiff(actual, expected, message);
+                return multiLineStringDiff(actual, expected, arguments[2]);
             }
@@ -265,4 +277,4 @@
 
-        assertMessage: "${2}${0} expected to be equal to ${1}",
-        refuteMessage: "${2}${0} expected not to be equal to ${1}",
+        assertMessage: "${customMessage}${actual} expected to be equal to ${expected}",
+        refuteMessage: "${customMessage}${actual} expected not to be equal to ${expected}",
         expectation: "toEqual",
@@ -272,3 +284,3 @@ values: actualAndExpectedMessageValues
 
-    assert.equals.multiLineStringHeading = "${0}Expected multi-line strings " +
+    assert.equals.multiLineStringHeading = "${customMessage}Expected multi-line strings " +
         "to be equal:\n";
@@ -281,4 +293,4 @@
 
-        assertMessage: "${2}Expected ${0} to be greater than ${1}",
-        refuteMessage: "${2}Expected ${0} to be less than or equal to ${1}",
+        assertMessage: "${customMessage}Expected ${actual} to be greater than ${expected}",
+        refuteMessage: "${customMessage}Expected ${actual} to be less than or equal to ${expected}",
         expectation: "toBeGreaterThan",
@@ -293,4 +305,4 @@ values: actualAndExpectedMessageValues
 
-        assertMessage: "${2}Expected ${0} to be less than ${1}",
-        refuteMessage: "${2}Expected ${0} to be greater than or equal to ${1}",
+        assertMessage: "${customMessage}Expected ${actual} to be less than ${expected}",
+        refuteMessage: "${customMessage}Expected ${actual} to be greater than or equal to ${expected}",
         expectation: "toBeLessThan",
@@ -304,4 +316,4 @@ values: actualAndExpectedMessageValues
         },
-        assertMessage: "${2}Expected to be defined",
-        refuteMessage: "${2}Expected ${0} (${1}) not to be defined",
+        assertMessage: "${customMessage}Expected to be defined",
+        refuteMessage: "${customMessage}Expected ${actual} (${actualType}) not to be defined",
         expectation: "toBeDefined",
@@ -315,4 +327,4 @@ values: actualAndTypeOfMessageValues
         },
-        assertMessage: "${1}Expected ${0} to be null",
-        refuteMessage: "${1}Expected not to be null",
+        assertMessage: "${customMessage}Expected ${actual} to be null",
+        refuteMessage: "${customMessage}Expected not to be null",
         expectation: "toBeNull",
@@ -340,6 +352,4 @@ values: actualMessageValues
             } catch (e) {
-                // Uses arguments[2] because the function's .length is used
-                // to determine the minimum required number of arguments.
-                var message = msg(arguments[2]);
-                return this.fail("exceptionMessage", e.message, message);
+                this.exceptionMessage = e.message;
+                return this.fail("exceptionMessage");
             }
@@ -356,3 +366,4 @@
             } catch (e) {
-                return this.fail("exceptionMessage", e.message);
+                this.exceptionMessage = e.message;
+                return this.fail("exceptionMessage");
             }
@@ -363,4 +374,4 @@
 
-        assertMessage: "${2}${0} expected to match ${1}",
-        refuteMessage: "${2}${0} expected not to match ${1}",
+        assertMessage: "${customMessage}${actual} expected to match ${expected}",
+        refuteMessage: "${customMessage}${actual} expected not to match ${expected}",
         expectation: "toMatch",
@@ -370,4 +381,3 @@ values: actualAndExpectedMessageValues
 
-    assert.match.exceptionMessage = "${1}${0}";
-    refute.match.exceptionMessage = "${1}${0}";
+    assert.match.exceptionMessage = refute.match.exceptionMessage = "${customMessage}${exceptionMessage}";
 
@@ -378,4 +388,4 @@ referee.add("isObject", {
         },
-        assertMessage: "${2}${0} (${1}) expected to be object and not null",
-        refuteMessage: "${2}${0} expected to be null or not an object",
+        assertMessage: "${customMessage}${actual} (${actualType}) expected to be object and not null",
+        refuteMessage: "${customMessage}${actual} expected to be null or not an object",
         expectation: "toBeObject",
@@ -389,10 +399,11 @@ values: actualAndTypeOfMessageValues
         },
-        assertMessage: "${2}${0} (${1}) expected to be function",
-        refuteMessage: "${2}${0} expected not to be function",
+        assertMessage: "${customMessage}${actual} (${actualType}) expected to be function",
+        refuteMessage: "${customMessage}${actual} expected not to be function",
         expectation: "toBeFunction",
-        values: function (actual) {
-            // Uses arguments[1] because the function's .length is used to
-            // determine the minimum required number of arguments.
-            var message = msg(arguments[1]);
-            return [String(actual).replace("\n", ""), typeof actual, message];
+        values: function (actual, message) {
+            return {
+                actual: String(actual).replace("\n", ""),
+                actualType: typeof actual,
+                customMessage: message
+            };
         }
@@ -405,4 +416,4 @@ });
         },
-        assertMessage: "${1}Expected ${0} to be true",
-        refuteMessage: "${1}Expected ${0} to not be true",
+        assertMessage: "${customMessage}Expected ${actual} to be true",
+        refuteMessage: "${customMessage}Expected ${actual} to not be true",
         expectation: "toBeTrue",
@@ -416,4 +427,4 @@ values: actualMessageValues
         },
-        assertMessage: "${1}Expected ${0} to be false",
-        refuteMessage: "${1}Expected ${0} to not be false",
+        assertMessage: "${customMessage}Expected ${actual} to be false",
+        refuteMessage: "${customMessage}Expected ${actual} to not be false",
         expectation: "toBeFalse",
@@ -427,4 +438,4 @@ values: actualMessageValues
         },
-        assertMessage: "${2}Expected ${0} (${1}) to be string",
-        refuteMessage: "${2}Expected ${0} not to be string",
+        assertMessage: "${customMessage}Expected ${actual} (${actualType}) to be string",
+        refuteMessage: "${customMessage}Expected ${actual} not to be string",
         expectation: "toBeString",
@@ -438,4 +449,4 @@ values: actualAndTypeOfMessageValues
         },
-        assertMessage: "${2}Expected ${0} (${1}) to be boolean",
-        refuteMessage: "${2}Expected ${0} not to be boolean",
+        assertMessage: "${customMessage}Expected ${actual} (${actualType}) to be boolean",
+        refuteMessage: "${customMessage}Expected ${actual} not to be boolean",
         expectation: "toBeBoolean",
@@ -449,4 +460,4 @@ values: actualAndTypeOfMessageValues
         },
-        assertMessage: "${2}Expected ${0} (${1}) to be a non-NaN number",
-        refuteMessage: "${2}Expected ${0} to be NaN or a non-number value",
+        assertMessage: "${customMessage}Expected ${actual} (${actualType}) to be a non-NaN number",
+        refuteMessage: "${customMessage}Expected ${actual} to be NaN or a non-number value",
         expectation: "toBeNumber",
@@ -460,4 +471,4 @@ values: actualAndTypeOfMessageValues
         },
-        assertMessage: "${2}Expected ${0} to be NaN",
-        refuteMessage: "${2}Expected not to be NaN",
+        assertMessage: "${customMessage}Expected ${actual} to be NaN",
+        refuteMessage: "${customMessage}Expected not to be NaN",
         expectation: "toBeNaN",
@@ -471,4 +482,4 @@ values: actualAndTypeOfMessageValues
         },
-        assertMessage: "${2}Expected ${0} to be array",
-        refuteMessage: "${2}Expected ${0} not to be array",
+        assertMessage: "${customMessage}Expected ${actual} to be array",
+        refuteMessage: "${customMessage}Expected ${actual} not to be array",
         expectation: "toBeArray",
@@ -491,4 +502,4 @@ values: actualAndTypeOfMessageValues
         },
-        assertMessage: "${2}Expected ${0} to be array like",
-        refuteMessage: "${2}Expected ${0} not to be array like",
+        assertMessage: "${customMessage}Expected ${actual} to be array like",
+        refuteMessage: "${customMessage}Expected ${actual} not to be array like",
         expectation: "toBeArrayLike",
@@ -516,9 +527,16 @@ values: actualAndTypeOfMessageValues
 
-    referee.add('keys', {
+    referee.add("keys", {
         assert: function (actual, keys) {
             return exactKeys(actual, keys);
         },
-        assertMessage: "Expected ${0} to have exact keys ${1}!",
-        refuteMessage: "Expected ${0} not to have exact keys ${1}!",
-        expectation: "toHaveKeys"
+        assertMessage: "${customMessage}Expected ${actualObject} to have exact keys ${keys}",
+        refuteMessage: "${customMessage}Expected not to have exact keys ${keys}",
+        expectation: "toHaveKeys",
+        values: function (actual, keys, message) {
+            return {
+                actualObject: actual,
+                keys: keys,
+                customMessage: message
+            }
+        }
     });
@@ -533,82 +551,65 @@
 
-    assert.exception = function (callback, matcher, message) {
-        referee.countAssertion();
-        if (!assertArgNum("assert.exception", arguments, 1)) { return; }
-        if (!callback) { return; }
+    referee.add("exception", {
+        assert: function (callback) {
+            var matcher = arguments[1];
+            var customMessage = arguments[2];
 
-        if (typeof matcher === "string") {
-            message = matcher;
-            matcher = function (err) {
-                return referee.match(err, message);
-            };
-        }
+            if (typeof matcher === "string") {
+                customMessage = matcher;
+                matcher = undefined;
+            }
 
-        var err = captureException(callback);
-        message = msg(message);
+            this.expected = matcher;
+            this.customMessage = customMessage;
 
-        if (!err) {
-            if (typeof matcher === "object") {
-                return fail.call(
-                    {},
-                    "assert",
-                    "exception",
-                    "typeNoExceptionMessage",
-                    message,
-                    referee.format(matcher)
-                );
-            } else {
-                return fail.call({}, "assert", "exception", "message", message);
+            var err = captureException(callback);
+
+            if (err) {
+                this.actualExceptionType = err.name;
+                this.actualExceptionMessage = err.message;
+                this.actualExceptionStack = err.stack;
             }
-        }
 
-        if (typeof matcher === "object" && !referee.match(err, matcher)) {
-            return fail.call(
-                {},
-                "assert",
-                "exception",
-                "typeFailMessage",
-                message,
-                referee.format(matcher),
-                err.name,
-                err.message,
-                err.stack
-            );
-        }
+            if (!err) {
+                if (typeof matcher === "object") {
+                    return this.fail("typeNoExceptionMessage");
+                } else {
+                    return this.fail("message");
+                }
+            }
 
-        if (typeof matcher === "function" && matcher(err) !== true) {
-            return fail.call({}, "assert", "exception", "matchFailMessage",
-                             message, err.name, err.message);
-        }
+            if (typeof matcher === "object" && !referee.match(err, matcher)) {
+                return this.fail("typeFailMessage");
+            }
 
-        referee.emit("pass", "assert.exception", message, callback, matcher);
-    };
+            if (typeof matcher === "function" && matcher(err) !== true) {
+                return this.fail("matchFailMessage");
+            }
 
-    assert.exception.typeNoExceptionMessage = "${0}Expected ${1} but no " +
-        "exception was thrown";
-    assert.exception.message = "${0}Expected exception";
-    assert.exception.typeFailMessage = "${0}Expected ${1} but threw ${2} " +
-        "(${3})\n${4}";
-    assert.exception.matchFailMessage = "${0}Expected thrown ${1} (${2}) to " +
-        "pass matcher function";
-    assert.exception.expectationName = "toThrow";
+            return true;
+        },
 
-    refute.exception = function (callback) {
-        referee.countAssertion();
-        if (!assertArgNum("refute.exception", arguments, 1)) { return; }
-        var err = captureException(callback);
+        refute: function (callback) {
+            var err = captureException(callback);
 
-        if (err) {
-            // Uses arguments[1] because the function's .length is used to
-            // determine the minimum required number of arguments.
-            fail.call({}, "refute", "exception", "message",
-                      msg(arguments[1]), err.name, err.message, callback);
-        } else {
-            referee.emit("pass", "refute.exception", callback);
-        }
-    };
+            if (err) {
+                this.customMessage = arguments[1];
+                this.actualExceptionType = err.name;
+                this.actualExceptionMessage = err.message;
+                return false;
+            }
 
-    refute.exception.message = "${0}Expected not to throw but " +
-        "threw ${1} (${2})";
-    refute.exception.expectationName = "toThrow";
+            return true;
+        },
 
+        expectation: "toThrow",
+        assertMessage: "${customMessage}Expected exception",
+        refuteMessage: "${customMessage}Expected not to throw but threw ${actualExceptionType} (${actualExceptionMessage})"
+    });
+
+    assert.exception.typeNoExceptionMessage = "${customMessage}Expected ${expected} but no exception was thrown";
+    assert.exception.typeFailMessage = "${customMessage}Expected ${expected} but threw ${actualExceptionType} (${actualExceptionMessage})\n${actualExceptionStack}";
+    assert.exception.matchFailMessage = "${customMessage}Expected thrown ${actualExceptionType} (${actualExceptionMessage}) to pass matcher function";
+
+
     referee.add("near", {
@@ -618,7 +619,12 @@ assert: function (actual, expected, delta) {
         },
-        assertMessage: "${3}Expected ${0} to be equal to ${1} +/- ${2}",
-        refuteMessage: "${3}Expected ${0} not to be equal to ${1} +/- ${2}",
+        assertMessage: "${customMessage}Expected ${actual} to be equal to ${expected} +/- ${delta}",
+        refuteMessage: "${customMessage}Expected ${actual} not to be equal to ${expected} +/- ${delta}",
         expectation: "toBeNear",
         values: function (actual, expected, delta, message) {
-            return [actual, expected, delta, msg(message)];
+            return {
+                actual: actual,
+                expected: expected,
+                delta: delta,
+                customMessage: message
+            };
         }
@@ -631,4 +637,4 @@ });
         },
-        assertMessage: "${2}Expected ${0} to have ${1} on its prototype chain",
-        refuteMessage: "${2}Expected ${0} not to have ${1} on its " +
+        assertMessage: "${customMessage}Expected ${actual} to have ${expected} on its prototype chain",
+        refuteMessage: "${customMessage}Expected ${actual} not to have ${expected} on its " +
             "prototype chain",
@@ -643,4 +649,4 @@ expectation: "toHavePrototype",
         },
-        assertMessage: "${2}Expected [${0}] to contain ${1}",
-        refuteMessage: "${2}Expected [${0}] not to contain ${1}",
+        assertMessage: "${customMessage}Expected [${actual}] to contain ${expected}",
+        refuteMessage: "${customMessage}Expected [${actual}] not to contain ${expected}",
         expectation: "toContain",
@@ -655,8 +661,3 @@ values: actualAndExpectedMessageValues
             if (!element.tagName) {
-                return this.fail(
-                    "noTagNameMessage",
-                    tagName,
-                    element,
-                    msg(arguments[2])
-                );
+                return this.fail("noTagNameMessage");
             }
@@ -667,13 +668,18 @@
         },
-        assertMessage: "${2}Expected tagName to be ${0} but was ${1}",
-        refuteMessage: "${2}Expected tagName not to be ${0}",
+        assertMessage: "${customMessage}Expected tagName to be ${expected} but was ${actual}",
+        refuteMessage: "${customMessage}Expected tagName not to be ${actual}",
         expectation: "toHaveTagName",
         values: function (element, tagName, message) {
-            return [tagName, element.tagName, msg(message)];
+            return {
+                actualElement: element,
+                actual: element.tagName,
+                expected: tagName,
+                customMessage: message
+            };
         }
     });
 
-    assert.tagName.noTagNameMessage = "${2}Expected ${1} to have tagName " +
+    assert.tagName.noTagNameMessage = "${customMessage}Expected ${actualElement} to have tagName " +
         "property";
-    refute.tagName.noTagNameMessage = "${2}Expected ${1} to have tagName " +
+    refute.tagName.noTagNameMessage = "${customMessage}Expected ${actualElement} to have tagName " +
         "property";
@@ -684,10 +690,3 @@
             if (typeof element.className === "undefined") {
-                // Uses arguments[2] because the function's .length is used to
-                // determine the minimum required number of arguments.
-                return this.fail(
-                    "noClassNameMessage",
-                    name,
-                    element,
-                    msg(arguments[2])
-                );
+                return this.fail("noClassNameMessage");
             }
@@ -704,14 +703,19 @@
         },
-        assertMessage: "${2}Expected object's className to include ${0} " +
-            "but was ${1}",
-        refuteMessage: "${2}Expected object's className not to include ${0}",
+        assertMessage: "${customMessage}Expected object's className to include ${expected} " +
+            "but was ${actual}",
+        refuteMessage: "${customMessage}Expected object's className not to include ${expected}",
         expectation: "toHaveClassName",
         values: function (element, className, message) {
-            return [className, element.className, msg(message)];
+            return {
+                actualElement: element,
+                actual: element.className,
+                expected: className,
+                customMessage: message
+            };
         }
     });
 
-    assert.className.noClassNameMessage = "${2}Expected object to have " +
+    assert.className.noClassNameMessage = "${customMessage}Expected object to have " +
         "className property";
-    refute.className.noClassNameMessage = "${2}Expected object to have " +
+    refute.className.noClassNameMessage = "${customMessage}Expected object to have " +
         "className property";
@@ -718,0 +722,0 @@

package.json

 {
     "name": "referee",
-    "version": "1.1.0",
+    "version": "1.1.1",
     "description": "Assertions for any JavaScript test framework and environment",
-    "homepage": "http://busterjs.org/docs/referee",
+    "homepage": "http://docs.busterjs.org/en/latest/modules/referee/",
     "author": "Christian Johansen",
@@ -7,0 +7,0 @@ "contributors": [{

Readme.md

@@ -26,2 +26,6 @@ # referee
 
+**1.1.1** (16.12.2014)
+
+* part of fix for issue [#274 - quoting in assertion failures](https://github.com/busterjs/buster/issues/274)
+
 **1.1.0** (31.10.2014)
@@ -28,0 +32,0 @@

Fixed alerts

No website

Quality

Package does not have a website.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

107994

increased by0.95%

Lines of code

2336

increased by0.21%

Number of low quality alerts

0

decreased by-100%

Number of lines in readme file

52

increased by8.33%

Worsened metrics

Number of package files

12

decreased by-7.69%

No dependency changes