From 9d914143fc77ffbfc2f750c4116fc7a8d1e5894c Mon Sep 17 00:00:00 2001 From: Eli White Date: Thu, 1 Sep 2016 10:34:58 -0700 Subject: [PATCH 1/4] Adding `.finite`. Fixes #271 --- lib/chai/core/assertions.js | 23 +++++++++++++++++++++++ lib/chai/interface/assert.js | 20 ++++++++++++++++++++ test/assert.js | 13 +++++++++++++ test/expect.js | 25 +++++++++++++++++++++++++ 4 files changed, 81 insertions(+) diff --git a/lib/chai/core/assertions.js b/lib/chai/core/assertions.js index ee442b2eb..1c71b4de8 100644 --- a/lib/chai/core/assertions.js +++ b/lib/chai/core/assertions.js @@ -2145,4 +2145,27 @@ module.exports = function (chai, _) { , 'expected #{this} to not be frozen' ); }); + + /** + * ### .finite + * + * Asserts that the target is a finite number. Unlike `.a('number')`, this will fail for `NaN` and `Infinity` + * + * expect(foo).to.be.finite(); + * + * @name finite + * @namespace BDD + * @api public + */ + + Assertion.addMethod('finite', function(msg) { + if (msg) flag(this, 'message', msg); + var obj = flag(this, 'object'); + + this.assert( + typeof obj === "number" && isFinite(obj) + , 'expected #{this} to be a finite number' + , 'expected #{this} to not be a finite number' + ); + }); }; diff --git a/lib/chai/interface/assert.js b/lib/chai/interface/assert.js index 898e5b6c3..64c1ef280 100644 --- a/lib/chai/interface/assert.js +++ b/lib/chai/interface/assert.js @@ -732,6 +732,26 @@ module.exports = function (chai, util) { new Assertion(val, msg).to.not.be.a('number'); }; + /** + * ### .isFinite(value, [message]) + * + * Asserts that `value` is a finite number. This will fail for NaN, unlike `.isNumber` + * Asserts that `value` is a finite number. Unlike `.isNumber`, this will fail for `NaN` and `Infinity` + * + * var cups = 2; + * assert.isFinite(cups, 'how many cups'); + * + * @name isFinite + * @param {Number} value + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.isFinite = function (val, msg) { + new Assertion(val, msg).to.be.finite(); + }; + /** * ### .isBoolean(value, [message]) * diff --git a/test/assert.js b/test/assert.js index 91da9d58c..2dd50a973 100644 --- a/test/assert.js +++ b/test/assert.js @@ -459,6 +459,19 @@ describe('assert', function () { }, "expected 4 not to be a number"); }); + it('isFinite', function() { + assert.isFinite(1); + assert.isFinite(Number('3')); + + err(function () { + assert.isFinite('1'); + }, "expected \'1\' to be a finite number"); + + err(function () { + assert.isFinite(NaN); + }, "expected NaN to be a finite number"); + }) + it('isBoolean', function() { assert.isBoolean(true); assert.isBoolean(false); diff --git a/test/expect.js b/test/expect.js index 8560608e4..57024985f 100644 --- a/test/expect.js +++ b/test/expect.js @@ -493,6 +493,31 @@ describe('expect', function () { }, "expected 'foo' not to be NaN"); }); + it('finite', function() { + expect(4).to.be.finite(); + expect(-10).to.be.finite(); + + err(function(){ + expect(NaN).to.be.finite(); + }, "expected NaN to be a finite number"); + + err(function(){ + expect(Infinity).to.be.finite(); + }, "expected Infinity to be a finite number"); + + err(function(){ + expect('foo').to.be.finite(); + }, "expected \'foo\' to be a finite number"); + + err(function(){ + expect([]).to.be.finite(); + }, "expected [] to be a finite number"); + + err(function(){ + expect({}).to.be.finite(); + }, "expected {} to be a finite number"); + }); + it('property(name)', function(){ expect('test').to.have.property('length'); expect(4).to.not.have.property('length'); From 754bd2415df0385ba4b50d0d3a23a9af174906dd Mon Sep 17 00:00:00 2001 From: Eli White Date: Thu, 1 Sep 2016 12:57:30 -0700 Subject: [PATCH 2/4] Adding tests for should. Fixing comment --- lib/chai/interface/assert.js | 1 - test/should.js | 25 +++++++++++++++++++++++++ 2 files changed, 25 insertions(+), 1 deletion(-) diff --git a/lib/chai/interface/assert.js b/lib/chai/interface/assert.js index 64c1ef280..44e6bd65e 100644 --- a/lib/chai/interface/assert.js +++ b/lib/chai/interface/assert.js @@ -735,7 +735,6 @@ module.exports = function (chai, util) { /** * ### .isFinite(value, [message]) * - * Asserts that `value` is a finite number. This will fail for NaN, unlike `.isNumber` * Asserts that `value` is a finite number. Unlike `.isNumber`, this will fail for `NaN` and `Infinity` * * var cups = 2; diff --git a/test/should.js b/test/should.js index 19a90acff..1281b3928 100644 --- a/test/should.js +++ b/test/should.js @@ -431,6 +431,31 @@ describe('should', function() { }, "expected { foo: \'bar\' } to be empty"); }); + it('finite(value)', function() { + (4).should.be.finite(); + (-10).should.be.finite(); + + err(function(){ + (NaN).should.be.finite(); + }, "expected NaN to be a finite number"); + + err(function(){ + (Infinity).should.be.finite(); + }, "expected Infinity to be a finite number"); + + err(function(){ + ('foo').should.be.finite(); + }, "expected \'foo\' to be a finite number"); + + err(function(){ + ([]).should.be.finite(); + }, "expected [] to be a finite number"); + + err(function(){ + ({}).should.be.finite(); + }, "expected {} to be a finite number"); + }); + it('property(name)', function(){ 'test'.should.have.property('length'); (4).should.not.have.property('length'); From 10cacc59be066e169e6470f5853f777b1849a884 Mon Sep 17 00:00:00 2001 From: Eli White Date: Thu, 1 Sep 2016 13:00:43 -0700 Subject: [PATCH 3/4] More docs updates --- lib/chai/core/assertions.js | 5 +++-- lib/chai/interface/assert.js | 2 ++ 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/lib/chai/core/assertions.js b/lib/chai/core/assertions.js index 1c71b4de8..aa3c51bf2 100644 --- a/lib/chai/core/assertions.js +++ b/lib/chai/core/assertions.js @@ -2149,9 +2149,10 @@ module.exports = function (chai, _) { /** * ### .finite * - * Asserts that the target is a finite number. Unlike `.a('number')`, this will fail for `NaN` and `Infinity` + * Asserts that the target is a finite number. Unlike `.a('number')`, this will fail for `NaN` and `Infinity`. * - * expect(foo).to.be.finite(); + * expect(4).to.be.finite(); + * expect(NaN).to.not.be.finite(); * * @name finite * @namespace BDD diff --git a/lib/chai/interface/assert.js b/lib/chai/interface/assert.js index 44e6bd65e..7fd54fc5f 100644 --- a/lib/chai/interface/assert.js +++ b/lib/chai/interface/assert.js @@ -740,6 +740,8 @@ module.exports = function (chai, util) { * var cups = 2; * assert.isFinite(cups, 'how many cups'); * + * assert.isFinite(NaN); // throws + * * @name isFinite * @param {Number} value * @param {String} message From f26e415be5d2655a7b43c28d9861021bd765b249 Mon Sep 17 00:00:00 2001 From: Eli White Date: Thu, 1 Sep 2016 20:55:09 -0700 Subject: [PATCH 4/4] Use a property assertion and update tests --- lib/chai/core/assertions.js | 7 +++---- lib/chai/interface/assert.js | 2 +- test/assert.js | 26 +++++++++++++++++++------- test/expect.js | 14 +++++++------- test/should.js | 14 +++++++------- 5 files changed, 37 insertions(+), 26 deletions(-) diff --git a/lib/chai/core/assertions.js b/lib/chai/core/assertions.js index aa3c51bf2..d38aaaed6 100644 --- a/lib/chai/core/assertions.js +++ b/lib/chai/core/assertions.js @@ -2151,16 +2151,15 @@ module.exports = function (chai, _) { * * Asserts that the target is a finite number. Unlike `.a('number')`, this will fail for `NaN` and `Infinity`. * - * expect(4).to.be.finite(); - * expect(NaN).to.not.be.finite(); + * expect(4).to.be.finite; + * expect(NaN).to.not.be.finite; * * @name finite * @namespace BDD * @api public */ - Assertion.addMethod('finite', function(msg) { - if (msg) flag(this, 'message', msg); + Assertion.addProperty('finite', function(msg) { var obj = flag(this, 'object'); this.assert( diff --git a/lib/chai/interface/assert.js b/lib/chai/interface/assert.js index 7fd54fc5f..3d1f69295 100644 --- a/lib/chai/interface/assert.js +++ b/lib/chai/interface/assert.js @@ -750,7 +750,7 @@ module.exports = function (chai, util) { */ assert.isFinite = function (val, msg) { - new Assertion(val, msg).to.be.finite(); + new Assertion(val, msg).to.be.finite; }; /** diff --git a/test/assert.js b/test/assert.js index 2dd50a973..8140b7a07 100644 --- a/test/assert.js +++ b/test/assert.js @@ -460,16 +460,28 @@ describe('assert', function () { }); it('isFinite', function() { - assert.isFinite(1); - assert.isFinite(Number('3')); + assert.isFinite(4); + assert.isFinite(-10); - err(function () { - assert.isFinite('1'); - }, "expected \'1\' to be a finite number"); - - err(function () { + err(function(){ assert.isFinite(NaN); }, "expected NaN to be a finite number"); + + err(function(){ + assert.isFinite(Infinity); + }, "expected Infinity to be a finite number"); + + err(function(){ + assert.isFinite('foo'); + }, "expected \'foo\' to be a finite number"); + + err(function(){ + assert.isFinite([]); + }, "expected [] to be a finite number"); + + err(function(){ + assert.isFinite({}); + }, "expected {} to be a finite number"); }) it('isBoolean', function() { diff --git a/test/expect.js b/test/expect.js index 57024985f..42b50e632 100644 --- a/test/expect.js +++ b/test/expect.js @@ -494,27 +494,27 @@ describe('expect', function () { }); it('finite', function() { - expect(4).to.be.finite(); - expect(-10).to.be.finite(); + expect(4).to.be.finite; + expect(-10).to.be.finite; err(function(){ - expect(NaN).to.be.finite(); + expect(NaN).to.be.finite; }, "expected NaN to be a finite number"); err(function(){ - expect(Infinity).to.be.finite(); + expect(Infinity).to.be.finite; }, "expected Infinity to be a finite number"); err(function(){ - expect('foo').to.be.finite(); + expect('foo').to.be.finite; }, "expected \'foo\' to be a finite number"); err(function(){ - expect([]).to.be.finite(); + expect([]).to.be.finite; }, "expected [] to be a finite number"); err(function(){ - expect({}).to.be.finite(); + expect({}).to.be.finite; }, "expected {} to be a finite number"); }); diff --git a/test/should.js b/test/should.js index 1281b3928..c32a9e3ac 100644 --- a/test/should.js +++ b/test/should.js @@ -432,27 +432,27 @@ describe('should', function() { }); it('finite(value)', function() { - (4).should.be.finite(); - (-10).should.be.finite(); + (4).should.be.finite; + (-10).should.be.finite; err(function(){ - (NaN).should.be.finite(); + (NaN).should.be.finite; }, "expected NaN to be a finite number"); err(function(){ - (Infinity).should.be.finite(); + (Infinity).should.be.finite; }, "expected Infinity to be a finite number"); err(function(){ - ('foo').should.be.finite(); + ('foo').should.be.finite; }, "expected \'foo\' to be a finite number"); err(function(){ - ([]).should.be.finite(); + ([]).should.be.finite; }, "expected [] to be a finite number"); err(function(){ - ({}).should.be.finite(); + ({}).should.be.finite; }, "expected {} to be a finite number"); });