class FormTest

Same name in this branch
  1. 10 core/modules/system/tests/src/Functional/Form/FormTest.php \Drupal\Tests\system\Functional\Form\FormTest
Same name in other branches
  1. 9 core/modules/field/tests/src/Functional/FormTest.php \Drupal\Tests\field\Functional\FormTest
  2. 9 core/modules/system/tests/src/Functional/Form/FormTest.php \Drupal\Tests\system\Functional\Form\FormTest
  3. 8.9.x core/modules/field/tests/src/Functional/FormTest.php \Drupal\Tests\field\Functional\FormTest
  4. 8.9.x core/modules/system/tests/src/Functional/Form/FormTest.php \Drupal\Tests\system\Functional\Form\FormTest
  5. 11.x core/modules/field/tests/src/Functional/FormTest.php \Drupal\Tests\field\Functional\FormTest
  6. 11.x core/modules/system/tests/src/Functional/Form/FormTest.php \Drupal\Tests\system\Functional\Form\FormTest

Tests field form handling.

@group field

Hierarchy

Expanded class hierarchy of FormTest

File

core/modules/field/tests/src/Functional/FormTest.php, line 21

Namespace

Drupal\Tests\field\Functional
View source
class FormTest extends FieldTestBase {
    
    /**
     * Modules to install.
     *
     * Locale is installed so that TranslatableMarkup actually does something.
     *
     * @var array
     */
    protected static $modules = [
        'field_test',
        'options',
        'entity_test',
        'locale',
        'field_ui',
    ];
    
    /**
     * {@inheritdoc}
     */
    protected $defaultTheme = 'stark';
    
    /**
     * An array of values defining a field single.
     *
     * @var array
     */
    protected $fieldStorageSingle;
    
    /**
     * An array of values defining a field with unlimited cardinality.
     *
     * @var array
     */
    protected $fieldStorageUnlimited;
    
    /**
     * An array of values defining a field.
     *
     * @var array
     */
    protected $field;
    
    /**
     * {@inheritdoc}
     */
    protected function setUp() : void {
        parent::setUp();
        $web_user = $this->drupalCreateUser([
            'view test entity',
            'administer entity_test content',
            'administer entity_test fields',
        ]);
        $this->drupalLogin($web_user);
        $this->fieldStorageSingle = [
            'field_name' => 'field_single',
            'entity_type' => 'entity_test',
            'type' => 'test_field',
        ];
        $this->fieldStorageUnlimited = [
            'field_name' => 'field_unlimited',
            'entity_type' => 'entity_test',
            'type' => 'test_field',
            'cardinality' => FieldStorageDefinitionInterface::CARDINALITY_UNLIMITED,
        ];
        $this->field = [
            'entity_type' => 'entity_test',
            'bundle' => 'entity_test',
            'label' => $this->randomMachineName() . '_label',
            'description' => '[site:name]_description',
            'weight' => mt_rand(0, 127),
            'settings' => [
                'test_field_setting' => $this->randomMachineName(),
            ],
        ];
    }
    public function testFieldFormSingle() : void {
        $field_storage = $this->fieldStorageSingle;
        $field_name = $field_storage['field_name'];
        $this->field['field_name'] = $field_name;
        FieldStorageConfig::create($field_storage)->save();
        FieldConfig::create($this->field)
            ->save();
        \Drupal::service('entity_display.repository')->getFormDisplay($this->field['entity_type'], $this->field['bundle'])
            ->setComponent($field_name)
            ->save();
        // Display creation form.
        $this->drupalGet('entity_test/add');
        // Create token value expected for description.
        $token_description = Html::escape($this->config('system.site')
            ->get('name')) . '_description';
        $this->assertSession()
            ->pageTextContains($token_description);
        $this->assertSession()
            ->fieldValueEquals("{$field_name}[0][value]", '');
        // Verify that no extraneous widget is displayed.
        $this->assertSession()
            ->fieldNotExists("{$field_name}[1][value]");
        // Check that hook_field_widget_single_element_form_alter() does not believe
        // this is the default value form.
        $this->assertSession()
            ->pageTextNotContains('From hook_field_widget_single_element_form_alter(): Default form is true.');
        // Check that hook_field_widget_single_element_form_alter() does not believe
        // this is the default value form.
        $this->assertSession()
            ->pageTextNotContains('From hook_field_widget_complete_form_alter(): Default form is true.');
        // Submit with invalid value (field-level validation).
        $edit = [
            "{$field_name}[0][value]" => -1,
        ];
        $this->submitForm($edit, 'Save');
        $this->assertSession()
            ->pageTextContains("{$this->field['label']} does not accept the value -1.");
        // @todo check that the correct field is flagged for error.
        // Create an entity
        $value = mt_rand(1, 127);
        $edit = [
            "{$field_name}[0][value]" => $value,
        ];
        $this->submitForm($edit, 'Save');
        preg_match('|entity_test/manage/(\\d+)|', $this->getUrl(), $match);
        $id = $match[1];
        $this->assertSession()
            ->pageTextContains('entity_test ' . $id . ' has been created.');
        $entity = EntityTest::load($id);
        $this->assertEquals($value, $entity->{$field_name}->value, 'Field value was saved');
        // Display edit form.
        $this->drupalGet('entity_test/manage/' . $id . '/edit');
        // Check that the widget is displayed with the correct default value.
        $this->assertSession()
            ->fieldValueEquals("{$field_name}[0][value]", $value);
        // Verify that no extraneous widget is displayed.
        $this->assertSession()
            ->fieldNotExists("{$field_name}[1][value]");
        // Update the entity.
        $value = mt_rand(1, 127);
        $edit = [
            "{$field_name}[0][value]" => $value,
        ];
        $this->submitForm($edit, 'Save');
        $this->assertSession()
            ->pageTextContains('entity_test ' . $id . ' has been updated.');
        $this->container
            ->get('entity_type.manager')
            ->getStorage('entity_test')
            ->resetCache([
            $id,
        ]);
        $entity = EntityTest::load($id);
        $this->assertEquals($value, $entity->{$field_name}->value, 'Field value was updated');
        // Empty the field.
        $value = '';
        $edit = [
            "{$field_name}[0][value]" => $value,
        ];
        $this->drupalGet('entity_test/manage/' . $id . '/edit');
        $this->submitForm($edit, 'Save');
        $this->assertSession()
            ->pageTextContains('entity_test ' . $id . ' has been updated.');
        $this->container
            ->get('entity_type.manager')
            ->getStorage('entity_test')
            ->resetCache([
            $id,
        ]);
        $entity = EntityTest::load($id);
        $this->assertTrue($entity->{$field_name}
            ->isEmpty(), 'Field was emptied');
    }
    
    /**
     * Tests field widget default values on entity forms.
     */
    public function testFieldFormDefaultValue() : void {
        $field_storage = $this->fieldStorageSingle;
        $field_name = $field_storage['field_name'];
        $this->field['field_name'] = $field_name;
        $default = rand(1, 127);
        $this->field['default_value'] = [
            [
                'value' => $default,
            ],
        ];
        FieldStorageConfig::create($field_storage)->save();
        FieldConfig::create($this->field)
            ->save();
        \Drupal::service('entity_display.repository')->getFormDisplay($this->field['entity_type'], $this->field['bundle'])
            ->setComponent($field_name)
            ->save();
        // Display creation form.
        $this->drupalGet('entity_test/add');
        // Test that the default value is displayed correctly.
        $this->assertSession()
            ->fieldValueEquals("{$field_name}[0][value]", $default);
        // Try to submit an empty value.
        $edit = [
            "{$field_name}[0][value]" => '',
        ];
        $this->submitForm($edit, 'Save');
        preg_match('|entity_test/manage/(\\d+)|', $this->getUrl(), $match);
        $id = $match[1];
        $this->assertSession()
            ->pageTextContains('entity_test ' . $id . ' has been created.');
        $entity = EntityTest::load($id);
        $this->assertTrue($entity->{$field_name}
            ->isEmpty(), 'Field is now empty.');
    }
    public function testFieldFormSingleRequired() : void {
        $field_storage = $this->fieldStorageSingle;
        $field_name = $field_storage['field_name'];
        $this->field['field_name'] = $field_name;
        $this->field['required'] = TRUE;
        FieldStorageConfig::create($field_storage)->save();
        FieldConfig::create($this->field)
            ->save();
        \Drupal::service('entity_display.repository')->getFormDisplay($this->field['entity_type'], $this->field['bundle'])
            ->setComponent($field_name)
            ->save();
        // Submit with missing required value.
        $edit = [];
        $this->drupalGet('entity_test/add');
        $this->submitForm($edit, 'Save');
        $this->assertSession()
            ->pageTextContains("{$this->field['label']} field is required.");
        // Create an entity
        $value = mt_rand(1, 127);
        $edit = [
            "{$field_name}[0][value]" => $value,
        ];
        $this->submitForm($edit, 'Save');
        preg_match('|entity_test/manage/(\\d+)|', $this->getUrl(), $match);
        $id = $match[1];
        $this->assertSession()
            ->pageTextContains('entity_test ' . $id . ' has been created.');
        $entity = EntityTest::load($id);
        $this->assertEquals($value, $entity->{$field_name}->value, 'Field value was saved');
        // Edit with missing required value.
        $value = '';
        $edit = [
            "{$field_name}[0][value]" => $value,
        ];
        $this->drupalGet('entity_test/manage/' . $id . '/edit');
        $this->submitForm($edit, 'Save');
        $this->assertSession()
            ->pageTextContains("{$this->field['label']} field is required.");
    }
    public function testFieldFormUnlimited() : void {
        $field_storage = $this->fieldStorageUnlimited;
        $field_name = $field_storage['field_name'];
        $this->field['field_name'] = $field_name;
        FieldStorageConfig::create($field_storage)->save();
        FieldConfig::create($this->field)
            ->save();
        \Drupal::service('entity_display.repository')->getFormDisplay($this->field['entity_type'], $this->field['bundle'])
            ->setComponent($field_name)
            ->save();
        // Verify that only one "Default value" field
        // exists on the Manage field display.
        $this->drupalGet("entity_test/structure/entity_test/fields/entity_test.entity_test.{$field_name}");
        $this->assertSession()
            ->elementsCount('xpath', "//table[@id='field-unlimited-values']/tbody/tr//input[contains(@class, 'form-text')]", 1);
        // Display creation form -> 1 widget.
        $this->drupalGet('entity_test/add');
        $this->assertSession()
            ->fieldValueEquals("{$field_name}[0][value]", '');
        // Verify that no extraneous widget is displayed.
        $this->assertSession()
            ->fieldNotExists("{$field_name}[1][value]");
        // Check if aria-describedby attribute is placed on multiple value widgets.
        $this->assertSession()
            ->elementAttributeContains('xpath', '//table[@id="field-unlimited-values"]', 'aria-describedby', 'edit-field-unlimited--description');
        // Press 'add more' button -> 2 widgets.
        $this->submitForm([], 'Add another item');
        $this->assertSession()
            ->fieldValueEquals("{$field_name}[0][value]", '');
        $this->assertSession()
            ->fieldValueEquals("{$field_name}[1][value]", '');
        // Verify that no extraneous widget is displayed.
        $this->assertSession()
            ->fieldNotExists("{$field_name}[2][value]");
        // @todo check that non-field inputs are preserved ('title'), etc.
        // Yet another time so that we can play with more values -> 3 widgets.
        $this->submitForm([], 'Add another item');
        // Prepare values and weights.
        $count = 3;
        $delta_range = $count - 1;
        $values = $weights = $pattern = $expected_values = [];
        $edit = [];
        for ($delta = 0; $delta <= $delta_range; $delta++) {
            // Assign unique random values and weights.
            do {
                $value = mt_rand(1, 127);
            } while (in_array($value, $values));
            do {
                $weight = mt_rand(-$delta_range, $delta_range);
            } while (in_array($weight, $weights));
            $edit["{$field_name}[{$delta}][value]"] = $value;
            $edit["{$field_name}[{$delta}][_weight]"] = $weight;
            // We'll need three slightly different formats to check the values.
            $values[$delta] = $value;
            $weights[$delta] = $weight;
            $field_values[$weight]['value'] = (string) $value;
            $pattern[$weight] = "<input [^>]*value=\"{$value}\" [^>]*";
        }
        // Press 'add more' button -> 4 widgets
        $this->submitForm($edit, 'Add another item');
        for ($delta = 0; $delta <= $delta_range; $delta++) {
            $this->assertSession()
                ->fieldValueEquals("{$field_name}[{$delta}][value]", $values[$delta]);
            $this->assertSession()
                ->fieldValueEquals("{$field_name}[{$delta}][_weight]", $weights[$delta]);
        }
        ksort($pattern);
        $pattern = implode('.*', array_values($pattern));
        // Verify that the widgets are displayed in the correct order.
        $this->assertSession()
            ->responseMatches("|{$pattern}|s");
        $this->assertSession()
            ->fieldValueEquals("{$field_name}[{$delta}][value]", '');
        $this->assertSession()
            ->fieldValueEquals("{$field_name}[{$delta}][_weight]", $delta);
        // Verify that no extraneous widget is displayed.
        $this->assertSession()
            ->fieldNotExists("{$field_name}[" . ($delta + 1) . '][value]');
        // Submit the form and create the entity.
        $this->submitForm($edit, 'Save');
        preg_match('|entity_test/manage/(\\d+)|', $this->getUrl(), $match);
        $id = $match[1];
        $this->assertSession()
            ->pageTextContains('entity_test ' . $id . ' has been created.');
        $entity = EntityTest::load($id);
        ksort($field_values);
        $field_values = array_values($field_values);
        $this->assertSame($field_values, $entity->{$field_name}
            ->getValue(), 'Field values were saved in the correct order');
        // Display edit form: check that the expected number of widgets is
        // displayed, with correct values change values, reorder, leave an empty
        // value in the middle.
        // Submit: check that the entity is updated with correct values
        // Re-submit: check that the field can be emptied.
        // Test with several multiple fields in a form
    }
    
    /**
     * Tests the position of the required label.
     */
    public function testFieldFormUnlimitedRequired() : void {
        $field_name = $this->fieldStorageUnlimited['field_name'];
        $this->field['field_name'] = $field_name;
        $this->field['required'] = TRUE;
        FieldStorageConfig::create($this->fieldStorageUnlimited)
            ->save();
        FieldConfig::create($this->field)
            ->save();
        \Drupal::service('entity_display.repository')->getFormDisplay($this->field['entity_type'], $this->field['bundle'])
            ->setComponent($field_name)
            ->save();
        // Display creation form -> 1 widget.
        $this->drupalGet('entity_test/add');
        // Check that the Required symbol is present for the label of the field
        // with unlimited cardinality.
        $this->assertSession()
            ->elementAttributeContains('xpath', "//h4[contains(@class, 'label') and contains(text(), '{$this->field['label']}')]", 'class', 'js-form-required');
        // Check that the label of the field input is visually hidden and contains
        // the field title and an indication of the delta for a11y.
        $this->assertSession()
            ->elementExists('xpath', "//label[@for='edit-field-unlimited-0-value' and contains(@class, 'visually-hidden') and contains(text(), '{$this->field['label']} (value 1)')]");
    }
    
    /**
     * Tests widget handling of multiple required radios.
     */
    public function testFieldFormMultivalueWithRequiredRadio() : void {
        
        /** @var \Drupal\Core\Entity\EntityDisplayRepositoryInterface $display_repository */
        $display_repository = \Drupal::service('entity_display.repository');
        // Create a multivalue test field.
        $field_storage = $this->fieldStorageUnlimited;
        $field_name = $field_storage['field_name'];
        $this->field['field_name'] = $field_name;
        FieldStorageConfig::create($field_storage)->save();
        FieldConfig::create($this->field)
            ->save();
        $display_repository->getFormDisplay($this->field['entity_type'], $this->field['bundle'])
            ->setComponent($field_name)
            ->save();
        // Add a required radio field.
        FieldStorageConfig::create([
            'field_name' => 'required_radio_test',
            'entity_type' => 'entity_test',
            'type' => 'list_string',
            'settings' => [
                'allowed_values' => [
                    'yes' => 'yes',
                    'no' => 'no',
                ],
            ],
        ])->save();
        $field = [
            'field_name' => 'required_radio_test',
            'entity_type' => 'entity_test',
            'bundle' => 'entity_test',
            'required' => TRUE,
        ];
        FieldConfig::create($field)->save();
        $display_repository->getFormDisplay($field['entity_type'], $field['bundle'])
            ->setComponent($field['field_name'], [
            'type' => 'options_buttons',
        ])
            ->save();
        // Display creation form.
        $this->drupalGet('entity_test/add');
        // Press the 'Add more' button.
        $this->submitForm([], 'Add another item');
        // Verify that no error is thrown by the radio element.
        $this->assertSession()
            ->elementNotExists('xpath', '//div[contains(@class, "error")]');
        // Verify that the widget is added.
        $this->assertSession()
            ->fieldValueEquals("{$field_name}[0][value]", '');
        $this->assertSession()
            ->fieldValueEquals("{$field_name}[1][value]", '');
        // Verify that no extraneous widget is displayed.
        $this->assertSession()
            ->fieldNotExists("{$field_name}[2][value]");
    }
    
    /**
     * Tests fields with no 'edit' access.
     */
    public function testFieldFormAccess() : void {
        
        /** @var \Drupal\Core\Entity\EntityDisplayRepositoryInterface $display_repository */
        $display_repository = \Drupal::service('entity_display.repository');
        $entity_type = 'entity_test_rev';
        // Create a "regular" field.
        $field_storage = $this->fieldStorageSingle;
        $field_storage['entity_type'] = $entity_type;
        $field_name = $field_storage['field_name'];
        $field = $this->field;
        $field['field_name'] = $field_name;
        $field['entity_type'] = $entity_type;
        $field['bundle'] = $entity_type;
        FieldStorageConfig::create($field_storage)->save();
        FieldConfig::create($field)->save();
        $display_repository->getFormDisplay($entity_type, $entity_type)
            ->setComponent($field_name)
            ->save();
        // Create a field with no edit access. See
        // field_test_entity_field_access().
        $field_storage_no_access = [
            'field_name' => 'field_no_edit_access',
            'entity_type' => $entity_type,
            'type' => 'test_field',
        ];
        $field_name_no_access = $field_storage_no_access['field_name'];
        $field_no_access = [
            'field_name' => $field_name_no_access,
            'entity_type' => $entity_type,
            'bundle' => $entity_type,
            'default_value' => [
                0 => [
                    'value' => 99,
                ],
            ],
        ];
        FieldStorageConfig::create($field_storage_no_access)->save();
        FieldConfig::create($field_no_access)->save();
        $display_repository->getFormDisplay($field_no_access['entity_type'], $field_no_access['bundle'])
            ->setComponent($field_name_no_access)
            ->save();
        // Test that the form structure includes full information for each delta
        // apart from #access.
        $entity = $this->container
            ->get('entity_type.manager')
            ->getStorage($entity_type)
            ->create([
            'id' => 0,
            'revision_id' => 0,
        ]);
        $display = $display_repository->getFormDisplay($entity_type, $entity_type);
        $form = [];
        $form_state = new FormState();
        $display->buildForm($entity, $form, $form_state);
        $this->assertFalse($form[$field_name_no_access]['#access'], 'Field #access is FALSE for the field without edit access.');
        // Display creation form.
        $this->drupalGet($entity_type . '/add');
        // Check that the widget is not displayed if field access is denied.
        $this->assertSession()
            ->fieldNotExists("{$field_name_no_access}[0][value]");
        // Create entity.
        $edit = [
            "{$field_name}[0][value]" => 1,
        ];
        $this->submitForm($edit, 'Save');
        preg_match("|{$entity_type}/manage/(\\d+)|", $this->getUrl(), $match);
        $id = $match[1];
        // Check that the default value was saved.
        $storage = $this->container
            ->get('entity_type.manager')
            ->getStorage($entity_type);
        $entity = $storage->load($id);
        $this->assertEquals(99, $entity->{$field_name_no_access}->value, 'Default value was saved for the field with no edit access.');
        $this->assertEquals(1, $entity->{$field_name}->value, 'Entered value vas saved for the field with edit access.');
        // Create a new revision.
        $edit = [
            "{$field_name}[0][value]" => 2,
            'revision' => TRUE,
        ];
        $this->drupalGet($entity_type . '/manage/' . $id . '/edit');
        $this->submitForm($edit, 'Save');
        // Check that the new revision has the expected values.
        $storage->resetCache([
            $id,
        ]);
        $entity = $storage->load($id);
        $this->assertEquals(99, $entity->{$field_name_no_access}->value, 'New revision has the expected value for the field with no edit access.');
        $this->assertEquals(2, $entity->{$field_name}->value, 'New revision has the expected value for the field with edit access.');
        // Check that the revision is also saved in the revisions table.
        
        /** @var \Drupal\Core\Entity\RevisionableStorageInterface $storage */
        $storage = $this->container
            ->get('entity_type.manager')
            ->getStorage($entity_type);
        $entity = $storage->loadRevision($entity->getRevisionId());
        $this->assertEquals(99, $entity->{$field_name_no_access}->value, 'New revision has the expected value for the field with no edit access.');
        $this->assertEquals(2, $entity->{$field_name}->value, 'New revision has the expected value for the field with edit access.');
    }
    
    /**
     * Tests hiding a field in a form.
     */
    public function testHiddenField() : void {
        $entity_type = 'entity_test_rev';
        $field_storage = $this->fieldStorageSingle;
        $field_storage['entity_type'] = $entity_type;
        $field_name = $field_storage['field_name'];
        $this->field['field_name'] = $field_name;
        $this->field['default_value'] = [
            0 => [
                'value' => 99,
            ],
        ];
        $this->field['entity_type'] = $entity_type;
        $this->field['bundle'] = $entity_type;
        FieldStorageConfig::create($field_storage)->save();
        $this->field = FieldConfig::create($this->field);
        $this->field
            ->save();
        // We explicitly do not assign a widget in a form display, so the field
        // stays hidden in forms.
        // Display the entity creation form.
        $this->drupalGet($entity_type . '/add');
        // Create an entity and test that the default value is assigned correctly to
        // the field that uses the hidden widget.
        $this->assertSession()
            ->fieldNotExists("{$field_name}[0][value]");
        $this->submitForm([], 'Save');
        preg_match('|' . $entity_type . '/manage/(\\d+)|', $this->getUrl(), $match);
        $id = $match[1];
        $this->assertSession()
            ->pageTextContains('entity_test_rev ' . $id . ' has been created.');
        $storage = $this->container
            ->get('entity_type.manager')
            ->getStorage($entity_type);
        $entity = $storage->load($id);
        $this->assertEquals(99, $entity->{$field_name}->value, 'Default value was saved');
        // Update the field to remove the default value, and switch to the default
        // widget.
        $this->field
            ->setDefaultValue([]);
        $this->field
            ->save();
        \Drupal::service('entity_display.repository')->getFormDisplay($entity_type, $this->field
            ->getTargetBundle())
            ->setComponent($this->field
            ->getName(), [
            'type' => 'test_field_widget',
        ])
            ->save();
        // Display edit form.
        $this->drupalGet($entity_type . '/manage/' . $id . '/edit');
        $this->assertSession()
            ->fieldValueEquals("{$field_name}[0][value]", 99);
        // Update the entity.
        $value = mt_rand(1, 127);
        $edit = [
            "{$field_name}[0][value]" => $value,
        ];
        $this->submitForm($edit, 'Save');
        $this->assertSession()
            ->pageTextContains('entity_test_rev ' . $id . ' has been updated.');
        $storage->resetCache([
            $id,
        ]);
        $entity = $storage->load($id);
        $this->assertEquals($value, $entity->{$field_name}->value, 'Field value was updated');
        // Set the field back to hidden.
        \Drupal::service('entity_display.repository')->getFormDisplay($entity_type, $this->field
            ->getTargetBundle())
            ->removeComponent($this->field
            ->getName())
            ->save();
        // Create a new revision.
        $edit = [
            'revision' => TRUE,
        ];
        $this->drupalGet($entity_type . '/manage/' . $id . '/edit');
        $this->submitForm($edit, 'Save');
        // Check that the expected value has been carried over to the new revision.
        $storage->resetCache([
            $id,
        ]);
        $entity = $storage->load($id);
        $this->assertEquals($value, $entity->{$field_name}->value, 'New revision has the expected value for the field with the Hidden widget');
    }
    
    /**
     * Tests the form display of the label for multi-value fields.
     */
    public function testLabelOnMultiValueFields() : void {
        $user = $this->drupalCreateUser([
            'administer entity_test content',
        ]);
        $this->drupalLogin($user);
        // Ensure that the 'bar' bundle exists, to avoid config validation errors.
        entity_test_create_bundle('bar', entity_type: 'entity_test_base_field_display');
        FieldStorageConfig::create([
            'entity_type' => 'entity_test_base_field_display',
            'field_name' => 'foo',
            'type' => 'text',
            'cardinality' => FieldStorageConfig::CARDINALITY_UNLIMITED,
        ])->save();
        FieldConfig::create([
            'entity_type' => 'entity_test_base_field_display',
            'bundle' => 'bar',
            'field_name' => 'foo',
            // Set a dangerous label to test XSS filtering.
'label' => "<script>alert('a configurable field');</script>",
        ])->save();
        EntityFormDisplay::create([
            'targetEntityType' => 'entity_test_base_field_display',
            'bundle' => 'bar',
            'mode' => 'default',
        ])->setComponent('foo', [
            'type' => 'text_textfield',
        ])
            ->enable()
            ->save();
        $entity = EntityTestBaseFieldDisplay::create([
            'type' => 'bar',
        ]);
        $entity->save();
        $this->drupalGet('entity_test_base_field_display/manage/' . $entity->id());
        $this->assertSession()
            ->statusCodeEquals(200);
        $this->assertSession()
            ->pageTextContains('A field with multiple values');
        // Test if labels were XSS filtered.
        $this->assertSession()
            ->assertEscaped("<script>alert('a configurable field');</script>");
    }

}

Members

Title Sort descending Deprecated Modifiers Object type Summary Member alias Overriden Title Overrides
BlockCreationTrait::placeBlock protected function Creates a block instance based on default settings. Aliased as: drupalPlaceBlock
BrowserHtmlDebugTrait::$htmlOutputBaseUrl protected property The Base URI to use for links to the output files.
BrowserHtmlDebugTrait::$htmlOutputClassName protected property Class name for HTML output logging.
BrowserHtmlDebugTrait::$htmlOutputCounter protected property Counter for HTML output logging.
BrowserHtmlDebugTrait::$htmlOutputCounterStorage protected property Counter storage for HTML output logging.
BrowserHtmlDebugTrait::$htmlOutputDirectory protected property Directory name for HTML output logging.
BrowserHtmlDebugTrait::$htmlOutputEnabled protected property HTML output enabled.
BrowserHtmlDebugTrait::$htmlOutputFile protected property The file name to write the list of URLs to.
BrowserHtmlDebugTrait::$htmlOutputTestId protected property HTML output test ID.
BrowserHtmlDebugTrait::formatHtmlOutputHeaders protected function Formats HTTP headers as string for HTML output logging.
BrowserHtmlDebugTrait::getHtmlOutputHeaders protected function Returns headers in HTML output format. 1
BrowserHtmlDebugTrait::getResponseLogHandler protected function Provides a Guzzle middleware handler to log every response received.
BrowserHtmlDebugTrait::htmlOutput protected function Logs a HTML output message in a text file.
BrowserHtmlDebugTrait::initBrowserOutputFile protected function Creates the directory to store browser output.
BrowserTestBase::$baseUrl protected property The base URL.
BrowserTestBase::$configImporter protected property The config importer that can be used in a test.
BrowserTestBase::$customTranslations protected property An array of custom translations suitable for SettingsEditor::rewrite().
BrowserTestBase::$mink protected property Mink session manager.
BrowserTestBase::$minkDefaultDriverArgs protected property Mink default driver params.
BrowserTestBase::$minkDefaultDriverClass protected property Mink class for the default driver to use. 1
BrowserTestBase::$originalContainer protected property The original container.
BrowserTestBase::$originalShutdownCallbacks protected property The original array of shutdown function callbacks.
BrowserTestBase::$preserveGlobalState protected property
BrowserTestBase::$profile protected property The profile to install as a basis for testing. 40
BrowserTestBase::$runTestInSeparateProcess protected property Browser tests are run in separate processes to prevent collisions between
code that may be loaded by tests.
BrowserTestBase::$timeLimit protected property Time limit in seconds for the test.
BrowserTestBase::$translationFilesDirectory protected property The translation file directory for the test environment.
BrowserTestBase::cleanupEnvironment protected function Clean up the test environment.
BrowserTestBase::config protected function Configuration accessor for tests. Returns non-overridden configuration.
BrowserTestBase::filePreDeleteCallback public static function Ensures test files are deletable.
BrowserTestBase::getDefaultDriverInstance protected function Gets an instance of the default Mink driver.
BrowserTestBase::getDrupalSettings protected function Gets the JavaScript drupalSettings variable for the currently-loaded page. 1
BrowserTestBase::getHttpClient protected function Obtain the HTTP client for the system under test.
BrowserTestBase::getMinkDriverArgs protected function Gets the Mink driver args from an environment variable. 1
BrowserTestBase::getOptions protected function Helper function to get the options of select field.
BrowserTestBase::getSession public function Returns Mink session.
BrowserTestBase::getSessionCookies protected function Get session cookies from current session.
BrowserTestBase::getTestMethodCaller protected function Retrieves the current calling line in the class under test. Overrides BrowserHtmlDebugTrait::getTestMethodCaller
BrowserTestBase::initFrontPage protected function Visits the front page when initializing Mink. 3
BrowserTestBase::initMink protected function Initializes Mink sessions. 1
BrowserTestBase::installDrupal public function Installs Drupal into the test site. 2
BrowserTestBase::registerSessions protected function Registers additional Mink sessions.
BrowserTestBase::setUpAppRoot protected function Sets up the root application path.
BrowserTestBase::setUpBeforeClass public static function 1
BrowserTestBase::tearDown protected function 3
BrowserTestBase::translatePostValues protected function Transforms a nested array into a flat array suitable for submitForm().
BrowserTestBase::xpath protected function Performs an xpath search on the contents of the internal browser.
BrowserTestBase::__get public function
BrowserTestBase::__sleep public function Prevents serializing any properties.
ConfigTestTrait::configImporter protected function Returns a ConfigImporter object to import test configuration.
ConfigTestTrait::copyConfig protected function Copies configuration objects from source storage to target storage.
ContentTypeCreationTrait::createContentType protected function Creates a custom content type based on default settings. Aliased as: drupalCreateContentType 1
ExtensionListTestTrait::getModulePath protected function Gets the path for the specified module.
ExtensionListTestTrait::getThemePath protected function Gets the path for the specified theme.
FieldTestBase::assertFieldValues public function Assert that a field has the expected values in an entity.
FieldTestBase::_generateTestFieldValues public function Generate random values for a field_test field.
FormTest::$defaultTheme protected property The theme to install as the default for testing. Overrides BrowserTestBase::$defaultTheme
FormTest::$field protected property An array of values defining a field.
FormTest::$fieldStorageSingle protected property An array of values defining a field single.
FormTest::$fieldStorageUnlimited protected property An array of values defining a field with unlimited cardinality.
FormTest::$modules protected static property Modules to install. Overrides BrowserTestBase::$modules
FormTest::setUp protected function Overrides BrowserTestBase::setUp
FormTest::testFieldFormAccess public function Tests fields with no &#039;edit&#039; access.
FormTest::testFieldFormDefaultValue public function Tests field widget default values on entity forms.
FormTest::testFieldFormMultivalueWithRequiredRadio public function Tests widget handling of multiple required radios.
FormTest::testFieldFormSingle public function
FormTest::testFieldFormSingleRequired public function
FormTest::testFieldFormUnlimited public function
FormTest::testFieldFormUnlimitedRequired public function Tests the position of the required label.
FormTest::testHiddenField public function Tests hiding a field in a form.
FormTest::testLabelOnMultiValueFields public function Tests the form display of the label for multi-value fields.
FunctionalTestSetupTrait::$apcuEnsureUniquePrefix protected property The flag to set &#039;apcu_ensure_unique_prefix&#039; setting. 1
FunctionalTestSetupTrait::$classLoader protected property The class loader to use for installation and initialization of setup.
FunctionalTestSetupTrait::$rootUser protected property The &quot;#1&quot; admin user.
FunctionalTestSetupTrait::$usesSuperUserAccessPolicy protected property Set to TRUE to make user 1 a super user. 10
FunctionalTestSetupTrait::doInstall protected function Execute the non-interactive installer. 2
FunctionalTestSetupTrait::getDatabaseTypes protected function Returns all supported database driver installer objects.
FunctionalTestSetupTrait::initConfig protected function Initialize various configurations post-installation. 1
FunctionalTestSetupTrait::initKernel protected function Initializes the kernel after installation.
FunctionalTestSetupTrait::initSettings protected function Initialize settings created during install.
FunctionalTestSetupTrait::initUserSession protected function Initializes user 1 for the site to be installed.
FunctionalTestSetupTrait::installDefaultThemeFromClassProperty protected function Installs the default theme defined by `static::$defaultTheme` when needed. 1
FunctionalTestSetupTrait::installModulesFromClassProperty protected function Install modules defined by `static::$modules`. 1
FunctionalTestSetupTrait::installParameters protected function Returns the parameters that will be used when the test installs Drupal. 8
FunctionalTestSetupTrait::prepareEnvironment protected function Prepares the current environment for running the test. 28
FunctionalTestSetupTrait::prepareRequestForGenerator protected function Creates a mock request and sets it on the generator.
FunctionalTestSetupTrait::prepareSettings protected function Prepares site settings and services before installation. 4
FunctionalTestSetupTrait::rebuildAll protected function Resets and rebuilds the environment after setup.
FunctionalTestSetupTrait::rebuildContainer protected function Rebuilds \Drupal::getContainer().
FunctionalTestSetupTrait::resetAll protected function Resets all data structures after having enabled new modules.
FunctionalTestSetupTrait::setContainerParameter protected function Changes parameters in the services.yml file.
FunctionalTestSetupTrait::setupBaseUrl protected function Sets up the base URL based upon the environment variable.
FunctionalTestSetupTrait::writeSettings protected function Rewrites the settings.php file of the test site. 1
NodeCreationTrait::createNode protected function Creates a node based on default settings. Aliased as: drupalCreateNode
NodeCreationTrait::getNodeByTitle public function Get a node from the database based on its title. Aliased as: drupalGetNodeByTitle
PhpUnitWarnings::$deprecationWarnings private static property Deprecation warnings from PHPUnit to raise with @trigger_error().
PhpUnitWarnings::addWarning public function Converts PHPUnit deprecation warnings to E_USER_DEPRECATED.
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.
RandomGeneratorTrait::randomStringValidate Deprecated public function Callback for random string validation.
RefreshVariablesTrait::refreshVariables protected function Refreshes in-memory configuration and state information. 2
SessionTestTrait::$sessionName protected property The name of the session cookie.
SessionTestTrait::generateSessionName protected function Generates a session cookie name.
SessionTestTrait::getSessionName protected function Returns the session name in use on the child site.
StorageCopyTrait::replaceStorageContents protected static function Copy the configuration from one storage to another and remove stale items.
TestRequirementsTrait::checkModuleRequirements Deprecated private function Checks missing module requirements.
TestRequirementsTrait::checkRequirements Deprecated protected function Check module requirements for the Drupal use case.
TestRequirementsTrait::getDrupalRoot protected static function Returns the Drupal root directory.
TestSetupTrait::$configSchemaCheckerExclusions protected static property An array of config object names that are excluded from schema checking. 2
TestSetupTrait::$container protected property The dependency injection container used in the test.
TestSetupTrait::$databasePrefix protected property The database prefix of this test run.
TestSetupTrait::$kernel protected property The DrupalKernel instance used in the test.
TestSetupTrait::$originalSite protected property The site directory of the original parent site.
TestSetupTrait::$privateFilesDirectory protected property The private file directory for the test environment.
TestSetupTrait::$publicFilesDirectory protected property The public file directory for the test environment.
TestSetupTrait::$root protected property The app root.
TestSetupTrait::$siteDirectory protected property The site directory of this test run.
TestSetupTrait::$strictConfigSchema protected property Set to TRUE to strict check all configuration saved. 4
TestSetupTrait::$tempFilesDirectory protected property The temporary file directory for the test environment.
TestSetupTrait::$testId protected property The test run ID.
TestSetupTrait::changeDatabasePrefix protected function Changes the database connection to the prefixed one.
TestSetupTrait::getConfigSchemaExclusions protected function Gets the config schema exclusions for this test.
TestSetupTrait::getDatabaseConnection Deprecated public static function Returns the database connection to the site under test.
TestSetupTrait::prepareDatabasePrefix protected function Generates a database prefix for running tests. 1
UiHelperTrait::$loggedInUser protected property The current user logged in using the Mink controlled browser.
UiHelperTrait::$maximumMetaRefreshCount protected property The number of meta refresh redirects to follow, or NULL if unlimited.
UiHelperTrait::$metaRefreshCount protected property The number of meta refresh redirects followed during ::drupalGet().
UiHelperTrait::$useOneTimeLoginLinks protected property Use one-time login links instead of submitting the login form. 3
UiHelperTrait::assertSession public function Returns WebAssert object. 1
UiHelperTrait::buildUrl protected function Builds an absolute URL from a system path or a URL object.
UiHelperTrait::checkForMetaRefresh protected function Checks for meta refresh tag and if found call drupalGet() recursively.
UiHelperTrait::click protected function Clicks the element with the given CSS selector.
UiHelperTrait::clickLink protected function Follows a link by complete name.
UiHelperTrait::cssSelect protected function Searches elements using a CSS selector in the raw content.
UiHelperTrait::cssSelectToXpath protected function Translates a CSS expression to its XPath equivalent.
UiHelperTrait::drupalGet protected function Retrieves a Drupal path or an absolute path. 3
UiHelperTrait::drupalLogin protected function Logs in a user using the Mink controlled browser.
UiHelperTrait::drupalLogout protected function Logs a user out of the Mink controlled browser and confirms.
UiHelperTrait::drupalResetSession protected function Resets the current active session back to Anonymous session.
UiHelperTrait::drupalUserIsLoggedIn protected function Returns whether a given user account is logged in.
UiHelperTrait::getAbsoluteUrl protected function Takes a path and returns an absolute path.
UiHelperTrait::getTextContent protected function Retrieves the plain-text content from the current page.
UiHelperTrait::getUrl protected function Get the current URL from the browser.
UiHelperTrait::isTestUsingGuzzleClient protected function Determines if test is using DrupalTestBrowser.
UiHelperTrait::prepareRequest protected function Prepare for a request to testing site. 1
UiHelperTrait::submitForm protected function Fills and submits a form.
UserCreationTrait::checkPermissions protected function Checks whether a given list of permission names is valid.
UserCreationTrait::createAdminRole protected function Creates an administrative role.
UserCreationTrait::createRole protected function Creates a role with specified permissions. Aliased as: drupalCreateRole
UserCreationTrait::createUser protected function Create a user with a given set of permissions. Aliased as: drupalCreateUser
UserCreationTrait::grantPermissions protected function Grant permissions to a user role.
UserCreationTrait::setCurrentUser protected function Switch the current logged in user.
UserCreationTrait::setUpCurrentUser protected function Creates a random user account and sets it as current user.
XdebugRequestTrait::extractCookiesFromRequest protected function Adds xdebug cookies, from request setup.

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