upjs-rails 0.11.0 → 0.11.1

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

@@ -1,271 +0,0 @@
-describe("QueueRunner", function() {
-
-  it("runs all the functions it's passed", function() {
-    var calls = [],
-      fn1 = jasmine.createSpy('fn1'),
-      fn2 = jasmine.createSpy('fn2'),
-      queueRunner = new j$.QueueRunner({
-        fns: [fn1, fn2]
-      });
-    fn1.and.callFake(function() {
-      calls.push('fn1');
-    });
-    fn2.and.callFake(function() {
-      calls.push('fn2');
-    });
-
-    queueRunner.execute();
-
-    expect(calls).toEqual(['fn1', 'fn2']);
-  });
-
-  it("calls each function with a consistent 'this'-- an empty object", function() {
-    var fn1 = jasmine.createSpy('fn1'),
-        fn2 = jasmine.createSpy('fn2'),
-        fn3 = function(done) { asyncContext = this; done(); },
-        queueRunner = new j$.QueueRunner({
-          fns: [fn1, fn2, fn3]
-        }),
-        asyncContext;
-
-    queueRunner.execute();
-
-    var context = fn1.calls.first().object;
-    expect(context).toEqual({});
-    expect(fn2.calls.first().object).toBe(context);
-    expect(asyncContext).toBe(context);
-  });
-
-  describe("with an asynchronous function", function() {
-    beforeEach(function() {
-      jasmine.clock().install();
-    });
-
-    afterEach(function() {
-      jasmine.clock().uninstall();
-    });
-
-    it("supports asynchronous functions, only advancing to next function after a done() callback", function() {
-      //TODO: it would be nice if spy arity could match the fake, so we could do something like:
-      //createSpy('asyncfn').and.callFake(function(done) {});
-
-      var onComplete = jasmine.createSpy('onComplete'),
-        beforeCallback = jasmine.createSpy('beforeCallback'),
-        fnCallback = jasmine.createSpy('fnCallback'),
-        afterCallback = jasmine.createSpy('afterCallback'),
-        fn1 = function(done) {
-          beforeCallback();
-          setTimeout(done, 100);
-        },
-        fn2 = function(done) {
-          fnCallback();
-          setTimeout(done, 100);
-        },
-        fn3 = function(done) {
-          afterCallback();
-          setTimeout(done, 100);
-        },
-        queueRunner = new j$.QueueRunner({
-          fns: [fn1, fn2, fn3],
-          onComplete: onComplete
-        });
-
-      queueRunner.execute();
-
-      expect(beforeCallback).toHaveBeenCalled();
-      expect(fnCallback).not.toHaveBeenCalled();
-      expect(afterCallback).not.toHaveBeenCalled();
-      expect(onComplete).not.toHaveBeenCalled();
-
-      jasmine.clock().tick(100);
-
-      expect(fnCallback).toHaveBeenCalled();
-      expect(afterCallback).not.toHaveBeenCalled();
-      expect(onComplete).not.toHaveBeenCalled();
-
-      jasmine.clock().tick(100);
-
-      expect(afterCallback).toHaveBeenCalled();
-      expect(onComplete).not.toHaveBeenCalled();
-
-      jasmine.clock().tick(100);
-
-      expect(onComplete).toHaveBeenCalled();
-    });
-
-    it("sets a timeout if requested for asynchronous functions so they don't go on forever", function() {
-      var beforeFn = function(done) { },
-        fn = jasmine.createSpy('fn'),
-        onComplete = jasmine.createSpy('onComplete'),
-        onException = jasmine.createSpy('onException'),
-        queueRunner = new j$.QueueRunner({
-          fns: [beforeFn, fn],
-          onComplete: onComplete,
-          onException: onException,
-          enforceTimeout: function() { return true; }
-        });
-
-      queueRunner.execute();
-      expect(fn).not.toHaveBeenCalled();
-
-      jasmine.clock().tick(j$.DEFAULT_TIMEOUT_INTERVAL);
-
-      expect(onException).toHaveBeenCalledWith(jasmine.any(Error));
-      expect(fn).toHaveBeenCalled();
-      expect(onComplete).toHaveBeenCalled();
-    });
-
-    it("by default does not set a timeout for asynchronous functions", function() {
-      var beforeFn = function(done) { },
-        fn = jasmine.createSpy('fn'),
-        onComplete = jasmine.createSpy('onComplete'),
-        onException = jasmine.createSpy('onException'),
-        queueRunner = new j$.QueueRunner({
-          fns: [beforeFn, fn],
-          onComplete: onComplete,
-          onException: onException,
-        });
-
-      queueRunner.execute();
-      expect(fn).not.toHaveBeenCalled();
-
-      jasmine.clock().tick(j$.DEFAULT_TIMEOUT_INTERVAL);
-
-      expect(onException).not.toHaveBeenCalled();
-      expect(fn).not.toHaveBeenCalled();
-      expect(onComplete).not.toHaveBeenCalled();
-    });
-
-    it("clears the timeout when an async function throws an exception, to prevent additional onException calls", function() {
-       var fn = function(done) { throw new Error("error!"); },
-        onComplete = jasmine.createSpy('onComplete'),
-        onException = jasmine.createSpy('onException'),
-        queueRunner = new j$.QueueRunner({
-          fns: [fn],
-          onComplete: onComplete,
-          onException: onException
-        });
-
-      queueRunner.execute();
-
-      expect(onComplete).toHaveBeenCalled();
-      expect(onException).toHaveBeenCalled();
-
-      jasmine.clock().tick(j$.DEFAULT_TIMEOUT_INTERVAL);
-      expect(onException.calls.count()).toEqual(1);
-    });
-
-    it("clears the timeout when the done callback is called", function() {
-      var fn = function(done) { done(); },
-        onComplete = jasmine.createSpy('onComplete'),
-        onException = jasmine.createSpy('onException'),
-        queueRunner = new j$.QueueRunner({
-          fns: [fn],
-          onComplete: onComplete,
-          onException: onException
-        });
-
-      queueRunner.execute();
-
-      expect(onComplete).toHaveBeenCalled();
-
-      jasmine.clock().tick(j$.DEFAULT_TIMEOUT_INTERVAL);
-      expect(onException).not.toHaveBeenCalled();
-    });
-
-    it("only moves to the next spec the first time you call done", function() {
-      var fn = function(done) {done(); done();},
-        nextFn = jasmine.createSpy('nextFn');
-      queueRunner = new j$.QueueRunner({
-        fns: [fn, nextFn]
-      });
-
-      queueRunner.execute();
-      expect(nextFn.calls.count()).toEqual(1);
-    });
-
-    it("does not move to the next spec if done is called after an exception has ended the spec", function() {
-       var fn = function(done) {
-         setTimeout(done, 1);
-         throw new Error('error!');
-       },
-        nextFn = jasmine.createSpy('nextFn');
-      queueRunner = new j$.QueueRunner({
-        fns: [fn, nextFn]
-      });
-
-      queueRunner.execute();
-      jasmine.clock().tick(1);
-      expect(nextFn.calls.count()).toEqual(1);
-    });
-  });
-
-  it("calls an exception handler when an exception is thrown in a fn", function() {
-    var fn = function() {
-        throw new Error('fake error');
-      },
-      exceptionCallback = jasmine.createSpy('exception callback'),
-      queueRunner = new j$.QueueRunner({
-        fns: [fn],
-        onException: exceptionCallback
-      });
-
-    queueRunner.execute();
-
-    expect(exceptionCallback).toHaveBeenCalledWith(jasmine.any(Error));
-  });
-
-  it("rethrows an exception if told to", function() {
-    var fn = function() {
-        throw new Error('fake error');
-      },
-      queueRunner = new j$.QueueRunner({
-        fns: [fn],
-        catchException: function(e) { return false; }
-      });
-
-    expect(queueRunner.execute).toThrow();
-  });
-
-  it("continues running the functions even after an exception is thrown in an async spec", function() {
-    var fn = function(done) { throw new Error("error"); },
-      nextFn = jasmine.createSpy("nextFunction"),
-      queueRunner = new j$.QueueRunner({
-        fns: [fn, nextFn]
-      });
-
-    queueRunner.execute();
-    expect(nextFn).toHaveBeenCalled();
-  });
-
-  it("calls a provided complete callback when done", function() {
-    var fn = jasmine.createSpy('fn'),
-      completeCallback = jasmine.createSpy('completeCallback'),
-      queueRunner = new j$.QueueRunner({
-        fns: [fn],
-        onComplete: completeCallback
-      });
-
-    queueRunner.execute();
-
-    expect(completeCallback).toHaveBeenCalled();
-  });
-
-  it("calls a provided stack clearing function when done", function() {
-    var asyncFn = function(done) { done() },
-        afterFn = jasmine.createSpy('afterFn'),
-        completeCallback = jasmine.createSpy('completeCallback'),
-        clearStack = jasmine.createSpy('clearStack'),
-        queueRunner = new j$.QueueRunner({
-          fns: [asyncFn, afterFn],
-          clearStack: clearStack,
-          onComplete: completeCallback
-        });
-
-    clearStack.and.callFake(function(fn) { fn(); });
-
-    queueRunner.execute();
-    expect(afterFn).toHaveBeenCalled();
-    expect(clearStack).toHaveBeenCalledWith(completeCallback);
-  });
-});

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

@@ -1,40 +0,0 @@
-describe("ReportDispatcher", function() {
-
-  it("builds an interface of requested methods", function() {
-    var dispatcher = new j$.ReportDispatcher(['foo', 'bar', 'baz']);
-
-    expect(dispatcher.foo).toBeDefined();
-    expect(dispatcher.bar).toBeDefined();
-    expect(dispatcher.baz).toBeDefined();
-  });
-
-  it("dispatches requested methods to added reporters", function() {
-    var dispatcher = new j$.ReportDispatcher(['foo', 'bar']),
-      reporter = jasmine.createSpyObj('reporter', ['foo', 'bar']),
-      anotherReporter = jasmine.createSpyObj('reporter', ['foo', 'bar']);
-
-    dispatcher.addReporter(reporter);
-    dispatcher.addReporter(anotherReporter);
-
-    dispatcher.foo(123, 456);
-
-    expect(reporter.foo).toHaveBeenCalledWith(123, 456);
-    expect(anotherReporter.foo).toHaveBeenCalledWith(123, 456);
-
-    dispatcher.bar('a', 'b');
-
-    expect(reporter.bar).toHaveBeenCalledWith('a', 'b');
-    expect(anotherReporter.bar).toHaveBeenCalledWith('a', 'b');
-  });
-
-  it("does not dispatch to a reporter if the reporter doesn't accept the method", function() {
-    var dispatcher = new j$.ReportDispatcher(['foo']),
-      reporter = jasmine.createSpyObj('reporter', ['baz']);
-
-    dispatcher.addReporter(reporter);
-
-    expect(function() {
-      dispatcher.foo(123, 456);
-    }).not.toThrow();
-  });
-});

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

@@ -1,260 +0,0 @@
-describe("Spec", function() {
-
-  it("#isPendingSpecException returns true for a pending spec exception", function() {
-    var e = new Error(j$.Spec.pendingSpecExceptionMessage);
-
-    expect(j$.Spec.isPendingSpecException(e)).toBe(true);
-  });
-
-  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; }
-    };
-
-    expect(j$.Spec.isPendingSpecException(fakeError)).toBe(true);
-  });
-
-  it("#isPendingSpecException returns true for a pending spec exception", function() {
-    var e = new Error("foo");
-
-    expect(j$.Spec.isPendingSpecException(e)).toBe(false);
-  });
-
-  it("#isPendingSpecException returns false for thrown values that don't have toString", function() {
-    expect(j$.Spec.isPendingSpecException(void 0)).toBe(false);
-  });
-
-  it("delegates execution to a QueueRunner", function() {
-    var fakeQueueRunner = jasmine.createSpy('fakeQueueRunner'),
-      spec = new j$.Spec({
-        description: 'my test',
-        id: 'some-id',
-        fn: function() {},
-        queueRunnerFactory: fakeQueueRunner
-      });
-
-    spec.execute();
-
-    expect(fakeQueueRunner).toHaveBeenCalled();
-  });
-
-  it("should call the start callback on execution", function() {
-    var fakeQueueRunner = jasmine.createSpy('fakeQueueRunner'),
-      startCallback = jasmine.createSpy('startCallback'),
-      spec = new j$.Spec({
-        id: 123,
-        description: 'foo bar',
-        fn: function() {},
-        onStart: startCallback,
-        queueRunnerFactory: fakeQueueRunner
-      });
-
-    spec.execute();
-
-    // TODO: due to some issue with the Pretty Printer, this line fails, but the other two pass.
-    // This means toHaveBeenCalledWith on IE8 will always be broken.
-
-    //   expect(startCallback).toHaveBeenCalledWith(spec);
-    expect(startCallback).toHaveBeenCalled();
-    expect(startCallback.calls.first().object).toEqual(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,
-        queueRunnerFactory: fakeQueueRunner
-      });
-
-    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]
-        },
-        queueRunnerFactory: fakeQueueRunner
-      });
-
-    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,
-        queueRunnerFactory: fakeQueueRunner
-      });
-
-
-    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,
-        queueRunnerFactory: fakeQueueRunner
-      });
-
-    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"
-        },
-        queueRunnerFactory: 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: [],
-      passedExpectations: []
-    });
-  });
-
-  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() {},
-        queueRunnerFactory: function(attrs) { attrs.onComplete(); }
-      });
-
-    spec.execute(done);
-
-    expect(done).toHaveBeenCalled();
-  });
-
-  it("#status returns passing by default", function(){
-    var spec = new j$.Spec({ fn: function () {} });
-    expect(spec.status()).toBe("passed");
-  });
-
-  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("keeps track of passed and failed expectations", function() {
-    var resultCallback = jasmine.createSpy('resultCallback'),
-      spec = new j$.Spec({
-        fn: jasmine.createSpy("spec body"),
-        expectationResultFactory: function (data) { return data; },
-        queueRunnerFactory: function(attrs) { attrs.onComplete(); },
-        resultCallback: resultCallback
-      });
-    spec.addExpectationResult(true, 'expectation1');
-    spec.addExpectationResult(false, 'expectation2');
-
-    spec.execute();
-
-    expect(resultCallback.calls.first().args[0].passedExpectations).toEqual(['expectation1']);
-    expect(resultCallback.calls.first().args[0].failedExpectations).toEqual(['expectation2']);
-  });
-
-  it("can return its full name", function() {
-    var specNameSpy = jasmine.createSpy('specNameSpy').and.returnValue('expected val');
-
-    var spec = new j$.Spec({
-      getSpecName: specNameSpy
-    });
-
-    expect(spec.getFullName()).toBe('expected val');
-    expect(specNameSpy.calls.mostRecent().args[0].id).toEqual(spec.id);
-  });
-
-   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() { },
-          queueRunnerFactory: fakeQueueRunner
-        });
-
-      spec.execute();
-
-      expect(spec.status()).toEqual("pending");
-    });
-  });
-});

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

@@ -1,67 +0,0 @@
-describe('Spies', function () {
-  describe("createSpy", function() {
-    var TestClass;
-
-    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);
-
-      expect(spy.bob).toEqual("test");
-    });
-
-    it("warns the user that we intend to overwrite an existing property", function() {
-      TestClass.prototype.someFunction.and = "turkey";
-
-      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("adds a spyStrategy and callTracker to the spy", function() {
-      var spy = j$.createSpy(TestClass.prototype, TestClass.prototype.someFunction);
-
-      expect(spy.and).toEqual(jasmine.any(j$.SpyStrategy));
-      expect(spy.calls).toEqual(jasmine.any(j$.CallTracker));
-    });
-
-    it("tracks the argument of calls", function () {
-      var spy = j$.createSpy(TestClass.prototype, TestClass.prototype.someFunction);
-      var trackSpy = spyOn(spy.calls, "track");
-
-      spy("arg");
-
-      expect(trackSpy.calls.mostRecent().args[0].args).toEqual(["arg"]);
-    });
-
-    it("tracks the context of calls", function () {
-      var spy = j$.createSpy(TestClass.prototype, TestClass.prototype.someFunction);
-      var trackSpy = spyOn(spy.calls, "track");
-
-      var contextObject = { spyMethod: spy };
-      contextObject.spyMethod();
-
-      expect(trackSpy.calls.mostRecent().args[0].object).toEqual(contextObject);
-    });
-  });
-
-  describe("createSpyObj", function() {
-    it("should create an object with a bunch of spy methods when you call jasmine.createSpyObj()", function() {
-      var spyObj = j$.createSpyObj('BaseName', ['method1', 'method2']);
-
-      expect(spyObj).toEqual({ method1: jasmine.any(Function), method2: jasmine.any(Function)});
-      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() {
-        j$.createSpyObj('BaseName');
-      }).toThrow("createSpyObj requires a non-empty array of method names to create spies for");
-    });
-  });
-});