alias isFunction to isCallable

lib/chai/core/assertions.js

@@ -678,11 +678,19 @@ Assertion.addProperty('true', function () {
 Assertion.addProperty('callable', function () {
   const val = flag(this, 'object')
   const ssfi = flag(this, 'ssfi')
-  const msg = `${flag(this, 'message')}: ` || ''
+  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 (!['Function', 'AsyncFunction', 'GeneratorFunction', 'AsyncGeneratorFunction'].includes(_.type(val))) {
+  if ((!isCallable && negate) || (isCallable && !negate)) {
     throw new AssertionError(
-      msg + 'expected ' + _.inspect(val) + ' to be callable',
+      assertionMessage,
       undefined,
       ssfi
     );

lib/chai/interface/assert.js

@@ -554,50 +554,41 @@ 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;
 };
 
-/**
- * TODO
- */
-assert.isCallable = function (val, msg) {
-  new Assertion(val, msg, assert.isCallable, true).is.callable;
-}
-
 /**
  * ### .isAsyncFunction(value, [message])
  *
@@ -3144,4 +3135,6 @@ assert.isNotEmpty = function(val, msg) {
 ('isFrozen', 'frozen')
 ('isNotFrozen', 'notFrozen')
 ('isEmpty', 'empty')
-('isNotEmpty', 'notEmpty');
+('isNotEmpty', 'notEmpty')
+('isCallable', 'isFunction')
+('isNotCallable', 'isNotFunction')

test/assert.js

@@ -527,7 +527,7 @@ describe('assert', function () {
 
     err(function () {
       assert.isFunction({}, 'blah');
-    }, "blah: expected {} to be a function");
+    }, "blah: expected {} to be a callable function");
   });
 
   it('isCallable', function() {
@@ -545,7 +545,7 @@ describe('assert', function () {
 
     err(function () {
       assert.isCallable({}, 'blah');
-    }, "blah: expected {} to be callable");
+    }, "blah: expected {} to be a callable function");
   });
 
   it('isAsyncFunction', function() {
@@ -594,7 +594,7 @@ describe('assert', function () {
 
     err(function () {
       assert.isNotFunction(function () {}, 'blah');
-    }, "blah: expected [Function] not to be a function");
+    }, "blah: expected [Function] not to be a callable function");
   });
 
   it('isArray', function() {