CollectionFilterOperationTest.php

<?php

declare(strict_types=1);

namespace Test\TinyBlocks\Collection\Operations\Filter;

use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\TestCase;
use Test\TinyBlocks\Collection\Models\CryptoCurrency;
use TinyBlocks\Collection\Collection;
use TinyBlocks\Mapper\KeyPreservation;

final class CollectionFilterOperationTest extends TestCase
{
    public function testFilterAppliesMultiplePredicates(): void
    {
        /** @Given a collection with elements */
        $collection = Collection::createFrom(elements: [1, 2, 3, 4, 5, 6]);

        /**
         * @When filtering the collection with three predicates,
         * the first predicate filters out values less than or equal to 2,
         * the second predicate keeps only even numbers,
         * and the third predicate filters out values greater than or equal to 6.
         */
        $actual = $collection->filter(
            static fn(int $value): bool => $value > 2,
            static fn(int $value): bool => $value % 2 === 0,
            static fn(int $value): bool => $value < 6
        );

        /** @Then the filtered collection should discard the keys and return the expected values */
        self::assertSame([4], $actual->toArray(keyPreservation: KeyPreservation::DISCARD));
    }

    public function testFilterFailsIfPredicatesAreNotReindex(): void
    {
        /** @Given a collection with elements */
        $collection = Collection::createFrom(elements: [10, 20, 30]);

        /** @When filtering with a null predicate in the first position. */
        $actual = $collection->filter(
            null,
            static fn(int $value): bool => $value > 15
        );

        /** @Then the filter should still work correctly. */
        $elements = iterator_to_array($actual);

        self::assertCount(2, $elements);
        self::assertContains(20, $elements);
        self::assertContains(30, $elements);
    }

    public function testFilterIgnoresNullPredicatesAndReindexesWeights(): void
    {
        /** @Given a collection with elements */
        $collection = Collection::createFrom(elements: [1, 2, 3, 4, 5]);

        /** @When filtering using null values interspersed with valid predicates. */
        $actual = $collection->filter(
            null,
            static fn(int $value): bool => $value > 2,
            null,
            static fn(int $value): bool => $value < 5
        );

        /** @Then it should only apply the valid predicates (result should be 3 and 4) */
        self::assertSame([3, 4], $actual->toArray(keyPreservation: KeyPreservation::DISCARD));
    }

    #[DataProvider('elementsDataProvider')]
    public function testFilterAppliesDefaultArrayFilter(iterable $elements, iterable $expected): void
    {
        /** @Given a collection with elements */
        $collection = Collection::createFrom(elements: $elements);

        /** @When filtering the collection without any predicates (using default truthy filter) */
        $actual = $collection->filter();

        /** @Then the filtered collection should contain only truthy elements */
        self::assertSame(array_values((array)$expected), $actual->toArray(keyPreservation: KeyPreservation::DISCARD));
    }

    #[DataProvider('elementsDataProviderWithKeys')]
    public function testFilterPreservesKeys(iterable $elements, iterable $expected): void
    {
        /** @Given a collection with elements and keys */
        $collection = Collection::createFrom(elements: $elements);

        /** @When filtering the collection without any predicates (using default truthy filter) */
        $actual = $collection->filter();

        /** @Then the filtered collection should preserve keys for truthy elements */
        self::assertSame($expected, $actual->toArray());
    }

    public static function elementsDataProvider(): iterable
    {
        $bitcoin = new CryptoCurrency(name: 'Bitcoin', price: (float)rand(60000, 999999), symbol: 'BTC');

        yield 'Empty array' => [
            'elements' => [],
            'expected' => []
        ];

        yield 'Array with boolean values' => [
            'elements' => [false, true, false, true],
            'expected' => [true, true]
        ];

        yield 'Array with null and numbers' => [
            'elements' => [null, 1, 2, 0],
            'expected' => [1, 2]
        ];

        yield 'Array with only falsy values' => [
            'elements' => [0, '', null, false],
            'expected' => []
        ];

        yield 'Array with objects and truthy values' => [
            'elements' => [$bitcoin, 1, 'valid string'],
            'expected' => [$bitcoin->toArray(keyPreservation: KeyPreservation::DISCARD), 1, 'valid string']
        ];
    }

    public static function elementsDataProviderWithKeys(): iterable
    {
        $bitcoin = new CryptoCurrency(name: 'Bitcoin', price: 60000.0, symbol: 'BTC');

        yield 'Array with keys preserved' => [
            'elements' => ['a' => false, 'b' => true, 'c' => false, 'd' => true],
            'expected' => ['b' => true, 'd' => true]
        ];

        yield 'Mixed elements with keys' => [
            'elements' => ['first' => null, 'second' => 1, 'third' => $bitcoin],
            'expected' => ['second' => 1, 'third' => $bitcoin->toArray()]
        ];
    }
}