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

[Validator] Add CollectionSize constraint

Browse Source 
[Validator] Rename constraint Size to Range

[Validator] Rename constraint CollectionSize to Size

[Validator] Merge the SizeLength into the Size constraint

[Validator] Update messages in Size constraint for consistancy

[Validator] Add english and french translation for Size messages

[Validator] Tweak expected types for exceptions in SizeValidator

[Validator] Fix CS in SizeValidator

[Validator] Update the ValidatorTypeGuesser

[Validator] Tweak SizeValidator

[Validator] Update CHANGELOG

[Validator] Complete previous CHANGELOG updates

[Form] Update validator type guesser

[Validator] Pluralize collection size english messages

[Validator] Pluralize Size french messages
This commit is contained in:
Antoine Hérault 2012-04-28 16:29:28 -05:00
parent 46ffbd5282
commit 3a5e84f4a7
12 changed files with 636 additions and 304 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
src/Symfony/Bundle/FrameworkBundle/Resources/translations/validators.en.xlf
View File

@ -214,6 +214,18 @@
<source>A PHP extension caused the upload to fail.</source>
<target>A PHP extension caused the upload to fail.</target>
</trans-unit>
<trans-unit id="54">
<source>This collection should contain {{ limit }} elements or more.</source>
<target>This collection should contain {{ limit }} element or more.|This collection should contain {{ limit }} elements or more.</target>
</trans-unit>
<trans-unit id="55">
<source>This collection should contain {{ limit }} elements or less.</source>
<target>This collection should contain {{ limit }} element or less.|This collection should contain {{ limit }} elements or less.</target>
</trans-unit>
<trans-unit id="56">
<source>This collection should contain exactly {{ limit }} elements.</source>
<target>This collection should contain exactly {{ limit }} element.|This collection should contain exactly {{ limit }} elements.</target>
</trans-unit>
</body>
</file>
</xliff>

18
src/Symfony/Bundle/FrameworkBundle/Resources/translations/validators.fr.xlf
View File

@ -76,7 +76,7 @@
</trans-unit>
<trans-unit id="19">
<source>This value is too long. It should have {{ limit }} characters or less.</source>
<target>Cette chaine est trop longue. Elle doit avoir au maximum {{ limit }} caractères.</target>
<target>Cette chaine est trop longue. Elle doit avoir au maximum {{ limit }} caractère.|Cette chaine est trop longue. Elle doit avoir au maximum {{ limit }} caractères.</target>
</trans-unit>
<trans-unit id="20">
<source>This value should be {{ limit }} or more.</source>
@ -84,7 +84,7 @@
</trans-unit>
<trans-unit id="21">
<source>This value is too short. It should have {{ limit }} characters or more.</source>
<target>Cette chaine est trop courte. Elle doit avoir au minimum {{ limit }} caractères.</target>
<target>Cette chaine est trop courte. Elle doit avoir au minimum {{ limit }} caractère.|Cette chaine est trop courte. Elle doit avoir au minimum {{ limit }} caractères.</target>
</trans-unit>
<trans-unit id="22">
<source>This value should not be blank.</source>
@ -192,7 +192,7 @@
</trans-unit>
<trans-unit id="48">
<source>This value should have exactly {{ limit }} characters.</source>
<target>Cette chaine doit avoir exactement {{ limit }} caractères.</target>
<target>Cette chaine doit avoir exactement {{ limit }} caractère.|Cette chaine doit avoir exactement {{ limit }} caractères.</target>
</trans-unit>
<trans-unit id="49">
<source>The file was only partially uploaded.</source>
@ -214,6 +214,18 @@
<source>A PHP extension caused the upload to fail.</source>
<target>Une extension PHP a empêché le transfert du fichier.</target>
</trans-unit>
<trans-unit id="54">
<source>This collection should contain {{ limit }} elements or more.</source>
<target>Cette collection doit contenir {{ limit }} élément ou plus.|Cette collection doit contenir {{ limit }} éléments ou plus.</target>
</trans-unit>
<trans-unit id="55">
<source>This collection should contain {{ limit }} elements or less.</source>
<target>Cette collection doit contenir {{ limit }} élément ou moins.|Cette collection doit contenir {{ limit }} éléments ou moins.</target>
</trans-unit>
<trans-unit id="56">
<source>This collection should contain exactly {{ limit }} elements.</source>
<target>Cette collection doit contenir exactement {{ limit }} élément.|Cette collection doit contenir exactement {{ limit }} éléments.</target>
</trans-unit>
</body>
</file>
</xliff>

41
src/Symfony/Component/Form/Extension/Validator/ValidatorTypeGuesser.php
View File

@ -155,11 +155,19 @@ class ValidatorTypeGuesser implements FormTypeGuesserInterface
case 'Symfony\Component\Validator\Constraints\MaxLength':
case 'Symfony\Component\Validator\Constraints\MinLength':
case 'Symfony\Component\Validator\Constraints\Regex':
case 'Symfony\Component\Validator\Constraints\SizeLength':
return new TypeGuess('text', array(), Guess::LOW_CONFIDENCE);
case 'Symfony\Component\Validator\Constraints\Min':
case 'Symfony\Component\Validator\Constraints\Size':
switch ($constraint->type) {
case 'string':
return new TypeGuess('text', array(), Guess::LOW_CONFIDENCE);
case 'collection':
return new TypeGuess('collection', array(), Guess::MEDIUM_CONFIDENCE);
}
break;
case 'Symfony\Component\Validator\Constraints\Min':
case 'Symfony\Component\Validator\Constraints\Range':
case 'Symfony\Component\Validator\Constraints\Max':
return new TypeGuess('number', array(), Guess::LOW_CONFIDENCE);
}
@ -194,8 +202,11 @@ class ValidatorTypeGuesser implements FormTypeGuesserInterface
case 'Symfony\Component\Validator\Constraints\MaxLength':
return new ValueGuess($constraint->limit, Guess::HIGH_CONFIDENCE);
case 'Symfony\Component\Validator\Constraints\SizeLength':
return new ValueGuess($constraint->max, Guess::HIGH_CONFIDENCE);
case 'Symfony\Component\Validator\Constraints\Size':
if ('string' === $constraint->type && null !== $constraint->max) {
return new ValueGuess($constraint->max, Guess::HIGH_CONFIDENCE);
}
break;
case 'Symfony\Component\Validator\Constraints\Type':
if (in_array($constraint->type, array('double', 'float', 'numeric', 'real'))) {
@ -206,7 +217,7 @@ class ValidatorTypeGuesser implements FormTypeGuesserInterface
case 'Symfony\Component\Validator\Constraints\Max':
return new ValueGuess(strlen((string) $constraint->limit), Guess::LOW_CONFIDENCE);
case 'Symfony\Component\Validator\Constraints\Size':
case 'Symfony\Component\Validator\Constraints\Range':
return new ValueGuess(strlen((string) $constraint->max), Guess::LOW_CONFIDENCE);
}
}
@ -224,7 +235,23 @@ class ValidatorTypeGuesser implements FormTypeGuesserInterface
case 'Symfony\Component\Validator\Constraints\MinLength':
return new ValueGuess(sprintf('.{%s,}', (string) $constraint->limit), Guess::LOW_CONFIDENCE);
case 'Symfony\Component\Validator\Constraints\SizeLength':
case 'Symfony\Component\Validator\Constraints\Size':
if ('string' !== $constraint->type) {
return;
}
if ($constraint->min === $constraint->max) {
return new ValueGuess(sprintf('.{%s}', (string) $constraint->min), Guess::LOW_CONFIDENCE);
}
if (null === $constraint->min) {
return new ValueGuess(sprintf('.{0,%s}', (string) $constraint->max), Guess::LOW_CONFIDENCE);
}
if (null === $constraint->max) {
return new ValueGuess(sprintf('.{%s,}', (string) $constraint->min), Guess::LOW_CONFIDENCE);
}
return new ValueGuess(sprintf('.{%s,%s}', (string) $constraint->min, (string) $constraint->max), Guess::LOW_CONFIDENCE);
case 'Symfony\Component\Validator\Constraints\Regex':
@ -233,7 +260,7 @@ class ValidatorTypeGuesser implements FormTypeGuesserInterface
case 'Symfony\Component\Validator\Constraints\Min':
return new ValueGuess(sprintf('.{%s,}', strlen((string) $constraint->limit)), Guess::LOW_CONFIDENCE);
case 'Symfony\Component\Validator\Constraints\Size':
case 'Symfony\Component\Validator\Constraints\Range':
return new ValueGuess(sprintf('.{%s,%s}', strlen((string) $constraint->min), strlen((string) $constraint->max)), Guess::LOW_CONFIDENCE);
case 'Symfony\Component\Validator\Constraints\Type':

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

@ -5,8 +5,8 @@ CHANGELOG
-----
* added support for `ctype_*` assertions in `TypeValidator`
* added a Size validator
* added a SizeLength validator
* added a Range validator for numeric values
* added a Size validator for string & collections
* improved the ImageValidator with min width, max width, min height, and max height constraints
* added support for MIME with wildcard in FileValidator
* changed Collection validator to add "missing" and "extra" errors to

9
src/Symfony/Component/Validator/Constraints/SizeLength.php → src/Symfony/Component/Validator/Constraints/Range.php
View File

@ -18,14 +18,13 @@ use Symfony\Component\Validator\Constraint;
*
* @api
*/
class SizeLength extends Constraint
class Range extends Constraint
{
public $minMessage = 'This value is too short. It should have {{ limit }} characters or more.';
public $maxMessage = 'This value is too long. It should have {{ limit }} characters or less.';
public $exactMessage = 'This value should have exactly {{ limit }} characters.';
public $minMessage = 'This value should be {{ limit }} or more.';
public $maxMessage = 'This value should be {{ limit }} or less.';
public $invalidMessage = 'This value should be a valid number.';
public $min;
public $max;
public $charset = 'UTF-8';
/**
* {@inheritDoc}

38
src/Symfony/Component/Validator/Constraints/SizeLengthValidator.php → src/Symfony/Component/Validator/Constraints/RangeValidator.php
View File

@ -13,12 +13,13 @@ namespace Symfony\Component\Validator\Constraints;
use Symfony\Component\Validator\Constraint;
use Symfony\Component\Validator\ConstraintValidator;
use Symfony\Component\Validator\Exception\UnexpectedTypeException;
/**
* @author Bernhard Schussek <bschussek@gmail.com>
*
* @api
*/
class SizeLengthValidator extends ConstraintValidator
class RangeValidator extends ConstraintValidator
{
/**
* Checks if the passed value is valid.
@ -26,51 +27,38 @@ class SizeLengthValidator extends ConstraintValidator
* @param mixed $value The value that should be validated
* @param Constraint $constraint The constraint for the validation
*
* @return Boolean Whether or not the value is valid
*
* @api
*/
public function validate($value, Constraint $constraint)
{
if (null === $value || '' === $value) {
if (null === $value) {
return;
}
if (!is_scalar($value) && !(is_object($value) && method_exists($value, '__toString'))) {
throw new UnexpectedTypeException($value, 'string');
}
$value = (string) $value;
if (function_exists('grapheme_strlen') && 'UTF-8' === $constraint->charset) {
$length = grapheme_strlen($value);
} elseif (function_exists('mb_strlen')) {
$length = mb_strlen($value, $constraint->charset);
} else {
$length = strlen($value);
}
if ($constraint->min == $constraint->max && $length != $constraint->max) {
$this->context->addViolation($constraint->exactMessage, array(
if (!is_numeric($value)) {
$this->context->addViolation($constraint->invalidMessage, array(
'{{ value }}' => $value,
'{{ limit }}' => $constraint->max,
), null, (int) $constraint->max);
));
return;
}
if ($length > $constraint->max) {
if ($value > $constraint->max) {
$this->context->addViolation($constraint->maxMessage, array(
'{{ value }}' => $value,
'{{ limit }}' => $constraint->max,
), null, (int) $constraint->max);
));
return;
}
if ($length < $constraint->min) {
if ($value < $constraint->min) {
$this->context->addViolation($constraint->minMessage, array(
'{{ value }}' => $value,
'{{ limit }}' => $constraint->min,
), null, (int) $constraint->min);
));
}
}
}

69
src/Symfony/Component/Validator/Constraints/Size.php
View File

@ -20,17 +20,70 @@ use Symfony\Component\Validator\Constraint;
*/
class Size extends Constraint
{
public $minMessage = 'This value should be {{ limit }} or more.';
public $maxMessage = 'This value should be {{ limit }} or less.';
public $invalidMessage = 'This value should be a valid number.';
const TYPE_STRING = 'string';
const TYPE_COLLECTION = 'collection';
public $minMessage;
public $maxMessage;
public $exactMessage;
public $type;
public $min;
public $max;
public $charset = 'UTF-8';
/**
* {@inheritDoc}
*/
public function getRequiredOptions()
private $stringMinMessage = 'This value is too short. It should have {{ limit }} characters or more.';
private $stringMaxMessage = 'This value is too long. It should have {{ limit }} characters or less.';
private $stringExactMessage = 'This value should have exactly {{ limit }} characters.';
private $collectionMinMessage = 'This collection should contain {{ limit }} elements or more.';
private $collectionMaxMessage = 'This collection should contain {{ limit }} elements or less.';
private $collectionExactMessage = 'This collection should contain exactly {{ limit }} elements.';
public function getMinMessage($type)
{
return array('min', 'max');
if (null !== $this->minMessage) {
return $this->minMessage;
}
switch ($type) {
case static::TYPE_STRING:
return $this->stringMinMessage;
case static::TYPE_COLLECTION:
return $this->collectionMinMessage;
default:
throw new \InvalidArgumentException('Invalid type specified.');
}
}
public function getMaxMessage($type)
{
if (null !== $this->maxMessage) {
return $this->maxMessage;
}
switch ($type) {
case static::TYPE_STRING:
return $this->stringMaxMessage;
case static::TYPE_COLLECTION:
return $this->collectionMaxMessage;
default:
throw new \InvalidArgumentException('Invalid type specified.');
}
}
public function getExactMessage($type)
{
if (null !== $this->exactMessage) {
return $this->exactMessage;
}
switch ($type) {
case static::TYPE_STRING:
return $this->stringExactMessage;
case static::TYPE_COLLECTION:
return $this->collectionExactMessage;
default:
throw new \InvalidArgumentException('Invalid type specified.');
}
}
}

153
src/Symfony/Component/Validator/Constraints/SizeValidator.php
View File

@ -13,52 +13,151 @@ namespace Symfony\Component\Validator\Constraints;
use Symfony\Component\Validator\Constraint;
use Symfony\Component\Validator\ConstraintValidator;
use Symfony\Component\Validator\Exception\UnexpectedTypeException;
use Symfony\Component\Validator\Exception\ConstraintDefinitionException;
/**
* @author Bernhard Schussek <bschussek@gmail.com>
*
* @api
*/
class SizeValidator extends ConstraintValidator
{
/**
* Checks if the passed value is valid.
*
* @param mixed $value The value that should be validated
* @param Constraint $constraint The constraint for the validation
*
* @return Boolean Whether or not the value is valid
*
* @api
* {@inheritDoc}
*/
public function validate($value, Constraint $constraint)
{
if (null === $constraint->min && null === $constraint->max) {
throw new ConstraintDefinitionException(
'Either "min" or "max" must be specified on constraint Size'
);
}
if (null === $constraint->type) {
$type = $this->guessType($value);
} else {
$type = $constraint->type;
}
switch ($type) {
case Size::TYPE_STRING:
return $this->validateString($value, $constraint);
case Size::TYPE_COLLECTION:
return $this->validateCollection($value, $constraint);
default:
throw new ConstraintDefinitionException(sprintf(
'The "type" on constraint Size must be either "%s" or "%s", "%s" given.',
Size::TYPE_STRING,
Size::TYPE_COLLECTION,
$type
));
}
}
private function validateString($value, Constraint $constraint)
{
if (null === $value || '' === $value) {
return;
}
if (!is_scalar($value) && !(is_object($value) && method_exists($value, '__toString'))) {
throw new UnexpectedTypeException($value, 'string, scalar or object with __toString()');
}
$value = (string) $value;
if (function_exists('grapheme_strlen') && 'UTF-8' === $constraint->charset) {
$length = grapheme_strlen($value);
} elseif (function_exists('mb_strlen')) {
$length = mb_strlen($value, $constraint->charset);
} else {
$length = strlen($value);
}
$this->validateSize(
$constraint,
$length,
Size::TYPE_STRING,
array('{{ value }}' => $value)
);
}
private function validateCollection($value, Constraint $constraint)
{
if (null === $value) {
return;
}
if (!is_numeric($value)) {
$this->context->addViolation($constraint->invalidMessage, array(
'{{ value }}' => $value,
));
if (!is_array($value) && !$value instanceof \Countable) {
throw new UnexpectedTypeException($value, 'array or Countable');
}
$count = count($value);
$this->validateSize(
$constraint,
$count,
Size::TYPE_COLLECTION,
array('{{ count }}' => $count)
);
}
private function validateSize(Constraint $constraint, $size, $type, array $parameters)
{
if ($constraint->min == $constraint->max && $size != $constraint->max) {
$this->context->addViolation(
$constraint->getExactMessage($type),
array_merge(array('{{ limit }}' => $constraint->max), $parameters),
null,
(int) $constraint->max
);
return;
}
if ($value > $constraint->max) {
$this->context->addViolation($constraint->maxMessage, array(
'{{ value }}' => $value,
'{{ limit }}' => $constraint->max,
));
if (null !== $constraint->max && $size > $constraint->max) {
$this->context->addViolation(
$constraint->getMaxMessage($type),
array_merge(array('{{ limit }}' => $constraint->max), $parameters),
null,
(int) $constraint->max
);
return;
}
if ($value < $constraint->min) {
$this->context->addViolation($constraint->minMessage, array(
'{{ value }}' => $value,
'{{ limit }}' => $constraint->min,
));
if (null !== $constraint->min && $size < $constraint->min) {
$this->context->addViolation(
$constraint->getMinMessage($type),
array_merge(array('{{ limit }}' => $constraint->min), $parameters),
null,
(int) $constraint->min
);
}
}
private function guessType($value)
{
if (null === $value || is_scalar($value)) {
return Size::TYPE_STRING;
}
if (is_object($value) && method_exists($value, '__toString')) {
if ($value instanceof \Countable) {
throw new \RuntimeException(
'The "type" must be specified on constraint Size because the '.
'validator is not able to guess it since the value is an object '.
'implementing both the __toString() method and the Countable '.
'interface.'
);
}
return Size::TYPE_STRING;
}
if (is_array($value) || $value instanceof \Countable) {
return Size::TYPE_COLLECTION;
}
throw new UnexpectedTypeException(
$value, 'scalar, string, array, Countable or object with __toString()'
);
}
}

121
src/Symfony/Component/Validator/Tests/Constraints/RangeValidatorTest.php Normal file
View File

@ -0,0 +1,121 @@
<?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\Range;
use Symfony\Component\Validator\Constraints\RangeValidator;
class RangeValidatorTest extends \PHPUnit_Framework_TestCase
{
protected $context;
protected $validator;
protected function setUp()
{
$this->context = $this->getMock('Symfony\Component\Validator\ExecutionContext', array(), array(), '', false);
$this->validator = new RangeValidator();
$this->validator->initialize($this->context);
}
public function testNullIsValid()
{
$this->context->expects($this->never())
->method('addViolation');
$this->validator->validate(null, new Range(array('min' => 10, 'max' => 20)));
}
/**
* @dataProvider getValidValues
*/
public function testValidValues($value)
{
$this->context->expects($this->never())
->method('addViolation');
$constraint = new Range(array('min' => 10, 'max' => 20));
$this->validator->validate($value, $constraint);
}
public function getValidValues()
{
return array(
array(10.00001),
array(19.99999),
array('10.00001'),
array('19.99999'),
array(10),
array(20),
array(10.0),
array(20.0),
);
}
/**
* @dataProvider getInvalidValues
*/
public function testInvalidValues($value)
{
$this->context->expects($this->once())
->method('addViolation');
$constraint = new Range(array('min' => 10, 'max' => 20));
$this->validator->validate($value, $constraint);
}
public function getInvalidValues()
{
return array(
array(9.999999),
array(20.000001),
array('9.999999'),
array('20.000001'),
array(new \stdClass()),
);
}
public function testMinMessageIsSet()
{
$constraint = new Range(array(
'min' => 10,
'max' => 20,
'minMessage' => 'myMessage',
));
$this->context->expects($this->once())
->method('addViolation')
->with('myMessage', array(
'{{ value }}' => 9,
'{{ limit }}' => 10,
));
$this->validator->validate(9, $constraint);
}
public function testMaxMessageIsSet()
{
$constraint = new Range(array(
'min' => 10,
'max' => 20,
'maxMessage' => 'myMessage',
));
$this->context->expects($this->once())
->method('addViolation')
->with('myMessage', array(
'{{ value }}' => 21,
'{{ limit }}' => 20,
));
$this->validator->validate(21, $constraint);
}
}

172
src/Symfony/Component/Validator/Tests/Constraints/SizeLengthValidatorTest.php
View File

@ -1,172 +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\Constraints;
use Symfony\Component\Validator\Constraints\SizeLength;
use Symfony\Component\Validator\Constraints\SizeLengthValidator;
class SizeLengthValidatorTest extends \PHPUnit_Framework_TestCase
{
protected $context;
protected $validator;
protected function setUp()
{
$this->context = $this->getMock('Symfony\Component\Validator\ExecutionContext', array(), array(), '', false);
$this->validator = new SizeLengthValidator();
$this->validator->initialize($this->context);
}
protected function tearDown()
{
$this->context = null;
$this->validator = null;
}
public function testNullIsValid()
{
$this->context->expects($this->never())
->method('addViolation');
$this->validator->validate(null, new SizeLength(array('min' => 6, 'max' => 10)));
}
public function testEmptyStringIsValid()
{
$this->context->expects($this->never())
->method('addViolation');
$this->validator->validate('', new SizeLength(array('min' => 6, 'max' => 10)));
}
/**
* @expectedException Symfony\Component\Validator\Exception\UnexpectedTypeException
*/
public function testExpectsStringCompatibleType()
{
$this->validator->validate(new \stdClass(), new SizeLength(array('min' => 6, 'max' => 10)));
}
/**
* @dataProvider getValidValues
*/
public function testValidValues($value, $mbOnly = false)
{
if ($mbOnly && !function_exists('mb_strlen')) {
return $this->markTestSkipped('mb_strlen does not exist');
}
$this->context->expects($this->never())
->method('addViolation');
$constraint = new SizeLength(array('min' => 6, 'max' => 10));
$this->validator->validate($value, $constraint);
}
public function getValidValues()
{
return array(
array(123456),
array(1234567890),
array('123456'),
array('1234567890'),
array('üüüüüü', true),
array('üüüüüüüüüü', true),
array('éééééé', true),
array('éééééééééé', true),
);
}
/**
* @dataProvider getInvalidValues
*/
public function testInvalidValues($value, $mbOnly = false)
{
if ($mbOnly && !function_exists('mb_strlen')) {
return $this->markTestSkipped('mb_strlen does not exist');
}
$this->context->expects($this->once())
->method('addViolation');
$constraint = new SizeLength(array('min' => 6, 'max' => 10));
$this->validator->validate($value, $constraint);
}
public function getInvalidValues()
{
return array(
array(12345),
array(12345678901),
array('12345'),
array('12345678901'),
array('üüüüü', true),
array('üüüüüüüüüüü', true),
array('ééééé', true),
array('ééééééééééé', true),
);
}
public function testMinMessageIsSet()
{
$constraint = new SizeLength(array(
'min' => 5,
'max' => 10,
'minMessage' => 'myMessage',
));
$this->context->expects($this->once())
->method('addViolation')
->with('myMessage', array(
'{{ value }}' => '1234',
'{{ limit }}' => 5,
), null, 5);
$this->validator->validate('1234', $constraint);
}
public function testMaxMessageIsSet()
{
$constraint = new SizeLength(array(
'min' => 5,
'max' => 10,
'maxMessage' => 'myMessage',
));
$this->context->expects($this->once())
->method('addViolation')
->with('myMessage', array(
'{{ value }}' => '12345678901',
'{{ limit }}' => 10,
), null, 10);
$this->validator->validate('12345678901', $constraint);
}
public function testExactMessageIsSet()
{
$constraint = new SizeLength(array(
'min' => 5,
'max' => 5,
'exactMessage' => 'myMessage',
));
$this->context->expects($this->once())
->method('addViolation')
->with('myMessage', array(
'{{ value }}' => '1234',
'{{ limit }}' => 5,
), null, 5);
$this->validator->validate('1234', $constraint);
}
}

98
src/Symfony/Component/Validator/Tests/Constraints/SizeTest.php Normal file
View File

@ -0,0 +1,98 @@
<?php
namespace Symfony\Component\Validator\Tests\Constraints;
use Symfony\Component\Validator\Constraints\Size;
class SizeTest extends \PHPUnit_Framework_TestCase
{
/**
* @dataProvider getMinMessageData
*/
public function testGetMinMessage($options, $type, $expected)
{
$size = new Size($options);
$this->assertEquals($expected, $size->getMinMessage($type));
}
public function getMinMessageData()
{
$size = new Size();
return array(
array(array(), Size::TYPE_STRING, $this->readAttribute($size, 'stringMinMessage')),
array(array(), Size::TYPE_COLLECTION, $this->readAttribute($size, 'collectionMinMessage')),
array(array('minMessage' => 'Custom min message'), Size::TYPE_STRING, 'Custom min message'),
array(array('minMessage' => 'Custom min message'), Size::TYPE_COLLECTION, 'Custom min message'),
);
}
/**
* @expectedException InvalidArgumentException
*/
public function testGetMinMessageWithInvalidType()
{
$size = new Size();
$size->getMinMessage('foo');
}
/**
* @dataProvider getMaxMessageData
*/
public function testGetMaxMessage($options, $type, $expected)
{
$size = new Size($options);
$this->assertEquals($expected, $size->getMaxMessage($type));
}
public function getMaxMessageData()
{
$size = new Size();
return array(
array(array(), Size::TYPE_STRING, $this->readAttribute($size, 'stringMaxMessage')),
array(array(), Size::TYPE_COLLECTION, $this->readAttribute($size, 'collectionMaxMessage')),
array(array('maxMessage' => 'Custom max message'), Size::TYPE_STRING, 'Custom max message'),
array(array('maxMessage' => 'Custom max message'), Size::TYPE_COLLECTION, 'Custom max message'),
);
}
/**
* @expectedException InvalidArgumentException
*/
public function testGetMaxMessageWithInvalidType()
{
$size = new Size();
$size->getMaxMessage('foo');
}
/**
* @dataProvider getExactMessageData
*/
public function testGetExactMessage($options, $type, $expected)
{
$size = new Size($options);
$this->assertEquals($expected, $size->getExactMessage($type));
}
public function getExactMessageData()
{
$size = new Size();
return array(
array(array(), Size::TYPE_STRING, $this->readAttribute($size, 'stringExactMessage')),
array(array(), Size::TYPE_COLLECTION, $this->readAttribute($size, 'collectionExactMessage')),
array(array('exactMessage' => 'Custom exact message'), Size::TYPE_STRING, 'Custom exact message'),
array(array('exactMessage' => 'Custom exact message'), Size::TYPE_COLLECTION, 'Custom exact message'),
);
}
/**
* @expectedException InvalidArgumentException
*/
public function testGetExactMessageWithInvalidType()
{
$size = new Size();
$size->getExactMessage('foo');
}
}

205
src/Symfony/Component/Validator/Tests/Constraints/SizeValidatorTest.php
View File

@ -14,6 +14,19 @@ namespace Symfony\Component\Validator\Tests\Constraints;
use Symfony\Component\Validator\Constraints\Size;
use Symfony\Component\Validator\Constraints\SizeValidator;
class SizeAmbiguous implements \Countable
{
public function __toString()
{
return '';
}
public function count()
{
return 0;
}
}
class SizeValidatorTest extends \PHPUnit_Framework_TestCase
{
protected $context;
@ -28,94 +41,176 @@ class SizeValidatorTest extends \PHPUnit_Framework_TestCase
public function testNullIsValid()
{
$this->context->expects($this->never())
->method('addViolation');
$this->context->expects($this->never())->method('addViolation');
$this->validator->validate(null, new Size(array('min' => 10, 'max' => 20)));
}
/**
* @dataProvider getValidValues
*/
public function testValidValues($value)
public function testNullIsValidAsAString()
{
$this->context->expects($this->never())->method('addViolation');
$this->validator->validate(null, new Size(array('type' => 'string', 'min' => 10, 'max' => 20)));
}
public function testNullIsValidAsACollectionCollection()
{
$this->context->expects($this->never())->method('addViolation');
$this->validator->validate(null, new Size(array('type' => 'collection', 'min' => 10, 'max' => 20)));
}
public function testEmptyStringIsValid()
{
$this->context->expects($this->never())->method('addViolation');
$this->validator->validate('', new Size(array('min' => 10, 'max' => 20)));
}
public function testEmptyStringIsValidAsAString()
{
$this->context->expects($this->never())->method('addViolation');
$this->validator->validate('', new Size(array('type' => 'string', 'min' => 10, 'max' => 20)));
}
/**
* @dataProvider getValidStringValues
*/
public function testValidStringValues($value, $mbOnly = false)
{
if ($mbOnly && !function_exists('mb_strlen')) {
return $this->markTestSkipped('mb_strlen does not exist');
}
$this->context->expects($this->never())
->method('addViolation');
$constraint = new Size(array('min' => 10, 'max' => 20));
$constraint = new Size(array('min' => 6, 'max' => 10));
$this->validator->validate($value, $constraint);
}
public function getValidValues()
public function getValidStringValues()
{
return array(
array(10.00001),
array(19.99999),
array('10.00001'),
array('19.99999'),
array(10),
array(20),
array(10.0),
array(20.0),
array(123456),
array(1234567890),
array('123456'),
array('1234567890'),
array('üüüüüü', true),
array('üüüüüüüüüü', true),
array('éééééé', true),
array('éééééééééé', true),
);
}
/**
* @dataProvider getInvalidValues
* @dataProvider getInvalidStringValues
*/
public function testInvalidValues($value)
public function testInvalidStringValues($value, $mbOnly = false)
{
$this->context->expects($this->once())
->method('addViolation');
if ($mbOnly && !function_exists('mb_strlen')) {
return $this->markTestSkipped('mb_strlen does not exist');
}
$constraint = new Size(array('min' => 10, 'max' => 20));
$this->validator->validate($value, $constraint);
$this->context->expects($this->once())->method('addViolation');
$this->validator->validate($value, new Size(array('min' => 6, 'max' => 10)));
}
public function getInvalidValues()
public function getInvalidStringValues()
{
return array(
array(9.999999),
array(20.000001),
array('9.999999'),
array('20.000001'),
array(new \stdClass()),
array(12345),
array(12345678901),
array('12345'),
array('12345678901'),
array('üüüüü', true),
array('üüüüüüüüüüü', true),
array('ééééé', true),
array('ééééééééééé', true),
);
}
public function testMinMessageIsSet()
/**
* @dataProvider getValidCollectionValues
*/
public function testValidCollectionValue($value)
{
$constraint = new Size(array(
'min' => 10,
'max' => 20,
'minMessage' => 'myMessage',
));
$this->context->expects($this->never())->method('addViolation');
$this->context->expects($this->once())
->method('addViolation')
->with('myMessage', array(
'{{ value }}' => 9,
'{{ limit }}' => 10,
));
$this->validator->validate(9, $constraint);
$this->validator->validate($value, new Size(array('min' => 10, 'max' => 20)));
}
public function testMaxMessageIsSet()
public function getValidCollectionValues()
{
$constraint = new Size(array(
'min' => 10,
'max' => 20,
'maxMessage' => 'myMessage',
));
$countable = $this->getMock('Countable');
$countable->expects($this->any())->method('count')->will($this->returnValue(15));
$this->context->expects($this->once())
->method('addViolation')
->with('myMessage', array(
'{{ value }}' => 21,
'{{ limit }}' => 20,
));
return array(
array($countable),
array(range(1, 15)),
);
}
$this->validator->validate(21, $constraint);
/**
* @dataProvider getInvalidCollectionValues
*/
public function testInvalidCollectionValue($value)
{
$this->context->expects($this->once())->method('addViolation');
$this->validator->validate($value, new Size(array('min' => 10, 'max' => 20)));
}
public function getInvalidCollectionValues()
{
$tooSmallCountable = $this->getMock('Countable');
$tooSmallCountable->expects($this->any())->method('count')->will($this->returnValue(5));
$tooBigCountable = $this->getmock('countable');
$tooBigCountable->expects($this->any())->method('count')->will($this->returnValue(25));
return array(
array($tooSmallCountable),
array($tooBigCountable),
array(array()),
array(range(1, 5)),
array(range(1, 25)),
);
}
/**
* @expectedException RuntimeException
*/
public function throwsAnExceptionWhenOnAmbiguousValue()
{
$this->validator->validate(new SizeAmbiguous(), new Size(array('min' => 10, 'max' => 20)));
}
/**
* @expectedException Symfony\Component\Validator\Exception\UnexpectedTypeException
*/
public function testExpectsEitherStringOrCollectionCompatible()
{
$this->validator->validate(new \stdCLass(), new Size(array('min' => 10, 'max' => 20)));
}
/**
* @expectedException Symfony\Component\Validator\Exception\UnexpectedTypeException
*/
public function testExpectsStringCompatibleType()
{
$countable = $this->getMock('Countable');
$this->validator->validate($countable, new Size(array('type' => 'string', 'min' => 6, 'max' => 10)));
}
/**
* @expectedException Symfony\Component\Validator\Exception\UnexpectedTypeException
*/
public function testExpectsCollectionCompatibleType()
{
$this->validator->validate('string', new Size(array('type' => 'collection', 'min' => 6, 'max' => 10)));
}
}