test(integration/sequelize): asyncify (#12295)

test/integration/sequelize/deferrable.test.js

@@ -14,7 +14,7 @@ if (!Support.sequelize.dialect.supports.deferrableConstraints) {
 describe(Support.getTestDialectTeaser('Sequelize'), () => {
 describe(Support.getTestDialectTeaser('Sequelize'), () => {
   describe('Deferrable', () => {
   describe('Deferrable', () => {
     beforeEach(function() {
     beforeEach(function() {
-      this.run = function(deferrable, options) {
+      this.run = async function(deferrable, options) {
         options = options || {};
         options = options || {};
 
 
         const taskTableName      = options.taskTableName || `tasks_${config.rand()}`;
         const taskTableName      = options.taskTableName || `tasks_${config.rand()}`;
@@ -42,69 +42,62 @@ describe(Support.getTestDialectTeaser('Sequelize'), () => {
           }
           }
         );
         );
 
 
-        return User.sync({ force: true }).then(() => {
-          return Task.sync({ force: true });
-        }).then(() => {
-          return this.sequelize.transaction(transactionOptions, t => {
-            return Task
-              .create({ title: 'a task', user_id: -1 }, { transaction: t })
-              .then(task => {
-                return Promise.all([task, User.create({}, { transaction: t })]);
-              })
-              .then(([task, user]) => {
-                task.user_id = user.id;
-                return task.save({ transaction: t });
-              });
-          });
+        await User.sync({ force: true });
+        await Task.sync({ force: true });
+
+        return this.sequelize.transaction(transactionOptions, async t => {
+          const task0 = await Task
+            .create({ title: 'a task', user_id: -1 }, { transaction: t });
+
+          const [task, user] = await Promise.all([task0, User.create({}, { transaction: t })]);
+          task.user_id = user.id;
+          return task.save({ transaction: t });
         });
         });
       };
       };
     });
     });
 
 
     describe('NOT', () => {
     describe('NOT', () => {
-      it('does not allow the violation of the foreign key constraint', function() {
-        return expect(this.run(Sequelize.Deferrable.NOT)).to.eventually.be.rejectedWith(Sequelize.ForeignKeyConstraintError);
+      it('does not allow the violation of the foreign key constraint', async function() {
+        await expect(this.run(Sequelize.Deferrable.NOT)).to.eventually.be.rejectedWith(Sequelize.ForeignKeyConstraintError);
       });
       });
     });
     });
 
 
     describe('INITIALLY_IMMEDIATE', () => {
     describe('INITIALLY_IMMEDIATE', () => {
-      it('allows the violation of the foreign key constraint if the transaction is deferred', function() {
-        return this
-          .run(Sequelize.Deferrable.INITIALLY_IMMEDIATE)
-          .then(task => {
-            expect(task.title).to.equal('a task');
-            expect(task.user_id).to.equal(1);
-          });
+      it('allows the violation of the foreign key constraint if the transaction is deferred', async function() {
+        const task = await this
+          .run(Sequelize.Deferrable.INITIALLY_IMMEDIATE);
+
+        expect(task.title).to.equal('a task');
+        expect(task.user_id).to.equal(1);
       });
       });
 
 
-      it('does not allow the violation of the foreign key constraint if the transaction is not deffered', function() {
-        return expect(this.run(Sequelize.Deferrable.INITIALLY_IMMEDIATE, {
+      it('does not allow the violation of the foreign key constraint if the transaction is not deffered', async function() {
+        await expect(this.run(Sequelize.Deferrable.INITIALLY_IMMEDIATE, {
           deferrable: undefined
           deferrable: undefined
         })).to.eventually.be.rejectedWith(Sequelize.ForeignKeyConstraintError);
         })).to.eventually.be.rejectedWith(Sequelize.ForeignKeyConstraintError);
       });
       });
 
 
-      it('allows the violation of the foreign key constraint if the transaction deferres only the foreign key constraint', function() {
+      it('allows the violation of the foreign key constraint if the transaction deferres only the foreign key constraint', async function() {
         const taskTableName = `tasks_${config.rand()}`;
         const taskTableName = `tasks_${config.rand()}`;
 
 
-        return this
+        const task = await this
           .run(Sequelize.Deferrable.INITIALLY_IMMEDIATE, {
           .run(Sequelize.Deferrable.INITIALLY_IMMEDIATE, {
             deferrable: Sequelize.Deferrable.SET_DEFERRED([`${taskTableName}_user_id_fkey`]),
             deferrable: Sequelize.Deferrable.SET_DEFERRED([`${taskTableName}_user_id_fkey`]),
             taskTableName
             taskTableName
-          })
-          .then(task => {
-            expect(task.title).to.equal('a task');
-            expect(task.user_id).to.equal(1);
           });
           });
+
+        expect(task.title).to.equal('a task');
+        expect(task.user_id).to.equal(1);
       });
       });
     });
     });
 
 
     describe('INITIALLY_DEFERRED', () => {
     describe('INITIALLY_DEFERRED', () => {
-      it('allows the violation of the foreign key constraint', function() {
-        return this
-          .run(Sequelize.Deferrable.INITIALLY_DEFERRED)
-          .then(task => {
-            expect(task.title).to.equal('a task');
-            expect(task.user_id).to.equal(1);
-          });
+      it('allows the violation of the foreign key constraint', async function() {
+        const task = await this
+          .run(Sequelize.Deferrable.INITIALLY_DEFERRED);
+
+        expect(task.title).to.equal('a task');
+        expect(task.user_id).to.equal(1);
       });
       });
     });
     });
   });
   });