Merge branch '3.4' into 4.4

* 3.4:
  add validator translation 99 for Italian language
  stop using the deprecated at() PHPUnit matcher
  Fix typehint phpdoc

Author: fabpot

Resources/translations/validators.it.xlf

@@ -382,6 +382,10 @@
                 <source>Each element of this collection should satisfy its own set of constraints.</source>
                 <target>Ciascun elemento di questa collezione dovrebbe soddisfare il suo insieme di vincoli.</target>
             </trans-unit>
+            <trans-unit id="99">
+                <source>This value is not a valid International Securities Identification Number (ISIN).</source>
+                <target>Questo valore non è un codice identificativo internazionale di valori mobiliari (ISIN) valido.</target>
+            </trans-unit>
         </body>
     </file>
 </xliff>

Test/ConstraintValidatorTestCase.php

@@ -12,15 +12,22 @@
 namespace Symfony\Component\Validator\Test;
 
 use PHPUnit\Framework\Assert;
+use PHPUnit\Framework\Constraint\IsIdentical;
+use PHPUnit\Framework\Constraint\IsInstanceOf;
+use PHPUnit\Framework\Constraint\IsNull;
+use PHPUnit\Framework\Constraint\LogicalOr;
+use PHPUnit\Framework\ExpectationFailedException;
 use PHPUnit\Framework\TestCase;
 use Symfony\Component\Validator\Constraint;
 use Symfony\Component\Validator\Constraints\NotNull;
+use Symfony\Component\Validator\Constraints\Valid;
 use Symfony\Component\Validator\ConstraintValidatorInterface;
 use Symfony\Component\Validator\ConstraintViolation;
 use Symfony\Component\Validator\Context\ExecutionContext;
 use Symfony\Component\Validator\Context\ExecutionContextInterface;
 use Symfony\Component\Validator\Mapping\ClassMetadata;
 use Symfony\Component\Validator\Mapping\PropertyMetadata;
+use Symfony\Component\Validator\Validator\ContextualValidatorInterface;
 use Symfony\Contracts\Translation\TranslatorInterface;
 
 /**
@@ -101,7 +108,6 @@ protected function createContext()
         $translator = $this->getMockBuilder(TranslatorInterface::class)->getMock();
         $translator->expects($this->any())->method('trans')->willReturnArgument(0);
         $validator = $this->getMockBuilder('Symfony\Component\Validator\Validator\ValidatorInterface')->getMock();
-        $contextualValidator = $this->getMockBuilder('Symfony\Component\Validator\Validator\ContextualValidatorInterface')->getMock();
 
         $context = new ExecutionContext($validator, $this->root, $translator);
         $context->setGroup($this->group);
@@ -111,7 +117,7 @@ protected function createContext()
         $validator->expects($this->any())
             ->method('inContext')
             ->with($context)
-            ->willReturn($contextualValidator);
+            ->willReturn(new AssertingContextualValidator());
 
         return $context;
     }
@@ -164,36 +170,26 @@ protected function setPropertyPath($propertyPath)
     protected function expectNoValidate()
     {
         $validator = $this->context->getValidator()->inContext($this->context);
-        $validator->expects($this->never())
-            ->method('atPath');
-        $validator->expects($this->never())
-            ->method('validate');
+        $validator->expectNoValidate();
     }
 
     protected function expectValidateAt($i, $propertyPath, $value, $group)
     {
         $validator = $this->context->getValidator()->inContext($this->context);
-        $validator->expects($this->at(2 * $i))
-            ->method('atPath')
-            ->with($propertyPath)
-            ->willReturn($validator);
-        $validator->expects($this->at(2 * $i + 1))
-            ->method('validate')
-            ->with($value, $this->logicalOr(null, [], $this->isInstanceOf('\Symfony\Component\Validator\Constraints\Valid')), $group)
-            ->willReturn($validator);
+        $validator->expectValidation($i, $propertyPath, $value, $group, function ($passedConstraints) {
+            $expectedConstraints = new LogicalOr();
+            $expectedConstraints->setConstraints([new IsNull(), new IsIdentical([]), new IsInstanceOf(Valid::class)]);
+
+            Assert::assertThat($passedConstraints, $expectedConstraints);
+        });
     }
 
     protected function expectValidateValueAt($i, $propertyPath, $value, $constraints, $group = null)
     {
         $contextualValidator = $this->context->getValidator()->inContext($this->context);
-        $contextualValidator->expects($this->at(2 * $i))
-            ->method('atPath')
-            ->with($propertyPath)
-            ->willReturn($contextualValidator);
-        $contextualValidator->expects($this->at(2 * $i + 1))
-            ->method('validate')
-            ->with($value, $constraints, $group)
-            ->willReturn($contextualValidator);
+        $contextualValidator->expectValidation($i, $propertyPath, $value, $group, function ($passedConstraints) use ($constraints) {
+            Assert::assertEquals($constraints, $passedConstraints);
+        });
     }
 
     protected function assertNoViolation()
@@ -346,3 +342,63 @@ private function getViolation(): ConstraintViolation
         );
     }
 }
+
+class AssertingContextualValidator implements ContextualValidatorInterface
+{
+    private $expectNoValidate = false;
+    private $atPathCalls = -1;
+    private $expectedAtPath = [];
+    private $validateCalls = -1;
+    private $expectedValidate = [];
+
+    public function atPath($path)
+    {
+        Assert::assertFalse($this->expectNoValidate, 'No validation calls have been expected.');
+
+        if (!isset($this->expectedAtPath[++$this->atPathCalls])) {
+            throw new ExpectationFailedException(sprintf('Validation for property path "%s" was not expected.', $path));
+        }
+
+        Assert::assertSame($this->expectedAtPath[$this->atPathCalls], $path);
+
+        return $this;
+    }
+
+    public function validate($value, $constraints = null, $groups = null)
+    {
+        Assert::assertFalse($this->expectNoValidate, 'No validation calls have been expected.');
+
+        list($expectedValue, $expectedGroup, $expectedConstraints) = $this->expectedValidate[++$this->validateCalls];
+
+        Assert::assertSame($expectedValue, $value);
+        $expectedConstraints($constraints);
+        Assert::assertSame($expectedGroup, $groups);
+
+        return $this;
+    }
+
+    public function validateProperty($object, $propertyName, $groups = null)
+    {
+        return $this;
+    }
+
+    public function validatePropertyValue($objectOrClass, $propertyName, $value, $groups = null)
+    {
+        return $this;
+    }
+
+    public function getViolations()
+    {
+    }
+
+    public function expectNoValidate()
+    {
+        $this->expectNoValidate = true;
+    }
+
+    public function expectValidation($call, $propertyPath, $value, $group, $constraints)
+    {
+        $this->expectedAtPath[$call] = $propertyPath;
+        $this->expectedValidate[$call] = [$value, $group, $constraints];
+    }
+}