Assertion test library.
An assertion test library.
Developed in Dogma, compiled to JavaScript.
Engineered in Valencia, Spain, EU by EthronLabs.
The package must be imported as follows:
``
const assert = require("@ethronjs/assert");
To load plugins, use its method plugin() as follows:
`
assert.plugin(require("@ethronjs/assert.plugin.fs"));
To check whether a value is of a type or another, we can use:
`
//string
assert(value).isText()
assert(value).isNotText()
assert(value).isString()
assert(value).isNotString()
//boolean
assert(value).isBool()
assert(value).isNotBool()
assert(value).isBoolean()
assert(value).isNotBoolean()
//number
assert(value).isNum()
assert(value).isNotNum()
assert(value).isNumber()
assert(value).isNotNumber()
//null
assert(value).isNil()
assert(value).isNotNil()
assert(value).isNull()
assert(value).isNotNull()
//object
assert(value).isMap()
assert(value).isNotMap()
assert(value).isObject()
assert(value).isNotObject()
//array
assert(value).isList()
assert(value).isNotList()
assert(value).isArray()
assert(value).isNotArray()
//set
assert(value).isSet()
assert(value).isNotSet()
//function
assert(value).isFn()
assert(value).isNotFn()
assert(value).isFunction()
assert(value).isNotFunction()
//callable object
assert(value).isCallable()
assert(value).isNotCallable()
//promise
assert(value).isPromise()
assert(value).isNotPromise()
`
For checking if a value is instance of a given class, we can use:
`
assert(value).isInstanceOf(className)
assert(value).isInstanceOf(class)
assert(value).isNotInstanceOf(className)
assert(value).isNotInstanceOf(class)
`
Instead of isInstanceOf() and isNotInstanceOf(), we also can use their aliases is() and isNot().
With eq(), ne(), lt(), le(), gt() and gt() we can check whether a value is equal to, not equal to, less than, less than or equal to, greater than and greater than or equal to another.
`
assert(value1).eq(value2)
assert(value1).ne(value2)
assert(value1).lt(value2)
assert(value1).le(value2)
assert(value1).gt(value2)
assert(value1).ge(value2)
With sameAs() and notSameAs() we can check whether a value is same as other:
`
assert(value).sameAs(value)
assert(value).notSameAs(value)
and notSimilarTo() we check whether an array is equal to another, not keeping in mind the order of the items:`
assert(array1).similarTo(array2)
assert(array1).notSimilarTo(array2)
Examples:
assert([1, 2, 3]).similarTo([2, 1, 3]) //true
assert([1, 2, 3]).similarTo([3, 2, 1]) //true
assert([1, 2, 3]).similarTo([1, 3, 2]) //true
assert([1, 2, 3]).similarTo([1, 2, 4]) //false
between() and notBetween()
With
and notBetween(), we check whether a value is into a range:`
assert(value).between(start, end)
assert(value).notBetween(start, end)
includes(), notIncludes() and doesNotInclude()
With
, notIncludes() and doesNotInclude() we check whether a string contains a given text or an array contains an item:`
assert(value).includes(item)
assert(value).notIncludes(item)
assert(value).doesNotInclude(item)
has(), notHas() and doesNotHave()
With
, notHas() and doesNotHave() we can check whether an object contains one or several fields:`
assert(value).has(field)
assert(value).has(fields)
assert(value).notHas(field)
assert(value).notHas(fields)
assert(value).doesNotHave(field)
assert(value).doesNotHave(fields)
Examples:
assert({one: 1, two: 2, three: 3}).has("one")
assert({one: 1, two: 2, three: 3}).has(["one", "two"])
assert({one: 1, two: 2, three: 3}).has({
one: 1,
two: 2
})
forEach()
When the value under assertion is a list, we can use
for checking the items:`
assert(value).forEach(fields)
assert(value).forEach(func)
When an object is passed as argument, the fields must have the given values.
So, for example, the following one:
assert(dev.getUserWorks(work.user)).isList().isNotEmpty().forEach({user: work.user});
is similar to:
const ww = dev.getUserWorks(work.user);
assert(ww).isList().isNotEmpty();
for (let w of ww) assert(w).has({user: work.user});
When a function is passed, each item is passed to the function.
Example:
assert(resp.json()).isList().isNotEmpty().forEach(function(o) {
assert(o.req).isObject().mem("req").eq(req);
});
isEmpty() and isNotEmpty()
With
and isNotEmpty() we can check whether an object is empty as for example a list or string:`
assert(value).isEmpty()
assert(value).isNotEmpty()
len() and notLen()
With
and notLen() we can check the string, array or object length:`
assert(value).len(size)
assert(value).notLen(size)
Also possible getting the length from other list:
assert([1, 2, 3]).len([1, 3, 5]) //ok, both with length equal to 3
assert([1, 2, 3]).len([1, 5]) //nop, one with length 3; and other 2
like() and notLike()
With
and notLike() we check whether a value matches a pattern:`
assert(value).like(pattern)
assert(value).notLike(pattern)
startsWith(), notStartsWith() and doesNotStartWith()
With
, we check whether a value starts with a given prefix:`
assert(value).startsWith(prefix)
assert(value).notStartsWith(prefix)
assert(value).doesNotStartWith(prefix)
endsWith(), notEndsWith() and doesNotEndWith()
With
, we check whether a value ends with a given suffix:`
assert(value).endsWith(suffix)
assert(value).notEndsWith(suffix)
assert(value).doesNotEndWith(suffix)
Function assertions
To check whether a function raises an error, we can use
, notRaises() and doesNotRaise():`
assert(fn).raises()
assert(fn).raises(err)
assert(fn).notRaises()
assert(fn).notRaises(err)
assert(fn).doesNotRaise()
assert(fn).doesNotRaise(err)
The function to check must not expect arguments.
Example:
assert(function() {
//code
}).raises()assert(function() {
//code
}).raises("My custom error.")
$3
Sometimes, we need to assert multiple members of a source value.
With the
method, we can get the value for one of its members:`
mem(name:string) : ValueWrapper
mem(idx:number) : ValueWrapper
mem(...:string|number) : ValueWrapper
Examples:
value = {x: 123, y: 456};
assert(value).mem("x").eq(123); //ok
assert(value).isMap().mem("x").isNum().eq(123).mem("y").isNum().eq(456); //okvalue = ["zero", "one", "two", "three"];
assert(value).mem(1).eq("one").mem(0).eq("zero"); //ok
value = {x: ["zero", "one", "two", "three"]};
assert(value).mem("x", 1).eq("one"); //ok
The
method always returns with respect to the source value passed to assert().
And the assertions are respect to the last member got from mem().We can use the alias
item() too.
Generally it is used when accessing to a list or array.Chaining assertions
We can chain assertion methods for the same value such as the following example:
`
assert(number).ge(10).le(25)
//similar to
assert(number).ge(10)
assert(number).le(25)