diff options
Diffstat (limited to 'vendor/symfony/form/Symfony/Component/Form/Tests/SimpleFormTest.php')
-rw-r--r-- | vendor/symfony/form/Symfony/Component/Form/Tests/SimpleFormTest.php | 1045 |
1 files changed, 0 insertions, 1045 deletions
diff --git a/vendor/symfony/form/Symfony/Component/Form/Tests/SimpleFormTest.php b/vendor/symfony/form/Symfony/Component/Form/Tests/SimpleFormTest.php deleted file mode 100644 index bedad676..00000000 --- a/vendor/symfony/form/Symfony/Component/Form/Tests/SimpleFormTest.php +++ /dev/null | |||
@@ -1,1045 +0,0 @@ | |||
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; | ||
13 | |||
14 | use Symfony\Component\Form\Form; | ||
15 | use Symfony\Component\Form\FormEvent; | ||
16 | use Symfony\Component\Form\FormEvents; | ||
17 | use Symfony\Component\PropertyAccess\PropertyPath; | ||
18 | use Symfony\Component\Form\FormConfigBuilder; | ||
19 | use Symfony\Component\Form\FormError; | ||
20 | use Symfony\Component\Form\Exception\TransformationFailedException; | ||
21 | use Symfony\Component\EventDispatcher\EventDispatcher; | ||
22 | use Symfony\Component\Form\Tests\Fixtures\FixedDataTransformer; | ||
23 | use Symfony\Component\Form\Tests\Fixtures\FixedFilterListener; | ||
24 | |||
25 | class SimpleFormTest_Countable implements \Countable | ||
26 | { | ||
27 | private $count; | ||
28 | |||
29 | public function __construct($count) | ||
30 | { | ||
31 | $this->count = $count; | ||
32 | } | ||
33 | |||
34 | public function count() | ||
35 | { | ||
36 | return $this->count; | ||
37 | } | ||
38 | } | ||
39 | |||
40 | class SimpleFormTest_Traversable implements \IteratorAggregate | ||
41 | { | ||
42 | private $iterator; | ||
43 | |||
44 | public function __construct($count) | ||
45 | { | ||
46 | $this->iterator = new \ArrayIterator($count > 0 ? array_fill(0, $count, 'Foo') : array()); | ||
47 | } | ||
48 | |||
49 | public function getIterator() | ||
50 | { | ||
51 | return $this->iterator; | ||
52 | } | ||
53 | } | ||
54 | |||
55 | class SimpleFormTest extends AbstractFormTest | ||
56 | { | ||
57 | public function testDataIsInitializedToConfiguredValue() | ||
58 | { | ||
59 | $model = new FixedDataTransformer(array( | ||
60 | 'default' => 'foo', | ||
61 | )); | ||
62 | $view = new FixedDataTransformer(array( | ||
63 | 'foo' => 'bar', | ||
64 | )); | ||
65 | |||
66 | $config = new FormConfigBuilder('name', null, $this->dispatcher); | ||
67 | $config->addViewTransformer($view); | ||
68 | $config->addModelTransformer($model); | ||
69 | $config->setData('default'); | ||
70 | $form = new Form($config); | ||
71 | |||
72 | $this->assertSame('default', $form->getData()); | ||
73 | $this->assertSame('foo', $form->getNormData()); | ||
74 | $this->assertSame('bar', $form->getViewData()); | ||
75 | } | ||
76 | |||
77 | // https://github.com/symfony/symfony/commit/d4f4038f6daf7cf88ca7c7ab089473cce5ebf7d8#commitcomment-1632879 | ||
78 | public function testDataIsInitializedFromSubmit() | ||
79 | { | ||
80 | $mock = $this->getMockBuilder('\stdClass') | ||
81 | ->setMethods(array('preSetData', 'preSubmit')) | ||
82 | ->getMock(); | ||
83 | $mock->expects($this->at(0)) | ||
84 | ->method('preSetData'); | ||
85 | $mock->expects($this->at(1)) | ||
86 | ->method('preSubmit'); | ||
87 | |||
88 | $config = new FormConfigBuilder('name', null, $this->dispatcher); | ||
89 | $config->addEventListener(FormEvents::PRE_SET_DATA, array($mock, 'preSetData')); | ||
90 | $config->addEventListener(FormEvents::PRE_SUBMIT, array($mock, 'preSubmit')); | ||
91 | $form = new Form($config); | ||
92 | |||
93 | // no call to setData() or similar where the object would be | ||
94 | // initialized otherwise | ||
95 | |||
96 | $form->submit('foobar'); | ||
97 | } | ||
98 | |||
99 | // https://github.com/symfony/symfony/pull/7789 | ||
100 | public function testFalseIsConvertedToNull() | ||
101 | { | ||
102 | $mock = $this->getMockBuilder('\stdClass') | ||
103 | ->setMethods(array('preBind')) | ||
104 | ->getMock(); | ||
105 | $mock->expects($this->once()) | ||
106 | ->method('preBind') | ||
107 | ->with($this->callback(function ($event) { | ||
108 | return null === $event->getData(); | ||
109 | })); | ||
110 | |||
111 | $config = new FormConfigBuilder('name', null, $this->dispatcher); | ||
112 | $config->addEventListener(FormEvents::PRE_BIND, array($mock, 'preBind')); | ||
113 | $form = new Form($config); | ||
114 | |||
115 | $form->bind(false); | ||
116 | |||
117 | $this->assertTrue($form->isValid()); | ||
118 | $this->assertNull($form->getData()); | ||
119 | } | ||
120 | |||
121 | /** | ||
122 | * @expectedException \Symfony\Component\Form\Exception\AlreadySubmittedException | ||
123 | */ | ||
124 | public function testSubmitThrowsExceptionIfAlreadySubmitted() | ||
125 | { | ||
126 | $this->form->submit(array()); | ||
127 | $this->form->submit(array()); | ||
128 | } | ||
129 | |||
130 | public function testSubmitIsIgnoredIfDisabled() | ||
131 | { | ||
132 | $form = $this->getBuilder() | ||
133 | ->setDisabled(true) | ||
134 | ->setData('initial') | ||
135 | ->getForm(); | ||
136 | |||
137 | $form->submit('new'); | ||
138 | |||
139 | $this->assertEquals('initial', $form->getData()); | ||
140 | $this->assertTrue($form->isSubmitted()); | ||
141 | } | ||
142 | |||
143 | public function testNeverRequiredIfParentNotRequired() | ||
144 | { | ||
145 | $parent = $this->getBuilder()->setRequired(false)->getForm(); | ||
146 | $child = $this->getBuilder()->setRequired(true)->getForm(); | ||
147 | |||
148 | $child->setParent($parent); | ||
149 | |||
150 | $this->assertFalse($child->isRequired()); | ||
151 | } | ||
152 | |||
153 | public function testRequired() | ||
154 | { | ||
155 | $parent = $this->getBuilder()->setRequired(true)->getForm(); | ||
156 | $child = $this->getBuilder()->setRequired(true)->getForm(); | ||
157 | |||
158 | $child->setParent($parent); | ||
159 | |||
160 | $this->assertTrue($child->isRequired()); | ||
161 | } | ||
162 | |||
163 | public function testNotRequired() | ||
164 | { | ||
165 | $parent = $this->getBuilder()->setRequired(true)->getForm(); | ||
166 | $child = $this->getBuilder()->setRequired(false)->getForm(); | ||
167 | |||
168 | $child->setParent($parent); | ||
169 | |||
170 | $this->assertFalse($child->isRequired()); | ||
171 | } | ||
172 | |||
173 | public function testAlwaysDisabledIfParentDisabled() | ||
174 | { | ||
175 | $parent = $this->getBuilder()->setDisabled(true)->getForm(); | ||
176 | $child = $this->getBuilder()->setDisabled(false)->getForm(); | ||
177 | |||
178 | $child->setParent($parent); | ||
179 | |||
180 | $this->assertTrue($child->isDisabled()); | ||
181 | } | ||
182 | |||
183 | public function testDisabled() | ||
184 | { | ||
185 | $parent = $this->getBuilder()->setDisabled(false)->getForm(); | ||
186 | $child = $this->getBuilder()->setDisabled(true)->getForm(); | ||
187 | |||
188 | $child->setParent($parent); | ||
189 | |||
190 | $this->assertTrue($child->isDisabled()); | ||
191 | } | ||
192 | |||
193 | public function testNotDisabled() | ||
194 | { | ||
195 | $parent = $this->getBuilder()->setDisabled(false)->getForm(); | ||
196 | $child = $this->getBuilder()->setDisabled(false)->getForm(); | ||
197 | |||
198 | $child->setParent($parent); | ||
199 | |||
200 | $this->assertFalse($child->isDisabled()); | ||
201 | } | ||
202 | |||
203 | public function testGetRootReturnsRootOfParent() | ||
204 | { | ||
205 | $parent = $this->getMockForm(); | ||
206 | $parent->expects($this->once()) | ||
207 | ->method('getRoot') | ||
208 | ->will($this->returnValue('ROOT')); | ||
209 | |||
210 | $this->form->setParent($parent); | ||
211 | |||
212 | $this->assertEquals('ROOT', $this->form->getRoot()); | ||
213 | } | ||
214 | |||
215 | public function testGetRootReturnsSelfIfNoParent() | ||
216 | { | ||
217 | $this->assertSame($this->form, $this->form->getRoot()); | ||
218 | } | ||
219 | |||
220 | public function testEmptyIfEmptyArray() | ||
221 | { | ||
222 | $this->form->setData(array()); | ||
223 | |||
224 | $this->assertTrue($this->form->isEmpty()); | ||
225 | } | ||
226 | |||
227 | public function testEmptyIfEmptyCountable() | ||
228 | { | ||
229 | $this->form = new Form(new FormConfigBuilder('name', __NAMESPACE__.'\SimpleFormTest_Countable', $this->dispatcher)); | ||
230 | |||
231 | $this->form->setData(new SimpleFormTest_Countable(0)); | ||
232 | |||
233 | $this->assertTrue($this->form->isEmpty()); | ||
234 | } | ||
235 | |||
236 | public function testNotEmptyIfFilledCountable() | ||
237 | { | ||
238 | $this->form = new Form(new FormConfigBuilder('name', __NAMESPACE__.'\SimpleFormTest_Countable', $this->dispatcher)); | ||
239 | |||
240 | $this->form->setData(new SimpleFormTest_Countable(1)); | ||
241 | |||
242 | $this->assertFalse($this->form->isEmpty()); | ||
243 | } | ||
244 | |||
245 | public function testEmptyIfEmptyTraversable() | ||
246 | { | ||
247 | $this->form = new Form(new FormConfigBuilder('name', __NAMESPACE__.'\SimpleFormTest_Traversable', $this->dispatcher)); | ||
248 | |||
249 | $this->form->setData(new SimpleFormTest_Traversable(0)); | ||
250 | |||
251 | $this->assertTrue($this->form->isEmpty()); | ||
252 | } | ||
253 | |||
254 | public function testNotEmptyIfFilledTraversable() | ||
255 | { | ||
256 | $this->form = new Form(new FormConfigBuilder('name', __NAMESPACE__.'\SimpleFormTest_Traversable', $this->dispatcher)); | ||
257 | |||
258 | $this->form->setData(new SimpleFormTest_Traversable(1)); | ||
259 | |||
260 | $this->assertFalse($this->form->isEmpty()); | ||
261 | } | ||
262 | |||
263 | public function testEmptyIfNull() | ||
264 | { | ||
265 | $this->form->setData(null); | ||
266 | |||
267 | $this->assertTrue($this->form->isEmpty()); | ||
268 | } | ||
269 | |||
270 | public function testEmptyIfEmptyString() | ||
271 | { | ||
272 | $this->form->setData(''); | ||
273 | |||
274 | $this->assertTrue($this->form->isEmpty()); | ||
275 | } | ||
276 | |||
277 | public function testNotEmptyIfText() | ||
278 | { | ||
279 | $this->form->setData('foobar'); | ||
280 | |||
281 | $this->assertFalse($this->form->isEmpty()); | ||
282 | } | ||
283 | |||
284 | public function testValidIfSubmitted() | ||
285 | { | ||
286 | $form = $this->getBuilder()->getForm(); | ||
287 | $form->submit('foobar'); | ||
288 | |||
289 | $this->assertTrue($form->isValid()); | ||
290 | } | ||
291 | |||
292 | public function testValidIfSubmittedAndDisabled() | ||
293 | { | ||
294 | $form = $this->getBuilder()->setDisabled(true)->getForm(); | ||
295 | $form->submit('foobar'); | ||
296 | |||
297 | $this->assertTrue($form->isValid()); | ||
298 | } | ||
299 | |||
300 | public function testNotValidIfNotSubmitted() | ||
301 | { | ||
302 | $this->assertFalse($this->form->isValid()); | ||
303 | } | ||
304 | |||
305 | public function testNotValidIfErrors() | ||
306 | { | ||
307 | $form = $this->getBuilder()->getForm(); | ||
308 | $form->submit('foobar'); | ||
309 | $form->addError(new FormError('Error!')); | ||
310 | |||
311 | $this->assertFalse($form->isValid()); | ||
312 | } | ||
313 | |||
314 | public function testHasErrors() | ||
315 | { | ||
316 | $this->form->addError(new FormError('Error!')); | ||
317 | |||
318 | $this->assertCount(1, $this->form->getErrors()); | ||
319 | } | ||
320 | |||
321 | public function testHasNoErrors() | ||
322 | { | ||
323 | $this->assertCount(0, $this->form->getErrors()); | ||
324 | } | ||
325 | |||
326 | /** | ||
327 | * @expectedException \Symfony\Component\Form\Exception\AlreadySubmittedException | ||
328 | */ | ||
329 | public function testSetParentThrowsExceptionIfAlreadySubmitted() | ||
330 | { | ||
331 | $this->form->submit(array()); | ||
332 | $this->form->setParent($this->getBuilder('parent')->getForm()); | ||
333 | } | ||
334 | |||
335 | public function testSubmitted() | ||
336 | { | ||
337 | $form = $this->getBuilder()->getForm(); | ||
338 | $form->submit('foobar'); | ||
339 | |||
340 | $this->assertTrue($form->isSubmitted()); | ||
341 | } | ||
342 | |||
343 | public function testNotSubmitted() | ||
344 | { | ||
345 | $this->assertFalse($this->form->isSubmitted()); | ||
346 | } | ||
347 | |||
348 | /** | ||
349 | * @expectedException \Symfony\Component\Form\Exception\AlreadySubmittedException | ||
350 | */ | ||
351 | public function testSetDataThrowsExceptionIfAlreadySubmitted() | ||
352 | { | ||
353 | $this->form->submit(array()); | ||
354 | $this->form->setData(null); | ||
355 | } | ||
356 | |||
357 | public function testSetDataClonesObjectIfNotByReference() | ||
358 | { | ||
359 | $data = new \stdClass(); | ||
360 | $form = $this->getBuilder('name', null, '\stdClass')->setByReference(false)->getForm(); | ||
361 | $form->setData($data); | ||
362 | |||
363 | $this->assertNotSame($data, $form->getData()); | ||
364 | $this->assertEquals($data, $form->getData()); | ||
365 | } | ||
366 | |||
367 | public function testSetDataDoesNotCloneObjectIfByReference() | ||
368 | { | ||
369 | $data = new \stdClass(); | ||
370 | $form = $this->getBuilder('name', null, '\stdClass')->setByReference(true)->getForm(); | ||
371 | $form->setData($data); | ||
372 | |||
373 | $this->assertSame($data, $form->getData()); | ||
374 | } | ||
375 | |||
376 | public function testSetDataExecutesTransformationChain() | ||
377 | { | ||
378 | // use real event dispatcher now | ||
379 | $form = $this->getBuilder('name', new EventDispatcher()) | ||
380 | ->addEventSubscriber(new FixedFilterListener(array( | ||
381 | 'preSetData' => array( | ||
382 | 'app' => 'filtered', | ||
383 | ), | ||
384 | ))) | ||
385 | ->addModelTransformer(new FixedDataTransformer(array( | ||
386 | '' => '', | ||
387 | 'filtered' => 'norm', | ||
388 | ))) | ||
389 | ->addViewTransformer(new FixedDataTransformer(array( | ||
390 | '' => '', | ||
391 | 'norm' => 'client', | ||
392 | ))) | ||
393 | ->getForm(); | ||
394 | |||
395 | $form->setData('app'); | ||
396 | |||
397 | $this->assertEquals('filtered', $form->getData()); | ||
398 | $this->assertEquals('norm', $form->getNormData()); | ||
399 | $this->assertEquals('client', $form->getViewData()); | ||
400 | } | ||
401 | |||
402 | public function testSetDataExecutesViewTransformersInOrder() | ||
403 | { | ||
404 | $form = $this->getBuilder() | ||
405 | ->addViewTransformer(new FixedDataTransformer(array( | ||
406 | '' => '', | ||
407 | 'first' => 'second', | ||
408 | ))) | ||
409 | ->addViewTransformer(new FixedDataTransformer(array( | ||
410 | '' => '', | ||
411 | 'second' => 'third', | ||
412 | ))) | ||
413 | ->getForm(); | ||
414 | |||
415 | $form->setData('first'); | ||
416 | |||
417 | $this->assertEquals('third', $form->getViewData()); | ||
418 | } | ||
419 | |||
420 | public function testSetDataExecutesModelTransformersInReverseOrder() | ||
421 | { | ||
422 | $form = $this->getBuilder() | ||
423 | ->addModelTransformer(new FixedDataTransformer(array( | ||
424 | '' => '', | ||
425 | 'second' => 'third', | ||
426 | ))) | ||
427 | ->addModelTransformer(new FixedDataTransformer(array( | ||
428 | '' => '', | ||
429 | 'first' => 'second', | ||
430 | ))) | ||
431 | ->getForm(); | ||
432 | |||
433 | $form->setData('first'); | ||
434 | |||
435 | $this->assertEquals('third', $form->getNormData()); | ||
436 | } | ||
437 | |||
438 | /* | ||
439 | * When there is no data transformer, the data must have the same format | ||
440 | * in all three representations | ||
441 | */ | ||
442 | public function testSetDataConvertsScalarToStringIfNoTransformer() | ||
443 | { | ||
444 | $form = $this->getBuilder()->getForm(); | ||
445 | |||
446 | $form->setData(1); | ||
447 | |||
448 | $this->assertSame('1', $form->getData()); | ||
449 | $this->assertSame('1', $form->getNormData()); | ||
450 | $this->assertSame('1', $form->getViewData()); | ||
451 | } | ||
452 | |||
453 | /* | ||
454 | * Data in client format should, if possible, always be a string to | ||
455 | * facilitate differentiation between '0' and '' | ||
456 | */ | ||
457 | public function testSetDataConvertsScalarToStringIfOnlyModelTransformer() | ||
458 | { | ||
459 | $form = $this->getBuilder() | ||
460 | ->addModelTransformer(new FixedDataTransformer(array( | ||
461 | '' => '', | ||
462 | 1 => 23, | ||
463 | ))) | ||
464 | ->getForm(); | ||
465 | |||
466 | $form->setData(1); | ||
467 | |||
468 | $this->assertSame(1, $form->getData()); | ||
469 | $this->assertSame(23, $form->getNormData()); | ||
470 | $this->assertSame('23', $form->getViewData()); | ||
471 | } | ||
472 | |||
473 | /* | ||
474 | * NULL remains NULL in app and norm format to remove the need to treat | ||
475 | * empty values and NULL explicitly in the application | ||
476 | */ | ||
477 | public function testSetDataConvertsNullToStringIfNoTransformer() | ||
478 | { | ||
479 | $form = $this->getBuilder()->getForm(); | ||
480 | |||
481 | $form->setData(null); | ||
482 | |||
483 | $this->assertNull($form->getData()); | ||
484 | $this->assertNull($form->getNormData()); | ||
485 | $this->assertSame('', $form->getViewData()); | ||
486 | } | ||
487 | |||
488 | public function testSetDataIsIgnoredIfDataIsLocked() | ||
489 | { | ||
490 | $form = $this->getBuilder() | ||
491 | ->setData('default') | ||
492 | ->setDataLocked(true) | ||
493 | ->getForm(); | ||
494 | |||
495 | $form->setData('foobar'); | ||
496 | |||
497 | $this->assertSame('default', $form->getData()); | ||
498 | } | ||
499 | |||
500 | public function testSubmitConvertsEmptyToNullIfNoTransformer() | ||
501 | { | ||
502 | $form = $this->getBuilder()->getForm(); | ||
503 | |||
504 | $form->submit(''); | ||
505 | |||
506 | $this->assertNull($form->getData()); | ||
507 | $this->assertNull($form->getNormData()); | ||
508 | $this->assertSame('', $form->getViewData()); | ||
509 | } | ||
510 | |||
511 | public function testSubmitExecutesTransformationChain() | ||
512 | { | ||
513 | // use real event dispatcher now | ||
514 | $form = $this->getBuilder('name', new EventDispatcher()) | ||
515 | ->addEventSubscriber(new FixedFilterListener(array( | ||
516 | 'preSubmit' => array( | ||
517 | 'client' => 'filteredclient', | ||
518 | ), | ||
519 | 'onSubmit' => array( | ||
520 | 'norm' => 'filterednorm', | ||
521 | ), | ||
522 | ))) | ||
523 | ->addViewTransformer(new FixedDataTransformer(array( | ||
524 | '' => '', | ||
525 | // direction is reversed! | ||
526 | 'norm' => 'filteredclient', | ||
527 | 'filterednorm' => 'cleanedclient' | ||
528 | ))) | ||
529 | ->addModelTransformer(new FixedDataTransformer(array( | ||
530 | '' => '', | ||
531 | // direction is reversed! | ||
532 | 'app' => 'filterednorm', | ||
533 | ))) | ||
534 | ->getForm(); | ||
535 | |||
536 | $form->submit('client'); | ||
537 | |||
538 | $this->assertEquals('app', $form->getData()); | ||
539 | $this->assertEquals('filterednorm', $form->getNormData()); | ||
540 | $this->assertEquals('cleanedclient', $form->getViewData()); | ||
541 | } | ||
542 | |||
543 | public function testSubmitExecutesViewTransformersInReverseOrder() | ||
544 | { | ||
545 | $form = $this->getBuilder() | ||
546 | ->addViewTransformer(new FixedDataTransformer(array( | ||
547 | '' => '', | ||
548 | 'third' => 'second', | ||
549 | ))) | ||
550 | ->addViewTransformer(new FixedDataTransformer(array( | ||
551 | '' => '', | ||
552 | 'second' => 'first', | ||
553 | ))) | ||
554 | ->getForm(); | ||
555 | |||
556 | $form->submit('first'); | ||
557 | |||
558 | $this->assertEquals('third', $form->getNormData()); | ||
559 | } | ||
560 | |||
561 | public function testSubmitExecutesModelTransformersInOrder() | ||
562 | { | ||
563 | $form = $this->getBuilder() | ||
564 | ->addModelTransformer(new FixedDataTransformer(array( | ||
565 | '' => '', | ||
566 | 'second' => 'first', | ||
567 | ))) | ||
568 | ->addModelTransformer(new FixedDataTransformer(array( | ||
569 | '' => '', | ||
570 | 'third' => 'second', | ||
571 | ))) | ||
572 | ->getForm(); | ||
573 | |||
574 | $form->submit('first'); | ||
575 | |||
576 | $this->assertEquals('third', $form->getData()); | ||
577 | } | ||
578 | |||
579 | public function testSynchronizedByDefault() | ||
580 | { | ||
581 | $this->assertTrue($this->form->isSynchronized()); | ||
582 | } | ||
583 | |||
584 | public function testSynchronizedAfterSubmission() | ||
585 | { | ||
586 | $this->form->submit('foobar'); | ||
587 | |||
588 | $this->assertTrue($this->form->isSynchronized()); | ||
589 | } | ||
590 | |||
591 | public function testNotSynchronizedIfViewReverseTransformationFailed() | ||
592 | { | ||
593 | $transformer = $this->getDataTransformer(); | ||
594 | $transformer->expects($this->once()) | ||
595 | ->method('reverseTransform') | ||
596 | ->will($this->throwException(new TransformationFailedException())); | ||
597 | |||
598 | $form = $this->getBuilder() | ||
599 | ->addViewTransformer($transformer) | ||
600 | ->getForm(); | ||
601 | |||
602 | $form->submit('foobar'); | ||
603 | |||
604 | $this->assertFalse($form->isSynchronized()); | ||
605 | } | ||
606 | |||
607 | public function testNotSynchronizedIfModelReverseTransformationFailed() | ||
608 | { | ||
609 | $transformer = $this->getDataTransformer(); | ||
610 | $transformer->expects($this->once()) | ||
611 | ->method('reverseTransform') | ||
612 | ->will($this->throwException(new TransformationFailedException())); | ||
613 | |||
614 | $form = $this->getBuilder() | ||
615 | ->addModelTransformer($transformer) | ||
616 | ->getForm(); | ||
617 | |||
618 | $form->submit('foobar'); | ||
619 | |||
620 | $this->assertFalse($form->isSynchronized()); | ||
621 | } | ||
622 | |||
623 | public function testEmptyDataCreatedBeforeTransforming() | ||
624 | { | ||
625 | $form = $this->getBuilder() | ||
626 | ->setEmptyData('foo') | ||
627 | ->addViewTransformer(new FixedDataTransformer(array( | ||
628 | '' => '', | ||
629 | // direction is reversed! | ||
630 | 'bar' => 'foo', | ||
631 | ))) | ||
632 | ->getForm(); | ||
633 | |||
634 | $form->submit(''); | ||
635 | |||
636 | $this->assertEquals('bar', $form->getData()); | ||
637 | } | ||
638 | |||
639 | public function testEmptyDataFromClosure() | ||
640 | { | ||
641 | $test = $this; | ||
642 | $form = $this->getBuilder() | ||
643 | ->setEmptyData(function ($form) use ($test) { | ||
644 | // the form instance is passed to the closure to allow use | ||
645 | // of form data when creating the empty value | ||
646 | $test->assertInstanceOf('Symfony\Component\Form\FormInterface', $form); | ||
647 | |||
648 | return 'foo'; | ||
649 | }) | ||
650 | ->addViewTransformer(new FixedDataTransformer(array( | ||
651 | '' => '', | ||
652 | // direction is reversed! | ||
653 | 'bar' => 'foo', | ||
654 | ))) | ||
655 | ->getForm(); | ||
656 | |||
657 | $form->submit(''); | ||
658 | |||
659 | $this->assertEquals('bar', $form->getData()); | ||
660 | } | ||
661 | |||
662 | public function testSubmitResetsErrors() | ||
663 | { | ||
664 | $this->form->addError(new FormError('Error!')); | ||
665 | $this->form->submit('foobar'); | ||
666 | |||
667 | $this->assertSame(array(), $this->form->getErrors()); | ||
668 | } | ||
669 | |||
670 | public function testCreateView() | ||
671 | { | ||
672 | $type = $this->getMock('Symfony\Component\Form\ResolvedFormTypeInterface'); | ||
673 | $view = $this->getMock('Symfony\Component\Form\FormView'); | ||
674 | $form = $this->getBuilder()->setType($type)->getForm(); | ||
675 | |||
676 | $type->expects($this->once()) | ||
677 | ->method('createView') | ||
678 | ->with($form) | ||
679 | ->will($this->returnValue($view)); | ||
680 | |||
681 | $this->assertSame($view, $form->createView()); | ||
682 | } | ||
683 | |||
684 | public function testCreateViewWithParent() | ||
685 | { | ||
686 | $type = $this->getMock('Symfony\Component\Form\ResolvedFormTypeInterface'); | ||
687 | $view = $this->getMock('Symfony\Component\Form\FormView'); | ||
688 | $parentForm = $this->getMock('Symfony\Component\Form\Test\FormInterface'); | ||
689 | $parentView = $this->getMock('Symfony\Component\Form\FormView'); | ||
690 | $form = $this->getBuilder()->setType($type)->getForm(); | ||
691 | $form->setParent($parentForm); | ||
692 | |||
693 | $parentForm->expects($this->once()) | ||
694 | ->method('createView') | ||
695 | ->will($this->returnValue($parentView)); | ||
696 | |||
697 | $type->expects($this->once()) | ||
698 | ->method('createView') | ||
699 | ->with($form, $parentView) | ||
700 | ->will($this->returnValue($view)); | ||
701 | |||
702 | $this->assertSame($view, $form->createView()); | ||
703 | } | ||
704 | |||
705 | public function testCreateViewWithExplicitParent() | ||
706 | { | ||
707 | $type = $this->getMock('Symfony\Component\Form\ResolvedFormTypeInterface'); | ||
708 | $view = $this->getMock('Symfony\Component\Form\FormView'); | ||
709 | $parentView = $this->getMock('Symfony\Component\Form\FormView'); | ||
710 | $form = $this->getBuilder()->setType($type)->getForm(); | ||
711 | |||
712 | $type->expects($this->once()) | ||
713 | ->method('createView') | ||
714 | ->with($form, $parentView) | ||
715 | ->will($this->returnValue($view)); | ||
716 | |||
717 | $this->assertSame($view, $form->createView($parentView)); | ||
718 | } | ||
719 | |||
720 | public function testGetErrorsAsString() | ||
721 | { | ||
722 | $this->form->addError(new FormError('Error!')); | ||
723 | |||
724 | $this->assertEquals("ERROR: Error!\n", $this->form->getErrorsAsString()); | ||
725 | } | ||
726 | |||
727 | public function testFormCanHaveEmptyName() | ||
728 | { | ||
729 | $form = $this->getBuilder('')->getForm(); | ||
730 | |||
731 | $this->assertEquals('', $form->getName()); | ||
732 | } | ||
733 | |||
734 | public function testSetNullParentWorksWithEmptyName() | ||
735 | { | ||
736 | $form = $this->getBuilder('')->getForm(); | ||
737 | $form->setParent(null); | ||
738 | |||
739 | $this->assertNull($form->getParent()); | ||
740 | } | ||
741 | |||
742 | /** | ||
743 | * @expectedException \Symfony\Component\Form\Exception\LogicException | ||
744 | * @expectedExceptionMessage A form with an empty name cannot have a parent form. | ||
745 | */ | ||
746 | public function testFormCannotHaveEmptyNameNotInRootLevel() | ||
747 | { | ||
748 | $this->getBuilder() | ||
749 | ->setCompound(true) | ||
750 | ->setDataMapper($this->getDataMapper()) | ||
751 | ->add($this->getBuilder('')) | ||
752 | ->getForm(); | ||
753 | } | ||
754 | |||
755 | public function testGetPropertyPathReturnsConfiguredPath() | ||
756 | { | ||
757 | $form = $this->getBuilder()->setPropertyPath('address.street')->getForm(); | ||
758 | |||
759 | $this->assertEquals(new PropertyPath('address.street'), $form->getPropertyPath()); | ||
760 | } | ||
761 | |||
762 | // see https://github.com/symfony/symfony/issues/3903 | ||
763 | public function testGetPropertyPathDefaultsToNameIfParentHasDataClass() | ||
764 | { | ||
765 | $parent = $this->getBuilder(null, null, 'stdClass') | ||
766 | ->setCompound(true) | ||
767 | ->setDataMapper($this->getDataMapper()) | ||
768 | ->getForm(); | ||
769 | $form = $this->getBuilder('name')->getForm(); | ||
770 | $parent->add($form); | ||
771 | |||
772 | $this->assertEquals(new PropertyPath('name'), $form->getPropertyPath()); | ||
773 | } | ||
774 | |||
775 | // see https://github.com/symfony/symfony/issues/3903 | ||
776 | public function testGetPropertyPathDefaultsToIndexedNameIfParentDataClassIsNull() | ||
777 | { | ||
778 | $parent = $this->getBuilder() | ||
779 | ->setCompound(true) | ||
780 | ->setDataMapper($this->getDataMapper()) | ||
781 | ->getForm(); | ||
782 | $form = $this->getBuilder('name')->getForm(); | ||
783 | $parent->add($form); | ||
784 | |||
785 | $this->assertEquals(new PropertyPath('[name]'), $form->getPropertyPath()); | ||
786 | } | ||
787 | |||
788 | public function testGetPropertyPathDefaultsToNameIfFirstParentWithoutInheritDataHasDataClass() | ||
789 | { | ||
790 | $grandParent = $this->getBuilder(null, null, 'stdClass') | ||
791 | ->setCompound(true) | ||
792 | ->setDataMapper($this->getDataMapper()) | ||
793 | ->getForm(); | ||
794 | $parent = $this->getBuilder() | ||
795 | ->setCompound(true) | ||
796 | ->setDataMapper($this->getDataMapper()) | ||
797 | ->setInheritData(true) | ||
798 | ->getForm(); | ||
799 | $form = $this->getBuilder('name')->getForm(); | ||
800 | $grandParent->add($parent); | ||
801 | $parent->add($form); | ||
802 | |||
803 | $this->assertEquals(new PropertyPath('name'), $form->getPropertyPath()); | ||
804 | } | ||
805 | |||
806 | public function testGetPropertyPathDefaultsToIndexedNameIfDataClassOfFirstParentWithoutInheritDataIsNull() | ||
807 | { | ||
808 | $grandParent = $this->getBuilder() | ||
809 | ->setCompound(true) | ||
810 | ->setDataMapper($this->getDataMapper()) | ||
811 | ->getForm(); | ||
812 | $parent = $this->getBuilder() | ||
813 | ->setCompound(true) | ||
814 | ->setDataMapper($this->getDataMapper()) | ||
815 | ->setInheritData(true) | ||
816 | ->getForm(); | ||
817 | $form = $this->getBuilder('name')->getForm(); | ||
818 | $grandParent->add($parent); | ||
819 | $parent->add($form); | ||
820 | |||
821 | $this->assertEquals(new PropertyPath('[name]'), $form->getPropertyPath()); | ||
822 | } | ||
823 | |||
824 | /** | ||
825 | * @expectedException \Symfony\Component\Form\Exception\LogicException | ||
826 | */ | ||
827 | public function testViewDataMustNotBeObjectIfDataClassIsNull() | ||
828 | { | ||
829 | $config = new FormConfigBuilder('name', null, $this->dispatcher); | ||
830 | $config->addViewTransformer(new FixedDataTransformer(array( | ||
831 | '' => '', | ||
832 | 'foo' => new \stdClass(), | ||
833 | ))); | ||
834 | $form = new Form($config); | ||
835 | |||
836 | $form->setData('foo'); | ||
837 | } | ||
838 | |||
839 | public function testViewDataMayBeArrayAccessIfDataClassIsNull() | ||
840 | { | ||
841 | $arrayAccess = $this->getMock('\ArrayAccess'); | ||
842 | $config = new FormConfigBuilder('name', null, $this->dispatcher); | ||
843 | $config->addViewTransformer(new FixedDataTransformer(array( | ||
844 | '' => '', | ||
845 | 'foo' => $arrayAccess, | ||
846 | ))); | ||
847 | $form = new Form($config); | ||
848 | |||
849 | $form->setData('foo'); | ||
850 | |||
851 | $this->assertSame($arrayAccess, $form->getViewData()); | ||
852 | } | ||
853 | |||
854 | /** | ||
855 | * @expectedException \Symfony\Component\Form\Exception\LogicException | ||
856 | */ | ||
857 | public function testViewDataMustBeObjectIfDataClassIsSet() | ||
858 | { | ||
859 | $config = new FormConfigBuilder('name', 'stdClass', $this->dispatcher); | ||
860 | $config->addViewTransformer(new FixedDataTransformer(array( | ||
861 | '' => '', | ||
862 | 'foo' => array('bar' => 'baz'), | ||
863 | ))); | ||
864 | $form = new Form($config); | ||
865 | |||
866 | $form->setData('foo'); | ||
867 | } | ||
868 | |||
869 | /** | ||
870 | * @expectedException \Symfony\Component\Form\Exception\RuntimeException | ||
871 | */ | ||
872 | public function testSetDataCannotInvokeItself() | ||
873 | { | ||
874 | // Cycle detection to prevent endless loops | ||
875 | $config = new FormConfigBuilder('name', 'stdClass', $this->dispatcher); | ||
876 | $config->addEventListener(FormEvents::PRE_SET_DATA, function (FormEvent $event) { | ||
877 | $event->getForm()->setData('bar'); | ||
878 | }); | ||
879 | $form = new Form($config); | ||
880 | |||
881 | $form->setData('foo'); | ||
882 | } | ||
883 | |||
884 | public function testSubmittingWrongDataIsIgnored() | ||
885 | { | ||
886 | $test = $this; | ||
887 | |||
888 | $child = $this->getBuilder('child', $this->dispatcher); | ||
889 | $child->addEventListener(FormEvents::PRE_SUBMIT, function (FormEvent $event) use ($test) { | ||
890 | // child form doesn't receive the wrong data that is submitted on parent | ||
891 | $test->assertNull($event->getData()); | ||
892 | }); | ||
893 | |||
894 | $parent = $this->getBuilder('parent', new EventDispatcher()) | ||
895 | ->setCompound(true) | ||
896 | ->setDataMapper($this->getDataMapper()) | ||
897 | ->add($child) | ||
898 | ->getForm(); | ||
899 | |||
900 | $parent->submit('not-an-array'); | ||
901 | } | ||
902 | |||
903 | public function testHandleRequestForwardsToRequestHandler() | ||
904 | { | ||
905 | $handler = $this->getMock('Symfony\Component\Form\RequestHandlerInterface'); | ||
906 | |||
907 | $form = $this->getBuilder() | ||
908 | ->setRequestHandler($handler) | ||
909 | ->getForm(); | ||
910 | |||
911 | $handler->expects($this->once()) | ||
912 | ->method('handleRequest') | ||
913 | ->with($this->identicalTo($form), 'REQUEST'); | ||
914 | |||
915 | $this->assertSame($form, $form->handleRequest('REQUEST')); | ||
916 | } | ||
917 | |||
918 | public function testFormInheritsParentData() | ||
919 | { | ||
920 | $child = $this->getBuilder('child') | ||
921 | ->setInheritData(true); | ||
922 | |||
923 | $parent = $this->getBuilder('parent') | ||
924 | ->setCompound(true) | ||
925 | ->setDataMapper($this->getDataMapper()) | ||
926 | ->setData('foo') | ||
927 | ->addModelTransformer(new FixedDataTransformer(array( | ||
928 | 'foo' => 'norm[foo]', | ||
929 | ))) | ||
930 | ->addViewTransformer(new FixedDataTransformer(array( | ||
931 | 'norm[foo]' => 'view[foo]', | ||
932 | ))) | ||
933 | ->add($child) | ||
934 | ->getForm(); | ||
935 | |||
936 | $this->assertSame('foo', $parent->get('child')->getData()); | ||
937 | $this->assertSame('norm[foo]', $parent->get('child')->getNormData()); | ||
938 | $this->assertSame('view[foo]', $parent->get('child')->getViewData()); | ||
939 | } | ||
940 | |||
941 | /** | ||
942 | * @expectedException \Symfony\Component\Form\Exception\RuntimeException | ||
943 | */ | ||
944 | public function testInheritDataDisallowsSetData() | ||
945 | { | ||
946 | $form = $this->getBuilder() | ||
947 | ->setInheritData(true) | ||
948 | ->getForm(); | ||
949 | |||
950 | $form->setData('foo'); | ||
951 | } | ||
952 | |||
953 | /** | ||
954 | * @expectedException \Symfony\Component\Form\Exception\RuntimeException | ||
955 | */ | ||
956 | public function testGetDataRequiresParentToBeSetIfInheritData() | ||
957 | { | ||
958 | $form = $this->getBuilder() | ||
959 | ->setInheritData(true) | ||
960 | ->getForm(); | ||
961 | |||
962 | $form->getData(); | ||
963 | } | ||
964 | |||
965 | /** | ||
966 | * @expectedException \Symfony\Component\Form\Exception\RuntimeException | ||
967 | */ | ||
968 | public function testGetNormDataRequiresParentToBeSetIfInheritData() | ||
969 | { | ||
970 | $form = $this->getBuilder() | ||
971 | ->setInheritData(true) | ||
972 | ->getForm(); | ||
973 | |||
974 | $form->getNormData(); | ||
975 | } | ||
976 | |||
977 | /** | ||
978 | * @expectedException \Symfony\Component\Form\Exception\RuntimeException | ||
979 | */ | ||
980 | public function testGetViewDataRequiresParentToBeSetIfInheritData() | ||
981 | { | ||
982 | $form = $this->getBuilder() | ||
983 | ->setInheritData(true) | ||
984 | ->getForm(); | ||
985 | |||
986 | $form->getViewData(); | ||
987 | } | ||
988 | |||
989 | public function testPostSubmitDataIsNullIfInheritData() | ||
990 | { | ||
991 | $test = $this; | ||
992 | $form = $this->getBuilder() | ||
993 | ->addEventListener(FormEvents::POST_SUBMIT, function (FormEvent $event) use ($test) { | ||
994 | $test->assertNull($event->getData()); | ||
995 | }) | ||
996 | ->setInheritData(true) | ||
997 | ->getForm(); | ||
998 | |||
999 | $form->submit('foo'); | ||
1000 | } | ||
1001 | |||
1002 | public function testSubmitIsNeverFiredIfInheritData() | ||
1003 | { | ||
1004 | $test = $this; | ||
1005 | $form = $this->getBuilder() | ||
1006 | ->addEventListener(FormEvents::SUBMIT, function (FormEvent $event) use ($test) { | ||
1007 | $test->fail('The SUBMIT event should not be fired'); | ||
1008 | }) | ||
1009 | ->setInheritData(true) | ||
1010 | ->getForm(); | ||
1011 | |||
1012 | $form->submit('foo'); | ||
1013 | } | ||
1014 | |||
1015 | public function testInitializeSetsDefaultData() | ||
1016 | { | ||
1017 | $config = $this->getBuilder()->setData('DEFAULT')->getFormConfig(); | ||
1018 | $form = $this->getMock('Symfony\Component\Form\Form', array('setData'), array($config)); | ||
1019 | |||
1020 | $form->expects($this->once()) | ||
1021 | ->method('setData') | ||
1022 | ->with($this->identicalTo('DEFAULT')); | ||
1023 | |||
1024 | /* @var Form $form */ | ||
1025 | $form->initialize(); | ||
1026 | } | ||
1027 | |||
1028 | /** | ||
1029 | * @expectedException \Symfony\Component\Form\Exception\RuntimeException | ||
1030 | */ | ||
1031 | public function testInitializeFailsIfParent() | ||
1032 | { | ||
1033 | $parent = $this->getBuilder()->setRequired(false)->getForm(); | ||
1034 | $child = $this->getBuilder()->setRequired(true)->getForm(); | ||
1035 | |||
1036 | $child->setParent($parent); | ||
1037 | |||
1038 | $child->initialize(); | ||
1039 | } | ||
1040 | |||
1041 | protected function createForm() | ||
1042 | { | ||
1043 | return $this->getBuilder()->getForm(); | ||
1044 | } | ||
1045 | } | ||