Improve ConnectionTest by triggering real exceptions

Co-authored-by: Simon Podlipsky <simon@podlipsky.net>

tests/Functional/ConnectionTest.php

@@ -4,20 +4,22 @@
 
 use Doctrine\DBAL\Connection;
 use Doctrine\DBAL\ConnectionException;
+use Doctrine\DBAL\Driver\AbstractSQLServerDriver;
 use Doctrine\DBAL\Driver\Connection as DriverConnection;
+use Doctrine\DBAL\Driver\IBMDB2;
 use Doctrine\DBAL\Driver\PDO\Connection as PDOConnection;
 use Doctrine\DBAL\DriverManager;
+use Doctrine\DBAL\Exception\UniqueConstraintViolationException;
 use Doctrine\DBAL\ParameterType;
 use Doctrine\DBAL\Platforms\AbstractPlatform;
 use Doctrine\DBAL\Platforms\SqlitePlatform;
 use Doctrine\DBAL\Platforms\SQLServer2012Platform;
+use Doctrine\DBAL\Schema\Table;
 use Doctrine\DBAL\Tests\FunctionalTestCase;
 use Doctrine\DBAL\Tests\TestUtil;
 use Doctrine\DBAL\Types\Types;
 use Error;
-use Exception;
 use PDO;
-use RuntimeException;
 use Throwable;
 
 use function file_exists;
@@ -26,6 +28,8 @@
 
 class ConnectionTest extends FunctionalTestCase
 {
+    private const TABLE = 'connection_test';
+
     protected function tearDown(): void
     {
         if (file_exists('/tmp/test_nesting.sqlite')) {
@@ -53,29 +57,32 @@ public function testCommitWithRollbackOnlyThrowsException(): void
 
     public function testTransactionNestingBehavior(): void
     {
+        $this->createTestTable();
+
         try {
             $this->connection->beginTransaction();
-            self::assertEquals(1, $this->connection->getTransactionNestingLevel());
+            self::assertSame(1, $this->connection->getTransactionNestingLevel());
 
             try {
                 $this->connection->beginTransaction();
-                self::assertEquals(2, $this->connection->getTransactionNestingLevel());
+                self::assertSame(2, $this->connection->getTransactionNestingLevel());
 
-                throw new Exception();
+                $this->connection->insert(self::TABLE, ['id' => 1]);
+                self::fail('Expected exception to be thrown because of the unique constraint.');
             } catch (Throwable $e) {
+                $this->assertIsUniqueConstraintException($e);
                 $this->connection->rollBack();
-                self::assertEquals(1, $this->connection->getTransactionNestingLevel());
-                //no rethrow
+                self::assertSame(1, $this->connection->getTransactionNestingLevel());
             }
 
             self::assertTrue($this->connection->isRollbackOnly());
 
             $this->connection->commit(); // should throw exception
             self::fail('Transaction commit after failed nested transaction should fail.');
         } catch (ConnectionException $e) {
-            self::assertEquals(1, $this->connection->getTransactionNestingLevel());
+            self::assertSame(1, $this->connection->getTransactionNestingLevel());
             $this->connection->rollBack();
-            self::assertEquals(0, $this->connection->getTransactionNestingLevel());
+            self::assertSame(0, $this->connection->getTransactionNestingLevel());
         }
 
         $this->connection->beginTransaction();
@@ -119,24 +126,27 @@ public function testTransactionNestingBehaviorWithSavepoints(): void
             self::markTestSkipped('This test requires the platform to support savepoints.');
         }
 
+        $this->createTestTable();
+
         $this->connection->setNestTransactionsWithSavepoints(true);
         try {
             $this->connection->beginTransaction();
-            self::assertEquals(1, $this->connection->getTransactionNestingLevel());
+            self::assertSame(1, $this->connection->getTransactionNestingLevel());
 
             try {
                 $this->connection->beginTransaction();
-                self::assertEquals(2, $this->connection->getTransactionNestingLevel());
+                self::assertSame(2, $this->connection->getTransactionNestingLevel());
                 $this->connection->beginTransaction();
-                self::assertEquals(3, $this->connection->getTransactionNestingLevel());
+                self::assertSame(3, $this->connection->getTransactionNestingLevel());
                 self::assertTrue($this->connection->commit());
-                self::assertEquals(2, $this->connection->getTransactionNestingLevel());
+                self::assertSame(2, $this->connection->getTransactionNestingLevel());
 
-                throw new Exception();
+                $this->connection->insert(self::TABLE, ['id' => 1]);
+                self::fail('Expected exception to be thrown because of the unique constraint.');
             } catch (Throwable $e) {
+                $this->assertIsUniqueConstraintException($e);
                 $this->connection->rollBack();
-                self::assertEquals(1, $this->connection->getTransactionNestingLevel());
-                //no rethrow
+                self::assertSame(1, $this->connection->getTransactionNestingLevel());
             }
 
             self::assertFalse($this->connection->isRollbackOnly());
@@ -222,43 +232,45 @@ public function testRollbackSavepointsNotSupportedThrowsException(): void
 
     public function testTransactionBehaviorWithRollback(): void
     {
+        $this->createTestTable();
+
         try {
             $this->connection->beginTransaction();
-            self::assertEquals(1, $this->connection->getTransactionNestingLevel());
+            self::assertSame(1, $this->connection->getTransactionNestingLevel());
 
-            throw new Exception();
+            $this->connection->insert(self::TABLE, ['id' => 1]);
+            self::fail('Expected exception to be thrown because of the unique constraint.');
         } catch (Throwable $e) {
-            self::assertEquals(1, $this->connection->getTransactionNestingLevel());
+            $this->assertIsUniqueConstraintException($e);
+            self::assertSame(1, $this->connection->getTransactionNestingLevel());
             $this->connection->rollBack();
-            self::assertEquals(0, $this->connection->getTransactionNestingLevel());
+            self::assertSame(0, $this->connection->getTransactionNestingLevel());
         }
     }
 
     public function testTransactionBehaviour(): void
     {
-        try {
-            $this->connection->beginTransaction();
-            self::assertEquals(1, $this->connection->getTransactionNestingLevel());
-            $this->connection->commit();
-        } catch (Throwable $e) {
-            $this->connection->rollBack();
-            self::assertEquals(0, $this->connection->getTransactionNestingLevel());
-        }
+        $this->createTestTable();
 
-        self::assertEquals(0, $this->connection->getTransactionNestingLevel());
+        $this->connection->beginTransaction();
+        self::assertSame(1, $this->connection->getTransactionNestingLevel());
+        $this->connection->insert(self::TABLE, ['id' => 2]);
+        $this->connection->commit();
+        self::assertSame(0, $this->connection->getTransactionNestingLevel());
     }
 
     public function testTransactionalWithException(): void
     {
-        try {
-            $this->connection->transactional(static function (Connection $conn): void {
-                $conn->executeQuery($conn->getDatabasePlatform()->getDummySelectSQL());
+        $this->createTestTable();
 
-                throw new RuntimeException('Ooops!');
+        try {
+            $this->connection->transactional(static function (Connection $connection): void {
+                $connection->insert(self::TABLE, ['id' => 1]);
             });
-            self::fail('Expected exception');
-        } catch (RuntimeException $expected) {
-            self::assertEquals(0, $this->connection->getTransactionNestingLevel());
+            self::fail('Expected exception to be thrown because of the unique constraint.');
+        } catch (Throwable $e) {
+            $this->assertIsUniqueConstraintException($e);
+            self::assertSame(0, $this->connection->getTransactionNestingLevel());
         }
     }
 
@@ -278,11 +290,14 @@ public function testTransactionalWithThrowable(): void
 
     public function testTransactional(): void
     {
-        $res = $this->connection->transactional(static function (Connection $conn): void {
-            $conn->executeQuery($conn->getDatabasePlatform()->getDummySelectSQL());
+        $this->createTestTable();
+
+        $res = $this->connection->transactional(static function (Connection $connection): void {
+            $connection->insert(self::TABLE, ['id' => 2]);
         });
 
         self::assertNull($res);
+        self::assertSame(0, $this->connection->getTransactionNestingLevel());
     }
 
     public function testTransactionalReturnValue(): void
@@ -373,4 +388,32 @@ public function testPersistentConnection(): void
 
         self::assertTrue($pdo->getAttribute(PDO::ATTR_PERSISTENT));
     }
+
+    private function createTestTable(): void
+    {
+        $table = new Table(self::TABLE);
+        $table->addColumn('id', 'integer');
+        $table->setPrimaryKey(['id']);
+
+        $this->connection->createSchemaManager()->dropAndCreateTable($table);
+
+        $this->connection->insert(self::TABLE, ['id' => 1]);
+    }
+
+    private function assertIsUniqueConstraintException(Throwable $exception): void
+    {
+        if ($this->connection->getDriver() instanceof IBMDB2\Driver) {
+            // The IBM DB2 driver currently doesn't instantiate specialized exceptions
+
+            return;
+        }
+
+        if ($this->connection->getDriver() instanceof AbstractSQLServerDriver) {
+            // The SQL Server drivers currently don't instantiate specialized exceptions
+
+            return;
+        }
+
+        self::assertInstanceOf(UniqueConstraintViolationException::class, $exception);
+    }
 }