upjs-rails 0.1.0 → 0.2.0

data/spec_app/vendor/assets/bower_components/jasmine/spec/core/integration/SpecRunningSpec.js

@@ -0,0 +1,306 @@
+describe("jasmine spec running", function () {
+  var env;
+  var fakeTimer;
+
+  beforeEach(function() {
+    env = new j$.Env();
+  });
+
+  it('should assign spec ids sequentially', function() {
+    var it0, it1, it2, it3, it4;
+    env.describe('test suite', function() {
+      it0 = env.it('spec 0', function() {
+      });
+      it1 = env.it('spec 1', function() {
+      });
+      it2 = env.xit('spec 2', function() {
+      });
+      it3 = env.it('spec 3', function() {
+      });
+    });
+    env.describe('test suite 2', function() {
+      it4 = env.it('spec 4', function() {
+      });
+    });
+
+    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) {
+
+    var foo = 0;
+    var bar = 0;
+    var baz = 0;
+    var quux = 0;
+    var nested = env.describe('suite', function () {
+      env.describe('nested', function () {
+        env.it('should run nested suites', function () {
+          foo++;
+        });
+        env.it('should run nested suites', function () {
+          bar++;
+        });
+      });
+
+      env.describe('nested 2', function () {
+        env.it('should run suites following nested suites', function () {
+          baz++;
+        });
+      });
+
+      env.it('should run tests following nested suites', function () {
+        quux++;
+      });
+    });
+
+    expect(foo).toEqual(0);
+    expect(bar).toEqual(0);
+    expect(baz).toEqual(0);
+    expect(quux).toEqual(0);
+    nested.execute(function() {
+      expect(foo).toEqual(1);
+      expect(bar).toEqual(1);
+      expect(baz).toEqual(1);
+      expect(quux).toEqual(1);
+      done();
+    });
+  });
+
+  it("should permit nested describes", function(done) {
+    var actions = [];
+
+    env.beforeEach(function () {
+      actions.push('topSuite beforeEach');
+    });
+
+    env.afterEach(function () {
+      actions.push('topSuite afterEach');
+    });
+
+    env.describe('Something', function() {
+      env.beforeEach(function() {
+        actions.push('outer beforeEach');
+      });
+
+      env.afterEach(function() {
+        actions.push('outer afterEach');
+      });
+
+      env.it('does it 1', function() {
+        actions.push('outer it 1');
+      });
+
+      env.describe('Inner 1', function() {
+        env.beforeEach(function() {
+          actions.push('inner 1 beforeEach');
+        });
+
+        env.afterEach(function() {
+          actions.push('inner 1 afterEach');
+        });
+
+        env.it('does it 2', function() {
+          actions.push('inner 1 it');
+        });
+      });
+
+      env.it('does it 3', function() {
+        actions.push('outer it 2');
+      });
+
+      env.describe('Inner 2', function() {
+        env.beforeEach(function() {
+          actions.push('inner 2 beforeEach');
+        });
+
+        env.afterEach(function() {
+          actions.push('inner 2 afterEach');
+        });
+
+        env.it('does it 2', function() {
+          actions.push('inner 2 it');
+        });
+      });
+    });
+
+    var assertions = function() {
+      var expected = [
+        "topSuite beforeEach",
+        "outer beforeEach",
+        "outer it 1",
+        "outer afterEach",
+        "topSuite afterEach",
+
+        "topSuite beforeEach",
+        "outer beforeEach",
+        "inner 1 beforeEach",
+        "inner 1 it",
+        "inner 1 afterEach",
+        "outer afterEach",
+        "topSuite afterEach",
+
+        "topSuite beforeEach",
+        "outer beforeEach",
+        "outer it 2",
+        "outer afterEach",
+        "topSuite afterEach",
+
+        "topSuite beforeEach",
+        "outer beforeEach",
+        "inner 2 beforeEach",
+        "inner 2 it",
+        "inner 2 afterEach",
+        "outer afterEach",
+        "topSuite afterEach"
+      ];
+      expect(actions).toEqual(expected);
+      done();
+    }
+
+    env.addReporter({jasmineDone: assertions});
+
+    env.execute();
+  });
+
+  it("should run multiple befores and afters in the order they are declared", function(done) {
+    var actions = [];
+
+    env.beforeEach(function () {
+      actions.push('runner beforeEach1');
+    });
+
+    env.afterEach(function () {
+      actions.push('runner afterEach1');
+    });
+
+    env.beforeEach(function () {
+      actions.push('runner beforeEach2');
+    });
+
+    env.afterEach(function () {
+      actions.push('runner afterEach2');
+    });
+
+    env.describe('Something', function() {
+      env.beforeEach(function() {
+        actions.push('beforeEach1');
+      });
+
+      env.afterEach(function() {
+        actions.push('afterEach1');
+      });
+
+      env.beforeEach(function() {
+        actions.push('beforeEach2');
+      });
+
+      env.afterEach(function() {
+        actions.push('afterEach2');
+      });
+
+      env.it('does it 1', function() {
+        actions.push('outer it 1');
+      });
+    });
+
+    var assertions = function() {
+      var expected = [
+        "runner beforeEach1",
+        "runner beforeEach2",
+        "beforeEach1",
+        "beforeEach2",
+        "outer it 1",
+        "afterEach2",
+        "afterEach1",
+        "runner afterEach2",
+        "runner afterEach1"
+      ];
+      expect(actions).toEqual(expected);
+      done();
+    };
+
+    env.addReporter({jasmineDone: assertions});
+
+    env.execute();
+  });
+
+  it("shouldn't run disabled suites", function(done) {
+    var specInADisabledSuite = jasmine.createSpy("specInADisabledSuite"),
+    suite = env.describe('A Suite', function() {
+      env.xdescribe('with a disabled suite', function(){
+        env.it('spec inside a disabled suite', specInADisabledSuite);
+      });
+    });
+
+    suite.execute(function() {
+      expect(specInADisabledSuite).not.toHaveBeenCalled();
+      done();
+    });
+  });
+
+  it("should set all pending specs to pending when a suite is run", function(done) {
+    var pendingSpec,
+      suite = env.describe('default current suite', function() {
+        pendingSpec = env.it("I am a pending spec");
+      });
+
+    suite.execute(function() {
+      expect(pendingSpec.status()).toBe("pending");
+      done();
+    });
+  });
+
+
+  // TODO: is this useful? It doesn't catch syntax errors
+  xit("should recover gracefully when there are errors in describe functions", function() {
+    var specs = [];
+    var superSimpleReporter = new j$.Reporter();
+    superSimpleReporter.reportSpecResults = function(result) {
+      specs.push("Spec: " + result.fullName);
+    };
+
+    try {
+      env.describe("outer1", function() {
+        env.describe("inner1", function() {
+          env.it("should thingy", function() {
+            this.expect(true).toEqual(true);
+          });
+
+          throw new Error("fake error");
+        });
+
+        env.describe("inner2", function() {
+          env.it("should other thingy", function() {
+            this.expect(true).toEqual(true);
+          });
+        });
+
+        throw new Error("fake error");
+
+      });
+    } catch(e) {
+    }
+
+    env.describe("outer2", function() {
+      env.it("should xxx", function() {
+        this.expect(true).toEqual(true);
+      });
+    });
+
+    env.addReporter(superSimpleReporter);
+    env.execute();
+
+    expect(specs.join('')).toMatch(new RegExp(
+      'Spec: outer1 inner1 should thingy.' +
+      'Spec: outer1 inner1 encountered a declaration exception.' +
+      'Spec: outer1 inner2 should other thingy.' +
+      'Spec: outer1 encountered a declaration exception.' +
+      'Spec: outer2 should xxx.'
+    ));
+
+  });
+});

data/spec_app/vendor/assets/bower_components/jasmine/spec/core/matchers/matchersUtilSpec.js

@@ -0,0 +1,239 @@
+describe("matchersUtil", function() {
+  describe("equals", function() {
+    it("passes for literals that are triple-equal", function() {
+      expect(j$.matchersUtil.equals(null, null)).toBe(true);
+      expect(j$.matchersUtil.equals(void 0, void 0)).toBe(true);
+    });
+
+    it("fails for things that are not equivalent", function() {
+      expect(j$.matchersUtil.equals({a: "foo"}, 1)).toBe(false);
+    });
+
+    it("passes for Strings that are equivalent", function() {
+      expect(j$.matchersUtil.equals("foo", "foo")).toBe(true);
+    });
+
+    it("fails for Strings that are not equivalent", function() {
+      expect(j$.matchersUtil.equals("foo", "bar")).toBe(false);
+    });
+
+    it("passes for Numbers that are equivalent", function() {
+      expect(j$.matchersUtil.equals(123, 123)).toBe(true);
+    });
+
+    it("fails for Numbers that are not equivalent", function() {
+      expect(j$.matchersUtil.equals(123, 456)).toBe(false);
+    });
+
+    it("passes for Dates that are equivalent", function() {
+      expect(j$.matchersUtil.equals(new Date("Jan 1, 1970"), new Date("Jan 1, 1970"))).toBe(true);
+    });
+
+    it("fails for Dates that are not equivalent", function() {
+      expect(j$.matchersUtil.equals(new Date("Jan 1, 1970"), new Date("Feb 3, 1991"))).toBe(false);
+    });
+
+    it("passes for Booleans that are equivalent", function() {
+      expect(j$.matchersUtil.equals(true, true)).toBe(true);
+    });
+
+    it("fails for Booleans that are not equivalent", function() {
+      expect(j$.matchersUtil.equals(true, false)).toBe(false);
+    });
+
+    it("passes for RegExps that are equivalent", function() {
+      expect(j$.matchersUtil.equals(/foo/, /foo/)).toBe(true);
+    });
+
+    it("fails for RegExps that are not equivalent", function() {
+      expect(j$.matchersUtil.equals(/foo/, /bar/)).toBe(false);
+      expect(j$.matchersUtil.equals(new RegExp("foo", "i"), new RegExp("foo"))).toBe(false);
+    });
+
+    it("passes for Arrays that are equivalent", function() {
+      expect(j$.matchersUtil.equals([1, 2], [1, 2])).toBe(true);
+    });
+
+    it("fails for Arrays that are not equivalent", function() {
+      expect(j$.matchersUtil.equals([1, 2], [1, 2, 3])).toBe(false);
+    });
+
+    it("passes for Errors that are the same type and have the same message", function() {
+      expect(j$.matchersUtil.equals(new Error("foo"), new Error("foo"))).toBe(true);
+    });
+
+    it("fails for Errors that are the same type and have different messages", function() {
+      expect(j$.matchersUtil.equals(new Error("foo"), new Error("bar"))).toBe(false);
+    });
+
+    it("passes for Objects that are equivalent (simple case)", function() {
+      expect(j$.matchersUtil.equals({a: "foo"}, {a: "foo"})).toBe(true);
+    });
+
+    it("fails for Objects that are not equivalent (simple case)", function() {
+      expect(j$.matchersUtil.equals({a: "foo"}, {a: "bar"})).toBe(false);
+    });
+
+    it("passes for Objects that are equivalent (deep case)", function() {
+      expect(j$.matchersUtil.equals({a: "foo", b: { c: "bar"}}, {a: "foo", b: { c: "bar"}})).toBe(true);
+    });
+
+    it("fails for Objects that are not equivalent (deep case)", function() {
+      expect(j$.matchersUtil.equals({a: "foo", b: { c: "baz"}}, {a: "foo", b: { c: "bar"}})).toBe(false);
+    });
+
+    it("passes for Objects that are equivalent (with cycles)", function() {
+      var actual = { a: "foo" },
+        expected = { a: "foo" };
+
+      actual.b = actual;
+      expected.b = actual;
+
+      expect(j$.matchersUtil.equals(actual, expected)).toBe(true);
+    });
+
+    it("fails for Objects that are not equivalent (with cycles)", function() {
+      var actual = { a: "foo" },
+        expected = { a: "bar" };
+
+      actual.b = actual;
+      expected.b = actual;
+
+      expect(j$.matchersUtil.equals(actual, expected)).toBe(false);
+    });
+
+    it("fails when comparing an empty object to an empty array (issue #114)", function() {
+      var emptyObject = {},
+        emptyArray = [];
+
+      expect(j$.matchersUtil.equals(emptyObject, emptyArray)).toBe(false);
+      expect(j$.matchersUtil.equals(emptyArray, emptyObject)).toBe(false);
+    });
+
+    it("passes for equivalent frozen objects (GitHub issue #266)", function() {
+      if (jasmine.getEnv().ieVersion < 9) { return; }
+
+      var a = { foo: 1 },
+        b = {foo: 1 };
+
+      Object.freeze(a);
+      Object.freeze(b);
+
+      expect(j$.matchersUtil.equals(a,b)).toBe(true);
+    });
+
+    it("passes when Any is used", function() {
+      var number = 3,
+        anyNumber = new j$.Any(Number);
+
+      expect(j$.matchersUtil.equals(number, anyNumber)).toBe(true);
+      expect(j$.matchersUtil.equals(anyNumber, number)).toBe(true);
+    });
+
+    it("fails when Any is compared to something unexpected", function() {
+      var number = 3,
+        anyString = new j$.Any(String);
+
+      expect(j$.matchersUtil.equals(number, anyString)).toBe(false);
+      expect(j$.matchersUtil.equals(anyString, number)).toBe(false);
+    });
+
+    it("passes when ObjectContaining is used", function() {
+      var obj = {
+        foo: 3,
+        bar: 7
+      };
+
+      expect(j$.matchersUtil.equals(obj, new j$.ObjectContaining({foo: 3}))).toBe(true);
+    });
+
+    it("passes when a custom equality matcher returns true", function() {
+      var tester = function(a, b) { return true; };
+
+      expect(j$.matchersUtil.equals(1, 2, [tester])).toBe(true);
+    });
+
+    it("passes for two empty Objects", function () {
+      expect(j$.matchersUtil.equals({}, {})).toBe(true);
+    });
+
+    describe("when a custom equality matcher is installed that returns 'undefined'", function () {
+      var tester = function(a, b) { return jasmine.undefined; };
+
+      it("passes for two empty Objects", function () {
+        expect(j$.matchersUtil.equals({}, {}, [tester])).toBe(true);
+      });
+    });
+
+    it("fails for equivalents when a custom equality matcher returns false", function() {
+      var tester = function(a, b) { return false; };
+
+      expect(j$.matchersUtil.equals(1, 1, [tester])).toBe(false);
+    });
+  });
+
+  describe("contains", function() {
+    it("passes when expected is a substring of actual", function() {
+      expect(j$.matchersUtil.contains("ABC", "B")).toBe(true);
+    });
+
+    it("fails when expected is a not substring of actual", function() {
+      expect(j$.matchersUtil.contains("ABC", "X")).toBe(false);
+    });
+
+    it("passes when expected is an element in an actual array", function() {
+      expect(j$.matchersUtil.contains(['foo', 'bar'], 'foo')).toBe(true);
+    });
+
+    it("fails when expected is not an element in an actual array", function() {
+      expect(j$.matchersUtil.contains(['foo', 'bar'], 'baz')).toBe(false);
+    });
+
+    it("passes with mixed-element arrays", function() {
+      expect(j$.matchersUtil.contains(["foo", {some: "bar"}], "foo")).toBe(true);
+      expect(j$.matchersUtil.contains(["foo", {some: "bar"}], {some: "bar"})).toBe(true);
+    });
+
+    it("uses custom equality testers if passed in and actual is an Array", function() {
+      var customTester = function(a, b) {return true;};
+
+      expect(j$.matchersUtil.contains([1, 2], 2, [customTester])).toBe(true);
+    });
+
+    it("fails when actual is undefined", function() {
+      expect(j$.matchersUtil.contains(undefined, 'A')).toBe(false);
+    });
+
+    it("fails when actual is null", function() {
+      expect(j$.matchersUtil.contains(null, 'A')).toBe(false);
+    });
+  });
+
+  describe("buildMessage", function() {
+
+    it("builds an English sentence for a failure case", function() {
+      var actual = "foo",
+        name = "toBar",
+        message = j$.matchersUtil.buildFailureMessage(name, false, actual);
+
+      expect(message).toEqual("Expected 'foo' to bar.");
+    });
+
+    it("builds an English sentence for a 'not' failure case", function() {
+      var actual = "foo",
+        name = "toBar",
+        isNot = true,
+        message = message = j$.matchersUtil.buildFailureMessage(name, isNot, actual);
+
+      expect(message).toEqual("Expected 'foo' not to bar.");
+    });
+
+    it("builds an English sentence for an arbitrary array of expected arguments", function() {
+      var actual = "foo",
+        name = "toBar",
+        message = j$.matchersUtil.buildFailureMessage(name, false, actual, "quux", "corge");
+
+      expect(message).toEqual("Expected 'foo' to bar 'quux', 'corge'.");
+    });
+  });
+});

data/spec_app/vendor/assets/bower_components/jasmine/spec/core/matchers/toBeCloseToSpec.js

@@ -0,0 +1,51 @@
+describe("toBeCloseTo", function() {
+  it("passes when within two decimal places by default", function() {
+    var matcher = j$.matchers.toBeCloseTo(),
+      result;
+
+    result = matcher.compare(0, 0);
+    expect(result.pass).toBe(true);
+
+    result = matcher.compare(0, 0.001);
+    expect(result.pass).toBe(true);
+  });
+
+  it("fails when not within two decimal places by default", function() {
+    var matcher = j$.matchers.toBeCloseTo(),
+      result;
+
+    result = matcher.compare(0, 0.01);
+    expect(result.pass).toBe(false);
+  });
+
+  it("accepts an optional precision argument", function() {
+    var matcher = j$.matchers.toBeCloseTo(),
+      result;
+
+    result = matcher.compare(0, 0.1, 0);
+    expect(result.pass).toBe(true);
+
+    result = matcher.compare(0, 0.0001, 3);
+    expect(result.pass).toBe(true);
+  });
+
+  it("rounds expected values", function() {
+    var matcher = j$.matchers.toBeCloseTo(),
+      result;
+
+    result = matcher.compare(1.23, 1.229);
+    expect(result.pass).toBe(true);
+
+    result = matcher.compare(1.23, 1.226);
+    expect(result.pass).toBe(true);
+
+    result = matcher.compare(1.23, 1.225);
+    expect(result.pass).toBe(true);
+
+    result = matcher.compare(1.23, 1.2249999);
+    expect(result.pass).toBe(false);
+
+    result = matcher.compare(1.23, 1.234);
+    expect(result.pass).toBe(true);
+  });
+});

data/spec_app/vendor/assets/bower_components/jasmine/spec/core/matchers/toBeDefinedSpec.js

@@ -0,0 +1,18 @@
+describe("toBeDefined", function() {
+  it("matches for defined values", function() {
+    var matcher = j$.matchers.toBeDefined(),
+      result;
+
+
+    result = matcher.compare('foo');
+    expect(result.pass).toBe(true);
+  });
+
+  it("fails when matching undefined values", function() {
+    var matcher = j$.matchers.toBeDefined(),
+      result;
+
+    result = matcher.compare(void 0);
+    expect(result.pass).toBe(false);
+  })
+});

data/spec_app/vendor/assets/bower_components/jasmine/spec/core/matchers/toBeFalsySpec.js

@@ -0,0 +1,38 @@
+describe("toBeFalsy", function() {
+  it("passes for 'falsy' values", function() {
+    var matcher = j$.matchers.toBeFalsy(),
+      result;
+
+    result = matcher.compare(false);
+    expect(result.pass).toBe(true);
+
+    result = matcher.compare(0);
+    expect(result.pass).toBe(true);
+
+    result = matcher.compare('');
+    expect(result.pass).toBe(true);
+
+    result = matcher.compare(null);
+    expect(result.pass).toBe(true);
+
+    result = matcher.compare(void 0);
+    expect(result.pass).toBe(true);
+  });
+
+  it("fails for 'truthy' values", function() {
+    var matcher = j$.matchers.toBeFalsy(),
+      result;
+
+    result = matcher.compare(true);
+    expect(result.pass).toBe(false);
+
+    result = matcher.compare(1);
+    expect(result.pass).toBe(false);
+
+    result = matcher.compare("foo");
+    expect(result.pass).toBe(false);
+
+    result = matcher.compare({});
+    expect(result.pass).toBe(false);
+  });
+});

data/spec_app/vendor/assets/bower_components/jasmine/spec/core/matchers/toBeGreaterThanSpec.js

@@ -0,0 +1,20 @@
+describe("toBeGreaterThan", function() {
+  it("passes when actual > expected", function() {
+    var matcher = j$.matchers.toBeGreaterThan(),
+      result;
+
+    result = matcher.compare(2, 1);
+    expect(result.pass).toBe(true);
+  });
+
+  it("fails when actual <= expected", function() {
+    var matcher = j$.matchers.toBeGreaterThan(),
+      result;
+
+    result = matcher.compare(1, 1);
+    expect(result.pass).toBe(false);
+
+    result = matcher.compare(1, 2);
+    expect(result.pass).toBe(false);
+  });
+});

data/spec_app/vendor/assets/bower_components/jasmine/spec/core/matchers/toBeLessThanSpec.js

@@ -0,0 +1,20 @@
+describe("toBeLessThan", function() {
+  it("passes when actual < expected", function() {
+    var matcher = j$.matchers.toBeLessThan(),
+      result;
+
+    result = matcher.compare(1, 2);
+    expect(result.pass).toBe(true);
+  });
+
+  it("fails when actual <= expected", function() {
+    var matcher = j$.matchers.toBeLessThan(),
+      result;
+
+    result = matcher.compare(1, 1);
+    expect(result.pass).toBe(false);
+
+    result = matcher.compare(2, 1);
+    expect(result.pass).toBe(false);
+  });
+});