Asserter function()

function() behavior

Does not contains assertions from the assertions containers.

var fn = function(){};
        test
          .value(test.function(fn).hasHeader)
            .isUndefined()
          .value(test.function(fn).isAfter)
            .isUndefined()
          .value(test.function(fn).hasMessage)
            .isUndefined()
        ;

Assert that the tested value is a function.

var fn = function(){};
      test
        .function(fn)
        .function(Date)
        .case('Test failure', function(){
          test
            .exception(function(){
              test.function(fn());
            })
            .exception(function(){
              test.function({});
            })
            .exception(function(){
              test.function([]);
            })
            .exception(function(){
              test.function(new Date());
            })
            .exception(function(){
              test.function('foobar');
            })
            .exception(function(){
              test.function(1);
            })
            .exception(function(){
              test.function(true);
            })
            .exception(function(){
              test.function(false);
            })
            .exception(function(){
              test.function(null);
            })
            .exception(function(){
              test.function(undefined);
            })
            .exception(function(){
              test.function();
            })
          ;
        })
      ;

Assertions of function()

is(expected).

var fn = function(){};
      var ref = fn;
      test
        .function(ref)
          .is(fn)
        .exception(function(){
          test.function(fn).is(function(){});
        })
      ;

isNot(expected).

var fn = function(){};
      var otherFunction = function(){};
      test
        .function(fn)
          .isNot(otherFunction)
          .isNot(function(){})
        .exception(function(){
          test.function(fn).isNot(fn);
        })
      ;

isIdenticalTo(expected).

var fn = function(){};
      var ref = fn;
      test
        .function(ref)
          .isIdenticalTo(fn)
        .exception(function(){
          test.function(fn).isIdenticalTo(function(){});
        })
      ;

isNotIdenticalTo(expected).

var fn = function(){};
      var otherFunction = function(){};
      test
        .function(fn)
          .isNotIdenticalTo(otherFunction)
          .isNotIdenticalTo(function(){})
        .exception(function(){
          test.function(fn).isNotIdenticalTo(fn);
        })
      ;

isEqualTo(expected).

var fn = function(){};
      var ref = fn;
      test
        .function(ref)
          .isEqualTo(fn)
        .exception(function(){
          test.function(fn).isEqualTo(function(){});
        })
      ;

isNotEqualTo(expected).

var fn = function(){};
      var otherFunction = function(){};
      test
        .function(fn)
          .isNotEqualTo(otherFunction)
          .isNotEqualTo(function(){})
        .exception(function(){
          test.function(fn).isNotEqualTo(fn);
        })
      ;

match(expected).

var fn = function(){
        return 'hello';
      };
      function myFunction(){
      };
      test
        .function(fn)
          .match('function')
          .match('func')
          .match(function(it){
            return it() === 'hello';
          })
        .function(Date)
          .match('Date')
        .function(myFunction)
          .match('myFunction')
          .match(/my/)
          .match(/[a-z]/i)
        .case('Test failure', function(){
          test
            .exception(function(){
              test.function(fn).match(function(it){
                return it() === 'hey';
              });
            })
            .exception(function(){
              test.function(fn).match('someFunction');
            })
            .exception(function(){
              test.function(myFunction).match(/someFunction/);
            })
          ;
        })
      ;

notMatch(expected).

var fn = function(){
        return 'hello';
      };
      function myFunction(){
      };
      test
        .function(fn)
          .notMatch('foo')
          .notMatch(/[A-Z]/)
          .notMatch(function(it){
            return it() === 'hey';
          })
        .function(Date)
          .notMatch('foo')
        .function(myFunction)
          .notMatch('someFunction')
          .notMatch(/some/)
        .case('Test failure', function(){
          test
            .exception(function(){
              test.function(fn).notMatch(function(it){
                return it() === 'hello';
              });
            })
            .exception(function(){
              test.function(fn).notMatch('function');
            })
            .exception(function(){
              test.function(myFunction).notMatch(/myFunction/);
            })
            .exception(function(){
              test.function(myFunction).notMatch(/my/);
            })
            .exception(function(){
              test.function(myFunction).notMatch('myFunction');
            })
          ;
        })
      ;

isValid(expected).

var fn = function(){
        return 'hello';
      };
      function myFunction(){
      };
      test
        .function(fn)
          .isValid('function')
          .isValid('func')
          .isValid(function(it){
            return it() === 'hello';
          })
        .function(Date)
          .isValid('Date')
        .function(myFunction)
          .isValid('myFunction')
          .isValid(/my/)
          .isValid(/[a-z]/i)
        .case('Test failure', function(){
          test
            .exception(function(){
              test.function(fn).isValid(function(it){
                return it() === 'hey';
              });
            })
            .exception(function(){
              test.function(fn).isValid('someFunction');
            })
            .exception(function(){
              test.function(myFunction).isValid(/someFunction/);
            })
          ;
        })
      ;

isNotValid(expected).

var fn = function(){
        return 'hello';
      };
      function myFunction(){
      };
      test
        .function(fn)
          .isNotValid('foo')
          .isNotValid(/[A-Z]/)
          .isNotValid(function(it){
            return it() === 'hey';
          })
        .function(Date)
          .isNotValid('foo')
        .function(myFunction)
          .isNotValid('someFunction')
          .isNotValid(/some/)
        .case('Test failure', function(){
          test
            .exception(function(){
              test.function(fn).isNotValid(function(it){
                return it() === 'hello';
              });
            })
            .exception(function(){
              test.function(fn).isNotValid('function');
            })
            .exception(function(){
              test.function(myFunction).isNotValid(/myFunction/);
            })
            .exception(function(){
              test.function(myFunction).isNotValid(/my/);
            })
            .exception(function(){
              test.function(myFunction).isNotValid('myFunction');
            })
          ;
        })
      ;

throws([constructor|expected], [expected]).

var fn = function(){};
      var trigger = function(){
        throw new Error('Whoops!');
      };
      test
        .function(trigger)
          .throws()
          .throws('Whoops!')
          .throws(/whoops/i)
          .throws(Error)
          .throws(Error, /whoops/i)
        .case('Test failure', function(){
          test
            .value(function(){
              test.function(fn).throws();
            })
            .throws()
            .value(function(){
              test.function(trigger).throws(TypeError);
            })
            .throws()
            .value(function(){
              test.function(trigger).throws('gloops');
            })
            .throws()
            .value(function(){
              test.function(trigger).throws(/gloops/);
            })
            .throws()
            .value(function(){
              test.function(trigger).throws(TypeError, 'gloops');
            })
            .throws()
            .value(function(){
              test.function(trigger).throws(Error, 'whoops');
            })
            .throws()
          ;
        })
      ;

isError().

var trigger = function(){
        throw new Error('Whoops!');
      };
      test
        .function(trigger)
          .isError()
        .case('Test failure', function(){
          test
            .value(function(){
              test.function(function(){}).isError();
            })
            .throws()
            .value(function(){
              test
                .function(function(){
                  throw 'error';
                })
                .isError()
              ;
            })
            .throws()
          ;
        })
      ;

hasName(expected).

var fn = function(){};
      function myFunction(){
      };
      test
        .function(Date)
          .hasName('Date')
        .function(myFunction)
          .hasName('myFunction')
        .case('Test failure', function(){
          test
            .exception(function(){
              test.function(new Date()).hasName('RegExp');
            })
            .exception(function(){
              test.function(myFunction).hasName('function');
            })
          ;
        })
      ;