FilterFormTest.php in Drupal 8

Namespace

Drupal\Tests\filter\Functional

File

core/modules/filter/tests/src/Functional/FilterFormTest.php

<?php

namespace Drupal\Tests\filter\Functional;

use Drupal\Component\Render\FormattableMarkup;
use Drupal\filter\Entity\FilterFormat;
use Drupal\Tests\BrowserTestBase;

/**
 * Tests form elements with associated text formats.
 *
 * @group filter
 */
class FilterFormTest extends BrowserTestBase {

  /**
   * Modules to enable for this test.
   *
   * @var array
   */
  protected static $modules = [
    'filter',
    'filter_test',
  ];

  /**
   * {@inheritdoc}
   */
  protected $defaultTheme = 'stark';

  /**
   * An administrative user account that can administer text formats.
   *
   * @var \Drupal\user\Entity\User
   */
  protected $adminUser;

  /**
   * An basic user account that can only access basic HTML text format.
   *
   * @var \Drupal\user\Entity\User
   */
  protected $webUser;

  /**
   * {@inheritdoc}
   */
  protected function setUp() {
    parent::setUp();

    /** @var \Drupal\filter\FilterFormatInterface $filter_test_format */
    $filter_test_format = FilterFormat::load('filter_test');

    /** @var \Drupal\filter\FilterFormatInterface $filtered_html_format */
    $filtered_html_format = FilterFormat::load('filtered_html');

    /** @var \Drupal\filter\FilterFormatInterface $full_html_format */
    $full_html_format = FilterFormat::load('full_html');

    // Create users.
    $this->adminUser = $this
      ->drupalCreateUser([
      'administer filters',
      $filtered_html_format
        ->getPermissionName(),
      $full_html_format
        ->getPermissionName(),
      $filter_test_format
        ->getPermissionName(),
    ]);
    $this->webUser = $this
      ->drupalCreateUser([
      $filtered_html_format
        ->getPermissionName(),
      $filter_test_format
        ->getPermissionName(),
    ]);
  }

  /**
   * Tests various different configurations of the 'text_format' element.
   */
  public function testFilterForm() {
    $this
      ->doFilterFormTestAsAdmin();
    $this
      ->doFilterFormTestAsNonAdmin();

    // Ensure that enabling modules which provide filter plugins behaves
    // correctly.
    // @see https://www.drupal.org/node/2387983
    \Drupal::service('module_installer')
      ->install([
      'filter_test_plugin',
    ]);
  }

  /**
   * Tests the behavior of the 'text_format' element as an administrator.
   */
  protected function doFilterFormTestAsAdmin() {
    $this
      ->drupalLogin($this->adminUser);
    $this
      ->drupalGet('filter-test/text-format');

    // Test a text format element with all formats.
    $formats = [
      'filtered_html',
      'full_html',
      'filter_test',
    ];
    $this
      ->assertEnabledTextarea('edit-all-formats-no-default-value');

    // If no default is given, the format with the lowest weight becomes the
    // default.
    $this
      ->assertOptions('edit-all-formats-no-default-format--2', $formats, 'filtered_html');
    $this
      ->assertEnabledTextarea('edit-all-formats-default-value');

    // \Drupal\filter_test\Form\FilterTestFormatForm::buildForm() uses
    // 'filter_test' as the default value in this case.
    $this
      ->assertOptions('edit-all-formats-default-format--2', $formats, 'filter_test');
    $this
      ->assertEnabledTextarea('edit-all-formats-default-missing-value');

    // If a missing format is set as the default, administrators must select a
    // valid replacement format.
    $this
      ->assertRequiredSelectAndOptions('edit-all-formats-default-missing-format--2', $formats);

    // Test a text format element with a predefined list of formats.
    $formats = [
      'full_html',
      'filter_test',
    ];
    $this
      ->assertEnabledTextarea('edit-restricted-formats-no-default-value');
    $this
      ->assertOptions('edit-restricted-formats-no-default-format--2', $formats, 'full_html');
    $this
      ->assertEnabledTextarea('edit-restricted-formats-default-value');
    $this
      ->assertOptions('edit-restricted-formats-default-format--2', $formats, 'full_html');
    $this
      ->assertEnabledTextarea('edit-restricted-formats-default-missing-value');
    $this
      ->assertRequiredSelectAndOptions('edit-restricted-formats-default-missing-format--2', $formats);
    $this
      ->assertEnabledTextarea('edit-restricted-formats-default-disallowed-value');
    $this
      ->assertRequiredSelectAndOptions('edit-restricted-formats-default-disallowed-format--2', $formats);

    // Test a text format element with a fixed format.
    $formats = [
      'filter_test',
    ];

    // When there is only a single option there is no point in choosing.
    $this
      ->assertEnabledTextarea('edit-single-format-no-default-value');
    $this
      ->assertNoSelect('edit-single-format-no-default-format--2');
    $this
      ->assertEnabledTextarea('edit-single-format-default-value');
    $this
      ->assertNoSelect('edit-single-format-default-format--2');

    // If the select has a missing or disallowed format, administrators must
    // explicitly choose the format.
    $this
      ->assertEnabledTextarea('edit-single-format-default-missing-value');
    $this
      ->assertRequiredSelectAndOptions('edit-single-format-default-missing-format--2', $formats);
    $this
      ->assertEnabledTextarea('edit-single-format-default-disallowed-value');
    $this
      ->assertRequiredSelectAndOptions('edit-single-format-default-disallowed-format--2', $formats);
  }

  /**
   * Tests the behavior of the 'text_format' element as a normal user.
   */
  protected function doFilterFormTestAsNonAdmin() {
    $this
      ->drupalLogin($this->webUser);
    $this
      ->drupalGet('filter-test/text-format');

    // Test a text format element with all formats. Only formats the user has
    // access to are shown.
    $formats = [
      'filtered_html',
      'filter_test',
    ];
    $this
      ->assertEnabledTextarea('edit-all-formats-no-default-value');

    // If no default is given, the format with the lowest weight becomes the
    // default. This happens to be 'filtered_html'.
    $this
      ->assertOptions('edit-all-formats-no-default-format--2', $formats, 'filtered_html');
    $this
      ->assertEnabledTextarea('edit-all-formats-default-value');

    // \Drupal\filter_test\Form\FilterTestFormatForm::buildForm() uses
    // 'filter_test' as the default value in this case.
    $this
      ->assertOptions('edit-all-formats-default-format--2', $formats, 'filter_test');

    // If a missing format is given as default, non-admin users are presented
    // with a disabled textarea.
    $this
      ->assertDisabledTextarea('edit-all-formats-default-missing-value');

    // Test a text format element with a predefined list of formats.
    $this
      ->assertEnabledTextarea('edit-restricted-formats-no-default-value');

    // The user only has access to the 'filter_test' format, so when no default
    // is given that is preselected and the text format select is hidden.
    $this
      ->assertNoSelect('edit-restricted-formats-no-default-format--2');

    // When the format that the user does not have access to is preselected, the
    // textarea should be disabled.
    $this
      ->assertDisabledTextarea('edit-restricted-formats-default-value');
    $this
      ->assertDisabledTextarea('edit-restricted-formats-default-missing-value');
    $this
      ->assertDisabledTextarea('edit-restricted-formats-default-disallowed-value');

    // Test a text format element with a fixed format.
    // When there is only a single option there is no point in choosing.
    $this
      ->assertEnabledTextarea('edit-single-format-no-default-value');
    $this
      ->assertNoSelect('edit-single-format-no-default-format--2');
    $this
      ->assertEnabledTextarea('edit-single-format-default-value');
    $this
      ->assertNoSelect('edit-single-format-default-format--2');

    // If the select has a missing or disallowed format make sure the textarea
    // is disabled.
    $this
      ->assertDisabledTextarea('edit-single-format-default-missing-value');
    $this
      ->assertDisabledTextarea('edit-single-format-default-disallowed-value');
  }

  /**
   * Makes sure that no select element with the given ID exists on the page.
   *
   * @param string $id
   *   The HTML ID of the select element.
   */
  protected function assertNoSelect($id) {
    $select = $this
      ->xpath('//select[@id=:id]', [
      ':id' => $id,
    ]);
    $this
      ->assertEmpty($select, new FormattableMarkup('Field @id does not exist.', [
      '@id' => $id,
    ]));
  }

  /**
   * Asserts that a select element has the correct options.
   *
   * @param string $id
   *   The HTML ID of the select element.
   * @param array $expected_options
   *   An array of option values.
   * @param string $selected
   *   The value of the selected option.
   *
   * @return bool
   *   TRUE if the assertion passed; FALSE otherwise.
   */
  protected function assertOptions($id, array $expected_options, $selected) {
    $select = $this
      ->xpath('//select[@id=:id]', [
      ':id' => $id,
    ]);
    $this
      ->assertNotEmpty($select, new FormattableMarkup('Field @id exists.', [
      '@id' => $id,
    ]));
    $select = reset($select);
    $found_options = $select
      ->findAll('css', 'option');
    foreach ($found_options as $found_key => $found_option) {
      $expected_key = array_search($found_option
        ->getValue(), $expected_options);
      if ($expected_key !== FALSE) {
        unset($found_options[$found_key]);
        unset($expected_options[$expected_key]);
      }
    }

    // Make sure that all expected options were found and that there are no
    // unexpected options.
    foreach ($expected_options as $expected_option) {
      $this
        ->fail(new FormattableMarkup('Option @option for field @id exists.', [
        '@option' => $expected_option,
        '@id' => $id,
      ]));
    }
    foreach ($found_options as $found_option) {
      $this
        ->fail(new FormattableMarkup('Option @option for field @id does not exist.', [
        '@option' => $found_option
          ->getValue(),
        '@id' => $id,
      ]));
    }
    $this
      ->assertOptionSelected($id, $selected);
  }

  /**
   * Asserts that there is a select element with the given ID that is required.
   *
   * @param string $id
   *   The HTML ID of the select element.
   * @param array $options
   *   An array of option values that are contained in the select element
   *   besides the "- Select -" option.
   *
   * @return bool
   *   TRUE if the assertion passed; FALSE otherwise.
   */
  protected function assertRequiredSelectAndOptions($id, array $options) {
    $select = $this
      ->xpath('//select[@id=:id and contains(@required, "required")]', [
      ':id' => $id,
    ]);
    $this
      ->assertNotEmpty($select, new FormattableMarkup('Required field @id exists.', [
      '@id' => $id,
    ]));

    // A required select element has a "- Select -" option whose key is an empty
    // string.
    $options[] = '';
    $this
      ->assertOptions($id, $options, '');
  }

  /**
   * Asserts that a textarea with a given ID exists and is not disabled.
   *
   * @param string $id
   *   The HTML ID of the textarea.
   *
   * @return bool
   *   TRUE if the assertion passed; FALSE otherwise.
   */
  protected function assertEnabledTextarea($id) {
    $textarea = $this
      ->xpath('//textarea[@id=:id and not(contains(@disabled, "disabled"))]', [
      ':id' => $id,
    ]);
    $this
      ->assertNotEmpty($textarea, new FormattableMarkup('Enabled field @id exists.', [
      '@id' => $id,
    ]));
  }

  /**
   * Asserts that a textarea with a given ID has been disabled from editing.
   *
   * @param string $id
   *   The HTML ID of the textarea.
   *
   * @return bool
   *   TRUE if the assertion passed; FALSE otherwise.
   */
  protected function assertDisabledTextarea($id) {
    $textarea = $this
      ->xpath('//textarea[@id=:id and contains(@disabled, "disabled")]', [
      ':id' => $id,
    ]);
    $this
      ->assertNotEmpty($textarea, new FormattableMarkup('Disabled field @id exists.', [
      '@id' => $id,
    ]));
    $textarea = reset($textarea);
    $expected = 'This field has been disabled because you do not have sufficient permissions to edit it.';
    $this
      ->assertEqual($textarea
      ->getText(), $expected, new FormattableMarkup('Disabled textarea @id hides text in an inaccessible text format.', [
      '@id' => $id,
    ]));

    // Make sure the text format select is not shown.
    $select_id = str_replace('value', 'format--2', $id);
    $this
      ->assertNoSelect($select_id);
  }

}

Classes

Name	Description
FilterFormTest	Tests form elements with associated text formats.