jasmine-core 1.3.1 → 2.0.0.rc2

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

@@ -1,124 +1,244 @@
-describe('Spec', function () {
-  var env, suite;
-  beforeEach(function() {
-    env = new jasmine.Env();
-    env.updateInterval = 0;
-    suite = new jasmine.Suite(env, 'suite 1');
-  });
+describe("Spec", function() {
 
-  describe('initialization', function () {
+  it("#isPendingSpecException returns true for a pending spec exception", function() {
+    var e = new Error(j$.Spec.pendingSpecExceptionMessage);
 
-    it('should raise an error if an env is not passed', function () {
-      try {
-        new jasmine.Spec();
-      }
-      catch (e) {
-        expect(e.message).toEqual('jasmine.Env() required');
-      }
-    });
+    expect(j$.Spec.isPendingSpecException(e)).toBe(true);
+  });
 
-    it('should raise an error if a suite is not passed', function () {
-      try {
-        new jasmine.Spec(env);
-      }
-      catch (e) {
-        expect(e.message).toEqual('jasmine.Suite() required');
-      }
-    });
+  it("#isPendingSpecException returns true for a pending spec exception (even when FF bug is present)", function() {
+    var fakeError = {
+      toString: function() { return "Error: " + j$.Spec.pendingSpecExceptionMessage; }
+    };
 
-    it('should assign sequential ids for specs belonging to the same env', function () {
-      var spec1 = new jasmine.Spec(env, suite);
-      var spec2 = new jasmine.Spec(env, suite);
-      var spec3 = new jasmine.Spec(env, suite);
-      expect(spec1.id).toEqual(0);
-      expect(spec2.id).toEqual(1);
-      expect(spec3.id).toEqual(2);
-    });
+    expect(j$.Spec.isPendingSpecException(fakeError)).toBe(true);
   });
 
-  it('getFullName returns suite & spec description', function () {
-    var spec = new jasmine.Spec(env, suite, 'spec 1');
-    expect(spec.getFullName()).toEqual('suite 1 spec 1.');
+  it("#isPendingSpecException returns true for a pending spec exception", function() {
+    var e = new Error("foo");
+
+    expect(j$.Spec.isPendingSpecException(e)).toBe(false);
   });
 
-  describe('results', function () {
-    var spec, results;
-    beforeEach(function () {
-      spec = new jasmine.Spec(env, suite);
-      results = spec.results();
-      expect(results.totalCount).toEqual(0);
-      spec.runs(function () {
-        this.expect(true).toEqual(true);
-        this.expect(true).toEqual(true);
+  it("delegates execution to a QueueRunner", function() {
+    var fakeQueueRunner = jasmine.createSpy('fakeQueueRunner'),
+      spec = new j$.Spec({
+        description: 'my test',
+        id: 'some-id',
+        fn: function() {},
+        queueRunner: fakeQueueRunner
       });
-    });
 
+    spec.execute();
 
-    it('results shows the total number of expectations for each spec after execution', function () {
-      expect(results.totalCount).toEqual(0);
-      spec.execute();
-      expect(results.totalCount).toEqual(2);
-    });
+    expect(fakeQueueRunner).toHaveBeenCalled();
+  });
 
-    it('results shows the number of passed expectations for each spec after execution', function () {
-      expect(results.passedCount).toEqual(0);
-      spec.execute();
-      expect(results.passedCount).toEqual(2);
-    });
+  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,
+        description: 'foo bar',
+        fn: function() {},
+        onStart: startCallback,
+        queueRunner: fakeQueueRunner
+      });
 
-    it('results shows the number of failed expectations for each spec after execution', function () {
-      spec.runs(function () {
-        this.expect(true).toEqual(false);
+    spec.execute();
+
+    expect(startCallback).toHaveBeenCalledWith(spec);
+  });
+
+  it("should call the start callback on execution but before any befores are called", function() {
+    var fakeQueueRunner = jasmine.createSpy('fakeQueueRunner'),
+      beforesWereCalled = false,
+      startCallback = jasmine.createSpy('start-callback').and.callFake(function() {
+        expect(beforesWereCalled).toBe(false);
+      }),
+      spec = new j$.Spec({
+        fn: function() {},
+        beforeFns: function() {
+          return [function() {
+            beforesWereCalled = true
+          }]
+        },
+        onStart: startCallback,
+        queueRunner: fakeQueueRunner
       });
-      expect(results.failedCount).toEqual(0);
-      spec.execute();
-      expect(results.failedCount).toEqual(1);
-    });
 
-    describe('results.passed', function () {
-      it('is true if all spec expectations pass', function () {
-        spec.runs(function () {
-          this.expect(true).toEqual(true);
-        });
-        spec.execute();
-        expect(results.passed()).toEqual(true);
+    spec.execute();
+
+    expect(startCallback).toHaveBeenCalled();
+  });
+
+  it("provides all before fns and after fns to be run", function() {
+    var fakeQueueRunner = jasmine.createSpy('fakeQueueRunner'),
+      before = jasmine.createSpy('before'),
+      after = jasmine.createSpy('after'),
+      fn = jasmine.createSpy('test body').and.callFake(function() {
+        expect(before).toHaveBeenCalled();
+        expect(after).not.toHaveBeenCalled();
+      }),
+      spec = new j$.Spec({
+        fn: fn,
+        beforeFns: function() {
+          return [before]
+        },
+        afterFns: function() {
+          return [after]
+        },
+        queueRunner: fakeQueueRunner
       });
 
-      it('is false if one spec expectation fails', function () {
-        spec.runs(function () {
-          this.expect(true).toEqual(false);
-        });
-        spec.execute();
-        expect(results.passed()).toEqual(false);
+    spec.execute();
+
+    var allSpecFns = fakeQueueRunner.calls.mostRecent().args[0].fns;
+    expect(allSpecFns).toEqual([before, fn, after]);
+  });
+
+  it("is marked pending if created without a function body", function() {
+    var fakeQueueRunner = jasmine.createSpy('fakeQueueRunner'),
+
+      startCallback = jasmine.createSpy('startCallback'),
+      resultCallback = jasmine.createSpy('resultCallback'),
+      spec = new j$.Spec({
+        onStart: startCallback,
+        fn: null,
+        resultCallback: resultCallback,
+        queueRunner: fakeQueueRunner
       });
 
-      it('a spec with no expectations will return true', function () {
-        var specWithoutExpectations = new jasmine.Spec(env, suite);
-        specWithoutExpectations.runs(function() {
 
-        });
-        specWithoutExpectations.execute();
-        expect(results.passed()).toEqual(true);
+    expect(spec.status()).toBe('pending');
+  });
+
+  it("can be disabled, but still calls callbacks", function() {
+    var fakeQueueRunner = jasmine.createSpy('fakeQueueRunner'),
+      startCallback = jasmine.createSpy('startCallback'),
+      specBody = jasmine.createSpy('specBody'),
+      resultCallback = jasmine.createSpy('resultCallback'),
+      spec = new j$.Spec({
+        onStart:startCallback,
+        fn: specBody,
+        resultCallback: resultCallback,
+        queueRunner: fakeQueueRunner
       });
 
-      it('an unexecuted spec will return true', function () {
-        expect(results.passed()).toEqual(true);
+    spec.disable();
+
+    expect(spec.status()).toBe('disabled');
+
+    spec.execute();
+
+    expect(fakeQueueRunner).not.toHaveBeenCalled();
+    expect(specBody).not.toHaveBeenCalled();
+
+    expect(startCallback).toHaveBeenCalled();
+    expect(resultCallback).toHaveBeenCalled();
+  });
+
+  it("can be marked pending, but still calls callbacks when executed", function() {
+    var fakeQueueRunner = jasmine.createSpy('fakeQueueRunner'),
+      startCallback = jasmine.createSpy('startCallback'),
+      resultCallback = jasmine.createSpy('resultCallback'),
+      spec = new j$.Spec({
+        onStart: startCallback,
+        resultCallback: resultCallback,
+        description: "with a spec",
+        getSpecName: function() {
+          return "a suite with a spec"
+        },
+        queueRunner: fakeQueueRunner
       });
+
+    spec.pend();
+
+    expect(spec.status()).toBe('pending');
+
+    spec.execute();
+
+    expect(fakeQueueRunner).not.toHaveBeenCalled();
+
+    expect(startCallback).toHaveBeenCalled();
+    expect(resultCallback).toHaveBeenCalledWith({
+      id: spec.id,
+      status: 'pending',
+      description: 'with a spec',
+      fullName: 'a suite with a spec',
+      failedExpectations: []
     });
+  });
 
-    it("includes log messages, which may contain arbitary objects", function() {
-      spec.runs(function() {
-        this.log("here's some log message", {key: 'value'}, 123);
+  it("should call the done callback on execution complete", function() {
+    var done = jasmine.createSpy('done callback'),
+      spec = new j$.Spec({
+        fn: function() {},
+        catchExceptions: function() { return false; },
+        resultCallback: function() {},
+        queueRunner: function(attrs) { attrs.onComplete(); }
       });
+
+    spec.execute(done);
+
+    expect(done).toHaveBeenCalled();
+  });
+
+  it("#status returns pending by default", function() {
+    var spec = new j$.Spec({fn: jasmine.createSpy("spec body")});
+    expect(spec.status()).toEqual('pending');
+  });
+
+  it("#status returns pending if no expectations were encountered", function() {
+    var specBody = jasmine.createSpy("spec body"),
+      spec = new j$.Spec({fn: specBody});
+
+    spec.execute();
+
+    expect(spec.status()).toEqual('pending');
+  });
+
+  it("#status returns passed if all expectations in the spec have passed", function() {
+    var spec = new j$.Spec({fn: jasmine.createSpy("spec body")});
+    spec.addExpectationResult(true);
+    expect(spec.status()).toBe('passed');
+  });
+
+  it("#status returns failed if any expectations in the spec have failed", function() {
+    var spec = new j$.Spec({ fn: jasmine.createSpy("spec body") });
+    spec.addExpectationResult(true);
+    spec.addExpectationResult(false);
+    expect(spec.status()).toBe('failed');
+  });
+
+  it("can return its full name", function() {
+    var spec;
+    spec = new j$.Spec({
+      getSpecName: function(passedVal) {
+//        expect(passedVal).toBe(spec);  TODO: a exec time, spec is undefined WTF?
+        return 'expected val';
+      }
+    });
+
+    expect(spec.getFullName()).toBe('expected val');
+  });
+
+  describe("when a spec is marked pending during execution", function() {
+    it("should mark the spec as pending", function() {
+      var fakeQueueRunner = function(opts) {
+          opts.onException(new Error(j$.Spec.pendingSpecExceptionMessage));
+        },
+        spec = new j$.Spec({
+          description: 'my test',
+          id: 'some-id',
+          fn: function() { },
+          queueRunner: fakeQueueRunner
+        });
+
       spec.execute();
-      var items = results.getItems();
-      expect(items).toEqual([
-          jasmine.any(jasmine.ExpectationResult),
-          jasmine.any(jasmine.ExpectationResult),
-          jasmine.any(jasmine.MessageResult)
-      ]);
-      var logResult = items[2];
-      expect(logResult.values).toEqual(["here's some log message", {key: 'value'}, 123]);
+
+      expect(spec.status()).toEqual("pending");
     });
   });
-});
+});

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

@@ -1,216 +1,48 @@
 describe('Spies', function () {
-  it('should replace the specified function with a spy object', function() {
-    var originalFunctionWasCalled = false;
-    var TestClass = {
-      someFunction: function() {
-        originalFunctionWasCalled = true;
-      }
-    };
-    this.spyOn(TestClass, 'someFunction');
+  describe("createSpy", function() {
+    var TestClass;
 
-    expect(TestClass.someFunction.wasCalled).toEqual(false);
-    expect(TestClass.someFunction.callCount).toEqual(0);
-    TestClass.someFunction('foo');
-    expect(TestClass.someFunction.wasCalled).toEqual(true);
-    expect(TestClass.someFunction.callCount).toEqual(1);
-    expect(TestClass.someFunction.mostRecentCall.args).toEqual(['foo']);
-    expect(TestClass.someFunction.mostRecentCall.object).toEqual(TestClass);
-    expect(originalFunctionWasCalled).toEqual(false);
-
-    TestClass.someFunction('bar');
-    expect(TestClass.someFunction.callCount).toEqual(2);
-    expect(TestClass.someFunction.mostRecentCall.args).toEqual(['bar']);
-  });
-
-  it('should allow you to view args for a particular call', function() {
-    var originalFunctionWasCalled = false;
-    var TestClass = {
-      someFunction: function() {
-        originalFunctionWasCalled = true;
-      }
-    };
-    this.spyOn(TestClass, 'someFunction');
-
-    TestClass.someFunction('foo');
-    TestClass.someFunction('bar');
-    expect(TestClass.someFunction.calls[0].args).toEqual(['foo']);
-    expect(TestClass.someFunction.calls[1].args).toEqual(['bar']);
-    expect(TestClass.someFunction.mostRecentCall.args).toEqual(['bar']);
-  });
-
-  it('should be possible to call through to the original method, or return a specific result', function() {
-    var originalFunctionWasCalled = false;
-    var passedArgs;
-    var passedObj;
-    var TestClass = {
-      someFunction: function() {
-        originalFunctionWasCalled = true;
-        passedArgs = arguments;
-        passedObj = this;
-        return "return value from original function";
-      }
-    };
-
-    this.spyOn(TestClass, 'someFunction').andCallThrough();
-    var result = TestClass.someFunction('arg1', 'arg2');
-    expect(result).toEqual("return value from original function");
-    expect(originalFunctionWasCalled).toEqual(true);
-    expect(passedArgs).toEqual(['arg1', 'arg2']);
-    expect(passedObj).toEqual(TestClass);
-    expect(TestClass.someFunction.wasCalled).toEqual(true);
-  });
-
-  it('should be possible to return a specific value', function() {
-    var originalFunctionWasCalled = false;
-    var TestClass = {
-      someFunction: function() {
-        originalFunctionWasCalled = true;
-        return "return value from original function";
-      }
-    };
-
-    this.spyOn(TestClass, 'someFunction').andReturn("some value");
-    originalFunctionWasCalled = false;
-    var result = TestClass.someFunction('arg1', 'arg2');
-    expect(result).toEqual("some value");
-    expect(originalFunctionWasCalled).toEqual(false);
-  });
-
-  it('should be possible to throw a specific error', function() {
-    var originalFunctionWasCalled = false;
-    var TestClass = {
-      someFunction: function() {
-        originalFunctionWasCalled = true;
-        return "return value from original function";
-      }
-    };
-
-    this.spyOn(TestClass, 'someFunction').andThrow(new Error('fake error'));
-    var exception;
-    try {
-      TestClass.someFunction('arg1', 'arg2');
-    } catch (e) {
-      exception = e;
-    }
-    expect(exception.message).toEqual('fake error');
-    expect(originalFunctionWasCalled).toEqual(false);
-  });
-
-  it('should be possible to call a specified function', function() {
-    var originalFunctionWasCalled = false;
-    var fakeFunctionWasCalled = false;
-    var passedArgs;
-    var passedObj;
-    var TestClass = {
-      someFunction: function() {
-        originalFunctionWasCalled = true;
-        return "return value from original function";
-      }
-    };
-
-    this.spyOn(TestClass, 'someFunction').andCallFake(function() {
-      fakeFunctionWasCalled = true;
-      passedArgs = arguments;
-      passedObj = this;
-      return "return value from fake function";
+    beforeEach(function() {
+      TestClass = function() {};
+      TestClass.prototype.someFunction = function() {};
+      TestClass.prototype.someFunction.bob = "test";
     });
+    
+    it("preserves the properties of the spied function", function() {
+      var spy = j$.createSpy(TestClass.prototype, TestClass.prototype.someFunction);
 
-    var result = TestClass.someFunction('arg1', 'arg2');
-    expect(result).toEqual("return value from fake function");
-    expect(originalFunctionWasCalled).toEqual(false);
-    expect(fakeFunctionWasCalled).toEqual(true);
-    expect(passedArgs).toEqual(['arg1', 'arg2']);
-    expect(passedObj).toEqual(TestClass);
-    expect(TestClass.someFunction.wasCalled).toEqual(true);
-  });
-
-  it('is torn down when this.removeAllSpies is called', function() {
-    var originalFunctionWasCalled = false;
-    var TestClass = {
-      someFunction: function() {
-        originalFunctionWasCalled = true;
-      }
-    };
-    this.spyOn(TestClass, 'someFunction');
-
-    TestClass.someFunction('foo');
-    expect(originalFunctionWasCalled).toEqual(false);
-
-    this.removeAllSpies();
-
-    TestClass.someFunction('foo');
-    expect(originalFunctionWasCalled).toEqual(true);
-  });
-
-  it('calls removeAllSpies during spec finish', function() {
-    var test = new jasmine.Spec(new jasmine.Env(), {}, 'sample test');
-
-    this.spyOn(test, 'removeAllSpies');
-
-    test.finish();
-
-    expect(test.removeAllSpies).wasCalled();
-  });
+      expect(spy.bob).toEqual("test");
+    });
 
-  it('throws an exception when some method is spied on twice', function() {
-    var TestClass = { someFunction: function() {
-    } };
-    this.spyOn(TestClass, 'someFunction');
-    var exception;
-    try {
-      this.spyOn(TestClass, 'someFunction');
-    } catch (e) {
-      exception = e;
-    }
-    expect(exception).toBeDefined();
-  });
+    it("warns the user that we indend to overwrite an existing property", function() {
+      TestClass.prototype.someFunction.and = "turkey";
 
-	
-	it('to spy on an undefined method throws exception', function() {
-		var TestClass = {
-			someFunction : function() {
-			}
-		};
-		function efunc() {
-			this.spyOn(TestClass, 'someOtherFunction');
-		};
-		expect(function() {
-			efunc();
-		}).toThrow('someOtherFunction() method does not exist');
-	
-	}); 
+      expect(function() {
+        j$.createSpy(TestClass.prototype, TestClass.prototype.someFunction);
+      }).toThrowError("Jasmine spies would overwrite the 'and' and 'calls' properties on the object being spied upon");
+    });
 
-  it('should be able to reset a spy', function() {
-    var TestClass = { someFunction: function() {} };
-    this.spyOn(TestClass, 'someFunction');
+    it("adds a spyStrategy and callTracker to the spy", function() {
+      var spy = j$.createSpy(TestClass.prototype, TestClass.prototype.someFunction);
 
-    expect(TestClass.someFunction).not.toHaveBeenCalled();
-    TestClass.someFunction();
-    expect(TestClass.someFunction).toHaveBeenCalled();
-    TestClass.someFunction.reset();
-    expect(TestClass.someFunction).not.toHaveBeenCalled();
-    expect(TestClass.someFunction.callCount).toEqual(0);
+      expect(spy.and).toEqual(jasmine.any(j$.SpyStrategy));
+      expect(spy.calls).toEqual(jasmine.any(j$.CallTracker));
+    });
   });
 
   describe("createSpyObj", function() {
     it("should create an object with a bunch of spy methods when you call jasmine.createSpyObj()", function() {
-      var spyObj = jasmine.createSpyObj('BaseName', ['method1', 'method2']);
+      var spyObj = j$.createSpyObj('BaseName', ['method1', 'method2']);
+
       expect(spyObj).toEqual({ method1: jasmine.any(Function), method2: jasmine.any(Function)});
-      expect(spyObj.method1.identity).toEqual('BaseName.method1');
-      expect(spyObj.method2.identity).toEqual('BaseName.method2');
+      expect(spyObj.method1.and.identity()).toEqual('BaseName.method1');
+      expect(spyObj.method2.and.identity()).toEqual('BaseName.method2');
     });
 
     it("should throw if you do not pass an array argument", function() {
       expect(function() {
-        jasmine.createSpyObj('BaseName');
-      }).toThrow('createSpyObj requires a non-empty array of method names to create spies for');
-    });
-
-    it("should throw if you pass an empty array argument", function() {
-      expect(function() {
-        jasmine.createSpyObj('BaseName');
-      }).toThrow('createSpyObj requires a non-empty array of method names to create spies for');
+        j$.createSpyObj('BaseName');
+      }).toThrow("createSpyObj requires a non-empty array of method names to create spies for");
     });
   });
-
 });