chai 5.0.0-rc.0 → 5.0.2

package/README.md

@@ -71,32 +71,12 @@ You can also use it within the browser; install via npm and use the `chai.js` fi
 Import the library in your code, and then pick one of the styles you'd like to use - either `assert`, `expect` or `should`:
 
 ```js
-var chai = require('chai');  
-var assert = chai.assert;    // Using Assert style
-var expect = chai.expect;    // Using Expect style
-var should = chai.should();  // Using Should style
-```
-
-### Pre-Native Modules Usage (_registers the chai testing style globally_)
-
-```js
-require('chai/register-assert');  // Using Assert style
-require('chai/register-expect');  // Using Expect style
-require('chai/register-should');  // Using Should style
-```
-
-### Pre-Native Modules Usage (_as local variables_)
-
-```js
-const { assert } = require('chai');  // Using Assert style
-const { expect } = require('chai');  // Using Expect style
-const { should } = require('chai');  // Using Should style
-should();  // Modifies `Object.prototype`
-
-const { expect, use } = require('chai');  // Creates local variables `expect` and `use`; useful for plugin use
+import { assert } from 'chai';  // Using Assert style
+import { expect } from 'chai';  // Using Expect style
+import { should } from 'chai';  // Using Should style
 ```
 
-### Native Modules Usage (_registers the chai testing style globally_)
+### Register the chai testing style globally
 
 ```js
 import 'chai/register-assert';  // Using Assert style
@@ -104,13 +84,15 @@ import 'chai/register-expect';  // Using Expect style
 import 'chai/register-should';  // Using Should style
 ```
 
-### Native Modules Usage (_local import only_)
+### Import assertion styles as local variables
 
 ```js
 import { assert } from 'chai';  // Using Assert style
 import { expect } from 'chai';  // Using Expect style
 import { should } from 'chai';  // Using Should style
 should();  // Modifies `Object.prototype`
+
+import { expect, use } from 'chai';  // Creates local variables `expect` and `use`; useful for plugin use
 ```
 
 ### Usage with Mocha

package/lib/chai/assertion.js

@@ -40,6 +40,8 @@ import * as util from './utils/index.js';
  *   from within another assertion. It's also temporarily set to `true` before
  *   an overwritten assertion gets called by the overwriting assertion.
  *
+ * - `eql`: This flag contains the deepEqual function to be used by the assertion.
+ *
  * @param {Mixed} obj target of the assertion
  * @param {String} msg (optional) custom error message
  * @param {Function} ssfi (optional) starting point for removing stack frames
@@ -52,6 +54,7 @@ export function Assertion (obj, msg, ssfi, lockSsfi) {
   util.flag(this, 'lockSsfi', lockSsfi);
   util.flag(this, 'object', obj);
   util.flag(this, 'message', msg);
+  util.flag(this, 'eql', config.deepEqual || util.eql);
 
   return util.proxify(this);
 }

package/lib/chai/config.js

@@ -90,5 +90,31 @@ export const config = {
    * @api public
    */
 
-  proxyExcludedKeys: ['then', 'catch', 'inspect', 'toJSON']
+  proxyExcludedKeys: ['then', 'catch', 'inspect', 'toJSON'],
+
+  /**
+   * ### config.deepEqual
+   *
+   * User configurable property, defines which a custom function to use for deepEqual
+   * comparisons.
+   * By default, the function used is the one from the `deep-eql` package without custom comparator.
+   *
+   *     // use a custom comparator
+   *     chai.config.deepEqual = (expected, actual) => {
+   *        return chai.util.eql(expected, actual, {
+   *           comparator: (expected, actual) => {
+   *              // for non number comparison, use the default behavior
+   *              if(typeof expected !== 'number') return null;
+   *              // allow a difference of 10 between compared numbers
+   *              return typeof actual === 'number' && Math.abs(actual - expected) < 10
+   *           }
+   *        })
+   *     };
+   *
+   * @param {Function}
+   * @api public
+   */
+
+  deepEqual: null
+
 };

package/lib/chai/core/assertions.js

@@ -239,6 +239,13 @@ Assertion.addProperty('all', function () {
   flag(this, 'any', false);
 });
 
+const functionTypes = {
+  'function': ['function', 'asyncfunction', 'generatorfunction', 'asyncgeneratorfunction'],
+  'asyncfunction': ['asyncfunction', 'asyncgeneratorfunction'],
+  'generatorfunction': ['generatorfunction', 'asyncgeneratorfunction'],
+  'asyncgeneratorfunction': ['asyncgeneratorfunction']
+}
+
 /**
  * ### .a(type[, msg])
  *
@@ -298,18 +305,27 @@ Assertion.addProperty('all', function () {
  * @namespace BDD
  * @api public
  */
-
 function an (type, msg) {
   if (msg) flag(this, 'message', msg);
   type = type.toLowerCase();
   var obj = flag(this, 'object')
     , article = ~[ 'a', 'e', 'i', 'o', 'u' ].indexOf(type.charAt(0)) ? 'an ' : 'a ';
 
-  this.assert(
-      type === _.type(obj).toLowerCase()
-    , 'expected #{this} to be ' + article + type
-    , 'expected #{this} not to be ' + article + type
-  );
+  const detectedType = _.type(obj).toLowerCase();
+
+  if (functionTypes['function'].includes(type)) {
+    this.assert(
+        functionTypes[type].includes(detectedType)
+      , 'expected #{this} to be ' + article + type
+      , 'expected #{this} not to be ' + article + type
+    );
+  } else {
+    this.assert(
+      type === detectedType
+      , 'expected #{this} to be ' + article + type
+      , 'expected #{this} not to be ' + article + type
+    );
+  }
 }
 
 Assertion.addChainableMethod('an', an);
@@ -479,7 +495,8 @@ function include (val, msg) {
     , negate = flag(this, 'negate')
     , ssfi = flag(this, 'ssfi')
     , isDeep = flag(this, 'deep')
-    , descriptor = isDeep ? 'deep ' : '';
+    , descriptor = isDeep ? 'deep ' : ''
+    , isEql = isDeep ? flag(this, 'eql') : SameValueZero;
 
   flagMsg = flagMsg ? flagMsg + ': ' : '';
 
@@ -503,7 +520,6 @@ function include (val, msg) {
       break;
 
     case 'map':
-      var isEql = isDeep ? _.eql : SameValueZero;
       obj.forEach(function (item) {
         included = included || isEql(item, val);
       });
@@ -512,7 +528,7 @@ function include (val, msg) {
     case 'set':
       if (isDeep) {
         obj.forEach(function (item) {
-          included = included || _.eql(item, val);
+          included = included || isEql(item, val);
         });
       } else {
         included = obj.has(val);
@@ -522,7 +538,7 @@ function include (val, msg) {
     case 'array':
       if (isDeep) {
         included = obj.some(function (item) {
-          return _.eql(item, val);
+          return isEql(item, val);
         })
       } else {
         included = obj.indexOf(val) !== -1;
@@ -672,6 +688,43 @@ Assertion.addProperty('true', function () {
   );
 });
 
+/**
+ * ### .callable
+ *
+ * Asserts that the target a callable function.
+ *
+ *     expect(console.log).to.be.callable;
+ *
+ * A custom error message can be given as the second argument to `expect`.
+ *
+ *     expect('not a function', 'nooo why fail??').to.be.callable;
+ *
+ * @name callable
+ * @namespace BDD
+ * @api public
+ */
+Assertion.addProperty('callable', function () {
+  const val = flag(this, 'object')
+  const ssfi = flag(this, 'ssfi')
+  const message = flag(this, 'message')
+  const msg = message ? `${message}: ` : ''
+  const negate = flag(this, 'negate');
+
+  const assertionMessage = negate ?
+    `${msg}expected ${_.inspect(val)} not to be a callable function` : 
+    `${msg}expected ${_.inspect(val)} to be a callable function`;
+
+  const isCallable = ['Function', 'AsyncFunction', 'GeneratorFunction', 'AsyncGeneratorFunction'].includes(_.type(val));
+
+  if ((isCallable && negate) || (!isCallable && !negate)) {
+    throw new AssertionError(
+      assertionMessage,
+      undefined,
+      ssfi
+    );
+  }
+});
+
 /**
  * ### .false
  *
@@ -1094,8 +1147,9 @@ Assertion.addMethod('eq', assertEqual);
 
 function assertEql(obj, msg) {
   if (msg) flag(this, 'message', msg);
+  var eql = flag(this, 'eql');
   this.assert(
-      _.eql(obj, flag(this, 'object'))
+      eql(obj, flag(this, 'object'))
     , 'expected #{this} to deeply equal #{exp}'
     , 'expected #{this} to not deeply equal #{exp}'
     , obj
@@ -1863,7 +1917,8 @@ function assertProperty (name, val, msg) {
   var isDeep = flag(this, 'deep')
     , negate = flag(this, 'negate')
     , pathInfo = isNested ? _.getPathInfo(obj, name) : null
-    , value = isNested ? pathInfo.value : obj[name];
+    , value = isNested ? pathInfo.value : obj[name]
+    , isEql = isDeep ? flag(this, 'eql') : (val1, val2) => val1 === val2;
 
   var descriptor = '';
   if (isDeep) descriptor += 'deep ';
@@ -1890,7 +1945,7 @@ function assertProperty (name, val, msg) {
 
   if (arguments.length > 1) {
     this.assert(
-        hasProperty && (isDeep ? _.eql(val, value) : val === value)
+      hasProperty && isEql(val, value)
       , 'expected #{this} to have ' + descriptor + _.inspect(name) + ' of #{exp}, but got #{act}'
       , 'expected #{this} to not have ' + descriptor + _.inspect(name) + ' of #{act}'
       , val
@@ -2038,9 +2093,10 @@ function assertOwnPropertyDescriptor (name, descriptor, msg) {
   if (msg) flag(this, 'message', msg);
   var obj = flag(this, 'object');
   var actualDescriptor = Object.getOwnPropertyDescriptor(Object(obj), name);
+  var eql = flag(this, 'eql');
   if (actualDescriptor && descriptor) {
     this.assert(
-        _.eql(descriptor, actualDescriptor)
+        eql(descriptor, actualDescriptor)
       , 'expected the own property descriptor for ' + _.inspect(name) + ' on #{this} to match ' + _.inspect(descriptor) + ', got ' + _.inspect(actualDescriptor)
       , 'expected the own property descriptor for ' + _.inspect(name) + ' on #{this} to not match ' + _.inspect(descriptor)
       , descriptor
@@ -2394,7 +2450,8 @@ function assertKeys (keys) {
   var len = keys.length
     , any = flag(this, 'any')
     , all = flag(this, 'all')
-    , expected = keys;
+    , expected = keys
+    , isEql = isDeep ? flag(this, 'eql') : (val1, val2) => val1 === val2;
 
   if (!any && !all) {
     all = true;
@@ -2404,11 +2461,7 @@ function assertKeys (keys) {
   if (any) {
     ok = expected.some(function(expectedKey) {
       return actual.some(function(actualKey) {
-        if (isDeep) {
-          return _.eql(expectedKey, actualKey);
-        } else {
-          return expectedKey === actualKey;
-        }
+        return isEql(expectedKey, actualKey);
       });
     });
   }
@@ -2417,11 +2470,7 @@ function assertKeys (keys) {
   if (all) {
     ok = expected.every(function(expectedKey) {
       return actual.some(function(actualKey) {
-        if (isDeep) {
-          return _.eql(expectedKey, actualKey);
-        } else {
-          return expectedKey === actualKey;
-        }
+        return isEql(expectedKey, actualKey);
       });
     });
 
@@ -3109,7 +3158,7 @@ Assertion.addMethod('members', function (subset, msg) {
     failNegateMsg = 'expected #{this} to not have the same ' + subject + ' as #{exp}';
   }
 
-  var cmp = flag(this, 'deep') ? _.eql : undefined;
+  var cmp = flag(this, 'deep') ? flag(this, 'eql') : undefined;
 
   this.assert(
       isSubsetOf(subset, obj, cmp, contains, ordered)
@@ -3165,7 +3214,8 @@ function oneOf (list, msg) {
     , flagMsg = flag(this, 'message')
     , ssfi = flag(this, 'ssfi')
     , contains = flag(this, 'contains')
-    , isDeep = flag(this, 'deep');
+    , isDeep = flag(this, 'deep')
+    , eql = flag(this, 'eql');
   new Assertion(list, flagMsg, ssfi, true).to.be.an('array');
 
   if (contains) {
@@ -3179,7 +3229,7 @@ function oneOf (list, msg) {
   } else {
     if (isDeep) {
       this.assert(
-        list.some(function(possibility) { return _.eql(expected, possibility) })
+        list.some(function(possibility) { return eql(expected, possibility) })
         , 'expected #{this} to deeply equal one of #{exp}'
         , 'expected #{this} to deeply equal one of #{exp}'
         , list

package/lib/chai/interface/assert.js

@@ -8,6 +8,7 @@ import * as chai from '../../../index.js';
 import {Assertion} from '../assertion.js';
 import {flag, inspect} from '../utils/index.js';
 import {AssertionError} from 'assertion-error';
+import {type} from '../utils/type-detect.js';
 
 /**
  * ### assert(expression, message)
@@ -553,41 +554,39 @@ assert.isDefined = function (val, msg) {
 };
 
 /**
- * ### .isFunction(value, [message])
+ * ### .isCallable(value, [message])
  *
- * Asserts that `value` is a function.
+ * Asserts that `value` is a callable function.
  *
  *     function serveTea() { return 'cup of tea'; };
- *     assert.isFunction(serveTea, 'great, we can have tea now');
+ *     assert.isCallable(serveTea, 'great, we can have tea now');
  *
- * @name isFunction
+ * @name isCallable
  * @param {Mixed} value
  * @param {String} message
  * @namespace Assert
  * @api public
  */
-
-assert.isFunction = function (val, msg) {
-  new Assertion(val, msg, assert.isFunction, true).to.be.a('function');
-};
+assert.isCallable = function (val, msg) {
+  new Assertion(val, msg, assert.isCallable, true).is.callable;
+}
 
 /**
- * ### .isNotFunction(value, [message])
+ * ### .isNotCallable(value, [message])
  *
- * Asserts that `value` is _not_ a function.
+ * Asserts that `value` is _not_ a callable function.
  *
  *     var serveTea = [ 'heat', 'pour', 'sip' ];
- *     assert.isNotFunction(serveTea, 'great, we have listed the steps');
+ *     assert.isNotCallable(serveTea, 'great, we have listed the steps');
  *
- * @name isNotFunction
+ * @name isNotCallable
  * @param {Mixed} value
  * @param {String} message
  * @namespace Assert
  * @api public
  */
-
-assert.isNotFunction = function (val, msg) {
-  new Assertion(val, msg, assert.isNotFunction, true).to.not.be.a('function');
+assert.isNotCallable = function (val, msg) {
+  new Assertion(val, msg, assert.isNotCallable, true).is.not.callable;
 };
 
 /**
@@ -3104,4 +3103,6 @@ assert.isNotEmpty = function(val, msg) {
 ('isFrozen', 'frozen')
 ('isNotFrozen', 'notFrozen')
 ('isEmpty', 'empty')
-('isNotEmpty', 'notEmpty');
+('isNotEmpty', 'notEmpty')
+('isCallable', 'isFunction')
+('isNotCallable', 'isNotFunction')

package/package.json

@@ -18,7 +18,7 @@
     "Veselin Todorov <hi@vesln.com>",
     "John Firebaugh <john.firebaugh@gmail.com>"
   ],
-  "version": "5.0.0-rc.0",
+  "version": "5.0.2",
   "repository": {
     "type": "git",
     "url": "https://github.com/chaijs/chai"
@@ -44,16 +44,15 @@
     "assertion-error": "^2.0.1",
     "check-error": "^2.0.0",
     "deep-eql": "^5.0.1",
-    "loupe": "^3.0.0",
+    "loupe": "^3.1.0",
     "pathval": "^2.0.0"
   },
   "devDependencies": {
     "@rollup/plugin-commonjs": "^25.0.7",
-    "@web/dev-server-rollup": "^0.5.4",
-    "@web/test-runner": "^0.17.2",
-    "@web/test-runner-playwright": "^0.10.2",
-    "bump-cli": "^1.1.3",
-    "esbuild": "^0.17.3",
-    "mocha": "^8.3.0"
+    "@web/dev-server-rollup": "^0.6.1",
+    "@web/test-runner": "^0.18.0",
+    "@web/test-runner-playwright": "^0.11.0",
+    "esbuild": "^0.19.10",
+    "mocha": "^10.2.0"
   }
 }

package/bower.json

@@ -1,26 +0,0 @@
-{
-  "name": "chai",
-  "description": "BDD/TDD assertion library for node.js and the browser. Test framework agnostic.",
-  "license": "MIT",
-  "keywords": [
-    "test",
-    "assertion",
-    "assert",
-    "testing",
-    "chai"
-  ],
-  "main": "chai.js",
-  "ignore": [
-    "build",
-    "components",
-    "lib",
-    "node_modules",
-    "support",
-    "test",
-    "index.js",
-    "Makefile",
-    ".*"
-  ],
-  "dependencies": {},
-  "devDependencies": {}
-}