ember-data-factory-guy 0.7.3 → 0.7.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9c2abf7589fecda0e42120d5c2e9bf8efc2caef7
-  data.tar.gz: 93fb335e1e15c4ad91be1b1716b7b30c71483f03
+  metadata.gz: 0c363f00f4ebb7fb8180ca566590bc388b72088a
+  data.tar.gz: 48aef40535b00c54b9c593c12a3b795452d7e8f2
 SHA512:
-  metadata.gz: 0b84a2d29390fd35426e6eb4e5fa5b04338999f5e2c859bebc8a76f53a24ad5b1487a18bacb2d0d110fc482b1211fdf6b4d412d91df557913eea1af496ce438a
-  data.tar.gz: 4f707a3a8702fb5ab142bf97c1e5a9dbb94ee709989e929d3b4356ba847b6798c86c571dba925c8412678bc926024df409438078f4034a041148e6d2d710fefc
+  metadata.gz: c6f5c33236bbeee62b5a61dcf321ad535af9f3e7af1677b7cc4e0ffcecf2ae1996ff4af4e352956d7d644e931e974e4aec4bc8c91d36f29297b6fd04216d7f3e
+  data.tar.gz: c3280a7223574403a20cd4cc34b8bb47ca4ffbb4c044a6249a33370e61ee55dac5e441438cc460eeae006a46dce8b32bd321ce4f7c26635556f8f6bc5d466619

data/Gruntfile.js

@@ -11,7 +11,8 @@ module.exports = function(grunt) {
           'src/model_definition.js',
           'src/factory_guy.js',
           'src/store.js',
-          'src/factory_guy_test_mixin.js'],
+          'src/factory_guy_test_mixin.js',
+          'bower_components/jquery-mockjax/jquery.mockjax.js'],
         dest: "dist/ember-data-factory-guy.js"
       },
       extra: {
@@ -25,7 +26,8 @@ module.exports = function(grunt) {
             'src/model_definition.js',
             'src/factory_guy.js',
             'src/store.js',
-            'src/factory_guy_test_mixin.js'],
+            'src/factory_guy_test_mixin.js',
+            'bower_components/jquery-mockjax/jquery.mockjax.js'],
           "vendor/assets/javascripts/factory_guy_has_many.js": ['src/has_many.js']
         }
       },

data/README.md

@@ -7,12 +7,12 @@ so, if you are using ember-data-1.0.0-beta.8 and earlier, then be sure to use ve
 ( or below ) of ember-data-factory-guy.  
 
 - Versions:
-  - 0.6.4  -> ember-data-1.0.0-beta.8 and under
-  - 0.7.1  -> ember-data-1.0.0-beta.10
-  - 0.7.3  -> ember-data-1.0.0-beta.11
-  - 0.7.3  -> ember-data-1.0.0-beta.12
+  - 0.6.4   -> ember-data-1.0.0-beta.8 and under
+  - 0.7.1.1 -> ember-data-1.0.0-beta.10
+  - 0.7.5   -> ember-data-1.0.0-beta.11
+  - 0.7.5   -> ember-data-1.0.0-beta.12
 
-**For versions ( 0.7.1 -> 0.7.3 ), support for the fixture adapter is currently broken.**  
+**For versions ( 0.7.1 -> 0.7.5 ), support for the fixture adapter is currently broken.**  
 
 ## Using as Gem
 
@@ -517,7 +517,7 @@ the reverse 'user' belongsTo association is being setup for you on the project
 ```
 
 
-###Testing models, controllers, views 
+### Testing models, controllers, views 
 
 - Testing the models, controllers and views in isolation
 - Use FactoryGuyTestMixin to help with testing
@@ -563,17 +563,17 @@ test("make a user using your applications default adapter", function() {
 ```
 
 
-###Integration Tests
+### Integration Tests
 
 
-##### Using FactoryGuyTestMixin
+#### Using FactoryGuyTestMixin
 
 - Uses mockjax
 - Has helper methods
-  - handleFind
+  - handleFindMany
   - handleCreate
-  - handleUpdate
-  - handleDelete
+  - handleUpdate ( can mock success or failure )
+  - handleDelete ( can mock success or failure )
 
 Since it is recommended to use your normal adapter ( which is usually a subclass of RESTAdapter, )
 FactoryGuyTestMixin assumes you will want to use that adapter to do your integration tests.
@@ -584,8 +584,55 @@ If you put models into the store ( with store#makeFixture ), the http GET call d
 since that model is already in the store.
 
 But what if you want to handle create, update or delete?
+
 FactoryGuy assumes you want to mock ajax calls with the mockjax library,
-and you will need to download and include that library to use the following feature.
+and this is already bundled for you when you use the ember-data-factory-guy library.
+                
+
+##### handleUpdate
+
+*success case is the default*
+
+```javascript
+  var profile = store.makeFixture('profile');
+  testHelper.handleUpdate('profile', profile.id);
+
+  profile.set('description', 'good value');
+  profile.save() //=> will succeed
+````
+
+*mocking failed update*
+
+```javascript
+  var profile = store.makeFixture('profile');
+  testHelper.handleUpdate('profile', profile.id, false);
+
+  profile.set('description', 'bad value');
+  profile.save() //=> will fail
+````
+
+
+##### handleDelete
+
+*success case is the default*
+
+```javascript
+  var profile = store.makeFixture('profile');
+  testHelper.handleDelete('profile', profile.id);
+
+  profile.destroyRecord() // => will succeed
+````
+
+*mocking failed delete*
+
+```javascript
+  var profile = store.makeFixture('profile');
+  // set the succeed flag to 'false'
+  testHelper.handleDelete('profile', profile.id, false);
+
+  profile.destroyRecord() // => will fail
+````
+
 
 Here is a sample of what you could do in a view test:
 

data/bower.json

@@ -1,6 +1,6 @@
 {
   "name": "ember-data-factory-guy",
-  "version": "0.7.3",
+  "version": "0.7.5",
   "authors": [
     "Daniel Sudol <dansudol@yahoo.com>",
     "Opak Alex <opak.alexandr@gmail.com>"
@@ -21,7 +21,8 @@
     "ember": "1.7.0",
     "ember-data": "1.0.0-beta.11",
     "chance": "latest",
-    "qunit": "latest"
+    "qunit": "latest",
+    "jquery-mockjax": "latest"
   },
 
   "ignore": [

data/dist/ember-data-factory-guy.js

@@ -328,9 +328,9 @@ FactoryGuy = {
     Given a fixture name like 'person' or 'dude' determine what model this name
     refers to. In this case it's 'person' for each one.
 
-   @param {String} name a fixture name could be model name like 'person'
+   @param {String} name  a fixture name could be model name like 'person'
           or a named person in model definition like 'dude'
-   @returns {String} model name associated with fixture name or undefined if not found
+   @returns {String} model  name associated with fixture name or undefined if not found
    */
   lookupModelForFixtureName: function (name) {
     var definition = this.lookupDefinitionForFixtureName(name);
@@ -360,11 +360,11 @@ FactoryGuy = {
    FactoryGuy.build('bob') for a 'bob' User
    FactoryGuy.build('bob', 'dude') for a 'bob' User with dude traits
    FactoryGuy.build('bob', 'dude', 'funny') for a 'bob' User with dude and funny traits
-   FactoryGuy.build('bob', 'dude', name: 'wombat') for a 'bob' User with dude trait and custom attribute name of 'wombat'
+   FactoryGuy.build('bob', 'dude', {name: 'wombat'}) for a 'bob' User with dude trait and custom attribute name of 'wombat'
 
-   @param {String} name Fixture name
-   @param {String} trait trait name ( can be more than one )
-   @param {Object} opts Options that will override default fixture values
+   @param {String} name  fixture name
+   @param {String} trait  optional trait names ( one or more )
+   @param {Object} opts  optional fixture options that will override default fixture values
    @returns {Object} json fixture
    */
   build: function () {
@@ -378,6 +378,7 @@ FactoryGuy = {
       opts  = args.pop();
     }
     var traits = args; // whatever is left are traits
+
     var definition = this.lookupDefinitionForFixtureName(name);
     if (!definition) {
       throw new Error("Can't find that factory named [" + name + "]");
@@ -391,10 +392,10 @@ FactoryGuy = {
    FactoryGuy.buildList('user', 2) for 2 User models
    FactoryGuy.build('bob', 2) for 2 User model with bob attributes
 
-   @param {String} name fixture name
-   @param {Number} number number of fixtures to create
-   @param {String} trait (one or more)
-   @param {Object} opts options that will override default fixture values
+   @param {String} name  fixture name
+   @param {Number} number  number of fixtures to create
+   @param {String} trait  optional traits (one or more)
+   @param {Object} opts  optional fixture options that will override default fixture values
    @returns {Array} list of fixtures
    */
   buildList: function () {
@@ -478,40 +479,47 @@ DS.Store.reopen({
 
   /**
    Make new fixture and save to store. If the store is using FixtureAdapter,
-   will push to FIXTURE array, otherwise will use push method on adapter.
+   will push to FIXTURE array, otherwise will use push method on adapter to load
+   the record into the store
 
-   @param {String} name name of fixture
-   @param {Object} options fixture options
+   @param {String} name  fixture name
+   @param {String} trait  optional trait names ( one or more )
+   @param {Object} opts  optional fixture options that will override default fixture values
    @returns {Object|DS.Model} json or record depending on the adapter type
    */
-  makeFixture: function (name, options) {
+  makeFixture: function () {
     var store = this;
+    var fixture = FactoryGuy.build.apply(FactoryGuy,arguments);
+    var name = arguments[0];
     var modelName = FactoryGuy.lookupModelForFixtureName(name);
-    var fixture = FactoryGuy.build(name, options);
     var modelType = store.modelFor(modelName);
 
     if (this.usingFixtureAdapter()) {
       this.setAssociationsForFixtureAdapter(modelType, modelName, fixture);
       return FactoryGuy.pushFixture(modelType, fixture);
     } else {
-      var store = this;
-
-      var model;
-      Em.run(function () {
-        store.findEmbeddedAssociationsForRESTAdapter(modelType, fixture);
-        if (fixture.type) {
-          // assuming its polymorphic if there is a type attribute
-          // is this too bold an assumption?
-          modelName = fixture.type.underscore();
-          modelType = store.modelFor(modelName);
-        }
-        model = store.push(modelName, fixture);
-        store.setAssociationsForRESTAdapter(modelType, modelName, model);
-      });
-      return model;
+      return store.makeModel(modelType, fixture)
     }
   },
 
+  makeModel: function (modelType, fixture) {
+    var store = this,
+        modelName = store.modelFor(modelType).typeKey,
+        model;
+    Em.run(function () {
+      store.findEmbeddedAssociationsForRESTAdapter(modelType, fixture);
+      if (fixture.type) {
+        // assuming its polymorphic if there is a type attribute
+        // is this too bold an assumption?
+        modelName = fixture.type.underscore();
+        modelType = store.modelFor(modelName);
+      }
+      model = store.push(modelName, fixture);
+      store.setAssociationsForRESTAdapter(modelType, modelName, model);
+    });
+    return model;
+  },
+
   /**
    Make a list of Fixtures
 
@@ -520,10 +528,11 @@ DS.Store.reopen({
    @param {Object} options fixture options
    @returns {Array} list of json fixtures or records depending on the adapter type
    */
-  makeList: function (name, number, options) {
+  makeList: function () {
     var arr = [];
+    var number = arguments[1];
     for (var i = 0; i < number; i++) {
-      arr.push(this.makeFixture(name, options))
+      arr.push(this.makeFixture.apply(this,arguments));
     }
     return arr;
   },
@@ -597,7 +606,8 @@ DS.Store.reopen({
   },
 
   /**
-   Before pushing the fixture to the store, do some preprocessing.
+   Before pushing the fixture to the store, do some preprocessing. Descend into the tree
+   of object data, and convert child objects to record instances recursively.
 
    If its a belongs to association, and the fixture has an object there,
    then push that model to the store and set the id of that new model
@@ -619,12 +629,11 @@ DS.Store.reopen({
       }
       if (relationship.kind == 'hasMany') {
         var hasManyRecords = fixture[relationship.key];
-        // if the records are objects and not instances they need to be converted to
-        // instances
         if (Ember.typeOf(hasManyRecords) == 'array') {
           if (Ember.typeOf(hasManyRecords[0]) == 'object') {
             var records = Em.A()
             hasManyRecords.map(function (object) {
+              store.findEmbeddedAssociationsForRESTAdapter(relationship.type, object);
               var record = store.push(relationship.type, object);
               records.push(record);
               return record;
@@ -681,7 +690,6 @@ DS.Store.reopen({
           }
         })
       }
-
     })
   },
 
@@ -812,15 +820,15 @@ FactoryGuyTestMixin = Em.Mixin.create({
     $.mockjax(request);
   },
 
+
   /**
    Build the json used for creating or finding a record.
 
-   @param {String} name of the fixture ( or model ) to create/find
-   @param {Object} opts fixture options
+   @param {String} modelName model name like 'user'
+   @param {String} fixture the fixture data
+   @return {Object} json response used for mocking a request
    */
-  buildAjaxHttpResponse: function (name, opts) {
-    var fixture = FactoryGuy.build(name, opts);
-    var modelName = FactoryGuy.lookupModelForFixtureName(name);
+  buildAjaxHttpResponse: function (modelName, fixture) {
     if (this.usingActiveModelSerializer(modelName)) {
       this.toSnakeCase(fixture);
     }
@@ -829,6 +837,26 @@ FactoryGuyTestMixin = Em.Mixin.create({
     return hash;
   },
 
+
+  _collectArgs: function (args, fromMethod) {
+    var args = Array.prototype.slice.call(arguments);
+    var name = args.shift();
+    if (!name) {
+      throw new Error(fromMethod + " needs a factory name to build");
+    }
+    var succeed = true;
+    if (Ember.typeOf(args[args.length-1]) == 'boolean') {
+      succeed  = args.pop();
+    }
+    var opts = {}
+    if (Ember.typeOf(args[args.length-1]) == 'object') {
+      opts  = args.pop();
+    }
+    var traits = args; // whatever is left are traits
+
+    return {name: name, traits: traits, opts: opts, succeed: succeed}
+  },
+
   /**
    Convert Object's keys to snake case
 
@@ -856,95 +884,796 @@ FactoryGuyTestMixin = Em.Mixin.create({
   },
 
 
-  handleSideloadFind: function (modelName, json, sideload) {
-    var id = json.id
-    var url = this.buildURL(modelName, id);
-    var responseJson = {};
-    responseJson[modelName] = json;
-    $.extend(responseJson, sideload)
-
-    this.stubEndpointForHttpRequest(
-      url,
-      responseJson,
-      {type: 'GET', status: (status || 200)}
-    )
-  },
-
-
   /**
-     Handling ajax GET ( find record ) for a model. You can mock
-     failed find by passing in status of 500.
+     Handling ajax GET for finding all records for a type of model.
+     You can mock failed find by passing in success argument as false.
+
+     @param {String} name  name of the fixture ( or model ) to find
+     @param {Number} number  number of fixtures to create
+     @param {String} trait  optional traits (one or more)
+     @param {Object} opts  optional fixture options
+     @return {Object} json response
+   */
+  handleFindMany: function () {
+    var store = this.getStore();
+    // make the records and load them in the store
+    store.makeList.apply(store,arguments);
 
-     @param {String} name of the fixture ( or model ) to find
-     @param {Object} opts fixture options
-     @param {Integer} status Optional HTTP status response code
-     */
-  handleFind: function (name, opts, status) {
+    var name = arguments[0];
     var modelName = FactoryGuy.lookupModelForFixtureName(name);
-    var responseJson = this.buildAjaxHttpResponse(name, opts);
-    var id = responseJson[modelName].id
-    var url = this.buildURL(modelName, id);
-    this.stubEndpointForHttpRequest(
-      url,
-      responseJson,
-      {type: 'GET', status: (status || 200)}
-    )
-    return responseJson;
+    var responseJson = {};
+    responseJson[modelName]=[];
+    var url = this.buildURL(modelName);
+    // mock the ajax call, but return nothing, since the records will be
+    // retrieved since they are already in the store
+    this.stubEndpointForHttpRequest(url, responseJson, {type: 'GET'})
   },
 
   /**
    Handling ajax POST ( create record ) for a model. You can mock
-   failed create by passing in status of 500.
+   failed create by passing in success argument as false.
 
-   @param {String} name of the fixture ( or model ) to create
-   @param {Object} opts fixture options
-   @param {Integer} status Optional HTTP status response code
+   @param {String} name  name of the fixture ( or model ) to create
+   @param {String} trait  optional traits ( one or more )
+   @param {Object} opts  optional fixture options
+   @return {Object} json response
    */
-  handleCreate: function (name, opts, status) {
+  handleCreate: function () {
+    var args = Array.prototype.slice.call(arguments);
+
+    var succeed = true;
+    if (Ember.typeOf(args[args.length-1]) == 'boolean') {
+      succeed = args.pop();
+    }
+
+    var name = args[0];
     var modelName = FactoryGuy.lookupModelForFixtureName(name);
-    var responseJson = this.buildAjaxHttpResponse(name, opts);
     var url = this.buildURL(modelName);
-    this.stubEndpointForHttpRequest(
-      url,
-      responseJson,
-      {type: 'POST', status: (status || 200)}
-    )
-    return responseJson;
+    var responseJson = {};
+    var httpOptions = {type: 'POST'}
+
+    if (succeed) {
+      var store = this.getStore();
+      // make the records and load them in the store
+      var model = store.makeFixture.apply(store,args);
+      responseJson[modelName]=model;
+    } else {
+      httpOptions.status = 500;
+    }
+    this.stubEndpointForHttpRequest(url, responseJson, httpOptions)
   },
 
   /**
    Handling ajax PUT ( update record ) for a model type. You can mock
-   failed update by passing in status of 500.
+   failed update by passing in success argument as false.
 
-   @param {String} type model type like 'user' for User model
-   @param {String} id id of record to update
-   @param {Integer} status Optional HTTP status response code
+   @param {String} type  model type like 'user' for User model
+   @param {String} id  id of record to update
+   @param {Boolean} succeed  optional flag to indicate if the request
+      should succeed ( default is true )
    */
-  handleUpdate: function (type, id, status) {
+  handleUpdate: function (type, id, succeed) {
+    succeed = succeed === undefined ? true : succeed;
+
     this.stubEndpointForHttpRequest(
       this.buildURL(type, id),
       {},
-      {type: 'PUT', status: (status || 200)}
+      {type: 'PUT', status: (succeed ? 200 : 500)}
     )
   },
 
   /**
    Handling ajax DELETE ( delete record ) for a model type. You can mock
-   failed delete by passing in status of 500.
+   failed delete by passing in success argument as false.
 
-   @param {String} type model type like 'user' for User model
-   @param {String} id id of record to update
-   @param {Integer} status Optional HTTP status response code
+   @param {String} type  model type like 'user' for User model
+   @param {String} id  id of record to update
+   @param {Boolean} succeed  optional flag to indicate if the request
+      should succeed ( default is true )
    */
-  handleDelete: function (type, id, status) {
+  handleDelete: function (type, id, succeed) {
+    succeed = succeed === undefined ? true : succeed;
+
     this.stubEndpointForHttpRequest(
       this.buildURL(type, id),
       {},
-      {type: 'DELETE', status: (status || 200)}
+      {type: 'DELETE', status: (succeed ? 200 : 500)}
     )
   },
 
   teardown: function () {
     FactoryGuy.resetModels(this.getStore());
   }
-})
+});
+/*!
+ * MockJax - jQuery Plugin to Mock Ajax requests
+ *
+ * Version:  1.6.1
+ * Released:
+ * Home:   https://github.com/jakerella/jquery-mockjax
+ * Author:   Jonathan Sharp (http://jdsharp.com)
+ * License:  MIT,GPL
+ *
+ * Copyright (c) 2014 appendTo, Jordan Kasper
+ * NOTE: This repository was taken over by Jordan Kasper (@jakerella) October, 2014
+ * 
+ * Dual licensed under the MIT or GPL licenses.
+ * http://opensource.org/licenses/MIT OR http://www.gnu.org/licenses/gpl-2.0.html
+ */
+(function($) {
+	var _ajax = $.ajax,
+		mockHandlers = [],
+		mockedAjaxCalls = [],
+		unmockedAjaxCalls = [],
+		CALLBACK_REGEX = /=\?(&|$)/,
+		jsc = (new Date()).getTime();
+
+
+	// Parse the given XML string.
+	function parseXML(xml) {
+		if ( window.DOMParser == undefined && window.ActiveXObject ) {
+			DOMParser = function() { };
+			DOMParser.prototype.parseFromString = function( xmlString ) {
+				var doc = new ActiveXObject('Microsoft.XMLDOM');
+				doc.async = 'false';
+				doc.loadXML( xmlString );
+				return doc;
+			};
+		}
+
+		try {
+			var xmlDoc = ( new DOMParser() ).parseFromString( xml, 'text/xml' );
+			if ( $.isXMLDoc( xmlDoc ) ) {
+				var err = $('parsererror', xmlDoc);
+				if ( err.length == 1 ) {
+					throw new Error('Error: ' + $(xmlDoc).text() );
+				}
+			} else {
+				throw new Error('Unable to parse XML');
+			}
+			return xmlDoc;
+		} catch( e ) {
+			var msg = ( e.name == undefined ? e : e.name + ': ' + e.message );
+			$(document).trigger('xmlParseError', [ msg ]);
+			return undefined;
+		}
+	}
+
+	// Check if the data field on the mock handler and the request match. This
+	// can be used to restrict a mock handler to being used only when a certain
+	// set of data is passed to it.
+	function isMockDataEqual( mock, live ) {
+		var identical = true;
+		// Test for situations where the data is a querystring (not an object)
+		if (typeof live === 'string') {
+			// Querystring may be a regex
+			return $.isFunction( mock.test ) ? mock.test(live) : mock == live;
+		}
+		$.each(mock, function(k) {
+			if ( live[k] === undefined ) {
+				identical = false;
+				return identical;
+			} else {
+				if ( typeof live[k] === 'object' && live[k] !== null ) {
+					if ( identical && $.isArray( live[k] ) ) {
+						identical = $.isArray( mock[k] ) && live[k].length === mock[k].length;
+					}
+					identical = identical && isMockDataEqual(mock[k], live[k]);
+				} else {
+					if ( mock[k] && $.isFunction( mock[k].test ) ) {
+						identical = identical && mock[k].test(live[k]);
+					} else {
+						identical = identical && ( mock[k] == live[k] );
+					}
+				}
+			}
+		});
+
+		return identical;
+	}
+
+    // See if a mock handler property matches the default settings
+    function isDefaultSetting(handler, property) {
+        return handler[property] === $.mockjaxSettings[property];
+    }
+
+	// Check the given handler should mock the given request
+	function getMockForRequest( handler, requestSettings ) {
+		// If the mock was registered with a function, let the function decide if we
+		// want to mock this request
+		if ( $.isFunction(handler) ) {
+			return handler( requestSettings );
+		}
+
+		// Inspect the URL of the request and check if the mock handler's url
+		// matches the url for this ajax request
+		if ( $.isFunction(handler.url.test) ) {
+			// The user provided a regex for the url, test it
+			if ( !handler.url.test( requestSettings.url ) ) {
+				return null;
+			}
+		} else {
+			// Look for a simple wildcard '*' or a direct URL match
+			var star = handler.url.indexOf('*');
+			if (handler.url !== requestSettings.url && star === -1 ||
+					!new RegExp(handler.url.replace(/[-[\]{}()+?.,\\^$|#\s]/g, "\\$&").replace(/\*/g, '.+')).test(requestSettings.url)) {
+				return null;
+			}
+		}
+
+		// Inspect the data submitted in the request (either POST body or GET query string)
+		if ( handler.data ) {
+			if ( ! requestSettings.data || !isMockDataEqual(handler.data, requestSettings.data) ) {
+				// They're not identical, do not mock this request
+				return null;
+			}
+		}
+		// Inspect the request type
+		if ( handler && handler.type &&
+				handler.type.toLowerCase() != requestSettings.type.toLowerCase() ) {
+			// The request type doesn't match (GET vs. POST)
+			return null;
+		}
+
+		return handler;
+	}
+
+	function parseResponseTimeOpt(responseTime) {
+		if ($.isArray(responseTime)) {
+			var min = responseTime[0];
+			var max = responseTime[1];
+			return (typeof min === 'number' && typeof max === 'number') ? Math.floor(Math.random() * (max - min)) + min : null;
+		} else {
+			return (typeof responseTime === 'number') ? responseTime: null;
+		}
+	}
+
+	// Process the xhr objects send operation
+	function _xhrSend(mockHandler, requestSettings, origSettings) {
+
+		// This is a substitute for < 1.4 which lacks $.proxy
+		var process = (function(that) {
+			return function() {
+				return (function() {
+					// The request has returned
+					this.status     = mockHandler.status;
+					this.statusText = mockHandler.statusText;
+					this.readyState	= 1;
+
+					var finishRequest = function () {
+						this.readyState	= 4;
+
+						var onReady;
+						// Copy over our mock to our xhr object before passing control back to
+						// jQuery's onreadystatechange callback
+						if ( requestSettings.dataType == 'json' && ( typeof mockHandler.responseText == 'object' ) ) {
+							this.responseText = JSON.stringify(mockHandler.responseText);
+						} else if ( requestSettings.dataType == 'xml' ) {
+							if ( typeof mockHandler.responseXML == 'string' ) {
+								this.responseXML = parseXML(mockHandler.responseXML);
+								//in jQuery 1.9.1+, responseXML is processed differently and relies on responseText
+								this.responseText = mockHandler.responseXML;
+							} else {
+								this.responseXML = mockHandler.responseXML;
+							}
+						} else if (typeof mockHandler.responseText === 'object' && mockHandler.responseText !== null) {
+							// since jQuery 1.9 responseText type has to match contentType
+							mockHandler.contentType = 'application/json';
+							this.responseText = JSON.stringify(mockHandler.responseText);
+						} else {
+							this.responseText = mockHandler.responseText;
+						}
+						if( typeof mockHandler.status == 'number' || typeof mockHandler.status == 'string' ) {
+							this.status = mockHandler.status;
+						}
+						if( typeof mockHandler.statusText === "string") {
+							this.statusText = mockHandler.statusText;
+						}
+						// jQuery 2.0 renamed onreadystatechange to onload
+						onReady = this.onreadystatechange || this.onload;
+
+						// jQuery < 1.4 doesn't have onreadystate change for xhr
+						if ( $.isFunction( onReady ) ) {
+							if( mockHandler.isTimeout) {
+								this.status = -1;
+							}
+							onReady.call( this, mockHandler.isTimeout ? 'timeout' : undefined );
+						} else if ( mockHandler.isTimeout ) {
+							// Fix for 1.3.2 timeout to keep success from firing.
+							this.status = -1;
+						}
+					};
+
+					// We have an executable function, call it to give
+					// the mock handler a chance to update it's data
+					if ( $.isFunction(mockHandler.response) ) {
+						// Wait for it to finish
+						if ( mockHandler.response.length === 2 ) {
+							mockHandler.response(origSettings, function () {
+								finishRequest.call(that);
+							});
+							return;
+						} else {
+							mockHandler.response(origSettings);
+						}
+					}
+
+					finishRequest.call(that);
+				}).apply(that);
+			};
+		})(this);
+
+		if ( mockHandler.proxy ) {
+			// We're proxying this request and loading in an external file instead
+			_ajax({
+				global: false,
+				url: mockHandler.proxy,
+				type: mockHandler.proxyType,
+				data: mockHandler.data,
+				dataType: requestSettings.dataType === "script" ? "text/plain" : requestSettings.dataType,
+				complete: function(xhr) {
+					mockHandler.responseXML = xhr.responseXML;
+					mockHandler.responseText = xhr.responseText;
+                    // Don't override the handler status/statusText if it's specified by the config
+                    if (isDefaultSetting(mockHandler, 'status')) {
+					    mockHandler.status = xhr.status;
+                    }
+                    if (isDefaultSetting(mockHandler, 'statusText')) {
+					    mockHandler.statusText = xhr.statusText;
+                    }
+					this.responseTimer = setTimeout(process, parseResponseTimeOpt(mockHandler.responseTime) || 0);
+				}
+			});
+		} else {
+			// type == 'POST' || 'GET' || 'DELETE'
+			if ( requestSettings.async === false ) {
+				// TODO: Blocking delay
+				process();
+			} else {
+				this.responseTimer = setTimeout(process, parseResponseTimeOpt(mockHandler.responseTime) || 50);
+			}
+		}
+	}
+
+	// Construct a mocked XHR Object
+	function xhr(mockHandler, requestSettings, origSettings, origHandler) {
+		// Extend with our default mockjax settings
+		mockHandler = $.extend(true, {}, $.mockjaxSettings, mockHandler);
+
+		if (typeof mockHandler.headers === 'undefined') {
+			mockHandler.headers = {};
+		}
+		if (typeof requestSettings.headers === 'undefined') {
+			requestSettings.headers = {};
+		}
+		if ( mockHandler.contentType ) {
+			mockHandler.headers['content-type'] = mockHandler.contentType;
+		}
+
+		return {
+			status: mockHandler.status,
+			statusText: mockHandler.statusText,
+			readyState: 1,
+			open: function() { },
+			send: function() {
+				origHandler.fired = true;
+				_xhrSend.call(this, mockHandler, requestSettings, origSettings);
+			},
+			abort: function() {
+				clearTimeout(this.responseTimer);
+			},
+			setRequestHeader: function(header, value) {
+				requestSettings.headers[header] = value;
+			},
+			getResponseHeader: function(header) {
+				// 'Last-modified', 'Etag', 'content-type' are all checked by jQuery
+				if ( mockHandler.headers && mockHandler.headers[header] ) {
+					// Return arbitrary headers
+					return mockHandler.headers[header];
+				} else if ( header.toLowerCase() == 'last-modified' ) {
+					return mockHandler.lastModified || (new Date()).toString();
+				} else if ( header.toLowerCase() == 'etag' ) {
+					return mockHandler.etag || '';
+				} else if ( header.toLowerCase() == 'content-type' ) {
+					return mockHandler.contentType || 'text/plain';
+				}
+			},
+			getAllResponseHeaders: function() {
+				var headers = '';
+				// since jQuery 1.9 responseText type has to match contentType
+				if (mockHandler.contentType) {
+					mockHandler.headers['Content-Type'] = mockHandler.contentType;
+				}
+				$.each(mockHandler.headers, function(k, v) {
+					headers += k + ': ' + v + "\n";
+				});
+				return headers;
+			}
+		};
+	}
+
+	// Process a JSONP mock request.
+	function processJsonpMock( requestSettings, mockHandler, origSettings ) {
+		// Handle JSONP Parameter Callbacks, we need to replicate some of the jQuery core here
+		// because there isn't an easy hook for the cross domain script tag of jsonp
+
+		processJsonpUrl( requestSettings );
+
+		requestSettings.dataType = "json";
+		if(requestSettings.data && CALLBACK_REGEX.test(requestSettings.data) || CALLBACK_REGEX.test(requestSettings.url)) {
+			createJsonpCallback(requestSettings, mockHandler, origSettings);
+
+			// We need to make sure
+			// that a JSONP style response is executed properly
+
+			var rurl = /^(\w+:)?\/\/([^\/?#]+)/,
+				parts = rurl.exec( requestSettings.url ),
+				remote = parts && (parts[1] && parts[1] !== location.protocol || parts[2] !== location.host);
+
+			requestSettings.dataType = "script";
+			if(requestSettings.type.toUpperCase() === "GET" && remote ) {
+				var newMockReturn = processJsonpRequest( requestSettings, mockHandler, origSettings );
+
+				// Check if we are supposed to return a Deferred back to the mock call, or just
+				// signal success
+				if(newMockReturn) {
+					return newMockReturn;
+				} else {
+					return true;
+				}
+			}
+		}
+		return null;
+	}
+
+	// Append the required callback parameter to the end of the request URL, for a JSONP request
+	function processJsonpUrl( requestSettings ) {
+		if ( requestSettings.type.toUpperCase() === "GET" ) {
+			if ( !CALLBACK_REGEX.test( requestSettings.url ) ) {
+				requestSettings.url += (/\?/.test( requestSettings.url ) ? "&" : "?") +
+					(requestSettings.jsonp || "callback") + "=?";
+			}
+		} else if ( !requestSettings.data || !CALLBACK_REGEX.test(requestSettings.data) ) {
+			requestSettings.data = (requestSettings.data ? requestSettings.data + "&" : "") + (requestSettings.jsonp || "callback") + "=?";
+		}
+	}
+
+	// Process a JSONP request by evaluating the mocked response text
+	function processJsonpRequest( requestSettings, mockHandler, origSettings ) {
+		// Synthesize the mock request for adding a script tag
+		var callbackContext = origSettings && origSettings.context || requestSettings,
+			newMock = null;
+
+
+		// If the response handler on the moock is a function, call it
+		if ( mockHandler.response && $.isFunction(mockHandler.response) ) {
+			mockHandler.response(origSettings);
+		} else {
+
+			// Evaluate the responseText javascript in a global context
+			if( typeof mockHandler.responseText === 'object' ) {
+				$.globalEval( '(' + JSON.stringify( mockHandler.responseText ) + ')');
+			} else {
+				$.globalEval( '(' + mockHandler.responseText + ')');
+			}
+		}
+
+		// Successful response
+		setTimeout(function() {
+			jsonpSuccess( requestSettings, callbackContext, mockHandler );
+			jsonpComplete( requestSettings, callbackContext, mockHandler );
+		}, parseResponseTimeOpt(mockHandler.responseTime) || 0);
+
+		// If we are running under jQuery 1.5+, return a deferred object
+		if($.Deferred){
+			newMock = new $.Deferred();
+			if(typeof mockHandler.responseText == "object"){
+				newMock.resolveWith( callbackContext, [mockHandler.responseText] );
+			}
+			else{
+				newMock.resolveWith( callbackContext, [$.parseJSON( mockHandler.responseText )] );
+			}
+		}
+		return newMock;
+	}
+
+
+	// Create the required JSONP callback function for the request
+	function createJsonpCallback( requestSettings, mockHandler, origSettings ) {
+		var callbackContext = origSettings && origSettings.context || requestSettings;
+		var jsonp = requestSettings.jsonpCallback || ("jsonp" + jsc++);
+
+		// Replace the =? sequence both in the query string and the data
+		if ( requestSettings.data ) {
+			requestSettings.data = (requestSettings.data + "").replace(CALLBACK_REGEX, "=" + jsonp + "$1");
+		}
+
+		requestSettings.url = requestSettings.url.replace(CALLBACK_REGEX, "=" + jsonp + "$1");
+
+
+		// Handle JSONP-style loading
+		window[ jsonp ] = window[ jsonp ] || function( tmp ) {
+			data = tmp;
+			jsonpSuccess( requestSettings, callbackContext, mockHandler );
+			jsonpComplete( requestSettings, callbackContext, mockHandler );
+			// Garbage collect
+			window[ jsonp ] = undefined;
+
+			try {
+				delete window[ jsonp ];
+			} catch(e) {}
+
+			if ( head ) {
+				head.removeChild( script );
+			}
+		};
+	}
+
+	// The JSONP request was successful
+	function jsonpSuccess(requestSettings, callbackContext, mockHandler) {
+		// If a local callback was specified, fire it and pass it the data
+		if ( requestSettings.success ) {
+			requestSettings.success.call( callbackContext, mockHandler.responseText || "", status, {} );
+		}
+
+		// Fire the global callback
+		if ( requestSettings.global ) {
+			(requestSettings.context ? $(requestSettings.context) : $.event).trigger("ajaxSuccess", [{}, requestSettings]);
+		}
+	}
+
+	// The JSONP request was completed
+	function jsonpComplete(requestSettings, callbackContext) {
+		// Process result
+		if ( requestSettings.complete ) {
+			requestSettings.complete.call( callbackContext, {} , status );
+		}
+
+		// The request was completed
+		if ( requestSettings.global ) {
+			(requestSettings.context ? $(requestSettings.context) : $.event).trigger("ajaxComplete", [{}, requestSettings]);
+		}
+
+		// Handle the global AJAX counter
+		if ( requestSettings.global && ! --$.active ) {
+			$.event.trigger( "ajaxStop" );
+		}
+	}
+
+
+	// The core $.ajax replacement.
+	function handleAjax( url, origSettings ) {
+		var mockRequest, requestSettings, mockHandler, overrideCallback;
+
+		// If url is an object, simulate pre-1.5 signature
+		if ( typeof url === "object" ) {
+			origSettings = url;
+			url = undefined;
+		} else {
+			// work around to support 1.5 signature
+			origSettings = origSettings || {};
+			origSettings.url = url;
+		}
+
+		// Extend the original settings for the request
+		requestSettings = $.extend(true, {}, $.ajaxSettings, origSettings);
+
+		// Generic function to override callback methods for use with
+		// callback options (onAfterSuccess, onAfterError, onAfterComplete)
+		overrideCallback = function(action, mockHandler) {
+			var origHandler = origSettings[action.toLowerCase()];
+			return function() {
+				if ( $.isFunction(origHandler) ) {
+					origHandler.apply(this, [].slice.call(arguments));
+				}
+				mockHandler['onAfter' + action]();
+			};
+		};
+
+		// Iterate over our mock handlers (in registration order) until we find
+		// one that is willing to intercept the request
+		for(var k = 0; k < mockHandlers.length; k++) {
+			if ( !mockHandlers[k] ) {
+				continue;
+			}
+
+			mockHandler = getMockForRequest( mockHandlers[k], requestSettings );
+			if(!mockHandler) {
+				// No valid mock found for this request
+				continue;
+			}
+
+			mockedAjaxCalls.push(requestSettings);
+
+			// If logging is enabled, log the mock to the console
+			$.mockjaxSettings.log( mockHandler, requestSettings );
+
+
+			if ( requestSettings.dataType && requestSettings.dataType.toUpperCase() === 'JSONP' ) {
+				if ((mockRequest = processJsonpMock( requestSettings, mockHandler, origSettings ))) {
+					// This mock will handle the JSONP request
+					return mockRequest;
+				}
+			}
+
+
+			// Removed to fix #54 - keep the mocking data object intact
+			//mockHandler.data = requestSettings.data;
+
+			mockHandler.cache = requestSettings.cache;
+			mockHandler.timeout = requestSettings.timeout;
+			mockHandler.global = requestSettings.global;
+
+			// In the case of a timeout, we just need to ensure
+			// an actual jQuery timeout (That is, our reponse won't)
+			// return faster than the timeout setting.
+			if ( mockHandler.isTimeout ) {
+				if ( mockHandler.responseTime > 1 ) {
+					origSettings.timeout = mockHandler.responseTime - 1;
+				} else {
+					mockHandler.responseTime = 2;
+					origSettings.timeout = 1;
+				}
+				mockHandler.isTimeout = false;
+			}
+
+			// Set up onAfter[X] callback functions
+			if ( $.isFunction( mockHandler.onAfterSuccess ) ) {
+				origSettings.success = overrideCallback('Success', mockHandler);
+			}
+			if ( $.isFunction( mockHandler.onAfterError ) ) {
+				origSettings.error = overrideCallback('Error', mockHandler);
+			}
+			if ( $.isFunction( mockHandler.onAfterComplete ) ) {
+				origSettings.complete = overrideCallback('Complete', mockHandler);
+			}
+
+			copyUrlParameters(mockHandler, origSettings);
+
+			(function(mockHandler, requestSettings, origSettings, origHandler) {
+
+				mockRequest = _ajax.call($, $.extend(true, {}, origSettings, {
+					// Mock the XHR object
+					xhr: function() { return xhr( mockHandler, requestSettings, origSettings, origHandler ); }
+				}));
+			})(mockHandler, requestSettings, origSettings, mockHandlers[k]);
+
+			return mockRequest;
+		}
+
+		// We don't have a mock request
+		unmockedAjaxCalls.push(origSettings);
+		if($.mockjaxSettings.throwUnmocked === true) {
+			throw new Error('AJAX not mocked: ' + origSettings.url);
+		}
+		else { // trigger a normal request
+			return _ajax.apply($, [origSettings]);
+		}
+	}
+
+	/**
+	* Copies URL parameter values if they were captured by a regular expression
+	* @param {Object} mockHandler
+	* @param {Object} origSettings
+	*/
+	function copyUrlParameters(mockHandler, origSettings) {
+		//parameters aren't captured if the URL isn't a RegExp
+		if (!(mockHandler.url instanceof RegExp)) {
+			return;
+		}
+		//if no URL params were defined on the handler, don't attempt a capture
+		if (!mockHandler.hasOwnProperty('urlParams')) {
+			return;
+		}
+		var captures = mockHandler.url.exec(origSettings.url);
+		//the whole RegExp match is always the first value in the capture results
+		if (captures.length === 1) {
+			return;
+		}
+		captures.shift();
+		//use handler params as keys and capture resuts as values
+		var i = 0,
+		capturesLength = captures.length,
+		paramsLength = mockHandler.urlParams.length,
+		//in case the number of params specified is less than actual captures
+		maxIterations = Math.min(capturesLength, paramsLength),
+		paramValues = {};
+		for (i; i < maxIterations; i++) {
+			var key = mockHandler.urlParams[i];
+			paramValues[key] = captures[i];
+		}
+		origSettings.urlParams = paramValues;
+	}
+
+
+	// Public
+
+	$.extend({
+		ajax: handleAjax
+	});
+
+	$.mockjaxSettings = {
+		//url:        null,
+		//type:       'GET',
+		log:          function( mockHandler, requestSettings ) {
+			if ( mockHandler.logging === false ||
+				 ( typeof mockHandler.logging === 'undefined' && $.mockjaxSettings.logging === false ) ) {
+				return;
+			}
+			if ( window.console && console.log ) {
+				var message = 'MOCK ' + requestSettings.type.toUpperCase() + ': ' + requestSettings.url;
+				var request = $.extend({}, requestSettings);
+
+				if (typeof console.log === 'function') {
+					console.log(message, request);
+				} else {
+					try {
+						console.log( message + ' ' + JSON.stringify(request) );
+					} catch (e) {
+						console.log(message);
+					}
+				}
+			}
+		},
+		logging:       true,
+		status:        200,
+		statusText:    "OK",
+		responseTime:  500,
+		isTimeout:     false,
+		throwUnmocked: false,
+		contentType:   'text/plain',
+		response:      '',
+		responseText:  '',
+		responseXML:   '',
+		proxy:         '',
+		proxyType:     'GET',
+
+		lastModified:  null,
+		etag:          '',
+		headers: {
+			etag: 'IJF@H#@923uf8023hFO@I#H#',
+			'content-type' : 'text/plain'
+		}
+	};
+
+	$.mockjax = function(settings) {
+		var i = mockHandlers.length;
+		mockHandlers[i] = settings;
+		return i;
+	};
+	$.mockjax.clear = function(i) {
+		if ( arguments.length == 1 ) {
+			mockHandlers[i] = null;
+		} else {
+			mockHandlers = [];
+		}
+		mockedAjaxCalls = [];
+		unmockedAjaxCalls = [];
+	};
+	// support older, deprecated version
+	$.mockjaxClear = function(i) {
+		window.console && window.console.warn && window.console.warn( 'DEPRECATED: The $.mockjaxClear() method has been deprecated in 1.6.0. Please use $.mockjax.clear() as the older function will be removed soon!' );
+		$.mockjax.clear();
+	};
+	$.mockjax.handler = function(i) {
+		if ( arguments.length == 1 ) {
+			return mockHandlers[i];
+		}
+	};
+	$.mockjax.mockedAjaxCalls = function() {
+		return mockedAjaxCalls;
+	};
+	$.mockjax.unfiredHandlers = function() {
+		var results = [];
+		for (var i=0, len=mockHandlers.length; i<len; i++) {
+			var handler = mockHandlers[i];
+            if (handler !== null && !handler.fired) {
+				results.push(handler);
+			}
+		}
+		return results;
+	};
+	$.mockjax.unmockedAjaxCalls = function() {
+		return unmockedAjaxCalls;
+	};
+})(jQuery);