refactor(belongsToMany): get association unit tests working for belongsToMany

lib/associations/belongs-to-many.js

@@ -347,6 +347,8 @@ module.exports = (function() {
       , primaryKeyAttribute = association.target.primaryKeyAttribute;
 
     obj[this.accessors.set] = function(newAssociatedObjects, additionalAttributes) {
+      additionalAttributes = additionalAttributes || {};
+
       if (newAssociatedObjects === null) {
         newAssociatedObjects = [];
       } else {
@@ -365,7 +367,7 @@ module.exports = (function() {
       var instance = this;
 
       return instance[association.accessors.get]({}, {
-        transaction: (additionalAttributes || {}).transaction
+        transaction: additionalAttributes.transaction
       }).then(function(oldAssociatedObjects) {
         var foreignIdentifier = association.foreignIdentifier
           , sourceKeys = Object.keys(association.source.primaryKeys)
@@ -486,7 +488,100 @@ module.exports = (function() {
           return newInstance;
         });
 
-        return new HasManyDoubleLinked(association, this).injectSetter([], newInstances, additionalAttributes);
+        var self = this
+          , foreignIdentifier = association.foreignIdentifier
+          , sourceKeys = Object.keys(association.source.primaryKeys)
+          , targetKeys = Object.keys(association.target.primaryKeys)
+          , obsoleteAssociations = []
+          , changedAssociations = []
+          , defaultAttributes = additionalAttributes || {}
+          , options = defaultAttributes
+          , promises = []
+          , oldAssociations = []
+          , unassociatedObjects;
+
+        defaultAttributes = Utils._.omit(defaultAttributes, ['transaction', 'hooks', 'individualHooks', 'ignoreDuplicates', 'validate', 'fields']); // Don't try to insert the transaction as an attribute in the through table
+
+        unassociatedObjects = newInstances.filter(function(obj) {
+          return !Utils._.find(oldAssociations, function(old) {
+            return (!!obj[foreignIdentifier] ? obj[foreignIdentifier] === old[foreignIdentifier] : (!!obj[targetKeys[0]] ? obj[targetKeys[0]] === old[targetKeys[0]] : obj.id === old.id));
+          });
+        });
+
+        oldAssociations.forEach(function(old) {
+          var newObj = Utils._.find(newInstances, function(obj) {
+            return (!!obj[foreignIdentifier] ? obj[foreignIdentifier] === old[foreignIdentifier] : (!!obj[targetKeys[0]] ? obj[targetKeys[0]] === old[targetKeys[0]] : obj.id === old.id));
+          });
+
+          if (!newObj) {
+            obsoleteAssociations.push(old);
+          } else if (Object(association.through.model) === association.through.model) {
+            var throughAttributes = newObj[association.through.model.name];
+            // Quick-fix for subtle bug when using existing objects that might have the through model attached (not as an attribute object)
+            if (throughAttributes instanceof association.through.model.Instance) {
+              throughAttributes = {};
+            }
+
+            var changedAssociation = {
+              where: {},
+              attributes: Utils._.defaults({}, throughAttributes, defaultAttributes)
+            };
+
+            changedAssociation.where[association.identifier] = instance[sourceKeys[0]] || instance.id;
+            changedAssociation.where[foreignIdentifier] = newObj[targetKeys[0]] || newObj.id;
+
+            if (Object.keys(changedAssociation.attributes).length) {
+              changedAssociations.push(changedAssociation);
+            }
+          }
+        });
+
+        if (obsoleteAssociations.length > 0) {
+          var foreignIds = obsoleteAssociations.map(function(associatedObject) {
+            return ((targetKeys.length === 1) ? associatedObject[targetKeys[0]] : associatedObject.id);
+          });
+
+          var where = {};
+          where[association.identifier] = ((sourceKeys.length === 1) ? instance[sourceKeys[0]] : instance.id);
+          where[association.foreignIdentifier] = foreignIds;
+
+          promises.push(association.through.model.destroy(Utils._.extend(options, {
+            where: where
+          })));
+        }
+
+        if (unassociatedObjects.length > 0) {
+          var bulk = unassociatedObjects.map(function(unassociatedObject) {
+            var attributes = {};
+
+            attributes[association.identifier] = ((sourceKeys.length === 1) ? instance[sourceKeys[0]] : instance.id);
+            attributes[association.foreignIdentifier] = ((targetKeys.length === 1) ? unassociatedObject[targetKeys[0]] : unassociatedObject.id);
+
+            if (Object(association.through.model) === association.through.model) {
+              attributes = Utils._.defaults(attributes, unassociatedObject[association.through.model.name], defaultAttributes);
+            }
+
+            if (association.through.scope) {
+              Object.keys(association.through.scope).forEach(function (attribute) {
+                attributes[attribute] = association.through.scope[attribute];
+              });
+            }
+
+            return attributes;
+          }.bind(this));
+
+          promises.push(association.through.model.bulkCreate(bulk, options));
+        }
+
+        if (changedAssociations.length > 0) {
+          changedAssociations.forEach(function(assoc) {
+            promises.push(association.through.model.update(assoc.attributes, Utils._.extend(options, {
+              where: assoc.where
+            })));
+          });
+        }
+
+        return Utils.Promise.all(promises);
       } else {
         if (!(newInstance instanceof association.target.Instance)) {
           var tmpInstance = {};
@@ -501,10 +596,40 @@ module.exports = (function() {
         }, {
           transaction: (additionalAttributes || {}).transaction
         }).then(function(currentAssociatedObjects) {
-          if (currentAssociatedObjects.length === 0 || Object(association.through.model) === association.through.model) {
-            return new HasManyDoubleLinked(association, instance).injectAdder(newInstance, additionalAttributes, !!currentAssociatedObjects.length);
+          additionalAttributes = additionalAttributes || {};
+
+          var attributes = {}
+            , foreignIdentifier = association.foreignIdentifier
+            , options = additionalAttributes;
+
+          var sourceKeys = Object.keys(association.source.primaryKeys);
+          var targetKeys = Object.keys(association.target.primaryKeys);
+
+          additionalAttributes = Utils._.omit(additionalAttributes, ['transaction', 'hooks', 'individualHooks', 'ignoreDuplicates', 'validate', 'fields']); // Don't try to insert the transaction as an attribute in the through table
+
+          attributes[association.identifier] = ((sourceKeys.length === 1) ? instance[sourceKeys[0]] : instance.id);
+          attributes[foreignIdentifier] = ((targetKeys.length === 1) ? newInstance[targetKeys[0]] : newInstance.id);
+
+          if (!!currentAssociatedObjects.length) {
+            var where = attributes;
+            attributes = Utils._.defaults({}, newInstance[association.through.model.name], additionalAttributes);
+
+            if (Object.keys(attributes).length) {
+              return association.through.model.update(attributes, Utils._.extend(options, {
+                where: where
+              }));
+            } else {
+              return Utils.Promise.resolve();
+            }
           } else {
-            return Utils.Promise.resolve(currentAssociatedObjects[0]);
+            attributes = Utils._.defaults(attributes, newInstance[association.through.model.name], additionalAttributes);
+            if (association.through.scope) {
+              Object.keys(association.through.scope).forEach(function (attribute) {
+                attributes[attribute] = association.through.scope[attribute];
+              });
+            }
+
+            return association.through.model.create(attributes, options);
           }
         });
       }

test/associations/has-many.test.js

@@ -1498,7 +1498,7 @@ describe(Support.getTestDialectTeaser("HasMany"), function() {
         Beacons.hasMany(Users);
         Users.hasMany(Beacons);
 
-        return this.sequelize.sync({force: true, logging: true});
+        return this.sequelize.sync({force: true});
       });
 
       it('uses the specified joinTableName or a reasonable default', function() {