ember-data-factory-guy 0.2.1 → 0.3.0

data/.gitignore

@@ -1,3 +1,6 @@
 bower_components/
 node_modules/
-*.gem
+factory_guy_presentation/
+factory_guy_presents/
+stats/
+*.gem

data/Gruntfile.js

@@ -49,6 +49,14 @@ module.exports = function(grunt) {
 
     qunit: {
       all: ['tests/*.html']
+    },
+
+    bump: {
+      options: {
+        files: ['package.json', 'bower.json', 'ember-data-factory-guy.gemspec'],
+        commitFiles: ["-a"],
+        push: false
+      }
     }
   });
 

data/README.md

@@ -1,7 +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)
-=================
+# 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
+## Using as Gem
 
 To Use with in Rails project or project with sprockets:
 
@@ -24,7 +23,7 @@ then:
 //= require ember_data_factory_guy
 ```
 
-# Using as bower component
+## Using as bower component
 
 Add as one of your dependencies in bower.json file:
 ```json
@@ -40,13 +39,13 @@ then:
 $ bower install
 ```
 
-# How this works
+## How this works
 
 Add fixtures to the store using the:
 
-  * DS.FixtureAdapter
   * DS.RestAdapter
   * DS.ActiveModelAdapter
+  * DS.FixtureAdapter
 
 NOTE: The benefit of using FactoryGuy is that you can run your tests with the
 default adapter that your application's store normally uses. In other words:
@@ -60,25 +59,39 @@ If you do get these types of errors try requiring the factory_guy_has_many.js fi
 ( located in dist dir and vendor dir ) AFTER you require ember-data,
 but BEFORE you require your models.
 
+Let's say you have a few models like these:
 
 ```javascript
 
-  ////////////////////////////////////////////
-  // Model definitions
-
   User = DS.Model.extend({
     name:     DS.attr('string'),
     type:     DS.attr('string'),
-    projects: DS.hasMany('project')
-  })
+    projects: DS.hasMany('project'),
+    hats: DS.hasMany('hat', {polymorphic: true})
+  });
 
   Project = DS.Model.extend({
-    title:  DS.attr('string')
+    title:  DS.attr('string'),
     user:   DS.belongsTo('user')
-  })
+  });
+
+  Hat = DS.Model.extend({
+    type: DS.attr('string'),
+    user: DS.belongsTo('user')
+  });
+
+  BigHat = Hat.extend();
+  SmallHat = Hat.extend();
 
+```
+
+
+### Defining a Fixture Factory for a Model
+
+```javascript
   ////////////////////////////////////////////
   // FactoryGuy definitions for models
+
   FactoryGuy.define('user', {
     // sequences to be used in attributes definition
     sequences: {
@@ -99,113 +112,185 @@ but BEFORE you require your models.
       type: 'superuser',
       name: 'Admin'
     }
+    // using a function for an attribute that refers to other attributes
+    funny_user: {
+      type: function(f) { return 'funny '  + f.name }
+    }
   });
 
   FactoryGuy.define('project', {
     default: {
       title: 'Project'
+    },
+    //
+    // define built in belongTo models
+    //
+    project_with_user: {
+      // user model with default attributes
+      user: {}
+    },
+    project_with_dude: {
+      // user model with custom attributes
+      user: {name: 'Dude'}
+    },
+    project_with_admin: {
+      // for named association, use this FactoryGuy.association helper method
+      user: FactoryGuy.association('admin')
     }
   });
 
+  FactoryGuy.define('hat', {
+    default: {},
+    small_hat: {
+      type: 'small_hat'
+    },
+    big_hat: {
+      type: 'big_hat'
+    }
+  })
+```
+
+
+### Building Json
+
+```javascript
   //////////////////////////////////////////////////////////////////
-  //            ** Make one fixture at time **
+  //
   // building json with FactoryGuy.build
   //
 
-  var userJson = FactoryGuy.build('user') // {id: 1, name: 'User1', type: 'normal'}
+  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'}
+  FactoryGuy.build('user') // {id: 2, name: 'User2', type: 'normal'}
+  FactoryGuy.build('user', {name: 'bob'}) // {id: 3, name: 'bob', type: 'normal'}
+  FactoryGuy.build('admin') // {id: 4, name: 'Admin', type: 'superuser'}
+  // note the type attribute was built from a function which depends on the name
+  // and the name is still a generated attribute from a sequence function
+  FactoryGuy.build('funny_user') // {id: 5, name: 'User3', type: 'funny User3'}
+
+  // basic project
+  FactoryGuy.build('project') // {id: 1, title: 'Project'}
+
+  // project with a user
+  FactoryGuy.build('project_with_user') // {id: 1, title: 'Project', user: {id:6, name: 'User4', type: 'normal'}
+  // project with user that has custom attributes
+  FactoryGuy.build('project_with_dude') // {id: 2, title: 'Project', user: {id:7, name: 'Dude', type: 'normal'}
+  // project with user that has a named user
+  FactoryGuy.build('project_with_admin') // {id: 3, title: 'Project', user: {id:8, 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'} ]
+  FactoryGuy.buildList('user', 2) // [ {id: 1, name: 'User1', type: 'normal'}, {id: 2, name: 'User2', type: 'normal'} ]
+```
 
-  //////////////////////////////////////////////////////////////////
-  //
-  //  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: 'Fred'}); //  user.FIXTURES = [{id: 4, name: 'Fred', type: 'superuser'}]
+###Adding records to store
 
+#####DS.ActiveModelAdapter/DS.RestAdapter
 
-  // 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;
-  });
+###### The Basics
 
-  // and to setup associations ...
-  var projectJson = store.makeFixture('project');
-  var userJson = store.makeFixture('user', projects: [project.id]);
-  // OR
-  var userJson = store.makeFixture('user');
-  var projectJson = store.makeFixture('project', user: userJson.id);
-
-  // will give you the same result, but with fixture adapter all associations
-  // are treated as async ( by factory_guy_has_many.js fix ), 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. But remember,
-  // you don't have to use the Fixture adapter.
-  store.find('user', 1).then(function(user) {
-    user.get('name') == 'My name';
-    user.get('projects').then(function(projects) {
-      projects.length == 1;
-    });
-  });
+store.makeFixture => creates model in the store and returns model instance
+*NOTE* since you are getting a model instances, you can synchronously
+start asking for data from the model, and its associations
 
-  // and for lists
-  var users = store.makeList('user', 2, projects: [project.id]);
+```javascript
+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('funny_user'); // user.toJSON() = {id: 3, name: 'User3', type: 'funny User3'}
+var user = store.makeFixture('user', {name: 'bob'}); // user.toJSON() = {id: 4, name: 'bob', type: 'normal'}
+var user = store.makeFixture('admin'); // user.toJSON() = {id: 5, name: 'Admin', type: 'superuser'}
+var user = store.makeFixture('admin', {name: 'Fred'}); // user.toJSON() = {id: 6, name: 'Fred', type: 'superuser'}
+```
 
-  //////////////////////////////////////////////////////////////////
-  //
-  //  with store using =>  DS.ActiveModelAdapter/DS.RestAdapter
-  //
-  //  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
-  //
+###### associations
 
-  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: 'Fred'); //  user.toJSON() = {id: 5, name: 'Fred', type: 'superuser'}
+``` javascript
+var project = store.makeFixture('project');
+var user = store.makeFixture('user', {projects: [project]});
+//  OR
+var user = store.makeFixture('user');
+var project = store.makeFixture('project', {user: user});
 
-  // and to setup associations ...
+// will get you the same results, since FactoryGuy makes sure the associations
+// are created in both directions
+// user.get('projects.length') == 1;
+// user.get('projects.firstObject.user') == user;
+```
+
+###### polymorphic hasMany associations
+
+```javascript
+var sh = store.makeFixture('big_hat');
+var bh = store.makeFixture('small_hat');
+var user = store.makeFixture('user', {hats: [sh, bh]})
+// user.get('hats.length') == 2;
+// (user.get('hats.firstObject') instanceof BigHat) == true
+// (user.get('hats.lastObject') instanceof SmallHat) == true
+```
+
+###### create lists
+
+```javascript
+var users = store.makeList('user', 3);
+```
+
+#####DS.Fixture adapter
+
+store.makeFixture => creates model in the store and returns json
 
-  var project = store.makeFixture('project');
-  var user = store.makeFixture('user', projects: [project]);
-  //  OR
-  var user = store.makeFixture('user');
-  var project = store.makeFixture('project', user: user);
+Technically when you call store.makeFixture with a store using the DS.FixtureAdapter,
+the fixture is actually added to the models FIXTURE array. It just seems to be added
+to the store because when you call store.find to get that record, the adapter looks
+in that FIXTURE array to find it and then puts it in the store.
+
+```javascript
+
+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'}]
 
-  // will get you the same results
-  user.get('projects.length') == 1;
-  user.get('projects.firstObject.user') == user;
 
-  // and to create lists ( of 3 users in this case )
-  var users = store.makeList('user', 3);
+// 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() ( pretty much equals ) userJson;
+});
 
+// and to setup associations ...
+var projectJson = store.makeFixture('project');
+var userJson = store.makeFixture('user', {projects: [projectJson.id]});
+// OR
+var userJson = store.makeFixture('user');
+var projectJson = store.makeFixture('project', {user: userJson.id});
+
+// will give you the same result, but with fixture adapter all associations
+// are treated as async ( by factory_guy_has_many.js fix ), 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. But remember,
+// you don't have to use the Fixture adapter.
+store.find('user', 1).then(function(user) {
+  user.toJSON() (pretty much equals) userJson;
+  user.get('projects').then(function(projects) {
+    projects.length == 1;
+  });
+});
+
+// and for lists
+store.makeList('user', 2, {projects: [project.id]});
 ```
 
-Extra Goodies
-=============
+###Testing models, controllers, views
+
+
+This section assumes you are testing the ( controllers and views ) in isolation.
 
 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.
@@ -219,7 +304,6 @@ TestHelper = Ember.Object.createWithMixins(FactoryGuyTestMixin);
 
 // Then in your tests you can use it like so:
 
-
 var testHelper, store;
 
 module('User Model', {
@@ -257,7 +341,85 @@ test("make a user using your applications default adapter", function() {
 ```
 
 
-Further Extra Goodies
-=====================
+###Integration Tests
+
+Since it is recommended to use your normal adapter ( which is usually a subclass of RESTAdapter, )
+FactoryGuyTestMixin assumes you will want to use that adapter to do your integration tests.
+
+To do that you will still have to deal with ember data trying to create, update or delete records.
+
+If you put models into the store ( with store#makeFixture ), the http GET call does not need to be mocked,
+since that model is already in the store.
+
+But what if you want to handle create, update or delete?
+FactoryGuy assumes you want to mock ajax calls with the mockjax library,
+and you will need to download and include that library to use the following feature.
+
+Here is a sample of what you could do in a view test:
+
+```javascript
+
+// create a view test helper using the FactoryGuyTestMixin
+ViewTestHelper = Ember.Object.createWithMixins(FactoryGuyTestMixin,{
+  // override setup to do a few extra things for view tests
+  setup: function (app, opts) {
+    app.reset();  // reset ember app before test
+    $.mockjaxSettings.logging = false;   // mockjax settings
+    $.mockjaxSettings.responseTime = 0;  // mockjax settings
+    return this._super(app); // still call the base setup from FactoryGuyTestMixin
+  },
+  // override teardown to clear mockjax declarations
+  teardown: function() {
+    $.mockjaxClear();
+    this._super();
+  }
+}
+
+var viewHelper;
+
+module('User View', {
+  setup: function() {
+    viewHelper = ViewTestHelper.setup(App); // set up helper
+    var user = viewHelper.make('user'); // create a user in the store
+    visit('/users/'+user.id); // visit the users route
+  },
+  teardown: function() {
+    Em.run(function() { viewHelper.teardown(); });
+  }
+});
+
+test("Creates new project", function() {
+  andThen(function() {
+    var newProjectName  = "Gonzo Project"
+
+    click('.add-div div:contains(New Project)')
+    fillIn('.add-project input', newProjectName)
+    // This is the special sauce that makes this project really hum.
+    // Check out the FactoryGuyTestMixin to see what is going on here
+    viewHelper.handleCreate('project', {name: newProjectName})
+
+    /**
+     Let's say that clicking this '.add-project .link', triggers action in the view to
+     create project record and looks something like this:
+
+        actions: {
+          addProject: function (user) {
+            this.get('controller.store')
+            .createRecord('project', {
+              name: this.$('.add-project input').val(),
+              user: user
+            })
+            .save()
+          }
+
+    */
+    click('.add-project .link')
+
+    var newProjectDiv = find('.project:contains('+newProjectName+')')
+    equal(newProjectDiv[0] != undefined, true)
+  })
+})
+
+```
+
 
-mockjax