evergreen 0.3.0 → 0.4.0

data/lib/jasmine/spec/suites/SpecRunningSpec.js

@@ -258,86 +258,146 @@ describe("jasmine spec running", function () {
     expect(another_spec.results().getItems()[0].passed()).toEqual(true);
   });
 
-  it("testWaitsFor", function() {
-    var doneWaiting = false;
-    var runsBlockExecuted = false;
-
+  describe("waitsFor", function() {
+    var latchFunction = function() {
+      return true;
+    };
     var spec;
-    env.describe('foo', function() {
-      spec = env.it('has a waits for', function() {
-        this.runs(function() {
-        });
 
-        this.waitsFor(500, function() {
-          return doneWaiting;
-        });
-
-        this.runs(function() {
-          runsBlockExecuted = true;
+    function makeWaitsForSpec() {
+      var args = jasmine.util.argsToArray(arguments);
+      env.describe('suite', function() {
+        spec = env.it('spec', function() {
+          this.waitsFor.apply(this, args);
         });
       });
+      env.execute();
+    }
+
+    it("should accept args (latchFunction, timeoutMessage, timeout)", function() {
+      makeWaitsForSpec(latchFunction, "message", 123);
+      var block = spec.queue.blocks[1];
+      expect(block.latchFunction).toBe(latchFunction);
+      expect(block.timeout).toEqual(123);
+      expect(block.message).toEqual('message');
     });
 
-    spec.execute();
-    expect(runsBlockExecuted).toEqual(false); //, 'should not have executed runs block yet');
-    fakeTimer.tick(100);
-    doneWaiting = true;
-    fakeTimer.tick(100);
-    expect(runsBlockExecuted).toEqual(true); //, 'should have executed runs block');
-  });
+    it("should accept args (latchFunction, timeout)", function() {
+      makeWaitsForSpec(latchFunction, 123);
+      var block = spec.queue.blocks[1];
+      expect(block.latchFunction).toBe(latchFunction);
+      expect(block.timeout).toEqual(123);
+      expect(block.message).toEqual(null);
+    });
 
-  it("testWaitsForFailsWithMessage", function() {
-    var spec;
-    env.describe('foo', function() {
-      spec = env.it('has a waits for', function() {
-        this.runs(function() {
-        });
+    it("should accept args (latchFunction, timeoutMessage)", function() {
+      env.defaultTimeoutInterval = 4321;
+      makeWaitsForSpec(latchFunction, "message");
+      var block = spec.queue.blocks[1];
+      expect(block.latchFunction).toBe(latchFunction);
+      expect(block.timeout).toEqual(4321);
+      expect(block.message).toEqual('message');
+    });
 
-        this.waitsFor(500, function() {
-          return false; // force a timeout
-        }, 'my awesome condition');
+    it("should accept args (latchFunction)", function() {
+      env.defaultTimeoutInterval = 4321;
+      makeWaitsForSpec(latchFunction);
+      var block = spec.queue.blocks[1];
+      expect(block.latchFunction).toBe(latchFunction);
+      expect(block.timeout).toEqual(4321);
+      expect(block.message).toEqual(null);
+    });
 
-        this.runs(function() {
+    it("should accept deprecated args order (timeout, latchFunction, timeoutMessage)", function() {
+      makeWaitsForSpec(123, latchFunction, "message");
+      var block = spec.queue.blocks[1];
+      expect(block.latchFunction).toBe(latchFunction);
+      expect(block.timeout).toEqual(123);
+      expect(block.message).toEqual('message');
+    });
+
+    it("testWaitsFor", function() {
+      var doneWaiting = false;
+      var runsBlockExecuted = false;
+
+      var spec;
+      env.describe('foo', function() {
+        spec = env.it('has a waits for', function() {
+          this.runs(function() {
+          });
+
+          this.waitsFor(500, function() {
+            return doneWaiting;
+          });
+
+          this.runs(function() {
+            runsBlockExecuted = true;
+          });
         });
       });
+
+      spec.execute();
+      expect(runsBlockExecuted).toEqual(false); //, 'should not have executed runs block yet');
+      fakeTimer.tick(100);
+      doneWaiting = true;
+      fakeTimer.tick(100);
+      expect(runsBlockExecuted).toEqual(true); //, 'should have executed runs block');
     });
 
-    spec.execute();
-    fakeTimer.tick(1000);
-    var actual = spec.results().getItems()[0].message;
-    var expected = 'timeout: timed out after 500 msec waiting for my awesome condition';
-    expect(actual).toEqual(expected);
-  });
+    it("fails with message", function() {
+      var spec;
+      env.describe('foo', function() {
+        spec = env.it('has a waits for', function() {
+          this.runs(function() {
+          });
 
-  it("waitsFor fails and skips the rest of the spec if timeout is reached and the latch function is still false", function() {
-    var runsBlockExecuted = false;
+          this.waitsFor(500, function() {
+            return false; // force a timeout
+          }, 'my awesome condition');
 
-    var spec;
-    env.describe('foo', function() {
-      spec = env.it('has a waits for', function() {
-        this.runs(function() {
+          this.runs(function() {
+          });
         });
+      });
+
+      spec.execute();
+      fakeTimer.tick(1000);
+      expect(spec.results().getItems()[0].message).toEqual('timeout: timed out after 500 msec waiting for my awesome condition');
+    });
+
+    it("fails and skips the rest of the spec if timeout is reached and the latch function hasn't returned true", function() {
+      var runsBlockExecuted = false;
+      var subsequentSpecRan = false;
+
+      var timeoutSpec, subsequentSpec;
+      var suite = env.describe('foo', function() {
+        timeoutSpec = env.it('has a waits for', function() {
+          this.runs(function() {
+          });
+
+          this.waitsFor(500, function() {
+            return false;
+          });
 
-        this.waitsFor(500, function() {
-          return false;
+          this.runs(function() {
+            runsBlockExecuted = true;
+          });
         });
 
-        this.runs(function() {
-          runsBlockExecuted = true;
+        subsequentSpec = env.it('then carries on to the next test', function() {
+          subsequentSpecRan = true;
         });
       });
-    });
 
-    spec.execute();
-    expect(runsBlockExecuted).toEqual(false);
-    fakeTimer.tick(100);
-    expect(runsBlockExecuted).toEqual(false);
-    fakeTimer.tick(400);
-    expect(runsBlockExecuted).toEqual(false);
-    var actual = spec.results().getItems()[0].message;
-    var expected = 'timeout: timed out after 500 msec waiting for something to happen';
-    expect(actual).toEqual(expected,
-      'expected "' + expected + '" but found "' + actual + '"');
+      env.execute();
+      expect(runsBlockExecuted).toEqual(false);
+      fakeTimer.tick(100);
+      expect(runsBlockExecuted).toEqual(false);
+      fakeTimer.tick(400);
+      expect(runsBlockExecuted).toEqual(false);
+      expect(timeoutSpec.results().getItems()[0].message).toEqual('timeout: timed out after 500 msec waiting for something to happen');
+      expect(subsequentSpecRan).toEqual(true);
+    });
   });
 
   it("testSpecAfter", function() {
@@ -520,17 +580,15 @@ describe("jasmine spec running", function () {
   });
 
   describe('#waitsFor should allow consecutive calls', function () {
-
     var foo;
     beforeEach(function () {
-
       foo = 0;
     });
 
     it('exits immediately (does not stack) if the latchFunction times out', function () {
       var reachedFirstWaitsFor = false;
       var reachedSecondWaitsFor = false;
-      var waitsSuite = env.describe('suite that waits', function () {
+      env.describe('suite that waits', function () {
         env.it('should stack timeouts', function() {
           this.waitsFor(500, function () {
             reachedFirstWaitsFor = true;
@@ -546,7 +604,7 @@ describe("jasmine spec running", function () {
       });
 
       expect(reachedFirstWaitsFor).toEqual(false);
-      waitsSuite.execute();
+      env.execute();
 
       expect(reachedFirstWaitsFor).toEqual(true);
       expect(foo).toEqual(0);

data/lib/jasmine/spec/suites/TrivialReporterSpec.js

@@ -172,6 +172,9 @@ describe("TrivialReporter", function() {
       var errorDiv = findElement(divs, 'resultMessage log');
       expect(errorDiv.innerHTML).toEqual("this is a multipart log message");
     });
+
+    xit("should work on IE without console.log.apply", function() {
+    });
   });
 
   describe("duplicate example names", function() {

data/lib/jasmine/spec/suites/WaitsForBlockSpec.js

@@ -15,7 +15,7 @@ describe('WaitsForBlock', function () {
       return true;
     };
     var block = new jasmine.WaitsForBlock(env, timeout, latchFunction, message, spec);
-    expect(onComplete).wasNotCalled();
+    expect(onComplete).not.toHaveBeenCalled();
     block.execute(onComplete);
     expect(onComplete).toHaveBeenCalled();
   });
@@ -51,22 +51,22 @@ describe('WaitsForBlock', function () {
       env.clearInterval = fakeTimer.clearInterval;
     });
 
-    it('latchFunction should be retried after 100 ms', function () {
+    it('latchFunction should be retried after 10 ms', function () {
       var block = new jasmine.WaitsForBlock(env, timeout, latchFunction, message, spec);
-      expect(latchFunction).wasNotCalled();
+      expect(latchFunction).not.toHaveBeenCalled();
       block.execute(onComplete);
       expect(latchFunction.callCount).toEqual(1);
-      fakeTimer.tick(50);
+      fakeTimer.tick(5);
       expect(latchFunction.callCount).toEqual(1);
-      fakeTimer.tick(50);
+      fakeTimer.tick(5);
       expect(latchFunction.callCount).toEqual(2);
     });
 
     it('onComplete should be called if latchFunction returns true before timeout', function () {
       var block = new jasmine.WaitsForBlock(env, timeout, latchFunction, message, spec);
-      expect(onComplete).wasNotCalled();
+      expect(onComplete).not.toHaveBeenCalled();
       block.execute(onComplete);
-      expect(onComplete).wasNotCalled();
+      expect(onComplete).not.toHaveBeenCalled();
       latchFunction.andReturn(true);
       fakeTimer.tick(100);
       expect(onComplete).toHaveBeenCalled();
@@ -76,12 +76,12 @@ describe('WaitsForBlock', function () {
       spyOn(spec, 'fail');
       var block = new jasmine.WaitsForBlock(env, timeout, latchFunction, message, spec);
       block.execute(onComplete);
-      expect(spec.fail).wasNotCalled();
+      expect(spec.fail).not.toHaveBeenCalled();
       fakeTimer.tick(timeout);
       expect(spec.fail).toHaveBeenCalled();
       var failMessage = spec.fail.mostRecentCall.args[0].message;
       expect(failMessage).toMatch(message);
-      expect(onComplete).wasNotCalled();
+      expect(onComplete).toHaveBeenCalled();
     });
   });
 });

data/lib/jasmine/src/Env.js

@@ -11,6 +11,7 @@ jasmine.Env = function() {
   this.reporter = new jasmine.MultiReporter();
 
   this.updateInterval = jasmine.DEFAULT_UPDATE_INTERVAL;
+  this.defaultTimeoutInterval = jasmine.DEFAULT_TIMEOUT_INTERVAL;
   this.lastUpdate = 0;
   this.specFilter = function() {
     return true;

data/lib/jasmine/src/Matchers.js

@@ -68,7 +68,7 @@ jasmine.Matchers.matcherFn_ = function(matcherName, matcherFunction) {
       message: message
     });
     this.spec.addMatcherResult(expectationResult);
-    return result;
+    return jasmine.undefined;
   };
 };
 
@@ -86,6 +86,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;
@@ -103,6 +104,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);
@@ -121,6 +123,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));
@@ -163,11 +166,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.
  */
@@ -181,12 +179,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.
  *
@@ -202,17 +206,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.
  *
@@ -226,15 +228,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);
@@ -243,7 +255,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);
@@ -262,6 +277,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);
@@ -295,9 +311,11 @@ jasmine.Matchers.prototype.toThrow = function(expected) {
     result = (expected === jasmine.undefined || this.env.equals_(exception.message || exception, expected.message || expected));
   }
 
+  var not = this.isNot ? "not " : "";
+
   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 " + not + "to throw", expected ? expected.message || expected : " an exception", ", but it threw", exception.message || exception].join(' ');
     } else {
       return "Expected function to throw an exception.";
     }

data/lib/jasmine/src/Queue.js

@@ -4,6 +4,7 @@ jasmine.Queue = function(env) {
   this.running = false;
   this.index = 0;
   this.offset = 0;
+  this.abort = false;
 };
 
 jasmine.Queue.prototype.addBefore = function(block) {
@@ -38,7 +39,7 @@ jasmine.Queue.prototype.next_ = function() {
   while (goAgain) {
     goAgain = false;
     
-    if (self.index < self.blocks.length) {
+    if (self.index < self.blocks.length && !this.abort) {
       var calledSynchronously = true;
       var completedSynchronously = false;
 
@@ -48,6 +49,10 @@ jasmine.Queue.prototype.next_ = function() {
           return;
         }
 
+        if (self.blocks[self.index].abort) {
+          self.abort = true;
+        }
+
         self.offset = 0;
         self.index++;