collection/tests/Operations/Aggregate/CollectionReduceOperationTest.php at cde50e288532ecf0e080438f856de5c44d2460d9 · tiny-blocks/collection · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
<?php

declare(strict_types=1);

namespace Test\TinyBlocks\Collection\Operations\Aggregate;

use PHPUnit\Framework\TestCase;
use Test\TinyBlocks\Collection\Models\InvoiceSummaries;
use Test\TinyBlocks\Collection\Models\InvoiceSummary;

final class CollectionReduceOperationTest extends TestCase
{
    public function testSumByCustomer(): void
    {
        /** @Given a collection of invoice summaries */
        $summaries = InvoiceSummaries::createFrom(elements: [
            new InvoiceSummary(amount: 100.0, customer: 'Customer A'),
            new InvoiceSummary(amount: 150.5, customer: 'Customer A'),
            new InvoiceSummary(amount: 200.75, customer: 'Customer B')
        ]);

        /** @When summing the amounts for customer 'Customer A' */
        $actual = $summaries->sumByCustomer(customer: 'Customer A');

        /** @Then the total amount for 'Customer A' should be 250.5 */
        self::assertSame(250.5, $actual);
    }

    public function testReduceSumOfNumbers(): void
    {
        /** @Given a collection of numbers */
        $numbers = InvoiceSummaries::createFrom(elements: [1, 2, 3, 4, 5]);

        /** @When reducing the collection to a sum */
        $actual = $numbers->reduce(
            aggregator: static fn(int $carry, int $number): int => $carry + $number,
            initial: 0
        );

        /** @Then the sum should be correct */
        self::assertSame(15, $actual);
    }

    public function testReduceProductOfNumbers(): void
    {
        /** @Given a collection of numbers */
        $numbers = InvoiceSummaries::createFrom(elements: [1, 2, 3, 4]);

        /** @When reducing the collection to a product */
        $actual = $numbers->reduce(
            aggregator: static fn(int $carry, int $number): int => $carry * $number,
            initial: 1
        );

        /** @Then the product should be correct */
        self::assertSame(24, $actual);
    }

    public function testReduceWhenNoMatchFound(): void
    {
        /** @Given a collection of invoice summaries */
        $summaries = InvoiceSummaries::createFrom(elements: [
            new InvoiceSummary(amount: 100.0, customer: 'Customer A'),
            new InvoiceSummary(amount: 150.5, customer: 'Customer A'),
            new InvoiceSummary(amount: 200.75, customer: 'Customer B')
        ]);

        /** @When reducing the collection for a customer with no match */
        $actual = $summaries
            ->filter(predicates: static fn(InvoiceSummary $summary): bool => $summary->customer === 'Customer C')
            ->reduce(aggregator: static fn(float $carry, InvoiceSummary $summary): float => $carry + $summary->amount,
                initial: 0.0);

        /** @Then the total amount for 'Customer C' should be zero */
        self::assertSame(0.0, $actual);
    }

    public function testReduceWithMixedDataTypes(): void
    {
        /** @Given a collection with mixed data types */
        $mixedData = InvoiceSummaries::createFrom(elements: [1, 'string', 3.14, true]);

        /** @When reducing the collection by concatenating values as strings */
        $actual = $mixedData->reduce(
            aggregator: static fn(string $carry, mixed $value): string => $carry . $value,
            initial: ''
        );

        /** @Then the concatenated string should be correct */
        self::assertSame('1string3.141', $actual);
    }

    public function testReduceSumForEmptyCollection(): void
    {
        /** @Given an empty collection of invoice summaries */
        $summaries = InvoiceSummaries::createFrom(elements: []);

        /** @When reducing an empty collection */
        $actual = $summaries->reduce(
            aggregator: static fn(float $carry, InvoiceSummary $summary): float => $carry + $summary->amount,
            initial: 0.0
        );

        /** @Then the total amount should be zero */
        self::assertSame(0.0, $actual);
    }

    public function testReduceWithDifferentInitialValue(): void
    {
        /** @Given a collection of invoice summaries */
        $summaries = InvoiceSummaries::createFrom(elements: [
            new InvoiceSummary(amount: 100.0, customer: 'Customer A'),
            new InvoiceSummary(amount: 150.5, customer: 'Customer A'),
            new InvoiceSummary(amount: 200.75, customer: 'Customer B')
        ]);

        /** @When summing the amounts for customer 'Customer A' with an initial value of 50 */
        $actual = $summaries
            ->filter(predicates: static fn(InvoiceSummary $summary): bool => $summary->customer === 'Customer A')
            ->reduce(aggregator: static fn(float $carry, InvoiceSummary $summary): float => $carry + $summary->amount,
                initial: 50.0);

        /** @Then the total amount for 'Customer A' should be 300.5 */
        self::assertSame(300.5, $actual);
    }
}