From 254ebb8a030d769da7fbf547f67b58126ae7d266 Mon Sep 17 00:00:00 2001 From: Christian Williams Date: Wed, 25 Aug 2010 13:37:05 -0700 Subject: [PATCH] Update jasmine.js. --- lib/jasmine.js | 89 +++++++++++++++++++++++++++++++++----------------- 1 file changed, 59 insertions(+), 30 deletions(-) diff --git a/lib/jasmine.js b/lib/jasmine.js index f72cb9c..9d61bf2 100644 --- a/lib/jasmine.js +++ b/lib/jasmine.js @@ -1135,7 +1135,7 @@ jasmine.Matchers.matcherFn_ = function(matcherName, matcherFunction) { message: message }); this.spec.addMatcherResult(expectationResult); - return result; + return jasmine.undefined; }; }; @@ -1153,6 +1153,7 @@ jasmine.Matchers.prototype.toBe = function(expected) { /** * toNotBe: compares the actual to the expected using !== * @param expected + * @deprecated as of 1.0. Use not.toBe() instead. */ jasmine.Matchers.prototype.toNotBe = function(expected) { return this.actual !== expected; @@ -1170,6 +1171,7 @@ jasmine.Matchers.prototype.toEqual = function(expected) { /** * toNotEqual: compares the actual to the expected using the ! of jasmine.Matchers.toEqual * @param expected + * @deprecated as of 1.0. Use not.toNotEqual() instead. */ jasmine.Matchers.prototype.toNotEqual = function(expected) { return !this.env.equals_(this.actual, expected); @@ -1188,6 +1190,7 @@ jasmine.Matchers.prototype.toMatch = function(expected) { /** * Matcher that compares the actual to the expected using the boolean inverse of jasmine.Matchers.toMatch * @param expected + * @deprecated as of 1.0. Use not.toMatch() instead. */ jasmine.Matchers.prototype.toNotMatch = function(expected) { return !(new RegExp(expected).test(this.actual)); @@ -1230,11 +1233,6 @@ jasmine.Matchers.prototype.toBeFalsy = function() { }; -/** @deprecated Use expect(xxx).toHaveBeenCalled() instead */ -jasmine.Matchers.prototype.wasCalled = function() { - return this.toHaveBeenCalled(); -}; - /** * Matcher that checks to see if the actual, a Jasmine spy, was called. */ @@ -1248,12 +1246,18 @@ jasmine.Matchers.prototype.toHaveBeenCalled = function() { } this.message = function() { - return "Expected spy " + this.actual.identity + " to have been called."; + return [ + "Expected spy " + this.actual.identity + " to have been called.", + "Expected spy " + this.actual.identity + " not to have been called." + ]; }; return this.actual.wasCalled; }; +/** @deprecated Use expect(xxx).toHaveBeenCalled() instead */ +jasmine.Matchers.prototype.wasCalled = jasmine.Matchers.prototype.toHaveBeenCalled; + /** * Matcher that checks to see if the actual, a Jasmine spy, was not called. * @@ -1269,17 +1273,15 @@ jasmine.Matchers.prototype.wasNotCalled = function() { } this.message = function() { - return "Expected spy " + this.actual.identity + " to not have been called."; + return [ + "Expected spy " + this.actual.identity + " to not have been called.", + "Expected spy " + this.actual.identity + " to have been called." + ]; }; return !this.actual.wasCalled; }; -/** @deprecated Use expect(xxx).toHaveBeenCalledWith() instead */ -jasmine.Matchers.prototype.wasCalledWith = function() { - return this.toHaveBeenCalledWith.apply(this, arguments); -}; - /** * Matcher that checks to see if the actual, a Jasmine spy, was called with a set of parameters. * @@ -1293,15 +1295,25 @@ jasmine.Matchers.prototype.toHaveBeenCalledWith = function() { } this.message = function() { if (this.actual.callCount == 0) { - return "Expected spy to have been called with " + jasmine.pp(expectedArgs) + " but it was never called."; + // todo: what should the failure message for .not.toHaveBeenCalledWith() be? is this right? test better. [xw] + return [ + "Expected spy to have been called with " + jasmine.pp(expectedArgs) + " but it was never called.", + "Expected spy not to have been called with " + jasmine.pp(expectedArgs) + " but it was." + ]; } else { - return "Expected spy to have been called with " + jasmine.pp(expectedArgs) + " but was called with " + jasmine.pp(this.actual.argsForCall); + return [ + "Expected spy to have been called with " + jasmine.pp(expectedArgs) + " but was called with " + jasmine.pp(this.actual.argsForCall), + "Expected spy not to have been called with " + jasmine.pp(expectedArgs) + " but was called with " + jasmine.pp(this.actual.argsForCall) + ]; } }; return this.env.contains_(this.actual.argsForCall, expectedArgs); }; +/** @deprecated Use expect(xxx).toHaveBeenCalledWith() instead */ +jasmine.Matchers.prototype.wasCalledWith = jasmine.Matchers.prototype.toHaveBeenCalledWith; + /** @deprecated Use expect(xxx).not.toHaveBeenCalledWith() instead */ jasmine.Matchers.prototype.wasNotCalledWith = function() { var expectedArgs = jasmine.util.argsToArray(arguments); @@ -1310,7 +1322,10 @@ jasmine.Matchers.prototype.wasNotCalledWith = function() { } this.message = function() { - return "Expected spy not to have been called with " + jasmine.pp(expectedArgs) + " but it was"; + return [ + "Expected spy not to have been called with " + jasmine.pp(expectedArgs) + " but it was", + "Expected spy to have been called with " + jasmine.pp(expectedArgs) + " but it was" + ] }; return !this.env.contains_(this.actual.argsForCall, expectedArgs); @@ -1329,6 +1344,7 @@ jasmine.Matchers.prototype.toContain = function(expected) { * Matcher that checks that the expected item is NOT an element in the actual Array. * * @param {Object} expected + * @deprecated as of 1.0. Use not.toNotContain() instead. */ jasmine.Matchers.prototype.toNotContain = function(expected) { return !this.env.contains_(this.actual, expected); @@ -1364,7 +1380,7 @@ jasmine.Matchers.prototype.toThrow = function(expected) { this.message = function() { if (exception && (expected === jasmine.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 ? expected.message || expected : " an exception", ", but it threw", exception.message || exception].join(' '); } else { return "Expected function to throw an exception."; } @@ -2114,6 +2130,17 @@ jasmine.WaitsBlock.prototype.execute = function (onComplete) { onComplete(); }, this.timeout); }; +/** + * A block which waits for some condition to become true, with timeout. + * + * @constructor + * @extends jasmine.Block + * @param {jasmine.Env} env The Jasmine environment. + * @param {Number} timeout The maximum time in milliseconds to wait for the condition to become true. + * @param {Function} latchFunction A function which returns true when the desired condition has been met. + * @param {String} message The message to display if the desired condition hasn't been met within the given time period. + * @param {jasmine.Spec} spec The Jasmine spec. + */ jasmine.WaitsForBlock = function(env, timeout, latchFunction, message, spec) { this.timeout = timeout; this.latchFunction = latchFunction; @@ -2121,34 +2148,36 @@ jasmine.WaitsForBlock = function(env, timeout, latchFunction, message, spec) { this.totalTimeSpentWaitingForLatch = 0; jasmine.Block.call(this, env, null, spec); }; - jasmine.util.inherit(jasmine.WaitsForBlock, jasmine.Block); -jasmine.WaitsForBlock.TIMEOUT_INCREMENT = 100; +jasmine.WaitsForBlock.TIMEOUT_INCREMENT = 10; -jasmine.WaitsForBlock.prototype.execute = function (onComplete) { - var self = this; - self.env.reporter.log('>> Jasmine waiting for ' + (self.message || 'something to happen')); +jasmine.WaitsForBlock.prototype.execute = function(onComplete) { + this.env.reporter.log('>> Jasmine waiting for ' + (this.message || 'something to happen')); var latchFunctionResult; try { - latchFunctionResult = self.latchFunction.apply(self.spec); + latchFunctionResult = this.latchFunction.apply(this.spec); } catch (e) { - self.spec.fail(e); + this.spec.fail(e); onComplete(); return; } if (latchFunctionResult) { onComplete(); - } else if (self.totalTimeSpentWaitingForLatch >= self.timeout) { - var message = 'timed out after ' + self.timeout + ' msec waiting for ' + (self.message || 'something to happen'); - self.spec.fail({ + } else if (this.totalTimeSpentWaitingForLatch >= this.timeout) { + var message = 'timed out after ' + this.timeout + ' msec waiting for ' + (this.message || 'something to happen'); + this.spec.fail({ name: 'timeout', message: message }); + // todo: need to prevent additional blocks in this spec from running... [xw 20100819] } else { - self.totalTimeSpentWaitingForLatch += jasmine.WaitsForBlock.TIMEOUT_INCREMENT; - self.env.setTimeout(function () { self.execute(onComplete); }, jasmine.WaitsForBlock.TIMEOUT_INCREMENT); + this.totalTimeSpentWaitingForLatch += jasmine.WaitsForBlock.TIMEOUT_INCREMENT; + var self = this; + this.env.setTimeout(function() { + self.execute(onComplete); + }, jasmine.WaitsForBlock.TIMEOUT_INCREMENT); } }; // Mock setTimeout, clearTimeout @@ -2339,5 +2368,5 @@ jasmine.version_= { "major": 0, "minor": 11, "build": 1, - "revision": 1277514571 + "revision": 1282768601 };