Refactor some more tests to use promises and fix some bugs

test/integration/dialects/mysql/connector-manager.test.js

@@ -21,7 +21,7 @@ if (Support.dialectIsMySQL()) {
             spy();
             spy();
 
 
             setTimeout(function() {
             setTimeout(function() {
-              User.count().on('success', function(count) {
+              User.count().then(function(count) {
                 expect(count).to.equal(1);
                 expect(count).to.equal(1);
                 spy();
                 spy();
                 if (spy.calledTwice) {
                 if (spy.calledTwice) {

test/integration/dialects/mysql/dao-factory.test.js

@@ -11,81 +11,71 @@ chai.config.includeStack = true;
 if (Support.dialectIsMySQL()) {
 if (Support.dialectIsMySQL()) {
   describe('[MYSQL Specific] DAOFactory', function() {
   describe('[MYSQL Specific] DAOFactory', function() {
     describe('constructor', function() {
     describe('constructor', function() {
-      it('handles extended attributes (unique)', function(done) {
+      it('handles extended attributes (unique)', function() {
         var User = this.sequelize.define('User' + config.rand(), {
         var User = this.sequelize.define('User' + config.rand(), {
           username: { type: DataTypes.STRING, unique: true }
           username: { type: DataTypes.STRING, unique: true }
         }, { timestamps: false });
         }, { timestamps: false });
 
 
         expect(this.sequelize.getQueryInterface().QueryGenerator.attributesToSQL(User.attributes)).to.deep.equal({username: 'VARCHAR(255) UNIQUE', id: 'INTEGER NOT NULL auto_increment PRIMARY KEY'});
         expect(this.sequelize.getQueryInterface().QueryGenerator.attributesToSQL(User.attributes)).to.deep.equal({username: 'VARCHAR(255) UNIQUE', id: 'INTEGER NOT NULL auto_increment PRIMARY KEY'});
-        done();
       });
       });
 
 
-      it('handles extended attributes (default)', function(done) {
+      it('handles extended attributes (default)', function() {
         var User = this.sequelize.define('User' + config.rand(), {
         var User = this.sequelize.define('User' + config.rand(), {
           username: {type: DataTypes.STRING, defaultValue: 'foo'}
           username: {type: DataTypes.STRING, defaultValue: 'foo'}
         }, { timestamps: false });
         }, { timestamps: false });
         expect(this.sequelize.getQueryInterface().QueryGenerator.attributesToSQL(User.attributes)).to.deep.equal({username: "VARCHAR(255) DEFAULT 'foo'", id: 'INTEGER NOT NULL auto_increment PRIMARY KEY'});
         expect(this.sequelize.getQueryInterface().QueryGenerator.attributesToSQL(User.attributes)).to.deep.equal({username: "VARCHAR(255) DEFAULT 'foo'", id: 'INTEGER NOT NULL auto_increment PRIMARY KEY'});
-        done();
       });
       });
 
 
-      it('handles extended attributes (null)', function(done) {
+      it('handles extended attributes (null)', function() {
         var User = this.sequelize.define('User' + config.rand(), {
         var User = this.sequelize.define('User' + config.rand(), {
           username: {type: DataTypes.STRING, allowNull: false}
           username: {type: DataTypes.STRING, allowNull: false}
         }, { timestamps: false });
         }, { timestamps: false });
         expect(this.sequelize.getQueryInterface().QueryGenerator.attributesToSQL(User.attributes)).to.deep.equal({username: 'VARCHAR(255) NOT NULL', id: 'INTEGER NOT NULL auto_increment PRIMARY KEY'});
         expect(this.sequelize.getQueryInterface().QueryGenerator.attributesToSQL(User.attributes)).to.deep.equal({username: 'VARCHAR(255) NOT NULL', id: 'INTEGER NOT NULL auto_increment PRIMARY KEY'});
-        done();
       });
       });
 
 
-      it('handles extended attributes (primaryKey)', function(done) {
+      it('handles extended attributes (primaryKey)', function() {
         var User = this.sequelize.define('User' + config.rand(), {
         var User = this.sequelize.define('User' + config.rand(), {
           username: {type: DataTypes.STRING, primaryKey: true}
           username: {type: DataTypes.STRING, primaryKey: true}
         }, { timestamps: false });
         }, { timestamps: false });
         expect(this.sequelize.getQueryInterface().QueryGenerator.attributesToSQL(User.attributes)).to.deep.equal({username: 'VARCHAR(255) PRIMARY KEY'});
         expect(this.sequelize.getQueryInterface().QueryGenerator.attributesToSQL(User.attributes)).to.deep.equal({username: 'VARCHAR(255) PRIMARY KEY'});
-        done();
       });
       });
 
 
-      it('adds timestamps', function(done) {
+      it('adds timestamps', function() {
         var User1 = this.sequelize.define('User' + config.rand(), {});
         var User1 = this.sequelize.define('User' + config.rand(), {});
         var User2 = this.sequelize.define('User' + config.rand(), {}, { timestamps: true });
         var User2 = this.sequelize.define('User' + config.rand(), {}, { timestamps: true });
 
 
         expect(this.sequelize.getQueryInterface().QueryGenerator.attributesToSQL(User1.attributes)).to.deep.equal({id: 'INTEGER NOT NULL auto_increment PRIMARY KEY', updatedAt: 'DATETIME NOT NULL', createdAt: 'DATETIME NOT NULL'});
         expect(this.sequelize.getQueryInterface().QueryGenerator.attributesToSQL(User1.attributes)).to.deep.equal({id: 'INTEGER NOT NULL auto_increment PRIMARY KEY', updatedAt: 'DATETIME NOT NULL', createdAt: 'DATETIME NOT NULL'});
         expect(this.sequelize.getQueryInterface().QueryGenerator.attributesToSQL(User2.attributes)).to.deep.equal({id: 'INTEGER NOT NULL auto_increment PRIMARY KEY', updatedAt: 'DATETIME NOT NULL', createdAt: 'DATETIME NOT NULL'});
         expect(this.sequelize.getQueryInterface().QueryGenerator.attributesToSQL(User2.attributes)).to.deep.equal({id: 'INTEGER NOT NULL auto_increment PRIMARY KEY', updatedAt: 'DATETIME NOT NULL', createdAt: 'DATETIME NOT NULL'});
-        done();
       });
       });
 
 
-      it('adds deletedAt if paranoid', function(done) {
+      it('adds deletedAt if paranoid', function() {
         var User = this.sequelize.define('User' + config.rand(), {}, { paranoid: true });
         var User = this.sequelize.define('User' + config.rand(), {}, { paranoid: true });
         expect(this.sequelize.getQueryInterface().QueryGenerator.attributesToSQL(User.attributes)).to.deep.equal({id: 'INTEGER NOT NULL auto_increment PRIMARY KEY', deletedAt: 'DATETIME', updatedAt: 'DATETIME NOT NULL', createdAt: 'DATETIME NOT NULL'});
         expect(this.sequelize.getQueryInterface().QueryGenerator.attributesToSQL(User.attributes)).to.deep.equal({id: 'INTEGER NOT NULL auto_increment PRIMARY KEY', deletedAt: 'DATETIME', updatedAt: 'DATETIME NOT NULL', createdAt: 'DATETIME NOT NULL'});
-        done();
       });
       });
 
 
-      it('underscores timestamps if underscored', function(done) {
+      it('underscores timestamps if underscored', function() {
         var User = this.sequelize.define('User' + config.rand(), {}, { paranoid: true, underscored: true });
         var User = this.sequelize.define('User' + config.rand(), {}, { paranoid: true, underscored: true });
         expect(this.sequelize.getQueryInterface().QueryGenerator.attributesToSQL(User.attributes)).to.deep.equal({id: 'INTEGER NOT NULL auto_increment PRIMARY KEY', deleted_at: 'DATETIME', updated_at: 'DATETIME NOT NULL', created_at: 'DATETIME NOT NULL'});
         expect(this.sequelize.getQueryInterface().QueryGenerator.attributesToSQL(User.attributes)).to.deep.equal({id: 'INTEGER NOT NULL auto_increment PRIMARY KEY', deleted_at: 'DATETIME', updated_at: 'DATETIME NOT NULL', created_at: 'DATETIME NOT NULL'});
-        done();
       });
       });
 
 
-      it('omits text fields with defaultValues', function(done) {
+      it('omits text fields with defaultValues', function() {
         var User = this.sequelize.define('User' + config.rand(), {name: {type: DataTypes.TEXT, defaultValue: 'helloworld'}});
         var User = this.sequelize.define('User' + config.rand(), {name: {type: DataTypes.TEXT, defaultValue: 'helloworld'}});
         expect(User.attributes.name.type.toString()).to.equal('TEXT');
         expect(User.attributes.name.type.toString()).to.equal('TEXT');
-        done();
       });
       });
 
 
-      it('omits blobs fields with defaultValues', function(done) {
+      it('omits blobs fields with defaultValues', function() {
         var User = this.sequelize.define('User' + config.rand(), {name: {type: DataTypes.STRING.BINARY, defaultValue: 'helloworld'}});
         var User = this.sequelize.define('User' + config.rand(), {name: {type: DataTypes.STRING.BINARY, defaultValue: 'helloworld'}});
         expect(User.attributes.name.type.toString()).to.equal('VARCHAR(255) BINARY');
         expect(User.attributes.name.type.toString()).to.equal('VARCHAR(255) BINARY');
-        done();
       });
       });
     });
     });
 
 
     describe('primaryKeys', function() {
     describe('primaryKeys', function() {
-      it('determines the correct primaryKeys', function(done) {
+      it('determines the correct primaryKeys', function() {
         var User = this.sequelize.define('User' + config.rand(), {
         var User = this.sequelize.define('User' + config.rand(), {
           foo: {type: DataTypes.STRING, primaryKey: true},
           foo: {type: DataTypes.STRING, primaryKey: true},
           bar: DataTypes.STRING
           bar: DataTypes.STRING
         });
         });
         expect(this.sequelize.getQueryInterface().QueryGenerator.attributesToSQL(User.primaryKeys)).to.deep.equal({'foo': 'VARCHAR(255) PRIMARY KEY'});
         expect(this.sequelize.getQueryInterface().QueryGenerator.attributesToSQL(User.primaryKeys)).to.deep.equal({'foo': 'VARCHAR(255) PRIMARY KEY'});
-        done();
       });
       });
     });
     });
   });
   });

test/integration/dialects/postgres/associations.test.js

@@ -56,7 +56,7 @@ if (dialect.match(/^postgres/)) {
 
 
     describe('HasMany', function() {
     describe('HasMany', function() {
       describe('addDAO / getDAO', function() {
       describe('addDAO / getDAO', function() {
-        beforeEach(function(done) {
+        beforeEach(function() {
           var self = this;
           var self = this;
 
 
           //prevent periods from occurring in the table name since they are used to delimit (table.column)
           //prevent periods from occurring in the table name since they are used to delimit (table.column)
@@ -79,14 +79,13 @@ if (dialect.match(/^postgres/)) {
             tasks[tasks.length] = {name: 'Task' + Math.random()};
             tasks[tasks.length] = {name: 'Task' + Math.random()};
           }
           }
 
 
-          this.sequelize.sync({ force: true }).success(function() {
-            self.User.bulkCreate(users).success(function() {
-              self.Task.bulkCreate(tasks).success(function() {
-                self.User.all().success(function(_users) {
-                  self.Task.all().success(function(_tasks) {
+          return this.sequelize.sync({ force: true }).then(function() {
+            return self.User.bulkCreate(users).then(function() {
+              return self.Task.bulkCreate(tasks).then(function() {
+                return self.User.findAll().then(function(_users) {
+                  return self.Task.findAll().then(function(_tasks) {
                     self.user = _users[0];
                     self.user = _users[0];
                     self.task = _tasks[0];
                     self.task = _tasks[0];
-                    done();
                   });
                   });
                 });
                 });
               });
               });
@@ -94,15 +93,14 @@ if (dialect.match(/^postgres/)) {
           });
           });
         });
         });
 
 
-        it('should correctly add an association to the dao', function(done) {
+        it('should correctly add an association to the dao', function() {
           var self = this;
           var self = this;
 
 
-          self.user.getTasks().on('success', function(_tasks) {
+          return self.user.getTasks().then(function(_tasks) {
             expect(_tasks).to.have.length(0);
             expect(_tasks).to.have.length(0);
-            self.user.addTask(self.task).on('success', function() {
-              self.user.getTasks().on('success', function(_tasks) {
+            return self.user.addTask(self.task).then(function() {
+              return self.user.getTasks().then(function(_tasks) {
                 expect(_tasks).to.have.length(1);
                 expect(_tasks).to.have.length(1);
-                done();
               });
               });
             });
             });
           });
           });
@@ -110,7 +108,7 @@ if (dialect.match(/^postgres/)) {
       });
       });
 
 
       describe('removeDAO', function() {
       describe('removeDAO', function() {
-        it('should correctly remove associated objects', function(done) {
+        it('should correctly remove associated objects', function() {
           var self = this
           var self = this
             , users = []
             , users = []
             , tasks = [];
             , tasks = [];
@@ -132,30 +130,29 @@ if (dialect.match(/^postgres/)) {
             tasks[tasks.length] = {id: x + 1, name: 'Task' + Math.random()};
             tasks[tasks.length] = {id: x + 1, name: 'Task' + Math.random()};
           }
           }
 
 
-          this.sequelize.sync({ force: true }).success(function() {
-            self.User.bulkCreate(users).done(function(err) {
+          return this.sequelize.sync({ force: true }).then(function() {
+            return self.User.bulkCreate(users).finally(function(err) {
               expect(err).not.to.be.ok;
               expect(err).not.to.be.ok;
-              self.Task.bulkCreate(tasks).done(function(err) {
+              return self.Task.bulkCreate(tasks).finally(function(err) {
                 expect(err).not.to.be.ok;
                 expect(err).not.to.be.ok;
-                self.User.all().success(function(_users) {
-                  self.Task.all().success(function(_tasks) {
+                return self.User.findAll().then(function(_users) {
+                  return self.Task.findAll().then(function(_tasks) {
                     self.user = _users[0];
                     self.user = _users[0];
                     self.task = _tasks[0];
                     self.task = _tasks[0];
                     self.users = _users;
                     self.users = _users;
                     self.tasks = _tasks;
                     self.tasks = _tasks;
 
 
-                    self.user.getTasks().on('success', function(__tasks) {
+                    return self.user.getTasks().then(function(__tasks) {
                       expect(__tasks).to.have.length(0);
                       expect(__tasks).to.have.length(0);
-                      self.user.setTasks(self.tasks).on('success', function() {
-                        self.user.getTasks().on('success', function(_tasks) {
+                      return self.user.setTasks(self.tasks).then(function() {
+                        return self.user.getTasks().then(function(_tasks) {
                           expect(_tasks).to.have.length(self.tasks.length);
                           expect(_tasks).to.have.length(self.tasks.length);
-                          self.user.removeTask(self.tasks[0]).on('success', function() {
-                            self.user.getTasks().on('success', function(_tasks) {
+                          return self.user.removeTask(self.tasks[0]).then(function() {
+                            return self.user.getTasks().then(function(_tasks) {
                               expect(_tasks).to.have.length(self.tasks.length - 1);
                               expect(_tasks).to.have.length(self.tasks.length - 1);
-                              self.user.removeTasks([self.tasks[1], self.tasks[2]]).on('success', function() {
-                                self.user.getTasks().on('success', function(_tasks) {
+                              return self.user.removeTasks([self.tasks[1], self.tasks[2]]).then(function() {
+                                return self.user.getTasks().then(function(_tasks) {
                                   expect(_tasks).to.have.length(self.tasks.length - 3);
                                   expect(_tasks).to.have.length(self.tasks.length - 3);
-                                  done();
                                 });
                                 });
                               });
                               });
                             });
                             });

test/integration/instance/update.test.js

@@ -61,7 +61,7 @@ describe(Support.getTestDialectTeaser('Instance'), function() {
 
 
     if (current.dialect.supports.transactions) {
     if (current.dialect.supports.transactions) {
       it('supports transactions', function() {
       it('supports transactions', function() {
-        Support.prepareTransactionTest(this.sequelize, function(sequelize) {
+        return Support.prepareTransactionTest(this.sequelize).bind({}).then(function(sequelize) {
           var User = sequelize.define('User', { username: Support.Sequelize.STRING });
           var User = sequelize.define('User', { username: Support.Sequelize.STRING });
 
 
           return User.sync({ force: true }).then(function() {
           return User.sync({ force: true }).then(function() {
@@ -351,7 +351,7 @@ describe(Support.getTestDialectTeaser('Instance'), function() {
       });
       });
 
 
       return User.sync({ force: true }).then(function() {
       return User.sync({ force: true }).then(function() {
-        User.create({
+        return User.create({
           name: 'snafu',
           name: 'snafu',
           identifier: 'identifier'
           identifier: 'identifier'
         }).then(function(user) {
         }).then(function(user) {
@@ -359,7 +359,7 @@ describe(Support.getTestDialectTeaser('Instance'), function() {
             , oldUpdatedAt = user.updatedAt
             , oldUpdatedAt = user.updatedAt
             , oldIdentifier = user.identifier;
             , oldIdentifier = user.identifier;
 
 
-          setTimeout(function() {
+          return Promise.delay(1000).then(function() {
             return user.update({
             return user.update({
               name: 'foobar',
               name: 'foobar',
               createdAt: new Date(2000, 1, 1),
               createdAt: new Date(2000, 1, 1),
@@ -369,7 +369,7 @@ describe(Support.getTestDialectTeaser('Instance'), function() {
               expect(new Date(user.updatedAt)).to.not.equalTime(new Date(oldUpdatedAt));
               expect(new Date(user.updatedAt)).to.not.equalTime(new Date(oldUpdatedAt));
               expect(user.identifier).to.equal(oldIdentifier);
               expect(user.identifier).to.equal(oldIdentifier);
             });
             });
-          }, 1000);
+          });
         });
         });
       });
       });
     });
     });