pdo-document/tests/integration/sqlite/FindTest.php

<?php
/**
 * @author Daniel J. Summers <daniel@bitbadger.solutions>
 * @license MIT
 */

declare(strict_types=1);

namespace Test\Integration\SQLite;

use BitBadger\PDODocument\{Custom, Delete, Document, DocumentException, Field, FieldMatch, Find};
use PHPUnit\Framework\Attributes\TestDox;
use PHPUnit\Framework\TestCase;
use Test\Integration\ArrayDocument;
use Test\Integration\TestDocument;

/**
 * SQLite integration tests for the Find class
 */
#[TestDox('Find (SQLite 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
    {
        Document::insert(ThrowawayDb::TABLE, ['id' => 18, 'value' => 'howdy']);
        $doc = Find::byId(ThrowawayDb::TABLE, 18, TestDocument::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() fails')]
    public function testByContainsFails(): void
    {
        $this->expectException(DocumentException::class);
        Find::byContains('', [], TestDocument::class);
    }

    #[TestDox('byJsonPath() fails')]
    public function testByJsonPathFails(): void
    {
        $this->expectException(DocumentException::class);
        Find::byJsonPath('', '', TestDocument::class);
    }

    #[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() fails')]
    public function testFirstByContainsFails(): void
    {
        $this->expectException(DocumentException::class);
        Find::firstByContains('', [], TestDocument::class);
    }

    #[TestDox('firstByJsonPath() fails')]
    public function testFirstByJsonPathFails(): void
    {
        $this->expectException(DocumentException::class);
        Find::firstByJsonPath('', '', TestDocument::class);
    }
}