fix(parametervalidator): deduplicate messages

src/ParameterValidator/ParameterValidator.php

@@ -60,18 +60,24 @@ public function validateFilters(string $resourceClass, array $resourceFilters, a
 
             foreach ($filter->getDescription($resourceClass) as $name => $data) {
                 $collectionFormat = $this->getCollectionFormat($data);
+                $validatorErrors = [];
 
                 // validate simple values
                 if ($errors = $this->validate($name, $data, $queryParameters)) {
-                    $errorList[] = $errors;
+                    $validatorErrors[] = $errors;
                 }
 
                 // manipulate query data to validate each value
                 foreach ($this->iterateValue($name, $queryParameters, $collectionFormat) as $scalarQueryParameters) {
                     if ($errors = $this->validate($name, $data, $scalarQueryParameters)) {
-                        $errorList[] = $errors;
+                        $validatorErrors[] = $errors;
                     }
                 }
+
+                if (\count($validatorErrors)) {
+                    // Remove duplicate messages
+                    $errorList[] = array_unique(array_merge(...$validatorErrors));
+                }
             }
         }
 

src/ParameterValidator/Tests/ParameterValidatorTest.php

@@ -127,4 +127,111 @@ public function testOnKernelRequestWithRequiredFilter(): void
 
         $this->testedInstance->validateFilters(Dummy::class, ['some_filter'], $request);
     }
+
+    /**
+     * @dataProvider provideValidateNonScalarsCases
+     */
+    public function testValidateNonScalars(array $request, array $description, string|null $exceptionMessage): void
+    {
+        $this->filterLocatorProphecy
+            ->has('some_filter')
+            ->shouldBeCalled()
+            ->willReturn(true);
+
+        $filterProphecy = $this->prophesize(FilterInterface::class);
+        $filterProphecy
+            ->getDescription(Dummy::class)
+            ->shouldBeCalled()
+            ->willReturn($description);
+
+        $this->filterLocatorProphecy
+            ->get('some_filter')
+            ->shouldBeCalled()
+            ->willReturn($filterProphecy->reveal());
+
+        if (null !== $exceptionMessage) {
+            $this->expectException(ValidationException::class);
+            $this->expectExceptionMessageMatches('#^'.preg_quote($exceptionMessage).'$#');
+        }
+
+        $this->testedInstance->validateFilters(Dummy::class, ['some_filter'], $request);
+    }
+
+    public function provideValidateNonScalarsCases(): iterable
+    {
+        $enum = ['parameter' => [
+            'openapi' => [
+                'enum' => ['foo', 'bar'],
+            ],
+        ]];
+
+        yield 'valid values should not throw' => [
+            ['parameter' => 'bar'], $enum, null,
+        ];
+
+        yield 'invalid single scalar should still throw' => [
+            ['parameter' => 'baz'], $enum, 'Query parameter "parameter" must be one of "foo, bar"',
+        ];
+
+        yield 'invalid single value in a non scalar should throw' => [
+            ['parameter' => ['baz']], $enum, 'Query parameter "parameter" must be one of "foo, bar"',
+        ];
+
+        yield 'multiple invalid values in a non scalar should throw' => [
+            ['parameter' => ['baz', 'boo']], $enum, 'Query parameter "parameter" must be one of "foo, bar"',
+        ];
+
+        yield 'combination of valid and invalid values should throw' => [
+            ['parameter' => ['foo', 'boo']], $enum, 'Query parameter "parameter" must be one of "foo, bar"',
+        ];
+
+        yield 'duplicate valid values should throw' => [
+            ['parameter' => ['foo', 'foo']],
+            ['parameter' => [
+                'openapi' => [
+                    'enum' => ['foo', 'bar'],
+                    'uniqueItems' => true,
+                ],
+            ]],
+            'Query parameter "parameter" must contain unique values',
+        ];
+
+        yield 'if less values than allowed is provided it should throw' => [
+            ['parameter' => ['foo']],
+            ['parameter' => [
+                'openapi' => [
+                    'enum' => ['foo', 'bar'],
+                    'minItems' => 2,
+                ],
+            ]],
+            'Query parameter "parameter" must contain more than 2 values', // todo: this message does seem accurate
+        ];
+
+        yield 'if more values than allowed is provided it should throw' => [
+            ['parameter' => ['foo', 'bar', 'baz']],
+            ['parameter' => [
+                'openapi' => [
+                    'enum' => ['foo', 'bar', 'baz'],
+                    'maxItems' => 2,
+                ],
+            ]],
+            'Query parameter "parameter" must contain less than 2 values', // todo: this message does seem accurate
+        ];
+
+        yield 'for array constraints all violation should be reported' => [
+            ['parameter' => ['foo', 'foo', 'bar']],
+            ['parameter' => [
+                'openapi' => [
+                    'enum' => ['foo', 'bar'],
+                    'uniqueItems' => true,
+                    'minItems' => 1,
+                    'maxItems' => 2,
+                ],
+            ]],
+            implode(\PHP_EOL, [
+                'Query parameter "parameter" must contain less than 2 values',
+                'Query parameter "parameter" must contain unique values',
+            ]),
+        ];
+    }
 }