test(integration/dialects): asyncify (#12239)

test/integration/dialects/abstract/connection-manager.test.js

@@ -55,7 +55,7 @@ describe(Support.getTestDialectTeaser('Connection Manager'), () => {
     expect(connectionManager.pool.write).to.be.instanceOf(Pool);
     expect(connectionManager.pool.write).to.be.instanceOf(Pool);
   });
   });
 
 
-  it('should round robin calls to the read pool', () => {
+  it('should round robin calls to the read pool', async () => {
     if (Support.getTestDialect() === 'sqlite') {
     if (Support.getTestDialect() === 'sqlite') {
       return;
       return;
     }
     }
@@ -91,21 +91,19 @@ describe(Support.getTestDialectTeaser('Connection Manager'), () => {
 
 
     const _getConnection = connectionManager.getConnection.bind(connectionManager, queryOptions);
     const _getConnection = connectionManager.getConnection.bind(connectionManager, queryOptions);
 
 
-    return _getConnection()
-      .then(_getConnection)
-      .then(_getConnection)
-      .then(() => {
-        chai.expect(connectStub.callCount).to.equal(4);
-
-        // First call is the get connection for DB versions - ignore
-        const calls = connectStub.getCalls();
-        chai.expect(calls[1].args[0].host).to.eql('slave1');
-        chai.expect(calls[2].args[0].host).to.eql('slave2');
-        chai.expect(calls[3].args[0].host).to.eql('slave1');
-      });
+    await _getConnection();
+    await _getConnection();
+    await _getConnection();
+    chai.expect(connectStub.callCount).to.equal(4);
+
+    // First call is the get connection for DB versions - ignore
+    const calls = connectStub.getCalls();
+    chai.expect(calls[1].args[0].host).to.eql('slave1');
+    chai.expect(calls[2].args[0].host).to.eql('slave2');
+    chai.expect(calls[3].args[0].host).to.eql('slave1');
   });
   });
 
 
-  it('should trigger deprecation for non supported engine version', () => {
+  it('should trigger deprecation for non supported engine version', async () => {
     const deprecationStub = sandbox.stub(deprecations, 'unsupportedEngine');
     const deprecationStub = sandbox.stub(deprecations, 'unsupportedEngine');
     const sequelize = Support.createSequelizeInstance();
     const sequelize = Support.createSequelizeInstance();
     const connectionManager = new ConnectionManager(sequelize.dialect, sequelize);
     const connectionManager = new ConnectionManager(sequelize.dialect, sequelize);
@@ -126,14 +124,12 @@ describe(Support.getTestDialectTeaser('Connection Manager'), () => {
       useMaster: true
       useMaster: true
     };
     };
 
 
-    return connectionManager.getConnection(queryOptions)
-      .then(() => {
-        chai.expect(deprecationStub).to.have.been.calledOnce;
-      });
+    await connectionManager.getConnection(queryOptions);
+    chai.expect(deprecationStub).to.have.been.calledOnce;
   });
   });
 
 
 
 
-  it('should allow forced reads from the write pool', () => {
+  it('should allow forced reads from the write pool', async () => {
     const master = { ...poolEntry };
     const master = { ...poolEntry };
     master.host = 'the-boss';
     master.host = 'the-boss';
 
 
@@ -161,15 +157,13 @@ describe(Support.getTestDialectTeaser('Connection Manager'), () => {
       useMaster: true
       useMaster: true
     };
     };
 
 
-    return connectionManager.getConnection(queryOptions)
-      .then(() => {
-        chai.expect(connectStub).to.have.been.calledTwice; // Once to get DB version, and once to actually get the connection.
-        const calls = connectStub.getCalls();
-        chai.expect(calls[1].args[0].host).to.eql('the-boss');
-      });
+    await connectionManager.getConnection(queryOptions);
+    chai.expect(connectStub).to.have.been.calledTwice; // Once to get DB version, and once to actually get the connection.
+    const calls = connectStub.getCalls();
+    chai.expect(calls[1].args[0].host).to.eql('the-boss');
   });
   });
 
 
-  it('should clear the pool after draining it', () => {
+  it('should clear the pool after draining it', async () => {
     const options = {
     const options = {
       replication: null
       replication: null
     };
     };
@@ -181,9 +175,8 @@ describe(Support.getTestDialectTeaser('Connection Manager'), () => {
     const poolDrainSpy = sandbox.spy(connectionManager.pool, 'drain');
     const poolDrainSpy = sandbox.spy(connectionManager.pool, 'drain');
     const poolClearSpy = sandbox.spy(connectionManager.pool, 'destroyAllNow');
     const poolClearSpy = sandbox.spy(connectionManager.pool, 'destroyAllNow');
 
 
-    return connectionManager.close().then(() => {
-      expect(poolDrainSpy.calledOnce).to.be.true;
-      expect(poolClearSpy.calledOnce).to.be.true;
-    });
+    await connectionManager.close();
+    expect(poolDrainSpy.calledOnce).to.be.true;
+    expect(poolClearSpy.calledOnce).to.be.true;
   });
   });
 });
 });

test/integration/dialects/mariadb/associations.test.js

@@ -11,33 +11,30 @@ if (dialect !== 'mariadb') return;
 describe('[MariaDB Specific] Associations', () => {
 describe('[MariaDB Specific] Associations', () => {
   describe('many-to-many', () => {
   describe('many-to-many', () => {
     describe('where tables have the same prefix', () => {
     describe('where tables have the same prefix', () => {
-      it('should create a table wp_table1wp_table2s', function() {
+      it('should create a table wp_table1wp_table2s', async function() {
         const Table2 = this.sequelize.define('wp_table2', { foo: DataTypes.STRING }),
         const Table2 = this.sequelize.define('wp_table2', { foo: DataTypes.STRING }),
           Table1 = this.sequelize.define('wp_table1',
           Table1 = this.sequelize.define('wp_table1',
             { foo: DataTypes.STRING });
             { foo: DataTypes.STRING });
 
 
         Table1.belongsToMany(Table2, { through: 'wp_table1swp_table2s' });
         Table1.belongsToMany(Table2, { through: 'wp_table1swp_table2s' });
         Table2.belongsToMany(Table1, { through: 'wp_table1swp_table2s' });
         Table2.belongsToMany(Table1, { through: 'wp_table1swp_table2s' });
-        return Table1.sync({ force: true }).then(() => {
-          return Table2.sync({ force: true }).then(() => {
-            expect(this.sequelize.modelManager.getModel(
-              'wp_table1swp_table2s')).to.exist;
-          });
-        });
+        await Table1.sync({ force: true });
+        await Table2.sync({ force: true });
+        expect(this.sequelize.modelManager.getModel(
+          'wp_table1swp_table2s')).to.exist;
       });
       });
     });
     });
 
 
     describe('when join table name is specified', () => {
     describe('when join table name is specified', () => {
-      beforeEach(function() {
+      beforeEach(async function() {
         const Table2 = this.sequelize.define('ms_table1', { foo: DataTypes.STRING }),
         const Table2 = this.sequelize.define('ms_table1', { foo: DataTypes.STRING }),
           Table1 = this.sequelize.define('ms_table2',
           Table1 = this.sequelize.define('ms_table2',
             { foo: DataTypes.STRING });
             { foo: DataTypes.STRING });
 
 
         Table1.belongsToMany(Table2, { through: 'table1_to_table2' });
         Table1.belongsToMany(Table2, { through: 'table1_to_table2' });
         Table2.belongsToMany(Table1, { through: 'table1_to_table2' });
         Table2.belongsToMany(Table1, { through: 'table1_to_table2' });
-        return Table1.sync({ force: true }).then(() => {
-          return Table2.sync({ force: true });
-        });
+        await Table1.sync({ force: true });
+        await Table2.sync({ force: true });
       });
       });
 
 
       it('should not use only a specified name', function() {
       it('should not use only a specified name', function() {
@@ -50,7 +47,7 @@ describe('[MariaDB Specific] Associations', () => {
   });
   });
 
 
   describe('HasMany', () => {
   describe('HasMany', () => {
-    beforeEach(function() {
+    beforeEach(async function() {
       //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)
       this.User = this.sequelize.define(`User${Math.ceil(Math.random() * 10000000)}`, { name: DataTypes.STRING });
       this.User = this.sequelize.define(`User${Math.ceil(Math.random() * 10000000)}`, { name: DataTypes.STRING });
       this.Task = this.sequelize.define(`Task${Math.ceil(Math.random() * 10000000)}`, { name: DataTypes.STRING });
       this.Task = this.sequelize.define(`Task${Math.ceil(Math.random() * 10000000)}`, { name: DataTypes.STRING });
@@ -68,10 +65,9 @@ describe('[MariaDB Specific] Associations', () => {
         tasks[i] = { name: `Task${Math.random()}` };
         tasks[i] = { name: `Task${Math.random()}` };
       }
       }
 
 
-      return this.sequelize.sync({ force: true })
-        .then(() => this.User.bulkCreate(users))
-        .then(() => this.Task.bulkCreate(tasks));
-
+      await this.sequelize.sync({ force: true });
+      await this.User.bulkCreate(users);
+      await this.Task.bulkCreate(tasks);
     });
     });
 
 
   });
   });

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

@@ -13,17 +13,15 @@ if (dialect !== 'mariadb') {
 
 
 describe('[MARIADB Specific] Connection Manager', () => {
 describe('[MARIADB Specific] Connection Manager', () => {
 
 
-  it('has existing init SQL', () => {
+  it('has existing init SQL', async () => {
     const sequelize = Support.createSequelizeInstance(
     const sequelize = Support.createSequelizeInstance(
       { dialectOptions: { initSql: 'SET @myUserVariable=\'myValue\'' } });
       { dialectOptions: { initSql: 'SET @myUserVariable=\'myValue\'' } });
-    return sequelize.query('SELECT @myUserVariable')
-      .then(res => {
-        expect(res[0]).to.deep.equal([{ '@myUserVariable': 'myValue' }]);
-        sequelize.close();
-      });
+    const res = await sequelize.query('SELECT @myUserVariable');
+    expect(res[0]).to.deep.equal([{ '@myUserVariable': 'myValue' }]);
+    sequelize.close();
   });
   });
 
 
-  it('has existing init SQL array', () => {
+  it('has existing init SQL array', async () => {
     const sequelize = Support.createSequelizeInstance(
     const sequelize = Support.createSequelizeInstance(
       {
       {
         dialectOptions: {
         dialectOptions: {
@@ -31,12 +29,10 @@ describe('[MARIADB Specific] Connection Manager', () => {
             'SET @myUserVariable2=\'myValue\'']
             'SET @myUserVariable2=\'myValue\'']
         }
         }
       });
       });
-    return sequelize.query('SELECT @myUserVariable1, @myUserVariable2')
-      .then(res => {
-        expect(res[0]).to.deep.equal(
-          [{ '@myUserVariable1': 'myValue', '@myUserVariable2': 'myValue' }]);
-        sequelize.close();
-      });
+    const res = await sequelize.query('SELECT @myUserVariable1, @myUserVariable2');
+    expect(res[0]).to.deep.equal(
+      [{ '@myUserVariable1': 'myValue', '@myUserVariable2': 'myValue' }]);
+    sequelize.close();
   });
   });
 
 
 
 
@@ -44,29 +40,29 @@ describe('[MARIADB Specific] Connection Manager', () => {
   describe('Errors', () => {
   describe('Errors', () => {
     const testHost = env.MARIADB_PORT_3306_TCP_ADDR || env.SEQ_MARIADB_HOST || env.SEQ_HOST || '127.0.0.1';
     const testHost = env.MARIADB_PORT_3306_TCP_ADDR || env.SEQ_MARIADB_HOST || env.SEQ_HOST || '127.0.0.1';
 
 
-    it('Connection timeout', () => {
+    it('Connection timeout', async () => {
       const sequelize = Support.createSequelizeInstance({ host: testHost, port: 65535, dialectOptions: { connectTimeout: 500 } });
       const sequelize = Support.createSequelizeInstance({ host: testHost, port: 65535, dialectOptions: { connectTimeout: 500 } });
-      return expect(sequelize.connectionManager.getConnection()).to.have.been.rejectedWith(Sequelize.SequelizeConnectionError);
+      await expect(sequelize.connectionManager.getConnection()).to.have.been.rejectedWith(Sequelize.SequelizeConnectionError);
     });
     });
 
 
-    it('ECONNREFUSED', () => {
+    it('ECONNREFUSED', async () => {
       const sequelize = Support.createSequelizeInstance({ host: testHost, port: 65535 });
       const sequelize = Support.createSequelizeInstance({ host: testHost, port: 65535 });
-      return expect(sequelize.connectionManager.getConnection()).to.have.been.rejectedWith(Sequelize.ConnectionRefusedError);
+      await expect(sequelize.connectionManager.getConnection()).to.have.been.rejectedWith(Sequelize.ConnectionRefusedError);
     });
     });
 
 
-    it('ENOTFOUND', () => {
+    it('ENOTFOUND', async () => {
       const sequelize = Support.createSequelizeInstance({ host: 'http://wowow.example.com' });
       const sequelize = Support.createSequelizeInstance({ host: 'http://wowow.example.com' });
-      return expect(sequelize.connectionManager.getConnection()).to.have.been.rejectedWith(Sequelize.HostNotFoundError);
+      await expect(sequelize.connectionManager.getConnection()).to.have.been.rejectedWith(Sequelize.HostNotFoundError);
     });
     });
 
 
-    it('EHOSTUNREACH', () => {
+    it('EHOSTUNREACH', async () => {
       const sequelize = Support.createSequelizeInstance({ host: '255.255.255.255' });
       const sequelize = Support.createSequelizeInstance({ host: '255.255.255.255' });
-      return expect(sequelize.connectionManager.getConnection()).to.have.been.rejectedWith(Sequelize.HostNotReachableError);
+      await expect(sequelize.connectionManager.getConnection()).to.have.been.rejectedWith(Sequelize.HostNotReachableError);
     });
     });
 
 
-    it('ER_ACCESS_DENIED_ERROR | ELOGIN', () => {
+    it('ER_ACCESS_DENIED_ERROR | ELOGIN', async () => {
       const sequelize = new Support.Sequelize('localhost', 'was', 'ddsd', Support.sequelize.options);
       const sequelize = new Support.Sequelize('localhost', 'was', 'ddsd', Support.sequelize.options);
-      return expect(sequelize.connectionManager.getConnection()).to.have.been.rejectedWith(Sequelize.AccessDeniedError);
+      await expect(sequelize.connectionManager.getConnection()).to.have.been.rejectedWith(Sequelize.AccessDeniedError);
     });
     });
   });
   });
 
 

test/integration/dialects/mariadb/dao.test.js

@@ -8,14 +8,14 @@ const chai = require('chai'),
 
 
 if (dialect !== 'mariadb') return;
 if (dialect !== 'mariadb') return;
 describe('[MariaDB Specific] DAO', () => {
 describe('[MariaDB Specific] DAO', () => {
-  beforeEach(function() {
+  beforeEach(async function() {
     this.sequelize.options.quoteIdentifiers = true;
     this.sequelize.options.quoteIdentifiers = true;
     this.User = this.sequelize.define('User', {
     this.User = this.sequelize.define('User', {
       username: DataTypes.STRING,
       username: DataTypes.STRING,
       email: DataTypes.STRING,
       email: DataTypes.STRING,
       location: DataTypes.GEOMETRY()
       location: DataTypes.GEOMETRY()
     });
     });
-    return this.User.sync({ force: true });
+    await this.User.sync({ force: true });
   });
   });
 
 
   afterEach(function() {
   afterEach(function() {
@@ -24,112 +24,99 @@ describe('[MariaDB Specific] DAO', () => {
 
 
   describe('integers', () => {
   describe('integers', () => {
     describe('integer', () => {
     describe('integer', () => {
-      beforeEach(function() {
+      beforeEach(async function() {
         this.User = this.sequelize.define('User', {
         this.User = this.sequelize.define('User', {
           aNumber: DataTypes.INTEGER
           aNumber: DataTypes.INTEGER
         });
         });
 
 
-        return this.User.sync({ force: true });
+        await this.User.sync({ force: true });
       });
       });
 
 
-      it('positive', function() {
+      it('positive', async function() {
         const User = this.User;
         const User = this.User;
 
 
-        return User.create({ aNumber: 2147483647 }).then(user => {
-          expect(user.aNumber).to.equal(2147483647);
-          return User.findOne({ where: { aNumber: 2147483647 } }).then(_user => {
-            expect(_user.aNumber).to.equal(2147483647);
-          });
-        });
+        const user = await User.create({ aNumber: 2147483647 });
+        expect(user.aNumber).to.equal(2147483647);
+        const _user = await User.findOne({ where: { aNumber: 2147483647 } });
+        expect(_user.aNumber).to.equal(2147483647);
       });
       });
 
 
-      it('negative', function() {
+      it('negative', async function() {
         const User = this.User;
         const User = this.User;
 
 
-        return User.create({ aNumber: -2147483647 }).then(user => {
-          expect(user.aNumber).to.equal(-2147483647);
-          return User.findOne({ where: { aNumber: -2147483647 } }).then(_user => {
-            expect(_user.aNumber).to.equal(-2147483647);
-          });
-        });
+        const user = await User.create({ aNumber: -2147483647 });
+        expect(user.aNumber).to.equal(-2147483647);
+        const _user = await User.findOne({ where: { aNumber: -2147483647 } });
+        expect(_user.aNumber).to.equal(-2147483647);
       });
       });
     });
     });
 
 
     describe('bigint', () => {
     describe('bigint', () => {
-      beforeEach(function() {
+      beforeEach(async function() {
         this.User = this.sequelize.define('User', {
         this.User = this.sequelize.define('User', {
           aNumber: DataTypes.BIGINT
           aNumber: DataTypes.BIGINT
         });
         });
 
 
-        return this.User.sync({ force: true });
+        await this.User.sync({ force: true });
       });
       });
 
 
-      it('positive', function() {
+      it('positive', async function() {
         const User = this.User;
         const User = this.User;
 
 
-        return User.create({ aNumber: '9223372036854775807' }).then(user => {
-          expect(user.aNumber).to.equal('9223372036854775807');
-          return User.findOne({ where: { aNumber: '9223372036854775807' } }).then(
-            _user => {
-              return expect(_user.aNumber.toString()).to.equal(
-                '9223372036854775807');
-            });
-        });
+        const user = await User.create({ aNumber: '9223372036854775807' });
+        expect(user.aNumber).to.equal('9223372036854775807');
+        const _user = await User.findOne({ where: { aNumber: '9223372036854775807' } });
+
+        await expect(_user.aNumber.toString()).to.equal('9223372036854775807');
       });
       });
 
 
-      it('negative', function() {
+      it('negative', async function() {
         const User = this.User;
         const User = this.User;
 
 
-        return User.create({ aNumber: '-9223372036854775807' }).then(user => {
-          expect(user.aNumber).to.equal('-9223372036854775807');
-          return User.findOne(
-            { where: { aNumber: '-9223372036854775807' } }).then(_user => {
-            return expect(_user.aNumber.toString()).to.equal(
-              '-9223372036854775807');
-          });
-        });
+        const user = await User.create({ aNumber: '-9223372036854775807' });
+        expect(user.aNumber).to.equal('-9223372036854775807');
+
+        const _user = await User.findOne(
+          { where: { aNumber: '-9223372036854775807' } });
+
+        await expect(_user.aNumber.toString()).to.equal('-9223372036854775807');
       });
       });
     });
     });
   });
   });
 
 
-  it('should save geometry correctly', function() {
+  it('should save geometry correctly', async function() {
     const point = { type: 'Point', coordinates: [39.807222, -76.984722] };
     const point = { type: 'Point', coordinates: [39.807222, -76.984722] };
-    return this.User.create(
-      { username: 'user', email: 'foo@bar.com', location: point }).then(
-      newUser => {
-        expect(newUser.location).to.deep.eql(point);
-      });
+
+    const newUser = await this.User.create(
+      { username: 'user', email: 'foo@bar.com', location: point });
+
+    expect(newUser.location).to.deep.eql(point);
   });
   });
 
 
-  it('should update geometry correctly', function() {
+  it('should update geometry correctly', async function() {
     const User = this.User;
     const User = this.User;
     const point1 = { type: 'Point', coordinates: [39.807222, -76.984722] };
     const point1 = { type: 'Point', coordinates: [39.807222, -76.984722] };
     const point2 = { type: 'Point', coordinates: [39.828333, -77.232222] };
     const point2 = { type: 'Point', coordinates: [39.828333, -77.232222] };
-    return User.create(
-      { username: 'user', email: 'foo@bar.com', location: point1 })
-      .then(oldUser => {
-        return User.update({ location: point2 },
-          { where: { username: oldUser.username } })
-          .then(() => {
-            return User.findOne({ where: { username: oldUser.username } });
-          })
-          .then(updatedUser => {
-            expect(updatedUser.location).to.deep.eql(point2);
-          });
-      });
+
+    const oldUser = await User.create(
+      { username: 'user', email: 'foo@bar.com', location: point1 });
+
+    await User.update({ location: point2 },
+      { where: { username: oldUser.username } });
+
+    const updatedUser = await User.findOne({ where: { username: oldUser.username } });
+    expect(updatedUser.location).to.deep.eql(point2);
   });
   });
 
 
-  it('should read geometry correctly', function() {
+  it('should read geometry correctly', async function() {
     const User = this.User;
     const User = this.User;
     const point = { type: 'Point', coordinates: [39.807222, -76.984722] };
     const point = { type: 'Point', coordinates: [39.807222, -76.984722] };
 
 
-    return User.create(
-      { username: 'user', email: 'foo@bar.com', location: point }).then(
-      user => {
-        return User.findOne({ where: { username: user.username } });
-      }).then(user => {
-      expect(user.location).to.deep.eql(point);
-    });
+    const user0 = await User.create(
+      { username: 'user', email: 'foo@bar.com', location: point });
+
+    const user = await User.findOne({ where: { username: user0.username } });
+    expect(user.location).to.deep.eql(point);
   });
   });
 
 
 });
 });

test/integration/dialects/mariadb/errors.test.js

@@ -9,12 +9,16 @@ const chai = require('chai'),
 if (dialect !== 'mariadb') return;
 if (dialect !== 'mariadb') return;
 describe('[MariaDB Specific] Errors', () => {
 describe('[MariaDB Specific] Errors', () => {
 
 
-  const validateError = (promise, errClass, errValues) => {
+  const validateError = async (promise, errClass, errValues) => {
     const wanted = { ...errValues };
     const wanted = { ...errValues };
 
 
-    return expect(promise).to.have.been.rejectedWith(errClass).then(() =>
-      promise.catch(err => Object.keys(wanted).forEach(
-        k => expect(err[k]).to.eql(wanted[k]))));
+    await expect(promise).to.have.been.rejectedWith(errClass);
+
+    try {
+      return await promise;
+    } catch (err) {
+      return Object.keys(wanted).forEach(k => expect(err[k]).to.eql(wanted[k]));
+    }
   };
   };
 
 
   describe('ForeignKeyConstraintError', () => {
   describe('ForeignKeyConstraintError', () => {
@@ -33,50 +37,51 @@ describe('[MariaDB Specific] Errors', () => {
         { foreignKey: 'primaryUserId', as: 'primaryUsers' });
         { foreignKey: 'primaryUserId', as: 'primaryUsers' });
     });
     });
 
 
-    it('in context of DELETE restriction', function() {
+    it('in context of DELETE restriction', async function() {
       const ForeignKeyConstraintError = this.sequelize.ForeignKeyConstraintError;
       const ForeignKeyConstraintError = this.sequelize.ForeignKeyConstraintError;
-      const ctx = {};
-      return this.sequelize.sync({ force: true }).then(() => {
-        return Promise.all([
-          this.User.create({ id: 67, username: 'foo' }),
-          this.Task.create({ id: 52, title: 'task' })
-        ]);
-      }).then(([user1, task1]) => {
-        ctx.user1 = user1;
-        ctx.task1 = task1;
-        return user1.setTasks([task1]);
-      }).then(() => {
-        return Promise.all([
-          validateError(ctx.user1.destroy(), ForeignKeyConstraintError, {
-            fields: ['userId'],
-            table: 'users',
-            value: undefined,
-            index: 'tasksusers_ibfk_1',
-            reltype: 'parent'
-          }),
-          validateError(ctx.task1.destroy(), ForeignKeyConstraintError, {
-            fields: ['taskId'],
-            table: 'tasks',
-            value: undefined,
-            index: 'tasksusers_ibfk_2',
-            reltype: 'parent'
-          })
-        ]);
-      });
+      await this.sequelize.sync({ force: true });
+
+      const [user1, task1] = await Promise.all([
+        this.User.create({ id: 67, username: 'foo' }),
+        this.Task.create({ id: 52, title: 'task' })
+      ]);
+
+      await user1.setTasks([task1]);
+
+      await Promise.all([
+        validateError(user1.destroy(), ForeignKeyConstraintError, {
+          fields: ['userId'],
+          table: 'users',
+          value: undefined,
+          index: 'tasksusers_ibfk_1',
+          reltype: 'parent'
+        }),
+        validateError(task1.destroy(), ForeignKeyConstraintError, {
+          fields: ['taskId'],
+          table: 'tasks',
+          value: undefined,
+          index: 'tasksusers_ibfk_2',
+          reltype: 'parent'
+        })
+      ]);
     });
     });
 
 
-    it('in context of missing relation', function() {
+    it('in context of missing relation', async function() {
       const ForeignKeyConstraintError = this.sequelize.ForeignKeyConstraintError;
       const ForeignKeyConstraintError = this.sequelize.ForeignKeyConstraintError;
 
 
-      return this.sequelize.sync({ force: true }).then(() =>
-        validateError(this.Task.create({ title: 'task', primaryUserId: 5 }),
-          ForeignKeyConstraintError, {
-            fields: ['primaryUserId'],
-            table: 'users',
-            value: 5,
-            index: 'tasks_ibfk_1',
-            reltype: 'child'
-          }));
+      await this.sequelize.sync({ force: true });
+
+      await validateError(
+        this.Task.create({ title: 'task', primaryUserId: 5 }),
+        ForeignKeyConstraintError,
+        {
+          fields: ['primaryUserId'],
+          table: 'users',
+          value: 5,
+          index: 'tasks_ibfk_1',
+          reltype: 'child'
+        }
+      );
     });
     });
 
 
   });
   });

test/integration/dialects/mariadb/query-interface.test.js

@@ -9,19 +9,13 @@ if (dialect.match(/^mariadb/)) {
   describe('QueryInterface', () => {
   describe('QueryInterface', () => {
 
 
     describe('databases', () => {
     describe('databases', () => {
-      it('should create and drop database', function() {
-        return this.sequelize.query('SHOW DATABASES')
-          .then(res => {
-            const databaseNumber = res[0].length;
-            return this.sequelize.getQueryInterface().createDatabase('myDB')
-              .then(() => {
-                return this.sequelize.query('SHOW DATABASES');
-              })
-              .then(databases => {
-                expect(databases[0]).to.have.length(databaseNumber + 1);
-                return this.sequelize.getQueryInterface().dropDatabase('myDB');
-              });
-          });
+      it('should create and drop database', async function() {
+        const res = await this.sequelize.query('SHOW DATABASES');
+        const databaseNumber = res[0].length;
+        await this.sequelize.getQueryInterface().createDatabase('myDB');
+        const databases = await this.sequelize.query('SHOW DATABASES');
+        expect(databases[0]).to.have.length(databaseNumber + 1);
+        await this.sequelize.getQueryInterface().dropDatabase('myDB');
       });
       });
     });
     });
   });
   });

test/integration/dialects/mssql/connection-manager.test.js

@@ -9,24 +9,24 @@ const dialect = Support.getTestDialect();
 if (dialect.match(/^mssql/)) {
 if (dialect.match(/^mssql/)) {
   describe('[MSSQL Specific] Connection Manager', () => {
   describe('[MSSQL Specific] Connection Manager', () => {
     describe('Errors', () => {
     describe('Errors', () => {
-      it('ECONNREFUSED', () => {
+      it('ECONNREFUSED', async () => {
         const sequelize = Support.createSequelizeInstance({ host: '127.0.0.1', port: 34237 });
         const sequelize = Support.createSequelizeInstance({ host: '127.0.0.1', port: 34237 });
-        return expect(sequelize.connectionManager.getConnection()).to.have.been.rejectedWith(Sequelize.ConnectionRefusedError);
+        await expect(sequelize.connectionManager.getConnection()).to.have.been.rejectedWith(Sequelize.ConnectionRefusedError);
       });
       });
 
 
-      it('ENOTFOUND', () => {
+      it('ENOTFOUND', async () => {
         const sequelize = Support.createSequelizeInstance({ host: 'http://wowow.example.com' });
         const sequelize = Support.createSequelizeInstance({ host: 'http://wowow.example.com' });
-        return expect(sequelize.connectionManager.getConnection()).to.have.been.rejectedWith(Sequelize.HostNotFoundError);
+        await expect(sequelize.connectionManager.getConnection()).to.have.been.rejectedWith(Sequelize.HostNotFoundError);
       });
       });
 
 
-      it('EHOSTUNREACH', () => {
+      it('EHOSTUNREACH', async () => {
         const sequelize = Support.createSequelizeInstance({ host: '255.255.255.255' });
         const sequelize = Support.createSequelizeInstance({ host: '255.255.255.255' });
-        return expect(sequelize.connectionManager.getConnection()).to.have.been.rejectedWith(Sequelize.HostNotReachableError);
+        await expect(sequelize.connectionManager.getConnection()).to.have.been.rejectedWith(Sequelize.HostNotReachableError);
       });
       });
 
 
-      it('ER_ACCESS_DENIED_ERROR | ELOGIN', () => {
+      it('ER_ACCESS_DENIED_ERROR | ELOGIN', async () => {
         const sequelize = new Support.Sequelize('localhost', 'was', 'ddsd', Support.sequelize.options);
         const sequelize = new Support.Sequelize('localhost', 'was', 'ddsd', Support.sequelize.options);
-        return expect(sequelize.connectionManager.getConnection()).to.have.been.rejectedWith(Sequelize.AccessDeniedError);
+        await expect(sequelize.connectionManager.getConnection()).to.have.been.rejectedWith(Sequelize.AccessDeniedError);
       });
       });
     });
     });
   });
   });

test/integration/dialects/mssql/query-queue.test.js

@@ -11,20 +11,20 @@ const chai = require('chai'),
 
 
 if (dialect.match(/^mssql/)) {
 if (dialect.match(/^mssql/)) {
   describe('[MSSQL Specific] Query Queue', () => {
   describe('[MSSQL Specific] Query Queue', () => {
-    beforeEach(function() {
+    beforeEach(async function() {
       const User = this.User = this.sequelize.define('User', {
       const User = this.User = this.sequelize.define('User', {
         username: DataTypes.STRING
         username: DataTypes.STRING
       });
       });
 
 
-      return this.sequelize.sync({ force: true }).then(() => {
-        return User.create({ username: 'John' });
-      });
+      await this.sequelize.sync({ force: true });
+
+      await User.create({ username: 'John' });
     });
     });
 
 
-    it('should queue concurrent requests to a connection', function() {
+    it('should queue concurrent requests to a connection', async function() {
       const User = this.User;
       const User = this.User;
 
 
-      return expect(this.sequelize.transaction(t => {
+      await expect(this.sequelize.transaction(async t => {
         return Promise.all([
         return Promise.all([
           User.findOne({
           User.findOne({
             transaction: t
             transaction: t

test/integration/dialects/mssql/regressions.test.js

@@ -9,7 +9,7 @@ const chai = require('chai'),
 
 
 if (dialect.match(/^mssql/)) {
 if (dialect.match(/^mssql/)) {
   describe('[MSSQL Specific] Regressions', () => {
   describe('[MSSQL Specific] Regressions', () => {
-    it('does not duplicate columns in ORDER BY statement, #9008', function() {
+    it('does not duplicate columns in ORDER BY statement, #9008', async function() {
       const LoginLog = this.sequelize.define('LoginLog', {
       const LoginLog = this.sequelize.define('LoginLog', {
         ID: {
         ID: {
           field: 'id',
           field: 'id',
@@ -45,71 +45,67 @@ if (dialect.match(/^mssql/)) {
         foreignKey: 'UserID'
         foreignKey: 'UserID'
       });
       });
 
 
-      return this.sequelize.sync({ force: true })
-        .then(() => User.bulkCreate([
-          { UserName: 'Vayom' },
-          { UserName: 'Shaktimaan' },
-          { UserName: 'Nikita' },
-          { UserName: 'Aryamaan' }
-        ], { returning: true }))
-        .then(([vyom, shakti, nikita, arya]) => {
-          return Promise.all([
-            vyom.createLoginLog(),
-            shakti.createLoginLog(),
-            nikita.createLoginLog(),
-            arya.createLoginLog()
-          ]);
-        }).then(() => {
-          return LoginLog.findAll({
-            include: [
-              {
-                model: User,
-                where: {
-                  UserName: {
-                    [Op.like]: '%maan%'
-                  }
-                }
+      await this.sequelize.sync({ force: true });
+
+      const [vyom, shakti, nikita, arya] = await User.bulkCreate([
+        { UserName: 'Vayom' },
+        { UserName: 'Shaktimaan' },
+        { UserName: 'Nikita' },
+        { UserName: 'Aryamaan' }
+      ], { returning: true });
+
+      await Promise.all([
+        vyom.createLoginLog(),
+        shakti.createLoginLog(),
+        nikita.createLoginLog(),
+        arya.createLoginLog()
+      ]);
+
+      const logs = await LoginLog.findAll({
+        include: [
+          {
+            model: User,
+            where: {
+              UserName: {
+                [Op.like]: '%maan%'
               }
               }
-            ],
-            order: [[User, 'UserName', 'DESC']],
-            offset: 0,
-            limit: 10
-          });
-        }).then(logs => {
-          expect(logs).to.have.length(2);
-          expect(logs[0].User.get('UserName')).to.equal('Shaktimaan');
-          expect(logs[1].User.get('UserName')).to.equal('Aryamaan');
-        });
+            }
+          }
+        ],
+        order: [[User, 'UserName', 'DESC']],
+        offset: 0,
+        limit: 10
+      });
+
+      expect(logs).to.have.length(2);
+      expect(logs[0].User.get('UserName')).to.equal('Shaktimaan');
+      expect(logs[1].User.get('UserName')).to.equal('Aryamaan');
     });
     });
   });
   });
 
 
-  it('sets the varchar(max) length correctly on describeTable', function() {
+  it('sets the varchar(max) length correctly on describeTable', async function() {
     const Users = this.sequelize.define('_Users', {
     const Users = this.sequelize.define('_Users', {
       username: Sequelize.STRING('MAX')
       username: Sequelize.STRING('MAX')
     }, { freezeTableName: true });
     }, { freezeTableName: true });
 
 
-    return Users.sync({ force: true }).then(() => {
-      return this.sequelize.getQueryInterface().describeTable('_Users').then(metadata => {
-        const username = metadata.username;
-        expect(username.type).to.include('(MAX)');
-      });
-    });
+    await Users.sync({ force: true });
+    const metadata = await this.sequelize.getQueryInterface().describeTable('_Users');
+    const username = metadata.username;
+    expect(username.type).to.include('(MAX)');
   });
   });
 
 
-  it('sets the char(10) length correctly on describeTable', function() {
+  it('sets the char(10) length correctly on describeTable', async function() {
     const Users = this.sequelize.define('_Users', {
     const Users = this.sequelize.define('_Users', {
       username: Sequelize.CHAR(10)
       username: Sequelize.CHAR(10)
     }, { freezeTableName: true });
     }, { freezeTableName: true });
 
 
-    return Users.sync({ force: true }).then(() => {
-      return this.sequelize.getQueryInterface().describeTable('_Users').then(metadata => {
-        const username = metadata.username;
-        expect(username.type).to.include('(10)');
-      });
-    });
+    await Users.sync({ force: true });
+    const metadata = await this.sequelize.getQueryInterface().describeTable('_Users');
+    const username = metadata.username;
+    expect(username.type).to.include('(10)');
   });
   });
 
 
-  it('saves value bigger than 2147483647, #11245', function() {
+  it('saves value bigger than 2147483647, #11245', async function() {
     const BigIntTable =  this.sequelize.define('BigIntTable', {
     const BigIntTable =  this.sequelize.define('BigIntTable', {
       business_id: {
       business_id: {
         type: Sequelize.BIGINT,
         type: Sequelize.BIGINT,
@@ -121,19 +117,17 @@ if (dialect.match(/^mssql/)) {
 
 
     const bigIntValue = 2147483648;
     const bigIntValue = 2147483648;
 
 
-    return BigIntTable.sync({ force: true })
-      .then(() => {
-        return BigIntTable.create({
-          business_id: bigIntValue
-        });
-      })
-      .then(() => BigIntTable.findOne())
-      .then(record => {
-        expect(Number(record.business_id)).to.equals(bigIntValue);
-      });
+    await BigIntTable.sync({ force: true });
+
+    await BigIntTable.create({
+      business_id: bigIntValue
+    });
+
+    const record = await BigIntTable.findOne();
+    expect(Number(record.business_id)).to.equals(bigIntValue);
   });
   });
 
 
-  it('saves boolean is true, #12090', function() {
+  it('saves boolean is true, #12090', async function() {
     const BooleanTable =  this.sequelize.define('BooleanTable', {
     const BooleanTable =  this.sequelize.define('BooleanTable', {
       status: {
       status: {
         type: Sequelize.BOOLEAN,
         type: Sequelize.BOOLEAN,
@@ -145,15 +139,13 @@ if (dialect.match(/^mssql/)) {
 
 
     const value = true;
     const value = true;
 
 
-    return BooleanTable.sync({ force: true })
-      .then(() => {
-        return BooleanTable.create({
-          status: value
-        });
-      })
-      .then(() => BooleanTable.findOne())
-      .then(record => {
-        expect(record.status).to.equals(value);
-      });
+    await BooleanTable.sync({ force: true });
+
+    await BooleanTable.create({
+      status: value
+    });
+
+    const record = await BooleanTable.findOne();
+    expect(record.status).to.equals(value);
   });
   });
 }
 }

test/integration/dialects/mysql/associations.test.js

@@ -10,30 +10,27 @@ if (dialect === 'mysql') {
   describe('[MYSQL Specific] Associations', () => {
   describe('[MYSQL Specific] Associations', () => {
     describe('many-to-many', () => {
     describe('many-to-many', () => {
       describe('where tables have the same prefix', () => {
       describe('where tables have the same prefix', () => {
-        it('should create a table wp_table1wp_table2s', function() {
+        it('should create a table wp_table1wp_table2s', async function() {
           const Table2 = this.sequelize.define('wp_table2', { foo: DataTypes.STRING }),
           const Table2 = this.sequelize.define('wp_table2', { foo: DataTypes.STRING }),
             Table1 = this.sequelize.define('wp_table1', { foo: DataTypes.STRING });
             Table1 = this.sequelize.define('wp_table1', { foo: DataTypes.STRING });
 
 
           Table1.belongsToMany(Table2, { through: 'wp_table1swp_table2s' });
           Table1.belongsToMany(Table2, { through: 'wp_table1swp_table2s' });
           Table2.belongsToMany(Table1, { through: 'wp_table1swp_table2s' });
           Table2.belongsToMany(Table1, { through: 'wp_table1swp_table2s' });
-          return Table1.sync({ force: true }).then(() => {
-            return Table2.sync({ force: true }).then(() => {
-              expect(this.sequelize.modelManager.getModel('wp_table1swp_table2s')).to.exist;
-            });
-          });
+          await Table1.sync({ force: true });
+          await Table2.sync({ force: true });
+          expect(this.sequelize.modelManager.getModel('wp_table1swp_table2s')).to.exist;
         });
         });
       });
       });
 
 
       describe('when join table name is specified', () => {
       describe('when join table name is specified', () => {
-        beforeEach(function() {
+        beforeEach(async function() {
           const Table2 = this.sequelize.define('ms_table1', { foo: DataTypes.STRING }),
           const Table2 = this.sequelize.define('ms_table1', { foo: DataTypes.STRING }),
             Table1 = this.sequelize.define('ms_table2', { foo: DataTypes.STRING });
             Table1 = this.sequelize.define('ms_table2', { foo: DataTypes.STRING });
 
 
           Table1.belongsToMany(Table2, { through: 'table1_to_table2' });
           Table1.belongsToMany(Table2, { through: 'table1_to_table2' });
           Table2.belongsToMany(Table1, { through: 'table1_to_table2' });
           Table2.belongsToMany(Table1, { through: 'table1_to_table2' });
-          return Table1.sync({ force: true }).then(() => {
-            return Table2.sync({ force: true });
-          });
+          await Table1.sync({ force: true });
+          await Table2.sync({ force: true });
         });
         });
 
 
         it('should not use only a specified name', function() {
         it('should not use only a specified name', function() {
@@ -44,7 +41,7 @@ if (dialect === 'mysql') {
     });
     });
 
 
     describe('HasMany', () => {
     describe('HasMany', () => {
-      beforeEach(function() {
+      beforeEach(async function() {
         //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)
         this.User = this.sequelize.define(`User${Math.ceil(Math.random() * 10000000)}`, { name: DataTypes.STRING });
         this.User = this.sequelize.define(`User${Math.ceil(Math.random() * 10000000)}`, { name: DataTypes.STRING });
         this.Task = this.sequelize.define(`Task${Math.ceil(Math.random() * 10000000)}`, { name: DataTypes.STRING });
         this.Task = this.sequelize.define(`Task${Math.ceil(Math.random() * 10000000)}`, { name: DataTypes.STRING });
@@ -62,70 +59,48 @@ if (dialect === 'mysql') {
           tasks[i] = { name: `Task${Math.random()}` };
           tasks[i] = { name: `Task${Math.random()}` };
         }
         }
 
 
-        return this.sequelize.sync({ force: true }).then(() => {
-          return this.User.bulkCreate(users).then(() => {
-            return this.Task.bulkCreate(tasks);
-          });
-        });
+        await this.sequelize.sync({ force: true });
+        await this.User.bulkCreate(users);
+        await this.Task.bulkCreate(tasks);
       });
       });
 
 
       describe('addDAO / getModel', () => {
       describe('addDAO / getModel', () => {
-        beforeEach(function() {
+        beforeEach(async function() {
           this.user = null;
           this.user = null;
           this.task = null;
           this.task = null;
 
 
-          return this.User.findAll().then(_users => {
-            return this.Task.findAll().then(_tasks => {
-              this.user = _users[0];
-              this.task = _tasks[0];
-            });
-          });
+          const _users = await this.User.findAll();
+          const _tasks = await this.Task.findAll();
+          this.user = _users[0];
+          this.task = _tasks[0];
         });
         });
 
 
-        it('should correctly add an association to the dao', function() {
-          return this.user.getTasks().then(_tasks => {
-            expect(_tasks.length).to.equal(0);
-            return this.user.addTask(this.task).then(() => {
-              return this.user.getTasks().then(_tasks => {
-                expect(_tasks.length).to.equal(1);
-              });
-            });
-          });
+        it('should correctly add an association to the dao', async function() {
+          expect(await this.user.getTasks()).to.have.length(0);
+          await this.user.addTask(this.task);
+          expect(await this.user.getTasks()).to.have.length(1);
         });
         });
       });
       });
 
 
       describe('removeDAO', () => {
       describe('removeDAO', () => {
-        beforeEach(function() {
+        beforeEach(async function() {
           this.user = null;
           this.user = null;
           this.tasks = null;
           this.tasks = null;
 
 
-          return this.User.findAll().then(_users => {
-            return this.Task.findAll().then(_tasks => {
-              this.user = _users[0];
-              this.tasks = _tasks;
-            });
-          });
+          const _users = await this.User.findAll();
+          const _tasks = await this.Task.findAll();
+          this.user = _users[0];
+          this.tasks = _tasks;
         });
         });
 
 
-        it('should correctly remove associated objects', function() {
-          return this.user.getTasks().then(__tasks => {
-            expect(__tasks.length).to.equal(0);
-            return this.user.setTasks(this.tasks).then(() => {
-              return this.user.getTasks().then(_tasks => {
-                expect(_tasks.length).to.equal(this.tasks.length);
-                return this.user.removeTask(this.tasks[0]).then(() => {
-                  return this.user.getTasks().then(_tasks => {
-                    expect(_tasks.length).to.equal(this.tasks.length - 1);
-                    return this.user.removeTasks([this.tasks[1], this.tasks[2]]).then(() => {
-                      return this.user.getTasks().then(_tasks => {
-                        expect(_tasks).to.have.length(this.tasks.length - 3);
-                      });
-                    });
-                  });
-                });
-              });
-            });
-          });
+        it('should correctly remove associated objects', async function() {
+          expect(await this.user.getTasks()).to.have.length(0);
+          await this.user.setTasks(this.tasks);
+          expect(await this.user.getTasks()).to.have.length(this.tasks.length);
+          await this.user.removeTask(this.tasks[0]);
+          expect(await this.user.getTasks()).to.have.length(this.tasks.length - 1);
+          await this.user.removeTasks([this.tasks[1], this.tasks[2]]);
+          expect(await this.user.getTasks()).to.have.length(this.tasks.length - 3);
         });
         });
       });
       });
     });
     });

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

@@ -8,31 +8,32 @@ const DataTypes = require('../../../../lib/data-types');
 
 
 if (dialect === 'mysql') {
 if (dialect === 'mysql') {
   describe('[MYSQL Specific] Connection Manager', () => {
   describe('[MYSQL Specific] Connection Manager', () => {
-    it('-FOUND_ROWS can be suppressed to get back legacy behavior', () => {
+    it('-FOUND_ROWS can be suppressed to get back legacy behavior', async () => {
       const sequelize = Support.createSequelizeInstance({ dialectOptions: { flags: '' } });
       const sequelize = Support.createSequelizeInstance({ dialectOptions: { flags: '' } });
       const User = sequelize.define('User', { username: DataTypes.STRING });
       const User = sequelize.define('User', { username: DataTypes.STRING });
 
 
-      return User.sync({ force: true })
-        .then(() => User.create({ id: 1, username: 'jozef' }))
-        .then(() => User.update({ username: 'jozef' }, {
-          where: {
-            id: 1
-          }
-        }))
-        // https://github.com/sequelize/sequelize/issues/7184
-        .then(([affectedCount]) => affectedCount.should.equal(1));
+      await User.sync({ force: true });
+      await User.create({ id: 1, username: 'jozef' });
+
+      const [affectedCount] = await User.update({ username: 'jozef' }, {
+        where: {
+          id: 1
+        }
+      });
+
+      // https://github.com/sequelize/sequelize/issues/7184
+      await affectedCount.should.equal(1);
     });
     });
 
 
-    it('should acquire a valid connection when keepDefaultTimezone is true', () => {
+    it('should acquire a valid connection when keepDefaultTimezone is true', async () => {
       const sequelize = Support.createSequelizeInstance({ keepDefaultTimezone: true, pool: { min: 1, max: 1, handleDisconnects: true, idle: 5000 } });
       const sequelize = Support.createSequelizeInstance({ keepDefaultTimezone: true, pool: { min: 1, max: 1, handleDisconnects: true, idle: 5000 } });
       const cm = sequelize.connectionManager;
       const cm = sequelize.connectionManager;
-      return sequelize
-        .sync()
-        .then(() => cm.getConnection())
-        .then(connection => {
-          expect(cm.validate(connection)).to.be.ok;
-          return cm.releaseConnection(connection);
-        });
+
+      await sequelize.sync();
+
+      const connection = await cm.getConnection();
+      expect(cm.validate(connection)).to.be.ok;
+      await cm.releaseConnection(connection);
     });
     });
   });
   });
 }
 }

test/integration/dialects/mysql/errors.test.js

@@ -10,11 +10,16 @@ const DataTypes = require('../../../../lib/data-types');
 if (dialect === 'mysql') {
 if (dialect === 'mysql') {
   describe('[MYSQL Specific] Errors', () => {
   describe('[MYSQL Specific] Errors', () => {
 
 
-    const validateError = (promise, errClass, errValues) => {
+    const validateError = async (promise, errClass, errValues) => {
       const wanted = { ...errValues };
       const wanted = { ...errValues };
 
 
-      return expect(promise).to.have.been.rejectedWith(errClass).then(() =>
-        promise.catch(err => Object.keys(wanted).forEach(k => expect(err[k]).to.eql(wanted[k]))));
+      await expect(promise).to.have.been.rejectedWith(errClass);
+
+      try {
+        return await promise;
+      } catch (err) {
+        return Object.keys(wanted).forEach(k => expect(err[k]).to.eql(wanted[k]));
+      }
     };
     };
 
 
     describe('ForeignKeyConstraintError', () => {
     describe('ForeignKeyConstraintError', () => {
@@ -29,46 +34,48 @@ if (dialect === 'mysql') {
         this.Task.belongsTo(this.User, { foreignKey: 'primaryUserId', as: 'primaryUsers' });
         this.Task.belongsTo(this.User, { foreignKey: 'primaryUserId', as: 'primaryUsers' });
       });
       });
 
 
-      it('in context of DELETE restriction', function() {
-        const ctx = {};
-        return this.sequelize.sync({ force: true }).then(() => {
-          return Promise.all([
-            this.User.create({ id: 67, username: 'foo' }),
-            this.Task.create({ id: 52, title: 'task' })
-          ]);
-        }).then(([user1, task1]) => {
-          ctx.user1 = user1;
-          ctx.task1 = task1;
-          return user1.setTasks([task1]);
-        }).then(() => {
-          return Promise.all([
-            validateError(ctx.user1.destroy(), Sequelize.ForeignKeyConstraintError, {
-              fields: ['userId'],
-              table: 'users',
-              value: undefined,
-              index: 'tasksusers_ibfk_1',
-              reltype: 'parent'
-            }),
-            validateError(ctx.task1.destroy(), Sequelize.ForeignKeyConstraintError, {
-              fields: ['taskId'],
-              table: 'tasks',
-              value: undefined,
-              index: 'tasksusers_ibfk_2',
-              reltype: 'parent'
-            })
-          ]);
-        });
+      it('in context of DELETE restriction', async function() {
+        await this.sequelize.sync({ force: true });
+
+        const [user1, task1] = await Promise.all([
+          this.User.create({ id: 67, username: 'foo' }),
+          this.Task.create({ id: 52, title: 'task' })
+        ]);
+
+        await user1.setTasks([task1]);
+
+        await Promise.all([
+          validateError(user1.destroy(), Sequelize.ForeignKeyConstraintError, {
+            fields: ['userId'],
+            table: 'users',
+            value: undefined,
+            index: 'tasksusers_ibfk_1',
+            reltype: 'parent'
+          }),
+          validateError(task1.destroy(), Sequelize.ForeignKeyConstraintError, {
+            fields: ['taskId'],
+            table: 'tasks',
+            value: undefined,
+            index: 'tasksusers_ibfk_2',
+            reltype: 'parent'
+          })
+        ]);
       });
       });
 
 
-      it('in context of missing relation', function() {
-        return this.sequelize.sync({ force: true }).then(() =>
-          validateError(this.Task.create({ title: 'task', primaryUserId: 5 }), Sequelize.ForeignKeyConstraintError, {
+      it('in context of missing relation', async function() {
+        await this.sequelize.sync({ force: true });
+
+        await validateError(
+          this.Task.create({ title: 'task', primaryUserId: 5 }),
+          Sequelize.ForeignKeyConstraintError,
+          {
             fields: ['primaryUserId'],
             fields: ['primaryUserId'],
             table: 'users',
             table: 'users',
             value: 5,
             value: 5,
             index: 'tasks_ibfk_1',
             index: 'tasks_ibfk_1',
             reltype: 'child'
             reltype: 'child'
-          }));
+          }
+        );
       });
       });
     });
     });
   });
   });

test/integration/dialects/mysql/warning.test.js

@@ -11,7 +11,7 @@ describe(Support.getTestDialectTeaser('Warning'), () => {
   // We can only test MySQL warnings when using MySQL.
   // We can only test MySQL warnings when using MySQL.
   if (dialect === 'mysql') {
   if (dialect === 'mysql') {
     describe('logging', () => {
     describe('logging', () => {
-      it('logs warnings when there are warnings', () => {
+      it('logs warnings when there are warnings', async () => {
         const logger = sinon.spy(console, 'log');
         const logger = sinon.spy(console, 'log');
         const sequelize = Support.createSequelizeInstance({
         const sequelize = Support.createSequelizeInstance({
           logging: logger,
           logging: logger,
@@ -23,20 +23,16 @@ describe(Support.getTestDialectTeaser('Warning'), () => {
           name: Sequelize.DataTypes.STRING(1, true)
           name: Sequelize.DataTypes.STRING(1, true)
         });
         });
 
 
-        return sequelize.sync({ force: true }).then(() => {
-          return sequelize.authenticate();
-        }).then(() => {
-          return sequelize.query("SET SESSION sql_mode='';");
-        }).then(() => {
-          return Model.create({
-            name: 'very-long-long-name'
-          });
-        }).then(() => {
-          // last log is warning message
-          expect(logger.args[logger.args.length - 1][0]).to.be.match(/^MySQL Warnings \(default\):.*/m);
-        }, () => {
-          expect.fail();
+        await sequelize.sync({ force: true });
+        await sequelize.authenticate();
+        await sequelize.query("SET SESSION sql_mode='';");
+
+        await Model.create({
+          name: 'very-long-long-name'
         });
         });
+
+        // last log is warning message
+        expect(logger.args[logger.args.length - 1][0]).to.be.match(/^MySQL Warnings \(default\):.*/m);
       });
       });
     });
     });
   }
   }

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

@@ -43,7 +43,7 @@ if (dialect.match(/^postgres/)) {
 
 
     describe('HasMany', () => {
     describe('HasMany', () => {
       describe('addDAO / getModel', () => {
       describe('addDAO / getModel', () => {
-        beforeEach(function() {
+        beforeEach(async function() {
           //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)
           this.User = this.sequelize.define(`User${config.rand()}`, { name: DataTypes.STRING });
           this.User = this.sequelize.define(`User${config.rand()}`, { name: DataTypes.STRING });
           this.Task = this.sequelize.define(`Task${config.rand()}`, { name: DataTypes.STRING });
           this.Task = this.sequelize.define(`Task${config.rand()}`, { name: DataTypes.STRING });
@@ -61,35 +61,25 @@ if (dialect.match(/^postgres/)) {
             tasks[i] = { name: `Task${Math.random()}` };
             tasks[i] = { name: `Task${Math.random()}` };
           }
           }
 
 
-          return this.sequelize.sync({ force: true }).then(() => {
-            return this.User.bulkCreate(users).then(() => {
-              return this.Task.bulkCreate(tasks).then(() => {
-                return this.User.findAll().then(_users => {
-                  return this.Task.findAll().then(_tasks => {
-                    this.user = _users[0];
-                    this.task = _tasks[0];
-                  });
-                });
-              });
-            });
-          });
+          await this.sequelize.sync({ force: true });
+          await this.User.bulkCreate(users);
+          await this.Task.bulkCreate(tasks);
+          const _users = await this.User.findAll();
+          const _tasks = await this.Task.findAll();
+          this.user = _users[0];
+          this.task = _tasks[0];
         });
         });
 
 
-        it('should correctly add an association to the dao', function() {
-          return this.user.getTasks().then(_tasks => {
-            expect(_tasks).to.have.length(0);
-            return this.user.addTask(this.task).then(() => {
-              return this.user.getTasks().then(_tasks => {
-                expect(_tasks).to.have.length(1);
-              });
-            });
-          });
+        it('should correctly add an association to the dao', async function() {
+          expect(await this.user.getTasks()).to.have.length(0);
+          await this.user.addTask(this.task);
+          expect(await this.user.getTasks()).to.have.length(1);
         });
         });
       });
       });
 
 
       describe('removeDAO', () => {
       describe('removeDAO', () => {
-        it('should correctly remove associated objects', function() {
-          const users = [],
+        it('should correctly remove associated objects', async function() {
+          const users = [], 
             tasks = [];
             tasks = [];
 
 
           //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)
@@ -106,39 +96,23 @@ if (dialect.match(/^postgres/)) {
             tasks[i] = { id: i + 1, name: `Task${Math.random()}` };
             tasks[i] = { id: i + 1, name: `Task${Math.random()}` };
           }
           }
 
 
-          return this.sequelize.sync({ force: true }).then(() => {
-            return this.User.bulkCreate(users).then(() => {
-              return this.Task.bulkCreate(tasks).then(() => {
-                return this.User.findAll().then(_users => {
-                  return this.Task.findAll().then(_tasks => {
-                    this.user = _users[0];
-                    this.task = _tasks[0];
-                    this.users = _users;
-                    this.tasks = _tasks;
-
-                    return this.user.getTasks().then(__tasks => {
-                      expect(__tasks).to.have.length(0);
-                      return this.user.setTasks(this.tasks).then(() => {
-                        return this.user.getTasks().then(_tasks => {
-                          expect(_tasks).to.have.length(this.tasks.length);
-                          return this.user.removeTask(this.tasks[0]).then(() => {
-                            return this.user.getTasks().then(_tasks => {
-                              expect(_tasks).to.have.length(this.tasks.length - 1);
-                              return this.user.removeTasks([this.tasks[1], this.tasks[2]]).then(() => {
-                                return this.user.getTasks().then(_tasks => {
-                                  expect(_tasks).to.have.length(this.tasks.length - 3);
-                                });
-                              });
-                            });
-                          });
-                        });
-                      });
-                    });
-                  });
-                });
-              });
-            });
-          });
+          await this.sequelize.sync({ force: true });
+          await this.User.bulkCreate(users);
+          await this.Task.bulkCreate(tasks);
+          const _users = await this.User.findAll();
+          const _tasks = await this.Task.findAll();
+          this.user = _users[0];
+          this.task = _tasks[0];
+          this.users = _users;
+          this.tasks = _tasks;
+
+          expect(await this.user.getTasks()).to.have.length(0);
+          await this.user.setTasks(this.tasks);
+          expect(await this.user.getTasks()).to.have.length(this.tasks.length);
+          await this.user.removeTask(this.tasks[0]);
+          expect(await this.user.getTasks()).to.have.length(this.tasks.length - 1);
+          await this.user.removeTasks([this.tasks[1], this.tasks[2]]);
+          expect(await this.user.getTasks()).to.have.length(this.tasks.length - 3);
         });
         });
       });
       });
     });
     });

test/integration/dialects/postgres/connection-manager.test.js

@@ -8,44 +8,36 @@ const chai = require('chai'),
 
 
 if (dialect.match(/^postgres/)) {
 if (dialect.match(/^postgres/)) {
   describe('[POSTGRES] Sequelize', () => {
   describe('[POSTGRES] Sequelize', () => {
-    function checkTimezoneParsing(baseOptions) {
+    async function checkTimezoneParsing(baseOptions) {
       const options = { ...baseOptions, timezone: 'Asia/Kolkata', timestamps: true };
       const options = { ...baseOptions, timezone: 'Asia/Kolkata', timestamps: true };
       const sequelize = Support.createSequelizeInstance(options);
       const sequelize = Support.createSequelizeInstance(options);
 
 
       const tzTable = sequelize.define('tz_table', { foo: DataTypes.STRING });
       const tzTable = sequelize.define('tz_table', { foo: DataTypes.STRING });
-      return tzTable.sync({ force: true }).then(() => {
-        return tzTable.create({ foo: 'test' }).then(row => {
-          expect(row).to.be.not.null;
-        });
-      });
+      await tzTable.sync({ force: true });
+      const row = await tzTable.create({ foo: 'test' });
+      expect(row).to.be.not.null;
     }
     }
 
 
-    it('should correctly parse the moment based timezone while fetching hstore oids', function() {
-      return checkTimezoneParsing(this.sequelize.options);
+    it('should correctly parse the moment based timezone while fetching hstore oids', async function() {
+      await checkTimezoneParsing(this.sequelize.options);
     });
     });
 
 
-    it('should set client_min_messages to warning by default', () => {
-      return Support.sequelize.query('SHOW client_min_messages')
-        .then(result => {
-          expect(result[0].client_min_messages).to.equal('warning');
-        });
+    it('should set client_min_messages to warning by default', async () => {
+      const result = await Support.sequelize.query('SHOW client_min_messages');
+      expect(result[0].client_min_messages).to.equal('warning');
     });
     });
 
 
-    it('should allow overriding client_min_messages', () => {
+    it('should allow overriding client_min_messages', async () => {
       const sequelize = Support.createSequelizeInstance({ clientMinMessages: 'ERROR' });
       const sequelize = Support.createSequelizeInstance({ clientMinMessages: 'ERROR' });
-      return sequelize.query('SHOW client_min_messages')
-        .then(result => {
-          expect(result[0].client_min_messages).to.equal('error');
-        });
+      const result = await sequelize.query('SHOW client_min_messages');
+      expect(result[0].client_min_messages).to.equal('error');
     });
     });
 
 
-    it('should not set client_min_messages if clientMinMessages is false', () => {
+    it('should not set client_min_messages if clientMinMessages is false', async () => {
       const sequelize = Support.createSequelizeInstance({ clientMinMessages: false });
       const sequelize = Support.createSequelizeInstance({ clientMinMessages: false });
-      return sequelize.query('SHOW client_min_messages')
-        .then(result => {
-          // `notice` is Postgres's default
-          expect(result[0].client_min_messages).to.equal('notice');
-        });
+      const result = await sequelize.query('SHOW client_min_messages');
+      // `notice` is Postgres's default
+      expect(result[0].client_min_messages).to.equal('notice');
     });
     });
   });
   });
 
 
@@ -79,66 +71,63 @@ if (dialect.match(/^postgres/)) {
       return User.sync({ force: true });
       return User.sync({ force: true });
     }
     }
 
 
-    it('should fetch regular dynamic oids and create parsers', () => {
+    it('should fetch regular dynamic oids and create parsers', async () => {
       const sequelize = Support.sequelize;
       const sequelize = Support.sequelize;
-      return reloadDynamicOIDs(sequelize).then(() => {
-        dynamicTypesToCheck.forEach(type => {
-          expect(type.types.postgres,
-            `DataType.${type.key}.types.postgres`).to.not.be.empty;
+      await reloadDynamicOIDs(sequelize);
+      dynamicTypesToCheck.forEach(type => {
+        expect(type.types.postgres,
+          `DataType.${type.key}.types.postgres`).to.not.be.empty;
 
 
-          for (const name of type.types.postgres) {
-            const entry = sequelize.connectionManager.nameOidMap[name];
-            const oidParserMap = sequelize.connectionManager.oidParserMap;
+        for (const name of type.types.postgres) {
+          const entry = sequelize.connectionManager.nameOidMap[name];
+          const oidParserMap = sequelize.connectionManager.oidParserMap;
 
 
-            expect(entry.oid, `nameOidMap[${name}].oid`).to.be.a('number');
-            expect(entry.arrayOid, `nameOidMap[${name}].arrayOid`).to.be.a('number');
+          expect(entry.oid, `nameOidMap[${name}].oid`).to.be.a('number');
+          expect(entry.arrayOid, `nameOidMap[${name}].arrayOid`).to.be.a('number');
 
 
-            expect(oidParserMap.get(entry.oid),
-              `oidParserMap.get(nameOidMap[${name}].oid)`).to.be.a('function');
-            expect(oidParserMap.get(entry.arrayOid),
-              `oidParserMap.get(nameOidMap[${name}].arrayOid)`).to.be.a('function');
-          }
+          expect(oidParserMap.get(entry.oid),
+            `oidParserMap.get(nameOidMap[${name}].oid)`).to.be.a('function');
+          expect(oidParserMap.get(entry.arrayOid),
+            `oidParserMap.get(nameOidMap[${name}].arrayOid)`).to.be.a('function');
+        }
 
 
-        });
       });
       });
     });
     });
 
 
-    it('should fetch enum dynamic oids and create parsers', () => {
+    it('should fetch enum dynamic oids and create parsers', async () => {
       const sequelize = Support.sequelize;
       const sequelize = Support.sequelize;
-      return reloadDynamicOIDs(sequelize).then(() => {
-        const enumOids = sequelize.connectionManager.enumOids;
-        const oidParserMap = sequelize.connectionManager.oidParserMap;
-
-        expect(enumOids.oids, 'enumOids.oids').to.not.be.empty;
-        expect(enumOids.arrayOids, 'enumOids.arrayOids').to.not.be.empty;
-
-        for (const oid of enumOids.oids) {
-          expect(oidParserMap.get(oid), 'oidParserMap.get(enumOids.oids)').to.be.a('function');
-        }
-        for (const arrayOid of enumOids.arrayOids) {
-          expect(oidParserMap.get(arrayOid), 'oidParserMap.get(enumOids.arrayOids)').to.be.a('function');
-        }
-      });
+      await reloadDynamicOIDs(sequelize);
+      const enumOids = sequelize.connectionManager.enumOids;
+      const oidParserMap = sequelize.connectionManager.oidParserMap;
+
+      expect(enumOids.oids, 'enumOids.oids').to.not.be.empty;
+      expect(enumOids.arrayOids, 'enumOids.arrayOids').to.not.be.empty;
+
+      for (const oid of enumOids.oids) {
+        expect(oidParserMap.get(oid), 'oidParserMap.get(enumOids.oids)').to.be.a('function');
+      }
+      for (const arrayOid of enumOids.arrayOids) {
+        expect(oidParserMap.get(arrayOid), 'oidParserMap.get(enumOids.arrayOids)').to.be.a('function');
+      }
     });
     });
 
 
-    it('should fetch range dynamic oids and create parsers', () => {
+    it('should fetch range dynamic oids and create parsers', async () => {
       const sequelize = Support.sequelize;
       const sequelize = Support.sequelize;
-      return reloadDynamicOIDs(sequelize).then(() => {
-        for (const baseKey in expCastTypes) {
-          const name = expCastTypes[baseKey];
-          const entry = sequelize.connectionManager.nameOidMap[name];
-          const oidParserMap = sequelize.connectionManager.oidParserMap;
-
-          for (const key of ['rangeOid', 'arrayRangeOid']) {
-            expect(entry[key], `nameOidMap[${name}][${key}]`).to.be.a('number');
-          }
+      await reloadDynamicOIDs(sequelize);
+      for (const baseKey in expCastTypes) {
+        const name = expCastTypes[baseKey];
+        const entry = sequelize.connectionManager.nameOidMap[name];
+        const oidParserMap = sequelize.connectionManager.oidParserMap;
 
 
-          expect(oidParserMap.get(entry.rangeOid),
-            `oidParserMap.get(nameOidMap[${name}].rangeOid)`).to.be.a('function');
-          expect(oidParserMap.get(entry.arrayRangeOid),
-            `oidParserMap.get(nameOidMap[${name}].arrayRangeOid)`).to.be.a('function');
+        for (const key of ['rangeOid', 'arrayRangeOid']) {
+          expect(entry[key], `nameOidMap[${name}][${key}]`).to.be.a('number');
         }
         }
-      });
+
+        expect(oidParserMap.get(entry.rangeOid),
+          `oidParserMap.get(nameOidMap[${name}].rangeOid)`).to.be.a('function');
+        expect(oidParserMap.get(entry.arrayRangeOid),
+          `oidParserMap.get(nameOidMap[${name}].arrayRangeOid)`).to.be.a('function');
+      }
     });
     });
 
 
   });
   });

test/integration/dialects/postgres/dao.test.js

@@ -11,7 +11,7 @@ const chai = require('chai'),
 
 
 if (dialect.match(/^postgres/)) {
 if (dialect.match(/^postgres/)) {
   describe('[POSTGRES Specific] DAO', () => {
   describe('[POSTGRES Specific] DAO', () => {
-    beforeEach(function() {
+    beforeEach(async function() {
       this.sequelize.options.quoteIdentifiers = true;
       this.sequelize.options.quoteIdentifiers = true;
       this.User = this.sequelize.define('User', {
       this.User = this.sequelize.define('User', {
         username: DataTypes.STRING,
         username: DataTypes.STRING,
@@ -35,15 +35,15 @@ if (dialect.match(/^postgres/)) {
         holidays: DataTypes.ARRAY(DataTypes.RANGE(DataTypes.DATE)),
         holidays: DataTypes.ARRAY(DataTypes.RANGE(DataTypes.DATE)),
         location: DataTypes.GEOMETRY()
         location: DataTypes.GEOMETRY()
       });
       });
-      return this.User.sync({ force: true });
+      await this.User.sync({ force: true });
     });
     });
 
 
     afterEach(function() {
     afterEach(function() {
       this.sequelize.options.quoteIdentifiers = true;
       this.sequelize.options.quoteIdentifiers = true;
     });
     });
 
 
-    it('should be able to search within an array', function() {
-      return this.User.findAll({
+    it('should be able to search within an array', async function() {
+      await this.User.findAll({
         where: {
         where: {
           email: ['hello', 'world']
           email: ['hello', 'world']
         },
         },
@@ -54,144 +54,116 @@ if (dialect.match(/^postgres/)) {
       });
       });
     });
     });
 
 
-    it('should be able to update a field with type ARRAY(JSON)', function() {
-      return this.User.create({
+    it('should be able to update a field with type ARRAY(JSON)', async function() {
+      const userInstance = await this.User.create({
         username: 'bob',
         username: 'bob',
         email: ['myemail@email.com'],
         email: ['myemail@email.com'],
         friends: [{
         friends: [{
           name: 'John Smith'
           name: 'John Smith'
         }]
         }]
-      }).then(userInstance => {
-        expect(userInstance.friends).to.have.length(1);
-        expect(userInstance.friends[0].name).to.equal('John Smith');
-
-        return userInstance.update({
-          friends: [{
-            name: 'John Smythe'
-          }]
-        });
-      }).then(obj => obj['friends'])
-        .then(friends => {
-          expect(friends).to.have.length(1);
-          expect(friends[0].name).to.equal('John Smythe');
-          return friends;
-        });
+      });
+
+      expect(userInstance.friends).to.have.length(1);
+      expect(userInstance.friends[0].name).to.equal('John Smith');
+
+      const obj = await userInstance.update({
+        friends: [{
+          name: 'John Smythe'
+        }]
+      });
+
+      const friends = await obj['friends'];
+      expect(friends).to.have.length(1);
+      expect(friends[0].name).to.equal('John Smythe');
+      await friends;
     });
     });
 
 
-    it('should be able to find a record while searching in an array', function() {
-      return this.User.bulkCreate([
+    it('should be able to find a record while searching in an array', async function() {
+      await this.User.bulkCreate([
         { username: 'bob', email: ['myemail@email.com'] },
         { username: 'bob', email: ['myemail@email.com'] },
         { username: 'tony', email: ['wrongemail@email.com'] }
         { username: 'tony', email: ['wrongemail@email.com'] }
-      ]).then(() => {
-        return this.User.findAll({ where: { email: ['myemail@email.com'] } }).then(user => {
-          expect(user).to.be.instanceof(Array);
-          expect(user).to.have.length(1);
-          expect(user[0].username).to.equal('bob');
-        });
-      });
+      ]);
+
+      const user = await this.User.findAll({ where: { email: ['myemail@email.com'] } });
+      expect(user).to.be.instanceof(Array);
+      expect(user).to.have.length(1);
+      expect(user[0].username).to.equal('bob');
     });
     });
 
 
     describe('json', () => {
     describe('json', () => {
-      it('should be able to retrieve a row with ->> operator', function() {
-        return Promise.all([
+      it('should be able to retrieve a row with ->> operator', async function() {
+        await Promise.all([
           this.User.create({ username: 'swen', emergency_contact: { name: 'kate' } }),
           this.User.create({ username: 'swen', emergency_contact: { name: 'kate' } }),
-          this.User.create({ username: 'anna', emergency_contact: { name: 'joe' } })])
-          .then(() => {
-            return this.User.findOne({ where: sequelize.json("emergency_contact->>'name'", 'kate'), attributes: ['username', 'emergency_contact'] });
-          })
-          .then(user => {
-            expect(user.emergency_contact.name).to.equal('kate');
-          });
+          this.User.create({ username: 'anna', emergency_contact: { name: 'joe' } })]);
+
+        const user = await this.User.findOne({ where: sequelize.json("emergency_contact->>'name'", 'kate'), attributes: ['username', 'emergency_contact'] });
+        expect(user.emergency_contact.name).to.equal('kate');
       });
       });
 
 
-      it('should be able to query using the nested query language', function() {
-        return Promise.all([
+      it('should be able to query using the nested query language', async function() {
+        await Promise.all([
           this.User.create({ username: 'swen', emergency_contact: { name: 'kate' } }),
           this.User.create({ username: 'swen', emergency_contact: { name: 'kate' } }),
-          this.User.create({ username: 'anna', emergency_contact: { name: 'joe' } })])
-          .then(() => {
-            return this.User.findOne({
-              where: sequelize.json({ emergency_contact: { name: 'kate' } })
-            });
-          })
-          .then(user => {
-            expect(user.emergency_contact.name).to.equal('kate');
-          });
+          this.User.create({ username: 'anna', emergency_contact: { name: 'joe' } })]);
+
+        const user = await this.User.findOne({
+          where: sequelize.json({ emergency_contact: { name: 'kate' } })
+        });
+
+        expect(user.emergency_contact.name).to.equal('kate');
       });
       });
 
 
-      it('should be able to query using dot syntax', function() {
-        return Promise.all([
+      it('should be able to query using dot syntax', async function() {
+        await Promise.all([
           this.User.create({ username: 'swen', emergency_contact: { name: 'kate' } }),
           this.User.create({ username: 'swen', emergency_contact: { name: 'kate' } }),
-          this.User.create({ username: 'anna', emergency_contact: { name: 'joe' } })])
-          .then(() => {
-            return this.User.findOne({ where: sequelize.json('emergency_contact.name', 'joe') });
-          })
-          .then(user => {
-            expect(user.emergency_contact.name).to.equal('joe');
-          });
+          this.User.create({ username: 'anna', emergency_contact: { name: 'joe' } })]);
+
+        const user = await this.User.findOne({ where: sequelize.json('emergency_contact.name', 'joe') });
+        expect(user.emergency_contact.name).to.equal('joe');
       });
       });
 
 
-      it('should be able to query using dot syntax with uppercase name', function() {
-        return Promise.all([
+      it('should be able to query using dot syntax with uppercase name', async function() {
+        await Promise.all([
           this.User.create({ username: 'swen', emergencyContact: { name: 'kate' } }),
           this.User.create({ username: 'swen', emergencyContact: { name: 'kate' } }),
-          this.User.create({ username: 'anna', emergencyContact: { name: 'joe' } })])
-          .then(() => {
-            return this.User.findOne({
-              attributes: [[sequelize.json('emergencyContact.name'), 'contactName']],
-              where: sequelize.json('emergencyContact.name', 'joe')
-            });
-          })
-          .then(user => {
-            expect(user.get('contactName')).to.equal('joe');
-          });
+          this.User.create({ username: 'anna', emergencyContact: { name: 'joe' } })]);
+
+        const user = await this.User.findOne({
+          attributes: [[sequelize.json('emergencyContact.name'), 'contactName']],
+          where: sequelize.json('emergencyContact.name', 'joe')
+        });
+
+        expect(user.get('contactName')).to.equal('joe');
       });
       });
 
 
-      it('should be able to store values that require JSON escaping', function() {
+      it('should be able to store values that require JSON escaping', async function() {
         const text = "Multi-line '$string' needing \"escaping\" for $$ and $1 type values";
         const text = "Multi-line '$string' needing \"escaping\" for $$ and $1 type values";
 
 
-        return this.User.create({ username: 'swen', emergency_contact: { value: text } })
-          .then(user => {
-            expect(user.isNewRecord).to.equal(false);
-          })
-          .then(() => {
-            return this.User.findOne({ where: { username: 'swen' } });
-          })
-          .then(() => {
-            return this.User.findOne({ where: sequelize.json('emergency_contact.value', text) });
-          })
-          .then(user => {
-            expect(user.username).to.equal('swen');
-          });
+        const user0 = await this.User.create({ username: 'swen', emergency_contact: { value: text } });
+        expect(user0.isNewRecord).to.equal(false);
+        await this.User.findOne({ where: { username: 'swen' } });
+        const user = await this.User.findOne({ where: sequelize.json('emergency_contact.value', text) });
+        expect(user.username).to.equal('swen');
       });
       });
 
 
-      it('should be able to findOrCreate with values that require JSON escaping', function() {
+      it('should be able to findOrCreate with values that require JSON escaping', async function() {
         const text = "Multi-line '$string' needing \"escaping\" for $$ and $1 type values";
         const text = "Multi-line '$string' needing \"escaping\" for $$ and $1 type values";
 
 
-        return this.User.findOrCreate({ where: { username: 'swen' }, defaults: { emergency_contact: { value: text } } })
-          .then(user => {
-            expect(!user.isNewRecord).to.equal(true);
-          })
-          .then(() => {
-            return this.User.findOne({ where: { username: 'swen' } });
-          })
-          .then(() => {
-            return this.User.findOne({ where: sequelize.json('emergency_contact.value', text) });
-          })
-          .then(user => {
-            expect(user.username).to.equal('swen');
-          });
+        const user0 = await this.User.findOrCreate({ where: { username: 'swen' }, defaults: { emergency_contact: { value: text } } });
+        expect(!user0.isNewRecord).to.equal(true);
+        await this.User.findOne({ where: { username: 'swen' } });
+        const user = await this.User.findOne({ where: sequelize.json('emergency_contact.value', text) });
+        expect(user.username).to.equal('swen');
       });
       });
     });
     });
 
 
     describe('hstore', () => {
     describe('hstore', () => {
-      it('should tell me that a column is hstore and not USER-DEFINED', function() {
-        return this.sequelize.queryInterface.describeTable('Users').then(table => {
-          expect(table.settings.type).to.equal('HSTORE');
-          expect(table.document.type).to.equal('HSTORE');
-        });
+      it('should tell me that a column is hstore and not USER-DEFINED', async function() {
+        const table = await this.sequelize.queryInterface.describeTable('Users');
+        expect(table.settings.type).to.equal('HSTORE');
+        expect(table.document.type).to.equal('HSTORE');
       });
       });
 
 
-      it('should NOT stringify hstore with insert', function() {
-        return this.User.create({
+      it('should NOT stringify hstore with insert', async function() {
+        await this.User.create({
           username: 'bob',
           username: 'bob',
           email: ['myemail@email.com'],
           email: ['myemail@email.com'],
           settings: { mailing: false, push: 'facebook', frequency: 3 }
           settings: { mailing: false, push: 'facebook', frequency: 3 }
@@ -203,7 +175,7 @@ if (dialect.match(/^postgres/)) {
         });
         });
       });
       });
 
 
-      it('should not rename hstore fields', function() {
+      it('should not rename hstore fields', async function() {
         const Equipment = this.sequelize.define('Equipment', {
         const Equipment = this.sequelize.define('Equipment', {
           grapplingHook: {
           grapplingHook: {
             type: DataTypes.STRING,
             type: DataTypes.STRING,
@@ -214,21 +186,21 @@ if (dialect.match(/^postgres/)) {
           }
           }
         });
         });
 
 
-        return Equipment.sync({ force: true }).then(() => {
-          return Equipment.findAll({
-            where: {
-              utilityBelt: {
-                grapplingHook: true
-              }
-            },
-            logging(sql) {
-              expect(sql).to.contains(' WHERE "Equipment"."utilityBelt" = \'"grapplingHook"=>"true"\';');
+        await Equipment.sync({ force: true });
+
+        await Equipment.findAll({
+          where: {
+            utilityBelt: {
+              grapplingHook: true
             }
             }
-          });
+          },
+          logging(sql) {
+            expect(sql).to.contains(' WHERE "Equipment"."utilityBelt" = \'"grapplingHook"=>"true"\';');
+          }
         });
         });
       });
       });
 
 
-      it('should not rename json fields', function() {
+      it('should not rename json fields', async function() {
         const Equipment = this.sequelize.define('Equipment', {
         const Equipment = this.sequelize.define('Equipment', {
           grapplingHook: {
           grapplingHook: {
             type: DataTypes.STRING,
             type: DataTypes.STRING,
@@ -239,62 +211,61 @@ if (dialect.match(/^postgres/)) {
           }
           }
         });
         });
 
 
-        return Equipment.sync({ force: true }).then(() => {
-          return Equipment.findAll({
-            where: {
-              utilityBelt: {
-                grapplingHook: true
-              }
-            },
-            logging(sql) {
-              expect(sql).to.contains(' WHERE CAST(("Equipment"."utilityBelt"#>>\'{grapplingHook}\') AS BOOLEAN) = true;');
+        await Equipment.sync({ force: true });
+
+        await Equipment.findAll({
+          where: {
+            utilityBelt: {
+              grapplingHook: true
             }
             }
-          });
+          },
+          logging(sql) {
+            expect(sql).to.contains(' WHERE CAST(("Equipment"."utilityBelt"#>>\'{grapplingHook}\') AS BOOLEAN) = true;');
+          }
         });
         });
       });
       });
 
 
     });
     });
 
 
     describe('range', () => {
     describe('range', () => {
-      it('should tell me that a column is range and not USER-DEFINED', function() {
-        return this.sequelize.queryInterface.describeTable('Users').then(table => {
-          expect(table.course_period.type).to.equal('TSTZRANGE');
-          expect(table.available_amount.type).to.equal('INT4RANGE');
-        });
+      it('should tell me that a column is range and not USER-DEFINED', async function() {
+        const table = await this.sequelize.queryInterface.describeTable('Users');
+        expect(table.course_period.type).to.equal('TSTZRANGE');
+        expect(table.available_amount.type).to.equal('INT4RANGE');
       });
       });
 
 
     });
     });
 
 
     describe('enums', () => {
     describe('enums', () => {
-      it('should be able to create enums with escape values', function() {
+      it('should be able to create enums with escape values', async function() {
         const User = this.sequelize.define('UserEnums', {
         const User = this.sequelize.define('UserEnums', {
           mood: DataTypes.ENUM('happy', 'sad', '1970\'s')
           mood: DataTypes.ENUM('happy', 'sad', '1970\'s')
         });
         });
 
 
-        return User.sync({ force: true });
+        await User.sync({ force: true });
       });
       });
 
 
-      it('should be able to ignore enum types that already exist', function() {
+      it('should be able to ignore enum types that already exist', async function() {
         const User = this.sequelize.define('UserEnums', {
         const User = this.sequelize.define('UserEnums', {
           mood: DataTypes.ENUM('happy', 'sad', 'meh')
           mood: DataTypes.ENUM('happy', 'sad', 'meh')
         });
         });
 
 
-        return User.sync({ force: true }).then(() => {
-          return User.sync();
-        });
+        await User.sync({ force: true });
+
+        await User.sync();
       });
       });
 
 
-      it('should be able to create/drop enums multiple times', function() {
+      it('should be able to create/drop enums multiple times', async function() {
         const User = this.sequelize.define('UserEnums', {
         const User = this.sequelize.define('UserEnums', {
           mood: DataTypes.ENUM('happy', 'sad', 'meh')
           mood: DataTypes.ENUM('happy', 'sad', 'meh')
         });
         });
 
 
-        return User.sync({ force: true }).then(() => {
-          return User.sync({ force: true });
-        });
+        await User.sync({ force: true });
+
+        await User.sync({ force: true });
       });
       });
 
 
-      it('should be able to create/drop multiple enums multiple times', function() {
+      it('should be able to create/drop multiple enums multiple times', async function() {
         const DummyModel = this.sequelize.define('Dummy-pg', {
         const DummyModel = this.sequelize.define('Dummy-pg', {
           username: DataTypes.STRING,
           username: DataTypes.STRING,
           theEnumOne: {
           theEnumOne: {
@@ -315,16 +286,14 @@ if (dialect.match(/^postgres/)) {
           }
           }
         });
         });
 
 
-        return DummyModel.sync({ force: true }).then(() => {
-          // now sync one more time:
-          return DummyModel.sync({ force: true }).then(() => {
-            // sync without dropping
-            return DummyModel.sync();
-          });
-        });
+        await DummyModel.sync({ force: true });
+        // now sync one more time:
+        await DummyModel.sync({ force: true });
+        // sync without dropping
+        await DummyModel.sync();
       });
       });
 
 
-      it('should be able to create/drop multiple enums multiple times with field name (#7812)', function() {
+      it('should be able to create/drop multiple enums multiple times with field name (#7812)', async function() {
         const DummyModel = this.sequelize.define('Dummy-pg', {
         const DummyModel = this.sequelize.define('Dummy-pg', {
           username: DataTypes.STRING,
           username: DataTypes.STRING,
           theEnumOne: {
           theEnumOne: {
@@ -347,55 +316,47 @@ if (dialect.match(/^postgres/)) {
           }
           }
         });
         });
 
 
-        return DummyModel.sync({ force: true }).then(() => {
-          // now sync one more time:
-          return DummyModel.sync({ force: true }).then(() => {
-            // sync without dropping
-            return DummyModel.sync();
-          });
-        });
+        await DummyModel.sync({ force: true });
+        // now sync one more time:
+        await DummyModel.sync({ force: true });
+        // sync without dropping
+        await DummyModel.sync();
       });
       });
 
 
-      it('should be able to add values to enum types', function() {
+      it('should be able to add values to enum types', async function() {
         let User = this.sequelize.define('UserEnums', {
         let User = this.sequelize.define('UserEnums', {
           mood: DataTypes.ENUM('happy', 'sad', 'meh')
           mood: DataTypes.ENUM('happy', 'sad', 'meh')
         });
         });
 
 
-        return User.sync({ force: true }).then(() => {
-          User = this.sequelize.define('UserEnums', {
-            mood: DataTypes.ENUM('neutral', 'happy', 'sad', 'ecstatic', 'meh', 'joyful')
-          });
-
-          return User.sync();
-        }).then(() => {
-          return this.sequelize.getQueryInterface().pgListEnums(User.getTableName());
-        }).then(enums => {
-          expect(enums).to.have.length(1);
-          expect(enums[0].enum_value).to.equal('{neutral,happy,sad,ecstatic,meh,joyful}');
+        await User.sync({ force: true });
+        User = this.sequelize.define('UserEnums', {
+          mood: DataTypes.ENUM('neutral', 'happy', 'sad', 'ecstatic', 'meh', 'joyful')
         });
         });
+
+        await User.sync();
+        const enums = await this.sequelize.getQueryInterface().pgListEnums(User.getTableName());
+        expect(enums).to.have.length(1);
+        expect(enums[0].enum_value).to.equal('{neutral,happy,sad,ecstatic,meh,joyful}');
       });
       });
 
 
-      it('should be able to add multiple values with different order', function() {
+      it('should be able to add multiple values with different order', async function() {
         let User = this.sequelize.define('UserEnums', {
         let User = this.sequelize.define('UserEnums', {
           priority: DataTypes.ENUM('1', '2', '6')
           priority: DataTypes.ENUM('1', '2', '6')
         });
         });
 
 
-        return User.sync({ force: true }).then(() => {
-          User = this.sequelize.define('UserEnums', {
-            priority: DataTypes.ENUM('0', '1', '2', '3', '4', '5', '6', '7')
-          });
-
-          return User.sync();
-        }).then(() => {
-          return this.sequelize.getQueryInterface().pgListEnums(User.getTableName());
-        }).then(enums => {
-          expect(enums).to.have.length(1);
-          expect(enums[0].enum_value).to.equal('{0,1,2,3,4,5,6,7}');
+        await User.sync({ force: true });
+        User = this.sequelize.define('UserEnums', {
+          priority: DataTypes.ENUM('0', '1', '2', '3', '4', '5', '6', '7')
         });
         });
+
+        await User.sync();
+        const enums = await this.sequelize.getQueryInterface().pgListEnums(User.getTableName());
+        expect(enums).to.have.length(1);
+        expect(enums[0].enum_value).to.equal('{0,1,2,3,4,5,6,7}');
       });
       });
 
 
       describe('ARRAY(ENUM)', () => {
       describe('ARRAY(ENUM)', () => {
-        it('should be able to ignore enum types that already exist', function() {
+        it('should be able to ignore enum types that already exist', async function() {
           const User = this.sequelize.define('UserEnums', {
           const User = this.sequelize.define('UserEnums', {
             permissions: DataTypes.ARRAY(DataTypes.ENUM([
             permissions: DataTypes.ARRAY(DataTypes.ENUM([
               'access',
               'access',
@@ -405,10 +366,12 @@ if (dialect.match(/^postgres/)) {
             ]))
             ]))
           });
           });
 
 
-          return User.sync({ force: true }).then(() => User.sync());
+          await User.sync({ force: true });
+
+          await User.sync();
         });
         });
 
 
-        it('should be able to create/drop enums multiple times', function() {
+        it('should be able to create/drop enums multiple times', async function() {
           const User = this.sequelize.define('UserEnums', {
           const User = this.sequelize.define('UserEnums', {
             permissions: DataTypes.ARRAY(DataTypes.ENUM([
             permissions: DataTypes.ARRAY(DataTypes.ENUM([
               'access',
               'access',
@@ -418,10 +381,12 @@ if (dialect.match(/^postgres/)) {
             ]))
             ]))
           });
           });
 
 
-          return User.sync({ force: true }).then(() => User.sync({ force: true }));
+          await User.sync({ force: true });
+
+          await User.sync({ force: true });
         });
         });
 
 
-        it('should be able to add values to enum types', function() {
+        it('should be able to add values to enum types', async function() {
           let User = this.sequelize.define('UserEnums', {
           let User = this.sequelize.define('UserEnums', {
             permissions: DataTypes.ARRAY(DataTypes.ENUM([
             permissions: DataTypes.ARRAY(DataTypes.ENUM([
               'access',
               'access',
@@ -431,23 +396,20 @@ if (dialect.match(/^postgres/)) {
             ]))
             ]))
           });
           });
 
 
-          return User.sync({ force: true }).then(() => {
-            User = this.sequelize.define('UserEnums', {
-              permissions: DataTypes.ARRAY(
-                DataTypes.ENUM('view', 'access', 'edit', 'write', 'check', 'delete')
-              )
-            });
-
-            return User.sync();
-          }).then(() => {
-            return this.sequelize.getQueryInterface().pgListEnums(User.getTableName());
-          }).then(enums => {
-            expect(enums).to.have.length(1);
-            expect(enums[0].enum_value).to.equal('{view,access,edit,write,check,delete}');
+          await User.sync({ force: true });
+          User = this.sequelize.define('UserEnums', {
+            permissions: DataTypes.ARRAY(
+              DataTypes.ENUM('view', 'access', 'edit', 'write', 'check', 'delete')
+            )
           });
           });
+
+          await User.sync();
+          const enums = await this.sequelize.getQueryInterface().pgListEnums(User.getTableName());
+          expect(enums).to.have.length(1);
+          expect(enums[0].enum_value).to.equal('{view,access,edit,write,check,delete}');
         });
         });
 
 
-        it('should be able to insert new record', function() {
+        it('should be able to insert new record', async function() {
           const User = this.sequelize.define('UserEnums', {
           const User = this.sequelize.define('UserEnums', {
             name: DataTypes.STRING,
             name: DataTypes.STRING,
             type: DataTypes.ENUM('A', 'B', 'C'),
             type: DataTypes.ENUM('A', 'B', 'C'),
@@ -460,24 +422,22 @@ if (dialect.match(/^postgres/)) {
             ]))
             ]))
           });
           });
 
 
-          return User.sync({ force: true })
-            .then(() => {
-              return User.create({
-                name: 'file.exe',
-                type: 'C',
-                owners: ['userA', 'userB'],
-                permissions: ['access', 'write']
-              });
-            })
-            .then(user => {
-              expect(user.name).to.equal('file.exe');
-              expect(user.type).to.equal('C');
-              expect(user.owners).to.deep.equal(['userA', 'userB']);
-              expect(user.permissions).to.deep.equal(['access', 'write']);
-            });
+          await User.sync({ force: true });
+
+          const user = await User.create({
+            name: 'file.exe',
+            type: 'C',
+            owners: ['userA', 'userB'],
+            permissions: ['access', 'write']
+          });
+
+          expect(user.name).to.equal('file.exe');
+          expect(user.type).to.equal('C');
+          expect(user.owners).to.deep.equal(['userA', 'userB']);
+          expect(user.permissions).to.deep.equal(['access', 'write']);
         });
         });
 
 
-        it('should fail when trying to insert foreign element on ARRAY(ENUM)', function() {
+        it('should fail when trying to insert foreign element on ARRAY(ENUM)', async function() {
           const User = this.sequelize.define('UserEnums', {
           const User = this.sequelize.define('UserEnums', {
             name: DataTypes.STRING,
             name: DataTypes.STRING,
             type: DataTypes.ENUM('A', 'B', 'C'),
             type: DataTypes.ENUM('A', 'B', 'C'),
@@ -490,7 +450,7 @@ if (dialect.match(/^postgres/)) {
             ]))
             ]))
           });
           });
 
 
-          return expect(User.sync({ force: true }).then(() => {
+          await expect(User.sync({ force: true }).then(() => {
             return User.create({
             return User.create({
               name: 'file.exe',
               name: 'file.exe',
               type: 'C',
               type: 'C',
@@ -500,7 +460,7 @@ if (dialect.match(/^postgres/)) {
           })).to.be.rejectedWith(/invalid input value for enum "enum_UserEnums_permissions": "cosmic_ray_disk_access"/);
           })).to.be.rejectedWith(/invalid input value for enum "enum_UserEnums_permissions": "cosmic_ray_disk_access"/);
         });
         });
 
 
-        it('should be able to find records', function() {
+        it('should be able to find records', async function() {
           const User = this.sequelize.define('UserEnums', {
           const User = this.sequelize.define('UserEnums', {
             name: DataTypes.STRING,
             name: DataTypes.STRING,
             type: DataTypes.ENUM('A', 'B', 'C'),
             type: DataTypes.ENUM('A', 'B', 'C'),
@@ -512,120 +472,109 @@ if (dialect.match(/^postgres/)) {
             ]))
             ]))
           });
           });
 
 
-          return User.sync({ force: true })
-            .then(() => {
-              return User.bulkCreate([{
-                name: 'file1.exe',
-                type: 'C',
-                permissions: ['access', 'write']
-              }, {
-                name: 'file2.exe',
-                type: 'A',
-                permissions: ['access', 'check']
-              }, {
-                name: 'file3.exe',
-                type: 'B',
-                permissions: ['access', 'write', 'delete']
-              }]);
-            })
-            .then(() => {
-              return User.findAll({
-                where: {
-                  type: {
-                    [Op.in]: ['A', 'C']
-                  },
-                  permissions: {
-                    [Op.contains]: ['write']
-                  }
-                }
-              });
-            })
-            .then(users => {
-              expect(users.length).to.equal(1);
-              expect(users[0].name).to.equal('file1.exe');
-              expect(users[0].type).to.equal('C');
-              expect(users[0].permissions).to.deep.equal(['access', 'write']);
-            });
+          await User.sync({ force: true });
+
+          await User.bulkCreate([{
+            name: 'file1.exe',
+            type: 'C',
+            permissions: ['access', 'write']
+          }, {
+            name: 'file2.exe',
+            type: 'A',
+            permissions: ['access', 'check']
+          }, {
+            name: 'file3.exe',
+            type: 'B',
+            permissions: ['access', 'write', 'delete']
+          }]);
+
+          const users = await User.findAll({
+            where: {
+              type: {
+                [Op.in]: ['A', 'C']
+              },
+              permissions: {
+                [Op.contains]: ['write']
+              }
+            }
+          });
+
+          expect(users.length).to.equal(1);
+          expect(users[0].name).to.equal('file1.exe');
+          expect(users[0].type).to.equal('C');
+          expect(users[0].permissions).to.deep.equal(['access', 'write']);
         });
         });
       });
       });
     });
     });
 
 
     describe('integers', () => {
     describe('integers', () => {
       describe('integer', () => {
       describe('integer', () => {
-        beforeEach(function() {
+        beforeEach(async function() {
           this.User = this.sequelize.define('User', {
           this.User = this.sequelize.define('User', {
             aNumber: DataTypes.INTEGER
             aNumber: DataTypes.INTEGER
           });
           });
 
 
-          return this.User.sync({ force: true });
+          await this.User.sync({ force: true });
         });
         });
 
 
-        it('positive', function() {
+        it('positive', async function() {
           const User = this.User;
           const User = this.User;
 
 
-          return User.create({ aNumber: 2147483647 }).then(user => {
-            expect(user.aNumber).to.equal(2147483647);
-            return User.findOne({ where: { aNumber: 2147483647 } }).then(_user => {
-              expect(_user.aNumber).to.equal(2147483647);
-            });
-          });
+          const user = await User.create({ aNumber: 2147483647 });
+          expect(user.aNumber).to.equal(2147483647);
+          const _user = await User.findOne({ where: { aNumber: 2147483647 } });
+          expect(_user.aNumber).to.equal(2147483647);
         });
         });
 
 
-        it('negative', function() {
+        it('negative', async function() {
           const User = this.User;
           const User = this.User;
 
 
-          return User.create({ aNumber: -2147483647 }).then(user => {
-            expect(user.aNumber).to.equal(-2147483647);
-            return User.findOne({ where: { aNumber: -2147483647 } }).then(_user => {
-              expect(_user.aNumber).to.equal(-2147483647);
-            });
-          });
+          const user = await User.create({ aNumber: -2147483647 });
+          expect(user.aNumber).to.equal(-2147483647);
+          const _user = await User.findOne({ where: { aNumber: -2147483647 } });
+          expect(_user.aNumber).to.equal(-2147483647);
         });
         });
       });
       });
 
 
       describe('bigint', () => {
       describe('bigint', () => {
-        beforeEach(function() {
+        beforeEach(async function() {
           this.User = this.sequelize.define('User', {
           this.User = this.sequelize.define('User', {
             aNumber: DataTypes.BIGINT
             aNumber: DataTypes.BIGINT
           });
           });
 
 
-          return this.User.sync({ force: true });
+          await this.User.sync({ force: true });
         });
         });
 
 
-        it('positive', function() {
+        it('positive', async function() {
           const User = this.User;
           const User = this.User;
 
 
-          return User.create({ aNumber: '9223372036854775807' }).then(user => {
-            expect(user.aNumber).to.equal('9223372036854775807');
-            return User.findOne({ where: { aNumber: '9223372036854775807' } }).then(_user => {
-              expect(_user.aNumber).to.equal('9223372036854775807');
-            });
-          });
+          const user = await User.create({ aNumber: '9223372036854775807' });
+          expect(user.aNumber).to.equal('9223372036854775807');
+          const _user = await User.findOne({ where: { aNumber: '9223372036854775807' } });
+          expect(_user.aNumber).to.equal('9223372036854775807');
         });
         });
 
 
-        it('negative', function() {
+        it('negative', async function() {
           const User = this.User;
           const User = this.User;
 
 
-          return User.create({ aNumber: '-9223372036854775807' }).then(user => {
-            expect(user.aNumber).to.equal('-9223372036854775807');
-            return User.findOne({ where: { aNumber: '-9223372036854775807' } }).then(_user => {
-              expect(_user.aNumber).to.equal('-9223372036854775807');
-            });
-          });
+          const user = await User.create({ aNumber: '-9223372036854775807' });
+          expect(user.aNumber).to.equal('-9223372036854775807');
+          const _user = await User.findOne({ where: { aNumber: '-9223372036854775807' } });
+          expect(_user.aNumber).to.equal('-9223372036854775807');
         });
         });
       });
       });
     });
     });
 
 
     describe('timestamps', () => {
     describe('timestamps', () => {
-      beforeEach(function() {
+      beforeEach(async function() {
         this.User = this.sequelize.define('User', {
         this.User = this.sequelize.define('User', {
           dates: DataTypes.ARRAY(DataTypes.DATE)
           dates: DataTypes.ARRAY(DataTypes.DATE)
         });
         });
-        return this.User.sync({ force: true });
+        await this.User.sync({ force: true });
       });
       });
 
 
-      it('should use bind params instead of "TIMESTAMP WITH TIME ZONE"', function() {
-        return this.User.create({
+      it('should use bind params instead of "TIMESTAMP WITH TIME ZONE"', async function() {
+        await this.User.create({
           dates: []
           dates: []
         }, {
         }, {
           logging(sql) {
           logging(sql) {
@@ -637,127 +586,105 @@ if (dialect.match(/^postgres/)) {
     });
     });
 
 
     describe('model', () => {
     describe('model', () => {
-      it('create handles array correctly', function() {
-        return this.User
-          .create({ username: 'user', email: ['foo@bar.com', 'bar@baz.com'] })
-          .then(oldUser => {
-            expect(oldUser.email).to.contain.members(['foo@bar.com', 'bar@baz.com']);
-          });
+      it('create handles array correctly', async function() {
+        const oldUser = await this.User
+          .create({ username: 'user', email: ['foo@bar.com', 'bar@baz.com'] });
+
+        expect(oldUser.email).to.contain.members(['foo@bar.com', 'bar@baz.com']);
       });
       });
 
 
-      it('should save hstore correctly', function() {
-        return this.User.create({ username: 'user', email: ['foo@bar.com'], settings: { created: '"value"' } }).then(newUser => {
-          // Check to see if the default value for an hstore field works
-          expect(newUser.document).to.deep.equal({ default: "'value'" });
-          expect(newUser.settings).to.deep.equal({ created: '"value"' });
+      it('should save hstore correctly', async function() {
+        const newUser = await this.User.create({ username: 'user', email: ['foo@bar.com'], settings: { created: '"value"' } });
+        // Check to see if the default value for an hstore field works
+        expect(newUser.document).to.deep.equal({ default: "'value'" });
+        expect(newUser.settings).to.deep.equal({ created: '"value"' });
 
 
-          // Check to see if updating an hstore field works
-          return newUser.update({ settings: { should: 'update', to: 'this', first: 'place' } }).then(oldUser => {
-            // Postgres always returns keys in alphabetical order (ascending)
-            expect(oldUser.settings).to.deep.equal({ first: 'place', should: 'update', to: 'this' });
-          });
-        });
+        // Check to see if updating an hstore field works
+        const oldUser = await newUser.update({ settings: { should: 'update', to: 'this', first: 'place' } });
+        // Postgres always returns keys in alphabetical order (ascending)
+        expect(oldUser.settings).to.deep.equal({ first: 'place', should: 'update', to: 'this' });
       });
       });
 
 
-      it('should save hstore array correctly', function() {
+      it('should save hstore array correctly', async function() {
         const User = this.User;
         const User = this.User;
 
 
-        return this.User.create({
+        await this.User.create({
           username: 'bob',
           username: 'bob',
           email: ['myemail@email.com'],
           email: ['myemail@email.com'],
           phones: [{ number: '123456789', type: 'mobile' }, { number: '987654321', type: 'landline' }, { number: '8675309', type: "Jenny's" }, { number: '5555554321', type: '"home\n"' }]
           phones: [{ number: '123456789', type: 'mobile' }, { number: '987654321', type: 'landline' }, { number: '8675309', type: "Jenny's" }, { number: '5555554321', type: '"home\n"' }]
-        }).then(() => {
-          return User.findByPk(1).then(user => {
-            expect(user.phones.length).to.equal(4);
-            expect(user.phones[1].number).to.equal('987654321');
-            expect(user.phones[2].type).to.equal("Jenny's");
-            expect(user.phones[3].type).to.equal('"home\n"');
-          });
         });
         });
+
+        const user = await User.findByPk(1);
+        expect(user.phones.length).to.equal(4);
+        expect(user.phones[1].number).to.equal('987654321');
+        expect(user.phones[2].type).to.equal("Jenny's");
+        expect(user.phones[3].type).to.equal('"home\n"');
       });
       });
 
 
-      it('should bulkCreate with hstore property', function() {
+      it('should bulkCreate with hstore property', async function() {
         const User = this.User;
         const User = this.User;
 
 
-        return this.User.bulkCreate([{
+        await this.User.bulkCreate([{
           username: 'bob',
           username: 'bob',
           email: ['myemail@email.com'],
           email: ['myemail@email.com'],
           settings: { mailing: true, push: 'facebook', frequency: 3 }
           settings: { mailing: true, push: 'facebook', frequency: 3 }
-        }]).then(() => {
-          return User.findByPk(1).then(user => {
-            expect(user.settings.mailing).to.equal('true');
-          });
-        });
+        }]);
+
+        const user = await User.findByPk(1);
+        expect(user.settings.mailing).to.equal('true');
       });
       });
 
 
-      it('should update hstore correctly', function() {
-        return this.User.create({ username: 'user', email: ['foo@bar.com'], settings: { test: '"value"' } }).then(newUser => {
-          // Check to see if the default value for an hstore field works
-          expect(newUser.document).to.deep.equal({ default: "'value'" });
-          expect(newUser.settings).to.deep.equal({ test: '"value"' });
-
-          // Check to see if updating an hstore field works
-          return this.User.update({ settings: { should: 'update', to: 'this', first: 'place' } }, { where: newUser.where() }).then(() => {
-            return newUser.reload().then(() => {
-              // Postgres always returns keys in alphabetical order (ascending)
-              expect(newUser.settings).to.deep.equal({ first: 'place', should: 'update', to: 'this' });
-            });
-          });
-        });
+      it('should update hstore correctly', async function() {
+        const newUser = await this.User.create({ username: 'user', email: ['foo@bar.com'], settings: { test: '"value"' } });
+        // Check to see if the default value for an hstore field works
+        expect(newUser.document).to.deep.equal({ default: "'value'" });
+        expect(newUser.settings).to.deep.equal({ test: '"value"' });
+
+        // Check to see if updating an hstore field works
+        await this.User.update({ settings: { should: 'update', to: 'this', first: 'place' } }, { where: newUser.where() });
+        await newUser.reload();
+        // Postgres always returns keys in alphabetical order (ascending)
+        expect(newUser.settings).to.deep.equal({ first: 'place', should: 'update', to: 'this' });
       });
       });
 
 
-      it('should update hstore correctly and return the affected rows', function() {
-        return this.User.create({ username: 'user', email: ['foo@bar.com'], settings: { test: '"value"' } }).then(oldUser => {
-          // Update the user and check that the returned object's fields have been parsed by the hstore library
-          return this.User.update({ settings: { should: 'update', to: 'this', first: 'place' } }, { where: oldUser.where(), returning: true }).then(([count, users]) => {
-            expect(count).to.equal(1);
-            expect(users[0].settings).to.deep.equal({ should: 'update', to: 'this', first: 'place' });
-          });
-        });
+      it('should update hstore correctly and return the affected rows', async function() {
+        const oldUser = await this.User.create({ username: 'user', email: ['foo@bar.com'], settings: { test: '"value"' } });
+        // Update the user and check that the returned object's fields have been parsed by the hstore library
+        const [count, users] = await this.User.update({ settings: { should: 'update', to: 'this', first: 'place' } }, { where: oldUser.where(), returning: true });
+        expect(count).to.equal(1);
+        expect(users[0].settings).to.deep.equal({ should: 'update', to: 'this', first: 'place' });
       });
       });
 
 
-      it('should read hstore correctly', function() {
+      it('should read hstore correctly', async function() {
         const data = { username: 'user', email: ['foo@bar.com'], settings: { test: '"value"' } };
         const data = { username: 'user', email: ['foo@bar.com'], settings: { test: '"value"' } };
 
 
-        return this.User.create(data)
-          .then(() => {
-            return this.User.findOne({ where: { username: 'user' } });
-          })
-          .then(user => {
-            // Check that the hstore fields are the same when retrieving the user
-            expect(user.settings).to.deep.equal(data.settings);
-          });
+        await this.User.create(data);
+        const user = await this.User.findOne({ where: { username: 'user' } });
+        // Check that the hstore fields are the same when retrieving the user
+        expect(user.settings).to.deep.equal(data.settings);
       });
       });
 
 
-      it('should read an hstore array correctly', function() {
+      it('should read an hstore array correctly', async function() {
         const data = { username: 'user', email: ['foo@bar.com'], phones: [{ number: '123456789', type: 'mobile' }, { number: '987654321', type: 'landline' }] };
         const data = { username: 'user', email: ['foo@bar.com'], phones: [{ number: '123456789', type: 'mobile' }, { number: '987654321', type: 'landline' }] };
 
 
-        return this.User.create(data)
-          .then(() => {
-            // Check that the hstore fields are the same when retrieving the user
-            return this.User.findOne({ where: { username: 'user' } });
-          }).then(user => {
-            expect(user.phones).to.deep.equal(data.phones);
-          });
+        await this.User.create(data);
+        // Check that the hstore fields are the same when retrieving the user
+        const user = await this.User.findOne({ where: { username: 'user' } });
+        expect(user.phones).to.deep.equal(data.phones);
       });
       });
 
 
-      it('should read hstore correctly from multiple rows', function() {
-        return this.User
-          .create({ username: 'user1', email: ['foo@bar.com'], settings: { test: '"value"' } })
-          .then(() => {
-            return this.User.create({ username: 'user2', email: ['foo2@bar.com'], settings: { another: '"example"' } });
-          })
-          .then(() => {
-            // Check that the hstore fields are the same when retrieving the user
-            return this.User.findAll({ order: ['username'] });
-          })
-          .then(users => {
-            expect(users[0].settings).to.deep.equal({ test: '"value"' });
-            expect(users[1].settings).to.deep.equal({ another: '"example"' });
-          });
+      it('should read hstore correctly from multiple rows', async function() {
+        await this.User
+          .create({ username: 'user1', email: ['foo@bar.com'], settings: { test: '"value"' } });
+
+        await this.User.create({ username: 'user2', email: ['foo2@bar.com'], settings: { another: '"example"' } });
+        // Check that the hstore fields are the same when retrieving the user
+        const users = await this.User.findAll({ order: ['username'] });
+        expect(users[0].settings).to.deep.equal({ test: '"value"' });
+        expect(users[1].settings).to.deep.equal({ another: '"example"' });
       });
       });
 
 
-      it('should read hstore correctly from included models as well', function() {
+      it('should read hstore correctly from included models as well', async function() {
         const HstoreSubmodel = this.sequelize.define('hstoreSubmodel', {
         const HstoreSubmodel = this.sequelize.define('hstoreSubmodel', {
           someValue: DataTypes.HSTORE
           someValue: DataTypes.HSTORE
         });
         });
@@ -765,179 +692,156 @@ if (dialect.match(/^postgres/)) {
 
 
         this.User.hasMany(HstoreSubmodel);
         this.User.hasMany(HstoreSubmodel);
 
 
-        return this.sequelize
-          .sync({ force: true })
-          .then(() => {
-            return this.User.create({ username: 'user1' })
-              .then(user => {
-                return HstoreSubmodel.create({ someValue: submodelValue })
-                  .then(submodel => {
-                    return user.setHstoreSubmodels([submodel]);
-                  });
-              });
-          })
-          .then(() => {
-            return this.User.findOne({ where: { username: 'user1' }, include: [HstoreSubmodel] });
-          })
-          .then(user => {
-            expect(user.hasOwnProperty('hstoreSubmodels')).to.be.ok;
-            expect(user.hstoreSubmodels.length).to.equal(1);
-            expect(user.hstoreSubmodels[0].someValue).to.deep.equal(submodelValue);
-          });
+        await this.sequelize
+          .sync({ force: true });
+
+        const user0 = await this.User.create({ username: 'user1' });
+        const submodel = await HstoreSubmodel.create({ someValue: submodelValue });
+        await user0.setHstoreSubmodels([submodel]);
+        const user = await this.User.findOne({ where: { username: 'user1' }, include: [HstoreSubmodel] });
+        expect(user.hasOwnProperty('hstoreSubmodels')).to.be.ok;
+        expect(user.hstoreSubmodels.length).to.equal(1);
+        expect(user.hstoreSubmodels[0].someValue).to.deep.equal(submodelValue);
       });
       });
 
 
-      it('should save range correctly', function() {
+      it('should save range correctly', async function() {
         const period = [new Date(2015, 0, 1), new Date(2015, 11, 31)];
         const period = [new Date(2015, 0, 1), new Date(2015, 11, 31)];
-        return this.User.create({ username: 'user', email: ['foo@bar.com'], course_period: period }).then(newUser => {
-          // Check to see if the default value for a range field works
-
-          expect(newUser.acceptable_marks.length).to.equal(2);
-          expect(newUser.acceptable_marks[0].value).to.equal('0.65'); // lower bound
-          expect(newUser.acceptable_marks[1].value).to.equal('1'); // upper bound
-          expect(newUser.acceptable_marks[0].inclusive).to.deep.equal(true); // inclusive
-          expect(newUser.acceptable_marks[1].inclusive).to.deep.equal(false); // exclusive
-          expect(newUser.course_period[0].value instanceof Date).to.be.ok; // lower bound
-          expect(newUser.course_period[1].value instanceof Date).to.be.ok; // upper bound
-          expect(newUser.course_period[0].value).to.equalTime(period[0]); // lower bound
-          expect(newUser.course_period[1].value).to.equalTime(period[1]); // upper bound
-          expect(newUser.course_period[0].inclusive).to.deep.equal(true); // inclusive
-          expect(newUser.course_period[1].inclusive).to.deep.equal(false); // exclusive
-
-          // Check to see if updating a range field works
-          return newUser.update({ acceptable_marks: [0.8, 0.9] })
-            .then(() => newUser.reload()) // Ensure the acceptable_marks array is loaded with the complete range definition
-            .then(() => {
-              expect(newUser.acceptable_marks.length).to.equal(2);
-              expect(newUser.acceptable_marks[0].value).to.equal('0.8'); // lower bound
-              expect(newUser.acceptable_marks[1].value).to.equal('0.9'); // upper bound
-            });
-        });
+        const newUser = await this.User.create({ username: 'user', email: ['foo@bar.com'], course_period: period });
+        // Check to see if the default value for a range field works
+
+        expect(newUser.acceptable_marks.length).to.equal(2);
+        expect(newUser.acceptable_marks[0].value).to.equal('0.65'); // lower bound
+        expect(newUser.acceptable_marks[1].value).to.equal('1'); // upper bound
+        expect(newUser.acceptable_marks[0].inclusive).to.deep.equal(true); // inclusive
+        expect(newUser.acceptable_marks[1].inclusive).to.deep.equal(false); // exclusive
+        expect(newUser.course_period[0].value instanceof Date).to.be.ok; // lower bound
+        expect(newUser.course_period[1].value instanceof Date).to.be.ok; // upper bound
+        expect(newUser.course_period[0].value).to.equalTime(period[0]); // lower bound
+        expect(newUser.course_period[1].value).to.equalTime(period[1]); // upper bound
+        expect(newUser.course_period[0].inclusive).to.deep.equal(true); // inclusive
+        expect(newUser.course_period[1].inclusive).to.deep.equal(false); // exclusive
+
+        // Check to see if updating a range field works
+        await newUser.update({ acceptable_marks: [0.8, 0.9] });
+        await newUser.reload(); // Ensure the acceptable_marks array is loaded with the complete range definition
+        expect(newUser.acceptable_marks.length).to.equal(2);
+        expect(newUser.acceptable_marks[0].value).to.equal('0.8'); // lower bound
+        expect(newUser.acceptable_marks[1].value).to.equal('0.9'); // upper bound
       });
       });
 
 
-      it('should save range array correctly', function() {
+      it('should save range array correctly', async function() {
         const User = this.User;
         const User = this.User;
         const holidays = [
         const holidays = [
           [new Date(2015, 3, 1), new Date(2015, 3, 15)],
           [new Date(2015, 3, 1), new Date(2015, 3, 15)],
           [new Date(2015, 8, 1), new Date(2015, 9, 15)]
           [new Date(2015, 8, 1), new Date(2015, 9, 15)]
         ];
         ];
 
 
-        return User.create({
+        await User.create({
           username: 'bob',
           username: 'bob',
           email: ['myemail@email.com'],
           email: ['myemail@email.com'],
           holidays
           holidays
-        }).then(() => {
-          return User.findByPk(1).then(user => {
-            expect(user.holidays.length).to.equal(2);
-            expect(user.holidays[0].length).to.equal(2);
-            expect(user.holidays[0][0].value instanceof Date).to.be.ok;
-            expect(user.holidays[0][1].value instanceof Date).to.be.ok;
-            expect(user.holidays[0][0].value).to.equalTime(holidays[0][0]);
-            expect(user.holidays[0][1].value).to.equalTime(holidays[0][1]);
-            expect(user.holidays[1].length).to.equal(2);
-            expect(user.holidays[1][0].value instanceof Date).to.be.ok;
-            expect(user.holidays[1][1].value instanceof Date).to.be.ok;
-            expect(user.holidays[1][0].value).to.equalTime(holidays[1][0]);
-            expect(user.holidays[1][1].value).to.equalTime(holidays[1][1]);
-          });
         });
         });
+
+        const user = await User.findByPk(1);
+        expect(user.holidays.length).to.equal(2);
+        expect(user.holidays[0].length).to.equal(2);
+        expect(user.holidays[0][0].value instanceof Date).to.be.ok;
+        expect(user.holidays[0][1].value instanceof Date).to.be.ok;
+        expect(user.holidays[0][0].value).to.equalTime(holidays[0][0]);
+        expect(user.holidays[0][1].value).to.equalTime(holidays[0][1]);
+        expect(user.holidays[1].length).to.equal(2);
+        expect(user.holidays[1][0].value instanceof Date).to.be.ok;
+        expect(user.holidays[1][1].value instanceof Date).to.be.ok;
+        expect(user.holidays[1][0].value).to.equalTime(holidays[1][0]);
+        expect(user.holidays[1][1].value).to.equalTime(holidays[1][1]);
       });
       });
 
 
-      it('should bulkCreate with range property', function() {
+      it('should bulkCreate with range property', async function() {
         const User = this.User;
         const User = this.User;
         const period = [new Date(2015, 0, 1), new Date(2015, 11, 31)];
         const period = [new Date(2015, 0, 1), new Date(2015, 11, 31)];
 
 
-        return User.bulkCreate([{
+        await User.bulkCreate([{
           username: 'bob',
           username: 'bob',
           email: ['myemail@email.com'],
           email: ['myemail@email.com'],
           course_period: period
           course_period: period
-        }]).then(() => {
-          return User.findByPk(1).then(user => {
-            expect(user.course_period[0].value instanceof Date).to.be.ok;
-            expect(user.course_period[1].value instanceof Date).to.be.ok;
-            expect(user.course_period[0].value).to.equalTime(period[0]);  // lower bound
-            expect(user.course_period[1].value).to.equalTime(period[1]);  // upper bound
-            expect(user.course_period[0].inclusive).to.deep.equal(true);  // inclusive
-            expect(user.course_period[1].inclusive).to.deep.equal(false); // exclusive
-          });
-        });
+        }]);
+
+        const user = await User.findByPk(1);
+        expect(user.course_period[0].value instanceof Date).to.be.ok;
+        expect(user.course_period[1].value instanceof Date).to.be.ok;
+        expect(user.course_period[0].value).to.equalTime(period[0]);  // lower bound
+        expect(user.course_period[1].value).to.equalTime(period[1]);  // upper bound
+        expect(user.course_period[0].inclusive).to.deep.equal(true);  // inclusive
+        expect(user.course_period[1].inclusive).to.deep.equal(false); // exclusive
       });
       });
 
 
-      it('should update range correctly', function() {
+      it('should update range correctly', async function() {
         const User = this.User;
         const User = this.User;
         const period = [new Date(2015, 0, 1), new Date(2015, 11, 31)];
         const period = [new Date(2015, 0, 1), new Date(2015, 11, 31)];
 
 
-        return User.create({ username: 'user', email: ['foo@bar.com'], course_period: period }).then(newUser => {
-          // Check to see if the default value for a range field works
-          expect(newUser.acceptable_marks.length).to.equal(2);
-          expect(newUser.acceptable_marks[0].value).to.equal('0.65'); // lower bound
-          expect(newUser.acceptable_marks[1].value).to.equal('1'); // upper bound
-          expect(newUser.acceptable_marks[0].inclusive).to.deep.equal(true); // inclusive
-          expect(newUser.acceptable_marks[1].inclusive).to.deep.equal(false); // exclusive
-          expect(newUser.course_period[0].value instanceof Date).to.be.ok;
-          expect(newUser.course_period[1].value instanceof Date).to.be.ok;
-          expect(newUser.course_period[0].value).to.equalTime(period[0]); // lower bound
-          expect(newUser.course_period[1].value).to.equalTime(period[1]); // upper bound
-          expect(newUser.course_period[0].inclusive).to.deep.equal(true);  // inclusive
-          expect(newUser.course_period[1].inclusive).to.deep.equal(false); // exclusive
-
-
-          const period2 = [new Date(2015, 1, 1), new Date(2015, 10, 30)];
-
-          // Check to see if updating a range field works
-          return User.update({ course_period: period2 }, { where: newUser.where() }).then(() => {
-            return newUser.reload().then(() => {
-              expect(newUser.course_period[0].value instanceof Date).to.be.ok;
-              expect(newUser.course_period[1].value instanceof Date).to.be.ok;
-              expect(newUser.course_period[0].value).to.equalTime(period2[0]); // lower bound
-              expect(newUser.course_period[1].value).to.equalTime(period2[1]); // upper bound
-              expect(newUser.course_period[0].inclusive).to.deep.equal(true);  // inclusive
-              expect(newUser.course_period[1].inclusive).to.deep.equal(false); // exclusive
-            });
-          });
-        });
+        const newUser = await User.create({ username: 'user', email: ['foo@bar.com'], course_period: period });
+        // Check to see if the default value for a range field works
+        expect(newUser.acceptable_marks.length).to.equal(2);
+        expect(newUser.acceptable_marks[0].value).to.equal('0.65'); // lower bound
+        expect(newUser.acceptable_marks[1].value).to.equal('1'); // upper bound
+        expect(newUser.acceptable_marks[0].inclusive).to.deep.equal(true); // inclusive
+        expect(newUser.acceptable_marks[1].inclusive).to.deep.equal(false); // exclusive
+        expect(newUser.course_period[0].value instanceof Date).to.be.ok;
+        expect(newUser.course_period[1].value instanceof Date).to.be.ok;
+        expect(newUser.course_period[0].value).to.equalTime(period[0]); // lower bound
+        expect(newUser.course_period[1].value).to.equalTime(period[1]); // upper bound
+        expect(newUser.course_period[0].inclusive).to.deep.equal(true);  // inclusive
+        expect(newUser.course_period[1].inclusive).to.deep.equal(false); // exclusive
+
+
+        const period2 = [new Date(2015, 1, 1), new Date(2015, 10, 30)];
+
+        // Check to see if updating a range field works
+        await User.update({ course_period: period2 }, { where: newUser.where() });
+        await newUser.reload();
+        expect(newUser.course_period[0].value instanceof Date).to.be.ok;
+        expect(newUser.course_period[1].value instanceof Date).to.be.ok;
+        expect(newUser.course_period[0].value).to.equalTime(period2[0]); // lower bound
+        expect(newUser.course_period[1].value).to.equalTime(period2[1]); // upper bound
+        expect(newUser.course_period[0].inclusive).to.deep.equal(true);  // inclusive
+        expect(newUser.course_period[1].inclusive).to.deep.equal(false); // exclusive
       });
       });
 
 
-      it('should update range correctly and return the affected rows', function() {
+      it('should update range correctly and return the affected rows', async function() {
         const User = this.User;
         const User = this.User;
         const period = [new Date(2015, 1, 1), new Date(2015, 10, 30)];
         const period = [new Date(2015, 1, 1), new Date(2015, 10, 30)];
 
 
-        return User.create({
+        const oldUser = await User.create({
           username: 'user',
           username: 'user',
           email: ['foo@bar.com'],
           email: ['foo@bar.com'],
           course_period: [new Date(2015, 0, 1), new Date(2015, 11, 31)]
           course_period: [new Date(2015, 0, 1), new Date(2015, 11, 31)]
-        }).then(oldUser => {
-          // Update the user and check that the returned object's fields have been parsed by the range parser
-          return User.update({ course_period: period }, { where: oldUser.where(), returning: true })
-            .then(([count, users]) => {
-              expect(count).to.equal(1);
-              expect(users[0].course_period[0].value instanceof Date).to.be.ok;
-              expect(users[0].course_period[1].value instanceof Date).to.be.ok;
-              expect(users[0].course_period[0].value).to.equalTime(period[0]); // lower bound
-              expect(users[0].course_period[1].value).to.equalTime(period[1]); // upper bound
-              expect(users[0].course_period[0].inclusive).to.deep.equal(true);  // inclusive
-              expect(users[0].course_period[1].inclusive).to.deep.equal(false); // exclusive
-            });
         });
         });
+
+        // Update the user and check that the returned object's fields have been parsed by the range parser
+        const [count, users] = await User.update({ course_period: period }, { where: oldUser.where(), returning: true });
+        expect(count).to.equal(1);
+        expect(users[0].course_period[0].value instanceof Date).to.be.ok;
+        expect(users[0].course_period[1].value instanceof Date).to.be.ok;
+        expect(users[0].course_period[0].value).to.equalTime(period[0]); // lower bound
+        expect(users[0].course_period[1].value).to.equalTime(period[1]); // upper bound
+        expect(users[0].course_period[0].inclusive).to.deep.equal(true);  // inclusive
+        expect(users[0].course_period[1].inclusive).to.deep.equal(false); // exclusive
       });
       });
 
 
-      it('should read range correctly', function() {
+      it('should read range correctly', async function() {
         const User = this.User;
         const User = this.User;
 
 
         const course_period = [{ value: new Date(2015, 1, 1), inclusive: false }, { value: new Date(2015, 10, 30), inclusive: false }];
         const course_period = [{ value: new Date(2015, 1, 1), inclusive: false }, { value: new Date(2015, 10, 30), inclusive: false }];
 
 
         const data = { username: 'user', email: ['foo@bar.com'], course_period };
         const data = { username: 'user', email: ['foo@bar.com'], course_period };
 
 
-        return User.create(data)
-          .then(() => {
-            return User.findOne({ where: { username: 'user' } });
-          })
-          .then(user => {
-            // Check that the range fields are the same when retrieving the user
-            expect(user.course_period).to.deep.equal(data.course_period);
-          });
+        await User.create(data);
+        const user = await User.findOne({ where: { username: 'user' } });
+        // Check that the range fields are the same when retrieving the user
+        expect(user.course_period).to.deep.equal(data.course_period);
       });
       });
 
 
-      it('should read range array correctly', function() {
+      it('should read range array correctly', async function() {
         const User = this.User;
         const User = this.User;
         const holidays = [
         const holidays = [
           [{ value: new Date(2015, 3, 1, 10), inclusive: true }, { value: new Date(2015, 3, 15), inclusive: true }],
           [{ value: new Date(2015, 3, 1, 10), inclusive: true }, { value: new Date(2015, 3, 15), inclusive: true }],
@@ -945,44 +849,36 @@ if (dialect.match(/^postgres/)) {
         ];
         ];
         const data = { username: 'user', email: ['foo@bar.com'], holidays };
         const data = { username: 'user', email: ['foo@bar.com'], holidays };
 
 
-        return User.create(data)
-          .then(() => {
-            // Check that the range fields are the same when retrieving the user
-            return User.findOne({ where: { username: 'user' } });
-          }).then(user => {
-            expect(user.holidays).to.deep.equal(data.holidays);
-          });
+        await User.create(data);
+        // Check that the range fields are the same when retrieving the user
+        const user = await User.findOne({ where: { username: 'user' } });
+        expect(user.holidays).to.deep.equal(data.holidays);
       });
       });
 
 
-      it('should read range correctly from multiple rows', function() {
+      it('should read range correctly from multiple rows', async function() {
         const User = this.User;
         const User = this.User;
         const periods = [
         const periods = [
           [new Date(2015, 0, 1), new Date(2015, 11, 31)],
           [new Date(2015, 0, 1), new Date(2015, 11, 31)],
           [new Date(2016, 0, 1), new Date(2016, 11, 31)]
           [new Date(2016, 0, 1), new Date(2016, 11, 31)]
         ];
         ];
 
 
-        return User
-          .create({ username: 'user1', email: ['foo@bar.com'], course_period: periods[0] })
-          .then(() => {
-            return User.create({ username: 'user2', email: ['foo2@bar.com'], course_period: periods[1] });
-          })
-          .then(() => {
-            // Check that the range fields are the same when retrieving the user
-            return User.findAll({ order: ['username'] });
-          })
-          .then(users => {
-            expect(users[0].course_period[0].value).to.equalTime(periods[0][0]); // lower bound
-            expect(users[0].course_period[1].value).to.equalTime(periods[0][1]); // upper bound
-            expect(users[0].course_period[0].inclusive).to.deep.equal(true); // inclusive
-            expect(users[0].course_period[1].inclusive).to.deep.equal(false); // exclusive
-            expect(users[1].course_period[0].value).to.equalTime(periods[1][0]); // lower bound
-            expect(users[1].course_period[1].value).to.equalTime(periods[1][1]); // upper bound
-            expect(users[1].course_period[0].inclusive).to.deep.equal(true); // inclusive
-            expect(users[1].course_period[1].inclusive).to.deep.equal(false); // exclusive
-          });
+        await User
+          .create({ username: 'user1', email: ['foo@bar.com'], course_period: periods[0] });
+
+        await User.create({ username: 'user2', email: ['foo2@bar.com'], course_period: periods[1] });
+        // Check that the range fields are the same when retrieving the user
+        const users = await User.findAll({ order: ['username'] });
+        expect(users[0].course_period[0].value).to.equalTime(periods[0][0]); // lower bound
+        expect(users[0].course_period[1].value).to.equalTime(periods[0][1]); // upper bound
+        expect(users[0].course_period[0].inclusive).to.deep.equal(true); // inclusive
+        expect(users[0].course_period[1].inclusive).to.deep.equal(false); // exclusive
+        expect(users[1].course_period[0].value).to.equalTime(periods[1][0]); // lower bound
+        expect(users[1].course_period[1].value).to.equalTime(periods[1][1]); // upper bound
+        expect(users[1].course_period[0].inclusive).to.deep.equal(true); // inclusive
+        expect(users[1].course_period[1].inclusive).to.deep.equal(false); // exclusive
       });
       });
 
 
-      it('should read range correctly from included models as well', function() {
+      it('should read range correctly from included models as well', async function() {
         const period = [new Date(2016, 0, 1), new Date(2016, 11, 31)];
         const period = [new Date(2016, 0, 1), new Date(2016, 11, 31)];
         const HolidayDate = this.sequelize.define('holidayDate', {
         const HolidayDate = this.sequelize.define('holidayDate', {
           period: DataTypes.RANGE(DataTypes.DATE)
           period: DataTypes.RANGE(DataTypes.DATE)
@@ -990,62 +886,49 @@ if (dialect.match(/^postgres/)) {
 
 
         this.User.hasMany(HolidayDate);
         this.User.hasMany(HolidayDate);
 
 
-        return this.sequelize
-          .sync({ force: true })
-          .then(() => {
-            return this.User
-              .create({ username: 'user', email: ['foo@bar.com'] })
-              .then(user => {
-                return HolidayDate.create({ period })
-                  .then(holidayDate => {
-                    return user.setHolidayDates([holidayDate]);
-                  });
-              });
-          })
-          .then(() => {
-            return this.User.findOne({ where: { username: 'user' }, include: [HolidayDate] });
-          })
-          .then(user => {
-            expect(user.hasOwnProperty('holidayDates')).to.be.ok;
-            expect(user.holidayDates.length).to.equal(1);
-            expect(user.holidayDates[0].period.length).to.equal(2);
-            expect(user.holidayDates[0].period[0].value).to.equalTime(period[0]);
-            expect(user.holidayDates[0].period[1].value).to.equalTime(period[1]);
-          });
+        await this.sequelize
+          .sync({ force: true });
+
+        const user0 = await this.User
+          .create({ username: 'user', email: ['foo@bar.com'] });
+
+        const holidayDate = await HolidayDate.create({ period });
+        await user0.setHolidayDates([holidayDate]);
+        const user = await this.User.findOne({ where: { username: 'user' }, include: [HolidayDate] });
+        expect(user.hasOwnProperty('holidayDates')).to.be.ok;
+        expect(user.holidayDates.length).to.equal(1);
+        expect(user.holidayDates[0].period.length).to.equal(2);
+        expect(user.holidayDates[0].period[0].value).to.equalTime(period[0]);
+        expect(user.holidayDates[0].period[1].value).to.equalTime(period[1]);
       });
       });
     });
     });
 
 
-    it('should save geometry correctly', function() {
+    it('should save geometry correctly', async function() {
       const point = { type: 'Point', coordinates: [39.807222, -76.984722] };
       const point = { type: 'Point', coordinates: [39.807222, -76.984722] };
-      return this.User.create({ username: 'user', email: ['foo@bar.com'], location: point }).then(newUser => {
-        expect(newUser.location).to.deep.eql(point);
-      });
+      const newUser = await this.User.create({ username: 'user', email: ['foo@bar.com'], location: point });
+      expect(newUser.location).to.deep.eql(point);
     });
     });
 
 
-    it('should update geometry correctly', function() {
+    it('should update geometry correctly', async function() {
       const User = this.User;
       const User = this.User;
       const point1 = { type: 'Point', coordinates: [39.807222, -76.984722] };
       const point1 = { type: 'Point', coordinates: [39.807222, -76.984722] };
       const point2 = { type: 'Point', coordinates: [39.828333, -77.232222] };
       const point2 = { type: 'Point', coordinates: [39.828333, -77.232222] };
-      return User.create({ username: 'user', email: ['foo@bar.com'], location: point1 }).then(oldUser => {
-        return User.update({ location: point2 }, { where: { username: oldUser.username }, returning: true }).then(([, updatedUsers]) => {
-          expect(updatedUsers[0].location).to.deep.eql(point2);
-        });
-      });
+      const oldUser = await User.create({ username: 'user', email: ['foo@bar.com'], location: point1 });
+      const [, updatedUsers] = await User.update({ location: point2 }, { where: { username: oldUser.username }, returning: true });
+      expect(updatedUsers[0].location).to.deep.eql(point2);
     });
     });
 
 
-    it('should read geometry correctly', function() {
+    it('should read geometry correctly', async function() {
       const User = this.User;
       const User = this.User;
       const point = { type: 'Point', coordinates: [39.807222, -76.984722] };
       const point = { type: 'Point', coordinates: [39.807222, -76.984722] };
 
 
-      return User.create({ username: 'user', email: ['foo@bar.com'], location: point }).then(user => {
-        return User.findOne({ where: { username: user.username } });
-      }).then(user => {
-        expect(user.location).to.deep.eql(point);
-      });
+      const user0 = await User.create({ username: 'user', email: ['foo@bar.com'], location: point });
+      const user = await User.findOne({ where: { username: user0.username } });
+      expect(user.location).to.deep.eql(point);
     });
     });
 
 
     describe('[POSTGRES] Unquoted identifiers', () => {
     describe('[POSTGRES] Unquoted identifiers', () => {
-      it('can insert and select', function() {
+      it('can insert and select', async function() {
         this.sequelize.options.quoteIdentifiers = false;
         this.sequelize.options.quoteIdentifiers = false;
         this.sequelize.getQueryInterface().queryGenerator.options.quoteIdentifiers = false;
         this.sequelize.getQueryInterface().queryGenerator.options.quoteIdentifiers = false;
 
 
@@ -1056,42 +939,40 @@ if (dialect.match(/^postgres/)) {
           quoteIdentifiers: false
           quoteIdentifiers: false
         });
         });
 
 
-        return this.User.sync({ force: true }).then(() => {
-          return this.User
-            .create({ username: 'user', fullName: 'John Smith' })
-            .then(user => {
-              // We can insert into a table with non-quoted identifiers
-              expect(user.id).to.exist;
-              expect(user.id).not.to.be.null;
-              expect(user.username).to.equal('user');
-              expect(user.fullName).to.equal('John Smith');
-
-              // We can query by non-quoted identifiers
-              return this.User.findOne({
-                where: { fullName: 'John Smith' }
-              }).then(user2 => {
-                // We can map values back to non-quoted identifiers
-                expect(user2.id).to.equal(user.id);
-                expect(user2.username).to.equal('user');
-                expect(user2.fullName).to.equal('John Smith');
-
-                // We can query and aggregate by non-quoted identifiers
-                return this.User
-                  .count({
-                    where: { fullName: 'John Smith' }
-                  })
-                  .then(count => {
-                    this.sequelize.options.quoteIndentifiers = true;
-                    this.sequelize.getQueryInterface().queryGenerator.options.quoteIdentifiers = true;
-                    this.sequelize.options.logging = false;
-                    expect(count).to.equal(1);
-                  });
-              });
-            });
+        await this.User.sync({ force: true });
+
+        const user = await this.User
+          .create({ username: 'user', fullName: 'John Smith' });
+
+        // We can insert into a table with non-quoted identifiers
+        expect(user.id).to.exist;
+        expect(user.id).not.to.be.null;
+        expect(user.username).to.equal('user');
+        expect(user.fullName).to.equal('John Smith');
+
+        // We can query by non-quoted identifiers
+        const user2 = await this.User.findOne({
+          where: { fullName: 'John Smith' }
         });
         });
+
+        // We can map values back to non-quoted identifiers
+        expect(user2.id).to.equal(user.id);
+        expect(user2.username).to.equal('user');
+        expect(user2.fullName).to.equal('John Smith');
+
+        // We can query and aggregate by non-quoted identifiers
+        const count = await this.User
+          .count({
+            where: { fullName: 'John Smith' }
+          });
+
+        this.sequelize.options.quoteIndentifiers = true;
+        this.sequelize.getQueryInterface().queryGenerator.options.quoteIdentifiers = true;
+        this.sequelize.options.logging = false;
+        expect(count).to.equal(1);
       });
       });
 
 
-      it('can select nested include', function() {
+      it('can select nested include', async function() {
         this.sequelize.options.quoteIdentifiers = false;
         this.sequelize.options.quoteIdentifiers = false;
         this.sequelize.getQueryInterface().queryGenerator.options.quoteIdentifiers = false;
         this.sequelize.getQueryInterface().queryGenerator.options.quoteIdentifiers = false;
         this.Professor = this.sequelize.define('Professor', {
         this.Professor = this.sequelize.define('Professor', {
@@ -1118,115 +999,105 @@ if (dialect.match(/^postgres/)) {
         this.Class.belongsTo(this.Professor);
         this.Class.belongsTo(this.Professor);
         this.Class.belongsToMany(this.Student, { through: this.ClassStudent });
         this.Class.belongsToMany(this.Student, { through: this.ClassStudent });
         this.Student.belongsToMany(this.Class, { through: this.ClassStudent });
         this.Student.belongsToMany(this.Class, { through: this.ClassStudent });
-        return this.Professor.sync({ force: true })
-          .then(() => {
-            return this.Student.sync({ force: true });
-          })
-          .then(() => {
-            return this.Class.sync({ force: true });
-          })
-          .then(() => {
-            return this.ClassStudent.sync({ force: true });
-          })
-          .then(() => {
-            return this.Professor.bulkCreate([
-              {
-                id: 1,
-                fullName: 'Albus Dumbledore'
-              },
-              {
-                id: 2,
-                fullName: 'Severus Snape'
-              }
-            ]);
-          })
-          .then(() => {
-            return this.Class.bulkCreate([
-              {
-                id: 1,
-                name: 'Transfiguration',
-                ProfessorId: 1
-              },
-              {
-                id: 2,
-                name: 'Potions',
-                ProfessorId: 2
-              },
-              {
-                id: 3,
-                name: 'Defence Against the Dark Arts',
-                ProfessorId: 2
-              }
-            ]);
-          })
-          .then(() => {
-            return this.Student.bulkCreate([
-              {
-                id: 1,
-                fullName: 'Harry Potter'
-              },
-              {
-                id: 2,
-                fullName: 'Ron Weasley'
-              },
-              {
-                id: 3,
-                fullName: 'Ginny Weasley'
-              },
+
+        try {
+          await this.Professor.sync({ force: true });
+          await this.Student.sync({ force: true });
+          await this.Class.sync({ force: true });
+          await this.ClassStudent.sync({ force: true });
+
+          await this.Professor.bulkCreate([
+            {
+              id: 1,
+              fullName: 'Albus Dumbledore'
+            },
+            {
+              id: 2,
+              fullName: 'Severus Snape'
+            }
+          ]);
+
+          await this.Class.bulkCreate([
+            {
+              id: 1,
+              name: 'Transfiguration',
+              ProfessorId: 1
+            },
+            {
+              id: 2,
+              name: 'Potions',
+              ProfessorId: 2
+            },
+            {
+              id: 3,
+              name: 'Defence Against the Dark Arts',
+              ProfessorId: 2
+            }
+          ]);
+
+          await this.Student.bulkCreate([
+            {
+              id: 1,
+              fullName: 'Harry Potter'
+            },
+            {
+              id: 2,
+              fullName: 'Ron Weasley'
+            },
+            {
+              id: 3,
+              fullName: 'Ginny Weasley'
+            },
+            {
+              id: 4,
+              fullName: 'Hermione Granger'
+            }
+          ]);
+
+          await Promise.all([
+            this.Student.findByPk(1)
+              .then(Harry => {
+                return Harry.setClasses([1, 2, 3]);
+              }),
+            this.Student.findByPk(2)
+              .then(Ron => {
+                return Ron.setClasses([1, 2]);
+              }),
+            this.Student.findByPk(3)
+              .then(Ginny => {
+                return Ginny.setClasses([2, 3]);
+              }),
+            this.Student.findByPk(4)
+              .then(Hermione => {
+                return Hermione.setClasses([1, 2, 3]);
+              })
+          ]);
+
+          const professors = await this.Professor.findAll({
+            include: [
               {
               {
-                id: 4,
-                fullName: 'Hermione Granger'
+                model: this.Class,
+                include: [
+                  {
+                    model: this.Student
+                  }
+                ]
               }
               }
-            ]);
-          })
-          .then(() => {
-            return Promise.all([
-              this.Student.findByPk(1)
-                .then(Harry => {
-                  return Harry.setClasses([1, 2, 3]);
-                }),
-              this.Student.findByPk(2)
-                .then(Ron => {
-                  return Ron.setClasses([1, 2]);
-                }),
-              this.Student.findByPk(3)
-                .then(Ginny => {
-                  return Ginny.setClasses([2, 3]);
-                }),
-              this.Student.findByPk(4)
-                .then(Hermione => {
-                  return Hermione.setClasses([1, 2, 3]);
-                })
-            ]);
-          })
-          .then(() => {
-            return this.Professor.findAll({
-              include: [
-                {
-                  model: this.Class,
-                  include: [
-                    {
-                      model: this.Student
-                    }
-                  ]
-                }
-              ],
-              order: [
-                ['id'],
-                [this.Class, 'id'],
-                [this.Class, this.Student, 'id']
-              ]
-            });
-          })
-          .then(professors => {
-            expect(professors.length).to.eql(2);
-            expect(professors[0].fullName).to.eql('Albus Dumbledore');
-            expect(professors[0].Classes.length).to.eql(1);
-            expect(professors[0].Classes[0].Students.length).to.eql(3);
-          })
-          .finally(() => {
-            this.sequelize.getQueryInterface().queryGenerator.options.quoteIdentifiers = true;
+            ],
+            order: [
+              ['id'],
+              [this.Class, 'id'],
+              [this.Class, this.Student, 'id']
+            ]
           });
           });
+
+          expect(professors.length).to.eql(2);
+          expect(professors[0].fullName).to.eql('Albus Dumbledore');
+          expect(professors[0].Classes.length).to.eql(1);
+          expect(professors[0].Classes[0].Students.length).to.eql(3);
+        } finally {
+          this.sequelize.getQueryInterface().queryGenerator.options.quoteIdentifiers = true;
+        }
       });
       });
     });
     });
   });
   });

test/integration/dialects/postgres/data-types.test.js

@@ -72,7 +72,7 @@ if (dialect === 'postgres') {
 
 
     describe('DATE SQL', () => {
     describe('DATE SQL', () => {
       // create dummy user
       // create dummy user
-      it('should be able to create and update records with Infinity/-Infinity', function() {
+      it('should be able to create and update records with Infinity/-Infinity', async function() {
         this.sequelize.options.typeValidation = true;
         this.sequelize.options.typeValidation = true;
 
 
         const date = new Date();
         const date = new Date();
@@ -97,69 +97,68 @@ if (dialect === 'postgres') {
           timestamps: true
           timestamps: true
         });
         });
 
 
-        return User.sync({
+        await User.sync({
           force: true
           force: true
-        }).then(() => {
-          return User.create({
-            username: 'bob',
-            anotherTime: Infinity
-          }, {
-            validate: true
-          });
-        }).then(user => {
-          expect(user.username).to.equal('bob');
-          expect(user.beforeTime).to.equal(-Infinity);
-          expect(user.sometime).to.be.withinTime(date, new Date());
-          expect(user.anotherTime).to.equal(Infinity);
-          expect(user.afterTime).to.equal(Infinity);
-
-          return user.update({
-            sometime: Infinity
-          }, {
-            returning: true
-          });
-        }).then(user => {
-          expect(user.sometime).to.equal(Infinity);
-
-          return user.update({
-            sometime: Infinity
-          });
-        }).then(user => {
-          expect(user.sometime).to.equal(Infinity);
-
-          return user.update({
-            sometime: this.sequelize.fn('NOW')
-          }, {
-            returning: true
-          });
-        }).then(user => {
-          expect(user.sometime).to.be.withinTime(date, new Date());
-
-          // find
-          return User.findAll();
-        }).then(users => {
-          expect(users[0].beforeTime).to.equal(-Infinity);
-          expect(users[0].sometime).to.not.equal(Infinity);
-          expect(users[0].afterTime).to.equal(Infinity);
-
-          return users[0].update({
-            sometime: date
-          });
-        }).then(user => {
-          expect(user.sometime).to.equalTime(date);
-
-          return user.update({
-            sometime: date
-          });
-        }).then(user => {
-          expect(user.sometime).to.equalTime(date);
         });
         });
+
+        const user4 = await User.create({
+          username: 'bob',
+          anotherTime: Infinity
+        }, {
+          validate: true
+        });
+
+        expect(user4.username).to.equal('bob');
+        expect(user4.beforeTime).to.equal(-Infinity);
+        expect(user4.sometime).to.be.withinTime(date, new Date());
+        expect(user4.anotherTime).to.equal(Infinity);
+        expect(user4.afterTime).to.equal(Infinity);
+
+        const user3 = await user4.update({
+          sometime: Infinity
+        }, {
+          returning: true
+        });
+
+        expect(user3.sometime).to.equal(Infinity);
+
+        const user2 = await user3.update({
+          sometime: Infinity
+        });
+
+        expect(user2.sometime).to.equal(Infinity);
+
+        const user1 = await user2.update({
+          sometime: this.sequelize.fn('NOW')
+        }, {
+          returning: true
+        });
+
+        expect(user1.sometime).to.be.withinTime(date, new Date());
+
+        // find
+        const users = await User.findAll();
+        expect(users[0].beforeTime).to.equal(-Infinity);
+        expect(users[0].sometime).to.not.equal(Infinity);
+        expect(users[0].afterTime).to.equal(Infinity);
+
+        const user0 = await users[0].update({
+          sometime: date
+        });
+
+        expect(user0.sometime).to.equalTime(date);
+
+        const user = await user0.update({
+          sometime: date
+        });
+
+        expect(user.sometime).to.equalTime(date);
       });
       });
     });
     });
 
 
     describe('DATEONLY SQL', () => {
     describe('DATEONLY SQL', () => {
       // create dummy user
       // create dummy user
-      it('should be able to create and update records with Infinity/-Infinity', function() {
+      it('should be able to create and update records with Infinity/-Infinity', async function() {
         this.sequelize.options.typeValidation = true;
         this.sequelize.options.typeValidation = true;
 
 
         const date = new Date();
         const date = new Date();
@@ -184,64 +183,63 @@ if (dialect === 'postgres') {
           timestamps: true
           timestamps: true
         });
         });
 
 
-        return User.sync({
+        await User.sync({
           force: true
           force: true
-        }).then(() => {
-          return User.create({
-            username: 'bob',
-            anotherTime: Infinity
-          }, {
-            validate: true
-          });
-        }).then(user => {
-          expect(user.username).to.equal('bob');
-          expect(user.beforeTime).to.equal(-Infinity);
-          expect(new Date(user.sometime)).to.be.withinDate(date, new Date());
-          expect(user.anotherTime).to.equal(Infinity);
-          expect(user.afterTime).to.equal(Infinity);
-
-          return user.update({
-            sometime: Infinity
-          }, {
-            returning: true
-          });
-        }).then(user => {
-          expect(user.sometime).to.equal(Infinity);
-
-          return user.update({
-            sometime: Infinity
-          });
-        }).then(user => {
-          expect(user.sometime).to.equal(Infinity);
-
-          return user.update({
-            sometime: this.sequelize.fn('NOW')
-          }, {
-            returning: true
-          });
-        }).then(user => {
-          expect(user.sometime).to.not.equal(Infinity);
-          expect(new Date(user.sometime)).to.be.withinDate(date, new Date());
-
-          // find
-          return User.findAll();
-        }).then(users => {
-          expect(users[0].beforeTime).to.equal(-Infinity);
-          expect(users[0].sometime).to.not.equal(Infinity);
-          expect(users[0].afterTime).to.equal(Infinity);
-
-          return users[0].update({
-            sometime: '1969-07-20'
-          });
-        }).then(user => {
-          expect(user.sometime).to.equal('1969-07-20');
-
-          return user.update({
-            sometime: '1969-07-20'
-          });
-        }).then(user => {
-          expect(user.sometime).to.equal('1969-07-20');
         });
         });
+
+        const user4 = await User.create({
+          username: 'bob',
+          anotherTime: Infinity
+        }, {
+          validate: true
+        });
+
+        expect(user4.username).to.equal('bob');
+        expect(user4.beforeTime).to.equal(-Infinity);
+        expect(new Date(user4.sometime)).to.be.withinDate(date, new Date());
+        expect(user4.anotherTime).to.equal(Infinity);
+        expect(user4.afterTime).to.equal(Infinity);
+
+        const user3 = await user4.update({
+          sometime: Infinity
+        }, {
+          returning: true
+        });
+
+        expect(user3.sometime).to.equal(Infinity);
+
+        const user2 = await user3.update({
+          sometime: Infinity
+        });
+
+        expect(user2.sometime).to.equal(Infinity);
+
+        const user1 = await user2.update({
+          sometime: this.sequelize.fn('NOW')
+        }, {
+          returning: true
+        });
+
+        expect(user1.sometime).to.not.equal(Infinity);
+        expect(new Date(user1.sometime)).to.be.withinDate(date, new Date());
+
+        // find
+        const users = await User.findAll();
+        expect(users[0].beforeTime).to.equal(-Infinity);
+        expect(users[0].sometime).to.not.equal(Infinity);
+        expect(users[0].afterTime).to.equal(Infinity);
+
+        const user0 = await users[0].update({
+          sometime: '1969-07-20'
+        });
+
+        expect(user0.sometime).to.equal('1969-07-20');
+
+        const user = await user0.update({
+          sometime: '1969-07-20'
+        });
+
+        expect(user.sometime).to.equal('1969-07-20');
       });
       });
     });
     });
 
 

test/integration/dialects/postgres/error.test.js

@@ -11,18 +11,18 @@ const chai      = require('chai'),
 if (dialect.match(/^postgres/)) {
 if (dialect.match(/^postgres/)) {
   describe('[POSTGRES Specific] ExclusionConstraintError', () => {
   describe('[POSTGRES Specific] ExclusionConstraintError', () => {
     const constraintName = 'overlap_period';
     const constraintName = 'overlap_period';
-    beforeEach(function() {
+    beforeEach(async function() {
       this.Booking = this.sequelize.define('Booking', {
       this.Booking = this.sequelize.define('Booking', {
         roomNo: DataTypes.INTEGER,
         roomNo: DataTypes.INTEGER,
         period: DataTypes.RANGE(DataTypes.DATE)
         period: DataTypes.RANGE(DataTypes.DATE)
       });
       });
-      return this.Booking
-        .sync({ force: true })
-        .then(() => {
-          return this.sequelize.query(
-            `ALTER TABLE "${this.Booking.tableName}" ADD CONSTRAINT ${constraintName} EXCLUDE USING gist ("roomNo" WITH =, period WITH &&)`
-          );
-        });
+
+      await this.Booking
+        .sync({ force: true });
+
+      await this.sequelize.query(
+        `ALTER TABLE "${this.Booking.tableName}" ADD CONSTRAINT ${constraintName} EXCLUDE USING gist ("roomNo" WITH =, period WITH &&)`
+      );
     });
     });
 
 
     it('should contain error specific properties', () => {
     it('should contain error specific properties', () => {
@@ -40,23 +40,22 @@ if (dialect.match(/^postgres/)) {
       });
       });
     });
     });
 
 
-    it('should throw ExclusionConstraintError when "period" value overlaps existing', function() {
+    it('should throw ExclusionConstraintError when "period" value overlaps existing', async function() {
       const Booking = this.Booking;
       const Booking = this.Booking;
 
 
-      return Booking
+      await Booking
         .create({
         .create({
           roomNo: 1,
           roomNo: 1,
           guestName: 'Incognito Visitor',
           guestName: 'Incognito Visitor',
           period: [new Date(2015, 0, 1), new Date(2015, 0, 3)]
           period: [new Date(2015, 0, 1), new Date(2015, 0, 3)]
-        })
-        .then(() => {
-          return expect(Booking
-            .create({
-              roomNo: 1,
-              guestName: 'Frequent Visitor',
-              period: [new Date(2015, 0, 2), new Date(2015, 0, 5)]
-            })).to.eventually.be.rejectedWith(Sequelize.ExclusionConstraintError);
         });
         });
+
+      await expect(Booking
+        .create({
+          roomNo: 1,
+          guestName: 'Frequent Visitor',
+          period: [new Date(2015, 0, 2), new Date(2015, 0, 5)]
+        })).to.eventually.be.rejectedWith(Sequelize.ExclusionConstraintError);
     });
     });
 
 
   });
   });

test/integration/dialects/postgres/query-interface.test.js

@@ -16,117 +16,111 @@ if (dialect.match(/^postgres/)) {
     });
     });
 
 
     describe('createSchema', () => {
     describe('createSchema', () => {
-      beforeEach(function() {
+      beforeEach(async function() {
         // make sure we don't have a pre-existing schema called testSchema.
         // make sure we don't have a pre-existing schema called testSchema.
-        return this.queryInterface.dropSchema('testschema').catch(() => {});
+        await this.queryInterface.dropSchema('testschema').catch(() => {});
       });
       });
 
 
-      it('creates a schema', function() {
-        return this.queryInterface.createSchema('testschema')
-          .then(() => this.sequelize.query(`
+      it('creates a schema', async function() {
+        await this.queryInterface.createSchema('testschema');
+
+        const res = await this.sequelize.query(`
             SELECT schema_name
             SELECT schema_name
             FROM information_schema.schemata
             FROM information_schema.schemata
             WHERE schema_name = 'testschema';
             WHERE schema_name = 'testschema';
-          `, { type: this.sequelize.QueryTypes.SELECT }))
-          .then(res => {
-            expect(res, 'query results').to.not.be.empty;
-            expect(res[0].schema_name).to.be.equal('testschema');
-          });
+          `, { type: this.sequelize.QueryTypes.SELECT });
+
+        expect(res, 'query results').to.not.be.empty;
+        expect(res[0].schema_name).to.be.equal('testschema');
       });
       });
 
 
-      it('works even when schema exists', function() {
-        return this.queryInterface.createSchema('testschema')
-          .then(() => this.queryInterface.createSchema('testschema'))
-          .then(() => this.sequelize.query(`
+      it('works even when schema exists', async function() {
+        await this.queryInterface.createSchema('testschema');
+        await this.queryInterface.createSchema('testschema');
+
+        const res = await this.sequelize.query(`
             SELECT schema_name
             SELECT schema_name
             FROM information_schema.schemata
             FROM information_schema.schemata
             WHERE schema_name = 'testschema';
             WHERE schema_name = 'testschema';
-          `, { type: this.sequelize.QueryTypes.SELECT }))
-          .then(res => {
-            expect(res, 'query results').to.not.be.empty;
-            expect(res[0].schema_name).to.be.equal('testschema');
-          });
+          `, { type: this.sequelize.QueryTypes.SELECT });
+
+        expect(res, 'query results').to.not.be.empty;
+        expect(res[0].schema_name).to.be.equal('testschema');
       });
       });
     });
     });
 
 
     describe('databaseVersion', () => {
     describe('databaseVersion', () => {
-      it('reports version', function() {
-        return this.queryInterface.databaseVersion()
-          .then(res => {
-            // check that result matches expected version number format. example 9.5.4
-            expect(res).to.match(/\d\.\d/);
-          });
+      it('reports version', async function() {
+        const res = await this.queryInterface.databaseVersion();
+        // check that result matches expected version number format. example 9.5.4
+        expect(res).to.match(/\d\.\d/);
       });
       });
     });
     });
 
 
     describe('renameFunction', () => {
     describe('renameFunction', () => {
-      beforeEach(function() {
+      beforeEach(async function() {
         // ensure the function names we'll use don't exist before we start.
         // ensure the function names we'll use don't exist before we start.
         // then setup our function to rename
         // then setup our function to rename
-        return this.queryInterface.dropFunction('rftest1', [])
-          .catch(() => {})
-          .then(() => this.queryInterface.dropFunction('rftest2', []))
-          .catch(() => {})
-          .then(() => this.queryInterface.createFunction('rftest1', [], 'varchar', 'plpgsql', 'return \'testreturn\';', {}));
+        await this.queryInterface.dropFunction('rftest1', [])
+          .catch(() => {});
+
+        await this.queryInterface.dropFunction('rftest2', [])
+          .catch(() => {});
+
+        await this.queryInterface.createFunction('rftest1', [], 'varchar', 'plpgsql', 'return \'testreturn\';', {});
       });
       });
 
 
-      it('renames a function', function() {
-        return this.queryInterface.renameFunction('rftest1', [], 'rftest2')
-          .then(() => this.sequelize.query('select rftest2();', { type: this.sequelize.QueryTypes.SELECT }))
-          .then(res => {
-            expect(res[0].rftest2).to.be.eql('testreturn');
-          });
+      it('renames a function', async function() {
+        await this.queryInterface.renameFunction('rftest1', [], 'rftest2');
+        const res = await this.sequelize.query('select rftest2();', { type: this.sequelize.QueryTypes.SELECT });
+        expect(res[0].rftest2).to.be.eql('testreturn');
       });
       });
     });
     });
 
 
     describe('createFunction', () => {
     describe('createFunction', () => {
 
 
-      beforeEach(function() {
+      beforeEach(async function() {
         // make sure we don't have a pre-existing function called create_job
         // make sure we don't have a pre-existing function called create_job
         // this is needed to cover the edge case of afterEach not getting called because of an unexpected issue or stopage with the
         // this is needed to cover the edge case of afterEach not getting called because of an unexpected issue or stopage with the
         // test suite causing a failure of afterEach's cleanup to be called.
         // test suite causing a failure of afterEach's cleanup to be called.
-        return this.queryInterface.dropFunction('create_job', [{ type: 'varchar', name: 'test' }])
+        await this.queryInterface.dropFunction('create_job', [{ type: 'varchar', name: 'test' }])
           // suppress errors here. if create_job doesn't exist thats ok.
           // suppress errors here. if create_job doesn't exist thats ok.
           .catch(() => {});
           .catch(() => {});
       });
       });
 
 
-      after(function() {
+      after(async function() {
         // cleanup
         // cleanup
-        return this.queryInterface.dropFunction('create_job', [{ type: 'varchar', name: 'test' }])
+        await this.queryInterface.dropFunction('create_job', [{ type: 'varchar', name: 'test' }])
           // suppress errors here. if create_job doesn't exist thats ok.
           // suppress errors here. if create_job doesn't exist thats ok.
           .catch(() => {});
           .catch(() => {});
       });
       });
 
 
-      it('creates a stored procedure', function() {
+      it('creates a stored procedure', async function() {
         const body = 'return test;';
         const body = 'return test;';
         const options = {};
         const options = {};
 
 
         // make our call to create a function
         // make our call to create a function
-        return this.queryInterface.createFunction('create_job', [{ type: 'varchar', name: 'test' }], 'varchar', 'plpgsql', body, options)
-          // validate
-          .then(() => this.sequelize.query('select create_job(\'test\');', { type: this.sequelize.QueryTypes.SELECT }))
-          .then(res => {
-            expect(res[0].create_job).to.be.eql('test');
-          });
+        await this.queryInterface.createFunction('create_job', [{ type: 'varchar', name: 'test' }], 'varchar', 'plpgsql', body, options);
+        // validate
+        const res = await this.sequelize.query('select create_job(\'test\');', { type: this.sequelize.QueryTypes.SELECT });
+        expect(res[0].create_job).to.be.eql('test');
       });
       });
 
 
-      it('treats options as optional', function() {
+      it('treats options as optional', async function() {
         const body = 'return test;';
         const body = 'return test;';
 
 
         // run with null options parameter
         // run with null options parameter
-        return this.queryInterface.createFunction('create_job', [{ type: 'varchar', name: 'test' }], 'varchar', 'plpgsql', body, null)
-          // validate
-          .then(() => this.sequelize.query('select create_job(\'test\');', { type: this.sequelize.QueryTypes.SELECT }))
-          .then(res => {
-            expect(res[0].create_job).to.be.eql('test');
-          });
+        await this.queryInterface.createFunction('create_job', [{ type: 'varchar', name: 'test' }], 'varchar', 'plpgsql', body, null);
+        // validate
+        const res = await this.sequelize.query('select create_job(\'test\');', { type: this.sequelize.QueryTypes.SELECT });
+        expect(res[0].create_job).to.be.eql('test');
       });
       });
 
 
-      it('produces an error when missing expected parameters', function() {
+      it('produces an error when missing expected parameters', async function() {
         const body = 'return 1;';
         const body = 'return 1;';
         const options = {};
         const options = {};
 
 
-        return Promise.all([
+        await Promise.all([
           // requires functionName
           // requires functionName
           expect(this.queryInterface.createFunction(null, [{ name: 'test' }], 'integer', 'plpgsql', body, options))
           expect(this.queryInterface.createFunction(null, [{ name: 'test' }], 'integer', 'plpgsql', body, options))
             .to.be.rejectedWith(/createFunction missing some parameters. Did you pass functionName, returnType, language and body/),
             .to.be.rejectedWith(/createFunction missing some parameters. Did you pass functionName, returnType, language and body/),
@@ -153,19 +147,25 @@ if (dialect.match(/^postgres/)) {
         ]);
         ]);
       });
       });
 
 
-      it('overrides a function', function() {
+      it('overrides a function', async function() {
         const first_body = 'return \'first\';';
         const first_body = 'return \'first\';';
         const second_body = 'return \'second\';';
         const second_body = 'return \'second\';';
 
 
         // create function
         // create function
-        return this.queryInterface.createFunction('create_job', [{ type: 'varchar', name: 'test' }], 'varchar', 'plpgsql', first_body, null)
-          // override
-          .then(() => this.queryInterface.createFunction('create_job', [{ type: 'varchar', name: 'test' }], 'varchar', 'plpgsql', second_body, null, { force: true }))
-          // validate
-          .then(() => this.sequelize.query("select create_job('abc');", { type: this.sequelize.QueryTypes.SELECT }))
-          .then(res => {
-            expect(res[0].create_job).to.be.eql('second');
-          });
+        await this.queryInterface.createFunction('create_job', [{ type: 'varchar', name: 'test' }], 'varchar', 'plpgsql', first_body, null);
+        // override
+        await this.queryInterface.createFunction(
+          'create_job',
+          [{ type: 'varchar', name: 'test' }],
+          'varchar',
+          'plpgsql',
+          second_body,
+          null,
+          { force: true }
+        );
+        // validate
+        const res = await this.sequelize.query("select create_job('abc');", { type: this.sequelize.QueryTypes.SELECT });
+        expect(res[0].create_job).to.be.eql('second');
       });
       });
 
 
       it('produces an error when options.variables is missing expected parameters', function() {
       it('produces an error when options.variables is missing expected parameters', function() {
@@ -180,43 +180,45 @@ if (dialect.match(/^postgres/)) {
           .to.be.rejectedWith(/function variable must have a name and type/);
           .to.be.rejectedWith(/function variable must have a name and type/);
       });
       });
 
 
-      it('uses declared variables', function() {
+      it('uses declared variables', async function() {
         const body = 'RETURN myVar + 1;';
         const body = 'RETURN myVar + 1;';
         const options = { variables: [{ type: 'integer', name: 'myVar', default: 100 }] };
         const options = { variables: [{ type: 'integer', name: 'myVar', default: 100 }] };
-        return this.queryInterface.createFunction('add_one', [], 'integer', 'plpgsql', body, [], options)
-          .then(() => this.sequelize.query('select add_one();', { type: this.sequelize.QueryTypes.SELECT }))
-          .then(res => {
-            expect(res[0].add_one).to.be.eql(101);
-          });
+        await this.queryInterface.createFunction('add_one', [], 'integer', 'plpgsql', body, [], options);
+        const res = await this.sequelize.query('select add_one();', { type: this.sequelize.QueryTypes.SELECT });
+        expect(res[0].add_one).to.be.eql(101);
       });
       });
     });
     });
 
 
     describe('dropFunction', () => {
     describe('dropFunction', () => {
-      beforeEach(function() {
+      beforeEach(async function() {
         const body = 'return test;';
         const body = 'return test;';
         const options = {};
         const options = {};
 
 
         // make sure we have a droptest function in place.
         // make sure we have a droptest function in place.
-        return this.queryInterface.createFunction('droptest', [{ type: 'varchar', name: 'test' }], 'varchar', 'plpgsql', body, options)
+        await this.queryInterface.createFunction(
+          'droptest',
+          [{ type: 'varchar', name: 'test' }],
+          'varchar',
+          'plpgsql',
+          body,
+          options
+        )
           // suppress errors.. this could fail if the function is already there.. thats ok.
           // suppress errors.. this could fail if the function is already there.. thats ok.
           .catch(() => {});
           .catch(() => {});
       });
       });
 
 
-      it('can drop a function', function() {
-        return expect(
-          // call drop function
-          this.queryInterface.dropFunction('droptest', [{ type: 'varchar', name: 'test' }])
-            // now call the function we attempted to drop.. if dropFunction worked as expect it should produce an error.
-            .then(() => {
-              // call the function we attempted to drop.. if it is still there then throw an error informing that the expected behavior is not met.
-              return this.sequelize.query('select droptest(\'test\');', { type: this.sequelize.QueryTypes.SELECT });
-            })
+      it('can drop a function', async function() {
+        // call drop function
+        await this.queryInterface.dropFunction('droptest', [{ type: 'varchar', name: 'test' }]);
+        await expect(
+          // now call the function we attempted to drop.. if dropFunction worked as expect it should produce an error.
+          this.sequelize.query('select droptest(\'test\');', { type: this.sequelize.QueryTypes.SELECT })
         // test that we did get the expected error indicating that droptest was properly removed.
         // test that we did get the expected error indicating that droptest was properly removed.
         ).to.be.rejectedWith(/.*function droptest.* does not exist/);
         ).to.be.rejectedWith(/.*function droptest.* does not exist/);
       });
       });
 
 
-      it('produces an error when missing expected parameters', function() {
-        return Promise.all([
+      it('produces an error when missing expected parameters', async function() {
+        await Promise.all([
           expect(this.queryInterface.dropFunction())
           expect(this.queryInterface.dropFunction())
             .to.be.rejectedWith(/.*requires functionName/),
             .to.be.rejectedWith(/.*requires functionName/),
 
 
@@ -230,46 +232,43 @@ if (dialect.match(/^postgres/)) {
     });
     });
 
 
     describe('indexes', () => {
     describe('indexes', () => {
-      beforeEach(function() {
-        return this.queryInterface.dropTable('Group')
-          .then(() => this.queryInterface.createTable('Group', {
-            username: DataTypes.STRING,
-            isAdmin: DataTypes.BOOLEAN,
-            from: DataTypes.STRING
-          }));
+      beforeEach(async function() {
+        await this.queryInterface.dropTable('Group');
+
+        await this.queryInterface.createTable('Group', {
+          username: DataTypes.STRING,
+          isAdmin: DataTypes.BOOLEAN,
+          from: DataTypes.STRING
+        });
       });
       });
 
 
-      it('supports newlines', function() {
-        return this.queryInterface.addIndex('Group', [this.sequelize.literal(`(
+      it('supports newlines', async function() {
+        await this.queryInterface.addIndex('Group', [this.sequelize.literal(`(
             CASE "username"
             CASE "username"
               WHEN 'foo' THEN 'bar'
               WHEN 'foo' THEN 'bar'
               ELSE 'baz'
               ELSE 'baz'
             END
             END
-          )`)], { name: 'group_username_case' })
-          .then(() => this.queryInterface.showIndex('Group'))
-          .then(indexes => {
-            const indexColumns = _.uniq(indexes.map(index => index.name));
+          )`)], { name: 'group_username_case' });
+
+        const indexes = await this.queryInterface.showIndex('Group');
+        const indexColumns = _.uniq(indexes.map(index => index.name));
 
 
-            expect(indexColumns).to.include('group_username_case');
-          });
+        expect(indexColumns).to.include('group_username_case');
       });
       });
 
 
-      it('adds, reads and removes a named functional index to the table', function() {
-        return this.queryInterface.addIndex('Group', [this.sequelize.fn('lower', this.sequelize.col('username'))], {
+      it('adds, reads and removes a named functional index to the table', async function() {
+        await this.queryInterface.addIndex('Group', [this.sequelize.fn('lower', this.sequelize.col('username'))], {
           name: 'group_username_lower'
           name: 'group_username_lower'
-        })
-          .then(() => this.queryInterface.showIndex('Group'))
-          .then(indexes => {
-            const indexColumns = _.uniq(indexes.map(index => index.name));
-
-            expect(indexColumns).to.include('group_username_lower');
-          })
-          .then(() => this.queryInterface.removeIndex('Group', 'group_username_lower'))
-          .then(() => this.queryInterface.showIndex('Group'))
-          .then(indexes => {
-            const indexColumns = _.uniq(indexes.map(index => index.name));
-            expect(indexColumns).to.be.empty;
-          });
+        });
+
+        const indexes0 = await this.queryInterface.showIndex('Group');
+        const indexColumns0 = _.uniq(indexes0.map(index => index.name));
+
+        expect(indexColumns0).to.include('group_username_lower');
+        await this.queryInterface.removeIndex('Group', 'group_username_lower');
+        const indexes = await this.queryInterface.showIndex('Group');
+        const indexColumns = _.uniq(indexes.map(index => index.name));
+        expect(indexColumns).to.be.empty;
       });
       });
     });
     });
   });
   });

test/integration/dialects/postgres/query.test.js

@@ -12,7 +12,7 @@ if (dialect.match(/^postgres/)) {
     const taskAlias = 'AnActualVeryLongAliasThatShouldBreakthePostgresLimitOfSixtyFourCharacters';
     const taskAlias = 'AnActualVeryLongAliasThatShouldBreakthePostgresLimitOfSixtyFourCharacters';
     const teamAlias = 'Toto';
     const teamAlias = 'Toto';
 
 
-    const executeTest = (options, test) => {
+    const executeTest = async (options, test) => {
       const sequelize = Support.createSequelizeInstance(options);
       const sequelize = Support.createSequelizeInstance(options);
 
 
       const User = sequelize.define('User', { name: DataTypes.STRING, updatedAt: DataTypes.DATE }, { underscored: true });
       const User = sequelize.define('User', { name: DataTypes.STRING, updatedAt: DataTypes.DATE }, { underscored: true });
@@ -23,48 +23,43 @@ if (dialect.match(/^postgres/)) {
       User.belongsToMany(Team, { as: teamAlias, foreignKey: 'teamId', through: 'UserTeam' });
       User.belongsToMany(Team, { as: teamAlias, foreignKey: 'teamId', through: 'UserTeam' });
       Team.belongsToMany(User, { foreignKey: 'userId', through: 'UserTeam' });
       Team.belongsToMany(User, { foreignKey: 'userId', through: 'UserTeam' });
 
 
-      return sequelize.sync({ force: true }).then(() => {
-        return Team.create({ name: 'rocket' }).then(team => {
-          return Task.create({ title: 'SuperTask' }).then(task => {
-            return User.create({ name: 'test', task_id: task.id, updatedAt: new Date() }).then(user => {
-              return user[`add${teamAlias}`](team).then(() => {
-                return User.findOne({
-                  include: [
-                    {
-                      model: Task,
-                      as: taskAlias
-                    },
-                    {
-                      model: Team,
-                      as: teamAlias
-                    }
-                  ]
-                }).then(test);
-              });
-            });
-          });
-        });
-      });
+      await sequelize.sync({ force: true });
+      const team = await Team.create({ name: 'rocket' });
+      const task = await Task.create({ title: 'SuperTask' });
+      const user = await User.create({ name: 'test', task_id: task.id, updatedAt: new Date() });
+      await user[`add${teamAlias}`](team);
 
 
+      return test(await User.findOne({
+        include: [
+          {
+            model: Task,
+            as: taskAlias
+          },
+          {
+            model: Team,
+            as: teamAlias
+          }
+        ]
+      }));
     };
     };
 
 
-    it('should throw due to alias being truncated', function() {
+    it('should throw due to alias being truncated', async function() {
       const options = { ...this.sequelize.options, minifyAliases: false };
       const options = { ...this.sequelize.options, minifyAliases: false };
 
 
-      return executeTest(options, res => {
+      await executeTest(options, res => {
         expect(res[taskAlias]).to.not.exist;
         expect(res[taskAlias]).to.not.exist;
       });
       });
     });
     });
 
 
-    it('should be able to retrieve include due to alias minifying', function() {
+    it('should be able to retrieve include due to alias minifying', async function() {
       const options = { ...this.sequelize.options, minifyAliases: true };
       const options = { ...this.sequelize.options, minifyAliases: true };
 
 
-      return executeTest(options, res => {
+      await executeTest(options, res => {
         expect(res[taskAlias].title).to.be.equal('SuperTask');
         expect(res[taskAlias].title).to.be.equal('SuperTask');
       });
       });
     });
     });
 
 
-    it('should throw due to table name being truncated', () => {
+    it('should throw due to table name being truncated', async () => {
       const sequelize = Support.createSequelizeInstance({ minifyAliases: true });
       const sequelize = Support.createSequelizeInstance({ minifyAliases: true });
 
 
       const User = sequelize.define('user_model_name_that_is_long_for_demo_but_also_surpasses_the_character_limit',
       const User = sequelize.define('user_model_name_that_is_long_for_demo_but_also_surpasses_the_character_limit',
@@ -95,19 +90,16 @@ if (dialect.match(/^postgres/)) {
       User.hasMany(Project, { foreignKey: 'userId' });
       User.hasMany(Project, { foreignKey: 'userId' });
       Project.belongsTo(Company, { foreignKey: 'companyId' });
       Project.belongsTo(Company, { foreignKey: 'companyId' });
 
 
-      return sequelize.sync({ force: true }).then(() => {
-        return Company.create({ name: 'Sequelize' }).then(comp => {
-          return User.create({ name: 'standard user' }).then(user => {
-            return Project.create({ name: 'Manhattan', companyId: comp.id, userId: user.id }).then(() => {
-              return User.findAll({
-                include: {
-                  model: Project,
-                  include: Company
-                }
-              });
-            });
-          });
-        });
+      await sequelize.sync({ force: true });
+      const comp = await Company.create({ name: 'Sequelize' });
+      const user = await User.create({ name: 'standard user' });
+      await Project.create({ name: 'Manhattan', companyId: comp.id, userId: user.id });
+
+      await User.findAll({
+        include: {
+          model: Project,
+          include: Company
+        }
       });
       });
     });
     });
   });
   });

test/integration/dialects/postgres/range.test.js

@@ -184,16 +184,16 @@ if (dialect.match(/^postgres/)) {
         expect(range.parse('some_non_array')).to.deep.equal('some_non_array');
         expect(range.parse('some_non_array')).to.deep.equal('some_non_array');
       });
       });
 
 
-      it('should handle native postgres timestamp format', () => {
+      it('should handle native postgres timestamp format', async () => {
         // Make sure nameOidMap is loaded
         // Make sure nameOidMap is loaded
-        return Support.sequelize.connectionManager.getConnection().then(connection => {
-          Support.sequelize.connectionManager.releaseConnection(connection);
+        const connection = await Support.sequelize.connectionManager.getConnection();
 
 
-          const tsName = DataTypes.postgres.DATE.types.postgres[0],
-            tsOid = Support.sequelize.connectionManager.nameOidMap[tsName].oid,
-            parser = pg.types.getTypeParser(tsOid);
-          expect(range.parse('(2016-01-01 08:00:00-04,)', parser)[0].value.toISOString()).to.equal('2016-01-01T12:00:00.000Z');
-        });
+        Support.sequelize.connectionManager.releaseConnection(connection);
+
+        const tsName = DataTypes.postgres.DATE.types.postgres[0],
+          tsOid = Support.sequelize.connectionManager.nameOidMap[tsName].oid,
+          parser = pg.types.getTypeParser(tsOid);
+        expect(range.parse('(2016-01-01 08:00:00-04,)', parser)[0].value.toISOString()).to.equal('2016-01-01T12:00:00.000Z');
       });
       });
 
 
     });
     });

test/integration/dialects/postgres/regressions.test.js

@@ -8,7 +8,7 @@ const chai = require('chai'),
 
 
 if (dialect.match(/^postgres/)) {
 if (dialect.match(/^postgres/)) {
   describe('[POSTGRES Specific] Regressions', () => {
   describe('[POSTGRES Specific] Regressions', () => {
-    it('properly fetch OIDs after sync, #8749', function() {
+    it('properly fetch OIDs after sync, #8749', async function() {
       const User = this.sequelize.define('User', {
       const User = this.sequelize.define('User', {
         active: Sequelize.BOOLEAN
         active: Sequelize.BOOLEAN
       });
       });
@@ -27,24 +27,18 @@ if (dialect.match(/^postgres/)) {
       User.hasMany(Media);
       User.hasMany(Media);
       Media.belongsTo(User);
       Media.belongsTo(User);
 
 
-      return this.sequelize
-        .sync({ force: true })
-        .then(() => User.create({ active: true }))
-        .then(user => {
-          expect(user.active).to.be.true;
-          expect(user.get('active')).to.be.true;
-
-          return User.findOne();
-        })
-        .then(user => {
-          expect(user.active).to.be.true;
-          expect(user.get('active')).to.be.true;
-
-          return User.findOne({ raw: true });
-        })
-        .then(user => {
-          expect(user.active).to.be.true;
-        });
+      await this.sequelize.sync({ force: true });
+
+      const user1 = await User.create({ active: true });
+      expect(user1.active).to.be.true;
+      expect(user1.get('active')).to.be.true;
+
+      const user0 = await User.findOne();
+      expect(user0.active).to.be.true;
+      expect(user0.get('active')).to.be.true;
+
+      const user = await User.findOne({ raw: true });
+      expect(user.active).to.be.true;
     });
     });
   });
   });
 }
 }

test/integration/dialects/sqlite/connection-manager.test.js

@@ -18,52 +18,48 @@ if (dialect === 'sqlite') {
       jetpack.remove(directoryName);
       jetpack.remove(directoryName);
     });
     });
 
 
-    it('close connection and remove journal and wal files', function() {
+    it('close connection and remove journal and wal files', async function() {
       const sequelize = Support.createSequelizeInstance({
       const sequelize = Support.createSequelizeInstance({
         storage: jetpack.path(fileName)
         storage: jetpack.path(fileName)
       });
       });
       const User = sequelize.define('User', { username: DataTypes.STRING });
       const User = sequelize.define('User', { username: DataTypes.STRING });
 
 
-      return User
-        .sync({ force: true })
-        .then(() => sequelize.query('PRAGMA journal_mode = WAL'))
-        .then(() => User.create({ username: 'user1' }))
-        .then(() => {
-          return sequelize.transaction(transaction => {
-            return User.create({ username: 'user2' }, { transaction });
-          });
-        })
-        .then(async () => {
-          expect(jetpack.exists(fileName)).to.be.equal('file');
-          expect(jetpack.exists(`${fileName}-shm`), 'shm file should exists').to.be.equal('file');
-          expect(jetpack.exists(`${fileName}-wal`), 'wal file should exists').to.be.equal('file');
+      await User.sync({ force: true });
 
 
-          // move wal file content to main database
-          // so those files can be removed on connection close
-          // https://www.sqlite.org/wal.html#ckpt
-          await sequelize.query('PRAGMA wal_checkpoint');
+      await sequelize.query('PRAGMA journal_mode = WAL');
+      await User.create({ username: 'user1' });
 
 
-          // wal, shm files exist after checkpoint
-          expect(jetpack.exists(`${fileName}-shm`), 'shm file should exists').to.be.equal('file');
-          expect(jetpack.exists(`${fileName}-wal`), 'wal file should exists').to.be.equal('file');
+      await sequelize.transaction(transaction => {
+        return User.create({ username: 'user2' }, { transaction });
+      });
+
+      expect(jetpack.exists(fileName)).to.be.equal('file');
+      expect(jetpack.exists(`${fileName}-shm`), 'shm file should exists').to.be.equal('file');
+      expect(jetpack.exists(`${fileName}-wal`), 'wal file should exists').to.be.equal('file');
+
+      // move wal file content to main database
+      // so those files can be removed on connection close
+      // https://www.sqlite.org/wal.html#ckpt
+      await sequelize.query('PRAGMA wal_checkpoint');
 
 
-          return sequelize.close();
-        })
-        .then(() => {
-          expect(jetpack.exists(fileName)).to.be.equal('file');
-          expect(jetpack.exists(`${fileName}-shm`), 'shm file exists').to.be.false;
-          expect(jetpack.exists(`${fileName}-wal`), 'wal file exists').to.be.false;
+      // wal, shm files exist after checkpoint
+      expect(jetpack.exists(`${fileName}-shm`), 'shm file should exists').to.be.equal('file');
+      expect(jetpack.exists(`${fileName}-wal`), 'wal file should exists').to.be.equal('file');
 
 
-          return this.sequelize.query('PRAGMA journal_mode = DELETE');
-        });
+      await sequelize.close();
+      expect(jetpack.exists(fileName)).to.be.equal('file');
+      expect(jetpack.exists(`${fileName}-shm`), 'shm file exists').to.be.false;
+      expect(jetpack.exists(`${fileName}-wal`), 'wal file exists').to.be.false;
+
+      await this.sequelize.query('PRAGMA journal_mode = DELETE');
     });
     });
 
 
-    it('automatic path provision for `options.storage`', () => {
-      return Support.createSequelizeInstance({ storage: nestedFileName })
+    it('automatic path provision for `options.storage`', async () => {
+      await Support.createSequelizeInstance({ storage: nestedFileName })
         .define('User', { username: DataTypes.STRING })
         .define('User', { username: DataTypes.STRING })
-        .sync({ force: true }).then(() => {
-          expect(jetpack.exists(nestedFileName)).to.be.equal('file');
-        });
+        .sync({ force: true });
+
+      expect(jetpack.exists(nestedFileName)).to.be.equal('file');
     });
     });
   });
   });
 }
 }

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

@@ -14,14 +14,14 @@ if (dialect === 'sqlite') {
       this.sequelize.options.storage = ':memory:';
       this.sequelize.options.storage = ':memory:';
     });
     });
 
 
-    beforeEach(function() {
+    beforeEach(async function() {
       this.sequelize.options.storage = dbFile;
       this.sequelize.options.storage = dbFile;
       this.User = this.sequelize.define('User', {
       this.User = this.sequelize.define('User', {
         age: DataTypes.INTEGER,
         age: DataTypes.INTEGER,
         name: DataTypes.STRING,
         name: DataTypes.STRING,
         bio: DataTypes.TEXT
         bio: DataTypes.TEXT
       });
       });
-      return this.User.sync({ force: true });
+      await this.User.sync({ force: true });
     });
     });
 
 
     storages.forEach(storage => {
     storages.forEach(storage => {
@@ -33,137 +33,128 @@ if (dialect === 'sqlite') {
         });
         });
 
 
         describe('create', () => {
         describe('create', () => {
-          it('creates a table entry', function() {
-            return this.User.create({ age: 21, name: 'John Wayne', bio: 'noot noot' }).then(user => {
-              expect(user.age).to.equal(21);
-              expect(user.name).to.equal('John Wayne');
-              expect(user.bio).to.equal('noot noot');
-
-              return this.User.findAll().then(users => {
-                const usernames = users.map(user => {
-                  return user.name;
-                });
-                expect(usernames).to.contain('John Wayne');
-              });
+          it('creates a table entry', async function() {
+            const user = await this.User.create({ age: 21, name: 'John Wayne', bio: 'noot noot' });
+            expect(user.age).to.equal(21);
+            expect(user.name).to.equal('John Wayne');
+            expect(user.bio).to.equal('noot noot');
+
+            const users = await this.User.findAll();
+            const usernames = users.map(user => {
+              return user.name;
             });
             });
+            expect(usernames).to.contain('John Wayne');
           });
           });
 
 
-          it('should allow the creation of an object with options as attribute', function() {
+          it('should allow the creation of an object with options as attribute', async function() {
             const Person = this.sequelize.define('Person', {
             const Person = this.sequelize.define('Person', {
               name: DataTypes.STRING,
               name: DataTypes.STRING,
               options: DataTypes.TEXT
               options: DataTypes.TEXT
             });
             });
 
 
-            return Person.sync({ force: true }).then(() => {
-              const options = JSON.stringify({ foo: 'bar', bar: 'foo' });
+            await Person.sync({ force: true });
+            const options = JSON.stringify({ foo: 'bar', bar: 'foo' });
 
 
-              return Person.create({
-                name: 'John Doe',
-                options
-              }).then(people => {
-                expect(people.options).to.deep.equal(options);
-              });
+            const people = await Person.create({
+              name: 'John Doe',
+              options
             });
             });
+
+            expect(people.options).to.deep.equal(options);
           });
           });
 
 
-          it('should allow the creation of an object with a boolean (true) as attribute', function() {
+          it('should allow the creation of an object with a boolean (true) as attribute', async function() {
             const Person = this.sequelize.define('Person', {
             const Person = this.sequelize.define('Person', {
               name: DataTypes.STRING,
               name: DataTypes.STRING,
               has_swag: DataTypes.BOOLEAN
               has_swag: DataTypes.BOOLEAN
             });
             });
 
 
-            return Person.sync({ force: true }).then(() => {
-              return Person.create({
-                name: 'John Doe',
-                has_swag: true
-              }).then(people => {
-                expect(people.has_swag).to.be.ok;
-              });
+            await Person.sync({ force: true });
+
+            const people = await Person.create({
+              name: 'John Doe',
+              has_swag: true
             });
             });
+
+            expect(people.has_swag).to.be.ok;
           });
           });
 
 
-          it('should allow the creation of an object with a boolean (false) as attribute', function() {
+          it('should allow the creation of an object with a boolean (false) as attribute', async function() {
             const Person = this.sequelize.define('Person', {
             const Person = this.sequelize.define('Person', {
               name: DataTypes.STRING,
               name: DataTypes.STRING,
               has_swag: DataTypes.BOOLEAN
               has_swag: DataTypes.BOOLEAN
             });
             });
 
 
-            return Person.sync({ force: true }).then(() => {
-              return Person.create({
-                name: 'John Doe',
-                has_swag: false
-              }).then(people => {
-                expect(people.has_swag).to.not.be.ok;
-              });
+            await Person.sync({ force: true });
+
+            const people = await Person.create({
+              name: 'John Doe',
+              has_swag: false
             });
             });
+
+            expect(people.has_swag).to.not.be.ok;
           });
           });
         });
         });
 
 
         describe('.findOne', () => {
         describe('.findOne', () => {
-          beforeEach(function() {
-            return this.User.create({ name: 'user', bio: 'footbar' });
+          beforeEach(async function() {
+            await this.User.create({ name: 'user', bio: 'footbar' });
           });
           });
 
 
-          it('finds normal lookups', function() {
-            return this.User.findOne({ where: { name: 'user' } }).then(user => {
-              expect(user.name).to.equal('user');
-            });
+          it('finds normal lookups', async function() {
+            const user = await this.User.findOne({ where: { name: 'user' } });
+            expect(user.name).to.equal('user');
           });
           });
 
 
-          it.skip('should make aliased attributes available', function() {
-            return this.User.findOne({
+          it.skip('should make aliased attributes available', async function() { // eslint-disable-line mocha/no-skipped-tests
+            const user = await this.User.findOne({
               where: { name: 'user' },
               where: { name: 'user' },
               attributes: ['id', ['name', 'username']]
               attributes: ['id', ['name', 'username']]
-            }).then(user => {
-              expect(user.username).to.equal('user');
             });
             });
+
+            expect(user.username).to.equal('user');
           });
           });
         });
         });
 
 
         describe('.all', () => {
         describe('.all', () => {
-          beforeEach(function() {
-            return this.User.bulkCreate([
+          beforeEach(async function() {
+            await this.User.bulkCreate([
               { name: 'user', bio: 'foobar' },
               { name: 'user', bio: 'foobar' },
               { name: 'user', bio: 'foobar' }
               { name: 'user', bio: 'foobar' }
             ]);
             ]);
           });
           });
 
 
-          it('should return all users', function() {
-            return this.User.findAll().then(users => {
-              expect(users).to.have.length(2);
-            });
+          it('should return all users', async function() {
+            const users = await this.User.findAll();
+            expect(users).to.have.length(2);
           });
           });
         });
         });
 
 
         describe('.min', () => {
         describe('.min', () => {
-          it('should return the min value', function() {
+          it('should return the min value', async function() {
             const users = [];
             const users = [];
 
 
             for (let i = 2; i < 5; i++) {
             for (let i = 2; i < 5; i++) {
               users[users.length] = { age: i };
               users[users.length] = { age: i };
             }
             }
 
 
-            return this.User.bulkCreate(users).then(() => {
-              return this.User.min('age').then(min => {
-                expect(min).to.equal(2);
-              });
-            });
+            await this.User.bulkCreate(users);
+            const min = await this.User.min('age');
+            expect(min).to.equal(2);
           });
           });
         });
         });
 
 
         describe('.max', () => {
         describe('.max', () => {
-          it('should return the max value', function() {
+          it('should return the max value', async function() {
             const users = [];
             const users = [];
 
 
             for (let i = 2; i <= 5; i++) {
             for (let i = 2; i <= 5; i++) {
               users[users.length] = { age: i };
               users[users.length] = { age: i };
             }
             }
 
 
-            return this.User.bulkCreate(users).then(() => {
-              return this.User.max('age').then(min => {
-                expect(min).to.equal(5);
-              });
-            });
+            await this.User.bulkCreate(users);
+            const min = await this.User.max('age');
+            expect(min).to.equal(5);
           });
           });
         });
         });
       });
       });

test/integration/dialects/sqlite/dao.test.js

@@ -10,7 +10,7 @@ const chai = require('chai'),
 
 
 if (dialect === 'sqlite') {
 if (dialect === 'sqlite') {
   describe('[SQLITE Specific] DAO', () => {
   describe('[SQLITE Specific] DAO', () => {
-    beforeEach(function() {
+    beforeEach(async function() {
       this.User = this.sequelize.define('User', {
       this.User = this.sequelize.define('User', {
         username: DataTypes.STRING,
         username: DataTypes.STRING,
         emergency_contact: DataTypes.JSON,
         emergency_contact: DataTypes.JSON,
@@ -28,90 +28,90 @@ if (dialect === 'sqlite') {
       });
       });
 
 
       this.User.hasMany(this.Project);
       this.User.hasMany(this.Project);
-      return this.sequelize.sync({ force: true });
+      await this.sequelize.sync({ force: true });
     });
     });
 
 
     describe('findAll', () => {
     describe('findAll', () => {
-      it('handles dates correctly', function() {
+      it('handles dates correctly', async function() {
         const user = this.User.build({ username: 'user' });
         const user = this.User.build({ username: 'user' });
 
 
         user.dataValues.createdAt = new Date(2011, 4, 4);
         user.dataValues.createdAt = new Date(2011, 4, 4);
 
 
-        return user.save().then(() => {
-          return this.User.create({ username: 'new user' }).then(() => {
-            return this.User.findAll({
-              where: { createdAt: { [Op.gt]: new Date(2012, 1, 1) } }
-            }).then(users => {
-              expect(users).to.have.length(1);
-            });
-          });
+        await user.save();
+        await this.User.create({ username: 'new user' });
+
+        const users = await this.User.findAll({
+          where: { createdAt: { [Op.gt]: new Date(2012, 1, 1) } }
         });
         });
+
+        expect(users).to.have.length(1);
       });
       });
 
 
-      it('handles dates with aliasses correctly #3611', function() {
-        return this.User.create({
+      it('handles dates with aliasses correctly #3611', async function() {
+        await this.User.create({
           dateField: new Date(2010, 10, 10)
           dateField: new Date(2010, 10, 10)
-        }).then(() => {
-          return this.User.findAll().then(obj => obj[0]);
-        }).then(user => {
-          expect(user.get('dateField')).to.be.an.instanceof(Date);
-          expect(user.get('dateField')).to.equalTime(new Date(2010, 10, 10));
         });
         });
+
+        const obj = await this.User.findAll();
+        const user = await obj[0];
+        expect(user.get('dateField')).to.be.an.instanceof(Date);
+        expect(user.get('dateField')).to.equalTime(new Date(2010, 10, 10));
       });
       });
 
 
-      it('handles dates in includes correctly #2644', function() {
-        return this.User.create({
+      it('handles dates in includes correctly #2644', async function() {
+        await this.User.create({
           projects: [
           projects: [
             { dateField: new Date(1990, 5, 5) }
             { dateField: new Date(1990, 5, 5) }
           ]
           ]
-        }, { include: [this.Project] }).then(() => {
-          return this.User.findAll({
-            include: [this.Project]
-          }).then(obj => obj[0]);
-        }).then(user => {
-          expect(user.projects[0].get('dateField')).to.be.an.instanceof(Date);
-          expect(user.projects[0].get('dateField')).to.equalTime(new Date(1990, 5, 5));
+        }, { include: [this.Project] });
+
+        const obj = await this.User.findAll({
+          include: [this.Project]
         });
         });
+
+        const user = await obj[0];
+        expect(user.projects[0].get('dateField')).to.be.an.instanceof(Date);
+        expect(user.projects[0].get('dateField')).to.equalTime(new Date(1990, 5, 5));
       });
       });
     });
     });
 
 
     describe('json', () => {
     describe('json', () => {
-      it('should be able to retrieve a row with json_extract function', function() {
-        return Promise.all([
+      it('should be able to retrieve a row with json_extract function', async function() {
+        await Promise.all([
           this.User.create({ username: 'swen', emergency_contact: { name: 'kate' } }),
           this.User.create({ username: 'swen', emergency_contact: { name: 'kate' } }),
           this.User.create({ username: 'anna', emergency_contact: { name: 'joe' } })
           this.User.create({ username: 'anna', emergency_contact: { name: 'joe' } })
-        ]).then(() => {
-          return this.User.findOne({
-            where: Sequelize.json('json_extract(emergency_contact, \'$.name\')', 'kate'),
-            attributes: ['username', 'emergency_contact']
-          });
-        }).then(user => {
-          expect(user.emergency_contact.name).to.equal('kate');
+        ]);
+
+        const user = await this.User.findOne({
+          where: Sequelize.json('json_extract(emergency_contact, \'$.name\')', 'kate'),
+          attributes: ['username', 'emergency_contact']
         });
         });
+
+        expect(user.emergency_contact.name).to.equal('kate');
       });
       });
 
 
-      it('should be able to retrieve a row by json_type function', function() {
-        return Promise.all([
+      it('should be able to retrieve a row by json_type function', async function() {
+        await Promise.all([
           this.User.create({ username: 'swen', emergency_contact: { name: 'kate' } }),
           this.User.create({ username: 'swen', emergency_contact: { name: 'kate' } }),
           this.User.create({ username: 'anna', emergency_contact: ['kate', 'joe'] })
           this.User.create({ username: 'anna', emergency_contact: ['kate', 'joe'] })
-        ]).then(() => {
-          return this.User.findOne({
-            where: Sequelize.json('json_type(emergency_contact)', 'array'),
-            attributes: ['username', 'emergency_contact']
-          });
-        }).then(user => {
-          expect(user.username).to.equal('anna');
+        ]);
+
+        const user = await this.User.findOne({
+          where: Sequelize.json('json_type(emergency_contact)', 'array'),
+          attributes: ['username', 'emergency_contact']
         });
         });
+
+        expect(user.username).to.equal('anna');
       });
       });
     });
     });
 
 
     describe('regression tests', () => {
     describe('regression tests', () => {
-      it('do not crash while parsing unique constraint errors', function() {
+      it('do not crash while parsing unique constraint errors', async function() {
         const Payments = this.sequelize.define('payments', {});
         const Payments = this.sequelize.define('payments', {});
 
 
-        return Payments.sync({ force: true }).then(() => {
-          return expect(Payments.bulkCreate([{ id: 1 }, { id: 1 }], { ignoreDuplicates: false })).to.eventually.be.rejected;
-        });
+        await Payments.sync({ force: true });
+
+        await expect(Payments.bulkCreate([{ id: 1 }, { id: 1 }], { ignoreDuplicates: false })).to.eventually.be.rejected;
       });
       });
     });
     });
   });
   });

test/integration/dialects/sqlite/sqlite-master.test.js

@@ -8,7 +8,7 @@ const chai = require('chai'),
 
 
 if (dialect === 'sqlite') {
 if (dialect === 'sqlite') {
   describe('[SQLITE Specific] sqlite_master raw queries', () => {
   describe('[SQLITE Specific] sqlite_master raw queries', () => {
-    beforeEach(function() {
+    beforeEach(async function() {
       this.sequelize.define('SomeTable', {
       this.sequelize.define('SomeTable', {
         someColumn: DataTypes.INTEGER
         someColumn: DataTypes.INTEGER
       }, {
       }, {
@@ -16,46 +16,40 @@ if (dialect === 'sqlite') {
         timestamps: false
         timestamps: false
       });
       });
 
 
-      return this.sequelize.sync({ force: true });
+      await this.sequelize.sync({ force: true });
     });
     });
 
 
-    it('should be able to select with tbl_name filter', function() {
-      return this.sequelize.query('SELECT * FROM sqlite_master WHERE tbl_name=\'SomeTable\'')
-        .then(result => {
-          const rows = result[0];
-          expect(rows).to.have.length(1);
-          const row = rows[0];
-          expect(row).to.have.property('type', 'table');
-          expect(row).to.have.property('name', 'SomeTable');
-          expect(row).to.have.property('tbl_name', 'SomeTable');
-          expect(row).to.have.property('sql');
-        });
+    it('should be able to select with tbl_name filter', async function() {
+      const result = await this.sequelize.query('SELECT * FROM sqlite_master WHERE tbl_name=\'SomeTable\'');
+      const rows = result[0];
+      expect(rows).to.have.length(1);
+      const row = rows[0];
+      expect(row).to.have.property('type', 'table');
+      expect(row).to.have.property('name', 'SomeTable');
+      expect(row).to.have.property('tbl_name', 'SomeTable');
+      expect(row).to.have.property('sql');
     });
     });
 
 
-    it('should be able to select *', function() {
-      return this.sequelize.query('SELECT * FROM sqlite_master')
-        .then(result => {
-          const rows = result[0];
-          expect(rows).to.have.length(2);
-          rows.forEach(row => {
-            expect(row).to.have.property('type');
-            expect(row).to.have.property('name');
-            expect(row).to.have.property('tbl_name');
-            expect(row).to.have.property('rootpage');
-            expect(row).to.have.property('sql');
-          });
-        });
+    it('should be able to select *', async function() {
+      const result = await this.sequelize.query('SELECT * FROM sqlite_master');
+      const rows = result[0];
+      expect(rows).to.have.length(2);
+      rows.forEach(row => {
+        expect(row).to.have.property('type');
+        expect(row).to.have.property('name');
+        expect(row).to.have.property('tbl_name');
+        expect(row).to.have.property('rootpage');
+        expect(row).to.have.property('sql');
+      });
     });
     });
 
 
-    it('should be able to select just "sql" column and get rows back', function() {
-      return this.sequelize.query('SELECT sql FROM sqlite_master WHERE tbl_name=\'SomeTable\'')
-        .then(result => {
-          const rows = result[0];
-          expect(rows).to.have.length(1);
-          const row = rows[0];
-          expect(row).to.have.property('sql',
-            'CREATE TABLE `SomeTable` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `someColumn` INTEGER)');
-        });
+    it('should be able to select just "sql" column and get rows back', async function() {
+      const result = await this.sequelize.query('SELECT sql FROM sqlite_master WHERE tbl_name=\'SomeTable\'');
+      const rows = result[0];
+      expect(rows).to.have.length(1);
+      const row = rows[0];
+      expect(row).to.have.property('sql',
+        'CREATE TABLE `SomeTable` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `someColumn` INTEGER)');
     });
     });
   });
   });
 }
 }