diff options
Diffstat (limited to 'vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Validator/Constraints/FormValidatorTest.php')
-rw-r--r-- | vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Validator/Constraints/FormValidatorTest.php | 748 |
1 files changed, 748 insertions, 0 deletions
diff --git a/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Validator/Constraints/FormValidatorTest.php b/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Validator/Constraints/FormValidatorTest.php new file mode 100644 index 00000000..a8bdde8a --- /dev/null +++ b/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Validator/Constraints/FormValidatorTest.php | |||
@@ -0,0 +1,748 @@ | |||
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\Form\Tests\Extension\Validator\Constraints; | ||
13 | |||
14 | use Symfony\Component\Form\FormBuilder; | ||
15 | use Symfony\Component\Form\Exception\TransformationFailedException; | ||
16 | use Symfony\Component\Form\CallbackTransformer; | ||
17 | use Symfony\Component\Form\FormInterface; | ||
18 | use Symfony\Component\Form\Extension\Validator\Constraints\Form; | ||
19 | use Symfony\Component\Form\Extension\Validator\Constraints\FormValidator; | ||
20 | use Symfony\Component\Form\SubmitButtonBuilder; | ||
21 | use Symfony\Component\Validator\Constraint; | ||
22 | use Symfony\Component\Validator\Constraints\NotNull; | ||
23 | use Symfony\Component\Validator\Constraints\NotBlank; | ||
24 | |||
25 | /** | ||
26 | * @author Bernhard Schussek <bschussek@gmail.com> | ||
27 | */ | ||
28 | class FormValidatorTest extends \PHPUnit_Framework_TestCase | ||
29 | { | ||
30 | /** | ||
31 | * @var \PHPUnit_Framework_MockObject_MockObject | ||
32 | */ | ||
33 | private $dispatcher; | ||
34 | |||
35 | /** | ||
36 | * @var \PHPUnit_Framework_MockObject_MockObject | ||
37 | */ | ||
38 | private $factory; | ||
39 | |||
40 | /** | ||
41 | * @var \PHPUnit_Framework_MockObject_MockObject | ||
42 | */ | ||
43 | private $serverParams; | ||
44 | |||
45 | /** | ||
46 | * @var FormValidator | ||
47 | */ | ||
48 | private $validator; | ||
49 | |||
50 | protected function setUp() | ||
51 | { | ||
52 | if (!class_exists('Symfony\Component\EventDispatcher\Event')) { | ||
53 | $this->markTestSkipped('The "EventDispatcher" component is not available'); | ||
54 | } | ||
55 | |||
56 | $this->dispatcher = $this->getMock('Symfony\Component\EventDispatcher\EventDispatcherInterface'); | ||
57 | $this->factory = $this->getMock('Symfony\Component\Form\FormFactoryInterface'); | ||
58 | $this->serverParams = $this->getMock( | ||
59 | 'Symfony\Component\Form\Extension\Validator\Util\ServerParams', | ||
60 | array('getNormalizedIniPostMaxSize', 'getContentLength') | ||
61 | ); | ||
62 | $this->validator = new FormValidator($this->serverParams); | ||
63 | } | ||
64 | |||
65 | public function testValidate() | ||
66 | { | ||
67 | $context = $this->getMockExecutionContext(); | ||
68 | $object = $this->getMock('\stdClass'); | ||
69 | $options = array('validation_groups' => array('group1', 'group2')); | ||
70 | $form = $this->getBuilder('name', '\stdClass', $options) | ||
71 | ->setData($object) | ||
72 | ->getForm(); | ||
73 | |||
74 | $context->expects($this->at(0)) | ||
75 | ->method('validate') | ||
76 | ->with($object, 'data', 'group1', true); | ||
77 | $context->expects($this->at(1)) | ||
78 | ->method('validate') | ||
79 | ->with($object, 'data', 'group2', true); | ||
80 | |||
81 | $this->validator->initialize($context); | ||
82 | $this->validator->validate($form, new Form()); | ||
83 | } | ||
84 | |||
85 | public function testValidateConstraints() | ||
86 | { | ||
87 | $context = $this->getMockExecutionContext(); | ||
88 | $object = $this->getMock('\stdClass'); | ||
89 | $constraint1 = new NotNull(array('groups' => array('group1', 'group2'))); | ||
90 | $constraint2 = new NotBlank(array('groups' => 'group2')); | ||
91 | |||
92 | $options = array( | ||
93 | 'validation_groups' => array('group1', 'group2'), | ||
94 | 'constraints' => array($constraint1, $constraint2), | ||
95 | ); | ||
96 | $form = $this->getBuilder('name', '\stdClass', $options) | ||
97 | ->setData($object) | ||
98 | ->getForm(); | ||
99 | |||
100 | // First default constraints | ||
101 | $context->expects($this->at(0)) | ||
102 | ->method('validate') | ||
103 | ->with($object, 'data', 'group1', true); | ||
104 | $context->expects($this->at(1)) | ||
105 | ->method('validate') | ||
106 | ->with($object, 'data', 'group2', true); | ||
107 | |||
108 | // Then custom constraints | ||
109 | $context->expects($this->at(2)) | ||
110 | ->method('validateValue') | ||
111 | ->with($object, $constraint1, 'data', 'group1'); | ||
112 | $context->expects($this->at(3)) | ||
113 | ->method('validateValue') | ||
114 | ->with($object, $constraint2, 'data', 'group2'); | ||
115 | |||
116 | $this->validator->initialize($context); | ||
117 | $this->validator->validate($form, new Form()); | ||
118 | } | ||
119 | |||
120 | public function testDontValidateIfParentWithoutCascadeValidation() | ||
121 | { | ||
122 | $context = $this->getMockExecutionContext(); | ||
123 | $object = $this->getMock('\stdClass'); | ||
124 | |||
125 | $parent = $this->getBuilder('parent', null, array('cascade_validation' => false)) | ||
126 | ->setCompound(true) | ||
127 | ->setDataMapper($this->getDataMapper()) | ||
128 | ->getForm(); | ||
129 | $options = array('validation_groups' => array('group1', 'group2')); | ||
130 | $form = $this->getBuilder('name', '\stdClass', $options)->getForm(); | ||
131 | $parent->add($form); | ||
132 | |||
133 | $form->setData($object); | ||
134 | |||
135 | $context->expects($this->never()) | ||
136 | ->method('validate'); | ||
137 | |||
138 | $this->validator->initialize($context); | ||
139 | $this->validator->validate($form, new Form()); | ||
140 | } | ||
141 | |||
142 | public function testValidateConstraintsEvenIfNoCascadeValidation() | ||
143 | { | ||
144 | $context = $this->getMockExecutionContext(); | ||
145 | $object = $this->getMock('\stdClass'); | ||
146 | $constraint1 = new NotNull(array('groups' => array('group1', 'group2'))); | ||
147 | $constraint2 = new NotBlank(array('groups' => 'group2')); | ||
148 | |||
149 | $parent = $this->getBuilder('parent', null, array('cascade_validation' => false)) | ||
150 | ->setCompound(true) | ||
151 | ->setDataMapper($this->getDataMapper()) | ||
152 | ->getForm(); | ||
153 | $options = array( | ||
154 | 'validation_groups' => array('group1', 'group2'), | ||
155 | 'constraints' => array($constraint1, $constraint2), | ||
156 | ); | ||
157 | $form = $this->getBuilder('name', '\stdClass', $options) | ||
158 | ->setData($object) | ||
159 | ->getForm(); | ||
160 | $parent->add($form); | ||
161 | |||
162 | $context->expects($this->at(0)) | ||
163 | ->method('validateValue') | ||
164 | ->with($object, $constraint1, 'data', 'group1'); | ||
165 | $context->expects($this->at(1)) | ||
166 | ->method('validateValue') | ||
167 | ->with($object, $constraint2, 'data', 'group2'); | ||
168 | |||
169 | $this->validator->initialize($context); | ||
170 | $this->validator->validate($form, new Form()); | ||
171 | } | ||
172 | |||
173 | public function testDontValidateIfNoValidationGroups() | ||
174 | { | ||
175 | $context = $this->getMockExecutionContext(); | ||
176 | $object = $this->getMock('\stdClass'); | ||
177 | |||
178 | $form = $this->getBuilder('name', '\stdClass', array( | ||
179 | 'validation_groups' => array(), | ||
180 | )) | ||
181 | ->setData($object) | ||
182 | ->getForm(); | ||
183 | |||
184 | $form->setData($object); | ||
185 | |||
186 | $context->expects($this->never()) | ||
187 | ->method('validate'); | ||
188 | |||
189 | $this->validator->initialize($context); | ||
190 | $this->validator->validate($form, new Form()); | ||
191 | } | ||
192 | |||
193 | public function testDontValidateConstraintsIfNoValidationGroups() | ||
194 | { | ||
195 | $context = $this->getMockExecutionContext(); | ||
196 | $object = $this->getMock('\stdClass'); | ||
197 | $constraint1 = $this->getMock('Symfony\Component\Validator\Constraint'); | ||
198 | $constraint2 = $this->getMock('Symfony\Component\Validator\Constraint'); | ||
199 | |||
200 | $options = array( | ||
201 | 'validation_groups' => array(), | ||
202 | 'constraints' => array($constraint1, $constraint2), | ||
203 | ); | ||
204 | $form = $this->getBuilder('name', '\stdClass', $options) | ||
205 | ->setData($object) | ||
206 | ->getForm(); | ||
207 | |||
208 | // Launch transformer | ||
209 | $form->submit(array()); | ||
210 | |||
211 | $context->expects($this->never()) | ||
212 | ->method('validate'); | ||
213 | |||
214 | $this->validator->initialize($context); | ||
215 | $this->validator->validate($form, new Form()); | ||
216 | } | ||
217 | |||
218 | public function testDontValidateIfNotSynchronized() | ||
219 | { | ||
220 | $context = $this->getMockExecutionContext(); | ||
221 | $object = $this->getMock('\stdClass'); | ||
222 | |||
223 | $form = $this->getBuilder('name', '\stdClass', array( | ||
224 | 'invalid_message' => 'invalid_message_key', | ||
225 | // Invalid message parameters must be supported, because the | ||
226 | // invalid message can be a translation key | ||
227 | // see https://github.com/symfony/symfony/issues/5144 | ||
228 | 'invalid_message_parameters' => array('{{ foo }}' => 'bar'), | ||
229 | )) | ||
230 | ->setData($object) | ||
231 | ->addViewTransformer(new CallbackTransformer( | ||
232 | function ($data) { return $data; }, | ||
233 | function () { throw new TransformationFailedException(); } | ||
234 | )) | ||
235 | ->getForm(); | ||
236 | |||
237 | // Launch transformer | ||
238 | $form->submit('foo'); | ||
239 | |||
240 | $context->expects($this->never()) | ||
241 | ->method('validate'); | ||
242 | |||
243 | $context->expects($this->once()) | ||
244 | ->method('addViolation') | ||
245 | ->with( | ||
246 | 'invalid_message_key', | ||
247 | array('{{ value }}' => 'foo', '{{ foo }}' => 'bar'), | ||
248 | 'foo' | ||
249 | ); | ||
250 | $context->expects($this->never()) | ||
251 | ->method('addViolationAt'); | ||
252 | |||
253 | $this->validator->initialize($context); | ||
254 | $this->validator->validate($form, new Form()); | ||
255 | } | ||
256 | |||
257 | public function testAddInvalidErrorEvenIfNoValidationGroups() | ||
258 | { | ||
259 | $context = $this->getMockExecutionContext(); | ||
260 | $object = $this->getMock('\stdClass'); | ||
261 | |||
262 | $form = $this->getBuilder('name', '\stdClass', array( | ||
263 | 'invalid_message' => 'invalid_message_key', | ||
264 | // Invalid message parameters must be supported, because the | ||
265 | // invalid message can be a translation key | ||
266 | // see https://github.com/symfony/symfony/issues/5144 | ||
267 | 'invalid_message_parameters' => array('{{ foo }}' => 'bar'), | ||
268 | 'validation_groups' => array(), | ||
269 | )) | ||
270 | ->setData($object) | ||
271 | ->addViewTransformer(new CallbackTransformer( | ||
272 | function ($data) { return $data; }, | ||
273 | function () { throw new TransformationFailedException(); } | ||
274 | )) | ||
275 | ->getForm(); | ||
276 | |||
277 | // Launch transformer | ||
278 | $form->submit('foo'); | ||
279 | |||
280 | $context->expects($this->never()) | ||
281 | ->method('validate'); | ||
282 | |||
283 | $context->expects($this->once()) | ||
284 | ->method('addViolation') | ||
285 | ->with( | ||
286 | 'invalid_message_key', | ||
287 | array('{{ value }}' => 'foo', '{{ foo }}' => 'bar'), | ||
288 | 'foo' | ||
289 | ); | ||
290 | $context->expects($this->never()) | ||
291 | ->method('addViolationAt'); | ||
292 | |||
293 | $this->validator->initialize($context); | ||
294 | $this->validator->validate($form, new Form()); | ||
295 | } | ||
296 | |||
297 | public function testDontValidateConstraintsIfNotSynchronized() | ||
298 | { | ||
299 | $context = $this->getMockExecutionContext(); | ||
300 | $object = $this->getMock('\stdClass'); | ||
301 | $constraint1 = $this->getMock('Symfony\Component\Validator\Constraint'); | ||
302 | $constraint2 = $this->getMock('Symfony\Component\Validator\Constraint'); | ||
303 | |||
304 | $options = array( | ||
305 | 'validation_groups' => array('group1', 'group2'), | ||
306 | 'constraints' => array($constraint1, $constraint2), | ||
307 | ); | ||
308 | $form = $this->getBuilder('name', '\stdClass', $options) | ||
309 | ->setData($object) | ||
310 | ->addViewTransformer(new CallbackTransformer( | ||
311 | function ($data) { return $data; }, | ||
312 | function () { throw new TransformationFailedException(); } | ||
313 | )) | ||
314 | ->getForm(); | ||
315 | |||
316 | // Launch transformer | ||
317 | $form->submit(array()); | ||
318 | |||
319 | $context->expects($this->never()) | ||
320 | ->method('validate'); | ||
321 | |||
322 | $this->validator->initialize($context); | ||
323 | $this->validator->validate($form, new Form()); | ||
324 | } | ||
325 | |||
326 | // https://github.com/symfony/symfony/issues/4359 | ||
327 | public function testDontMarkInvalidIfAnyChildIsNotSynchronized() | ||
328 | { | ||
329 | $context = $this->getMockExecutionContext(); | ||
330 | $object = $this->getMock('\stdClass'); | ||
331 | |||
332 | $failingTransformer = new CallbackTransformer( | ||
333 | function ($data) { return $data; }, | ||
334 | function () { throw new TransformationFailedException(); } | ||
335 | ); | ||
336 | |||
337 | $form = $this->getBuilder('name', '\stdClass') | ||
338 | ->setData($object) | ||
339 | ->addViewTransformer($failingTransformer) | ||
340 | ->setCompound(true) | ||
341 | ->setDataMapper($this->getDataMapper()) | ||
342 | ->add( | ||
343 | $this->getBuilder('child') | ||
344 | ->addViewTransformer($failingTransformer) | ||
345 | ) | ||
346 | ->getForm(); | ||
347 | |||
348 | // Launch transformer | ||
349 | $form->submit(array('child' => 'foo')); | ||
350 | |||
351 | $context->expects($this->never()) | ||
352 | ->method('addViolation'); | ||
353 | $context->expects($this->never()) | ||
354 | ->method('addViolationAt'); | ||
355 | |||
356 | $this->validator->initialize($context); | ||
357 | $this->validator->validate($form, new Form()); | ||
358 | } | ||
359 | |||
360 | public function testHandleCallbackValidationGroups() | ||
361 | { | ||
362 | $context = $this->getMockExecutionContext(); | ||
363 | $object = $this->getMock('\stdClass'); | ||
364 | $options = array('validation_groups' => array($this, 'getValidationGroups')); | ||
365 | $form = $this->getBuilder('name', '\stdClass', $options) | ||
366 | ->setData($object) | ||
367 | ->getForm(); | ||
368 | |||
369 | $context->expects($this->at(0)) | ||
370 | ->method('validate') | ||
371 | ->with($object, 'data', 'group1', true); | ||
372 | $context->expects($this->at(1)) | ||
373 | ->method('validate') | ||
374 | ->with($object, 'data', 'group2', true); | ||
375 | |||
376 | $this->validator->initialize($context); | ||
377 | $this->validator->validate($form, new Form()); | ||
378 | } | ||
379 | |||
380 | public function testDontExecuteFunctionNames() | ||
381 | { | ||
382 | $context = $this->getMockExecutionContext(); | ||
383 | $object = $this->getMock('\stdClass'); | ||
384 | $options = array('validation_groups' => 'header'); | ||
385 | $form = $this->getBuilder('name', '\stdClass', $options) | ||
386 | ->setData($object) | ||
387 | ->getForm(); | ||
388 | |||
389 | $context->expects($this->once()) | ||
390 | ->method('validate') | ||
391 | ->with($object, 'data', 'header', true); | ||
392 | |||
393 | $this->validator->initialize($context); | ||
394 | $this->validator->validate($form, new Form()); | ||
395 | } | ||
396 | |||
397 | public function testHandleClosureValidationGroups() | ||
398 | { | ||
399 | $context = $this->getMockExecutionContext(); | ||
400 | $object = $this->getMock('\stdClass'); | ||
401 | $options = array('validation_groups' => function(FormInterface $form){ | ||
402 | return array('group1', 'group2'); | ||
403 | }); | ||
404 | $form = $this->getBuilder('name', '\stdClass', $options) | ||
405 | ->setData($object) | ||
406 | ->getForm(); | ||
407 | |||
408 | $context->expects($this->at(0)) | ||
409 | ->method('validate') | ||
410 | ->with($object, 'data', 'group1', true); | ||
411 | $context->expects($this->at(1)) | ||
412 | ->method('validate') | ||
413 | ->with($object, 'data', 'group2', true); | ||
414 | |||
415 | $this->validator->initialize($context); | ||
416 | $this->validator->validate($form, new Form()); | ||
417 | } | ||
418 | |||
419 | public function testUseValidationGroupOfClickedButton() | ||
420 | { | ||
421 | $context = $this->getMockExecutionContext(); | ||
422 | $object = $this->getMock('\stdClass'); | ||
423 | |||
424 | $parent = $this->getBuilder('parent', null, array('cascade_validation' => true)) | ||
425 | ->setCompound(true) | ||
426 | ->setDataMapper($this->getDataMapper()) | ||
427 | ->getForm(); | ||
428 | $form = $this->getForm('name', '\stdClass', array( | ||
429 | 'validation_groups' => 'form_group', | ||
430 | )); | ||
431 | |||
432 | $parent->add($form); | ||
433 | $parent->add($this->getClickedSubmitButton('submit', array( | ||
434 | 'validation_groups' => 'button_group', | ||
435 | ))); | ||
436 | |||
437 | $form->setData($object); | ||
438 | |||
439 | $context->expects($this->once()) | ||
440 | ->method('validate') | ||
441 | ->with($object, 'data', 'button_group', true); | ||
442 | |||
443 | $this->validator->initialize($context); | ||
444 | $this->validator->validate($form, new Form()); | ||
445 | } | ||
446 | |||
447 | public function testDontUseValidationGroupOfUnclickedButton() | ||
448 | { | ||
449 | $context = $this->getMockExecutionContext(); | ||
450 | $object = $this->getMock('\stdClass'); | ||
451 | |||
452 | $parent = $this->getBuilder('parent', null, array('cascade_validation' => true)) | ||
453 | ->setCompound(true) | ||
454 | ->setDataMapper($this->getDataMapper()) | ||
455 | ->getForm(); | ||
456 | $form = $this->getForm('name', '\stdClass', array( | ||
457 | 'validation_groups' => 'form_group', | ||
458 | )); | ||
459 | |||
460 | $parent->add($form); | ||
461 | $parent->add($this->getSubmitButton('submit', array( | ||
462 | 'validation_groups' => 'button_group', | ||
463 | ))); | ||
464 | |||
465 | $form->setData($object); | ||
466 | |||
467 | $context->expects($this->once()) | ||
468 | ->method('validate') | ||
469 | ->with($object, 'data', 'form_group', true); | ||
470 | |||
471 | $this->validator->initialize($context); | ||
472 | $this->validator->validate($form, new Form()); | ||
473 | } | ||
474 | |||
475 | public function testUseInheritedValidationGroup() | ||
476 | { | ||
477 | $context = $this->getMockExecutionContext(); | ||
478 | $object = $this->getMock('\stdClass'); | ||
479 | |||
480 | $parentOptions = array( | ||
481 | 'validation_groups' => 'group', | ||
482 | 'cascade_validation' => true, | ||
483 | ); | ||
484 | $parent = $this->getBuilder('parent', null, $parentOptions) | ||
485 | ->setCompound(true) | ||
486 | ->setDataMapper($this->getDataMapper()) | ||
487 | ->getForm(); | ||
488 | $form = $this->getBuilder('name', '\stdClass')->getForm(); | ||
489 | $parent->add($form); | ||
490 | |||
491 | $form->setData($object); | ||
492 | |||
493 | $context->expects($this->once()) | ||
494 | ->method('validate') | ||
495 | ->with($object, 'data', 'group', true); | ||
496 | |||
497 | $this->validator->initialize($context); | ||
498 | $this->validator->validate($form, new Form()); | ||
499 | } | ||
500 | |||
501 | public function testUseInheritedCallbackValidationGroup() | ||
502 | { | ||
503 | $context = $this->getMockExecutionContext(); | ||
504 | $object = $this->getMock('\stdClass'); | ||
505 | |||
506 | $parentOptions = array( | ||
507 | 'validation_groups' => array($this, 'getValidationGroups'), | ||
508 | 'cascade_validation' => true, | ||
509 | ); | ||
510 | $parent = $this->getBuilder('parent', null, $parentOptions) | ||
511 | ->setCompound(true) | ||
512 | ->setDataMapper($this->getDataMapper()) | ||
513 | ->getForm(); | ||
514 | $form = $this->getBuilder('name', '\stdClass')->getForm(); | ||
515 | $parent->add($form); | ||
516 | |||
517 | $form->setData($object); | ||
518 | |||
519 | $context->expects($this->at(0)) | ||
520 | ->method('validate') | ||
521 | ->with($object, 'data', 'group1', true); | ||
522 | $context->expects($this->at(1)) | ||
523 | ->method('validate') | ||
524 | ->with($object, 'data', 'group2', true); | ||
525 | |||
526 | $this->validator->initialize($context); | ||
527 | $this->validator->validate($form, new Form()); | ||
528 | } | ||
529 | |||
530 | public function testUseInheritedClosureValidationGroup() | ||
531 | { | ||
532 | $context = $this->getMockExecutionContext(); | ||
533 | $object = $this->getMock('\stdClass'); | ||
534 | |||
535 | $parentOptions = array( | ||
536 | 'validation_groups' => function(FormInterface $form){ | ||
537 | return array('group1', 'group2'); | ||
538 | }, | ||
539 | 'cascade_validation' => true, | ||
540 | ); | ||
541 | $parent = $this->getBuilder('parent', null, $parentOptions) | ||
542 | ->setCompound(true) | ||
543 | ->setDataMapper($this->getDataMapper()) | ||
544 | ->getForm(); | ||
545 | $form = $this->getBuilder('name', '\stdClass')->getForm(); | ||
546 | $parent->add($form); | ||
547 | |||
548 | $form->setData($object); | ||
549 | |||
550 | $context->expects($this->at(0)) | ||
551 | ->method('validate') | ||
552 | ->with($object, 'data', 'group1', true); | ||
553 | $context->expects($this->at(1)) | ||
554 | ->method('validate') | ||
555 | ->with($object, 'data', 'group2', true); | ||
556 | |||
557 | $this->validator->initialize($context); | ||
558 | $this->validator->validate($form, new Form()); | ||
559 | } | ||
560 | |||
561 | public function testAppendPropertyPath() | ||
562 | { | ||
563 | $context = $this->getMockExecutionContext(); | ||
564 | $object = $this->getMock('\stdClass'); | ||
565 | $form = $this->getBuilder('name', '\stdClass') | ||
566 | ->setData($object) | ||
567 | ->getForm(); | ||
568 | |||
569 | $context->expects($this->once()) | ||
570 | ->method('validate') | ||
571 | ->with($object, 'data', 'Default', true); | ||
572 | |||
573 | $this->validator->initialize($context); | ||
574 | $this->validator->validate($form, new Form()); | ||
575 | } | ||
576 | |||
577 | public function testDontWalkScalars() | ||
578 | { | ||
579 | $context = $this->getMockExecutionContext(); | ||
580 | |||
581 | $form = $this->getBuilder() | ||
582 | ->setData('scalar') | ||
583 | ->getForm(); | ||
584 | |||
585 | $context->expects($this->never()) | ||
586 | ->method('validate'); | ||
587 | |||
588 | $this->validator->initialize($context); | ||
589 | $this->validator->validate($form, new Form()); | ||
590 | } | ||
591 | |||
592 | public function testViolationIfExtraData() | ||
593 | { | ||
594 | $context = $this->getMockExecutionContext(); | ||
595 | |||
596 | $form = $this->getBuilder('parent', null, array('extra_fields_message' => 'Extra!')) | ||
597 | ->setCompound(true) | ||
598 | ->setDataMapper($this->getDataMapper()) | ||
599 | ->add($this->getBuilder('child')) | ||
600 | ->getForm(); | ||
601 | |||
602 | $form->submit(array('foo' => 'bar')); | ||
603 | |||
604 | $context->expects($this->once()) | ||
605 | ->method('addViolation') | ||
606 | ->with( | ||
607 | 'Extra!', | ||
608 | array('{{ extra_fields }}' => 'foo'), | ||
609 | array('foo' => 'bar') | ||
610 | ); | ||
611 | $context->expects($this->never()) | ||
612 | ->method('addViolationAt'); | ||
613 | |||
614 | $this->validator->initialize($context); | ||
615 | $this->validator->validate($form, new Form()); | ||
616 | } | ||
617 | |||
618 | /** | ||
619 | * @dataProvider getPostMaxSizeFixtures | ||
620 | */ | ||
621 | public function testPostMaxSizeViolation($contentLength, $iniMax, $nbViolation, array $params = array()) | ||
622 | { | ||
623 | $this->serverParams->expects($this->once()) | ||
624 | ->method('getContentLength') | ||
625 | ->will($this->returnValue($contentLength)); | ||
626 | $this->serverParams->expects($this->any()) | ||
627 | ->method('getNormalizedIniPostMaxSize') | ||
628 | ->will($this->returnValue($iniMax)); | ||
629 | |||
630 | $context = $this->getMockExecutionContext(); | ||
631 | $options = array('post_max_size_message' => 'Max {{ max }}!'); | ||
632 | $form = $this->getBuilder('name', null, $options)->getForm(); | ||
633 | |||
634 | for ($i = 0; $i < $nbViolation; ++$i) { | ||
635 | if (0 === $i && count($params) > 0) { | ||
636 | $context->expects($this->at($i)) | ||
637 | ->method('addViolation') | ||
638 | ->with($options['post_max_size_message'], $params); | ||
639 | } else { | ||
640 | $context->expects($this->at($i)) | ||
641 | ->method('addViolation'); | ||
642 | } | ||
643 | } | ||
644 | |||
645 | $context->expects($this->never()) | ||
646 | ->method('addViolationAt'); | ||
647 | |||
648 | $this->validator->initialize($context); | ||
649 | $this->validator->validate($form, new Form()); | ||
650 | } | ||
651 | |||
652 | public function getPostMaxSizeFixtures() | ||
653 | { | ||
654 | return array( | ||
655 | array(pow(1024, 3) + 1, '1G', 1, array('{{ max }}' => '1G')), | ||
656 | array(pow(1024, 3), '1G', 0), | ||
657 | array(pow(1024, 2) + 1, '1M', 1, array('{{ max }}' => '1M')), | ||
658 | array(pow(1024, 2), '1M', 0), | ||
659 | array(1024 + 1, '1K', 1, array('{{ max }}' => '1K')), | ||
660 | array(1024, '1K', 0), | ||
661 | array(null, '1K', 0), | ||
662 | array(1024, '', 0), | ||
663 | array(1024, 0, 0), | ||
664 | ); | ||
665 | } | ||
666 | |||
667 | public function testNoViolationIfNotRoot() | ||
668 | { | ||
669 | $this->serverParams->expects($this->once()) | ||
670 | ->method('getContentLength') | ||
671 | ->will($this->returnValue(1025)); | ||
672 | $this->serverParams->expects($this->never()) | ||
673 | ->method('getNormalizedIniPostMaxSize'); | ||
674 | |||
675 | $context = $this->getMockExecutionContext(); | ||
676 | $parent = $this->getBuilder() | ||
677 | ->setCompound(true) | ||
678 | ->setDataMapper($this->getDataMapper()) | ||
679 | ->getForm(); | ||
680 | $form = $this->getForm(); | ||
681 | $parent->add($form); | ||
682 | |||
683 | $context->expects($this->never()) | ||
684 | ->method('addViolation'); | ||
685 | $context->expects($this->never()) | ||
686 | ->method('addViolationAt'); | ||
687 | |||
688 | $this->validator->initialize($context); | ||
689 | $this->validator->validate($form, new Form()); | ||
690 | } | ||
691 | |||
692 | /** | ||
693 | * Access has to be public, as this method is called via callback array | ||
694 | * in {@link testValidateFormDataCanHandleCallbackValidationGroups()} | ||
695 | * and {@link testValidateFormDataUsesInheritedCallbackValidationGroup()} | ||
696 | */ | ||
697 | public function getValidationGroups(FormInterface $form) | ||
698 | { | ||
699 | return array('group1', 'group2'); | ||
700 | } | ||
701 | |||
702 | private function getMockExecutionContext() | ||
703 | { | ||
704 | return $this->getMock('Symfony\Component\Validator\ExecutionContextInterface'); | ||
705 | } | ||
706 | |||
707 | /** | ||
708 | * @param string $name | ||
709 | * @param string $dataClass | ||
710 | * @param array $options | ||
711 | * | ||
712 | * @return FormBuilder | ||
713 | */ | ||
714 | private function getBuilder($name = 'name', $dataClass = null, array $options = array()) | ||
715 | { | ||
716 | $options = array_replace(array( | ||
717 | 'constraints' => array(), | ||
718 | 'invalid_message_parameters' => array(), | ||
719 | ), $options); | ||
720 | |||
721 | return new FormBuilder($name, $dataClass, $this->dispatcher, $this->factory, $options); | ||
722 | } | ||
723 | |||
724 | private function getForm($name = 'name', $dataClass = null, array $options = array()) | ||
725 | { | ||
726 | return $this->getBuilder($name, $dataClass, $options)->getForm(); | ||
727 | } | ||
728 | |||
729 | private function getSubmitButton($name = 'name', array $options = array()) | ||
730 | { | ||
731 | $builder = new SubmitButtonBuilder($name, $options); | ||
732 | |||
733 | return $builder->getForm(); | ||
734 | } | ||
735 | |||
736 | private function getClickedSubmitButton($name = 'name', array $options = array()) | ||
737 | { | ||
738 | return $this->getSubmitButton($name, $options)->submit(''); | ||
739 | } | ||
740 | |||
741 | /** | ||
742 | * @return \PHPUnit_Framework_MockObject_MockObject | ||
743 | */ | ||
744 | private function getDataMapper() | ||
745 | { | ||
746 | return $this->getMock('Symfony\Component\Form\DataMapperInterface'); | ||
747 | } | ||
748 | } | ||