jazrb 0.1.0

data/vendor/jasmine/spec/suites/SpecSpec.js

@@ -0,0 +1,110 @@
+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);
+      });
+    });
+  });
+});

data/vendor/jasmine/spec/suites/SpySpec.js

@@ -0,0 +1,187 @@
+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).wasNotCalled();
+    TestClass.someFunction();
+    expect(TestClass.someFunction).wasCalled();
+    TestClass.someFunction.reset();
+    expect(TestClass.someFunction).wasNotCalled();
+    expect(TestClass.someFunction.callCount).toEqual(0);
+  });
+
+  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');
+  });
+
+});

data/vendor/jasmine/spec/suites/SuiteSpec.js

@@ -0,0 +1,101 @@
+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 () {
+    it('#specs should return all immediate children that are specs.', function () {
+      var 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);
+          });
+        });
+      });
+
+      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');
+    });
+
+    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);
+      });
+    });
+  });
+});

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

@@ -0,0 +1,140 @@
+describe("TrivialReporter", function() {
+  var trivialReporter;
+  var body;
+
+  beforeEach(function() {
+    body = document.createElement("body");
+  });
+
+  function fakeSpec(name) {
+    return {
+      getFullName: function() {
+        return name;
+      }
+    };
+  }
+
+  it("should run only specs beginning with spec parameter", function() {
+    var trivialReporter = new jasmine.TrivialReporter({ location: {search: "?spec=run%20this"} });
+    expect(trivialReporter.specFilter(fakeSpec("run this"))).toBeTruthy();
+    expect(trivialReporter.specFilter(fakeSpec("not the right spec"))).toBeFalsy();
+    expect(trivialReporter.specFilter(fakeSpec("not run this"))).toBeFalsy();
+  });
+
+  it("should display empty divs for every suite when the runner is starting", function() {
+    var trivialReporter = new jasmine.TrivialReporter({ body: body });
+    trivialReporter.reportRunnerStarting({
+      suites: function() {
+        return [ new jasmine.Suite({}, "suite 1", null, null) ];
+      }
+    });
+
+    var divs = body.getElementsByTagName("div");
+    expect(divs.length).toEqual(2);
+    expect(divs[1].innerHTML).toContain("suite 1");
+  });
+
+  describe('Matcher reporting', function () {
+    var getResultMessageDiv = function (body) {
+      var divs = body.getElementsByTagName("div");
+      for (var i = 0; i < divs.length; i++) {
+        if (divs[i].className.match(/resultMessage/)) {
+          return divs[i];
+        }
+      }
+    };
+
+    var runner, spec, fakeTimer;
+    beforeEach(function () {
+      var env = new jasmine.Env();
+      fakeTimer = new jasmine.FakeTimer();
+      env.setTimeout = fakeTimer.setTimeout;
+      env.clearTimeout = fakeTimer.clearTimeout;
+      env.setInterval = fakeTimer.setInterval;
+      env.clearInterval = fakeTimer.clearInterval;
+      runner = env.currentRunner();
+      var suite = new jasmine.Suite(env, 'some suite');
+      runner.add(suite);
+      spec = new jasmine.Spec(env, suite, 'some spec');
+      suite.add(spec);
+      var trivialReporter = new jasmine.TrivialReporter({ body: body, location: {search: "?"} });
+      env.addReporter(trivialReporter);
+    });
+
+    describe('toContain', function () {
+      it('should show actual and expected', function () {
+        spec.runs(function () {
+          this.expect('foo').toContain('bar');
+        });
+        runner.execute();
+        fakeTimer.tick(0);
+
+        var resultEl = getResultMessageDiv(body);
+        expect(resultEl.innerHTML).toMatch(/foo/);
+        expect(resultEl.innerHTML).toMatch(/bar/);
+      });
+    });
+  });
+
+
+  describe("failure messages (integration)", function () {
+    var spec, results, expectationResult;
+
+    beforeEach(function() {
+      results = {
+        passed: function() {
+          return false;
+        },
+        getItems: function() {
+        }};
+
+      spec = {
+        suite: {
+          getFullName: function() {
+            return "suite 1";
+          }
+        },
+        getFullName: function() {
+          return "foo";
+        },
+        results: function() {
+          return results;
+        }
+      };
+
+      trivialReporter = new jasmine.TrivialReporter({ body: body });
+      trivialReporter.reportRunnerStarting({
+        suites: function() {
+          return [ new jasmine.Suite({}, "suite 1", null, null) ];
+        }
+      });
+    });
+
+    it("should add the failure message to the DOM (non-toEquals matchers)", function() {
+      expectationResult = new jasmine.ExpectationResult({
+        matcherName: "toBeNull", passed: false, message: "Expected 'a' to be null, but it was not"
+      });
+    
+      spyOn(results, 'getItems').andReturn([expectationResult]);
+
+      trivialReporter.reportSpecResults(spec);
+
+      var divs = body.getElementsByTagName("div");
+      expect(divs[3].innerText || divs[3].textContent).toEqual("Expected 'a' to be null, but it was not");
+    });
+
+    it("should add the failure message to the DOM (non-toEquals matchers)", function() {
+      expectationResult = new jasmine.ExpectationResult({
+        matcherName: "toBeNull", passed: false, message: "Expected '1 < 2' to <b>e null, & it was not"
+      });
+
+      spyOn(results, 'getItems').andReturn([expectationResult]);
+
+      trivialReporter.reportSpecResults(spec);
+
+      var divs = body.getElementsByTagName("div");
+      expect(divs[3].innerHTML).toEqual("Expected '1 &lt; 2' to &lt;b&gt;e null, &amp; it was not");
+    });
+  });
+
+});

data/vendor/jasmine/spec/suites/UtilSpec.js

@@ -0,0 +1,23 @@
+describe("jasmine.util", function() {
+  describe("extend", function () {
+    it("should add properies to a destination object ", function() {
+      var destination = {baz: 'baz'};
+      jasmine.util.extend(destination, {
+        foo: 'foo', bar: 'bar'
+      });
+      expect(destination).toEqual({foo: 'foo', bar: 'bar', baz: 'baz'});
+    });
+
+    it("should replace properies that already exist on a destination object", function() {
+      var destination = {foo: 'foo'};
+      jasmine.util.extend(destination, {
+        foo: 'bar'
+      });
+      expect(destination).toEqual({foo: 'bar'});
+      jasmine.util.extend(destination, {
+        foo: null
+      });
+      expect(destination).toEqual({foo: null});
+    });
+  });
+});

data/vendor/jasmine/src/Block.js

@@ -0,0 +1,34 @@
+/**
+ * Blocks are functions with executable code that make up a spec.
+ *
+ * @constructor
+ * @param {jasmine.Env} env
+ * @param {Function} func
+ * @param {jasmine.Spec} spec
+ */
+jasmine.Block = function(env, func, spec) {
+  this.env = env;
+  this.func = func;
+  this.spec = spec;
+};
+
+jasmine.Block.prototype.execute = function(onComplete) {  
+  try {
+    if(!this.spec.pending ||
+       (this.is_after && this.spec.is_before_ran)){
+      if(this.is_before){
+        this.spec.is_before_ran = true;
+      }
+      this.func.apply(this.spec);
+    }
+  } catch (e) {
+    if(e instanceof jasmine.pending_){
+      this.spec.pending = true;
+    } else if (e instanceof jasmine.eventually_){
+      throw e;
+    } else {
+      this.spec && this.spec.fail(e);
+    }
+  }
+  onComplete();
+};