assertion
TypeScript icon, indicating that this package has built-in type declarations

1.3.35 • Public • Published

Assertion Library for Browsers and NodeJS

Build Status NPM version Bower version

Based on the API Interface of the NodeJS Assert module. And is part of the uTest Library.

As a standalone module can be found in NPM repository

npm install assertion
API
NodeJS API
  • Assert Documentation

    assert
     
        equal
        notEqual
        deepEqual
        notDeepEqual
        strictEqual
        notStrictEqual
        throws
        doesNotThrow
        ifError
Additional API
  • has / hasNot

    Subset matching

    // Substring search
    assert.has(String, String | RegExp, ?message);
     
    // Simple property existence check
    assert.has(Object, String);
     
    // Sub-object match
    assert.has(Object, Object);
     
    // Check if item exists in set
    assert.has(Array, Primitive);
     
    // Subset match
    assert.has(Array, Array);

    When checking arrays or objects, deep matching is performed. See tests

     
    assert.has({
        foo: 'foo',
        bar: {
            qux: {
                qux: 'qux'
                quux: 'quux'
            },
            baz: [1, 2, 3]
        }
    }, {
        foo: null,
        bar: {
            baz: [1],
            qux: {
                qux: 'qux'
            }
        }
    });
     
  • is/isNot

    Type check

        // Check by Typename
        assert.is(Any, String, ?message)
        
        // Check by Contructor (instanceof)
        assert.is(Any, Function);

    Typename is extracted from Object.prototype.toString.call, so these are:

        'String'
        'Number'
        'Null'
        'Undefined'
        'Function'
        'RegExp'
        'Date'
        'Object' // any `object` will pass here
        'HTML**' // DOM Node, e.g. HTMLBodyElement
        'CustomEvent'
        ...
        all other built-in types
  • lessThan lessThanOrEqaul greaterThan greaterThanOrEqual

    Compares two digits

  • Aliases

    There are also aliases (which can be set to globals, to simplify the write-read of tests)

    assert.eq_      === assert.equal
    assert.notEq_   === assert.notEqual
     
    assert.lt_      === assert.lessThan
    assert.lte_     === assert.lessThanOrEqaul
    assert.gt_      === assert.greaterThan
    assert.gt_      === assert.greaterThanOrEqual
     
    assert.deepEq_  === assert.deepEqual
    assert.notDeepEq_  === assert.notDeepEqual
  • jQuery

    jQuery Assertion Extensions (alias name syntax)

        $.fn.eq_
        $.fn.notEq_
        $.fn.deepEq_
        $.fn.notDeepEq_
        $.fn.has_
        $.fn.hasNot_
        $.fn.lt_
        $.fn.lte_
        $.fn.gt_
        $.fn.gte_

    Functions API:

    • Get Property
      • (Key, Expected)
      • ([Key, Expected], message)
    • Function call
      • (FnName [, ...arguments], Expected)
      • ([FnName [, ...arguments], Expected], message)

    has/hasNot

    • Node Find/Filter Assertions
      • (Selector, ?ExpectedCount)

    Example:

    // <div class='container' id='foo'>
    // <h4>Baz</h4>
    // <span>Qux</span>
    // </div>
     
    $('.container')
        .eq_('length', 1)
        .eq_('attr', 'id', 'foo')
        .eq_('hasClass', 'container', true)
        
        .children()
        .eq_('length', 2)
        .has_('html', 'span')
        
        .filter('h4')
        .eq_('length', 1)
        .eq_('text', 'Baz')
        
        // addition sample
        .is_('visible'),
        .is_('hidden')
        .eq_('css', 'border-left-width', '2px')
        ;
        
    $('.container')
        .has_('h4')
        .hasNot_('h1')
        ;
  • Assert callbacks calls

    • await

      Wait for a callback

      Creates a wrapper function to ensure that the function is called.

          // ! Arguments order does not matter
          var fn = assert.await(
              String   /* optional - name of this wrapper*/
              Function /* optional - wrap the function*/,
              Object   /* optional - use binded context*/,
              Number   /* optional - expectation count, default is `1`*/
          );
          
          // creates item in assert.callbacks
          [
              {
                  name: String,
                  error: Error, // to receive the stack trace
                  count: Number
              }
          ];
          
          // after the `fn` function is called `count` times, then the object is removed
          // from the callbacks set
          
          
          // Example
          var fn = assert.await();
          assert.callbacks.length === 1;
          try {
              throw new Error()
          } catch {
              fn();
          }
          
          assert.callbacks.length === 0;
          
    • avoid

      Unexpect more then N function calls

      // ! Arguments order does not matter
      var fn = assert.avoid(
          String   /* optional - name of this wrapper*/
          Function /* optional - wrap the function*/,
          Object   /* optional - use binded context*/,
          Number   /* optional - amount of allowed calls, default is `0`*/
      );
       
      fooDfr()
          .fail(assert.avoid())
          .done(function(){
              // ..
          })
          
       
  • Listener

    You can attach listener to the assertions. Event Types:

    • start
    • fail

      if fail type listener is attached, then exceptions are not thrown.

    • success
    // sample
    assert.on('fail', function(error){
        error instanceof assert.AssertionError;
    });

©️ MIT - The Atma.js Project

Package Sidebar

Install

npm i assertion

Weekly Downloads

988

Version

1.3.35

License

MIT

Last publish

Collaborators

  • tenbits