upjs-rails 0.11.0 → 0.11.1

data/spec_app/vendor/assets/bower_components/jasmine/spec/core/EnvSpec.js

@@ -1,85 +0,0 @@
-// TODO: Fix these unit tests!
-describe("Env", function() {
-  var env;
-  beforeEach(function() {
-    env = new j$.Env();
-  });
-
-  it('removes all spies when env is executed', function(done) {
-    var originalFoo = function() {},
-      testObj = {
-        foo: originalFoo
-      },
-      firstSpec = jasmine.createSpy('firstSpec').and.callFake(function() {
-        env.spyOn(testObj, 'foo');
-      }),
-      secondSpec = jasmine.createSpy('secondSpec').and.callFake(function() {
-        expect(testObj.foo).toBe(originalFoo);
-      });
-      env.describe('test suite', function() {
-        env.it('spec 0', firstSpec);
-        env.it('spec 1', secondSpec);
-      });
-
-    var assertions = function() {
-      expect(firstSpec).toHaveBeenCalled();
-      expect(secondSpec).toHaveBeenCalled();
-      done();
-    };
-
-    env.addReporter({ jasmineDone: assertions });
-
-    env.execute();
-  });
-
-  describe("#spyOn", function() {
-    it("checks for the existence of the object", function() {
-      expect(function() {
-        env.spyOn(void 0, 'pants');
-      }).toThrowError(/could not find an object/);
-    });
-
-    it("checks for the existence of the method", function() {
-      var subject = {};
-
-      expect(function() {
-        env.spyOn(subject, 'pants');
-      }).toThrowError(/method does not exist/);
-    });
-
-    it("checks if it has already been spied upon", function() {
-      var subject = { spiedFunc: function() {} };
-
-      env.spyOn(subject, 'spiedFunc');
-
-      expect(function() {
-        env.spyOn(subject, 'spiedFunc');
-      }).toThrowError(/has already been spied upon/);
-    });
-
-    it("overrides the method on the object and returns the spy", function() {
-      var originalFunctionWasCalled = false;
-      var subject = { spiedFunc: function() { originalFunctionWasCalled = true; } };
-
-      var spy = env.spyOn(subject, 'spiedFunc');
-
-      expect(subject.spiedFunc).toEqual(spy);
-    });
-  });
-
-  describe("#pending", function() {
-    it("throws the Pending Spec exception", function() {
-      expect(function() {
-        env.pending();
-      }).toThrow(j$.Spec.pendingSpecExceptionMessage);
-    });
-  });
-
-  describe("#topSuite", function() {
-    it("returns the Jasmine top suite for users to traverse the spec tree", function() {
-      var suite = env.topSuite();
-      expect(suite.description).toEqual('Jasmine__TopLevel__Suite');
-    });
-  });
-});
-

data/spec_app/vendor/assets/bower_components/jasmine/spec/core/ExceptionFormatterSpec.js

@@ -1,63 +0,0 @@
-describe("ExceptionFormatter", function() {
-  describe("#message", function() {
-    it('formats Firefox exception messages', function() {
-      var sampleFirefoxException = {
-          fileName: 'foo.js',
-          lineNumber: '1978',
-          message: 'you got your foo in my bar',
-          name: 'A Classic Mistake'
-        },
-        exceptionFormatter = new j$.ExceptionFormatter(),
-        message = exceptionFormatter.message(sampleFirefoxException);
-
-      expect(message).toEqual('A Classic Mistake: you got your foo in my bar in foo.js (line 1978)');
-    });
-
-    it('formats Webkit exception messages', function() {
-      var sampleWebkitException = {
-          sourceURL: 'foo.js',
-          line: '1978',
-          message: 'you got your foo in my bar',
-          name: 'A Classic Mistake'
-        },
-        exceptionFormatter = new j$.ExceptionFormatter(),
-        message = exceptionFormatter.message(sampleWebkitException);
-
-      expect(message).toEqual('A Classic Mistake: you got your foo in my bar in foo.js (line 1978)');
-    });
-
-    it('formats V8 exception messages', function() {
-      var sampleV8 = {
-          message: 'you got your foo in my bar',
-          name: 'A Classic Mistake'
-        },
-        exceptionFormatter = new j$.ExceptionFormatter(),
-        message = exceptionFormatter.message(sampleV8);
-
-      expect(message).toEqual('A Classic Mistake: you got your foo in my bar');
-    });
-
-    it("formats thrown exceptions that aren't errors", function() {
-      var thrown = "crazy error",
-          exceptionFormatter = new j$.ExceptionFormatter(),
-          message = exceptionFormatter.message(thrown);
-
-      expect(message).toEqual("crazy error thrown");
-    });
-  });
-
-  describe("#stack", function() {
-    it("formats stack traces from Webkit, Firefox, node.js or IE10+", function() {
-      if (jasmine.getEnv().ieVersion < 10 || jasmine.getEnv().safariVersion < 6) { return; }
-
-      var error;
-      try { throw new Error("an error") } catch(e) { error = e; }
-
-      expect(new j$.ExceptionFormatter().stack(error)).toMatch(/ExceptionFormatterSpec\.js.*\d+/)
-    });
-
-    it("returns null if no Error provided", function() {
-      expect(new j$.ExceptionFormatter().stack()).toBeNull();
-    });
-  });
-});

data/spec_app/vendor/assets/bower_components/jasmine/spec/core/ExceptionsSpec.js

@@ -1,68 +0,0 @@
-describe('Exceptions:', function() {
-  var env;
-
-  beforeEach(function() {
-    env = new j$.Env();
-  });
-
-  describe('with break on exception', function() {
-    it('should not catch the exception', function() {
-      env.catchExceptions(false);
-      env.describe('suite for break on exceptions', function() {
-        env.it('should break when an exception is thrown', function() {
-          throw new Error('I should hit a breakpoint!');
-        });
-      });
-      var spy = jasmine.createSpy('spy');
-
-      try {
-        env.execute();
-        spy();
-      }
-      catch (e) {}
-
-      expect(spy).not.toHaveBeenCalled();
-    });
-  });
-
-  describe("with catch on exception", function() {
-    it('should handle exceptions thrown, but continue', function(done) {
-      var secondTest = jasmine.createSpy('second test');
-      env.describe('Suite for handles exceptions', function () {
-        env.it('should be a test that fails because it throws an exception', function() {
-          throw new Error();
-        });
-        env.it('should be a passing test that runs after exceptions are thrown from a async test', secondTest);
-      });
-
-      var expectations = function() {
-        expect(secondTest).toHaveBeenCalled();
-        done();
-      };
-
-      env.addReporter({ jasmineDone: expectations });
-      env.execute();
-    });
-
-    it("should handle exceptions thrown directly in top-level describe blocks and continue", function(done) {
-      var secondDescribe = jasmine.createSpy("second describe");
-      env.describe("a suite that throws an exception", function () {
-        env.it("is a test that should pass", function () {
-         this.expect(true).toEqual(true);
-        });
-
-        throw new Error("top level error");
-      });
-      env.describe("a suite that doesn't throw an exception", secondDescribe);
-
-      var expectations = function() {
-        expect(secondDescribe).toHaveBeenCalled();
-        done();
-      };
-
-      env.addReporter({ jasmineDone: expectations });
-      env.execute();
-    });
-  });
-});
-

data/spec_app/vendor/assets/bower_components/jasmine/spec/core/ExpectationResultSpec.js

@@ -1,61 +0,0 @@
-describe("buildExpectationResult", function() {
-  it("defaults to passed", function() {
-    var result = j$.buildExpectationResult({passed: 'some-value'});
-    expect(result.passed).toBe('some-value');
-  });
-
-  it("message defaults to Passed for passing specs", function() {
-    var result = j$.buildExpectationResult({passed: true, message: 'some-value'});
-    expect(result.message).toBe('Passed.');
-  });
-
-  it("message returns the message for failing expectations", function() {
-    var result = j$.buildExpectationResult({passed: false, message: 'some-value'});
-    expect(result.message).toBe('some-value');
-  });
-
-  it("delegates message formatting to the provided formatter if there was an Error", function() {
-    var fakeError = {message: 'foo'},
-      messageFormatter = jasmine.createSpy("exception message formatter").and.returnValue(fakeError.message);
-
-    var result = j$.buildExpectationResult(
-      {
-        passed: false,
-        error: fakeError,
-        messageFormatter: messageFormatter
-      });
-
-    expect(messageFormatter).toHaveBeenCalledWith(fakeError);
-    expect(result.message).toEqual('foo');
-  });
-
-  it("delegates stack formatting to the provided formatter if there was an Error", function() {
-    var fakeError = {stack: 'foo'},
-      stackFormatter = jasmine.createSpy("stack formatter").and.returnValue(fakeError.stack);
-
-    var result = j$.buildExpectationResult(
-      {
-        passed: false,
-        error: fakeError,
-        stackFormatter: stackFormatter
-      });
-
-    expect(stackFormatter).toHaveBeenCalledWith(fakeError);
-    expect(result.stack).toEqual('foo');
-  });
-
-  it("matcherName returns passed matcherName", function() {
-    var result = j$.buildExpectationResult({matcherName: 'some-value'});
-    expect(result.matcherName).toBe('some-value');
-  });
-
-  it("expected returns passed expected", function() {
-    var result = j$.buildExpectationResult({expected: 'some-value'});
-    expect(result.expected).toBe('some-value');
-  });
-
-  it("actual returns passed actual", function() {
-    var result = j$.buildExpectationResult({actual: 'some-value'});
-    expect(result.actual).toBe('some-value');
-  });
-});

data/spec_app/vendor/assets/bower_components/jasmine/spec/core/ExpectationSpec.js

@@ -1,427 +0,0 @@
-describe("Expectation", function() {
-  it(".addMatchers makes matchers available to any expectation", function() {
-    var matchers = {
-        toFoo: function() {},
-        toBar: function() {}
-      },
-      expectation;
-
-    j$.Expectation.addMatchers(matchers);
-
-    expectation = new j$.Expectation({});
-
-    expect(expectation.toFoo).toBeDefined();
-    expect(expectation.toBar).toBeDefined();
-  });
-
-  it(".addCoreMatchers makes matchers available to any expectation", function() {
-    var coreMatchers = {
-        toQuux: function() {}
-      },
-      expectation;
-
-    j$.Expectation.addCoreMatchers(coreMatchers);
-
-    expectation = new j$.Expectation({});
-
-    expect(expectation.toQuux).toBeDefined();
-  });
-
-  it(".resetMatchers should keep only core matchers", function() {
-    var matchers = {
-        toFoo: function() {}
-      },
-      coreMatchers = {
-        toQuux: function() {}
-      },
-      expectation;
-
-    j$.Expectation.addCoreMatchers(coreMatchers);
-    j$.Expectation.addMatchers(matchers);
-    j$.Expectation.resetMatchers();
-
-    expectation = new j$.Expectation({});
-
-    expect(expectation.toQuux).toBeDefined();
-    expect(expectation.toFoo).toBeUndefined();
-  });
-
-  it("Factory builds an expectation/negative expectation", function() {
-    var builtExpectation = j$.Expectation.Factory();
-
-    expect(builtExpectation instanceof j$.Expectation).toBe(true);
-    expect(builtExpectation.not instanceof j$.Expectation).toBe(true);
-    expect(builtExpectation.not.isNot).toBe(true);
-  });
-
-  it("wraps matchers's compare functions, passing in matcher dependencies", function() {
-    var fakeCompare = function() { return { pass: true }; },
-      matcherFactory = jasmine.createSpy("matcher").and.returnValue({ compare: fakeCompare }),
-      matchers = {
-        toFoo: matcherFactory
-      },
-      util = {},
-      customEqualityTesters = ['a'],
-      addExpectationResult = jasmine.createSpy("addExpectationResult"),
-      expectation;
-
-    j$.Expectation.addMatchers(matchers);
-
-    expectation = new j$.Expectation({
-      util: util,
-      customEqualityTesters: customEqualityTesters,
-      actual: "an actual",
-      addExpectationResult: addExpectationResult
-    });
-
-    expectation.toFoo("hello");
-
-    expect(matcherFactory).toHaveBeenCalledWith(util, customEqualityTesters)
-  });
-
-  it("wraps matchers's compare functions, passing the actual and expected", function() {
-    var fakeCompare = jasmine.createSpy('fake-compare').and.returnValue({pass: true}),
-      matchers = {
-        toFoo: function() {
-          return {
-            compare: fakeCompare
-          };
-        }
-      },
-      util = {
-        buildFailureMessage: jasmine.createSpy('buildFailureMessage')
-      },
-      addExpectationResult = jasmine.createSpy("addExpectationResult"),
-      expectation;
-
-    j$.Expectation.addMatchers(matchers);
-
-    expectation = new j$.Expectation({
-      util: util,
-      actual: "an actual",
-      addExpectationResult: addExpectationResult
-    });
-
-    expectation.toFoo("hello");
-
-    expect(fakeCompare).toHaveBeenCalledWith("an actual", "hello");
-  });
-
-  it("reports a passing result to the spec when the comparison passes", function() {
-    var matchers = {
-        toFoo: function() {
-          return {
-            compare: function() { return { pass: true }; }
-          };
-        }
-      },
-      util = {
-        buildFailureMessage: jasmine.createSpy('buildFailureMessage')
-      },
-      addExpectationResult = jasmine.createSpy("addExpectationResult"),
-      expectation;
-
-    j$.Expectation.addMatchers(matchers);
-
-    expectation = new j$.Expectation({
-      matchers: matchers,
-      util: util,
-      actual: "an actual",
-      addExpectationResult: addExpectationResult
-    });
-
-    expectation.toFoo("hello");
-
-    expect(addExpectationResult).toHaveBeenCalledWith(true, {
-      matcherName: "toFoo",
-      passed: true,
-      message: "",
-      expected: "hello",
-      actual: "an actual"
-    });
-  });
-
-  it("reports a failing result to the spec when the comparison fails", function() {
-    var matchers = {
-        toFoo: function() {
-          return {
-            compare: function() { return { pass: false }; }
-          };
-        }
-      },
-      util = {
-        buildFailureMessage: function() { return ""; }
-      },
-      addExpectationResult = jasmine.createSpy("addExpectationResult"),
-      expectation;
-
-    j$.Expectation.addMatchers(matchers);
-
-    expectation = new j$.Expectation({
-      matchers: matchers,
-      util: util,
-      actual: "an actual",
-      addExpectationResult: addExpectationResult
-    });
-
-    expectation.toFoo("hello");
-
-    expect(addExpectationResult).toHaveBeenCalledWith(false, {
-      matcherName: "toFoo",
-      passed: false,
-      expected: "hello",
-      actual: "an actual",
-      message: ""
-    });
-  });
-
-  it("reports a failing result and a custom fail message to the spec when the comparison fails", function() {
-    var matchers = {
-        toFoo: function() {
-          return {
-            compare: function() {
-              return {
-                pass: false,
-                message: "I am a custom message"
-              };
-            }
-          };
-        }
-      },
-      addExpectationResult = jasmine.createSpy("addExpectationResult"),
-      expectation;
-
-    j$.Expectation.addMatchers(matchers);
-
-    expectation = new j$.Expectation({
-      actual: "an actual",
-      addExpectationResult: addExpectationResult
-    });
-
-    expectation.toFoo("hello");
-
-    expect(addExpectationResult).toHaveBeenCalledWith(false, {
-      matcherName: "toFoo",
-      passed: false,
-      expected: "hello",
-      actual: "an actual",
-      message: "I am a custom message"
-    });
-  });
-
-  it("reports a failing result with a custom fail message function to the spec when the comparison fails", function() {
-    var matchers = {
-        toFoo: function() {
-          return {
-            compare: function() {
-              return {
-                pass: false,
-                message: function() { return "I am a custom message"; }
-              };
-            }
-          };
-        }
-      },
-      addExpectationResult = jasmine.createSpy("addExpectationResult"),
-      expectation;
-
-    j$.Expectation.addMatchers(matchers);
-
-    expectation = new j$.Expectation({
-      matchers: matchers,
-      actual: "an actual",
-      addExpectationResult: addExpectationResult
-    });
-
-    expectation.toFoo("hello");
-
-    expect(addExpectationResult).toHaveBeenCalledWith(false, {
-      matcherName: "toFoo",
-      passed: false,
-      expected: "hello",
-      actual: "an actual",
-      message: "I am a custom message"
-    });
-  });
-
-  it("reports a passing result to the spec when the comparison fails for a negative expectation", function() {
-    var matchers = {
-        toFoo: function() {
-          return {
-            compare: function() { return { pass: false }; }
-          };
-        }
-      },
-      util = {
-        buildFailureMessage: function() { return ""; }
-      },
-      addExpectationResult = jasmine.createSpy("addExpectationResult"),
-      actual = "an actual",
-      expectation;
-
-    j$.Expectation.addMatchers(matchers);
-
-    expectation = new j$.Expectation({
-      matchers: matchers,
-      actual: "an actual",
-      addExpectationResult: addExpectationResult,
-      isNot: true
-    });
-
-    expectation.toFoo("hello");
-
-    expect(addExpectationResult).toHaveBeenCalledWith(true, {
-      matcherName: "toFoo",
-      passed: true,
-      message: "",
-      expected: "hello",
-      actual: actual
-    });
-  });
-
-  it("reports a failing result to the spec when the comparison passes for a negative expectation", function() {
-    var matchers = {
-        toFoo: function() {
-          return {
-            compare: function() { return { pass: true }; }
-          };
-        }
-      },
-      util = {
-        buildFailureMessage: function() { return "default message"; }
-      },
-      addExpectationResult = jasmine.createSpy("addExpectationResult"),
-      actual = "an actual",
-      expectation;
-
-    j$.Expectation.addMatchers(matchers);
-
-    expectation = new j$.Expectation({
-      matchers: matchers,
-      actual: "an actual",
-      util: util,
-      addExpectationResult: addExpectationResult,
-      isNot: true
-    });
-
-    expectation.toFoo("hello");
-
-    expect(addExpectationResult).toHaveBeenCalledWith(false, {
-      matcherName: "toFoo",
-      passed: false,
-      expected: "hello",
-      actual: actual,
-      message: "default message"
-    });
-  });
-
-  it("reports a failing result and a custom fail message to the spec when the comparison passes for a negative expectation", function() {
-    var matchers = {
-        toFoo: function() {
-          return {
-            compare: function() {
-              return {
-                pass: true,
-                message: "I am a custom message"
-              };
-            }
-          };
-        }
-      },
-      addExpectationResult = jasmine.createSpy("addExpectationResult"),
-      actual = "an actual",
-      expectation;
-
-    j$.Expectation.addMatchers(matchers);
-
-    expectation = new j$.Expectation({
-      matchers: matchers,
-      actual: "an actual",
-      addExpectationResult: addExpectationResult,
-      isNot: true
-    });
-
-    expectation.toFoo("hello");
-
-    expect(addExpectationResult).toHaveBeenCalledWith(false, {
-      matcherName: "toFoo",
-      passed: false,
-      expected: "hello",
-      actual: actual,
-      message: "I am a custom message"
-    });
-  });
-
-  it("reports a passing result to the spec when the 'not' comparison passes, given a negativeCompare", function() {
-    var matchers = {
-        toFoo: function() {
-          return {
-            compare: function() { return { pass: true }; },
-            negativeCompare: function() { return { pass: true }; }
-          };
-        }
-      },
-      addExpectationResult = jasmine.createSpy("addExpectationResult"),
-      actual = "an actual",
-      expectation;
-
-    j$.Expectation.addMatchers(matchers);
-
-    expectation = new j$.Expectation({
-      matchers: matchers,
-      actual: "an actual",
-      addExpectationResult: addExpectationResult,
-      isNot: true
-    });
-
-    expectation.toFoo("hello");
-
-    expect(addExpectationResult).toHaveBeenCalledWith(true, {
-      matcherName: "toFoo",
-      passed: true,
-      expected: "hello",
-      actual: actual,
-      message: ""
-    });
-  });
-
-  it("reports a failing result and a custom fail message to the spec when the 'not' comparison fails, given a negativeCompare", function() {
-    var matchers = {
-        toFoo: function() {
-          return {
-            compare: function() { return { pass: true }; },
-            negativeCompare: function() {
-              return {
-                pass: false,
-                message: "I'm a custom message"
-              };
-            }
-          };
-        }
-      },
-      addExpectationResult = jasmine.createSpy("addExpectationResult"),
-      actual = "an actual",
-      expectation;
-
-    j$.Expectation.addMatchers(matchers);
-
-    expectation = new j$.Expectation({
-      matchers: matchers,
-      actual: "an actual",
-      addExpectationResult: addExpectationResult,
-      isNot: true
-    });
-
-    expectation.toFoo("hello");
-
-    expect(addExpectationResult).toHaveBeenCalledWith(false, {
-      matcherName: "toFoo",
-      passed: false,
-      expected: "hello",
-      actual: actual,
-      message: "I'm a custom message"
-    });
-  });
-
-});
-