More WIP on test migration

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": {
@@ -47,5 +47,10 @@
   },
   "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/Feature/ExampleTest.php

@@ -0,0 +1,5 @@
+<?php
+
+test('example', function () {
+    expect(true)->toBeTrue();
+});

tests/Pest.php

@@ -0,0 +1,53 @@
+<?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');
+
+/*
+|--------------------------------------------------------------------------
+| 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/TestCase.php

@@ -0,0 +1,10 @@
+<?php
+
+namespace Tests;
+
+use PHPUnit\Framework\TestCase as BaseTestCase;
+
+abstract class TestCase extends BaseTestCase
+{
+    //
+}

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/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/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/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/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/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');
-    }
-}