diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..3c3629e --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +node_modules diff --git a/assert.js b/assert.js index d275994..22897d3 100644 --- a/assert.js +++ b/assert.js @@ -1,6 +1,3 @@ -(function () { - "use strict" - // http://wiki.commonjs.org/wiki/Unit_Testing/1.0 // // THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8! @@ -25,15 +22,18 @@ // 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 util = require('util'); +// when used in node, this will actually load the util module we depend on +// versus loading the builtin util module as happens otherwise +// this is a bug in node module loading as far as I am concerned +var util = require('./node_modules/util'); + 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; +var assert = module.exports = ok; // 2. The AssertionError is defined in assert. // new assert.AssertionError({ message: message, @@ -42,32 +42,52 @@ var assert = exports; assert.AssertionError = function AssertionError(options) { this.name = 'AssertionError'; - this.message = options.message; this.actual = options.actual; this.expected = options.expected; this.operator = options.operator; + if (options.message) { + this.message = options.message; + this.generatedMessage = false; + } else { + this.message = getMessage(this); + this.generatedMessage = true; + } var stackStartFunction = options.stackStartFunction || fail; if (Error.captureStackTrace) { Error.captureStackTrace(this, stackStartFunction); } }; + +// assert.AssertionError instanceof Error util.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(' '); +function replacer(key, value) { + if (util.isUndefined(value)) { + return '' + value; } -}; + if (util.isNumber(value) && (isNaN(value) || !isFinite(value))) { + return value.toString(); + } + if (util.isFunction(value) || util.isRegExp(value)) { + return value.toString(); + } + return value; +} -// assert.AssertionError instanceof Error +function truncate(s, n) { + if (util.isString(s)) { + return s.length < n ? s : s.slice(0, n); + } else { + return s; + } +} -assert.AssertionError.__proto__ = Error.prototype; +function getMessage(self) { + return truncate(JSON.stringify(self.actual, replacer), 128) + ' ' + + self.operator + ' ' + + truncate(JSON.stringify(self.expected, replacer), 128); +} // At present only the three keys mentioned above are used and // understood by the spec. Implementations or sub modules can pass @@ -96,13 +116,14 @@ assert.fail = fail; // 4. Pure assertion tests whether a value is truthy, as determined // by !!guard. // assert.ok(guard, message_opt); -// This statement is equivalent to assert.equal(true, guard, +// This statement is equivalent to assert.equal(true, !!guard, // message_opt);. To test strictly for the value true, use // assert.strictEqual(true, guard, message_opt);. -assert.ok = function ok(value, message) { - if (!!!value) fail(value, true, message, '==', assert.ok); -}; +function ok(value, message) { + if (!value) fail(value, true, message, '==', assert.ok); +} +assert.ok = ok; // 5. The equality assertion tests shallow, coercive equality with // ==. @@ -135,7 +156,7 @@ function _deepEqual(actual, expected) { if (actual === expected) { return true; - } else if (Buffer.isBuffer(actual) && Buffer.isBuffer(expected)) { + } else if (util.isBuffer(actual) && util.isBuffer(expected)) { if (actual.length != expected.length) return false; for (var i = 0; i < actual.length; i++) { @@ -146,15 +167,25 @@ function _deepEqual(actual, expected) { // 7.2. If the expected value is a Date object, the actual value is // equivalent if it is also a Date object that refers to the same time. - } else if (actual instanceof Date && expected instanceof Date) { + } else if (util.isDate(actual) && util.isDate(expected)) { return actual.getTime() === expected.getTime(); - // 7.3. Other pairs that do not both pass typeof value == 'object', + // 7.3 If the expected value is a RegExp object, the actual value is + // equivalent if it is also a RegExp object with the same source and + // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`). + } else if (util.isRegExp(actual) && util.isRegExp(expected)) { + return actual.source === expected.source && + actual.global === expected.global && + actual.multiline === expected.multiline && + actual.lastIndex === expected.lastIndex && + actual.ignoreCase === expected.ignoreCase; + + // 7.4. Other pairs that do not both pass typeof value == 'object', // equivalence is determined by ==. - } else if (typeof actual != 'object' && typeof expected != 'object') { + } else if (!util.isObject(actual) && !util.isObject(expected)) { return actual == expected; - // 7.4. For all other Object pairs, including Array objects, equivalence is + // 7.5 For all other Object pairs, including Array objects, equivalence is // determined by having the same number of owned properties (as verified // with Object.prototype.hasOwnProperty.call), the same set of keys // (although not necessarily the same order), equivalent values for every @@ -165,16 +196,12 @@ function _deepEqual(actual, expected) { } } -function isUndefinedOrNull(value) { - return value === null || value === undefined; -} - function isArguments(object) { return Object.prototype.toString.call(object) == '[object Arguments]'; } function objEquiv(a, b) { - if (isUndefinedOrNull(a) || isUndefinedOrNull(b)) + if (util.isNullOrUndefined(a) || util.isNullOrUndefined(b)) return false; // an identical 'prototype' property. if (a.prototype !== b.prototype) return false; @@ -248,7 +275,7 @@ function expectedException(actual, expected) { return false; } - if (expected instanceof RegExp) { + if (Object.prototype.toString.call(expected) == '[object RegExp]') { return expected.test(actual); } else if (actual instanceof expected) { return true; @@ -262,7 +289,7 @@ function expectedException(actual, expected) { function _throws(shouldThrow, block, expected, message) { var actual; - if (typeof expected === 'string') { + if (util.isString(expected)) { message = expected; expected = null; } @@ -277,11 +304,11 @@ function _throws(shouldThrow, block, expected, message) { (message ? ' ' + message : '.'); if (shouldThrow && !actual) { - fail('Missing expected exception' + message); + fail(actual, expected, 'Missing expected exception' + message); } if (!shouldThrow && expectedException(actual, expected)) { - fail('Got unwanted exception' + message); + fail(actual, expected, 'Got unwanted exception' + message); } if ((shouldThrow && actual && expected && @@ -298,10 +325,8 @@ assert.throws = function(block, /*optional*/error, /*optional*/message) { }; // EXTENSION! This is annoying to write outside this module. -assert.doesNotThrow = function(block, /*optional*/error, /*optional*/message) { +assert.doesNotThrow = function(block, /*optional*/message) { _throws.apply(this, [false].concat(pSlice.call(arguments))); }; assert.ifError = function(err) { if (err) {throw err;}}; - -}()); diff --git a/package.json b/package.json index 16cc68a..21fef66 100644 --- a/package.json +++ b/package.json @@ -13,6 +13,12 @@ }, "main": "./assert.js", "dependencies": { - "util": ">= 0.4.9" + "util": "0.10.0" + }, + "devDependencies": { + "mocha": "1.14.0" + }, + "scripts": { + "test": "mocha --ui qunit test.js" } } diff --git a/test.js b/test.js new file mode 100644 index 0000000..3151a93 --- /dev/null +++ b/test.js @@ -0,0 +1,322 @@ +// Copyright Joyent, Inc. and other Node contributors. +// +// 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 OR COPYRIGHT HOLDERS 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. + +var assert = require('./'); + +var keys = Object.keys; + +function makeBlock(f) { + var args = Array.prototype.slice.call(arguments, 1); + return function() { + return f.apply(this, args); + }; +} + +test('assert.ok', function () { + assert.throws(makeBlock(assert, false), assert.AssertionError, 'ok(false)'); + + assert.doesNotThrow(makeBlock(assert, true), assert.AssertionError, 'ok(true)'); + + assert.doesNotThrow(makeBlock(assert, 'test', 'ok(\'test\')')); + + assert.throws(makeBlock(assert.ok, false), + assert.AssertionError, 'ok(false)'); + + assert.doesNotThrow(makeBlock(assert.ok, true), + assert.AssertionError, 'ok(true)'); + + assert.doesNotThrow(makeBlock(assert.ok, 'test'), 'ok(\'test\')'); +}); + +test('assert.equal', function () { + assert.throws(makeBlock(assert.equal, true, false), assert.AssertionError, 'equal'); + + assert.doesNotThrow(makeBlock(assert.equal, null, null), 'equal'); + + assert.doesNotThrow(makeBlock(assert.equal, undefined, undefined), 'equal'); + + assert.doesNotThrow(makeBlock(assert.equal, null, undefined), 'equal'); + + assert.doesNotThrow(makeBlock(assert.equal, true, true), 'equal'); + + assert.doesNotThrow(makeBlock(assert.equal, 2, '2'), 'equal'); + + assert.doesNotThrow(makeBlock(assert.notEqual, true, false), 'notEqual'); + + assert.throws(makeBlock(assert.notEqual, true, true), + assert.AssertionError, 'notEqual'); +}); + +test('assert.strictEqual', function () { + assert.throws(makeBlock(assert.strictEqual, 2, '2'), + assert.AssertionError, 'strictEqual'); + + assert.throws(makeBlock(assert.strictEqual, null, undefined), + assert.AssertionError, 'strictEqual'); + + assert.doesNotThrow(makeBlock(assert.notStrictEqual, 2, '2'), 'notStrictEqual'); +}); + +test('assert.deepEqual - 7.2', function () { + assert.doesNotThrow(makeBlock(assert.deepEqual, new Date(2000, 3, 14), + new Date(2000, 3, 14)), 'deepEqual date'); + + assert.throws(makeBlock(assert.deepEqual, new Date(), new Date(2000, 3, 14)), + assert.AssertionError, + 'deepEqual date'); +}); + +test('assert.deepEqual - 7.3', function () { + assert.doesNotThrow(makeBlock(assert.deepEqual, /a/, /a/)); + assert.doesNotThrow(makeBlock(assert.deepEqual, /a/g, /a/g)); + assert.doesNotThrow(makeBlock(assert.deepEqual, /a/i, /a/i)); + assert.doesNotThrow(makeBlock(assert.deepEqual, /a/m, /a/m)); + assert.doesNotThrow(makeBlock(assert.deepEqual, /a/igm, /a/igm)); + assert.throws(makeBlock(assert.deepEqual, /ab/, /a/)); + assert.throws(makeBlock(assert.deepEqual, /a/g, /a/)); + assert.throws(makeBlock(assert.deepEqual, /a/i, /a/)); + assert.throws(makeBlock(assert.deepEqual, /a/m, /a/)); + assert.throws(makeBlock(assert.deepEqual, /a/igm, /a/im)); + + var re1 = /a/; + re1.lastIndex = 3; + assert.throws(makeBlock(assert.deepEqual, re1, /a/)); +}); + +test('assert.deepEqual - 7.4', function () { + assert.doesNotThrow(makeBlock(assert.deepEqual, 4, '4'), 'deepEqual == check'); + assert.doesNotThrow(makeBlock(assert.deepEqual, true, 1), 'deepEqual == check'); + assert.throws(makeBlock(assert.deepEqual, 4, '5'), + assert.AssertionError, + 'deepEqual == check'); +}); + +test('assert.deepEqual - 7.5', function () { + // having the same number of owned properties && the same set of keys + assert.doesNotThrow(makeBlock(assert.deepEqual, {a: 4}, {a: 4})); + assert.doesNotThrow(makeBlock(assert.deepEqual, {a: 4, b: '2'}, {a: 4, b: '2'})); + assert.doesNotThrow(makeBlock(assert.deepEqual, [4], ['4'])); + assert.throws(makeBlock(assert.deepEqual, {a: 4}, {a: 4, b: true}), + assert.AssertionError); + assert.doesNotThrow(makeBlock(assert.deepEqual, ['a'], {0: 'a'})); + //(although not necessarily the same order), + assert.doesNotThrow(makeBlock(assert.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(assert.deepEqual, keys(a1), keys(a2)), + assert.AssertionError); + assert.doesNotThrow(makeBlock(assert.deepEqual, a1, a2)); +}); + +test('assert.deepEqual - instances', function () { + // having an identical prototype property + var nbRoot = { + toString: function() { return this.first + ' ' + this.last; } + }; + + function nameBuilder(first, last) { + this.first = first; + this.last = last; + return this; + } + nameBuilder.prototype = nbRoot; + + function nameBuilder2(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(assert.deepEqual, nb1, nb2)); + + nameBuilder2.prototype = Object; + nb2 = new nameBuilder2('Ryan', 'Dahl'); + assert.throws(makeBlock(assert.deepEqual, nb1, nb2), assert.AssertionError); + + // String literal + object blew up my implementation... + assert.throws(makeBlock(assert.deepEqual, 'a', {}), assert.AssertionError); +}); + +function thrower(errorConstructor) { + throw new errorConstructor('test'); +} + +test('assert - Testing the throwing', function () { + var aethrow = makeBlock(thrower, assert.AssertionError); + aethrow = makeBlock(thrower, assert.AssertionError); + + // the basic calls work + assert.throws(makeBlock(thrower, assert.AssertionError), + assert.AssertionError, 'message'); + assert.throws(makeBlock(thrower, assert.AssertionError), assert.AssertionError); + assert.throws(makeBlock(thrower, assert.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 { + assert.throws(makeBlock(thrower, TypeError), assert.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', + assert.AssertionError); + threw = false; + + // doesNotThrow should pass through all errors + try { + assert.doesNotThrow(makeBlock(thrower, TypeError), assert.AssertionError); + } catch (e) { + threw = true; + assert.ok(e instanceof TypeError); + } + assert.equal(true, threw, + 'a.doesNotThrow with an explicit error is eating extra errors'); + + // key difference is that throwing our correct error makes an assertion error + try { + assert.doesNotThrow(makeBlock(thrower, TypeError), TypeError); + } catch (e) { + threw = true; + assert.ok(e instanceof assert.AssertionError); + } + assert.equal(true, threw, + 'a.doesNotThrow is not catching type matching errors'); +}); + +test('assert.ifError', function () { + assert.throws(function() {assert.ifError(new Error('test error'))}); + assert.doesNotThrow(function() {assert.ifError(null)}); + assert.doesNotThrow(function() {assert.ifError()}); +}); + +test('assert - make sure that validating using constructor really works', function () { + var threw = false; + try { + assert.throws( + function() { + throw ({}); + }, + Array + ); + } catch (e) { + threw = true; + } + assert.ok(threw, 'wrong constructor validation'); +}); + +test('assert - use a RegExp to validate error message', function () { + assert.throws(makeBlock(thrower, TypeError), /test/); +}); + +test('assert - se a fn to validate error object', function () { + assert.throws(makeBlock(thrower, TypeError), function(err) { + if ((err instanceof TypeError) && /test/.test(err)) { + return true; + } + }); +}); + +test('assert - Make sure deepEqual doesn\'t loop forever on circular refs', function () { + var b = {}; + b.b = b; + + var c = {}; + c.b = c; + + var gotError = false; + try { + assert.deepEqual(b, c); + } catch (e) { + gotError = true; + } + + assert.ok(gotError); +}); + + +test('assert - test assertion message', function () { + function testAssertionMessage(actual, expected) { + try { + assert.equal(actual, ''); + } catch (e) { + assert.equal(e.toString(), + ['AssertionError:', expected, '==', '""'].join(' ')); + } + } + testAssertionMessage(undefined, '"undefined"'); + testAssertionMessage(null, 'null'); + testAssertionMessage(true, 'true'); + testAssertionMessage(false, 'false'); + testAssertionMessage(0, '0'); + testAssertionMessage(100, '100'); + testAssertionMessage(NaN, '"NaN"'); + testAssertionMessage(Infinity, '"Infinity"'); + testAssertionMessage(-Infinity, '"-Infinity"'); + testAssertionMessage('', '""'); + testAssertionMessage('foo', '"foo"'); + testAssertionMessage([], '[]'); + testAssertionMessage([1, 2, 3], '[1,2,3]'); + testAssertionMessage(/a/, '"/a/"'); + testAssertionMessage(function f() {}, '"function f() {}"'); + testAssertionMessage({}, '{}'); + testAssertionMessage({a: undefined, b: null}, '{"a":"undefined","b":null}'); + testAssertionMessage({a: NaN, b: Infinity, c: -Infinity}, + '{"a":"NaN","b":"Infinity","c":"-Infinity"}'); +}); + +test('assert - regressions from node.js testcase', function () { + var threw = false; + + try { + assert.throws(function () { + assert.ifError(null); + }); + } catch (e) { + threw = true; + assert.equal(e.message, 'Missing expected exception..'); + } + assert.ok(threw); + + try { + assert.equal(1, 2); + } catch (e) { + assert.equal(e.toString().split('\n')[0], 'AssertionError: 1 == 2'); + } + + try { + assert.equal(1, 2, 'oh no'); + } catch (e) { + assert.equal(e.toString().split('\n')[0], 'AssertionError: oh no'); + } +});