Migrate tests to Pest (#8)

Reviewed-on: #8

tests/Unit/Query/CountTest.php

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

tests/Unit/Query/DefinitionTest.php

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

tests/Unit/Query/DeleteTest.php

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

tests/Unit/Query/ExistsTest.php

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

tests/Unit/Query/FindTest.php

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

tests/Unit/Query/PatchTest.php

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

tests/Unit/Query/RemoveFieldsTest.php

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