Add classes and tests from common project

tests/unit/ConfigurationTest.php

@@ -0,0 +1,28 @@
+<?php declare(strict_types=1);
+
+namespace Test\Unit;
+
+use BitBadger\PDODocument\Configuration;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * Unit tests for the Configuration class
+ */
+class ConfigurationTest extends TestCase
+{
+    public function testIdFieldDefaultSucceeds(): void
+    {
+        $this->assertEquals('id', Configuration::idField(), 'Default ID field should be "id"');
+    }
+
+    public function testUseIdFieldSucceeds()
+    {
+        try {
+            Configuration::useIdField('EyeDee');
+            $this->assertEquals('EyeDee', Configuration::idField(), 'ID field should have been updated');
+        } finally {
+            Configuration::useIdField('id');
+            $this->assertEquals('id', Configuration::idField(), 'Default ID value should have been restored');
+        }
+    }
+}

tests/unit/DocumentExceptionTest.php

@@ -0,0 +1,46 @@
+<?php
+
+namespace Test\Unit;
+
+use BitBadger\PDODocument\DocumentException;
+use Exception;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * Unit tests for the DocumentException class
+ */
+class DocumentExceptionTest extends TestCase
+{
+    public function testConstructorSucceedsWithCodeAndPriorException()
+    {
+        $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()
+    {
+        $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');
+    }
+
+    public function testToStringSucceedsWithoutCode()
+    {
+        $ex = new DocumentException('Test failure');
+        $this->assertEquals("BitBadger\PDODocument\DocumentException: Test failure\n", "$ex",
+            'toString not generated correctly');
+    }
+
+    public function testToStringSucceedsWithCode()
+    {
+        $ex = new DocumentException('Oof', -6);
+        $this->assertEquals("BitBadger\PDODocument\DocumentException: [-6] Oof\n", "$ex",
+            'toString not generated correctly');
+    }
+}

tests/unit/FieldTest.php

@@ -0,0 +1,257 @@
+<?php declare(strict_types=1);
+
+namespace Test\Unit;
+
+use BitBadger\PDODocument\Field;
+use BitBadger\PDODocument\Op;
+use PHPUnit\Framework\Attributes\TestDox;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * Unit tests for the Field class
+ */
+class FieldTest extends TestCase
+{
+    #[TestDox('Append parameter succeeds for EX')]
+    public function testAppendParameterSucceedsForEX(): void
+    {
+        $this->assertEquals([], Field::EX('exists')->appendParameter([]), 'EX should not have appended a parameter');
+    }
+
+    #[TestDox('Append parameter succeeds for NEX')]
+    public function testAppendParameterSucceedsForNEX(): void
+    {
+        $this->assertEquals([], Field::NEX('absent')->appendParameter([]), 'NEX should not have appended a parameter');
+    }
+
+    #[TestDox('Append parameter succeeds for BT')]
+    public function testAppendParameterSucceedsForBT(): void
+    {
+        $this->assertEquals(['@nummin' => 5, '@nummax' => 9], Field::BT('exists', 5, 9, '@num')->appendParameter([]),
+            'BT should have appended min and max parameters');
+    }
+
+    public function testAppendParameterSucceedsForOthers(): void
+    {
+        $this->assertEquals(['@test' => 33], Field::EQ('the_field', 33, '@test')->appendParameter([]),
+            'Field parameter not returned correctly');
+    }
+
+    #[TestDox('To where succeeds for EX without qualifier')]
+    public function testToWhereSucceedsForEXWithoutQualifier(): void
+    {
+        $this->assertEquals("data->>'that_field' IS NOT NULL", Field::EX('that_field')->toWhere(),
+            'WHERE fragment not generated correctly');
+    }
+
+    #[TestDox('To where succeeds for NEX without qualifier')]
+    public function testToWhereSucceedsForNEXWithoutQualifier(): void
+    {
+        $this->assertEquals("data->>'a_field' IS NULL", Field::NEX('a_field')->toWhere(),
+            'WHERE fragment not generated correctly');
+    }
+
+    #[TestDox('To where succeeds for BT without qualifier')]
+    public function testToWhereSucceedsForBTWithoutQualifier(): void
+    {
+        $this->assertEquals("data->>'age' BETWEEN @agemin AND @agemax", Field::BT('age', 13, 17, '@age')->toWhere(),
+            'WHERE fragment not generated correctly');
+    }
+
+    public function testToWhereSucceedsForOthersWithoutQualifier(): void
+    {
+        $this->assertEquals("data->>'some_field' = @value", Field::EQ('some_field', '', '@value')->toWhere(),
+            'WHERE fragment not generated correctly');
+    }
+
+    public function testToWhereSucceedsWithQualifierNoParameter(): void
+    {
+        $field = Field::EX('no_field');
+        $field->qualifier = 'test';
+        $this->assertEquals("test.data->>'no_field' IS NOT NULL", $field->toWhere(),
+            'WHERE fragment not generated correctly');
+    }
+
+    public function testToWhereSucceedsWithQualifierAndParameter(): void
+    {
+        $field = Field::LE('le_field', 18, '@it');
+        $field->qualifier = 'q';
+        $this->assertEquals("q.data->>'le_field' <= @it", $field->toWhere(), 'WHERE fragment not generated correctly');
+    }
+
+    #[TestDox('EQ succeeds without parameter')]
+    public function testEQSucceedsWithoutParameter(): void
+    {
+        $field = Field::EQ('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::EQ, $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('EQ succeeds with parameter')]
+    public function testEQSucceedsWithParameter(): void
+    {
+        $field = Field::EQ('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::EQ, $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('GT succeeds without parameter')]
+    public function testGTSucceedsWithoutParameter(): void
+    {
+        $field = Field::GT('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::GT, $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('GT succeeds with parameter')]
+    public function testGTSucceedsWithParameter(): void
+    {
+        $field = Field::GT('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::GT, $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('GE succeeds without parameter')]
+    public function testGESucceedsWithoutParameter(): void
+    {
+        $field = Field::GE('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::GE, $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('GE succeeds with parameter')]
+    public function testGESucceedsWithParameter(): void
+    {
+        $field = Field::GE('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::GE, $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('LT succeeds without parameter')]
+    public function testLTSucceedsWithoutParameter(): void
+    {
+        $field = Field::LT('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::LT, $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('LT succeeds with parameter')]
+    public function testLTSucceedsWithParameter(): void
+    {
+        $field = Field::LT('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::LT, $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('LE succeeds without parameter')]
+    public function testLESucceedsWithoutParameter(): void
+    {
+        $field = Field::LE('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::LE, $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('LE succeeds with parameter')]
+    public function testLESucceedsWithParameter(): void
+    {
+        $field = Field::LE('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::LE, $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('NE succeeds without parameter')]
+    public function testNESucceedsWithoutParameter(): void
+    {
+        $field = Field::NE('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::NE, $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('NE succeeds with parameter')]
+    public function testNESucceedsWithParameter(): void
+    {
+        $field = Field::NE('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::NE, $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('BT succeeds without parameter')]
+    public function testBTSucceedsWithoutParameter(): void
+    {
+        $field = Field::BT('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::BT, $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('BT succeeds with parameter')]
+    public function testBTSucceedsWithParameter(): void
+    {
+        $field = Field::BT('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::BT, $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('EX succeeds')]
+    public function testEXSucceeds(): void
+    {
+        $field = Field::EX('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::EX, $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('NEX succeeds')]
+    public function testNEXSucceeds(): void
+    {
+        $field = Field::NEX('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::NEX, $field->op, 'Operation not filled correctly');
+        $this->assertEquals('', $field->value, 'Value should have been blank');
+        $this->assertEquals('', $field->paramName, 'Parameter name should have been blank');
+    }
+}

tests/unit/Mapper/ArrayMapperTest.php

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

tests/unit/Mapper/JsonMapperTest.php

@@ -0,0 +1,57 @@
+<?php declare(strict_types=1);
+
+namespace Test\Unit\Mapper;
+
+use BitBadger\PDODocument\DocumentException;
+use BitBadger\PDODocument\Field;
+use BitBadger\PDODocument\Mapper\JsonMapper;
+use PHPUnit\Framework\Attributes\TestDox;
+use PHPUnit\Framework\TestCase;
+
+// ** Test class hierarchy for serialization **
+
+class SubDocument
+{
+    public function __construct(public int $id = 0, public string $name = '') { }
+}
+
+class TestDocument
+{
+    public function __construct(public int $id = 0, public SubDocument $subDoc = new SubDocument()) { }
+}
+
+/**
+ * Unit tests for the JsonMapper class
+ */
+class JsonMapperTest extends TestCase
+{
+    public function testConstructorSucceedsWithDefaultField(): void
+    {
+        $mapper = new JsonMapper(Field::class);
+        $this->assertEquals('data', $mapper->fieldName, 'Default field name should have been "data"');
+    }
+
+    public function testConstructorSucceedsWithSpecifiedField(): void
+    {
+        $mapper = new JsonMapper(Field::class, 'json');
+        $this->assertEquals('json', $mapper->fieldName, 'Field name not recorded correctly');
+    }
+
+    #[TestDox('Map succeeds with valid JSON')]
+    public function testMapSucceedsWithValidJSON(): void
+    {
+        $doc = (new JsonMapper(TestDocument::class))->map(['data' => '{"id":7,"subDoc":{"id":22,"name":"tester"}}']);
+        $this->assertNotNull($doc, 'The document should not have been null');
+        $this->assertEquals(7, $doc->id, 'ID not filled correctly');
+        $this->assertNotNull($doc->subDoc, 'The sub-document should not have been null');
+        $this->assertEquals(22, $doc->subDoc->id, 'Sub-document ID not filled correctly');
+        $this->assertEquals('tester', $doc->subDoc->name, 'Sub-document name not filled correctly');
+    }
+
+    #[TestDox('Map fails with invalid JSON')]
+    public function testMapFailsWithInvalidJSON(): void
+    {
+        $this->expectException(DocumentException::class);
+        (new JsonMapper(TestDocument::class))->map(['data' => 'this is not valid']);
+    }
+}

tests/unit/Mapper/StringMapperTest.php

@@ -0,0 +1,29 @@
+<?php declare(strict_types=1);
+
+namespace Test\Unit\Mapper;
+
+use BitBadger\PDODocument\Mapper\StringMapper;
+use PHPUnit\Framework\TestCase;
+
+class StringMapperTest extends TestCase
+{
+    public function testMapSucceedsWhenFieldIsPresentAndString()
+    {
+        $result = ['test_field' => 'test_value'];
+        $mapper = new StringMapper('test_field');
+        $this->assertEquals('test_value', $mapper->map($result), 'String value not returned correctly');
+    }
+
+    public function testMapSucceedsWhenFieldIsPresentAndNotString()
+    {
+        $result = ['a_number' => 6.7];
+        $mapper = new StringMapper('a_number');
+        $this->assertEquals('6.7', $mapper->map($result), 'Number value not returned correctly');
+    }
+
+    public function testMapSucceedsWhenFieldIsNotPresent()
+    {
+        $mapper = new StringMapper('something_else');
+        $this->assertNull($mapper->map([]), 'Missing value not returned correctly');
+    }
+}

tests/unit/OpTest.php

@@ -0,0 +1,67 @@
+<?php 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
+ */
+class OpTest extends TestCase
+{
+    #[TestDox('To string succeeds for EQ')]
+    public function testToStringSucceedsForEQ(): void
+    {
+        $this->assertEquals('=', Op::EQ->toString(), 'EQ operator incorrect');
+    }
+
+    #[TestDox('To string succeeds for GT')]
+    public function testToStringSucceedsForGT(): void
+    {
+        $this->assertEquals('>', Op::GT->toString(), 'GT operator incorrect');
+    }
+
+    #[TestDox('To string succeeds for GE')]
+    public function testToStringSucceedsForGE(): void
+    {
+        $this->assertEquals('>=', Op::GE->toString(), 'GE operator incorrect');
+    }
+
+    #[TestDox('To string succeeds for LT')]
+    public function testToStringSucceedsForLT(): void
+    {
+        $this->assertEquals('<', Op::LT->toString(), 'LT operator incorrect');
+    }
+
+    #[TestDox('To string succeeds for LE')]
+    public function testToStringSucceedsForLE(): void
+    {
+        $this->assertEquals('<=', Op::LE->toString(), 'LE operator incorrect');
+    }
+
+    #[TestDox('To string succeeds for NE')]
+    public function testToStringSucceedsForNE(): void
+    {
+        $this->assertEquals('<>', Op::NE->toString(), 'NE operator incorrect');
+    }
+
+    #[TestDox('To string succeeds for BT')]
+    public function testToStringSucceedsForBT(): void
+    {
+        $this->assertEquals('BETWEEN', Op::BT->toString(), 'BT operator incorrect');
+    }
+
+    #[TestDox('To string succeeds for EX')]
+    public function testToStringSucceedsForEX(): void
+    {
+        $this->assertEquals('IS NOT NULL', Op::EX->toString(), 'EX operator incorrect');
+    }
+
+    #[TestDox('To string succeeds for NEX')]
+    public function testToStringSucceedsForNEX(): void
+    {
+        $this->assertEquals('IS NULL', Op::NEX->toString(), 'NEX operator incorrect');
+    }
+}

tests/unit/Query/CountTest.php

@@ -0,0 +1,26 @@
+<?php declare(strict_types=1);
+
+namespace Test\Unit\Query;
+
+use BitBadger\PDODocument\Field;
+use BitBadger\PDODocument\Query\Count;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * Unit tests for the Count class
+ */
+class CountTest extends TestCase
+{
+
+    public function testAllSucceeds()
+    {
+        $this->assertEquals('SELECT COUNT(*) FROM a_table', Count::all('a_table'),
+            'SELECT statement not generated correctly');
+    }
+
+    public function testByFieldsSucceeds()
+    {
+        $this->assertEquals("SELECT COUNT(*) FROM somewhere WHERE data->>'errors' > @errors",
+            Count::byFields('somewhere', [Field::GT('errors', 10, '@errors')]));
+    }
+}

tests/unit/Query/DefinitionTest.php

@@ -0,0 +1,38 @@
+<?php declare(strict_types=1);
+
+namespace Test\Unit\Query;
+
+use BitBadger\PDODocument\Query\Definition;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * Unit tests for the Definition class
+ */
+class DefinitionTest extends TestCase
+{
+    public function testEnsureTableForSucceeds(): void
+    {
+        $this->assertEquals('CREATE TABLE IF NOT EXISTS documents (data JSON NOT NULL)',
+            Definition::ensureTableFor('documents', 'JSON'), 'CREATE TABLE statement not generated correctly');
+    }
+
+    public function testEnsureIndexOnSucceedsWithoutSchemaSingleAscendingField(): void
+    {
+        $this->assertEquals("CREATE INDEX IF NOT EXISTS idx_test_fields ON test ((data->>'details'))",
+            Definition::ensureIndexOn('test', 'fields', ['details']), 'CREATE INDEX statement not generated correctly');
+    }
+
+    public function testEnsureIndexOnSucceedsWithSchemaMultipleFields(): void
+    {
+        $this->assertEquals(
+            "CREATE INDEX IF NOT EXISTS idx_testing_json ON sch.testing ((data->>'group'), (data->>'sub_group') DESC)",
+            Definition::ensureIndexOn('sch.testing', 'json', ['group', 'sub_group DESC']),
+            'CREATE INDEX statement not generated correctly');
+    }
+
+    public function testEnsureKey(): void
+    {
+        $this->assertEquals("CREATE UNIQUE INDEX IF NOT EXISTS idx_tbl_key ON tbl ((data->>'id'))",
+            Definition::ensureKey('tbl'), 'CREATE INDEX statement for document key not generated correctly');
+    }
+}

tests/unit/Query/DeleteTest.php

@@ -0,0 +1,26 @@
+<?php declare(strict_types=1);
+
+namespace Test\Unit\Query;
+
+use BitBadger\PDODocument\Field;
+use BitBadger\PDODocument\Query\Delete;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * Unit tests for the Delete class
+ */
+class DeleteTest extends TestCase
+{
+    public function testByIdSucceeds(): void
+    {
+        $this->assertEquals("DELETE FROM over_there WHERE data->>'id' = @id", Delete::byId('over_there'),
+            'DELETE statement not constructed correctly');
+    }
+
+    public function testByFieldsSucceeds(): void
+    {
+        $this->assertEquals("DELETE FROM my_table WHERE data->>'value' < @max AND data->>'value' >= @min",
+            Delete::byFields('my_table', [Field::LT('value', 99, '@max'), Field::GE('value', 18, '@min')]),
+            'DELETE statement not constructed correctly');
+    }
+}

tests/unit/Query/ExistsTest.php

@@ -0,0 +1,32 @@
+<?php declare(strict_types=1);
+
+namespace Test\Unit\Query;
+
+use BitBadger\PDODocument\Field;
+use BitBadger\PDODocument\Query\Exists;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * Unit tests for the Exists class
+ */
+class ExistsTest extends TestCase
+{
+    public function testQuerySucceeds(): void
+    {
+        $this->assertEquals('SELECT EXISTS (SELECT 1 FROM abc WHERE def)', Exists::query('abc', 'def'),
+            'Existence query not generated correctly');
+    }
+
+    public function testByIdSucceeds(): void
+    {
+        $this->assertEquals("SELECT EXISTS (SELECT 1 FROM dox WHERE data->>'id' = @id)", Exists::byId('dox'),
+            'Existence query not generated correctly');
+    }
+
+    public function testByFieldsSucceeds(): void
+    {
+        $this->assertEquals("SELECT EXISTS (SELECT 1 FROM box WHERE data->>'status' <> @status)",
+            Exists::byFields('box', [Field::NE('status', 'occupied', '@status')]),
+            'Existence query not generated correctly');
+    }
+}

tests/unit/Query/FindTest.php

@@ -0,0 +1,26 @@
+<?php declare(strict_types=1);
+
+namespace Test\Unit\Query;
+
+use BitBadger\PDODocument\Field;
+use BitBadger\PDODocument\Query\Find;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * Unit tests for the Find class
+ */
+class FindTest extends TestCase
+{
+    public function testByIdSucceeds(): void
+    {
+        $this->assertEquals("SELECT data FROM here WHERE data->>'id' = @id", Find::byId('here'),
+            'SELECT query not generated correctly');
+    }
+
+    public function testByFieldsSucceeds(): void
+    {
+        $this->assertEquals("SELECT data FROM there WHERE data->>'active' = @act OR data->>'locked' = @lock",
+            Find::byFields('there', [Field::EQ('active', true, '@act'), Field::EQ('locked', true, '@lock')], 'OR'),
+            'SELECT query not generated correctly');
+    }
+}

tests/unit/QueryTest.php

@@ -0,0 +1,68 @@
+<?php declare(strict_types=1);
+
+namespace Test\Unit;
+
+use BitBadger\PDODocument\Field;
+use BitBadger\PDODocument\Query;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * Unit tests for the Query class
+ */
+class QueryTest extends TestCase
+{
+    public function testSelectFromTableSucceeds(): void
+    {
+        $this->assertEquals('SELECT data FROM testing', Query::selectFromTable('testing'),
+            'Query not constructed correctly');
+    }
+
+    public function testWhereByFieldsSucceedsForSingleField(): void
+    {
+        $this->assertEquals("data->>'test_field' <= @it",
+            Query::whereByFields([Field::LE('test_field', '', '@it')]), 'WHERE fragment not constructed correctly');
+    }
+
+    public function testWhereByFieldsSucceedsForMultipleFields(): void
+    {
+        $this->assertEquals("data->>'test_field' <= @it AND data->>'other_field' = @other",
+            Query::whereByFields([Field::LE('test_field', '', '@it'), Field::EQ('other_field', '', '@other')]),
+            'WHERE fragment not constructed correctly');
+    }
+
+    public function testWhereByFieldsSucceedsForMultipleFieldsWithOr(): void
+    {
+        $this->assertEquals("data->>'test_field' <= @it OR data->>'other_field' = @other",
+            Query::whereByFields([Field::LE('test_field', '', '@it'), Field::EQ('other_field', '', '@other')], 'OR'),
+            'WHERE fragment not constructed correctly');
+    }
+
+    public function testWhereByIdSucceedsWithDefaultParameter(): void
+    {
+        $this->assertEquals("data->>'id' = @id", Query::whereById(), 'WHERE fragment not constructed correctly');
+    }
+
+    public function testWhereByIdSucceedsWithSpecificParameter(): void
+    {
+        $this->assertEquals("data->>'id' = @di", Query::whereById('@di'), 'WHERE fragment not constructed correctly');
+    }
+
+    public function testInsertSucceeds(): void
+    {
+        $this->assertEquals('INSERT INTO my_table VALUES (@data)', Query::insert('my_table'),
+            'INSERT statement not constructed correctly');
+    }
+
+    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');
+    }
+
+    public function testUpdateSucceeds()
+    {
+        $this->assertEquals("UPDATE testing SET data = @data WHERE data->>'id' = @id", Query::update('testing'),
+            'UPDATE statement not constructed correctly');
+    }
+}