Merge branch 'feature/add-association-transaction-support' into feature/create-relation-objects

Conflicts:
	test/associations/has-many.test.js

lib/associations/has-many-double-linked.js

@@ -21,7 +21,7 @@ module.exports = (function() {
         , options = _options || {}
         , queryOptions = {}
         , targetAssociation = self.association.targetAssociation
-        
+
       //fully qualify
       var instancePrimaryKeys = Object.keys(self.instance.daoFactory.primaryKeys)
         , instancePrimaryKey = instancePrimaryKeys.length > 0 ? instancePrimaryKeys[0] : 'id'
@@ -187,11 +187,17 @@ module.exports = (function() {
   HasManyDoubleLinked.prototype.injectAdder = function(emitterProxy, newAssociation, additionalAttributes, exists) {
     var attributes          = {}
       , targetAssociation   = this.association.targetAssociation
-      , foreignIdentifier   = targetAssociation.isSelfAssociation ? targetAssociation.foreignIdentifier : targetAssociation.identifier;
+      , foreignIdentifier   = targetAssociation.isSelfAssociation ? targetAssociation.foreignIdentifier : targetAssociation.identifier
+      , options = {}
 
     var sourceKeys = Object.keys(this.association.source.primaryKeys);
     var targetKeys = Object.keys(this.association.target.primaryKeys);
 
+    if ((additionalAttributes || {}).transaction instanceof Transaction) {
+      options.transaction = additionalAttributes.transaction
+      delete additionalAttributes.transaction
+    }
+
     attributes[this.association.identifier] = ((sourceKeys.length === 1) ? this.instance[sourceKeys[0]] : this.instance.id)
     attributes[foreignIdentifier] = ((targetKeys.length === 1) ? newAssociation[targetKeys[0]] : newAssociation.id)
 
@@ -207,7 +213,7 @@ module.exports = (function() {
     } else {
       attributes = Utils._.defaults(attributes, newAssociation[targetAssociation.through.name], additionalAttributes)
 
-      this.association.through.create(attributes)
+      this.association.through.create(attributes, options)
         .success(function() { emitterProxy.emit('success', newAssociation) })
         .error(function(err) { emitterProxy.emit('error', err) })
         .on('sql', function(sql) { emitterProxy.emit('sql', sql) })

lib/associations/has-many-single-linked.js

@@ -108,13 +108,19 @@ module.exports = (function() {
       .on('sql', function(sql) { emitter.emit('sql', sql) })
   }
 
-  HasManySingleLinked.prototype.injectAdder = function(emitterProxy, newAssociation) {
+  HasManySingleLinked.prototype.injectAdder = function(emitterProxy, newAssociation, additionalAttributes) {
     var primaryKeys = Object.keys(this.instance.daoFactory.primaryKeys)
       , primaryKey = primaryKeys.length === 1 ? primaryKeys[0] : 'id'
+      , options = {}
+
+    if ((additionalAttributes || {}).transaction instanceof Transaction) {
+      options.transaction = additionalAttributes.transaction
+      delete additionalAttributes.transaction
+    }
 
     newAssociation[this.__factory.identifier] = this.instance[primaryKey]
 
-    newAssociation.save()
+    newAssociation.save(options)
       .success(function() { emitterProxy.emit('success', newAssociation) })
       .error(function(err) { emitterProxy.emit('error', err) })
       .on('sql', function(sql) { emitterProxy.emit('sql', sql) })

test/associations/has-many.test.js

@@ -265,6 +265,40 @@ describe(Support.getTestDialectTeaser("HasMany"), function() {
       })
     })
 
+    describe('addAssociations', function() {
+      it('supports transactions', function(done) {
+        Support.prepareTransactionTest(this.sequelize, function(sequelize) {
+          var Article = sequelize.define('Article', { 'title': DataTypes.STRING })
+            , Label   = sequelize.define('Label', { 'text': DataTypes.STRING })
+
+          Article.hasMany(Label)
+
+          sequelize.sync({ force: true }).success(function() {
+            Article.create({ title: 'foo' }).success(function(article) {
+              Label.create({ text: 'bar' }).success(function(label) {
+                sequelize.transaction(function(t) {
+                  article.addLabel(label, { transaction: t }).success(function() {
+                    Label
+                      .findAll({ where: { ArticleId: article.id }, transaction: undefined })
+                      .success(function(labels) {
+                        expect(labels.length).to.equal(0)
+
+                        Label
+                          .findAll({ where: { ArticleId: article.id }, transaction: t })
+                          .success(function(labels) {
+                            expect(labels.length).to.equal(1)
+                            t.rollback().success(function() { done() })
+                          })
+                      })
+                  })
+                })
+              })
+            })
+          })
+        })
+      })
+    })
+
     it("clears associations when passing null to the set-method with omitNull set to true", function(done) {
       this.sequelize.options.omitNull = true
 
@@ -669,6 +703,40 @@ describe(Support.getTestDialectTeaser("HasMany"), function() {
       })
     })
 
+    describe('addAssociations', function() {
+      it('supports transactions', function(done) {
+        var self = this
+
+        Support.prepareTransactionTest(this.sequelize, function(sequelize) {
+          var User = self.sequelize.define('User', { username: DataTypes.STRING })
+            , Task = self.sequelize.define('Task', { title: DataTypes.STRING })
+
+          User.hasMany(Task)
+          Task.hasMany(User)
+
+          User.sync({ force: true }).success(function() {
+            Task.sync({ force: true }).success(function() {
+              User.create({ username: 'foo' }).success(function(user) {
+                Task.create({ title: 'task' }).success(function(task) {
+                  self.sequelize.transaction(function(t){
+                    task.addUser(user, { transaction: t }).success(function() {
+                      task.hasUser(user).success(function(hasUser) {
+                        expect(hasUser).to.be.false
+                        task.hasUser(user, { transaction: t }).success(function(hasUser) {
+                          expect(hasUser).to.be.true
+                          t.rollback().success(function() { done() })
+                        })
+                      })
+                    })
+                  })
+                })
+              })
+            })
+          })
+        })
+      })
+    })
+
     describe('optimizations using bulk create, destroy and update', function () {
       beforeEach(function (done) {
         var self = this