ember-data-factory-guy 0.9.2 → 0.9.3

data/tests/index.html

@@ -31,7 +31,7 @@
 <div id="qunit"></div> <!-- QUnit fills this with results, etc -->
 <script src='active_model_adapter_factory_test.js'></script>
 <script src='rest_adapter_factory_test.js'></script>
-<!--<script src='fixture_adapter_factory_test.js'></script>-->
+<script src='fixture_adapter_factory_test.js'></script>
 <script src='store_test.js'></script>
 <script src='factory_guy_test.js'></script>
 <script src='factory_guy_test_mixin_test.js'></script>

data/tests/store_test.js

@@ -29,4 +29,202 @@ test("with DS.ActiveModelAdapter", function() {
   equal(store.usingFixtureAdapter(), false );
 });
 
+var store, testHelper, testFixtureEquality;
+module('DS.Store#pushPayload', {
+  setup: function(){
+    testHelper = TestHelper.setup(DS.FixtureAdapter);
+    store = testHelper.getStore();
+  },
+  teardown: function() {
+    Em.run(function() {
+      testHelper.teardown();
+    });
+  }
+});
+
+testFixtureEquality = function(models, json, num){
+  equal(models.get('length'), num, 'Expected ' + num + ' ' + models.type.typeKey + ' in the data store but got ' + models.get('length'));
+  deepEqual(
+    models.map(function(model){ return model.get('id') }).sort(),
+    json.map(function(model){ return model.id; }).sort(),
+    'Expected to have all ' + Ember.String.pluralize(models.type.typeKey) + ' created'
+  );
+}
+
+asyncTest("no root", function() {
+  var userJson = {
+        id: '1',
+        name: 'monkey'
+      };
+
+  store.pushPayload('user', userJson);
+  store.find('user').then(function(users){
+    equal(users.get('length'), 1, 'Expected one user in the data store');
+
+    equal(users.get('firstObject.id'), userJson.id);
+    equal(users.get('firstObject.name'), userJson.name);
+    start();
+  });
+});
+
+asyncTest("no root replace data", function(){
+  var projectJson = {
+    id: '1',
+    title: 'monkey',
+    user: null
+  };
+  var u = FactoryGuy.make('user', { id: '1', name: 'banana' });
+  var p = FactoryGuy.make('project', { user: u.id});
+  store.find('user');
+
+  store.find('project').then(function(projects) {
+    var project = projects.get('firstObject'),
+        user = project.get('user');
+
+    equal(user.get('name'), u.name, 'Expected user name to be equal');
+    equal(user.get('id'), u.id, 'Expected user id to be equal');
+    equal(project.get('title'), p.title, 'Expected project title to equal');
+
+    store.pushPayload('project', projectJson);
+
+    ok(Ember.isEmpty(project.get('user')), 'Did not expect a user on project');
+    equal(project.get('title'), projectJson.title, 'Expected project title to equal');
+    start();
+  });
+});
+
+asyncTest("single root", function() {
+  var userJson = {
+    users: [{ id:'1', name:'monkey' }, { id:'2', name:'banana' }]
+  };
+
+  store.pushPayload(userJson);
+  store.find('user').then(function(users) {
+
+    testFixtureEquality(users, userJson['users'], 2);
+
+    users.forEach(function(user) {
+      var u = userJson['users'].findBy('id', user.get('id'));
+      equal(user.get('name'), u.name, 'Got unexpected name ' + user.get('name'));
+    });
+
+    start();
+  });
+});
+
+asyncTest("multiple roots", function() {
+  var json = {
+    companies: [{ id: '1', name: 'Google', projects: ['1', '2'] }],
+    projects: [
+      { id:'1', title: 'Docs', user: '1' },
+      { id:'2', title: 'Gmail' }
+    ],
+    users: [{ id: '1', name: 'monkey', projects: ['1'] }],
+    profiles: [
+      { id: '1', created_at: new Date(), description: 'banana' },
+      { id: '2', created_at: new Date(), description: 'monkey' }
+    ],
+    hats: [
+      { id: '2', type: 'Trilby' }
+    ],
+  };
 
+  store.pushPayload(json);
+  Ember.RSVP.Promise.all([
+    store.find('company'), store.find('project'),
+    store.find('user'), store.find('profile'), store.find('hat')
+  ]).then(function(data) {
+    var companies = data[0],
+        projects = data[1],
+        users = data[2],
+        profiles = data[3],
+        hats = data[4];
+
+    testFixtureEquality(companies, json['companies'], 1);
+    testFixtureEquality(projects, json['projects'], 2);
+    testFixtureEquality(users, json['users'], 1);
+    testFixtureEquality(profiles, json['profiles'], 2);
+    testFixtureEquality(hats, json['hats'], 1);
+
+    start();
+  });
+});
+
+asyncTest("multiple roots with type specified", function() {
+  var json = {
+    companies: [{ id: '1', name: 'Google', projects: ['1', '2'] }],
+    projects: [
+      { id:'1', title: 'Docs', user: '1' },
+      { id:'2', title: 'Gmail' }
+    ],
+    users: [{ id: '1', name: 'monkey', projects: ['1'] }],
+  }
+
+  store.pushPayload('company', json);
+
+  Ember.RSVP.Promise.all([
+    store.find('company'), store.find('project'), store.find('user')
+  ]).then(function(data) {
+    var companies = data[0],
+        projects = data[1],
+        users = data[2];
+
+    testFixtureEquality(companies, json['companies'], 1);
+    testFixtureEquality(projects, json['projects'], 2);
+    testFixtureEquality(users, json['users'], 1);
+
+    start();
+  });
+});
+
+test('testing for exceptions', function(){
+  throws(function() { store.pushPayload('user'); }, Ember.Error, 'Excepted to raise Ember.Error');
+  throws(function() { store.pushPayload('user', { name: 'foo' }); }, Ember.Error, 'Excepted to raise Ember.Error');
+  throws(function() { store.pushPayload({ someCrazyModelNotPresent: { id: 1, name: 'foo' } }); }, 'Excepted exception');
+  throws(function() { store.pushPayload('someCrazyModelNotPresent', { id: 1, name: 'foo' }); }, 'Excepted exception');
+
+  //no exceptions
+  var noExceptions = true
+  try {
+    store.pushPayload('user', {});
+    store.pushPayload({});
+  } catch(error) {
+    noExceptions = false;
+  }
+
+  ok(noExceptions, 'Should not raise exceptions');
+});
+
+asyncTest("replacing record", function() {
+  var json = {
+    companies: [{ id: '1', name: 'Google', projects: ['2', '3'] }],
+    projects: [
+      { id:'2', title: 'Docs', user: '1' },
+      { id:'3', title: 'Gmail' }
+    ],
+    users: [{ id: '1', name: 'monkey', projects: ['2'] }],
+    profiles: [
+      { id: '1', created_at: new Date(), description: 'banana' },
+      { id: '2', created_at: new Date(), description: 'monkey' }
+    ],
+    hats: [
+      { id: '2', type: 'Trilby' }
+    ],
+  };
+
+  var p = FactoryGuy.make('project');
+  FactoryGuy.make('user', { id: '1', name: 'banana', projects: [ p.id ] });
+  store.find('project');
+
+  store.find('user').then(function(user) {
+    equal(user.get('firstObject.projects.length'), 1, 'Expected one project');
+    equal(user.get('firstObject.projects.firstObject.id'), '1', 'Expected project with id 1');
+
+    store.pushPayload(json);
+
+    equal(user.get('firstObject.projects.length'), 1, 'Expected one project');
+    equal(user.get('firstObject.projects.firstObject.id'), '2', 'Expected project with id 2');
+
+    start();
+  });
+});

data/tests/support/factories/company_factory.js

@@ -3,6 +3,9 @@ FactoryGuy.define("company", {
     name: 'Silly corp'
   },
   traits: {
+    with_profile: {
+      profile: {}
+    },
     with_projects: {
       projects: FactoryGuy.hasMany('project', 2)
     }
@@ -15,4 +18,4 @@ FactoryGuy.define("small_company", {
     name: 'Small Corp',
     projects: FactoryGuy.hasMany('project', 2)
   }
-})
+})

data/tests/support/factories/property_factory.js

@@ -1,5 +1,10 @@
 FactoryGuy.define('property', {
   default: {
     name: 'Silly property'
+  },
+  traits: {
+    with_owners_with_projects: {
+      owners: FactoryGuy.hasMany('user', 2, 'with_projects')
+    }
   }
-})
+})

data/tests/support/factories/user_factory.js

@@ -14,6 +14,9 @@ FactoryGuy.define('user', {
     projects: FactoryGuy.hasMany('project', 2)
   },
   traits: {
+    with_company: {
+      company: {}
+    },
     with_projects: {
       projects: FactoryGuy.hasMany('project', 2)
     },

data/tests/support/models/person.js

@@ -1,4 +1,6 @@
 Person = DS.Model.extend({
   type: DS.attr('string'),
-  name: DS.attr('string')
+  name: DS.attr('string'),
+  company: DS.belongsTo('company', {embedded: 'always'}),
+  outfits: DS.hasMany('outfit', {embedded: 'always'})
 })

data/tests/support/models/user.js

@@ -3,7 +3,7 @@ User = DS.Model.extend({
   info:       DS.attr('object'),
   company:    DS.belongsTo('company', {async: true, inverse: 'users', polymorphic: true}),
   properties: DS.hasMany('property', {async: true, inverse: 'owners'}),
-  projects:   DS.hasMany('project'),
+  projects:   DS.hasMany('project', {embedded: 'always'}),
   hats:       DS.hasMany('hat', {polymorphic: true})
 });
 

data/tests/support/test_helper.js

@@ -1,9 +1,9 @@
 ObjectTransform = DS.Transform.extend({
   serialize: function(obj) {
-    return JSON.parse(obj);
+    return obj ? JSON.parse(obj) : {};
   },
   deserialize: function(obj) {
-    return JSON.stringify(obj);
+    return obj ? JSON.stringify(obj) : '{}';
   }
 });
 
@@ -95,4 +95,4 @@ TestHelper = Ember.Object.createWithMixins(FactoryGuy.testMixin,{
     return setupStore(options).store;
   };
 
-})();
+})();

data/tests/test_setup.js

@@ -63,7 +63,9 @@ Outfit = DS.Model.extend({
 
 Person = DS.Model.extend({
   type: DS.attr('string'),
-  name: DS.attr('string')
+  name: DS.attr('string'),
+  company: DS.belongsTo('company', {embedded: 'always'}),
+  outfits: DS.hasMany('outfit', {embedded: 'always'})
 })
 
 Profile = DS.Model.extend({
@@ -97,7 +99,7 @@ User = DS.Model.extend({
   info:       DS.attr('object'),
   company:    DS.belongsTo('company', {async: true, inverse: 'users', polymorphic: true}),
   properties: DS.hasMany('property', {async: true, inverse: 'owners'}),
-  projects:   DS.hasMany('project'),
+  projects:   DS.hasMany('project', {embedded: 'always'}),
   hats:       DS.hasMany('hat', {polymorphic: true})
 });
 
@@ -107,6 +109,9 @@ FactoryGuy.define("company", {
     name: 'Silly corp'
   },
   traits: {
+    with_profile: {
+      profile: {}
+    },
     with_projects: {
       projects: FactoryGuy.hasMany('project', 2)
     }
@@ -120,6 +125,7 @@ FactoryGuy.define("small_company", {
     projects: FactoryGuy.hasMany('project', 2)
   }
 })
+
 FactoryGuy.define("group", {
   sequences: {
     name: function(num) {return 'Group' + num}
@@ -242,8 +248,14 @@ FactoryGuy.define("project", {
 FactoryGuy.define('property', {
   default: {
     name: 'Silly property'
+  },
+  traits: {
+    with_owners_with_projects: {
+      owners: FactoryGuy.hasMany('user', 2, 'with_projects')
+    }
   }
 })
+
 FactoryGuy.define('user', {
   sequences: {
     name: function(num) {return 'User' + num}
@@ -260,6 +272,9 @@ FactoryGuy.define('user', {
     projects: FactoryGuy.hasMany('project', 2)
   },
   traits: {
+    with_company: {
+      company: {}
+    },
     with_projects: {
       projects: FactoryGuy.hasMany('project', 2)
     },

data/vendor/assets/javascripts/ember_data_factory_guy.js

@@ -462,7 +462,9 @@ var FactoryGuy = {
 
     if (store.usingFixtureAdapter()) {
       store.setAssociationsForFixtureAdapter(modelType, modelName, fixture);
-      return this.pushFixture(modelType, fixture);
+      fixture = FactoryGuy.pushFixture(modelType, fixture);
+      store.loadModelForFixtureAdapter(modelType, fixture);
+      return fixture;
     } else {
       return store.makeModel(modelType, fixture);
     }
@@ -643,9 +645,11 @@ var FactoryGuy = {
     setAssociationsForFixtureAdapter: function (modelType, modelName, fixture) {
       var self = this;
       var adapter = this.adapterFor('application');
+
       Ember.get(modelType, 'relationshipsByName').forEach(function (relationship, name) {
+        var hasManyRelation, belongsToRecord;
         if (relationship.kind == 'hasMany') {
-          var hasManyRelation = fixture[relationship.key];
+          hasManyRelation = fixture[relationship.key];
           if (hasManyRelation) {
             $.each(fixture[relationship.key], function (index, object) {
               // used to require that the relationship was set by id,
@@ -653,17 +657,19 @@ var FactoryGuy = {
               // normalize that back to the id
               var id = object;
               if (Ember.typeOf(object) == 'object') {
+                FactoryGuy.pushFixture(relationship.type, object);
                 id = object.id;
                 hasManyRelation[index] = id;
               }
               var hasManyfixtures = adapter.fixturesForType(relationship.type);
-              var fixture = adapter.findFixtureById(hasManyfixtures, id);
-              fixture[modelName] = fixture.id;
+              var hasManyFixture = adapter.findFixtureById(hasManyfixtures, id);
+              hasManyFixture[modelName] = fixture.id;
+              self.loadModelForFixtureAdapter(relationship.type, hasManyFixture);
             });
           }
         }
         if (relationship.kind == 'belongsTo') {
-          var belongsToRecord = fixture[relationship.key];
+          belongsToRecord = fixture[relationship.key];
           if (belongsToRecord) {
             if (typeof belongsToRecord == 'object') {
               FactoryGuy.pushFixture(relationship.type, belongsToRecord);
@@ -676,10 +682,29 @@ var FactoryGuy = {
               belongsTofixture[hasManyName] = [];
             }
             belongsTofixture[hasManyName].push(fixture.id);
+            self.loadModelForFixtureAdapter(relationship.type, belongsTofixture);
           }
         }
       });
     },
+
+    loadModelForFixtureAdapter: function(modelType, fixture) {
+      var storeModel = this.getById(modelType, fixture.id),
+          that = this;
+      if (!Ember.isPresent(storeModel) || storeModel.get('isEmpty')) {
+        Ember.run(function () {
+          var dup = Ember.copy(fixture, true);
+          that.push(modelType, fixture);
+          //replace relationships back to ids instead of built ember objects
+          Ember.get(modelType, 'relationshipsByName').forEach(function (relationship, name) {
+            if(fixture[relationship.key]) {
+              fixture[relationship.key] = dup[relationship.key];
+            }
+          });
+        });
+      }
+    },
+
     /**
      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.
@@ -788,9 +813,32 @@ var FactoryGuy = {
      @param {Object} payload
      */
     pushPayload: function (type, payload) {
+      var typeName, model;
+
       if (this.usingFixtureAdapter()) {
-        var model = this.modelFor(type);
-        FactoryGuy.pushFixture(model, payload);
+        if (Ember.typeOf(type) === 'string' && Ember.isPresent(payload) && Ember.isPresent(payload.id)){
+          //pushPayload('user', {id:..})
+          model = this.modelFor(type);
+          FactoryGuy.pushFixture(model, payload);
+          this.push(model, Ember.copy(payload, true));
+        } else if(Ember.typeOf(type) === 'object' || Ember.typeOf(payload) === 'object') {
+          //pushPayload({users: {id:..}}) OR pushPayload('user', {users: {id:..}})
+          if(Ember.isBlank(payload)){
+            payload = type;
+          }
+
+          for (var prop in payload) {
+            typeName = Ember.String.camelize(Ember.String.singularize(prop));
+            model = this.modelFor(typeName);
+
+            this.pushMany(model, Ember.makeArray( Ember.copy(payload[prop], true) ));
+            Ember.ArrayPolyfills.forEach.call(Ember.makeArray(payload[prop]), function(hash) {
+              FactoryGuy.pushFixture(model, hash);
+            }, this);
+          }
+        } else {
+          throw new Ember.Error('Assertion Failed: You cannot use `store#pushPayload` with this method signature pushPayload(' + type + ',' + payload + ')');
+        }
       } else {
         this._super(type, payload);
       }
@@ -877,6 +925,17 @@ var FactoryGuyTestMixin = Em.Mixin.create({
      Handling ajax GET for finding all records for a type of model.
      You can mock failed find by passing in success argument as false.
 
+   ```js
+     // Pass in the parameters you would normally pass into FactoryGuy.makeList,
+     // like fixture name, number of fixtures to make, and optional traits,
+     // or fixture options
+     testHelper.handleFindMany('user', 2, 'with_hats');
+
+     store.find('user').then(function(users){
+
+     });
+   ```
+
      @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)
@@ -884,39 +943,54 @@ var FactoryGuyTestMixin = Em.Mixin.create({
    */
   handleFindMany: function () {
     // make the records and load them in the store
-    FactoryGuy.makeList.apply(FactoryGuy, arguments);
+    var records = FactoryGuy.makeList.apply(FactoryGuy, arguments);
     var name = arguments[0];
     var modelName = FactoryGuy.lookupModelForFixtureName(name);
     var responseJson = {};
-    responseJson[modelName] = [];
+    var json = records.map(function(record) {return record.toJSON({includeId: true})});
+    responseJson[modelName.pluralize()] = json;
     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);
   },
   /**
    Handling ajax GET for finding all records for a type of model with query parameters.
 
+          First variation = pass in model instances
    ```js
-     // First build json for the instances you want 'returned' in your query.
-     var usersJson = FactoryGuy.buildList('user', 2);
 
-     // Pass in the parameters you will search on ( in this case 'name' and 'age' ) as an array,
-     // in the second argument.
-     testHelper.handleFindQuery('user', ['name', 'age'], usersJson);
+     // Create model instances
+     var users = FactoryGuy.makeList('user', 2, 'with_hats');
+
+     // Pass in the array of model instances as last argument
+     testHelper.handleFindQuery('user', ['name', 'age'], users);
 
      store.findQuery('user', {name:'Bob', age: 10}}).then(function(userInstances){
-        /// userInstances were created from the usersJson that you passed in
+        /// userInstances will be the same of the users that were passed in
      })
    ```
 
-   The model instances will be created from the json you have passed in.
+        Third variation - pass in nothing for last argument
+   ```js
+   // This simulates a query that returns no results
+   testHelper.handleFindQuery('user', ['age']);
+
+   store.findQuery('user', {age: 10000}}).then(function(userInstances){
+        /// userInstances will be empty
+     })
+   ```
 
    @param {String} modelName  name of the mode like 'user' for User model type
    @param {String} searchParams  the parameters that will be queried
-   @param {Object} json   fixture json used to build the resulting modelType instances
+   @param {Array}  array of DS.Model records to be 'returned' by query
    */
-  handleFindQuery: function (modelName, searchParams, json) {
+  handleFindQuery: function (modelName, searchParams, records) {
+    Ember.assert('The second argument of searchParams must be an array',Em.typeOf(searchParams) == 'array')
+    if (records) {
+      Ember.assert('The third argument ( records ) must be an array - found type:' + Em.typeOf(records), Em.typeOf(records) == 'array')
+    } else {
+      records = []
+    }
+    var json = records.map(function(record) {return record.toJSON({includeId: true})})
     var responseJson = {};
     responseJson[modelName.pluralize()] = json;
     var url = this.buildURL(modelName);
@@ -1163,10 +1237,12 @@ if (FactoryGuy !== undefined) {
 				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) ) {
+//      console.log('request.data', requestSettings.data )
+//      console.log('handler.data', handler.data )
+//      console.log('data equal', isMockDataEqual(handler.data, requestSettings.data) )
+			if  ( ! requestSettings.data || !isMockDataEqual(handler.data, requestSettings.data) ) {
 				// They're not identical, do not mock this request
 				return null;
 			}
@@ -1177,7 +1253,6 @@ if (FactoryGuy !== undefined) {
 			// The request type doesn't match (GET vs. POST)
 			return null;
 		}
-
 		return handler;
 	}