Function verifyDeadlock

test/integration/transaction.test.js:540–652

()

          }

          const verifyDeadlock = async () => {
            const User = this.sequelize.define('user', {
              username: DataTypes.STRING,
              awesome: DataTypes.BOOLEAN
            }, { timestamps: false });

            await this.sequelize.sync({ force: true });
            const { id } = await User.create({ username: 'jan' });

            // First, we start a transaction T1 and perform a SELECT with it using the `LOCK.SHARE` mode (setting a shared mode lock on the row).
            // This will cause other sessions to be able to read the row but not modify it.
            // So, if another transaction tries to update those same rows, it will wait until T1 commits (or rolls back).
            // https://dev.mysql.com/doc/refman/5.7/en/innodb-locking-reads.html
            const t1 = await this.sequelize.transaction();
            const t1Jan = await User.findByPk(id, { lock: t1.LOCK.SHARE, transaction: t1 });

            // Then we start another transaction T2 and see that it can indeed read the same row.
            const t2 = await this.sequelize.transaction({ isolationLevel: Transaction.ISOLATION_LEVELS.READ_COMMITTED });
            const t2Jan = await User.findByPk(id, { transaction: t2 });

            // Then, we want to see that an attempt to update that row from T2 will be queued until T1 commits.
            // However, before commiting T1 we will also perform an update via T1 on the same rows.
            // This should cause T2 to notice that it can't function anymore, so it detects a deadlock and automatically rolls itself back (and throws an error).
            // Meanwhile, T1 should still be ok.
            const executionOrder = [];
            const [t2AttemptData, t1AttemptData] = await pSettle([
              (async () => {
                try {
                  executionOrder.push('Begin attempt to update via T2');
                  await t2Jan.update({ awesome: false }, { transaction: t2 });
                  executionOrder.push('Done updating via T2'); // Shouldn't happen
                } catch (error) {
                  executionOrder.push('Failed to update via T2');
                  throw error;
                }

                await delay(30);

                try {
                  // We shouldn't reach this point, but if we do, let's at least commit the transaction
                  // to avoid forever occupying one connection of the pool with a pending transaction.
                  executionOrder.push('Attempting to commit T2');
                  await t2.commit();
                  executionOrder.push('Done committing T2');
                } catch {
                  executionOrder.push('Failed to commit T2');
                }
              })(),
              (async () => {
                await delay(100);

                try {
                  executionOrder.push('Begin attempt to update via T1');
                  await t1Jan.update({ awesome: true }, { transaction: t1 });
                  executionOrder.push('Done updating via T1');
                } catch (error) {
                  executionOrder.push('Failed to update via T1'); // Shouldn't happen
                  throw error;