www.aleph1.co.uk Git - yaffs-website/blob - vendor/symfony/validator/Tests/Constraints/CallbackValidatorTest.php

   1 <?php
   2
   3 /*
   4  * This file is part of the Symfony package.
   5  *
   6  * (c) Fabien Potencier <fabien@symfony.com>
   7  *
   8  * For the full copyright and license information, please view the LICENSE
   9  * file that was distributed with this source code.
  10  */
  11
  12 namespace Symfony\Component\Validator\Tests\Constraints;
  13
  14 use Symfony\Component\Validator\Constraint;
  15 use Symfony\Component\Validator\Constraints\Callback;
  16 use Symfony\Component\Validator\Constraints\CallbackValidator;
  17 use Symfony\Component\Validator\ExecutionContextInterface;
  18 use Symfony\Component\Validator\Validation;
  19
  20 class CallbackValidatorTest_Class
  21 {
  22     public static function validateCallback($object, ExecutionContextInterface $context)
  23     {
  24         $context->addViolation('Callback message', array('{{ value }}' => 'foobar'));
  25
  26         return false;
  27     }
  28 }
  29
  30 class CallbackValidatorTest_Object
  31 {
  32     public function validate(ExecutionContextInterface $context)
  33     {
  34         $context->addViolation('My message', array('{{ value }}' => 'foobar'));
  35
  36         return false;
  37     }
  38
  39     public static function validateStatic($object, ExecutionContextInterface $context)
  40     {
  41         $context->addViolation('Static message', array('{{ value }}' => 'baz'));
  42
  43         return false;
  44     }
  45 }
  46
  47 class CallbackValidatorTest extends AbstractConstraintValidatorTest
  48 {
  49     protected function getApiVersion()
  50     {
  51         return Validation::API_VERSION_2_5;
  52     }
  53
  54     protected function createValidator()
  55     {
  56         return new CallbackValidator();
  57     }
  58
  59     public function testNullIsValid()
  60     {
  61         $this->validator->validate(null, new Callback());
  62
  63         $this->assertNoViolation();
  64     }
  65
  66     public function testSingleMethod()
  67     {
  68         $object = new CallbackValidatorTest_Object();
  69         $constraint = new Callback('validate');
  70
  71         $this->validator->validate($object, $constraint);
  72
  73         $this->buildViolation('My message')
  74             ->setParameter('{{ value }}', 'foobar')
  75             ->assertRaised();
  76     }
  77
  78     public function testSingleMethodExplicitName()
  79     {
  80         $object = new CallbackValidatorTest_Object();
  81         $constraint = new Callback(array('callback' => 'validate'));
  82
  83         $this->validator->validate($object, $constraint);
  84
  85         $this->buildViolation('My message')
  86             ->setParameter('{{ value }}', 'foobar')
  87             ->assertRaised();
  88     }
  89
  90     public function testSingleStaticMethod()
  91     {
  92         $object = new CallbackValidatorTest_Object();
  93         $constraint = new Callback('validateStatic');
  94
  95         $this->validator->validate($object, $constraint);
  96
  97         $this->buildViolation('Static message')
  98             ->setParameter('{{ value }}', 'baz')
  99             ->assertRaised();
 100     }
 101
 102     public function testClosure()
 103     {
 104         $object = new CallbackValidatorTest_Object();
 105         $constraint = new Callback(function ($object, ExecutionContextInterface $context) {
 106             $context->addViolation('My message', array('{{ value }}' => 'foobar'));
 107
 108             return false;
 109         });
 110
 111         $this->validator->validate($object, $constraint);
 112
 113         $this->buildViolation('My message')
 114             ->setParameter('{{ value }}', 'foobar')
 115             ->assertRaised();
 116     }
 117
 118     public function testClosureNullObject()
 119     {
 120         $constraint = new Callback(function ($object, ExecutionContextInterface $context) {
 121             $context->addViolation('My message', array('{{ value }}' => 'foobar'));
 122
 123             return false;
 124         });
 125
 126         $this->validator->validate(null, $constraint);
 127
 128         $this->buildViolation('My message')
 129             ->setParameter('{{ value }}', 'foobar')
 130             ->assertRaised();
 131     }
 132
 133     public function testClosureExplicitName()
 134     {
 135         $object = new CallbackValidatorTest_Object();
 136         $constraint = new Callback(array(
 137             'callback' => function ($object, ExecutionContextInterface $context) {
 138                 $context->addViolation('My message', array('{{ value }}' => 'foobar'));
 139
 140                 return false;
 141             },
 142         ));
 143
 144         $this->validator->validate($object, $constraint);
 145
 146         $this->buildViolation('My message')
 147             ->setParameter('{{ value }}', 'foobar')
 148             ->assertRaised();
 149     }
 150
 151     public function testArrayCallable()
 152     {
 153         $object = new CallbackValidatorTest_Object();
 154         $constraint = new Callback(array(__CLASS__.'_Class', 'validateCallback'));
 155
 156         $this->validator->validate($object, $constraint);
 157
 158         $this->buildViolation('Callback message')
 159             ->setParameter('{{ value }}', 'foobar')
 160             ->assertRaised();
 161     }
 162
 163     public function testArrayCallableNullObject()
 164     {
 165         $constraint = new Callback(array(__CLASS__.'_Class', 'validateCallback'));
 166
 167         $this->validator->validate(null, $constraint);
 168
 169         $this->buildViolation('Callback message')
 170             ->setParameter('{{ value }}', 'foobar')
 171             ->assertRaised();
 172     }
 173
 174     public function testArrayCallableExplicitName()
 175     {
 176         $object = new CallbackValidatorTest_Object();
 177         $constraint = new Callback(array(
 178             'callback' => array(__CLASS__.'_Class', 'validateCallback'),
 179         ));
 180
 181         $this->validator->validate($object, $constraint);
 182
 183         $this->buildViolation('Callback message')
 184             ->setParameter('{{ value }}', 'foobar')
 185             ->assertRaised();
 186     }
 187
 188     /**
 189      * @group legacy
 190      */
 191     public function testLegacySingleMethodBc()
 192     {
 193         $object = new CallbackValidatorTest_Object();
 194         $constraint = new Callback(array('validate'));
 195
 196         $this->validator->validate($object, $constraint);
 197
 198         $this->buildViolation('My message')
 199             ->setParameter('{{ value }}', 'foobar')
 200             ->assertRaised();
 201     }
 202
 203     /**
 204      * @group legacy
 205      */
 206     public function testLegacySingleMethodBcExplicitName()
 207     {
 208         $object = new CallbackValidatorTest_Object();
 209         $constraint = new Callback(array('methods' => array('validate')));
 210
 211         $this->validator->validate($object, $constraint);
 212
 213         $this->buildViolation('My message')
 214             ->setParameter('{{ value }}', 'foobar')
 215             ->assertRaised();
 216     }
 217
 218     /**
 219      * @group legacy
 220      */
 221     public function testLegacyMultipleMethodsBc()
 222     {
 223         $object = new CallbackValidatorTest_Object();
 224         $constraint = new Callback(array('validate', 'validateStatic'));
 225
 226         $this->validator->validate($object, $constraint);
 227
 228         $this->buildViolation('My message')
 229             ->setParameter('{{ value }}', 'foobar')
 230             ->buildNextViolation('Static message')
 231             ->setParameter('{{ value }}', 'baz')
 232             ->assertRaised();
 233     }
 234
 235     /**
 236      * @group legacy
 237      */
 238     public function testLegacyMultipleMethodsBcExplicitName()
 239     {
 240         $object = new CallbackValidatorTest_Object();
 241         $constraint = new Callback(array(
 242             'methods' => array('validate', 'validateStatic'),
 243         ));
 244
 245         $this->validator->validate($object, $constraint);
 246
 247         $this->buildViolation('My message')
 248             ->setParameter('{{ value }}', 'foobar')
 249             ->buildNextViolation('Static message')
 250             ->setParameter('{{ value }}', 'baz')
 251             ->assertRaised();
 252     }
 253
 254     /**
 255      * @group legacy
 256      */
 257     public function testLegacySingleStaticMethodBc()
 258     {
 259         $object = new CallbackValidatorTest_Object();
 260         $constraint = new Callback(array(
 261             array(__CLASS__.'_Class', 'validateCallback'),
 262         ));
 263
 264         $this->validator->validate($object, $constraint);
 265
 266         $this->buildViolation('Callback message')
 267             ->setParameter('{{ value }}', 'foobar')
 268             ->assertRaised();
 269     }
 270
 271     /**
 272      * @group legacy
 273      */
 274     public function testLegacySingleStaticMethodBcExplicitName()
 275     {
 276         $object = new CallbackValidatorTest_Object();
 277         $constraint = new Callback(array(
 278             'methods' => array(array(__CLASS__.'_Class', 'validateCallback')),
 279         ));
 280
 281         $this->validator->validate($object, $constraint);
 282
 283         $this->buildViolation('Callback message')
 284             ->setParameter('{{ value }}', 'foobar')
 285             ->assertRaised();
 286     }
 287
 288     /**
 289      * @expectedException \Symfony\Component\Validator\Exception\ConstraintDefinitionException
 290      */
 291     public function testExpectValidMethods()
 292     {
 293         $object = new CallbackValidatorTest_Object();
 294
 295         $this->validator->validate($object, new Callback(array('callback' => array('foobar'))));
 296     }
 297
 298     /**
 299      * @expectedException \Symfony\Component\Validator\Exception\ConstraintDefinitionException
 300      */
 301     public function testExpectValidCallbacks()
 302     {
 303         $object = new CallbackValidatorTest_Object();
 304
 305         $this->validator->validate($object, new Callback(array('callback' => array('foo', 'bar'))));
 306     }
 307
 308     /**
 309      * @expectedException \Symfony\Component\Validator\Exception\ConstraintDefinitionException
 310      * @group legacy
 311      */
 312     public function testLegacyExpectEitherCallbackOrMethods()
 313     {
 314         $object = new CallbackValidatorTest_Object();
 315
 316         $this->validator->validate($object, new Callback(array(
 317             'callback' => 'validate',
 318             'methods' => array('validateStatic'),
 319         )));
 320     }
 321
 322     public function testConstraintGetTargets()
 323     {
 324         $constraint = new Callback(array());
 325         $targets = array(Constraint::CLASS_CONSTRAINT, Constraint::PROPERTY_CONSTRAINT);
 326
 327         $this->assertEquals($targets, $constraint->getTargets());
 328     }
 329
 330     // Should succeed. Needed when defining constraints as annotations.
 331     public function testNoConstructorArguments()
 332     {
 333         $constraint = new Callback();
 334
 335         $this->assertSame(array(Constraint::CLASS_CONSTRAINT, Constraint::PROPERTY_CONSTRAINT), $constraint->getTargets());
 336     }
 337
 338     public function testAnnotationInvocationSingleValued()
 339     {
 340         $constraint = new Callback(array('value' => 'validateStatic'));
 341
 342         $this->assertEquals(new Callback('validateStatic'), $constraint);
 343     }
 344
 345     public function testAnnotationInvocationMultiValued()
 346     {
 347         $constraint = new Callback(array('value' => array(__CLASS__.'_Class', 'validateCallback')));
 348
 349         $this->assertEquals(new Callback(array(__CLASS__.'_Class', 'validateCallback')), $constraint);
 350     }
 351 }