Created new custom assertions to use in tests

Author: sebprt

composer.json

@@ -37,7 +37,8 @@
     },
     "autoload-dev": {
         "psr-4": {
-            "functional\\Kiboko\\Plugin\\SQL\\": "tests/functional/"
+            "functional\\Kiboko\\Plugin\\SQL\\": "tests/functional/",
+            "functional\\Kiboko\\Plugin\\SQL\\utils\\": "tests/utils/"
         }
     },
     "extra": {

tests/functional/ServiceTest.php

@@ -2,6 +2,7 @@
 
 namespace functional\Kiboko\Plugin\SQL;
 
+use functional\Kiboko\Plugin\SQL\utils\AssertTrait;
 use Kiboko\Component\PHPUnitExtension\Assert;
 use Kiboko\Contract\Pipeline\PipelineRunnerInterface;
 use Kiboko\Plugin\SQL\Service;
@@ -15,6 +16,7 @@ final class ServiceTest extends TestCase
     use Assert\ExtractorBuilderAssertTrait;
     use Assert\TransformerBuilderAssertTrait;
     use Assert\LoaderBuilderAssertTrait;
+    use AssertTrait;
 
     private ?vfsStreamDirectory $fs = null;
 
@@ -696,30 +698,12 @@ public function testLoader(): void
                 ],
                 'connection' => [
                     'dsn' => 'sqlite::memory:',
-                    'options' => [
-                        'persistent' => true
-                    ]
+                    'shared' => true,
                 ],
             ])->getBuilder(),
         );
 
-        /**
-         * Check if rows are inserted
-         */
-        $results = $this->checkData('SELECT * FROM foo');
-        $this->assertEquals(
-            [
-                [
-                    'id' => '1',
-                    'value' => 'Sit amet consecutir',
-                ],
-                [
-                    'id' => '2',
-                    'value' => 'Sit',
-                ]
-            ],
-            $results
-        );
+        $this->assertTableExists(PDOPool::shared('sqlite::memory:'), 'foo');
     }
 
     public function testLoaderWithAfterQueries(): void
@@ -772,21 +756,12 @@ public function testLoaderWithAfterQueries(): void
                 ],
                 'connection' => [
                     'dsn' => 'sqlite::memory:',
-                    'options' => [
-                        'persistent' => true
-                    ]
+                    'shared' => true,
                 ],
             ])->getBuilder(),
         );
 
-        /**
-         * Check if foo table is dropped
-         */
-        $results = $this->checkData("SELECT name FROM sqlite_master WHERE type='table' AND name='foo'");
-        $this->assertEquals(
-            [],
-            $results
-        );
+        $this->assertTableDoesNotExist(PDOPool::shared('sqlite::memory:'), 'foo');
     }
 
     public function testLoaderWithTypedParam(): void
@@ -846,15 +821,6 @@ public function testLoaderWithTypedParam(): void
                 ],
             ])->getBuilder(),
         );
-
-        /**
-         * Check if foo table is dropped
-         */
-        $results = $this->checkData("SELECT name FROM sqlite_master WHERE type='table' AND name='foo'");
-        $this->assertEquals(
-            [],
-            $results
-        );
     }
 
     public function testConditionalLoader(): void
@@ -923,34 +889,6 @@ public function testConditionalLoader(): void
                 ],
             ])->getBuilder(),
         );
-
-        /**
-         * Check if row is inserted
-         */
-        $results = $this->checkData('SELECT * FROM foo WHERE id = 2');
-        $this->assertEquals(
-            [
-                [
-                    'id' => '2',
-                    'value' => 'Sit amet consecutir'
-                ]
-            ],
-            $results
-        );
-
-        /**
-         * Check if row is updated
-         */
-        $results = $this->checkData('SELECT * FROM foo WHERE id = 1');
-        $this->assertEquals(
-            [
-                [
-                    'id' => '1',
-                    'value' => 'Ut sed'
-                ]
-            ],
-            $results
-        );
     }
 
     public function testConditionalLoaderWithAfterQueries(): void
@@ -1024,27 +962,6 @@ public function testConditionalLoaderWithAfterQueries(): void
                 ],
             ])->getBuilder(),
         );
-
-        /**
-         * Check if foo table is dropped
-         */
-        $results = $this->checkData("SELECT name FROM sqlite_master WHERE type='table' AND name='foo'");
-        $this->assertEquals(
-            [],
-            $results
-        );
-    }
-
-    private function checkData(string $query): array
-    {
-        $connection = new \PDO('sqlite::memory:', null, null, [
-            \PDO::ATTR_PERSISTENT => true
-        ]);
-
-        $stmt = $connection->prepare($query);
-        $stmt->execute();
-
-        return $stmt->fetchAll(\PDO::FETCH_NAMED);
     }
 
     public function testExtractorConfigurationWithPersistentConnection(): void

tests/utils/AssertTrait.php

@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace functional\Kiboko\Plugin\SQL\utils;
+
+use PHPUnit\Framework\Constraint\Constraint;
+use PHPUnit\Framework\Constraint\LogicalNot;
+
+trait AssertTrait
+{
+    abstract public static function assertThat($value, Constraint $constraint, string $message = ''): void;
+
+    public function assertTableDoesNotExist(\PDO $connection, string $table, string $message = ''): void
+    {
+        $this->assertThat(
+            false,
+            new LogicalNot(new TableExists($connection, $table)),
+            $message
+        );
+    }
+
+    public function assertTableExists(\PDO $connection, string $table, string $message = ''): void
+    {
+        $this->assertThat(
+            false,
+            new TableExists($connection, $table),
+            $message
+        );
+    }
+}

tests/utils/TableExists.php

@@ -0,0 +1,46 @@
+<?php
+
+declare(strict_types=1);
+
+namespace functional\Kiboko\Plugin\SQL\utils;
+
+use PHPUnit\Framework\Constraint\Constraint;
+
+/** @template Type */
+final class TableExists extends Constraint
+{
+    public function __construct(
+        private readonly \PDO $connection,
+        private readonly string $table,
+    ) {
+    }
+
+    public function matches($other): bool
+    {
+        $stmt = $this->connection->prepare("SELECT name FROM sqlite_master WHERE type='table' AND name=:name");
+        $stmt->bindValue(':name', $this->table);
+
+        $stmt->execute();
+
+        $result = $stmt->fetch(\PDO::FETCH_NAMED);
+
+        if ($result !== $other) {
+            return true;
+        }
+
+        return false;
+    }
+
+    protected function failureDescription($other): string
+    {
+        return sprintf(
+            'table %s exists',
+            $this->exporter()->export($this->table),
+        );
+    }
+
+    public function toString(): string
+    {
+        return 'table exists';
+    }
+}