1<?php 2 3namespace Drupal\Tests\Core\Form; 4 5use Drupal\Core\Form\FormInterface; 6use Drupal\Core\Form\FormStateDecoratorBase; 7use Drupal\Core\Form\FormStateInterface; 8use Drupal\Core\Url; 9use Drupal\Tests\UnitTestCase; 10use Prophecy\Argument; 11use Symfony\Component\HttpFoundation\RedirectResponse; 12use Symfony\Component\HttpFoundation\Response; 13 14/** 15 * @coversDefaultClass \Drupal\Core\Form\FormStateDecoratorBase 16 * 17 * @group Form 18 */ 19class FormStateDecoratorBaseTest extends UnitTestCase { 20 21 /** 22 * The decorated form state. 23 * 24 * @var \Drupal\Core\Form\FormStateInterface|\Prophecy\Prophecy\ObjectProphecy 25 */ 26 protected $decoratedFormState; 27 28 /** 29 * The form state decorator base under test. 30 * 31 * @var \Drupal\Core\Form\FormStateDecoratorBase 32 */ 33 protected $formStateDecoratorBase; 34 35 /** 36 * {@inheritdoc} 37 */ 38 public function setUp() { 39 parent::setUp(); 40 41 $this->decoratedFormState = $this->prophesize(FormStateInterface::class); 42 43 $this->formStateDecoratorBase = new NonAbstractFormStateDecoratorBase($this->decoratedFormState->reveal()); 44 } 45 46 /** 47 * Provides data to test methods that take a single boolean argument. 48 */ 49 public function providerSingleBooleanArgument() { 50 return [ 51 [TRUE], 52 [FALSE], 53 ]; 54 } 55 56 /** 57 * @covers ::setFormState 58 */ 59 public function testSetFormState() { 60 $form_state_additions = [ 61 'foo' => 'bar', 62 ]; 63 64 $this->decoratedFormState->setFormState($form_state_additions) 65 ->shouldBeCalled(); 66 67 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setFormState($form_state_additions)); 68 } 69 70 /** 71 * @covers ::setAlwaysProcess 72 * 73 * @dataProvider providerSingleBooleanArgument 74 * 75 * @param bool $always_process 76 */ 77 public function testSetAlwaysProcess($always_process) { 78 $this->decoratedFormState->setAlwaysProcess($always_process) 79 ->shouldBeCalled(); 80 81 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setAlwaysProcess($always_process)); 82 } 83 84 /** 85 * @covers ::getAlwaysProcess 86 * 87 * @dataProvider providerSingleBooleanArgument 88 * 89 * @param bool $always_process 90 */ 91 public function testGetAlwaysProcess($always_process) { 92 $this->decoratedFormState->getAlwaysProcess() 93 ->willReturn($always_process) 94 ->shouldBeCalled(); 95 96 $this->assertSame($always_process, $this->formStateDecoratorBase->getAlwaysProcess()); 97 } 98 99 /** 100 * @covers ::setButtons 101 */ 102 public function testSetButtons() { 103 $buttons = [ 104 'FOO' => 'BAR', 105 ]; 106 107 $this->decoratedFormState->setButtons($buttons) 108 ->shouldBeCalled(); 109 110 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setButtons($buttons)); 111 } 112 113 /** 114 * @covers ::getButtons 115 */ 116 public function testGetButtons() { 117 $buttons = [ 118 'FOO' => 'BAR', 119 ]; 120 121 $this->decoratedFormState->getButtons() 122 ->willReturn($buttons) 123 ->shouldBeCalled(); 124 125 $this->assertSame($buttons, $this->formStateDecoratorBase->getButtons()); 126 } 127 128 /** 129 * @covers ::setCached 130 * 131 * @dataProvider providerSingleBooleanArgument 132 * 133 * @param bool $cache 134 */ 135 public function testSetCached($cache) { 136 $this->decoratedFormState->setCached($cache) 137 ->shouldBeCalled(); 138 139 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setCached($cache)); 140 } 141 142 /** 143 * @covers ::isCached 144 * 145 * @dataProvider providerSingleBooleanArgument 146 * 147 * @param bool $cache 148 */ 149 public function testIsCached($cache) { 150 $this->decoratedFormState->isCached() 151 ->willReturn($cache) 152 ->shouldBeCalled(); 153 $this->assertSame($cache, $this->formStateDecoratorBase->isCached()); 154 } 155 156 /** 157 * @covers ::setCached 158 * 159 * @dataProvider providerSingleBooleanArgument 160 * 161 * @param bool $cache 162 */ 163 public function testSetCachedWithLogicException($cache) { 164 $this->decoratedFormState->setCached($cache) 165 ->willThrow(\LogicException::class); 166 $this->expectException(\LogicException::class); 167 $this->formStateDecoratorBase->setCached($cache); 168 } 169 170 /** 171 * @covers ::disableCache 172 */ 173 public function testDisableCache() { 174 $this->decoratedFormState->disableCache() 175 ->shouldBeCalled(); 176 177 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->disableCache()); 178 } 179 180 /** 181 * @covers ::setExecuted 182 */ 183 public function testSetExecuted() { 184 $this->decoratedFormState->setExecuted() 185 ->shouldBecalled(); 186 187 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setExecuted()); 188 } 189 190 /** 191 * @covers ::isExecuted 192 * 193 * @dataProvider providerSingleBooleanArgument 194 * 195 * @param bool $executed 196 */ 197 public function testIsExecuted($executed) { 198 $this->decoratedFormState->isExecuted() 199 ->willReturn($executed) 200 ->shouldBeCalled(); 201 202 $this->assertSame($executed, $this->formStateDecoratorBase->isExecuted()); 203 } 204 205 /** 206 * @covers ::setGroups 207 */ 208 public function testSetGroups() { 209 $groups = [ 210 'FOO' => 'BAR', 211 ]; 212 213 $this->decoratedFormState->setGroups($groups) 214 ->shouldBeCalled(); 215 216 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setGroups($groups)); 217 } 218 219 /** 220 * @covers ::getGroups 221 */ 222 public function testGetGroups() { 223 $groups = [ 224 'FOO' => 'BAR', 225 ]; 226 227 // Use PHPUnit for mocking, because Prophecy cannot mock methods that return 228 // by reference. See \Prophecy\Doubler\Generator\Node::getCode(). 229 $decorated_form_state = $this->createMock(FormStateInterface::class); 230 $decorated_form_state->expects($this->once()) 231 ->method('getGroups') 232 ->willReturn($groups); 233 234 $this->formStateDecoratorBase = new NonAbstractFormStateDecoratorBase($decorated_form_state); 235 236 $this->assertSame($groups, $this->formStateDecoratorBase->getGroups()); 237 } 238 239 /** 240 * @covers ::setHasFileElement 241 * 242 * @dataProvider providerSingleBooleanArgument 243 * 244 * @param bool $has_file_element 245 */ 246 public function testSetHasFileElement($has_file_element) { 247 $this->decoratedFormState->setHasFileElement($has_file_element) 248 ->shouldBeCalled(); 249 250 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setHasFileElement($has_file_element)); 251 } 252 253 /** 254 * @covers ::hasFileElement 255 * 256 * @dataProvider providerSingleBooleanArgument 257 * 258 * @param bool $has_file_element 259 */ 260 public function testHasFileElement($has_file_element) { 261 $this->decoratedFormState->hasFileElement() 262 ->willReturn($has_file_element) 263 ->shouldBeCalled(); 264 265 $this->assertSame($has_file_element, $this->formStateDecoratorBase->hasFileElement()); 266 } 267 268 /** 269 * @covers ::setLimitValidationErrors 270 * 271 * @dataProvider providerLimitValidationErrors 272 * 273 * @param array[]|null $limit_validation_errors 274 * Any valid value for 275 * \Drupal\Core\Form\FormStateInterface::setLimitValidationErrors()'s 276 * $limit_validation_errors argument; 277 */ 278 public function testSetLimitValidationErrors($limit_validation_errors) { 279 $this->decoratedFormState->setLimitValidationErrors($limit_validation_errors) 280 ->shouldBecalled(); 281 282 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setLimitValidationErrors($limit_validation_errors)); 283 } 284 285 /** 286 * @covers ::getLimitValidationErrors 287 * 288 * @dataProvider providerLimitValidationErrors 289 * 290 * @param array[]|null $limit_validation_errors 291 * Any valid value for 292 * \Drupal\Core\Form\FormStateInterface::getLimitValidationErrors()'s 293 * return value; 294 */ 295 public function testGetLimitValidationErrors($limit_validation_errors) { 296 $this->decoratedFormState->getLimitValidationErrors() 297 ->willReturn($limit_validation_errors) 298 ->shouldBeCalled(); 299 300 $this->assertSame($limit_validation_errors, $this->formStateDecoratorBase->getLimitValidationErrors()); 301 } 302 303 /** 304 * Provides data to self::testGetLimitValidationErrors() and self::testGetLimitValidationErrors(). 305 */ 306 public function providerLimitValidationErrors() { 307 return [ 308 [NULL], 309 [ 310 [ 311 ['foo', 'bar', 'baz'], 312 ], 313 ], 314 ]; 315 } 316 317 /** 318 * @covers ::setMethod 319 * 320 * @dataProvider providerSingleBooleanArgument 321 * 322 * @param bool $method 323 */ 324 public function testSetMethod($method) { 325 $this->decoratedFormState->setMethod($method) 326 ->shouldBecalled(); 327 328 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setMethod($method)); 329 } 330 331 /** 332 * @covers ::isMethodType 333 * 334 * @dataProvider providerIsMethodType 335 * 336 * @param bool $expected_return_value 337 * @param string $method_type 338 * Either "GET" or "POST". 339 */ 340 public function testIsMethodType($expected_return_value, $method_type) { 341 $this->decoratedFormState->isMethodType($method_type) 342 ->willReturn($expected_return_value) 343 ->shouldBecalled(); 344 345 $this->assertSame($expected_return_value, $this->formStateDecoratorBase->isMethodType($method_type)); 346 } 347 348 /** 349 * Provides data to self::testIsMethodType(). 350 */ 351 public function providerIsMethodType() { 352 return [ 353 [TRUE, 'GET'], 354 [TRUE, 'POST'], 355 [FALSE, 'GET'], 356 [FALSE, 'POST'], 357 ]; 358 } 359 360 /** 361 * @covers ::setRequestMethod 362 * 363 * @dataProvider providerSetRequestMethod 364 * 365 * @param bool $method 366 */ 367 public function testSetRequestMethod($method) { 368 $this->decoratedFormState->setRequestMethod($method) 369 ->shouldBeCalled(); 370 371 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setRequestMethod($method)); 372 } 373 374 /** 375 * Provides data to self::testSetMethod(). 376 */ 377 public function providerSetRequestMethod() { 378 return [ 379 ['GET'], 380 ['POST'], 381 ]; 382 } 383 384 /** 385 * @covers ::setValidationEnforced 386 * 387 * @dataProvider providerSingleBooleanArgument 388 * 389 * @param bool $must_validate 390 */ 391 public function testSetValidationEnforced($must_validate) { 392 $this->decoratedFormState->setValidationEnforced($must_validate) 393 ->shouldBeCalled(); 394 395 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setValidationEnforced($must_validate)); 396 } 397 398 /** 399 * @covers ::isValidationEnforced 400 * 401 * @dataProvider providerSingleBooleanArgument 402 * 403 * @param bool $must_validate 404 */ 405 public function testIsValidationEnforced($must_validate) { 406 $this->decoratedFormState->isValidationEnforced() 407 ->willReturn($must_validate) 408 ->shouldBecalled(); 409 410 $this->assertSame($must_validate, $this->formStateDecoratorBase->isValidationEnforced()); 411 } 412 413 /** 414 * @covers ::disableRedirect 415 * 416 * @dataProvider providerSingleBooleanArgument 417 * 418 * @param bool $no_redirect 419 */ 420 public function testDisableRedirect($no_redirect) { 421 $this->decoratedFormState->disableRedirect($no_redirect) 422 ->shouldBeCalled(); 423 424 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->disableRedirect($no_redirect)); 425 } 426 427 /** 428 * @covers ::isRedirectDisabled 429 * 430 * @dataProvider providerSingleBooleanArgument 431 * 432 * @param bool $no_redirect 433 */ 434 public function testIsRedirectDisabled($no_redirect) { 435 $this->decoratedFormState->isRedirectDisabled() 436 ->willReturn($no_redirect) 437 ->shouldBeCalled(); 438 439 $this->assertSame($no_redirect, $this->formStateDecoratorBase->isRedirectDisabled()); 440 } 441 442 /** 443 * @covers ::setProcessInput 444 * 445 * @dataProvider providerSingleBooleanArgument 446 * 447 * @param bool $process_input 448 */ 449 public function testSetProcessInput($process_input) { 450 $this->decoratedFormState->setProcessInput($process_input) 451 ->shouldBeCalled(); 452 453 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setProcessInput($process_input)); 454 } 455 456 /** 457 * @covers ::isProcessingInput 458 * 459 * @dataProvider providerSingleBooleanArgument 460 * 461 * @param bool $process_input 462 */ 463 public function testIsProcessingInput($process_input) { 464 $this->decoratedFormState->isProcessingInput() 465 ->willReturn($process_input) 466 ->shouldBecalled(); 467 468 $this->assertSame($process_input, $this->formStateDecoratorBase->isProcessingInput()); 469 } 470 471 /** 472 * @covers ::setProgrammed 473 * 474 * @dataProvider providerSingleBooleanArgument 475 * 476 * @param bool $programmed 477 */ 478 public function testSetProgrammed($programmed) { 479 $this->decoratedFormState->setProgrammed($programmed) 480 ->shouldBecalled(); 481 482 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setProgrammed($programmed)); 483 } 484 485 /** 486 * @covers ::isProgrammed 487 * 488 * @dataProvider providerSingleBooleanArgument 489 * 490 * @param bool $programmed 491 */ 492 public function testIsProgrammed($programmed) { 493 $this->decoratedFormState->isProgrammed() 494 ->willReturn($programmed) 495 ->shouldBecalled(); 496 497 $this->assertSame($programmed, $this->formStateDecoratorBase->isProgrammed()); 498 } 499 500 /** 501 * @covers ::setProgrammedBypassAccessCheck 502 * 503 * @dataProvider providerSingleBooleanArgument 504 * 505 * @param bool $programmed_bypass_access_check 506 */ 507 public function testSetProgrammedBypassAccessCheck($programmed_bypass_access_check) { 508 $this->decoratedFormState->setProgrammedBypassAccessCheck($programmed_bypass_access_check) 509 ->shouldBecalled(); 510 511 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setProgrammedBypassAccessCheck($programmed_bypass_access_check)); 512 } 513 514 /** 515 * @covers ::isBypassingProgrammedAccessChecks 516 * 517 * @dataProvider providerSingleBooleanArgument 518 * 519 * @param bool $programmed_bypass_access_check 520 */ 521 public function testIsBypassingProgrammedAccessChecks($programmed_bypass_access_check) { 522 $this->decoratedFormState->isBypassingProgrammedAccessChecks() 523 ->willReturn($programmed_bypass_access_check) 524 ->shouldBeCalled(); 525 526 $this->assertSame($programmed_bypass_access_check, $this->formStateDecoratorBase->isBypassingProgrammedAccessChecks()); 527 } 528 529 /** 530 * @covers ::setRebuildInfo 531 */ 532 public function testSetRebuildInfo() { 533 $rebuild_info = [ 534 'FOO' => 'BAR', 535 ]; 536 537 $this->decoratedFormState->setRebuildInfo($rebuild_info) 538 ->shouldBeCalled(); 539 540 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setRebuildInfo($rebuild_info)); 541 } 542 543 /** 544 * @covers ::getRebuildInfo 545 */ 546 public function testGetRebuildInfo() { 547 $rebuild_info = [ 548 'FOO' => 'BAR', 549 ]; 550 551 $this->decoratedFormState->getRebuildInfo() 552 ->willReturn($rebuild_info) 553 ->shouldBeCalled(); 554 555 $this->assertSame($rebuild_info, $this->formStateDecoratorBase->getRebuildInfo()); 556 } 557 558 /** 559 * @covers ::addRebuildInfo 560 */ 561 public function testAddRebuildInfo() { 562 $property = 'FOO'; 563 $value = 'BAR'; 564 565 $this->decoratedFormState->addRebuildInfo($property, $value); 566 567 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->addRebuildInfo($property, $value)); 568 } 569 570 /** 571 * @covers ::setStorage 572 */ 573 public function testSetStorage() { 574 $storage = [ 575 'FOO' => 'BAR', 576 ]; 577 578 $this->decoratedFormState->setStorage($storage) 579 ->shouldBeCalled(); 580 581 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setStorage($storage)); 582 } 583 584 /** 585 * @covers ::getStorage 586 */ 587 public function testGetStorage() { 588 $storage = [ 589 'FOO' => 'BAR', 590 ]; 591 592 // Use PHPUnit for mocking, because Prophecy cannot mock methods that return 593 // by reference. See \Prophecy\Doubler\Generator\Node::getCode(). 594 $decorated_form_state = $this->createMock(FormStateInterface::class); 595 $decorated_form_state->expects($this->once()) 596 ->method('getStorage') 597 ->willReturn($storage); 598 599 $this->formStateDecoratorBase = new NonAbstractFormStateDecoratorBase($decorated_form_state); 600 601 $this->assertSame($storage, $this->formStateDecoratorBase->getStorage()); 602 } 603 604 /** 605 * @covers ::setSubmitHandlers 606 */ 607 public function testSetSubmitHandlers() { 608 $submit_handlers = [ 609 'FOO' => 'BAR', 610 ]; 611 612 $this->decoratedFormState->setSubmitHandlers($submit_handlers) 613 ->shouldBeCalled(); 614 615 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setSubmitHandlers($submit_handlers)); 616 } 617 618 /** 619 * @covers ::getSubmitHandlers 620 */ 621 public function testGetSubmitHandlers() { 622 $submit_handlers = [ 623 'FOO' => 'BAR', 624 ]; 625 626 $this->decoratedFormState->getSubmitHandlers() 627 ->willReturn($submit_handlers) 628 ->shouldBeCalled(); 629 630 $this->assertSame($submit_handlers, $this->formStateDecoratorBase->getSubmitHandlers()); 631 } 632 633 /** 634 * @covers ::setSubmitted 635 */ 636 public function testSetSubmitted() { 637 $this->decoratedFormState->setSubmitted() 638 ->shouldBeCalled(); 639 640 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setSubmitted()); 641 } 642 643 /** 644 * @covers ::isSubmitted 645 * 646 * @dataProvider providerSingleBooleanArgument 647 * 648 * @param bool $submitted 649 */ 650 public function testIsSubmitted($submitted) { 651 $this->decoratedFormState->isSubmitted() 652 ->willReturn($submitted); 653 654 $this->assertSame($submitted, $this->formStateDecoratorBase->isSubmitted()); 655 } 656 657 /** 658 * @covers ::setTemporary 659 */ 660 public function testSetTemporary() { 661 $temporary = [ 662 'FOO' => 'BAR', 663 ]; 664 665 $this->decoratedFormState->setTemporary($temporary) 666 ->shouldBeCalled(); 667 668 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setTemporary($temporary)); 669 } 670 671 /** 672 * @covers ::getTemporary 673 */ 674 public function testGetTemporary() { 675 $temporary = [ 676 'FOO' => 'BAR', 677 ]; 678 679 $this->decoratedFormState->getTemporary() 680 ->willReturn($temporary) 681 ->shouldBeCalled(); 682 683 $this->assertSame($temporary, $this->formStateDecoratorBase->getTemporary()); 684 } 685 686 /** 687 * @covers ::setTemporaryValue 688 * 689 * @dataProvider providerSetTemporaryValue 690 * 691 * @param string $key 692 * @param mixed $value 693 */ 694 public function testSetTemporaryValue($key, $value) { 695 $this->decoratedFormState->setTemporaryValue($key, $value) 696 ->shouldBeCalled(); 697 698 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setTemporaryValue($key, $value)); 699 } 700 701 /** 702 * Provides data to self::testSetTemporaryValue(). 703 */ 704 public function providerSetTemporaryValue() { 705 return [ 706 ['FOO', 'BAR'], 707 ['FOO', NULL], 708 ]; 709 } 710 711 /** 712 * @covers ::getTemporaryValue 713 * 714 * @dataProvider providerGetTemporaryValue 715 * 716 * @param string $key 717 * @param mixed $value 718 */ 719 public function testGetTemporaryValue($key, $value = NULL) { 720 // Use PHPUnit for mocking, because Prophecy cannot mock methods that return 721 // by reference. See \Prophecy\Doubler\Generator\Node::getCode(). 722 $decorated_form_state = $this->createMock(FormStateInterface::class); 723 $decorated_form_state->expects($this->once()) 724 ->method('getTemporaryValue') 725 ->with($key) 726 ->willReturn($value); 727 728 $this->formStateDecoratorBase = new NonAbstractFormStateDecoratorBase($decorated_form_state); 729 730 $this->assertSame($value, $this->formStateDecoratorBase->getTemporaryValue($key)); 731 } 732 733 /** 734 * Provides data to self::testGetTemporaryValue(). 735 */ 736 public function providerGetTemporaryValue() { 737 return [ 738 [TRUE, 'FOO', 'BAR'], 739 [TRUE, 'FOO', NULL], 740 ]; 741 } 742 743 /** 744 * @covers ::hasTemporaryValue 745 * 746 * @dataProvider providerHasTemporaryValue 747 * 748 * @param bool $exists 749 * @param string $key 750 */ 751 public function testHasTemporaryValue($exists, $key) { 752 $this->decoratedFormState->hasTemporaryValue($key) 753 ->willReturn($exists) 754 ->shouldBeCalled(); 755 756 $this->assertSame($exists, $this->formStateDecoratorBase->hasTemporaryValue($key)); 757 } 758 759 /** 760 * Provides data to self::testHasTemporaryValue(). 761 */ 762 public function providerHasTemporaryValue() { 763 return [ 764 [TRUE, 'FOO'], 765 [FALSE, 'FOO'], 766 ]; 767 } 768 769 /** 770 * @covers ::setTriggeringElement 771 */ 772 public function testSetTriggeringElement() { 773 $triggering_element = [ 774 'FOO' => 'BAR', 775 ]; 776 777 $this->decoratedFormState->setTriggeringElement($triggering_element) 778 ->shouldBeCalled(); 779 780 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setTriggeringElement($triggering_element)); 781 } 782 783 /** 784 * @covers ::getTriggeringElement 785 */ 786 public function testGetTriggeringElement() { 787 $triggering_element = [ 788 'FOO' => 'BAR', 789 ]; 790 791 // Use PHPUnit for mocking, because Prophecy cannot mock methods that return 792 // by reference. See \Prophecy\Doubler\Generator\Node::getCode(). 793 $decorated_form_state = $this->createMock(FormStateInterface::class); 794 $decorated_form_state->expects($this->once()) 795 ->method('getTriggeringElement') 796 ->willReturn($triggering_element); 797 798 $this->formStateDecoratorBase = new NonAbstractFormStateDecoratorBase($decorated_form_state); 799 800 $this->assertSame($triggering_element, $this->formStateDecoratorBase->getTriggeringElement()); 801 } 802 803 /** 804 * @covers ::setValidateHandlers 805 */ 806 public function testSetValidateHandlers() { 807 $validate_handlers = [ 808 'FOO' => 'BAR', 809 ]; 810 811 $this->decoratedFormState->setValidateHandlers($validate_handlers) 812 ->shouldBeCalled(); 813 814 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setValidateHandlers($validate_handlers)); 815 } 816 817 /** 818 * @covers ::getValidateHandlers 819 */ 820 public function testGetValidateHandlers() { 821 $validate_handlers = [ 822 'FOO' => 'BAR', 823 ]; 824 825 $this->decoratedFormState->getValidateHandlers() 826 ->willReturn($validate_handlers) 827 ->shouldBecalled(); 828 829 $this->assertSame($validate_handlers, $this->formStateDecoratorBase->getValidateHandlers()); 830 } 831 832 /** 833 * @covers ::setValidationComplete 834 * 835 * @dataProvider providerSingleBooleanArgument 836 * 837 * @param bool $complete 838 */ 839 public function testSetValidationComplete($complete) { 840 $this->decoratedFormState->setValidationComplete($complete) 841 ->shouldBeCalled(); 842 843 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setValidationComplete($complete)); 844 } 845 846 /** 847 * @covers ::isValidationComplete 848 * 849 * @dataProvider providerSingleBooleanArgument 850 * 851 * @param bool $complete 852 */ 853 public function testIsValidationComplete($complete) { 854 $this->decoratedFormState->isValidationComplete() 855 ->willReturn($complete) 856 ->shouldBeCalled(); 857 858 $this->assertSame($complete, $this->formStateDecoratorBase->isValidationComplete()); 859 } 860 861 /** 862 * @covers ::loadInclude 863 * 864 * @dataProvider providerLoadInclude 865 * 866 * @param string|false $expected 867 * @param string $module 868 * @param string $type 869 * @param string|null $name 870 */ 871 public function testLoadInclude($expected, $module, $type, $name) { 872 $this->decoratedFormState->loadInclude($module, $type, $name) 873 ->willReturn($expected) 874 ->shouldBeCalled(); 875 876 $this->assertSame($expected, $this->formStateDecoratorBase->loadInclude($module, $type, $name)); 877 } 878 879 /** 880 * Provides data to self::testLoadInclude(). 881 */ 882 public function providerLoadInclude() { 883 return [ 884 // Existing files. 885 [__FILE__, 'foo', 'inc', 'foo'], 886 [__FILE__, 'foo', 'inc', 'foo.admin'], 887 [__FILE__, 'bar', 'inc', 'bar'], 888 // Non-existent files. 889 [FALSE, 'foo', 'php', 'foo'], 890 [FALSE, 'bar', 'php', 'foo'], 891 ]; 892 } 893 894 /** 895 * @covers ::getCacheableArray 896 */ 897 public function testGetCacheableArray() { 898 $cacheable_array = [ 899 'foo' => 'bar', 900 ]; 901 902 $this->decoratedFormState->getCacheableArray() 903 ->willReturn($cacheable_array) 904 ->shouldBeCalled(); 905 906 $this->assertSame($cacheable_array, $this->formStateDecoratorBase->getCacheableArray()); 907 } 908 909 /** 910 * @covers ::setCompleteForm 911 */ 912 public function testSetCompleteForm() { 913 $complete_form = [ 914 'FOO' => 'BAR', 915 ]; 916 917 $this->decoratedFormState->setCompleteForm($complete_form) 918 ->shouldBeCalled(); 919 920 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setCompleteForm($complete_form)); 921 } 922 923 /** 924 * @covers ::getCompleteForm 925 */ 926 public function testGetCompleteForm() { 927 $complete_form = [ 928 'FOO' => 'BAR', 929 ]; 930 931 // Use PHPUnit for mocking, because Prophecy cannot mock methods that return 932 // by reference. See \Prophecy\Doubler\Generator\Node::getCode(). 933 $decorated_form_state = $this->createMock(FormStateInterface::class); 934 $decorated_form_state->expects($this->once()) 935 ->method('getCompleteForm') 936 ->willReturn($complete_form); 937 938 $this->formStateDecoratorBase = new NonAbstractFormStateDecoratorBase($decorated_form_state); 939 940 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setCompleteForm($complete_form)); 941 $this->assertSame($complete_form, $this->formStateDecoratorBase->getCompleteForm()); 942 } 943 944 /** 945 * @covers ::set 946 * 947 * @dataProvider providerSet 948 * 949 * @param string $key 950 * @param mixed $value 951 */ 952 public function testSet($key, $value) { 953 $this->decoratedFormState->set($key, $value) 954 ->shouldBeCalled(); 955 956 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->set($key, $value)); 957 } 958 959 /** 960 * Provides data to self::testSet(). 961 */ 962 public function providerSet() { 963 return [ 964 ['FOO', 'BAR'], 965 ['FOO', NULL], 966 ]; 967 } 968 969 /** 970 * @covers ::get 971 * 972 * @dataProvider providerGet 973 * 974 * @param string $key 975 * @param mixed $value 976 */ 977 public function testGet($key, $value = NULL) { 978 979 // Use PHPUnit for mocking, because Prophecy cannot mock methods that return 980 // by reference. See \Prophecy\Doubler\Generator\Node::getCode(). 981 $decorated_form_state = $this->createMock(FormStateInterface::class); 982 $decorated_form_state->expects($this->once()) 983 ->method('get') 984 ->with($key) 985 ->willReturn($value); 986 987 $this->formStateDecoratorBase = new NonAbstractFormStateDecoratorBase($decorated_form_state); 988 989 $this->assertSame($value, $this->formStateDecoratorBase->get($key)); 990 } 991 992 /** 993 * Provides data to self::testGet(). 994 */ 995 public function providerGet() { 996 return [ 997 ['FOO', 'BAR'], 998 ['FOO', NULL], 999 ]; 1000 } 1001 1002 /** 1003 * @covers ::has 1004 * 1005 * @dataProvider providerHas 1006 * 1007 * @param bool $exists 1008 * @param string $key 1009 */ 1010 public function testHas($exists, $key) { 1011 $this->decoratedFormState->has($key) 1012 ->willReturn($exists) 1013 ->shouldBeCalled(); 1014 1015 $this->assertSame($exists, $this->formStateDecoratorBase->has($key)); 1016 } 1017 1018 /** 1019 * Provides data to self::testHas(). 1020 */ 1021 public function providerHas() { 1022 return [ 1023 [TRUE, 'FOO'], 1024 [FALSE, 'FOO'], 1025 ]; 1026 } 1027 1028 /** 1029 * @covers ::setBuildInfo 1030 */ 1031 public function testSetBuildInfo() { 1032 $build_info = [ 1033 'FOO' => 'BAR', 1034 ]; 1035 1036 $this->decoratedFormState->setBuildInfo($build_info) 1037 ->shouldBeCalled(); 1038 1039 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setBuildInfo($build_info)); 1040 } 1041 1042 /** 1043 * @covers ::getBuildInfo 1044 */ 1045 public function testGetBuildInfo() { 1046 $build_info = [ 1047 'FOO' => 'BAR', 1048 ]; 1049 1050 $this->decoratedFormState->getBuildInfo() 1051 ->willReturn($build_info) 1052 ->shouldBeCalled(); 1053 1054 $this->assertSame($build_info, $this->formStateDecoratorBase->getBuildInfo()); 1055 } 1056 1057 /** 1058 * @covers ::addBuildInfo 1059 */ 1060 public function testAddBuildInfo() { 1061 $property = 'FOO'; 1062 $value = 'BAR'; 1063 1064 $this->decoratedFormState->addBuildInfo($property, $value) 1065 ->shouldBeCalled(); 1066 1067 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->addBuildInfo($property, $value)); 1068 } 1069 1070 /** 1071 * @covers ::setUserInput 1072 */ 1073 public function testSetUserInput() { 1074 $user_input = [ 1075 'FOO' => 'BAR', 1076 ]; 1077 1078 $this->decoratedFormState->setUserInput($user_input) 1079 ->shouldBeCalled(); 1080 1081 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setUserInput($user_input)); 1082 } 1083 1084 /** 1085 * @covers ::getUserInput 1086 */ 1087 public function testGetUserInput() { 1088 $user_input = [ 1089 'FOO' => 'BAR', 1090 ]; 1091 1092 // Use PHPUnit for mocking, because Prophecy cannot mock methods that return 1093 // by reference. See \Prophecy\Doubler\Generator\Node::getCode(). 1094 $decorated_form_state = $this->createMock(FormStateInterface::class); 1095 $decorated_form_state->expects($this->once()) 1096 ->method('getUserInput') 1097 ->willReturn($user_input); 1098 1099 $this->formStateDecoratorBase = new NonAbstractFormStateDecoratorBase($decorated_form_state); 1100 1101 $this->assertSame($user_input, $this->formStateDecoratorBase->getUserInput()); 1102 } 1103 1104 /** 1105 * @covers ::getValues 1106 */ 1107 public function testGetValues() { 1108 $values = [ 1109 'FOO' => 'BAR', 1110 ]; 1111 1112 // Use PHPUnit for mocking, because Prophecy cannot mock methods that return 1113 // by reference. See \Prophecy\Doubler\Generator\Node::getCode(). 1114 $decorated_form_state = $this->createMock(FormStateInterface::class); 1115 $decorated_form_state->expects($this->once()) 1116 ->method('getValues') 1117 ->willReturn($values); 1118 1119 $this->formStateDecoratorBase = new NonAbstractFormStateDecoratorBase($decorated_form_state); 1120 1121 $this->assertSame($values, $this->formStateDecoratorBase->getValues()); 1122 } 1123 1124 /** 1125 * @covers ::getValue 1126 */ 1127 public function testGetValue() { 1128 $key = 'FOO'; 1129 $value = 'BAR'; 1130 1131 // Use PHPUnit for mocking, because Prophecy cannot mock methods that return 1132 // by reference. See \Prophecy\Doubler\Generator\Node::getCode(). 1133 $decorated_form_state = $this->createMock(FormStateInterface::class); 1134 $decorated_form_state->expects($this->once()) 1135 ->method('getValue') 1136 ->with($key, $value) 1137 ->willReturn($value); 1138 1139 $this->formStateDecoratorBase = new NonAbstractFormStateDecoratorBase($decorated_form_state); 1140 1141 $this->assertSame($value, $this->formStateDecoratorBase->getValue($key, $value)); 1142 } 1143 1144 /** 1145 * @covers ::setValues 1146 */ 1147 public function testSetValues() { 1148 $values = [ 1149 'foo' => 'Foo', 1150 'bar' => ['Bar'], 1151 ]; 1152 1153 $this->decoratedFormState->setValues($values) 1154 ->shouldBeCalled(); 1155 1156 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setValues($values)); 1157 } 1158 1159 /** 1160 * @covers ::setValue 1161 */ 1162 public function testSetValue() { 1163 $key = 'FOO'; 1164 $value = 'BAR'; 1165 1166 $this->decoratedFormState->setValue($key, $value) 1167 ->shouldBeCalled(); 1168 1169 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setValue($key, $value)); 1170 } 1171 1172 /** 1173 * @covers ::unsetValue 1174 */ 1175 public function testUnsetValue() { 1176 $key = 'FOO'; 1177 1178 $this->decoratedFormState->unsetValue($key) 1179 ->shouldBeCalled(); 1180 1181 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->unsetValue($key)); 1182 } 1183 1184 /** 1185 * @covers ::hasValue 1186 */ 1187 public function testHasValue() { 1188 $key = ['foo', 'bar']; 1189 $has = TRUE; 1190 1191 $this->decoratedFormState->hasValue($key) 1192 ->willReturn($has) 1193 ->shouldBeCalled(); 1194 1195 $this->assertSame($has, $this->formStateDecoratorBase->hasValue($key)); 1196 } 1197 1198 /** 1199 * @covers ::isValueEmpty 1200 */ 1201 public function testIsValueEmpty() { 1202 $key = ['foo', 'bar']; 1203 $is_empty = TRUE; 1204 1205 $this->decoratedFormState->isValueEmpty($key) 1206 ->willReturn($is_empty) 1207 ->shouldBeCalled(); 1208 1209 $this->assertSame($is_empty, $this->formStateDecoratorBase->isValueEmpty($key)); 1210 } 1211 1212 /** 1213 * @covers ::setValueForElement 1214 */ 1215 public function testSetValueForElement() { 1216 $element = [ 1217 '#type' => 'foo', 1218 ]; 1219 $value = 'BAR'; 1220 1221 $this->decoratedFormState->setValueForElement($element, $value) 1222 ->shouldBeCalled(); 1223 1224 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setValueForElement($element, $value)); 1225 } 1226 1227 /** 1228 * @covers ::setResponse 1229 */ 1230 public function testSetResponse() { 1231 $response = $this->createMock(Response::class); 1232 1233 $this->decoratedFormState->setResponse($response) 1234 ->shouldBeCalled(); 1235 1236 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setResponse($response)); 1237 } 1238 1239 /** 1240 * @covers ::getResponse 1241 */ 1242 public function testGetResponse() { 1243 $response = $this->createMock(Response::class); 1244 1245 $this->decoratedFormState->getResponse() 1246 ->willReturn($response) 1247 ->shouldBeCalled(); 1248 1249 $this->assertSame($response, $this->formStateDecoratorBase->getResponse()); 1250 } 1251 1252 /** 1253 * @covers ::setRedirect 1254 */ 1255 public function testSetRedirect() { 1256 $route_name = 'foo'; 1257 $route_parameters = [ 1258 'bar' => 'baz', 1259 ]; 1260 $options = [ 1261 'qux' => 'foo', 1262 ]; 1263 1264 $this->decoratedFormState->setRedirect($route_name, $route_parameters, $options) 1265 ->shouldBeCalled(); 1266 1267 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setRedirect($route_name, $route_parameters, $options)); 1268 } 1269 1270 /** 1271 * @covers ::setRedirectUrl 1272 */ 1273 public function testSetRedirectUrl() { 1274 $url = new Url('foo'); 1275 1276 $this->decoratedFormState->setRedirectUrl($url) 1277 ->shouldBeCalled(); 1278 1279 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setRedirectUrl($url)); 1280 } 1281 1282 /** 1283 * @covers ::getRedirect 1284 * 1285 * @dataProvider providerGetRedirect 1286 * 1287 * @param bool $expected 1288 */ 1289 public function testGetRedirect($expected) { 1290 $this->decoratedFormState->getRedirect() 1291 ->willReturn($expected) 1292 ->shouldBeCalled(); 1293 1294 $this->assertSame($expected, $this->formStateDecoratorBase->getRedirect()); 1295 } 1296 1297 /** 1298 * Provides data to self::testGetRedirect(). 1299 */ 1300 public function providerGetRedirect() { 1301 return [ 1302 [NULL], 1303 [FALSE], 1304 [new Url('foo')], 1305 [new RedirectResponse('http://example.com')], 1306 ]; 1307 } 1308 1309 /** 1310 * @covers ::setErrorByName 1311 */ 1312 public function testSetErrorByName() { 1313 $name = 'foo'; 1314 $message = 'bar'; 1315 1316 $this->decoratedFormState->setErrorByName($name, $message) 1317 ->shouldBeCalled(); 1318 1319 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setErrorByName($name, $message)); 1320 } 1321 1322 /** 1323 * @covers ::setError 1324 */ 1325 public function testSetError() { 1326 $element = [ 1327 '#foo' => 'bar', 1328 ]; 1329 $message = 'bar'; 1330 1331 $this->decoratedFormState->setError($element, $message) 1332 ->shouldBeCalled(); 1333 1334 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setError($element, $message)); 1335 } 1336 1337 /** 1338 * @covers ::clearErrors 1339 */ 1340 public function testClearErrors() { 1341 $this->decoratedFormState->clearErrors() 1342 ->shouldBeCalled(); 1343 1344 $this->formStateDecoratorBase->clearErrors(); 1345 } 1346 1347 /** 1348 * @covers ::getError 1349 */ 1350 public function testGetError() { 1351 $element = [ 1352 '#foo' => 'bar', 1353 ]; 1354 $message = 'bar'; 1355 1356 $this->decoratedFormState->getError($element) 1357 ->willReturn($message) 1358 ->shouldBeCalled(); 1359 1360 $this->assertSame($message, $this->formStateDecoratorBase->getError($element)); 1361 } 1362 1363 /** 1364 * @covers ::getErrors 1365 */ 1366 public function testGetErrors() { 1367 $errors = [ 1368 'foo' => 'bar', 1369 ]; 1370 $this->decoratedFormState->getErrors() 1371 ->willReturn($errors) 1372 ->shouldBeCalled(); 1373 1374 $this->assertSame($errors, $this->formStateDecoratorBase->getErrors()); 1375 } 1376 1377 /** 1378 * @covers ::setRebuild 1379 * 1380 * @dataProvider providerSingleBooleanArgument 1381 * 1382 * @param bool $rebuild 1383 */ 1384 public function testSetRebuild($rebuild) { 1385 $this->decoratedFormState->setRebuild($rebuild) 1386 ->shouldBeCalled(); 1387 1388 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setRebuild($rebuild)); 1389 } 1390 1391 /** 1392 * @covers ::isRebuilding 1393 * 1394 * @dataProvider providerSingleBooleanArgument 1395 * 1396 * @param bool $rebuild 1397 */ 1398 public function testIsRebuilding($rebuild) { 1399 $this->decoratedFormState->isRebuilding() 1400 ->willReturn($rebuild) 1401 ->shouldBeCalled(); 1402 1403 $this->assertSame($rebuild, $this->formStateDecoratorBase->isRebuilding()); 1404 } 1405 1406 /** 1407 * @covers ::setInvalidToken 1408 * 1409 * @dataProvider providerSingleBooleanArgument 1410 * 1411 * @param bool $expected 1412 */ 1413 public function testSetInvalidToken($expected) { 1414 $this->decoratedFormState->setInvalidToken($expected) 1415 ->shouldBeCalled(); 1416 1417 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setInvalidToken($expected)); 1418 } 1419 1420 /** 1421 * @covers ::hasInvalidToken 1422 * 1423 * @dataProvider providerSingleBooleanArgument 1424 * 1425 * @param bool $expected 1426 */ 1427 public function testHasInvalidToken($expected) { 1428 $this->decoratedFormState->hasInvalidToken() 1429 ->willReturn($expected) 1430 ->shouldBeCalled(); 1431 1432 $this->assertSame($expected, $this->formStateDecoratorBase->hasInvalidToken()); 1433 } 1434 1435 /** 1436 * @covers ::prepareCallback 1437 * 1438 * @dataProvider providerPrepareCallback 1439 * 1440 * @param string|callable $unprepared_callback 1441 * @param callable $prepared_callback 1442 */ 1443 public function testPrepareCallback($unprepared_callback, callable $prepared_callback) { 1444 $this->decoratedFormState->prepareCallback(Argument::is($unprepared_callback)) 1445 ->willReturn($prepared_callback) 1446 ->shouldBeCalled(); 1447 1448 $this->assertSame($prepared_callback, $this->formStateDecoratorBase->prepareCallback($unprepared_callback)); 1449 } 1450 1451 /** 1452 * Provides data to self::testPrepareCallback(). 1453 */ 1454 public function providerPrepareCallback() { 1455 $function = 'sleep'; 1456 $shorthand_form_method = '::submit()'; 1457 $closure = function () {}; 1458 $static_method_string = __METHOD__; 1459 $static_method_array = [__CLASS__, __FUNCTION__]; 1460 $object_method_array = [$this, __FUNCTION__]; 1461 1462 return [ 1463 // A shorthand form method is generally expanded to become a method on an 1464 // object. 1465 [$shorthand_form_method, $object_method_array], 1466 // Functions, closures, and static method calls generally remain the same. 1467 [$function, $function], 1468 [$closure, $closure], 1469 [$static_method_string, $static_method_string], 1470 [$static_method_array, $static_method_array], 1471 ]; 1472 } 1473 1474 /** 1475 * @covers ::setFormObject 1476 */ 1477 public function testSetFormObject() { 1478 $form = $this->createMock(FormInterface::class); 1479 1480 $this->decoratedFormState->setFormObject($form) 1481 ->shouldBeCalled(); 1482 1483 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setFormObject($form)); 1484 } 1485 1486 /** 1487 * @covers ::getFormObject 1488 */ 1489 public function testGetFormObject() { 1490 $form = $this->createMock(FormInterface::class); 1491 1492 $this->decoratedFormState->getFormObject() 1493 ->willReturn($form) 1494 ->shouldBeCalled(); 1495 1496 $this->assertSame($form, $this->formStateDecoratorBase->getFormObject()); 1497 } 1498 1499 /** 1500 * @covers ::setCleanValueKeys 1501 */ 1502 public function testSetCleanValueKeys() { 1503 $keys = ['BAR']; 1504 1505 $this->decoratedFormState->setCleanValueKeys($keys) 1506 ->shouldBeCalled(); 1507 1508 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setCleanValueKeys($keys)); 1509 } 1510 1511 /** 1512 * @covers ::getCleanValueKeys 1513 */ 1514 public function testGetCleanValueKeys() { 1515 $keys = ['BAR']; 1516 1517 $this->decoratedFormState->getCleanValueKeys() 1518 ->willReturn($keys) 1519 ->shouldBeCalled(); 1520 1521 $this->assertSame($keys, $this->formStateDecoratorBase->getCleanValueKeys()); 1522 } 1523 1524 /** 1525 * @covers ::addCleanValueKey 1526 */ 1527 public function testAddCleanValueKey() { 1528 $key = 'BAR'; 1529 1530 $this->decoratedFormState->addCleanValueKey($key) 1531 ->shouldBeCalled(); 1532 1533 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->addCleanValueKey($key)); 1534 } 1535 1536 /** 1537 * @covers ::cleanValues 1538 */ 1539 public function testCleanValues() { 1540 $this->decoratedFormState->cleanValues() 1541 ->shouldBeCalled(); 1542 1543 $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->cleanValues()); 1544 } 1545 1546} 1547 1548/** 1549 * Provides a non-abstract version of the class under test. 1550 */ 1551class NonAbstractFormStateDecoratorBase extends FormStateDecoratorBase { 1552 1553 /** 1554 * Creates a new instance. 1555 * 1556 * @param \Drupal\Core\Form\FormStateInterface $decorated_form_state 1557 * The decorated form state. 1558 */ 1559 public function __construct(FormStateInterface $decorated_form_state) { 1560 $this->decoratedFormState = $decorated_form_state; 1561 } 1562 1563} 1564