Add $all and $elemMatch field query operator tests (mongodb#17)

* Add $all and $elemMatch query operator tests

* Accept a single Query operator in $elemMatch

* Remove variadic argument for $elemMatch operator to prevent ambiquity

Author: GromNaN

generator/config/projection/elemMatch.yaml

@@ -3,7 +3,7 @@ name: $elemMatch
 link: 'https://www.mongodb.com/docs/manual/reference/operator/projection/elemMatch/'
 type:
     - projection
-encode: object
+encode: single
 description: |
     Projects the first element in an array that matches the specified $elemMatch condition.
 arguments:

generator/config/query/all.yaml

@@ -10,5 +10,34 @@ arguments:
     -
         name: value
         type:
-            - any
+            - fieldQuery
         variadic: array
+tests:
+    -
+        name: 'Use $all to Match Values'
+        link: 'https://www.mongodb.com/docs/manual/reference/operator/query/all/#use--all-to-match-values'
+        pipeline:
+            -
+                $match:
+                    tags:
+                        $all:
+                            - 'appliance'
+                            - 'school'
+                            - 'book'
+    -
+        name: 'Use $all with $elemMatch'
+        link: 'https://www.mongodb.com/docs/manual/reference/operator/query/all/#use--all-with--elemmatch'
+        pipeline:
+            -
+                $match:
+                    qty:
+                        $all:
+                            -
+                                $elemMatch:
+                                    size: 'M'
+                                    num:
+                                        $gt: 50
+                            -
+                                $elemMatch:
+                                    num: 100
+                                    color: 'green'

generator/config/query/elemMatch.yaml

@@ -3,11 +3,66 @@ name: $elemMatch
 link: 'https://www.mongodb.com/docs/manual/reference/operator/query/elemMatch/'
 type:
     - fieldQuery
-encode: object
+encode: single
 description: |
     The $elemMatch operator matches documents that contain an array field with at least one element that matches all the specified query criteria.
 arguments:
     -
         name: query
         type:
             - query
+            - fieldQuery
+tests:
+    -
+        name: 'Element Match'
+        link: 'https://www.mongodb.com/docs/manual/reference/operator/query/elemMatch/#element-match'
+        pipeline:
+            -
+                $match:
+                    results:
+                        $elemMatch:
+                            $gte: 80
+                            $lt: 85
+    -
+        name: 'Array of Embedded Documents'
+        link: 'https://www.mongodb.com/docs/manual/reference/operator/query/elemMatch/#array-of-embedded-documents'
+        pipeline:
+            -
+                $match:
+                    results:
+                        $elemMatch:
+                            product: 'xyz'
+                            score:
+                                $gte: 8
+    -
+        name: 'Single Query Condition'
+        link: 'https://www.mongodb.com/docs/manual/reference/operator/query/elemMatch/#single-query-condition'
+        pipeline:
+            -
+                $match:
+                    results:
+                        $elemMatch:
+                            product:
+                                $ne: 'xyz'
+    -
+        name: 'Using $or with $elemMatch'
+        pipeline:
+            -
+                $match:
+                    game:
+                        $elemMatch:
+                            $or:
+                                -
+                                    score:
+                                        $gt: 10
+                                -
+                                    score:
+                                        $lt: 5
+    -
+        name: 'Single field operator'
+        pipeline:
+            -
+                $match:
+                    results:
+                        $elemMatch:
+                            $gt: 10

src/Builder/Projection/ElemMatchOperator.php

@@ -7,6 +7,7 @@
 use MongoDB\BSON\Regex;
 use MongoDB\BSON\Type;
 use MongoDB\Builder\Query\RegexOperator;
+use MongoDB\Builder\Type\CombinedFieldQuery;
 use MongoDB\Builder\Type\FieldQueryInterface;
 use MongoDB\Builder\Type\QueryInterface;
 use MongoDB\Builder\Type\QueryObject;
@@ -40,6 +41,14 @@ public static function regex(Regex|string $regex, string|null $flags = null): Re
         return self::generatedRegex($regex);
     }
 
+    /**
+     * Combine multiple field query operators that apply to a same field.
+     */
+    public static function fieldQuery(FieldQueryInterface|Type|stdClass|array|bool|float|int|string|null ...$query): FieldQueryInterface
+    {
+        return new CombinedFieldQuery($query);
+    }
+
     public static function query(QueryInterface|FieldQueryInterface|Type|stdClass|array|bool|float|int|string|null ...$query): QueryInterface
     {
         return QueryObject::create($query);

src/Builder/Query.php

@@ -0,0 +1,51 @@
+<?php
+
+declare(strict_types=1);
+
+namespace MongoDB\Tests\Builder\Query;
+
+use MongoDB\Builder\Pipeline;
+use MongoDB\Builder\Query;
+use MongoDB\Builder\Stage;
+use MongoDB\Tests\Builder\PipelineTestCase;
+
+/**
+ * Test $all query
+ */
+class AllOperatorTest extends PipelineTestCase
+{
+    public function testUseAllToMatchValues(): void
+    {
+        $pipeline = new Pipeline(
+            Stage::match(
+                tags: Query::all('appliance', 'school', 'book'),
+            ),
+        );
+
+        $this->assertSamePipeline(Pipelines::AllUseAllToMatchValues, $pipeline);
+    }
+
+    public function testUseAllWithElemMatch(): void
+    {
+        $pipeline = new Pipeline(
+            Stage::match(
+                qty: Query::all(
+                    Query::elemMatch(
+                        Query::query(
+                            size: 'M',
+                            num: Query::gt(50),
+                        ),
+                    ),
+                    Query::elemMatch(
+                        Query::query(
+                            num: 100,
+                            color: 'green',
+                        ),
+                    ),
+                ),
+            ),
+        );
+
+        $this->assertSamePipeline(Pipelines::AllUseAllWithElemMatch, $pipeline);
+    }
+}

src/Builder/Query/AllOperator.php

@@ -0,0 +1,92 @@
+<?php
+
+declare(strict_types=1);
+
+namespace MongoDB\Tests\Builder\Query;
+
+use MongoDB\Builder\Pipeline;
+use MongoDB\Builder\Query;
+use MongoDB\Builder\Stage;
+use MongoDB\Tests\Builder\PipelineTestCase;
+
+/**
+ * Test $elemMatch query
+ */
+class ElemMatchOperatorTest extends PipelineTestCase
+{
+    public function testArrayOfEmbeddedDocuments(): void
+    {
+        $pipeline = new Pipeline(
+            Stage::match(
+                results: Query::elemMatch(
+                    Query::query(
+                        product: 'xyz',
+                        score: Query::gte(8),
+                    ),
+                ),
+            ),
+        );
+
+        $this->assertSamePipeline(Pipelines::ElemMatchArrayOfEmbeddedDocuments, $pipeline);
+    }
+
+    public function testElementMatch(): void
+    {
+        $pipeline = new Pipeline(
+            Stage::match(
+                results: Query::elemMatch(
+                    Query::fieldQuery(
+                        Query::gte(80),
+                        Query::lt(85),
+                    ),
+                ),
+            ),
+        );
+
+        $this->assertSamePipeline(Pipelines::ElemMatchElementMatch, $pipeline);
+    }
+
+    public function testSingleFieldOperator(): void
+    {
+        $pipeline = new Pipeline(
+            Stage::match(
+                results: Query::elemMatch(
+                    Query::gt(10),
+                ),
+            ),
+        );
+
+        $this->assertSamePipeline(Pipelines::ElemMatchSingleFieldOperator, $pipeline);
+    }
+
+    public function testSingleQueryCondition(): void
+    {
+        $pipeline = new Pipeline(
+            Stage::match(
+                results: Query::elemMatch(
+                    Query::query(
+                        product: Query::ne('xyz'),
+                    ),
+                ),
+            ),
+        );
+
+        $this->assertSamePipeline(Pipelines::ElemMatchSingleQueryCondition, $pipeline);
+    }
+
+    public function testUsingOrWithElemMatch(): void
+    {
+        $pipeline = new Pipeline(
+            Stage::match(
+                game: Query::elemMatch(
+                    Query::or(
+                        Query::query(score: Query::gt(10)),
+                        Query::query(score: Query::lt(5)),
+                    ),
+                ),
+            ),
+        );
+
+        $this->assertSamePipeline(Pipelines::ElemMatchUsingOrWithElemMatch, $pipeline);
+    }
+}