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