Merge pull request #626 from kevinbeaty/emitpromise

Promises/A Support

lib/emitters/custom-event-emitter.js

 var util           = require("util")
 var util           = require("util")
   , EventEmitter   = require("events").EventEmitter
   , EventEmitter   = require("events").EventEmitter
+  , Promise        = require("promise")
   , proxyEventKeys = ['success', 'error', 'sql']
   , proxyEventKeys = ['success', 'error', 'sql']
 
 
 
 
@@ -61,6 +62,17 @@ module.exports = (function() {
     }.bind(this))
     }.bind(this))
   }
   }
 
 
+  CustomEventEmitter.prototype.then =
+  function (onFulfilled, onRejected) {
+    var self = this
+    onFulfilled = bindToProcess(onFulfilled)
+    onRejected = bindToProcess(onRejected)
+    return new Promise(function (resolve, reject) {
+      self.on('error', reject)
+          .on('success', resolve);
+    }).then(onFulfilled, onRejected)
+  }
+
 
 
   return CustomEventEmitter;
   return CustomEventEmitter;
 })()
 })()

package.json

@@ -38,7 +38,7 @@
     "dottie": "0.0.6-1",
     "dottie": "0.0.6-1",
     "toposort-class": "0.1.4",
     "toposort-class": "0.1.4",
     "generic-pool": "2.0.3",
     "generic-pool": "2.0.3",
-    "dottie": "0.0.6-1"
+    "promise": "~3.0.0"
   },
   },
   "devDependencies": {
   "devDependencies": {
     "jasmine-node": "1.5.0",
     "jasmine-node": "1.5.0",

spec/promise.spec.js

+if (typeof require === 'function') {
+  const buster  = require("buster")
+      , Helpers = require('./buster-helpers')
+      , dialect = Helpers.getTestDialect()
+      , _ = require('lodash')
+}
+
+buster.spec.expose()
+
+describe(Helpers.getTestDialectTeaser("Promise"), function () {
+  before(function (done) {
+    var self = this
+
+    Helpers.initTests({
+      dialect: dialect,
+      beforeComplete: function (sequelize, DataTypes) {
+        self.sequelize = sequelize
+        self.User      = sequelize.define('User', {
+          username:  { type: DataTypes.STRING },
+          touchedAt: { type: DataTypes.DATE, defaultValue: DataTypes.NOW },
+          aNumber:   { type: DataTypes.INTEGER },
+          bNumber:   { type: DataTypes.INTEGER },
+
+          validateTest: {
+            type: DataTypes.INTEGER,
+            allowNull: true,
+            validate: {isInt: true}
+          },
+          validateCustom: {
+            type: DataTypes.STRING,
+            allowNull: true,
+            validate: {len: {msg: 'Length failed.', args: [1, 20]}}
+          },
+
+          dateAllowNullTrue: {
+            type: DataTypes.DATE,
+            allowNull: true
+          }
+        })
+
+        self.HistoryLog = sequelize.define('HistoryLog', {
+          someText:  { type: DataTypes.STRING },
+          aNumber:   { type: DataTypes.INTEGER },
+          aRandomId: { type: DataTypes.INTEGER }
+        })
+
+        self.ParanoidUser = sequelize.define('ParanoidUser', {
+          username: { type: DataTypes.STRING }
+        }, {
+          paranoid: true
+        })
+
+        self.ParanoidUser.hasOne(self.ParanoidUser)
+      },
+      onComplete: function () {
+        self.User.sync({ force: true }).then(function () {
+            return self.HistoryLog.sync({ force: true })
+          }).then(function () {
+            return self.ParanoidUser.sync({force: true })
+          })
+          .then(function () {done()}, done)
+      }
+    })
+  })
+
+  describe('increment', function () {
+    before(function (done) {
+      this.User.create({ id: 1, aNumber: 0, bNumber: 0 }).done(done)
+    });
+
+    it('with array', function (done) {
+      var self = this;
+
+      // Select something
+      this.User.find(1).then(function (user1) {
+        return user1.increment(['aNumber'], 2)
+      }).then(function (user2) {
+        return self.User.find(1)
+      }).then(function (user3) {
+        expect(user3.aNumber).toBe(2);
+        done();
+      }, done);
+    });
+
+    it('should still work right with other concurrent updates', function (done) {
+      var self = this;
+      // Select something
+      this.User.find(1).then(function (user1) {
+        // Select the user again (simulating a concurrent query)
+        return self.User.find(1).then(function (user2) {
+          return user2.updateAttributes({
+            aNumber: user2.aNumber + 1
+          }).then(function (user3) {
+            return user1.increment(['aNumber'], 2)
+          }).then(function (user4) {
+            return self.User.find(1)
+          }).then(function (user5) {
+            expect(user5.aNumber).toBe(3);
+            done();
+          }, done)
+        });
+      });
+    });
+
+    it('with key value pair', function (done) {
+      var self = this;
+
+      // Select something
+      this.User.find(1).then(function (user1) {
+        return user1.increment({ 'aNumber': 1, 'bNumber': 2})
+      }).then(function () {
+        return self.User.find(1)
+      }).then(function (user3) {
+        expect(user3.aNumber).toBe(1);
+        expect(user3.bNumber).toBe(2);
+        done();
+      }, done);
+    });
+  });
+
+  describe('decrement', function () {
+    before(function (done) {
+      this.User.create({ id: 1, aNumber: 0, bNumber: 0 }).done(done)
+    });
+
+    it('with array', function (done) {
+      var self = this;
+
+      // Select something
+      this.User.find(1).then(function (user1) {
+        return user1.decrement(['aNumber'], 2)
+      }).then(function () {
+        return self.User.find(1);
+      }).then(function (user3) {
+        expect(user3.aNumber).toBe(-2);
+        done();
+      }, done);
+    });
+
+    it('with single field', function (done) {
+      var self = this;
+
+      // Select something
+      this.User.find(1).then(function (user1) {
+        return user1.decrement(['aNumber'], 2)
+      }).then(function () {
+        return self.User.find(1);
+      }).then(function (user3) {
+        expect(user3.aNumber).toBe(-2);
+        done();
+      }, done);
+    });
+
+    it('should still work right with other concurrent decrements', function (done) {
+      var self = this;
+      // Select something
+      this.User.find(1).then(function (user1) {
+        var _done = _.after(3, function () {
+          self.User.find(1).then(function (user2) {
+            expect(user2.aNumber).toEqual(-6);
+            done();
+          })
+        });
+
+        user1.decrement(['aNumber'], 2).done(_done);
+        user1.decrement(['aNumber'], 2).done(_done);
+        user1.decrement(['aNumber'], 2).done(_done);
+      });
+    });
+  });
+
+  describe('reload', function () {
+    it("should return a reference to the same DAO instead of creating a new one", function (done) {
+      this.User.create({ username: 'John Doe' }).then(function (originalUser) {
+
+        return originalUser.updateAttributes({ username: 'Doe John' }).then(function () {
+          return originalUser.reload()
+        }).then(function (updatedUser) {
+          expect(originalUser === updatedUser).toBeTrue()
+          done();
+        }, done)
+      })
+    })
+
+    it("should update the values on all references to the DAO", function (done) {
+      var self = this
+
+      this.User.create({ username: 'John Doe' }).then(function (originalUser) {
+        return self.User.find(originalUser.id).then(function (updater) {
+          return updater.updateAttributes({ username: 'Doe John' })
+        }).then(function () {
+          // We used a different reference when calling updateAttributes, so originalUser is now out of sync
+          expect(originalUser.username).toEqual('John Doe')
+          return originalUser.reload()
+        }).then(function (updatedUser) {
+          expect(originalUser.username).toEqual('Doe John')
+          expect(updatedUser.username).toEqual('Doe John')
+
+          done();
+        }, done)
+      })
+    })
+
+
+    it("should update the associations as well", function (done) {
+      var Book = this.sequelize.define('Book', { title:   Helpers.Sequelize.STRING })
+        , Page = this.sequelize.define('Page', { content: Helpers.Sequelize.TEXT })
+
+      Book.hasMany(Page)
+      Page.belongsTo(Book)
+
+      this.sequelize.sync({ force: true }).then(function () {
+        return Book.create({ title: 'A very old book' })
+      }).then(function (book) {
+        return Page.create({ content: 'om nom nom' }).then(function (page) {
+          return book.setPages([ page ]).then(function () {
+            return Book.find({
+              where: (dialect === 'postgres' ? '"Books"."id"=' : '`Books`.`id`=') + book.id,
+              include: [Page]
+            }).then(function (leBook) {
+              return page.updateAttributes({ content: 'something totally different' }).then(function (page) {
+                expect(leBook.pages[0].content).toEqual('om nom nom')
+                expect(page.content).toEqual('something totally different')
+
+                return leBook.reload().then(function (leBook) {
+                  expect(leBook.pages[0].content).toEqual('something totally different')
+                  expect(page.content).toEqual('something totally different')
+
+                  done()
+                })
+              })
+            })
+          })
+        })
+      }, done)
+    })
+  });
+
+  describe('complete', function () {
+    it("gets triggered if an error occurs", function (done) {
+      this.User.find({ where: "asdasdasd" }).then(null, function (err) {
+        expect(err).toBeDefined()
+        expect(err.message).toBeDefined()
+        done()
+      })
+    })
+
+    it("gets triggered if everything was ok", function (done) {
+      this.User.count().then(function (result) {
+        expect(result).toBeDefined()
+        done()
+      })
+    })
+  })
+
+  describe('save', function () {
+    it('should fail a validation upon creating', function (done) {
+      this.User.create({aNumber: 0, validateTest: 'hello'}).then(null, function (err) {
+        expect(err).toBeDefined()
+        expect(err).toBeObject()
+        expect(err.validateTest).toBeArray()
+        expect(err.validateTest[0]).toBeDefined()
+        expect(err.validateTest[0].indexOf('Invalid integer')).toBeGreaterThan(-1);
+        done();
+      });
+    })
+
+    it('should fail a validation upon building', function (done) {
+      this.User.build({aNumber: 0, validateCustom: 'aaaaaaaaaaaaaaaaaaaaaaaaaa'}).save()
+      .then(null, function (err) {
+        expect(err).toBeDefined()
+        expect(err).toBeObject()
+        expect(err.validateCustom).toBeDefined()
+        expect(err.validateCustom).toBeArray()
+        expect(err.validateCustom[0]).toBeDefined()
+        expect(err.validateCustom[0]).toEqual('Length failed.')
+        done()
+      })
+    })
+
+    it('should fail a validation when updating', function (done) {
+      this.User.create({aNumber: 0}).then(function (user) {
+        return user.updateAttributes({validateTest: 'hello'})
+      }).then(null, function (err) {
+        expect(err).toBeDefined()
+        expect(err).toBeObject()
+        expect(err.validateTest).toBeDefined()
+        expect(err.validateTest).toBeArray()
+        expect(err.validateTest[0]).toBeDefined()
+        expect(err.validateTest[0].indexOf('Invalid integer:')).toBeGreaterThan(-1)
+        done()
+      })
+    })
+  })
+})