class FormStateTest

Same name in other branches
  1. 9 core/tests/Drupal/Tests/Core/Form/FormStateTest.php \Drupal\Tests\Core\Form\FormStateTest
  2. 8.9.x core/tests/Drupal/Tests/Core/Form/FormStateTest.php \Drupal\Tests\Core\Form\FormStateTest
  3. 10 core/tests/Drupal/Tests/Core/Form/FormStateTest.php \Drupal\Tests\Core\Form\FormStateTest

@coversDefaultClass \Drupal\Core\Form\FormState

@group Form

Hierarchy

Expanded class hierarchy of FormStateTest

File

core/tests/Drupal/Tests/Core/Form/FormStateTest.php, line 19

Namespace

Drupal\Tests\Core\Form
View source
class FormStateTest extends UnitTestCase {
    
    /**
     * Tests the getRedirect() method.
     *
     * @covers ::getRedirect
     *
     * @dataProvider providerTestGetRedirect
     */
    public function testGetRedirect($form_state_additions, $expected) : void {
        $form_state = (new FormState())->setFormState($form_state_additions);
        $redirect = $form_state->getRedirect();
        $this->assertEquals($expected, $redirect);
    }
    
    /**
     * Provides test data for testing the getRedirect() method.
     *
     * @return array
     *   Returns some test data.
     */
    public static function providerTestGetRedirect() {
        $data = [];
        $data[] = [
            [],
            NULL,
        ];
        $redirect = new RedirectResponse('/example');
        $data[] = [
            [
                'redirect' => $redirect,
            ],
            $redirect,
        ];
        $data[] = [
            [
                'redirect' => new Url('test_route_b', [
                    'key' => 'value',
                ]),
            ],
            new Url('test_route_b', [
                'key' => 'value',
            ]),
        ];
        $data[] = [
            [
                'programmed' => TRUE,
            ],
            NULL,
        ];
        $data[] = [
            [
                'rebuild' => TRUE,
            ],
            NULL,
        ];
        $data[] = [
            [
                'no_redirect' => TRUE,
            ],
            NULL,
        ];
        return $data;
    }
    
    /**
     * Tests the setError() method.
     *
     * @covers ::setError
     */
    public function testSetError() : void {
        $form_state = new FormState();
        $element['#parents'] = [
            'foo',
            'bar',
        ];
        $form_state->setError($element, 'Fail');
        $this->assertSame([
            'foo][bar' => 'Fail',
        ], $form_state->getErrors());
    }
    
    /**
     * Tests the getError() method.
     *
     * @covers ::getError
     *
     * @dataProvider providerTestGetError
     */
    public function testGetError($errors, $parents, $error = NULL) : void {
        $element['#parents'] = $parents;
        $form_state = (new FormState())->setFormState([
            'errors' => $errors,
        ]);
        $this->assertSame($error, $form_state->getError($element));
    }
    public static function providerTestGetError() {
        return [
            [
                [],
                [
                    'foo',
                ],
            ],
            [
                [
                    'foo][bar' => 'Fail',
                ],
                [],
            ],
            [
                [
                    'foo][bar' => 'Fail',
                ],
                [
                    'foo',
                ],
            ],
            [
                [
                    'foo][bar' => 'Fail',
                ],
                [
                    'bar',
                ],
            ],
            [
                [
                    'foo][bar' => 'Fail',
                ],
                [
                    'baz',
                ],
            ],
            [
                [
                    'foo][bar' => 'Fail',
                ],
                [
                    'foo',
                    'bar',
                ],
                'Fail',
            ],
            [
                [
                    'foo][bar' => 'Fail',
                ],
                [
                    'foo',
                    'bar',
                    'baz',
                ],
                'Fail',
            ],
            [
                [
                    'foo][bar' => 'Fail 2',
                ],
                [
                    'foo',
                ],
            ],
            [
                [
                    'foo' => 'Fail 1',
                    'foo][bar' => 'Fail 2',
                ],
                [
                    'foo',
                ],
                'Fail 1',
            ],
            [
                [
                    'foo' => 'Fail 1',
                    'foo][bar' => 'Fail 2',
                ],
                [
                    'foo',
                    'bar',
                ],
                'Fail 1',
            ],
        ];
    }
    
    /**
     * @covers ::setErrorByName
     *
     * @dataProvider providerTestSetErrorByName
     */
    public function testSetErrorByName($limit_validation_errors, $expected_errors) : void {
        $form_state = new FormState();
        $form_state->setLimitValidationErrors($limit_validation_errors);
        $form_state->clearErrors();
        $form_state->setErrorByName('test', 'Fail 1');
        $form_state->setErrorByName('test', 'Fail 2');
        $form_state->setErrorByName('options');
        $this->assertSame(!empty($expected_errors), $form_state::hasAnyErrors());
        $this->assertSame($expected_errors, $form_state->getErrors());
    }
    public static function providerTestSetErrorByName() {
        return [
            // Only validate the 'options' element.
[
                [
                    [
                        'options',
                    ],
                ],
                [
                    'options' => '',
                ],
            ],
            // Do not limit a validation, ensure the first error is returned
            // for the 'test' element.
[
                NULL,
                [
                    'test' => 'Fail 1',
                    'options' => '',
                ],
            ],
            // Limit all validation.
[
                [],
                [],
            ],
        ];
    }
    
    /**
     * Tests that form errors during submission throw an exception.
     *
     * @covers ::setErrorByName
     */
    public function testFormErrorsDuringSubmission() : void {
        $form_state = new FormState();
        $form_state->setValidationComplete();
        $this->expectException(\LogicException::class);
        $this->expectExceptionMessage('Form errors cannot be set after form validation has finished.');
        $form_state->setErrorByName('test', 'message');
    }
    
    /**
     * @covers ::prepareCallback
     */
    public function testPrepareCallbackValidMethod() : void {
        $form_state = new FormState();
        $form_state->setFormObject(new PrepareCallbackTestForm());
        $processed_callback = $form_state->prepareCallback('::buildForm');
        $this->assertEquals([
            $form_state->getFormObject(),
            'buildForm',
        ], $processed_callback);
    }
    
    /**
     * @covers ::prepareCallback
     */
    public function testPrepareCallbackInValidMethod() : void {
        $form_state = new FormState();
        $form_state->setFormObject(new PrepareCallbackTestForm());
        $processed_callback = $form_state->prepareCallback('not_a_method');
        // The callback was not changed as no such method exists.
        $this->assertEquals('not_a_method', $processed_callback);
    }
    
    /**
     * @covers ::prepareCallback
     */
    public function testPrepareCallbackArray() : void {
        $form_state = new FormState();
        $form_state->setFormObject(new PrepareCallbackTestForm());
        $callback = [
            $form_state->getFormObject(),
            'buildForm',
        ];
        $processed_callback = $form_state->prepareCallback($callback);
        $this->assertEquals($callback, $processed_callback);
    }
    
    /**
     * @covers ::loadInclude
     */
    public function testLoadInclude() : void {
        $type = 'some_type';
        $module = 'some_module';
        $name = 'some_name';
        $form_state = $this->getMockBuilder('Drupal\\Core\\Form\\FormState')
            ->onlyMethods([
            'moduleLoadInclude',
        ])
            ->getMock();
        $form_state->expects($this->once())
            ->method('moduleLoadInclude')
            ->with($module, $type, $name)
            ->willReturn(TRUE);
        $this->assertTrue($form_state->loadInclude($module, $type, $name));
    }
    
    /**
     * @covers ::loadInclude
     */
    public function testLoadIncludeNoName() : void {
        $type = 'some_type';
        $module = 'some_module';
        $form_state = $this->getMockBuilder('Drupal\\Core\\Form\\FormState')
            ->onlyMethods([
            'moduleLoadInclude',
        ])
            ->getMock();
        $form_state->expects($this->once())
            ->method('moduleLoadInclude')
            ->with($module, $type, $module)
            ->willReturn(TRUE);
        $this->assertTrue($form_state->loadInclude($module, $type));
    }
    
    /**
     * @covers ::loadInclude
     */
    public function testLoadIncludeNotFound() : void {
        $type = 'some_type';
        $module = 'some_module';
        $form_state = $this->getMockBuilder('Drupal\\Core\\Form\\FormState')
            ->onlyMethods([
            'moduleLoadInclude',
        ])
            ->getMock();
        $form_state->expects($this->once())
            ->method('moduleLoadInclude')
            ->with($module, $type, $module)
            ->willReturn(FALSE);
        $this->assertFalse($form_state->loadInclude($module, $type));
    }
    
    /**
     * @covers ::loadInclude
     */
    public function testLoadIncludeAlreadyLoaded() : void {
        $type = 'some_type';
        $module = 'some_module';
        $name = 'some_name';
        $form_state = $this->getMockBuilder('Drupal\\Core\\Form\\FormState')
            ->onlyMethods([
            'moduleLoadInclude',
        ])
            ->getMock();
        $form_state->addBuildInfo('files', [
            'some_module:some_name.some_type' => [
                'type' => $type,
                'module' => $module,
                'name' => $name,
            ],
        ]);
        $form_state->expects($this->never())
            ->method('moduleLoadInclude');
        $this->assertFalse($form_state->loadInclude($module, $type, $name));
    }
    
    /**
     * @covers ::isCached
     *
     * @dataProvider providerTestIsCached
     */
    public function testIsCached($cache_key, $no_cache_key, $expected) : void {
        $form_state = (new FormState())->setFormState([
            'cache' => $cache_key,
            'no_cache' => $no_cache_key,
        ]);
        $form_state->setMethod('POST');
        $this->assertSame($expected, $form_state->isCached());
        $form_state->setMethod('GET');
        $this->assertSame($expected, $form_state->isCached());
    }
    
    /**
     * Provides test data for testIsCached().
     */
    public static function providerTestIsCached() {
        $data = [];
        $data[] = [
            TRUE,
            TRUE,
            FALSE,
        ];
        $data[] = [
            FALSE,
            TRUE,
            FALSE,
        ];
        $data[] = [
            FALSE,
            FALSE,
            FALSE,
        ];
        $data[] = [
            TRUE,
            FALSE,
            TRUE,
        ];
        $data[] = [
            TRUE,
            NULL,
            TRUE,
        ];
        $data[] = [
            FALSE,
            NULL,
            FALSE,
        ];
        return $data;
    }
    
    /**
     * @covers ::setCached
     */
    public function testSetCachedPost() : void {
        $form_state = new FormState();
        $form_state->setRequestMethod('POST');
        $form_state->setCached();
        $this->assertTrue($form_state->isCached());
    }
    
    /**
     * @covers ::setCached
     */
    public function testSetCachedGet() : void {
        $form_state = new FormState();
        $form_state->setRequestMethod('GET');
        $this->expectException(\LogicException::class);
        $this->expectExceptionMessage('Form state caching on GET requests is not allowed.');
        $form_state->setCached();
    }
    
    /**
     * @covers ::isMethodType
     * @covers ::setMethod
     *
     * @dataProvider providerTestIsMethodType
     */
    public function testIsMethodType($set_method_type, $input, $expected) : void {
        $form_state = (new FormState())->setMethod($set_method_type);
        $this->assertSame($expected, $form_state->isMethodType($input));
    }
    
    /**
     * Provides test data for testIsMethodType().
     */
    public static function providerTestIsMethodType() {
        $data = [];
        $data[] = [
            'get',
            'get',
            TRUE,
        ];
        $data[] = [
            'get',
            'GET',
            TRUE,
        ];
        $data[] = [
            'GET',
            'GET',
            TRUE,
        ];
        $data[] = [
            'post',
            'get',
            FALSE,
        ];
        return $data;
    }
    
    /**
     * @covers ::getTemporaryValue
     * @covers ::hasTemporaryValue
     * @covers ::setTemporaryValue
     */
    public function testTemporaryValue() : void {
        $form_state = new FormState();
        $this->assertFalse($form_state->hasTemporaryValue('rainbow_sparkles'));
        $form_state->setTemporaryValue('rainbow_sparkles', 'yes');
        $this->assertSame($form_state->getTemporaryValue('rainbow_sparkles'), 'yes');
        $this->assertTrue($form_state->hasTemporaryValue('rainbow_sparkles'));
        $form_state->setTemporaryValue([
            'rainbow_sparkles',
            'magic_ponies',
        ], 'yes');
        $this->assertSame($form_state->getTemporaryValue([
            'rainbow_sparkles',
            'magic_ponies',
        ]), 'yes');
        $this->assertTrue($form_state->hasTemporaryValue([
            'rainbow_sparkles',
            'magic_ponies',
        ]));
    }
    
    /**
     * @covers ::getCleanValueKeys
     */
    public function testGetCleanValueKeys() : void {
        $form_state = new FormState();
        $this->assertSame($form_state->getCleanValueKeys(), [
            'form_id',
            'form_token',
            'form_build_id',
            'op',
        ]);
    }
    
    /**
     * @covers ::setCleanValueKeys
     */
    public function testSetCleanValueKeys() : void {
        $form_state = new FormState();
        $form_state->setCleanValueKeys([
            'key1',
            'key2',
        ]);
        $this->assertSame($form_state->getCleanValueKeys(), [
            'key1',
            'key2',
        ]);
    }
    
    /**
     * @covers ::addCleanValueKey
     */
    public function testAddCleanValueKey() {
        $form_state = new FormState();
        $form_state->setValue('value_to_clean', 'rainbow_sprinkles');
        $form_state->addCleanValueKey('value_to_clean');
        $this->assertSame($form_state->getCleanValueKeys(), [
            'form_id',
            'form_token',
            'form_build_id',
            'op',
            'value_to_clean',
        ]);
        return $form_state;
    }
    
    /**
     * @depends testAddCleanValueKey
     *
     * @covers ::cleanValues
     */
    public function testCleanValues($form_state) : void {
        $form_state->setValue('value_to_keep', 'magic_ponies');
        $this->assertSame($form_state->cleanValues()
            ->getValues(), [
            'value_to_keep' => 'magic_ponies',
        ]);
    }
    
    /**
     * @covers ::setValues
     * @covers ::getValues
     */
    public function testGetValues() : void {
        $values = [
            'foo' => 'bar',
        ];
        $form_state = new FormState();
        $form_state->setValues($values);
        $this->assertSame($values, $form_state->getValues());
    }

}

Members

Title Sort descending Modifiers Object type Summary Overrides
ExpectDeprecationTrait::expectDeprecation public function Adds an expected deprecation.
ExpectDeprecationTrait::getCallableName private static function Returns a callable as a string suitable for inclusion in a message.
ExpectDeprecationTrait::setUpErrorHandler public function Sets up the test error handler.
ExpectDeprecationTrait::tearDownErrorHandler public function Tears down the test error handler.
FormStateTest::providerTestGetError public static function
FormStateTest::providerTestGetRedirect public static function Provides test data for testing the getRedirect() method.
FormStateTest::providerTestIsCached public static function Provides test data for testIsCached().
FormStateTest::providerTestIsMethodType public static function Provides test data for testIsMethodType().
FormStateTest::providerTestSetErrorByName public static function
FormStateTest::testAddCleanValueKey public function @covers ::addCleanValueKey
FormStateTest::testCleanValues public function @depends testAddCleanValueKey
FormStateTest::testFormErrorsDuringSubmission public function Tests that form errors during submission throw an exception.
FormStateTest::testGetCleanValueKeys public function @covers ::getCleanValueKeys
FormStateTest::testGetError public function Tests the getError() method.
FormStateTest::testGetRedirect public function Tests the getRedirect() method.
FormStateTest::testGetValues public function @covers ::setValues
@covers ::getValues
FormStateTest::testIsCached public function @covers ::isCached
FormStateTest::testIsMethodType public function @covers ::isMethodType
@covers ::setMethod
FormStateTest::testLoadInclude public function @covers ::loadInclude
FormStateTest::testLoadIncludeAlreadyLoaded public function @covers ::loadInclude
FormStateTest::testLoadIncludeNoName public function @covers ::loadInclude
FormStateTest::testLoadIncludeNotFound public function @covers ::loadInclude
FormStateTest::testPrepareCallbackArray public function @covers ::prepareCallback
FormStateTest::testPrepareCallbackInValidMethod public function @covers ::prepareCallback
FormStateTest::testPrepareCallbackValidMethod public function @covers ::prepareCallback
FormStateTest::testSetCachedGet public function @covers ::setCached
FormStateTest::testSetCachedPost public function @covers ::setCached
FormStateTest::testSetCleanValueKeys public function @covers ::setCleanValueKeys
FormStateTest::testSetError public function Tests the setError() method.
FormStateTest::testSetErrorByName public function @covers ::setErrorByName
FormStateTest::testTemporaryValue public function @covers ::getTemporaryValue
@covers ::hasTemporaryValue
@covers ::setTemporaryValue
RandomGeneratorTrait::getRandomGenerator protected function Gets the random generator for the utility methods.
RandomGeneratorTrait::randomMachineName protected function Generates a unique random string containing letters and numbers.
RandomGeneratorTrait::randomObject public function Generates a random PHP object.
RandomGeneratorTrait::randomString public function Generates a pseudo-random string of ASCII characters of codes 32 to 126.
UnitTestCase::$root protected property The app root.
UnitTestCase::getClassResolverStub protected function Returns a stub class resolver.
UnitTestCase::getConfigFactoryStub public function Returns a stub config factory that behaves according to the passed array.
UnitTestCase::getConfigStorageStub public function Returns a stub config storage that returns the supplied configuration.
UnitTestCase::getContainerWithCacheTagsInvalidator protected function Sets up a container with a cache tags invalidator.
UnitTestCase::getStringTranslationStub public function Returns a stub translation manager that just returns the passed string.
UnitTestCase::setUp protected function 367
UnitTestCase::setUpBeforeClass public static function

Buggy or inaccurate documentation? Please file an issue. Need support? Need help programming? Connect with the Drupal community.