Remove 'actual' param from matchers test and message functions. Use this.actual instead. This way, the signature of the test function matches how the matcher is called from a spec.

Spy matchers now throw an exception when called with non-spies, rather than returning false.  This makes the message function simpler, and will work better with future dot-not support.
Added better specs for error conditions on spy matchers.
This commit is contained in:
Christian Williams 2009-11-12 12:47:44 -05:00
parent 2a5754600a
commit 1b3545c82a
3 changed files with 134 additions and 148 deletions

View File

@ -463,7 +463,7 @@ describe("jasmine.Matchers", function() {
} catch (e) { } catch (e) {
exception = e; exception = e;
} }
;
expect(exception).toBeDefined(); expect(exception).toBeDefined();
expect(exception.message).toEqual('Actual is not a function'); expect(exception.message).toEqual('Actual is not a function');
@ -476,21 +476,44 @@ describe("jasmine.Matchers", function() {
}); });
describe("wasCalled, wasNotCalled, wasCalledWith", function() { describe("spy matchers (wasCalled, wasNotCalled, wasCalledWith)", function() {
var TestClass; var TestClass;
beforeEach(function() { beforeEach(function() {
TestClass = { someFunction: function() { TestClass = { someFunction: function() {
} }; } };
}); });
describe('without spies', function() {
it('should always show an error', function () {
expect(match(TestClass.someFunction).wasCalled()).toEqual(false);
var result = mockSpec.addMatcherResult.mostRecentCall.args[0];
expect(result.message).toEqual("Actual is not a spy.");
expect(match(TestClass.someFunction).wasNotCalled()).toEqual(false); it("should throw an exception when wasCalled and wasNotCalled are invoked with the wrong number of arguments", function() {
result = mockSpec.addMatcherResult.mostRecentCall.args[0]; expect(function() {
expect(result.message).toEqual("Actual is not a spy."); match(TestClass.someFunction).wasCalled("unwanted argument");
}).toThrow('wasCalled does not take arguments, use wasCalledWith');
expect(function() {
match(TestClass.someFunction).wasNotCalled("unwanted argument");
}).toThrow('wasNotCalled does not take arguments');
});
describe('with non-spies', function() {
it('should always show an error', function () {
expect(function() {
match(TestClass.someFunction).wasCalled();
}).toThrow('Expected a spy, but got Function.');
expect(function() {
match(TestClass.someFunction).wasNotCalled();
}).toThrow('Expected a spy, but got Function.');
expect(function() {
match(TestClass.someFunction).wasCalledWith();
}).toThrow('Expected a spy, but got Function.');
expect(function() {
match(undefined).wasCalled();
}).toThrow('Expected a spy, but got undefined.');
expect(function() {
match({some:'object'}).wasCalled();
}).toThrow('Expected a spy, but got { some : \'object\' }.');
}); });
}); });
@ -538,7 +561,6 @@ describe("jasmine.Matchers", function() {
}); });
}); });
describe("wasCalledWith to build an ExpectationResult", function () { describe("wasCalledWith to build an ExpectationResult", function () {
var TestClass; var TestClass;
beforeEach(function() { beforeEach(function() {
@ -552,30 +574,6 @@ describe("jasmine.Matchers", function() {
spec.spyOn(TestClass, 'someFunction'); spec.spyOn(TestClass, 'someFunction');
}); });
it("should handle case of actual not being a spy", function() {
var matcher = match();
matcher.wasCalledWith('a', 'b');
var result = mockSpec.addMatcherResult.mostRecentCall.args[0];
expect(result.matcherName).toEqual("wasCalledWith");
expect(result.passed()).toEqual(false);
expect(result.message).toEqual("Actual is not a spy");
expect(result.actual).toEqual(undefined);
expect(result.expected).toEqual(['a','b']);
matcher = match('foo');
matcher.wasCalledWith('a', 'b');
result = mockSpec.addMatcherResult.mostRecentCall.args[0];
expect(result.matcherName).toEqual("wasCalledWith");
expect(result.passed()).toEqual(false);
expect(result.message).toEqual("Actual is not a spy");
expect(result.actual).toEqual('foo');
expect(result.expected).toEqual(['a','b']);
});
it("should should handle the case of a spy", function() { it("should should handle the case of a spy", function() {
TestClass.someFunction('a', 'c'); TestClass.someFunction('a', 'c');
var matcher = match(TestClass.someFunction); var matcher = match(TestClass.someFunction);
@ -590,5 +588,4 @@ describe("jasmine.Matchers", function() {
expect(result.expected).toEqual(['a','b']); expect(result.expected).toEqual(['a','b']);
}); });
}); });
}) });
;

View File

@ -28,11 +28,10 @@ jasmine.Matchers.matcherFn_ = function(matcherName, options) {
return function () { return function () {
jasmine.util.extend(this, options); jasmine.util.extend(this, options);
var matcherArgs = jasmine.util.argsToArray(arguments); var matcherArgs = jasmine.util.argsToArray(arguments);
var args = [this.actual].concat(matcherArgs); var result = options.test.apply(this, arguments);
var result = options.test.apply(this, args);
var message; var message;
if (!result) { if (!result) {
message = options.message.apply(this, args); message = options.message.apply(this, arguments);
} }
var expectationResult = new jasmine.ExpectationResult({ var expectationResult = new jasmine.ExpectationResult({
matcherName: matcherName, matcherName: matcherName,
@ -55,11 +54,11 @@ jasmine.Matchers.matcherFn_ = function(matcherName, options) {
*/ */
jasmine.Matchers.prototype.toBe = jasmine.Matchers.matcherFn_('toBe', { jasmine.Matchers.prototype.toBe = jasmine.Matchers.matcherFn_('toBe', {
test: function (actual, expected) { test: function(expected) {
return actual === expected; return this.actual === expected;
}, },
message: function(actual, expected) { message: function(expected) {
return "Expected " + jasmine.pp(actual) + " to be " + jasmine.pp(expected); return "Expected " + jasmine.pp(this.actual) + " to be " + jasmine.pp(expected);
} }
}); });
@ -68,11 +67,11 @@ jasmine.Matchers.prototype.toBe = jasmine.Matchers.matcherFn_('toBe', {
* @param expected * @param expected
*/ */
jasmine.Matchers.prototype.toNotBe = jasmine.Matchers.matcherFn_('toNotBe', { jasmine.Matchers.prototype.toNotBe = jasmine.Matchers.matcherFn_('toNotBe', {
test: function (actual, expected) { test: function(expected) {
return actual !== expected; return this.actual !== expected;
}, },
message: function(actual, expected) { message: function(expected) {
return "Expected " + jasmine.pp(actual) + " to not be " + jasmine.pp(expected); return "Expected " + jasmine.pp(this.actual) + " to not be " + jasmine.pp(expected);
} }
}); });
@ -83,11 +82,11 @@ jasmine.Matchers.prototype.toNotBe = jasmine.Matchers.matcherFn_('toNotBe', {
*/ */
jasmine.Matchers.prototype.toEqual = jasmine.Matchers.matcherFn_('toEqual', { jasmine.Matchers.prototype.toEqual = jasmine.Matchers.matcherFn_('toEqual', {
test: function (actual, expected) { test: function(expected) {
return this.env.equals_(actual, expected); return this.env.equals_(this.actual, expected);
}, },
message: function(actual, expected) { message: function(expected) {
return "Expected " + jasmine.pp(actual) + " to equal " + jasmine.pp(expected); return "Expected " + jasmine.pp(this.actual) + " to equal " + jasmine.pp(expected);
} }
}); });
@ -96,11 +95,11 @@ jasmine.Matchers.prototype.toEqual = jasmine.Matchers.matcherFn_('toEqual', {
* @param expected * @param expected
*/ */
jasmine.Matchers.prototype.toNotEqual = jasmine.Matchers.matcherFn_('toNotEqual', { jasmine.Matchers.prototype.toNotEqual = jasmine.Matchers.matcherFn_('toNotEqual', {
test: function (actual, expected) { test: function(expected) {
return !this.env.equals_(actual, expected); return !this.env.equals_(this.actual, expected);
}, },
message: function(actual, expected) { message: function(expected) {
return "Expected " + jasmine.pp(actual) + " to not equal " + jasmine.pp(expected); return "Expected " + jasmine.pp(this.actual) + " to not equal " + jasmine.pp(expected);
} }
}); });
@ -111,11 +110,11 @@ jasmine.Matchers.prototype.toNotEqual = jasmine.Matchers.matcherFn_('toNotEqual'
* @param reg_exp * @param reg_exp
*/ */
jasmine.Matchers.prototype.toMatch = jasmine.Matchers.matcherFn_('toMatch', { jasmine.Matchers.prototype.toMatch = jasmine.Matchers.matcherFn_('toMatch', {
test: function(actual, expected) { test: function(expected) {
return new RegExp(expected).test(actual); return new RegExp(expected).test(this.actual);
}, },
message: function(actual, expected) { message: function(expected) {
return jasmine.pp(actual) + " does not match the regular expression " + new RegExp(expected).toString(); return jasmine.pp(this.actual) + " does not match the regular expression " + new RegExp(expected).toString();
} }
}); });
@ -125,21 +124,21 @@ jasmine.Matchers.prototype.toMatch = jasmine.Matchers.matcherFn_('toMatch', {
*/ */
jasmine.Matchers.prototype.toNotMatch = jasmine.Matchers.matcherFn_('toNotMatch', { jasmine.Matchers.prototype.toNotMatch = jasmine.Matchers.matcherFn_('toNotMatch', {
test: function(actual, expected) { test: function(expected) {
return !(new RegExp(expected).test(actual)); return !(new RegExp(expected).test(this.actual));
}, },
message: function(actual, expected) { message: function(expected) {
return jasmine.pp(actual) + " should not match " + new RegExp(expected).toString(); return jasmine.pp(this.actual) + " should not match " + new RegExp(expected).toString();
} }
}); });
/** /**
* Matcher that compares the acutal to undefined. * Matcher that compares the actual to undefined.
*/ */
jasmine.Matchers.prototype.toBeDefined = jasmine.Matchers.matcherFn_('toBeDefined', { jasmine.Matchers.prototype.toBeDefined = jasmine.Matchers.matcherFn_('toBeDefined', {
test: function(actual) { test: function() {
return (actual !== undefined); return (this.actual !== undefined);
}, },
message: function() { message: function() {
return 'Expected actual to not be undefined.'; return 'Expected actual to not be undefined.';
@ -147,15 +146,15 @@ jasmine.Matchers.prototype.toBeDefined = jasmine.Matchers.matcherFn_('toBeDefine
}); });
/** /**
* Matcher that compares the acutal to undefined. * Matcher that compares the actual to undefined.
*/ */
jasmine.Matchers.prototype.toBeUndefined = jasmine.Matchers.matcherFn_('toBeUndefined', { jasmine.Matchers.prototype.toBeUndefined = jasmine.Matchers.matcherFn_('toBeUndefined', {
test: function(actual) { test: function() {
return (actual === undefined); return (this.actual === undefined);
}, },
message: function(actual) { message: function() {
return 'Expected ' + jasmine.pp(actual) + ' to be undefined.'; return 'Expected ' + jasmine.pp(this.actual) + ' to be undefined.';
} }
}); });
@ -164,11 +163,11 @@ jasmine.Matchers.prototype.toBeUndefined = jasmine.Matchers.matcherFn_('toBeUnde
* *
*/ */
jasmine.Matchers.prototype.toBeNull = jasmine.Matchers.matcherFn_('toBeNull', { jasmine.Matchers.prototype.toBeNull = jasmine.Matchers.matcherFn_('toBeNull', {
test: function(actual) { test: function() {
return (actual === null); return (this.actual === null);
}, },
message: function(actual) { message: function() {
return 'Expected ' + jasmine.pp(actual) + ' to be null.'; return 'Expected ' + jasmine.pp(this.actual) + ' to be null.';
} }
}); });
@ -176,8 +175,8 @@ jasmine.Matchers.prototype.toBeNull = jasmine.Matchers.matcherFn_('toBeNull', {
* Matcher that boolean not-nots the actual. * Matcher that boolean not-nots the actual.
*/ */
jasmine.Matchers.prototype.toBeTruthy = jasmine.Matchers.matcherFn_('toBeTruthy', { jasmine.Matchers.prototype.toBeTruthy = jasmine.Matchers.matcherFn_('toBeTruthy', {
test: function(actual) { test: function() {
return !!actual; return !!this.actual;
}, },
message: function() { message: function() {
return 'Expected actual to be truthy'; return 'Expected actual to be truthy';
@ -189,90 +188,70 @@ jasmine.Matchers.prototype.toBeTruthy = jasmine.Matchers.matcherFn_('toBeTruthy'
* Matcher that boolean nots the actual. * Matcher that boolean nots the actual.
*/ */
jasmine.Matchers.prototype.toBeFalsy = jasmine.Matchers.matcherFn_('toBeFalsy', { jasmine.Matchers.prototype.toBeFalsy = jasmine.Matchers.matcherFn_('toBeFalsy', {
test: function(actual) { test: function() {
return !actual; return !this.actual;
}, },
message: function(actual) { message: function() {
return 'Expected ' + jasmine.pp(actual) + ' to be falsy'; return 'Expected ' + jasmine.pp(this.actual) + ' to be falsy';
} }
}); });
/** /**
* Matcher that checks to see if the acutal, a Jasmine spy, was called. * Matcher that checks to see if the actual, a Jasmine spy, was called.
*/ */
jasmine.Matchers.prototype.wasCalled = jasmine.Matchers.matcherFn_('wasCalled', { jasmine.Matchers.prototype.wasCalled = jasmine.Matchers.matcherFn_('wasCalled', {
getActual_: function() {
var args = jasmine.util.argsToArray(arguments);
if (args.length > 1) {
throw(new Error('wasCalled does not take arguments, use wasCalledWith'));
}
return args.splice(0, 1)[0];
},
test: function() { test: function() {
var actual = this.getActual_.apply(this, arguments); if (arguments.length > 0) {
if (!actual || !actual.isSpy) { throw new Error('wasCalled does not take arguments, use wasCalledWith');
return false;
} }
return actual.wasCalled;
if (!jasmine.isSpy(this.actual)) {
throw new Error('Expected a spy, but got ' + jasmine.Matchers.pp(this.actual) + '.');
}
return this.actual.wasCalled;
}, },
message: function() { message: function() {
var actual = this.getActual_.apply(this, arguments); return "Expected spy " + this.actual.identity + " to have been called.";
if (!actual || !actual.isSpy) {
return 'Actual is not a spy.';
}
return "Expected spy " + actual.identity + " to have been called.";
} }
}); });
/** /**
* Matcher that checks to see if the acutal, a Jasmine spy, was not called. * Matcher that checks to see if the actual, a Jasmine spy, was not called.
*/ */
jasmine.Matchers.prototype.wasNotCalled = jasmine.Matchers.matcherFn_('wasNotCalled', { jasmine.Matchers.prototype.wasNotCalled = jasmine.Matchers.matcherFn_('wasNotCalled', {
getActual_: function() {
var args = jasmine.util.argsToArray(arguments);
return args.splice(0, 1)[0];
},
test: function() { test: function() {
var actual = this.getActual_.apply(this, arguments); if (arguments.length > 0) {
if (!actual || !actual.isSpy) { throw new Error('wasNotCalled does not take arguments');
return false;
} }
return !actual.wasCalled;
if (!jasmine.isSpy(this.actual)) {
throw new Error('Expected a spy, but got ' + jasmine.Matchers.pp(this.actual) + '.');
}
return !this.actual.wasCalled;
}, },
message: function() { message: function() {
var actual = this.getActual_.apply(this, arguments); return "Expected spy " + this.actual.identity + " to not have been called.";
if (!actual || !actual.isSpy) {
return 'Actual is not a spy.';
}
return "Expected spy " + actual.identity + " to not have been called.";
} }
}); });
jasmine.Matchers.prototype.wasCalledWith = jasmine.Matchers.matcherFn_('wasCalledWith', { jasmine.Matchers.prototype.wasCalledWith = jasmine.Matchers.matcherFn_('wasCalledWith', {
test: function() { test: function() {
var args = jasmine.util.argsToArray(arguments); if (!jasmine.isSpy(this.actual)) {
var actual = args.splice(0, 1)[0]; throw new Error('Expected a spy, but got ' + jasmine.Matchers.pp(this.actual) + '.');
if (!actual || !actual.isSpy) {
return false;
} }
return this.env.contains_(actual.argsForCall, args);
return this.env.contains_(this.actual.argsForCall, arguments);
}, },
message: function() { message: function() {
var args = jasmine.util.argsToArray(arguments); return "Expected spy to have been called with " + jasmine.pp(arguments) + " but was called with " + this.actual.argsForCall;
var actual = args.splice(0, 1)[0];
var message;
if (!actual || !actual.isSpy) {
message = 'Actual is not a spy';
} else {
message = "Expected spy to have been called with " + jasmine.pp(args) + " but was called with " + actual.argsForCall;
}
return message;
} }
}); });
/** /**
* Matcher that checks to see if the acutal, a Jasmine spy, was called with a set of parameters. * Matcher that checks to see if the actual, a Jasmine spy, was called with a set of parameters.
* *
* @example * @example
* *
@ -285,11 +264,11 @@ jasmine.Matchers.prototype.wasCalledWith = jasmine.Matchers.matcherFn_('wasCalle
*/ */
jasmine.Matchers.prototype.toContain = jasmine.Matchers.matcherFn_('toContain', { jasmine.Matchers.prototype.toContain = jasmine.Matchers.matcherFn_('toContain', {
test: function(actual, expected) { test: function(expected) {
return this.env.contains_(actual, expected); return this.env.contains_(this.actual, expected);
}, },
message: function(actual, expected) { message: function(expected) {
return 'Expected ' + jasmine.pp(actual) + ' to contain ' + jasmine.pp(expected); return 'Expected ' + jasmine.pp(this.actual) + ' to contain ' + jasmine.pp(expected);
} }
}); });
@ -299,29 +278,29 @@ jasmine.Matchers.prototype.toContain = jasmine.Matchers.matcherFn_('toContain',
* @param {Object} item * @param {Object} item
*/ */
jasmine.Matchers.prototype.toNotContain = jasmine.Matchers.matcherFn_('toNotContain', { jasmine.Matchers.prototype.toNotContain = jasmine.Matchers.matcherFn_('toNotContain', {
test: function(actual, expected) { test: function(expected) {
return !this.env.contains_(actual, expected); return !this.env.contains_(this.actual, expected);
}, },
message: function(actual, expected) { message: function(expected) {
return 'Expected ' + jasmine.pp(actual) + ' to not contain ' + jasmine.pp(expected); return 'Expected ' + jasmine.pp(this.actual) + ' to not contain ' + jasmine.pp(expected);
} }
}); });
jasmine.Matchers.prototype.toBeLessThan = jasmine.Matchers.matcherFn_('toBeLessThan', { jasmine.Matchers.prototype.toBeLessThan = jasmine.Matchers.matcherFn_('toBeLessThan', {
test: function(actual, expected) { test: function(expected) {
return actual < expected; return this.actual < expected;
}, },
message: function(actual, expected) { message: function(expected) {
return 'Expected ' + jasmine.pp(actual) + ' to be less than ' + jasmine.pp(expected); return 'Expected ' + jasmine.pp(this.actual) + ' to be less than ' + jasmine.pp(expected);
} }
}); });
jasmine.Matchers.prototype.toBeGreaterThan = jasmine.Matchers.matcherFn_('toBeGreaterThan', { jasmine.Matchers.prototype.toBeGreaterThan = jasmine.Matchers.matcherFn_('toBeGreaterThan', {
test: function(actual, expected) { test: function(expected) {
return actual > expected; return this.actual > expected;
}, },
message: function(actual, expected) { message: function(expected) {
return 'Expected ' + jasmine.pp(actual) + ' to be greater than ' + jasmine.pp(expected); return 'Expected ' + jasmine.pp(this.actual) + ' to be greater than ' + jasmine.pp(expected);
} }
}); });
@ -343,16 +322,16 @@ jasmine.Matchers.prototype.toThrow = jasmine.Matchers.matcherFn_('toThrow', {
} }
return exception; return exception;
}, },
test: function(actual, expected) { test: function(expected) {
var result = false; var result = false;
var exception = this.getException_(actual, expected); var exception = this.getException_(this.actual, expected);
if (exception) { if (exception) {
result = (expected === undefined || this.env.equals_(exception.message || exception, expected.message || expected)); result = (expected === undefined || this.env.equals_(exception.message || exception, expected.message || expected));
} }
return result; return result;
}, },
message: function(actual, expected) { message: function(expected) {
var exception = this.getException_(actual, expected); var exception = this.getException_(this.actual, expected);
if (exception && (expected === undefined || !this.env.equals_(exception.message || exception, expected.message || expected))) { if (exception && (expected === undefined || !this.env.equals_(exception.message || exception, expected.message || expected))) {
return ["Expected function to throw", expected.message || expected, ", but it threw", exception.message || exception ].join(' '); return ["Expected function to throw", expected.message || expected, ", but it threw", exception.message || exception ].join(' ');
} else { } else {

View File

@ -324,6 +324,16 @@ jasmine.createSpy = function(name) {
return spyObj; return spyObj;
}; };
/**
* Determines whether an object is a spy.
*
* @param {jasmine.Spy|Object} putativeSpy
* @returns {Boolean}
*/
jasmine.isSpy = function(putativeSpy) {
return putativeSpy && putativeSpy.isSpy;
};
/** /**
* Creates a more complicated spy: an Object that has every property a function that is a spy. Used for stubbing something * Creates a more complicated spy: an Object that has every property a function that is a spy. Used for stubbing something
* large in one call. * large in one call.