From 047f61b1ebb0a1bbe0693905f7f26f1ff9d2dbc8 Mon Sep 17 00:00:00 2001 From: Jake Lazaroff Date: Sat, 12 Dec 2015 16:02:50 -0500 Subject: [PATCH] Use Iterable.isIterable for Immutable check --- chai-immutable.js | 10 ++++---- test/test.js | 65 +++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 70 insertions(+), 5 deletions(-) diff --git a/chai-immutable.js b/chai-immutable.js index 1adb128..eee10e1 100644 --- a/chai-immutable.js +++ b/chai-immutable.js @@ -46,7 +46,7 @@ return function () { var obj = this._obj; - if (obj && obj instanceof Collection) { + if (Immutable.Iterable.isIterable(obj)) { var size = obj.size; new Assertion(size).a('number'); @@ -96,7 +96,7 @@ return function (collection) { var obj = this._obj; - if (obj && obj instanceof Collection) { + if (Immutable.Iterable.isIterable(obj)) { this.assert( Immutable.is(obj, collection), 'expected #{act} to equal #{exp}', @@ -141,7 +141,7 @@ return function (val) { var obj = this._obj; - if (obj && obj instanceof Collection) { + if (Immutable.Iterable.isIterable(obj)) { this.assert( obj.includes(val), 'expected #{act} to include #{exp}', @@ -483,7 +483,7 @@ // It seems like we shouldn't actually need this check, however, // `assert.equal` actually behaves differently than its BDD counterpart! // Namely, the BDD version is strict while the "assert" one isn't. - if (actual instanceof Collection) { + if (Immutable.Iterable.isIterable(actual)) { return new Assertion(actual).equal(expected); } else return originalEqual(actual, expected); @@ -509,7 +509,7 @@ */ assert.notEqual = function (actual, expected) { - if (actual instanceof Collection) { + if (Immutable.Iterable.isIterable(actual)) { return new Assertion(actual).not.equal(expected); } else return originalNotEqual(actual, expected); diff --git a/test/test.js b/test/test.js index c982f3f..89b88bc 100644 --- a/test/test.js +++ b/test/test.js @@ -5,6 +5,7 @@ if (!chai) { var chai = require('chai'); var chaiImmutable = require('../chai-immutable'); var Immutable = require('immutable'); + var otherImmutable = require('../node_modules/immutable/dist/immutable.min.js'); chai.use(chaiImmutable); typeEnv = 'Node.js'; @@ -45,6 +46,8 @@ describe('chai-immutable (' + typeEnv + ')', function () { list: List.of(42) }); + var otherImmutableList = otherImmutable.List.of(1, 2, 3); + describe('BDD interface', function () { describe('empty property', function () { it('should pass given an empty collection', function () { @@ -68,6 +71,12 @@ describe('chai-immutable (' + typeEnv + ')', function () { it('should fail using `not` given an empty collection', function () { fail(function () { expect(new List()).to.not.be.empty; }); }); + + if (typeEnv === 'Node.js') { + it('should work if using different copies of Immtuable', function () { + expect(otherImmutable.List()).to.be.empty; + }); + } }); describe('equal method', function () { @@ -162,6 +171,12 @@ describe('chai-immutable (' + typeEnv + ')', function () { fail(function () { expect(deepMap).to.not.eqls(sameDeepMap); }); fail(function () { expect(deepMap).to.not.deep.equal(sameDeepMap); }); }); + + if (typeEnv === 'Node.js') { + it('should work if using different copies of Immtuable', function () { + expect(otherImmutableList).to.equal(otherImmutable.List.of(1, 2, 3)); + }); + } }); describe('include method', function () { @@ -376,6 +391,12 @@ describe('chai-immutable (' + typeEnv + ')', function () { fail(function () { expect(map).to.contain.key('z'); }); fail(function () { expect(obj).to.contain.key('z'); }); }); + + if (typeEnv === 'Node.js') { + it('should work if using different copies of Immtuable', function () { + expect(otherImmutable.Map({ x: 1 })).to.have.key('x'); + }); + } }); describe('size method', function () { @@ -399,6 +420,12 @@ describe('chai-immutable (' + typeEnv + ')', function () { it('should fail using `not` given the right size', function () { fail(function () { expect(list3).to.not.have.size(3); }); }); + + if (typeEnv === 'Node.js') { + it('should work if using different copies of Immtuable', function () { + expect(otherImmutableList).to.have.size(3); + }); + } }); describe('size property', function () { @@ -530,6 +557,12 @@ describe('chai-immutable (' + typeEnv + ')', function () { it('most should fail using `not` given a bad max size', function () { fail(function () { expect(list3).to.not.have.size.of.at.most(42); }); }); + + if (typeEnv === 'Node.js') { + it('should work if using different copies of Immtuable', function () { + expect(otherImmutableList).to.have.size.above(2); + }); + } }); }); @@ -568,6 +601,12 @@ describe('chai-immutable (' + typeEnv + ')', function () { it('should fail given deeply different values', function () { fail(function () { assert.equal(deepMap, differentDeepMap); }); }); + + if (typeEnv === 'Node.js') { + it('should work if using different copies of Immtuable', function () { + assert.equal(otherImmutableList, otherImmutable.List.of(1, 2, 3)); + }); + } }); describe('notEqual assertion', function () { @@ -595,6 +634,12 @@ describe('chai-immutable (' + typeEnv + ')', function () { it('should fail given deeply equal values', function () { fail(function () { assert.notEqual(deepMap, sameDeepMap); }); }); + + if (typeEnv === 'Node.js') { + it('should work if using different copies of Immtuable', function () { + assert.notEqual(otherImmutableList, otherImmutable.List.of()); + }); + } }); describe('unoverridden strictEqual and deepEqual assertions', function () { @@ -617,6 +662,13 @@ describe('chai-immutable (' + typeEnv + ')', function () { fail(function () { assert.strictEqual(deepMap, differentDeepMap); }); fail(function () { assert.deepEqual(deepMap, differentDeepMap); }); }); + + if (typeEnv === 'Node.js') { + it('should work if using different copies of Immtuable', function () { + assert.strictEqual(otherImmutableList, otherImmutable.List.of(1, 2, 3)); + assert.deepEqual(otherImmutableList, otherImmutable.List.of(1, 2, 3)); + }); + } }); describe('unoverridden notStrictEqual and notDeepEqual assertions', function () { @@ -639,6 +691,13 @@ describe('chai-immutable (' + typeEnv + ')', function () { fail(function () { assert.notStrictEqual(deepMap, sameDeepMap); }); fail(function () { assert.notDeepEqual(deepMap, sameDeepMap); }); }); + + if (typeEnv === 'Node.js') { + it('should work if using different copies of Immtuable', function () { + assert.notStrictEqual(otherImmutableList, otherImmutable.List()); + assert.notDeepEqual(otherImmutableList, otherImmutable.List()); + }); + } }); describe('sizeOf assertion', function () { @@ -653,6 +712,12 @@ describe('chai-immutable (' + typeEnv + ')', function () { it('should fail given the wrong size', function () { fail(function () { assert.sizeOf(list3, 42); }); }); + + if (typeEnv === 'Node.js') { + it('should work if using different copies of Immtuable', function () { + assert.sizeOf(otherImmutableList, 3); + }); + } }); }); });