ember-data-factory-guy 0.1.3 → 0.2.0

data/Gruntfile.js

@@ -56,6 +56,7 @@ module.exports = function(grunt) {
   grunt.loadNpmTasks('grunt-contrib-concat');
   grunt.loadNpmTasks('grunt-contrib-uglify');
   grunt.loadNpmTasks('grunt-contrib-qunit');
+  grunt.loadNpmTasks('grunt-bump');
 
   grunt.registerTask('default', ['concat', 'uglify']);
   grunt.registerTask('test', ['concat:dist', 'qunit']);

data/README.md

@@ -17,6 +17,13 @@ then:
 $ bundle install
 ```
 
+then:
+
+```javascript
+// require the 'ember_data_factory_guy' javascript file in your test helper
+//= require ember_data_factory_guy
+```
+
 # Using as bower component
 
 Add as one of your dependencies in bower.json file:
@@ -58,13 +65,14 @@ but BEFORE you require your models.
   // Model definitions
 
   User = DS.Model.extend({
-    name:     DS.attr 'string',
-    type:     DS.attr 'string',
-    projects: DS.hasMany 'project'
+    name:     DS.attr('string'),
+    type:     DS.attr('string'),
+    projects: DS.hasMany('project')
   })
 
   Project = DS.Model.extend({
-    title: DS.attr 'string'
+    title:  DS.attr('string')
+    user:   DS.belongsTo('user')
   })
 
   ////////////////////////////////////////////
@@ -77,12 +85,13 @@ but BEFORE you require your models.
       }
    },
 
-   // default values for 'user' attributes
+   // default 'user' attributes
     default: {
       type: 'normal',
       // use the 'userName' sequence for this attribute
       name: FactoryGuy.generate('userName')
     },
+
     // named 'user' type with custom attributes
     admin: {
       type: 'superuser',
@@ -91,13 +100,16 @@ but BEFORE you require your models.
   });
 
   FactoryGuy.define('project', {
-    default: {title: 'Project'}
+    default: {
+      title: 'Project'
+    }
   });
 
   //////////////////////////////////////////////////////////////////
   //            ** Make one fixture at time **
   // building json with FactoryGuy.build
   //
+
   var userJson = FactoryGuy.build('user') // {id: 1, name: 'User1', type: 'normal'}
   // note the sequence used in the name attribute
   var user2Json = FactoryGuy.build('user') // {id: 2, name: 'User2', type: 'normal'}
@@ -108,26 +120,29 @@ but BEFORE you require your models.
   //            ** Make a list of fixtures **
   // building json with FactoryGuy.buildList
   //
+
   var userJson = FactoryGuy.buildList('user',2) // [ {id: 1, name: 'User1', type: 'normal'}, {id: 2, name: 'User2', type: 'normal'} ]
 
   //////////////////////////////////////////////////////////////////
-  // store.makeFixture method creates model in the store
-  // store.makeList method creates list of models in the store
   //
-  // with DS.Fixture adapter
-  //  makeFixture returns json
-  //  makeList returns json
+  //  with store using =>    DS.Fixture adapter
+  //
+  //  store.makeFixture => creates model in the store and returns json
+  //  store.makeList    => creates list of models in the store and returns json
   //
-  store.makeFixture('user'); //  user.FIXTURES = {id: 1, name: 'User1', type: 'normal'}
-  store.makeFixture('user', {name: 'bob'}); //  user.FIXTURES = {id: 2, name: 'bob', type: 'normal'}
-  store.makeFixture('admin'); //  user.FIXTURES = {id: 3, name: 'Admin', type: 'superuser'}
-  store.makeFixture('admin', name: 'My name'); //  user.FIXTURES = {id: 4, name: 'My name', type: 'normal'}
 
+  store.makeFixture('user'); //  user.FIXTURES = [{id: 1, name: 'User1', type: 'normal'}]
+  store.makeFixture('user', {name: 'bob'}); //  user.FIXTURES = [{id: 2, name: 'bob', type: 'normal'}]
+  store.makeFixture('admin'); //  user.FIXTURES = [{id: 3, name: 'Admin', type: 'superuser'}]
+  store.makeFixture('admin', name: 'Fred'); //  user.FIXTURES = [{id: 4, name: 'Fred', type: 'superuser'}]
 
-  // Use store.find to get the model instance
-  store.makeFixture('user');
-  store.find('user', 1).then(function(user) {
-    user.get('name') == 'My name';
+
+  // Use store.find to get the model instance ( Remember this is the Fixture adapter, if
+  // you use the ActiveModelAdapter or RESTAdapter the record is returned so you don't
+  // have to then go and find it
+  var userJson = store.makeFixture('user');
+  store.find('user', userJson.id).then(function(user) {
+    user.toJSON() ( has all the same key/values as ) userJson;
   });
 
   // and to setup associations ...
@@ -147,21 +162,24 @@ but BEFORE you require your models.
     });
   });
 
+
   //////////////////////////////////////////////////////////////////
-  // store.makeFixture method creates model and adds it to store
-  // store.makeList methods creates list of models and ads each to the store
   //
-  // with DS.ActiveModelAdapter/DS.RestAdapter
+  //  with store using =>  DS.ActiveModelAdapter/DS.RestAdapter
   //
-  // returns a model instances so you can synchronously
-  // start asking for data, as soon as you get the model
+  //  store.makeFixture => creates model in the store and returns model instance
+  //  store.makeList    => creates list of models in the store and returns model instance
   //
+  //  *NOTE*  since you are now getting a model instances, you can synchronously
+  //   start asking for data from the model
+  //
+
   var user = store.makeFixture('user'); //  user.toJSON() = {id: 1, name: 'User1', type: 'normal'}
   // note that the user name is a sequence
   var user = store.makeFixture('user'); //  user.toJSON() = {id: 2, name: 'User2', type: 'normal'}
   var user = store.makeFixture('user', {name: 'bob'}); //  user.toJSON() = {id: 3, name: 'bob', type: 'normal'}
   var user = store.makeFixture('admin'); //  user.toJSON() = {id: 4, name: 'Admin', type: 'superuser'}
-  var user = store.makeFixture('admin', name: 'Nother Admin'); //  user.toJSON() = {id: 5, name: 'Nother Admin', type: 'superuser'}
+  var user = store.makeFixture('admin', name: 'Fred'); //  user.toJSON() = {id: 5, name: 'Fred', type: 'superuser'}
 
   // and to setup associations ...
 
@@ -214,12 +232,13 @@ test("make a user using fixture adapter", function() {
   testHelper.useFixtureAdapter();
   var json = make('user');
   equal(User.FIXTURES.length, 1);
+  equal(User.FIXTURES[0], json);
 });
 
 // assuming your default adapter is ActiveModelAdapter or RESTAdapter
 test("make a user using your applications default adapter", function() {
   var user = make('user');
-  equal(store.all('user').get('content.length'), 1)
+  equal(store.all('user').get('content.length'), 1);
   equal(user instanceof DS.Model, true);
 });
 

data/bower.json

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

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

@@ -1,6 +1,5 @@
 Sequence = function (fn) {
   var index = 1;
-  var fn = fn;
 
   this.next = function () {
     return fn.call(this, index++);
@@ -9,12 +8,19 @@ Sequence = function (fn) {
   this.reset = function () {
     index = 1;
   }
-}
+};
 
 function MissingSequenceError(message) {
   this.toString = function() { return message }
-}
+};
+
+/**
+ A ModelDefinition encapsulates a model's definition
 
+ @param model
+ @param config
+ @constructor
+ */
 ModelDefinition = function (model, config) {
   var sequences = {};
   var defaultAttributes = {};
@@ -23,36 +29,50 @@ ModelDefinition = function (model, config) {
   this.model = model;
 
   /**
-   @param name model name like 'user' or named type like 'admin'
-   @return boolean true if name is this definitions model or this definition
-           contains a named model with that name
+   @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];
   }
 
+  // TODO
   this.merge = function (config) {
   }
 
   /**
-    @param sequenceName
-    @returns output of sequence function
+   Call the next method on the named sequence function
+
+   @param {String} sequenceName
+   @returns {String} output of sequence function
    */
   this.generate = function (sequenceName) {
-    if (!sequences[sequenceName]) {
-      throw new MissingSequenceError("Can not find that sequence named ["+sequenceName+"] in '"+ model+"' definition")
+    var sequence = sequences[sequenceName];
+    if (!sequence) {
+      throw new MissingSequenceError("Can not find that sequence named [" + sequenceName + "] in '" + model + "' definition")
     }
-    return sequences[sequenceName].next();
+    return sequence.next();
   }
 
+  /**
+   Build a fixture by name
+
+   @param {String} name fixture name
+   @param {Object} opts attributes to override
+   @returns {Object} json
+   */
   this.build = function (name, opts) {
     var modelAttributes = namedModels[name] || {};
+    // merge default, modelAttributes and opts to get the rough fixture
     var fixture = $.extend({}, defaultAttributes, modelAttributes, opts);
-    for (attr in fixture) {
-      if (typeof fixture[attr] == 'function') {
-        fixture[attr] = fixture[attr].call(this)
+    // convert attributes that are functions to strings
+    for (attribute in fixture) {
+      if (typeof fixture[attribute] == 'function') {
+        fixture[attribute] = fixture[attribute].call(this, fixture);
       }
     }
+    // set the id, unless it was already set in opts
     if (!fixture.id) {
       fixture.id = modelId++;
     }
@@ -60,12 +80,12 @@ ModelDefinition = function (model, config) {
   }
 
   /**
-    Build a list of fixtures
+   Build a list of fixtures
 
-    @param name model name or named model type
-    @param number of fixtures to build
-    @param opts attribute options
-    @returns array of fixtures
+   @param name model name or named model type
+   @param number of fixtures to build
+   @param opts attribute options
+   @returns array of fixtures
    */
   this.buildList = function (name, number, opts) {
     var arr = [];
@@ -75,8 +95,12 @@ ModelDefinition = function (model, config) {
     return arr;
   }
 
+  // Set the modelId back to 1, and reset the sequences
   this.reset = function () {
     modelId = 1;
+    for (name in sequences) {
+      sequences[name].reset();
+    }
   }
 
   var parseDefault = function (object) {
@@ -144,12 +168,12 @@ FactoryGuy = {
 
    ```
 
-   For the Person model, you can define fixtures like 'dude' or just use 'person'
-   and get default values.
+   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('person') or FactoryGuy.build('dude')
+   FactoryGuy.build('dude') or FactoryGuy.build('person')
 
    @param model the model to define
    @param config your model definition object
@@ -162,18 +186,41 @@ FactoryGuy = {
     }
   },
 
+  /**
+   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} sequenceName
+   @returns {Function} wrapper function that is called by the model
+            definition containing the sequence
+   */
   generate: function (sequenceName) {
     return function () {
       return this.generate(sequenceName);
     }
   },
 
-
   /**
+    Given a name like 'person' or 'dude' determine what model this name
+    refers to. In this case it's 'person' for each one.
 
-   @param name fixture name could be model name like 'user'
-   or specific user like 'admin'
-   @returns model associated with fixture name
+   @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
    */
   lookupModelForName: function (name) {
     for (model in this.modelDefinitions) {
@@ -186,9 +233,9 @@ FactoryGuy = {
 
   /**
 
-   @param name fixture name could be model name like 'user'
-   or specific user like 'admin'
-   @returns definition associated with model
+   @param {String} name a fixture name could be model name like 'person'
+          or a named person in model definition like 'dude'
+   @returns {ModelDefinition} definition associated with model
    */
   lookupDefinitionForName: function (name) {
     for (model in this.modelDefinitions) {
@@ -206,9 +253,9 @@ FactoryGuy = {
    FactoryGuy.build('user') for User model
    FactoryGuy.build('bob') for User model with bob attributes
 
-   @param name fixture name
-   @param opts options that will override default fixture values
-   @returns {*}
+   @param {String} name fixture name
+   @param {Object} opts options that will override default fixture values
+   @returns {Object} json fixture
    */
   build: function (name, opts) {
     var definition = this.lookupDefinitionForName(name);
@@ -224,10 +271,10 @@ FactoryGuy = {
    FactoryGuy.buildList('user', 2) for 2 User models
    FactoryGuy.build('bob', 2) for 2 User model with bob attributes
 
-   @param name fixture name
-   @param number number of fixtures to create
-   @param opts options that will override default fixture values
-   @returns list of fixtures
+   @param {String} name fixture name
+   @param {Number} number number of fixtures to create
+   @param {Object} opts options that will override default fixture values
+   @returns {Array} list of fixtures
    */
   buildList: function (name, number, opts) {
     var definition = this.lookupDefinitionForName(name);
@@ -238,9 +285,11 @@ FactoryGuy = {
   },
 
   /**
+   TODO: This is kind of problematic right now .. needs work
+
    Clear model instances from FIXTURES array, and from store cache.
    Reset the id sequence for the models back to zero.
-   */
+  */
   resetModels: function (store) {
     var typeMaps = store.typeMaps;
     for (model in this.modelDefinitions) {
@@ -259,9 +308,6 @@ FactoryGuy = {
 //        store.unloadAll(typeMaps[model].type);
 //      }
 //    }
-
-//    for (model in this.modelDefinitions) {
-//      this.modelDefinitions[model].reset();
     }
   },
 
@@ -269,9 +315,9 @@ FactoryGuy = {
    Push fixture to model's FIXTURES array.
    Used when store's adapter is a DS.FixtureAdapter.
 
-   @param modelClass DS.Model type
-   @param fixture the fixture to add
-   @returns json fixture data
+   @param {DS.Model} modelClass
+   @param {Object} fixture the fixture to add
+   @returns {Object} json fixture data
    */
   pushFixture: function (modelClass, fixture) {
     if (!modelClass['FIXTURES']) {
@@ -279,22 +325,34 @@ FactoryGuy = {
     }
     modelClass['FIXTURES'].push(fixture);
     return fixture;
+  },
+
+  /**
+   Clears all model definitions
+  */
+  clear: function (opts) {
+    if (!opts) {
+      this.modelDefinitions = {};
+      return;
+    }
   }
 }
 DS.Store.reopen({
-
-  usingFixtureAdapter: function() {
+  /**
+   @returns {Boolean} true if store's adapter is DS.FixtureAdapter
+   */
+  usingFixtureAdapter: function () {
     var adapter = this.adapterFor('application');
-    return adapter instanceof DS.FixtureAdapter
+    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.
+   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.
 
-    @param name name of fixture
-    @param options fixture options
-    @returns json or record
+   @param {String} name name of fixture
+   @param {Object} options fixture options
+   @returns {Object|DS.Model} json or record depending on the adapter type
    */
   makeFixture: function (name, options) {
     var modelName = FactoryGuy.lookupModelForName(name);
@@ -307,7 +365,7 @@ DS.Store.reopen({
     } else {
       var self = this;
       var model;
-      Em.run( function() {
+      Em.run(function () {
         model = self.push(modelName, fixture);
         self.setBelongsToRESTAdapter(modelType, modelName, model);
       });
@@ -316,13 +374,13 @@ DS.Store.reopen({
   },
 
   /**
-    Make a list of Fixtures
+   Make a list of Fixtures
 
-    @param name name of fixture
-    @param number number of fixtures
-    @param options fixture options
-    @returns list of json fixtures or records depending on the adapter type
-  */
+   @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 (name, number, options) {
     var arr = [];
     for (var i = 0; i < number; i++) {
@@ -332,16 +390,16 @@ DS.Store.reopen({
   },
 
   /**
-    Set the belongsTo association for FixtureAdapter,
-      with models that have a hasMany association.
+   Set the belongsTo association for FixtureAdapter,
+   with models that have a hasMany association.
 
-    For example if a user hasMany projects, then set the user.id
-    on each project that the user hasMany of, so that the project
-    now has the belongsTo user association setup.
+   For example if a user hasMany projects, then set the user.id
+   on each project that the user hasMany of, so that the project
+   now has the belongsTo user association setup.
 
-    @param modelType model type like App.User
-    @param modelName model name like 'user'
-    @param parentFixture parent to assign as belongTo
+   @param {String} modelType model type like App.User
+   @param {String} modelName model name like 'user'
+   @param {Object} parentFixture parent to assign as belongTo
    */
   setBelongsToFixturesAdapter: function (modelType, modelName, parentFixture) {
     var store = this;
@@ -351,7 +409,7 @@ DS.Store.reopen({
       relationShips.hasMany.forEach(function (relationship) {
         var hasManyModel = store.modelFor(Em.String.singularize(relationship));
         if (parentFixture[relationship]) {
-          parentFixture[relationship].forEach(function(id) {
+          parentFixture[relationship].forEach(function (id) {
             var hasManyfixtures = adapter.fixturesForType(hasManyModel);
             var fixture = adapter.findFixtureById(hasManyfixtures, id);
             fixture[modelName] = parentFixture.id;
@@ -362,38 +420,59 @@ DS.Store.reopen({
   },
 
   /**
-    Set the belongsTo association for the REST type models
-      with a hasMany association
+   For the REST type models:
+
+   Set the belongsTo association with a hasMany association
 
-    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
+   Set this model in the parent hasMany array this model belongsTo
 
-    @param modelType model type like 'App.User'
-    @param modelName model name like 'user'
-    @param parent model to check for hasMany
+   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
+
+   @param {DS.Model} modelType model type like 'User'
+   @param {String} modelName model name like 'user'
+   @param {DS.Model} model
    */
-  setBelongsToRESTAdapter: function (modelType, modelName, parent) {
-    var relationShips = Ember.get(modelType, 'relationshipNames');
+  setBelongsToRESTAdapter: function (modelType, modelName, model) {
+    var self = this;
+    Ember.get(modelType, 'relationshipsByName').forEach(function (name, relationship) {
+      if (relationship.kind == 'hasMany') {
+        var children = model.get(name) || [];
+        children.forEach(function (child) {
+          child.set(modelName, model)
+        })
+      }
 
-    if (relationShips.hasMany) {
-      relationShips.hasMany.forEach(function (name) {
-        var children = parent.get(name);
-        if (children.get('length') > 0) {
-          children.forEach(function(child) {
-            child.set(modelName, parent)
-          })
+      if (relationship.kind == 'belongsTo') {
+        var belongsToRecord = model.get(name);
+        if (belongsToRecord) {
+          var hasManyName = self.findHasManyRelationshipName(belongsToRecord, model)
+          belongsToRecord.get(hasManyName).addObject(model);
         }
-      })
-    }
+      }
+    })
+  },
+
+  findHasManyRelationshipName: function (belongToModel, childModel) {
+    var relationshipName;
+    Ember.get(belongToModel.constructor, 'relationshipsByName').forEach(
+      function (name, relationship) {
+        if (relationship.kind == 'hasMany' &&
+          relationship.type == childModel.constructor) {
+          relationshipName = relationship.key;
+        }
+      }
+    )
+    return relationshipName;
   },
 
   /**
-    Adding a pushPayload for FixtureAdapter, but using the original with
-     other adapters that support pushPayload.
+   Adding a pushPayload for FixtureAdapter, but using the original with
+   other adapters that support pushPayload.
 
-    @param type
-    @param payload
+   @param {String} type
+   @param {Object} payload
    */
   pushPayload: function (type, payload) {
     if (this.usingFixtureAdapter()) {
@@ -409,38 +488,63 @@ DS.Store.reopen({
 DS.FixtureAdapter.reopen({
 
   /**
-    Overriding createRecord in FixtureAdapter to add the record
-     created to the hashMany records for all of the records that
-     this one belongsTo.
-
-    @method createRecord
-    @param {DS.Store} store
-    @param {subclass of DS.Model} type
-    @param {DS.Model} record
-    @return {Promise} promise
-  */
-  createRecord: function(store, type, record) {
+   Overriding createRecord to add the record created to the
+   hashMany records for all of the records that this record belongsTo.
+
+   For example:
+
+   If models are defined like so:
+
+   User = DS.Model.extend({
+       projects: DS.hasMany('project')
+     })
+
+   Project = DS.Model.extend({
+       user: DS.belongsTo('user')
+     })
+
+   and you create a project record with a user defined:
+    store.createRecord('project', {user: user})
+
+   this method will take the new project created and add it to the user's 'projects'
+   hasMany array.
+
+   And a full code example:
+
+   var userJson = store.makeFixture('user');
+
+   store.find('user', userJson.id).then(function(user) {
+       store.createRecord('project', {user: user}).save()
+         .then( function(project) {
+           // user.get('projects.length') == 1;
+       })
+     })
+
+   @method createRecord
+   @param {DS.Store} store
+   @param {subclass of DS.Model} type
+   @param {DS.Model} record
+   @return {Promise} promise
+   */
+  createRecord: function (store, type, record) {
     var promise = this._super(store, type, record);
 
-//    promise.then( function() {
-//      var hasManyName = Ember.String.pluralize(type.typeKey);
-//      var relationShips = Ember.get(type, 'relationshipNames');
-//      if (relationShips.belongsTo) {
-//        console.log('record',record+'', type.typeKey, hasManyName);
-//        relationShips.belongsTo.forEach(function (relationship) {
-//          console.log(relationship, record.get(relationship)+'')
-//          var belongsToRecord = record.get(relationship);
-//          console.log(relationshipForType)
-//          belongsToRecord.get(hasManyName).addObject(record);
-//        })
-//      }
-//    })
+    promise.then(function () {
+      var relationShips = Ember.get(type, 'relationshipNames');
+      if (relationShips.belongsTo) {
+        relationShips.belongsTo.forEach(function (relationship) {
+          var belongsToRecord = record.get(relationship);
+          if (belongsToRecord) {
+            var hasManyName = store.findHasManyRelationshipName(belongsToRecord, record);
+            belongsToRecord.get(hasManyName).addObject(record);
+          }
+        })
+      }
+    });
+
     return promise;
   }
-
 })
-
-
 FactoryGuyTestMixin = Em.Mixin.create({
 
   // Pass in the app root, which typically is App.
@@ -454,6 +558,13 @@ FactoryGuyTestMixin = Em.Mixin.create({
     this.getStore().adapterFor('application').simulateRemoteResponse = false;
   },
 
+  /**
+    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);
   },
@@ -474,6 +585,13 @@ FactoryGuyTestMixin = Em.Mixin.create({
     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 = {
@@ -492,21 +610,27 @@ FactoryGuyTestMixin = Em.Mixin.create({
   },
 
   /**
-   * Handling ajax POST for a model
-   *
-   * @param name of the fixture ( or model ) to create
-   * @param opts fixture options
+    Handling ajax POST ( create record ) for a model
+
+    @param {String} name of the fixture ( or model ) to create
+    @param {Object} opts fixture options
    */
   handleCreate: function (name, opts) {
     var model = FactoryGuy.lookupModelForName(name);
     this.stubEndpointForHttpRequest(
       "/" + Em.String.pluralize(model),
-      this.buildAjaxResponse(name, opts),
+      this.buildAjaxCreateResponse(name, opts),
       {type: 'POST'}
     )
   },
 
-  buildAjaxResponse: function (name, opts) {
+  /**
+    Build the json used for creating record
+
+    @param {String} name of the fixture ( or model ) to create
+    @param {Object} opts fixture options
+¬  */
+  buildAjaxCreateResponse: function (name, opts) {
     var fixture = FactoryGuy.build(name, opts);
     var model = FactoryGuy.lookupModelForName(name);
     var hash = {};
@@ -529,5 +653,4 @@ FactoryGuyTestMixin = Em.Mixin.create({
   teardown: function () {
     FactoryGuy.resetModels(this.getStore());
   }
-
 })