Function verifyDeadlock

test/integration/transaction.test.js:527–639

()

        it(class="st">'should release the connection for a deadlocked transaction (2/2)', async function() {
          const verifyDeadlock = async () => {
            const User = this.sequelize.define(class="st">'user', {
              username: DataTypes.STRING,
              awesome: DataTypes.BOOLEAN
            }, { timestamps: false });

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

            class="cm">// 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).
            class="cm">// This will cause other sessions to be able to read the row but not modify it.
            class="cm">// So, if another transaction tries to update those same rows, it will wait until T1 commits (or rolls back).
            class="cm">// 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 });

            class="cm">// 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 });

            class="cm">// Then, we want to see that an attempt to update that row from T2 will be queued until T1 commits.
            class="cm">// However, before commiting T1 we will also perform an update via T1 on the same rows.
            class="cm">// 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).
            class="cm">// Meanwhile, T1 should still be ok.
            const executionOrder = [];
            const [t2AttemptData, t1AttemptData] = await pSettle([
              (async () => {
                try {
                  executionOrder.push(class="st">'Begin attempt to update via T2');
                  await t2Jan.update({ awesome: false }, { transaction: t2 });
                  executionOrder.push(class="st">'Done updating via T2'); class="cm">// Shouldn't happen
                } catch (error) {
                  executionOrder.push(class="st">'Failed to update via T2');
                  throw error;
                }

                await delay(30);

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

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