Should.js

Question 0

Chaining assertions (9)

Answer 0

.a
.an
.and
.be
.have
.is
.of
.which
.with

Question 1

What is Should.js?

Answer 1

Should is a readable assertion library. It is test framework agnostic.

Question 2

Negate current assertion

Answer 2

.not

Question 4

Assertions for testing if value is truthy, true, false, falsey, and empty

Answer 4

.ok // == true
.true // === true
.not.ok // == false
.false
.empty

Question 5

Assertion should test that the values are equal in content (what does that mean?), strict equal, or equal in type (what does that mean?)? Shortcuts to equal in type (9 of them)?

Answer 5

.eql(value) // value content is same; this will check the elements of an array or object to see if the content is the same
.equal(value) || .exactly(value) // => === value
.type(“object”) // => === typeof ?

Shortcuts:
.Boolean
.Number
.NaN
.Infinity
.String
.Array
.Object
.Function
.Error

Question 6

Data types you cannot assert (else you will get an error)? Work around?

Answer 6

undefined & null

(val === undefined).should.be.true;

Question 7

Assert a string starts or ends with a substring

Answer 7

“foobar”.should.startWith(“foo”);

“foobar”.should.endWith(“bar”);

Question 8

Test if number is within a given range? Inclusive or exclusive?

Answer 8

Inclusive range test:

.within(start, end)

(5).should.be.within(5, 50).and.within(0, 10);

Question 9

Assert if number is approximately another number?

Answer 9

.approximately(num, delta)

(99.99).should.be.approximately(100, 0.1);

Question 10

Assert if number is greater than another number

Answer 10

.above(number);
.greaterThan(number);

(5).should.be.above(4);

Question 11

Assert if number is less than another number

Answer 11

.below(number)
.lessThan(number)

(4).should.be.below(5);

Question 12

Assert if the object is an instance of a constructor

Answer 12

.instanceof(constructor)
.instanceOf(constructor)

user.should.be.instanceof(User);

Question 13

Check that a property exists. Check the property’s value

Answer 13

.property(name, [value]);

user.should.have.property(“name”, “Julie”);

.property() returns the property’s value, so careful when chaining.

Question 14

Check that a group of properties exist. Check their values too.

Answer 14

.properties(name1, name2, …);
.properties( [name1, name2, … ] );
.properties({ name1 : value1, name2 : value2 });

user.should.have.properties(“name”, “age”);

Question 15

Check the length’s value

Answer 15

.length(num)
.lengthOf(num)

users.name.should.have.length(5);

Shortcut for .property(“length”, ?);
Consequentially, .length() returns the length’s value, so careful when chaining.

Question 16

Check if an object has its own property

Answer 16

.ownProperty(name)
.hasOwnProperty(name)

users.should.have.ownProperty(“name”);

.ownProperty() returns the property’s value, so careful when chaining. Example

users.should.have.ownProperty(“name”).and.equal(“Julie”);

Question 17

Check what fields an object has (checks if all fields exist). Does it check the prototype chain?

Answer 17

.keys(key1, key2, …)
.keys([ key1, key2, … ])

{name: “Julie”, age: 26}.should.have.keys(“name”, “age”);

Does not check the prototype chain

Question 18

Assert that a function/method throws an error.

How to do this when the function needs arguments supplied.

Answer 18

.throw()
.throwError()

If args are needed, use .bind().

noArgsFunc.should.throw();
withArgsFunc.bind(null, arg1, arg2).should.throw();

Question 19

Assert that something should contain something else. For example, an object or array should have the element X, or a string should have a substring.

What about if you need to assert multiple values are contained?

Answer 19

.containEql(value)

“string”.should.containEql(“tr”);
{a: true, b: false}.should.containEql({a: true});
[“a”, “b”, “c”].should.containEql(“a”);
[ [“a”], [“b”] ].should.containEql( [“a”] );
[ [“a”], [“b”] ].should.not.containEql( “a” );

.containDeep(value) is useful when you want to assert what data type you are asserting against & assert for multiple values at once. The “Deep” word is misleading, so read carefully…

For example, notice on deep how the value has to be the same data type I am testing against:
[1, 2, 3].should.containEql( 3 );
[1, 2, 3].should.containDeep( [3] );
[ [1], [2], [3] ].should.containDeep( [[3]] );

This also allows you to test for multiple elements on an object or an array; however, in an array, the order of elements matters whereas the order of object elements does not:
[1, 2, 3].should.containDeep( [1, 3] );
[1, 2, 3].should.not.containDeep( [3, 1] );
{a: 1, b: 2, c: 3}.should.containEql( {c: 3, a: 1} );