jasmine-core 1.3.1 → 2.0.0.rc2

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

@@ -0,0 +1,101 @@
+describe("SpyStrategy", function() {
+
+  it("defaults its name to unknown", function() {
+    var spyStrategy = new j$.SpyStrategy();
+
+    expect(spyStrategy.identity()).toEqual("unknown");
+  });
+
+  it("takes a name", function() {
+    var spyStrategy = new j$.SpyStrategy({name: "foo"});
+
+    expect(spyStrategy.identity()).toEqual("foo");
+  });
+
+  it("stubs an original function, if provided", function() {
+    var originalFn = jasmine.createSpy("original"),
+        spyStrategy = new j$.SpyStrategy({fn: originalFn});
+
+    spyStrategy.exec();
+
+    expect(originalFn).not.toHaveBeenCalled();
+  });
+
+  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),
+        spyStrategy = new j$.SpyStrategy({fn: originalFn}),
+        returnValue;
+
+    spyStrategy.callThrough();
+    returnValue = spyStrategy.exec("foo");
+
+    expect(originalFn).toHaveBeenCalled();
+    expect(originalFn.calls.mostRecent().args).toEqual(["foo"]);
+    expect(returnValue).toEqual(42);
+  });
+
+  it("can return a specified value when executed", function() {
+    var originalFn = jasmine.createSpy("original"),
+        spyStrategy = new j$.SpyStrategy({fn: originalFn}),
+        returnValue;
+
+    spyStrategy.callReturn(17);
+    returnValue = spyStrategy.exec();
+
+    expect(originalFn).not.toHaveBeenCalled();
+    expect(returnValue).toEqual(17);
+  });
+
+  it("allows an exception to be thrown when executed", function() {
+    var originalFn = jasmine.createSpy("original"),
+        spyStrategy = new j$.SpyStrategy({fn: originalFn});
+
+    spyStrategy.callThrow("bar");
+
+    expect(function() { spyStrategy.exec(); }).toThrow("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),
+        spyStrategy = new j$.SpyStrategy({fn: originalFn}),
+        returnValue;
+
+    spyStrategy.callFake(fakeFn);
+    returnValue = spyStrategy.exec();
+
+    expect(originalFn).not.toHaveBeenCalled();
+    expect(returnValue).toEqual(67);
+  });
+
+  it("allows a return to plan stubbing after another strategy", function() {
+    var originalFn = jasmine.createSpy("original"),
+        fakeFn = jasmine.createSpy("fake").and.callReturn(67),
+        spyStrategy = new j$.SpyStrategy({fn: originalFn}),
+        returnValue;
+
+    spyStrategy.callFake(fakeFn);
+    returnValue = spyStrategy.exec();
+
+    expect(originalFn).not.toHaveBeenCalled();
+    expect(returnValue).toEqual(67);
+    
+    spyStrategy.stub();
+    returnValue = spyStrategy.exec();
+
+    expect(returnValue).toEqual(void 0);
+  });
+
+  it("returns the spy after changing the strategy", function(){
+    var spy = {},
+        spyFn = jasmine.createSpy('spyFn').and.callReturn(spy),
+        spyStrategy = new j$.SpyStrategy({getSpy: spyFn});
+
+    expect(spyStrategy.callThrough()).toBe(spy);
+    expect(spyStrategy.callReturn()).toBe(spy);
+    expect(spyStrategy.callThrow()).toBe(spy);
+    expect(spyStrategy.callFake()).toBe(spy);
+    expect(spyStrategy.stub()).toBe(spy);
+  });
+});

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

@@ -1,120 +1,230 @@
-describe('Suite', function() {
-  var fakeTimer;
-  var env;
-
-  beforeEach(function() {
-    env = new jasmine.Env();
-    env.updateInterval = 0;
-
-    fakeTimer = new jasmine.FakeTimer();
-    env.setTimeout = fakeTimer.setTimeout;
-    env.clearTimeout = fakeTimer.clearTimeout;
-    env.setInterval = fakeTimer.setInterval;
-    env.clearInterval = fakeTimer.clearInterval;
+describe("Suite", function() {
+
+  it("keeps its id", function() {
+    var env = new j$.Env(),
+      suite = new j$.Suite({
+        env: env,
+        id: 456,
+        description: "I am a suite"
+      });
+
+    expect(suite.id).toEqual(456);
   });
 
-  describe('Specs', function () {
-    var suite;
-
-    beforeEach(function() {
-      suite = env.describe('Suite 1', function () {
-        env.it('Spec 1', function() {
-          this.runs(function () {
-            this.expect(true).toEqual(true);
-          });
-        });
-        env.it('Spec 2', function() {
-          this.runs(function () {
-            this.expect(true).toEqual(true);
-          });
-        });
-        env.describe('Suite 2', function () {
-          env.it('Spec 3', function() {
-            this.runs(function () {
-              this.expect(true).toEqual(true);
-            });
-          });
-        });
-        env.it('Spec 4', function() {
-          this.runs(function () {
-            this.expect(true).toEqual(true);
-          });
-        });
+  it("returns its full name", function() {
+    var env = new j$.Env(),
+      suite = new j$.Suite({
+        env: env,
+        description: "I am a suite"
       });
-    });
-    
-    it('#specs should return all immediate children that are specs.', function () {
-      var suiteSpecs = suite.specs();
-      expect(suiteSpecs.length).toEqual(3);
-      expect(suiteSpecs[0].description).toEqual('Spec 1');
-      expect(suiteSpecs[1].description).toEqual('Spec 2');
-      expect(suiteSpecs[2].description).toEqual('Spec 4');
-    });
 
-    it("#suites should return all immediate children that are suites.", function() {
-      var nestedSuites = suite.suites();
-      expect(nestedSuites.length).toEqual(1);
-      expect(nestedSuites[0].description).toEqual('Suite 2');
-    });
+    expect(suite.getFullName()).toEqual("I am a suite");
+  });
 
-    it("#children should return all immediate children including suites and specs.", function() {
-      var children = suite.children();
-      expect(children.length).toEqual(4);
-      expect(children[0].description).toEqual('Spec 1');
-      expect(children[1].description).toEqual('Spec 2');
-      expect(children[2].description).toEqual('Suite 2');
-      expect(children[3].description).toEqual('Spec 4');
-    });
+  it("returns its full name when it has parent suites", function() {
+    var env = new j$.Env(),
+      parentSuite = new j$.Suite({
+        env: env,
+        description: "I am a parent suite",
+        parentSuite: jasmine.createSpy('pretend top level suite')
+      }),
+      suite = new j$.Suite({
+        env: env,
+        description: "I am a suite",
+        parentSuite: parentSuite
+      });
+
+    expect(suite.getFullName()).toEqual("I am a parent suite I am a suite");
   });
 
-  describe('SpecCount', function () {
-
-    it('should keep a count of the number of specs that are run', function() {
-      var suite = env.describe('one suite description', function () {
-        env.it('should be a test', function() {
-          this.runs(function () {
-            this.expect(true).toEqual(true);
-          });
-        });
-        env.it('should be another test', function() {
-          this.runs(function () {
-            this.expect(true).toEqual(true);
-          });
-        });
-        env.it('should be a third test', function() {
-          this.runs(function () {
-            this.expect(true).toEqual(true);
-          });
-        });
+  it("adds before functions in order of needed execution", function() {
+    var env = new j$.Env(),
+      suite = new j$.Suite({
+        env: env,
+        description: "I am a suite"
+      }),
+      outerBefore = jasmine.createSpy('outerBeforeEach'),
+      innerBefore = jasmine.createSpy('insideBeforeEach');
+
+    suite.beforeEach(outerBefore);
+    suite.beforeEach(innerBefore);
+
+    expect(suite.beforeFns).toEqual([innerBefore, outerBefore]);
+  });
+
+  it("adds after functions in order of needed execution", function() {
+    var env = new j$.Env(),
+      suite = new j$.Suite({
+        env: env,
+        description: "I am a suite"
+      }),
+      outerAfter = jasmine.createSpy('outerAfterEach'),
+      innerAfter = jasmine.createSpy('insideAfterEach');
+
+    suite.afterEach(outerAfter);
+    suite.afterEach(innerAfter);
+
+    expect(suite.afterFns).toEqual([innerAfter, outerAfter]);
+  });
+
+  it("adds specs", function() {
+    var env = new j$.Env(),
+      fakeQueue = {
+        add: jasmine.createSpy()
+      },
+      suite = new j$.Suite({
+        env: env,
+        description: "I am a suite",
+        queueFactory: function() {
+          return fakeQueue
+        }
+      }),
+      fakeSpec = {};
+
+    expect(suite.specs.length).toEqual(0);
+
+    suite.addSpec(fakeSpec);
+
+    expect(suite.specs.length).toEqual(1);
+  });
+
+  it("adds suites", function() {
+    var env = new j$.Env(),
+      fakeQueue = {
+        add: jasmine.createSpy()
+      },
+      suite = new j$.Suite({
+        env: env,
+        description: "I am a suite",
+        queueFactory: function() {
+          return fakeQueue
+        }
+      }),
+      anotherSuite = new j$.Suite({
+        env: env,
+        description: "I am another suite",
+        queueFactory: function() {
+          return fakeQueue
+        }
       });
 
-      expect(suite.specs().length).toEqual(3);
-    });
+    expect(suite.suites.length).toEqual(0);
+
+    suite.addSuite(anotherSuite);
 
-    it('specCount should be correct even with runs/waits blocks', function() {
-      var suite = env.describe('one suite description', function () {
-        env.it('should be a test', function() {
-          this.runs(function () {
-            this.expect(true).toEqual(true);
-          });
-        });
-        env.it('should be another test', function() {
-          this.runs(function () {
-            this.expect(true).toEqual(true);
-          });
-          this.waits(10);
-          this.runs(function () {
-            this.expect(true).toEqual(true);
-          });
-        });
-        env.it('should be a third test', function() {
-          this.runs(function () {
-            this.expect(true).toEqual(true);
-          });
-        });
+    expect(suite.suites.length).toEqual(1);
+  });
+
+  it("can be disabled", function() {
+    var env = new j$.Env(),
+      fakeQueueRunner = jasmine.createSpy('fake queue runner'),
+      suite = new j$.Suite({
+        env: env,
+        description: "with a child suite",
+        queueRunner: fakeQueueRunner
       });
 
-      expect(suite.specs().length).toEqual(3);
+    suite.disable();
+
+    expect(suite.disabled).toBe(true);
+
+    suite.execute();
+
+    expect(fakeQueueRunner).not.toHaveBeenCalled();
+  });
+
+  it("delegates execution of its specs and suites", function() {
+    var env = new j$.Env(),
+      parentSuiteDone = jasmine.createSpy('parent suite done'),
+      fakeQueueRunnerForParent = jasmine.createSpy('fake parent queue runner'),
+      parentSuite = new j$.Suite({
+        env: env,
+        description: "I am a parent suite",
+        queueRunner: fakeQueueRunnerForParent
+      }),
+      fakeQueueRunner = jasmine.createSpy('fake queue runner'),
+      suite = new j$.Suite({
+        env: env,
+        description: "with a child suite",
+        queueRunner: fakeQueueRunner
+      }),
+      fakeSpec1 = {
+        execute: jasmine.createSpy('fakeSpec1')
+      };
+
+    spyOn(suite, "execute");
+
+    parentSuite.addSpec(fakeSpec1);
+    parentSuite.addSuite(suite);
+
+    parentSuite.execute(parentSuiteDone);
+
+    var parentSuiteFns = fakeQueueRunnerForParent.calls.mostRecent().args[0].fns;
+
+    parentSuiteFns[0]();
+    expect(fakeSpec1.execute).toHaveBeenCalled();
+    parentSuiteFns[1]();
+    expect(suite.execute).toHaveBeenCalled();
+  });
+
+  it("calls a provided onStart callback when starting", function() {
+    var env = new j$.Env(),
+      suiteStarted = jasmine.createSpy('suiteStarted'),
+      fakeQueueRunner = function(attrs) { attrs.onComplete(); },
+      suite = new j$.Suite({
+        env: env,
+        description: "with a child suite",
+        onStart: suiteStarted,
+        queueRunner: fakeQueueRunner
+      }),
+      fakeSpec1 = {
+        execute: jasmine.createSpy('fakeSpec1')
+      };
+
+    suite.execute();
+
+    expect(suiteStarted).toHaveBeenCalledWith(suite);
+  });
+
+  it("calls a provided onComplete callback when done", function() {
+    var env = new j$.Env(),
+      suiteCompleted = jasmine.createSpy('parent suite done'),
+      fakeQueueRunner = function(attrs) { attrs.onComplete(); },
+      suite = new j$.Suite({
+        env: env,
+        description: "with a child suite",
+        queueRunner: fakeQueueRunner
+      }),
+      fakeSpec1 = {
+        execute: jasmine.createSpy('fakeSpec1')
+      };
+
+    suite.execute(suiteCompleted);
+
+    expect(suiteCompleted).toHaveBeenCalled();
+  });
+
+  it("calls a provided result callback when done", function() {
+    var env = new j$.Env(),
+      suiteResultsCallback = jasmine.createSpy('suite result callback'),
+      fakeQueueRunner = function(attrs) { attrs.onComplete(); },
+      suite = new j$.Suite({
+        env: env,
+        description: "with a child suite",
+        queueRunner: fakeQueueRunner,
+        resultCallback: suiteResultsCallback
+      }),
+      fakeSpec1 = {
+        execute: jasmine.createSpy('fakeSpec1')
+      };
+
+    suite.execute();
+
+    expect(suiteResultsCallback).toHaveBeenCalledWith({
+      id: suite.id,
+      status: '',
+      description: "with a child suite",
+      fullName: "with a child suite"
     });
   });
-});
+});

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

@@ -0,0 +1,13 @@
+describe("Timer", function() {
+  it("reports the time elapsed", function() {
+    var fakeNow = jasmine.createSpy('fake Date.now'),
+        timer = new j$.Timer({now: fakeNow});
+
+    fakeNow.and.callReturn(100);
+    timer.start();
+
+    fakeNow.and.callReturn(200);
+
+    expect(timer.elapsed()).toEqual(100);
+  });
+});