| var tap = require('tap') |
| var test = tap.test |
| var match = require('../') |
| |
| test("shouldn't care about key order and types", function (t) { |
| t.ok(match({ a: 1, b: 2 }, { b: 2, a: '1' })) |
| t.end() |
| }) |
| |
| test('should notice objects with different shapes', function (t) { |
| t.notOk(match( |
| { a: 1, b: 'a thing' }, |
| { a: 1, b: undefined } |
| )) |
| t.ok(match( |
| { a: 1 }, |
| { a: 1, b: undefined } |
| )) |
| t.end() |
| }) |
| |
| test('extra keys in object are ok', function (t) { |
| t.ok(match( |
| { a: 1, b: null, c: 'ok' }, |
| { a: 1, b: undefined } |
| )) |
| t.end() |
| }) |
| |
| test('should notice objects with different keys', function (t) { |
| t.notOk(match( |
| { a: 1, b: 2 }, |
| { a: 1, c: 2 } |
| )) |
| t.end() |
| }) |
| |
| test('should handle dates', function (t) { |
| t.notOk(match(new Date('1972-08-01'), null)) |
| t.notOk(match(new Date('1972-08-01'), undefined)) |
| t.ok(match(new Date('1972-08-01'), new Date('1972-08-01'))) |
| t.ok(match({ x: new Date('1972-08-01') }, { x: new Date('1972-08-01') })) |
| t.end() |
| }) |
| |
| test('should handle RegExps', function (t) { |
| t.notOk(match(/[b]/, /[a]/)) |
| t.notOk(match(/[a]/i, /[a]/g)) |
| t.ok(match(/[a]/, /[a]/)) |
| t.ok(match(/ab?[a-z]{,6}/g, /ab?[a-z]{,6}/g)) |
| t.notOk(match([1, 2, 3], /asdf/)) |
| t.ok(match([1, 2, 3], /,2,/)) |
| t.ok(match({ x: 123 }, { x: /^\w+/ })) |
| t.ok(match({ toString: function () { return 'FooBar' }}, /^FooBar$/)) |
| t.notOk(match({ toString: function () { return 'x' }}, /^FooBar$/)) |
| t.end() |
| }) |
| |
| test('should handle functions', function (t) { |
| var fnA = function (a) { return a } |
| var fnB = function (a) { return a } |
| |
| t.notOk(match( |
| function a () {}, |
| function a () {} // but is it the _same_ a tho |
| )) |
| t.notOk(match(fnA, fnB)) |
| t.ok(match(fnA, fnA)) |
| t.ok(match(fnB, fnB)) |
| t.end() |
| }) |
| |
| test('should handle arguments', function (t) { |
| var outer = arguments |
| ;(function (tt) { |
| var inner = arguments |
| t.ok(match(outer, outer)) |
| t.ok(match(outer, inner)) |
| t.ok(match(outer, [t])) |
| }(t)) |
| t.end() |
| }) |
| |
| test('same arrays match', function (t) { |
| t.ok(match([1, 2, 3], [1, 2, 3])) |
| t.end() |
| }) |
| |
| test("different arrays don't match", function (t) { |
| t.notOk(match([1, 2, 3], [1, 2, 3, 4])) |
| t.notOk(match([1, 2, 3], [1, 2, 4])) |
| t.end() |
| }) |
| |
| test('empty arrays match', function (t) { |
| t.ok(match([], [])) |
| t.ok(match({ x: [] }, { x: [] })) |
| t.end() |
| }) |
| |
| test("shallower shouldn't care about key order recursively and types", function (t) { |
| t.ok(match( |
| { x: { a: 1, b: 2 }, y: { c: 3, d: 4 } }, |
| { y: { d: 4, c: 3 }, x: { b: '2', a: '1' } } |
| )) |
| t.end() |
| }) |
| |
| test('undefined is the same as itself', function (t) { |
| t.ok(match(undefined, undefined)) |
| t.ok(match({ x: undefined }, { x: undefined })) |
| t.ok(match({ x: [undefined] }, { x: [undefined] })) |
| t.end() |
| }) |
| |
| test('undefined and null are Close Enough', function (t) { |
| t.ok(match(undefined, null)) |
| t.ok(match({ x: null }, { x: undefined })) |
| t.ok(match({ x: [undefined] }, { x: [null] })) |
| t.end() |
| }) |
| |
| test("null is as shallow as you'd expect", function (t) { |
| t.ok(match(null, null)) |
| t.ok(match({ x: null }, { x: null })) |
| t.ok(match({ x: [null] }, { x: [null] })) |
| t.end() |
| }) |
| |
| test('the same number matches', function (t) { |
| t.ok(match(0, 0)) |
| t.ok(match(1, 1)) |
| t.ok(match(3.14, 3.14)) |
| t.end() |
| }) |
| |
| test("different numbers don't match", function (t) { |
| t.notOk(match(0, 1)) |
| t.notOk(match(1, -1)) |
| t.notOk(match(3.14, 2.72)) |
| t.end() |
| }) |
| |
| test("tmatch shouldn't care about key order (but still might) and types", function (t) { |
| t.ok(match( |
| [ |
| { foo: { z: 100, y: 200, x: 300 } }, |
| 'bar', |
| 11, |
| { baz: { d: 4, a: 1, b: 2, c: 3 } } |
| ], |
| [ |
| { foo: { z: 100, y: 200, x: 300 } }, |
| 'bar', |
| 11, |
| { baz: { a: '1', b: '2', c: '3', d: '4' } } |
| ] |
| )) |
| t.end() |
| }) |
| |
| test("match shouldn't blow up on circular data structures", function (t) { |
| var x1 = { z: 4 } |
| var y1 = { x: x1 } |
| x1.y = y1 |
| |
| var x2 = { z: 4 } |
| var y2 = { x: x2 } |
| x2.y = y2 |
| |
| t.ok(match(x1, x2)) |
| t.end() |
| }) |
| |
| test('regexps match strings', function (t) { |
| var x = { one: 'String' } |
| var y = { one: /.ring$/ } |
| t.ok(match(x, y)) |
| t.ok(match(x.one, y.one)) |
| |
| x = [ 'String', 'String' ] |
| y = [ /.ring$/, /.ring$/ ] |
| t.ok(match(x, y)) |
| |
| x = [ 'Ring', /.ring$/ ] |
| y = [ /.ring$/ ] |
| t.notOk(match(x, y)) |
| t.end() |
| }) |
| |
| test('partial strings match on indexOf', function (t) { |
| var x = { one: 'String' } |
| var y = { one: 'rin' } |
| |
| t.ok(match(x, y)) |
| t.notOk(match(y, x)) |
| t.end() |
| }) |
| |
| test('ctors and other fun things', function (t) { |
| function Foo () { |
| this._isFoo = 'foo' |
| } |
| |
| if (!Buffer.prototype.equals) { |
| Buffer.prototype.equals = function (pattern) { |
| var obj = this |
| if (obj.length !== pattern.length) return false |
| for (var j = 0; j < obj.length; j++) if (obj[j] != pattern[j]) return false |
| |
| return true |
| } |
| } |
| |
| t.notOk(match(new Buffer('asdf'), new Buffer('asdff'))) |
| |
| var d = new Date().toISOString() |
| |
| var obj = { |
| buffer: new Buffer('x'), |
| date: new Date(d), |
| fn: function () {}, |
| foo: new Foo(), |
| num: 1.2, |
| nan: NaN, |
| bool: true, |
| array: [], |
| str: 'asdf', |
| inf: Infinity, |
| neginf: -Infinity |
| } |
| |
| t.ok(match(obj, { |
| buffer: Buffer, |
| date: Date, |
| fn: Function, |
| foo: Foo, |
| num: Number, |
| nan: NaN, |
| bool: Boolean, |
| array: Array, |
| str: String |
| })) |
| |
| t.ok(match(obj, { |
| buffer: new Buffer('x'), |
| date: d, |
| foo: new Foo(), |
| str: 'sd' |
| })) |
| |
| var buf = new Buffer('x') |
| buf.equals = null |
| t.ok(match(obj, { |
| buffer: buf |
| })) |
| |
| var buf2 = new Buffer('y') |
| buf2.equals = null |
| t.notOk(match(buf, buf2)) |
| |
| var buf3 = new Buffer('xy') |
| buf3.equals = null |
| t.notOk(match(buf, buf3)) |
| |
| var buf4 = new Buffer('xy') |
| buf4.equals = null |
| t.ok(match(buf4, buf3)) |
| |
| t.notOk(match(obj, { |
| inf: Number |
| })) |
| |
| t.notOk(match(obj, { |
| neginf: Number |
| })) |
| |
| t.notOk(match(obj, { |
| nan: Number |
| })) |
| |
| t.end() |
| }) |
| |
| test('js WAT! array/string stuff', function (t) { |
| t.notOk(match([1], 1)) |
| t.notOk(match(1, [1])) |
| t.ok(match([1], [1])) |
| var o = {} |
| t.ok(match(o, o)) |
| t.ok(match(1, '1')) |
| t.end() |
| }) |