ember-data-factory-guy 0.1

data/src/store.js

@@ -0,0 +1,142 @@
+DS.Store.reopen({
+
+  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.
+
+    @param name
+    @param options
+    @returns {*}
+   */
+  makeFixture: function (name, options) {
+    var modelName = FactoryGuy.lookupModelForName(name);
+    var fixture = FactoryGuy.build(name, options);
+    var modelType = this.modelFor(modelName);
+
+    if (this.usingFixtureAdapter()) {
+      this.setBelongsToFixturesAssociation(modelType, modelName, fixture);
+      return FactoryGuy.pushFixture(modelType, fixture);
+    } else {
+      var self = this;
+      var model;
+      Em.run( function() {
+        model = self.push(modelName, fixture);
+        self.setBelongsToRestAssociation(modelType, modelName, model);
+      });
+      return model;
+    }
+  },
+
+  /**
+    Trying to set the belongsTo association for FixtureAdapter,
+      with models that have a hasMany association.
+
+    For example if a client hasMany projects, then set the client.id
+    on each project that the client hasMany of, so that the project
+    now has the belongsTo client association setup.
+
+    @param name
+    @param model
+   */
+  setBelongsToFixturesAssociation: function (modelType, modelName, parentFixture) {
+    var store = this;
+    var adapter = this.adapterFor('application');
+    var relationShips = Ember.get(modelType, 'relationshipNames');
+    if (relationShips.hasMany) {
+      relationShips.hasMany.forEach(function (relationship) {
+        var hasManyModel = store.modelFor(Em.String.singularize(relationship));
+        if (parentFixture[relationship]) {
+          parentFixture[relationship].forEach(function(id) {
+            var hasManyfixtures = adapter.fixturesForType(hasManyModel);
+            var fixture = adapter.findFixtureById(hasManyfixtures, id);
+            fixture[modelName] = parentFixture.id;
+          })
+        }
+      })
+    }
+  },
+
+  /**
+   * Trying to set the belongsTo association for the rest type models
+   * with a hasMany association
+   *
+   * For example if a client hasMany projects, then set the client
+   * on each project that the client hasMany of, so that the project
+   * now has the belongsTo client association setup
+   *
+   * @param modelType
+   * @param modelName
+   * @param parent model to check for hasMany
+   */
+  setBelongsToRestAssociation: function (modelType, modelName, parent) {
+    var relationShips = Ember.get(modelType, 'relationshipNames');
+
+    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)
+          })
+        }
+      })
+    }
+  },
+
+  /**
+    Adding a pushPayload for FixtureAdapter, but using the original with
+     other adapters that support pushPayload.
+
+    @param type
+    @param payload
+   */
+  pushPayload: function (type, payload) {
+    if (this.usingFixtureAdapter()) {
+      var model = this.modelFor(modelName);
+      FactoryGuy.pushFixture(model, payload);
+    } else {
+      this._super(type, payload);
+    }
+  }
+});
+
+
+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) {
+    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);
+//        })
+      }
+    })
+    return promise;
+  }
+
+})
+

data/tests/active_model_adapter_factory_test.js

@@ -0,0 +1,63 @@
+var testHelper;
+var store;
+
+module('FactoryGuy with ActiveModelAdapter', {
+  setup: function() {
+    testHelper = TestHelper.setup(DS.ActiveModelAdapter);
+    store = testHelper.getStore();
+  },
+  teardown: function() {
+    Em.run(function() { testHelper.teardown(); });
+  }
+});
+
+
+test("#resetModels clears the store of models, and resets the model ids", function() {
+  var project = store.makeFixture('project');
+  var user = store.makeFixture('user', {projects: [project.id]});
+
+  FactoryGuy.resetModels(store);
+
+  equal(store.all('user').get('content.length'),0)
+  equal(store.all('project').get('content.length'),0)
+
+  deepEqual(FactoryGuy.modelIds, {});
+});
+
+
+module('DS.Store#makeFixture with ActiveModelAdapter', {
+  setup: function() {
+    testHelper = TestHelper.setup(DS.ActiveModelAdapter);
+    store = testHelper.getStore();
+  },
+  teardown: function() {
+    Em.run(function() { testHelper.teardown(); });
+  }
+});
+
+
+asyncTest("creates records in the store", function() {
+  var user = store.makeFixture('user');
+
+  store.find('user', user.id).then ( function(store_user) {
+    deepEqual(store_user.toJSON(), user.toJSON());
+    start();
+  });
+});
+
+test("supports hasMany associations", function() {
+  var p1 = store.makeFixture('project');
+  var p2 = store.makeFixture('project');
+  var user = store.makeFixture('user', {projects: [p1.id, p2.id]})
+
+  equal(user.get('projects.length'), 2);
+})
+
+
+test("when hasMany associations assigned, belongTo parent is assigned", function() {
+  var p1 = store.makeFixture('project');
+  var user = store.makeFixture('user', {projects: [p1.id]})
+
+  deepEqual(p1.get('user').toJSON(), user.toJSON());
+})
+

data/tests/fixture_adapter_factory_test.js

@@ -0,0 +1,134 @@
+window.testHelper;
+var store;
+
+module('FactoryGuy with DS.FixtureAdapter', {
+  setup: function() {
+    testHelper = TestHelper.setup(DS.FixtureAdapter);
+    store = testHelper.getStore();
+  },
+  teardown: function() {
+    Em.run(function() { testHelper.teardown(); });
+  }
+});
+
+
+test("#build creates default json for model", function() {
+  var json = FactoryGuy.build('user');
+  deepEqual(json, {id: 1, name: 'User1'});
+});
+
+
+test("#build can override default model attributes", function() {
+  var json = FactoryGuy.build('user',{name: 'bob'});
+  deepEqual(json, {id: 1, name: 'bob'});
+});
+
+
+test("#build can have named model definition with custom attributes", function() {
+  var json = FactoryGuy.build('admin')
+  deepEqual(json, {id: 1, name: 'Admin'});
+});
+
+
+test("#build can override named model attributes", function() {
+  var json = FactoryGuy.build('admin', {name: 'AdminGuy'})
+  deepEqual(json, {id: 1, name: 'AdminGuy'});
+});
+
+
+test("#build similar model type ids are created sequentially", function() {
+  var user1 = FactoryGuy.build('user');
+  var user2 = FactoryGuy.build('user');
+  var project = FactoryGuy.build('project');
+  equal(user1.id, 1);
+  equal(user2.id, 2);
+  equal(project.id, 1);
+});
+
+
+test("#pushFixture adds fixture to Fixture array on model", function() {
+  var fixtureJson = FactoryGuy.build('user');
+  FactoryGuy.pushFixture(User, fixtureJson);
+  equal(User.FIXTURES.length, 1);
+
+  var fixtureJson2 = FactoryGuy.build('user');
+  FactoryGuy.pushFixture(User, fixtureJson2);
+  equal(User.FIXTURES.length, 2);
+});
+
+
+asyncTest("can change fixture attributes after creation", function() {
+  var user = store.makeFixture('user');
+  user.name = "new name";
+
+  store.find('user', 1).then( function(user) {
+    equal(user.get('name'), "new name", "changes local attributes");
+    start();
+  });
+});
+
+
+test("#resetModels clears the store of models, clears the FIXTURES arrays for each model and resets the model ids", function() {
+  var project = store.makeFixture('project');
+  var user = store.makeFixture('user', {projects: [project.id]});
+
+  FactoryGuy.resetModels(store);
+
+  equal(User.FIXTURES.length, 0);
+  equal(Project.FIXTURES.length, 0);
+
+  equal(store.all('user').get('content.length'),0)
+  equal(store.all('project').get('content.length'),0)
+
+  deepEqual(FactoryGuy.modelIds, {});
+});
+
+
+module('DS.Store with DS.FixtureAdapter', {
+  setup: function() {
+    testHelper = TestHelper.setup(DS.FixtureAdapter);
+    store = testHelper.getStore();
+  },
+  teardown: function() {
+    Em.run(function() { testHelper.teardown(); });
+  }
+});
+
+
+test("#makeFixture builds and pushes fixture into the store", function() {
+  var json = store.makeFixture('user');
+  equal(User.FIXTURES.length, 1);
+  equal(User.FIXTURES[0], json);
+});
+
+
+asyncTest("#makeFixture sets hasMany associations on fixtures", function() {
+  var p1 = store.makeFixture('project');
+  // second project not added on purpose to make sure only one is
+  // assigned in hasMany
+  store.makeFixture('project');
+  var user = store.makeFixture('user', {projects: [p1.id]})
+
+  store.find('user', 1).then ( function(user) {
+    user.get('projects').then( function(projects) {
+      equal(projects.get('length'), 1, "adds hasMany records");
+      equal(projects.get('firstObject.user.id'), 1, "sets belongsTo record");
+      start();
+    })
+  })
+})
+
+asyncTest("#createRecord adds belongsTo associations to hasMany array", function() {
+  var user = store.makeFixture('user');
+
+  store.find('user', user.id).then(function(user){
+
+    var projectJson = {title:'project', user: user};
+
+    store.createRecord('project', projectJson).save()
+      .then( function() {
+        equal(user.get('projects.length'), 1);
+        start();
+      });
+  })
+})

data/tests/index.html

@@ -0,0 +1,38 @@
+<!doctype html>
+<html>
+<head>
+    <meta charset='UTF-8' />
+    <meta http-equiv='content-type' content='text/html; charset=utf-8' />
+
+    <title>jQuery.simpleFAQ QUnit Test Runner</title>
+
+    <link rel="stylesheet" type="text/css" href="../bower_components/qunit/qunit/qunit.css">
+    <!-- add any external libraries your code needs -->
+    <script src='../bower_components/jquery/jquery.js'></script>
+    <script src='../bower_components/handlebars/handlebars.js'></script>
+    <script src='../bower_components/ember/ember.js'></script>
+    <script src='../bower_components/ember-data/ember-data.js'></script>
+
+    <script src='../dist/ember-data-factory-guy.js'></script>
+    <script src='../src/has_many.js'></script>
+
+    <!-- your tests, any and all to run with the given fixtures below -->
+    <script src='../tests/test_setup.js'></script>
+    <script src='../tests/support/test_helper.js'></script>
+
+    <script src="../bower_components/qunit/qunit/qunit.js"></script>
+
+</head>
+<body>
+<div id="qunit"></div> <!-- QUnit fills this with results, etc -->
+<script src='active_model_adapter_factory_test.js'></script>
+<script src='fixture_adapter_factory_test.js'></script>
+<script src='rest_adapter_factory_test.js'></script>
+<script src='store_test.js'></script>
+<div id='qunit-fixture'>
+
+    <!-- any HTML you want to be present in each test (will be reset for each test) -->
+
+</div>
+</body>
+</html>

data/tests/rest_adapter_factory_test.js

@@ -0,0 +1,61 @@
+var testHelper;
+var store;
+
+module('FactoryGuy with DS.RESTAdapter', {
+  setup: function() {
+    testHelper = TestHelper.setup(DS.RESTAdapter);
+    store = testHelper.getStore();
+  },
+  teardown: function() {
+    Em.run(function() { testHelper.teardown(); });
+  }
+});
+
+
+test("#resetModels clears the store of models, and resets the model ids", function() {
+  var project = store.makeFixture('project');
+  var user = store.makeFixture('user', {projects: [project.id]});
+
+  FactoryGuy.resetModels(store);
+
+  equal(store.all('user').get('content.length'),0)
+  equal(store.all('project').get('content.length'),0)
+
+  deepEqual(FactoryGuy.modelIds, {});
+});
+
+
+module('DS.Store#makeFixture with RestAdapter', {
+  setup: function() {
+    testHelper = TestHelper.setup(DS.RESTAdapter);
+    store = testHelper.getStore();
+  },
+  teardown: function() {
+    Em.run(function() { testHelper.teardown(); });
+  }
+});
+
+asyncTest("creates records in the store", function() {
+  var user = store.makeFixture('user');
+
+  store.find('user', user.id).then ( function(store_user) {
+    deepEqual(store_user.toJSON(), user.toJSON());
+    start()
+  });
+});
+
+test("supports hasMany associations", function() {
+  var p1 = store.makeFixture('project');
+  var p2 = store.makeFixture('project');
+  var user = store.makeFixture('user', {projects: [p1.id, p2.id]})
+
+  equal(user.get('projects.length'), 2);
+});
+
+
+test("when hasMany associations assigned, belongTo parent is assigned", function() {
+  var p1 = store.makeFixture('project');
+  var user = store.makeFixture('user', {projects: [p1.id]})
+
+  deepEqual(p1.get('user').toJSON(), user.toJSON());
+});

data/tests/store_test.js

@@ -0,0 +1,35 @@
+var container;
+
+module('DS.Store#usingFixtureAdapter', {
+  setup: function() {
+    container = new Ember.Container();
+  },
+  teardown: function() {}
+});
+
+var getStore = function(adapter) {
+  container.register("store:main", DS.Store.extend({adapter: adapter}));
+  return container.lookup("store:main");
+}
+
+test("with DS.FixtureAdapter", function() {
+  var adapter = DS.FixtureAdapter
+  equal(getStore(adapter).usingFixtureAdapter(), true );
+});
+
+test("when extending DS.FixtureAdapter", function() {
+  var adapter = DS.FixtureAdapter.extend({});
+  equal(getStore(adapter).usingFixtureAdapter(), true );
+});
+
+test("with DS.RESTAdapter", function() {
+  var adapter = DS.RESTAdapter
+  equal(getStore(adapter).usingFixtureAdapter(), false );
+});
+
+test("with DS.ActiveModelAdapter", function() {
+  var adapter = DS.ActiveModelAdapter
+  equal(getStore(adapter).usingFixtureAdapter(), false );
+});
+
+