Add tests on $minN accumulator

Author: GromNaN

generator/config/accumulator/minN.yaml

@@ -20,3 +20,54 @@ arguments:
             - resolvesToInt
         description: |
             An expression that resolves to a positive integer. The integer specifies the number of array elements that $maxN returns.
+tests:
+    -
+        name: 'Find the Minimum Three Scores for a Single Game'
+        link: 'https://www.mongodb.com/docs/manual/reference/operator/aggregation/minN/#find-the-minimum-three-scores-for-a-single-game'
+        pipeline:
+            -
+                $match:
+                    gameId: 'G1'
+            -
+                $group:
+                    _id: '$gameId'
+                    minScores:
+                        $minN:
+                            input:
+                                - '$score'
+                                - '$playerId'
+                            n: 3
+    -
+        name: 'Finding the Minimum Three Documents Across Multiple Games'
+        link: 'https://www.mongodb.com/docs/manual/reference/operator/aggregation/minN/#finding-the-minimum-three-documents-across-multiple-games'
+        pipeline:
+            -
+                $group:
+                    _id: '$gameId'
+                    minScores:
+                        $minN:
+                            input:
+                                - '$score'
+                                - '$playerId'
+                            n: 3
+    -
+        name: 'Computing n Based on the Group Key for $group'
+        link: 'https://www.mongodb.com/docs/manual/reference/operator/aggregation/minN/#computing-n-based-on-the-group-key-for--group'
+        pipeline:
+            -
+                $group:
+                    _id:
+                        gameId: '$gameId'
+                    gamescores:
+                        $minN:
+                            input:
+                                - '$score'
+                                - '$playerId'
+                            n:
+                                $cond:
+                                    if:
+                                        $eq:
+                                            - '$gameId'
+                                            - 'G2'
+                                    then: 1
+                                    else: 3

tests/Builder/Accumulator/DenseRankAccumulatorTest.php

@@ -45,6 +45,7 @@ public function testDenseRankPartitionsByAnIntegerField(): void
                     quantity: -1,
                 ),
                 output: object(
+                    // The outputWindow is optional when no window property is set.
                     denseRankQuantityForState: Accumulator::denseRank(),
                 ),
             ),

tests/Builder/Accumulator/MinNAccumulatorTest.php

@@ -0,0 +1,85 @@
+<?php
+
+declare(strict_types=1);
+
+namespace MongoDB\Tests\Builder\Accumulator;
+
+use MongoDB\Builder\Accumulator;
+use MongoDB\Builder\Expression;
+use MongoDB\Builder\Pipeline;
+use MongoDB\Builder\Stage;
+use MongoDB\Tests\Builder\PipelineTestCase;
+
+use function MongoDB\object;
+
+/**
+ * Test $minN accumulator
+ */
+class MinNAccumulatorTest extends PipelineTestCase
+{
+    public function testComputingNBasedOnTheGroupKeyForGroup(): void
+    {
+        $pipeline = new Pipeline(
+            Stage::group(
+                _id: object(
+                    gameId: Expression::fieldPath('gameId'),
+                ),
+                gamescores: Accumulator::minN(
+                    input: [
+                        Expression::fieldPath('score'),
+                        Expression::fieldPath('playerId'),
+                    ],
+                    n: Expression::cond(
+                        if: Expression::eq(
+                            Expression::fieldPath('gameId'),
+                            'G2',
+                        ),
+                        then: 1,
+                        else: 3,
+                    ),
+                ),
+            ),
+        );
+
+        $this->assertSamePipeline(Pipelines::MinNComputingNBasedOnTheGroupKeyForGroup, $pipeline);
+    }
+
+    public function testFindTheMinimumThreeScoresForASingleGame(): void
+    {
+        $pipeline = new Pipeline(
+            Stage::match(
+                gameId: 'G1',
+            ),
+            Stage::group(
+                _id: Expression::fieldPath('gameId'),
+                minScores: Accumulator::minN(
+                    input: [
+                        Expression::fieldPath('score'),
+                        Expression::fieldPath('playerId'),
+                    ],
+                    n: 3,
+                ),
+            ),
+        );
+
+        $this->assertSamePipeline(Pipelines::MinNFindTheMinimumThreeScoresForASingleGame, $pipeline);
+    }
+
+    public function testFindingTheMinimumThreeDocumentsAcrossMultipleGames(): void
+    {
+        $pipeline = new Pipeline(
+            Stage::group(
+                _id: Expression::fieldPath('gameId'),
+                minScores: Accumulator::minN(
+                    input: [
+                        Expression::fieldPath('score'),
+                        Expression::fieldPath('playerId'),
+                    ],
+                    n: 3,
+                ),
+            ),
+        );
+
+        $this->assertSamePipeline(Pipelines::MinNFindingTheMinimumThreeDocumentsAcrossMultipleGames, $pipeline);
+    }
+}