vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/Type/FormTypeTest.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\Form\Tests\Extension\Core\Type;
  13
  14 use Symfony\Component\PropertyAccess\PropertyPath;
  15 use Symfony\Component\Form\Form;
  16 use Symfony\Component\Form\CallbackTransformer;
  17 use Symfony\Component\Form\Tests\Fixtures\Author;
  18 use Symfony\Component\Form\Tests\Fixtures\FixedDataTransformer;
  19 use Symfony\Component\Form\FormError;
  20
  21 class FormTest_AuthorWithoutRefSetter
  22 {
  23     protected $reference;
  24
  25     protected $referenceCopy;
  26
  27     public function __construct($reference)
  28     {
  29         $this->reference = $reference;
  30         $this->referenceCopy = $reference;
  31     }
  32
  33     // The returned object should be modified by reference without having
  34     // to provide a setReference() method
  35     public function getReference()
  36     {
  37         return $this->reference;
  38     }
  39
  40     // The returned object is a copy, so setReferenceCopy() must be used
  41     // to update it
  42     public function getReferenceCopy()
  43     {
  44         return is_object($this->referenceCopy) ? clone $this->referenceCopy : $this->referenceCopy;
  45     }
  46
  47     public function setReferenceCopy($reference)
  48     {
  49         $this->referenceCopy = $reference;
  50     }
  51 }
  52
  53 class FormTypeTest extends BaseTypeTest
  54 {
  55     public function testCreateFormInstances()
  56     {
  57         $this->assertInstanceOf('Symfony\Component\Form\Form', $this->factory->create('form'));
  58     }
  59
  60     public function testPassRequiredAsOption()
  61     {
  62         $form = $this->factory->create('form', null, array('required' => false));
  63
  64         $this->assertFalse($form->isRequired());
  65
  66         $form = $this->factory->create('form', null, array('required' => true));
  67
  68         $this->assertTrue($form->isRequired());
  69     }
  70
  71     public function testSubmittedDataIsTrimmedBeforeTransforming()
  72     {
  73         $form = $this->factory->createBuilder('form')
  74             ->addViewTransformer(new FixedDataTransformer(array(
  75                 null => '',
  76                 'reverse[a]' => 'a',
  77             )))
  78             ->setCompound(false)
  79             ->getForm();
  80
  81         $form->submit(' a ');
  82
  83         $this->assertEquals('a', $form->getViewData());
  84         $this->assertEquals('reverse[a]', $form->getData());
  85     }
  86
  87     public function testSubmittedDataIsNotTrimmedBeforeTransformingIfNoTrimming()
  88     {
  89         $form = $this->factory->createBuilder('form', null, array('trim' => false))
  90             ->addViewTransformer(new FixedDataTransformer(array(
  91                 null => '',
  92                 'reverse[ a ]' => ' a ',
  93             )))
  94             ->setCompound(false)
  95             ->getForm();
  96
  97         $form->submit(' a ');
  98
  99         $this->assertEquals(' a ', $form->getViewData());
 100         $this->assertEquals('reverse[ a ]', $form->getData());
 101     }
 102
 103     public function testNonReadOnlyFormWithReadOnlyParentIsReadOnly()
 104     {
 105         $view = $this->factory->createNamedBuilder('parent', 'form', null, array('read_only' => true))
 106             ->add('child', 'form')
 107             ->getForm()
 108             ->createView();
 109
 110         $this->assertTrue($view['child']->vars['read_only']);
 111     }
 112
 113     public function testReadOnlyFormWithNonReadOnlyParentIsReadOnly()
 114     {
 115         $view = $this->factory->createNamedBuilder('parent', 'form')
 116             ->add('child', 'form', array('read_only' => true))
 117             ->getForm()
 118             ->createView();
 119
 120         $this->assertTrue($view['child']->vars['read_only']);
 121     }
 122
 123     public function testNonReadOnlyFormWithNonReadOnlyParentIsNotReadOnly()
 124     {
 125         $view = $this->factory->createNamedBuilder('parent', 'form')
 126                 ->add('child', 'form')
 127                 ->getForm()
 128                 ->createView();
 129
 130         $this->assertFalse($view['child']->vars['read_only']);
 131     }
 132
 133     public function testPassMaxLengthToView()
 134     {
 135         $form = $this->factory->create('form', null, array('max_length' => 10));
 136         $view = $form->createView();
 137
 138         $this->assertSame(10, $view->vars['max_length']);
 139     }
 140
 141     public function testSubmitWithEmptyDataCreatesObjectIfClassAvailable()
 142     {
 143         $builder = $this->factory->createBuilder('form', null, array(
 144             'data_class' => 'Symfony\Component\Form\Tests\Fixtures\Author',
 145             'required' => false,
 146         ));
 147         $builder->add('firstName', 'text');
 148         $builder->add('lastName', 'text');
 149         $form = $builder->getForm();
 150
 151         $form->setData(null);
 152         // partially empty, still an object is created
 153         $form->submit(array('firstName' => 'Bernhard', 'lastName' => ''));
 154
 155         $author = new Author();
 156         $author->firstName = 'Bernhard';
 157         $author->setLastName('');
 158
 159         $this->assertEquals($author, $form->getData());
 160     }
 161
 162     public function testSubmitWithEmptyDataCreatesObjectIfInitiallySubmittedWithObject()
 163     {
 164         $builder = $this->factory->createBuilder('form', null, array(
 165             // data class is inferred from the passed object
 166             'data' => new Author(),
 167             'required' => false,
 168         ));
 169         $builder->add('firstName', 'text');
 170         $builder->add('lastName', 'text');
 171         $form = $builder->getForm();
 172
 173         $form->setData(null);
 174         // partially empty, still an object is created
 175         $form->submit(array('firstName' => 'Bernhard', 'lastName' => ''));
 176
 177         $author = new Author();
 178         $author->firstName = 'Bernhard';
 179         $author->setLastName('');
 180
 181         $this->assertEquals($author, $form->getData());
 182     }
 183
 184     public function testSubmitWithEmptyDataCreatesArrayIfDataClassIsNull()
 185     {
 186         $builder = $this->factory->createBuilder('form', null, array(
 187             'data_class' => null,
 188             'required' => false,
 189         ));
 190         $builder->add('firstName', 'text');
 191         $form = $builder->getForm();
 192
 193         $form->setData(null);
 194         $form->submit(array('firstName' => 'Bernhard'));
 195
 196         $this->assertSame(array('firstName' => 'Bernhard'), $form->getData());
 197     }
 198
 199     public function testSubmitEmptyWithEmptyDataCreatesNoObjectIfNotRequired()
 200     {
 201         $builder = $this->factory->createBuilder('form', null, array(
 202             'data_class' => 'Symfony\Component\Form\Tests\Fixtures\Author',
 203             'required' => false,
 204         ));
 205         $builder->add('firstName', 'text');
 206         $builder->add('lastName', 'text');
 207         $form = $builder->getForm();
 208
 209         $form->setData(null);
 210         $form->submit(array('firstName' => '', 'lastName' => ''));
 211
 212         $this->assertNull($form->getData());
 213     }
 214
 215     public function testSubmitEmptyWithEmptyDataCreatesObjectIfRequired()
 216     {
 217         $builder = $this->factory->createBuilder('form', null, array(
 218             'data_class' => 'Symfony\Component\Form\Tests\Fixtures\Author',
 219             'required' => true,
 220         ));
 221         $builder->add('firstName', 'text');
 222         $builder->add('lastName', 'text');
 223         $form = $builder->getForm();
 224
 225         $form->setData(null);
 226         $form->submit(array('firstName' => '', 'lastName' => ''));
 227
 228         $this->assertEquals(new Author(), $form->getData());
 229     }
 230
 231     /*
 232      * We need something to write the field values into
 233      */
 234     public function testSubmitWithEmptyDataStoresArrayIfNoClassAvailable()
 235     {
 236         $form = $this->factory->createBuilder('form')
 237             ->add('firstName', 'text')
 238             ->getForm();
 239
 240         $form->setData(null);
 241         $form->submit(array('firstName' => 'Bernhard'));
 242
 243         $this->assertSame(array('firstName' => 'Bernhard'), $form->getData());
 244     }
 245
 246     public function testSubmitWithEmptyDataPassesEmptyStringToTransformerIfNotCompound()
 247     {
 248         $form = $this->factory->createBuilder('form')
 249             ->addViewTransformer(new FixedDataTransformer(array(
 250                 // required for the initial, internal setData(null)
 251                 null => 'null',
 252                 // required to test that submit(null) is converted to ''
 253                 'empty' => '',
 254             )))
 255             ->setCompound(false)
 256             ->getForm();
 257
 258         $form->submit(null);
 259
 260         $this->assertSame('empty', $form->getData());
 261     }
 262
 263     public function testSubmitWithEmptyDataUsesEmptyDataOption()
 264     {
 265         $author = new Author();
 266
 267         $builder = $this->factory->createBuilder('form', null, array(
 268             'data_class' => 'Symfony\Component\Form\Tests\Fixtures\Author',
 269             'empty_data' => $author,
 270         ));
 271         $builder->add('firstName', 'text');
 272         $form = $builder->getForm();
 273
 274         $form->submit(array('firstName' => 'Bernhard'));
 275
 276         $this->assertSame($author, $form->getData());
 277         $this->assertEquals('Bernhard', $author->firstName);
 278     }
 279
 280     public function provideZeros()
 281     {
 282         return array(
 283             array(0, '0'),
 284             array('0', '0'),
 285             array('00000', '00000'),
 286         );
 287     }
 288
 289     /**
 290      * @dataProvider provideZeros
 291      * @see https://github.com/symfony/symfony/issues/1986
 292      */
 293     public function testSetDataThroughParamsWithZero($data, $dataAsString)
 294     {
 295         $form = $this->factory->create('form', null, array(
 296             'data' => $data,
 297             'compound' => false,
 298         ));
 299         $view = $form->createView();
 300
 301         $this->assertFalse($form->isEmpty());
 302
 303         $this->assertSame($dataAsString, $view->vars['value']);
 304         $this->assertSame($dataAsString, $form->getData());
 305     }
 306
 307     /**
 308      * @expectedException \Symfony\Component\OptionsResolver\Exception\InvalidOptionsException
 309      */
 310     public function testAttributesException()
 311     {
 312         $this->factory->create('form', null, array('attr' => ''));
 313     }
 314
 315     public function testNameCanBeEmptyString()
 316     {
 317         $form = $this->factory->createNamed('', 'form');
 318
 319         $this->assertEquals('', $form->getName());
 320     }
 321
 322     public function testSubformDoesntCallSetters()
 323     {
 324         $author = new FormTest_AuthorWithoutRefSetter(new Author());
 325
 326         $builder = $this->factory->createBuilder('form', $author);
 327         $builder->add('reference', 'form', array(
 328             'data_class' => 'Symfony\Component\Form\Tests\Fixtures\Author',
 329         ));
 330         $builder->get('reference')->add('firstName', 'text');
 331         $form = $builder->getForm();
 332
 333         $form->submit(array(
 334             // reference has a getter, but not setter
 335             'reference' => array(
 336                 'firstName' => 'Foo',
 337             )
 338         ));
 339
 340         $this->assertEquals('Foo', $author->getReference()->firstName);
 341     }
 342
 343     public function testSubformCallsSettersIfTheObjectChanged()
 344     {
 345         // no reference
 346         $author = new FormTest_AuthorWithoutRefSetter(null);
 347         $newReference = new Author();
 348
 349         $builder = $this->factory->createBuilder('form', $author);
 350         $builder->add('referenceCopy', 'form', array(
 351             'data_class' => 'Symfony\Component\Form\Tests\Fixtures\Author',
 352         ));
 353         $builder->get('referenceCopy')->add('firstName', 'text');
 354         $form = $builder->getForm();
 355
 356         $form['referenceCopy']->setData($newReference); // new author object
 357
 358         $form->submit(array(
 359         // referenceCopy has a getter that returns a copy
 360             'referenceCopy' => array(
 361                 'firstName' => 'Foo',
 362         )
 363         ));
 364
 365         $this->assertEquals('Foo', $author->getReferenceCopy()->firstName);
 366     }
 367
 368     public function testSubformCallsSettersIfByReferenceIsFalse()
 369     {
 370         $author = new FormTest_AuthorWithoutRefSetter(new Author());
 371
 372         $builder = $this->factory->createBuilder('form', $author);
 373         $builder->add('referenceCopy', 'form', array(
 374             'data_class' => 'Symfony\Component\Form\Tests\Fixtures\Author',
 375             'by_reference' => false
 376         ));
 377         $builder->get('referenceCopy')->add('firstName', 'text');
 378         $form = $builder->getForm();
 379
 380         $form->submit(array(
 381             // referenceCopy has a getter that returns a copy
 382             'referenceCopy' => array(
 383                 'firstName' => 'Foo',
 384             )
 385         ));
 386
 387         // firstName can only be updated if setReferenceCopy() was called
 388         $this->assertEquals('Foo', $author->getReferenceCopy()->firstName);
 389     }
 390
 391     public function testSubformCallsSettersIfReferenceIsScalar()
 392     {
 393         $author = new FormTest_AuthorWithoutRefSetter('scalar');
 394
 395         $builder = $this->factory->createBuilder('form', $author);
 396         $builder->add('referenceCopy', 'form');
 397         $builder->get('referenceCopy')->addViewTransformer(new CallbackTransformer(
 398             function () {},
 399             function ($value) { // reverseTransform
 400
 401                 return 'foobar';
 402             }
 403         ));
 404         $form = $builder->getForm();
 405
 406         $form->submit(array(
 407             'referenceCopy' => array(), // doesn't matter actually
 408         ));
 409
 410         // firstName can only be updated if setReferenceCopy() was called
 411         $this->assertEquals('foobar', $author->getReferenceCopy());
 412     }
 413
 414     public function testSubformAlwaysInsertsIntoArrays()
 415     {
 416         $ref1 = new Author();
 417         $ref2 = new Author();
 418         $author = array('referenceCopy' => $ref1);
 419
 420         $builder = $this->factory->createBuilder('form');
 421         $builder->setData($author);
 422         $builder->add('referenceCopy', 'form');
 423         $builder->get('referenceCopy')->addViewTransformer(new CallbackTransformer(
 424             function () {},
 425             function ($value) use ($ref2) { // reverseTransform
 426
 427                 return $ref2;
 428             }
 429         ));
 430         $form = $builder->getForm();
 431
 432         $form->submit(array(
 433             'referenceCopy' => array('a' => 'b'), // doesn't matter actually
 434         ));
 435
 436         // the new reference was inserted into the array
 437         $author = $form->getData();
 438         $this->assertSame($ref2, $author['referenceCopy']);
 439     }
 440
 441     public function testPassMultipartTrueIfAnyChildIsMultipartToView()
 442     {
 443         $view = $this->factory->createBuilder('form')
 444             ->add('foo', 'text')
 445             ->add('bar', 'file')
 446             ->getForm()
 447             ->createView();
 448
 449         $this->assertTrue($view->vars['multipart']);
 450     }
 451
 452     public function testViewIsNotRenderedByDefault()
 453     {
 454         $view = $this->factory->createBuilder('form')
 455                 ->add('foo', 'form')
 456                 ->getForm()
 457                 ->createView();
 458
 459         $this->assertFalse($view->isRendered());
 460     }
 461
 462     public function testErrorBubblingIfCompound()
 463     {
 464         $form = $this->factory->create('form', null, array(
 465             'compound' => true,
 466         ));
 467
 468         $this->assertTrue($form->getConfig()->getErrorBubbling());
 469     }
 470
 471     public function testNoErrorBubblingIfNotCompound()
 472     {
 473         $form = $this->factory->create('form', null, array(
 474             'compound' => false,
 475         ));
 476
 477         $this->assertFalse($form->getConfig()->getErrorBubbling());
 478     }
 479
 480     public function testOverrideErrorBubbling()
 481     {
 482         $form = $this->factory->create('form', null, array(
 483             'compound' => false,
 484             'error_bubbling' => true,
 485         ));
 486
 487         $this->assertTrue($form->getConfig()->getErrorBubbling());
 488     }
 489
 490     public function testPropertyPath()
 491     {
 492         $form = $this->factory->create('form', null, array(
 493             'property_path' => 'foo',
 494         ));
 495
 496         $this->assertEquals(new PropertyPath('foo'), $form->getPropertyPath());
 497         $this->assertTrue($form->getConfig()->getMapped());
 498     }
 499
 500     public function testPropertyPathNullImpliesDefault()
 501     {
 502         $form = $this->factory->createNamed('name', 'form', null, array(
 503             'property_path' => null,
 504         ));
 505
 506         $this->assertEquals(new PropertyPath('name'), $form->getPropertyPath());
 507         $this->assertTrue($form->getConfig()->getMapped());
 508     }
 509
 510     public function testNotMapped()
 511     {
 512         $form = $this->factory->create('form', null, array(
 513             'property_path' => 'foo',
 514             'mapped' => false,
 515         ));
 516
 517         $this->assertEquals(new PropertyPath('foo'), $form->getPropertyPath());
 518         $this->assertFalse($form->getConfig()->getMapped());
 519     }
 520
 521     public function testViewValidNotSubmitted()
 522     {
 523         $form = $this->factory->create('form');
 524         $view = $form->createView();
 525         $this->assertTrue($view->vars['valid']);
 526     }
 527
 528     public function testViewNotValidSubmitted()
 529     {
 530         $form = $this->factory->create('form');
 531         $form->submit(array());
 532         $form->addError(new FormError('An error'));
 533         $view = $form->createView();
 534         $this->assertFalse($view->vars['valid']);
 535     }
 536
 537     public function testDataOptionSupersedesSetDataCalls()
 538     {
 539         $form = $this->factory->create('form', null, array(
 540             'data' => 'default',
 541             'compound' => false,
 542         ));
 543
 544         $form->setData('foobar');
 545
 546         $this->assertSame('default', $form->getData());
 547     }
 548
 549     public function testNormDataIsPassedToView()
 550     {
 551         $view = $this->factory->createBuilder('form')
 552             ->addViewTransformer(new FixedDataTransformer(array(
 553                 'foo' => 'bar',
 554             )))
 555             ->setData('foo')
 556             ->getForm()
 557             ->createView();
 558
 559         $this->assertSame('foo', $view->vars['data']);
 560         $this->assertSame('bar', $view->vars['value']);
 561     }
 562
 563     // https://github.com/symfony/symfony/issues/6862
 564     public function testPassZeroLabelToView()
 565     {
 566         $view = $this->factory->create('form', null, array(
 567                 'label' => '0'
 568             ))
 569             ->createView();
 570
 571         $this->assertSame('0', $view->vars['label']);
 572     }
 573
 574     protected function getTestedType()
 575     {
 576         return 'form';
 577     }
 578 }