upjs-rails 0.1.0 → 0.2.0

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

@@ -0,0 +1,40 @@
+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

@@ -0,0 +1,260 @@
+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

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

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

@@ -0,0 +1,111 @@
+describe("SpyStrategy", function() {
+
+  it("defaults its name to unknown", function() {
+    var spyStrategy = new j$.SpyStrategy();
+
+    expect(spyStrategy.identity()).toEqual("unknown");
+  });
+
+  it("takes a name", function() {
+    var spyStrategy = new j$.SpyStrategy({name: "foo"});
+
+    expect(spyStrategy.identity()).toEqual("foo");
+  });
+
+  it("stubs an original function, if provided", function() {
+    var originalFn = jasmine.createSpy("original"),
+        spyStrategy = new j$.SpyStrategy({fn: originalFn});
+
+    spyStrategy.exec();
+
+    expect(originalFn).not.toHaveBeenCalled();
+  });
+
+  it("allows an original function to be called, passed through the params and returns it's value", function() {
+    var originalFn = jasmine.createSpy("original").and.returnValue(42),
+        spyStrategy = new j$.SpyStrategy({fn: originalFn}),
+        returnValue;
+
+    spyStrategy.callThrough();
+    returnValue = spyStrategy.exec("foo");
+
+    expect(originalFn).toHaveBeenCalled();
+    expect(originalFn.calls.mostRecent().args).toEqual(["foo"]);
+    expect(returnValue).toEqual(42);
+  });
+
+  it("can return a specified value when executed", function() {
+    var originalFn = jasmine.createSpy("original"),
+        spyStrategy = new j$.SpyStrategy({fn: originalFn}),
+        returnValue;
+
+    spyStrategy.returnValue(17);
+    returnValue = spyStrategy.exec();
+
+    expect(originalFn).not.toHaveBeenCalled();
+    expect(returnValue).toEqual(17);
+  });
+
+  it("allows an exception to be thrown when executed", function() {
+    var originalFn = jasmine.createSpy("original"),
+        spyStrategy = new j$.SpyStrategy({fn: originalFn});
+
+    spyStrategy.throwError(new TypeError("bar"));
+
+    expect(function() { spyStrategy.exec(); }).toThrowError(TypeError, "bar");
+    expect(originalFn).not.toHaveBeenCalled();
+  });
+
+  it("allows a non-Error to be thrown, wrapping it into an exception when executed", function() {
+    var originalFn = jasmine.createSpy("original"),
+        spyStrategy = new j$.SpyStrategy({fn: originalFn});
+
+    spyStrategy.throwError("bar");
+
+    expect(function() { spyStrategy.exec(); }).toThrowError(Error, "bar");
+    expect(originalFn).not.toHaveBeenCalled();
+  });
+
+  it("allows a fake function to be called instead", function() {
+    var originalFn = jasmine.createSpy("original"),
+        fakeFn = jasmine.createSpy("fake").and.returnValue(67),
+        spyStrategy = new j$.SpyStrategy({fn: originalFn}),
+        returnValue;
+
+    spyStrategy.callFake(fakeFn);
+    returnValue = spyStrategy.exec();
+
+    expect(originalFn).not.toHaveBeenCalled();
+    expect(returnValue).toEqual(67);
+  });
+
+  it("allows a return to plan stubbing after another strategy", function() {
+    var originalFn = jasmine.createSpy("original"),
+        fakeFn = jasmine.createSpy("fake").and.returnValue(67),
+        spyStrategy = new j$.SpyStrategy({fn: originalFn}),
+        returnValue;
+
+    spyStrategy.callFake(fakeFn);
+    returnValue = spyStrategy.exec();
+
+    expect(originalFn).not.toHaveBeenCalled();
+    expect(returnValue).toEqual(67);
+    
+    spyStrategy.stub();
+    returnValue = spyStrategy.exec();
+
+    expect(returnValue).toEqual(void 0);
+  });
+
+  it("returns the spy after changing the strategy", function(){
+    var spy = {},
+        spyFn = jasmine.createSpy('spyFn').and.returnValue(spy),
+        spyStrategy = new j$.SpyStrategy({getSpy: spyFn});
+
+    expect(spyStrategy.callThrough()).toBe(spy);
+    expect(spyStrategy.returnValue()).toBe(spy);
+    expect(spyStrategy.throwError()).toBe(spy);
+    expect(spyStrategy.callFake()).toBe(spy);
+    expect(spyStrategy.stub()).toBe(spy);
+  });
+});

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

@@ -0,0 +1,216 @@
+describe("Suite", function() {
+
+  it("keeps its id", function() {
+    var env = new j$.Env(),
+      suite = new j$.Suite({
+        env: env,
+        id: 456,
+        description: "I am a suite"
+      });
+
+    expect(suite.id).toEqual(456);
+  });
+
+  it("returns its full name", function() {
+    var env = new j$.Env(),
+      suite = new j$.Suite({
+        env: env,
+        description: "I am a suite"
+      });
+
+    expect(suite.getFullName()).toEqual("I am a suite");
+  });
+
+  it("returns its full name when it has parent suites", function() {
+    var env = new j$.Env(),
+      parentSuite = new j$.Suite({
+        env: env,
+        description: "I am a parent suite",
+        parentSuite: jasmine.createSpy('pretend top level suite')
+      }),
+      suite = new j$.Suite({
+        env: env,
+        description: "I am a suite",
+        parentSuite: parentSuite
+      });
+
+    expect(suite.getFullName()).toEqual("I am a parent suite I am a suite");
+  });
+
+  it("adds before functions in order of needed execution", function() {
+    var env = new j$.Env(),
+      suite = new j$.Suite({
+        env: env,
+        description: "I am a suite"
+      }),
+      outerBefore = jasmine.createSpy('outerBeforeEach'),
+      innerBefore = jasmine.createSpy('insideBeforeEach');
+
+    suite.beforeEach(outerBefore);
+    suite.beforeEach(innerBefore);
+
+    expect(suite.beforeFns).toEqual([innerBefore, outerBefore]);
+  });
+
+  it("adds after functions in order of needed execution", function() {
+    var env = new j$.Env(),
+      suite = new j$.Suite({
+        env: env,
+        description: "I am a suite"
+      }),
+      outerAfter = jasmine.createSpy('outerAfterEach'),
+      innerAfter = jasmine.createSpy('insideAfterEach');
+
+    suite.afterEach(outerAfter);
+    suite.afterEach(innerAfter);
+
+    expect(suite.afterFns).toEqual([innerAfter, outerAfter]);
+  });
+
+  it("can be disabled, but still calls callbacks", function() {
+    var env = new j$.Env(),
+      fakeQueueRunner = jasmine.createSpy('fake queue runner'),
+      onStart = jasmine.createSpy('onStart'),
+      resultCallback = jasmine.createSpy('resultCallback'),
+      onComplete = jasmine.createSpy('onComplete'),
+      suite = new j$.Suite({
+        env: env,
+        description: "with a child suite",
+        onStart: onStart,
+        resultCallback: resultCallback,
+        queueRunner: fakeQueueRunner
+      });
+
+    suite.disable();
+
+    expect(suite.disabled).toBe(true);
+
+    suite.execute(onComplete);
+
+    expect(fakeQueueRunner).not.toHaveBeenCalled();
+    expect(onStart).toHaveBeenCalled();
+    expect(resultCallback).toHaveBeenCalled();
+    expect(onComplete).toHaveBeenCalled();
+  });
+
+  it("delegates execution of its specs and suites", function() {
+    var env = new j$.Env(),
+      parentSuiteDone = jasmine.createSpy('parent suite done'),
+      fakeQueueRunnerForParent = jasmine.createSpy('fake parent queue runner'),
+      parentSuite = new j$.Suite({
+        env: env,
+        description: "I am a parent suite",
+        queueRunner: fakeQueueRunnerForParent
+      }),
+      fakeQueueRunner = jasmine.createSpy('fake queue runner'),
+      suite = new j$.Suite({
+        env: env,
+        description: "with a child suite",
+        queueRunner: fakeQueueRunner
+      }),
+      fakeSpec1 = {
+        execute: jasmine.createSpy('fakeSpec1')
+      };
+
+    spyOn(suite, "execute");
+
+    parentSuite.addChild(fakeSpec1);
+    parentSuite.addChild(suite);
+
+    parentSuite.execute(parentSuiteDone);
+
+    var parentSuiteFns = fakeQueueRunnerForParent.calls.mostRecent().args[0].fns;
+
+    parentSuiteFns[0]();
+    expect(fakeSpec1.execute).toHaveBeenCalled();
+    parentSuiteFns[1]();
+    expect(suite.execute).toHaveBeenCalled();
+  });
+
+  it("calls a provided onStart callback when starting", function() {
+    var env = new j$.Env(),
+      suiteStarted = jasmine.createSpy('suiteStarted'),
+      fakeQueueRunner = function(attrs) { attrs.onComplete(); },
+      suite = new j$.Suite({
+        env: env,
+        description: "with a child suite",
+        onStart: suiteStarted,
+        queueRunner: fakeQueueRunner
+      }),
+      fakeSpec1 = {
+        execute: jasmine.createSpy('fakeSpec1')
+      };
+
+    suite.execute();
+
+    expect(suiteStarted).toHaveBeenCalledWith(suite);
+  });
+
+  it("calls a provided onComplete callback when done", function() {
+    var env = new j$.Env(),
+      suiteCompleted = jasmine.createSpy('parent suite done'),
+      fakeQueueRunner = function(attrs) { attrs.onComplete(); },
+      suite = new j$.Suite({
+        env: env,
+        description: "with a child suite",
+        queueRunner: fakeQueueRunner
+      }),
+      fakeSpec1 = {
+        execute: jasmine.createSpy('fakeSpec1')
+      };
+
+    suite.execute(suiteCompleted);
+
+    expect(suiteCompleted).toHaveBeenCalled();
+  });
+
+  it("calls a provided result callback when done", function() {
+    var env = new j$.Env(),
+      suiteResultsCallback = jasmine.createSpy('suite result callback'),
+      fakeQueueRunner = function(attrs) { attrs.onComplete(); },
+      suite = new j$.Suite({
+        env: env,
+        description: "with a child suite",
+        queueRunner: fakeQueueRunner,
+        resultCallback: suiteResultsCallback
+      }),
+      fakeSpec1 = {
+        execute: jasmine.createSpy('fakeSpec1')
+      };
+
+    suite.execute();
+
+    expect(suiteResultsCallback).toHaveBeenCalledWith({
+      id: suite.id,
+      status: '',
+      description: "with a child suite",
+      fullName: "with a child suite"
+    });
+  });
+
+  it("calls a provided result callback with status being disabled when disabled and done", function() {
+    var env = new j$.Env(),
+      suiteResultsCallback = jasmine.createSpy('suite result callback'),
+      fakeQueueRunner = function(attrs) { attrs.onComplete(); },
+      suite = new j$.Suite({
+        env: env,
+        description: "with a child suite",
+        queueRunner: fakeQueueRunner,
+        resultCallback: suiteResultsCallback
+      }),
+      fakeSpec1 = {
+        execute: jasmine.createSpy('fakeSpec1')
+      };
+
+    suite.disable();
+
+    suite.execute();
+
+    expect(suiteResultsCallback).toHaveBeenCalledWith({
+      id: suite.id,
+      status: 'disabled',
+      description: "with a child suite",
+      fullName: "with a child suite"
+    });
+  });
+});