Support big int in approximently

lib/chai/core/assertions.js

@@ -233,7 +233,6 @@ Assertion.addProperty('any', function () {
  * @namespace BDD
  * @public
  */
-
 Assertion.addProperty('all', function () {
   flag(this, 'all', true);
   flag(this, 'any', false);
@@ -694,6 +693,17 @@ Assertion.addProperty('true', function () {
   );
 });
 
+Assertion.addProperty('numeric', function () {
+  const object = flag(this, 'object');
+
+  this.assert(
+      ['Number', 'BigInt'].includes(_.type(object))
+    , 'expected #{this} to be numeric'
+    , 'expected #{this} to not be numeric'
+    , flag(this, 'negate') ? false : true
+  );
+});
+
 /**
  * ### .callable
  *
@@ -1208,27 +1218,21 @@ function assertAbove (n, msg) {
     , msgPrefix = ((flagMsg) ? flagMsg + ': ' : '')
     , ssfi = flag(this, 'ssfi')
     , objType = _.type(obj).toLowerCase()
-    , nType = _.type(n).toLowerCase()
-    , errorMessage
-    , shouldThrow = true;
+    , nType = _.type(n).toLowerCase();
 
   if (doLength && objType !== 'map' && objType !== 'set') {
     new Assertion(obj, flagMsg, ssfi, true).to.have.property('length');
   }
 
+  const isNumeric = x => ['Number', 'BigInt'].includes(_.type(x))
+
   if (!doLength && (objType === 'date' && nType !== 'date')) {
-    errorMessage = msgPrefix + 'the argument to above must be a date';
-  } else if (nType !== 'number' && (doLength || objType === 'number')) {
-    errorMessage = msgPrefix + 'the argument to above must be a number';
-  } else if (!doLength && (objType !== 'date' && objType !== 'number')) {
+    throw new AssertionError(msgPrefix + 'the argument to above must be a date', undefined, ssfi);
+  } else if (!isNumeric(n) && (doLength || isNumeric(obj))) {
+    throw new AssertionError(msgPrefix + 'the argument to above must be a number', undefined, ssfi);
+  } else if (!doLength && (objType !== 'date' && !isNumeric(obj))) {
     var printObj = (objType === 'string') ? "'" + obj + "'" : obj;
-    errorMessage = msgPrefix + 'expected ' + printObj + ' to be a number or a date';
-  } else {
-    shouldThrow = false;
-  }
-
-  if (shouldThrow) {
-    throw new AssertionError(errorMessage, undefined, ssfi);
+    throw new AssertionError(msgPrefix + 'expected ' + printObj + ' to be a number or a date', undefined, ssfi);
   }
 
   if (doLength) {
@@ -1299,7 +1303,7 @@ Assertion.addMethod('greaterThan', assertAbove);
  * @name least
  * @alias gte
  * @alias greaterThanOrEqual
- * @param {number} n
+ * @param {unknown} n
  * @param {string} msg _optional_
  * @namespace BDD
  * @public
@@ -1320,11 +1324,13 @@ function assertLeast (n, msg) {
     new Assertion(obj, flagMsg, ssfi, true).to.have.property('length');
   }
 
+  const isNumeric = x => ['Number', 'BigInt'].includes(_.type(x))
+
   if (!doLength && (objType === 'date' && nType !== 'date')) {
     errorMessage = msgPrefix + 'the argument to least must be a date';
-  } else if (nType !== 'number' && (doLength || objType === 'number')) {
+  } else if (!isNumeric(n) && (doLength || isNumeric(obj))) {
     errorMessage = msgPrefix + 'the argument to least must be a number';
-  } else if (!doLength && (objType !== 'date' && objType !== 'number')) {
+  } else if (!doLength && (objType !== 'date' && !isNumeric(obj))) {
     var printObj = (objType === 'string') ? "'" + obj + "'" : obj;
     errorMessage = msgPrefix + 'expected ' + printObj + ' to be a number or a date';
   } else {
@@ -1402,7 +1408,7 @@ Assertion.addMethod('greaterThanOrEqual', assertLeast);
  * @name below
  * @alias lt
  * @alias lessThan
- * @param {number} n
+ * @param {unknown} n
  * @param {string} msg _optional_
  * @namespace BDD
  * @public
@@ -1422,12 +1428,14 @@ function assertBelow (n, msg) {
   if (doLength && objType !== 'map' && objType !== 'set') {
     new Assertion(obj, flagMsg, ssfi, true).to.have.property('length');
   }
+
+  const isNumeric = x => ['Number', 'BigInt'].includes(_.type(x))
 
   if (!doLength && (objType === 'date' && nType !== 'date')) {
     errorMessage = msgPrefix + 'the argument to below must be a date';
-  } else if (nType !== 'number' && (doLength || objType === 'number')) {
+  } else if (!isNumeric(n) && (doLength || isNumeric(obj))) {
     errorMessage = msgPrefix + 'the argument to below must be a number';
-  } else if (!doLength && (objType !== 'date' && objType !== 'number')) {
+  } else if (!doLength && (objType !== 'date' && !isNumeric(obj))) {
     var printObj = (objType === 'string') ? "'" + obj + "'" : obj;
     errorMessage = msgPrefix + 'expected ' + printObj + ' to be a number or a date';
   } else {
@@ -1506,7 +1514,7 @@ Assertion.addMethod('lessThan', assertBelow);
  * @name most
  * @alias lte
  * @alias lessThanOrEqual
- * @param {number} n
+ * @param {unknown} n
  * @param {string} msg _optional_
  * @namespace BDD
  * @public
@@ -1527,11 +1535,13 @@ function assertMost (n, msg) {
     new Assertion(obj, flagMsg, ssfi, true).to.have.property('length');
   }
 
+  const isNumeric = x => ['Number', 'BigInt'].includes(_.type(x))
+
   if (!doLength && (objType === 'date' && nType !== 'date')) {
     errorMessage = msgPrefix + 'the argument to most must be a date';
-  } else if (nType !== 'number' && (doLength || objType === 'number')) {
+  } else if (!isNumeric(n) && (doLength || isNumeric(obj))) {
     errorMessage = msgPrefix + 'the argument to most must be a number';
-  } else if (!doLength && (objType !== 'date' && objType !== 'number')) {
+  } else if (!doLength && (objType !== 'date' && !isNumeric(obj))) {
     var printObj = (objType === 'string') ? "'" + obj + "'" : obj;
     errorMessage = msgPrefix + 'expected ' + printObj + ' to be a number or a date';
   } else {
@@ -1608,8 +1618,8 @@ Assertion.addMethod('lessThanOrEqual', assertMost);
  *     expect(4, 'nooo why fail??').to.be.within(1, 3);
  *
  * @name within
- * @param {number} start lower bound inclusive
- * @param {number} finish upper bound inclusive
+ * @param {unknown} start lower bound inclusive
+ * @param {unknown} finish upper bound inclusive
  * @param {string} msg _optional_
  * @namespace BDD
  * @public
@@ -1633,12 +1643,14 @@ Assertion.addMethod('within', function (start, finish, msg) {
   if (doLength && objType !== 'map' && objType !== 'set') {
     new Assertion(obj, flagMsg, ssfi, true).to.have.property('length');
   }
+
+  const isNumeric = x => ['Number', 'BigInt'].includes(_.type(x))
 
   if (!doLength && (objType === 'date' && (startType !== 'date' || finishType !== 'date'))) {
     errorMessage = msgPrefix + 'the arguments to within must be dates';
-  } else if ((startType !== 'number' || finishType !== 'number') && (doLength || objType === 'number')) {
+  } else if ((!isNumeric(start) || !isNumeric(finish)) && (doLength || isNumeric(obj))) {
     errorMessage = msgPrefix + 'the arguments to within must be numbers';
-  } else if (!doLength && (objType !== 'date' && objType !== 'number')) {
+  } else if (!doLength && (objType !== 'date' && !isNumeric(obj))) {
     var printObj = (objType === 'string') ? "'" + obj + "'" : obj;
     errorMessage = msgPrefix + 'expected ' + printObj + ' to be a number or a date';
   } else {
@@ -3013,19 +3025,14 @@ function closeTo(expected, delta, msg) {
     , flagMsg = flag(this, 'message')
     , ssfi = flag(this, 'ssfi');
 
-  new Assertion(obj, flagMsg, ssfi, true).is.a('number');
-  if (typeof expected !== 'number' || typeof delta !== 'number') {
-    flagMsg = flagMsg ? flagMsg + ': ' : '';
-    var deltaMessage = delta === undefined ? ", and a delta is required" : "";
-    throw new AssertionError(
-        flagMsg + 'the arguments to closeTo or approximately must be numbers' + deltaMessage,
-        undefined,
-        ssfi
-    );
-  }
+  new Assertion(obj, flagMsg, ssfi, true).is.numeric;
+  new Assertion(delta, flagMsg, ssfi, true).is.numeric;
+  new Assertion(expected, flagMsg, ssfi, true).is.numeric;
+
+  const abs = (x) => x < 0n ? -x : x;
 
   this.assert(
-      Math.abs(obj - expected) <= delta
+      abs(obj - expected) <= delta
     , 'expected #{this} to be close to ' + expected + ' +/- ' + delta
     , 'expected #{this} not to be close to ' + expected + ' +/- ' + delta
   );

lib/chai/interface/assert.js

@@ -706,6 +706,45 @@ assert.isNotNumber = function (val, msg) {
   new Assertion(val, msg, assert.isNotNumber, true).to.not.be.a('number');
 };
 
+/**
+ * ### .isNumeric(value, [message])
+ *
+ * Asserts that `value` is a number or BigInt.
+ *
+ *     var cups = 2;
+ *     assert.isNumeric(cups, 'how many cups');
+ * 
+ *     var cups = 10n;
+ *     assert.isNumeric(cups, 'how many cups');
+ *
+ * @name isNumeric
+ * @param {unknown} val
+ * @param {string} msg
+ * @namespace Assert
+ * @public
+ */
+assert.isNumeric = function (val, msg) {
+  new Assertion(val, msg, assert.isNumeric, true).is.numeric;
+};
+
+/**
+ * ### .isNotNumeric(value, [message])
+ *
+ * Asserts that `value` is _not_ a number or BigInt.
+ *
+ *     var cups = '2 cups please';
+ *     assert.isNotNumeric(cups, 'how many cups');
+ *
+ * @name isNotNumeric
+ * @param {unknown} val
+ * @param {string} msg
+ * @namespace Assert
+ * @public
+ */
+assert.isNotNumeric = function (val, msg) {
+  new Assertion(val, msg, assert.isNotNumeric, true).is.not.numeric;
+};
+
  /**
   * ### .isFinite(value, [message])
   *

test/assert.js

@@ -153,6 +153,23 @@ describe('assert', function () {
       assert.typeOf(function() {}, 'asyncfunction', 'blah');
     }, "blah: expected [Function] to be an asyncfunction");
 
+    assert.typeOf(5n, 'bigint');
+
+    assert.typeOf(() => {}, 'function');
+    assert.typeOf(function() {}, 'function');
+    assert.typeOf(async function() {}, 'asyncfunction');
+    assert.typeOf(function*() {}, 'generatorfunction');
+    assert.typeOf(async function*() {}, 'asyncgeneratorfunction');
+    assert.typeOf(Symbol(), 'symbol');
+
+    err(function () {
+      assert.typeOf(5, 'function', 'blah');
+    }, "blah: expected 5 to be a function");
+
+    err(function () {
+      assert.typeOf(function() {}, 'asyncfunction', 'blah');
+    }, "blah: expected [Function] to be an asyncfunction");
+
     err(function () {
       assert.typeOf(5, 'string', 'blah');
     }, "blah: expected 5 to be a string");
@@ -632,6 +649,27 @@ describe('assert', function () {
     }, "blah: expected 4 not to be a number");
   });
 
+
+  it('isNumeric', function() {
+    assert.isNumeric(1);
+    assert.isNumeric(Number('3'));
+    assert.isNumeric(6n);
+    assert.isNumeric(BigInt(9));
+
+    err(function () {
+      assert.isNumeric('1', 'blah');
+    }, "blah: expected \'1\' to be numeric");
+  });
+
+  it('isNotNumeric', function () {
+    assert.isNotNumeric('hello');
+    assert.isNotNumeric([ 5 ]);
+
+    err(function () {
+      assert.isNotNumeric(4, 'blah');
+    }, "blah: expected 4 to not be numeric");
+  });
+
   it('isFinite', function() {
     assert.isFinite(4);
     assert.isFinite(-10);
@@ -1866,25 +1904,26 @@ describe('assert', function () {
 
     err(function() {
       assert.closeTo([1.5], 1.0, 0.5, 'blah');
-    }, "blah: expected [ 1.5 ] to be a number");
+    }, "blah: expected [ 1.5 ] to be numeric");
 
     err(function() {
       assert.closeTo(1.5, "1.0", 0.5, 'blah');
-    }, "blah: the arguments to closeTo or approximately must be numbers");
+    }, "blah: expected '1.0' to be numeric");
 
     err(function() {
       assert.closeTo(1.5, 1.0, true, 'blah');
-    }, "blah: the arguments to closeTo or approximately must be numbers");
+    }, "blah: expected true to be numeric");
 
     err(function() {
       assert.closeTo(1.5, 1.0, undefined, 'blah');
-    }, "blah: the arguments to closeTo or approximately must be numbers, and a delta is required");
+    }, "blah: expected undefined to be numeric");
   });
 
   it('approximately', function(){
     assert.approximately(1.5, 1.0, 0.5);
     assert.approximately(10, 20, 20);
     assert.approximately(-10, 20, 30);
+    assert.approximately(1n, 2n, 1n);
 
     err(function(){
       assert.approximately(2, 1.0, 0.5, 'blah');
@@ -1896,19 +1935,19 @@ describe('assert', function () {
 
     err(function() {
       assert.approximately([1.5], 1.0, 0.5);
-    }, "expected [ 1.5 ] to be a number");
+    }, "expected [ 1.5 ] to be numeric");
 
     err(function() {
       assert.approximately(1.5, "1.0", 0.5, 'blah');
-    }, "blah: the arguments to closeTo or approximately must be numbers");
+    }, "blah: expected '1.0' to be numeric");
 
     err(function() {
       assert.approximately(1.5, 1.0, true, 'blah');
-    }, "blah: the arguments to closeTo or approximately must be numbers");
+    }, "blah: expected true to be numeric");
 
     err(function() {
       assert.approximately(1.5, 1.0, undefined, 'blah');
-    }, "blah: the arguments to closeTo or approximately must be numbers, and a delta is required");
+    }, "blah: expected undefined to be numeric");
   });
 
   it('sameMembers', function() {
@@ -2135,6 +2174,10 @@ describe('assert', function () {
 
   it('above', function() {
     assert.isAbove(5, 2, '5 should be above 2');
+    assert.isAbove(5n, 2, '5 should be above 2');
+    assert.isAbove(5, 2n, '5 should be above 2');
+    assert.isAbove(5n, 2n, '5 should be above 2');
+    assert.isAbove(9007199254740994n, 2, '9007199254740994 should be above 2');
 
     err(function() {
       assert.isAbove(1, 3, 'blah');
@@ -2186,6 +2229,8 @@ describe('assert', function () {
   it('atLeast', function() {
     assert.isAtLeast(5, 2, '5 should be above 2');
     assert.isAtLeast(1, 1, '1 should be equal to 1');
+    assert.isAtLeast(5n, 2, '5 should be above 2');
+    assert.isAtLeast(1, 1n, '1 should be equal to 1');
 
     err(function() {
       assert.isAtLeast(1, 3, 'blah');
@@ -2231,6 +2276,9 @@ describe('assert', function () {
 
   it('below', function() {
     assert.isBelow(2, 5, '2 should be below 5');
+    assert.isBelow(2, 5n, '2 should be below 5');
+    assert.isBelow(2n, 5, '2 should be below 5');
+    assert.isBelow(2n, 5n, '2 should be below 5');
 
     err(function() {
       assert.isBelow(3, 1, 'blah');
@@ -2282,6 +2330,8 @@ describe('assert', function () {
   it('atMost', function() {
     assert.isAtMost(2, 5, '2 should be below 5');
     assert.isAtMost(1, 1, '1 should be equal to 1');
+    assert.isAtMost(2n, 5, '2 should be below 5');
+    assert.isAtMost(1, 1n, '1 should be equal to 1');
 
     err(function() {
       assert.isAtMost(3, 1, 'blah');