Dependency free assert module with unit tests

lib/assert.js

@@ -1,21 +1,72 @@
-var sys = require('sys');
-var util = require('util');
+// http://wiki.commonjs.org/wiki/Unit_Testing/1.0
+//
+// THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!
+//
+// Originally from narwhal.js (http://narwhaljs.org)
+// Copyright (c) 2009 Thomas Robinson <280north.com>
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the “Software”), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// UTILITY
+
+var pSlice = Array.prototype.slice;
+
+// 1. The assert module provides functions that throw
+// AssertionError's when particular conditions are not met. The
+// assert module must conform to the following interface.
+
 var assert = exports;
 
-assert.AssertionError = function (options) {
+// 2. The AssertionError is defined in assert.
+// new assert.AssertionError({message: message, actual: actual, expected: expected})
+
+assert.AssertionError = function AssertionError(options) {
     this.name = "AssertionError";
     this.message = options.message;
     this.actual = options.actual;
     this.expected = options.expected;
     this.operator = options.operator;
-
+    //v8 specific
+    if(Error.captureStackTrace){
         Error.captureStackTrace(this,fail);
+        //node specific, removes the node machinery stack frames
+        if(typeof(__filename) !== undefined){
+            var stack = this.stack.split('\n');
+            for (var i = stack.length - 1; i >= 0; i--) {
+                if(stack[i].indexOf(__filename) != -1){
+                    this.stack = stack.slice(0,i+2).join('\n');
+                    break;
+                }
+            }
+        }
+    }
 };
-sys.inherits(assert.AssertionError, Error);
+
+assert.AssertionError.prototype.toString = function(){
+    if(this.message)
+        return [this.name+":", this.message].join(' ');
+    else
+        return [this.name+":", JSON.stringify(this.expected ), this.operator , JSON.stringify(this.actual)].join(" ");
+}
 
 // assert.AssertionError instanceof Error
 
-// assert.AssertionError.prototype = Object.create(Error.prototype);
+assert.AssertionError.__proto__ = Error.prototype;
 
 // At present only the three keys mentioned above are used and
 // understood by the spec. Implementations or sub modules can pass
@@ -37,6 +88,9 @@ function fail(actual, expected, message, operator) {
     });
 }
 
+// EXTENSION! allows for well behaved errors defined elsewhere.
+assert.fail = fail;
+
 // 4. Pure assertion tests whether a value is truthy, as determined
 // by !!guard.
 // assert.ok(guard, message_opt);
@@ -44,7 +98,7 @@ function fail(actual, expected, message, operator) {
 // message_opt);. To test strictly for the value true, use
 // assert.strictEqual(true, guard, message_opt);.
 
-assert.ok = function (value, message) {
+assert.ok = function ok(value, message) {
     if (!!!value)
         fail(value, true, message, "==");
 };
@@ -53,7 +107,7 @@ assert.ok = function (value, message) {
 // ==.
 // assert.equal(actual, expected, message_opt);
 
-assert.equal = function (actual, expected, message) {
+assert.equal = function equal(actual, expected, message) {
     if (actual != expected)
         fail(actual, expected, message, "==");
 };
@@ -62,7 +116,7 @@ assert.equal = function (actual, expected, message) {
 // 6. The non-equality assertion tests for whether two objects are not equal
 // with != assert.notEqual(actual, expected, message_opt);
 
-assert.notEqual = function (actual, expected, message) {
+assert.notEqual = function notEqual(actual, expected, message) {
     if (actual == expected)
         fail(actual, expected, message, "!=");
 };
@@ -70,13 +124,12 @@ assert.notEqual = function (actual, expected, message) {
 // 7. The equivalence assertion tests a deep equality relation.
 // assert.deepEqual(actual, expected, message_opt);
 
-exports.deepEqual = function (actual, expected, message) {
-    if (!deepEqual(actual, expected))
+exports.deepEqual = function deepEqual(actual, expected, message) {
+    if (!_deepEqual(actual, expected))
         fail(actual, expected, message, "deepEqual");
 };
 
-function deepEqual(actual, expected) {
-    
+function _deepEqual(actual, expected) {
     // 7.1. All identical values are equivalent, as determined by ===.
     if (actual === expected) {
         return true;
@@ -85,7 +138,7 @@ function deepEqual(actual, expected) {
     // equivalent if it is also a Date object that refers to the same time.
     } else if (actual instanceof Date
             && expected instanceof Date) {
-        return actual.toValue() === expected.toValue();
+        return actual.getTime() === expected.getTime();
 
     // 7.3. Other pairs that do not both pass typeof value == "object",
     // equivalence is determined by ==.
@@ -100,43 +153,73 @@ function deepEqual(actual, expected) {
     // corresponding key, and an identical "prototype" property. Note: this
     // accounts for both named and indexed properties on Arrays.
     } else {
-        return actual.prototype === expected.prototype && objEquiv(actual, expected);
+        return objEquiv(actual, expected);
     }
 }
 
-function objEquiv(a, b, stack) {
-    return (
-        !util.no(a) && !util.no(b) &&
-        arrayEquiv(
-            util.sort(util.object.keys(a)),
-            util.sort(util.object.keys(b))
-        ) &&
-        util.object.keys(a).every(function (key) {
-            return deepEqual(a[key], b[key], stack);
-        })
-    );
+function isUndefinedOrNull (value) {
+    return value === null || value === undefined;
 }
 
-function arrayEquiv(a, b, stack) {
-    return util.isArrayLike(b) &&
-        a.length == b.length &&
-        util.zip(a, b).every(util.apply(function (a, b) {
-            return deepEqual(a, b, stack);
-        }));
+function isArguments (object){
+    return Object.prototype.toString.call(object) == '[object Arguments]';
+}
+
+function objEquiv (a, b) {
+    if (isUndefinedOrNull(a) || isUndefinedOrNull(b))
+        return false;
+    // an identical "prototype" property.
+    if (a.prototype !== b.prototype) return false;
+    //~~~I've managed to break Object.keys through screwy arguments passing.
+    //   Converting to array solves the problem.
+    if(isArguments(a)){
+        if(!isArguments(b)){
+            return false;
+        }
+        a = pSlice.call(a);
+        b = pSlice.call(b);
+        return _deepEqual(a,b);
+    }
+    try{
+        var ka = Object.keys(a),
+            kb = Object.keys(b),
+            key, i;
+    } catch (e) {//happens when one is a string literal and the other isn't
+        return false;
+    }
+    // having the same number of owned properties (keys incorporates hasOwnProperty)
+    if(ka.length != kb.length)
+        return false;
+    //the same set of keys (although not necessarily the same order),
+    ka.sort();
+    kb.sort();
+    //~~~cheap key test
+    for (i = ka.length - 1; i >= 0; i--) {
+        if(ka[i] != kb[i])
+            return false;
+    }
+    //equivalent values for every corresponding key, and
+    //~~~possibly expensive deep test
+    for (i = ka.length - 1; i >= 0; i--) {
+        key = ka[i];
+        if(!_deepEqual(a[key], b[key] ))
+           return false;
+    }
+    return true;
 }
 
 // 8. The non-equivalence assertion tests for any deep inequality.
 // assert.notDeepEqual(actual, expected, message_opt);
 
-exports.notDeepEqual = function (actual, expected, message) {
-    if (deepEqual(actual, expected))
+exports.notDeepEqual = function notDeepEqual(actual, expected, message) {
+    if (_deepEqual(actual, expected))
         fail(actual, expected, message, "notDeepEqual");
 };
 
 // 9. The strict equality assertion tests strict equality, as determined by ===.
 // assert.strictEqual(actual, expected, message_opt);
 
-assert.strictEqual = function (actual, expected, message) {
+assert.strictEqual = function strictEqual(actual, expected, message) {
     if (actual !== expected)
         fail(actual, expected, message, "===");
 };
@@ -144,7 +227,7 @@ assert.strictEqual = function (actual, expected, message) {
 // 10. The strict non-equality assertion tests for strict inequality, as determined by !==.
 // assert.notStrictEqual(actual, expected, message_opt);
 
-assert.notStrictEqual = function (actual, expected, message) {
+assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
     if (actual === expected)
         fail(actual, expected, message, "!==");
 };
@@ -152,16 +235,31 @@ assert.notStrictEqual = function (actual, expected, message) {
 // 11. Expected to throw an error:
 // assert.throws(block, Error_opt, message_opt);
 
-assert["throws"] = function (block, Error, message) {
-    var threw = false,
-        exception = null;
+assert.throws = function(block, /*optional*/error, /*optional*/message){
+    var args = [true]
+    _throws.apply(this, args.concat(pSlice.call(arguments)));
+}
+
+// EXTENSION! This is annoying to write outside this module.
+assert.doesNotThrow = function(block, /*optional*/error, /*optional*/message){
+    var args = [false]
+    _throws.apply(this, args.concat(pSlice.call(arguments)));
+}
 
-    if (typeof Error == "string") {
-        message = Error;
-        Error = undefined;
-    } else {
-        Error = message;
-        message = "";
+var _throws = function (shouldThrow, block, err, message) {
+    var exception = null
+        threw = false
+        typematters = true;
+    message = message || "";
+
+    //handle optional arguments
+    if(arguments.length == 3){
+        if(typeof(err) == "string"){
+            message = err;
+            typematters = false;
+        }
+    } else if(arguments.length == 2) {
+        typematters = false;
     }
 
     try {
@@ -171,6 +269,18 @@ assert["throws"] = function (block, Error, message) {
         exception = e;
     }
 
-    if (!threw)
-        fail("Expected exception" + (message ? ": " + message : ""));
+    if(shouldThrow && !threw){
+        fail("Missing expected exception"+
+             (err && err.name ? " ("+err.name+")." : '.') +
+             (message ? " " + message : ""));
+    }
+    if(!shouldThrow && threw && typematters && exception instanceof err){
+        fail("Got unwanted exception" +
+             (err && err.name ? " ("+err.name+")." : '.') +
+             (message ? " " + message : ""));
+    }
+    if((shouldThrow && threw && typematters && !(exception instanceof err)) ||
+       (!shouldThrow && threw)){
+        throw exception;
+    }
 };

test/mjsunit/common.js

@@ -13,4 +13,3 @@ process.mixin(exports, sys);
 exports.assert = require('assert');
 exports.posix = require("posix");
 exports.path = path;
-

test/mjsunit/test-assert.js

@@ -0,0 +1,127 @@
+process.mixin(require("./common"));
+
+//strangely meta, no?
+
+var a = require('assert');
+
+
+function makeBlock(f){
+    var args = Array.prototype.slice.call(arguments,1);
+    return function(){
+        return f.apply(this,args);
+    }
+}
+
+assert.ok(a.AssertionError instanceof Error, "a.AssertionError instanceof Error")
+
+assert.throws(makeBlock(a.ok, false), a.AssertionError, "ok(false)");
+assert.doesNotThrow(makeBlock(a.ok, true), a.AssertionError, "ok(true)");
+assert.doesNotThrow(makeBlock(a.ok, "test"),"ok('test')");
+
+assert.throws(makeBlock(a.equal, true, false), a.AssertionError, 'equal');
+assert.doesNotThrow(makeBlock(a.equal, null, null), 'equal');
+assert.doesNotThrow(makeBlock(a.equal, undefined, undefined), 'equal');
+assert.doesNotThrow(makeBlock(a.equal, null, undefined), 'equal');
+assert.doesNotThrow(makeBlock(a.equal, true, true), 'equal');
+assert.doesNotThrow(makeBlock(a.equal, 2, "2"), 'equal');
+
+assert.doesNotThrow(makeBlock(a.notEqual, true, false), 'notEqual');
+assert.throws(makeBlock(a.notEqual, true, true), a.AssertionError, 'notEqual');
+
+assert.throws(makeBlock(a.strictEqual, 2, "2"), a.AssertionError, 'strictEqual');
+assert.throws(makeBlock(a.strictEqual, null, undefined), a.AssertionError, 'strictEqual');
+
+assert.doesNotThrow(makeBlock(a.notStrictEqual, 2, "2"), 'notStrictEqual');
+
+//deepEquals joy!
+//7.2
+assert.doesNotThrow(makeBlock(a.deepEqual, new Date(2000,3,14), new Date(2000,3,14)), 'deepEqual date');
+assert.throws(      makeBlock(a.deepEqual, new Date(), new Date(2000,3,14)), a.AssertionError, 'deepEqual date');
+//7.3
+assert.doesNotThrow(makeBlock(a.deepEqual, 4, "4"), 'deepEqual == check');
+assert.doesNotThrow(makeBlock(a.deepEqual, true, 1), 'deepEqual == check');
+assert.throws(      makeBlock(a.deepEqual, 4, "5"), a.AssertionError, 'deepEqual == check');
+//7.4
+// having the same number of owned properties && the same set of keys
+assert.doesNotThrow(makeBlock(a.deepEqual, {a:4}, {a:4}));
+assert.doesNotThrow(makeBlock(a.deepEqual, {a:4,b:"2"}, {a:4,b:"2"}));
+assert.doesNotThrow(makeBlock(a.deepEqual, [4], ["4"]));
+assert.throws(      makeBlock(a.deepEqual, {a:4}, {a:4,b:true}), a.AssertionError);
+assert.doesNotThrow(makeBlock(a.deepEqual, ["a"], {0:"a"}));
+//(although not necessarily the same order),
+assert.doesNotThrow(makeBlock(a.deepEqual, {a:4,b:"1"}, {b:"1",a:4}));
+var a1 = [1,2,3];
+var a2 = [1,2,3];
+a1.a = "test";
+a1.b = true;
+a2.b = true;
+a2.a = "test"
+assert.throws(      makeBlock(a.deepEqual, Object.keys(a1), Object.keys(a2)), a.AssertionError);
+assert.doesNotThrow(makeBlock(a.deepEqual, a1, a2));
+
+// having an identical prototype property
+var nbRoot = {
+    toString: function(){return this.first+' '+this.last;}
+}
+var nameBuilder = function(first,last){
+    this.first = first;
+    this.last = last;
+    return this;
+}
+nameBuilder.prototype = nbRoot;
+var nameBuilder2 = function(first,last){
+    this.first = first;
+    this.last = last;
+    return this;
+}
+nameBuilder2.prototype = nbRoot;
+var nb1 = new nameBuilder('Ryan', 'Dahl');
+var nb2 = new nameBuilder2('Ryan','Dahl');
+
+assert.doesNotThrow(makeBlock(a.deepEqual, nb1, nb2));
+
+nameBuilder2.prototype = Object;
+nb2 = new nameBuilder2('Ryan','Dahl');
+assert.throws(      makeBlock(a.deepEqual, nb1, nb2), a.AssertionError);
+
+//String literal + object blew up my implementation...
+assert.throws(      makeBlock(a.deepEqual, 'a', {}), a.AssertionError);
+
+//Testing the throwing
+function thrower(errorConstructor){
+    throw new errorConstructor('test');
+}
+aethrow = makeBlock(thrower, a.AssertionError);
+aethrow = makeBlock(thrower, a.AssertionError);
+//the basic calls work
+assert.throws(      makeBlock(thrower, a.AssertionError), a.AssertionError, 'message');
+assert.throws(      makeBlock(thrower, a.AssertionError), a.AssertionError);
+assert.throws(      makeBlock(thrower, a.AssertionError));
+//if not passing an error, catch all.
+assert.throws(      makeBlock(thrower, TypeError));
+//when passing a type, only catch errors of the appropriate type
+var threw = false;
+try{
+    a.throws(      makeBlock(thrower, TypeError), a.AssertionError);
+}catch (e){
+    threw = true;
+    assert.ok(e instanceof TypeError, 'type');
+}
+assert.equal(true,threw,'a.throws with an explicit error is eating extra errors', a.AssertionError);
+threw = false;
+//doesNotThrow should pass through all errors
+try{
+    a.doesNotThrow(makeBlock(thrower, TypeError), a.AssertionError);
+}catch(e){
+    threw = true
+    assert.ok(e instanceof TypeError);
+}
+assert.equal(true,threw,'a.doesNotThrow with an explicit error is eating extra errors');
+//the key difference is that throwing our correct error makes an assertion error
+try{
+    a.doesNotThrow(makeBlock(thrower, TypeError), TypeError);
+}catch(e){
+    threw = true
+    assert.ok(e instanceof a.AssertionError);
+}
+assert.equal(true,threw,'a.doesNotThrow is not catching type matching errors');