ember-data-factory-guy 0.7.0 → 0.7.1

data/tests/support/factories/project_factory.js

@@ -29,4 +29,15 @@ FactoryGuy.define("project", {
     // differs from the model name
     parent: FactoryGuy.belongsTo('project')
   }
+});
+
+
+FactoryGuy.define("sub_project", {
+  sequences: {
+    title: function (num) { return 'SubProject' + num }
+  },
+  default: {
+    title: FactoryGuy.generate('title'),
+    type: "SubProject"
+  }
 });

data/tests/support/models/group.js

@@ -0,0 +1,12 @@
+Group = DS.Model.extend({
+  versions: DS.hasMany('group')
+})
+
+BigGroup = Group.extend({
+  group: DS.belongsTo('group')
+})
+
+SmallGroup = Group.extend({
+  group: DS.belongsTo('group')
+})
+

data/tests/support/models/hat.js

@@ -2,7 +2,8 @@ Hat = DS.Model.extend({
   type: DS.attr('string'),
   user: DS.belongsTo('user'),
   hat:  DS.belongsTo('hat', {inverse: 'hats', polymorphic: true}),
-  hats: DS.hasMany('hat', {inverse: 'hat', polymorphic: true})
+  hats: DS.hasMany('hat', {inverse: 'hat', polymorphic: true}),
+  fluffy_materials: DS.hasMany('fluffy_materials')
 });
 
 BigHat = Hat.extend({

data/tests/support/models/material.js

@@ -2,3 +2,8 @@ SoftMaterial = DS.Model.extend({
   name: DS.attr('string'),
   hat:  DS.belongsTo('big_hat')
 })
+
+FluffyMaterial = DS.Model.extend({
+  name: DS.attr('string'),
+  hat:  DS.belongsTo('hat', {polymorphic: true})
+})

data/tests/support/models/project.js

@@ -4,3 +4,8 @@ Project = DS.Model.extend({
   parent:   DS.belongsTo('project', {inverse: 'children'}),
   children: DS.hasMany('project', {inverse: 'parent'})
 });
+
+
+
+
+

data/tests/support/test_helper.js

@@ -8,32 +8,262 @@ TestHelper = Ember.Object.createWithMixins(FactoryGuyTestMixin,{
   setup: function(adapter) {
     $.mockjaxSettings.logging = false;
     $.mockjaxSettings.responseTime = 0;
-    var container = new Ember.Container();
-    this.set('container', container);
-
-    container.register("model:hat", Hat);
-    container.register("model:small_hat", SmallHat);
-    container.register("model:big_hat", BigHat);
-    container.register("model:soft_material", SoftMaterial);
-    container.register("model:user", User);
-    container.register("model:profile", Profile);
-    container.register("model:company", Company);
-    container.register("model:small_company", SmallCompany);
-    container.register("model:property", Property);
-    container.register("model:project", Project);
-    container.register("store:main", DS.Store.extend({adapter: adapter}));
-    if (adapter == DS.ActiveModelAdapter) {
-      container.register("serializer:-default", DS.ActiveModelSerializer);
-    } else if (adapter == DS.RESTAdapter) {
-      container.register("serializer:-default", DS.RESTSerializer);
-    } else {
-      container.register("serializer:-default", DS.JSONSerializer);
-    }
-    container.register('transform:string', DS.StringTransform);
+
+    var env = setupStore({
+      adapter: adapter,
+      hat: Hat,
+      small_hat: SmallHat,
+      big_hat: BigHat,
+      soft_material: SoftMaterial,
+      fluffy_material: FluffyMaterial,
+      profile: Profile,
+      user: User,
+      company: Company,
+      property: Property,
+      project: Project,
+      group: Group,
+      big_group: BigGroup,
+      small_group: SmallGroup
+    })
 
     if (adapter instanceof DS.FixtureAdapter) {
       adapter.simulateRemoteResponse = false;
     }
+    this.set('container', env.container);
     return this;
   }
-});
+});
+
+
+/* globals ENV, QUnit */
+
+(function (){
+  window.Ember = window.Ember || {};
+
+  Ember.config = {};
+  Ember.testing = true;
+  Ember.LOG_VERSION = false;
+
+  window.ENV = { TESTING: true, LOG_VERSION: false };
+
+  var extendPrototypes = QUnit.urlParams.extendprototypes;
+  ENV['EXTEND_PROTOTYPES'] = !!extendPrototypes;
+
+  window.async = function(callback, timeout) {
+    stop();
+
+    timeout = setTimeout(function() {
+      start();
+      ok(false, "Timeout was reached");
+    }, timeout || 200);
+
+    return function() {
+      clearTimeout(timeout);
+
+      start();
+
+      var args = arguments;
+      return Ember.run(function() {
+        return callback.apply(this, args);
+      });
+    };
+  };
+
+  window.asyncEqual = function(a, b, message) {
+    Ember.RSVP.all([ Ember.RSVP.resolve(a), Ember.RSVP.resolve(b) ]).then(async(function(array) {
+      /*globals QUnit*/
+      QUnit.push(array[0] === array[1], array[0], array[1], message);
+    }));
+  };
+
+  window.invokeAsync = function(callback, timeout) {
+    timeout = timeout || 1;
+
+    setTimeout(async(callback, timeout+100), timeout);
+  };
+
+  window.setupStore = function(options) {
+    var env = {};
+    options = options || {};
+
+    var container = env.container = new Ember.Container();
+
+    var adapter = env.adapter = (options.adapter || DS.Adapter);
+    delete options.adapter;
+
+    for (var prop in options) {
+      container.register('model:' + prop, options[prop]);
+    }
+
+    container.register('store:main', DS.Store.extend({
+      adapter: adapter
+    }));
+
+    var serializer = DS.JSONSerializer;
+    if (adapter == DS.ActiveModelAdapter) {
+      serializer = DS.ActiveModelSerializer;
+    } else if (adapter == DS.RESTAdapter) {
+      serializer = DS.RESTSerializer;
+    }
+
+    container.register('serializer:-default', serializer);
+
+    container.register('transform:string', DS.StringTransform);
+
+    container.injection('serializer', 'store', 'store:main');
+
+    env.store = container.lookup('store:main');
+    env.adapter = env.store.get('defaultAdapter');
+
+    return env;
+  };
+
+  window.createStore = function(options) {
+    return setupStore(options).store;
+  };
+
+  var async = window.async  = function(callback, timeout) {
+     stop();
+
+     timeout = setTimeout(function() {
+       start();
+       ok(false, "Timeout was reached");
+     }, timeout || 200);
+
+     return function() {
+       clearTimeout(timeout);
+
+       start();
+
+       var args = arguments;
+       return Ember.run(function() {
+         return callback.apply(this, args);
+       });
+     };
+   };
+
+  var syncForTest = window.syncForTest = function(fn) {
+    var callSuper;
+
+    if (typeof fn !== "function") { callSuper = true; }
+
+    return function() {
+      var override = false, ret;
+
+      if (Ember.run && !Ember.run.currentRunLoop) {
+        Ember.run.begin();
+        override = true;
+      }
+
+      try {
+        if (callSuper) {
+          ret = this._super.apply(this, arguments);
+        } else {
+          ret = fn.apply(this, arguments);
+        }
+      } finally {
+        if (override) {
+          Ember.run.end();
+        }
+      }
+
+      return ret;
+    };
+  };
+
+  Ember.config.overrideAccessors = function() {
+    Ember.set = syncForTest(Ember.set);
+    Ember.get = syncForTest(Ember.get);
+  };
+
+  Ember.config.overrideClassMixin = function(ClassMixin) {
+    ClassMixin.reopen({
+      create: syncForTest()
+    });
+  };
+
+  Ember.config.overridePrototypeMixin = function(PrototypeMixin) {
+    PrototypeMixin.reopen({
+      destroy: syncForTest()
+    });
+  };
+
+  QUnit.begin(function(){
+    Ember.RSVP.configure('onerror', function(reason) {
+      // only print error messages if they're exceptions;
+      // otherwise, let a future turn of the event loop
+      // handle the error.
+      if (reason && reason instanceof Error) {
+        Ember.Logger.log(reason, reason.stack);
+        throw reason;
+      }
+    });
+
+    Ember.RSVP.resolve = syncForTest(Ember.RSVP.resolve);
+
+    Ember.View.reopen({
+      _insertElementLater: syncForTest()
+    });
+
+    DS.Store.reopen({
+      save: syncForTest(),
+      createRecord: syncForTest(),
+      deleteRecord: syncForTest(),
+      push: syncForTest(),
+      pushMany: syncForTest(),
+      filter: syncForTest(),
+      find: syncForTest(),
+      findMany: syncForTest(),
+      findByIds: syncForTest(),
+      didSaveRecord: syncForTest(),
+      didSaveRecords: syncForTest(),
+      didUpdateAttribute: syncForTest(),
+      didUpdateAttributes: syncForTest(),
+      didUpdateRelationship: syncForTest(),
+      didUpdateRelationships: syncForTest(),
+      scheduleFetch: syncForTest(),
+      scheduleFetchMany: syncForTest()
+    });
+
+    DS.Model.reopen({
+      save: syncForTest(),
+      reload: syncForTest(),
+      deleteRecord: syncForTest(),
+      dataDidChange: Ember.observer(syncForTest(), 'data'),
+      updateRecordArraysLater: syncForTest(),
+      updateRecordArrays: syncForTest()
+    });
+
+    DS.Errors.reopen({
+      add: syncForTest(),
+      remove: syncForTest(),
+      clear: syncForTest()
+    });
+
+    DS.Relationship.prototype.addRecord = syncForTest(DS.Relationship.prototype.addRecord);
+    DS.Relationship.prototype.removeRecord = syncForTest(DS.Relationship.prototype.removeRecord);
+    DS.Relationship.prototype.removeRecordFromInverse = syncForTest(DS.Relationship.prototype.removeRecordFromInverse);
+    DS.Relationship.prototype.removeRecordFromOwn = syncForTest(DS.Relationship.prototype.removeRecordFromOwn);
+
+    var transforms = {
+      'boolean': DS.BooleanTransform.create(),
+      'date': DS.DateTransform.create(),
+      'number': DS.NumberTransform.create(),
+      'string': DS.StringTransform.create()
+    };
+
+    // Prevent all tests involving serialization to require a container
+    DS.JSONSerializer.reopen({
+      transformFor: function(attributeType) {
+        return this._super(attributeType, true) || transforms[attributeType];
+      }
+    });
+
+    Ember.RSVP.Promise.prototype.then = syncForTest(Ember.RSVP.Promise.prototype.then);
+  });
+
+  // Generate the jQuery expando on window ahead of time
+  // to make the QUnit global check run clean
+  jQuery(window).data('testing', true);
+
+})();

data/tests/test_setup.js

@@ -3,6 +3,35 @@ FactoryGuy.define("company", {
     name: 'Silly corp'
   }
 })
+FactoryGuy.define("group", {
+  sequences: {
+    name: function(num) {return 'Group' + num}
+  },
+  default: {
+    type: "Group",
+    name: FactoryGuy.generate('name')
+  }
+});
+
+FactoryGuy.define("big_group", {
+  sequences: {
+    name: function(num) {return 'Big Group' + num}
+  },
+  default: {
+    type: "BigGroup",
+    name: FactoryGuy.generate('name')
+  }
+})
+
+FactoryGuy.define("small_group", {
+  sequences: {
+    name: function(num) {return 'Small Group' + num}
+  },
+  default: {
+    type: "SmallGroup",
+    name: FactoryGuy.generate('name')
+  }
+})
 FactoryGuy.define('hat', {
   default: {},
   small_hat: {
@@ -20,6 +49,15 @@ FactoryGuy.define('soft_material', {
     name: 'silk'
   }
 })
+
+FactoryGuy.define('fluffy_material', {
+  default: {
+    name: 'fluffy material'
+  },
+  silk: {
+    name: 'fluff'
+  }
+})
 FactoryGuy.define('profile', {
   default: {
     description: 'Text goes here'
@@ -57,6 +95,17 @@ FactoryGuy.define("project", {
     parent: FactoryGuy.belongsTo('project')
   }
 });
+
+
+FactoryGuy.define("sub_project", {
+  sequences: {
+    title: function (num) { return 'SubProject' + num }
+  },
+  default: {
+    title: FactoryGuy.generate('title'),
+    type: "SubProject"
+  }
+});
 FactoryGuy.define('property', {
   default: {
     name: 'Silly property'
@@ -91,11 +140,25 @@ SmallCompany = Company.extend({
   projects: DS.hasMany('project', {async: true})
 });
 
+Group = DS.Model.extend({
+  versions: DS.hasMany('group')
+})
+
+BigGroup = Group.extend({
+  group: DS.belongsTo('group')
+})
+
+SmallGroup = Group.extend({
+  group: DS.belongsTo('group')
+})
+
+
 Hat = DS.Model.extend({
   type: DS.attr('string'),
   user: DS.belongsTo('user'),
   hat:  DS.belongsTo('hat', {inverse: 'hats', polymorphic: true}),
-  hats: DS.hasMany('hat', {inverse: 'hat', polymorphic: true})
+  hats: DS.hasMany('hat', {inverse: 'hat', polymorphic: true}),
+  fluffy_materials: DS.hasMany('fluffy_materials')
 });
 
 BigHat = Hat.extend({
@@ -110,6 +173,11 @@ SoftMaterial = DS.Model.extend({
   hat:  DS.belongsTo('big_hat')
 })
 
+FluffyMaterial = DS.Model.extend({
+  name: DS.attr('string'),
+  hat:  DS.belongsTo('hat', {polymorphic: true})
+})
+
 Profile = DS.Model.extend({
   description:            DS.attr('string'),
   camelCaseDescription:   DS.attr('string'),
@@ -124,6 +192,11 @@ Project = DS.Model.extend({
   children: DS.hasMany('project', {inverse: 'parent'})
 });
 
+
+
+
+
+
 Property = DS.Model.extend({
   name:    DS.attr('string'),
   company: DS.belongsTo('company', {async: true}),