jasmine-utils
Jasmine-Utils is a set of custom matchers that I used in my previous projects.
Jasmine-Utils is compatible with Jasmine 1.3 and Jasmine 2.0.
Utils Functions
-
jasmine.spyAll(object)
- Spy all functions of given object.
- Spies are configured with
callThrough
it('should spy all methods', function() {
var obj = {
id: 1,
method1: function() {
},
method2: function() {
}
};
jasmine.spyAll(obj);
expect(obj.method1).not.toHaveBeenCalled();
expect(obj.method2).not.toHaveBeenCalled();
});
-
jasmine.spyIf(function)
- Spy function if and only if function is not already a spy.
- Spy is returned.
it('should spy method once', function() {
var obj = {
id: 1,
method1: function() {
},
method2: function() {
}
};
jasmine.spyIf(obj, 'method1');
jasmine.spyIf(obj, 'method1');
});
-
jasmine.spyAllExcept(object, [excepts])
- Spy all functions of given object, excepts function names given in array (second arguments).
- Spies are configured with
callThrough
it('should spy selected method', function() {
var obj = {
id: 1,
method1: function() {
},
method2: function() {
}
};
jasmine.spyAllExcept(obj, 'method2');
});
-
jasmine.spyEach(object, [only])
- Spy all functions of given object that are specified in array as second arguments.
- Spies are configured with
callThrough
it('should spy selected method', function() {
var obj = {
id: 1,
method1: function() {
},
method2: function() {
},
method3: function() {
}
};
jasmine.spyEach(obj, ['method1', 'method2']);
});
-
jasmine.resetAll(object)
- Reset all spy of given object.
it('should reset all methods', function() {
var obj = {
id: 1,
method1: function() {
},
method2: function() {
}
};
spyOn(obj, 'method1');
spyOn(obj, 'method2');
obj.method1();
obj.method2();
expect(obj.method1).toHaveBeenCalled();
expect(obj.method2).toHaveBeenCalled();
jasmine.resetAll(obj);
expect(obj.method1).not.toHaveBeenCalled();
expect(obj.method2).not.toHaveBeenCalled();
});
-
jasmine.resetEach(object, [methods])
- Reset each specified spies of given object.
it('should reset all methods', function() {
var obj = {
id: 1,
method1: function() {
},
method2: function() {
}
};
spyOn(obj, 'method1');
spyOn(obj, 'method2');
obj.method1();
obj.method2();
expect(obj.method1).toHaveBeenCalled();
expect(obj.method2).toHaveBeenCalled();
jasmine.resetEach(obj, ['method1']);
expect(obj.method1).not.toHaveBeenCalled();
expect(obj.method2).toHaveBeenCalled();
});
-
jasmine.resetAllExcept(object, [methods])
- Reset all spies of given object except specified methods.
it('should reset all methods', function() {
var obj = {
id: 1,
method1: function() {
},
method2: function() {
}
};
spyOn(obj, 'method1');
spyOn(obj, 'method2');
obj.method1();
obj.method2();
expect(obj.method1).toHaveBeenCalled();
expect(obj.method2).toHaveBeenCalled();
jasmine.resetAllExcept(obj, ['method1']);
expect(obj.method1).toHaveBeenCalled();
expect(obj.method2).not.toHaveBeenCalled();
});
Matchers
toBeABoolean
Check that the tested object is a boolean
(a boolean
is exactly true
or false
).
Since
0.1.0
Parameters
No parameters
Message
Expect [actual] (not) to be a boolean
Example:
expect(true).toBeABoolean();
expect(false).toBeABoolean();
expect(null).not.toBeABoolean();
expect(undefined).not.toBeABoolean();
toBeADate
Check that the tested object is an instance of Date
.
Since
0.1.0
Parameters
No parameters
Message
Expect [actual] (not) to be a date
Example:
expect(new Date()).toBeADate();
expect(null).not.toBeADate();
expect(123).not.toBeADate();
toBeAFunction
Check that the tested object is a function
.
Since
0.1.0
Parameters
No parameters
Message
Expect [actual] (not) to be a function
Example:
expect(() => {}).toBeAFunction();
expect(function() {}).toBeAFunction();
expect(undefined).not.toBeAFunction();
expect(null).not.toBeAFunction();
toBeAMap
Check that the tested object is a Map
.
Since
0.3.0
Parameters
No parameters
Message
Expect [actual] (not) to be a Map
Example:
expect(new Map()).toBeAMap();
expect({}).not.toBeAMap();
toBeANumber
Check that the tested object is a number
.
Since
0.1.0
Parameters
No parameters
Message
Expect [actual] (not) to be a number
Example:
expect(0).toBeANumber();
expect(1).toBeANumber();
expect(1.5).toBeANumber();
expect('0').not.toBeANumber();
expect('1').not.toBeANumber();
toBeASet
Check that the tested object is a Set
.
Since
0.3.0
Parameters
No parameters
Message
Expect [actual] (not) to be a Set
Example:
expect(new Set()).toBeASet();
expect({}).not.toBeASet();
expect([]).not.toBeASet();
toBeAString
Check that the tested object is a string.
Since
0.1.0
Parameters
No parameters
Message
Expect [actual] (not) to be a string
Example:
expect('').toBeAString();
expect('foo').toBeAString();
expect(String('foo')).toBeAString();
expect(false).not.toBeAString();
expect(0).not.toBeAString();
toBeAnArray
Check that the tested object is an array (a real array, not an array-like object).
This matcher will use Array.isArray
or a fallback if it is not available.
Since
0.1.0
Parameters
No parameters
Message
Expect [actual] (not) to be an array
Example:
expect([]).toBeAnArray();
expect('123').not.toBeAnArray();
expect(1).not.toBeAnArray();
expect(false).not.toBeAnArray();
expect({}).not.toBeAnArray();
expect(null).not.toBeAnArray();
expect(undefined).not.toBeAnArray();
toBeAnEmptyString
Check that the tested object is an empty string (a string
equals to ''
).
Since
0.1.0
Parameters
No parameters
Message
Expect [actual] (not) to be an empty string
Example:
expect('').toBeAnEmptyString();
expect(' ').not.toBeAnEmptyString();
expect('foo').not.toBeAnEmptyString();
toBeArguments
Check that the tested object is an arguments
object.
Since
0.5.0
Parameters
No parameters
Message
Expect [actual] (not) to be arguments
Example:
expect((function() { return arguments; })()).toBeArguments();
expect([]).not.toBeArguments();
toBeDateAfterNow
Check that the tested date object is a date "after" now
.
The tested date may be:
- A date instance.
- A timestamp.
- A string that can be parsed with the
Date
constructor (i.enew Date('2016-01-01')
).
Note: Using date strings should be avoided due to browser differences and inconsistencies.
Since
0.1.0
Parameters
No parameters
Message
Expect date [actual] (not) to be after now
Example:
expect(Date.now() + 1000).toBeDateAfterNow();
expect(new Date(Date.now() + 1000)).toBeDateAfterNow();
expect(new Date(Date.now() - 1000)).not.toBeDateAfterNow();
toBeDateAfter
Check that the tested date object is a date "after" an other date.
The tested date and the date to compare may be:
- A date instance.
- A timestamp.
- A string that can be parsed with the
Date
constructor (i.enew Date('2016-01-01')
).
Note: Using date strings should be avoided due to browser differences and inconsistencies.
Since
0.1.0
Parameters
Name | Type | Description |
---|---|---|
lower |
Date,number,string |
The lower bound. |
Message
Expect date [actual] (not) to be after [lower]
Example:
expect(Date.now()).toBeDateAfter(Date.now() - 1000));
expect(Date.now() - 1000).toBeDateAfter(Date.now()));
toBeDateBeforeNow
Check that the tested date object is a date "before" now
.
The tested date may be:
- A date instance.
- A timestamp.
- A string that can be parsed with the
Date
constructor (i.enew Date('2016-01-01')
).
Note: Using date strings should be avoided due to browser differences and inconsistencies.
Since
0.1.0
Parameters
No parameters
Message
Expect date [actual] (not) to be before now
Example:
expect(Date.now() - 1000).toBeDateBeforeNow();
expect(new Date(Date.now() - 1000)).toBeDateBeforeNow();
expect(new Date(Date.now() + 1000)).not.toBeDateBeforeNow();
toBeDateBefore
Check that the tested date object is a date "before" an other date.
The tested date and the date to compare may be:
- A date instance.
- A timestamp.
- A string that can be parsed with the
Date
constructor (i.enew Date('2016-01-01')
).
Note: Using date strings should be avoided due to browser differences and inconsistencies.
Since
0.1.0
Parameters
Name | Type | Description |
---|---|---|
upper |
Date,number,string |
The upper bound. |
Message
Expect date [actual] (not) to be before [lower]
Example:
expect(Date.now()).toBeDateBefore(Date.now() + 1000));
expect(Date.now() + 1000).toBeDateBefore(Date.now()));
toBeDateCloseToNow
Check that the tested object is a date close to 'now'.
The tested date may be:
- A date instance.
- A timestamp.
- A string that can be parsed with the
Date
constructor (i.enew Date('2016-01-01')
).
Note: Using date strings should be avoided due to browser differences and inconsistencies.
Since
0.1.0
Parameters
Name | Type | Description |
---|---|---|
max |
number |
The maximum difference (in milliseconds), defaults to 1000. |
Message
Expect date [actual] (not) to be close to now
Example:
expect(Date.now()).toBeDateCloseToNow();
expect(Date.now() + 1000).toBeDateCloseToNow(2000);
expect(Date.now() - 1000).toBeDateCloseToNow(2000);
expect(new Date()).toBeDateCloseToNow();
expect(new Date(Date.now() + 1000)).not.toBeDateCloseToNow(2000);
expect(new Date(Date.now() - 1000)).not.toBeDateCloseToNow(2000);
toBeDateCloseTo
Check that the tested date object and an actual date object are close.
By default, the difference in milliseconds between both dates must not exceed 1000ms, but the last parameter may be set to increase/decrease this value.
The tested date and the date to compare may be:
- A date instance.
- A timestamp.
- A string that can be parsed with the
Date
constructor (i.enew Date('2016-01-01')
).
Note: Using date strings should be avoided due to browser differences and inconsistencies.
Since
0.1.0
Parameters
Name | Type | Description |
---|---|---|
date |
Date,number,string |
The second date to compare with. |
max |
number |
The maximum difference in milliseconds between both dates, default to 1000. |
Message
Expect date [actual] (not) to be close to [date]
Example:
expect(new Date(1995, 1, 1, 10, 0, 0, 0)).toBeDateCloseTo(new Date(1995, 1, 1, 10, 0, 0, 500));
expect(new Date(1995, 1, 1, 10, 0, 0, 0)).toBeDateCloseTo(new Date(1995, 1, 1, 10, 0, 0, 500), 1000);
expect(new Date(1995, 1, 1, 10, 0, 0, 0)).toBeDateCloseTo(new Date(1995, 1, 1, 10, 0, 0, 500), 100);
toBeDOMElementWithAttributes
Check that the tested object is a DOM element with expected attributes (using
the getAttribute
function).
Note that the attribute value can also be a jasmine matcher (jasmine.any(String)
for example).
Since
0.1.0
Parameters
Name | Type | Description |
---|---|---|
attributes |
Object |
Expected attributes. |
Message
Expect [actual] (not) to be a DOM element with attributes [attributes] but was [actualAttributes]
Example:
const span = document.createElement('span');
span.setAttribute('foo', 'foo');
span.setAttribute('bar', 'bar');
expect(span).toBeDOMElementWithAttributes({ foo: 'foo', bar: jasmine.any(String) });
toBeDOMElementWithClasses
Check that the tested object is a DOM element with expected class names.
Since
0.1.0
Parameters
Name | Type | Description |
---|---|---|
classes |
Array.<string>,string |
Expected class names. |
Message
Expect [actual] (not) to be a DOM element with classes [classes] but was [actualClasses]
Example:
const span = document.createElement('span');
span.className = 'foo bar';
expect(span).toBeDOMElementWithClasses('foo');
expect(span).toBeDOMElementWithClasses('bar');
expect(span).toBeDOMElementWithClasses('foo bar');
expect(span).toBeDOMElementWithClasses(['foo', 'bar']);
toBeDOMElementWithId
Check that the tested object is a DOM element with an expected id (note that
the id
is retrieved using getAttribute('id')
).
Since
0.1.0
Parameters
Name | Type | Description |
---|---|---|
id |
string |
Expected id. |
Message
Expect [actual] (not) to be a DOM element with id [id] but was [actualId]
Example:
const span = document.createElement('span');
span.setAttribute('id', 'mySpan');
expect(span).toBeDOMElementWithId('mySpan');
toBeDOMElement
Check that the tested object is DOM element with an expected tag name. The tag name is optional, if not set this matcher will juste check that the actual object is a DOM element.
Since
0.1.0
Parameters
Name | Type | Description |
---|---|---|
tagName |
string |
Expected tag name (optional). |
Message
Expect [actual] (not) to be a DOM element Expect [actual] (not) to be [tagName] element but was [actualTagName]
Example:
const span = document.createElement('span');
expect(span).toBeDOMElement();
expect(span).toBeDOMElement('span');
expect(span).toBeDOMElement('SPAN');
expect(span).not.toBeDOMElement('div');
toBeEmpty
Check that tested object is empty:
- If it is an
array
or an array-like, check that the length is equal to zero. - If it is an object, check that it does not have any property.
- If it is a
map
or aset
, check that the size is equal to zero.
Since
0.1.0
Parameters
No parameters
Message
Expect [actual] (not) to be empty.
Example:
expect('').toBeEmpty();
expect([]).toBeEmpty();
expect({}).toBeEmpty();
expect(new Map()).toBeEmpty();
expect(new Set()).toBeEmpty();
toBeEvenNumber
Check that the tested object is an even number.
Since
0.1.0
Parameters
No parameters
Message
Expect [actual] to be an even number
Example:
expect(2).toBeEvenNumber();
expect(0).not.toBeEvenNumber();
expect(1).not.toBeEvenNumber();
toBeExtensible
Check that the tested object is extensible.
Objects are extensible by default: they can have new properties added to them, and can be modified. An object can be marked as non-extensible using:
-
Object.preventExtensions()
, -
Object.seal()
, Object.freeze()
This matcher use internally Object.isExtensible
(supported in Chrome, Firefox,
Safari and IE >= 9). If Object.isExtensible
is not supported, this matcher
treat the tested object as an extensible object.
Important: This matcher (as ES6 specification) treat primitive
(null
, undefined
, numbers, strings and booleans) as non extensible object.
See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isExtensible
Since
0.5.0
Parameters
No parameters
Message
Expect [actual] (not) to be extensible
Example:
expect({}).toBeExtensible();
expect([]).toBeExtensible();
expect(null).not.toBeExtensible();
expect(undefined).not.toBeExtensible();
expect('').not.toBeExtensible();
expect(0).not.toBeExtensible();
expect(true).not.toBeExtensible();
expect(Object.freeze({})).not.toBeExtensible();
expect(Object.freeze([])).not.toBeExtensible();
expect(Object.seal({})).not.toBeExtensible();
expect(Object.seal([])).not.toBeExtensible();
expect(Object.preventExtensions({})).not.toBeExtensible();
expect(Object.preventExtensions([])).not.toBeExtensible();
toBeFalse
Check that the tested object is strictly equal false
.
Since
0.1.0
Parameters
No parameters
Message
Expect [actual] (not) to be false
Example:
expect(false).toBeFalse();
expect(true).not.toBeFalse();
expect(0).not.toBeFalse();
toBeFiniteNumber
Check that the tested object is a finite number.
Important: This matcher does not convert the tested object to a number, but
returns the equivalent of Number.isFinite
function.
See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isFinite
Since
0.5.0
Parameters
No parameters
Message
Expect [actual] (not) to be finite number
Example:
expect(1).toBeFiniteNumber();
expect(1.0).toBeFiniteNumber();
expect('1').not.toBeFiniteNumber();
expect(NaN).not.toBeFiniteNumber();
expect(Infinity).not.toBeFiniteNumber();
expect(-Infinity).not.toBeFiniteNumber();
expect(null).not.toBeFiniteNumber();
toBeFloat
Check that the tested object is a float
value.
Note that for this matcher, a float
is a numeric value (see toBeNumeric
matcher) that
is not an integer (a numeric value may be a number
or a string
containing a number).
JavaScript makes no distinction between integers and floats so 1.0 is considered integer.
Since
0.1.0
Parameters
No parameters
Message
Expect [actual] (not) to be a float
Example:
expect(1.5).toBeFloat();
expect('1.5').toBeFloat();
expect(1).not.toBeFloat();
expect(1.0).not.toBeFloat();
toBeFrozen
Check that the tested object is frozen: an object is frozen if and only if it is not extensible, all its properties are non-configurable, and all its data properties (that is, properties which are not accessor properties with getter or setter components) are non-writable.
This function use internally Object.isFrozen
(supported in Chrome, Firefox,
Safari and IE >= 9). If Object.isFrozen
is not supported, this function
returns false
.
Important: This function (as ES6 specification) treat primitive
(null
, undefined
, numbers, strings and booleans) as frozen object.
See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isFrozen
Since
0.5.0
Parameters
No parameters
Message
Expect [actual] (not) to frozen
Example:
expect(null).toBeFrozen();
expect(undefined).toBeFrozen();
expect('').toBeFrozen();
expect(0).toBeFrozen();
expect(true).toBeFrozen();
expect(Object.freeze({})).toBeFrozen();
expect(Object.freeze([])).toBeFrozen();
expect({}).not.toBeFrozen();
expect([]).not.toBeFrozen();
toBeInRange
Check that the tested object is a number
(strictly) greater than a lower bound
and (strictly) less than a lower bound.
Since
0.1.0
Parameters
Name | Type | Description |
---|---|---|
lower |
number |
The lower bound. |
upper |
number |
The upper bound. |
Message
Expect [actual] (not) to be between [lower] and [upper]
Example:
expect(2).toBeInRange(1, 3);
expect(1).not.toBeInRange(1, 3);
expect(3).not.toBeInRange(1, 3);
toBeInstanceOf
Check that the tested object is an instance of a given constructor
.
Since
0.1.0
Parameters
Name | Type | Description |
---|---|---|
ctor |
* |
Expected constructor. |
Message
Expect [actual] (not) to be an instance of [constructor]
Example:
expect(new Date()).toBeInstanceOf(Date);
expect('foo').toBeInstanceOf(String);
class Foo { }
expect(new Foo()).toBeInstanceOf(Foo);
toBeInteger
Check that the tested object is an integer
value.
Note that for this matcher, an integer
is a numeric value (see toBeNumeric
matcher) that
is not a float
(a numeric value may be a number
or a string
containing a number).
JavaScript makes no distinction between integers and floats so both 1 and 1.0 are considered integers.
Since
0.1.0
Parameters
No parameters
Message
Expect [actual] (not) to be an integer
Example:
expect(1).toBeInteger();
expect(1.0).toBeInteger();
expect('1').toBeInteger();
expect('1.0').toBeInteger();
expect(1.5).not.toBeInteger();
toBeIterable
Check that the tested object is an iterable value.
An iterable value allows is an object that can define or customize its iteration behavior,
such as what values are looped over in a for..of
construct.
An iterable value may be:
- An
array
. - A
Map
. - A
Set
. - An object that implement the
@@iterator
method.
Since
0.3.0
Parameters
Name | Type | Description |
---|---|---|
Klass |
* |
Expected class. |
Message
Expect [actual] (not) to be iterable
Example:
expect([]).toBeIterable();
expect(new Map()).toBeIterable();
expect(new Set()).toBeIterable();
toBeNegative
Check that the tested object is a number strictly less than zero.
Since
0.1.0
Parameters
No parameters
Message
Expect [actual] (not) to be a negative number
Example:
expect(-1).toBeNegative();
expect(0).not.toBeNegative();
expect(1).not.toBeNegative();
toBeNil
Check that the tested object is nil (i.e null
or undefined
).
Since
0.3.0
Parameters
No parameters
Message
Expect [actual] (not) to be nil (null or undefined)
Example:
expect(null).toBeNil();
expect(undefined).toBeNil();
expect(void 0).toBeNil();
expect(false).not.toBeNil();
expect(0).not.toBeNil();
expect(NaN).not.toBeNil();
toBeNull
Check that tested object is null
.
Since
0.1.0
Parameters
No parameters
Message
Expect [actual] (not) to be null
Example:
expect(null).toBeNull();
expect(undefined).not.toBeNull();
expect(false).not.toBeNull();
toBeNumeric
Check that the tested object is a numeric value.
A numeric is something that contains a numeric value, regardless of its type (it
can be a string
containing a numeric value or a number
).
Since
0.1.0
Parameters
No parameters
Message
Expect [actual] (not) to be a numeric value
Example:
expect(2).toBeNumeric();
expect(1.5).toBeNumeric();
expect('2').toBeNumeric();
expect('1.5').toBeNumeric();
expect('foo').not.toBeNumeric();
toBeOddNumber
Check that the tested object is an odd number.
Since
0.1.0
Parameters
No parameters
Message
Expect [actual] (not) to be an odd number
Example:
expect(1).toBeOddNumber();
expect(2).not.toBeOddNumber();
expect(0).not.toBeOddNumber();
toBeOk
Check that the tested object is not nil (i.e not null
and not undefined
).
Since
0.6.0
Parameters
No parameters
Message
Expect [actual] (not) to be ok (not null and not undefined)
Example:
expect(false).toBeOk();
expect(0).toBeOk();
expect(NaN).toBeOk();
expect(null).not.toBeOk();
expect(undefined).not.toBeOk();
expect(void 0).not.toBeOk();
toBeOneOf
Check that the tested object is strictly equal to one of the values
in an array. Note that this matcher use the strict equality (===
), please
use toEqualOneOf
for other equality check.
Since
0.5.0
Parameters
Name | Type | Description |
---|---|---|
array |
Array |
The array that should contains the actual value. |
Message
Expect [actual] (not) to be one of [values]
Example:
expect(1).toBeOneOf([1, 2, 3]);
expect(10).not.toBeOneOf([1, 2, 3]);
toBePartiallyEqualTo
Check that the tested object is partially equals to a second one. Note that this matcher works fine with custom equality matchers.
Since
0.1.0
Parameters
Name | Type | Description |
---|---|---|
other |
Array.<*>,Object |
The second object to use for equality. |
Message
Expect [actual] (not) to be partially equal to [other]
Example:
const a1 = { id: 1, foo: 'bar' };
const a2 = { id: 2, foo: 'bar' };
const b1 = { id: 1 };
const b2 = { id: 2 };
const c1 = { id: 2 };
const c2 = { id: 2 };
const array1 = [a1, a2];
const array2 = [b1, b2];
const array3 = [c1, c2];
expect(array1).toBePartiallyEqualTo(array2);
expect(array1).not.toBePartiallyEqualTo(array3);
toBePositive
Check that the tested object is a number strictly greater than zero.
Since
0.1.0
Parameters
No parameters
Message
Expect [actual] (not) to be a positive number
Example:
expect(1).toBePositive();
expect(0).not.toBePositive();
expect(-1).not.toBePositive();
toBeSameDay
Check that the tested object is the same day as an other date.
The tested date and the date to compare may be:
- A date instance.
- A timestamp.
- A string that can be parsed with the
Date
constructor (i.enew Date('2016-01-01')
).
Note: Using date strings should be avoided due to browser differences and inconsistencies.
Since
0.1.0
Parameters
Name | Type | Description |
---|---|---|
day |
Date,number,string |
The other date. |
Message
Expect [actual] (not) the same day as [day]
Example:
const date1 = new Date(2014, 5, 5, 10, 0, 0, 0);
const date2 = new Date(2014, 5, 5, 15, 0, 0, 0);
const date3 = new Date(2014, 5, 6, 10, 0, 0, 0);
expect(date1).toBeSameDay(date2);
expect(date1).not.toBeSameDay(date3);
toBeSealed
Check that a given value is sealed: an object is sealed if it is not extensible and if all its properties are non-configurable and therefore not removable (but not necessarily non-writable).
This matcher use internally Object.isSealed
(supported in Chrome, Firefox,
Safari and IE >= 9). If Object.isSealed
is not supported, the matcher will
always treat objects and arrays as non sealed.
Important: This matcher (as ES6 specification) treat primitive
(null
, undefined
, numbers, strings and booleans) as sealed object.
See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isSealed
Since
0.5.0
Parameters
No parameters
Message
Expect [actual] (not) to sealed
Example:
expect(null).toBeSealed();
expect(undefined).toBeSealed();
expect('').toBeSealed();
expect(0).toBeSealed();
expect(true).toBeSealed();
expect(Object.seal({})).toBeSealed();
expect(Object.seal([])).toBeSealed();
expect({}).not.toBeSealed();
expect([]).not.toBeSealed();
toBeSorted
Check that the tested object is an array and is sorted (i.e for each elements in
the array, array[i - 1] <= array[i]
).
A custom comparator can be specified as parameter:
- Takes values to compare as arguments.
- Must return a number:
- Less than zero if first argument is less than the second.
- Greater than zero if first argument is greater than the second.
- Zero if both parameters are "equivalent".
Since
0.1.0
Parameters
Name | Type | Description |
---|---|---|
comparator |
function |
Comparator function (optional). |
Message
Expect [actual] (not) to be sorted
Example:
expect([0, 1, 2, 3]).toBeSorted();
expect(['bar', 'foo']).toBeSorted();
expect([false, false, true, true]).toBeSorted();
expect([{ id: 1 }, { id: 2 }, { id: 3 }]).toBeSorted((a, b) => a.id - b.id);
expect([1, 0, 2, 3]).not.toBeSorted();
toBeToday
Check that the tested object is the same day as now (i.e Date.now()
).
The tested date may be:
- A date instance.
- A timestamp.
- A string that can be parsed with the
Date
constructor (i.enew Date('2016-01-01')
).
Note: Using date strings should be avoided due to browser differences and inconsistencies.
Since
0.1.0
Parameters
No parameters
Message
Expect [actual] (not) to be today
Example:
const date1 = new Date();
const date2 = new Date();
date2.setDate(date1.getDate() - 1);
expect(date1).toBeToday();
expect(date2).not.toBeToday();
toBeTrue
Check that the tested object is strictly equal to true
.
Since
0.1.0
Parameters
No parameters
Message
Expect [actual] (not) to be true
Example:
expect(true).toBeTrue();
expect(false).not.toBeTrue();
expect(1).not.toBeTrue();
toBeZero
Check that the tested object is a number strictly equal to zero.
Since
0.1.0
Parameters
No parameters
Message
Expect [actual] (not) to be zero
Example:
expect(0).toBeZero();
expect(1).not.toBeZero();
expect('0').not.toBeZero();
toContainsDistinctValues
Check that the tested object is an array containing only distinct values.
The tested object may be an array or any iterable object (i.e that can be
traversed with the for..of
loop).
Note that this matcher works fine with custom equality matchers.
Since
0.1.0
Parameters
No parameters
Message
Expect [actual] (not) to contains only distinct values
Example:
expect([0, 1, 2, 3]).toContainsDistinctValues();
expect([0, 1, 2, 3, 0]).not.toContainsDistinctValues();
toContainsOnlyFalsyValues
Check that the tested object contains only falsy values.
The tested object may be an array or any iterable object (i.e that can be
traversed with the for..of
loop).
Note that this matcher works fine with custom equality matchers.
Since
0.1.0
Parameters
No parameters
Message
Expect [actual] (not) to contains only falsy values
Example:
expect([0, false, null, undefined, '']).toContainsOnlyFalsyValues();
expect([1, false, null, undefined, '']).not.toContainsOnlyFalsyValues();
expect([0, true, null, undefined, '']).not.toContainsOnlyFalsyValues();
expect([0, false, {}, undefined, '']).not.toContainsOnlyFalsyValues();
expect([0, false, null, [], '']).not.toContainsOnlyFalsyValues();
expect([0, false, null, undefined, 'foo']).not.toContainsOnlyFalsyValues();
toContainsOnlyTruthyValues
Check that the tested object contains only truthy values.
The tested object may be an array or any iterable object (i.e that can be
traversed with the for..of
loop).
Note that this matcher works fine with custom equality matchers.
Since
0.1.0
Parameters
No parameters
Message
Expect [actual] (not) to contains only truthy values.
Example:
expect([1, 2, true, 'foo', {}, []]).toContainsOnlyTruthyValues();
expect([1, 2, false, 'foo', {}, []]).not.toContainsOnlyTruthyValues();
expect([1, 2, true, '', {}, []]).not.toContainsOnlyTruthyValues();
expect([0, 2, true, 'foo', {}, []]).not.toContainsOnlyTruthyValues();
toEndWith
Check that the tested object is a string
and end with an expected suffix.
Since
0.1.0
Parameters
Name | Type | Description |
---|---|---|
suffix |
string |
The suffix to look for. |
Message
Expect [actual] (not) to end with [suffix]
Example:
expect('foo').toEndWith('o');
expect('foo').toEndWith('oo');
expect('foo').toEndWith('foo');
expect('foo').not.toEndWith('bar');
toEqualIgnoringCase
Check that the tested object is a string
equal to an other string
: comparison is
case-insensitive.
Since
0.1.0
Parameters
Name | Type | Description |
---|---|---|
other |
string |
Other string to compare. |
Message
Expect [actual] (not) to be equal to [other] (case insensitive)
Example:
expect('foo').toEqualIgnoringCase('foo');
expect('foo').toEqualIgnoringCase('FOO');
expect('foo').not.toEqualIgnoringCase('bar');
toEqualOneOf
Check that the tested object is equal to one of the values in an array.
Note that this matcher use the deep equality check and also works with
custom equality tester. For strict comparison (===
) please use toBeOneOf
.
Since
0.5.0
Parameters
Name | Type | Description |
---|---|---|
array |
Array |
The array that should contains the actual value. |
Message
Expect [actual] (not) to equal one of [values]
Example:
expect(1).toEqualOneOf([1, 2, 3]);
expect({id: 1}).toEqualOneOf([{id: 1}]);
expect(10).not.toEqualOneOf([1, 2, 3]);
toHaveBeenCalledOnceWith
Check that the tested object is a spy that has been called once (and exactly once) with expected arguments.
Since
0.1.0
Parameters
Name | Type | Description |
---|---|---|
args |
...* |
Expected call arguments. |
Message
Expect [actual] to have been called once but was called [count] time(s) Expect [actual] to have been called once but was called [count] time(s) with different arguments
Example:
const spy = jasmine.createSpy('foo');
expect(spy).not.toHaveBeenCalledOnce();
spy('foo');
expect(spy).toHaveBeenCalledOnceWith('foo');
expect(spy).not.toHaveBeenCalledOnceWith('bar');
toHaveBeenCalledOnce
Check that the tested object is a spy that has been called once (and only once).
Since
0.1.0
Parameters
No parameters
Message
Expect [actual] (not) to have been called once but was called [count] time(s)
Example:
const spy = jasmine.createSpy('foo');
expect(spy).not.toHaveBeenCalledOnce();
spy();
expect(spy).toHaveBeenCalledOnce();
spy();
expect(spy).not.toHaveBeenCalledOnce();
toHaveFunctions
Check that actual object contains all given expected functions.
Since
0.1.0
Parameters
Name | Type | Description |
---|---|---|
methods |
...string |
List of methods to look for. |
Message
Expect [actual] (not) to contain functions [methods]
Example:
const foo = jasmine.createSpy('foo');
const bar = jasmine.createSpy('bar');
const obj = { id: 1, name: 'foo', foo, bar };
expect(obj).toHaveFunctions('foo', 'bar');
expect(obj).not.toHaveFunctions('id', 'name');
toHaveKeys
Check that actual object contains all given expected keys.
Since
0.1.0
Parameters
Name | Type | Description |
---|---|---|
expectedKeys |
...string |
Keys to look for in tested object. |
Message
Expect [actual] (not) to have keys [expectedKeys]
Example:
const obj = { id: 1, name: 'foo' };
expect(obj).toHaveKeys('id', 'name');
expect(obj).not.toHaveKeys('foo', 'bar');
toHaveLength
Check that tested object has a length
property with expected value.
Since
0.1.0
Parameters
Name | Type | Description |
---|---|---|
expectedLength |
number |
The expected length value. |
Message
Expect length of [actual] (not) to be [expectedLength]
Example:
expect([]).toHaveLength(0);
expect([0, 1, 2]).toHaveLength(3);
expect('').toHaveLength(0);
expect('foo').toHaveLength(3);
toHaveSameLengthAs
Check that tested object has the same length as an other value with length
property.
Since
0.1.0
Parameters
Name | Type | Description |
---|---|---|
expected |
Array.<*> |
The other array. |
Message
Expect [actual] (not) to have same length as [expected]
Example:
expect([]).toHaveSameLengthAs('');
expect(['f', 'o', 'o']).toHaveSameLengthAs('foo');
expect('').toHaveSameLengthAs([]);
expect('foo').toHaveSameLengthAs(['f', 'o', 'o']);
toHaveSameSizeAs
Check that tested object has the same size as an other one.
A size may be computed from:
- An array (or an array-like object) with the
length
property. - A
Map
or aSet
using itssize
property. - Any iterable object (using a
for..of
loop). - An object (number of own enumerable properties).
Since
0.1.0
Parameters
Name | Type | Description |
---|---|---|
expected |
* |
The other object (or array, or array-like object). |
Message
Expect [actual] to have same size as [expected]
Example:
expect('foo').toHaveSameSizeAs('foo');
expect('bar').toHaveSameSizeAs({ b: 1, a: 1, r: 1 });
expect([ 'foo', 'bar' ]).toHaveSameSizeAs(new Set(['foo', 'bar']));
toHaveSize
Check that tested object has an expected size.
A size may be computed from:
- An array (or an array-like object) with the
length
property. - A
Map
or aSet
using itssize
property. - Any iterable object (using a
for..of
loop). - An object (number of own enumerable properties).
Since
0.1.0
Parameters
Name | Type | Description |
---|---|---|
expectedSize |
number |
The expected size. |
Message
Expect size of [actual] (not) to be [expectedSize]
Example:
expect([1, 2, 3]).toHaveSize(3);
expect('foo bar').toHaveSize(7);
expect(new Set([0, 1, 2])).toHaveSize(3);
expect({ foo: 'bar' }).toHaveSize(1);
toHaveSome
Verifies that the tested object satisfies a predicate function for at at least one element in the collection.
The collection may be an array
, a set
, a map
or any iterable object.
The predicate function is executed with three arguments:
- The value being iterated.
- The key of the value being iterated.
- The collection being iterated.
Important: Note that the key may be different with arrays and map/set:
- With an array or an iterable object, the key will be the index of the value being traversed.
- With a map, the key will be the index value of the value being traversed.
- With a set, the key will be the same value being traversed (since a
Set
does not have any keys).
See the documentation of the forEach
functions of Map
and Set
structure:
- https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Set/forEach
- https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Map
This matcher may take an optional first argument: the error message that will be displayed if the matcher does not pass.
Since
0.1.0
Parameters
Name | Type | Description |
---|---|---|
msg |
string |
Custom error message (optional). |
iterator |
function |
Predicate function. |
Message
Expect [actual] (not) to have at least one element that verify condition Expect [actual] (not) to have at least one element that verify "[message]"
Example:
expect([1, 2, 3]).toHaveSome(x => x % 2 === 0);
expect([1, 3, 5, 7]).not.toHaveSome(x => x % 2 === 0);
toHaveValues
Check that the tested object contains expected values (the key is not checked, only the value).
Since
0.1.0
Parameters
Name | Type | Description |
---|---|---|
expectedValues |
...* |
The values to look for. |
Message
Expect [actual] (not) to have values [values]
Example:
const obj = { id: 1, name: 'foo', array: [1, 2, 3] };
expect(obj).toHaveValues(1, 'foo', [1, 2, 3]);
expect(obj).not.toHaveValues(2, 'bar');
expect(obj).not.toHaveValues([ 1, 2, 3, 4 ]);
toStartWith
Check that the tested object is a string and start with an expected prefix.
Since
0.1.0
Parameters
Name | Type | Description |
---|---|---|
prefix |
string |
The prefix to look for. |
Message
Expect [actual] (not) to start with [prefix]
Example:
expect('foo').toStartWith('f');
expect('foo').toStartWith('fo');
expect('foo').toStartWith('foo');
expect('foo').not.toStartWith('bar');
toVerify
Check that the tested object satisfies a given predicate.
The collection may be an array
, a set
, a map
or any iterable object.
The predicate function is executed with three arguments:
- The value being iterated.
- The key of the value being iterated.
- The collection being iterated.
Important: Note that the key may be different with arrays and map/set:
- With an array or an iterable object, the key will be the index of the value being traversed.
- With a map, the key will be the index value of the value being traversed.
- With a set, the key will be the same value being traversed (since a
Set
does not have any keys).
See the documentation of the forEach
functions of Map
and Set
structure:
- https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Set/forEach
- https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Map
This matcher may take an optional first argument: the error message that will be displayed if the matcher does not pass.
Since
0.1.0
Parameters
Name | Type | Description |
---|---|---|
msg |
string |
Error message thrown when the test fail (optional). |
iterator |
function |
Predicate function. |
Message
Expect [actual] (not) to verify condition Expect [actual] (not) to verify "[message]"
Example:
expect([2, 4, 6, 8]).toVerify(x => x % 2 === 0);
expect([2, 4, 6, 8, 9]).not.toVerify(x => x % 2 === 0);
Licence
MIT License (MIT)
Contributing
If you think some matchers are missing or error messages are not useful enough, feel free to contribute and submit an issue or a pull request.
Thanks to @geoffdutton for his contribution!