diogo
/
symfony
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[Validator] Refactored ValidatorTest and ValidationVisitorTest into an abstract validator test class

This commit is contained in:
Bernhard Schussek 2014-02-12 12:38:50 +01:00
parent 95f8e43205
commit 25cdc68d36
13 changed files with 1410 additions and 835 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
UPGRADE-2.5.md
View File

@ -56,10 +56,11 @@ Validator
After:
Default email validation is now done via a simple regex which may cause invalid emails (not RFC compilant) to be
Default email validation is now done via a simple regex which may cause invalid emails (not RFC compilant) to be
valid. This is the default behaviour.
Strict email validation has to be explicitly activated in the configuration file by adding
```
framework:
//...
@ -68,7 +69,29 @@ Validator
//...
```
Also you have to add to your composer.json:
```
"egulias/email-validator": "1.1.*"
```
* `ClassMetadata::getGroupSequence()` now returns `GroupSequence` instances
instead of an array. The sequence implements `\Traversable`, `\ArrayAccess`
and `\Countable`, so in most cases you should be fine. If you however use the
sequence with PHP's `array_*()` functions, you should cast it to an array
first using `iterator_to_array()`:
Before:
```
$sequence = $metadata->getGroupSequence();
$result = array_map($callback, $sequence);
```
After:
```
$sequence = iterator_to_array($metadata->getGroupSequence());
$result = array_map($callback, $sequence);
```

2
src/Symfony/Component/Validator/CHANGELOG.md
View File

@ -6,6 +6,8 @@ CHANGELOG
* deprecated `ApcCache` in favor of `DoctrineCache`
* added `DoctrineCache` to adapt any Doctrine cache
* `GroupSequence` now implements `ArrayAccess`, `Countable` and `Traversable`
* changed `ClassMetadata::getGroupSequence()` to return a `GroupSequence` instance instead of an array
2.4.0
-----

2
src/Symfony/Component/Validator/Constraints/Callback.php
View File

@ -71,6 +71,6 @@ class Callback extends Constraint
*/
public function getTargets()
{
return self::CLASS_CONSTRAINT;
return array(self::CLASS_CONSTRAINT, self::PROPERTY_CONSTRAINT);
}
}

41
src/Symfony/Component/Validator/Constraints/GroupSequence.php
View File

@ -20,7 +20,7 @@ namespace Symfony\Component\Validator\Constraints;
*
* @api
*/
class GroupSequence
class GroupSequence implements \ArrayAccess, \IteratorAggregate, \Countable
{
/**
* The members of the sequence
@ -30,6 +30,43 @@ class GroupSequence
public function __construct(array $groups)
{
$this->groups = $groups['value'];
// Support for Doctrine annotations
$this->groups = isset($groups['value']) ? $groups['value'] : $groups;
}
public function getIterator()
{
return new \ArrayIterator($this->groups);
}
public function offsetExists($offset)
{
return isset($this->groups[$offset]);
}
public function offsetGet($offset)
{
return $this->groups[$offset];
}
public function offsetSet($offset, $value)
{
if (null !== $offset) {
$this->groups[$offset] = $value;
return;
}
$this->groups[] = $value;
}
public function offsetUnset($offset)
{
unset($this->groups[$offset]);
}
public function count()
{
return count($this->groups);
}
}

17
src/Symfony/Component/Validator/Mapping/ClassMetadata.php
View File

@ -11,6 +11,7 @@
namespace Symfony\Component\Validator\Mapping;
use Symfony\Component\Validator\Constraints\GroupSequence;
use Symfony\Component\Validator\ValidationVisitorInterface;
use Symfony\Component\Validator\PropertyMetadataContainerInterface;
use Symfony\Component\Validator\ClassBasedInterface;
@ -330,27 +331,31 @@ class ClassMetadata extends ElementMetadata implements MetadataInterface, ClassB
/**
* Sets the default group sequence for this class.
*
* @param array $groups An array of group names
* @param array $groupSequence An array of group names
*
* @return ClassMetadata
*
* @throws GroupDefinitionException
*/
public function setGroupSequence(array $groups)
public function setGroupSequence($groupSequence)
{
if ($this->isGroupSequenceProvider()) {
throw new GroupDefinitionException('Defining a static group sequence is not allowed with a group sequence provider');
}
if (in_array(Constraint::DEFAULT_GROUP, $groups, true)) {
if (is_array($groupSequence)) {
$groupSequence = new GroupSequence($groupSequence);
}
if (in_array(Constraint::DEFAULT_GROUP, $groupSequence->groups, true)) {
throw new GroupDefinitionException(sprintf('The group "%s" is not allowed in group sequences', Constraint::DEFAULT_GROUP));
}
if (!in_array($this->getDefaultGroup(), $groups, true)) {
if (!in_array($this->getDefaultGroup(), $groupSequence->groups, true)) {
throw new GroupDefinitionException(sprintf('The group "%s" is missing in the group sequence', $this->getDefaultGroup()));
}
$this->groupSequence = $groups;
$this->groupSequence = $groupSequence;
return $this;
}
@ -368,7 +373,7 @@ class ClassMetadata extends ElementMetadata implements MetadataInterface, ClassB
/**
* Returns the default group sequence for this class.
*
* @return array An array of group names
* @return GroupSequence The group sequence or null
*/
public function getGroupSequence()
{

1236
src/Symfony/Component/Validator/Tests/AbstractValidatorTest.php Normal file
View File

File diff suppressed because it is too large Load Diff

4
src/Symfony/Component/Validator/Tests/Constraints/CallbackValidatorTest.php
View File

@ -11,6 +11,7 @@
namespace Symfony\Component\Validator\Tests\Constraints;
use Symfony\Component\Validator\Constraint;
use Symfony\Component\Validator\ExecutionContext;
use Symfony\Component\Validator\Constraints\Callback;
use Symfony\Component\Validator\Constraints\CallbackValidator;
@ -320,8 +321,9 @@ class CallbackValidatorTest extends \PHPUnit_Framework_TestCase
public function testConstraintGetTargets()
{
$constraint = new Callback(array('foo'));
$targets = array(Constraint::CLASS_CONSTRAINT, Constraint::PROPERTY_CONSTRAINT);
$this->assertEquals('class', $constraint->getTargets());
$this->assertEquals($targets, $constraint->getTargets());
}
// Should succeed. Needed when defining constraints as annotations.

66
src/Symfony/Component/Validator/Tests/Constraints/GroupSequenceTest.php Normal file
View File

@ -0,0 +1,66 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Validator\Tests\Constraints;
use Symfony\Component\Validator\Constraints\GroupSequence;
/**
* @author Bernhard Schussek <bschussek@gmail.com>
*/
class GroupSequenceTest extends \PHPUnit_Framework_TestCase
{
public function testCreate()
{
$sequence = new GroupSequence(array('Group 1', 'Group 2'));
$this->assertSame(array('Group 1', 'Group 2'), $sequence->groups);
}
public function testCreateDoctrineStyle()
{
$sequence = new GroupSequence(array('value' => array('Group 1', 'Group 2')));
$this->assertSame(array('Group 1', 'Group 2'), $sequence->groups);
}
public function testIterate()
{
$sequence = new GroupSequence(array('Group 1', 'Group 2'));
$this->assertSame(array('Group 1', 'Group 2'), iterator_to_array($sequence));
}
public function testCount()
{
$sequence = new GroupSequence(array('Group 1', 'Group 2'));
$this->assertCount(2, $sequence);
}
public function testArrayAccess()
{
$sequence = new GroupSequence(array('Group 1', 'Group 2'));
$this->assertSame('Group 1', $sequence[0]);
$this->assertSame('Group 2', $sequence[1]);
$this->assertTrue(isset($sequence[0]));
$this->assertFalse(isset($sequence[2]));
unset($sequence[0]);
$this->assertFalse(isset($sequence[0]));
$sequence[] = 'Group 3';
$this->assertTrue(isset($sequence[2]));
$this->assertSame('Group 3', $sequence[2]);
$sequence[0] = 'Group 1';
$this->assertTrue(isset($sequence[0]));
$this->assertSame('Group 1', $sequence[0]);
}
}

8
src/Symfony/Component/Validator/Tests/Fixtures/Entity.php
View File

@ -32,9 +32,10 @@ class Entity extends EntityParent implements EntityInterface
* })
* @Assert\Choice(choices={"A", "B"}, message="Must be one of %choices%")
*/
protected $firstName;
public $firstName;
protected $lastName;
public $reference;
public $reference2;
private $internal;
public $data = 'Overridden data';
@ -48,6 +49,11 @@ class Entity extends EntityParent implements EntityInterface
return $this->internal.' from getter';
}
public function setLastName($lastName)
{
$this->lastName = $lastName;
}
/**
* @Assert\NotNull
*/

8
src/Symfony/Component/Validator/Tests/Fixtures/GroupSequenceProviderEntity.php
View File

@ -22,15 +22,15 @@ class GroupSequenceProviderEntity implements GroupSequenceProviderInterface
public $firstName;
public $lastName;
protected $groups = array();
protected $sequence = array();
public function setGroups($groups)
public function __construct($sequence)
{
$this->groups = $groups;
$this->sequence = $sequence;
}
public function getGroupSequence()
{
return $this->groups;
return $this->sequence;
}
}

13
src/Symfony/Component/Validator/Tests/Fixtures/Reference.php
View File

@ -13,4 +13,17 @@ namespace Symfony\Component\Validator\Tests\Fixtures;
class Reference
{
public $value;
private $privateValue;
public function setPrivateValue($privateValue)
{
$this->privateValue = $privateValue;
}
public function getPrivateValue()
{
return $this->privateValue;
}
}

564
src/Symfony/Component/Validator/Tests/ValidationVisitorTest.php
View File

@ -1,564 +0,0 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Validator\Tests;
use Symfony\Component\Validator\Tests\Fixtures\FakeMetadataFactory;
use Symfony\Component\Validator\Constraints\Valid;
use Symfony\Component\Validator\Tests\Fixtures\Reference;
use Symfony\Component\Validator\DefaultTranslator;
use Symfony\Component\Validator\ConstraintViolation;
use Symfony\Component\Validator\ConstraintViolationList;
use Symfony\Component\Validator\Tests\Fixtures\FailingConstraint;
use Symfony\Component\Validator\Tests\Fixtures\ConstraintAValidator;
use Symfony\Component\Validator\Tests\Fixtures\Entity;
use Symfony\Component\Validator\Tests\Fixtures\ConstraintA;
use Symfony\Component\Validator\Mapping\ClassMetadata;
use Symfony\Component\Validator\ConstraintValidatorFactory;
use Symfony\Component\Validator\ValidationVisitor;
/**
* @author Bernhard Schussek <bschussek@gmail.com>
*/
class ValidationVisitorTest extends \PHPUnit_Framework_TestCase
{
const CLASS_NAME = 'Symfony\Component\Validator\Tests\Fixtures\Entity';
/**
* @var ValidationVisitor
*/
private $visitor;
/**
* @var FakeMetadataFactory
*/
private $metadataFactory;
/**
* @var ClassMetadata
*/
private $metadata;
protected function setUp()
{
$this->metadataFactory = new FakeMetadataFactory();
$this->visitor = new ValidationVisitor('Root', $this->metadataFactory, new ConstraintValidatorFactory(), new DefaultTranslator());
$this->metadata = new ClassMetadata(self::CLASS_NAME);
$this->metadataFactory->addMetadata($this->metadata);
}
protected function tearDown()
{
$this->metadataFactory = null;
$this->visitor = null;
$this->metadata = null;
}
public function testValidatePassesCorrectClassAndProperty()
{
$this->metadata->addConstraint(new ConstraintA());
$entity = new Entity();
$this->visitor->validate($entity, 'Default', '');
$context = ConstraintAValidator::$passedContext;
$this->assertEquals('Symfony\Component\Validator\Tests\Fixtures\Entity', $context->getClassName());
$this->assertNull($context->getPropertyName());
}
public function testValidateConstraints()
{
$this->metadata->addConstraint(new ConstraintA());
$this->visitor->validate(new Entity(), 'Default', '');
$this->assertCount(1, $this->visitor->getViolations());
}
public function testValidateTwiceValidatesConstraintsOnce()
{
$this->metadata->addConstraint(new ConstraintA());
$entity = new Entity();
$this->visitor->validate($entity, 'Default', '');
$this->visitor->validate($entity, 'Default', '');
$this->assertCount(1, $this->visitor->getViolations());
}
public function testValidateDifferentObjectsValidatesTwice()
{
$this->metadata->addConstraint(new ConstraintA());
$this->visitor->validate(new Entity(), 'Default', '');
$this->visitor->validate(new Entity(), 'Default', '');
$this->assertCount(2, $this->visitor->getViolations());
}
public function testValidateTwiceInDifferentGroupsValidatesTwice()
{
$this->metadata->addConstraint(new ConstraintA());
$this->metadata->addConstraint(new ConstraintA(array('groups' => 'Custom')));
$entity = new Entity();
$this->visitor->validate($entity, 'Default', '');
$this->visitor->validate($entity, 'Custom', '');
$this->assertCount(2, $this->visitor->getViolations());
}
public function testValidatePropertyConstraints()
{
$this->metadata->addPropertyConstraint('firstName', new ConstraintA());
$this->visitor->validate(new Entity(), 'Default', '');
$this->assertCount(1, $this->visitor->getViolations());
}
public function testValidateGetterConstraints()
{
$this->metadata->addGetterConstraint('lastName', new ConstraintA());
$this->visitor->validate(new Entity(), 'Default', '');
$this->assertCount(1, $this->visitor->getViolations());
}
public function testValidateInDefaultGroupTraversesGroupSequence()
{
$entity = new Entity();
$this->metadata->addPropertyConstraint('firstName', new FailingConstraint(array(
'groups' => 'First',
)));
$this->metadata->addGetterConstraint('lastName', new FailingConstraint(array(
'groups' => 'Default',
)));
$this->metadata->setGroupSequence(array('First', $this->metadata->getDefaultGroup()));
$this->visitor->validate($entity, 'Default', '');
// After validation of group "First" failed, no more group was
// validated
$violations = new ConstraintViolationList(array(
new ConstraintViolation(
'Failed',
'Failed',
array(),
'Root',
'firstName',
''
),
));
$this->assertEquals($violations, $this->visitor->getViolations());
}
public function testValidateInGroupSequencePropagatesDefaultGroup()
{
$entity = new Entity();
$entity->reference = new Reference();
$this->metadata->addPropertyConstraint('reference', new Valid());
$this->metadata->setGroupSequence(array($this->metadata->getDefaultGroup()));
$referenceMetadata = new ClassMetadata(get_class($entity->reference));
$referenceMetadata->addConstraint(new FailingConstraint(array(
// this constraint is only evaluated if group "Default" is
// propagated to the reference
'groups' => 'Default',
)));
$this->metadataFactory->addMetadata($referenceMetadata);
$this->visitor->validate($entity, 'Default', '');
// The validation of the reference's FailingConstraint in group
// "Default" was launched
$violations = new ConstraintViolationList(array(
new ConstraintViolation(
'Failed',
'Failed',
array(),
'Root',
'reference',
$entity->reference
),
));
$this->assertEquals($violations, $this->visitor->getViolations());
}
public function testValidateInOtherGroupTraversesNoGroupSequence()
{
$entity = new Entity();
$this->metadata->addPropertyConstraint('firstName', new FailingConstraint(array(
'groups' => 'First',
)));
$this->metadata->addGetterConstraint('lastName', new FailingConstraint(array(
'groups' => $this->metadata->getDefaultGroup(),
)));
$this->metadata->setGroupSequence(array('First', $this->metadata->getDefaultGroup()));
$this->visitor->validate($entity, $this->metadata->getDefaultGroup(), '');
// Only group "Second" was validated
$violations = new ConstraintViolationList(array(
new ConstraintViolation(
'Failed',
'Failed',
array(),
'Root',
'lastName',
''
),
));
$this->assertEquals($violations, $this->visitor->getViolations());
}
public function testValidateCascadedPropertyValidatesReferences()
{
$entity = new Entity();
$entity->reference = new Entity();
// add a constraint for the entity that always fails
$this->metadata->addConstraint(new FailingConstraint());
// validate entity when validating the property "reference"
$this->metadata->addPropertyConstraint('reference', new Valid());
// invoke validation on an object
$this->visitor->validate($entity, 'Default', '');
$violations = new ConstraintViolationList(array(
// generated by the root object
new ConstraintViolation(
'Failed',
'Failed',
array(),
'Root',
'',
$entity
),
// generated by the reference
new ConstraintViolation(
'Failed',
'Failed',
array(),
'Root',
'reference',
$entity->reference
),
));
$this->assertEquals($violations, $this->visitor->getViolations());
}
public function testValidateCascadedPropertyValidatesArraysByDefault()
{
$entity = new Entity();
$entity->reference = array('key' => new Entity());
// add a constraint for the entity that always fails
$this->metadata->addConstraint(new FailingConstraint());
// validate array when validating the property "reference"
$this->metadata->addPropertyConstraint('reference', new Valid());
$this->visitor->validate($entity, 'Default', '');
$violations = new ConstraintViolationList(array(
// generated by the root object
new ConstraintViolation(
'Failed',
'Failed',
array(),
'Root',
'',
$entity
),
// generated by the reference
new ConstraintViolation(
'Failed',
'Failed',
array(),
'Root',
'reference[key]',
$entity->reference['key']
),
));
$this->assertEquals($violations, $this->visitor->getViolations());
}
public function testValidateCascadedPropertyValidatesTraversableByDefault()
{
$entity = new Entity();
$entity->reference = new \ArrayIterator(array('key' => new Entity()));
// add a constraint for the entity that always fails
$this->metadata->addConstraint(new FailingConstraint());
// validate array when validating the property "reference"
$this->metadata->addPropertyConstraint('reference', new Valid());
$this->visitor->validate($entity, 'Default', '');
$violations = new ConstraintViolationList(array(
// generated by the root object
new ConstraintViolation(
'Failed',
'Failed',
array(),
'Root',
'',
$entity
),
// generated by the reference
new ConstraintViolation(
'Failed',
'Failed',
array(),
'Root',
'reference[key]',
$entity->reference['key']
),
));
$this->assertEquals($violations, $this->visitor->getViolations());
}
public function testValidateCascadedPropertyDoesNotValidateTraversableIfDisabled()
{
$entity = new Entity();
$entity->reference = new \ArrayIterator(array('key' => new Entity()));
$this->metadataFactory->addMetadata(new ClassMetadata('ArrayIterator'));
// add a constraint for the entity that always fails
$this->metadata->addConstraint(new FailingConstraint());
// validate array when validating the property "reference"
$this->metadata->addPropertyConstraint('reference', new Valid(array(
'traverse' => false,
)));
$this->visitor->validate($entity, 'Default', '');
$violations = new ConstraintViolationList(array(
// generated by the root object
new ConstraintViolation(
'Failed',
'Failed',
array(),
'Root',
'',
$entity
),
// nothing generated by the reference!
));
$this->assertEquals($violations, $this->visitor->getViolations());
}
public function testMetadataMayNotExistIfTraversalIsEnabled()
{
$entity = new Entity();
$entity->reference = new \ArrayIterator();
$this->metadata->addPropertyConstraint('reference', new Valid(array(
'traverse' => true,
)));
$this->visitor->validate($entity, 'Default', '');
}
/**
* @expectedException \Symfony\Component\Validator\Exception\NoSuchMetadataException
*/
public function testMetadataMustExistIfTraversalIsDisabled()
{
$entity = new Entity();
$entity->reference = new \ArrayIterator();
$this->metadata->addPropertyConstraint('reference', new Valid(array(
'traverse' => false,
)));
$this->visitor->validate($entity, 'Default', '');
}
public function testValidateCascadedPropertyDoesNotRecurseByDefault()
{
$entity = new Entity();
$entity->reference = new \ArrayIterator(array(
// The inner iterator should not be traversed by default
'key' => new \ArrayIterator(array(
'nested' => new Entity(),
)),
));
$this->metadataFactory->addMetadata(new ClassMetadata('ArrayIterator'));
// add a constraint for the entity that always fails
$this->metadata->addConstraint(new FailingConstraint());
// validate iterator when validating the property "reference"
$this->metadata->addPropertyConstraint('reference', new Valid());
$this->visitor->validate($entity, 'Default', '');
$violations = new ConstraintViolationList(array(
// generated by the root object
new ConstraintViolation(
'Failed',
'Failed',
array(),
'Root',
'',
$entity
),
// nothing generated by the reference!
));
$this->assertEquals($violations, $this->visitor->getViolations());
}
// https://github.com/symfony/symfony/issues/6246
public function testValidateCascadedPropertyRecursesArraysByDefault()
{
$entity = new Entity();
$entity->reference = array(
'key' => array(
'nested' => new Entity(),
),
);
// add a constraint for the entity that always fails
$this->metadata->addConstraint(new FailingConstraint());
// validate iterator when validating the property "reference"
$this->metadata->addPropertyConstraint('reference', new Valid());
$this->visitor->validate($entity, 'Default', '');
$violations = new ConstraintViolationList(array(
// generated by the root object
new ConstraintViolation(
'Failed',
'Failed',
array(),
'Root',
'',
$entity
),
// nothing generated by the reference!
new ConstraintViolation(
'Failed',
'Failed',
array(),
'Root',
'reference[key][nested]',
$entity->reference['key']['nested']
),
));
$this->assertEquals($violations, $this->visitor->getViolations());
}
public function testValidateCascadedPropertyRecursesIfDeepIsSet()
{
$entity = new Entity();
$entity->reference = new \ArrayIterator(array(
// The inner iterator should now be traversed
'key' => new \ArrayIterator(array(
'nested' => new Entity(),
)),
));
// add a constraint for the entity that always fails
$this->metadata->addConstraint(new FailingConstraint());
// validate iterator when validating the property "reference"
$this->metadata->addPropertyConstraint('reference', new Valid(array(
'deep' => true,
)));
$this->visitor->validate($entity, 'Default', '');
$violations = new ConstraintViolationList(array(
// generated by the root object
new ConstraintViolation(
'Failed',
'Failed',
array(),
'Root',
'',
$entity
),
// nothing generated by the reference!
new ConstraintViolation(
'Failed',
'Failed',
array(),
'Root',
'reference[key][nested]',
$entity->reference['key']['nested']
),
));
$this->assertEquals($violations, $this->visitor->getViolations());
}
public function testValidateCascadedPropertyDoesNotValidateNestedScalarValues()
{
$entity = new Entity();
$entity->reference = array('scalar', 'values');
// validate array when validating the property "reference"
$this->metadata->addPropertyConstraint('reference', new Valid());
$this->visitor->validate($entity, 'Default', '');
$this->assertCount(0, $this->visitor->getViolations());
}
public function testValidateCascadedPropertyDoesNotValidateNullValues()
{
$entity = new Entity();
$entity->reference = null;
$this->metadata->addPropertyConstraint('reference', new Valid());
$this->visitor->validate($entity, 'Default', '');
$this->assertCount(0, $this->visitor->getViolations());
}
/**
* @expectedException \Symfony\Component\Validator\Exception\NoSuchMetadataException
*/
public function testValidateCascadedPropertyRequiresObjectOrArray()
{
$entity = new Entity();
$entity->reference = 'no object';
$this->metadata->addPropertyConstraint('reference', new Valid());
$this->visitor->validate($entity, 'Default', '');
}
}

259
src/Symfony/Component/Validator/Tests/ValidatorTest.php
View File

@ -11,266 +11,15 @@
namespace Symfony\Component\Validator\Tests;
use Symfony\Component\Validator\Tests\Fixtures\Entity;
use Symfony\Component\Validator\Tests\Fixtures\GroupSequenceProviderEntity;
use Symfony\Component\Validator\Tests\Fixtures\FakeMetadataFactory;
use Symfony\Component\Validator\Tests\Fixtures\FailingConstraint;
use Symfony\Component\Validator\MetadataFactoryInterface;
use Symfony\Component\Validator\Validator;
use Symfony\Component\Validator\DefaultTranslator;
use Symfony\Component\Validator\ConstraintViolation;
use Symfony\Component\Validator\ConstraintViolationList;
use Symfony\Component\Validator\ConstraintValidatorFactory;
use Symfony\Component\Validator\Constraints\Valid;
use Symfony\Component\Validator\Mapping\ClassMetadata;
class ValidatorTest extends \PHPUnit_Framework_TestCase
class ValidatorTest extends AbstractValidatorTest
{
/**
* @var FakeMetadataFactory
*/
private $metadataFactory;
/**
* @var Validator
*/
private $validator;
protected function setUp()
protected function createValidator(MetadataFactoryInterface $metadataFactory)
{
$this->metadataFactory = new FakeMetadataFactory();
$this->validator = new Validator($this->metadataFactory, new ConstraintValidatorFactory(), new DefaultTranslator());
}
protected function tearDown()
{
$this->metadataFactory = null;
$this->validator = null;
}
public function testValidateDefaultGroup()
{
$entity = new Entity();
$metadata = new ClassMetadata(get_class($entity));
$metadata->addPropertyConstraint('firstName', new FailingConstraint());
$metadata->addPropertyConstraint('lastName', new FailingConstraint(array(
'groups' => 'Custom',
)));
$this->metadataFactory->addMetadata($metadata);
// Only the constraint of group "Default" failed
$violations = new ConstraintViolationList();
$violations->add(new ConstraintViolation(
'Failed',
'Failed',
array(),
$entity,
'firstName',
''
));
$this->assertEquals($violations, $this->validator->validate($entity));
}
public function testValidateOneGroup()
{
$entity = new Entity();
$metadata = new ClassMetadata(get_class($entity));
$metadata->addPropertyConstraint('firstName', new FailingConstraint());
$metadata->addPropertyConstraint('lastName', new FailingConstraint(array(
'groups' => 'Custom',
)));
$this->metadataFactory->addMetadata($metadata);
// Only the constraint of group "Custom" failed
$violations = new ConstraintViolationList();
$violations->add(new ConstraintViolation(
'Failed',
'Failed',
array(),
$entity,
'lastName',
''
));
$this->assertEquals($violations, $this->validator->validate($entity, 'Custom'));
}
public function testValidateMultipleGroups()
{
$entity = new Entity();
$metadata = new ClassMetadata(get_class($entity));
$metadata->addPropertyConstraint('firstName', new FailingConstraint(array(
'groups' => 'First',
)));
$metadata->addPropertyConstraint('lastName', new FailingConstraint(array(
'groups' => 'Second',
)));
$this->metadataFactory->addMetadata($metadata);
// The constraints of both groups failed
$violations = new ConstraintViolationList();
$violations->add(new ConstraintViolation(
'Failed',
'Failed',
array(),
$entity,
'firstName',
''
));
$violations->add(new ConstraintViolation(
'Failed',
'Failed',
array(),
$entity,
'lastName',
''
));
$result = $this->validator->validate($entity, array('First', 'Second'));
$this->assertEquals($violations, $result);
}
public function testValidateGroupSequenceProvider()
{
$entity = new GroupSequenceProviderEntity();
$metadata = new ClassMetadata(get_class($entity));
$metadata->addPropertyConstraint('firstName', new FailingConstraint(array(
'groups' => 'First',
)));
$metadata->addPropertyConstraint('lastName', new FailingConstraint(array(
'groups' => 'Second',
)));
$metadata->setGroupSequenceProvider(true);
$this->metadataFactory->addMetadata($metadata);
$violations = new ConstraintViolationList();
$violations->add(new ConstraintViolation(
'Failed',
'Failed',
array(),
$entity,
'firstName',
''
));
$entity->setGroups(array('First'));
$result = $this->validator->validate($entity);
$this->assertEquals($violations, $result);
$violations = new ConstraintViolationList();
$violations->add(new ConstraintViolation(
'Failed',
'Failed',
array(),
$entity,
'lastName',
''
));
$entity->setGroups(array('Second'));
$result = $this->validator->validate($entity);
$this->assertEquals($violations, $result);
$entity->setGroups(array());
$result = $this->validator->validate($entity);
$this->assertEquals(new ConstraintViolationList(), $result);
}
public function testValidateProperty()
{
$entity = new Entity();
$metadata = new ClassMetadata(get_class($entity));
$metadata->addPropertyConstraint('firstName', new FailingConstraint());
$this->metadataFactory->addMetadata($metadata);
$result = $this->validator->validateProperty($entity, 'firstName');
$this->assertCount(1, $result);
$result = $this->validator->validateProperty($entity, 'lastName');
$this->assertCount(0, $result);
}
public function testValidatePropertyValue()
{
$entity = new Entity();
$metadata = new ClassMetadata(get_class($entity));
$metadata->addPropertyConstraint('firstName', new FailingConstraint());
$this->metadataFactory->addMetadata($metadata);
$result = $this->validator->validatePropertyValue(get_class($entity), 'firstName', 'Bernhard');
$this->assertCount(1, $result);
}
public function testValidateValue()
{
$violations = new ConstraintViolationList();
$violations->add(new ConstraintViolation(
'Failed',
'Failed',
array(),
'Bernhard',
'',
'Bernhard'
));
$this->assertEquals($violations, $this->validator->validateValue('Bernhard', new FailingConstraint()));
}
/**
* @expectedException \Symfony\Component\Validator\Exception\ValidatorException
*/
public function testValidateValueRejectsValid()
{
$entity = new Entity();
$metadata = new ClassMetadata(get_class($entity));
$this->metadataFactory->addMetadata($metadata);
$this->validator->validateValue($entity, new Valid());
}
/**
* @expectedException \Symfony\Component\Validator\Exception\ValidatorException
*/
public function testValidatePropertyFailsIfPropertiesNotSupported()
{
// $metadata does not implement PropertyMetadataContainerInterface
$metadata = $this->getMock('Symfony\Component\Validator\MetadataInterface');
$this->metadataFactory = $this->getMock('Symfony\Component\Validator\MetadataFactoryInterface');
$this->metadataFactory->expects($this->any())
->method('getMetadataFor')
->with('VALUE')
->will($this->returnValue($metadata));
$this->validator = new Validator($this->metadataFactory, new ConstraintValidatorFactory(), new DefaultTranslator());
$this->validator->validateProperty('VALUE', 'someProperty');
}
/**
* @expectedException \Symfony\Component\Validator\Exception\ValidatorException
*/
public function testValidatePropertyValueFailsIfPropertiesNotSupported()
{
// $metadata does not implement PropertyMetadataContainerInterface
$metadata = $this->getMock('Symfony\Component\Validator\MetadataInterface');
$this->metadataFactory = $this->getMock('Symfony\Component\Validator\MetadataFactoryInterface');
$this->metadataFactory->expects($this->any())
->method('getMetadataFor')
->with('VALUE')
->will($this->returnValue($metadata));
$this->validator = new Validator($this->metadataFactory, new ConstraintValidatorFactory(), new DefaultTranslator());
$this->validator->validatePropertyValue('VALUE', 'someProperty', 'propertyValue');
}
public function testGetMetadataFactory()
{
$this->assertInstanceOf(
'Symfony\Component\Validator\MetadataFactoryInterface',
$this->validator->getMetadataFactory()
);
return new Validator($metadataFactory, new ConstraintValidatorFactory(), new DefaultTranslator());
}
}