ember-data-factory-guy 0.8.3 → 0.8.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6cec722b2159388b70506a21e8a83f4023b7af30
-  data.tar.gz: 35e7f0e16e331d54fca3e5e9d783b411db4b459d
+  metadata.gz: a62de689fff74d16df3fb9b94729bc70cc8a6732
+  data.tar.gz: 6efd7d089935309736957886b63d9b3494e4f02f
 SHA512:
-  metadata.gz: 935baa72d03b250f8164f8861a8d0ca46d97e4acd731c2088222a71fa69f7e97f1e2cf4823e0ec4f04af0f2b035843cce9b9b86c3080689678511ecf067b1bf8
-  data.tar.gz: 499d2a19b0118865c5fff04b64ea9258f4ff6f190aaf8f7defd0cce946b9e7443ca34f7b12f9ced4cf8a77afe63b78231a409a23da4a947d5fdf1ae33f53e7a4
+  metadata.gz: 04df59360622690f76bc7980592b77262b32190d4420aad6d99084d579abaae5fa94e77e18f21767ed32c4537bd0ad35b07f484ada08b388e873e9ffb2c7386a
+  data.tar.gz: b3ed6abf13aaf67a201a9d711defe20d3695f3cedcb9cb98f6a9d79190ac9125514f376a5773f95078798574add538a4ae2b968e4fe7a689eb5babafdd207106

data/Gruntfile.js

@@ -6,6 +6,16 @@ module.exports = function(grunt) {
 
     concat: {
       dist: {
+        src: [
+          'src/sequence.js',
+          'src/model_definition.js',
+          'src/factory_guy.js',
+          'src/store.js',
+          'src/factory_guy_test_mixin.js',
+        ],
+        dest: "dist/ember-data-factory-guy.js"
+      },
+      amd: {
         src: [
           'src/prologue.js',
           'src/sequence.js',
@@ -15,7 +25,7 @@ module.exports = function(grunt) {
           'src/factory_guy_test_mixin.js',
           'src/epilogue.js'
         ],
-        dest: "dist/ember-data-factory-guy.js"
+        dest: "dist/amd/factory-guy.js"
       },
       extra: {
         src: ['src/has_many.js'],

data/README.md

@@ -9,18 +9,25 @@ of ember-data-factory-guy.
 - Versions:
   - 0.6.4   -> ember-data-1.0.0-beta.8 and under
   - 0.7.1.1 -> ember-data-1.0.0-beta.10
-  - 0.8.2   -> ember-data-1.0.0-beta.11
-  - 0.8.2   -> ember-data-1.0.0-beta.12
+  - 0.8.3   -> ember-data-1.0.0-beta.11
+  - 0.8.3   -> ember-data-1.0.0-beta.12
 
-**For versions ( 0.7.1 -> 0.8.2 ), support for the fixture adapter is currently broken.**  
+**For versions ( 0.7.1 -> 0.8.3 ), support for the fixture adapter is currently broken.**  
 
-*Version 0.8.2 has many bug fixes and improvements that the earlier versions don't have, so 
+*Version 0.8.3 has many bug fixes and improvements that the earlier versions don't have, so 
 hopefully you can switch to newer version of ember-data and therefore the best 
 ember-data-factory-guy version, but if not, send me bug report and I will try and go back 
 and fix the older version you are using.*  
 
 **Version 0.8.0 introduces amd and commonjs support**
 
+## Using with Ember Cli
+  - https://github.com/igorrKurr/ember-cli-factory-guy-example
+    An example of how to manually set up ember-data-factory-guy with ember cli 
+  
+  - https://github.com/cristinawithout/ember-cli-data-factory-guy
+    A wrapper around ember-data-factory-guy for ember-cli for even easier setup
+
 ## Using as Gem
 
 To Use with in Rails project or project with sprockets:
@@ -34,7 +41,7 @@ gem 'ember-data-factory-guy', group: test
 or for particular version:
 
 ```ruby
-gem 'ember-data-factory-guy', '0.8.2', group: test
+gem 'ember-data-factory-guy', '0.8.3', group: test
 ```
 
 then:
@@ -69,7 +76,7 @@ or for particular version:
   "dependencies": {
     "foo-dependency": "latest",
     "other-foo-dependency": "latest",
-    "ember-data-factory-guy": "0.8.2"
+    "ember-data-factory-guy": "0.8.3"
   }
 ```
 
@@ -614,14 +621,15 @@ and this is already bundled for you when you use the ember-data-factory-guy libr
     - returns - attributes to include in response json
     - succeed - flag to indicate if the request should succeed ( default is true )
 
-*Note* 
-  That any attributes in match will be added to the response json automatically,
-  so you don't need to include them in the returns hash as well.
+**Note**
+ 
+  *Any attributes in match will be added to the response json automatically,
+  so you don't need to include them in the returns hash as well.*
     
-  If you don't use match options for exact match, there will be no id returned to the model.
+  *If you don't use match options for exact match, there will be no id returned to the model.*
      
-  If you match on a belongsTo association, you don't have to include that in the
-  returns hash.
+  *If you match on a belongsTo association, you don't have to include that in the
+  returns hash.*
   
   
 Realistically, you will have code in a view action or controller action that will
@@ -645,9 +653,15 @@ to a particular user. To mock this createRecord call here are a few ways to do t
 match and or returns options.
   
 ```javascript
-  // note that you don't need the returns option since the 
-  // match options are returned automatically  
+  // Simplest case  
+  // Don't care about a match just handle createRecord for any project  
+  testHelper.handleCreate('project')
+  // Exactly matching attributes
   testHelper.handleCreate('project', {match: {name: "Moo", user: user}})
+  // Exactly matching attributes, and returning extra attributes
+  testHelper.handleCreate('project', {
+    match: {name: "Moo", user: user}, returns: {created_at: new Date()}
+  })
 
 ```
 
@@ -655,11 +669,17 @@ match and or returns options.
 
 ```javascript
   // set the succeed flag to 'false' 
-  testHelper.handleCreate('profile', {succeed: false});
+  testHelper.handleCreate('project', {succeed: false});
   
   // when the createRecord on the 'project' is called, it will fail
   store.createRecord('project').save() //=> fails
 
+  // or fail only if the attribues match exactly  
+  testHelper.handleCreate('project', {
+    match: {name: "Moo", user: user}, {succeed: false}
+  })
+  
+  store.createRecord('project', {name: "Moo", user: user}).save() //=> fails
 ```
 
 

data/bower.json

@@ -1,6 +1,6 @@
 {
   "name": "ember-data-factory-guy",
-  "version": "0.8.3",
+  "version": "0.8.4",
   "authors": [
     "Daniel Sudol <dansudol@yahoo.com>",
     "Opak Alex <opak.alexandr@gmail.com>"

data/dist/amd/factory-guy.js

@@ -0,0 +1,921 @@
+define("factory-guy", ["ember-data"], function(__d1__) {
+  "use strict";
+
+  var DS = __d1__["default"] || __d1__;
+
+var Sequence = function (fn) {
+  var index = 1;
+  this.next = function () {
+    return fn.call(this, index++);
+  };
+  this.reset = function () {
+    index = 1;
+  };
+};
+
+var MissingSequenceError = function(message) {
+  this.toString = function () {
+    return message;
+  };
+};
+
+if (FactoryGuy !== undefined) {
+  FactoryGuy.sequence = Sequence;
+  FactoryGuy.missingSequenceError = MissingSequenceError;
+};
+
+/**
+ A ModelDefinition encapsulates a model's definition
+
+ @param model
+ @param config
+ @constructor
+ */
+var ModelDefinition = function (model, config) {
+  var sequences = {};
+  var traits = {};
+  var defaultAttributes = {};
+  var namedModels = {};
+  var modelId = 1;
+  var sequenceName = null;
+  this.model = model;
+  /**
+   @param {String} name model name like 'user' or named type like 'admin'
+   @returns {Boolean} true if name is this definitions model or this definition
+   contains a named model with that name
+   */
+  this.matchesName = function (name) {
+    return model == name || namedModels[name];
+  };
+  // Increment id
+  this.nextId = function () {
+    return modelId++;
+  };
+  /**
+   Call the next method on the named sequence function. If the name
+   is a function, create the sequence with that function
+
+   @param   {String} name previously declared sequence name or
+            an the random name generate for inline functions
+   @param   {Function} sequenceFn optional function to use as sequence
+   @returns {String} output of sequence function
+   */
+  this.generate = function (name, sequenceFn) {
+    if (sequenceFn) {
+      if (!sequences[name]) {
+        // create and add that sequence function on the fly
+        sequences[name] = new Sequence(sequenceFn);
+      }
+    }
+    var sequence = sequences[name];
+    if (!sequence) {
+      throw new MissingSequenceError('Can not find that sequence named [' + sequenceName + '] in \'' + model + '\' definition');
+    }
+    return sequence.next();
+  };
+  /**
+   Build a fixture by name
+
+   @param {String} name fixture name
+   @param {Object} opts attributes to override
+   @param {String} traitArgs array of traits
+   @returns {Object} json
+   */
+  this.build = function (name, opts, traitArgs) {
+    var traitsObj = {};
+    traitArgs.forEach(function (trait) {
+      $.extend(traitsObj, traits[trait]);
+    });
+    var modelAttributes = namedModels[name] || {};
+    // merge default, modelAttributes, traits and opts to get the rough fixture
+    var fixture = $.extend({}, defaultAttributes, modelAttributes, traitsObj, opts);
+    // deal with attributes that are functions or objects
+    for (var attribute in fixture) {
+      if (Ember.typeOf(fixture[attribute]) == 'function') {
+        // function might be a sequence of a named association
+        fixture[attribute] = fixture[attribute].call(this, fixture);
+      } else if (Ember.typeOf(fixture[attribute]) == 'object') {
+        // if it's an object it's for a model association, so build the json
+        // for the association and replace the attribute with that json
+        fixture[attribute] = FactoryGuy.build(attribute, fixture[attribute]);
+      }
+    }
+    // set the id, unless it was already set in opts
+    if (!fixture.id) {
+      fixture.id = this.nextId();
+    }
+    return fixture;
+  };
+  /**
+   Build a list of fixtures
+
+   @param {String} name model name or named model type
+   @param {Integer} number of fixtures to build
+   @param {Array} array of traits to build with
+   @param {Object} opts attribute options
+   @returns array of fixtures
+   */
+  this.buildList = function (name, number, traits, opts) {
+    var arr = [];
+    for (var i = 0; i < number; i++) {
+      arr.push(this.build(name, opts, traits));
+    }
+    return arr;
+  };
+  // Set the modelId back to 1, and reset the sequences
+  this.reset = function () {
+    modelId = 1;
+    for (var name in sequences) {
+      sequences[name].reset();
+    }
+  };
+  var parseDefault = function (object) {
+    if (!object) {
+      return;
+    }
+    defaultAttributes = object;
+  };
+  var parseTraits = function (object) {
+    if (!object) {
+      return;
+    }
+    traits = object;
+  };
+  var parseSequences = function (object) {
+    if (!object) {
+      return;
+    }
+    for (sequenceName in object) {
+      var sequenceFn = object[sequenceName];
+      if (Ember.typeOf(sequenceFn) != 'function') {
+        throw new Error('Problem with [' + sequenceName + '] sequence definition. Sequences must be functions');
+      }
+      object[sequenceName] = new Sequence(sequenceFn);
+    }
+    sequences = object;
+  };
+  var parseConfig = function (config) {
+    parseSequences(config.sequences);
+    delete config.sequences;
+    parseTraits(config.traits);
+    delete config.traits;
+    parseDefault(config.default);
+    delete config.default;
+    namedModels = config;
+  };
+  // initialize
+  parseConfig(config);
+};
+
+if (FactoryGuy !== undefined) {
+  FactoryGuy.modelDefiniton = ModelDefinition;
+};
+
+var FactoryGuy = {
+  modelDefinitions: {},
+  /**
+   ```javascript
+
+   Person = DS.Model.extend({
+     type: DS.attr('string'),
+     name: DS.attr('string')
+   })
+
+   FactoryGuy.define('person', {
+     sequences: {
+       personName: function(num) {
+         return 'person #' + num;
+       },
+       personType: function(num) {
+         return 'person type #' + num;
+       }
+     },
+     default: {
+       type: 'normal',
+       name: FactoryGuy.generate('personName')
+     },
+     dude: {
+       type: FactoryGuy.generate('personType')
+     },
+   });
+
+   ```
+
+   For the Person model, you can define named fixtures like 'dude' or
+   just use 'person' and get default values.
+
+   And to get those fixtures you would call them this way:
+
+   FactoryGuy.build('dude') or FactoryGuy.build('person')
+
+   @param {String} model the model to define
+   @param {Object} config your model definition
+   */
+  define: function (model, config) {
+    if (this.modelDefinitions[model]) {
+      this.modelDefinitions[model].merge(config);
+    } else {
+      this.modelDefinitions[model] = new ModelDefinition(model, config);
+    }
+  },
+  /**
+   Used in model definitions to declare use of a sequence. For example:
+
+   ```
+
+   FactoryGuy.define('person', {
+     sequences: {
+       personName: function(num) {
+         return 'person #' + num;
+       }
+     },
+     default: {
+       name: FactoryGuy.generate('personName')
+     }
+   });
+
+   ```
+
+   @param   {String|Function} value previously declared sequence name or
+            an inline function to use as the sequence
+   @returns {Function} wrapper function that is called by the model
+            definition containing the sequence
+   */
+  generate: function (nameOrFunction) {
+    var sortaRandomName = Math.floor((1 + Math.random()) * 65536).toString(16) + Date.now();
+    return function () {
+      if (Em.typeOf(nameOrFunction) == 'function') {
+        return this.generate(sortaRandomName, nameOrFunction);
+      } else {
+        return this.generate(nameOrFunction);
+      }
+    };
+  },
+  /**
+   Used in model definitions to define a belongsTo association attribute.
+   For example:
+
+    ```
+     FactoryGuy.define('project', {
+       default: {
+         title: 'Project'
+       },
+
+       // setup named project with built in associated user
+       project_with_admin: {
+         user: FactoryGuy.belongsTo('admin')
+       }
+
+       // or use as a trait
+       traits: {
+         with_admin: {
+           user: FactoryGuy.belongsTo('admin')
+         }
+       }
+     })
+    ```
+
+   @param   {String} fixtureName fixture name
+   @param   {Object} opts options
+   @returns {Function} wrapper function that will build the association json
+   */
+  belongsTo: function (fixtureName, opts) {
+    return function () {
+      return FactoryGuy.build(fixtureName, opts);
+    };
+  },
+  association: function (fixtureName, opts) {
+    console.log('DEPRECATION Warning: use FactoryGuy.belongsTo instead');
+    return this.belongsTo(fixtureName, opts);
+  },
+  /**
+   Used in model definitions to define a hasMany association attribute.
+   For example:
+
+   ```
+   FactoryGuy.define('user', {
+     default: {
+       name: 'Bob'
+     },
+
+     // define the named user type that will have projects
+     user_with_projects: { FactoryGuy.hasMany('project', 2) }
+
+     // or use as a trait
+     traits: {
+       with_projects: {
+         projects: FactoryGuy.hasMany('project', 2)
+       }
+     }
+   })
+
+    ```
+
+   @param   {String} fixtureName fixture name
+   @param   {Number} number of hasMany association items to build
+   @param   {Object} opts options
+   @returns {Function} wrapper function that will build the association json
+   */
+  hasMany: function (fixtureName, number, opts) {
+    return function () {
+      return FactoryGuy.buildList(fixtureName, number, opts);
+    };
+  },
+  /**
+    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'
+          or a named person in model definition like 'dude'
+   @returns {String} model  name associated with fixture name or undefined if not found
+   */
+  lookupModelForFixtureName: function (name) {
+    var definition = this.lookupDefinitionForFixtureName(name);
+    if (definition) {
+      return definition.model;
+    }
+  },
+  /**
+
+   @param {String} name a fixture name could be model name like 'person'
+          or a named person in model definition like 'dude'
+   @returns {ModelDefinition} ModelDefinition associated with model or undefined if not found
+   */
+  lookupDefinitionForFixtureName: function (name) {
+    for (var model in this.modelDefinitions) {
+      var definition = this.modelDefinitions[model];
+      if (definition.matchesName(name)) {
+        return definition;
+      }
+    }
+  },
+  /**
+   Build fixtures for model or specific fixture name. For example:
+
+   FactoryGuy.build('user') for User model
+   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'
+
+   @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 () {
+    var args = Array.prototype.slice.call(arguments);
+    var opts = {};
+    var name = args.shift();
+    if (!name) {
+      throw new Error('Build needs a factory name to build');
+    }
+    if (Ember.typeOf(args[args.length - 1]) == 'object') {
+      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 + ']');
+    }
+    return definition.build(name, opts, traits);
+  },
+  /**
+   Build list of fixtures for model or specific fixture name. For example:
+
+   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  optional traits (one or more)
+   @param {Object} opts  optional fixture options that will override default fixture values
+   @returns {Array} list of fixtures
+   */
+  buildList: function () {
+    var args = Array.prototype.slice.call(arguments);
+    var name = args.shift();
+    var number = args.shift();
+    if (!name || !number) {
+      throw new Error('buildList needs a name and a number ( at least ) to build with');
+    }
+    var opts = {};
+    if (Ember.typeOf(args[args.length - 1]) == 'object') {
+      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 + ']');
+    }
+    return definition.buildList(name, number, traits, opts);
+  },
+
+  /**
+   Clear model instances from FIXTURES array, and from store cache.
+   Reset the id sequence for the models back to zero.
+  */
+  resetModels: function (store) {
+    for (var model in this.modelDefinitions) {
+      var definition = this.modelDefinitions[model];
+      definition.reset();
+      try {
+        var modelType = store.modelFor(definition.model);
+        if (store.usingFixtureAdapter()) {
+          modelType.FIXTURES = [];
+        }
+        store.unloadAll(modelType);
+      } catch (e) {
+        console.log('resetModels',e)
+      }
+    }
+  },
+  /**
+   Push fixture to model's FIXTURES array.
+   Used when store's adapter is a DS.FixtureAdapter.
+
+   @param {DS.Model} modelClass
+   @param {Object} fixture the fixture to add
+   @returns {Object} json fixture data
+   */
+  pushFixture: function (modelClass, fixture) {
+    if (!modelClass.FIXTURES) {
+      modelClass.FIXTURES = [];
+    }
+    modelClass.FIXTURES.push(fixture);
+    return fixture;
+  },
+  /**
+   Clears all model definitions
+  */
+  clear: function (opts) {
+    if (!opts) {
+      this.modelDefinitions = {};
+    }
+  }
+};
+(function () {
+  DS.Store.reopen({
+    /**
+     @returns {Boolean} true if store's adapter is DS.FixtureAdapter
+     */
+    usingFixtureAdapter: function () {
+      var adapter = this.adapterFor('application');
+      return adapter instanceof DS.FixtureAdapter;
+    },
+    /**
+     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 to load
+     the record into the store
+
+     @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 () {
+      var store = this;
+      var fixture = FactoryGuy.build.apply(FactoryGuy, arguments);
+      var name = arguments[0];
+      var modelName = FactoryGuy.lookupModelForFixtureName(name);
+      var modelType = store.modelFor(modelName);
+      if (this.usingFixtureAdapter()) {
+        this.setAssociationsForFixtureAdapter(modelType, modelName, fixture);
+        return FactoryGuy.pushFixture(modelType, fixture);
+      } else {
+        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
+
+     @param {String} name name of fixture
+     @param {Number} number number to create
+     @param {Object} options fixture options
+     @returns {Array} list of json fixtures or records depending on the adapter type
+     */
+    makeList: function () {
+      var arr = [];
+      var number = arguments[1];
+      for (var i = 0; i < number; i++) {
+        arr.push(this.makeFixture.apply(this, arguments));
+      }
+      return arr;
+    },
+    /**
+     Set the hasMany and belongsTo associations for FixtureAdapter.
+
+     For example, assuming a user hasMany projects, if you make a project,
+     then a user with that project in the users list of project, then this method
+     will go back and set the user.id on each project that the user hasMany of,
+     so that the project now has the belongsTo user association setup.
+     As in this scenario:
+
+     ```js
+     var projectJson = store.makeFixture('project');
+     var userJson = store.makeFixture('user', {projects: [projectJson]});
+     ```
+
+     Or if you make a project with a user, then set this project in
+     the users list of 'projects' it hasMany of. As in this scenario:
+
+     ```js
+     var userJson = store.makeFixture('user');
+     var projectJson = store.makeFixture('project', {user: userJson});
+     ```
+
+     @param {DS.Model} modelType model type like User
+     @param {String} modelName model name like 'user'
+     @param {Object} fixture to check for needed association assignments
+     */
+    setAssociationsForFixtureAdapter: function (modelType, modelName, fixture) {
+      var self = this;
+      var adapter = this.adapterFor('application');
+      Ember.get(modelType, 'relationshipsByName').forEach(function (relationship, name) {
+        if (relationship.kind == 'hasMany') {
+          var hasManyRelation = fixture[relationship.key];
+          if (hasManyRelation) {
+            $.each(fixture[relationship.key], function (index, object) {
+              // used to require that the relationship was set by id,
+              // but now, you can set it as the json object, and this will
+              // normalize that back to the id
+              var id = object;
+              if (Ember.typeOf(object) == 'object') {
+                id = object.id;
+                hasManyRelation[index] = id;
+              }
+              var hasManyfixtures = adapter.fixturesForType(relationship.type);
+              var fixture = adapter.findFixtureById(hasManyfixtures, id);
+              fixture[modelName] = fixture.id;
+            });
+          }
+        }
+        if (relationship.kind == 'belongsTo') {
+          var belongsToRecord = fixture[relationship.key];
+          if (belongsToRecord) {
+            if (typeof belongsToRecord == 'object') {
+              FactoryGuy.pushFixture(relationship.type, belongsToRecord);
+              fixture[relationship.key] = belongsToRecord.id;
+            }
+            var hasManyName = self.findHasManyRelationshipNameForFixtureAdapter(relationship.type, relationship.parentType);
+            var belongsToFixtures = adapter.fixturesForType(relationship.type);
+            var belongsTofixture = adapter.findFixtureById(belongsToFixtures, fixture[relationship.key]);
+            if (!belongsTofixture[hasManyName]) {
+              belongsTofixture[hasManyName] = [];
+            }
+            belongsTofixture[hasManyName].push(fixture.id);
+          }
+        }
+      });
+    },
+    /**
+     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
+     as the attribute value in the fixture
+
+     @param modelType
+     @param fixture
+     */
+    findEmbeddedAssociationsForRESTAdapter: function (modelType, fixture) {
+      var store = this;
+      Ember.get(modelType, 'relationshipsByName').forEach(function (relationship, name) {
+        if (relationship.kind == 'belongsTo') {
+          var belongsToRecord = fixture[relationship.key];
+          if (Ember.typeOf(belongsToRecord) == 'object') {
+            store.findEmbeddedAssociationsForRESTAdapter(relationship.type, belongsToRecord);
+            belongsToRecord = store.push(relationship.type, belongsToRecord);
+            fixture[relationship.key] = belongsToRecord;
+          }
+        }
+        if (relationship.kind == 'hasMany') {
+          var hasManyRecords = fixture[relationship.key];
+          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;
+              });
+              fixture[relationship.key] = records;
+            }
+          }
+        }
+      });
+    },
+    /**
+     For the REST type models:
+
+     For example if a user hasMany projects, then set the user
+     on each project that the user hasMany of, so that the project
+     now has the belongsTo user association setup. As in this scenario:
+
+     ```js
+     var project = store.makeFixture('project');
+     var user = store.makeFixture('user', {projects: [project]});
+     ```
+
+     Or if you make a user, then a project with that user, then set the project
+     in the users list of 'projects' it hasMany of. As in this scenario:
+
+     ```js
+     var user = store.makeFixture('user');
+     var project = store.makeFixture('project', {user: user});
+     ```
+
+     NOTE:
+     As of ember-data-1.0.0-beta.10 and ember-data-1.0.0-beta.12,
+     this method is only needed because the belongsTo is not assigned when
+     there is a self referential polymorphic has many association.
+
+     @param {DS.Model} modelType model type like 'User'
+     @param {String} modelName model name like 'user'
+     @param {DS.Model} model model to check for needed association assignments
+     */
+    setAssociationsForRESTAdapter: function (modelType, modelName, model) {
+      var self = this;
+      Ember.get(modelType, 'relationshipsByName').forEach(function (relationship, name) {
+        if (relationship.kind == 'hasMany') {
+          var children = model.get(name) || [];
+          children.forEach(function (child) {
+            var belongsToName = self.findRelationshipName('belongsTo', child.constructor, model);
+            if (belongsToName) {
+              child.set(belongsToName, model);
+            }
+          });
+        }
+      });
+    },
+    findRelationshipName: function (kind, belongToModelType, childModel) {
+      var relationshipName;
+      Ember.get(belongToModelType, 'relationshipsByName').forEach(function (relationship, name) {
+        if (relationship.kind == kind && childModel instanceof relationship.type) {
+          relationshipName = relationship.key;
+        }
+      });
+      return relationshipName;
+    },
+    findHasManyRelationshipNameForFixtureAdapter: function (belongToModelType, childModelType) {
+      var relationshipName;
+      Ember.get(belongToModelType, 'relationshipsByName').forEach(function (relationship, name) {
+        if (relationship.kind == 'hasMany' && childModelType == relationship.type) {
+          relationshipName = relationship.key;
+        }
+      });
+      return relationshipName;
+    },
+    /**
+     Adding a pushPayload for FixtureAdapter, but using the original with
+     other adapters that support pushPayload.
+
+     @param {String} type
+     @param {Object} payload
+     */
+    pushPayload: function (type, payload) {
+      if (this.usingFixtureAdapter()) {
+        var model = this.modelFor(modelName);
+        FactoryGuy.pushFixture(model, payload);
+      } else {
+        this._super(type, payload);
+      }
+    }
+  });
+})();
+var FactoryGuyTestMixin = Em.Mixin.create({
+  // Pass in the app root, which typically is App.
+  setup: function (app) {
+    this.set('container', app.__container__);
+    return this;
+  },
+  useFixtureAdapter: function (app) {
+    app.ApplicationAdapter = DS.FixtureAdapter;
+    this.getStore().adapterFor('application').simulateRemoteResponse = false;
+  },
+  /**
+   @param {String} model type like user for model User
+   @return {boolean} true if model's serializer is ActiveModelSerializer based
+   */
+  usingActiveModelSerializer: function (type) {
+    var store = this.getStore();
+    var modelType = store.modelFor(type);
+    var serializer = store.serializerFor(modelType.typeKey);
+    return serializer instanceof DS.ActiveModelSerializer;
+  },
+  /**
+   Proxy to store's find method
+
+   @param {String or subclass of DS.Model} type
+   @param {Object|String|Integer|null} id
+   @return {Promise} promise
+   */
+  find: function (type, id) {
+    return this.getStore().find(type, id);
+  },
+  /**
+   Proxy to store's makeFixture method
+
+   */
+  make: function () {
+    var store = this.getStore();
+    return store.makeFixture.apply(store, arguments);
+  },
+  getStore: function () {
+    return this.get('container').lookup('store:main');
+  },
+  pushPayload: function (type, hash) {
+    return this.getStore().pushPayload(type, hash);
+  },
+  pushRecord: function (type, hash) {
+    return this.getStore().push(type, hash);
+  },
+  /**
+   Using mockjax to stub an http request.
+
+   @param {String} url request url
+   @param {Object} json response
+   @param {Object} options ajax request options
+   */
+  stubEndpointForHttpRequest: function (url, json, options) {
+    options = options || {};
+    var request = {
+      url: url,
+      dataType: 'json',
+      responseText: json,
+      type: options.type || 'GET',
+      status: options.status || 200
+    };
+    if (options.data) {
+      request.data = options.data;
+    }
+    $.mockjax(request);
+  },
+  /**
+   Build url for the mockjax call. Proxy to the adapters buildURL method.
+
+   @param {String} typeName model type name like 'user' for User model
+   @param {String} id
+   @return {String} url
+   */
+  buildURL: function (typeName, id) {
+    var type = this.getStore().modelFor(typeName);
+    return this.getStore().adapterFor(type).buildURL(type.typeKey, id);
+  },
+  /**
+     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
+   */
+  handleFindMany: function () {
+    var store = this.getStore();
+    // make the records and load them in the store
+    store.makeList.apply(store, arguments);
+    var name = arguments[0];
+    var modelName = FactoryGuy.lookupModelForFixtureName(name);
+    var responseJson = {};
+    responseJson[modelName] = [];
+    var url = this.buildURL(modelName);
+    // mock the ajax call, but return nothing, since the records will be
+    // retrieved from the store where they were just loaded above
+    this.stubEndpointForHttpRequest(url, responseJson, { type: 'GET' });
+  },
+  /**
+   Handling ajax POST ( create record ) for a model. You can mock
+   failed create by passing in success argument as false.
+
+   ```js
+     handleCreate('post')
+     handleCreate('post', { match: {title: 'foo'} )
+     handleCreate('post', { match: {title: 'foo', user: user} )
+     handleCreate('post', { returns: {createdAt: new Date()} )
+     handleCreate('post', { match: {title: 'foo'}, returns: {createdAt: new Date()} )
+     handleCreate('post', { match: {title: 'foo'}, success: false} } )
+   ```
+
+    match - attributes that must be in request json,
+    returns - attributes to include in response json,
+    succeed - flag to indicate if the request should succeed ( default is true )
+
+    Note:
+     1) that any attributes in match will be added to the response json automatically,
+    so you don't need to include them in the returns hash as well.
+
+     2) If you don't use match options for exact match, there will be no id returned to the model.
+
+     3) If you match on a belongsTo association, you don't have to include that in the
+    returns hash.
+
+   @param {String} modelName  name of model your creating like 'profile' for Profile
+   @param {Object} options  hash of options for handling request
+   */
+  handleCreate: function (modelName, options) {
+    var opts = options === undefined ? {} : options;
+    var succeed = opts.succeed === undefined ? true : opts.succeed;
+    var match = opts.match || {};
+    var returnArgs = opts.returns || {};
+
+    var url = this.buildURL(modelName);
+    var definition = FactoryGuy.modelDefinitions[modelName];
+
+    var httpOptions = {type: 'POST'};
+    if (opts.match) {
+      var expectedRequest = {};
+      var record = this.getStore().createRecord(modelName, match);
+      expectedRequest[modelName] = record.serialize();
+      httpOptions.data = JSON.stringify(expectedRequest);
+    }
+
+    var modelType = this.getStore().modelFor(modelName)
+
+    var responseJson = {};
+    if (succeed) {
+      if (options) {
+        responseJson[modelName] = $.extend({id: definition.nextId()}, match, returnArgs);
+        // Remove belongsTo associations since they will already be set when you called
+        // createRecord, and included them in those attributes
+        Ember.get(modelType, 'relationshipsByName').forEach(function (relationship) {
+          if (relationship.kind == 'belongsTo') {
+            delete responseJson[modelName][relationship.key];
+          }
+        })
+      }
+    } 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 success argument as false.
+
+   @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, succeed) {
+    succeed = succeed === undefined ? true : succeed;
+    this.stubEndpointForHttpRequest(this.buildURL(type, id), {}, {
+      type: 'PUT',
+      status: succeed ? 200 : 500
+    });
+  },
+  /**
+   Handling ajax DELETE ( delete record ) for a model type. You can mock
+   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 {Boolean} succeed  optional flag to indicate if the request
+      should succeed ( default is true )
+   */
+  handleDelete: function (type, id, succeed) {
+    succeed = succeed === undefined ? true : succeed;
+    this.stubEndpointForHttpRequest(this.buildURL(type, id), {}, {
+      type: 'DELETE',
+      status: succeed ? 200 : 500
+    });
+  },
+  teardown: function () {
+    FactoryGuy.resetModels(this.getStore());
+    $.mockjax.clear();
+  }
+});
+
+if (FactoryGuy !== undefined) {
+  FactoryGuy.testMixin = FactoryGuyTestMixin;
+};
+
+
+  return {
+    default: FactoryGuy,
+    modelDefinition: FactoryGuy.modelDefinition,
+    sequence: FactoryGuy.sequence,
+    testMixin: FactoryGuy.testMixin
+  }
+});