ember-data-factory-guy 0.1

data/.gitignore

@@ -0,0 +1,2 @@
+bower_components/
+node_modules/

data/Gruntfile.js

@@ -0,0 +1,45 @@
+module.exports = function(grunt) {
+
+  grunt.initConfig({
+
+    pkg: grunt.file.readJSON('package.json'),
+
+    concat: {
+      dist: {
+        src: ['src/factory_guy.js', 'src/store.js', 'src/factory_guy_helper_mixin.js'],
+        dest: "dist/ember-data-factory-guy.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/factory_guy_has_many.js": ['src/has_many.js']
+        }
+      },
+      test: {
+        src: ['tests/support/factories/*.js', 'tests/support/models/*.js'],
+        dest: "tests/test_setup.js"
+      }
+    },
+
+    uglify: {
+      options: { mangle: false, compress: false },
+
+      dist: {
+        src: ['dist/ember-data-factory-guy.js'],
+        dest: 'dist/ember-data-factory-guy.min.js'
+      }
+    },
+
+    qunit: {
+      all: ['tests/*.html']
+    }
+  });
+
+  grunt.loadNpmTasks('grunt-contrib-coffee');
+  grunt.loadNpmTasks('grunt-contrib-concat');
+  grunt.loadNpmTasks('grunt-contrib-uglify');
+  grunt.loadNpmTasks('grunt-contrib-qunit');
+
+  grunt.registerTask('default', ['concat', 'uglify']);
+  grunt.registerTask('test', ['concat:dist', 'qunit']);
+};

data/README.md

@@ -0,0 +1,118 @@
+# Using as Gem
+
+To Use with in Rails project or project with sprockets:
+
+In Gemfile:
+
+```ruby
+gem 'ember-data-factory-guy', group: test
+```
+
+then:
+
+```
+$ bundle install
+```
+
+# How this works
+
+Add fixtures to the store using the:
+
+  * DS.FixtureAdapter
+  * DS.RestAdapter
+  * DS.ActiveModelAdapter
+
+```javascript
+
+  ////////////////////////////////////////////
+  // Model definitions
+
+  User = DS.Model.extend({
+    name:     DS.attr 'string',
+    projects: DS.hasMany 'project'
+  })
+
+  Project = DS.Model.extend({
+    title: DS.attr 'string'
+  })
+
+  ////////////////////////////////////////////
+  // Fixture definitions for models
+
+  FactoryGuy.define('user', {
+   // default values for 'user' attributes
+    default: {
+      name: 'User1'
+    },
+    // named 'user' type with custom attributes
+    admin: {
+      name: 'Admin'
+    }
+  });
+
+  FactoryGuy.define('project', {
+    default: {title: 'Project'}
+  });
+
+  //////////////////////////////////////////////////////////////////
+  //
+  // 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'}
+
+  //////////////////////////////////////////////////////////////////
+  // store.makeFixture method creates model in the store
+  //
+  // with DS.Fixture adapter
+  //  makeFixture 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'}
+
+  // Use store.find to get the model instance
+  store.makeFixture('user');
+  store.find('user', 1).then(function(user) {
+    user.get('name') == 'My name';
+  });
+
+  // and to setup associations ...
+  var project = store.makeFixture('project');
+  var user = store.makeFixture('user', 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.
+  store.find('user', 1).then(function(user) {
+    user.get('name') == 'My name';
+    user.get('projects').then(function(projects) {
+      projects.length == 1;
+    });
+  });
+
+  //////////////////////////////////////////////////////////////////
+  // store.makeFixture method creates model and adds it to 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'}
+
+  // and to setup associations ...
+
+  var project = store.makeFixture('project');
+  var user = store.makeFixture('user', projects: [project.id]);
+
+  user.get('projects.length') == 1;
+  user.get('projects.firstObject.user') == user;
+
+
+```

data/bower.json

@@ -0,0 +1,35 @@
+{
+  "name": "ember-data-factory-guy",
+  "version": "0.0.1",
+  "authors": [
+    "Daniel Sudol <dansudol@yahoo.com>",
+    "Opak Alex <opak.alexandr@gmail.com>"
+  ],
+  "description": "Factory for testing Ember application using Ember Data",
+  "main": "dist/ember-data-factory-guy.js",
+  "keywords": [
+    "Factory",
+    "Ember",
+    "Data",
+    "FixtureAdapter"
+  ],
+  "license": "MIT",
+
+  "dependencies": {
+    "handlebars": "~1.1.2",
+    "jquery": "1.10.2",
+    "ember": "~1.6.0",
+    "ember-data": "~1.0.0-beta.7",
+    "emblem.js": "*",
+    "chance": "latest",
+    "qunit": "latest"
+  },
+
+  "ignore": [
+    "**/.*",
+    "node_modules",
+    "bower_components",
+    "test",
+    "tests"
+  ]
+}

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

@@ -0,0 +1,376 @@
+FactoryGuy = Ember.Object.reopenClass({
+  fixtureStore: {},
+  fixtureLookup: {},
+  modelIds: {},
+
+  /**
+   ```javascript
+
+     User = DS.Model.extend({
+        name: DS.attr('string'),
+     })
+
+     FactoryGuy.define('user', {
+        default: {
+          name: "Fred"
+        },
+
+        bob: {
+          name: "Bob"
+        }
+     });
+
+    ```
+
+     For the User model, you can define fixtures like 'bob' or just use 'user'
+     and get default values.
+
+     And to get those fixtures you would call them this way:
+
+      FactoryGuy.build('user') or FactoryGuy.build('bob')
+
+    @param model the model to define
+    @param config your default and specific 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;
+      }
+    }
+    // setup id
+    this.modelIds[model] = 0;
+  },
+
+  /**
+
+    @param model
+   */
+  getModelInfo: function (model) {
+    if (!this.fixtureStore[model]) {
+      this.fixtureStore[model] = {};
+    }
+    return this.fixtureStore[model];
+  },
+
+  /**
+
+    @param name fixture name
+    @returns model associated with fixture name
+   */
+  lookupModelForName: function (name) {
+    var model = this.fixtureLookup[name];
+    if (!model) {
+      if (this.fixtureStore[name]) {
+        model = name;
+      }
+    }
+    return model;
+  },
+
+  /**
+    Generate next id for model
+   */
+  generateId: function (model) {
+    var lastId = this.modelIds[model] || 0;
+    this.modelIds[model] = lastId + 1;
+    return this.modelIds[model];
+  },
+
+  /**
+    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
+
+    @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 modelInfo = this.fixtureStore[model];
+    var modelAttributes = modelInfo[name] || {};
+    var defaultModelAttributes = modelInfo.default;
+    var fixture = $.extend({}, defaultModelAttributes, modelAttributes, opts);
+    fixture.id = this.generateId(model);
+    return fixture;
+  },
+
+  /**
+    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 = [];
+        store.unloadAll(modelType);
+      }
+    } else {
+      for (model in typeMaps) {
+        if (typeMaps[model].type.typeKey != 'user') {
+//          console.log(typeMaps[model].type.typeKey)
+          store.unloadAll(typeMaps[model].type);
+        }
+      }
+    }
+    this.modelIds = {}
+  },
+
+  /**
+    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
+   */
+  pushFixture: function (modelClass, fixture) {
+    if (!modelClass['FIXTURES']) {
+      modelClass['FIXTURES'] = [];
+    }
+    modelClass['FIXTURES'].push(fixture);
+    return fixture;
+  }
+})
+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;
+  }
+
+})
+
+
+FactoryGuyHelperMixin = Em.Mixin.create({
+
+  setup: function(app) {
+    this.set('container', app.__container__);
+    return this;
+  },
+
+  useFixtureAdapter: function(app) {
+    app.ApplicationAdapter = DS.FixtureAdapter;
+    this.getStore().adapterFor('application').simulateRemoteResponse = false;
+  },
+
+  find: function(type, id) {
+    return this.getStore().find(type, id);
+  },
+
+  make: function(name, opts) {
+    return this.getStore().makeFixture(name, opts);
+  },
+
+  getStore: function () {
+    return this.get('container').lookup('store:main');
+  },
+
+  pushPayload: function(type, hash) {
+    return this.getStore().pushPayload(type, hash);
+  },
+
+  pushRecord: function(type, hash) {
+    return this.getStore().push(type, hash);
+  },
+
+  stubEndpointForHttpRequest: function (url, json, options) {
+    options = options || {};
+    var request = {
+      url: url,
+      dataType: 'json',
+      responseText: json,
+      type: options.type || 'GET',
+      status: options.status || 200
+    }
+
+    if (options.data) {
+      request.data = options.data
+    }
+
+    $.mockjax(request);
+  },
+
+  /**
+   * Handling ajax POST for a model
+   *
+   * @param name of the fixture ( or model ) to create
+   * @param opts fixture options
+   */
+  handleCreate: function (name, opts) {
+    var model = FactoryGuy.lookupModelForName(name);
+    this.stubEndpointForHttpRequest(
+      "/" + Em.String.pluralize(model),
+      this.buildAjaxResponse(name, opts),
+      {type: 'POST'}
+    )
+  },
+
+  buildAjaxResponse: function (name, opts) {
+    var fixture = FactoryGuy.build(name, opts);
+    var model = FactoryGuy.lookupModelForName(name);
+    var hash = {};
+    hash[model] = fixture;
+    return hash;
+  },
+
+  handleUpdate: function (root, id) {
+    this.stubEndpointForHttpRequest(
+      "/" + Em.String.pluralize(root) + "/" + id, '{}', {type: 'PUT'}
+    )
+  },
+
+  handleDelete: function (root, id) {
+    this.stubEndpointForHttpRequest(
+      "/" + Em.String.pluralize(root) + "/" + id, {}, {type: 'DELETE'}
+    )
+  },
+
+  teardown: function () {
+    FactoryGuy.resetModels(this.getStore());
+  }
+
+})