Assertion Library for Browsers and NodeJS

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