Initial SQLite development (#1)

Reviewed-on: #1

tests/unit/Query/CountTest.php

@@ -0,0 +1,31 @@
+<?php declare(strict_types=1);
+
+namespace Test\Unit\Query;
+
+use BitBadger\PDODocument\{Configuration, Field, Mode};
+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()
+    {
+        Configuration::$mode = Mode::SQLite;
+        try {
+            $this->assertEquals("SELECT COUNT(*) FROM somewhere WHERE data->>'errors' > :errors",
+                Count::byFields('somewhere', [Field::GT('errors', 10, ':errors')]));
+        } finally {
+            Configuration::$mode = null;
+        }
+    }
+}

tests/unit/Query/DefinitionTest.php

@@ -0,0 +1,65 @@
+<?php declare(strict_types=1);
+
+namespace Test\Unit\Query;
+
+use BitBadger\PDODocument\{Configuration, DocumentException, Mode};
+use BitBadger\PDODocument\Query\Definition;
+use PHPUnit\Framework\Attributes\TestDox;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * Unit tests for the Definition class
+ */
+class DefinitionTest extends TestCase
+{
+    #[TestDox('Ensure table succeeds for PosgtreSQL')]
+    public function testEnsureTableSucceedsForPostgreSQL(): void
+    {
+        try {
+            Configuration::$mode = Mode::PgSQL;
+            $this->assertEquals('CREATE TABLE IF NOT EXISTS documents (data JSONB NOT NULL)',
+                Definition::ensureTable('documents'), 'CREATE TABLE statement not generated correctly');
+        } finally {
+            Configuration::$mode = null;
+        }
+    }
+
+    #[TestDox('Ensure table succeeds for SQLite')]
+    public function testEnsureTableSucceedsForSQLite(): void
+    {
+        try {
+            Configuration::$mode = Mode::SQLite;
+            $this->assertEquals('CREATE TABLE IF NOT EXISTS dox (data TEXT NOT NULL)', Definition::ensureTable('dox'),
+                'CREATE TABLE statement not generated correctly');
+        } finally {
+            Configuration::$mode = null;
+        }
+    }
+
+    public function testEnsureTableFailsWhenModeNotSet(): void
+    {
+        $this->expectException(DocumentException::class);
+        Configuration::$mode = null;
+        Definition::ensureTable('boom');
+    }
+
+    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,38 @@
+<?php declare(strict_types=1);
+
+namespace Test\Unit\Query;
+
+use BitBadger\PDODocument\{Configuration, Field, Mode};
+use BitBadger\PDODocument\Query\Delete;
+use PHPUnit\Framework\Attributes\TestDox;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * Unit tests for the Delete class
+ */
+class DeleteTest extends TestCase
+{
+    protected function setUp(): void
+    {
+        Configuration::$mode = Mode::SQLite;
+    }
+
+    protected function tearDown(): void
+    {
+        Configuration::$mode = null;
+    }
+
+    #[TestDox('By ID succeeds')]
+    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,44 @@
+<?php declare(strict_types=1);
+
+namespace Test\Unit\Query;
+
+use BitBadger\PDODocument\{Configuration, Field, Mode};
+use BitBadger\PDODocument\Query\Exists;
+use PHPUnit\Framework\Attributes\TestDox;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * Unit tests for the Exists class
+ */
+class ExistsTest extends TestCase
+{
+    protected function setUp(): void
+    {
+        Configuration::$mode = Mode::SQLite;
+    }
+
+    protected function tearDown(): void
+    {
+        Configuration::$mode = null;
+    }
+
+    public function testQuerySucceeds(): void
+    {
+        $this->assertEquals('SELECT EXISTS (SELECT 1 FROM abc WHERE def)', Exists::query('abc', 'def'),
+            'Existence query not generated correctly');
+    }
+
+    #[TestDox('By ID succeeds')]
+    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,38 @@
+<?php declare(strict_types=1);
+
+namespace Test\Unit\Query;
+
+use BitBadger\PDODocument\{Configuration, Field, Mode};
+use BitBadger\PDODocument\Query\Find;
+use PHPUnit\Framework\Attributes\TestDox;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * Unit tests for the Find class
+ */
+class FindTest extends TestCase
+{
+    protected function setUp(): void
+    {
+        Configuration::$mode = Mode::SQLite;
+    }
+
+    protected function tearDown(): void
+    {
+        Configuration::$mode = null;
+    }
+
+    #[TestDox('By ID succeeds')]
+    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/Query/PatchTest.php

@@ -0,0 +1,80 @@
+<?php declare(strict_types=1);
+
+namespace Test\Unit\Query;
+
+use BitBadger\PDODocument\{Configuration, DocumentException, Field, Mode};
+use BitBadger\PDODocument\Query\Patch;
+use PHPUnit\Framework\Attributes\TestDox;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * Unit tests for the Patch class
+ */
+class PatchTest extends TestCase
+{
+    #[TestDox('By ID succeeds for PostgreSQL')]
+    public function testByIdSucceedsForPostgreSQL(): void
+    {
+        try {
+            Configuration::$mode = Mode::PgSQL;
+            $this->assertEquals("UPDATE doc_table SET data = data || :data WHERE data->>'id' = :id",
+                Patch::byId('doc_table'), 'Patch UPDATE statement is not correct');
+        } finally {
+            Configuration::$mode = null;
+        }
+    }
+
+    #[TestDox('By ID succeeds for SQLite')]
+    public function testByIdSucceedsForSQLite(): void
+    {
+        try {
+            Configuration::$mode = Mode::SQLite;
+            $this->assertEquals("UPDATE my_table SET data = json_patch(data, json(:data)) WHERE data->>'id' = :id",
+                Patch::byId('my_table'), 'Patch UPDATE statement is not correct');
+        } finally {
+            Configuration::$mode = null;
+        }
+    }
+
+    #[TestDox('By ID fails when mode not set')]
+    public function testByIdFailsWhenModeNotSet(): void
+    {
+        $this->expectException(DocumentException::class);
+        Configuration::$mode = null;
+        Patch::byId('oof');
+    }
+
+    #[TestDox('By fields succeeds for PostgreSQL')]
+    public function testByFieldsSucceedsForPostgreSQL(): void
+    {
+        try {
+            Configuration::$mode = Mode::PgSQL;
+            $this->assertEquals("UPDATE that SET data = data || :data WHERE data->>'something' < :some",
+                Patch::byFields('that', [Field::LT('something', 17, ':some')]),
+                'Patch UPDATE statement is not correct');
+        } finally {
+            Configuration::$mode = null;
+        }
+    }
+
+    #[TestDox('By fields succeeds for SQLite')]
+    public function testByFieldsSucceedsForSQLite(): void
+    {
+        try {
+            Configuration::$mode = Mode::SQLite;
+            $this->assertEquals(
+                "UPDATE a_table SET data = json_patch(data, json(:data)) WHERE data->>'something' > :it",
+                Patch::byFields('a_table', [Field::GT('something', 17, ':it')]),
+                'Patch UPDATE statement is not correct');
+        } finally {
+            Configuration::$mode = null;
+        }
+    }
+
+    public function testByFieldsFailsWhenModeNotSet(): void
+    {
+        $this->expectException(DocumentException::class);
+        Configuration::$mode = null;
+        Patch::byFields('oops', []);
+    }
+}

tests/unit/Query/RemoveFieldsTest.php

@@ -0,0 +1,117 @@
+<?php declare(strict_types=1);
+
+namespace Test\Unit\Query;
+
+use BitBadger\PDODocument\{Configuration, DocumentException, Field, Mode, Parameters};
+use BitBadger\PDODocument\Query\RemoveFields;
+use PHPUnit\Framework\Attributes\TestDox;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * Unit tests for the RemoveFields class
+ */
+class RemoveFieldsTest extends TestCase
+{
+    #[TestDox('Update succeeds for PostgreSQL')]
+    public function testUpdateSucceedsForPostgreSQL(): void
+    {
+        try {
+            Configuration::$mode = Mode::PgSQL;
+            $this->assertEquals('UPDATE taco SET data = data - :names WHERE it = true',
+                RemoveFields::update('taco', [':names' => "ARRAY['one','two']"], 'it = true'),
+                'UPDATE statement not correct');
+        } finally {
+            Configuration::$mode = null;
+        }
+    }
+
+    #[TestDox('Update succeeds for SQLite')]
+    public function testUpdateSucceedsForSQLite(): void
+    {
+        try {
+            Configuration::$mode = Mode::SQLite;
+            $this->assertEquals('UPDATE burrito SET data = json_remove(data, :name0, :name1, :name2) WHERE a = b',
+                RemoveFields::update('burrito', Parameters::fieldNames(':name', ['one', 'two', 'ten']), 'a = b'),
+                'UPDATE statement not correct');
+        } finally {
+            Configuration::$mode = null;
+        }
+    }
+
+    public function testUpdateFailsWhenModeNotSet(): void
+    {
+        $this->expectException(DocumentException::class);
+        Configuration::$mode = null;
+        RemoveFields::update('wow', [], '');
+    }
+
+    #[TestDox('By ID succeeds for PostgreSQL')]
+    public function testByIdSucceedsForPostgreSQL()
+    {
+        try {
+            Configuration::$mode = Mode::PgSQL;
+            $this->assertEquals("UPDATE churro SET data = data - :bite WHERE data->>'id' = :id",
+                RemoveFields::byId('churro', Parameters::fieldNames(':bite', ['byte'])),
+                'UPDATE statement not correct');
+        } finally {
+            Configuration::$mode = null;
+        }
+    }
+
+    #[TestDox('By ID succeeds for SQLite')]
+    public function testByIdSucceedsForSQLite()
+    {
+        try {
+            Configuration::$mode = Mode::SQLite;
+            $this->assertEquals("UPDATE quesadilla SET data = json_remove(data, :bite0) WHERE data->>'id' = :id",
+                RemoveFields::byId('quesadilla', Parameters::fieldNames(':bite', ['byte'])),
+                'UPDATE statement not correct');
+        } finally {
+            Configuration::$mode = null;
+        }
+    }
+
+    #[TestDox('By ID fails when mode not set')]
+    public function testByIdFailsWhenModeNotSet(): void
+    {
+        $this->expectException(DocumentException::class);
+        Configuration::$mode = null;
+        RemoveFields::byId('oof', []);
+    }
+
+    #[TestDox('By fields succeeds for PostgreSQL')]
+    public function testByFieldsSucceedsForPostgreSQL()
+    {
+        try {
+            Configuration::$mode = Mode::PgSQL;
+            $this->assertEquals("UPDATE enchilada SET data = data - :sauce WHERE data->>'cheese' = :queso",
+                RemoveFields::byFields('enchilada', [Field::EQ('cheese', 'jack', ':queso')],
+                    Parameters::fieldNames(':sauce', ['white'])),
+                'UPDATE statement not correct');
+        } finally {
+            Configuration::$mode = null;
+        }
+    }
+
+    #[TestDox('By fields succeeds for SQLite')]
+    public function testByFieldsSucceedsForSQLite()
+    {
+        try {
+            Configuration::$mode = Mode::SQLite;
+            $this->assertEquals(
+                "UPDATE chimichanga SET data = json_remove(data, :filling0) WHERE data->>'side' = :rice",
+                RemoveFields::byFields('chimichanga', [Field::EQ('side', 'beans', ':rice')],
+                    Parameters::fieldNames(':filling', ['beef'])),
+                'UPDATE statement not correct');
+        } finally {
+            Configuration::$mode = null;
+        }
+    }
+
+    public function testByFieldsFailsWhenModeNotSet(): void
+    {
+        $this->expectException(DocumentException::class);
+        Configuration::$mode = null;
+        RemoveFields::byFields('boing', [], []);
+    }
+}