josephholsten-jasmine 1.1.0.pre.1

data/jasmine/spec/suites/SpecSpec.js

@@ -0,0 +1,124 @@
+describe('Spec', function () {
+  var env, suite;
+  beforeEach(function() {
+    env = new jasmine.Env();
+    env.updateInterval = 0;
+    suite = new jasmine.Suite(env, 'suite 1');
+  });
+
+  describe('initialization', function () {
+
+    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');
+      }
+    });
+
+    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('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);
+    });
+  });
+
+  it('getFullName returns suite & spec description', function () {
+    var spec = new jasmine.Spec(env, suite, 'spec 1');
+    expect(spec.getFullName()).toEqual('suite 1 spec 1.');
+  });
+
+  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('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);
+    });
+
+    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('results shows the number of failed expectations for each spec after execution', function () {
+      spec.runs(function () {
+        this.expect(true).toEqual(false);
+      });
+      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);
+      });
+
+      it('is false if one spec expectation fails', function () {
+        spec.runs(function () {
+          this.expect(true).toEqual(false);
+        });
+        spec.execute();
+        expect(results.passed()).toEqual(false);
+      });
+
+      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);
+      });
+
+      it('an unexecuted spec will return true', function () {
+        expect(results.passed()).toEqual(true);
+      });
+    });
+
+    it("includes log messages, which may contain arbitary objects", function() {
+      spec.runs(function() {
+        this.log("here's some log message", {key: 'value'}, 123);
+      });
+      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]);
+    });
+  });
+});

data/jasmine/spec/suites/SpySpec.js

@@ -0,0 +1,201 @@
+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');
+
+    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";
+    });
+
+    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();
+  });
+
+  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('should be able to reset a spy', function() {
+    var TestClass = { someFunction: function() {} };
+    this.spyOn(TestClass, '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);
+  });
+
+  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']);
+      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');
+    });
+
+    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');
+    });
+  });
+
+});

data/jasmine/spec/suites/SuiteSpec.js

@@ -0,0 +1,120 @@
+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('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('#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');
+    });
+
+    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');
+    });
+  });
+
+  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);
+          });
+        });
+      });
+
+      expect(suite.specs().length).toEqual(3);
+    });
+
+    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.specs().length).toEqual(3);
+    });
+  });
+});