Integration test that intentionally creates a deadlock (PHP) - php

Question

I'm trying to test a class MyConnection I've created that extends Doctrine\DBAL\Connection and handles deadlock cases (or lock waits) by releasing any deadlocks and resolving them.
Therefore I need to create a deadlock on my test, in order to confirm that it works as it should.
The idea is to create a temporary table in the database, and try to access it in two connections at once.
The challenge is that I need to do this without using multiple threads. (threads in php are created with pthreads that needs PHP7.2+ and I have 7.1, and it's not an option to upgrade for now)
What I've already tried is using multiple connections on the database. However this created a lock wait instead. The problems with the lock wait were that:
1. it makes the integration test too slow
2. I can't delete the temporary table I create on my test. Even though the test runs on a test database, it's good practice to clean up after your tests
I have also tried forking my process. The problems with that were
1. it still creates a lock wait instead
2. I had to exit the child process, and have the parent handling everything and making assertions. But since the deadlock happens in the child, I can't catch the errors thrown from the child through the parent
The idea in the code below is that when my executeQuery fails to handle the dead lock, it won't be able to write 'I am handling the deadlock or the lock wait' in the logger, therefore I put that shouldReceive('critical') that will throw an error when things don't work out. Otherwise the test should pass
Class extending Doctrine\DBAL\Connection
class MyConnection extends Connection
{
public function executeQuery($query, array $params = [], $types = [], QueryCacheProfile $qcp = null)
{
try {
$result = parent::executeQuery($query, $params, $types, $qcp);
} catch (\Doctrine\DBAL\DBALException $exception ) {
$this->logger->critical('I am handling the deadlock or the lock wait');
}
}
}
Integration Test
class DeadlockCreationTest extends Test
{
const SERIALIZE_TRANSACTION = 'SET TRANSACTION ISOLATION LEVEL SERIALIZABLE;';
const START_TRANSACTION = 'START TRANSACTION;';
const SELECT_QUERY = 'SELECT * FROM %s.innodb_deadlock_maker WHERE a = %d;';
const UPDATE_QUERY = 'UPDATE %s.innodb_deadlock_maker SET a=%d WHERE a <> %d';
public function setUp()
{
parent::setUp();
$this->currentDbConnection = $this->getConnection();
$this->newDbConnection = $this->getNewIdenticalDBConnection($this->currentDbConnection);
$this->logger = Mockery::mock(Logger::class);
$this->currentDbConnection->executeQuery(
'CREATE TABLE IF NOT EXISTS ' . $this->dbName .
'.innodb_deadlock_maker(b INT PRIMARY KEY AUTO_INCREMENT, a INT NOT NULL) engine=innodb;'
);
$this->currentDbConnection->executeQuery(
'insert into ' . $this->dbName . '.innodb_deadlock_maker(a) values(0), (1);'
);
}
public function testCreateDeadlock()
{
$pid = pcntl_fork();
if ($pid === -1) {
$this->fail('Could not fork child process');
}
if ($pid === 0) {
$this->process = 'child';
// In child process
try {
$this->logger->shouldReceive('critical')
->with(
'I am handling the deadlock or the lock wait'
);
$this->newDbConnection->setLogger($this->logger);
$this->newDbConnection->executeQuery(self::SERIALIZE_TRANSACTION);
$this->newDbConnection->executeQuery(self::START_TRANSACTION);
$this->newDbConnection->executeQuery(sprintf(self::SELECT_QUERY, $this->dbName, 1));
$this->newDbConnection->executeUpdate(sprintf(self::UPDATE_QUERY, $this->dbName, 1, 1));
} catch (\Doctrine\DBAL\DBALException $exception) {
if (stripos($exception->getMessage(), 'try restarting transaction') !== false) {
exit(123);
}
exit(100); // Our exit code to indicate a different error occurred
}
exit(0); // Our exit code to indicate no error occurred
}
$this->process = 'parent';
// Otherwise in parent process:
$this->currentDbConnection->executeQuery(self::SERIALIZE_TRANSACTION);
$this->currentDbConnection->executeQuery(self::START_TRANSACTION);
$this->currentDbConnection->executeQuery(sprintf(self::SELECT_QUERY, $this->dbName, 0));
$this->currentDbConnection->executeUpdate(sprintf(self::UPDATE_QUERY, $this->dbName, 0, 0));
pcntl_waitpid($pid, $status); // Wait for forked child to exit
$childExitCode = pcntl_wexitstatus($status);
switch ($childExitCode) {
case 0:
echo "\nNo error occurred, or deadlock occurred in child but was handled correctly - success!\n";
break;
case 100:
$this->fail('A different error occurred');
break;
case 123:
$this->fail('Deadlock occurred in child and was not handled correctly');
break;
default:
$this->fail('Child exited with unexpected exit code');
}
}
public function tearDown()
{
$this->newDbConnection->executeQuery('DROP TABLE ' . $this->dbName . '.innodb_deadlock_maker;');
$this->newDbConnection->close();
parent::tearDown();
}
}
What I need is ideally to create a deadlock instead of a lock wait.
Also I need to somehow confirm that my Connection class worked as it should.
Another issue I have with the code above is that I get the error message PDO::exec(): MySQL server has gone away and I don't know if and how can I stop that.
PS: The idea of the test is based on this article