NUnit.js
========
Neal's unit test framework for JavaScript.
* No callbacks and closures. Simple and Intuitive. Easier to understand and write tests.
* Pure JavaScript based. Runnable in browser or in NodeJS.
* A similar syntax to JUnit test framework. Less learning curve for developer who is already familiar with the most popular Java unit test framework.
v0.2.1
$3
#### In browser
#### In NodeJS
var nunit = require("nunit");
var test = new NUnit.Test("Test Hello Node!");
test.myTest = function(assert){
assert.equals("hello Node!", "hello " + "Node" + "!");
};
nunit.execute(); //Use default configuration to run all test modules.
$3
#### NUnit.Test
* A test module (or test object) is an instance of
NUnit.Test class.
var test = new NUnit.Test("Test description.");
* Every function on this module object are treated as one test except these four:
before,
after,
beforeAll, and
afterAll.
* If
before and
after was defined on the test object, they will run before and after each test respectively.
* If
beforeAll and
afterAll was defined on the test object, they will run before and after all tests respectively.
#### NUnit.Assert
##### Accessing the assert object
There are two ways to get to the assert object.
* From
assert attribute of the test module
var test = new NUnit.Test("a test module");
var a = test.assert ;
* From the first argument of the test function:
test.myTest = function(a){
a.assertTrue(true);
}
* And they are equivalent:
test.testAssert = function(a){
a.strictEquals(a, this.assert);
}
##### Assert functions
*
equals(obj1, obj2, desc) (Aliases:
eq, equal, assertEqual, assertEquals)
Asserts
obj1 equals to
obj2. It uses
== to compare the two. For javascript object it also tries
JSON.stringify(obj1) == JSON.stringify(obj2). Do not use to compare two null value. Use
#isNull to assert a null(or undefined) value.
*
strictEquals(obj1, obj2, desc) (Aliases:
strictEqual, assertStrictEqual, assertStrictEquals)
Asserts
obj1 is strictly equal to (
===)
obj2
*
notEqual(obj1, obj2, desc) (Aliases:
neq, notEquals, assertNotEqual)
Asserts not equal.
*
isTrue(obj, desc) (Aliases:
t, assertTrue)
Asserts
obj is
true.
*
isFalse(obj, desc) (Aliases:
f, assertFalse)
Asserts
obj is
false.
*
isNull(obj, desc) (Alias:
assertNull)
Asserts
obj is
null or
undefined.
*
notNull(obj, desc) (Alias:
assertNotNull)
Asserts
obj is not
null or
undefined.
*
fail(msg): Fails the current test with message
msg.
*
contains(obj1, obj2, desc) (Alias:
contain)
Asserts
obj1 contains
obj2. It uses
indexOf function on
obj1.
*
exception(callback, desc): Asserts that the
callback will throw an error.
*
tracer(): Returns a
Tracer object. A
Tracer object is useful to assure an asynchronized callback has actually been called as well as to verify the number of times it's called.
+
Tracer
-
trace(desc): Adds 1 to the trace count every time it is called.
-
once(desc): Adds 1 to the trace count the first time it is called. It uses
desc to identify different calls.
-
verify(count, desc): Veryfies the total number of trace count is
count and throws error if failed.
+ For example:
test.testTracer = function(a){
var tr = assert.tracer();
a.notNull(tr);
for(var i = 0 ; i < 10; i++){
tr.trace();
tr.once();
tr.once();//same
desc as tr.once() above, so it will take no effect
tr.once("second trace.once()");
}
tr.verify(12);
}