Migrate tests to Pest

composer.json

@@ -25,9 +25,9 @@
     "ext-pdo": "*"
   },
   "require-dev": {
-    "phpunit/phpunit": "^11",
     "square/pjson": "^0.5.0",
-    "phpstan/phpstan": "^1.12"
+    "phpstan/phpstan": "^1.12",
+    "pestphp/pest": "^3.2"
   },
   "autoload": {
     "psr-4": {
@@ -39,13 +39,17 @@
   "autoload-dev": {
     "psr-4": {
       "Test\\": "./tests",
-      "Test\\Unit\\": "./tests/unit",
-      "Test\\Integration\\": "./tests/integration",
-      "Test\\Integration\\PostgreSQL\\": "./tests/integration/postgresql",
-      "Test\\Integration\\SQLite\\": "./tests/integration/sqlite"
+      "Test\\Integration\\": "./tests/Integration",
+      "Test\\Integration\\PostgreSQL\\": "./tests/Integration/PostgreSQL",
+      "Test\\Integration\\SQLite\\": "./tests/Integration/SQLite"
     }
   },
   "archive": {
     "exclude": [ "/tests", "/.gitattributes", "/.gitignore", "/.git", "/composer.lock" ]
+  },
+  "config": {
+    "allow-plugins": {
+      "pestphp/pest-plugin": true
+    }
   }
 }

phpunit.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/10.3/phpunit.xsd"
+         bootstrap="vendor/autoload.php"
+         colors="true"
+>
+    <testsuites>
+        <testsuite name="Test Suite">
+            <directory suffix="Test.php">./tests</directory>
+        </testsuite>
+    </testsuites>
+    <source>
+        <include>
+            <directory suffix=".php">./app</directory>
+            <directory suffix=".php">./src</directory>
+        </include>
+    </source>
+</phpunit>

src/DocumentException.php

@@ -9,12 +9,13 @@ declare(strict_types=1);
 namespace BitBadger\PDODocument;
 
 use Exception;
+use Stringable;
 use Throwable;
 
 /**
  * Exceptions occurring during document processing
  */
-class DocumentException extends Exception
+class DocumentException extends Exception implements Stringable
 {
     /**
      * Constructor

tests/Integration/PgIntegrationTest.php

@@ -0,0 +1,60 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ * @see https://github.com/Zaid-Ajaj/ThrowawayDb The origin concept
+ */
+
+declare(strict_types=1);
+
+namespace Test\Integration;
+
+use BitBadger\PDODocument\{Configuration, Custom, Delete, DocumentException, Field};
+use BitBadger\PDODocument\Mapper\ExistsMapper;
+use PHPUnit\Framework\TestCase;
+use Test\Integration\PostgreSQL\ThrowawayDb;
+
+/**
+ * Integration Test Class wrapper for PostgreSQL integration tests
+ */
+class PgIntegrationTest extends TestCase
+{
+    /** @var string Database name for throwaway database */
+    static private string $dbName = '';
+
+    public static function setUpBeforeClass(): void
+    {
+        self::$dbName = ThrowawayDb::create(false);
+    }
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+        ThrowawayDb::loadData();
+    }
+
+    protected function tearDown(): void
+    {
+        Delete::byFields(ThrowawayDb::TABLE, [ Field::exists(Configuration::$idField)]);
+        parent::tearDown();
+    }
+
+    public static function tearDownAfterClass(): void
+    {
+        ThrowawayDb::destroy(self::$dbName);
+        self::$dbName = '';
+    }
+
+    /**
+     * Does the given named object exist in the database?
+     *
+     * @param string $name The name of the object whose existence should be verified
+     * @return bool True if the object exists, false if not
+     * @throws DocumentException If any is encountered
+     */
+    protected function dbObjectExists(string $name): bool
+    {
+        return Custom::scalar('SELECT EXISTS (SELECT 1 FROM pg_class WHERE relname = :name)',
+            [':name' => $name], new ExistsMapper());
+    }
+}

tests/Integration/PostgreSQL/CountTest.php

@@ -0,0 +1,45 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
+
+use BitBadger\PDODocument\{Count, Field};
+use Test\Integration\PostgreSQL\ThrowawayDb;
+
+pest()->group('integration', 'postgresql');
+
+describe('::all()', function () {
+    test('counts all documents', function () {
+        expect(Count::all(ThrowawayDb::TABLE))->toBe(5);
+    });
+});
+
+describe('::byFields()', function () {
+    test('counts for numeric range correctly', function () {
+        expect(Count::byFields(ThrowawayDb::TABLE, [Field::between('num_value', 10, 20)]))->toBe(3);
+    });
+    test('counts for non-numeric range correctly', function () {
+        expect(Count::byFields(ThrowawayDb::TABLE, [Field::between('value', 'aardvark', 'apple')]))->toBe(1);
+    });
+});
+
+describe('::byContains()', function () {
+    test('counts matching documents', function () {
+        expect(Count::byContains(ThrowawayDb::TABLE, ['value' => 'purple']))->toBe(2);
+    });
+    test('returns 0 for no matching documents', function () {
+        expect(Count::byContains(ThrowawayDb::TABLE, ['value' => 'magenta']))->toBe(0);
+    });
+});
+
+describe('::byJsonPath()', function () {
+    test('counts matching documents', function () {
+        expect(Count::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ < 5)'))->toBe(2);
+    });
+    test('returns 0 for no matching documents', function () {
+        expect(Count::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ > 100)'))->toBe(0);
+    });
+});

tests/Integration/PostgreSQL/CustomTest.php

@@ -0,0 +1,97 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
+
+use BitBadger\PDODocument\{Count, Custom, DocumentException, Query};
+use BitBadger\PDODocument\Mapper\{CountMapper, DocumentMapper};
+use Test\Integration\PostgreSQL\ThrowawayDb;
+use Test\Integration\TestDocument;
+
+pest()->group('integration', 'postgresql');
+
+describe('::runQuery()', function () {
+    test('runs a valid query successfully', function () {
+        $stmt = &Custom::runQuery('SELECT data FROM ' . ThrowawayDb::TABLE . ' LIMIT 1', []);
+        try {
+            expect($stmt)->not->toBeNull();
+        } finally {
+            $stmt = null;
+        }
+    });
+    test('fails with an invalid query', function () {
+        $stmt = null;
+        try {
+            expect(function () use (&$stmt) { $stmt = &Custom::runQuery('GRAB stuff FROM over_there UNTIL done', []); })
+                ->toThrow(DocumentException::class);
+        } finally {
+            $stmt = null;
+        }
+    });
+});
+
+describe('::list()', function () {
+    test('returns non-empty list when data found', function () {
+        $list = Custom::list(Query::selectFromTable(ThrowawayDb::TABLE), [], new DocumentMapper(TestDocument::class));
+        expect($list)->not->toBeNull();
+        $count = 0;
+        foreach ($list->items as $ignored) $count++;
+        expect($count)->toBe(5);
+    });
+    test('returns empty list when no data found', function () {
+        expect(Custom::list(
+                Query::selectFromTable(ThrowawayDb::TABLE) . " WHERE (data->>'num_value')::numeric > :value",
+                [':value' => 100], new DocumentMapper(TestDocument::class)))
+            ->not->toBeNull()
+            ->hasItems->toBeFalse();
+    });
+});
+
+describe('::array()', function () {
+    test('returns non-empty array when data found', function () {
+        expect(Custom::array(Query::selectFromTable(ThrowawayDb::TABLE) . " WHERE data->>'sub' IS NOT NULL", [],
+                new DocumentMapper(TestDocument::class)))
+            ->not->toBeNull()
+            ->toHaveCount(2);
+    });
+    test('returns empty array when no data found', function () {
+        expect(Custom::array(Query::selectFromTable(ThrowawayDb::TABLE) . " WHERE data->>'value' = :value",
+                [':value' => 'not there'], new DocumentMapper(TestDocument::class)))
+            ->not->toBeNull()
+            ->toBeEmpty();
+    });
+});
+
+describe('::single()', function () {
+    test('returns a document when one is found', function () {
+        $doc = Custom::single('SELECT data FROM ' . ThrowawayDb::TABLE . " WHERE data->>'id' = :id", [':id' => 'one'],
+            new DocumentMapper(TestDocument::class));
+        expect($doc)->isSome->toBeTrue()->and($doc->value)->id->toBe('one');
+    });
+    test('returns no document when one is not found', function () {
+        expect(Custom::single('SELECT data FROM ' . ThrowawayDb::TABLE . " WHERE data->>'id' = :id",
+                [':id' => 'eighty'], new DocumentMapper(TestDocument::class)))
+            ->isNone->toBeTrue();
+    });
+});
+
+describe('::nonQuery()', function () {
+    test('works when documents match the WHERE clause', function () {
+        Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
+        expect(Count::all(ThrowawayDb::TABLE))->toBe(0);
+    });
+    test('works when no documents match the WHERE clause', function () {
+        Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE . " WHERE (data->>'num_value')::numeric > :value",
+            [':value' => 100]);
+        expect(Count::all(ThrowawayDb::TABLE))->toBe(5);
+    });
+});
+
+describe('::scalar()', function () {
+    test('returns a scalar value', function () {
+        expect(Custom::scalar("SELECT 5 AS it", [], new CountMapper()))->toBe(5);
+    });
+});

tests/Integration/PostgreSQL/DefinitionTest.php

@@ -0,0 +1,47 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
+
+use BitBadger\PDODocument\{Definition, DocumentIndex};
+
+pest()->group('integration', 'postgresql');
+
+describe('::ensureTable()', function () {
+    test('creates a table', function () {
+        expect($this->dbObjectExists('ensured'))->toBeFalse()
+            ->and($this->dbObjectExists('idx_ensured_key'))->toBeFalse();
+        Definition::ensureTable('ensured');
+        expect($this->dbObjectExists('ensured'))->toBeTrue()
+            ->and($this->dbObjectExists('idx_ensured_key'))->toBeTrue();
+    });
+});
+
+describe('::ensureFieldIndex()', function () {
+    test('creates an index', function () {
+        expect($this->dbObjectExists('idx_ensured_test'))->toBeFalse();
+        Definition::ensureTable('ensured');
+        Definition::ensureFieldIndex('ensured', 'test', ['name', 'age']);
+        expect($this->dbObjectExists('idx_ensured_test'))->toBeTrue();
+    });
+});
+
+describe('::ensureDocumentIndex()', function () {
+    test('creates a full index', function () {
+        $docIdx = 'idx_doc_table_document';
+        Definition::ensureTable('doc_table');
+        expect($this->dbObjectExists($docIdx))->toBeFalse();
+        Definition::ensureDocumentIndex('doc_table', DocumentIndex::Full);
+        expect($this->dbObjectExists($docIdx))->toBeTrue();
+    });
+    test('creates an optimized index', function () {
+        $docIdx = 'idx_doc_tbl_document';
+        Definition::ensureTable('doc_tbl');
+        expect($this->dbObjectExists($docIdx))->toBeFalse();
+        Definition::ensureDocumentIndex('doc_tbl', DocumentIndex::Optimized);
+        expect($this->dbObjectExists($docIdx))->toBeTrue();
+    });
+});

tests/Integration/PostgreSQL/DeleteTest.php

@@ -0,0 +1,64 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
+
+use BitBadger\PDODocument\{Count, Delete, Field};
+use Test\Integration\PostgreSQL\ThrowawayDb;
+
+pest()->group('integration', 'postgresql');
+
+describe('::byId()', function () {
+    test('deletes a document when ID is matched', function () {
+        expect(Count::all(ThrowawayDb::TABLE))->toBe(5);
+        Delete::byId(ThrowawayDb::TABLE, 'four');
+        expect(Count::all(ThrowawayDb::TABLE))->toBe(4);
+    });
+    test('does not delete a document when ID is not matched', function () {
+        expect(Count::all(ThrowawayDb::TABLE))->toBe(5);
+        Delete::byId(ThrowawayDb::TABLE, 'negative four');
+        expect(Count::all(ThrowawayDb::TABLE))->toBe(5);
+    });
+});
+
+describe('::byFields()', function () {
+    test('deletes documents when fields match', function () {
+        expect(Count::all(ThrowawayDb::TABLE))->toBe(5);
+        Delete::byFields(ThrowawayDb::TABLE, [Field::notEqual('value', 'purple')]);
+        expect(Count::all(ThrowawayDb::TABLE))->toBe(2);
+    });
+    test('does not delete documents when fields are not matched', function () {
+        expect(Count::all(ThrowawayDb::TABLE))->toBe(5);
+        Delete::byFields(ThrowawayDb::TABLE, [Field::equal('value', 'crimson')]);
+        expect(Count::all(ThrowawayDb::TABLE))->toBe(5);
+    });
+});
+
+describe('::byContains()', function () {
+    test('deletes documents when containment matches', function () {
+        expect(Count::all(ThrowawayDb::TABLE))->toBe(5);
+        Delete::byContains(ThrowawayDb::TABLE, ['value' => 'purple']);
+        expect(Count::all(ThrowawayDb::TABLE))->toBe(3);
+    });
+    test('does not delete documents when containment is not matched', function () {
+        expect(Count::all(ThrowawayDb::TABLE))->toBe(5);
+        Delete::byContains(ThrowawayDb::TABLE, ['target' => 'acquired']);
+        expect(Count::all(ThrowawayDb::TABLE))->toBe(5);
+    });
+});
+
+describe('::byJsonPath()', function () {
+    test('deletes documents when path matches', function () {
+        expect(Count::all(ThrowawayDb::TABLE))->toBe(5);
+        Delete::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ <> 0)');
+        expect(Count::all(ThrowawayDb::TABLE))->toBe(1);
+    });
+    test('does not delete documents when path is not matched', function () {
+        expect(Count::all(ThrowawayDb::TABLE))->toBe(5);
+        Delete::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ < 0)');
+        expect(Count::all(ThrowawayDb::TABLE))->toBe(5);
+    });
+});

tests/Integration/PostgreSQL/DocumentListTest.php

@@ -0,0 +1,96 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
+
+use BitBadger\PDODocument\{DocumentException, DocumentList, Query};
+use BitBadger\PDODocument\Mapper\DocumentMapper;
+use Test\Integration\PostgreSQL\ThrowawayDb;
+use Test\Integration\TestDocument;
+
+pest()->group('integration', 'postgresql');
+
+describe('::create()', function () {
+    test('creates a document list', function () {
+        $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
+            new DocumentMapper(TestDocument::class));
+        expect($list)->not->toBeNull();
+        $list = null; // free database result
+    });
+});
+
+describe('->items', function () {
+    test('enumerates items in the list', function () {
+        $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
+            new DocumentMapper(TestDocument::class));
+        expect($list)->not->toBeNull();
+        $count = 0;
+        foreach ($list->items as $item) {
+            expect(['one', 'two', 'three', 'four', 'five'])->toContain($item->id);
+            $count++;
+        }
+        expect($count)->toBe(5);
+    });
+    test('fails when the list is exhausted', function () {
+        $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
+            new DocumentMapper(TestDocument::class));
+        expect($list)->not->toBeNull()->hasItems->toBeTrue();
+        $ignored = iterator_to_array($list->items);
+        expect($list)->hasItems->toBeFalse()
+            ->and(fn () => iterator_to_array($list->items))->toThrow(DocumentException::class);
+    });
+});
+
+describe('->hasItems', function () {
+    test('returns false when no items are in the list', function () {
+        expect(DocumentList::create(
+                Query::selectFromTable(ThrowawayDb::TABLE) . " WHERE (data->>'num_value')::numeric < 0", [],
+                new DocumentMapper(TestDocument::class)))
+            ->not->toBeNull()
+            ->hasItems->toBeFalse();
+    });
+    test('returns true when items are in the list', function () {
+        $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
+            new DocumentMapper(TestDocument::class));
+        expect($list)->not->toBeNull()->hasItems->toBeTrue();
+        foreach ($list->items as $ignored) {
+            expect($list)->hasItems->toBeTrue();
+        }
+        expect($list)->hasItems->toBeFalse();
+    });
+});
+
+describe('->map()', function () {
+    test('transforms the list', function () {
+        $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
+            new DocumentMapper(TestDocument::class));
+        expect($list)->not->toBeNull()->hasItems->toBeTrue();
+        foreach ($list->map(fn($doc) => strrev($doc->id)) as $mapped) {
+            expect(['eno', 'owt', 'eerht', 'ruof', 'evif'])->toContain($mapped);
+        }
+    });
+});
+
+describe('->iter()', function () {
+    test('walks the list', function () {
+        $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
+            new DocumentMapper(TestDocument::class));
+        expect($list)->not->toBeNull()->hasItems->toBeTrue();
+        $splats = [];
+        $list->iter(function ($doc) use (&$splats) { $splats[] = str_repeat('*', strlen($doc->id)); });
+        expect(implode(' ', $splats))->toBe('*** *** ***** **** ****');
+    });
+});
+
+describe('->mapToArray()', function () {
+    test('creates an associative array', function () {
+        $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
+            new DocumentMapper(TestDocument::class));
+        expect($list)->not->toBeNull()->hasItems->toBeTrue()
+            ->and($list->mapToArray(fn($it) => $it->id, fn($it) => $it->value))
+            ->toBe(['one' => 'FIRST!', 'two' => 'another', 'three' => '', 'four' => 'purple', 'five' => 'purple']);
+    });
+});

tests/Integration/PostgreSQL/DocumentTest.php

@@ -0,0 +1,249 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
+
+use BitBadger\PDODocument\{AutoId, Configuration, Custom, Document, DocumentException, Field, Find, Query};
+use BitBadger\PDODocument\Mapper\ArrayMapper;
+use Test\Integration\{NumDocument, SubDocument, TestDocument};
+use Test\Integration\PostgreSQL\ThrowawayDb;
+
+pest()->group('integration', 'postgresql');
+
+describe('::insert()', function () {
+    test('inserts an array with no automatic ID', function () {
+        Document::insert(ThrowawayDb::TABLE, ['id' => 'turkey', 'sub' => ['foo' => 'gobble', 'bar' => 'gobble']]);
+        $tryDoc = Find::byId(ThrowawayDb::TABLE, 'turkey', TestDocument::class);
+        expect($tryDoc)
+            ->isSome->toBeTrue()
+            ->and($tryDoc->value)
+            ->id->toBe('turkey')
+            ->num_value->toBe(0)
+            ->sub->not->toBeNull()
+            ->sub->foo->toBe('gobble')
+            ->sub->bar->toBe('gobble')
+            ->and($tryDoc->value->value)->toBe('');
+    });
+    test('inserts an array with auto-number ID, not provided', function () {
+        Configuration::$autoId = AutoId::Number;
+        try {
+            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
+
+            Document::insert(ThrowawayDb::TABLE, ['id' => 0, 'value' => 'new', 'num_value' => 8]);
+            $doc = Custom::single('SELECT data FROM ' . ThrowawayDb::TABLE, [], new ArrayMapper());
+            expect($doc)->isSome->toBeTrue()
+                ->and(json_decode($doc->value['data']))
+                ->id->toBe(1);
+
+            Document::insert(ThrowawayDb::TABLE, ['id' => 0, 'value' => 'again', 'num_value' => 7]);
+            $doc = Custom::single('SELECT data FROM ' . ThrowawayDb::TABLE . " WHERE " . Query::whereById(docId: 2),
+                [':id' => 2], new ArrayMapper());
+            expect($doc)->isSome->toBeTrue()
+                ->and(json_decode($doc->value['data']))
+                ->id->toBe(2);
+        } finally {
+            Configuration::$autoId = AutoId::None;
+        }
+    });
+    test('inserts an array with auto-number ID, provided', function () {
+        Configuration::$autoId = AutoId::Number;
+        try {
+            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
+            Document::insert(ThrowawayDb::TABLE, ['id' => 7, 'value' => 'new', 'num_value' => 8]);
+            $doc = Custom::single('SELECT data FROM ' . ThrowawayDb::TABLE, [], new ArrayMapper());
+            expect($doc)->isSome->toBeTrue()
+                ->and(json_decode($doc->value['data']))
+                ->id->toBe(7);
+        } finally {
+            Configuration::$autoId = AutoId::None;
+        }
+
+    });
+    test('inserts an array with auto-UUID ID, not provided', function () {
+        Configuration::$autoId = AutoId::UUID;
+        try {
+            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
+            Document::insert(ThrowawayDb::TABLE, ['id' => '', 'num_value' => 5]);
+            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 5)], TestDocument::class);
+            expect($doc)
+                ->isSome->toBeTrue()
+                ->and($doc->value)->id->not->toBeEmpty();
+        } finally {
+            Configuration::$autoId = AutoId::None;
+        }
+    });
+    test('inserts an array with auto-UUID ID, provided', function () {
+        Configuration::$autoId = AutoId::UUID;
+        try {
+            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
+            $uuid = AutoId::generateUUID();
+            Document::insert(ThrowawayDb::TABLE, ['id' => $uuid, 'value' => 'uuid', 'num_value' => 12]);
+            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 12)], TestDocument::class);
+            expect($doc)->isSome->toBeTrue()
+                ->and($doc->value)->id->toBe($uuid);
+        } finally {
+            Configuration::$autoId = AutoId::None;
+        }
+    });
+    test('inserts an array with auto-string ID, not provided', function () {
+        Configuration::$autoId         = AutoId::RandomString;
+        Configuration::$idStringLength = 6;
+        try {
+            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
+            Document::insert(ThrowawayDb::TABLE, ['id' => '', 'value' => 'new', 'num_value' => 8]);
+            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 8)], TestDocument::class);
+            expect($doc)->isSome->toBeTrue()
+                ->and($doc->value)->id->toHaveLength(6);
+        } finally {
+            Configuration::$autoId         = AutoId::None;
+            Configuration::$idStringLength = 16;
+        }
+    });
+    test('inserts an array with auto-string ID, provided', function () {
+        Configuration::$autoId = AutoId::RandomString;
+        try {
+            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
+            Document::insert(ThrowawayDb::TABLE, ['id' => 'my-key', 'value' => 'old', 'num_value' => 3]);
+            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 3)], TestDocument::class);
+            expect($doc)->isSome->toBeTrue()
+                ->and($doc->value)->id->toBe('my-key');
+        } finally {
+            Configuration::$autoId = AutoId::None;
+        }
+    });
+    test('inserts an object with no automatic ID', function () {
+        Document::insert(ThrowawayDb::TABLE, new TestDocument('turkey', sub: new SubDocument('gobble', 'gobble')));
+        $tryDoc = Find::byId(ThrowawayDb::TABLE, 'turkey', TestDocument::class);
+        expect($tryDoc)->isSome->toBeTrue();
+        $doc = $tryDoc->value;
+        expect($doc)
+            ->id->toBe('turkey')
+            ->num_value->toBe(0)
+            ->sub->not->toBeNull()
+            ->sub->foo->toBe('gobble')
+            ->sub->bar->toBe('gobble')
+            ->and($doc->value)->toBe('');
+    });
+    test('inserts an object with auto-number ID, not provided', function () {
+        Configuration::$autoId = AutoId::Number;
+        try {
+            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
+
+            Document::insert(ThrowawayDb::TABLE, new NumDocument(value: 'taco'));
+            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('value', 'taco')], NumDocument::class);
+            expect($doc)->isSome->toBeTrue()
+                ->and($doc->value)->id->toBe(1);
+
+            Document::insert(ThrowawayDb::TABLE, new NumDocument(value: 'burrito'));
+            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('value', 'burrito')], NumDocument::class);
+            expect($doc)->isSome->toBeTrue()
+                ->and($doc->value)->id->toBe(2);
+        } finally {
+            Configuration::$autoId = AutoId::None;
+        }
+    });
+    test('inserts an object with auto-number ID, provided', function () {
+        Configuration::$autoId = AutoId::Number;
+        try {
+            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
+            Document::insert(ThrowawayDb::TABLE, new NumDocument(64, 'large'));
+            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('value', 'large')], NumDocument::class);
+            expect($doc)->isSome->toBeTrue()
+                ->and($doc->value)->id->toBe(64);
+        } finally {
+            Configuration::$autoId = AutoId::None;
+        }
+    });
+    test('inserts an object with auto-UUID ID, not provided', function () {
+        Configuration::$autoId = AutoId::UUID;
+        try {
+            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
+            Document::insert(ThrowawayDb::TABLE, new TestDocument(value: 'something', num_value: 9));
+            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::exists('value')], TestDocument::class);
+            expect($doc)->isSome->toBeTrue()
+                ->and($doc->value)->id->not->toBeEmpty();
+        } finally {
+            Configuration::$autoId = AutoId::None;
+        }
+    });
+    test('inserts an object with auto-UUID ID, provided', function () {
+        Configuration::$autoId = AutoId::UUID;
+        try {
+            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
+            $uuid = AutoId::generateUUID();
+            Document::insert(ThrowawayDb::TABLE, new TestDocument($uuid, num_value: 14));
+            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 14)], TestDocument::class);
+            expect($doc)->isSome->toBeTrue()
+                ->and($doc->value)->id->toBe($uuid);
+        } finally {
+            Configuration::$autoId = AutoId::None;
+        }
+    });
+    test('inserts an object with auto-string ID, not provided', function () {
+        Configuration::$autoId         = AutoId::RandomString;
+        Configuration::$idStringLength = 40;
+        try {
+            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
+            Document::insert(ThrowawayDb::TABLE, new TestDocument(num_value: 55));
+            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 55)], TestDocument::class);
+            expect($doc)->isSome->toBeTrue()
+                ->and($doc->value)->id->toHaveLength(40);
+        } finally {
+            Configuration::$autoId         = AutoId::None;
+            Configuration::$idStringLength = 16;
+        }
+    });
+    test('inserts an object with auto-string ID, provided', function () {
+        Configuration::$autoId = AutoId::RandomString;
+        try {
+            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
+            Document::insert(ThrowawayDb::TABLE, new TestDocument('my-key', num_value: 3));
+            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 3)], TestDocument::class);
+            expect($doc)->isSome->toBeTrue()
+                ->and($doc->value)->id->toBe('my-key');
+        } finally {
+            Configuration::$autoId = AutoId::None;
+        }
+    });
+    test('throws an exception for duplicate key', function () {
+        expect(fn () => Document::insert(ThrowawayDb::TABLE, new TestDocument('one')))
+            ->toThrow(DocumentException::class);
+    });
+});
+
+describe('::save()', function () {
+    test('inserts a new document', function () {
+        Document::save(ThrowawayDb::TABLE, new TestDocument('test', sub: new SubDocument('a', 'b')));
+        expect(Find::byId(ThrowawayDb::TABLE, 'one', TestDocument::class))->isSome->toBeTrue();
+    });
+    test('updates an existing document', function () {
+        Document::save(ThrowawayDb::TABLE, new TestDocument('two', num_value: 44));
+        $tryDoc = Find::byId(ThrowawayDb::TABLE, 'two', TestDocument::class);
+        expect($tryDoc)->isSome->toBeTrue()
+            ->and($tryDoc->value)
+            ->num_value->toBe(44)
+            ->sub->toBeNull();
+    });
+});
+
+describe('::update()', function () {
+    test('replaces an existing document', function () {
+        Document::update(ThrowawayDb::TABLE, 'one', new TestDocument('one', 'howdy', 8, new SubDocument('y', 'z')));
+        $tryDoc = Find::byId(ThrowawayDb::TABLE, 'one', TestDocument::class);
+        expect($tryDoc)->isSome->toBeTrue();
+        $doc = $tryDoc->value;
+        expect($doc)
+            ->num_value->toBe(8)
+            ->sub->not->toBeNull()
+            ->sub->foo->toBe('y')
+            ->sub->bar->toBe('z')
+            ->and($doc->value)->toBe('howdy');
+    });
+    test('does nothing for a non-existent document', function () {
+        Document::update(ThrowawayDb::TABLE, 'two-hundred', new TestDocument('200'));
+        expect(Find::byId(ThrowawayDb::TABLE, 'two-hundred', TestDocument::class))->isNone->toBeTrue();
+    });
+});

tests/Integration/PostgreSQL/ExistsTest.php

@@ -0,0 +1,48 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
+
+use BitBadger\PDODocument\{Exists, Field};
+use Test\Integration\PostgreSQL\ThrowawayDb;
+
+pest()->group('integration', 'postgresql');
+
+describe('::byId()', function () {
+    test('returns true when a document exists', function () {
+        expect(Exists::byId(ThrowawayDb::TABLE, 'three'))->toBeTrue();
+    });
+    test('returns false when a document does not exist', function () {
+        expect(Exists::byId(ThrowawayDb::TABLE, 'seven'))->toBeFalse();
+    });
+});
+
+describe('::byFields()', function () {
+    test('returns true when matching documents exist', function () {
+        expect(Exists::byFields(ThrowawayDb::TABLE, [Field::equal('num_value', 10)]))->toBeTrue();
+    });
+    test('returns false when no matching documents exist', function () {
+        expect(Exists::byFields(ThrowawayDb::TABLE, [Field::less('nothing', 'none')]))->toBeFalse();
+    });
+});
+
+describe('::byContains()', function () {
+    test('returns true when matching documents exist', function () {
+        expect(Exists::byContains(ThrowawayDb::TABLE, ['value' => 'purple']))->toBeTrue();
+    });
+    test('returns false when no matching documents exist', function () {
+        expect(Exists::byContains(ThrowawayDb::TABLE, ['value' => 'violet']))->toBeFalse();
+    });
+});
+
+describe('::byJsonPath()', function () {
+    test('returns true when matching documents exist', function () {
+        expect(Exists::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ == 10)'))->toBeTrue();
+    });
+    test('returns false when no matching documents exist', function () {
+        expect(Exists::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ == 10.1)'))->toBeFalse();
+    });
+});

tests/Integration/PostgreSQL/FindTest.php

@@ -0,0 +1,214 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
+
+use BitBadger\PDODocument\{Custom, Delete, Document, Field, FieldMatch, Find};
+use Test\Integration\{ArrayDocument, NumDocument, TestDocument};
+use Test\Integration\PostgreSQL\ThrowawayDb;
+
+pest()->group('integration', 'postgresql');
+
+describe('::all()', function () {
+    test('retrieves data', function () {
+        $docs = Find::all(ThrowawayDb::TABLE, TestDocument::class);
+        expect($docs)->not->toBeNull();
+        $count = 0;
+        foreach ($docs->items as $ignored) $count++;
+        expect($count)->toBe(5);
+    });
+    test('sorts data ascending', function () {
+        $docs = Find::all(ThrowawayDb::TABLE, TestDocument::class, [Field::named('id')]);
+        expect($docs)->not->toBeNull()
+            ->and(iterator_to_array($docs->map(fn ($it) => $it->id), false))
+            ->toBe(['five', 'four', 'one', 'three', 'two']);
+    });
+    test('sorts data descending', function () {
+        $docs = Find::all(ThrowawayDb::TABLE, TestDocument::class, [Field::named('id DESC')]);
+        expect($docs)->not->toBeNull()
+            ->and(iterator_to_array($docs->map(fn ($it) => $it->id), false))
+            ->toBe(['two', 'three', 'one', 'four', 'five']);
+    });
+    test('sorts data numerically', function () {
+        $docs = Find::all(ThrowawayDb::TABLE, TestDocument::class,
+            [Field::named('sub.foo NULLS LAST'), Field::named('n:num_value')]);
+        expect($docs)->not->toBeNull()
+            ->and(iterator_to_array($docs->map(fn ($it) => $it->id), false))
+            ->toBe(['two', 'four', 'one', 'three', 'five']);
+    });
+    test('retrieves empty results', function () {
+        Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
+        expect(Find::all(ThrowawayDb::TABLE, TestDocument::class))
+            ->not->toBeNull()
+            ->hasItems->toBeFalse();
+    });
+});
+
+describe('::byId()', function () {
+    test('retrieves a document via string ID', function () {
+        $doc = Find::byId(ThrowawayDb::TABLE, 'two', TestDocument::class);
+        expect($doc)->isSome->toBeTrue()->and($doc->value)->id->toBe('two');
+    });
+    test('retrieves a document via numeric ID', function () {
+        Delete::byFields(ThrowawayDb::TABLE, [Field::notExists('absent')]);
+        Document::insert(ThrowawayDb::TABLE, ['id' => 18, 'value' => 'howdy']);
+        $doc = Find::byId(ThrowawayDb::TABLE, 18, NumDocument::class);
+        expect($doc)->isSome->toBeTrue()->and($doc->value)->id->toBe(18);
+    });
+    test('returns None when a document is not found', function () {
+        expect(Find::byId(ThrowawayDb::TABLE, 'seventy-five', TestDocument::class))->isNone->toBeTrue();
+    });
+});
+
+describe('::byFields()', function () {
+    test('retrieves matching documents', function () {
+        $docs = Find::byFields(ThrowawayDb::TABLE, [Field::in('value', ['blue', 'purple']), Field::exists('sub')],
+            TestDocument::class, FieldMatch::All);
+        expect($docs)->not->toBeNull();
+        $count = 0;
+        foreach ($docs->items as $ignored) $count++;
+        expect($count)->toBe(1);
+    });
+    test('retrieves ordered matching documents', function () {
+        $docs = Find::byFields(ThrowawayDb::TABLE, [Field::equal('value', 'purple')], TestDocument::class,
+            FieldMatch::All, [Field::named('id')]);
+        expect($docs)->not->toBeNull()
+            ->and(iterator_to_array($docs->map(fn ($it) => $it->id), false))->toBe(['five', 'four']);
+    });
+    test('retrieves documents matching a numeric IN clause', function () {
+        $docs = Find::byFields(ThrowawayDb::TABLE, [Field::in('num_value', [2, 4, 6, 8])], TestDocument::class);
+        expect($docs)->not->toBeNull();
+        $count = 0;
+        foreach ($docs->items as $ignored) $count++;
+        expect($count)->toBe(1);
+    });
+    test('returns an empty list when no matching documents are found', function () {
+        expect(Find::byFields(ThrowawayDb::TABLE, [Field::greater('num_value', 100)], TestDocument::class))
+            ->not->toBeNull()
+            ->hasItems->toBeFalse();
+    });
+    test('retrieves documents matching an inArray condition', function () {
+        Delete::byFields(ThrowawayDb::TABLE, [Field::notExists('absentField')]);
+        foreach (ArrayDocument::testDocuments() as $doc) Document::insert(ThrowawayDb::TABLE, $doc);
+        $docs = Find::byFields(ThrowawayDb::TABLE, [Field::inArray('values', ThrowawayDb::TABLE, ['c'])],
+            ArrayDocument::class);
+        expect($docs)->not->toBeNull();
+        $count = 0;
+        foreach ($docs->items as $ignored) $count++;
+        expect($count)->toBe(2);
+    });
+    test('returns an empty list when no documents match an inArray condition', function () {
+        Delete::byFields(ThrowawayDb::TABLE, [Field::notExists('absentField')]);
+        foreach (ArrayDocument::testDocuments() as $doc) Document::insert(ThrowawayDb::TABLE, $doc);
+        expect(Find::byFields(ThrowawayDb::TABLE, [Field::inArray('values', ThrowawayDb::TABLE, ['j'])],
+                ArrayDocument::class))
+            ->not->toBeNull()
+            ->hasItems->toBeFalse();
+    });
+});
+
+describe('::byContains()', function () {
+    test('retrieves matching documents', function () {
+        $docs = Find::byContains(ThrowawayDb::TABLE, ['value' => 'purple'], TestDocument::class);
+        expect($docs)->not->toBeNull();
+        $count = 0;
+        foreach ($docs->items as $ignored) $count++;
+        expect($count)->toBe(2);
+    });
+    test('retrieves ordered matching documents', function () {
+        $docs = Find::byContains(ThrowawayDb::TABLE, ['sub' => ['foo' => 'green']], TestDocument::class,
+            [Field::named('value')]);
+        expect($docs)
+            ->not->toBeNull()
+            ->and(iterator_to_array($docs->map(fn ($it) => $it->id), false))->toBe(['two', 'four']);
+    });
+    test('returns an empty list when no documents match', function () {
+        expect(Find::byContains(ThrowawayDb::TABLE, ['value' => 'indigo'], TestDocument::class))
+            ->not->toBeNull()
+            ->hasItems->toBeFalse();
+    });
+});
+
+describe('::byJsonPath()', function () {
+    test('retrieves matching documents', function () {
+        $docs = Find::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ > 10)', TestDocument::class);
+        expect($docs)->not->toBeNull();
+        $count = 0;
+        foreach ($docs->items as $ignored) $count++;
+        expect($count)->toBe(2);
+    });
+    test('retrieves ordered matching documents', function () {
+        $docs = Find::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ > 10)', TestDocument::class,
+            [Field::named('id')]);
+        expect($docs)->not->toBeNull()
+            ->and(iterator_to_array($docs->map(fn ($it) => $it->id), false))->toBe(['five', 'four']);
+    });
+    test('returns an empty list when no documents match', function () {
+        expect(Find::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ > 100)', TestDocument::class))
+            ->not->toBeNull()
+            ->hasItems->toBeFalse();
+    });
+});
+
+describe('::firstByFields()', function () {
+    test('retrieves a matching document', function () {
+        $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('value', 'another')], TestDocument::class);
+        expect($doc)->isSome->toBeTrue()->and($doc->value)->id->toBe('two');
+    });
+    test('retrieves a document for multiple results', function () {
+        $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('sub.foo', 'green')], TestDocument::class);
+        expect($doc)->isSome->toBeTrue()->and(['two', 'four'])->toContain($doc->value->id);
+    });
+    test('retrieves a document for multiple ordered results', function () {
+        $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('sub.foo', 'green')], TestDocument::class,
+            orderBy: [Field::named('n:num_value DESC')]);
+        expect($doc)->isSome->toBeTrue()->and($doc->value)->id->toBe('four');
+    });
+    test('returns None when no documents match', function () {
+        expect(Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('value', 'absent')], TestDocument::class))
+            ->isNone->toBeTrue();
+    });
+});
+
+describe('::firstByContains()', function () {
+    test('retrieves a matching document', function () {
+        $doc = Find::firstByContains(ThrowawayDb::TABLE, ['value' => 'FIRST!'], TestDocument::class);
+        expect($doc)->isSome->toBeTrue()->and($doc->value)->id->toBe('one');
+    });
+    test('retrieves a document for multiple results', function () {
+        $doc = Find::firstByContains(ThrowawayDb::TABLE, ['value' => 'purple'], TestDocument::class);
+        expect($doc)->isSome->toBeTrue()->and(['four', 'five'])->toContain($doc->value->id);
+    });
+    test('retrieves a document for multiple ordered results', function () {
+        $doc = Find::firstByContains(ThrowawayDb::TABLE, ['value' => 'purple'], TestDocument::class,
+            [Field::named('sub.bar NULLS FIRST')]);
+        expect($doc)->isSome->toBeTrue()->and($doc->value)->id->toBe('five');
+    });
+    test('returns None when no documents match', function () {
+        expect(Find::firstByContains(ThrowawayDb::TABLE, ['value' => 'indigo'], TestDocument::class))
+            ->isNone->toBeTrue();
+    });
+});
+
+describe('::firstByJsonPath()', function () {
+    test('retrieves a matching document', function () {
+        $doc = Find::firstByJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ == 10)', TestDocument::class);
+        expect($doc)->isSome->toBeTrue()->and($doc->value)->id->toBe('two');
+    });
+    test('retrieves a document for multiple results', function () {
+        $doc = Find::firstByJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ > 10)', TestDocument::class);
+        expect($doc)->isSome->toBeTrue()->and(['four', 'five'])->toContain($doc->value->id);
+    });
+    test('retrieves a document for multiple ordered results', function () {
+        $doc = Find::firstByJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ > 10)', TestDocument::class,
+            [Field::named('id DESC')]);
+        expect($doc)->isSome->toBeTrue()->and($doc->value)->id->toBe('four');
+    });
+    test('returns None when no documents match', function () {
+        expect(Find::firstByJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ > 100)', TestDocument::class))
+            ->isNone->toBeTrue();
+    });
+});

tests/Integration/PostgreSQL/PatchTest.php

@@ -0,0 +1,71 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
+
+use BitBadger\PDODocument\{Count, Exists, Field, Find, Patch};
+use Test\Integration\PostgreSQL\ThrowawayDb;
+use Test\Integration\TestDocument;
+
+pest()->group('integration', 'postgresql');
+
+describe('::byId()', function () {
+    test('updates an existing document', function () {
+        Patch::byId(ThrowawayDb::TABLE, 'one', ['num_value' => 44]);
+        $doc = Find::byId(ThrowawayDb::TABLE, 'one', TestDocument::class);
+        expect($doc)->isSome->toBeTrue()->and($doc->value)->num_value->toBe(44);
+    });
+    test('does nothing when a document does not exist', function () {
+        $id = 'forty-seven';
+        expect(Exists::byId(ThrowawayDb::TABLE, $id))->toBeFalse();
+        Patch::byId(ThrowawayDb::TABLE, $id, ['foo' => 'green']); // no exception = pass
+    });
+});
+
+describe('::byFields()', function () {
+    test('updates existing documents', function () {
+        Patch::byFields(ThrowawayDb::TABLE, [Field::equal('value', 'purple')], ['num_value' => 77]);
+        expect(Count::byFields(ThrowawayDb::TABLE, [Field::equal('num_value', 77)]))->toBe(2);
+    });
+    test('does nothing when no matching documents exist', function () {
+        $fields = [Field::equal('value', 'burgundy')];
+        expect(Count::byFields(ThrowawayDb::TABLE, $fields))->toBe(0);
+        Patch::byFields(ThrowawayDb::TABLE, $fields, ['foo' => 'green']); // no exception = pass
+    });
+});
+
+describe('::byContains()', function () {
+    test('updates existing documents', function () {
+        Patch::byContains(ThrowawayDb::TABLE, ['value' => 'another'], ['num_value' => 12]);
+        $tryDoc = Find::firstByContains(ThrowawayDb::TABLE, ['value' => 'another'], TestDocument::class);
+        expect($tryDoc)->isSome->toBeTrue()
+            ->and($tryDoc->value)
+            ->id->toBe('two')
+            ->num_value->toBe(12);
+    });
+    test('does nothing when no matching documents exist', function () {
+        $criteria = ['value' => 'updated'];
+        expect(Count::byContains(ThrowawayDb::TABLE, $criteria))->toBe(0);
+        Patch::byContains(ThrowawayDb::TABLE, $criteria, ['sub.foo' => 'green']); // no exception = pass
+    });
+});
+
+describe('::byJsonPath()', function () {
+    test('updates existing documents', function () {
+        Patch::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ > 10)', ['value' => 'blue']);
+        $docs = Find::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ > 10)', TestDocument::class);
+        expect($docs)->not->toBeNull()->hasItems->toBeTrue();
+        foreach ($docs->items as $item) {
+            expect(['four', 'five'])->toContain($item->id)
+                ->and($item->value)->toBe('blue');
+        }
+    });
+    test('does nothing when no matching documents exist', function () {
+        $path = '$.num_value ? (@ > 100)';
+        expect(Count::byJsonPath(ThrowawayDb::TABLE, $path))->toBe(0);
+        Patch::byJsonPath(ThrowawayDb::TABLE, $path, ['value' => 'blue']); // no exception = pass
+    });
+});

tests/Integration/PostgreSQL/RemoveFieldsTest.php

@@ -0,0 +1,90 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
+
+use BitBadger\PDODocument\{Exists, Field, Find, RemoveFields};
+use Test\Integration\PostgreSQL\ThrowawayDb;
+use Test\Integration\TestDocument;
+
+pest()->group('integration', 'postgresql');
+
+describe('::byId()', function () {
+    test('removes fields', function () {
+        RemoveFields::byId(ThrowawayDb::TABLE, 'two', ['sub', 'value']);
+        $tryDoc = Find::byId(ThrowawayDb::TABLE, 'two', TestDocument::class);
+        expect($tryDoc)->isSome->toBeTrue();
+        $doc = $tryDoc->value;
+        expect($doc)->sub->toBeNull()
+            ->and($doc->value)->toBeEmpty();
+    });
+    test('does nothing when the field to remove does not exist', function () {
+        expect(Exists::byFields(ThrowawayDb::TABLE, [Field::exists('a_field_that_does_not_exist')]))->toBeFalse();
+        RemoveFields::byId(ThrowawayDb::TABLE, 'one', ['a_field_that_does_not_exist']); // no exception = pass
+    });
+    test('does nothing when the document does not exist', function () {
+        expect(Exists::byId(ThrowawayDb::TABLE, 'fifty'))->toBeFalse();
+        RemoveFields::byId(ThrowawayDb::TABLE, 'fifty', ['sub']); // no exception = pass
+    });
+});
+
+describe('::byFields()', function () {
+    test('removes fields from matching documents', function () {
+        RemoveFields::byFields(ThrowawayDb::TABLE, [Field::equal('num_value', 17)], ['sub']);
+        $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 17)], TestDocument::class);
+        expect($doc)->isSome->toBeTrue()->and($doc->value)->sub->toBeNull();
+    });
+    test('does nothing when the field to remove does not exist', function () {
+        expect(Exists::byFields(ThrowawayDb::TABLE, [Field::exists('nada')]))->toBeFalse();
+        RemoveFields::byFields(ThrowawayDb::TABLE, [Field::equal('num_value', 17)], ['nada']); // no exception = pass
+    });
+    test('does nothing when no documents match', function () {
+        expect(Exists::byFields(ThrowawayDb::TABLE, [Field::notEqual('missing', 'nope')]))->toBeFalse();
+        RemoveFields::byFields(ThrowawayDb::TABLE, [Field::notEqual('missing', 'nope')], ['value']); // no exn = pass
+    });
+});
+
+describe('::byContains()', function () {
+    test('removes fields from matching documents', function () {
+        $criteria = ['sub' => ['foo' => 'green']];
+        RemoveFields::byContains(ThrowawayDb::TABLE, $criteria, ['value']);
+        $docs = Find::byContains(ThrowawayDb::TABLE, $criteria, TestDocument::class);
+        expect($docs)->not->toBeNull()->hasItems->toBeTrue();
+        foreach ($docs->items as $item) {
+            expect(['two', 'four'])->toContain($item->id)
+                ->and($item->value)->toBeEmpty();
+        }
+    });
+    test('does nothing when the field to remove does not exist', function () {
+        expect(Exists::byFields(ThrowawayDb::TABLE, [Field::exists('invalid_field')]))->toBeFalse();
+        RemoveFields::byContains(ThrowawayDb::TABLE, ['sub' => ['foo' => 'green']], ['invalid_field']); // no exn = pass
+    });
+    test('does nothing when no documents match', function () {
+        expect(Exists::byContains(ThrowawayDb::TABLE, ['value' => 'substantial']))->toBeFalse();
+        RemoveFields::byContains(ThrowawayDb::TABLE, ['value' => 'substantial'], ['num_value']); // no exception = pass
+    });
+});
+
+describe('::byJsonPath()', function () {
+    test('removes fields from matching documents', function () {
+        $path = '$.value ? (@ == "purple")';
+        RemoveFields::byJsonPath(ThrowawayDb::TABLE, $path, ['sub']);
+        $docs = Find::byJsonPath(ThrowawayDb::TABLE, $path, TestDocument::class);
+        expect($docs)->not->toBeNull()->hasItems->toBeTrue();
+        foreach ($docs->items as $item) {
+            expect(['four', 'five'])->toContain($item->id)
+                ->and($item->sub)->toBeNull();
+        }
+    });
+    test('does nothing when the field to remove does not exist', function () {
+        expect(Exists::byFields(ThrowawayDb::TABLE, [Field::exists('submarine')]))->toBeFalse();
+        RemoveFields::byJsonPath(ThrowawayDb::TABLE, '$.value ? (@ == "purple")', ['submarine']); // no exception = pass
+    });
+    test('does nothing when no documents match', function () {
+        expect(Exists::byJsonPath(ThrowawayDb::TABLE, '$.value ? (@ == "mauve")'))->toBeFalse();
+        RemoveFields::byJsonPath(ThrowawayDb::TABLE, '$.value ? (@ == "mauve")', ['value']); // no exception = pass
+    });
+});

tests/Integration/PostgreSQL/ThrowawayDb.php

@@ -37,6 +37,20 @@ class ThrowawayDb
         Configuration::resetPDO();
     }
 
+    /**
+     * Load data into the test table
+     *
+     * @throws DocumentException If any is encountered
+     */
+    public static function loadData(): void
+    {
+        Document::insert(self::TABLE, new TestDocument('one', 'FIRST!', 0));
+        Document::insert(self::TABLE, new TestDocument('two', 'another', 10, new SubDocument('green', 'blue')));
+        Document::insert(self::TABLE, new TestDocument('three', '', 4));
+        Document::insert(self::TABLE, new TestDocument('four', 'purple', 17, new SubDocument('green', 'red')));
+        Document::insert(self::TABLE, new TestDocument('five', 'purple', 18));
+    }
+
     /**
      * Create a throwaway PostgreSQL database
      *
@@ -51,13 +65,10 @@ class ThrowawayDb
         Custom::nonQuery("CREATE DATABASE $dbName WITH OWNER " . Configuration::$username, []);
         self::configure($dbName);
 
+        Definition::ensureTable(self::TABLE);
+
         if ($withData) {
-            Definition::ensureTable(self::TABLE);
-            Document::insert(self::TABLE, new TestDocument('one', 'FIRST!', 0));
-            Document::insert(self::TABLE, new TestDocument('two', 'another', 10, new SubDocument('green', 'blue')));
-            Document::insert(self::TABLE, new TestDocument('three', '', 4));
-            Document::insert(self::TABLE, new TestDocument('four', 'purple', 17, new SubDocument('green', 'red')));
-            Document::insert(self::TABLE, new TestDocument('five', 'purple', 18));
+            self::loadData();
         }
 
         return $dbName;

tests/Integration/SQLite/CountTest.php

@@ -0,0 +1,39 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
+
+use BitBadger\PDODocument\{Count, DocumentException, Field};
+use Test\Integration\SQLite\ThrowawayDb;
+
+pest()->group('integration', 'sqlite');
+
+describe('::all()', function () {
+    test('counts all documents', function () {
+        expect(Count::all(ThrowawayDb::TABLE))->toBe(5);
+    });
+});
+
+describe('::byFields()', function () {
+    test('counts by numeric range', function () {
+        expect(Count::byFields(ThrowawayDb::TABLE, [Field::between('num_value', 10, 20)]))->toBe(3);
+    });
+    test('counts by non-numeric range', function () {
+        expect(Count::byFields(ThrowawayDb::TABLE, [Field::between('value', 'aardvark', 'apple')]))->toBe(1);
+    });
+});
+
+describe('::byContains()', function () {
+    test('throws an exception', function () {
+        expect(fn () => Count::byContains('', []))->toThrow(DocumentException::class);
+    });
+});
+
+describe('::byJsonPath()', function () {
+    test('throws an exception', function () {
+        expect(fn () => Count::byJsonPath('', ''))->toThrow(DocumentException::class);
+    });
+});

tests/Integration/SQLite/CustomTest.php

@@ -0,0 +1,94 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
+
+use BitBadger\PDODocument\{Count, Custom, DocumentException, Query};
+use BitBadger\PDODocument\Mapper\{CountMapper, DocumentMapper};
+use Test\Integration\SQLite\ThrowawayDb;
+use Test\Integration\TestDocument;
+
+pest()->group('integration', 'sqlite');
+
+describe('::runQuery()', function () {
+    test('runs a valid query successfully', function () {
+        $stmt = &Custom::runQuery('SELECT data FROM ' . ThrowawayDb::TABLE . ' LIMIT 1', []);
+        try {
+            expect($stmt)->not->toBeNull();
+        } finally {
+            $stmt = null;
+        }
+    });
+    test('fails with an invalid query', function () {
+        $stmt = null;
+        try {
+            expect(function () use (&$stmt) { $stmt = &Custom::runQuery('GRAB stuff FROM over_there UNTIL done', []); })
+                ->toThrow(DocumentException::class);
+        } finally {
+            $stmt = null;
+        }
+    });
+});
+
+describe('::list()', function () {
+    test('returns non-empty list when data is found', function () {
+        $list = Custom::list(Query::selectFromTable(ThrowawayDb::TABLE), [], new DocumentMapper(TestDocument::class));
+        expect($list)->not->toBeNull();
+        $count = 0;
+        foreach ($list->items as $ignored) $count++;
+        expect($count)->toBe(5);
+    });
+    test('returns empty list when not data is found', function () {
+        expect(Custom::list(Query::selectFromTable(ThrowawayDb::TABLE) . " WHERE data->>'num_value' > :value",
+            [':value' => 100], new DocumentMapper(TestDocument::class)))
+            ->not->toBeNull()
+            ->hasItems->toBeFalse();
+
+    });
+});
+
+describe('::array()', function () {
+    test('returns non-empty array when data is found', function () {
+        expect(Custom::array(Query::selectFromTable(ThrowawayDb::TABLE) . " WHERE data->>'sub' IS NOT NULL", [],
+                new DocumentMapper(TestDocument::class)))
+            ->not->toBeNull()->toHaveCount(2);
+    });
+    test('returns empty array when data is not found', function () {
+        expect(Custom::array(Query::selectFromTable(ThrowawayDb::TABLE) . " WHERE data->>'value' = :value",
+                [':value' => 'not there'], new DocumentMapper(TestDocument::class)))
+            ->not->toBeNull()->toBeEmpty();
+    });
+});
+
+describe('::single()', function () {
+    test('returns a document when one is found', function () {
+        $doc = Custom::single('SELECT data FROM ' . ThrowawayDb::TABLE . " WHERE data->>'id' = :id", [':id' => 'one'],
+            new DocumentMapper(TestDocument::class));
+        expect($doc)->isSome->toBeTrue()->and($doc->value)->id->toBe('one');
+    });
+    test('returns no document when none is found', function () {
+        expect(Custom::single('SELECT data FROM ' . ThrowawayDb::TABLE . " WHERE data->>'id' = :id",
+                [':id' => 'eighty'], new DocumentMapper(TestDocument::class)))
+            ->isNone->toBeTrue();
+    });
+});
+
+describe('::nonQuery()', function () {
+    test('works when documents match the WHERE clause', function () {
+        Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
+        expect(Count::all(ThrowawayDb::TABLE))->toBe(0);
+    });
+    test('works when no documents match the WHERE clause', function () {
+        Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE . " WHERE data->>'num_value' > :value", [':value' => 100]);
+        expect(Count::all(ThrowawayDb::TABLE))->toBe(5);
+    });
+});
+
+describe('::scalar()', function () {
+    test('returns a scalar value', function () {
+        expect(Custom::scalar("SELECT 5 AS it", [], new CountMapper()))->toBe(5);
+    });
+});

tests/Integration/SQLite/DefinitionTest.php

@@ -0,0 +1,36 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
+
+use BitBadger\PDODocument\{Definition, DocumentException, DocumentIndex};
+
+pest()->group('integration', 'sqlite');
+
+describe('::ensureTable()', function () {
+    test('creates table and PK index', function () {
+        expect($this->dbObjectExists('ensured'))->toBeFalse()
+            ->and($this->dbObjectExists('idx_ensured_key'))->toBeFalse();
+        Definition::ensureTable('ensured');
+        expect($this->dbObjectExists('ensured'))->toBeTrue()
+            ->and($this->dbObjectExists('idx_ensured_key'))->toBeTrue();
+    });
+});
+
+describe('::ensureFieldIndex()', function () {
+    test('creates an index', function () {
+        expect($this->dbObjectExists('idx_ensured_test'))->toBeFalse();
+        Definition::ensureTable('ensured');
+        Definition::ensureFieldIndex('ensured', 'test', ['name', 'age']);
+        expect($this->dbObjectExists('idx_ensured_test'))->toBeTrue();
+    });
+});
+
+describe('::ensureDocumentIndex()', function () {
+    test('throws an exception', function () {
+        expect(fn () => Definition::ensureDocumentIndex('', DocumentIndex::Full))->toThrow(DocumentException::class);
+    });
+});

tests/Integration/SQLite/DeleteTest.php

@@ -0,0 +1,50 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
+
+use BitBadger\PDODocument\{Count, Delete, DocumentException, Field};
+use Test\Integration\SQLite\ThrowawayDb;
+
+pest()->group('integration', 'sqlite');
+
+describe('::byId()', function () {
+    test('deletes a document when one exists', function () {
+        expect(Count::all(ThrowawayDb::TABLE))->toBe(5);
+        Delete::byId(ThrowawayDb::TABLE, 'four');
+        expect(Count::all(ThrowawayDb::TABLE))->toBe(4);
+    });
+    test('does nothing when the document does not exist', function () {
+        expect(Count::all(ThrowawayDb::TABLE))->toBe(5);
+        Delete::byId(ThrowawayDb::TABLE, 'negative four');
+        expect(Count::all(ThrowawayDb::TABLE))->toBe(5);
+    });
+});
+
+describe('::byFields()', function () {
+    test('deletes matching documents', function () {
+        expect(Count::all(ThrowawayDb::TABLE))->toBe(5);
+        Delete::byFields(ThrowawayDb::TABLE, [Field::notEqual('value', 'purple')]);
+        expect(Count::all(ThrowawayDb::TABLE))->toBe(2);
+    });
+    test('does nothing when no documents match', function () {
+        expect(Count::all(ThrowawayDb::TABLE))->toBe(5);
+        Delete::byFields(ThrowawayDb::TABLE, [Field::equal('value', 'crimson')]);
+        expect(Count::all(ThrowawayDb::TABLE))->toBe(5);
+    });
+});
+
+describe('::byContains()', function () {
+    test('throws an exception', function () {
+        expect(fn () => Delete::byContains('', []))->toThrow(DocumentException::class);
+    });
+});
+
+describe('::byJsonPath()', function () {
+    test('throws an exception', function () {
+        expect(fn () => Delete::byJsonPath('', ''))->toThrow(DocumentException::class);
+    });
+});

tests/Integration/SQLite/DocumentListTest.php

@@ -0,0 +1,94 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
+
+use BitBadger\PDODocument\{DocumentException, DocumentList, Query};
+use BitBadger\PDODocument\Mapper\DocumentMapper;
+use Test\Integration\SQLite\ThrowawayDb;
+use Test\Integration\TestDocument;
+
+pest()->group('integration', 'sqlite');
+
+describe('::create()', function () {
+    test('creates a document list', function () {
+        $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
+            new DocumentMapper(TestDocument::class));
+        expect($list)->not->toBeNull();
+        $list = null; // free database result
+    });
+});
+
+describe('->items', function () {
+    test('enumerates items in the list', function () {
+        $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
+            new DocumentMapper(TestDocument::class));
+        expect($list)->not->toBeNull();
+        $count = 0;
+        foreach ($list->items as $item) {
+            expect(['one', 'two', 'three', 'four', 'five'])->toContain($item->id);
+            $count++;
+        }
+        expect($count)->toBe(5);
+    });
+    test('fails when the list is exhausted', function () {
+        $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
+            new DocumentMapper(TestDocument::class));
+        expect($list)->not->toBeNull()->hasItems->toBeTrue();
+        $ignored = iterator_to_array($list->items);
+        expect($list)->hasItems->toBeFalse()
+            ->and(fn () => iterator_to_array($list->items))->toThrow(DocumentException::class);
+    });
+});
+
+describe('->hasItems', function () {
+    test('returns true when items exist', function () {
+        $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
+            new DocumentMapper(TestDocument::class));
+        expect($list)->not->toBeNull()->hasItems->toBeTrue();
+        foreach ($list->items as $ignored) {
+            expect($list)->hasItems->toBeTrue();
+        }
+        expect($list)->hasItems->toBeFalse();
+    });
+    test('returns false when no items exist', function () {
+        expect(DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE) . " WHERE data->>'num_value' < 0", [],
+                new DocumentMapper(TestDocument::class)))
+            ->not->toBeNull()->hasItems->toBeFalse();
+    });
+});
+
+describe('->map()', function () {
+    test('transforms the list', function () {
+        $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
+            new DocumentMapper(TestDocument::class));
+        expect($list)->not->toBeNull()->hasItems->toBeTrue();
+        foreach ($list->map(fn($doc) => strrev($doc->id)) as $mapped) {
+            expect(['eno', 'owt', 'eerht', 'ruof', 'evif'])->toContain($mapped);
+        }
+    });
+});
+
+describe('->iter()', function () {
+    test('walks the list', function () {
+        $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
+            new DocumentMapper(TestDocument::class));
+        expect($list)->not->toBeNull()->hasItems->toBeTrue();
+        $splats = [];
+        $list->iter(function ($doc) use (&$splats) { $splats[] = str_repeat('*', strlen($doc->id)); });
+        expect(implode(' ', $splats))->toBe('*** *** ***** **** ****');
+    });
+});
+
+describe('->mapToArray()', function () {
+    test('creates an associative array', function () {
+        $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
+            new DocumentMapper(TestDocument::class));
+        expect($list)->not->toBeNull()->hasItems->toBeTrue()
+            ->and($list->mapToArray(fn($it) => $it->id, fn($it) => $it->value))
+            ->toBe(['one' => 'FIRST!', 'two' => 'another', 'three' => '', 'four' => 'purple', 'five' => 'purple']);
+    });
+});

tests/Integration/SQLite/DocumentTest.php

@@ -0,0 +1,231 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
+
+use BitBadger\PDODocument\{AutoId, Configuration, Custom, Document, DocumentException, Exists, Field, Find};
+use BitBadger\PDODocument\Mapper\ArrayMapper;
+use Test\Integration\{NumDocument, SubDocument, TestDocument};
+use Test\Integration\SQLite\ThrowawayDb;
+
+pest()->group('integration', 'sqlite');
+
+describe('::insert()', function () {
+    test('inserts an array with no automatic ID', function () {
+        Document::insert(ThrowawayDb::TABLE, ['id' => 'turkey', 'sub' => ['foo' => 'gobble', 'bar' => 'gobble']]);
+        $tryDoc = Find::byId(ThrowawayDb::TABLE, 'turkey', TestDocument::class);
+        expect($tryDoc)->isSome->toBeTrue()
+            ->and($tryDoc->value)
+            ->id->toBe('turkey')
+            ->num_value->toBe(0)
+            ->sub->not->toBeNull()
+            ->sub->foo->toBe('gobble')
+            ->sub->bar->toBe('gobble')
+            ->and($tryDoc->value->value)->toBeEmpty();
+    });
+    test('inserts an array with auto-number ID, not provided', function () {
+        Configuration::$autoId = AutoId::Number;
+        try {
+            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
+
+            Document::insert(ThrowawayDb::TABLE, ['id' => 0, 'value' => 'new', 'num_value' => 8]);
+            $doc = Custom::single('SELECT data FROM ' . ThrowawayDb::TABLE, [], new ArrayMapper());
+            expect($doc)->isSome->toBeTrue()
+                ->and(json_decode($doc->value['data']))->id->toBe(1);
+
+            Document::insert(ThrowawayDb::TABLE, ['id' => 0, 'value' => 'again', 'num_value' => 7]);
+            $doc = Custom::single('SELECT data FROM ' . ThrowawayDb::TABLE . " WHERE data->>'id' = 2", [],
+                new ArrayMapper());
+            expect($doc)->isSome->toBeTrue()
+                ->and(json_decode($doc->value['data']))->id->toBe(2);
+        } finally {
+            Configuration::$autoId = AutoId::None;
+        }
+    });
+    test('inserts an array with auto-number ID, provided', function () {
+        Configuration::$autoId = AutoId::Number;
+        try {
+            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
+            Document::insert(ThrowawayDb::TABLE, ['id' => 7, 'value' => 'new', 'num_value' => 8]);
+            $doc = Custom::single('SELECT data FROM ' . ThrowawayDb::TABLE, [], new ArrayMapper());
+            expect($doc)->isSome->toBeTrue()
+                ->and(json_decode($doc->value['data']))->id->toBe(7);
+        } finally {
+            Configuration::$autoId = AutoId::None;
+        }
+    });
+    test('inserts an array with auto-UUID ID, not provided', function () {
+        Configuration::$autoId = AutoId::UUID;
+        try {
+            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
+            Document::insert(ThrowawayDb::TABLE, ['id' => '', 'num_value' => 5]);
+            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 5)], TestDocument::class);
+            expect($doc)->isSome->toBeTrue()->and($doc->value)->id->not->toBeEmpty();
+        } finally {
+            Configuration::$autoId = AutoId::None;
+        }
+    });
+    test('inserts an array with auto-UUID ID, provided', function () {
+        Configuration::$autoId = AutoId::UUID;
+        try {
+            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
+            $uuid = AutoId::generateUUID();
+            Document::insert(ThrowawayDb::TABLE, ['id' => $uuid, 'value' => 'uuid', 'num_value' => 12]);
+            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 12)], TestDocument::class);
+            expect($doc)->isSome->toBeTrue()->and($doc->value)->id->toBe($uuid);
+        } finally {
+            Configuration::$autoId = AutoId::None;
+        }
+    });
+    test('inserts an array with auto-string ID, not provided', function () {
+        Configuration::$autoId         = AutoId::RandomString;
+        Configuration::$idStringLength = 6;
+        try {
+            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
+            Document::insert(ThrowawayDb::TABLE, ['id' => '', 'value' => 'new', 'num_value' => 8]);
+            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 8)], TestDocument::class);
+            expect($doc)->isSome->toBeTrue()->and($doc->value)->id->toHaveLength(6);
+        } finally {
+            Configuration::$autoId         = AutoId::None;
+            Configuration::$idStringLength = 16;
+        }
+    });
+    test('inserts an array with auto-string ID, provided', function () {
+        Configuration::$autoId = AutoId::RandomString;
+        try {
+            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
+            Document::insert(ThrowawayDb::TABLE, ['id' => 'my-key', 'value' => 'old', 'num_value' => 3]);
+            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 3)], TestDocument::class);
+            expect($doc)->isSome->toBeTrue()->and($doc->value)->id->toBe('my-key');
+        } finally {
+            Configuration::$autoId = AutoId::None;
+        }
+    });
+    test('inserts an object with no automatic ID', function () {
+        Document::insert(ThrowawayDb::TABLE, new TestDocument('turkey', sub: new SubDocument('gobble', 'gobble')));
+        $tryDoc = Find::byId(ThrowawayDb::TABLE, 'turkey', TestDocument::class);
+        expect($tryDoc)->isSome->toBeTrue()
+            ->and($tryDoc->value)
+            ->id->toBe('turkey')
+            ->num_value->toBe(0)
+            ->sub->not->toBeNull()
+            ->sub->foo->toBe('gobble')
+            ->sub->bar->toBe('gobble')
+            ->and($tryDoc->value->value)->toBeEmpty();
+    });
+    test('inserts an object with auto-number ID, not provided', function () {
+        Configuration::$autoId = AutoId::Number;
+        try {
+            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
+
+            Document::insert(ThrowawayDb::TABLE, new NumDocument(value: 'taco'));
+            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('value', 'taco')], NumDocument::class);
+            expect($doc)->isSome->toBeTrue()->and($doc->value)->id->toBe(1);
+
+            Document::insert(ThrowawayDb::TABLE, new NumDocument(value: 'burrito'));
+            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('value', 'burrito')], NumDocument::class);
+            expect($doc)->isSome->toBeTrue()->and($doc->value)->id->toBe(2);
+        } finally {
+            Configuration::$autoId = AutoId::None;
+        }
+    });
+    test('inserts an object with auto-number ID, provided', function () {
+        Configuration::$autoId = AutoId::Number;
+        try {
+            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
+            Document::insert(ThrowawayDb::TABLE, new NumDocument(64, 'large'));
+            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('value', 'large')], NumDocument::class);
+            expect($doc)->isSome->toBeTrue()->and($doc->value)->id->toBe(64);
+        } finally {
+            Configuration::$autoId = AutoId::None;
+        }
+    });
+    test('inserts an object with auto-UUID ID, not provided', function () {
+        Configuration::$autoId = AutoId::UUID;
+        try {
+            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
+            Document::insert(ThrowawayDb::TABLE, new TestDocument(value: 'something', num_value: 9));
+            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::exists('value')], TestDocument::class);
+            expect($doc)->isSome->toBeTrue()->and($doc->value)->id->not->toBeEmpty();
+        } finally {
+            Configuration::$autoId = AutoId::None;
+        }
+    });
+    test('inserts an object with auto-UUID ID, provided', function () {
+        Configuration::$autoId = AutoId::UUID;
+        try {
+            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
+            $uuid = AutoId::generateUUID();
+            Document::insert(ThrowawayDb::TABLE, new TestDocument($uuid, num_value: 14));
+            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 14)], TestDocument::class);
+            expect($doc)->isSome->toBeTrue()->and($doc->value)->id->toBe($uuid);
+        } finally {
+            Configuration::$autoId = AutoId::None;
+        }
+    });
+    test('inserts an object with auto-string ID, not provided', function () {
+        Configuration::$autoId         = AutoId::RandomString;
+        Configuration::$idStringLength = 40;
+        try {
+            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
+            Document::insert(ThrowawayDb::TABLE, new TestDocument(num_value: 55));
+            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 55)], TestDocument::class);
+            expect($doc)->isSome->toBeTrue()->and($doc->value)->id->toHaveLength(40);
+        } finally {
+            Configuration::$autoId         = AutoId::None;
+            Configuration::$idStringLength = 16;
+        }
+    });
+    test('inserts an object with auto-string ID, provided', function () {
+        Configuration::$autoId = AutoId::RandomString;
+        try {
+            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
+            Document::insert(ThrowawayDb::TABLE, new TestDocument('my-key', num_value: 3));
+            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 3)], TestDocument::class);
+            expect($doc)->isSome->toBeTrue()->and($doc->value)->id->toBe('my-key');
+        } finally {
+            Configuration::$autoId = AutoId::None;
+        }
+    });
+    test('throws an exception for duplicate key', function () {
+        expect(fn () => Document::insert(ThrowawayDb::TABLE, new TestDocument('one')))
+            ->toThrow(DocumentException::class);
+    });
+});
+
+describe('::save()', function () {
+    test('inserts a new document', function () {
+        Document::save(ThrowawayDb::TABLE, new TestDocument('test', sub: new SubDocument('a', 'b')));
+        expect(Find::byId(ThrowawayDb::TABLE, 'one', TestDocument::class))->isSome->toBeTrue();
+    });
+    test('updates an existing document', function () {
+        Document::save(ThrowawayDb::TABLE, new TestDocument('two', num_value: 44));
+        $tryDoc = Find::byId(ThrowawayDb::TABLE, 'two', TestDocument::class);
+        expect($tryDoc)->isSome->toBeTrue()
+            ->and($tryDoc->value)
+            ->num_value->toBe(44)
+            ->sub->toBeNull();
+    });
+});
+
+describe('::update()', function () {
+    test('replaces an existing document', function () {
+        Document::update(ThrowawayDb::TABLE, 'one', new TestDocument('one', 'howdy', 8, new SubDocument('y', 'z')));
+        $tryDoc = Find::byId(ThrowawayDb::TABLE, 'one', TestDocument::class);
+        expect($tryDoc)->isSome->toBeTrue()
+            ->and($tryDoc->value)
+            ->num_value->toBe(8)
+            ->sub->not->toBeNull()
+            ->sub->foo->toBe('y')
+            ->sub->bar->toBe('z')
+            ->and($tryDoc->value->value)->toBe('howdy');
+    });
+    test('does nothing for a non-existent document', function () {
+        expect(Exists::byId(ThrowawayDb::TABLE, 'two-hundred'))->toBeFalse();
+        Document::update(ThrowawayDb::TABLE, 'two-hundred', new TestDocument('200'));
+        expect(Find::byId(ThrowawayDb::TABLE, 'two-hundred', TestDocument::class))->isNone->toBeTrue();
+    });
+});

tests/Integration/SQLite/ExistsTest.php

@@ -0,0 +1,42 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
+
+use BitBadger\PDODocument\{DocumentException, Exists, Field};
+use Test\Integration\SQLite\ThrowawayDb;
+
+pest()->group('integration', 'sqlite');
+
+describe('::byId()', function () {
+    test('returns true when a document exists', function () {
+        expect(Exists::byId(ThrowawayDb::TABLE, 'three'))->toBeTrue();
+    });
+    test('returns false when no document exists', function () {
+        expect(Exists::byId(ThrowawayDb::TABLE, 'seven'))->toBeFalse();
+    });
+});
+
+describe('::byFields()', function () {
+    test('returns true when matching documents exist', function () {
+        expect(Exists::byFields(ThrowawayDb::TABLE, [Field::equal('num_value', 10)]))->toBeTrue();
+    });
+    test('returns false when no matching documents exist', function () {
+        expect(Exists::byFields(ThrowawayDb::TABLE, [Field::less('nothing', 'none')]))->toBeFalse();
+    });
+});
+
+describe('::byContains()', function () {
+    test('throws an exception', function () {
+        expect(fn () => Exists::byContains('', []))->toThrow(DocumentException::class);
+    });
+});
+
+describe('::byJsonPath()', function () {
+    test('throws an exception', function () {
+        expect(fn () => Exists::byJsonPath('', ''))->toThrow(DocumentException::class);
+    });
+});

tests/Integration/SQLite/FindTest.php

@@ -0,0 +1,151 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
+
+use BitBadger\PDODocument\{Custom, Delete, Document, DocumentException, Field, FieldMatch, Find};
+use Test\Integration\{ArrayDocument, TestDocument};
+use Test\Integration\SQLite\ThrowawayDb;
+
+pest()->group('integration', 'sqlite');
+
+describe('::all()', function () {
+    test('retrieves data', function () {
+        $docs = Find::all(ThrowawayDb::TABLE, TestDocument::class);
+        expect($docs)->not->toBeNull();
+        $count = 0;
+        foreach ($docs->items as $ignored) $count++;
+        expect($count)->toBe(5);
+    });
+    test('sorts data ascending', function () {
+        $docs = Find::all(ThrowawayDb::TABLE, TestDocument::class, [Field::named('id')]);
+        expect($docs)->not->toBeNull()
+            ->and(iterator_to_array($docs->map(fn ($it) => $it->id), false))
+            ->toBe(['five', 'four', 'one', 'three', 'two']);
+    });
+    test('sorts data descending', function () {
+        $docs = Find::all(ThrowawayDb::TABLE, TestDocument::class, [Field::named('id DESC')]);
+        expect($docs)->not->toBeNull()
+            ->and(iterator_to_array($docs->map(fn ($it) => $it->id), false))
+            ->toBe(['two', 'three', 'one', 'four', 'five']);
+    });
+    test('sorts data numerically', function () {
+        $docs = Find::all(ThrowawayDb::TABLE, TestDocument::class,
+            [Field::named('sub.foo NULLS LAST'), Field::named('n:num_value')]);
+        expect($docs)->not->toBeNull()
+            ->and(iterator_to_array($docs->map(fn ($it) => $it->id), false))
+            ->toBe(['two', 'four', 'one', 'three', 'five']);
+    });
+    test('returns an empty list when no data exists', function () {
+        Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
+        expect(Find::all(ThrowawayDb::TABLE, TestDocument::class))
+            ->not->toBeNull()->hasItems->toBeFalse();
+    });
+});
+
+describe('::byId()', function () {
+    test('returns a document when it exists', function () {
+        $doc = Find::byId(ThrowawayDb::TABLE, 'two', TestDocument::class);
+        expect($doc)->isSome->toBeTrue()->and($doc->value)->id->toBe('two');
+    });
+    test('returns a document with a numeric ID', function () {
+        Document::insert(ThrowawayDb::TABLE, ['id' => 18, 'value' => 'howdy']);
+        $doc = Find::byId(ThrowawayDb::TABLE, 18, TestDocument::class);
+        expect($doc)->isSome->toBeTrue()->and($doc->value)->id->toBe('18');
+    });
+    test('returns None when no document exists', function () {
+        expect(Find::byId(ThrowawayDb::TABLE, 'seventy-five', TestDocument::class))->isNone->toBeTrue();
+    });
+});
+
+describe('::byFields()', function () {
+    test('returns matching documents', function () {
+        $docs = Find::byFields(ThrowawayDb::TABLE, [Field::in('value', ['blue', 'purple']), Field::exists('sub')],
+            TestDocument::class, FieldMatch::All);
+        expect($docs)->not->toBeNull();
+        $count = 0;
+        foreach ($docs->items as $ignored) $count++;
+        expect($count)->toBe(1);
+    });
+    test('returns ordered matching documents', function () {
+        $docs = Find::byFields(ThrowawayDb::TABLE, [Field::equal('value', 'purple')], TestDocument::class,
+            FieldMatch::All, [Field::named('id')]);
+        expect($docs)->not->toBeNull()
+            ->and(iterator_to_array($docs->map(fn ($it) => $it->id), false))->toBe(['five', 'four']);
+    });
+    test('returns documents matching numeric IN clause', function () {
+        $docs = Find::byFields(ThrowawayDb::TABLE, [Field::in('num_value', [2, 4, 6, 8])], TestDocument::class);
+        expect($docs)->not->toBeNull();
+        $count = 0;
+        foreach ($docs->items as $ignored) $count++;
+        expect($count)->toBe(1);
+    });
+    test('returns empty list when no documents match', function () {
+        expect(Find::byFields(ThrowawayDb::TABLE, [Field::greater('num_value', 100)], TestDocument::class))
+            ->not->toBeNull()->hasItems->toBeFalse();
+    });
+    test('returns matching documents for inArray comparison', function () {
+        Delete::byFields(ThrowawayDb::TABLE, [Field::notExists('absentField')]);
+        foreach (ArrayDocument::testDocuments() as $doc) Document::insert(ThrowawayDb::TABLE, $doc);
+        $docs = Find::byFields(ThrowawayDb::TABLE, [Field::inArray('values', ThrowawayDb::TABLE, ['c'])],
+            ArrayDocument::class);
+        expect($docs)->not->toBeNull();
+        $count = 0;
+        foreach ($docs->items as $ignored) $count++;
+        expect($count)->toBe(2);
+    });
+    test('returns empty list when no documents match inArray comparison', function () {
+        Delete::byFields(ThrowawayDb::TABLE, [Field::notExists('absentField')]);
+        foreach (ArrayDocument::testDocuments() as $doc) Document::insert(ThrowawayDb::TABLE, $doc);
+        expect(Find::byFields(ThrowawayDb::TABLE, [Field::inArray('values', ThrowawayDb::TABLE, ['j'])],
+                ArrayDocument::class))
+            ->not->toBeNull()->hasItems->toBeFalse();
+    });
+});
+
+describe('::byContains()', function () {
+    test('throws an exception', function () {
+        expect(fn () => Find::byContains('', [], TestDocument::class))->toThrow(DocumentException::class);
+    });
+});
+
+describe('::byJsonPath()', function () {
+    test('throws an exception', function () {
+        expect(fn () => Find::byJsonPath('', '', TestDocument::class))->toThrow(DocumentException::class);
+    });
+});
+
+describe('::firstByFields()', function () {
+    test('returns a matching document', function () {
+        $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('value', 'another')], TestDocument::class);
+        expect($doc)->isSome->toBeTrue()->and($doc->value)->id->toBe('two');
+    });
+    test('returns one of several matching documents', function () {
+        $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('sub.foo', 'green')], TestDocument::class);
+        expect($doc)->isSome->toBeTrue()->and(['two', 'four'])->toContain($doc->value->id);
+    });
+    test('returns first of ordered matching documents', function () {
+        $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('sub.foo', 'green')], TestDocument::class,
+            orderBy: [Field::named('n:num_value DESC')]);
+        expect($doc)->isSome->toBeTrue()->and($doc->value)->id->toBe('four');
+    });
+    test('returns None when no documents match', function () {
+        expect(Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('value', 'absent')], TestDocument::class))
+            ->isNone->toBeTrue();
+    });
+});
+
+describe('::firstByContains()', function () {
+    test('throws an exception', function () {
+        expect(fn () => Find::firstByContains('', [], TestDocument::class))->toThrow(DocumentException::class);
+    });
+});
+
+describe('::firstByJsonPath()', function () {
+    test('throws an exception', function () {
+        expect(fn () => Find::firstByJsonPath('', '', TestDocument::class))->toThrow(DocumentException::class);
+    });
+});

tests/Integration/SQLite/PatchTest.php

@@ -0,0 +1,48 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
+
+use BitBadger\PDODocument\{Count, DocumentException, Exists, Field, Find, Patch};
+use Test\Integration\SQLite\ThrowawayDb;
+use Test\Integration\TestDocument;
+
+pest()->group('integration', 'sqlite');
+
+describe('::byId()', function () {
+    test('updates an existing document', function () {
+        Patch::byId(ThrowawayDb::TABLE, 'one', ['num_value' => 44]);
+        $doc = Find::byId(ThrowawayDb::TABLE, 'one', TestDocument::class);
+        expect($doc)->isSome->toBeTrue()->and($doc->value)->num_value->toBe(44);
+    });
+    test('does nothing when no document exists', function () {
+        expect(Exists::byId(ThrowawayDb::TABLE, 'forty-seven'))->toBeFalse();
+        Patch::byId(ThrowawayDb::TABLE, 'forty-seven', ['foo' => 'green']);
+    });
+});
+
+describe('::byFields()', function () {
+    test('updates matching documents', function () {
+        Patch::byFields(ThrowawayDb::TABLE, [Field::equal('value', 'purple')], ['num_value' => 77]);
+        expect(Count::byFields(ThrowawayDb::TABLE, [Field::equal('num_value', 77)]))->toBe(2);
+    });
+    test('does nothing when no documents match', function () {
+        expect(Exists::byFields(ThrowawayDb::TABLE, [Field::equal('value', 'burgundy')]))->toBeFalse();
+        Patch::byFields(ThrowawayDb::TABLE, [Field::equal('value', 'burgundy')], ['foo' => 'green']);
+    });
+});
+
+describe('::byContains()', function () {
+    test('throws an exception', function () {
+        expect(fn () => Patch::byContains('', [], []))->toThrow(DocumentException::class);
+    });
+});
+
+describe('::byJsonPath()', function () {
+    test('throws an exception', function () {
+        expect(fn () => Patch::byJsonPath('', '', []))->toThrow(DocumentException::class);
+    });
+});

tests/Integration/SQLite/RemoveFieldsTest.php

@@ -0,0 +1,59 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
+
+use BitBadger\PDODocument\{DocumentException, Exists, Field, Find, RemoveFields};
+use Test\Integration\SQLite\ThrowawayDb;
+use Test\Integration\TestDocument;
+
+pest()->group('integration', 'sqlite');
+
+describe('::byId()', function () {
+    test('updates an existing document', function () {
+        RemoveFields::byId(ThrowawayDb::TABLE, 'two', ['sub', 'value']);
+        $tryDoc = Find::byId(ThrowawayDb::TABLE, 'two', TestDocument::class);
+        expect($tryDoc)->isSome->toBeTrue()
+            ->and($tryDoc->value)->sub->toBeNull()
+            ->and($tryDoc->value->value)->toBeEmpty();
+    });
+    test('does nothing when the field to remove does not exist', function () {
+        expect(Exists::byFields(ThrowawayDb::TABLE, [Field::exists('a_field_that_does_not_exist')]))->toBeFalse();
+        RemoveFields::byId(ThrowawayDb::TABLE, 'one', ['a_field_that_does_not_exist']);
+    });
+    test('does nothing when the document does not exist', function () {
+        expect(Exists::byId(ThrowawayDb::TABLE, 'fifty'))->toBeFalse();
+        RemoveFields::byId(ThrowawayDb::TABLE, 'fifty', ['sub']);
+    });
+});
+
+describe('::byFields()', function () {
+    test('updates matching documents', function () {
+        RemoveFields::byFields(ThrowawayDb::TABLE, [Field::equal('num_value', 17)], ['sub']);
+        $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 17)], TestDocument::class);
+        expect($doc)->isSome->toBeTrue()->and($doc->value)->sub->toBeNull();
+    });
+    test('does nothing when the field to remove does not exist', function () {
+        expect(Exists::byFields(ThrowawayDb::TABLE, [Field::exists('nada')]))->toBeFalse();
+        RemoveFields::byFields(ThrowawayDb::TABLE, [Field::equal('num_value', 17)], ['nada']);
+    });
+    test('does nothing when no documents match', function () {
+        expect(Exists::byFields(ThrowawayDb::TABLE, [Field::notEqual('missing', 'nope')]))->toBeFalse();
+        RemoveFields::byFields(ThrowawayDb::TABLE, [Field::notEqual('missing', 'nope')], ['value']);
+    });
+});
+
+describe('::byContains()', function () {
+    test('throws an exception', function () {
+        expect(fn () => RemoveFields::byContains('', [], []))->toThrow(DocumentException::class);
+    });
+});
+
+describe('::byJsonPath()', function () {
+    test('throws an exception', function () {
+        expect(fn () => RemoveFields::byJsonPath('', '', []))->toThrow(DocumentException::class);
+    });
+});

tests/Integration/SQLite/ThrowawayDb.php

@@ -21,6 +21,20 @@ class ThrowawayDb
     /** @var string The table used for document manipulation */
     public const TABLE = 'test_table';
 
+    /**
+     * Load data into the test table
+     *
+     * @throws DocumentException If any is encountered
+     */
+    public static function loadData(): void
+    {
+        Document::insert(self::TABLE, new TestDocument('one', 'FIRST!', 0));
+        Document::insert(self::TABLE, new TestDocument('two', 'another', 10, new SubDocument('green', 'blue')));
+        Document::insert(self::TABLE, new TestDocument('three', '', 4));
+        Document::insert(self::TABLE, new TestDocument('four', 'purple', 17, new SubDocument('green', 'red')));
+        Document::insert(self::TABLE, new TestDocument('five', 'purple', 18));
+    }
+
     /**
      * Create a throwaway SQLite database
      *
@@ -34,13 +48,10 @@ class ThrowawayDb
         Configuration::useDSN("sqlite:./$fileName");
         Configuration::resetPDO();
 
+        Definition::ensureTable(self::TABLE);
+
         if ($withData) {
-            Definition::ensureTable(self::TABLE);
-            Document::insert(self::TABLE, new TestDocument('one', 'FIRST!', 0));
-            Document::insert(self::TABLE, new TestDocument('two', 'another', 10, new SubDocument('green', 'blue')));
-            Document::insert(self::TABLE, new TestDocument('three', '', 4));
-            Document::insert(self::TABLE, new TestDocument('four', 'purple', 17, new SubDocument('green', 'red')));
-            Document::insert(self::TABLE, new TestDocument('five', 'purple', 18));
+            self::loadData();
         }
 
         return $fileName;

tests/Integration/SQLiteIntegrationTest.php

@@ -0,0 +1,60 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ * @see https://github.com/Zaid-Ajaj/ThrowawayDb The origin concept
+ */
+
+declare(strict_types=1);
+
+namespace Test\Integration;
+
+use BitBadger\PDODocument\{Configuration, Custom, Delete, DocumentException, Field};
+use BitBadger\PDODocument\Mapper\ExistsMapper;
+use PHPUnit\Framework\TestCase;
+use Test\Integration\SQLite\ThrowawayDb;
+
+/**
+ * Integration Test Class wrapper for SQLite integration tests
+ */
+class SQLiteIntegrationTest extends TestCase
+{
+    /** @var string Database name for throwaway database */
+    static private string $dbName = '';
+
+    public static function setUpBeforeClass(): void
+    {
+        self::$dbName = ThrowawayDb::create(false);
+    }
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+        ThrowawayDb::loadData();
+    }
+
+    protected function tearDown(): void
+    {
+        Delete::byFields(ThrowawayDb::TABLE, [ Field::exists(Configuration::$idField)]);
+        parent::tearDown();
+    }
+
+    public static function tearDownAfterClass(): void
+    {
+        ThrowawayDb::destroy(self::$dbName);
+        self::$dbName = '';
+    }
+
+    /**
+     * Does the given named object exist in the database?
+     *
+     * @param string $name The name of the object whose existence should be verified
+     * @return bool True if the object exists, false if not
+     * @throws DocumentException If any is encountered
+     */
+    protected function dbObjectExists(string $name): bool
+    {
+        return Custom::scalar('SELECT EXISTS (SELECT 1 FROM sqlite_master WHERE name = :name)',
+            [':name' => $name], new ExistsMapper());
+    }
+}

tests/Pest.php

@@ -0,0 +1,55 @@
+<?php
+
+/*
+|--------------------------------------------------------------------------
+| Test Case
+|--------------------------------------------------------------------------
+|
+| The closure you provide to your test functions is always bound to a specific PHPUnit test
+| case class. By default, that class is "PHPUnit\Framework\TestCase". Of course, you may
+| need to change it using the "pest()" function to bind a different classes or traits.
+|
+*/
+
+// pest()->extend(Tests\TestCase::class)->in('Feature');
+pest()->extend(Test\Integration\PgIntegrationTest::class)->in('Integration/PostgreSQL');
+pest()->extend(Test\Integration\SQLiteIntegrationTest::class)->in('Integration/SQLite');
+
+/*
+|--------------------------------------------------------------------------
+| Expectations
+|--------------------------------------------------------------------------
+|
+| When you're writing tests, you often need to check that values meet certain conditions. The
+| "expect()" function gives you access to a set of "expectations" methods that you can use
+| to assert different things. Of course, you may extend the Expectation API at any time.
+|
+*/
+
+expect()->extend('toBeOne', function () {
+    return $this->toBe(1);
+});
+
+/*
+|--------------------------------------------------------------------------
+| Functions
+|--------------------------------------------------------------------------
+|
+| While Pest is very powerful out-of-the-box, you may have some testing code specific to your
+| project that you don't want to repeat in every file. Here you can also expose helpers as
+| global functions to help you to reduce the number of lines of code in your test files.
+|
+*/
+
+/**
+ * Reset the database mode
+ */
+function reset_mode(): void
+{
+    \BitBadger\PDODocument\Configuration::overrideMode(null);
+}
+
+function something()
+{
+    // ..
+}

tests/Unit/ConfigurationTest.php

@@ -0,0 +1,36 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
+
+use BitBadger\PDODocument\{AutoId, Configuration, DocumentException};
+
+pest()->group('unit');
+
+describe('::$idField', function () {
+    test('has expected default value', function () {
+        expect(Configuration::$idField)->toBe('id');
+    });
+});
+
+describe('::$autoId', function () {
+    test('has expected default value', function () {
+        expect(Configuration::$autoId)->toBe(AutoId::None);
+    });
+});
+
+describe('::$idStringLength', function () {
+    test('has expected default value', function () {
+        expect(Configuration::$idStringLength)->toBe(16);
+    });
+});
+
+describe('::dbConn()', function () {
+    test('throws if DSN has not been set', function () {
+        Configuration::useDSN('');
+        expect(fn() => Configuration::dbConn())->toThrow(DocumentException::class);
+    });
+});

tests/Unit/DocumentExceptionTest.php

@@ -0,0 +1,40 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
+
+use BitBadger\PDODocument\DocumentException;
+
+pest()->group('unit');
+
+describe('Constructor', function () {
+    test('fills code and prior exception if provided', function () {
+        $priorEx = new Exception('Uh oh');
+        expect(new DocumentException('Test Exception', 17, $priorEx))
+            ->not->toBeNull()
+            ->getMessage()->toBe('Test Exception')
+            ->getCode()->toBe(17)
+            ->getPrevious()->toBe($priorEx);
+    });
+    test('uses expected code and prior exception if not provided', function () {
+        expect(new DocumentException('Oops'))
+            ->not->toBeNull()
+            ->getMessage()->toBe('Oops')
+            ->getCode()->toBe(0)
+            ->getPrevious()->toBeNull();
+    });
+});
+
+describe('->__toString()', function () {
+    test('excludes code if 0', function () {
+        $ex = new DocumentException('Test failure');
+        expect("$ex")->toBe("BitBadger\PDODocument\DocumentException: Test failure\n");
+    });
+    test('includes code if non-zero', function () {
+        $ex = new DocumentException('Oof', -6);
+        expect("$ex")->toBe("BitBadger\PDODocument\DocumentException: [-6] Oof\n");
+    });
+});

tests/Unit/FieldMatchTest.php

@@ -0,0 +1,20 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
+
+use BitBadger\PDODocument\FieldMatch;
+
+pest()->group('unit');
+
+describe('->toSQL()', function () {
+    test('returns AND for All', function () {
+        expect(FieldMatch::All)->toSQL()->toBe('AND');
+    });
+    test('returns OR for Any', function () {
+        expect(FieldMatch::Any)->toSQL()->toBe('OR');
+    });
+});

tests/Unit/FieldTest.php

@@ -0,0 +1,418 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
+
+use BitBadger\PDODocument\{Configuration, Field, Mode, Op};
+
+pest()->group('unit');
+
+describe('->appendParameter()', function () {
+    afterEach(function () { Configuration::overrideMode(null); });
+    test('appends no parameter for exists', function () {
+        expect(Field::exists('exists')->appendParameter([]))->toBeEmpty();
+    });
+    test('appends no parameter for notExists', function () {
+        expect(Field::notExists('absent')->appendParameter([]))->toBeEmpty();
+    });
+    test('appends two parameters for between', function () {
+        expect(Field::between('exists', 5, 9, '@num')->appendParameter([]))
+            ->toHaveLength(2)
+            ->toEqual(['@nummin' => 5, '@nummax' => 9]);
+    });
+    test('appends a parameter for each value for in', function () {
+        expect(Field::in('it', ['test', 'unit', 'great'], ':val')->appendParameter([]))
+            ->toHaveLength(3)
+            ->toEqual([':val_0' => 'test', ':val_1' => 'unit', ':val_2' => 'great']);
+    });
+    test('appends a parameter for each value for inArray [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(Field::inArray('it', 'table', [2, 8, 64], ':bit')->appendParameter([]))
+            ->toHaveLength(3)
+            ->toEqual([':bit_0' => '2', ':bit_1' => '8', ':bit_2' => '64']);
+    })->group('postgresql');
+    test('appends a parameter for each value for inArray [SQLite]', function () {
+        Configuration::overrideMode(Mode::SQLite);
+        expect(Field::inArray('it', 'table', [2, 8, 64], ':bit')->appendParameter([]))
+            ->toHaveLength(3)
+            ->toEqual([':bit_0' => 2, ':bit_1' => 8, ':bit_2' => 64]);
+    })->group('sqlite');
+    test('appends a parameter for other operators', function () {
+        expect(Field::equal('the_field', 33, ':test')->appendParameter([]))
+            ->toHaveLength(1)
+            ->toEqual([':test' => 33]);
+    });
+});
+
+describe('->path()', function () {
+    afterEach(function () { Configuration::overrideMode(null); });
+    test('returns simple SQL path [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(Field::equal('it', 'that'))->path()->toBe("data->>'it'");
+    })->group('postgresql');
+    test('returns simple SQL path [SQLite]', function () {
+        Configuration::overrideMode(Mode::SQLite);
+        expect(Field::equal('top', 'that'))->path()->toBe("data->>'top'");
+    })->group('sqlite');
+    test('returns nested SQL path [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(Field::equal('parts.to.the.path', ''))->path()->toBe("data#>>'{parts,to,the,path}'");
+    })->group('postgresql');
+    test('returns nested SQL path [SQLite]', function () {
+        Configuration::overrideMode(Mode::SQLite);
+        expect(Field::equal('one.two.three', ''))->path()->toBe("data->'one'->'two'->>'three'");
+    })->group('sqlite');
+    test('returns simple JSON path [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(Field::equal('it', 'that'))->path(true)->toBe("data->'it'");
+    })->group('postgresql');
+    test('returns simple JSON path [SQLite]', function () {
+        Configuration::overrideMode(Mode::SQLite);
+        expect(Field::equal('top', 'that'))->path(true)->toBe("data->'top'");
+    })->group('sqlite');
+    test('returns nested JSON path [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(Field::equal('parts.to.the.path', ''))->path(true)->toBe("data#>'{parts,to,the,path}'");
+    })->group('postgresql');
+    test('returns nested JSON path [SQLite]', function () {
+        Configuration::overrideMode(Mode::SQLite);
+        expect(Field::equal('one.two.three', ''))->path(true)->toBe("data->'one'->'two'->'three'");
+    })->group('sqlite');
+});
+
+describe('->toWhere()', function () {
+    afterEach(function () { Configuration::overrideMode(null); });
+    test('generates IS NOT NULL for exists w/o qualifier [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(Field::exists('that_field'))->toWhere()->toBe("data->>'that_field' IS NOT NULL");
+    })->group('postgresql');
+    test('generates IS NOT NULL for exists w/o qualifier [SQLite]', function () {
+        Configuration::overrideMode(Mode::SQLite);
+        expect(Field::exists('that_field'))->toWhere()->toBe("data->>'that_field' IS NOT NULL");
+    })->group('sqlite');
+    test('generates IS NULL for notExists w/o qualifier [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(Field::notExists('a_field'))->toWhere()->toBe("data->>'a_field' IS NULL");
+    })->group('postgresql');
+    test('generates IS NULL for notExists w/o qualifier [SQLite]', function () {
+        Configuration::overrideMode(Mode::SQLite);
+        expect(Field::notExists('a_field'))->toWhere()->toBe("data->>'a_field' IS NULL");
+    })->group('sqlite');
+    test('generates BETWEEN for between w/o qualifier [SQLite]', function () {
+        Configuration::overrideMode(Mode::SQLite);
+        expect(Field::between('age', 13, 17, '@age'))->toWhere()->toBe("data->>'age' BETWEEN @agemin AND @agemax");
+    })->group('sqlite');
+    test('generates BETWEEN for between w/o qualifier, numeric range [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(Field::between('age', 13, 17, '@age'))->toWhere()
+            ->toBe("(data->>'age')::numeric BETWEEN @agemin AND @agemax");
+    })->group('postgresql');
+    test('generates BETWEEN for between w/o qualifier, non-numeric range [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(Field::between('city', 'Atlanta', 'Chicago', ':city'))->toWhere()
+            ->toBe("data->>'city' BETWEEN :citymin AND :citymax");
+    })->group('postgresql');
+    test('generates BETWEEN for between w/ qualifier [SQLite]', function () {
+        Configuration::overrideMode(Mode::SQLite);
+        $field = Field::between('age', 13, 17, '@age');
+        $field->qualifier = 'me';
+        expect($field)->toWhere()->toBe("me.data->>'age' BETWEEN @agemin AND @agemax");
+    })->group('sqlite');
+    test('generates BETWEEN for between w/ qualifier, numeric range [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        $field = Field::between('age', 13, 17, '@age');
+        $field->qualifier = 'me';
+        expect($field)->toWhere()->toBe("(me.data->>'age')::numeric BETWEEN @agemin AND @agemax");
+    })->group('postgresql');
+    test('generates BETWEEN for between w/ qualifier, non-numeric range [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        $field = Field::between('city', 'Atlanta', 'Chicago', ':city');
+        $field->qualifier = 'me';
+        expect($field)->toWhere()->toBe("me.data->>'city' BETWEEN :citymin AND :citymax");
+    })->group('postgresql');
+    test('generates IN for in, non-numeric values [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(Field::in('test', ['Atlanta', 'Chicago'], ':city'))->toWhere()
+            ->toBe("data->>'test' IN (:city_0, :city_1)");
+    })->group('postgresql');
+    test('generates IN for in, numeric values [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(Field::in('even', [2, 4, 6], ':nbr'))->toWhere()
+            ->toBe("(data->>'even')::numeric IN (:nbr_0, :nbr_1, :nbr_2)");
+    })->group('postgresql');
+    test('generates IN for in [SQLite]', function () {
+        Configuration::overrideMode(Mode::SQLite);
+        expect(Field::in('test', ['Atlanta', 'Chicago'], ':city'))->toWhere()
+            ->toBe("data->>'test' IN (:city_0, :city_1)");
+    })->group('sqlite');
+    test('generates clause for inArray [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(Field::inArray('even', 'tbl', [2, 4, 6, 8], ':it'))->toWhere()
+            ->toBe("data->'even' ??| ARRAY[:it_0, :it_1, :it_2, :it_3]");
+    })->group('postgresql');
+    test('generates clause for inArray [SQLite]', function () {
+        Configuration::overrideMode(Mode::SQLite);
+        expect(Field::inArray('test', 'tbl', ['Atlanta', 'Chicago'], ':city'))->toWhere()
+            ->toBe("EXISTS (SELECT 1 FROM json_each(tbl.data, '\$.test') WHERE value IN (:city_0, :city_1))");
+    })->group('sqlite');
+    test('generates clause for other operators w/o qualifier [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(Field::equal('some_field', '', ':value'))->toWhere()->toBe("data->>'some_field' = :value");
+    })->group('postgresql');
+    test('generates clause for other operators w/o qualifier [SQLite]', function () {
+        Configuration::overrideMode(Mode::SQLite);
+        expect(Field::equal('some_field', '', ':value'))->toWhere()->toBe("data->>'some_field' = :value");
+    })->group('sqlite');
+    test('generates no-parameter clause w/ qualifier [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        $field = Field::exists('no_field');
+        $field->qualifier = 'test';
+        expect($field)->toWhere()->toBe("test.data->>'no_field' IS NOT NULL");
+    })->group('postgresql');
+    test('generates no-parameter clause w/ qualifier [SQLite]', function () {
+        Configuration::overrideMode(Mode::SQLite);
+        $field = Field::exists('no_field');
+        $field->qualifier = 'test';
+        expect($field)->toWhere()->toBe("test.data->>'no_field' IS NOT NULL");
+    })->group('sqlite');
+    test('generates parameter clause w/ qualifier [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        $field = Field::lessOrEqual('le_field', 18, ':it');
+        $field->qualifier = 'q';
+        expect($field)->toWhere()->toBe("(q.data->>'le_field')::numeric <= :it");
+    })->group('postgresql');
+    test('generates parameter clause w/ qualifier [SQLite]', function () {
+        Configuration::overrideMode(Mode::SQLite);
+        $field = Field::lessOrEqual('le_field', 18, ':it');
+        $field->qualifier = 'q';
+        expect($field)->toWhere()->toBe("q.data->>'le_field' <= :it");
+    })->group('sqlite');
+});
+
+describe('::equal()', function () {
+    test('creates Field w/o parameter', function () {
+        $field = Field::equal('my_test', 9);
+        expect($field)
+            ->not->toBeNull()
+            ->fieldName->toBe('my_test')
+            ->op->toBe(Op::Equal)
+            ->paramName->toBeEmpty()
+            ->and($field->value)->toBe(9);
+    });
+    test('creates Field w/ parameter', function () {
+        $field = Field::equal('another_test', 'turkey', ':test');
+        expect($field)
+            ->not->toBeNull()
+            ->fieldName->toBe('another_test')
+            ->op->toBe(Op::Equal)
+            ->paramName->toBe(':test')
+            ->and($field->value)->toBe('turkey');
+    });
+});
+
+describe('::greater()', function () {
+    test('creates Field w/o parameter', function () {
+        $field = Field::greater('your_test', 4);
+        expect($field)
+            ->not->toBeNull()
+            ->fieldName->toBe('your_test')
+            ->op->toBe(Op::Greater)
+            ->paramName->toBeEmpty()
+            ->and($field->value)->toBe(4);
+    });
+    test('creates Field w/ parameter', function () {
+        $field = Field::greater('more_test', 'chicken', ':value');
+        expect($field)
+            ->not->toBeNull()
+            ->fieldName->toBe('more_test')
+            ->op->toBe(Op::Greater)
+            ->paramName->toBe(':value')
+            ->and($field->value)->toBe('chicken');
+    });
+});
+
+describe('::greaterOrEqual()', function () {
+    test('creates Field w/o parameter', function () {
+        $field = Field::greaterOrEqual('their_test', 6);
+        expect($field)
+            ->not->toBeNull()
+            ->fieldName->toBe('their_test')
+            ->op->toBe(Op::GreaterOrEqual)
+            ->paramName->toBeEmpty()
+            ->and($field->value)->toBe(6);
+    });
+    test('creates Field w/ parameter', function () {
+        $field = Field::greaterOrEqual('greater_test', 'poultry', ':cluck');
+        expect($field)
+            ->not->toBeNull()
+            ->fieldName->toBe('greater_test')
+            ->op->toBe(Op::GreaterOrEqual)
+            ->paramName->toBe(':cluck')
+            ->and($field->value)->toBe('poultry');
+    });
+});
+
+describe('::less()', function () {
+    test('creates Field w/o parameter', function () {
+        $field = Field::less('z', 32);
+        expect($field)
+            ->not->toBeNull()
+            ->fieldName->toBe('z')
+            ->op->toBe(Op::Less)
+            ->paramName->toBeEmpty()
+            ->and($field->value)->toBe(32);
+    });
+    test('creates Field w/ parameter', function () {
+        $field = Field::less('additional_test', 'fowl', ':boo');
+        expect($field)
+            ->not->toBeNull()
+            ->fieldName->toBe('additional_test')
+            ->op->toBe(Op::Less)
+            ->paramName->toBe(':boo')
+            ->and($field->value)->toBe('fowl');
+    });
+});
+
+describe('::lessOrEqual()', function () {
+    test('creates Field w/o parameter', function () {
+        $field = Field::lessOrEqual('g', 87);
+        expect($field)
+            ->not->toBeNull()
+            ->fieldName->toBe('g')
+            ->op->toBe(Op::LessOrEqual)
+            ->paramName->toBeEmpty()
+            ->and($field->value)->toBe(87);
+    });
+    test('creates Field w/ parameter', function () {
+        $field = Field::lessOrEqual('lesser_test', 'hen', ':woo');
+        expect($field)
+            ->not->toBeNull()
+            ->fieldName->toBe('lesser_test')
+            ->op->toBe(Op::LessOrEqual)
+            ->paramName->toBe(':woo')
+            ->and($field->value)->toBe('hen');
+    });
+});
+
+describe('::notEqual()', function () {
+    test('creates Field w/o parameter', function () {
+        $field = Field::notEqual('j', 65);
+        expect($field)
+            ->not->toBeNull()
+            ->fieldName->toBe('j')
+            ->op->toBe(Op::NotEqual)
+            ->paramName->toBeEmpty()
+            ->and($field->value)->toBe(65);
+    });
+    test('creates Field w/ parameter', function () {
+        $field = Field::notEqual('unequal_test', 'egg', ':zoo');
+        expect($field)
+            ->not->toBeNull()
+            ->fieldName->toBe('unequal_test')
+            ->op->toBe(Op::NotEqual)
+            ->paramName->toBe(':zoo')
+            ->and($field->value)->toBe('egg');
+    });
+});
+
+describe('::between()', function () {
+    test('creates Field w/o parameter', function () {
+        $field = Field::between('k', 'alpha', 'zed');
+        expect($field)
+            ->not->toBeNull()
+            ->fieldName->toBe('k')
+            ->op->toBe(Op::Between)
+            ->paramName->toBeEmpty()
+            ->and($field->value)->toEqual(['alpha', 'zed']);
+    });
+    test('creates Field w/ parameter', function () {
+        $field = Field::between('between_test', 18, 49, ':count');
+        expect($field)
+            ->not->toBeNull()
+            ->fieldName->toBe('between_test')
+            ->op->toBe(Op::Between)
+            ->paramName->toBe(':count')
+            ->and($field->value)->toEqual([18, 49]);
+    });
+});
+
+describe('::in()', function () {
+    test('creates Field w/o parameter', function () {
+        $field = Field::in('test', [1, 2, 3]);
+        expect($field)
+            ->not->toBeNull()
+            ->fieldName->toBe('test')
+            ->op->toBe(Op::In)
+            ->paramName->toBeEmpty()
+            ->and($field->value)->toEqual([1, 2, 3]);
+    });
+    test('creates Field w/ parameter', function () {
+        $field = Field::in('unit', ['a', 'b'], ':inParam');
+        expect($field)
+            ->not->toBeNull()
+            ->fieldName->toBe('unit')
+            ->op->toBe(Op::In)
+            ->paramName->toBe(':inParam')
+            ->and($field->value)->toEqual(['a', 'b']);
+    });
+});
+
+describe('::inArray()', function () {
+    test('creates Field w/o parameter', function () {
+        $field = Field::inArray('test', 'tbl', [1, 2, 3]);
+        expect($field)
+            ->not->toBeNull()
+            ->fieldName->toBe('test')
+            ->op->toBe(Op::InArray)
+            ->paramName->toBeEmpty()
+            ->and($field->value)->toEqual(['table' => 'tbl', 'values' => [1, 2, 3]]);
+    });
+    test('creates Field w/ parameter', function () {
+        $field = Field::inArray('unit', 'tab', ['a', 'b'], ':inAParam');
+        expect($field)
+            ->not->toBeNull()
+            ->fieldName->toBe('unit')
+            ->op->toBe(Op::InArray)
+            ->paramName->toBe(':inAParam')
+            ->and($field->value)->toEqual(['table' => 'tab', 'values' => ['a', 'b']]);
+    });
+});
+
+describe('::exists()', function () {
+    test('creates Field', function () {
+        $field = Field::exists('be_there');
+        expect($field)
+            ->not->toBeNull()
+            ->fieldName->toBe('be_there')
+            ->op->toBe(Op::Exists)
+            ->paramName->toBeEmpty()
+            ->and($field->value)->toBeEmpty();
+    });
+});
+
+describe('::notExists()', function () {
+    test('creates Field', function () {
+        $field = Field::notExists('be_absent');
+        expect($field)
+            ->not->toBeNull()
+            ->fieldName->toBe('be_absent')
+            ->op->toBe(Op::NotExists)
+            ->paramName->toBeEmpty()
+            ->and($field->value)->toBeEmpty();
+    });
+});
+
+describe('::named()', function () {
+    test('creates Field', function () {
+        $field = Field::named('the_field');
+        expect($field)
+            ->not->toBeNull()
+            ->fieldName->toBe('the_field')
+            ->op->toBe(Op::Equal)
+            ->value->toBeEmpty()
+            ->and($field->value)->toBeEmpty();
+    });
+});

tests/Unit/Mapper/ArrayMapperTest.php

@@ -0,0 +1,18 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
+
+use BitBadger\PDODocument\Mapper\ArrayMapper;
+
+pest()->group('unit');
+
+describe('->map()', function () {
+    test('returns the given array', function () {
+        $result = ['one' => 2, 'three' => 4, 'eight' => 'five'];
+        expect(new ArrayMapper()->map($result))->toBe($result);
+    });
+});

tests/Unit/Mapper/CountMapperTest.php

@@ -0,0 +1,17 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
+
+use BitBadger\PDODocument\Mapper\CountMapper;
+
+pest()->group('unit');
+
+describe('->map()', function () {
+    test('returns item 0 in the given array', function () {
+        expect(new CountMapper()->map([5, 8, 10]))->toBe(5);
+    });
+});

tests/Unit/Mapper/DocumentMapperTest.php

@@ -0,0 +1,65 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
+
+use BitBadger\PDODocument\{DocumentException, Field};
+use BitBadger\PDODocument\Mapper\DocumentMapper;
+use Test\{PjsonDocument, PjsonId};
+
+// ** Test class hierarchy for serialization **
+
+class DocMapSubDoc
+{
+    public function __construct(public int $id = 0, public string $name = '') { }
+}
+
+class DocMapTestDoc
+{
+    public function __construct(public int $id = 0, public DocMapSubDoc $subDoc = new DocMapSubDoc()) { }
+}
+
+pest()->group('unit');
+
+describe('Constructor', function () {
+    test('uses "data" as the default field name', function () {
+        expect(new DocumentMapper(Field::class))->fieldName->toBe('data');
+    });
+    test('uses the provided field name', function () {
+        expect(new DocumentMapper(Field::class, 'json'))->fieldName->toBe('json');
+    });
+});
+
+describe('->map()', function () {
+    test('deserializes valid JSON', function () {
+        $doc = new DocumentMapper(DocMapTestDoc::class)
+            ->map(['data' => '{"id":7,"subDoc":{"id":22,"name":"tester"}}']);
+        expect($doc)
+            ->not->toBeNull()
+            ->id->toBe(7)
+            ->and($doc->subDoc)
+            ->not->toBeNull()
+            ->id->toBe(22)
+            ->name->toBe('tester');
+    });
+    test('deserializes valid JSON [Pjson]', function () {
+        $doc = new DocumentMapper(PjsonDocument::class)->map(['data' => '{"id":"seven","name":"bob","num_value":8}']);
+        expect($doc)
+            ->not->toBeNull()
+            ->id->toEqual(new PjsonId('seven'))
+            ->name->toBe('bob')
+            ->numValue->toBe(8)
+            ->skipped->toBeEmpty();
+    });
+    test('throws for invalid JSON', function () {
+        expect(fn() => new DocumentMapper(DocMapTestDoc::class)->map(['data' => 'this is not valid']))
+            ->toThrow(DocumentException::class);
+    });
+    test('throws for invalid JSON [Pjson]', function () {
+        expect(fn() => new DocumentMapper(PjsonDocument::class)->map(['data' => 'not even close']))
+            ->toThrow(DocumentException::class);
+    });
+});

tests/Unit/Mapper/ExistsMapperTest.php

@@ -0,0 +1,28 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
+
+use BitBadger\PDODocument\{Configuration, DocumentException, Mode};
+use BitBadger\PDODocument\Mapper\ExistsMapper;
+
+pest()->group('unit');
+
+afterEach(function () { Configuration::overrideMode(null); });
+
+describe('->map()', function () {
+    test('returns a boolean value from index 0 [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(new ExistsMapper()->map([false, 'nope']))->toBeFalse();
+    });
+    test('returns a number value as boolean from index 0 [SQLite]', function () {
+        Configuration::overrideMode(Mode::SQLite);
+        expect(new ExistsMapper()->map([1, 'yep']))->toBeTrue();
+    });
+    test('throws if mode is not set', function () {
+        expect(fn() => new ExistsMapper()->map(['0']))->toThrow(DocumentException::class);
+    });
+});

tests/Unit/Mapper/StringMapperTest.php

@@ -0,0 +1,23 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
+
+use BitBadger\PDODocument\Mapper\StringMapper;
+
+pest()->group('unit');
+
+describe('->map()', function () {
+    test('returns existing string column value', function () {
+        expect(new StringMapper('test_field'))->map(['test_field' => 'test_value'])->toBe('test_value');
+    });
+    test('returns string value of non-string column', function () {
+        expect(new StringMapper('a_number'))->map(['a_number' => 6.7])->toBe('6.7');
+    });
+    test('returns null for a missing column', function () {
+        expect(new StringMapper('something_else'))->map([])->toBeNull();
+    });
+});

tests/Unit/ModeTest.php

@@ -0,0 +1,23 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
+
+use BitBadger\PDODocument\{DocumentException, Mode};
+
+pest()->group('unit');
+
+describe('::deriveFromDSN()', function () {
+    test('derives for PostgreSQL', function () {
+        expect(Mode::deriveFromDSN('pgsql:Host=localhost'))->toBe(Mode::PgSQL);
+    })->group('postgresql');
+    test('derives for SQLite', function () {
+        expect(Mode::deriveFromDSN('sqlite:data.db'))->toBe(Mode::SQLite);
+    })->group('sqlite');
+    test('throws for other drivers', function () {
+        expect(fn() => Mode::deriveFromDSN('mysql:Host=localhost'))->toThrow(DocumentException::class);
+    });
+});

tests/Unit/OpTest.php

@@ -0,0 +1,47 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
+
+use BitBadger\PDODocument\Op;
+
+pest()->group('unit');
+
+describe('->toSQL()', function () {
+    test('returns "=" for Equal', function () {
+        expect(Op::Equal)->toSQL()->toBe('=');
+    });
+    test('returns ">" for Greater', function () {
+        expect(Op::Greater)->toSQL()->toBe('>');
+    });
+    test('returns ">=" for GreaterOrEqual', function () {
+        expect(Op::GreaterOrEqual)->toSQL()->toBe('>=');
+    });
+    test('returns "<" for Less', function () {
+        expect(Op::Less)->toSQL()->toBe('<');
+    });
+    test('returns "<=" for LessOrEqual', function () {
+        expect(Op::LessOrEqual)->toSQL()->toBe('<=');
+    });
+    test('returns "<>" for NotEqual', function () {
+        expect(Op::NotEqual)->toSQL()->toBe('<>');
+    });
+    test('returns "BETWEEN" for Between', function () {
+        expect(Op::Between)->toSQL()->toBe('BETWEEN');
+    });
+    test('returns "IN" for In', function () {
+        expect(Op::In)->toSQL()->toBe('IN');
+    });
+    test('returns "?|" (escaped) for InArray', function () {
+        expect(Op::InArray)->toSQL()->toBe('??|');
+    });
+    test('returns "IS NOT NULL" for Exists', function () {
+        expect(Op::Exists)->toSQL()->toBe('IS NOT NULL');
+    });
+    test('returns "IS NULL" for NotExists', function () {
+        expect(Op::NotExists)->toSQL()->toBe('IS NULL');
+    });
+});

tests/Unit/ParametersTest.php

@@ -0,0 +1,85 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
+
+use BitBadger\PDODocument\{Configuration, DocumentException, Field, Mode, Parameters};
+use Test\{PjsonDocument, PjsonId};
+
+pest()->group('unit');
+
+describe('::id()', function () {
+    test('creates string ID parameter', function () {
+        expect(Parameters::id('key'))->toEqual([':id' => 'key']);
+    });
+    test('creates string from numeric ID parameter', function () {
+        expect(Parameters::id(7))->toEqual([':id' => '7']);
+    });
+});
+
+describe('::json()', function () {
+    test('serializes an array', function () {
+        expect(Parameters::json(':it', ['id' => 18, 'url' => 'https://www.unittest.com']))
+            ->toEqual([':it' => '{"id":18,"url":"https://www.unittest.com"}']);
+    });
+    test('serializes an array w/ an empty array value', function () {
+        expect(Parameters::json(':it', ['id' => 18, 'urls' => []]))->toEqual([':it' => '{"id":18,"urls":[]}']);
+    });
+    test('serializes a 1-D array w/ an empty array value', function () {
+        expect(Parameters::json(':it', ['urls' => []]))->toEqual([':it' => '{"urls":[]}']);
+    });
+    test('serializes a stdClass instance', function () {
+        $obj      = new stdClass();
+        $obj->id  = 19;
+        $obj->url = 'https://testhere.info';
+        expect(Parameters::json(':it', $obj))->toEqual([':it' => '{"id":19,"url":"https://testhere.info"}']);
+    });
+    test('serializes a Pjson class instance', function () {
+        expect(Parameters::json(':it', new PjsonDocument(new PjsonId('999'), 'a test', 98, 'nothing')))
+            ->toEqual([':it' => '{"id":"999","name":"a test","num_value":98}']);
+    });
+    test('serializes an array of Pjson class instances', function () {
+        expect(Parameters::json(':it',
+            ['pjson' => [new PjsonDocument(new PjsonId('997'), 'another test', 94, 'nothing')]]))
+            ->toEqual([':it' => '{"pjson":[{"id":"997","name":"another test","num_value":94}]}']);
+    });
+});
+
+describe('::nameFields()', function () {
+    test('provides missing parameter names', function () {
+        $named = [Field::equal('it', 17), Field::equal('also', 22, ':also'), Field::equal('other', 24)];
+        Parameters::nameFields($named);
+        expect($named)
+            ->toHaveLength(3)
+            ->sequence(
+                fn($it) => $it->paramName->toBe(':field0'),
+                fn($it) => $it->paramName->toBe(':also'),
+                fn($it) => $it->paramName->toBe(':field2'));
+    });
+});
+
+describe('::addFields()', function () {
+    test('appends to an existing parameter array', function () {
+        expect(Parameters::addFields([Field::equal('b', 'two', ':b'), Field::equal('z', 18, ':z')], [':a' => 1]))
+            ->toEqual([':a' => 1, ':b' => 'two', ':z' => 18]);
+    });
+});
+
+describe('::fieldNames()', function () {
+    afterEach(function () { Configuration::overrideMode(null); });
+    test('generates names [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(Parameters::fieldNames(':names', ['one', 'two', 'seven']))->toEqual([':names' => "{one,two,seven}"]);
+    })->group('postgresql');
+    test('generates names [SQLite]', function () {
+        Configuration::overrideMode(Mode::SQLite);
+        expect(Parameters::fieldNames(':it', ['test', 'unit', 'wow']))
+            ->toEqual([':it0' => '$.test', ':it1' => '$.unit', ':it2' => '$.wow']);
+    })->group('sqlite');
+    test('throws when mode is not set', function () {
+        expect(fn() => Parameters::fieldNames('', []))->toThrow(DocumentException::class);
+    });
+});

tests/Unit/Query/CountTest.php

@@ -0,0 +1,51 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
+
+use BitBadger\PDODocument\{Configuration, DocumentException, Field, Mode};
+use BitBadger\PDODocument\Query\Count;
+
+pest()->group('unit');
+
+afterEach(function () { Configuration::overrideMode(null); });
+
+describe('::all()', function () {
+    test('generates the correct SQL', function () {
+        expect(Count::all('a_table'))->toBe('SELECT COUNT(*) FROM a_table');
+    });
+});
+
+describe('::byFields()', function () {
+    test('generates the correct SQL', function () {
+        Configuration::overrideMode(Mode::SQLite);
+        expect(Count::byFields('somewhere', [Field::greater('errors', 10, ':errors')]))
+            ->toBe("SELECT COUNT(*) FROM somewhere WHERE data->>'errors' > :errors");
+    });
+});
+
+describe('::byContains()', function () {
+    test('generates the correct SQL [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(Count::byContains('the_table'))->toBe('SELECT COUNT(*) FROM the_table WHERE data @> :criteria');
+    })->group('postgresql');
+    test('throws an exception [SQLite]', function () {
+        Configuration::overrideMode(Mode::SQLite);
+        expect(fn () => Count::byContains(''))->toThrow(DocumentException::class);
+    })->group('sqlite');
+});
+
+describe('::byJsonPath()', function () {
+    test('generates the correct SQL [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(Count::byJsonPath('a_table'))
+            ->toBe('SELECT COUNT(*) FROM a_table WHERE jsonb_path_exists(data, :path::jsonpath)');
+    })->group('postgresql');
+    test('throws an exception [SQLite]', function () {
+        Configuration::overrideMode(Mode::SQLite);
+        expect(fn () => Count::byJsonPath(''))->toThrow(DocumentException::class);
+    })->group('sqlite');
+});

tests/Unit/Query/DefinitionTest.php

@@ -0,0 +1,65 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
+
+use BitBadger\PDODocument\{Configuration, DocumentException, DocumentIndex, Mode};
+use BitBadger\PDODocument\Query\Definition;
+
+pest()->group('unit');
+
+describe('::ensureTable()', function () {
+    afterEach(function () { Configuration::overrideMode(null); });
+    test('generates correct SQL [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(Definition::ensureTable('documents'))
+            ->toBe('CREATE TABLE IF NOT EXISTS documents (data JSONB NOT NULL)');
+    })->group('postgresql');
+    test('generates correct SQL [SQLite]', function () {
+        Configuration::overrideMode(Mode::SQLite);
+        expect(Definition::ensureTable('dox'))->toBe('CREATE TABLE IF NOT EXISTS dox (data TEXT NOT NULL)');
+    })->group('sqlite');
+    test('throws an exception if mode is not set', function () {
+        expect(fn () => Definition::ensureTable(''))->toThrow(DocumentException::class);
+    });
+});
+
+describe('::ensureIndexOn()', function () {
+    test('generates correct SQL for unqualified table, single ascending field', function () {
+        expect(Definition::ensureIndexOn('test', 'fields', ['details']))
+            ->toBe("CREATE INDEX IF NOT EXISTS idx_test_fields ON test ((data->>'details'))");
+    });
+    test('generates correct SQL for qualified table, multiple fields', function () {
+        expect(Definition::ensureIndexOn('sch.testing', 'json', ['group', 'sub_group DESC']))
+            ->toBe('CREATE INDEX IF NOT EXISTS idx_testing_json ON sch.testing '
+                . "((data->>'group'), (data->>'sub_group') DESC)");
+    });
+});
+
+describe('::ensureKey()', function () {
+    test('generates correct SQL', function () {
+        expect(Definition::ensureKey('tbl'))
+            ->toBe("CREATE UNIQUE INDEX IF NOT EXISTS idx_tbl_key ON tbl ((data->>'id'))");
+    });
+});
+
+describe('::ensureDocumentIndexOn()', function () {
+    afterEach(function () { Configuration::overrideMode(null); });
+    test('generates correct SQL for qualified table, full index [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(Definition::ensureDocumentIndexOn('my.tbl', DocumentIndex::Full))
+            ->toBe("CREATE INDEX IF NOT EXISTS idx_tbl_document ON my.tbl USING GIN (data)");
+    })->group('postgresql');
+    test('generates correct SQL for unqualified table, optimized index [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(Definition::ensureDocumentIndexOn('it', DocumentIndex::Optimized))
+            ->toBe("CREATE INDEX IF NOT EXISTS idx_it_document ON it USING GIN (data jsonb_path_ops)");
+    })->group('postgresql');
+    test('throws an exception [SQLite]', function () {
+        Configuration::overrideMode(Mode::SQLite);
+        expect(fn () => Definition::ensureDocumentIndexOn('', DocumentIndex::Full))->toThrow(DocumentException::class);
+    })->group('sqlite');
+});

tests/Unit/Query/DeleteTest.php

@@ -0,0 +1,52 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
+
+use BitBadger\PDODocument\{Configuration, DocumentException, Field, Mode};
+use BitBadger\PDODocument\Query\Delete;
+
+pest()->group('unit');
+
+afterEach(function () { Configuration::overrideMode(null); });
+
+describe('::byId()', function () {
+    test('generates correct SQL', function () {
+        Configuration::overrideMode(Mode::SQLite);
+        expect(Delete::byId('over_there'))->toBe("DELETE FROM over_there WHERE data->>'id' = :id");
+    });
+});
+
+describe('::byFields()', function () {
+    test('generates correct SQL', function () {
+        Configuration::overrideMode(Mode::SQLite);
+        expect(Delete::byFields('my_table',
+                [Field::less('value', 99, ':max'), Field::greaterOrEqual('value', 18, ':min')]))
+            ->toBe("DELETE FROM my_table WHERE data->>'value' < :max AND data->>'value' >= :min");
+    });
+});
+
+describe('::byContains()', function () {
+    test('generates correct SQL [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(Delete::byContains('somewhere'))->toBe('DELETE FROM somewhere WHERE data @> :criteria');
+    })->group('postgresql');
+    test('throws an exception [SQLite]', function () {
+        Configuration::overrideMode(Mode::SQLite);
+        expect(fn () => Delete::byContains(''))->toThrow(DocumentException::class);
+    })->group('sqlite');
+});
+
+describe('::byJsonPath()', function () {
+    test('generates correct SQL [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(Delete::byJsonPath('here'))->toBe('DELETE FROM here WHERE jsonb_path_exists(data, :path::jsonpath)');
+    })->group('postgresql');
+    test('throws an exception [SQLite]', function () {
+        Configuration::overrideMode(Mode::SQLite);
+        expect(fn () => Delete::byJsonPath(''))->toThrow(DocumentException::class);
+    });
+});

tests/Unit/Query/ExistsTest.php

@@ -0,0 +1,59 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
+
+use BitBadger\PDODocument\{Configuration, DocumentException, Field, Mode};
+use BitBadger\PDODocument\Query\Exists;
+
+pest()->group('unit');
+
+afterEach(function () { Configuration::overrideMode(null); });
+
+describe('::query()', function () {
+    test('generates correct SQL', function () {
+        Configuration::overrideMode(Mode::SQLite);
+        expect(Exists::query('abc', 'def'))->toBe('SELECT EXISTS (SELECT 1 FROM abc WHERE def)');
+    });
+});
+
+describe('::byId()', function () {
+    test('generates correct SQL', function () {
+        Configuration::overrideMode(Mode::SQLite);
+        expect(Exists::byId('dox'))->toBe("SELECT EXISTS (SELECT 1 FROM dox WHERE data->>'id' = :id)");
+    });
+});
+
+describe('::byFields()', function () {
+    test('generates correct SQL', function () {
+        Configuration::overrideMode(Mode::SQLite);
+        expect(Exists::byFields('box', [Field::notEqual('status', 'occupied', ':status')]))
+            ->toBe("SELECT EXISTS (SELECT 1 FROM box WHERE data->>'status' <> :status)");
+    });
+});
+
+describe('::byContains()', function () {
+    test('generates correct SQL [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(Exists::byContains('pocket'))->toBe('SELECT EXISTS (SELECT 1 FROM pocket WHERE data @> :criteria)');
+    })->group('postgresql');
+    test('throws an exception [SQLite]', function () {
+        Configuration::overrideMode(Mode::SQLite);
+        expect(fn () => Exists::byContains(''))->toThrow(DocumentException::class);
+    })->group('sqlite');
+});
+
+describe('::byJsonPath()', function () {
+    test('generates correct SQL [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(Exists::byJsonPath('lint'))
+            ->toBe('SELECT EXISTS (SELECT 1 FROM lint WHERE jsonb_path_exists(data, :path::jsonpath))');
+    })->group('postgresql');
+    test('throws an exception [SQLite]', function () {
+        Configuration::overrideMode(Mode::SQLite);
+        expect(fn () => Exists::byJsonPath(''))->toThrow(DocumentException::class);
+    })->group('sqlite');
+});

tests/Unit/Query/FindTest.php

@@ -0,0 +1,53 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
+
+use BitBadger\PDODocument\{Configuration, DocumentException, Field, FieldMatch, Mode};
+use BitBadger\PDODocument\Query\Find;
+
+pest()->group('unit');
+
+afterEach(function () { Configuration::overrideMode(null); });
+
+describe('::byId()', function () {
+    test('generates correct SQL', function () {
+        Configuration::overrideMode(Mode::SQLite);
+        expect(Find::byId('here'))->toBe("SELECT data FROM here WHERE data->>'id' = :id");
+    });
+});
+
+describe('::byFields()', function () {
+    test('generates correct SQL', function () {
+        Configuration::overrideMode(Mode::SQLite);
+        expect(Find::byFields('there', [Field::equal('active', true, ':act'), Field::equal('locked', true, ':lock')],
+                FieldMatch::Any))
+            ->toBe("SELECT data FROM there WHERE data->>'active' = :act OR data->>'locked' = :lock");
+    });
+});
+
+describe('::byContains()', function () {
+    test('generates correct SQL [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(Find::byContains('disc'))->toBe('SELECT data FROM disc WHERE data @> :criteria');
+    })->group('postgresql');
+    test('throws an exception [SQLite]', function () {
+        Configuration::overrideMode(Mode::SQLite);
+        expect(fn () => Find::byContains(''))->toThrow(DocumentException::class);
+    })->group('sqlite');
+});
+
+describe('::byJsonPath()', function () {
+    test('generates correct SQL [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(Find::byJsonPath('light'))
+            ->toBe('SELECT data FROM light WHERE jsonb_path_exists(data, :path::jsonpath)');
+    })->group('postgresql');
+    test('throws an exception [SQLite]', function () {
+        Configuration::overrideMode(Mode::SQLite);
+        expect(fn () => Find::byJsonPath(''))->toThrow(DocumentException::class);
+    })->group('sqlite');
+});

tests/Unit/Query/PatchTest.php

@@ -0,0 +1,68 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
+
+use BitBadger\PDODocument\{Configuration, DocumentException, Field, Mode};
+use BitBadger\PDODocument\Query\Patch;
+
+pest()->group('unit');
+
+afterEach(function () { Configuration::overrideMode(null); });
+
+describe('::byId()', function () {
+    test('generates correct SQL [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(Patch::byId('doc_table'))->toBe("UPDATE doc_table SET data = data || :data WHERE data->>'id' = :id");
+    })->group('postgresql');
+    test('generates correct SQL [SQLite]', function () {
+        Configuration::overrideMode(Mode::SQLite);
+        expect(Patch::byId('my_table'))
+            ->toBe("UPDATE my_table SET data = json_patch(data, json(:data)) WHERE data->>'id' = :id");
+    })->group('sqlite');
+    test('throws an exception [mode not set]', function () {
+        expect(fn () => Patch::byId(''))->toThrow(DocumentException::class);
+    });
+});
+
+describe('::byFields()', function () {
+    test('generates correct SQL [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(Patch::byFields('that', [Field::less('something', 17, ':some')]))
+            ->toBe("UPDATE that SET data = data || :data WHERE (data->>'something')::numeric < :some");
+    })->group('postgresql');
+    test('generates correct SQL [SQLite]', function () {
+        Configuration::overrideMode(Mode::SQLite);
+        expect(Patch::byFields('a_table', [Field::greater('something', 17, ':it')]))
+            ->toBe("UPDATE a_table SET data = json_patch(data, json(:data)) WHERE data->>'something' > :it");
+    })->group('sqlite');
+    test('throws an exception [mode not set]', function () {
+        expect(fn () => Patch::byFields('', []))->toThrow(DocumentException::class);
+    });
+});
+
+describe('::byContains()', function () {
+    test('generates correct SQL [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(Patch::byContains('this'))->toBe('UPDATE this SET data = data || :data WHERE data @> :criteria');
+    })->group('postgresql');
+    test('throws an exception [SQLite]', function () {
+        Configuration::overrideMode(Mode::SQLite);
+        expect(fn () => Patch::byContains(''))->toThrow(DocumentException::class);
+    })->group('sqlite');
+});
+
+describe('::byJsonPath()', function () {
+    test('generates correct SQL [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(Patch::byJsonPath('that'))
+            ->toBe('UPDATE that SET data = data || :data WHERE jsonb_path_exists(data, :path::jsonpath)');
+    })->group('postgresql');
+    test('throws an exception [SQLite]', function () {
+        Configuration::overrideMode(Mode::SQLite);
+        expect(fn () => Patch::byJsonPath(''))->toThrow(DocumentException::class);
+    })->group('sqlite');
+});

tests/Unit/Query/RemoveFieldsTest.php

@@ -0,0 +1,86 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
+
+use BitBadger\PDODocument\{Configuration, DocumentException, Field, Mode, Parameters};
+use BitBadger\PDODocument\Query\RemoveFields;
+
+pest()->group('unit');
+
+afterEach(function () { Configuration::overrideMode(null); });
+
+describe('::update()', function () {
+    test('generates correct SQL [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(RemoveFields::update('taco', [':names' => "{one,two}"], 'it = true'))
+            ->toBe('UPDATE taco SET data = data - :names::text[] WHERE it = true');
+    })->group('postgresql');
+    test('generates correct SQL [SQLite]', function () {
+        Configuration::overrideMode(Mode::SQLite);
+        expect(RemoveFields::update('burrito', Parameters::fieldNames(':name', ['one', 'two', 'ten']), 'a = b'))
+            ->toBe('UPDATE burrito SET data = json_remove(data, :name0, :name1, :name2) WHERE a = b');
+    })->group('sqlite');
+    test('throws an exception [mode not set]', function () {
+        expect(fn () => RemoveFields::update('', [], ''))->toThrow(DocumentException::class);
+    });
+});
+
+describe('::byId()', function () {
+    test('generates correct SQL [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(RemoveFields::byId('churro', Parameters::fieldNames(':bite', ['byte'])))
+            ->toBe("UPDATE churro SET data = data - :bite::text[] WHERE data->>'id' = :id");
+    })->group('postgresql');
+    test('generates correct SQL [SQLite]', function () {
+        Configuration::overrideMode(Mode::SQLite);
+        expect(RemoveFields::byId('quesadilla', Parameters::fieldNames(':bite', ['byte'])))
+            ->toBe("UPDATE quesadilla SET data = json_remove(data, :bite0) WHERE data->>'id' = :id");
+    })->group('sqlite');
+    test('throws an exception [mode not set]', function () {
+        expect(fn () => RemoveFields::byId('', []))->toThrow(DocumentException::class);
+    });
+});
+
+describe('::byFields()', function () {
+    test('generates correct SQL [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(RemoveFields::byFields('enchilada', [Field::equal('cheese', 'jack', ':queso')],
+                Parameters::fieldNames(':sauce', ['white'])))
+            ->toBe("UPDATE enchilada SET data = data - :sauce::text[] WHERE data->>'cheese' = :queso");
+    })->group('postgresql');
+    test('generates correct SQL [SQLite]', function () {
+        Configuration::overrideMode(Mode::SQLite);
+        expect(RemoveFields::byFields('chimichanga', [Field::equal('side', 'beans', ':rice')],
+                Parameters::fieldNames(':filling', ['beef'])))
+            ->toBe("UPDATE chimichanga SET data = json_remove(data, :filling0) WHERE data->>'side' = :rice");
+    })->group('sqlite');
+    test('throws an exception [mode not set]', function () {
+        expect(fn () => RemoveFields::byFields('', [], []))->toThrow(DocumentException::class);
+    });
+});
+
+describe('::byContains()', function () {
+    test('generates correct SQL [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(RemoveFields::byContains('food', Parameters::fieldNames(':drink', ['a', 'b'])))
+            ->toBe('UPDATE food SET data = data - :drink::text[] WHERE data @> :criteria');
+    })->group('postgresql');
+    test('throws an exception [SQLite]', function () {
+        expect(fn () => RemoveFields::byContains('', []))->toThrow(DocumentException::class);
+    })->group('sqlite');
+});
+
+describe('::byJsonPath()', function () {
+    test('generates correct SQL [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(RemoveFields::byJsonPath('dessert', Parameters::fieldNames(':cake', ['b', 'c'])))
+            ->toBe('UPDATE dessert SET data = data - :cake::text[] WHERE jsonb_path_exists(data, :path::jsonpath)');
+    });
+    test('throws an exception [SQLite]', function () {
+        expect(fn () => RemoveFields::byJsonPath('', []))->toThrow(DocumentException::class);
+    })->group('sqlite');
+});

tests/Unit/QueryTest.php

@@ -0,0 +1,201 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
+
+use BitBadger\PDODocument\{AutoId, Configuration, DocumentException, Field, FieldMatch, Mode, Query};
+
+pest()->group('unit');
+
+beforeEach(function () { Configuration::overrideMode(Mode::SQLite); });
+afterEach(function () { Configuration::overrideMode(null); });
+
+describe('::selectFromTable()', function () {
+    test('correctly forms a query', function () {
+        expect(Query::selectFromTable('testing'))->toBe('SELECT data FROM testing');
+    });
+});
+
+describe('::whereByFields()', function () {
+    test('generates a single field correctly', function () {
+        expect(Query::whereByFields([Field::lessOrEqual('test_field', '', ':it')]))->toBe("data->>'test_field' <= :it");
+    });
+    test('generates all fields correctly', function () {
+        expect(Query::whereByFields(
+
+                [Field::lessOrEqual('test_field', '', ':it'), Field::equal('other_field', '', ':other')]))
+            ->toBe("data->>'test_field' <= :it AND data->>'other_field' = :other",);
+    });
+    test('generates any field correctly', function () {
+        expect(Query::whereByFields(
+                [Field::lessOrEqual('test_field', '', ':it'), Field::equal('other_field', '', ':other')],
+                FieldMatch::Any))
+            ->toBe("data->>'test_field' <= :it OR data->>'other_field' = :other");
+    });
+});
+
+describe('::whereById()', function () {
+    test('uses default parameter name', function () {
+        expect(Query::whereById())->toBe("data->>'id' = :id");
+    });
+    test('uses provided parameter name', function () {
+        expect(Query::whereById(':di'))->toBe("data->>'id' = :di");
+    });
+});
+
+describe('::whereDataContains()', function () {
+    test('uses default parameter [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(Query::whereDataContains())->toBe('data @> :criteria');
+    });
+    test('uses provided parameter [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(Query::whereDataContains(':it'))->toBe('data @> :it');
+    });
+    test('throws [SQLite]', function () {
+        expect(fn () => Query::whereDataContains())->toThrow(DocumentException::class);
+    });
+});
+
+describe('::whereJsonPathMatches()', function () {
+    test('uses default parameter [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(Query::whereJsonPathMatches())->toBe('jsonb_path_exists(data, :path::jsonpath)');
+    });
+    test('uses provided parameter [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(Query::whereJsonPathMatches(':road'))->toBe('jsonb_path_exists(data, :road::jsonpath)');
+    });
+    test('throws [SQLite]', function () {
+        expect(fn () => Query::whereJsonPathMatches())->toThrow(DocumentException::class);
+    });
+});
+
+describe('::insert()', function () {
+    test('generates with no auto-ID [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(Query::insert('test_tbl'))->toBe('INSERT INTO test_tbl VALUES (:data)');
+    });
+    test('generates with no auto-ID [SQLite]', function () {
+        expect(Query::insert('test_tbl'))->toBe('INSERT INTO test_tbl VALUES (:data)');
+    });
+    test('generates with auto numeric ID [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(Query::insert('test_tbl', AutoId::Number))
+            ->toBe("INSERT INTO test_tbl VALUES (:data::jsonb || ('{\"id\":' "
+                . "|| (SELECT COALESCE(MAX((data->>'id')::numeric), 0) + 1 FROM test_tbl) || '}')::jsonb)");
+    });
+    test('generates with auto numeric ID [SQLite]', function () {
+        expect(Query::insert('test_tbl', AutoId::Number))
+            ->toBe("INSERT INTO test_tbl VALUES (json_set(:data, '$.id', "
+                . "(SELECT coalesce(max(data->>'id'), 0) + 1 FROM test_tbl)))");
+    });
+    test('generates with auto UUID [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(Query::insert('test_tbl', AutoId::UUID))
+            ->toStartWith("INSERT INTO test_tbl VALUES (:data::jsonb || '{\"id\":\"")
+            ->toEndWith("\"}')");
+    });
+    test('generates with auto UUID [SQLite]', function () {
+        expect(Query::insert('test_tbl', AutoId::UUID))
+            ->toStartWith("INSERT INTO test_tbl VALUES (json_set(:data, '$.id', '")
+            ->toEndWith("'))");
+    });
+    test('generates with auto random string [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        Configuration::$idStringLength = 8;
+        try {
+            $query = Query::insert('test_tbl', AutoId::RandomString);
+            expect($query)
+                ->toStartWith("INSERT INTO test_tbl VALUES (:data::jsonb || '{\"id\":\"")
+                ->toEndWith("\"}')")
+                ->and(str_replace(["INSERT INTO test_tbl VALUES (:data::jsonb || '{\"id\":\"", "\"}')"], '', $query))
+                ->toHaveLength(8);
+        } finally {
+            Configuration::$idStringLength = 16;
+        }
+    });
+    test('generates with auto random string [SQLite]', function () {
+        $query = Query::insert('test_tbl', AutoId::RandomString);
+        expect($query)
+            ->toStartWith("INSERT INTO test_tbl VALUES (json_set(:data, '$.id', '")
+            ->toEndWith("'))")
+            ->and(str_replace(["INSERT INTO test_tbl VALUES (json_set(:data, '$.id', '", "'))"], '', $query))
+            ->toHaveLength(16);
+    });
+    test('throws when mode not set', function () {
+        Configuration::overrideMode(null);
+        expect(fn () => Query::insert('kaboom'))->toThrow(DocumentException::class);
+    });
+});
+
+describe('::save()', function () {
+    test('generates the correct query', function () {
+        expect(Query::save('test_tbl'))
+            ->toBe("INSERT INTO test_tbl VALUES (:data) ON CONFLICT ((data->>'id')) DO UPDATE SET data = EXCLUDED.data");
+    });
+});
+
+describe('::update()', function () {
+    test('generates the correct query', function () {
+        expect(Query::update('testing'))->toBe("UPDATE testing SET data = :data WHERE data->>'id' = :id");
+    });
+});
+
+describe('::orderBy()', function () {
+    test('returns blank for no criteria [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(Query::orderBy([]))->toBeEmpty();
+    });
+    test('returns blank for no criteria [SQLite]', function () {
+        expect(Query::orderBy([]))->toBeEmpty();
+    });
+    test('generates one field with no direction [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(Query::orderBy([Field::named('TestField')]))->toBe(" ORDER BY data->>'TestField'");
+    });
+    test('generates one field with no direction [SQLite]', function () {
+        expect(Query::orderBy([Field::named('TestField')]))->toBe(" ORDER BY data->>'TestField'");
+    });
+    test('generates with one qualified field [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        $field = Field::named('TestField');
+        $field->qualifier = 'qual';
+        expect(Query::orderBy([$field]))->toBe(" ORDER BY qual.data->>'TestField'");
+    });
+    test('generates with one qualified field [SQLite]', function () {
+        $field = Field::named('TestField');
+        $field->qualifier = 'qual';
+        expect(Query::orderBy([$field]))->toBe(" ORDER BY qual.data->>'TestField'");
+    });
+    test('generates with multiple fields and direction [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(Query::orderBy(
+                [Field::named('Nested.Test.Field DESC'), Field::named('AnotherField'), Field::named('It DESC')]))
+            ->toBe(" ORDER BY data#>>'{Nested,Test,Field}' DESC, data->>'AnotherField', data->>'It' DESC");
+    });
+    test('generates with multiple fields and direction [SQLite]', function () {
+        expect(Query::orderBy(
+                [Field::named('Nested.Test.Field DESC'), Field::named('AnotherField'), Field::named('It DESC')]))
+            ->toBe(" ORDER BY data->'Nested'->'Test'->>'Field' DESC, data->>'AnotherField', data->>'It' DESC");
+    });
+    test('generates with numeric field [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(Query::orderBy([Field::named('n:Test')]))->toBe(" ORDER BY (data->>'Test')::numeric");
+    });
+    test('generates with numeric field [SQLite]', function () {
+        expect(Query::orderBy([Field::named('n:Test')]))->toBe(" ORDER BY data->>'Test'");
+    });
+    test('generates case-insensitive ordering [PostgreSQL]', function () {
+        Configuration::overrideMode(Mode::PgSQL);
+        expect(Query::orderBy([Field::named('i:Test.Field DESC NULLS FIRST')]))
+            ->toBe(" ORDER BY LOWER(data#>>'{Test,Field}') DESC NULLS FIRST");
+    });
+    test('generates case-insensitive ordering [SQLite]', function () {
+        expect(Query::orderBy([Field::named('i:Test.Field ASC NULLS LAST')]))
+            ->toBe(" ORDER BY data->'Test'->>'Field' COLLATE NOCASE ASC NULLS LAST");
+    });
+});

tests/integration/postgresql/CountTest.php

@@ -1,84 +0,0 @@
-<?php
-/**
- * @author Daniel J. Summers <daniel@bitbadger.solutions>
- * @license MIT
- */
-
-declare(strict_types=1);
-
-namespace Test\Integration\PostgreSQL;
-
-use BitBadger\PDODocument\{Count, Field};
-use PHPUnit\Framework\Attributes\TestDox;
-use PHPUnit\Framework\TestCase;
-
-/**
- * PostgreSQL integration tests for the Count class
- */
-#[TestDox('Count (PostgreSQL integration)')]
-class CountTest extends TestCase
-{
-    /** @var string Database name for throwaway database */
-    private string $dbName;
-
-    protected function setUp(): void
-    {
-        parent::setUp();
-        $this->dbName = ThrowawayDb::create();
-    }
-
-    protected function tearDown(): void
-    {
-        ThrowawayDb::destroy($this->dbName);
-        parent::tearDown();
-    }
-
-    #[TestDox('all() succeeds')]
-    public function testAllSucceeds(): void
-    {
-        $count = Count::all(ThrowawayDb::TABLE);
-        $this->assertEquals(5, $count, 'There should have been 5 matching documents');
-    }
-
-    #[TestDox('byFields() succeeds for a numeric range')]
-    public function testByFieldsSucceedsForANumericRange(): void
-    {
-        $count = Count::byFields(ThrowawayDb::TABLE, [Field::between('num_value', 10, 20)]);
-        $this->assertEquals(3, $count, 'There should have been 3 matching documents');
-    }
-
-    #[TestDox('byFields() succeeds for a non-numeric range')]
-    public function testByFieldsSucceedsForANonNumericRange(): void
-    {
-        $count = Count::byFields(ThrowawayDb::TABLE, [Field::between('value', 'aardvark', 'apple')]);
-        $this->assertEquals(1, $count, 'There should have been 1 matching document');
-    }
-
-    #[TestDox('byContains() succeeds when documents match')]
-    public function testByContainsSucceedsWhenDocumentsMatch(): void
-    {
-        $this->assertEquals(2, Count::byContains(ThrowawayDb::TABLE, ['value' => 'purple']),
-            'There should have been 2 matching documents');
-    }
-
-    #[TestDox('byContains() succeeds when no documents match')]
-    public function testByContainsSucceedsWhenNoDocumentsMatch(): void
-    {
-        $this->assertEquals(0, Count::byContains(ThrowawayDb::TABLE, ['value' => 'magenta']),
-            'There should have been no matching documents');
-    }
-
-    #[TestDox('byJsonPath() succeeds when documents match')]
-    public function testByJsonPathSucceedsWhenDocumentsMatch(): void
-    {
-        $this->assertEquals(2, Count::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ < 5)'),
-            'There should have been 2 matching documents');
-    }
-
-    #[TestDox('byJsonPath() succeeds when no documents match')]
-    public function testByJsonPathSucceedsWhenNoDocumentsMatch(): void
-    {
-        $this->assertEquals(0, Count::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ > 100)'),
-            'There should have been no matching documents');
-    }
-}

tests/integration/postgresql/CustomTest.php

@@ -1,138 +0,0 @@
-<?php
-/**
- * @author Daniel J. Summers <daniel@bitbadger.solutions>
- * @license MIT
- */
-
-declare(strict_types=1);
-
-namespace Test\Integration\PostgreSQL;
-
-use BitBadger\PDODocument\{Count, Custom, DocumentException, Query};
-use BitBadger\PDODocument\Mapper\{CountMapper, DocumentMapper};
-use PHPUnit\Framework\Attributes\TestDox;
-use PHPUnit\Framework\TestCase;
-use Test\Integration\TestDocument;
-
-/**
- * PostgreSQL integration tests for the Custom class
- */
-#[TestDox('Custom (PostgreSQL integration)')]
-class CustomTest extends TestCase
-{
-    /** @var string Database name for throwaway database */
-    private string $dbName;
-
-    public function setUp(): void
-    {
-        parent::setUp();
-        $this->dbName = ThrowawayDb::create();
-    }
-
-    public function tearDown(): void
-    {
-        ThrowawayDb::destroy($this->dbName);
-    }
-
-    #[TestDox('runQuery() succeeds with a valid query')]
-    public function testRunQuerySucceedsWithAValidQuery(): void
-    {
-        $stmt = &Custom::runQuery('SELECT data FROM ' . ThrowawayDb::TABLE . ' LIMIT 1', []);
-        try {
-            $this->assertNotNull($stmt, 'The statement should not have been null');
-        } finally {
-            $stmt = null;
-        }
-    }
-
-    #[TestDox('runQuery() fails with an invalid query')]
-    public function testRunQueryFailsWithAnInvalidQuery(): void
-    {
-        $this->expectException(DocumentException::class);
-        $stmt = &Custom::runQuery('GRAB stuff FROM over_there UNTIL done', []);
-        try {
-            $this->assertTrue(false, 'This code should not be reached');
-        } finally {
-            $stmt = null;
-        }
-    }
-
-    #[TestDox('list() succeeds when data is found')]
-    public function testListSucceedsWhenDataIsFound(): void
-    {
-        $list = Custom::list(Query::selectFromTable(ThrowawayDb::TABLE), [], new DocumentMapper(TestDocument::class));
-        $this->assertNotNull($list, 'The document list should not be null');
-        $count = 0;
-        foreach ($list->items as $ignored) $count++;
-        $this->assertEquals(5, $count, 'There should have been 5 documents in the list');
-    }
-
-    #[TestDox('list() succeeds when no data is found')]
-    public function testListSucceedsWhenNoDataIsFound(): void
-    {
-        $list = Custom::list(
-            Query::selectFromTable(ThrowawayDb::TABLE) . " WHERE (data->>'num_value')::numeric > :value",
-            [':value' => 100], new DocumentMapper(TestDocument::class));
-        $this->assertNotNull($list, 'The document list should not be null');
-        $this->assertFalse($list->hasItems, 'There should have been no documents in the list');
-    }
-
-    #[TestDox('array() succeeds when data is found')]
-    public function testArraySucceedsWhenDataIsFound(): void
-    {
-        $array = Custom::array(Query::selectFromTable(ThrowawayDb::TABLE) . " WHERE data->>'sub' IS NOT NULL", [],
-            new DocumentMapper(TestDocument::class));
-        $this->assertNotNull($array, 'The document array should not be null');
-        $this->assertCount(2, $array, 'There should have been 2 documents in the array');
-    }
-
-    #[TestDox('array() succeeds when no data is found')]
-    public function testArraySucceedsWhenNoDataIsFound(): void
-    {
-        $array = Custom::array(Query::selectFromTable(ThrowawayDb::TABLE) . " WHERE data->>'value' = :value",
-            [':value' => 'not there'], new DocumentMapper(TestDocument::class));
-        $this->assertNotNull($array, 'The document array should not be null');
-        $this->assertCount(0, $array, 'There should have been no documents in the array');
-    }
-
-    #[TestDox('single() succeeds when a row is found')]
-    public function testSingleSucceedsWhenARowIsFound(): void
-    {
-        $doc = Custom::single('SELECT data FROM ' . ThrowawayDb::TABLE . " WHERE data->>'id' = :id", [':id' => 'one'],
-            new DocumentMapper(TestDocument::class));
-        $this->assertTrue($doc->isSome, 'There should have been a document returned');
-        $this->assertEquals('one', $doc->value->id, 'The incorrect document was returned');
-    }
-
-    #[TestDox('single() succeeds when a row is not found')]
-    public function testSingleSucceedsWhenARowIsNotFound(): void
-    {
-        $doc = Custom::single('SELECT data FROM ' . ThrowawayDb::TABLE . " WHERE data->>'id' = :id",
-            [':id' => 'eighty'], new DocumentMapper(TestDocument::class));
-        $this->assertTrue($doc->isNone, 'There should not have been a document returned');
-    }
-
-    #[TestDox('nonQuery() succeeds when operating on data')]
-    public function testNonQuerySucceedsWhenOperatingOnData(): void
-    {
-        Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
-        $remaining = Count::all(ThrowawayDb::TABLE);
-        $this->assertEquals(0, $remaining, 'There should be no documents remaining in the table');
-    }
-
-    #[TestDox('nonQuery() succeeds when no data matches WHERE clause')]
-    public function testNonQuerySucceedsWhenNoDataMatchesWhereClause(): void
-    {
-        Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE . " WHERE (data->>'num_value')::numeric > :value",
-            [':value' => 100]);
-        $remaining = Count::all(ThrowawayDb::TABLE);
-        $this->assertEquals(5, $remaining, 'There should be 5 documents remaining in the table');
-    }
-
-    #[TestDox('scalar() succeeds')]
-    public function testScalarSucceeds(): void
-    {
-        $value = Custom::scalar("SELECT 5 AS it", [], new CountMapper());
-        $this->assertEquals(5, $value, 'The scalar value was not returned correctly');
-    }
-}

tests/integration/postgresql/DefinitionTest.php

@@ -1,88 +0,0 @@
-<?php
-/**
- * @author Daniel J. Summers <daniel@bitbadger.solutions>
- * @license MIT
- */
-
-declare(strict_types=1);
-
-namespace Test\Integration\PostgreSQL;
-
-use BitBadger\PDODocument\{Custom, Definition, DocumentException, DocumentIndex};
-use BitBadger\PDODocument\Mapper\ExistsMapper;
-use PHPUnit\Framework\Attributes\TestDox;
-use PHPUnit\Framework\TestCase;
-
-/**
- * PostgreSQL integration tests for the Definition class
- */
-#[TestDox('Definition (PostgreSQL integration)')]
-class DefinitionTest extends TestCase
-{
-    /** @var string Database name for throwaway database */
-    private string $dbName;
-
-    protected function setUp(): void
-    {
-        parent::setUp();
-        $this->dbName = ThrowawayDb::create(withData: false);
-    }
-
-    protected function tearDown(): void
-    {
-        ThrowawayDb::destroy($this->dbName);
-        parent::tearDown();
-    }
-
-    /**
-     * Does the given named object exist in the database?
-     *
-     * @param string $name The name of the object whose existence should be verified
-     * @return bool True if the object exists, false if not
-     * @throws DocumentException If any is encountered
-     */
-    private function itExists(string $name): bool
-    {
-        return Custom::scalar('SELECT EXISTS (SELECT 1 FROM pg_class WHERE relname = :name)',
-            [':name' => $name], new ExistsMapper());
-    }
-
-    #[TestDox('ensureTable() succeeds')]
-    public function testEnsureTableSucceeds(): void
-    {
-        $this->assertFalse($this->itExists('ensured'), 'The table should not exist already');
-        $this->assertFalse($this->itExists('idx_ensured_key'), 'The key index should not exist already');
-        Definition::ensureTable('ensured');
-        $this->assertTrue($this->itExists('ensured'), 'The table should now exist');
-        $this->assertTrue($this->itExists('idx_ensured_key'), 'The key index should now exist');
-    }
-
-    #[TestDox('ensureFieldIndex() succeeds')]
-    public function testEnsureFieldIndexSucceeds(): void
-    {
-        $this->assertFalse($this->itExists('idx_ensured_test'), 'The index should not exist already');
-        Definition::ensureTable('ensured');
-        Definition::ensureFieldIndex('ensured', 'test', ['name', 'age']);
-        $this->assertTrue($this->itExists('idx_ensured_test'), 'The index should now exist');
-    }
-
-    #[TestDox('ensureDocumentIndex() succeeds for Full')]
-    public function testEnsureDocumentIndexSucceedsForFull(): void
-    {
-        $docIdx = 'idx_' . ThrowawayDb::TABLE . '_document';
-        Definition::ensureTable(ThrowawayDb::TABLE);
-        $this->assertFalse($this->itExists($docIdx), 'The document index should not exist');
-        Definition::ensureDocumentIndex(ThrowawayDb::TABLE, DocumentIndex::Full);
-        $this->assertTrue($this->itExists($docIdx), 'The document index should now exist');
-    }
-
-    #[TestDox('ensureDocumentIndex() succeeds for Optimized')]
-    public function testEnsureDocumentIndexSucceedsForOptimized(): void
-    {
-        $docIdx = 'idx_' . ThrowawayDb::TABLE . '_document';
-        Definition::ensureTable(ThrowawayDb::TABLE);
-        $this->assertFalse($this->itExists($docIdx), 'The document index should not exist');
-        Definition::ensureDocumentIndex(ThrowawayDb::TABLE, DocumentIndex::Optimized);
-        $this->assertTrue($this->itExists($docIdx), 'The document index should now exist');
-    }
-}

tests/integration/postgresql/DeleteTest.php

@@ -1,99 +0,0 @@
-<?php
-/**
- * @author Daniel J. Summers <daniel@bitbadger.solutions>
- * @license MIT
- */
-
-declare(strict_types=1);
-
-namespace Test\Integration\PostgreSQL;
-
-use BitBadger\PDODocument\{Count, Delete, Field};
-use PHPUnit\Framework\Attributes\TestDox;
-use PHPUnit\Framework\TestCase;
-
-/**
- * PostgreSQL integration tests for the Delete class
- */
-#[TestDox('Delete (PostgreSQL integration)')]
-class DeleteTest extends TestCase
-{
-    /** @var string Database name for throwaway database */
-    private string $dbName;
-
-    protected function setUp(): void
-    {
-        parent::setUp();
-        $this->dbName = ThrowawayDb::create();
-    }
-
-    protected function tearDown(): void
-    {
-        ThrowawayDb::destroy($this->dbName);
-        parent::tearDown();
-    }
-
-    #[TestDox('byId() succeeds when a document is deleted')]
-    public function testByIdSucceedsWhenADocumentIsDeleted(): void
-    {
-        $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start');
-        Delete::byId(ThrowawayDb::TABLE, 'four');
-        $this->assertEquals(4, Count::all(ThrowawayDb::TABLE), 'There should have been 4 documents remaining');
-    }
-
-    #[TestDox('byId() succeeds when a document is not deleted')]
-    public function testByIdSucceedsWhenADocumentIsNotDeleted(): void
-    {
-        $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start');
-        Delete::byId(ThrowawayDb::TABLE, 'negative four');
-        $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents remaining');
-    }
-
-    #[TestDox('byFields() succeeds when documents are deleted')]
-    public function testByFieldsSucceedsWhenDocumentsAreDeleted(): void
-    {
-        $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start');
-        Delete::byFields(ThrowawayDb::TABLE, [Field::notEqual('value', 'purple')]);
-        $this->assertEquals(2, Count::all(ThrowawayDb::TABLE), 'There should have been 2 documents remaining');
-    }
-
-    #[TestDox('byFields() succeeds when documents are not deleted')]
-    public function testByFieldsSucceedsWhenDocumentsAreNotDeleted(): void
-    {
-        $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start');
-        Delete::byFields(ThrowawayDb::TABLE, [Field::equal('value', 'crimson')]);
-        $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents remaining');
-    }
-
-    #[TestDox('byContains() succeeds when documents are deleted')]
-    public function testByContainsSucceedsWhenDocumentsAreDeleted(): void
-    {
-        $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start');
-        Delete::byContains(ThrowawayDb::TABLE, ['value' => 'purple']);
-        $this->assertEquals(3, Count::all(ThrowawayDb::TABLE), 'There should have been 3 documents remaining');
-    }
-
-    #[TestDox('byContains() succeeds when documents are not deleted')]
-    public function testByContainsSucceedsWhenDocumentsAreNotDeleted(): void
-    {
-        $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start');
-        Delete::byContains(ThrowawayDb::TABLE, ['target' => 'acquired']);
-        $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents remaining');
-    }
-
-    #[TestDox('byJsonPath() succeeds when documents are deleted')]
-    public function testByJsonPathSucceedsWhenDocumentsAreDeleted(): void
-    {
-        $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start');
-        Delete::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ <> 0)');
-        $this->assertEquals(1, Count::all(ThrowawayDb::TABLE), 'There should have been 1 document remaining');
-    }
-
-    #[TestDox('byJsonPath() succeeds when documents are not deleted')]
-    public function testByJsonPathSucceedsWhenDocumentsAreNotDeleted(): void
-    {
-        $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start');
-        Delete::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ < 0)');
-        $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents remaining');
-    }
-}

tests/integration/postgresql/DocumentListTest.php

@@ -1,135 +0,0 @@
-<?php
-/**
- * @author Daniel J. Summers <daniel@bitbadger.solutions>
- * @license MIT
- */
-
-declare(strict_types=1);
-
-namespace Test\Integration\PostgreSQL;
-
-use BitBadger\PDODocument\{DocumentException, DocumentList, Query};
-use BitBadger\PDODocument\Mapper\DocumentMapper;
-use PHPUnit\Framework\Attributes\TestDox;
-use PHPUnit\Framework\TestCase;
-use Test\Integration\TestDocument;
-
-/**
- * PostgreSQL integration tests for the DocumentList class
- */
-#[TestDox('DocumentList (PostgreSQL integration)')]
-class DocumentListTest extends TestCase
-{
-    /** @var string Database name for throwaway database */
-    private string $dbName;
-
-    protected function setUp(): void
-    {
-        parent::setUp();
-        $this->dbName = ThrowawayDb::create();
-    }
-
-    protected function tearDown(): void
-    {
-        ThrowawayDb::destroy($this->dbName);
-        parent::tearDown();
-    }
-
-    #[TestDox('create() succeeds')]
-    public function testCreateSucceeds(): void
-    {
-        $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
-            new DocumentMapper(TestDocument::class));
-        $this->assertNotNull($list, 'There should have been a document list created');
-        $list = null;
-    }
-
-    #[TestDox('items succeeds')]
-    public function testItemsSucceeds(): void
-    {
-        $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
-            new DocumentMapper(TestDocument::class));
-        $this->assertNotNull($list, 'There should have been a document list created');
-        $count = 0;
-        foreach ($list->items as $item) {
-            $this->assertContains($item->id, ['one', 'two', 'three', 'four', 'five'],
-                'An unexpected document ID was returned');
-            $count++;
-        }
-        $this->assertEquals(5, $count, 'There should have been 5 documents returned');
-    }
-
-    #[TestDox('items fails when already consumed')]
-    public function testItemsFailsWhenAlreadyConsumed(): void
-    {
-        $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
-            new DocumentMapper(TestDocument::class));
-        $this->assertNotNull($list, 'There should have been a document list created');
-        $this->assertTrue($list->hasItems, 'There should be items in the list');
-        $ignored = iterator_to_array($list->items);
-        $this->assertFalse($list->hasItems, 'The list should no longer have items');
-        $this->expectException(DocumentException::class);
-        iterator_to_array($list->items);
-    }
-
-    #[TestDox('hasItems succeeds with empty results')]
-    public function testHasItemsSucceedsWithEmptyResults(): void
-    {
-        $list = DocumentList::create(
-            Query::selectFromTable(ThrowawayDb::TABLE) . " WHERE (data->>'num_value')::numeric < 0", [],
-            new DocumentMapper(TestDocument::class));
-        $this->assertNotNull($list, 'There should have been a document list created');
-        $this->assertFalse($list->hasItems, 'There should be no items in the list');
-    }
-
-    #[TestDox('hasItems succeeds with non-empty results')]
-    public function testHasItemsSucceedsWithNonEmptyResults(): void
-    {
-        $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
-            new DocumentMapper(TestDocument::class));
-        $this->assertNotNull($list, 'There should have been a document list created');
-        $this->assertTrue($list->hasItems, 'There should be items in the list');
-        foreach ($list->items as $ignored) {
-            $this->assertTrue($list->hasItems, 'There should be items remaining in the list');
-        }
-        $this->assertFalse($list->hasItems, 'There should be no remaining items in the list');
-    }
-
-    #[TestDox('map() succeeds')]
-    public function testMapSucceeds(): void
-    {
-        $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
-            new DocumentMapper(TestDocument::class));
-        $this->assertNotNull($list, 'There should have been a document list created');
-        $this->assertTrue($list->hasItems, 'There should be items in the list');
-        foreach ($list->map(fn($doc) => strrev($doc->id)) as $mapped) {
-            $this->assertContains($mapped, ['eno', 'owt', 'eerht', 'ruof', 'evif'],
-                'An unexpected mapped value was returned');
-        }
-    }
-
-    #[TestDox('iter() succeeds')]
-    public function testIterSucceeds(): void
-    {
-        $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
-            new DocumentMapper(TestDocument::class));
-        $this->assertNotNull($list, 'There should have been a document list created');
-        $this->assertTrue($list->hasItems, 'There should be items in the list');
-        $splats = [];
-        $list->iter(function ($doc) use (&$splats) { $splats[] = str_repeat('*', strlen($doc->id)); });
-        $this->assertEquals('*** *** ***** **** ****', implode(' ', $splats),
-            'Iteration did not have the expected result');
-    }
-
-    #[TestDox('mapToArray() succeeds')]
-    public function testMapToArraySucceeds(): void
-    {
-        $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
-            new DocumentMapper(TestDocument::class));
-        $this->assertNotNull($list, 'There should have been a document list created');
-        $this->assertTrue($list->hasItems, 'There should be items in the list');
-        $lookup   = $list->mapToArray(fn($it) => $it->id, fn($it) => $it->value);
-        $expected = ['one' => 'FIRST!', 'two' => 'another', 'three' => '', 'four' => 'purple', 'five' => 'purple'];
-        $this->assertEquals($expected, $lookup, 'The array was not mapped correctly');
-    }
-}

tests/integration/postgresql/DocumentTest.php

@@ -1,319 +0,0 @@
-<?php
-/**
- * @author Daniel J. Summers <daniel@bitbadger.solutions>
- * @license MIT
- */
-
-declare(strict_types=1);
-
-namespace Test\Integration\PostgreSQL;
-
-use BitBadger\PDODocument\{AutoId, Configuration, Custom, Document, DocumentException, Field, Find, Query};
-use BitBadger\PDODocument\Mapper\ArrayMapper;
-use PHPUnit\Framework\Attributes\TestDox;
-use PHPUnit\Framework\TestCase;
-use Test\Integration\{NumDocument, SubDocument, TestDocument};
-
-/**
- * PostgreSQL integration tests for the Document class
- */
-#[TestDox('Document (PostgreSQL integration)')]
-class DocumentTest extends TestCase
-{
-    /** @var string Database name for throwaway database */
-    private string $dbName;
-
-    protected function setUp(): void
-    {
-        parent::setUp();
-        $this->dbName = ThrowawayDb::create();
-    }
-
-    protected function tearDown(): void
-    {
-        ThrowawayDb::destroy($this->dbName);
-        parent::tearDown();
-    }
-
-    #[TestDox('insert() succeeds for array no auto ID')]
-    public function testInsertSucceedsForArrayNoAutoId(): void
-    {
-        Document::insert(ThrowawayDb::TABLE, ['id' => 'turkey', 'sub' => ['foo' => 'gobble', 'bar' => 'gobble']]);
-        $tryDoc = Find::byId(ThrowawayDb::TABLE, 'turkey', TestDocument::class);
-        $this->assertTrue($tryDoc->isSome, 'There should have been a document inserted');
-        $doc = $tryDoc->value;
-        $this->assertEquals('turkey', $doc->id, 'The ID was incorrect');
-        $this->assertEquals('', $doc->value, 'The value was incorrect');
-        $this->assertEquals(0, $doc->num_value, 'The numeric value was incorrect');
-        $this->assertNotNull($doc->sub, 'The sub-document should not have been null');
-        $this->assertEquals('gobble', $doc->sub->foo, 'The sub-document foo property was incorrect');
-        $this->assertEquals('gobble', $doc->sub->bar, 'The sub-document bar property was incorrect');
-    }
-
-    #[TestDox('insert() succeeds for array with auto number ID not provided')]
-    public function testInsertSucceedsForArrayWithAutoNumberIdNotProvided(): void
-    {
-        Configuration::$autoId = AutoId::Number;
-        try {
-            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
-
-            Document::insert(ThrowawayDb::TABLE, ['id' => 0, 'value' => 'new', 'num_value' => 8]);
-            $doc = Custom::single('SELECT data FROM ' . ThrowawayDb::TABLE, [], new ArrayMapper());
-            $this->assertTrue($doc->isSome, 'There should have been a document returned');
-            $obj = json_decode($doc->value['data']);
-            $this->assertEquals(1, $obj->id, 'The ID 1 should have been auto-generated');
-
-            Document::insert(ThrowawayDb::TABLE, ['id' => 0, 'value' => 'again', 'num_value' => 7]);
-            $doc = Custom::single('SELECT data FROM ' . ThrowawayDb::TABLE . " WHERE " . Query::whereById(docId: 2),
-                [':id' => 2], new ArrayMapper());
-            $this->assertTrue($doc->isSome, 'There should have been a document returned');
-            $obj = json_decode($doc->value['data']);
-            $this->assertEquals(2, $obj->id, 'The ID 2 should have been auto-generated');
-        } finally {
-            Configuration::$autoId = AutoId::None;
-        }
-    }
-
-    #[TestDox('insert() succeeds for array with auto number ID with ID provided')]
-    public function testInsertSucceedsForArrayWithAutoNumberIdWithIdProvided(): void
-    {
-        Configuration::$autoId = AutoId::Number;
-        try {
-            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
-            Document::insert(ThrowawayDb::TABLE, ['id' => 7, 'value' => 'new', 'num_value' => 8]);
-            $doc = Custom::single('SELECT data FROM ' . ThrowawayDb::TABLE, [], new ArrayMapper());
-            $this->assertTrue($doc->isSome, 'There should have been a document returned');
-            $obj = json_decode($doc->value['data']);
-            $this->assertEquals(7, $obj->id, 'The ID 7 should have been stored');
-        } finally {
-            Configuration::$autoId = AutoId::None;
-        }
-    }
-
-    #[TestDox('insert() succeeds for array with auto UUID ID not provided')]
-    public function testInsertSucceedsForArrayWithAutoUuidIdNotProvided(): void
-    {
-        Configuration::$autoId = AutoId::UUID;
-        try {
-            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
-            Document::insert(ThrowawayDb::TABLE, ['id' => '', 'num_value' => 5]);
-            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 5)], TestDocument::class);
-            $this->assertTrue($doc->isSome, 'There should have been a document returned');
-            $this->assertNotEmpty($doc->value->id, 'The ID should have been auto-generated');
-        } finally {
-            Configuration::$autoId = AutoId::None;
-        }
-    }
-
-    #[TestDox('insert() succeeds for array with auto UUID ID with ID provided')]
-    public function testInsertSucceedsForArrayWithAutoUuidIdWithIdProvided(): void
-    {
-        Configuration::$autoId = AutoId::UUID;
-        try {
-            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
-            $uuid = AutoId::generateUUID();
-            Document::insert(ThrowawayDb::TABLE, ['id' => $uuid, 'value' => 'uuid', 'num_value' => 12]);
-            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 12)], TestDocument::class);
-            $this->assertTrue($doc->isSome, 'There should have been a document returned');
-            $this->assertEquals($uuid, $doc->value->id, 'The ID should not have been changed');
-        } finally {
-            Configuration::$autoId = AutoId::None;
-        }
-    }
-
-    #[TestDox('insert() succeeds for array with auto string ID not provided')]
-    public function testInsertSucceedsForArrayWithAutoStringIdNotProvided(): void
-    {
-        Configuration::$autoId         = AutoId::RandomString;
-        Configuration::$idStringLength = 6;
-        try {
-            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
-            Document::insert(ThrowawayDb::TABLE, ['id' => '', 'value' => 'new', 'num_value' => 8]);
-            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 8)], TestDocument::class);
-            $this->assertTrue($doc->isSome, 'There should have been a document returned');
-            $this->assertEquals(6, strlen($doc->value->id),
-                'The ID should have been auto-generated and had 6 characters');
-        } finally {
-            Configuration::$autoId         = AutoId::None;
-            Configuration::$idStringLength = 16;
-        }
-    }
-
-    #[TestDox('insert() succeeds for array with auto string ID with ID provided')]
-    public function testInsertSucceedsForArrayWithAutoStringIdWithIdProvided(): void
-    {
-        Configuration::$autoId = AutoId::RandomString;
-        try {
-            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
-            Document::insert(ThrowawayDb::TABLE, ['id' => 'my-key', 'value' => 'old', 'num_value' => 3]);
-            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 3)], TestDocument::class);
-            $this->assertTrue($doc->isSome, 'There should have been a document returned');
-            $this->assertEquals('my-key', $doc->value->id, 'The ID should not have been changed');
-        } finally {
-            Configuration::$autoId = AutoId::None;
-        }
-    }
-
-    #[TestDox('insert() succeeds for object no auto ID')]
-    public function testInsertSucceedsForObjectNoAutoId(): void
-    {
-        Document::insert(ThrowawayDb::TABLE, new TestDocument('turkey', sub: new SubDocument('gobble', 'gobble')));
-        $tryDoc = Find::byId(ThrowawayDb::TABLE, 'turkey', TestDocument::class);
-        $this->assertTrue($tryDoc->isSome, 'There should have been a document inserted');
-        $doc = $tryDoc->value;
-        $this->assertEquals('turkey', $doc->id, 'The ID was incorrect');
-        $this->assertEquals('', $doc->value, 'The value was incorrect');
-        $this->assertEquals(0, $doc->num_value, 'The numeric value was incorrect');
-        $this->assertNotNull($doc->sub, 'The sub-document should not have been null');
-        $this->assertEquals('gobble', $doc->sub->foo, 'The sub-document foo property was incorrect');
-        $this->assertEquals('gobble', $doc->sub->bar, 'The sub-document bar property was incorrect');
-    }
-
-    #[TestDox('insert() succeeds for object with auto number ID not provided')]
-    public function testInsertSucceedsForObjectWithAutoNumberIdNotProvided(): void
-    {
-        Configuration::$autoId = AutoId::Number;
-        try {
-            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
-
-            Document::insert(ThrowawayDb::TABLE, new NumDocument(value: 'taco'));
-            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('value', 'taco')], NumDocument::class);
-            $this->assertTrue($doc->isSome, 'There should have been a document returned');
-            $this->assertEquals(1, $doc->value->id, 'The ID 1 should have been auto-generated');
-
-            Document::insert(ThrowawayDb::TABLE, new NumDocument(value: 'burrito'));
-            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('value', 'burrito')], NumDocument::class);
-            $this->assertTrue($doc->isSome, 'There should have been a document returned');
-            $this->assertEquals(2, $doc->value->id, 'The ID 2 should have been auto-generated');
-        } finally {
-            Configuration::$autoId = AutoId::None;
-        }
-    }
-
-    #[TestDox('insert() succeeds for object with auto number ID with ID provided')]
-    public function testInsertSucceedsForObjectWithAutoNumberIdWithIdProvided(): void
-    {
-        Configuration::$autoId = AutoId::Number;
-        try {
-            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
-            Document::insert(ThrowawayDb::TABLE, new NumDocument(64, 'large'));
-            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('value', 'large')], NumDocument::class);
-            $this->assertTrue($doc->isSome, 'There should have been a document returned');
-            $this->assertEquals(64, $doc->value->id, 'The ID 64 should have been stored');
-        } finally {
-            Configuration::$autoId = AutoId::None;
-        }
-    }
-
-    #[TestDox('insert() succeeds for object with auto UUID ID not provided')]
-    public function testInsertSucceedsForObjectWithAutoUuidIdNotProvided(): void
-    {
-        Configuration::$autoId = AutoId::UUID;
-        try {
-            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
-            Document::insert(ThrowawayDb::TABLE, new TestDocument(value: 'something', num_value: 9));
-            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::exists('value')], TestDocument::class);
-            $this->assertTrue($doc->isSome, 'There should have been a document returned');
-            $this->assertNotEmpty($doc->value->id, 'The ID should have been auto-generated');
-        } finally {
-            Configuration::$autoId = AutoId::None;
-        }
-    }
-
-    #[TestDox('insert() succeeds for object with auto UUID ID with ID provided')]
-    public function testInsertSucceedsForObjectWithAutoUuidIdWithIdProvided(): void
-    {
-        Configuration::$autoId = AutoId::UUID;
-        try {
-            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
-            $uuid = AutoId::generateUUID();
-            Document::insert(ThrowawayDb::TABLE, new TestDocument($uuid, num_value: 14));
-            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 14)], TestDocument::class);
-            $this->assertTrue($doc->isSome, 'There should have been a document returned');
-            $this->assertEquals($uuid, $doc->value->id, 'The ID should not have been changed');
-        } finally {
-            Configuration::$autoId = AutoId::None;
-        }
-    }
-
-    #[TestDox('insert() succeeds for object with auto string ID not provided')]
-    public function testInsertSucceedsForObjectWithAutoStringIdNotProvided(): void
-    {
-        Configuration::$autoId         = AutoId::RandomString;
-        Configuration::$idStringLength = 40;
-        try {
-            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
-            Document::insert(ThrowawayDb::TABLE, new TestDocument(num_value: 55));
-            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 55)], TestDocument::class);
-            $this->assertTrue($doc->isSome, 'There should have been a document returned');
-            $this->assertEquals(40, strlen($doc->value->id),
-                'The ID should have been auto-generated and had 40 characters');
-        } finally {
-            Configuration::$autoId         = AutoId::None;
-            Configuration::$idStringLength = 16;
-        }
-    }
-
-    #[TestDox('insert() succeeds for object with auto string ID with ID provided')]
-    public function testInsertSucceedsForObjectWithAutoStringIdWithIdProvided(): void
-    {
-        Configuration::$autoId = AutoId::RandomString;
-        try {
-            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
-            Document::insert(ThrowawayDb::TABLE, new TestDocument('my-key', num_value: 3));
-            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 3)], TestDocument::class);
-            $this->assertTrue($doc->isSome, 'There should have been a document returned');
-            $this->assertEquals('my-key', $doc->value->id, 'The ID should not have been changed');
-        } finally {
-            Configuration::$autoId = AutoId::None;
-        }
-    }
-
-    #[TestDox('insert() fails for duplicate key')]
-    public function testInsertFailsForDuplicateKey(): void
-    {
-        $this->expectException(DocumentException::class);
-        Document::insert(ThrowawayDb::TABLE, new TestDocument('one'));
-    }
-
-    #[TestDox('save() succeeds when a document is inserted')]
-    public function testSaveSucceedsWhenADocumentIsInserted(): void
-    {
-        Document::save(ThrowawayDb::TABLE, new TestDocument('test', sub: new SubDocument('a', 'b')));
-        $doc = Find::byId(ThrowawayDb::TABLE, 'one', TestDocument::class);
-        $this->assertTrue($doc->isSome, 'There should have been a document returned');
-    }
-
-    #[TestDox('save() succeeds when a document is updated')]
-    public function testSaveSucceedsWhenADocumentIsUpdated(): void
-    {
-        Document::save(ThrowawayDb::TABLE, new TestDocument('two', num_value: 44));
-        $tryDoc = Find::byId(ThrowawayDb::TABLE, 'two', TestDocument::class);
-        $this->assertTrue($tryDoc->isSome, 'There should have been a document returned');
-        $doc = $tryDoc->value;
-        $this->assertEquals(44, $doc->num_value, 'The numeric value was not updated');
-        $this->assertNull($doc->sub, 'The sub-document should have been null');
-    }
-
-    #[TestDox('update() succeeds when replacing a document')]
-    public function testUpdateSucceedsWhenReplacingADocument(): void
-    {
-        Document::update(ThrowawayDb::TABLE, 'one', new TestDocument('one', 'howdy', 8, new SubDocument('y', 'z')));
-        $tryDoc = Find::byId(ThrowawayDb::TABLE, 'one', TestDocument::class);
-        $this->assertNotFalse($tryDoc->isSome, 'There should have been a document returned');
-        $doc = $tryDoc->value;
-        $this->assertEquals('howdy', $doc->value, 'The value was incorrect');
-        $this->assertEquals(8, $doc->num_value, 'The numeric value was incorrect');
-        $this->assertNotNull($doc->sub, 'The sub-document should not have been null');
-        $this->assertEquals('y', $doc->sub->foo, 'The sub-document foo property was incorrect');
-        $this->assertEquals('z', $doc->sub->bar, 'The sub-document bar property was incorrect');
-    }
-
-    #[TestDox('update() succeeds when no document is replaced')]
-    public function testUpdateSucceedsWhenNoDocumentIsReplaced(): void
-    {
-        Document::update(ThrowawayDb::TABLE, 'two-hundred', new TestDocument('200'));
-        $doc = Find::byId(ThrowawayDb::TABLE, 'two-hundred', TestDocument::class);
-        $this->assertTrue($doc->isNone, 'There should not have been a document returned');
-    }
-}

tests/integration/postgresql/ExistsTest.php

@@ -1,90 +0,0 @@
-<?php
-/**
- * @author Daniel J. Summers <daniel@bitbadger.solutions>
- * @license MIT
- */
-
-declare(strict_types=1);
-
-namespace Test\Integration\PostgreSQL;
-
-use BitBadger\PDODocument\{Exists, Field};
-use PHPUnit\Framework\Attributes\TestDox;
-use PHPUnit\Framework\TestCase;
-
-/**
- * PostgreSQL integration tests for the Exists class
- */
-#[TestDox('Exists (PostgreSQL integration)')]
-class ExistsTest extends TestCase
-{
-    /** @var string Database name for throwaway database */
-    private string $dbName;
-
-    protected function setUp(): void
-    {
-        parent::setUp();
-        $this->dbName = ThrowawayDb::create();
-    }
-
-    protected function tearDown(): void
-    {
-        ThrowawayDb::destroy($this->dbName);
-        parent::tearDown();
-    }
-
-    #[TestDox('byId() succeeds when a document exists')]
-    public function testByIdSucceedsWhenADocumentExists(): void
-    {
-        $this->assertTrue(Exists::byId(ThrowawayDb::TABLE, 'three'), 'There should have been an existing document');
-    }
-
-    #[TestDox('byId() succeeds when a document does not exist')]
-    public function testByIdSucceedsWhenADocumentDoesNotExist(): void
-    {
-        $this->assertFalse(Exists::byId(ThrowawayDb::TABLE, 'seven'),
-            'There should not have been an existing document');
-    }
-
-    #[TestDox('byFields() succeeds when documents exist')]
-    public function testByFieldsSucceedsWhenDocumentsExist(): void
-    {
-        $this->assertTrue(Exists::byFields(ThrowawayDb::TABLE, [Field::equal('num_value', 10)]),
-            'There should have been existing documents');
-    }
-
-    #[TestDox('byFields() succeeds when no matching documents exist')]
-    public function testByFieldsSucceedsWhenNoMatchingDocumentsExist(): void
-    {
-        $this->assertFalse(Exists::byFields(ThrowawayDb::TABLE, [Field::less('nothing', 'none')]),
-            'There should not have been any existing documents');
-    }
-
-    #[TestDox('byContains() succeeds when documents exist')]
-    public function testByContainsSucceedsWhenDocumentsExist(): void
-    {
-        $this->assertTrue(Exists::byContains(ThrowawayDb::TABLE, ['value' => 'purple']),
-            'There should have been existing documents');
-    }
-
-    #[TestDox('byContains() succeeds when no matching documents exist')]
-    public function testByContainsSucceedsWhenNoMatchingDocumentsExist(): void
-    {
-        $this->assertFalse(Exists::byContains(ThrowawayDb::TABLE, ['value' => 'violet']),
-            'There should not have been existing documents');
-    }
-
-    #[TestDox('byJsonPath() succeeds when documents exist')]
-    public function testByJsonPathSucceedsWhenDocumentsExist(): void
-    {
-        $this->assertTrue(Exists::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ == 10)'),
-            'There should have been existing documents');
-    }
-
-    #[TestDox('byJsonPath() succeeds when no matching documents exist')]
-    public function testByJsonPathSucceedsWhenNoMatchingDocumentsExist(): void
-    {
-        $this->assertFalse(Exists::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ == 10.1)'),
-            'There should have been existing documents');
-    }
-}

tests/integration/postgresql/FindTest.php

@@ -1,335 +0,0 @@
-<?php
-/**
- * @author Daniel J. Summers <daniel@bitbadger.solutions>
- * @license MIT
- */
-
-declare(strict_types=1);
-
-namespace Test\Integration\PostgreSQL;
-
-use BitBadger\PDODocument\{Custom, Delete, Document, Field, FieldMatch, Find};
-use PHPUnit\Framework\Attributes\TestDox;
-use PHPUnit\Framework\TestCase;
-use Test\Integration\{ArrayDocument, NumDocument, TestDocument};
-
-/**
- * PostgreSQL integration tests for the Find class
- */
-#[TestDox('Find (PostgreSQL integration)')]
-class FindTest extends TestCase
-{
-    /** @var string Database name for throwaway database */
-    private string $dbName;
-
-    protected function setUp(): void
-    {
-        parent::setUp();
-        $this->dbName = ThrowawayDb::create();
-    }
-
-    protected function tearDown(): void
-    {
-        ThrowawayDb::destroy($this->dbName);
-        parent::tearDown();
-    }
-
-    #[TestDox('all() succeeds when there is data')]
-    public function testAllSucceedsWhenThereIsData(): void
-    {
-        $docs = Find::all(ThrowawayDb::TABLE, TestDocument::class);
-        $this->assertNotNull($docs, 'There should have been a document list returned');
-        $this->assertTrue($docs->hasItems, 'There should have been documents in the list');
-        $count = 0;
-        foreach ($docs->items as $ignored) $count++;
-        $this->assertEquals(5, $count, 'There should have been 5 documents in the list');
-    }
-
-    #[TestDox('all() succeeds when ordering data ascending')]
-    public function testAllSucceedsWhenOrderingDataAscending(): void
-    {
-        $docs = Find::all(ThrowawayDb::TABLE, TestDocument::class, [Field::named('id')]);
-        $this->assertNotNull($docs, 'There should have been a document list returned');
-        $this->assertTrue($docs->hasItems, 'There should have been documents in the list');
-        $ids = iterator_to_array($docs->map(fn ($it) => $it->id), false);
-        $this->assertEquals(['five', 'four', 'one', 'three', 'two'], $ids, 'The documents were not ordered correctly');
-    }
-
-    #[TestDox('all() succeeds when ordering data descending')]
-    public function testAllSucceedsWhenOrderingDataDescending(): void
-    {
-        $docs = Find::all(ThrowawayDb::TABLE, TestDocument::class, [Field::named('id DESC')]);
-        $this->assertNotNull($docs, 'There should have been a document list returned');
-        $this->assertTrue($docs->hasItems, 'There should have been documents in the list');
-        $ids = iterator_to_array($docs->map(fn ($it) => $it->id), false);
-        $this->assertEquals(['two', 'three', 'one', 'four', 'five'], $ids, 'The documents were not ordered correctly');
-    }
-
-    #[TestDox('all() succeeds when ordering data numerically')]
-    public function testAllSucceedsWhenOrderingDataNumerically(): void
-    {
-        $docs = Find::all(ThrowawayDb::TABLE, TestDocument::class,
-            [Field::named('sub.foo NULLS LAST'), Field::named('n:num_value')]);
-        $this->assertNotNull($docs, 'There should have been a document list returned');
-        $this->assertTrue($docs->hasItems, 'There should have been documents in the list');
-        $ids = iterator_to_array($docs->map(fn ($it) => $it->id), false);
-        $this->assertEquals(['two', 'four', 'one', 'three', 'five'], $ids, 'The documents were not ordered correctly');
-    }
-
-    #[TestDox('all() succeeds when there is no data')]
-    public function testAllSucceedsWhenThereIsNoData(): void
-    {
-        Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
-        $docs = Find::all(ThrowawayDb::TABLE, TestDocument::class);
-        $this->assertNotNull($docs, 'There should have been a document list returned');
-        $this->assertFalse($docs->hasItems, 'There should have been no documents in the list');
-    }
-
-    #[TestDox('byId() succeeds when a document is found')]
-    public function testByIdSucceedsWhenADocumentIsFound(): void
-    {
-        $doc = Find::byId(ThrowawayDb::TABLE, 'two', TestDocument::class);
-        $this->assertTrue($doc->isSome, 'There should have been a document returned');
-        $this->assertEquals('two', $doc->value->id, 'An incorrect document was returned');
-    }
-
-    #[TestDox('byId() succeeds when a document is found with numeric ID')]
-    public function testByIdSucceedsWhenADocumentIsFoundWithNumericId(): void
-    {
-        Delete::byFields(ThrowawayDb::TABLE, [Field::notExists('absent')]);
-        Document::insert(ThrowawayDb::TABLE, ['id' => 18, 'value' => 'howdy']);
-        $doc = Find::byId(ThrowawayDb::TABLE, 18, NumDocument::class);
-        $this->assertTrue($doc->isSome, 'There should have been a document returned');
-        $this->assertEquals(18, $doc->value->id, 'An incorrect document was returned');
-    }
-
-    #[TestDox('byId() succeeds when a document is not found')]
-    public function testByIdSucceedsWhenADocumentIsNotFound(): void
-    {
-        $doc = Find::byId(ThrowawayDb::TABLE, 'seventy-five', TestDocument::class);
-        $this->assertTrue($doc->isNone, 'There should not have been a document returned');
-    }
-
-    #[TestDox('byFields() succeeds when documents are found')]
-    public function testByFieldsSucceedsWhenDocumentsAreFound(): void
-    {
-        $docs = Find::byFields(ThrowawayDb::TABLE, [Field::in('value', ['blue', 'purple']), Field::exists('sub')],
-            TestDocument::class, FieldMatch::All);
-        $this->assertNotNull($docs, 'There should have been a document list returned');
-        $this->assertTrue($docs->hasItems, 'There should have been documents in the list');
-        $count = 0;
-        foreach ($docs->items as $ignored) $count++;
-        $this->assertEquals(1, $count, 'There should have been 1 document in the list');
-    }
-
-    #[TestDox('byFields() succeeds when documents are found and ordered')]
-    public function testByFieldsSucceedsWhenDocumentsAreFoundAndOrdered(): void
-    {
-        $docs = Find::byFields(ThrowawayDb::TABLE, [Field::equal('value', 'purple')], TestDocument::class,
-            FieldMatch::All, [Field::named('id')]);
-        $this->assertNotNull($docs, 'There should have been a document list returned');
-        $this->assertTrue($docs->hasItems, 'There should have been documents in the list');
-        $ids = iterator_to_array($docs->map(fn ($it) => $it->id), false);
-        $this->assertEquals(['five', 'four'], $ids, 'The documents were not ordered correctly');
-    }
-
-    #[TestDox('byFields() succeeds when documents are found using IN with numeric field')]
-    public function testByFieldsSucceedsWhenDocumentsAreFoundUsingInWithNumericField(): void
-    {
-        $docs = Find::byFields(ThrowawayDb::TABLE, [Field::in('num_value', [2, 4, 6, 8])], TestDocument::class);
-        $this->assertNotNull($docs, 'There should have been a document list returned');
-        $this->assertTrue($docs->hasItems, 'There should have been documents in the list');
-        $count = 0;
-        foreach ($docs->items as $ignored) $count++;
-        $this->assertEquals(1, $count, 'There should have been 1 document in the list');
-    }
-
-    #[TestDox('byFields() succeeds when no documents are found')]
-    public function testByFieldsSucceedsWhenNoDocumentsAreFound(): void
-    {
-        $docs = Find::byFields(ThrowawayDb::TABLE, [Field::greater('num_value', 100)], TestDocument::class);
-        $this->assertNotNull($docs, 'There should have been a document list returned');
-        $this->assertFalse($docs->hasItems, 'There should have been no documents in the list');
-    }
-
-    #[TestDox('byFields() succeeds for inArray when matching documents exist')]
-    public function testByFieldsSucceedsForInArrayWhenMatchingDocumentsExist(): void
-    {
-        Delete::byFields(ThrowawayDb::TABLE, [Field::notExists('absentField')]);
-        foreach (ArrayDocument::testDocuments() as $doc) Document::insert(ThrowawayDb::TABLE, $doc);
-        $docs = Find::byFields(ThrowawayDb::TABLE, [Field::inArray('values', ThrowawayDb::TABLE, ['c'])],
-            ArrayDocument::class);
-        $this->assertNotNull($docs, 'There should have been a document list returned');
-        $this->assertTrue($docs->hasItems, 'There should have been documents in the list');
-        $count = 0;
-        foreach ($docs->items as $ignored) $count++;
-        $this->assertEquals(2, $count, 'There should have been 2 documents in the list');
-    }
-
-    #[TestDox('byFields() succeeds for inArray when no matching documents exist')]
-    public function testByFieldsSucceedsForInArrayWhenNoMatchingDocumentsExist(): void
-    {
-        Delete::byFields(ThrowawayDb::TABLE, [Field::notExists('absentField')]);
-        foreach (ArrayDocument::testDocuments() as $doc) Document::insert(ThrowawayDb::TABLE, $doc);
-        $docs = Find::byFields(ThrowawayDb::TABLE, [Field::inArray('values', ThrowawayDb::TABLE, ['j'])],
-            ArrayDocument::class);
-        $this->assertNotNull($docs, 'There should have been a document list returned');
-        $this->assertFalse($docs->hasItems, 'There should have been no documents in the list');
-    }
-
-    #[TestDox('byContains() succeeds when documents are found')]
-    public function testByContainsSucceedsWhenDocumentsAreFound(): void
-    {
-        $docs = Find::byContains(ThrowawayDb::TABLE, ['value' => 'purple'], TestDocument::class);
-        $this->assertNotNull($docs, 'There should have been a document list returned');
-        $this->assertTrue($docs->hasItems, 'There should have been documents in the list');
-        $count = 0;
-        foreach ($docs->items as $ignored) $count++;
-        $this->assertEquals(2, $count, 'There should have been 2 documents in the list');
-    }
-
-    #[TestDox('byContains() succeeds when documents are found and ordered')]
-    public function testByContainsSucceedsWhenDocumentsAreFoundAndOrdered(): void
-    {
-        $docs = Find::byContains(ThrowawayDb::TABLE, ['sub' => ['foo' => 'green']], TestDocument::class,
-            [Field::named('value')]);
-        $this->assertNotNull($docs, 'There should have been a document list returned');
-        $this->assertTrue($docs->hasItems, 'There should have been documents in the list');
-        $ids = iterator_to_array($docs->map(fn ($it) => $it->id), false);
-        $this->assertEquals(['two', 'four'], $ids, 'The documents were not ordered correctly');
-    }
-
-    #[TestDox('byContains() succeeds when no documents are found')]
-    public function testByContainsSucceedsWhenNoDocumentsAreFound(): void
-    {
-        $docs = Find::byContains(ThrowawayDb::TABLE, ['value' => 'indigo'], TestDocument::class);
-        $this->assertNotNull($docs, 'There should have been a document list returned');
-        $this->assertFalse($docs->hasItems, 'The document list should be empty');
-    }
-
-    #[TestDox('byJsonPath() succeeds when documents are found')]
-    public function testByJsonPathSucceedsWhenDocumentsAreFound(): void
-    {
-        $docs = Find::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ > 10)', TestDocument::class);
-        $this->assertNotNull($docs, 'There should have been a document list returned');
-        $this->assertTrue($docs->hasItems, 'There should have been documents in the list');
-        $count = 0;
-        foreach ($docs->items as $ignored) $count++;
-        $this->assertEquals(2, $count, 'There should have been 2 documents in the list');
-    }
-
-    #[TestDox('byJsonPath() succeeds when documents are found and ordered')]
-    public function testByJsonPathSucceedsWhenDocumentsAreFoundAndOrdered(): void
-    {
-        $docs = Find::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ > 10)', TestDocument::class,
-            [Field::named('id')]);
-        $this->assertNotNull($docs, 'There should have been a document list returned');
-        $this->assertTrue($docs->hasItems, 'There should have been documents in the list');
-        $ids = iterator_to_array($docs->map(fn ($it) => $it->id), false);
-        $this->assertEquals(['five', 'four'], $ids, 'The documents were not ordered correctly');
-    }
-
-    #[TestDox('byJsonPath() succeeds when no documents are found')]
-    public function testByJsonPathSucceedsWhenNoDocumentsAreFound(): void
-    {
-        $docs = Find::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ > 100)', TestDocument::class);
-        $this->assertNotNull($docs, 'There should have been a document list returned');
-        $this->assertFalse($docs->hasItems, 'The document list should be empty');
-    }
-
-    #[TestDox('firstByFields() succeeds when a document is found')]
-    public function testFirstByFieldsSucceedsWhenADocumentIsFound(): void
-    {
-        $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('value', 'another')], TestDocument::class);
-        $this->assertTrue($doc->isSome, 'There should have been a document returned');
-        $this->assertEquals('two', $doc->value->id, 'The incorrect document was returned');
-    }
-
-    #[TestDox('firstByFields() succeeds when multiple documents are found')]
-    public function testFirstByFieldsSucceedsWhenMultipleDocumentsAreFound(): void
-    {
-        $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('sub.foo', 'green')], TestDocument::class);
-        $this->assertTrue($doc->isSome, 'There should have been a document returned');
-        $this->assertContains($doc->value->id, ['two', 'four'], 'An incorrect document was returned');
-    }
-
-    #[TestDox('firstByFields() succeeds when multiple ordered documents are found')]
-    public function testFirstByFieldsSucceedsWhenMultipleOrderedDocumentsAreFound(): void
-    {
-        $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('sub.foo', 'green')], TestDocument::class,
-            orderBy: [Field::named('n:num_value DESC')]);
-        $this->assertTrue($doc->isSome, 'There should have been a document returned');
-        $this->assertEquals('four', $doc->value->id, 'The incorrect document was returned');
-    }
-
-    #[TestDox('firstByFields() succeeds when a document is not found')]
-    public function testFirstByFieldsSucceedsWhenADocumentIsNotFound(): void
-    {
-        $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('value', 'absent')], TestDocument::class);
-        $this->assertTrue($doc->isNone, 'There should not have been a document returned');
-    }
-
-    #[TestDox('firstByContains() succeeds when a document is found')]
-    public function testFirstByContainsSucceedsWhenADocumentIsFound(): void
-    {
-        $doc = Find::firstByContains(ThrowawayDb::TABLE, ['value' => 'FIRST!'], TestDocument::class);
-        $this->assertTrue($doc->isSome, 'There should have been a document returned');
-        $this->assertEquals('one', $doc->value->id, 'The incorrect document was returned');
-    }
-
-    #[TestDox('firstByContains() succeeds when multiple documents are found')]
-    public function testFirstByContainsSucceedsWhenMultipleDocumentsAreFound(): void
-    {
-        $doc = Find::firstByContains(ThrowawayDb::TABLE, ['value' => 'purple'], TestDocument::class);
-        $this->assertTrue($doc->isSome, 'There should have been a document returned');
-        $this->assertContains($doc->value->id, ['four', 'five'], 'An incorrect document was returned');
-    }
-
-    #[TestDox('firstByContains() succeeds when multiple ordered documents are found')]
-    public function testFirstByContainsSucceedsWhenMultipleOrderedDocumentsAreFound(): void
-    {
-        $doc = Find::firstByContains(ThrowawayDb::TABLE, ['value' => 'purple'], TestDocument::class,
-            [Field::named('sub.bar NULLS FIRST')]);
-        $this->assertTrue($doc->isSome, 'There should have been a document returned');
-        $this->assertEquals('five', $doc->value->id, 'The incorrect document was returned');
-    }
-
-    #[TestDox('firstByContains() succeeds when a document is not found')]
-    public function testFirstByContainsSucceedsWhenADocumentIsNotFound(): void
-    {
-        $doc = Find::firstByContains(ThrowawayDb::TABLE, ['value' => 'indigo'], TestDocument::class);
-        $this->assertTrue($doc->isNone, 'There should not have been a document returned');
-    }
-
-    #[TestDox('firstByJsonPath() succeeds when a document is found')]
-    public function testFirstByJsonPathSucceedsWhenADocumentIsFound(): void
-    {
-        $doc = Find::firstByJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ == 10)', TestDocument::class);
-        $this->assertTrue($doc->isSome, 'There should have been a document returned');
-        $this->assertEquals('two', $doc->value->id, 'The incorrect document was returned');
-    }
-
-    #[TestDox('firstByJsonPath() succeeds when multiple documents are found')]
-    public function testFirstByJsonPathSucceedsWhenMultipleDocumentsAreFound(): void
-    {
-        $doc = Find::firstByJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ > 10)', TestDocument::class);
-        $this->assertTrue($doc->isSome, 'There should have been a document returned');
-        $this->assertContains($doc->value->id, ['four', 'five'], 'An incorrect document was returned');
-    }
-
-    #[TestDox('firstByJsonPath() succeeds when multiple ordered documents are found')]
-    public function testFirstByJsonPathSucceedsWhenMultipleOrderedDocumentsAreFound(): void
-    {
-        $doc = Find::firstByJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ > 10)', TestDocument::class,
-            [Field::named('id DESC')]);
-        $this->assertTrue($doc->isSome, 'There should have been a document returned');
-        $this->assertEquals('four', $doc->value->id, 'The incorrect document was returned');
-    }
-
-    #[TestDox('firstByJsonPath() succeeds when a document is not found')]
-    public function testFirstByJsonPathSucceedsWhenADocumentIsNotFound(): void
-    {
-        $doc = Find::firstByJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ > 100)', TestDocument::class);
-        $this->assertTrue($doc->isNone, 'There should not have been a document returned');
-    }
-}

tests/integration/postgresql/PatchTest.php

@@ -1,115 +0,0 @@
-<?php
-/**
- * @author Daniel J. Summers <daniel@bitbadger.solutions>
- * @license MIT
- */
-
-declare(strict_types=1);
-
-namespace Test\Integration\PostgreSQL;
-
-use BitBadger\PDODocument\{Count, Exists, Field, Find, Patch};
-use PHPUnit\Framework\Attributes\TestDox;
-use PHPUnit\Framework\TestCase;
-use Test\Integration\TestDocument;
-
-/**
- * PostgreSQL integration tests for the Patch class
- */
-#[TestDox('Patch (PostgreSQL integration)')]
-class PatchTest extends TestCase
-{
-    /** @var string Database name for throwaway database */
-    private string $dbName;
-
-    protected function setUp(): void
-    {
-        parent::setUp();
-        $this->dbName = ThrowawayDb::create();
-    }
-
-    protected function tearDown(): void
-    {
-        ThrowawayDb::destroy($this->dbName);
-        parent::tearDown();
-    }
-
-    #[TestDox('byId() succeeds when a document is updated')]
-    public function testByIdSucceedsWhenADocumentIsUpdated(): void
-    {
-        Patch::byId(ThrowawayDb::TABLE, 'one', ['num_value' => 44]);
-        $doc = Find::byId(ThrowawayDb::TABLE, 'one', TestDocument::class);
-        $this->assertTrue($doc->isSome, 'There should have been a document returned');
-        $this->assertEquals(44, $doc->value->num_value, 'The updated document is not correct');
-    }
-
-    #[TestDox('byId() succeeds when no document is updated')]
-    public function testByIdSucceedsWhenNoDocumentIsUpdated(): void
-    {
-        $id = 'forty-seven';
-        $this->assertFalse(Exists::byId(ThrowawayDb::TABLE, $id), 'The document should not exist');
-        Patch::byId(ThrowawayDb::TABLE, $id, ['foo' => 'green']);
-        $this->assertTrue(true, 'The above not throwing an exception is the test');
-    }
-
-    #[TestDox('byFields() succeeds when a document is updated')]
-    public function testByFieldsSucceedsWhenADocumentIsUpdated(): void
-    {
-        Patch::byFields(ThrowawayDb::TABLE, [Field::equal('value', 'purple')], ['num_value' => 77]);
-        $after = Count::byFields(ThrowawayDb::TABLE, [Field::equal('num_value', 77)]);
-        $this->assertEquals(2, $after, 'There should have been 2 documents updated');
-    }
-
-    #[TestDox('byFields() succeeds when no document is updated')]
-    public function testByFieldsSucceedsWhenNoDocumentIsUpdated(): void
-    {
-        $fields = [Field::equal('value', 'burgundy')];
-        $this->assertEquals(0, Count::byFields(ThrowawayDb::TABLE, $fields), 'There should be no matching documents');
-        Patch::byFields(ThrowawayDb::TABLE, $fields, ['foo' => 'green']);
-        $this->assertTrue(true, 'The above not throwing an exception is the test');
-    }
-
-    #[TestDox('byContains() succeeds when documents are updated')]
-    public function testByContainsSucceedsWhenDocumentsAreUpdated(): void
-    {
-        Patch::byContains(ThrowawayDb::TABLE, ['value' => 'another'], ['num_value' => 12]);
-        $tryDoc = Find::firstByContains(ThrowawayDb::TABLE, ['value' => 'another'], TestDocument::class);
-        $this->assertTrue($tryDoc->isSome, 'There should have been a document returned');
-        $doc = $tryDoc->value;
-        $this->assertEquals('two', $doc->id, 'An incorrect document was returned');
-        $this->assertEquals(12, $doc->num_value, 'The document was not patched');
-    }
-
-    #[TestDox('byContains() succeeds when no documents are updated')]
-    public function testByContainsSucceedsWhenNoDocumentsAreUpdated(): void
-    {
-        $criteria = ['value' => 'updated'];
-        $this->assertEquals(0, Count::byContains(ThrowawayDb::TABLE, $criteria),
-            'There should be no matching documents');
-        Patch::byContains(ThrowawayDb::TABLE, $criteria, ['sub.foo' => 'green']);
-        $this->assertTrue(true, 'The above not throwing an exception is the test');
-    }
-
-    #[TestDox('byJsonPath() succeeds when documents are updated')]
-    public function testByJsonPathSucceedsWhenDocumentsAreUpdated(): void
-    {
-        Patch::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ > 10)', ['value' => 'blue']);
-        $docs = Find::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ > 10)', TestDocument::class);
-        $this->assertNotNull($docs, 'There should have been a document list returned');
-        $this->assertTrue($docs->hasItems, 'The document list should not be empty');
-        foreach ($docs->items as $item) {
-            $this->assertContains($item->id, ['four', 'five'], 'An incorrect document was returned');
-            $this->assertEquals('blue', $item->value, 'The document was not patched');
-        }
-    }
-
-    #[TestDox('byJsonPath() succeeds when documents are not updated')]
-    public function testByJsonPathSucceedsWhenDocumentsAreNotUpdated(): void
-    {
-        $path = '$.num_value ? (@ > 100)';
-        $this->assertEquals(0, Count::byJsonPath(ThrowawayDb::TABLE, $path),
-            'There should be no documents matching this path');
-        Patch::byJsonPath(ThrowawayDb::TABLE, $path, ['value' => 'blue']);
-        $this->assertTrue(true, 'The above not throwing an exception is the test');
-    }
-}

tests/integration/postgresql/RemoveFieldsTest.php

@@ -1,140 +0,0 @@
-<?php
-/**
- * @author Daniel J. Summers <daniel@bitbadger.solutions>
- * @license MIT
- */
-
-declare(strict_types=1);
-
-namespace Test\Integration\PostgreSQL;
-
-use BitBadger\PDODocument\{Field, Find, RemoveFields};
-use PHPUnit\Framework\Attributes\TestDox;
-use PHPUnit\Framework\TestCase;
-use Test\Integration\TestDocument;
-
-/**
- * PostgreSQL integration tests for the RemoveFields class
- */
-#[TestDox('Remove Fields (PostgreSQL integration)')]
-class RemoveFieldsTest extends TestCase
-{
-    /** @var string Database name for throwaway database */
-    private string $dbName;
-
-    protected function setUp(): void
-    {
-        parent::setUp();
-        $this->dbName = ThrowawayDb::create();
-    }
-
-    protected function tearDown(): void
-    {
-        ThrowawayDb::destroy($this->dbName);
-        parent::tearDown();
-    }
-
-    #[TestDox('byId() succeeds when fields are removed')]
-    public function testByIdSucceedsWhenFieldsAreRemoved(): void
-    {
-        RemoveFields::byId(ThrowawayDb::TABLE, 'two', ['sub', 'value']);
-        $tryDoc = Find::byId(ThrowawayDb::TABLE, 'two', TestDocument::class);
-        $this->assertTrue($tryDoc->isSome, 'There should have been a document returned');
-        $doc = $tryDoc->value;
-        $this->assertEquals('', $doc->value, 'Value should have been blank (its default value)');
-        $this->assertNull($doc->sub, 'Sub-document should have been null');
-    }
-
-    #[TestDox('byId() succeeds when a field is not removed')]
-    public function testByIdSucceedsWhenAFieldIsNotRemoved(): void
-    {
-        RemoveFields::byId(ThrowawayDb::TABLE, 'one', ['a_field_that_does_not_exist']);
-        $this->assertTrue(true, 'The above not throwing an exception is the test');
-    }
-
-    #[TestDox('byId() succeeds when no document is matched')]
-    public function testByIdSucceedsWhenNoDocumentIsMatched(): void
-    {
-        RemoveFields::byId(ThrowawayDb::TABLE, 'fifty', ['sub']);
-        $this->assertTrue(true, 'The above not throwing an exception is the test');
-    }
-
-    #[TestDox('byFields() succeeds when a field is removed')]
-    public function testByFieldsSucceedsWhenAFieldIsRemoved(): void
-    {
-        RemoveFields::byFields(ThrowawayDb::TABLE, [Field::equal('num_value', 17)], ['sub']);
-        $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 17)], TestDocument::class);
-        $this->assertTrue($doc->isSome, 'There should have been a document returned');
-        $this->assertNull($doc->value->sub, 'Sub-document should have been null');
-    }
-
-    #[TestDox('byFields() succeeds when a field is not removed')]
-    public function testByFieldsSucceedsWhenAFieldIsNotRemoved(): void
-    {
-        RemoveFields::byFields(ThrowawayDb::TABLE, [Field::equal('num_value', 17)], ['nada']);
-        $this->assertTrue(true, 'The above not throwing an exception is the test');
-    }
-
-    #[TestDox('byFields() succeeds when no document is matched')]
-    public function testByFieldsSucceedsWhenNoDocumentIsMatched(): void
-    {
-        RemoveFields::byFields(ThrowawayDb::TABLE, [Field::notEqual('missing', 'nope')], ['value']);
-        $this->assertTrue(true, 'The above not throwing an exception is the test');
-    }
-
-    #[TestDox('byContains() succeeds when a field is removed')]
-    public function testByContainsSucceedsWhenAFieldIsRemoved(): void
-    {
-        $criteria = ['sub' => ['foo' => 'green']];
-        RemoveFields::byContains(ThrowawayDb::TABLE, $criteria, ['value']);
-        $docs = Find::byContains(ThrowawayDb::TABLE, $criteria, TestDocument::class);
-        $this->assertNotNull($docs, 'There should have been a document list returned');
-        $this->assertTrue($docs->hasItems, 'The document list should not have been empty');
-        foreach ($docs->items as $item) {
-            $this->assertContains($item->id, ['two', 'four'], 'An incorrect document was returned');
-            $this->assertEquals('', $item->value, 'The value field was not removed');
-        }
-    }
-
-    #[TestDox('byContains() succeeds when a field is not removed')]
-    public function testByContainsSucceedsWhenAFieldIsNotRemoved(): void
-    {
-        RemoveFields::byContains(ThrowawayDb::TABLE, ['sub' => ['foo' => 'green']], ['invalid_field']);
-        $this->assertTrue(true, 'The above not throwing an exception is the test');
-    }
-
-    #[TestDox('byContains() succeeds when no document is matched')]
-    public function testByContainsSucceedsWhenNoDocumentIsMatched(): void
-    {
-        RemoveFields::byContains(ThrowawayDb::TABLE, ['value' => 'substantial'], ['num_value']);
-        $this->assertTrue(true, 'The above not throwing an exception is the test');
-    }
-
-    #[TestDox('byJsonPath() succeeds when a field is removed')]
-    public function testByJsonPathSucceedsWhenAFieldIsRemoved(): void
-    {
-        $path = '$.value ? (@ == "purple")';
-        RemoveFields::byJsonPath(ThrowawayDb::TABLE, $path, ['sub']);
-        $docs = Find::byJsonPath(ThrowawayDb::TABLE, $path, TestDocument::class);
-        $this->assertNotNull($docs, 'There should have been a document list returned');
-        $this->assertTrue($docs->hasItems, 'The document list should not have been empty');
-        foreach ($docs->items as $item) {
-            $this->assertContains($item->id, ['four', 'five'], 'An incorrect document was returned');
-            $this->assertNull($item->sub, 'The sub field was not removed');
-        }
-    }
-
-    #[TestDox('byJsonPath() succeeds when a field is not removed')]
-    public function testByJsonPathSucceedsWhenAFieldIsNotRemoved(): void
-    {
-        RemoveFields::byJsonPath(ThrowawayDb::TABLE, '$.value ? (@ == "purple")', ['submarine']);
-        $this->assertTrue(true, 'The above not throwing an exception is the test');
-    }
-
-    #[TestDox('byJsonPath() succeeds when no document is matched')]
-    public function testByJsonPathSucceedsWhenNoDocumentIsMatched(): void
-    {
-        RemoveFields::byJsonPath(ThrowawayDb::TABLE, '$.value ? (@ == "mauve")', ['value']);
-        $this->assertTrue(true, 'The above not throwing an exception is the test');
-    }
-}

tests/integration/sqlite/CountTest.php

@@ -1,70 +0,0 @@
-<?php
-/**
- * @author Daniel J. Summers <daniel@bitbadger.solutions>
- * @license MIT
- */
-
-declare(strict_types=1);
-
-namespace Test\Integration\SQLite;
-
-use BitBadger\PDODocument\{Count, DocumentException, Field};
-use PHPUnit\Framework\Attributes\TestDox;
-use PHPUnit\Framework\TestCase;
-
-/**
- * SQLite integration tests for the Count class
- */
-#[TestDox('Count (SQLite integration)')]
-class CountTest extends TestCase
-{
-    /** @var string Database name for throwaway database */
-    private string $dbName;
-
-    protected function setUp(): void
-    {
-        parent::setUp();
-        $this->dbName = ThrowawayDb::create();
-    }
-
-    protected function tearDown(): void
-    {
-        ThrowawayDb::destroy($this->dbName);
-        parent::tearDown();
-    }
-
-    #[TestDox('all() succeeds')]
-    public function testAllSucceeds(): void
-    {
-        $count = Count::all(ThrowawayDb::TABLE);
-        $this->assertEquals(5, $count, 'There should have been 5 matching documents');
-    }
-
-    #[TestDox('byFields() succeeds for a numeric range')]
-    public function testByFieldsSucceedsForANumericRange(): void
-    {
-        $count = Count::byFields(ThrowawayDb::TABLE, [Field::between('num_value', 10, 20)]);
-        $this->assertEquals(3, $count, 'There should have been 3 matching documents');
-    }
-
-    #[TestDox('byFields() succeeds for a non-numeric range')]
-    public function testByFieldsSucceedsForANonNumericRange(): void
-    {
-        $count = Count::byFields(ThrowawayDb::TABLE, [Field::between('value', 'aardvark', 'apple')]);
-        $this->assertEquals(1, $count, 'There should have been 1 matching document');
-    }
-
-    #[TestDox('byContains() fails')]
-    public function testByContainsFails(): void
-    {
-        $this->expectException(DocumentException::class);
-        Count::byContains('', []);
-    }
-
-    #[TestDox('byJsonPath() fails')]
-    public function testByJsonPathFails(): void
-    {
-        $this->expectException(DocumentException::class);
-        Count::byJsonPath('', '');
-    }
-}

tests/integration/sqlite/CustomTest.php

@@ -1,137 +0,0 @@
-<?php
-/**
- * @author Daniel J. Summers <daniel@bitbadger.solutions>
- * @license MIT
- */
-
-declare(strict_types=1);
-
-namespace Test\Integration\SQLite;
-
-use BitBadger\PDODocument\{Count, Custom, DocumentException, Query};
-use BitBadger\PDODocument\Mapper\{CountMapper, DocumentMapper};
-use PHPUnit\Framework\Attributes\TestDox;
-use PHPUnit\Framework\TestCase;
-use Test\Integration\TestDocument;
-
-/**
- * SQLite Integration tests for the Custom class
- */
-#[TestDox('Custom (SQLite integration)')]
-class CustomTest extends TestCase
-{
-    /** @var string Database name for throwaway database */
-    private string $dbName;
-
-    public function setUp(): void
-    {
-        parent::setUp();
-        $this->dbName = ThrowawayDb::create();
-    }
-
-    public function tearDown(): void
-    {
-        ThrowawayDb::destroy($this->dbName);
-    }
-
-    #[TestDox('runQuery() succeeds with a valid query')]
-    public function testRunQuerySucceedsWithAValidQuery(): void
-    {
-        $stmt = &Custom::runQuery('SELECT data FROM ' . ThrowawayDb::TABLE . ' LIMIT 1', []);
-        try {
-            $this->assertNotNull($stmt, 'The statement should not have been null');
-        } finally {
-            $stmt = null;
-        }
-    }
-
-    #[TestDox('runQuery() fails with an invalid query')]
-    public function testRunQueryFailsWithAnInvalidQuery(): void
-    {
-        $this->expectException(DocumentException::class);
-        $stmt = &Custom::runQuery('GRAB stuff FROM over_there UNTIL done', []);
-        try {
-            $this->assertTrue(false, 'This code should not be reached');
-        } finally {
-            $stmt = null;
-        }
-    }
-
-    #[TestDox('list() succeeds when data is found')]
-    public function testListSucceedsWhenDataIsFound(): void
-    {
-        $list = Custom::list(Query::selectFromTable(ThrowawayDb::TABLE), [], new DocumentMapper(TestDocument::class));
-        $this->assertNotNull($list, 'The document list should not be null');
-        $this->assertTrue($list->hasItems, 'There should have been documents in the list');
-        $count = 0;
-        foreach ($list->items as $ignored) $count++;
-        $this->assertEquals(5, $count, 'There should have been 5 documents in the list');
-    }
-
-    #[TestDox('list() succeeds when no data is found')]
-    public function testListSucceedsWhenNoDataIsFound(): void
-    {
-        $list = Custom::list(Query::selectFromTable(ThrowawayDb::TABLE) . " WHERE data->>'num_value' > :value",
-            [':value' => 100], new DocumentMapper(TestDocument::class));
-        $this->assertNotNull($list, 'The document list should not be null');
-        $this->assertFalse($list->hasItems, 'There should have been no documents in the list');
-    }
-
-    #[TestDox('array() succeeds when data is found')]
-    public function testArraySucceedsWhenDataIsFound(): void
-    {
-        $array = Custom::array(Query::selectFromTable(ThrowawayDb::TABLE) . " WHERE data->>'sub' IS NOT NULL", [],
-            new DocumentMapper(TestDocument::class));
-        $this->assertNotNull($array, 'The document array should not be null');
-        $this->assertCount(2, $array, 'There should have been 2 documents in the array');
-    }
-
-    #[TestDox('array() succeeds when no data is found')]
-    public function testArraySucceedsWhenNoDataIsFound(): void
-    {
-        $array = Custom::array(Query::selectFromTable(ThrowawayDb::TABLE) . " WHERE data->>'value' = :value",
-            [':value' => 'not there'], new DocumentMapper(TestDocument::class));
-        $this->assertNotNull($array, 'The document array should not be null');
-        $this->assertCount(0, $array, 'There should have been no documents in the array');
-    }
-
-    #[TestDox('single() succeeds when a row is found')]
-    public function testSingleSucceedsWhenARowIsFound(): void
-    {
-        $doc = Custom::single('SELECT data FROM ' . ThrowawayDb::TABLE . " WHERE data->>'id' = :id", [':id' => 'one'],
-            new DocumentMapper(TestDocument::class));
-        $this->assertTrue($doc->isSome, 'There should have been a document returned');
-        $this->assertEquals('one', $doc->value->id, 'The incorrect document was returned');
-    }
-
-    #[TestDox('single() succeeds when a row is not found')]
-    public function testSingleSucceedsWhenARowIsNotFound(): void
-    {
-        $doc = Custom::single('SELECT data FROM ' . ThrowawayDb::TABLE . " WHERE data->>'id' = :id",
-            [':id' => 'eighty'], new DocumentMapper(TestDocument::class));
-        $this->assertTrue($doc->isNone, 'There should not have been a document returned');
-    }
-
-    #[TestDox('nonQuery() succeeds when operating on data')]
-    public function testNonQuerySucceedsWhenOperatingOnData(): void
-    {
-        Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
-        $remaining = Count::all(ThrowawayDb::TABLE);
-        $this->assertEquals(0, $remaining, 'There should be no documents remaining in the table');
-    }
-
-    #[TestDox('nonQuery() succeeds when no data matches WHERE clause')]
-    public function testNonQuerySucceedsWhenNoDataMatchesWhereClause(): void
-    {
-        Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE . " WHERE data->>'num_value' > :value", [':value' => 100]);
-        $remaining = Count::all(ThrowawayDb::TABLE);
-        $this->assertEquals(5, $remaining, 'There should be 5 documents remaining in the table');
-    }
-
-    #[TestDox('scalar() succeeds')]
-    public function testScalarSucceeds(): void
-    {
-        $value = Custom::scalar("SELECT 5 AS it", [], new CountMapper());
-        $this->assertEquals(5, $value, 'The scalar value was not returned correctly');
-    }
-}

tests/integration/sqlite/DefinitionTest.php

@@ -1,75 +0,0 @@
-<?php
-/**
- * @author Daniel J. Summers <daniel@bitbadger.solutions>
- * @license MIT
- */
-
-declare(strict_types=1);
-
-namespace Test\Integration\SQLite;
-
-use BitBadger\PDODocument\{Custom, Definition, DocumentException, DocumentIndex};
-use BitBadger\PDODocument\Mapper\ExistsMapper;
-use PHPUnit\Framework\Attributes\TestDox;
-use PHPUnit\Framework\TestCase;
-
-/**
- * SQLite integration tests for the Definition class
- */
-#[TestDox('Definition (SQLite integration)')]
-class DefinitionTest extends TestCase
-{
-    /** @var string Database name for throwaway database */
-    private string $dbName;
-
-    protected function setUp(): void
-    {
-        parent::setUp();
-        $this->dbName = ThrowawayDb::create(withData: false);
-    }
-
-    protected function tearDown(): void
-    {
-        ThrowawayDb::destroy($this->dbName);
-        parent::tearDown();
-    }
-
-    /**
-     * Does the given named object exist in the database?
-     *
-     * @param string $name The name of the object whose existence should be verified
-     * @return bool True if the object exists, false if not
-     * @throws DocumentException If any is encountered
-     */
-    private function itExists(string $name): bool
-    {
-        return Custom::scalar('SELECT EXISTS (SELECT 1 FROM sqlite_master WHERE name = :name)',
-            [':name' => $name], new ExistsMapper());
-    }
-
-    #[TestDox('ensureTable() succeeds')]
-    public function testEnsureTableSucceeds(): void
-    {
-        $this->assertFalse($this->itExists('ensured'), 'The table should not exist already');
-        $this->assertFalse($this->itExists('idx_ensured_key'), 'The key index should not exist already');
-        Definition::ensureTable('ensured');
-        $this->assertTrue($this->itExists('ensured'), 'The table should now exist');
-        $this->assertTrue($this->itExists('idx_ensured_key'), 'The key index should now exist');
-    }
-
-    #[TestDox('ensureFieldIndex() succeeds')]
-    public function testEnsureFieldIndexSucceeds(): void
-    {
-        $this->assertFalse($this->itExists('idx_ensured_test'), 'The index should not exist already');
-        Definition::ensureTable('ensured');
-        Definition::ensureFieldIndex('ensured', 'test', ['name', 'age']);
-        $this->assertTrue($this->itExists('idx_ensured_test'), 'The index should now exist');
-    }
-
-    #[TestDox('ensureDocumentIndex() fails')]
-    public function testEnsureDocumentIndexFails(): void
-    {
-        $this->expectException(DocumentException::class);
-        Definition::ensureDocumentIndex('nope', DocumentIndex::Full);
-    }
-}

tests/integration/sqlite/DeleteTest.php

@@ -1,81 +0,0 @@
-<?php
-/**
- * @author Daniel J. Summers <daniel@bitbadger.solutions>
- * @license MIT
- */
-
-declare(strict_types=1);
-
-namespace Test\Integration\SQLite;
-
-use BitBadger\PDODocument\{Count, Delete, DocumentException, Field};
-use PHPUnit\Framework\Attributes\TestDox;
-use PHPUnit\Framework\TestCase;
-
-/**
- * SQLite integration tests for the Delete class
- */
-#[TestDox('Delete (SQLite integration)')]
-class DeleteTest extends TestCase
-{
-    /** @var string Database name for throwaway database */
-    private string $dbName;
-
-    protected function setUp(): void
-    {
-        parent::setUp();
-        $this->dbName = ThrowawayDb::create();
-    }
-
-    protected function tearDown(): void
-    {
-        ThrowawayDb::destroy($this->dbName);
-        parent::tearDown();
-    }
-
-    #[TestDox('byId() succeeds when a document is deleted')]
-    public function testByIdSucceedsWhenADocumentIsDeleted(): void
-    {
-        $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start');
-        Delete::byId(ThrowawayDb::TABLE, 'four');
-        $this->assertEquals(4, Count::all(ThrowawayDb::TABLE), 'There should have been 4 documents remaining');
-    }
-
-    #[TestDox('byId() succeeds when a document is not deleted')]
-    public function testByIdSucceedsWhenADocumentIsNotDeleted(): void
-    {
-        $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start');
-        Delete::byId(ThrowawayDb::TABLE, 'negative four');
-        $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents remaining');
-    }
-
-    #[TestDox('byFields() succeeds when documents are deleted')]
-    public function testByFieldsSucceedsWhenDocumentsAreDeleted(): void
-    {
-        $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start');
-        Delete::byFields(ThrowawayDb::TABLE, [Field::notEqual('value', 'purple')]);
-        $this->assertEquals(2, Count::all(ThrowawayDb::TABLE), 'There should have been 2 documents remaining');
-    }
-
-    #[TestDox('byFields() succeeds when documents are not deleted')]
-    public function testByFieldsSucceedsWhenDocumentsAreNotDeleted(): void
-    {
-        $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start');
-        Delete::byFields(ThrowawayDb::TABLE, [Field::equal('value', 'crimson')]);
-        $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents remaining');
-    }
-
-    #[TestDox('byContains() fails')]
-    public function testByContainsFails(): void
-    {
-        $this->expectException(DocumentException::class);
-        Delete::byContains('', []);
-    }
-
-    #[TestDox('byJsonPath() fails')]
-    public function testByJsonPathFails(): void
-    {
-        $this->expectException(DocumentException::class);
-        Delete::byJsonPath('', '');
-    }
-}

tests/integration/sqlite/DocumentListTest.php

@@ -1,134 +0,0 @@
-<?php
-/**
- * @author Daniel J. Summers <daniel@bitbadger.solutions>
- * @license MIT
- */
-
-declare(strict_types=1);
-
-namespace Test\Integration\SQLite;
-
-use BitBadger\PDODocument\{DocumentException, DocumentList, Query};
-use BitBadger\PDODocument\Mapper\DocumentMapper;
-use PHPUnit\Framework\Attributes\TestDox;
-use PHPUnit\Framework\TestCase;
-use Test\Integration\TestDocument;
-
-/**
- * SQLite integration tests for the DocumentList class
- */
-#[TestDox('DocumentList (SQLite integration)')]
-class DocumentListTest extends TestCase
-{
-    /** @var string Database name for throwaway database */
-    private string $dbName;
-
-    protected function setUp(): void
-    {
-        parent::setUp();
-        $this->dbName = ThrowawayDb::create();
-    }
-
-    protected function tearDown(): void
-    {
-        ThrowawayDb::destroy($this->dbName);
-        parent::tearDown();
-    }
-
-    #[TestDox('create() succeeds')]
-    public function testCreateSucceeds(): void
-    {
-        $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
-            new DocumentMapper(TestDocument::class));
-        $this->assertNotNull($list, 'There should have been a document list created');
-        $list = null;
-    }
-
-    #[TestDox('items succeeds')]
-    public function testItemsSucceeds(): void
-    {
-        $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
-            new DocumentMapper(TestDocument::class));
-        $this->assertNotNull($list, 'There should have been a document list created');
-        $count = 0;
-        foreach ($list->items as $item) {
-            $this->assertContains($item->id, ['one', 'two', 'three', 'four', 'five'],
-                'An unexpected document ID was returned');
-            $count++;
-        }
-        $this->assertEquals(5, $count, 'There should have been 5 documents returned');
-    }
-
-    #[TestDox('items fails when already consumed')]
-    public function testItemsFailsWhenAlreadyConsumed(): void
-    {
-        $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
-            new DocumentMapper(TestDocument::class));
-        $this->assertNotNull($list, 'There should have been a document list created');
-        $this->assertTrue($list->hasItems, 'There should be items in the list');
-        $ignored = iterator_to_array($list->items);
-        $this->assertFalse($list->hasItems, 'The list should no longer have items');
-        $this->expectException(DocumentException::class);
-        iterator_to_array($list->items);
-    }
-
-    #[TestDox('hasItems succeeds with empty results')]
-    public function testHasItemsSucceedsWithEmptyResults(): void
-    {
-        $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE) . " WHERE data->>'num_value' < 0", [],
-            new DocumentMapper(TestDocument::class));
-        $this->assertNotNull($list, 'There should have been a document list created');
-        $this->assertFalse($list->hasItems, 'There should be no items in the list');
-    }
-
-    #[TestDox('hasItems succeeds with non-empty results')]
-    public function testHasItemsSucceedsWithNonEmptyResults(): void
-    {
-        $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
-            new DocumentMapper(TestDocument::class));
-        $this->assertNotNull($list, 'There should have been a document list created');
-        $this->assertTrue($list->hasItems, 'There should be items in the list');
-        foreach ($list->items as $ignored) {
-            $this->assertTrue($list->hasItems, 'There should be items remaining in the list');
-        }
-        $this->assertFalse($list->hasItems, 'There should be no remaining items in the list');
-    }
-
-    #[TestDox('map() succeeds')]
-    public function testMapSucceeds(): void
-    {
-        $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
-            new DocumentMapper(TestDocument::class));
-        $this->assertNotNull($list, 'There should have been a document list created');
-        $this->assertTrue($list->hasItems, 'There should be items in the list');
-        foreach ($list->map(fn($doc) => strrev($doc->id)) as $mapped) {
-            $this->assertContains($mapped, ['eno', 'owt', 'eerht', 'ruof', 'evif'],
-                'An unexpected mapped value was returned');
-        }
-    }
-
-    #[TestDox('iter() succeeds')]
-    public function testIterSucceeds(): void
-    {
-        $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
-            new DocumentMapper(TestDocument::class));
-        $this->assertNotNull($list, 'There should have been a document list created');
-        $this->assertTrue($list->hasItems, 'There should be items in the list');
-        $splats = [];
-        $list->iter(function ($doc) use (&$splats) { $splats[] = str_repeat('*', strlen($doc->id)); });
-        $this->assertEquals('*** *** ***** **** ****', implode(' ', $splats),
-            'Iteration did not have the expected result');
-    }
-
-    #[TestDox('mapToArray() succeeds')]
-    public function testMapToArraySucceeds(): void
-    {
-        $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
-            new DocumentMapper(TestDocument::class));
-        $this->assertNotNull($list, 'There should have been a document list created');
-        $this->assertTrue($list->hasItems, 'There should be items in the list');
-        $lookup   = $list->mapToArray(fn($it) => $it->id, fn($it) => $it->value);
-        $expected = ['one' => 'FIRST!', 'two' => 'another', 'three' => '', 'four' => 'purple', 'five' => 'purple'];
-        $this->assertEquals($expected, $lookup, 'The array was not mapped correctly');
-    }
-}

tests/integration/sqlite/DocumentTest.php

@@ -1,319 +0,0 @@
-<?php
-/**
- * @author Daniel J. Summers <daniel@bitbadger.solutions>
- * @license MIT
- */
-
-declare(strict_types=1);
-
-namespace Test\Integration\SQLite;
-
-use BitBadger\PDODocument\{AutoId, Configuration, Custom, Document, DocumentException, Field, Find};
-use BitBadger\PDODocument\Mapper\ArrayMapper;
-use PHPUnit\Framework\Attributes\TestDox;
-use PHPUnit\Framework\TestCase;
-use Test\Integration\{NumDocument, SubDocument, TestDocument};
-
-/**
- * SQLite integration tests for the Document class
- */
-#[TestDox('Document (SQLite integration)')]
-class DocumentTest extends TestCase
-{
-    /** @var string Database name for throwaway database */
-    private string $dbName;
-
-    protected function setUp(): void
-    {
-        parent::setUp();
-        $this->dbName = ThrowawayDb::create();
-    }
-
-    protected function tearDown(): void
-    {
-        ThrowawayDb::destroy($this->dbName);
-        parent::tearDown();
-    }
-
-    #[TestDox('insert() succeeds for array no auto ID')]
-    public function testInsertSucceedsForArrayNoAutoId(): void
-    {
-        Document::insert(ThrowawayDb::TABLE, ['id' => 'turkey', 'sub' => ['foo' => 'gobble', 'bar' => 'gobble']]);
-        $tryDoc = Find::byId(ThrowawayDb::TABLE, 'turkey', TestDocument::class);
-        $this->assertTrue($tryDoc->isSome, 'There should have been a document inserted');
-        $doc = $tryDoc->value;
-        $this->assertEquals('turkey', $doc->id, 'The ID was incorrect');
-        $this->assertEquals('', $doc->value, 'The value was incorrect');
-        $this->assertEquals(0, $doc->num_value, 'The numeric value was incorrect');
-        $this->assertNotNull($doc->sub, 'The sub-document should not have been null');
-        $this->assertEquals('gobble', $doc->sub->foo, 'The sub-document foo property was incorrect');
-        $this->assertEquals('gobble', $doc->sub->bar, 'The sub-document bar property was incorrect');
-    }
-
-    #[TestDox('insert() succeeds for array with auto number ID not provided')]
-    public function testInsertSucceedsForArrayWithAutoNumberIdNotProvided(): void
-    {
-        Configuration::$autoId = AutoId::Number;
-        try {
-            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
-
-            Document::insert(ThrowawayDb::TABLE, ['id' => 0, 'value' => 'new', 'num_value' => 8]);
-            $doc = Custom::single('SELECT data FROM ' . ThrowawayDb::TABLE, [], new ArrayMapper());
-            $this->assertTrue($doc->isSome, 'There should have been a document returned');
-            $obj = json_decode($doc->value['data']);
-            $this->assertEquals(1, $obj->id, 'The ID 1 should have been auto-generated');
-
-            Document::insert(ThrowawayDb::TABLE, ['id' => 0, 'value' => 'again', 'num_value' => 7]);
-            $doc = Custom::single('SELECT data FROM ' . ThrowawayDb::TABLE . " WHERE data->>'id' = 2", [],
-                new ArrayMapper());
-            $this->assertTrue($doc->isSome, 'There should have been a document returned');
-            $obj = json_decode($doc->value['data']);
-            $this->assertEquals(2, $obj->id, 'The ID 2 should have been auto-generated');
-        } finally {
-            Configuration::$autoId = AutoId::None;
-        }
-    }
-
-    #[TestDox('insert() succeeds for array with auto number ID with ID provided')]
-    public function testInsertSucceedsForArrayWithAutoNumberIdWithIdProvided(): void
-    {
-        Configuration::$autoId = AutoId::Number;
-        try {
-            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
-            Document::insert(ThrowawayDb::TABLE, ['id' => 7, 'value' => 'new', 'num_value' => 8]);
-            $doc = Custom::single('SELECT data FROM ' . ThrowawayDb::TABLE, [], new ArrayMapper());
-            $this->assertTrue($doc->isSome, 'There should have been a document returned');
-            $obj = json_decode($doc->value['data']);
-            $this->assertEquals(7, $obj->id, 'The ID 7 should have been stored');
-        } finally {
-            Configuration::$autoId = AutoId::None;
-        }
-    }
-
-    #[TestDox('insert() succeeds for array with auto UUID ID not provided')]
-    public function testInsertSucceedsForArrayWithAutoUuidIdNotProvided(): void
-    {
-        Configuration::$autoId = AutoId::UUID;
-        try {
-            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
-            Document::insert(ThrowawayDb::TABLE, ['id' => '', 'num_value' => 5]);
-            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 5)], TestDocument::class);
-            $this->assertTrue($doc->isSome, 'There should have been a document returned');
-            $this->assertNotEmpty($doc->value->id, 'The ID should have been auto-generated');
-        } finally {
-            Configuration::$autoId = AutoId::None;
-        }
-    }
-
-    #[TestDox('insert() succeeds for array with auto UUID ID with ID provided')]
-    public function testInsertSucceedsForArrayWithAutoUuidIdWithIdProvided(): void
-    {
-        Configuration::$autoId = AutoId::UUID;
-        try {
-            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
-            $uuid = AutoId::generateUUID();
-            Document::insert(ThrowawayDb::TABLE, ['id' => $uuid, 'value' => 'uuid', 'num_value' => 12]);
-            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 12)], TestDocument::class);
-            $this->assertTrue($doc->isSome, 'There should have been a document returned');
-            $this->assertEquals($uuid, $doc->value->id, 'The ID should not have been changed');
-        } finally {
-            Configuration::$autoId = AutoId::None;
-        }
-    }
-
-    #[TestDox('insert() succeeds for array with auto string ID not provided')]
-    public function testInsertSucceedsForArrayWithAutoStringIdNotProvided(): void
-    {
-        Configuration::$autoId         = AutoId::RandomString;
-        Configuration::$idStringLength = 6;
-        try {
-            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
-            Document::insert(ThrowawayDb::TABLE, ['id' => '', 'value' => 'new', 'num_value' => 8]);
-            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 8)], TestDocument::class);
-            $this->assertTrue($doc->isSome, 'There should have been a document returned');
-            $this->assertEquals(6, strlen($doc->value->id),
-                'The ID should have been auto-generated and had 6 characters');
-        } finally {
-            Configuration::$autoId         = AutoId::None;
-            Configuration::$idStringLength = 16;
-        }
-    }
-
-    #[TestDox('insert() succeeds for array with auto string ID with ID provided')]
-    public function testInsertSucceedsForArrayWithAutoStringIdWithIdProvided(): void
-    {
-        Configuration::$autoId = AutoId::RandomString;
-        try {
-            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
-            Document::insert(ThrowawayDb::TABLE, ['id' => 'my-key', 'value' => 'old', 'num_value' => 3]);
-            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 3)], TestDocument::class);
-            $this->assertTrue($doc->isSome, 'There should have been a document returned');
-            $this->assertEquals('my-key', $doc->value->id, 'The ID should not have been changed');
-        } finally {
-            Configuration::$autoId = AutoId::None;
-        }
-    }
-
-    #[TestDox('insert() succeeds for object no auto ID')]
-    public function testInsertSucceedsForObjectNoAutoId(): void
-    {
-        Document::insert(ThrowawayDb::TABLE, new TestDocument('turkey', sub: new SubDocument('gobble', 'gobble')));
-        $tryDoc = Find::byId(ThrowawayDb::TABLE, 'turkey', TestDocument::class);
-        $this->assertNotFalse($tryDoc->isSome, 'There should have been a document inserted');
-        $doc = $tryDoc->value;
-        $this->assertEquals('turkey', $doc->id, 'The ID was incorrect');
-        $this->assertEquals('', $doc->value, 'The value was incorrect');
-        $this->assertEquals(0, $doc->num_value, 'The numeric value was incorrect');
-        $this->assertNotNull($doc->sub, 'The sub-document should not have been null');
-        $this->assertEquals('gobble', $doc->sub->foo, 'The sub-document foo property was incorrect');
-        $this->assertEquals('gobble', $doc->sub->bar, 'The sub-document bar property was incorrect');
-    }
-
-    #[TestDox('insert() succeeds for object with auto number ID not provided')]
-    public function testInsertSucceedsForObjectWithAutoNumberIdNotProvided(): void
-    {
-        Configuration::$autoId = AutoId::Number;
-        try {
-            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
-
-            Document::insert(ThrowawayDb::TABLE, new NumDocument(value: 'taco'));
-            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('value', 'taco')], NumDocument::class);
-            $this->assertTrue($doc->isSome, 'There should have been a document returned');
-            $this->assertEquals(1, $doc->value->id, 'The ID 1 should have been auto-generated');
-
-            Document::insert(ThrowawayDb::TABLE, new NumDocument(value: 'burrito'));
-            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('value', 'burrito')], NumDocument::class);
-            $this->assertTrue($doc->isSome, 'There should have been a document returned');
-            $this->assertEquals(2, $doc->value->id, 'The ID 2 should have been auto-generated');
-        } finally {
-            Configuration::$autoId = AutoId::None;
-        }
-    }
-
-    #[TestDox('insert() succeeds for object with auto number ID with ID provided')]
-    public function testInsertSucceedsForObjectWithAutoNumberIdWithIdProvided(): void
-    {
-        Configuration::$autoId = AutoId::Number;
-        try {
-            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
-            Document::insert(ThrowawayDb::TABLE, new NumDocument(64, 'large'));
-            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('value', 'large')], NumDocument::class);
-            $this->assertTrue($doc->isSome, 'There should have been a document returned');
-            $this->assertEquals(64, $doc->value->id, 'The ID 64 should have been stored');
-        } finally {
-            Configuration::$autoId = AutoId::None;
-        }
-    }
-
-    #[TestDox('insert() succeeds for object with auto UUID ID not provided')]
-    public function testInsertSucceedsForObjectWithAutoUuidIdNotProvided(): void
-    {
-        Configuration::$autoId = AutoId::UUID;
-        try {
-            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
-            Document::insert(ThrowawayDb::TABLE, new TestDocument(value: 'something', num_value: 9));
-            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::exists('value')], TestDocument::class);
-            $this->assertTrue($doc->isSome, 'There should have been a document returned');
-            $this->assertNotEmpty($doc->value->id, 'The ID should have been auto-generated');
-        } finally {
-            Configuration::$autoId = AutoId::None;
-        }
-    }
-
-    #[TestDox('insert() succeeds for object with auto UUID ID with ID provided')]
-    public function testInsertSucceedsForObjectWithAutoUuidIdWithIdProvided(): void
-    {
-        Configuration::$autoId = AutoId::UUID;
-        try {
-            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
-            $uuid = AutoId::generateUUID();
-            Document::insert(ThrowawayDb::TABLE, new TestDocument($uuid, num_value: 14));
-            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 14)], TestDocument::class);
-            $this->assertTrue($doc->isSome, 'There should have been a document returned');
-            $this->assertEquals($uuid, $doc->value->id, 'The ID should not have been changed');
-        } finally {
-            Configuration::$autoId = AutoId::None;
-        }
-    }
-
-    #[TestDox('insert() succeeds for object with auto string ID not provided')]
-    public function testInsertSucceedsForObjectWithAutoStringIdNotProvided(): void
-    {
-        Configuration::$autoId         = AutoId::RandomString;
-        Configuration::$idStringLength = 40;
-        try {
-            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
-            Document::insert(ThrowawayDb::TABLE, new TestDocument(num_value: 55));
-            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 55)], TestDocument::class);
-            $this->assertTrue($doc->isSome, 'There should have been a document returned');
-            $this->assertEquals(40, strlen($doc->value->id),
-                'The ID should have been auto-generated and had 40 characters');
-        } finally {
-            Configuration::$autoId         = AutoId::None;
-            Configuration::$idStringLength = 16;
-        }
-    }
-
-    #[TestDox('insert() succeeds for object with auto string ID with ID provided')]
-    public function testInsertSucceedsForObjectWithAutoStringIdWithIdProvided(): void
-    {
-        Configuration::$autoId = AutoId::RandomString;
-        try {
-            Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
-            Document::insert(ThrowawayDb::TABLE, new TestDocument('my-key', num_value: 3));
-            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 3)], TestDocument::class);
-            $this->assertTrue($doc->isSome, 'There should have been a document returned');
-            $this->assertEquals('my-key', $doc->value->id, 'The ID should not have been changed');
-        } finally {
-            Configuration::$autoId = AutoId::None;
-        }
-    }
-
-    #[TestDox('insert() fails for duplicate key')]
-    public function testInsertFailsForDuplicateKey(): void
-    {
-        $this->expectException(DocumentException::class);
-        Document::insert(ThrowawayDb::TABLE, new TestDocument('one'));
-    }
-
-    #[TestDox('save() succeeds when a document is inserted')]
-    public function testSaveSucceedsWhenADocumentIsInserted(): void
-    {
-        Document::save(ThrowawayDb::TABLE, new TestDocument('test', sub: new SubDocument('a', 'b')));
-        $doc = Find::byId(ThrowawayDb::TABLE, 'one', TestDocument::class);
-        $this->assertTrue($doc->isSome, 'There should have been a document returned');
-    }
-
-    #[TestDox('save() succeeds when a document is updated')]
-    public function testSaveSucceedsWhenADocumentIsUpdated(): void
-    {
-        Document::save(ThrowawayDb::TABLE, new TestDocument('two', num_value: 44));
-        $tryDoc = Find::byId(ThrowawayDb::TABLE, 'two', TestDocument::class);
-        $this->assertTrue($tryDoc->isSome, 'There should have been a document returned');
-        $doc = $tryDoc->value;
-        $this->assertEquals(44, $doc->num_value, 'The numeric value was not updated');
-        $this->assertNull($doc->sub, 'The sub-document should have been null');
-    }
-
-    #[TestDox('update() succeeds when replacing a document')]
-    public function testUpdateSucceedsWhenReplacingADocument(): void
-    {
-        Document::update(ThrowawayDb::TABLE, 'one', new TestDocument('one', 'howdy', 8, new SubDocument('y', 'z')));
-        $tryDoc = Find::byId(ThrowawayDb::TABLE, 'one', TestDocument::class);
-        $this->assertTrue($tryDoc->isSome, 'There should have been a document returned');
-        $doc = $tryDoc->value;
-        $this->assertEquals('howdy', $doc->value, 'The value was incorrect');
-        $this->assertEquals(8, $doc->num_value, 'The numeric value was incorrect');
-        $this->assertNotNull($doc->sub, 'The sub-document should not have been null');
-        $this->assertEquals('y', $doc->sub->foo, 'The sub-document foo property was incorrect');
-        $this->assertEquals('z', $doc->sub->bar, 'The sub-document bar property was incorrect');
-    }
-
-    #[TestDox('update() succeeds when no document is replaced')]
-    public function testUpdateSucceedsWhenNoDocumentIsReplaced(): void
-    {
-        Document::update(ThrowawayDb::TABLE, 'two-hundred', new TestDocument('200'));
-        $doc = Find::byId(ThrowawayDb::TABLE, 'two-hundred', TestDocument::class);
-        $this->assertTrue($doc->isNone, 'There should not have been a document returned');
-    }
-}

tests/integration/sqlite/ExistsTest.php

@@ -1,77 +0,0 @@
-<?php
-/**
- * @author Daniel J. Summers <daniel@bitbadger.solutions>
- * @license MIT
- */
-
-declare(strict_types=1);
-
-namespace Test\Integration\SQLite;
-
-use BitBadger\PDODocument\{DocumentException, Exists, Field};
-use PHPUnit\Framework\Attributes\TestDox;
-use PHPUnit\Framework\TestCase;
-
-/**
- * SQLite integration tests for the Exists class
- */
-#[TestDox('Exists (SQLite integration)')]
-class ExistsTest extends TestCase
-{
-    /** @var string Database name for throwaway database */
-    private string $dbName;
-
-    protected function setUp(): void
-    {
-        parent::setUp();
-        $this->dbName = ThrowawayDb::create();
-    }
-
-    protected function tearDown(): void
-    {
-        ThrowawayDb::destroy($this->dbName);
-        parent::tearDown();
-    }
-
-    #[TestDox('byId() succeeds when a document exists')]
-    public function testByIdSucceedsWhenADocumentExists(): void
-    {
-        $this->assertTrue(Exists::byId(ThrowawayDb::TABLE, 'three'), 'There should have been an existing document');
-    }
-
-    #[TestDox('byId() succeeds when a document does not exist')]
-    public function testByIdSucceedsWhenADocumentDoesNotExist(): void
-    {
-        $this->assertFalse(Exists::byId(ThrowawayDb::TABLE, 'seven'),
-            'There should not have been an existing document');
-    }
-
-    #[TestDox('byFields() succeeds when documents exist')]
-    public function testByFieldsSucceedsWhenDocumentsExist(): void
-    {
-        $this->assertTrue(Exists::byFields(ThrowawayDb::TABLE, [Field::equal('num_value', 10)]),
-            'There should have been existing documents');
-    }
-
-    #[TestDox('byFields() succeeds when no matching documents exist')]
-    public function testByFieldsSucceedsWhenNoMatchingDocumentsExist(): void
-    {
-        $this->assertFalse(Exists::byFields(ThrowawayDb::TABLE, [Field::less('nothing', 'none')]),
-            'There should not have been any existing documents');
-    }
-
-    #[TestDox('byContains() fails')]
-    public function testByContainsFails(): void
-    {
-        $this->expectException(DocumentException::class);
-        Exists::byContains('', []);
-    }
-
-    #[TestDox('byJsonPath() fails')]
-    public function testByJsonPathFails(): void
-    {
-        $this->expectException(DocumentException::class);
-        Exists::byJsonPath('', '');
-    }
-}
-

tests/integration/sqlite/FindTest.php

@@ -1,239 +0,0 @@
-<?php
-/**
- * @author Daniel J. Summers <daniel@bitbadger.solutions>
- * @license MIT
- */
-
-declare(strict_types=1);
-
-namespace Test\Integration\SQLite;
-
-use BitBadger\PDODocument\{Custom, Delete, Document, DocumentException, Field, FieldMatch, Find};
-use PHPUnit\Framework\Attributes\TestDox;
-use PHPUnit\Framework\TestCase;
-use Test\Integration\ArrayDocument;
-use Test\Integration\TestDocument;
-
-/**
- * SQLite integration tests for the Find class
- */
-#[TestDox('Find (SQLite integration)')]
-class FindTest extends TestCase
-{
-    /** @var string Database name for throwaway database */
-    private string $dbName;
-
-    protected function setUp(): void
-    {
-        parent::setUp();
-        $this->dbName = ThrowawayDb::create();
-    }
-
-    protected function tearDown(): void
-    {
-        ThrowawayDb::destroy($this->dbName);
-        parent::tearDown();
-    }
-
-    #[TestDox('all() succeeds when there is data')]
-    public function testAllSucceedsWhenThereIsData(): void
-    {
-        $docs = Find::all(ThrowawayDb::TABLE, TestDocument::class);
-        $this->assertNotNull($docs, 'There should have been a document list returned');
-        $this->assertTrue($docs->hasItems, 'There should have been documents in the list');
-        $count = 0;
-        foreach ($docs->items as $ignored) $count++;
-        $this->assertEquals(5, $count, 'There should have been 5 documents in the list');
-    }
-
-    #[TestDox('all() succeeds when ordering data ascending')]
-    public function testAllSucceedsWhenOrderingDataAscending(): void
-    {
-        $docs = Find::all(ThrowawayDb::TABLE, TestDocument::class, [Field::named('id')]);
-        $this->assertNotNull($docs, 'There should have been a document list returned');
-        $this->assertTrue($docs->hasItems, 'There should have been documents in the list');
-        $ids = iterator_to_array($docs->map(fn ($it) => $it->id), false);
-        $this->assertEquals(['five', 'four', 'one', 'three', 'two'], $ids, 'The documents were not ordered correctly');
-    }
-
-    #[TestDox('all() succeeds when ordering data descending')]
-    public function testAllSucceedsWhenOrderingDataDescending(): void
-    {
-        $docs = Find::all(ThrowawayDb::TABLE, TestDocument::class, [Field::named('id DESC')]);
-        $this->assertNotNull($docs, 'There should have been a document list returned');
-        $this->assertTrue($docs->hasItems, 'There should have been documents in the list');
-        $ids = iterator_to_array($docs->map(fn ($it) => $it->id), false);
-        $this->assertEquals(['two', 'three', 'one', 'four', 'five'], $ids, 'The documents were not ordered correctly');
-    }
-
-    #[TestDox('all() succeeds when ordering data numerically')]
-    public function testAllSucceedsWhenOrderingDataNumerically(): void
-    {
-        $docs = Find::all(ThrowawayDb::TABLE, TestDocument::class,
-            [Field::named('sub.foo NULLS LAST'), Field::named('n:num_value')]);
-        $this->assertNotNull($docs, 'There should have been a document list returned');
-        $this->assertTrue($docs->hasItems, 'There should have been documents in the list');
-        $ids = iterator_to_array($docs->map(fn ($it) => $it->id), false);
-        $this->assertEquals(['two', 'four', 'one', 'three', 'five'], $ids, 'The documents were not ordered correctly');
-    }
-
-    #[TestDox('all() succeeds when there is no data')]
-    public function testAllSucceedsWhenThereIsNoData(): void
-    {
-        Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
-        $docs = Find::all(ThrowawayDb::TABLE, TestDocument::class);
-        $this->assertNotNull($docs, 'There should have been a document list returned');
-        $this->assertFalse($docs->hasItems, 'There should have been no documents in the list');
-    }
-
-    #[TestDox('byId() succeeds when a document is found')]
-    public function testByIdSucceedsWhenADocumentIsFound(): void
-    {
-        $doc = Find::byId(ThrowawayDb::TABLE, 'two', TestDocument::class);
-        $this->assertTrue($doc->isSome, 'There should have been a document returned');
-        $this->assertEquals('two', $doc->value->id, 'An incorrect document was returned');
-    }
-
-    #[TestDox('byId() succeeds when a document is found with numeric ID')]
-    public function testByIdSucceedsWhenADocumentIsFoundWithNumericId(): void
-    {
-        Document::insert(ThrowawayDb::TABLE, ['id' => 18, 'value' => 'howdy']);
-        $doc = Find::byId(ThrowawayDb::TABLE, 18, TestDocument::class);
-        $this->assertTrue($doc->isSome, 'There should have been a document returned');
-        $this->assertEquals('18', $doc->value->id, 'An incorrect document was returned');
-    }
-
-    #[TestDox('byId() succeeds when a document is not found')]
-    public function testByIdSucceedsWhenADocumentIsNotFound(): void
-    {
-        $doc = Find::byId(ThrowawayDb::TABLE, 'seventy-five', TestDocument::class);
-        $this->assertTrue($doc->isNone, 'There should not have been a document returned');
-    }
-
-    #[TestDox('byFields() succeeds when documents are found')]
-    public function testByFieldsSucceedsWhenDocumentsAreFound(): void
-    {
-        $docs = Find::byFields(ThrowawayDb::TABLE, [Field::in('value', ['blue', 'purple']), Field::exists('sub')],
-            TestDocument::class, FieldMatch::All);
-        $this->assertNotNull($docs, 'There should have been a document list returned');
-        $this->assertTrue($docs->hasItems, 'There should have been documents in the list');
-        $count = 0;
-        foreach ($docs->items as $ignored) $count++;
-        $this->assertEquals(1, $count, 'There should have been 1 document in the list');
-    }
-
-    #[TestDox('byFields() succeeds when documents are found and ordered')]
-    public function testByFieldsSucceedsWhenDocumentsAreFoundAndOrdered(): void
-    {
-        $docs = Find::byFields(ThrowawayDb::TABLE, [Field::equal('value', 'purple')], TestDocument::class,
-            FieldMatch::All, [Field::named('id')]);
-        $this->assertNotNull($docs, 'There should have been a document list returned');
-        $this->assertTrue($docs->hasItems, 'There should have been documents in the list');
-        $ids = iterator_to_array($docs->map(fn ($it) => $it->id), false);
-        $this->assertEquals(['five', 'four'], $ids, 'The documents were not ordered correctly');
-    }
-
-    #[TestDox('byFields() succeeds when documents are found using IN with numeric field')]
-    public function testByFieldsSucceedsWhenDocumentsAreFoundUsingInWithNumericField(): void
-    {
-        $docs = Find::byFields(ThrowawayDb::TABLE, [Field::in('num_value', [2, 4, 6, 8])], TestDocument::class);
-        $this->assertNotNull($docs, 'There should have been a document list returned');
-        $this->assertTrue($docs->hasItems, 'There should have been documents in the list');
-        $count = 0;
-        foreach ($docs->items as $ignored) $count++;
-        $this->assertEquals(1, $count, 'There should have been 1 document in the list');
-    }
-
-    #[TestDox('byFields() succeeds when no documents are found')]
-    public function testByFieldsSucceedsWhenNoDocumentsAreFound(): void
-    {
-        $docs = Find::byFields(ThrowawayDb::TABLE, [Field::greater('num_value', 100)], TestDocument::class);
-        $this->assertNotNull($docs, 'There should have been a document list returned');
-        $this->assertFalse($docs->hasItems, 'There should have been no documents in the list');
-    }
-
-    #[TestDox('byFields() succeeds for inArray when matching documents exist')]
-    public function testByFieldsSucceedsForInArrayWhenMatchingDocumentsExist(): void
-    {
-        Delete::byFields(ThrowawayDb::TABLE, [Field::notExists('absentField')]);
-        foreach (ArrayDocument::testDocuments() as $doc) Document::insert(ThrowawayDb::TABLE, $doc);
-        $docs = Find::byFields(ThrowawayDb::TABLE, [Field::inArray('values', ThrowawayDb::TABLE, ['c'])],
-            ArrayDocument::class);
-        $this->assertNotNull($docs, 'There should have been a document list returned');
-        $this->assertTrue($docs->hasItems, 'There should have been documents in the list');
-        $count = 0;
-        foreach ($docs->items as $ignored) $count++;
-        $this->assertEquals(2, $count, 'There should have been 2 documents in the list');
-    }
-
-    #[TestDox('byFields() succeeds for inArray when no matching documents exist')]
-    public function testByFieldsSucceedsForInArrayWhenNoMatchingDocumentsExist(): void
-    {
-        Delete::byFields(ThrowawayDb::TABLE, [Field::notExists('absentField')]);
-        foreach (ArrayDocument::testDocuments() as $doc) Document::insert(ThrowawayDb::TABLE, $doc);
-        $docs = Find::byFields(ThrowawayDb::TABLE, [Field::inArray('values', ThrowawayDb::TABLE, ['j'])],
-            ArrayDocument::class);
-        $this->assertNotNull($docs, 'There should have been a document list returned');
-        $this->assertFalse($docs->hasItems, 'There should have been no documents in the list');
-    }
-
-    #[TestDox('byContains() fails')]
-    public function testByContainsFails(): void
-    {
-        $this->expectException(DocumentException::class);
-        Find::byContains('', [], TestDocument::class);
-    }
-
-    #[TestDox('byJsonPath() fails')]
-    public function testByJsonPathFails(): void
-    {
-        $this->expectException(DocumentException::class);
-        Find::byJsonPath('', '', TestDocument::class);
-    }
-
-    #[TestDox('firstByFields() succeeds when a document is found')]
-    public function testFirstByFieldsSucceedsWhenADocumentIsFound(): void
-    {
-        $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('value', 'another')], TestDocument::class);
-        $this->assertTrue($doc->isSome, 'There should have been a document returned');
-        $this->assertEquals('two', $doc->value->id, 'The incorrect document was returned');
-    }
-
-    #[TestDox('firstByFields() succeeds when multiple documents are found')]
-    public function testFirstByFieldsSucceedsWhenMultipleDocumentsAreFound(): void
-    {
-        $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('sub.foo', 'green')], TestDocument::class);
-        $this->assertTrue($doc->isSome, 'There should have been a document returned');
-        $this->assertContains($doc->value->id, ['two', 'four'], 'An incorrect document was returned');
-    }
-
-    #[TestDox('firstByFields() succeeds when multiple ordered documents are found')]
-    public function testFirstByFieldsSucceedsWhenMultipleOrderedDocumentsAreFound(): void
-    {
-        $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('sub.foo', 'green')], TestDocument::class,
-            orderBy: [Field::named('n:num_value DESC')]);
-        $this->assertTrue($doc->isSome, 'There should have been a document returned');
-        $this->assertEquals('four', $doc->value->id, 'The incorrect document was returned');
-    }
-
-    #[TestDox('firstByFields() succeeds when a document is not found')]
-    public function testFirstByFieldsSucceedsWhenADocumentIsNotFound(): void
-    {
-        $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('value', 'absent')], TestDocument::class);
-        $this->assertTrue($doc->isNone, 'There should not have been a document returned');
-    }
-
-    #[TestDox('firstByContains() fails')]
-    public function testFirstByContainsFails(): void
-    {
-        $this->expectException(DocumentException::class);
-        Find::firstByContains('', [], TestDocument::class);
-    }
-
-    #[TestDox('firstByJsonPath() fails')]
-    public function testFirstByJsonPathFails(): void
-    {
-        $this->expectException(DocumentException::class);
-        Find::firstByJsonPath('', '', TestDocument::class);
-    }
-}

tests/integration/sqlite/PatchTest.php

@@ -1,81 +0,0 @@
-<?php
-/**
- * @author Daniel J. Summers <daniel@bitbadger.solutions>
- * @license MIT
- */
-
-declare(strict_types=1);
-
-namespace Test\Integration\SQLite;
-
-use BitBadger\PDODocument\{Count, DocumentException, Field, Find, Patch};
-use PHPUnit\Framework\Attributes\TestDox;
-use PHPUnit\Framework\TestCase;
-use Test\Integration\TestDocument;
-
-/**
- * SQLite integration tests for the Patch class
- */
-#[TestDox('Patch (SQLite integration)')]
-class PatchTest extends TestCase
-{
-    /** @var string Database name for throwaway database */
-    private string $dbName;
-
-    protected function setUp(): void
-    {
-        parent::setUp();
-        $this->dbName = ThrowawayDb::create();
-    }
-
-    protected function tearDown(): void
-    {
-        ThrowawayDb::destroy($this->dbName);
-        parent::tearDown();
-    }
-
-    #[TestDox('byId() succeeds when a document is updated')]
-    public function testByIdSucceedsWhenADocumentIsUpdated(): void
-    {
-        Patch::byId(ThrowawayDb::TABLE, 'one', ['num_value' => 44]);
-        $doc = Find::byId(ThrowawayDb::TABLE, 'one', TestDocument::class);
-        $this->assertTrue($doc->isSome, 'There should have been a document returned');
-        $this->assertEquals(44, $doc->value->num_value, 'The updated document is not correct');
-    }
-
-    #[TestDox('byId() succeeds when no document is updated')]
-    public function testByIdSucceedsWhenNoDocumentIsUpdated(): void
-    {
-        Patch::byId(ThrowawayDb::TABLE, 'forty-seven', ['foo' => 'green']);
-        $this->assertTrue(true, 'The above not throwing an exception is the test');
-    }
-
-    #[TestDox('byFields() succeeds when a document is updated')]
-    public function testByFieldsSucceedsWhenADocumentIsUpdated(): void
-    {
-        Patch::byFields(ThrowawayDb::TABLE, [Field::equal('value', 'purple')], ['num_value' => 77]);
-        $after = Count::byFields(ThrowawayDb::TABLE, [Field::equal('num_value', 77)]);
-        $this->assertEquals(2, $after, 'There should have been 2 documents updated');
-    }
-
-    #[TestDox('byFields() succeeds when no document is updated')]
-    public function testByFieldsSucceedsWhenNoDocumentIsUpdated(): void
-    {
-        Patch::byFields(ThrowawayDb::TABLE, [Field::equal('value', 'burgundy')], ['foo' => 'green']);
-        $this->assertTrue(true, 'The above not throwing an exception is the test');
-    }
-
-    #[TestDox('byContains() fails')]
-    public function testByContainsFails(): void
-    {
-        $this->expectException(DocumentException::class);
-        Patch::byContains('', [], []);
-    }
-
-    #[TestDox('byJsonPath() fails')]
-    public function testByJsonPathFails(): void
-    {
-        $this->expectException(DocumentException::class);
-        Patch::byJsonPath('', '', []);
-    }
-}

tests/integration/sqlite/RemoveFieldsTest.php

@@ -1,98 +0,0 @@
-<?php
-/**
- * @author Daniel J. Summers <daniel@bitbadger.solutions>
- * @license MIT
- */
-
-declare(strict_types=1);
-
-namespace Test\Integration\SQLite;
-
-use BitBadger\PDODocument\{DocumentException, Field, Find, RemoveFields};
-use PHPUnit\Framework\Attributes\TestDox;
-use PHPUnit\Framework\TestCase;
-use Test\Integration\TestDocument;
-
-/**
- * SQLite integration tests for the RemoveFields class
- */
-#[TestDox('Remove Fields (SQLite integration)')]
-class RemoveFieldsTest extends TestCase
-{
-    /** @var string Database name for throwaway database */
-    private string $dbName;
-
-    protected function setUp(): void
-    {
-        parent::setUp();
-        $this->dbName = ThrowawayDb::create();
-    }
-
-    protected function tearDown(): void
-    {
-        ThrowawayDb::destroy($this->dbName);
-        parent::tearDown();
-    }
-
-    #[TestDox('byId() succeeds when fields are removed')]
-    public function testByIdSucceedsWhenFieldsAreRemoved(): void
-    {
-        RemoveFields::byId(ThrowawayDb::TABLE, 'two', ['sub', 'value']);
-        $tryDoc = Find::byId(ThrowawayDb::TABLE, 'two', TestDocument::class);
-        $this->assertTrue($tryDoc->isSome, 'There should have been a document returned');
-        $doc = $tryDoc->value;
-        $this->assertEquals('', $doc->value, 'Value should have been blank (its default value)');
-        $this->assertNull($doc->sub, 'Sub-document should have been null');
-    }
-
-    #[TestDox('byId() succeeds when a field is not removed')]
-    public function testByIdSucceedsWhenAFieldIsNotRemoved(): void
-    {
-        RemoveFields::byId(ThrowawayDb::TABLE, 'one', ['a_field_that_does_not_exist']);
-        $this->assertTrue(true, 'The above not throwing an exception is the test');
-    }
-
-    #[TestDox('byId() succeeds when no document is matched')]
-    public function testByIdSucceedsWhenNoDocumentIsMatched(): void
-    {
-        RemoveFields::byId(ThrowawayDb::TABLE, 'fifty', ['sub']);
-        $this->assertTrue(true, 'The above not throwing an exception is the test');
-    }
-
-    #[TestDox('byFields() succeeds when a field is removed')]
-    public function testByFieldsSucceedsWhenAFieldIsRemoved(): void
-    {
-        RemoveFields::byFields(ThrowawayDb::TABLE, [Field::equal('num_value', 17)], ['sub']);
-        $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 17)], TestDocument::class);
-        $this->assertTrue($doc->isSome, 'There should have been a document returned');
-        $this->assertNull($doc->value->sub, 'Sub-document should have been null');
-    }
-
-    #[TestDox('byFields() succeeds when a field is not removed')]
-    public function testByFieldsSucceedsWhenAFieldIsNotRemoved(): void
-    {
-        RemoveFields::byFields(ThrowawayDb::TABLE, [Field::equal('num_value', 17)], ['nada']);
-        $this->assertTrue(true, 'The above not throwing an exception is the test');
-    }
-
-    #[TestDox('byFields() succeeds when no document is matched')]
-    public function testByFieldsSucceedsWhenNoDocumentIsMatched(): void
-    {
-        RemoveFields::byFields(ThrowawayDb::TABLE, [Field::notEqual('missing', 'nope')], ['value']);
-        $this->assertTrue(true, 'The above not throwing an exception is the test');
-    }
-
-    #[TestDox('byContains() fails')]
-    public function testByContainsFails(): void
-    {
-        $this->expectException(DocumentException::class);
-        RemoveFields::byContains('', [], []);
-    }
-
-    #[TestDox('byJsonPath() fails')]
-    public function testByJsonPathFails(): void
-    {
-        $this->expectException(DocumentException::class);
-        RemoveFields::byJsonPath('', '', []);
-    }
-}

tests/unit/ConfigurationTest.php

@@ -1,58 +0,0 @@
-<?php
-/**
- * @author Daniel J. Summers <daniel@bitbadger.solutions>
- * @license MIT
- */
-
-declare(strict_types=1);
-
-namespace Test\Unit;
-
-use BitBadger\PDODocument\{AutoId, Configuration, DocumentException};
-use PHPUnit\Framework\Attributes\TestDox;
-use PHPUnit\Framework\TestCase;
-
-/**
- * Unit tests for the Configuration class
- */
-#[TestDox('Configuration (Unit tests)')]
-class ConfigurationTest extends TestCase
-{
-    #[TestDox('id default succeeds')]
-    public function testIdFieldDefaultSucceeds(): void
-    {
-        $this->assertEquals('id', Configuration::$idField, 'Default ID field should be "id"');
-    }
-
-    #[TestDox('id change succeeds')]
-    public function testIdFieldChangeSucceeds(): void
-    {
-        try {
-            Configuration::$idField = 'EyeDee';
-            $this->assertEquals('EyeDee', Configuration::$idField, 'ID field should have been updated');
-        } finally {
-            Configuration::$idField = 'id';
-            $this->assertEquals('id', Configuration::$idField, 'Default ID value should have been restored');
-        }
-    }
-
-    #[TestDox('autoId default succeeds')]
-    public function testAutoIdDefaultSucceeds(): void
-    {
-        $this->assertEquals(AutoId::None, Configuration::$autoId, 'Auto ID should default to None');
-    }
-
-    #[TestDox('idStringLength default succeeds')]
-    public function testIdStringLengthDefaultSucceeds(): void
-    {
-        $this->assertEquals(16, Configuration::$idStringLength, 'ID string length should default to 16');
-    }
-
-    #[TestDox("dbConn() fails when no DSN specified")]
-    public function testDbConnFailsWhenNoDSNSpecified(): void
-    {
-        $this->expectException(DocumentException::class);
-        Configuration::useDSN('');
-        Configuration::dbConn();
-    }
-}

tests/unit/DocumentExceptionTest.php

@@ -1,56 +0,0 @@
-<?php
-/**
- * @author Daniel J. Summers <daniel@bitbadger.solutions>
- * @license MIT
- */
-
-declare(strict_types=1);
-
-namespace Test\Unit;
-
-use BitBadger\PDODocument\DocumentException;
-use Exception;
-use PHPUnit\Framework\Attributes\TestDox;
-use PHPUnit\Framework\TestCase;
-
-/**
- * Unit tests for the DocumentException class
- */
-#[TestDox('Document Exception (Unit tests)')]
-class DocumentExceptionTest extends TestCase
-{
-    public function testConstructorSucceedsWithCodeAndPriorException(): void
-    {
-        $priorEx = new Exception('Uh oh');
-        $ex = new DocumentException('Test Exception', 17, $priorEx);
-        $this->assertNotNull($ex, 'The exception should not have been null');
-        $this->assertEquals('Test Exception', $ex->getMessage(), 'Message not filled properly');
-        $this->assertEquals(17, $ex->getCode(), 'Code not filled properly');
-        $this->assertSame($priorEx, $ex->getPrevious(), 'Prior exception not filled properly');
-    }
-
-    public function testConstructorSucceedsWithoutCodeAndPriorException(): void
-    {
-        $ex = new DocumentException('Oops');
-        $this->assertNotNull($ex, 'The exception should not have been null');
-        $this->assertEquals('Oops', $ex->getMessage(), 'Message not filled properly');
-        $this->assertEquals(0, $ex->getCode(), 'Code not filled properly');
-        $this->assertNull($ex->getPrevious(), 'Prior exception should have been null');
-    }
-
-    #[TestDox('toString() succeeds without code')]
-    public function testToStringSucceedsWithoutCode(): void
-    {
-        $ex = new DocumentException('Test failure');
-        $this->assertEquals("BitBadger\PDODocument\DocumentException: Test failure\n", "$ex",
-            'toString not generated correctly');
-    }
-
-    #[TestDox('toString() succeeds with code')]
-    public function testToStringSucceedsWithCode(): void
-    {
-        $ex = new DocumentException('Oof', -6);
-        $this->assertEquals("BitBadger\PDODocument\DocumentException: [-6] Oof\n", "$ex",
-            'toString not generated correctly');
-    }
-}

tests/unit/FieldMatchTest.php

@@ -1,32 +0,0 @@
-<?php
-/**
- * @author Daniel J. Summers <daniel@bitbadger.solutions>
- * @license MIT
- */
-
-declare(strict_types=1);
-
-namespace Test\Unit;
-
-use BitBadger\PDODocument\FieldMatch;
-use PHPUnit\Framework\Attributes\TestDox;
-use PHPUnit\Framework\TestCase;
-
-/**
- * Unit tests for the FieldMatch enum
- */
-#[TestDox('Field Match (Unit tests)')]
-class FieldMatchTest extends TestCase
-{
-    #[TestDox('toSQL() succeeds for All')]
-    public function testToSQLSucceedsForAll(): void
-    {
-        $this->assertEquals('AND', FieldMatch::All->toSQL(), 'All should have returned AND');
-    }
-
-    #[TestDox('toSQL() succeeds for Any')]
-    public function testToSQLSucceedsForAny(): void
-    {
-        $this->assertEquals('OR', FieldMatch::Any->toSQL(), 'Any should have returned OR');
-    }
-}

tests/unit/FieldTest.php

@@ -1,683 +0,0 @@
-<?php
-/**
- * @author Daniel J. Summers <daniel@bitbadger.solutions>
- * @license MIT
- */
-
-declare(strict_types=1);
-
-namespace Test\Unit;
-
-use BitBadger\PDODocument\{Configuration, Field, Mode, Op};
-use PHPUnit\Framework\Attributes\TestDox;
-use PHPUnit\Framework\TestCase;
-
-/**
- * Unit tests for the Field class
- */
-#[TestDox('Field (Unit tests)')]
-class FieldTest extends TestCase
-{
-    #[TestDox('appendParameter() succeeds for exists')]
-    public function testAppendParameterSucceedsForExists(): void
-    {
-        $this->assertEquals([], Field::exists('exists')->appendParameter([]),
-            'exists should not have appended a parameter');
-    }
-
-    #[TestDox('appendParameter() succeeds for notExists')]
-    public function testAppendParameterSucceedsForNotExists(): void
-    {
-        $this->assertEquals([], Field::notExists('absent')->appendParameter([]),
-            'notExists should not have appended a parameter');
-    }
-
-    #[TestDox('appendParameter() succeeds for between')]
-    public function testAppendParameterSucceedsForBetween(): void
-    {
-        $this->assertEquals(['@nummin' => 5, '@nummax' => 9],
-            Field::between('exists', 5, 9, '@num')->appendParameter([]),
-            'Between should have appended min and max parameters');
-    }
-
-    #[TestDox('appendParameter() succeeds for in')]
-    public function testAppendParameterSucceedsForIn(): void
-    {
-        $this->assertEquals([':val_0' => 'test', ':val_1' => 'unit', ':val_2' => 'great'],
-            Field::in('it', ['test', 'unit', 'great'], ':val')->appendParameter([]),
-            'In should have appended 3 parameters for the input values');
-    }
-
-    #[TestDox('appendParameter() succeeds for inArray for PostgreSQL')]
-    public function testAppendParameterSucceedsForInArrayForPostgreSQL(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        try {
-            $this->assertEquals([':bit_0' => '2', ':bit_1' => '8', ':bit_2' => '64'],
-                Field::inArray('it', 'table', [2, 8, 64], ':bit')->appendParameter([]),
-                'InArray should have appended 3 string parameters for the input values');
-        } finally {
-            Configuration::overrideMode(null);
-        }
-    }
-
-    #[TestDox('appendParameter() succeeds for inArray for SQLite')]
-    public function testAppendParameterSucceedsForInArrayForSQLite(): void
-    {
-        Configuration::overrideMode(Mode::SQLite);
-        try {
-            $this->assertEquals([':bit_0' => 2, ':bit_1' => 8, ':bit_2' => 64],
-                Field::inArray('it', 'table', [2, 8, 64], ':bit')->appendParameter([]),
-                'InArray should have appended 3 parameters for the input values');
-        } finally {
-            Configuration::overrideMode(null);
-        }
-    }
-
-    #[TestDox('appendParameter() succeeds for others')]
-    public function testAppendParameterSucceedsForOthers(): void
-    {
-        $this->assertEquals(['@test' => 33], Field::equal('the_field', 33, '@test')->appendParameter([]),
-            'Field parameter not returned correctly');
-    }
-
-    #[TestDox('path() succeeds for simple SQL path for PostgreSQL')]
-    public function testPathSucceedsForSimpleSqlPathForPostgreSQL(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        try {
-            $this->assertEquals("data->>'it'", Field::equal('it', 'that')->path(),
-                'SQL value path not generated correctly');
-        } finally {
-            Configuration::overrideMode(null);
-        }
-    }
-
-    #[TestDox('path() succeeds for simple SQL path for SQLite')]
-    public function testPathSucceedsForSimpleSqlPathForSQLite(): void
-    {
-        Configuration::overrideMode(Mode::SQLite);
-        try {
-            $this->assertEquals("data->>'top'", Field::equal('top', 'that')->path(),
-                'SQL value path not generated correctly');
-        } finally {
-            Configuration::overrideMode(null);
-        }
-    }
-
-    #[TestDox('path() succeeds for nested SQL path for PostgreSQL')]
-    public function testPathSucceedsForNestedSqlPathForPostgreSQL(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        try {
-            $this->assertEquals("data#>>'{parts,to,the,path}'", Field::equal('parts.to.the.path', '')->path(),
-                'SQL value path not generated correctly');
-        } finally {
-            Configuration::overrideMode(null);
-        }
-    }
-
-    #[TestDox('path() succeeds for nested SQL path for SQLite')]
-    public function testPathSucceedsForNestedSqlPathForSQLite(): void
-    {
-        Configuration::overrideMode(Mode::SQLite);
-        try {
-            $this->assertEquals("data->'one'->'two'->>'three'", Field::equal('one.two.three', '')->path(),
-                'SQL value path not generated correctly');
-        } finally {
-            Configuration::overrideMode(null);
-        }
-    }
-
-    #[TestDox('path() succeeds for simple JSON path for PostgreSQL')]
-    public function testPathSucceedsForSimpleJsonPathForPostgreSQL(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        try {
-            $this->assertEquals("data->'it'", Field::equal('it', 'that')->path(true),
-                'JSON value path not generated correctly');
-        } finally {
-            Configuration::overrideMode(null);
-        }
-    }
-
-    #[TestDox('path() succeeds for simple JSON path for SQLite')]
-    public function testPathSucceedsForSimpleJsonPathForSQLite(): void
-    {
-        Configuration::overrideMode(Mode::SQLite);
-        try {
-            $this->assertEquals("data->'top'", Field::equal('top', 'that')->path(true),
-                'JSON value path not generated correctly');
-        } finally {
-            Configuration::overrideMode(null);
-        }
-    }
-
-    #[TestDox('path() succeeds for nested JSON path for PostgreSQL')]
-    public function testPathSucceedsForNestedJsonPathForPostgreSQL(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        try {
-            $this->assertEquals("data#>'{parts,to,the,path}'", Field::equal('parts.to.the.path', '')->path(true),
-                'JSON value path not generated correctly');
-        } finally {
-            Configuration::overrideMode(null);
-        }
-    }
-
-    #[TestDox('path() succeeds for nested JSON path for SQLite')]
-    public function testPathSucceedsForNestedJsonPathForSQLite(): void
-    {
-        Configuration::overrideMode(Mode::SQLite);
-        try {
-            $this->assertEquals("data->'one'->'two'->'three'", Field::equal('one.two.three', '')->path(true),
-                'SQL value path not generated correctly');
-        } finally {
-            Configuration::overrideMode(null);
-        }
-    }
-
-    #[TestDox('toWhere() succeeds for exists without qualifier for PostgreSQL')]
-    public function testToWhereSucceedsForExistsWithoutQualifierForPostgreSQL(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        try {
-            $this->assertEquals("data->>'that_field' IS NOT NULL", Field::exists('that_field')->toWhere(),
-                'WHERE fragment not generated correctly');
-        } finally {
-            Configuration::overrideMode(null);
-        }
-    }
-
-    #[TestDox('toWhere() succeeds for exists without qualifier for SQLite')]
-    public function testToWhereSucceedsForExistsWithoutQualifierForSQLite(): void
-    {
-        Configuration::overrideMode(Mode::SQLite);
-        try {
-            $this->assertEquals("data->>'that_field' IS NOT NULL", Field::exists('that_field')->toWhere(),
-                'WHERE fragment not generated correctly');
-        } finally {
-            Configuration::overrideMode(null);
-        }
-    }
-
-    #[TestDox('toWhere() succeeds for notExists without qualifier for PostgreSQL')]
-    public function testToWhereSucceedsForNotExistsWithoutQualifierForPostgreSQL(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        try {
-            $this->assertEquals("data->>'a_field' IS NULL", Field::notExists('a_field')->toWhere(),
-                'WHERE fragment not generated correctly');
-        } finally {
-            Configuration::overrideMode(null);
-        }
-    }
-
-    #[TestDox('toWhere() succeeds for notExists without qualifier for SQLite')]
-    public function testToWhereSucceedsForNotExistsWithoutQualifierForSQLite(): void
-    {
-        Configuration::overrideMode(Mode::SQLite);
-        try {
-            $this->assertEquals("data->>'a_field' IS NULL", Field::notExists('a_field')->toWhere(),
-                'WHERE fragment not generated correctly');
-        } finally {
-            Configuration::overrideMode(null);
-        }
-    }
-
-    #[TestDox('toWhere() succeeds for between without qualifier for SQLite')]
-    public function testToWhereSucceedsForBetweenWithoutQualifierForSQLite(): void
-    {
-        Configuration::overrideMode(Mode::SQLite);
-        try {
-            $this->assertEquals("data->>'age' BETWEEN @agemin AND @agemax",
-                Field::between('age', 13, 17, '@age')->toWhere(), 'WHERE fragment not generated correctly');
-        } finally {
-            Configuration::overrideMode(null);
-        }
-    }
-
-    #[TestDox('toWhere() succeeds for between without qualifier for PostgreSQL with numeric range')]
-    public function testToWhereSucceedsForBetweenWithoutQualifierForPostgreSQLWithNumericRange(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        try {
-            $this->assertEquals("(data->>'age')::numeric BETWEEN @agemin AND @agemax",
-                Field::between('age', 13, 17, '@age')->toWhere(), 'WHERE fragment not generated correctly');
-        } finally {
-            Configuration::overrideMode(null);
-        }
-    }
-
-    #[TestDox('toWhere() succeeds for between without qualifier for PostgreSQL with non-numeric range')]
-    public function testToWhereSucceedsForBetweenWithoutQualifierForPostgreSQLWithNonNumericRange(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        try {
-            $this->assertEquals("data->>'city' BETWEEN :citymin AND :citymax",
-                Field::between('city', 'Atlanta', 'Chicago', ':city')->toWhere(),
-                'WHERE fragment not generated correctly');
-        } finally {
-            Configuration::overrideMode(null);
-        }
-    }
-
-    #[TestDox('toWhere() succeeds for between with qualifier for SQLite')]
-    public function testToWhereSucceedsForBetweenWithQualifierForSQLite(): void
-    {
-        Configuration::overrideMode(Mode::SQLite);
-        try {
-            $field = Field::between('age', 13, 17, '@age');
-            $field->qualifier = 'me';
-            $this->assertEquals("me.data->>'age' BETWEEN @agemin AND @agemax", $field->toWhere(),
-                'WHERE fragment not generated correctly');
-        } finally {
-            Configuration::overrideMode(null);
-        }
-    }
-
-    #[TestDox('toWhere() succeeds for between with qualifier for PostgreSQL with numeric range')]
-    public function testToWhereSucceedsForBetweenWithQualifierForPostgreSQLWithNumericRange(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        try {
-            $field = Field::between('age', 13, 17, '@age');
-            $field->qualifier = 'me';
-            $this->assertEquals("(me.data->>'age')::numeric BETWEEN @agemin AND @agemax", $field->toWhere(),
-                'WHERE fragment not generated correctly');
-        } finally {
-            Configuration::overrideMode(null);
-        }
-    }
-
-    #[TestDox('toWhere() succeeds for between with qualifier for PostgreSQL with non-numeric range')]
-    public function testToWhereSucceedsForBetweenWithQualifierForPostgreSQLWithNonNumericRange(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        try {
-            $field = Field::between('city', 'Atlanta', 'Chicago', ':city');
-            $field->qualifier = 'me';
-            $this->assertEquals("me.data->>'city' BETWEEN :citymin AND :citymax", $field->toWhere(),
-                'WHERE fragment not generated correctly');
-        } finally {
-            Configuration::overrideMode(null);
-        }
-    }
-
-    #[TestDox('toWhere() succeeds for in for PostgreSQL with non-numeric values')]
-    public function testToWhereSucceedsForInForPostgreSQLWithNonNumericValues(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        try {
-            $field = Field::in('test', ['Atlanta', 'Chicago'], ':city');
-            $this->assertEquals("data->>'test' IN (:city_0, :city_1)", $field->toWhere(),
-                'WHERE fragment not generated correctly');
-        } finally {
-            Configuration::overrideMode(null);
-        }
-    }
-
-    #[TestDox('toWhere() succeeds for in for PostgreSQL with numeric values')]
-    public function testToWhereSucceedsForInForPostgreSQLWithNumericValues(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        try {
-            $field = Field::in('even', [2, 4, 6], ':nbr');
-            $this->assertEquals("(data->>'even')::numeric IN (:nbr_0, :nbr_1, :nbr_2)", $field->toWhere(),
-                'WHERE fragment not generated correctly');
-        } finally {
-            Configuration::overrideMode(null);
-        }
-    }
-
-    #[TestDox('toWhere() succeeds for in for SQLite')]
-    public function testToWhereSucceedsForInForSQLite(): void
-    {
-        Configuration::overrideMode(Mode::SQLite);
-        try {
-            $field = Field::in('test', ['Atlanta', 'Chicago'], ':city');
-            $this->assertEquals("data->>'test' IN (:city_0, :city_1)", $field->toWhere(),
-                'WHERE fragment not generated correctly');
-        } finally {
-            Configuration::overrideMode(null);
-        }
-    }
-
-    #[TestDox('toWhere() succeeds for inArray for PostgreSQL')]
-    public function testToWhereSucceedsForInArrayForPostgreSQL(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        try {
-            $field = Field::inArray('even', 'tbl', [2, 4, 6, 8], ':it');
-            $this->assertEquals("data->'even' ??| ARRAY[:it_0, :it_1, :it_2, :it_3]", $field->toWhere(),
-                'WHERE fragment not generated correctly');
-        } finally {
-            Configuration::overrideMode(null);
-        }
-    }
-
-    #[TestDox('toWhere() succeeds for inArray for SQLite')]
-    public function testToWhereSucceedsForInArrayForSQLite(): void
-    {
-        Configuration::overrideMode(Mode::SQLite);
-        try {
-            $field = Field::inArray('test', 'tbl', ['Atlanta', 'Chicago'], ':city');
-            $this->assertEquals(
-                "EXISTS (SELECT 1 FROM json_each(tbl.data, '\$.test') WHERE value IN (:city_0, :city_1))",
-                $field->toWhere(), 'WHERE fragment not generated correctly');
-        } finally {
-            Configuration::overrideMode(null);
-        }
-    }
-
-    #[TestDox('toWhere() succeeds for others without qualifier for PostgreSQL')]
-    public function testToWhereSucceedsForOthersWithoutQualifierForPostgreSQL(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        try {
-            $this->assertEquals("data->>'some_field' = @value", Field::equal('some_field', '', '@value')->toWhere(),
-                'WHERE fragment not generated correctly');
-        } finally {
-            Configuration::overrideMode(null);
-        }
-    }
-
-    #[TestDox('toWhere() succeeds for others without qualifier for SQLite')]
-    public function testToWhereSucceedsForOthersWithoutQualifierForSQLite(): void
-    {
-        Configuration::overrideMode(Mode::SQLite);
-        try {
-            $this->assertEquals("data->>'some_field' = @value", Field::equal('some_field', '', '@value')->toWhere(),
-                'WHERE fragment not generated correctly');
-        } finally {
-            Configuration::overrideMode(null);
-        }
-    }
-
-    #[TestDox('toWhere() succeeds with qualifier no parameter for PostgreSQL')]
-    public function testToWhereSucceedsWithQualifierNoParameterForPostgreSQL(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        try {
-            $field = Field::exists('no_field');
-            $field->qualifier = 'test';
-            $this->assertEquals("test.data->>'no_field' IS NOT NULL", $field->toWhere(),
-                'WHERE fragment not generated correctly');
-        } finally {
-            Configuration::overrideMode(null);
-        }
-    }
-
-    #[TestDox('toWhere() succeeds with qualifier no parameter for SQLite')]
-    public function testToWhereSucceedsWithQualifierNoParameterForSQLite(): void
-    {
-        Configuration::overrideMode(Mode::SQLite);
-        try {
-            $field = Field::exists('no_field');
-            $field->qualifier = 'test';
-            $this->assertEquals("test.data->>'no_field' IS NOT NULL", $field->toWhere(),
-                'WHERE fragment not generated correctly');
-        } finally {
-            Configuration::overrideMode(null);
-        }
-    }
-
-    #[TestDox('toWhere() succeeds with qualifier and parameter for PostgreSQL')]
-    public function testToWhereSucceedsWithQualifierAndParameterForPostgreSQL(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        try {
-            $field = Field::lessOrEqual('le_field', 18, '@it');
-            $field->qualifier = 'q';
-            $this->assertEquals("(q.data->>'le_field')::numeric <= @it", $field->toWhere(),
-                'WHERE fragment not generated correctly');
-        } finally {
-            Configuration::overrideMode(null);
-        }
-    }
-
-    #[TestDox('toWhere() succeeds with qualifier and parameter for SQLite')]
-    public function testToWhereSucceedsWithQualifierAndParameterForSQLite(): void
-    {
-        Configuration::overrideMode(Mode::SQLite);
-        try {
-            $field = Field::lessOrEqual('le_field', 18, '@it');
-            $field->qualifier = 'q';
-            $this->assertEquals("q.data->>'le_field' <= @it", $field->toWhere(),
-                'WHERE fragment not generated correctly');
-        } finally {
-            Configuration::overrideMode(null);
-        }
-    }
-
-    #[TestDox('equal() succeeds without parameter')]
-    public function testEqualSucceedsWithoutParameter(): void
-    {
-        $field = Field::equal('my_test', 9);
-        $this->assertNotNull($field, 'The field should not have been null');
-        $this->assertEquals('my_test', $field->fieldName, 'Field name not filled correctly');
-        $this->assertEquals(Op::Equal, $field->op, 'Operation not filled correctly');
-        $this->assertEquals(9, $field->value, 'Value not filled correctly');
-        $this->assertEquals('', $field->paramName, 'Parameter name should have been blank');
-    }
-
-    #[TestDox('equal() succeeds with parameter')]
-    public function testEqualSucceedsWithParameter(): void
-    {
-        $field = Field::equal('another_test', 'turkey', '@test');
-        $this->assertNotNull($field, 'The field should not have been null');
-        $this->assertEquals('another_test', $field->fieldName, 'Field name not filled correctly');
-        $this->assertEquals(Op::Equal, $field->op, 'Operation not filled correctly');
-        $this->assertEquals('turkey', $field->value, 'Value not filled correctly');
-        $this->assertEquals('@test', $field->paramName, 'Parameter name not filled correctly');
-    }
-
-    #[TestDox('greater() succeeds without parameter')]
-    public function testGreaterSucceedsWithoutParameter(): void
-    {
-        $field = Field::greater('your_test', 4);
-        $this->assertNotNull($field, 'The field should not have been null');
-        $this->assertEquals('your_test', $field->fieldName, 'Field name not filled correctly');
-        $this->assertEquals(Op::Greater, $field->op, 'Operation not filled correctly');
-        $this->assertEquals(4, $field->value, 'Value not filled correctly');
-        $this->assertEquals('', $field->paramName, 'Parameter name should have been blank');
-    }
-
-    #[TestDox('greater() succeeds with parameter')]
-    public function testGreaterSucceedsWithParameter(): void
-    {
-        $field = Field::greater('more_test', 'chicken', '@value');
-        $this->assertNotNull($field, 'The field should not have been null');
-        $this->assertEquals('more_test', $field->fieldName, 'Field name not filled correctly');
-        $this->assertEquals(Op::Greater, $field->op, 'Operation not filled correctly');
-        $this->assertEquals('chicken', $field->value, 'Value not filled correctly');
-        $this->assertEquals('@value', $field->paramName, 'Parameter name not filled correctly');
-    }
-
-    #[TestDox('greaterOrEqual() succeeds without parameter')]
-    public function testGreaterOrEqualSucceedsWithoutParameter(): void
-    {
-        $field = Field::greaterOrEqual('their_test', 6);
-        $this->assertNotNull($field, 'The field should not have been null');
-        $this->assertEquals('their_test', $field->fieldName, 'Field name not filled correctly');
-        $this->assertEquals(Op::GreaterOrEqual, $field->op, 'Operation not filled correctly');
-        $this->assertEquals(6, $field->value, 'Value not filled correctly');
-        $this->assertEquals('', $field->paramName, 'Parameter name should have been blank');
-    }
-
-    #[TestDox('greaterOrEqual() succeeds with parameter')]
-    public function testGreaterOrEqualSucceedsWithParameter(): void
-    {
-        $field = Field::greaterOrEqual('greater_test', 'poultry', '@cluck');
-        $this->assertNotNull($field, 'The field should not have been null');
-        $this->assertEquals('greater_test', $field->fieldName, 'Field name not filled correctly');
-        $this->assertEquals(Op::GreaterOrEqual, $field->op, 'Operation not filled correctly');
-        $this->assertEquals('poultry', $field->value, 'Value not filled correctly');
-        $this->assertEquals('@cluck', $field->paramName, 'Parameter name not filled correctly');
-    }
-
-    #[TestDox('less() succeeds without parameter')]
-    public function testLessSucceedsWithoutParameter(): void
-    {
-        $field = Field::less('z', 32);
-        $this->assertNotNull($field, 'The field should not have been null');
-        $this->assertEquals('z', $field->fieldName, 'Field name not filled correctly');
-        $this->assertEquals(Op::Less, $field->op, 'Operation not filled correctly');
-        $this->assertEquals(32, $field->value, 'Value not filled correctly');
-        $this->assertEquals('', $field->paramName, 'Parameter name should have been blank');
-    }
-
-    #[TestDox('less() succeeds with parameter')]
-    public function testLessSucceedsWithParameter(): void
-    {
-        $field = Field::less('additional_test', 'fowl', '@boo');
-        $this->assertNotNull($field, 'The field should not have been null');
-        $this->assertEquals('additional_test', $field->fieldName, 'Field name not filled correctly');
-        $this->assertEquals(Op::Less, $field->op, 'Operation not filled correctly');
-        $this->assertEquals('fowl', $field->value, 'Value not filled correctly');
-        $this->assertEquals('@boo', $field->paramName, 'Parameter name not filled correctly');
-    }
-
-    #[TestDox('lessOrEqual() succeeds without parameter')]
-    public function testLessOrEqualSucceedsWithoutParameter(): void
-    {
-        $field = Field::lessOrEqual('g', 87);
-        $this->assertNotNull($field, 'The field should not have been null');
-        $this->assertEquals('g', $field->fieldName, 'Field name not filled correctly');
-        $this->assertEquals(Op::LessOrEqual, $field->op, 'Operation not filled correctly');
-        $this->assertEquals(87, $field->value, 'Value not filled correctly');
-        $this->assertEquals('', $field->paramName, 'Parameter name should have been blank');
-    }
-
-    #[TestDox('lessOrEqual() succeeds with parameter')]
-    public function testLessOrEqualSucceedsWithParameter(): void
-    {
-        $field = Field::lessOrEqual('lesser_test', 'hen', '@woo');
-        $this->assertNotNull($field, 'The field should not have been null');
-        $this->assertEquals('lesser_test', $field->fieldName, 'Field name not filled correctly');
-        $this->assertEquals(Op::LessOrEqual, $field->op, 'Operation not filled correctly');
-        $this->assertEquals('hen', $field->value, 'Value not filled correctly');
-        $this->assertEquals('@woo', $field->paramName, 'Parameter name not filled correctly');
-    }
-
-    #[TestDox('notEqual() succeeds without parameter')]
-    public function testNotEqualSucceedsWithoutParameter(): void
-    {
-        $field = Field::notEqual('j', 65);
-        $this->assertNotNull($field, 'The field should not have been null');
-        $this->assertEquals('j', $field->fieldName, 'Field name not filled correctly');
-        $this->assertEquals(Op::NotEqual, $field->op, 'Operation not filled correctly');
-        $this->assertEquals(65, $field->value, 'Value not filled correctly');
-        $this->assertEquals('', $field->paramName, 'Parameter name should have been blank');
-    }
-
-    #[TestDox('notEqual() succeeds with parameter')]
-    public function testNotEqualSucceedsWithParameter(): void
-    {
-        $field = Field::notEqual('unequal_test', 'egg', '@zoo');
-        $this->assertNotNull($field, 'The field should not have been null');
-        $this->assertEquals('unequal_test', $field->fieldName, 'Field name not filled correctly');
-        $this->assertEquals(Op::NotEqual, $field->op, 'Operation not filled correctly');
-        $this->assertEquals('egg', $field->value, 'Value not filled correctly');
-        $this->assertEquals('@zoo', $field->paramName, 'Parameter name not filled correctly');
-    }
-
-    #[TestDox('between() succeeds without parameter')]
-    public function testBetweenSucceedsWithoutParameter(): void
-    {
-        $field = Field::between('k', 'alpha', 'zed');
-        $this->assertNotNull($field, 'The field should not have been null');
-        $this->assertEquals('k', $field->fieldName, 'Field name not filled correctly');
-        $this->assertEquals(Op::Between, $field->op, 'Operation not filled correctly');
-        $this->assertEquals(['alpha', 'zed'], $field->value, 'Value not filled correctly');
-        $this->assertEquals('', $field->paramName, 'Parameter name should have been blank');
-    }
-
-    #[TestDox('between() succeeds with parameter')]
-    public function testBetweenSucceedsWithParameter(): void
-    {
-        $field = Field::between('between_test', 18, 49, '@count');
-        $this->assertNotNull($field, 'The field should not have been null');
-        $this->assertEquals('between_test', $field->fieldName, 'Field name not filled correctly');
-        $this->assertEquals(Op::Between, $field->op, 'Operation not filled correctly');
-        $this->assertEquals([18, 49], $field->value, 'Value not filled correctly');
-        $this->assertEquals('@count', $field->paramName, 'Parameter name not filled correctly');
-    }
-
-    #[TestDox('in() succeeds without parameter')]
-    public function testInSucceedsWithoutParameter(): void
-    {
-        $field = Field::in('test', [1, 2, 3]);
-        $this->assertNotNull($field, 'The field should not have been null');
-        $this->assertEquals('test', $field->fieldName, 'Field name not filled correctly');
-        $this->assertEquals(Op::In, $field->op, 'Operation not filled correctly');
-        $this->assertEquals([1, 2, 3], $field->value, 'Value not filled correctly');
-        $this->assertEquals('', $field->paramName, 'Parameter name should have been blank');
-    }
-
-    #[TestDox('in() succeeds with parameter')]
-    public function testInSucceedsWithParameter(): void
-    {
-        $field = Field::in('unit', ['a', 'b'], '@inParam');
-        $this->assertNotNull($field, 'The field should not have been null');
-        $this->assertEquals('unit', $field->fieldName, 'Field name not filled correctly');
-        $this->assertEquals(Op::In, $field->op, 'Operation not filled correctly');
-        $this->assertEquals(['a', 'b'], $field->value, 'Value not filled correctly');
-        $this->assertEquals('@inParam', $field->paramName, 'Parameter name not filled correctly');
-    }
-
-    #[TestDox('inArray() succeeds without parameter')]
-    public function testInArraySucceedsWithoutParameter(): void
-    {
-        $field = Field::inArray('test', 'tbl', [1, 2, 3]);
-        $this->assertNotNull($field, 'The field should not have been null');
-        $this->assertEquals('test', $field->fieldName, 'Field name not filled correctly');
-        $this->assertEquals(Op::InArray, $field->op, 'Operation not filled correctly');
-        $this->assertEquals(['table' => 'tbl', 'values' => [1, 2, 3]], $field->value, 'Value not filled correctly');
-        $this->assertEquals('', $field->paramName, 'Parameter name should have been blank');
-    }
-
-    #[TestDox('inArray() succeeds with parameter')]
-    public function testInArraySucceedsWithParameter(): void
-    {
-        $field = Field::inArray('unit', 'tab', ['a', 'b'], '@inAParam');
-        $this->assertNotNull($field, 'The field should not have been null');
-        $this->assertEquals('unit', $field->fieldName, 'Field name not filled correctly');
-        $this->assertEquals(Op::InArray, $field->op, 'Operation not filled correctly');
-        $this->assertEquals(['table' => 'tab', 'values' => ['a', 'b']], $field->value, 'Value not filled correctly');
-        $this->assertEquals('@inAParam', $field->paramName, 'Parameter name not filled correctly');
-    }
-
-    #[TestDox('exists() succeeds')]
-    public function testExistsSucceeds(): void
-    {
-        $field = Field::exists('be_there');
-        $this->assertNotNull($field, 'The field should not have been null');
-        $this->assertEquals('be_there', $field->fieldName, 'Field name not filled correctly');
-        $this->assertEquals(Op::Exists, $field->op, 'Operation not filled correctly');
-        $this->assertEquals('', $field->value, 'Value should have been blank');
-        $this->assertEquals('', $field->paramName, 'Parameter name should have been blank');
-    }
-
-    #[TestDox('notExists() succeeds')]
-    public function testNotExistsSucceeds(): void
-    {
-        $field = Field::notExists('be_absent');
-        $this->assertNotNull($field, 'The field should not have been null');
-        $this->assertEquals('be_absent', $field->fieldName, 'Field name not filled correctly');
-        $this->assertEquals(Op::NotExists, $field->op, 'Operation not filled correctly');
-        $this->assertEquals('', $field->value, 'Value should have been blank');
-        $this->assertEquals('', $field->paramName, 'Parameter name should have been blank');
-    }
-
-    #[TestDox('named() succeeds')]
-    public function testNamedSucceeds(): void
-    {
-        $field = Field::named('the_field');
-        $this->assertNotNull($field, 'The field should not have been null');
-        $this->assertEquals('the_field', $field->fieldName, 'Field name not filled correctly');
-        $this->assertEquals(Op::Equal, $field->op, 'Operation not filled correctly');
-        $this->assertEquals('', $field->value, 'Value should have been blank');
-        $this->assertEquals('', $field->paramName, 'Parameter name should have been blank');
-    }
-}

tests/unit/Mapper/ArrayMapperTest.php

@@ -1,28 +0,0 @@
-<?php
-/**
- * @author Daniel J. Summers <daniel@bitbadger.solutions>
- * @license MIT
- */
-
-declare(strict_types=1);
-
-namespace Test\Unit\Mapper;
-
-use BitBadger\PDODocument\Mapper\ArrayMapper;
-use PHPUnit\Framework\Attributes\TestDox;
-use PHPUnit\Framework\TestCase;
-
-/**
- * Unit tests for the ArrayMapper class
- */
-#[TestDox('Array Mapper (Unit tests)')]
-class ArrayMapperTest extends TestCase
-{
-    #[TestDox('map() succeeds')]
-    public function testMapSucceeds(): void
-    {
-        $result = ['one' => 2, 'three' => 4, 'eight' => 'five'];
-        $mapped = new ArrayMapper()->map($result);
-        $this->assertSame($result, $mapped, 'The array mapper should return the parameter given to it');
-    }
-}

tests/unit/Mapper/CountMapperTest.php

@@ -1,26 +0,0 @@
-<?php
-/**
- * @author Daniel J. Summers <daniel@bitbadger.solutions>
- * @license MIT
- */
-
-declare(strict_types=1);
-
-namespace Test\Unit\Mapper;
-
-use BitBadger\PDODocument\Mapper\CountMapper;
-use PHPUnit\Framework\Attributes\TestDox;
-use PHPUnit\Framework\TestCase;
-
-/**
- * Unit tests for the CountMapper class
- */
-#[TestDox('Count Mapper (Unit tests)')]
-class CountMapperTest extends TestCase
-{
-    #[TestDox('map() succeeds')]
-    public function testMapSucceeds(): void
-    {
-        $this->assertEquals(5, new CountMapper()->map([5, 8, 10]), 'Count not correct');
-    }
-}

tests/unit/Mapper/DocumentMapperTest.php

@@ -1,82 +0,0 @@
-<?php
-/**
- * @author Daniel J. Summers <daniel@bitbadger.solutions>
- * @license MIT
- */
-
-declare(strict_types=1);
-
-namespace Test\Unit\Mapper;
-
-use BitBadger\PDODocument\{DocumentException, Field};
-use BitBadger\PDODocument\Mapper\DocumentMapper;
-use PHPUnit\Framework\Attributes\TestDox;
-use PHPUnit\Framework\TestCase;
-use Test\{PjsonDocument, PjsonId};
-
-// ** Test class hierarchy for serialization **
-
-class SubDocument
-{
-    public function __construct(public int $id = 0, public string $name = '') { }
-}
-
-class TestDocument
-{
-    public function __construct(public int $id = 0, public SubDocument $subDoc = new SubDocument()) { }
-}
-
-/**
- * Unit tests for the DocumentMapper class
- */
-#[TestDox('Document Mapper (Unit tests)')]
-class DocumentMapperTest extends TestCase
-{
-    public function testConstructorSucceedsWithDefaultField(): void
-    {
-        $mapper = new DocumentMapper(Field::class);
-        $this->assertEquals('data', $mapper->fieldName, 'Default field name should have been "data"');
-    }
-
-    public function testConstructorSucceedsWithSpecifiedField(): void
-    {
-        $mapper = new DocumentMapper(Field::class, 'json');
-        $this->assertEquals('json', $mapper->fieldName, 'Field name not recorded correctly');
-    }
-
-    #[TestDox('map() succeeds with valid JSON')]
-    public function testMapSucceedsWithValidJSON(): void
-    {
-        $doc = new DocumentMapper(TestDocument::class)->map(['data' => '{"id":7,"subDoc":{"id":22,"name":"tester"}}']);
-        $this->assertNotNull($doc, 'The document should not have been null');
-        $this->assertEquals(7, $doc->id, 'ID not filled correctly');
-        $this->assertNotNull($doc->subDoc, 'The sub-document should not have been null');
-        $this->assertEquals(22, $doc->subDoc->id, 'Sub-document ID not filled correctly');
-        $this->assertEquals('tester', $doc->subDoc->name, 'Sub-document name not filled correctly');
-    }
-
-    #[TestDox('map() succeeds with valid JSON for Pjson class')]
-    public function testMapSucceedsWithValidJSONForPjsonClass(): void
-    {
-        $doc = new DocumentMapper(PjsonDocument::class)->map(['data' => '{"id":"seven","name":"bob","num_value":8}']);
-        $this->assertNotNull($doc, 'The document should not have been null');
-        $this->assertEquals(new PjsonId('seven'), $doc->id, 'ID not filled correctly');
-        $this->assertEquals('bob', $doc->name, 'Name not filled correctly');
-        $this->assertEquals(8, $doc->numValue, 'Numeric value not filled correctly');
-        $this->assertFalse(isset($doc->skipped), 'Non-JSON field has not been set');
-    }
-
-    #[TestDox('map() fails with invalid JSON')]
-    public function testMapFailsWithInvalidJSON(): void
-    {
-        $this->expectException(DocumentException::class);
-        new DocumentMapper(TestDocument::class)->map(['data' => 'this is not valid']);
-    }
-
-    #[TestDox('map() fails with invalid JSON for Pjson class')]
-    public function testMapFailsWithInvalidJSONForPjsonClass(): void
-    {
-        $this->expectException(DocumentException::class);
-        new DocumentMapper(PjsonDocument::class)->map(['data' => 'not even close']);
-    }
-}

tests/unit/Mapper/ExistsMapperTest.php

@@ -1,51 +0,0 @@
-<?php
-/**
- * @author Daniel J. Summers <daniel@bitbadger.solutions>
- * @license MIT
- */
-
-declare(strict_types=1);
-
-namespace Test\Unit\Mapper;
-
-use BitBadger\PDODocument\{Configuration, DocumentException, Mode};
-use BitBadger\PDODocument\Mapper\ExistsMapper;
-use PHPUnit\Framework\Attributes\TestDox;
-use PHPUnit\Framework\TestCase;
-
-/**
- * Unit tests for the ExistsMapper class
- */
-#[TestDox('Exists Mapper (Unit tests)')]
-class ExistsMapperTest extends TestCase
-{
-    #[TestDox('map() succeeds for PostgreSQL')]
-    public function testMapSucceedsForPostgreSQL(): void
-    {
-        try {
-            Configuration::overrideMode(Mode::PgSQL);
-            $this->assertFalse(new ExistsMapper()->map([false, 'nope']), 'Result should have been false');
-        } finally {
-            Configuration::overrideMode(null);
-        }
-    }
-
-    #[TestDox('map() succeeds for SQLite')]
-    public function testMapSucceedsForSQLite(): void
-    {
-        try {
-            Configuration::overrideMode(Mode::SQLite);
-            $this->assertTrue(new ExistsMapper()->map([1, 'yep']), 'Result should have been true');
-        } finally {
-            Configuration::overrideMode(null);
-        }
-    }
-
-    #[TestDox('map() fails when mode not set')]
-    public function testMapFailsWhenModeNotSet(): void
-    {
-        $this->expectException(DocumentException::class);
-        Configuration::overrideMode(null);
-        new ExistsMapper()->map(['0']);
-    }
-}

tests/unit/Mapper/StringMapperTest.php

@@ -1,43 +0,0 @@
-<?php
-/**
- * @author Daniel J. Summers <daniel@bitbadger.solutions>
- * @license MIT
- */
-
-declare(strict_types=1);
-
-namespace Test\Unit\Mapper;
-
-use BitBadger\PDODocument\Mapper\StringMapper;
-use PHPUnit\Framework\Attributes\TestDox;
-use PHPUnit\Framework\TestCase;
-
-/**
- * Unit tests for the StringMapper class
- */
-#[TestDox('String Mapper (Unit tests)')]
-class StringMapperTest extends TestCase
-{
-    #[TestDox('map() succeeds when field is present and string')]
-    public function testMapSucceedsWhenFieldIsPresentAndString(): void
-    {
-        $result = ['test_field' => 'test_value'];
-        $mapper = new StringMapper('test_field');
-        $this->assertEquals('test_value', $mapper->map($result), 'String value not returned correctly');
-    }
-
-    #[TestDox('map() succeeds when field is present and not string')]
-    public function testMapSucceedsWhenFieldIsPresentAndNotString(): void
-    {
-        $result = ['a_number' => 6.7];
-        $mapper = new StringMapper('a_number');
-        $this->assertEquals('6.7', $mapper->map($result), 'Number value not returned correctly');
-    }
-
-    #[TestDox('map() succeeds when field is not present')]
-    public function testMapSucceedsWhenFieldIsNotPresent(): void
-    {
-        $mapper = new StringMapper('something_else');
-        $this->assertNull($mapper->map([]), 'Missing value not returned correctly');
-    }
-}

tests/unit/ModeTest.php

@@ -1,39 +0,0 @@
-<?php
-/**
- * @author Daniel J. Summers <daniel@bitbadger.solutions>
- * @license MIT
- */
-
-declare(strict_types=1);
-
-namespace Test\Unit;
-
-use BitBadger\PDODocument\{DocumentException, Mode};
-use PHPUnit\Framework\Attributes\TestDox;
-use PHPUnit\Framework\TestCase;
-
-/**
- * Unit tests for the Mode enumeration
- */
-#[TestDox('Mode (Unit tests)')]
-class ModeTest extends TestCase
-{
-    #[TestDox('deriveFromDSN() succeeds for PostgreSQL')]
-    public function testDeriveFromDSNSucceedsForPostgreSQL(): void
-    {
-        $this->assertEquals(Mode::PgSQL, Mode::deriveFromDSN('pgsql:Host=localhost'), 'PostgreSQL mode incorrect');
-    }
-
-    #[TestDox('deriveFromDSN() succeeds for SQLite')]
-    public function testDeriveFromDSNSucceedsForSQLite(): void
-    {
-        $this->assertEquals(Mode::SQLite, Mode::deriveFromDSN('sqlite:data.db'), 'SQLite mode incorrect');
-    }
-
-    #[TestDox('deriveFromDSN() fails for MySQL')]
-    public function testDeriveFromDSNFailsForMySQL(): void
-    {
-        $this->expectException(DocumentException::class);
-        Mode::deriveFromDSN('mysql:Host=localhost');
-    }
-}

tests/unit/OpTest.php

@@ -1,86 +0,0 @@
-<?php
-/**
- * @author Daniel J. Summers <daniel@bitbadger.solutions>
- * @license MIT
- */
-
-declare(strict_types=1);
-
-namespace Test\Unit;
-
-use BitBadger\PDODocument\Op;
-use PHPUnit\Framework\Attributes\TestDox;
-use PHPUnit\Framework\TestCase;
-
-/**
- * Unit tests for the Op enumeration
- */
-#[TestDox('Op (Unit tests)')]
-class OpTest extends TestCase
-{
-    #[TestDox('toSQL() succeeds for Equal')]
-    public function testToSQLSucceedsForEqual(): void
-    {
-        $this->assertEquals('=', Op::Equal->toSQL(), 'Equal SQL operator incorrect');
-    }
-
-    #[TestDox('toSQL() succeeds for Greater')]
-    public function testToSQLSucceedsForGreater(): void
-    {
-        $this->assertEquals('>', Op::Greater->toSQL(), 'Greater SQL operator incorrect');
-    }
-
-    #[TestDox('toSQL() succeeds for GreaterOrEqual')]
-    public function testToSQLSucceedsForGreaterOrEqual(): void
-    {
-        $this->assertEquals('>=', Op::GreaterOrEqual->toSQL(), 'GreaterOrEqual SQL operator incorrect');
-    }
-
-    #[TestDox('toSQL() succeeds for Less')]
-    public function testToSQLSucceedsForLess(): void
-    {
-        $this->assertEquals('<', Op::Less->toSQL(), 'Less SQL operator incorrect');
-    }
-
-    #[TestDox('toSQL() succeeds for LessOrEqual')]
-    public function testToSQLSucceedsForLessOrEqual(): void
-    {
-        $this->assertEquals('<=', Op::LessOrEqual->toSQL(), 'LessOrEqual SQL operator incorrect');
-    }
-
-    #[TestDox('toSQL() succeeds for NotEqual')]
-    public function testToSQLSucceedsForNotEqual(): void
-    {
-        $this->assertEquals('<>', Op::NotEqual->toSQL(), 'NotEqual SQL operator incorrect');
-    }
-
-    #[TestDox('toSQL() succeeds for Between')]
-    public function testToSQLSucceedsForBetween(): void
-    {
-        $this->assertEquals('BETWEEN', Op::Between->toSQL(), 'Between SQL operator incorrect');
-    }
-
-    #[TestDox('toSQL() succeeds for In')]
-    public function testToSQLSucceedsForIn(): void
-    {
-        $this->assertEquals('IN', Op::In->toSQL(), 'In SQL operator incorrect');
-    }
-
-    #[TestDox('toSQL() succeeds for InArray')]
-    public function testToSQLSucceedsForInArray(): void
-    {
-        $this->assertEquals('??|', Op::InArray->toSQL(), 'InArray SQL operator incorrect');
-    }
-
-    #[TestDox('toSQL() succeeds for Exists')]
-    public function testToSQLSucceedsForExists(): void
-    {
-        $this->assertEquals('IS NOT NULL', Op::Exists->toSQL(), 'Exists SQL operator incorrect');
-    }
-
-    #[TestDox('toSQL() succeeds for NotExists')]
-    public function testToSQLSucceedsForNEX(): void
-    {
-        $this->assertEquals('IS NULL', Op::NotExists->toSQL(), 'NotExists SQL operator incorrect');
-    }
-}

tests/unit/ParametersTest.php

@@ -1,134 +0,0 @@
-<?php
-/**
- * @author Daniel J. Summers <daniel@bitbadger.solutions>
- * @license MIT
- */
-
-declare(strict_types=1);
-
-namespace Test\Unit;
-
-use BitBadger\PDODocument\{Configuration, DocumentException, Field, Mode, Parameters};
-use PHPUnit\Framework\Attributes\TestDox;
-use PHPUnit\Framework\TestCase;
-use stdClass;
-use Test\{PjsonDocument, PjsonId};
-
-/**
- * Unit tests for the Parameters class
- */
-#[TestDox('Parameters (Unit tests)')]
-class ParametersTest extends TestCase
-{
-    #[TestDox('id() succeeds with string')]
-    public function testIdSucceedsWithString(): void
-    {
-        $this->assertEquals([':id' => 'key'], Parameters::id('key'), 'ID parameter not constructed correctly');
-    }
-
-    #[TestDox('id() succeeds with non string')]
-    public function testIdSucceedsWithNonString(): void
-    {
-        $this->assertEquals([':id' => '7'], Parameters::id(7), 'ID parameter not constructed correctly');
-    }
-
-    #[TestDox('json() succeeds for array')]
-    public function testJsonSucceedsForArray(): void
-    {
-        $this->assertEquals([':it' => '{"id":18,"url":"https://www.unittest.com"}'],
-            Parameters::json(':it', ['id' => 18, 'url' => 'https://www.unittest.com']),
-            'JSON parameter not constructed correctly');
-    }
-
-    #[TestDox('json() succeeds for array with empty array parameter')]
-    public function testJsonSucceedsForArrayWithEmptyArrayParameter(): void
-    {
-        $this->assertEquals([':it' => '{"id":18,"urls":[]}'], Parameters::json(':it', ['id' => 18, 'urls' => []]),
-            'JSON parameter not constructed correctly');
-    }
-
-    #[TestDox('json() succeeds for 1D array with empty array parameter')]
-    public function testJsonSucceedsFor1DArrayWithEmptyArrayParameter(): void
-    {
-        $this->assertEquals([':it' => '{"urls":[]}'], Parameters::json(':it', ['urls' => []]),
-            'JSON parameter not constructed correctly');
-    }
-
-    #[TestDox('json() succeeds for stdClass')]
-    public function testJsonSucceedsForStdClass(): void
-    {
-        $obj      = new stdClass();
-        $obj->id  = 19;
-        $obj->url = 'https://testhere.info';
-        $this->assertEquals([':it' => '{"id":19,"url":"https://testhere.info"}'], Parameters::json(':it', $obj),
-            'JSON parameter not constructed correctly');
-    }
-
-    #[TestDox('json() succeeds for Pjson class')]
-    public function testJsonSucceedsForPjsonClass(): void
-    {
-        $this->assertEquals([':it' => '{"id":"999","name":"a test","num_value":98}'],
-            Parameters::json(':it', new PjsonDocument(new PjsonId('999'), 'a test', 98, 'nothing')),
-            'JSON parameter not constructed correctly');
-    }
-
-    #[TestDox('json() succeeds for array of Pjson class')]
-    public function testJsonSucceedsForArrayOfPjsonClass(): void
-    {
-        $this->assertEquals([':it' => '{"pjson":[{"id":"997","name":"another test","num_value":94}]}'],
-            Parameters::json(':it',
-                ['pjson' => [new PjsonDocument(new PjsonId('997'), 'another test', 94, 'nothing')]]),
-            'JSON parameter not constructed correctly');
-    }
-
-    #[TestDox('nameFields() succeeds')]
-    public function testNameFieldsSucceeds(): void
-    {
-        $named = [Field::equal('it', 17), Field::equal('also', 22, ':also'), Field::equal('other', 24)];
-        Parameters::nameFields($named);
-        $this->assertCount(3, $named, 'There should be 3 parameters in the array');
-        $this->assertEquals(':field0', $named[0]->paramName, 'Parameter 1 not named correctly');
-        $this->assertEquals(':also', $named[1]->paramName, 'Parameter 2 not named correctly');
-        $this->assertEquals(':field2', $named[2]->paramName, 'Parameter 3 not named correctly');
-    }
-
-    #[TestDox('addFields() succeeds')]
-    public function testAddFieldsSucceeds(): void
-    {
-        $this->assertEquals([':a' => 1, ':b' => 'two', ':z' => 18],
-            Parameters::addFields([Field::equal('b', 'two', ':b'), Field::equal('z', 18, ':z')], [':a' => 1]),
-            'Field parameters not added correctly');
-    }
-
-    #[TestDox('fieldNames() succeeds for PostgreSQL')]
-    public function testFieldNamesSucceedsForPostgreSQL(): void
-    {
-        try {
-            Configuration::overrideMode(Mode::PgSQL);
-            $this->assertEquals([':names' => "{one,two,seven}"],
-                Parameters::fieldNames(':names', ['one', 'two', 'seven']), 'Field name parameters not correct');
-        } finally {
-            Configuration::overrideMode(null);
-        }
-    }
-
-    #[TestDox('fieldNames() succeeds for SQLite')]
-    public function testFieldNamesSucceedsForSQLite(): void
-    {
-        try {
-            Configuration::overrideMode(Mode::SQLite);
-            $this->assertEquals([':it0' => '$.test', ':it1' => '$.unit', ':it2' => '$.wow'],
-                Parameters::fieldNames(':it', ['test', 'unit', 'wow']), 'Field name parameters not correct');
-        } finally {
-            Configuration::overrideMode(null);
-        }
-    }
-
-    #[TestDox('fieldNames() fails when mode not set')]
-    public function testFieldNamesFailsWhenModeNotSet(): void
-    {
-        $this->expectException(DocumentException::class);
-        Configuration::overrideMode(null);
-        Parameters::fieldNames('', []);
-    }
-}

tests/unit/Query/CountTest.php

@@ -1,73 +0,0 @@
-<?php
-/**
- * @author Daniel J. Summers <daniel@bitbadger.solutions>
- * @license MIT
- */
-
-declare(strict_types=1);
-
-namespace Test\Unit\Query;
-
-use BitBadger\PDODocument\{Configuration, DocumentException, Field, Mode};
-use BitBadger\PDODocument\Query\Count;
-use PHPUnit\Framework\Attributes\TestDox;
-use PHPUnit\Framework\TestCase;
-
-/**
- * Unit tests for the Count class
- */
-#[TestDox('Count Queries (Unit tests)')]
-class CountTest extends TestCase
-{
-    public function tearDown(): void
-    {
-        Configuration::overrideMode(null);
-        parent::tearDown();
-    }
-
-    #[TestDox('all() succeeds')]
-    public function testAllSucceeds(): void
-    {
-        $this->assertEquals('SELECT COUNT(*) FROM a_table', Count::all('a_table'),
-            'SELECT statement not generated correctly');
-    }
-
-    #[TestDox('byFields() succeeds')]
-    public function testByFieldsSucceeds(): void
-    {
-        Configuration::overrideMode(Mode::SQLite);
-        $this->assertEquals("SELECT COUNT(*) FROM somewhere WHERE data->>'errors' > :errors",
-            Count::byFields('somewhere', [Field::greater('errors', 10, ':errors')]),
-            'SELECT statement not generated correctly');
-    }
-
-    #[TestDox('byContains() succeeds for PostgreSQL')]
-    public function testByContainsSucceedsForPostgreSQL(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        $this->assertEquals('SELECT COUNT(*) FROM the_table WHERE data @> :criteria', Count::byContains('the_table'),
-            'SELECT statement not generated correctly');
-    }
-
-    #[TestDox('byContains() fails for non PostgreSQL')]
-    public function testByContainsFailsForNonPostgreSQL(): void
-    {
-        $this->expectException(DocumentException::class);
-        Count::byContains('');
-    }
-
-    #[TestDox('byJsonPath() succeeds for PostgreSQL')]
-    public function testByJsonPathSucceedsForPostgreSQL(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        $this->assertEquals('SELECT COUNT(*) FROM a_table WHERE jsonb_path_exists(data, :path::jsonpath)',
-            Count::byJsonPath('a_table'), 'SELECT statement not generated correctly');
-    }
-
-    #[TestDox('byJsonPath() fails for non PostgreSQL')]
-    public function testByJsonPathFailsForNonPostgreSQL(): void
-    {
-        $this->expectException(DocumentException::class);
-        Count::byJsonPath('');
-    }
-}

tests/unit/Query/DefinitionTest.php

@@ -1,96 +0,0 @@
-<?php
-/**
- * @author Daniel J. Summers <daniel@bitbadger.solutions>
- * @license MIT
- */
-
-declare(strict_types=1);
-
-namespace Test\Unit\Query;
-
-use BitBadger\PDODocument\{Configuration, DocumentException, DocumentIndex, Mode};
-use BitBadger\PDODocument\Query\Definition;
-use PHPUnit\Framework\Attributes\TestDox;
-use PHPUnit\Framework\TestCase;
-
-/**
- * Unit tests for the Definition class
- */
-#[TestDox('Definition Queries (Unit tests)')]
-class DefinitionTest extends TestCase
-{
-    protected function tearDown(): void
-    {
-        Configuration::overrideMode(null);
-        parent::tearDown();
-    }
-
-    #[TestDox('ensureTable() succeeds for PostgreSQL')]
-    public function testEnsureTableSucceedsForPostgreSQL(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        $this->assertEquals('CREATE TABLE IF NOT EXISTS documents (data JSONB NOT NULL)',
-            Definition::ensureTable('documents'), 'CREATE TABLE statement not generated correctly');
-    }
-
-    #[TestDox('ensureTable() succeeds for SQLite')]
-    public function testEnsureTableSucceedsForSQLite(): void
-    {
-        Configuration::overrideMode(Mode::SQLite);
-        $this->assertEquals('CREATE TABLE IF NOT EXISTS dox (data TEXT NOT NULL)', Definition::ensureTable('dox'),
-            'CREATE TABLE statement not generated correctly');
-    }
-
-    #[TestDox('ensureTable() fails when mode not set')]
-    public function testEnsureTableFailsWhenModeNotSet(): void
-    {
-        $this->expectException(DocumentException::class);
-        Definition::ensureTable('boom');
-    }
-
-    #[TestDox('ensureIndexOn() succeeds without schema single ascending field')]
-    public function testEnsureIndexOnSucceedsWithoutSchemaSingleAscendingField(): void
-    {
-        $this->assertEquals("CREATE INDEX IF NOT EXISTS idx_test_fields ON test ((data->>'details'))",
-            Definition::ensureIndexOn('test', 'fields', ['details']), 'CREATE INDEX statement not generated correctly');
-    }
-
-    #[TestDox('ensureIndexOn() succeeds with schema multiple fields')]
-    public function testEnsureIndexOnSucceedsWithSchemaMultipleFields(): void
-    {
-        $this->assertEquals(
-            "CREATE INDEX IF NOT EXISTS idx_testing_json ON sch.testing ((data->>'group'), (data->>'sub_group') DESC)",
-            Definition::ensureIndexOn('sch.testing', 'json', ['group', 'sub_group DESC']),
-            'CREATE INDEX statement not generated correctly');
-    }
-
-    #[TestDox('ensureKey() succeeds')]
-    public function testEnsureKeySucceeds(): void
-    {
-        $this->assertEquals("CREATE UNIQUE INDEX IF NOT EXISTS idx_tbl_key ON tbl ((data->>'id'))",
-            Definition::ensureKey('tbl'), 'CREATE INDEX statement for document key not generated correctly');
-    }
-
-    #[TestDox('ensureDocumentIndexOn() succeeds for schema and Full')]
-    public function testEnsureDocumentIndexOnSucceedsForSchemaAndFull(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        $this->assertEquals("CREATE INDEX IF NOT EXISTS idx_tbl_document ON my.tbl USING GIN (data)",
-            Definition::ensureDocumentIndexOn('my.tbl', DocumentIndex::Full));
-    }
-
-    #[TestDox('ensureDocumentIndexOn() succeeds for no schema and Optimized')]
-    public function testEnsureDocumentIndexOnSucceedsForNoSchemaAndOptimized(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        $this->assertEquals("CREATE INDEX IF NOT EXISTS idx_it_document ON it USING GIN (data jsonb_path_ops)",
-            Definition::ensureDocumentIndexOn('it', DocumentIndex::Optimized));
-    }
-
-    #[TestDox('ensureDocumentIndexOn() fails for non PostgreSQL')]
-    public function testEnsureDocumentIndexOnFailsForNonPostgreSQL(): void
-    {
-        $this->expectException(DocumentException::class);
-        Definition::ensureDocumentIndexOn('', DocumentIndex::Full);
-    }
-}

tests/unit/Query/DeleteTest.php

@@ -1,74 +0,0 @@
-<?php
-/**
- * @author Daniel J. Summers <daniel@bitbadger.solutions>
- * @license MIT
- */
-
-declare(strict_types=1);
-
-namespace Test\Unit\Query;
-
-use BitBadger\PDODocument\{Configuration, DocumentException, Field, Mode};
-use BitBadger\PDODocument\Query\Delete;
-use PHPUnit\Framework\Attributes\TestDox;
-use PHPUnit\Framework\TestCase;
-
-/**
- * Unit tests for the Delete class
- */
-#[TestDox('Delete Queries (Unit tests)')]
-class DeleteTest extends TestCase
-{
-    protected function tearDown(): void
-    {
-        Configuration::overrideMode(null);
-    }
-
-    #[TestDox('byId() succeeds')]
-    public function testByIdSucceeds(): void
-    {
-        Configuration::overrideMode(Mode::SQLite);
-        $this->assertEquals("DELETE FROM over_there WHERE data->>'id' = :id", Delete::byId('over_there'),
-            'DELETE statement not constructed correctly');
-    }
-
-    #[TestDox('byFields() succeeds')]
-    public function testByFieldsSucceeds(): void
-    {
-        Configuration::overrideMode(Mode::SQLite);
-        $this->assertEquals("DELETE FROM my_table WHERE data->>'value' < :max AND data->>'value' >= :min",
-            Delete::byFields('my_table',
-                [Field::less('value', 99, ':max'), Field::greaterOrEqual('value', 18, ':min')]),
-            'DELETE statement not constructed correctly');
-    }
-
-    #[TestDox('byContains() succeeds for PostgreSQL')]
-    public function testByContainsSucceedsForPostgreSQL(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        $this->assertEquals('DELETE FROM somewhere WHERE data @> :criteria', Delete::byContains('somewhere'),
-            'DELETE statement not constructed correctly');
-    }
-
-    #[TestDox('byContains() fails for non PostgreSQL')]
-    public function testByContainsFailsForNonPostgreSQL(): void
-    {
-        $this->expectException(DocumentException::class);
-        Delete::byContains('');
-    }
-
-    #[TestDox('byJsonPath() succeeds for PostgreSQL')]
-    public function testByJsonPathSucceedsForPostgreSQL(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        $this->assertEquals('DELETE FROM here WHERE jsonb_path_exists(data, :path::jsonpath)',
-            Delete::byJsonPath('here'), 'DELETE statement not constructed correctly');
-    }
-
-    #[TestDox('byJsonPath() fails for non PostgreSQL')]
-    public function testByJsonPathFailsForNonPostgreSQL(): void
-    {
-        $this->expectException(DocumentException::class);
-        Delete::byJsonPath('');
-    }
-}

tests/unit/Query/ExistsTest.php

@@ -1,81 +0,0 @@
-<?php
-/**
- * @author Daniel J. Summers <daniel@bitbadger.solutions>
- * @license MIT
- */
-
-declare(strict_types=1);
-
-namespace Test\Unit\Query;
-
-use BitBadger\PDODocument\{Configuration, DocumentException, Field, Mode};
-use BitBadger\PDODocument\Query\Exists;
-use PHPUnit\Framework\Attributes\TestDox;
-use PHPUnit\Framework\TestCase;
-
-/**
- * Unit tests for the Exists class
- */
-#[TestDox('Exists Queries (Unit tests)')]
-class ExistsTest extends TestCase
-{
-    protected function tearDown(): void
-    {
-        Configuration::overrideMode(null);
-    }
-
-    #[TestDox('query() succeeds')]
-    public function testQuerySucceeds(): void
-    {
-        Configuration::overrideMode(Mode::SQLite);
-        $this->assertEquals('SELECT EXISTS (SELECT 1 FROM abc WHERE def)', Exists::query('abc', 'def'),
-            'Existence query not generated correctly');
-    }
-
-    #[TestDox('byId() succeeds')]
-    public function testByIdSucceeds(): void
-    {
-        Configuration::overrideMode(Mode::SQLite);
-        $this->assertEquals("SELECT EXISTS (SELECT 1 FROM dox WHERE data->>'id' = :id)", Exists::byId('dox'),
-            'Existence query not generated correctly');
-    }
-
-    #[TestDox('byFields() succeeds')]
-    public function testByFieldsSucceeds(): void
-    {
-        Configuration::overrideMode(Mode::SQLite);
-        $this->assertEquals("SELECT EXISTS (SELECT 1 FROM box WHERE data->>'status' <> :status)",
-            Exists::byFields('box', [Field::notEqual('status', 'occupied', ':status')]),
-            'Existence query not generated correctly');
-    }
-
-    #[TestDox('byContains() succeeds for PostgreSQL')]
-    public function testByContainsSucceedsForPostgreSQL(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        $this->assertEquals('SELECT EXISTS (SELECT 1 FROM pocket WHERE data @> :criteria)',
-            Exists::byContains('pocket'), 'Existence query not generated correctly');
-    }
-
-    #[TestDox('byContains() fails for non PostgreSQL')]
-    public function testByContainsFailsForNonPostgreSQL(): void
-    {
-        $this->expectException(DocumentException::class);
-        Exists::byContains('');
-    }
-
-    #[TestDox('byJsonPath() succeeds for PostgreSQL')]
-    public function testByJsonPathSucceedsForPostgreSQL(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        $this->assertEquals('SELECT EXISTS (SELECT 1 FROM lint WHERE jsonb_path_exists(data, :path::jsonpath))',
-            Exists::byJsonPath('lint'), 'Existence query not generated correctly');
-    }
-
-    #[TestDox('byJsonPath() fails for non PostgreSQL')]
-    public function testByJsonPathFailsForNonPostgreSQL(): void
-    {
-        $this->expectException(DocumentException::class);
-        Exists::byJsonPath('');
-    }
-}

tests/unit/Query/FindTest.php

@@ -1,74 +0,0 @@
-<?php
-/**
- * @author Daniel J. Summers <daniel@bitbadger.solutions>
- * @license MIT
- */
-
-declare(strict_types=1);
-
-namespace Test\Unit\Query;
-
-use BitBadger\PDODocument\{Configuration, DocumentException, Field, FieldMatch, Mode};
-use BitBadger\PDODocument\Query\Find;
-use PHPUnit\Framework\Attributes\TestDox;
-use PHPUnit\Framework\TestCase;
-
-/**
- * Unit tests for the Find class
- */
-#[TestDox('Find Queries (Unit tests)')]
-class FindTest extends TestCase
-{
-    protected function tearDown(): void
-    {
-        Configuration::overrideMode(null);
-    }
-
-    #[TestDox('byId() succeeds')]
-    public function testByIdSucceeds(): void
-    {
-        Configuration::overrideMode(Mode::SQLite);
-        $this->assertEquals("SELECT data FROM here WHERE data->>'id' = :id", Find::byId('here'),
-            'SELECT query not generated correctly');
-    }
-
-    #[TestDox('byFields() succeeds')]
-    public function testByFieldsSucceeds(): void
-    {
-        Configuration::overrideMode(Mode::SQLite);
-        $this->assertEquals("SELECT data FROM there WHERE data->>'active' = :act OR data->>'locked' = :lock",
-            Find::byFields('there', [Field::equal('active', true, ':act'), Field::equal('locked', true, ':lock')],
-                FieldMatch::Any),
-            'SELECT query not generated correctly');
-    }
-
-    #[TestDox('byContains() succeeds for PostgreSQL')]
-    public function testByContainsSucceedsForPostgreSQL(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        $this->assertEquals('SELECT data FROM disc WHERE data @> :criteria', Find::byContains('disc'),
-            'SELECT query not generated correctly');
-    }
-
-    #[TestDox('byContains() fails for non PostgreSQL')]
-    public function testByContainsFailsForNonPostgreSQL(): void
-    {
-        $this->expectException(DocumentException::class);
-        Find::byContains('');
-    }
-
-    #[TestDox('byJsonPath() succeeds for PostgreSQL')]
-    public function testByJsonPathSucceedsForPostgreSQL(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        $this->assertEquals('SELECT data FROM light WHERE jsonb_path_exists(data, :path::jsonpath)',
-            Find::byJsonPath('light'), 'SELECT query not generated correctly');
-    }
-
-    #[TestDox('byJsonPath() fails for non PostgreSQL')]
-    public function testByJsonPathFailsForNonPostgreSQL(): void
-    {
-        $this->expectException(DocumentException::class);
-        Find::byJsonPath('');
-    }
-}

tests/unit/Query/PatchTest.php

@@ -1,104 +0,0 @@
-<?php
-/**
- * @author Daniel J. Summers <daniel@bitbadger.solutions>
- * @license MIT
- */
-
-declare(strict_types=1);
-
-namespace Test\Unit\Query;
-
-use BitBadger\PDODocument\{Configuration, DocumentException, Field, Mode};
-use BitBadger\PDODocument\Query\Patch;
-use PHPUnit\Framework\Attributes\TestDox;
-use PHPUnit\Framework\TestCase;
-
-/**
- * Unit tests for the Patch class
- */
-#[TestDox('Patch Queries (Unit tests)')]
-class PatchTest extends TestCase
-{
-    protected function tearDown(): void
-    {
-        Configuration::overrideMode(null);
-        parent::tearDown();
-    }
-    #[TestDox('byId() succeeds for PostgreSQL')]
-    public function testByIdSucceedsForPostgreSQL(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        $this->assertEquals("UPDATE doc_table SET data = data || :data WHERE data->>'id' = :id",
-            Patch::byId('doc_table'), 'Patch UPDATE statement is not correct');
-    }
-
-    #[TestDox('byId() succeeds for SQLite')]
-    public function testByIdSucceedsForSQLite(): void
-    {
-        Configuration::overrideMode(Mode::SQLite);
-        $this->assertEquals("UPDATE my_table SET data = json_patch(data, json(:data)) WHERE data->>'id' = :id",
-            Patch::byId('my_table'), 'Patch UPDATE statement is not correct');
-    }
-
-    #[TestDox('byId() fails when mode not set')]
-    public function testByIdFailsWhenModeNotSet(): void
-    {
-        $this->expectException(DocumentException::class);
-        Patch::byId('oof');
-    }
-
-    #[TestDox('byFields() succeeds for PostgreSQL')]
-    public function testByFieldsSucceedsForPostgreSQL(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        $this->assertEquals("UPDATE that SET data = data || :data WHERE (data->>'something')::numeric < :some",
-            Patch::byFields('that', [Field::less('something', 17, ':some')]), 'Patch UPDATE statement is not correct');
-    }
-
-    #[TestDox('byFields() succeeds for SQLite')]
-    public function testByFieldsSucceedsForSQLite(): void
-    {
-        Configuration::overrideMode(Mode::SQLite);
-        $this->assertEquals(
-            "UPDATE a_table SET data = json_patch(data, json(:data)) WHERE data->>'something' > :it",
-            Patch::byFields('a_table', [Field::greater('something', 17, ':it')]),
-                'Patch UPDATE statement is not correct');
-    }
-
-    #[TestDox('byFields() fails when mode not set')]
-    public function testByFieldsFailsWhenModeNotSet(): void
-    {
-        $this->expectException(DocumentException::class);
-        Patch::byFields('oops', []);
-    }
-
-    #[TestDox('byContains() succeeds for PostgreSQL')]
-    public function testByContainsSucceedsForPostgreSQL(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        $this->assertEquals('UPDATE this SET data = data || :data WHERE data @> :criteria', Patch::byContains('this'),
-            'Patch UPDATE statement is not correct');
-    }
-
-    #[TestDox('byContains() fails for non PostgreSQL')]
-    public function testByContainsFailsForNonPostgreSQL(): void
-    {
-        $this->expectException(DocumentException::class);
-        Patch::byContains('');
-    }
-
-    #[TestDox('byJsonPath() succeeds for PostgreSQL')]
-    public function testByJsonPathSucceedsForPostgreSQL(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        $this->assertEquals('UPDATE that SET data = data || :data WHERE jsonb_path_exists(data, :path::jsonpath)',
-            Patch::byJsonPath('that'), 'Patch UPDATE statement is not correct');
-    }
-
-    #[TestDox('byJsonPath() fails for non PostgreSQL')]
-    public function testByJsonPathFailsForNonPostgreSQL(): void
-    {
-        $this->expectException(DocumentException::class);
-        Patch::byJsonPath('');
-    }
-}

tests/unit/Query/RemoveFieldsTest.php

@@ -1,135 +0,0 @@
-<?php
-/**
- * @author Daniel J. Summers <daniel@bitbadger.solutions>
- * @license MIT
- */
-
-declare(strict_types=1);
-
-namespace Test\Unit\Query;
-
-use BitBadger\PDODocument\{Configuration, DocumentException, Field, Mode, Parameters};
-use BitBadger\PDODocument\Query\RemoveFields;
-use PHPUnit\Framework\Attributes\TestDox;
-use PHPUnit\Framework\TestCase;
-
-/**
- * Unit tests for the RemoveFields class
- */
-#[TestDox('Remove Fields Queries (Unit tests)')]
-class RemoveFieldsTest extends TestCase
-{
-    protected function tearDown(): void
-    {
-        Configuration::overrideMode(null);
-    }
-
-    #[TestDox('update() succeeds for PostgreSQL')]
-    public function testUpdateSucceedsForPostgreSQL(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        $this->assertEquals('UPDATE taco SET data = data - :names::text[] WHERE it = true',
-            RemoveFields::update('taco', [':names' => "{one,two}"], 'it = true'), 'UPDATE statement not correct');
-    }
-
-    #[TestDox('update() succeeds for SQLite')]
-    public function testUpdateSucceedsForSQLite(): void
-    {
-        Configuration::overrideMode(Mode::SQLite);
-        $this->assertEquals('UPDATE burrito SET data = json_remove(data, :name0, :name1, :name2) WHERE a = b',
-            RemoveFields::update('burrito', Parameters::fieldNames(':name', ['one', 'two', 'ten']), 'a = b'),
-            'UPDATE statement not correct');
-    }
-
-    #[TestDox('update() fails when mode not set')]
-    public function testUpdateFailsWhenModeNotSet(): void
-    {
-        $this->expectException(DocumentException::class);
-        RemoveFields::update('wow', [], '');
-    }
-
-    #[TestDox('byId() succeeds for PostgreSQL')]
-    public function testByIdSucceedsForPostgreSQL(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        $this->assertEquals("UPDATE churro SET data = data - :bite::text[] WHERE data->>'id' = :id",
-            RemoveFields::byId('churro', Parameters::fieldNames(':bite', ['byte'])), 'UPDATE statement not correct');
-    }
-
-    #[TestDox('byId() succeeds for SQLite')]
-    public function testByIdSucceedsForSQLite(): void
-    {
-        Configuration::overrideMode(Mode::SQLite);
-        $this->assertEquals("UPDATE quesadilla SET data = json_remove(data, :bite0) WHERE data->>'id' = :id",
-            RemoveFields::byId('quesadilla', Parameters::fieldNames(':bite', ['byte'])),
-            'UPDATE statement not correct');
-    }
-
-    #[TestDox('byId() fails when mode not set')]
-    public function testByIdFailsWhenModeNotSet(): void
-    {
-        $this->expectException(DocumentException::class);
-        RemoveFields::byId('oof', []);
-    }
-
-    #[TestDox('byFields() succeeds for PostgreSQL')]
-    public function testByFieldsSucceedsForPostgreSQL(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        $this->assertEquals("UPDATE enchilada SET data = data - :sauce::text[] WHERE data->>'cheese' = :queso",
-            RemoveFields::byFields('enchilada', [Field::equal('cheese', 'jack', ':queso')],
-                Parameters::fieldNames(':sauce', ['white'])),
-            'UPDATE statement not correct');
-    }
-
-    #[TestDox('byFields() succeeds for SQLite')]
-    public function testByFieldsSucceedsForSQLite(): void
-    {
-        Configuration::overrideMode(Mode::SQLite);
-        $this->assertEquals(
-            "UPDATE chimichanga SET data = json_remove(data, :filling0) WHERE data->>'side' = :rice",
-            RemoveFields::byFields('chimichanga', [Field::equal('side', 'beans', ':rice')],
-                Parameters::fieldNames(':filling', ['beef'])),
-            'UPDATE statement not correct');
-    }
-
-    #[TestDox('byFields() fails when mode not set')]
-    public function testByFieldsFailsWhenModeNotSet(): void
-    {
-        $this->expectException(DocumentException::class);
-        RemoveFields::byFields('boing', [], []);
-    }
-
-    #[TestDox('byContains() succeeds for PostgreSQL')]
-    public function testByContainsSucceedsForPostgreSQL(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        $this->assertEquals('UPDATE food SET data = data - :drink::text[] WHERE data @> :criteria',
-            RemoveFields::byContains('food', Parameters::fieldNames(':drink', ['a', 'b'])),
-            'UPDATE statement not correct');
-    }
-
-    #[TestDox('byContains() fails for non PostgreSQL')]
-    public function testByContainsFailsForNonPostgreSQL(): void
-    {
-        $this->expectException(DocumentException::class);
-        RemoveFields::byContains('', []);
-    }
-
-    #[TestDox('byJsonPath() succeeds for PostgreSQL')]
-    public function testByJsonPathSucceedsForPostgreSQL(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        $this->assertEquals(
-            'UPDATE dessert SET data = data - :cake::text[] WHERE jsonb_path_exists(data, :path::jsonpath)',
-            RemoveFields::byJsonPath('dessert', Parameters::fieldNames(':cake', ['b', 'c'])),
-            'UPDATE statement not correct');
-    }
-
-    #[TestDox('byJsonPath() fails for non PostgreSQL')]
-    public function testByJsonPathFailsForNonPostgreSQL(): void
-    {
-        $this->expectException(DocumentException::class);
-        RemoveFields::byJsonPath('', []);
-    }
-}

tests/unit/QueryTest.php

@@ -1,323 +0,0 @@
-<?php
-/**
- * @author Daniel J. Summers <daniel@bitbadger.solutions>
- * @license MIT
- */
-
-declare(strict_types=1);
-
-namespace Test\Unit;
-
-use BitBadger\PDODocument\{AutoId, Configuration, DocumentException, Field, FieldMatch, Mode, Query};
-use PHPUnit\Framework\Attributes\TestDox;
-use PHPUnit\Framework\TestCase;
-
-/**
- * Unit tests for the Query class
- */
-#[TestDox('Query (Unit tests)')]
-class QueryTest extends TestCase
-{
-    protected function setUp(): void
-    {
-        Configuration::overrideMode(Mode::SQLite);
-    }
-
-    protected function tearDown(): void
-    {
-        Configuration::overrideMode(null);
-    }
-
-    #[TestDox('selectFromTable() succeeds')]
-    public function testSelectFromTableSucceeds(): void
-    {
-        $this->assertEquals('SELECT data FROM testing', Query::selectFromTable('testing'),
-            'Query not constructed correctly');
-    }
-
-    #[TestDox('whereByFields() succeeds for single field')]
-    public function testWhereByFieldsSucceedsForSingleField(): void
-    {
-        $this->assertEquals("data->>'test_field' <= :it",
-            Query::whereByFields([Field::lessOrEqual('test_field', '', ':it')]),
-            'WHERE fragment not constructed correctly');
-    }
-
-    #[TestDox('whereByFields() succeeds for multiple fields All')]
-    public function testWhereByFieldsSucceedsForMultipleFieldsAll(): void
-    {
-        $this->assertEquals("data->>'test_field' <= :it AND data->>'other_field' = :other",
-            Query::whereByFields(
-                [Field::lessOrEqual('test_field', '', ':it'), Field::equal('other_field', '', ':other')]),
-            'WHERE fragment not constructed correctly');
-    }
-
-    #[TestDox('whereByFields() succeeds for multiple fields Any')]
-    public function testWhereByFieldsSucceedsForMultipleFieldsAny(): void
-    {
-        $this->assertEquals("data->>'test_field' <= :it OR data->>'other_field' = :other",
-            Query::whereByFields(
-                [Field::lessOrEqual('test_field', '', ':it'), Field::equal('other_field', '', ':other')],
-                FieldMatch::Any),
-            'WHERE fragment not constructed correctly');
-    }
-
-    #[TestDox('whereById() succeeds with default parameter')]
-    public function testWhereByIdSucceedsWithDefaultParameter(): void
-    {
-        $this->assertEquals("data->>'id' = :id", Query::whereById(), 'WHERE fragment not constructed correctly');
-    }
-
-    #[TestDox('whereById() succeeds with specific parameter')]
-    public function testWhereByIdSucceedsWithSpecificParameter(): void
-    {
-        $this->assertEquals("data->>'id' = :di", Query::whereById(':di'), 'WHERE fragment not constructed correctly');
-    }
-
-    #[TestDox('whereDataContains() succeeds with default parameter')]
-    public function testWhereDataContainsSucceedsWithDefaultParameter(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        $this->assertEquals('data @> :criteria', Query::whereDataContains(),
-            'WHERE fragment not constructed correctly');
-    }
-
-    #[TestDox('whereDataContains() succeeds with specific parameter')]
-    public function testWhereDataContainsSucceedsWithSpecifiedParameter(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        $this->assertEquals('data @> :it', Query::whereDataContains(':it'), 'WHERE fragment not constructed correctly');
-    }
-
-    #[TestDox('whereDataContains() fails if not PostgreSQL')]
-    public function testWhereDataContainsFailsIfNotPostgreSQL(): void
-    {
-        Configuration::overrideMode(null);
-        $this->expectException(DocumentException::class);
-        Query::whereDataContains();
-    }
-
-    #[TestDox('whereJsonPathMatches() succeeds with default parameter')]
-    public function testWhereJsonPathMatchesSucceedsWithDefaultParameter(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        $this->assertEquals('jsonb_path_exists(data, :path::jsonpath)', Query::whereJsonPathMatches(),
-            'WHERE fragment not constructed correctly');
-    }
-
-    #[TestDox('whereJsonPathMatches() succeeds with specified parameter')]
-    public function testWhereJsonPathMatchesSucceedsWithSpecifiedParameter(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        $this->assertEquals('jsonb_path_exists(data, :road::jsonpath)', Query::whereJsonPathMatches(':road'),
-            'WHERE fragment not constructed correctly');
-    }
-
-    #[TestDox('whereJsonPathMatches() fails if not PostgreSQL')]
-    public function testWhereJsonPathMatchesFailsIfNotPostgreSQL(): void
-    {
-        Configuration::overrideMode(null);
-        $this->expectException(DocumentException::class);
-        Query::whereJsonPathMatches();
-    }
-
-    #[TestDox('insert() succeeds with no auto-ID for PostgreSQL')]
-    public function testInsertSucceedsWithNoAutoIdForPostgreSQL(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        $this->assertEquals('INSERT INTO test_tbl VALUES (:data)', Query::insert('test_tbl'),
-            'INSERT statement not constructed correctly');
-    }
-
-    #[TestDox('insert() succeeds with no auto-ID for SQLite')]
-    public function testInsertSucceedsWithNoAutoIdForSQLite(): void
-    {
-        $this->assertEquals('INSERT INTO test_tbl VALUES (:data)', Query::insert('test_tbl'),
-            'INSERT statement not constructed correctly');
-    }
-
-    #[TestDox('insert() succeeds with auto numeric ID for PostgreSQL')]
-    public function testInsertSucceedsWithAutoNumericIdForPostgreSQL(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        $this->assertEquals(
-            "INSERT INTO test_tbl VALUES (:data::jsonb || ('{\"id\":' "
-                . "|| (SELECT COALESCE(MAX((data->>'id')::numeric), 0) + 1 FROM test_tbl) || '}')::jsonb)",
-            Query::insert('test_tbl', AutoId::Number), 'INSERT statement not constructed correctly');
-    }
-
-    #[TestDox('insert() succeeds with auto numeric ID for SQLite')]
-    public function testInsertSucceedsWithAutoNumericIdForSQLite(): void
-    {
-        $this->assertEquals(
-            "INSERT INTO test_tbl VALUES (json_set(:data, '$.id', "
-                . "(SELECT coalesce(max(data->>'id'), 0) + 1 FROM test_tbl)))",
-            Query::insert('test_tbl', AutoId::Number), 'INSERT statement not constructed correctly');
-    }
-
-    #[TestDox('insert() succeeds with auto UUID for PostgreSQL')]
-    public function testInsertSucceedsWithAutoUuidForPostgreSQL(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        $query = Query::insert('test_tbl', AutoId::UUID);
-        $this->assertStringStartsWith("INSERT INTO test_tbl VALUES (:data::jsonb || '{\"id\":\"", $query,
-            'INSERT statement not constructed correctly');
-        $this->assertStringEndsWith("\"}')", $query, 'INSERT statement not constructed correctly');
-    }
-
-    #[TestDox('insert() succeeds with auto UUID for SQLite')]
-    public function testInsertSucceedsWithAutoUuidForSQLite(): void
-    {
-        $query = Query::insert('test_tbl', AutoId::UUID);
-        $this->assertStringStartsWith("INSERT INTO test_tbl VALUES (json_set(:data, '$.id', '", $query,
-            'INSERT statement not constructed correctly');
-        $this->assertStringEndsWith("'))", $query, 'INSERT statement not constructed correctly');
-    }
-
-    #[TestDox('insert() succeeds with auto random string for PostgreSQL')]
-    public function testInsertSucceedsWithAutoRandomStringForPostgreSQL(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        Configuration::$idStringLength = 8;
-        try {
-            $query = Query::insert('test_tbl', AutoId::RandomString);
-            $this->assertStringStartsWith("INSERT INTO test_tbl VALUES (:data::jsonb || '{\"id\":\"", $query,
-                'INSERT statement not constructed correctly');
-            $this->assertStringEndsWith("\"}')", $query, 'INSERT statement not constructed correctly');
-            $id = str_replace(["INSERT INTO test_tbl VALUES (:data::jsonb || '{\"id\":\"", "\"}')"], '', $query);
-            $this->assertEquals(8, strlen($id), "Generated ID [$id] should have been 8 characters long");
-        } finally {
-            Configuration::$idStringLength = 16;
-        }
-    }
-
-    #[TestDox('insert() succeeds with auto random string for SQLite')]
-    public function testInsertSucceedsWithAutoRandomStringForSQLite(): void
-    {
-        $query = Query::insert('test_tbl', AutoId::RandomString);
-        $this->assertStringStartsWith("INSERT INTO test_tbl VALUES (json_set(:data, '$.id', '", $query,
-            'INSERT statement not constructed correctly');
-        $this->assertStringEndsWith("'))", $query, 'INSERT statement not constructed correctly');
-        $id = str_replace(["INSERT INTO test_tbl VALUES (json_set(:data, '$.id', '", "'))"], '', $query);
-        $this->assertEquals(16, strlen($id), "Generated ID [$id] should have been 16 characters long");
-    }
-
-    #[TestDox('insert() fails when mode not set')]
-    public function testInsertFailsWhenModeNotSet(): void
-    {
-        $this->expectException(DocumentException::class);
-        Configuration::overrideMode(null);
-        Query::insert('kaboom');
-    }
-
-    #[TestDox('save() succeeds')]
-    public function testSaveSucceeds(): void
-    {
-        $this->assertEquals(
-            "INSERT INTO test_tbl VALUES (:data) ON CONFLICT ((data->>'id')) DO UPDATE SET data = EXCLUDED.data",
-            Query::save('test_tbl'), 'INSERT ON CONFLICT statement not constructed correctly');
-    }
-
-    #[TestDox('update() succeeds')]
-    public function testUpdateSucceeds(): void
-    {
-        $this->assertEquals("UPDATE testing SET data = :data WHERE data->>'id' = :id", Query::update('testing'),
-            'UPDATE statement not constructed correctly');
-    }
-
-    #[TestDox('orderBy() succeeds with no fields for PostgreSQL')]
-    public function testOrderBySucceedsWithNoFieldsForPostgreSQL(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        $this->assertEquals('', Query::orderBy([]), 'ORDER BY should have been blank');
-    }
-
-    #[TestDox('orderBy() succeeds with no fields for SQLite')]
-    public function testOrderBySucceedsWithNoFieldsForSQLite(): void
-    {
-        $this->assertEquals('', Query::orderBy([]), 'ORDER BY should have been blank');
-    }
-
-    #[TestDox('orderBy() succeeds with one field and no direction for PostgreSQL')]
-    public function testOrderBySucceedsWithOneFieldAndNoDirectionForPostgreSQL(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        $this->assertEquals(" ORDER BY data->>'TestField'", Query::orderBy([Field::named('TestField')]),
-            'ORDER BY not constructed correctly');
-    }
-
-    #[TestDox('orderBy() succeeds with one field and no direction for SQLite')]
-    public function testOrderBySucceedsWithOneFieldAndNoDirectionForSQLite(): void
-    {
-        $this->assertEquals(" ORDER BY data->>'TestField'", Query::orderBy([Field::named('TestField')]),
-            'ORDER BY not constructed correctly');
-    }
-
-    #[TestDox('orderBy() succeeds with one qualified field for PostgreSQL')]
-    public function testOrderBySucceedsWithOneQualifiedFieldForPostgreSQL(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        $field = Field::named('TestField');
-        $field->qualifier = 'qual';
-        $this->assertEquals(" ORDER BY qual.data->>'TestField'", Query::orderBy([$field]),
-            'ORDER BY not constructed correctly');
-    }
-
-    #[TestDox('orderBy() succeeds with one qualified field for SQLite')]
-    public function testOrderBySucceedsWithOneQualifiedFieldForSQLite(): void
-    {
-        $field = Field::named('TestField');
-        $field->qualifier = 'qual';
-        $this->assertEquals(" ORDER BY qual.data->>'TestField'", Query::orderBy([$field]),
-            'ORDER BY not constructed correctly');
-    }
-
-    #[TestDox('orderBy() succeeds with multiple fields and direction for PostgreSQL')]
-    public function testOrderBySucceedsWithMultipleFieldsAndDirectionForPostgreSQL(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        $this->assertEquals(" ORDER BY data#>>'{Nested,Test,Field}' DESC, data->>'AnotherField', data->>'It' DESC",
-            Query::orderBy(
-                [Field::named('Nested.Test.Field DESC'), Field::named('AnotherField'), Field::named('It DESC')]),
-            'ORDER BY not constructed correctly');
-    }
-
-    #[TestDox('orderBy() succeeds with multiple fields and direction for SQLite')]
-    public function testOrderBySucceedsWithMultipleFieldsAndDirectionForSQLite(): void
-    {
-        $this->assertEquals(" ORDER BY data->'Nested'->'Test'->>'Field' DESC, data->>'AnotherField', data->>'It' DESC",
-            Query::orderBy(
-                [Field::named('Nested.Test.Field DESC'), Field::named('AnotherField'), Field::named('It DESC')]),
-            'ORDER BY not constructed correctly');
-    }
-
-    #[TestDox('orderBy() succeeds with numeric field for PostgreSQL')]
-    public function testOrderBySucceedsWithNumericFieldForPostgreSQL(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        $this->assertEquals(" ORDER BY (data->>'Test')::numeric", Query::orderBy([Field::named('n:Test')]),
-            'ORDER BY not constructed correctly');
-    }
-
-    #[TestDox('orderBy() succeeds with numeric field for SQLite')]
-    public function testOrderBySucceedsWithNumericFieldForSQLite(): void
-    {
-        $this->assertEquals(" ORDER BY data->>'Test'", Query::orderBy([Field::named('n:Test')]),
-            'ORDER BY not constructed correctly');
-    }
-
-    #[TestDox('orderBy() succeeds with case-insensitive ordering for PostgreSQL')]
-    public function testOrderBySucceedsWithCaseInsensitiveOrderingForPostgreSQL(): void
-    {
-        Configuration::overrideMode(Mode::PgSQL);
-        $this->assertEquals(" ORDER BY LOWER(data#>>'{Test,Field}') DESC NULLS FIRST",
-            Query::orderBy([Field::named('i:Test.Field DESC NULLS FIRST')]), 'ORDER BY not constructed correctly');
-    }
-
-    #[TestDox('orderBy() succeeds with case-insensitive ordering for SQLite')]
-    public function testOrderBySucceedsWithCaseInsensitiveOrderingForSQLite(): void
-    {
-        $this->assertEquals(" ORDER BY data->'Test'->>'Field' COLLATE NOCASE ASC NULLS LAST",
-            Query::orderBy([Field::named('i:Test.Field ASC NULLS LAST')]), 'ORDER BY not constructed correctly');
-    }
-}