jasmine-core 2.0.0.rc2 → 2.0.0.rc3

data/lib/jasmine-core/spec/core/EnvSpec.js

@@ -8,9 +8,9 @@ describe("Env", function() {
 
   describe('ids', function() {
     it('nextSpecId should return consecutive integers, starting at 0', function() {
-      expect(env.nextSpecId()).toEqual(0);
-      expect(env.nextSpecId()).toEqual(1);
-      expect(env.nextSpecId()).toEqual(2);
+      expect(env.nextSpecId()).toEqual('spec0');
+      expect(env.nextSpecId()).toEqual('spec1');
+      expect(env.nextSpecId()).toEqual('spec2');
     });
   });
 
@@ -27,7 +27,7 @@ describe("Env", function() {
       expect(fakeReporter.jasmineStarted).toHaveBeenCalled();
     });
   });
-  
+
   it('removes all spies when env is executed', function(done) {
     originalFoo = function() {},
     testObj = {
@@ -85,11 +85,11 @@ describe("Env", function() {
       var subject = { spiedFunc: function() { originalFunctionWasCalled = true; } };
 
       originalFunc = subject.spiedFunc;
-      
+
       var spy = env.spyOn(subject, 'spiedFunc');
 
       expect(subject.spiedFunc).toEqual(spy);
-      
+
       expect(subject.spiedFunc.calls.any()).toEqual(false);
       expect(subject.spiedFunc.calls.count()).toEqual(0);
 
@@ -236,6 +236,106 @@ describe("Env integration", function() {
     env.execute();
   });
 
+  it("calls associated befores/specs/afters with the same 'this'", function(done) {
+    var env = new j$.Env();
+
+    env.addReporter({jasmineDone: done});
+
+    env.describe("tests", function() {
+      var firstTimeThrough = true, firstSpecContext, secondSpecContext;
+
+      env.beforeEach(function() {
+        if (firstTimeThrough) {
+          firstSpecContext = this;
+        } else {
+          secondSpecContext = this;
+        }
+        expect(this).toEqual({});
+      });
+
+      env.it("sync spec", function() {
+        expect(this).toBe(firstSpecContext);
+      });
+
+      env.it("another sync spec", function() {
+        expect(this).toBe(secondSpecContext);
+      });
+
+      env.afterEach(function() {
+        if (firstTimeThrough) {
+          expect(this).toBe(firstSpecContext);
+          firstTimeThrough = false;
+        } else {
+          expect(this).toBe(secondSpecContext);
+        }
+      });
+    });
+
+    env.execute();
+  });
+
+  it("calls associated befores/its/afters with the same 'this' for an async spec", function(done) {
+    var env = new j$.Env();
+
+    env.addReporter({jasmineDone: done});
+
+    env.describe("with an async spec", function() {
+      var specContext;
+
+      env.beforeEach(function() {
+        specContext = this;
+        expect(this).toEqual({});
+      });
+
+      env.it("sync spec", function(underTestCallback) {
+        expect(this).toBe(specContext);
+        underTestCallback();
+      });
+
+      env.afterEach(function() {
+        expect(this).toBe(specContext);
+      });
+    });
+
+    env.execute();
+  });
+
+  it("Allows specifying which specs and suites to run", function(done) {
+    var env = new j$.Env(),
+        calls = [],
+        suiteCallback = jasmine.createSpy('suite callback'),
+        firstSpec,
+        secondSuite;
+
+    var assertions = function() {
+      expect(calls).toEqual([
+        'third spec',
+        'first spec'
+      ]);
+      expect(suiteCallback).toHaveBeenCalled();
+      done();
+    };
+
+    env.addReporter({jasmineDone: assertions, suiteDone: suiteCallback});
+
+    env.describe("first suite", function() {
+      firstSpec = env.it("first spec", function() {
+        calls.push('first spec');
+      });
+      env.it("second spec", function() {
+        calls.push('second spec');
+      });
+    });
+
+    secondSuite = env.describe("second suite", function() {
+      env.it("third spec", function() {
+        calls.push('third spec');
+      });
+    });
+
+    env.execute([secondSuite.id, firstSpec.id]);
+  });
+
   it("Mock clock can be installed and used in tests", function(done) {
     var globalSetTimeout = jasmine.createSpy('globalSetTimeout'),
         delayedFunctionForGlobalClock = jasmine.createSpy('delayedFunctionForGlobalClock'),
@@ -293,52 +393,37 @@ describe("Env integration", function() {
   });
 
   describe("with a mock clock", function() {
-      beforeEach(function() {
-          jasmine.getEnv().clock.install();
-      });
-
-      afterEach(function() {
-          jasmine.getEnv().clock.uninstall();
-      });
-
-      it("should not hang on async specs that forget to call done()", function(done) {
-          var env = new j$.Env(),
-          reporter = jasmine.createSpyObj('fakeReporter', [
-              "jasmineStarted",
-              "jasmineDone",
-              "suiteStarted",
-              "suiteDone",
-              "specStarted",
-              "specDone"
-              ]);
-
-          env.addReporter(reporter);
-
-          env.describe("tests", function() {
-              env.it("async spec that will hang", function(underTestCallback) {
-                  env.expect(true).toBeTruthy();
-              });
+    var originalTimeout;
 
-              env.it("after async spec", function() {
-                  env.expect(true).toBeTruthy();
-              });
-          });
+    beforeEach(function() {
+      originalTimeout = j$.DEFAULT_TIMEOUT_INTERVAL;
+      jasmine.getEnv().clock.install();
+    });
 
-          env.execute();
+    afterEach(function() {
+      jasmine.getEnv().clock.uninstall();
+      j$.DEFAULT_TIMEOUT_INTERVAL = originalTimeout;
+    });
 
-          reporter.jasmineDone.and.callFake(function() {
-              expect(reporter.jasmineStarted).toHaveBeenCalledWith({
-                  totalSpecsDefined: 2
-              });
+    it("should wait a specified interval before failing specs haven't called done yet", function(done) {
+      var env = new j$.Env(),
+          reporter = jasmine.createSpyObj('fakeReporter', [ "specDone" ]);
 
-              expect(reporter.specDone).toHaveBeenCalledWith(jasmine.objectContaining({status: 'passed'}));
-              expect(reporter.specDone).toHaveBeenCalledWith(jasmine.objectContaining({status: 'failed'}));
+      reporter.specDone.and.callFake(function() {
+        expect(reporter.specDone).toHaveBeenCalledWith(jasmine.objectContaining({status: 'failed'}));
+        done();
+      });
 
-              done();
-          });
+      env.addReporter(reporter);
+      j$.DEFAULT_TIMEOUT_INTERVAL = 8414;
 
-          jasmine.getEnv().clock.tick(60001);
+      env.it("async spec that doesn't call done", function(underTestCallback) {
+        env.expect(true).toBeTruthy();
+        jasmine.getEnv().clock.tick(8414);
       });
+
+      env.execute();
+    });
   });
 
   // TODO: something is wrong with this spec
@@ -400,9 +485,9 @@ describe("Env integration", function() {
       });
     });
 
-    expect(topLevelSpec.getFullName()).toBe("my tests are sometimes top level.");
-    expect(nestedSpec.getFullName()).toBe("my tests are sometimes singly nested.");
-    expect(doublyNestedSpec.getFullName()).toBe("my tests are sometimes even doubly nested.");
+    expect(topLevelSpec.getFullName()).toBe("my tests are sometimes top level");
+    expect(nestedSpec.getFullName()).toBe("my tests are sometimes singly nested");
+    expect(doublyNestedSpec.getFullName()).toBe("my tests are sometimes even doubly nested");
   });
 
   it("Custom equality testers should be per spec", function(done) {

data/lib/jasmine-core/spec/core/ExceptionsSpec.js

@@ -1,4 +1,4 @@
-xdescribe('Exceptions:', function() {
+describe('Exceptions:', function() {
   var env;
 
   beforeEach(function() {

data/lib/jasmine-core/spec/core/ExpectationResultSpec.js

@@ -16,7 +16,7 @@ describe("buildExpectationResult", function() {
 
   it("delegates message formatting to the provided formatter if there was an Error", function() {
     var fakeError = {message: 'foo'},
-      messageFormatter = jasmine.createSpy("exception message formatter").and.callReturn(fakeError.message);
+      messageFormatter = jasmine.createSpy("exception message formatter").and.returnValue(fakeError.message);
 
     var result = j$.buildExpectationResult(
       {
@@ -31,7 +31,7 @@ describe("buildExpectationResult", function() {
 
   it("delegates stack formatting to the provided formatter if there was an Error", function() {
     var fakeError = {stack: 'foo'},
-      stackFormatter = jasmine.createSpy("stack formatter").and.callReturn(fakeError.stack);
+      stackFormatter = jasmine.createSpy("stack formatter").and.returnValue(fakeError.stack);
 
     var result = j$.buildExpectationResult(
       {

data/lib/jasmine-core/spec/core/ExpectationSpec.js

@@ -56,7 +56,7 @@ describe("Expectation", function() {
 
   it("wraps matchers's compare functions, passing in matcher dependencies", function() {
     var fakeCompare = function() { return { pass: true }; },
-      matcherFactory = jasmine.createSpy("matcher").and.callReturn({ compare: fakeCompare }),
+      matcherFactory = jasmine.createSpy("matcher").and.returnValue({ compare: fakeCompare }),
       matchers = {
         toFoo: matcherFactory
       },
@@ -80,7 +80,7 @@ describe("Expectation", function() {
   });
 
   it("wraps matchers's compare functions, passing the actual and expected", function() {
-    var fakeCompare = jasmine.createSpy('fake-compare').and.callReturn({pass: true}),
+    var fakeCompare = jasmine.createSpy('fake-compare').and.returnValue({pass: true}),
       matchers = {
         toFoo: function() {
           return {

data/lib/jasmine-core/spec/core/JsApiReporterSpec.js

@@ -196,7 +196,7 @@ describe("JsApiReporter", function() {
             timer: timerSpy
           });
 
-      timerSpy.elapsed.and.callReturn(1000);
+      timerSpy.elapsed.and.returnValue(1000);
       reporter.jasmineDone();
       expect(reporter.executionTime()).toEqual(1000);
     });

data/lib/jasmine-core/spec/core/QueueRunnerSpec.js

@@ -19,6 +19,23 @@ describe("QueueRunner", function() {
     expect(calls).toEqual(['fn1', 'fn2']);
   });
 
+  it("calls each function with a consistent 'this'-- an empty object", function() {
+    var fn1 = jasmine.createSpy('fn1'),
+        fn2 = jasmine.createSpy('fn2'),
+        fn3 = function(done) { asyncContext = this; done(); },
+        queueRunner = new j$.QueueRunner({
+          fns: [fn1, fn2, fn3]
+        }),
+        asyncContext;
+
+    queueRunner.execute();
+
+    var context = fn1.calls.first().object;
+    expect(context).toEqual({});
+    expect(fn2.calls.first().object).toBe(context);
+    expect(asyncContext).toBe(context);
+  });
+
   it("supports asynchronous functions, only advancing to next function after a done() callback", function() {
     //TODO: it would be nice if spy arity could match the fake, so we could do something like:
     //createSpy('asyncfn').and.callFake(function(done) {});

data/lib/jasmine-core/spec/core/SpecRunningSpec.js

@@ -25,11 +25,11 @@ describe("jasmine spec running", function () {
       });
     });
 
-    expect(it0.id).toEqual(0);
-    expect(it1.id).toEqual(1);
-    expect(it2.id).toEqual(2);
-    expect(it3.id).toEqual(3);
-    expect(it4.id).toEqual(4);
+    expect(it0.id).toEqual('spec0');
+    expect(it1.id).toEqual('spec1');
+    expect(it2.id).toEqual('spec2');
+    expect(it3.id).toEqual('spec3');
+    expect(it4.id).toEqual('spec4');
   });
 
   it('nested suites', function (done) {
@@ -305,4 +305,4 @@ describe("jasmine spec running", function () {
     ));
 
   });
-});
+});

data/lib/jasmine-core/spec/core/SpecSpec.js

@@ -36,7 +36,6 @@ describe("Spec", function() {
 
   it("should call the start callback on execution", function() {
     var fakeQueueRunner = jasmine.createSpy('fakeQueueRunner'),
-      beforesWereCalled = false,
       startCallback = jasmine.createSpy('startCallback'),
       spec = new j$.Spec({
         id: 123,
@@ -48,7 +47,12 @@ describe("Spec", function() {
 
     spec.execute();
 
-    expect(startCallback).toHaveBeenCalledWith(spec);
+    // TODO: due to some issue with the Pretty Printer, this line fails, but the other two pass.
+    // This means toHaveBeenCalledWith on IE8 will always be broken.
+
+    //   expect(startCallback).toHaveBeenCalledWith(spec);
+    expect(startCallback).toHaveBeenCalled();
+    expect(startCallback.calls.first().object).toEqual(spec);
   });
 
   it("should call the start callback on execution but before any befores are called", function() {

data/lib/jasmine-core/spec/core/SpyStrategySpec.js

@@ -22,7 +22,7 @@ describe("SpyStrategy", function() {
   });
 
   it("allows an original function to be called, passed through the params and returns it's value", function() {
-    var originalFn = jasmine.createSpy("original").and.callReturn(42),
+    var originalFn = jasmine.createSpy("original").and.returnValue(42),
         spyStrategy = new j$.SpyStrategy({fn: originalFn}),
         returnValue;
 
@@ -39,7 +39,7 @@ describe("SpyStrategy", function() {
         spyStrategy = new j$.SpyStrategy({fn: originalFn}),
         returnValue;
 
-    spyStrategy.callReturn(17);
+    spyStrategy.returnValue(17);
     returnValue = spyStrategy.exec();
 
     expect(originalFn).not.toHaveBeenCalled();
@@ -50,15 +50,25 @@ describe("SpyStrategy", function() {
     var originalFn = jasmine.createSpy("original"),
         spyStrategy = new j$.SpyStrategy({fn: originalFn});
 
-    spyStrategy.callThrow("bar");
+    spyStrategy.throwError(new TypeError("bar"));
 
-    expect(function() { spyStrategy.exec(); }).toThrow("bar");
+    expect(function() { spyStrategy.exec(); }).toThrowError(TypeError, "bar");
+    expect(originalFn).not.toHaveBeenCalled();
+  });
+
+  it("allows a non-Error to be thrown, wrapping it into an exception when executed", function() {
+    var originalFn = jasmine.createSpy("original"),
+        spyStrategy = new j$.SpyStrategy({fn: originalFn});
+
+    spyStrategy.throwError("bar");
+
+    expect(function() { spyStrategy.exec(); }).toThrowError(Error, "bar");
     expect(originalFn).not.toHaveBeenCalled();
   });
 
   it("allows a fake function to be called instead", function() {
     var originalFn = jasmine.createSpy("original"),
-        fakeFn = jasmine.createSpy("fake").and.callReturn(67),
+        fakeFn = jasmine.createSpy("fake").and.returnValue(67),
         spyStrategy = new j$.SpyStrategy({fn: originalFn}),
         returnValue;
 
@@ -71,7 +81,7 @@ describe("SpyStrategy", function() {
 
   it("allows a return to plan stubbing after another strategy", function() {
     var originalFn = jasmine.createSpy("original"),
-        fakeFn = jasmine.createSpy("fake").and.callReturn(67),
+        fakeFn = jasmine.createSpy("fake").and.returnValue(67),
         spyStrategy = new j$.SpyStrategy({fn: originalFn}),
         returnValue;
 
@@ -89,12 +99,12 @@ describe("SpyStrategy", function() {
 
   it("returns the spy after changing the strategy", function(){
     var spy = {},
-        spyFn = jasmine.createSpy('spyFn').and.callReturn(spy),
+        spyFn = jasmine.createSpy('spyFn').and.returnValue(spy),
         spyStrategy = new j$.SpyStrategy({getSpy: spyFn});
 
     expect(spyStrategy.callThrough()).toBe(spy);
-    expect(spyStrategy.callReturn()).toBe(spy);
-    expect(spyStrategy.callThrow()).toBe(spy);
+    expect(spyStrategy.returnValue()).toBe(spy);
+    expect(spyStrategy.throwError()).toBe(spy);
     expect(spyStrategy.callFake()).toBe(spy);
     expect(spyStrategy.stub()).toBe(spy);
   });

data/lib/jasmine-core/spec/core/TimerSpec.js

@@ -3,10 +3,10 @@ describe("Timer", function() {
     var fakeNow = jasmine.createSpy('fake Date.now'),
         timer = new j$.Timer({now: fakeNow});
 
-    fakeNow.and.callReturn(100);
+    fakeNow.and.returnValue(100);
     timer.start();
 
-    fakeNow.and.callReturn(200);
+    fakeNow.and.returnValue(200);
 
     expect(timer.elapsed()).toEqual(100);
   });

data/lib/jasmine-core/spec/core/matchers/toContainSpec.js

@@ -1,7 +1,7 @@
 describe("toContain", function() {
   it("delegates to j$.matchersUtil.contains", function() {
     var util = {
-        contains: jasmine.createSpy('delegated-contains').and.callReturn(true)
+        contains: jasmine.createSpy('delegated-contains').and.returnValue(true)
       },
       matcher = j$.matchers.toContain(util);
 
@@ -12,7 +12,7 @@ describe("toContain", function() {
 
   it("delegates to j$.matchersUtil.contains, passing in equality testers if present", function() {
     var util = {
-        contains: jasmine.createSpy('delegated-contains').and.callReturn(true)
+        contains: jasmine.createSpy('delegated-contains').and.returnValue(true)
       },
       customEqualityTesters = ['a', 'b'],
       matcher = j$.matchers.toContain(util, customEqualityTesters);