ember-data-factory-guy 0.1.1 → 0.1.2

data/.gitignore

@@ -1,2 +1,3 @@
 bower_components/
-node_modules/
+node_modules/
+*.gem

data/.travis.yml

@@ -0,0 +1,7 @@
+language: node_js
+node_js:
+  - 0.10
+before_install:
+  - npm install -g grunt-cli
+  - npm install -g bower
+  - bower install

data/Gruntfile.js

@@ -6,17 +6,32 @@ module.exports = function(grunt) {
 
     concat: {
       dist: {
-        src: ['src/factory_guy.js', 'src/store.js', 'src/factory_guy_helper_mixin.js'],
+        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"
       },
+      extra: {
+        src: ['src/has_many.js'],
+        dest: "dist/factory_guy_has_many.js"
+      },
       gem: {
         files: {
-          "vendor/assets/javascripts/ember_data_factory_guy.js": ['src/factory_guy.js', 'src/store.js', 'src/factory_guy_helper_mixin.js'],
+          "vendor/assets/javascripts/ember_data_factory_guy.js": [
+            'src/factory_guy.js',
+            'src/store.js',
+            'src/factory_guy_test_mixin.js'],
           "vendor/assets/javascripts/factory_guy_has_many.js": ['src/has_many.js']
         }
       },
       test: {
-        src: ['tests/support/factories/*.js', 'tests/support/models/*.js'],
+        src: [
+          'tests/support/factories/*.js',
+          'tests/support/models/*.js',
+          'tests/support/libs/*.js'],
         dest: "tests/test_setup.js"
       }
     },

data/README.md

@@ -1,3 +1,6 @@
+Ember Data Factory Guy [![Build Status](https://secure.travis-ci.org/danielspaniel/ember-data-factory-guy.png?branch=master)](http://travis-ci.org/danielspaniel/ember-data-factory-guy)
+=================
+
 # Using as Gem
 
 To Use with in Rails project or project with sprockets:
@@ -14,6 +17,22 @@ then:
 $ bundle install
 ```
 
+# Using as bower component
+
+Add as one of your dependencies in bower.json file:
+```json
+  "dependencies": {
+    "foo-dependency": "latest",
+    "other-foo-dependency": "latest",
+    "ember-data-factory-guy": "latest"
+  }
+```
+
+then:
+```
+$ bower install
+```
+
 # How this works
 
 Add fixtures to the store using the:
@@ -22,6 +41,16 @@ Add fixtures to the store using the:
   * DS.RestAdapter
   * DS.ActiveModelAdapter
 
+NOTE: The benefit of using FactoryGuy is that you can run your tests with the
+default adapter that you store normally uses. In other words: You do not have
+to use the DS.FixtureAdapter.  But if you do choose to use the Fixture adapter,
+which does not run any faster, and does not handle associations as elegantly ( if at all ),
+you may run into problems with accessing associations.
+If you do get these errors try requiring the factory_guy_has_many.js file
+( located in dist dir and vendor dir ) AFTER you require ember-data,
+but BEFORE you require your models.
+
+
 ```javascript
 
   ////////////////////////////////////////////
@@ -29,6 +58,7 @@ Add fixtures to the store using the:
 
   User = DS.Model.extend({
     name:     DS.attr 'string',
+    type:     DS.attr 'string',
     projects: DS.hasMany 'project'
   })
 
@@ -37,15 +67,23 @@ Add fixtures to the store using the:
   })
 
   ////////////////////////////////////////////
-  // Fixture definitions for models
-
+  // FactoryGuy definitions for models
   FactoryGuy.define('user', {
+    // sequences to be used in attributes definition
+    sequences: {
+      userName: function(num) {
+        return 'User' + num;
+      }
+   },
+
    // default values for 'user' attributes
     default: {
-      name: 'User1'
+      type: 'normal'
+      name: FactoryGuy.generate('userName'),
     },
     // named 'user' type with custom attributes
     admin: {
+      type: 'superuser'
       name: 'Admin'
     }
   });
@@ -55,23 +93,34 @@ Add fixtures to the store using the:
   });
 
   //////////////////////////////////////////////////////////////////
-  //
+  //            ** Make one fixture at time **
   // building json with FactoryGuy.build
   //
-  var userJson = FactoryGuy.build('user') // {id: 1, name: 'User1'}
-  var customUserJson = FactoryGuy.build('user', name: 'bob') // {id: 2, name: 'bob'}
-  var namedUserJson = FactoryGuy.build('admin') // {id: 3, name: 'Admin'}
+  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'}
+  var customUserJson = FactoryGuy.build('user', name: 'bob') // {id: 3, name: 'bob', type: 'normal'}
+  var namedUserJson = FactoryGuy.build('admin') // {id: 4, name: 'Admin', type: 'superuser'}
+
+  //////////////////////////////////////////////////////////////////
+  //            ** 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
   //
-  store.makeFixture('user'); //  user.FIXTURES = {id: 1, name: 'User1'}
-  store.makeFixture('user', {name: 'bob'}); //  user.FIXTURES = {id: 2, name: 'bob'}
-  store.makeFixture('admin'); //  user.FIXTURES = {id: 3, name: 'Admin'}
-  store.makeFixture('admin', name: 'My name'); //  user.FIXTURES = {id: 4, name: 'My name'}
+  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'}
+
 
   // Use store.find to get the model instance
   store.makeFixture('user');
@@ -83,6 +132,9 @@ Add fixtures to the store using the:
   var project = store.makeFixture('project');
   var user = store.makeFixture('user', projects: [project.id]);
 
+  // and for lists
+  var users = store.makeList('user', 2, projects: [project.id]);
+
   // with fixture adapter all associations are treated as async, so it's
   // a bit clunky to get this associated data. When using DS.FixtureAdapter
   // in view specs though, this clunk is dealt with for you.
@@ -95,16 +147,18 @@ Add fixtures to the store using the:
 
   //////////////////////////////////////////////////////////////////
   // 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
   //
   // returns a model instances so you can synchronously
   // start asking for data, as soon as you get the model
   //
-  var user = store.makeFixture('user');
-  var user = store.makeFixture('user', {name: 'bob'}); //  user.toJSON() = {id: 2, name: 'bob'}
-  var user = store.makeFixture('admin'); //  user.toJSON() = {id: 3, name: 'Admin'}
-  var user = store.makeFixture('admin', name: 'My name'); //  user.toJSON() = {id: 4, name: 'My name'}
+  var user = store.makeFixture('user'); //  user.toJSON() = {id: 1, name: 'User1', type: 'normal'}
+  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'}
 
   // and to setup associations ...
 
@@ -114,5 +168,57 @@ Add fixtures to the store using the:
   user.get('projects.length') == 1;
   user.get('projects.firstObject.user') == user;
 
+  // and to create lists
+  var users = store.makeList('user');
 
-```
+```
+
+Extra Goodies
+=============
+
+The code bundled in dist/ember-data-factory-guy.js includes a mixin named FactoryGuyTestMixin which
+can be used in your tests to make it easier to access the store and make fixtures.
+
+```javascript
+
+// Let's say you have a helper for your tests named TestHelper declared in a file.
+
+TestHelper = Ember.Object.createWithMixins(FactoryGuyTestMixin);
+
+
+// Then in your tests you can use it like so:
+
+
+var testHelper, store;
+
+module('User Model', {
+  setup: function() {
+    testHelper = TestHelper.setup(App);
+  },
+  teardown: function() {
+    Em.run(function() { testHelper.teardown(); });
+  }
+});
+
+// You could at this point, make fixtures with testHelper.make('user'), but
+// to be even more concise in tests you could add this method to your tests
+var make = function(name, opts) { return testHelper.make(name, opts); }
+
+
+test("make a user using fixture adapter", function() {
+  // useFixtureAdapter method is built into FactoryGuyTestMixin, and usually
+  // this would be called in the setup function
+  testHelper.useFixtureAdapter();
+  var json = make('user');
+  equal(User.FIXTURES.length, 1);
+});
+
+// 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(user instanceof DS.Model, true);
+});
+
+
+```

data/bower.json

@@ -1,6 +1,6 @@
 {
   "name": "ember-data-factory-guy",
-  "version": "0.0.1",
+  "version": "0.1.2",
   "authors": [
     "Daniel Sudol <dansudol@yahoo.com>",
     "Opak Alex <opak.alexandr@gmail.com>"
@@ -20,7 +20,6 @@
     "jquery": "1.10.2",
     "ember": "~1.6.0",
     "ember-data": "~1.0.0-beta.7",
-    "emblem.js": "*",
     "chance": "latest",
     "qunit": "latest"
   },
@@ -29,6 +28,11 @@
     "**/.*",
     "node_modules",
     "bower_components",
+    "bower.json",
+    "gruntfile.js",
+    "package.json",
+    "README.md",
+    "src",
     "test",
     "tests"
   ]

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

@@ -1,137 +1,277 @@
-FactoryGuy = Ember.Object.reopenClass({
-  fixtureStore: {},
-  fixtureLookup: {},
-  modelIds: {},
+Sequence = function (fn) {
+  var index = 1;
+  var fn = fn;
 
-  /**
-   ```javascript
+  this.next = function () {
+    return fn.call(this, index++);
+  }
 
-     User = DS.Model.extend({
-        name: DS.attr('string'),
-     })
+  this.reset = function () {
+    index = 1;
+  }
+}
 
-     FactoryGuy.define('user', {
-        default: {
-          name: "Fred"
-        },
+function MissingSequenceError(message) {
+  this.toString = function() { return message }
+}
 
-        bob: {
-          name: "Bob"
-        }
-     });
+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) {
+  }
 
-     For the User model, you can define fixtures like 'bob' or just use 'user'
-     and get default values.
+  /**
+    @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();
+  }
 
-     And to get those fixtures you would call them this way:
+  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;
+  }
 
-      FactoryGuy.build('user') or FactoryGuy.build('bob')
+  /**
+    Build a list of fixtures
 
-    @param model the model to define
-    @param config your default and named fixtures
+    @param name model name or named model type
+    @param number of fixtures to build
+    @param opts attribute options
+    @returns array of fixtures
    */
-  define: function (model, config) {
-    var info = this.getModelInfo(model);
-    for (key in config) {
-      var value = config[key];
-      info[key] = value;
-      if (key != 'default') {
-        this.fixtureLookup[key] = model;
+  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);
     }
-    // setup id
-    this.modelIds[model] = 0;
-  },
+    sequences = object;
+  }
+
+  var parseConfig = function (config) {
+    parseSequences(config.sequences);
+    delete config.sequences;
+
+    parseDefault(config.default);
+    delete config.default;
+
+    namedModels = config;
+  }
+
+  // initialize
+  parseConfig(config);
+}
+FactoryGuy = Ember.Object.reopenClass({
+  modelDefinitions: {},
 
   /**
+   ```javascript
 
-    @param model
+   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 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')
+
+   @param model the model to define
+   @param config your model definition object
    */
-  getModelInfo: function (model) {
-    if (!this.fixtureStore[model]) {
-      this.fixtureStore[model] = {};
+  define: function (model, config) {
+    if (this.modelDefinitions[model]) {
+      this.modelDefinitions[model].merge(config);
+    } else {
+      this.modelDefinitions[model] = new ModelDefinition(model, config);
+    }
+  },
+
+  generate: function (sequenceName) {
+    return function () {
+      return this.generate(sequenceName);
     }
-    return this.fixtureStore[model];
   },
 
+
   /**
 
-    @param name fixture name
-    @returns model associated with fixture name
+   @param name fixture name could be model name like 'user'
+   or specific user like 'admin'
+   @returns model associated with fixture name
    */
   lookupModelForName: function (name) {
-    var model = this.fixtureLookup[name];
-    if (!model) {
-      if (this.fixtureStore[name]) {
-        model = name;
+    for (model in this.modelDefinitions) {
+      var definition = this.modelDefinitions[model];
+      if (definition.matchesName(name)) {
+        return definition.model;
       }
     }
-    return model;
   },
 
   /**
-    Generate next id for model
+
+   @param name fixture name could be model name like 'user'
+   or specific user like 'admin'
+   @returns definition associated with model
    */
-  generateId: function (model) {
-    var lastId = this.modelIds[model] || 0;
-    this.modelIds[model] = lastId + 1;
-    return this.modelIds[model];
+  lookupDefinitionForName: function (name) {
+    for (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:
+   Build fixtures for model or specific fixture name. For example:
 
-      FactoryGuy.build('user') for User model
-      FactoryGuy.build('bob') for User model with bob attributes
+   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 name fixture name
+   @param opts options that will override default fixture values
+   @returns {*}
    */
   build: function (name, opts) {
-    var model = this.lookupModelForName(name);
-    if (!model) {
-      throw new Error("can't find that factory named [" + name + "]");
+    var definition = this.lookupDefinitionForName(name);
+    if (!definition) {
+      throw new Error("Can't find that factory named [" + name + "]");
     }
+    return definition.build(name, opts);
+  },
+
+  /**
+   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
 
-    var modelInfo = this.fixtureStore[model];
-    var modelAttributes = modelInfo[name] || {};
-    var defaultModelAttributes = modelInfo.default;
-    var fixture = $.extend({}, defaultModelAttributes, modelAttributes, opts);
-    if(!fixture.id){
-      fixture.id = this.generateId(model);
+   @param name fixture name
+   @param number number of fixtures to create
+   @param opts options that will override default fixture values
+   @returns list of fixtures
+   */
+  buildList: function (name, number, opts) {
+    var definition = this.lookupDefinitionForName(name);
+    if (!definition) {
+      throw new Error("Can't find that factory named [" + name + "]");
     }
-    return fixture;
+    return definition.buildList(name, number, opts);
   },
 
   /**
-    Clear model instances from FIXTURES array, and from store cache.
-    Reset the id sequence for the models back to zero.
+   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;
-    if (store.usingFixtureAdapter()) {
-      for (typeKey in this.fixtureStore) {
-        var modelType = store.modelFor(typeKey);
-        modelType.FIXTURES = [];
+    for (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) {
       }
-    } else {
-      for (model in typeMaps) {
-        store.unloadAll(typeMaps[model].type);
-      }
+//    } else {
+//      for (model in typeMaps) {
+//        store.unloadAll(typeMaps[model].type);
+//      }
+//    }
+
+//    for (model in this.modelDefinitions) {
+//      this.modelDefinitions[model].reset();
     }
-    this.modelIds = {}
   },
 
   /**
-    Push fixture to model's FIXTURES array.
-    Used when store's adapter is a DS.FixtureAdapter.
+   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
+   @param modelClass DS.Model type
+   @param fixture the fixture to add
+   @returns json fixture data
    */
   pushFixture: function (modelClass, fixture) {
     if (!modelClass['FIXTURES']) {
@@ -141,7 +281,6 @@ FactoryGuy = Ember.Object.reopenClass({
     return fixture;
   }
 })
-
 DS.Store.reopen({
 
   usingFixtureAdapter: function() {
@@ -153,9 +292,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);
@@ -163,31 +302,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');
@@ -206,18 +362,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) {
@@ -285,8 +441,9 @@ DS.FixtureAdapter.reopen({
 })
 
 
-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;