Asserter array()

array() behavior

Does not contains assertions from the assertions containers.

test
  .value(test.array([]).hasHeader)
    .isUndefined()
  .value(test.array([]).isError)
    .isUndefined()
  .value(test.array([]).hasMessage)
    .isUndefined()
  .value(test.array([]).isInfinite)
    .isUndefined()
;

Assert that the tested value is an array.

var Foo = function Foo(){};
        test
          .array([])
          .array(['a', 'b', 'c'])
          .array(new Array())
          .case('Test failure', function(){
            test
              .exception(function(){
                test.array({});
              })
              .exception(function(){
                test.array('Foo');
              })
              .exception(function(){
                test.array(Foo);
              })
              .exception(function(){
                test.array(1);
              })
              .exception(function(){
                test.array(undefined);
              })
              .exception(function(){
                test.array(true);
              })
              .exception(function(){
                test.array(false);
              })
              .exception(function(){
                test.array(null);
              })
              .exception(function(){
                test.array(function(){});
              })
            ;
          })
        ;

Assertions of array()

is(expected).

test
        .array(['foo', [0, 1]])
          .is(['foo', [0, 1]])
        .case('Test failure', function(){
          test
            .exception(function(){
              test.array(['foo', [0, 1]])
                .is(['foo', [0, '1']]);
            })
            .exception(function(){
              test.array(['foo', [0, 1]])
                .is(['foo', [0, 1, 2]]);
            })
            .exception(function(){
              test.array(['foo', [0, 1]])
                .is(['foo', [0]]);
            })
            .exception(function(){
              test.array(['foo', [0, 1]])
                .is(['foobar', [0, 1]]);
            })
          ;
        })
      ;

isNot(expected).

test
        .array(['foo', [0, 1]])
          .isNot(['foo', [0, '1']])
        .exception(function(){
          test.array(['foo', [0, 1]])
            .isNot(['foo', [0, 1]]);
        })
      ;

isIdenticalTo(expected).

var
        arr = [1],
        arr2 = arr
      ;
      test
        .array(arr)
          .isIdenticalTo(arr2)
        .exception(function(){
          test.array(arr)
            .isIdenticalTo([1]);
        })
      ;

isNotIdenticalTo(expected).

var
        arr = [1],
        arr2 = arr
      ;
      test
        .array(arr)
          .isNotIdenticalTo([1])
        .exception(function(){
          test.array(arr)
            .isNotIdenticalTo(arr2);
        })
      ;

isEqualTo(expected).

var
        arr = [1],
        arr2 = arr
      ;
      test
        .array(arr)
          .isEqualTo(arr2)
        .exception(function(){
          test.array(arr)
            .isEqualTo([1]);
        })
      ;

isNotEqualTo(expected).

var
        arr = [1],
        arr2 = arr
      ;
      test
        .array(arr)
          .isNotEqualTo([1])
        .exception(function(){
          test.array(arr)
            .isNotEqualTo(arr2);
        })
      ;

match(expected).

test
        .array(['a', 'b', 'c'])
          .match(/[a-z]/)
        .array([42, 10])
          .match(function(actual) {
            return actual[1] === 10;
          })
        .exception(function() {
          test.array([42, '10']).match(function(actual) {
            return actual[1] === 10;
          });
        })
      ;

notMatch(expected).

test
        .array(['a', 'b', 'c'])
          .notMatch(/[d-z]/)
        .array([42, 10])
          .notMatch(function(actual) {
            return actual[1] === '10';
        })
        .exception(function() {
          test.array([42, '10']).notMatch(function(actual) {
            return actual[0] === 42;
          });
        })
      ;

isValid(expected).

test
        .array(['a', 'b', 'c'])
          .isValid(/[a-z]/)
        .array([42, 10])
          .isValid(function(actual) {
            return actual[1] === 10;
          })
        .exception(function() {
          test.array([42, '10']).isValid(function(actual) {
            return actual[1] === 10;
          });
        })
      ;

isNotValid(expected).

test
        .array(['a', 'b', 'c'])
          .isNotValid(/[d-z]/)
        .array([42, 10])
          .isNotValid(function(actual) {
            return actual[1] === '10';
        })
        .exception(function() {
          test.array([42, '10']).isNotValid(function(actual) {
            return actual[0] === 42;
          });
        })
      ;

matchEach(expected).

test
        .array([10, 11, 12])
          .matchEach(function(it) {
            return it >= 10;
          })
        .exception(function() {
          // error if one or several does not match
          test.array([10, 11, 12]).matchEach(function(it) {
            return it >= 11;
          });
        })
      ;

notMatchEach(expected).

test
        .array([10, 11, 12])
          .notMatchEach(function(it) {
            return it >= 13;
          })
        .exception(function() {
          // error all match
          test.array([10, 11, 12]).notMatchEach(function(it) {
            return it >= 11;
          });
        })
      ;

isEmpty().

test
        .array([])
          .isEmpty()
        .exception(function(){
          test.array([0])
            .isEmpty();
        })
        .exception(function(){
          test.array([''])
            .isEmpty();
        })
      ;

isNotEmpty().

test
        .array(['a'])
          .isNotEmpty()
        .exception(function(){
          test.array([])
            .isNotEmpty();
        })
      ;

hasLength(expected).

test
  .array([1, 2])
    .hasLength(2)
  .exception(function(){
    test.array([1, 2])
      .hasLength(1);
  })
;

hasNotLength(expected).

test
  .array([1, 2])
    .hasNotLength(1)
  .exception(function(){
    test.array([1, 2])
      .hasNotLength(2);
  })
;

isEnumerable(property).

var arr = ['is enumerable'];
test
  .array(arr)
    .isEnumerable(0)
  .array(arr)
    .isNotEnumerable('length')
  .exception(function(){
    test.array(arr)
      .isEnumerable('length');
  })
;

isNotEnumerable(property).

var arr = ['is enumerable'];
test
  .array(arr)
    .isNotEnumerable('length')
  .array(arr)
    .isEnumerable(0)
  .exception(function(){
    test.array(arr)
      .isNotEnumerable(0);
  })
;

hasProperty(property [, value]).

test
  .array(['a', 'b'])
    .hasProperty(1)
    .hasProperty(0, 'a')
  .exception(function(){
    test.array(['a', 'b'])
      .hasProperty(3);
  })
  .exception(function(){
    test.array(['a', 'b'])
      .hasProperty(0, 'b');
  })
;

hasNotProperty(property [, value]).

test
  .array(['a', 'b'])
    .hasNotProperty(2)
    .hasNotProperty(0, 'b')
  .exception(function(){
    test.array(['a', 'b'])
      .hasNotProperty(0);
  })
  .exception(function(){
    test.array(['a', 'b'])
      .hasNotProperty(1, 'b');
  })
;

hasKey(key [, value]).

test
  .array(['a', 'b'])
    .hasKey(1)
    .hasKey(0, 'a')
  .exception(function(){
    test.array(['a', 'b'])
      .hasKey(3);
  })
  .exception(function(){
    test.array(['a', 'b'])
      .hasKey(0, 'b');
  })
;

notHasKey(key [, value]).

test
  .array(['a', 'b'])
    .notHasKey(2)
    .notHasKey(0, 'b')
  .exception(function(){
    test.array(['a', 'b'])
      .notHasKey(0);
  })
  .exception(function(){
    test.array(['a', 'b'])
      .notHasKey(1, 'b');
  })
;

hasValue(expected).

test
  .array([1, 42, 3])
    .hasValue(42)
  .exception(function(){
    test.array([1, 42, 3])
      .hasValue(0);
  })
;

notHasValue(expected).

test
  .array([1, 42, 3])
    .notHasValue(4)
  .exception(function(){
    test.array([1, 42, 3])
      .notHasValue(42);
  })
;

hasValues(expected).

test
  .array([1, 42, 3])
    .hasValues([42, 3])
  .exception(function(){
    test.array([1, 42, 3])
      .hasValues([42, 3, 10]);
  })
;

notHasValues(expected).

test
  .array([1, 42, 3])
    .notHasValues([4, 2])
  .exception(function(){
    test.array([1, 42, 3])
      .notHasValues([4, 1]);
  })
;

contains(expected [, ...]).

test
  .array([1,2,3])
    .contains([3])
  .array([1,2,3])
    .contains([1, 3])
  .array([1,2,3])
    .contains([3], [1, 3])
  .array([1, 2, 3, { a: { b: { d: 12 }}}])
    .contains([2], [1, 2], [{ a: { b: {d: 12}}}])
  .array([[1],[2],[3]])
    .contains([[3]])
  .array([[1],[2],[3, 4]])
    .contains([[3]])
  .array([{a: 'a'}, {b: 'b', c: 'c'}])
    .contains([{a: 'a'}], [{b: 'b'}])
  .exception(function(){
    test.array([1,2,3])
      .contains([0]);
  })
;

notContains(expected [, ...]).

test
  .array([[1],[2],[3, 4]])
    .notContains([[0]])
  .array([{a: 'a'}, {b: 'b', c: 'c'}])
    .notContains([{a: 'b'}], [{c: 'b'}])
  .exception(function(){
    test.array([{a: 'a'}, {b: 'b', c: 'c'}])
    .notContains([{a: 'a'}], [{b: 'b'}]);
  })
;