ember-data-factory-guy 0.1.1 → 0.1.2

data/src/{factory_guy_helper_mixin.js → factory_guy_test_mixin.js}

@@ -1,5 +1,6 @@
-FactoryGuyHelperMixin = Em.Mixin.create({
+FactoryGuyTestMixin = Em.Mixin.create({
 
+  // Pass in the app root, which typically is App.
   setup: function(app) {
     this.set('container', app.__container__);
     return this;

data/src/model_definition.js

@@ -0,0 +1,98 @@
+ModelDefinition = function (model, config) {
+  var sequences = {};
+  var defaultAttributes = {};
+  var namedModels = {};
+  var modelId = 1;
+  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
+   */
+  this.matchesName = function (name) {
+    return model == name || namedModels[name];
+  }
+
+  this.merge = function (config) {
+  }
+
+  /**
+    @param sequenceName
+    @returns output of sequence function
+   */
+  this.generate = function (sequenceName) {
+    if (!sequences[sequenceName]) {
+      throw new MissingSequenceError("Can not find that sequence named ["+sequenceName+"] in '"+ model+"' definition")
+    }
+    return sequences[sequenceName].next();
+  }
+
+  this.build = function (name, opts) {
+    var modelAttributes = namedModels[name] || {};
+    var fixture = $.extend({}, defaultAttributes, modelAttributes, opts);
+    for (attr in fixture) {
+      if (typeof fixture[attr] == 'function') {
+        fixture[attr] = fixture[attr].call(this)
+      }
+    }
+    if (!fixture.id) {
+      fixture.id = modelId++;
+    }
+    return fixture;
+  }
+
+  /**
+    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
+   */
+  this.buildList = function (name, number, opts) {
+    var arr = [];
+    for (var i = 0; i < number; i++) {
+      arr.push(this.build(name, opts))
+    }
+    return arr;
+  }
+
+  this.reset = function () {
+    modelId = 1;
+  }
+
+  var parseDefault = function (object) {
+    if (!object) {
+      return
+    }
+    defaultAttributes = object;
+  }
+
+  var parseSequences = function (object) {
+    if (!object) {
+      return
+    }
+    for (sequenceName in object) {
+      var sequenceFn = object[sequenceName];
+      if (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;
+
+    parseDefault(config.default);
+    delete config.default;
+
+    namedModels = config;
+  }
+
+  // initialize
+  parseConfig(config);
+}

data/src/sequence.js

@@ -0,0 +1,16 @@
+Sequence = function (fn) {
+  var index = 1;
+  var fn = fn;
+
+  this.next = function () {
+    return fn.call(this, index++);
+  }
+
+  this.reset = function () {
+    index = 1;
+  }
+}
+
+function MissingSequenceError(message) {
+  this.toString = function() { return message }
+}

data/src/store.js

@@ -9,9 +9,9 @@ DS.Store.reopen({
     Make new fixture and save to store. If the store is using FixtureAdapter,
     will push to FIXTURE array, otherwise will use push method on adapter.
 
-    @param name
-    @param options
-    @returns {*}
+    @param name name of fixture
+    @param options fixture options
+    @returns json or record
    */
   makeFixture: function (name, options) {
     var modelName = FactoryGuy.lookupModelForName(name);
@@ -19,31 +19,48 @@ DS.Store.reopen({
     var modelType = this.modelFor(modelName);
 
     if (this.usingFixtureAdapter()) {
-      this.setBelongsToFixturesAssociation(modelType, modelName, fixture);
+      this.setBelongsToFixturesAdapter(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);
+        self.setBelongsToRESTAdapter(modelType, modelName, model);
       });
       return model;
     }
   },
 
   /**
-    Trying to set the belongsTo association for FixtureAdapter,
+    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
+  */
+  makeList: function (name, number, options) {
+    var arr = [];
+    for (var i = 0; i < number; i++) {
+      arr.push(this.makeFixture(name, options))
+    }
+    return arr;
+  },
+
+  /**
+    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.
+    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 name
-    @param model
+    @param modelType model type like App.User
+    @param modelName model name like 'user'
+    @param parentFixture parent to assign as belongTo
    */
-  setBelongsToFixturesAssociation: function (modelType, modelName, parentFixture) {
+  setBelongsToFixturesAdapter: function (modelType, modelName, parentFixture) {
     var store = this;
     var adapter = this.adapterFor('application');
     var relationShips = Ember.get(modelType, 'relationshipNames');
@@ -62,18 +79,18 @@ DS.Store.reopen({
   },
 
   /**
-   * 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
+    Set the belongsTo association for the REST type models
+      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
+
+    @param modelType model type like 'App.User'
+    @param modelName model name like 'user'
+    @param parent model to check for hasMany
    */
-  setBelongsToRestAssociation: function (modelType, modelName, parent) {
+  setBelongsToRESTAdapter: function (modelType, modelName, parent) {
     var relationShips = Ember.get(modelType, 'relationshipNames');
 
     if (relationShips.hasMany) {

data/tests/active_model_adapter_factory_test.js

@@ -1,5 +1,4 @@
-var testHelper;
-var store;
+var testHelper, store;
 
 module('FactoryGuy with ActiveModelAdapter', {
   setup: function() {
@@ -12,16 +11,25 @@ module('FactoryGuy with ActiveModelAdapter', {
 });
 
 
-test("#resetModels clears the store of models, and resets the model ids", function() {
+test("#resetModels clears the store of models, and resets the model definition", function() {
   var project = store.makeFixture('project');
   var user = store.makeFixture('user', {projects: [project.id]});
 
+  for (model in FactoryGuy.modelDefinitions) {
+    var definition = FactoryGuy.modelDefinitions[model];
+    sinon.spy(definition, 'reset');
+  }
+
   FactoryGuy.resetModels(store);
 
   equal(store.all('user').get('content.length'),0)
   equal(store.all('project').get('content.length'),0)
 
-  deepEqual(FactoryGuy.modelIds, {});
+  for (model in FactoryGuy.modelDefinitions) {
+    var definition = FactoryGuy.modelDefinitions[model];
+    ok(definition.reset.calledOnce);
+    definition.reset.restore();
+  }
 });
 
 
@@ -36,7 +44,13 @@ module('DS.Store#makeFixture with ActiveModelAdapter', {
 });
 
 
-asyncTest("creates records in the store", function() {
+test("creates DS.Model instance", function() {
+  var user = store.makeFixture('user');
+  equal(user instanceof DS.Model, true);
+});
+
+
+asyncTest("creates record in the store", function() {
   var user = store.makeFixture('user');
 
   store.find('user', user.id).then ( function(store_user) {
@@ -61,3 +75,29 @@ test("when hasMany associations assigned, belongTo parent is assigned", function
   deepEqual(p1.get('user').toJSON(), user.toJSON());
 })
 
+
+module('DS.Store#makeList with ActiveModelAdapter', {
+  setup: function() {
+    testHelper = TestHelper.setup(DS.ActiveModelAdapter);
+    store = testHelper.getStore();
+  },
+  teardown: function() {
+    Em.run(function() { testHelper.teardown(); });
+  }
+});
+
+
+test("creates list of DS.Model instances", function() {
+  var users = store.makeList('user', 2);
+  equal(users.length, 2);
+  equal(users[0] instanceof DS.Model, true);
+});
+
+
+test("creates records in the store", function() {
+  var users = store.makeList('user', 2);
+
+  var storeUsers = store.all('user').get('content');
+  deepEqual(storeUsers[0].toJSON(), users[0].toJSON());
+  deepEqual(storeUsers[1].toJSON(), users[1].toJSON());
+});

data/tests/factory_guy_test.js

@@ -0,0 +1,93 @@
+Person = DS.Model.extend({
+  type: DS.attr('string'),
+  name: DS.attr('string')
+})
+
+var testHelper, store;
+
+module('FactoryGuy', {
+  setup: function() {
+    testHelper = TestHelper.setup(DS.FixtureAdapter);
+    store = testHelper.getStore();
+  },
+  teardown: function() {
+    Em.run(function() { testHelper.teardown(); });
+  }
+});
+
+
+test("Using sequences in definitions", function() {
+  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')
+    },
+    bro: {
+      type: FactoryGuy.generate('broType')
+    }
+  });
+
+  var json = FactoryGuy.build('person');
+  deepEqual(json, {id: 1, name: 'person #1', type: 'normal'}, 'in default attributes');
+
+  var json = FactoryGuy.build('dude');
+  deepEqual(json, {id: 2, name: 'person #2', type: 'person type #1'}, 'in named attributes');
+
+  throws( function() {
+    FactoryGuy.build('bro')
+    }, MissingSequenceError,
+    "throws error when sequence name not found"
+  )
+});
+
+
+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("#buildList creates list of fixtures", function() {
+  var userList = FactoryGuy.buildList('user', 2);
+  deepEqual(userList[0], {id: 1, name: 'User1'});
+  deepEqual(userList[1], {id: 2, name: 'User1'});
+});

data/tests/fixture_adapter_factory_test.js

@@ -1,5 +1,4 @@
-window.testHelper;
-var store;
+var testHelper, store;
 
 module('FactoryGuy with DS.FixtureAdapter', {
   setup: function() {
@@ -12,40 +11,6 @@ module('FactoryGuy with DS.FixtureAdapter', {
 });
 
 
-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);
@@ -68,19 +33,28 @@ asyncTest("can change fixture attributes after creation", function() {
 });
 
 
-test("#resetModels clears the store of models, clears the FIXTURES arrays for each model and resets the model ids", function() {
+test("#resetModels clears the store of models, clears the FIXTURES arrays for each model and resets the model definition", function() {
   var project = store.makeFixture('project');
   var user = store.makeFixture('user', {projects: [project.id]});
 
+  for (model in FactoryGuy.modelDefinitions) {
+    var definition = FactoryGuy.modelDefinitions[model];
+    sinon.spy(definition, 'reset');
+  }
+
   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)
+  equal(store.all('user').get('content.length'), 0)
+  equal(store.all('project').get('content.length'), 0)
 
-  deepEqual(FactoryGuy.modelIds, {});
+  for (model in FactoryGuy.modelDefinitions) {
+    var definition = FactoryGuy.modelDefinitions[model];
+    ok(definition.reset.calledOnce);
+    definition.reset.restore();
+  }
 });