dec67bd535
This makes it easier to write high quality matchers and asymmetric equality
testers, and is also a step toward supporting custom object formatters.
Previously, Jasmine passed custom object formatters as the second argument
to matcher factories and as and the second argument to asymmetric equality
testers' `asymmetricMatch` method. Matchers and asymmetric equality testers
were responsible for passing the custom object formatters to methods like
`matchersUtil#equals`:
function toEqual(util, customEqualityTesters) {
return {
compare: function(actual, expected) {
// ...
result.pass = util.equals(actual, expected, customEqualityTesters, diffBuilder);
And:
ArrayContaining.prototype.asymmetricMatch = function(other, customTesters) {
// ...
for (var i = 0; i < this.sample.length; i++) {
var item = this.sample[i];
if (!j$.matchersUtil.contains(other, item, customTesters)) {
return false;
}
}
With this change, that is no longer necessary. Matchers and asymmetric
equality testers can ignore the existence of custom equality testers and
still fully support them:
function toEqual(util) {
return {
compare: function(actual, expected) {
// ...
result.pass = util.equals(actual, expected, diffBuilder);
And:
ArrayContaining.prototype.asymmetricMatch = function(other, matchersUtil) {
// ...
for (var i = 0; i < this.sample.length; i++) {
var item = this.sample[i];
if (!matchersUtil.contains(other, item)) {
return false;
}
}
The old interfaces are still supported, for now, but will be deprecated
in a future commit and removed in the next major release after that.
In addition to making matchers and custom equality testers simpler,
this change sets the stage for adding support for custom object
formatters. Those will be architecturally similar to custom equality
testers, and by injecting a `MatchersUtil` instance everywhere we can
add them without requiring user code to pass them around as used to be
the case with custom object formatters.
80 lines
3.0 KiB
JavaScript
80 lines
3.0 KiB
JavaScript
describe("toHaveBeenCalledWith", function() {
|
|
|
|
it("passes when the actual was called with matching parameters", function() {
|
|
var util = {
|
|
contains: jasmine.createSpy('delegated-contains').and.returnValue(true)
|
|
},
|
|
matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(util),
|
|
calledSpy = new jasmineUnderTest.Env().createSpy('called-spy'),
|
|
result;
|
|
|
|
calledSpy('a', 'b');
|
|
result = matcher.compare(calledSpy, 'a', 'b');
|
|
|
|
expect(result.pass).toBe(true);
|
|
expect(result.message()).toEqual("Expected spy called-spy not to have been called with:\n [ 'a', 'b' ]\nbut it was.");
|
|
});
|
|
|
|
it("supports custom equality testers", function() {
|
|
var customEqualityTesters = [function() { return true; }],
|
|
matchersUtil = new jasmineUnderTest.MatchersUtil({customTesters: customEqualityTesters}),
|
|
matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(matchersUtil),
|
|
calledSpy = new jasmineUnderTest.Env().createSpy('called-spy'),
|
|
result;
|
|
|
|
calledSpy('a', 'b');
|
|
result = matcher.compare(calledSpy, 'a', 'b');
|
|
expect(result.pass).toBe(true);
|
|
});
|
|
|
|
it("fails when the actual was not called", function() {
|
|
var util = {
|
|
contains: jasmine.createSpy('delegated-contains').and.returnValue(false)
|
|
},
|
|
matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(util),
|
|
uncalledSpy = new jasmineUnderTest.Env().createSpy('uncalled spy'),
|
|
result;
|
|
|
|
result = matcher.compare(uncalledSpy);
|
|
expect(result.pass).toBe(false);
|
|
expect(result.message()).toEqual("Expected spy uncalled spy to have been called with:\n [ ]\nbut it was never called.");
|
|
});
|
|
|
|
it("fails when the actual was called with different parameters", function() {
|
|
var util = new jasmineUnderTest.MatchersUtil(),
|
|
matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(util),
|
|
calledSpy = new jasmineUnderTest.Env().createSpy('called spy'),
|
|
result;
|
|
|
|
calledSpy('a');
|
|
calledSpy('c', 'd');
|
|
calledSpy('a', 'b', 'c');
|
|
result = matcher.compare(calledSpy, 'a', 'b');
|
|
|
|
expect(result.pass).toBe(false);
|
|
expect(result.message()).toEqual(
|
|
"Expected spy called spy to have been called with:\n" +
|
|
" [ 'a', 'b' ]\n" +
|
|
"but actual calls were:\n" +
|
|
" [ 'a' ],\n" +
|
|
" [ 'c', 'd' ],\n" +
|
|
" [ 'a', 'b', 'c' ].\n\n" +
|
|
"Call 0:\n" +
|
|
" Expected $.length = 1 to equal 2.\n" +
|
|
" Expected $[1] = undefined to equal 'b'.\n" +
|
|
"Call 1:\n" +
|
|
" Expected $[0] = 'c' to equal 'a'.\n" +
|
|
" Expected $[1] = 'd' to equal 'b'.\n" +
|
|
"Call 2:\n" +
|
|
" Expected $.length = 3 to equal 2.\n" +
|
|
" Unexpected $[2] = 'c' in array.");
|
|
});
|
|
|
|
it("throws an exception when the actual is not a spy", function() {
|
|
var matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(),
|
|
fn = function() {};
|
|
|
|
expect(function() { matcher.compare(fn) }).toThrowError(/Expected a spy, but got Function./);
|
|
});
|
|
});
|