jasmine-ajax 0.0.1

data/lib/assets/javascripts/mock-ajax.js

@@ -0,0 +1,207 @@
+/*
+ Jasmine-Ajax : a set of helpers for testing AJAX requests under the Jasmine
+ BDD framework for JavaScript.
+
+ Supports both Prototype.js and jQuery.
+
+ http://github.com/pivotal/jasmine-ajax
+
+ Jasmine Home page: http://pivotal.github.com/jasmine
+
+ Copyright (c) 2008-2010 Pivotal Labs
+
+ Permission is hereby granted, free of charge, to any person obtaining
+ a copy of this software and associated documentation files (the
+ "Software"), to deal in the Software without restriction, including
+ without limitation the rights to use, copy, modify, merge, publish,
+ distribute, sublicense, and/or sell copies of the Software, and to
+ permit persons to whom the Software is furnished to do so, subject to
+ the following conditions:
+
+ The above copyright notice and this permission notice shall be
+ included in all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+ */
+
+// Jasmine-Ajax interface
+var ajaxRequests = [];
+
+function mostRecentAjaxRequest() {
+  if (ajaxRequests.length > 0) {
+    return ajaxRequests[ajaxRequests.length - 1];
+  } else {
+    return null;
+  }
+}
+
+function clearAjaxRequests() {
+  ajaxRequests = [];
+}
+
+// Fake XHR for mocking Ajax Requests & Responses
+function FakeXMLHttpRequest() {
+  var extend = Object.extend || $.extend;
+  extend(this, {
+    requestHeaders: {},
+
+    open: function() {
+      this.method = arguments[0];
+      this.url = arguments[1];
+      this.readyState = 1;
+    },
+
+    setRequestHeader: function(header, value) {
+      this.requestHeaders[header] = value;
+    },
+
+    abort: function() {
+      this.readyState = 0;
+    },
+
+    readyState: 0,
+
+    onreadystatechange: function(isTimeout) {
+    },
+
+    status: null,
+
+    send: function(data) {
+      this.params = data;
+      this.readyState = 2;
+    },
+
+    getResponseHeader: function(name) {
+      return this.responseHeaders[name];
+    },
+
+    getAllResponseHeaders: function() {
+      var responseHeaders = [];
+      for (var i in this.responseHeaders) {
+        if (this.responseHeaders.hasOwnProperty(i)) {
+          responseHeaders.push(i + ': ' + this.responseHeaders[i]);
+        }
+      }
+      return responseHeaders.join('\r\n');
+    },
+
+    responseText: null,
+
+    response: function(response) {
+      this.status = response.status;
+      this.responseText = response.responseText || "";
+      this.readyState = 4;
+      this.responseHeaders = response.responseHeaders ||
+      {"Content-type": response.contentType || "application/json" };
+      // uncomment for jquery 1.3.x support
+      // jasmine.Clock.tick(20);
+
+      this.onreadystatechange();
+    },
+    responseTimeout: function() {
+      this.readyState = 4;
+      jasmine.Clock.tick(jQuery.ajaxSettings.timeout || 30000);
+      this.onreadystatechange('timeout');
+    }
+  });
+
+  return this;
+}
+
+
+jasmine.Ajax = {
+
+  isInstalled: function() {
+    return jasmine.Ajax.installed == true;
+  },
+
+  assertInstalled: function() {
+    if (!jasmine.Ajax.isInstalled()) {
+      throw new Error("Mock ajax is not installed, use jasmine.Ajax.useMock()")
+    }
+  },
+
+  useMock: function() {
+    if (!jasmine.Ajax.isInstalled()) {
+      var spec = jasmine.getEnv().currentSpec;
+      spec.after(jasmine.Ajax.uninstallMock);
+
+      jasmine.Ajax.installMock();
+    }
+  },
+
+  installMock: function() {
+    if (typeof jQuery != 'undefined') {
+      jasmine.Ajax.installJquery();
+    } else if (typeof Prototype != 'undefined') {
+      jasmine.Ajax.installPrototype();
+    } else {
+      throw new Error("jasmine.Ajax currently only supports jQuery and Prototype");
+    }
+    jasmine.Ajax.installed = true;
+  },
+
+  installJquery: function() {
+    jasmine.Ajax.mode = 'jQuery';
+    jasmine.Ajax.real = jQuery.ajaxSettings.xhr;
+    jQuery.ajaxSettings.xhr = jasmine.Ajax.jQueryMock;
+
+  },
+
+  installPrototype: function() {
+    jasmine.Ajax.mode = 'Prototype';
+    jasmine.Ajax.real = Ajax.getTransport;
+
+    Ajax.getTransport = jasmine.Ajax.prototypeMock;
+  },
+
+  uninstallMock: function() {
+    jasmine.Ajax.assertInstalled();
+    if (jasmine.Ajax.mode == 'jQuery') {
+      jQuery.ajaxSettings.xhr = jasmine.Ajax.real;
+    } else if (jasmine.Ajax.mode == 'Prototype') {
+      Ajax.getTransport = jasmine.Ajax.real;
+    }
+    jasmine.Ajax.reset();
+  },
+
+  reset: function() {
+    jasmine.Ajax.installed = false;
+    jasmine.Ajax.mode = null;
+    jasmine.Ajax.real = null;
+  },
+
+  jQueryMock: function() {
+    var newXhr = new FakeXMLHttpRequest();
+    ajaxRequests.push(newXhr);
+    return newXhr;
+  },
+
+  prototypeMock: function() {
+    return new FakeXMLHttpRequest();
+  },
+
+  installed: false,
+  mode: null
+}
+
+
+// Jasmine-Ajax Glue code for Prototype.js
+if (typeof Prototype != 'undefined' && Ajax && Ajax.Request) {
+  Ajax.Request.prototype.originalRequest = Ajax.Request.prototype.request;
+  Ajax.Request.prototype.request = function(url) {
+    this.originalRequest(url);
+    ajaxRequests.push(this);
+  };
+
+  Ajax.Request.prototype.response = function(responseOptions) {
+    return this.transport.response(responseOptions);
+  };
+}

data/lib/version.rb

@@ -0,0 +1,5 @@
+module Jasmine
+  module Ajax
+    VERSION = "0.0.1"
+  end
+end

data/spec/javascripts/fake-xml-http-request-spec.js

@@ -0,0 +1,45 @@
+describe("FakeXMLHttpRequest", function() {
+  var xhr;
+  beforeEach(function() {
+    xhr = new FakeXMLHttpRequest();
+  });
+  it("should have an initial readyState of 0 (uninitialized)", function() {
+    expect(xhr.readyState).toEqual(0);
+  });
+  describe("when opened", function() {
+    beforeEach(function() {
+      xhr.open("GET", "http://example.com")
+    });
+    it("should have a readyState of 1 (open)", function() {
+      expect(xhr.readyState).toEqual(1);
+    });
+
+    describe("when sent", function() {
+      it("should have a readyState of 2 (sent)", function() {
+        xhr.send(null);
+        expect(xhr.readyState).toEqual(2);
+      });
+    });
+
+    describe("when a response comes in", function() {
+      it("should have a readyState of 4 (loaded)", function() {
+        xhr.response({status: 200});
+        expect(xhr.readyState).toEqual(4);
+      });
+    });
+
+    describe("when aborted", function() {
+      it("should have a readyState of 0 (uninitialized)", function() {
+        xhr.abort();
+        expect(xhr.readyState).toEqual(0);
+      });
+    });
+  });
+
+  it("can be extended", function(){
+    FakeXMLHttpRequest.prototype.foo = function(){
+      return "foo";
+    }
+    expect(new FakeXMLHttpRequest().foo()).toEqual("foo");
+  });
+});

data/spec/javascripts/helpers/spec-helper.js

@@ -0,0 +1,5 @@
+jQuery.noConflict();
+
+beforeEach(function() {
+  clearAjaxRequests();
+});

data/spec/javascripts/mock-ajax-jquery-spec.js

@@ -0,0 +1,374 @@
+describe("Jasmine Mock Ajax (for jQuery)", function() {
+  var request, anotherRequest, response;
+  var success, error, complete;
+  var sharedContext = {};
+  var prototype = Prototype;
+
+  beforeEach(function() {
+    Prototype = undefined;
+    jasmine.Ajax.useMock();
+
+    success = jasmine.createSpy("onSuccess");
+    error = jasmine.createSpy("onFailure");
+    complete = jasmine.createSpy("onComplete");
+  });
+
+  afterEach(function() {
+    Prototype = prototype;
+  });
+
+  describe("when making a request", function () {
+    beforeEach(function() {
+      jQuery.ajax({
+        url: "example.com/someApi",
+        type: "GET",
+        success: success,
+        complete: complete,
+        error: error
+      });
+      request = mostRecentAjaxRequest();
+    });
+
+    it("should store URL and transport", function() {
+      expect(request.url).toEqual("example.com/someApi");
+    });
+
+    it("should queue the request", function() {
+      expect(ajaxRequests.length).toEqual(1);
+    });
+
+    it("should allow access to the queued request", function() {
+      expect(ajaxRequests[0]).toEqual(request);
+    });
+
+    describe("and then another request", function () {
+      beforeEach(function() {
+        jQuery.ajax({
+          url: "example.com/someApi",
+          type: "GET",
+          success: success,
+          complete: complete,
+          error: error
+        });
+        anotherRequest = mostRecentAjaxRequest();
+      });
+
+      it("should queue the next request", function() {
+        expect(ajaxRequests.length).toEqual(2);
+      });
+
+      it("should allow access to the other queued request", function() {
+        expect(ajaxRequests[1]).toEqual(anotherRequest);
+      });
+    });
+
+    describe("mostRecentAjaxRequest", function () {
+
+      describe("when there is one request queued", function () {
+        it("should return the request", function() {
+          expect(mostRecentAjaxRequest()).toEqual(request);
+        });
+      });
+
+      describe("when there is more than one request", function () {
+        beforeEach(function() {
+          jQuery.ajax({
+            url: "example.com/someApi",
+            type: "GET",
+            success: success,
+            complete: complete,
+            error: error
+          });
+          anotherRequest = mostRecentAjaxRequest();
+        });
+
+        it("should return the most recent request", function() {
+          expect(mostRecentAjaxRequest()).toEqual(anotherRequest);
+        });
+      });
+
+      describe("when there are no requests", function () {
+        beforeEach(function() {
+          clearAjaxRequests();
+        });
+
+        it("should return null", function() {
+          expect(mostRecentAjaxRequest()).toEqual(null);
+        });
+      });
+    });
+
+    describe("clearAjaxRequests()", function () {
+      beforeEach(function() {
+        clearAjaxRequests();
+      });
+
+      it("should remove all requests", function() {
+        expect(ajaxRequests.length).toEqual(0);
+        expect(mostRecentAjaxRequest()).toEqual(null);
+      });
+    });
+  });
+
+  describe("when simulating a response with request.response", function () {
+    describe("and the response is Success", function () {
+      beforeEach(function() {
+        jQuery.ajax({
+          url: "example.com/someApi",
+          type: "GET",
+          dataType: 'text',
+          success: success,
+          complete: complete,
+          error: error
+        });
+        request = mostRecentAjaxRequest();
+        response = {status: 200, contentType: "text/html", responseText: "OK!"};
+        request.response(response);
+
+        sharedContext.responseCallback = success;
+        sharedContext.status = response.status;
+        sharedContext.contentType = response.contentType;
+        sharedContext.responseText = response.responseText;
+      });
+
+      it("should call the success handler", function() {
+        expect(success).toHaveBeenCalled();
+      });
+
+      it("should not call the failure handler", function() {
+        expect(error).not.toHaveBeenCalled();
+      });
+
+      it("should call the complete handler", function() {
+        expect(complete).toHaveBeenCalled();
+      });
+
+      sharedAjaxResponseBehaviorForJQuery_Success(sharedContext);
+    });
+
+    describe("and the response is Success, but with JSON", function () {
+      beforeEach(function() {
+        jQuery.ajax({
+          url: "example.com/someApi",
+          type: "GET",
+          dataType: 'json',
+          success: success,
+          complete: complete,
+          error: error
+        });
+        request = mostRecentAjaxRequest();
+        var responseObject = {status: 200, contentType: "application/json", responseText: '{"foo":"bar"}'};
+
+        request.response(responseObject);
+
+        sharedContext.responseCallback = success;
+        sharedContext.status = responseObject.status;
+        sharedContext.contentType = responseObject.contentType;
+        sharedContext.responseText = responseObject.responseText;
+        
+        response = success.mostRecentCall.args[2];
+      });
+
+      it("should call the success handler", function() {
+        expect(success).toHaveBeenCalled();
+      });
+
+      it("should not call the failure handler", function() {
+        expect(error).not.toHaveBeenCalled();
+      });
+
+      it("should call the complete handler", function() {
+        expect(complete).toHaveBeenCalled();
+      });
+
+      it("should return a JavaScript object", function() {
+        expect(success.mostRecentCall.args[0]).toEqual({foo: "bar"});
+      });
+
+      sharedAjaxResponseBehaviorForJQuery_Success(sharedContext);
+    });
+
+    describe("the content type defaults to application/json", function () {
+      beforeEach(function() {
+        jQuery.ajax({
+          url: "example.com/someApi",
+          type: "GET",
+          dataType: 'json',
+          success: success,
+          complete: complete,
+          error: error
+        });
+        request = mostRecentAjaxRequest();
+        response = {status: 200, responseText: '{"foo": "valid JSON, dammit."}'};
+        request.response(response);
+
+        sharedContext.responseCallback = success;
+        sharedContext.status = response.status;
+        sharedContext.contentType = "application/json";
+        sharedContext.responseText = response.responseText;
+      });
+
+      it("should call the success handler", function() {
+        expect(success).toHaveBeenCalled();
+      });
+
+      it("should not call the failure handler", function() {
+        expect(error).not.toHaveBeenCalled();
+      });
+
+      it("should call the complete handler", function() {
+        expect(complete).toHaveBeenCalled();
+      });
+
+      sharedAjaxResponseBehaviorForJQuery_Success(sharedContext);
+    });
+
+    describe("and the status/response code is 0", function () {
+      beforeEach(function() {
+        jQuery.ajax({
+          url: "example.com/someApi",
+          type: "GET",
+          dataType: "text",
+          success: success,
+          complete: complete,
+          error: error
+        });
+        request = mostRecentAjaxRequest();
+        response = {status: 0, responseText: '{"foo": "whoops!"}'};
+        request.response(response);
+
+        sharedContext.responseCallback = success;
+        sharedContext.status = 304; /* jQuery detects status code zero as 304 when headers are present */
+        sharedContext.contentType = 'application/json';
+        sharedContext.responseText = response.responseText;
+      });
+
+      it("should call the success handler", function() {
+        expect(success).toHaveBeenCalled();
+      });
+
+      it("should not call the failure handler", function() {
+        expect(error).not.toHaveBeenCalled();
+      });
+      
+      it("should call the complete handler", function() {
+        expect(complete).toHaveBeenCalled();
+      });
+
+      sharedAjaxResponseBehaviorForJQuery_Success(sharedContext);
+    });
+  });
+
+  describe("and the response is error", function () {
+    beforeEach(function() {
+      jQuery.ajax({
+        url: "example.com/someApi",
+        type: "GET",
+        dataType: "text",
+        success: success,
+        complete: complete,
+        error: error
+      });
+      request = mostRecentAjaxRequest();
+      response = {status: 500, contentType: "text/html", responseText: "(._){"};
+      request.response(response);
+
+      sharedContext.responseCallback = error;
+      sharedContext.status = response.status;
+      sharedContext.contentType = response.contentType;
+      sharedContext.responseText = response.responseText;
+    });
+
+    it("should not call the success handler", function() {
+      expect(success).not.toHaveBeenCalled();
+    });
+
+    it("should call the failure handler", function() {
+      expect(error).toHaveBeenCalled();
+    });
+
+    it("should call the complete handler", function() {
+      expect(complete).toHaveBeenCalled();
+    });
+
+    sharedAjaxResponseBehaviorForJQuery_Failure(sharedContext);
+  });
+
+  describe('when simulating a response with request.responseTimeout', function() {
+    beforeEach(function() {
+      jasmine.Clock.useMock();
+
+      jQuery.ajax({
+        url: "example.com/someApi",
+        type: "GET",
+        dataType: "text",
+        success: success,
+        complete: complete,
+        error: error
+      });
+      request = mostRecentAjaxRequest();
+      response = {contentType: "text/html", responseText: "(._){"};
+      request.responseTimeout(response);
+
+      sharedContext.responseCallback = error;
+      sharedContext.status = response.status;
+      sharedContext.contentType = response.contentType;
+      sharedContext.responseText = response.responseText;
+    });
+
+    it("should not call the success handler", function() {
+      expect(success).not.toHaveBeenCalled();
+    });
+
+    it("should call the failure handler", function() {
+      expect(error).toHaveBeenCalled();
+    });
+
+    it("should call the complete handler", function() {
+      expect(complete).toHaveBeenCalled();
+    });
+  });
+});
+
+
+function sharedAjaxResponseBehaviorForJQuery_Success(context) {
+  describe("the success response", function () {
+    var xhr;
+    beforeEach(function() {
+      xhr = context.responseCallback.mostRecentCall.args[2];
+    });
+
+    it("should have the expected status code", function() {
+      expect(xhr.status).toEqual(context.status);
+    });
+
+    it("should have the expected content type", function() {
+      expect(xhr.getResponseHeader('Content-type')).toEqual(context.contentType);
+    });
+
+    it("should have the expected response text", function() {
+      expect(xhr.responseText).toEqual(context.responseText);
+    });
+  });
+}
+
+function sharedAjaxResponseBehaviorForJQuery_Failure(context) {
+  describe("the failure response", function () {
+    var xhr;
+    beforeEach(function() {
+      xhr = context.responseCallback.mostRecentCall.args[0];
+    });
+
+    it("should have the expected status code", function() {
+      expect(xhr.status).toEqual(context.status);
+    });
+
+    it("should have the expected content type", function() {
+      expect(xhr.getResponseHeader('Content-type')).toEqual(context.contentType);
+    });
+
+    it("should have the expected response text", function() {
+      expect(xhr.responseText).toEqual(context.responseText);
+    });
+  });
+}