Issue #1591436 by aspilicious, Rob Loach: Convert filter tests to PSR-0.

core/modules/filter/filter.info

@@ -3,6 +3,5 @@ description = Filters content in preparation for display.
 package = Core
 version = VERSION
 core = 8.x
-files[] = filter.test
 required = TRUE
 configure = admin/config/content/formats

core/modules/filter/lib/Drupal/filter/Tests/FilterAdminTest.php

+<?php
+
+/**
+ * @file
+ * Definition of Drupal\filter\Tests\FilterAdminTest.
+ */
+
+namespace Drupal\filter\Tests;
+
+use Drupal\simpletest\WebTestBase;
+
+class FilterAdminTest extends WebTestBase {
+  protected $profile = 'standard';
+
+  public static function getInfo() {
+    return array(
+      'name' => 'Filter administration functionality',
+      'description' => 'Thoroughly test the administrative interface of the filter module.',
+      'group' => 'Filter',
+    );
+  }
+
+  function setUp() {
+    parent::setUp();
+
+    // Create users.
+    $filtered_html_format = filter_format_load('filtered_html');
+    $full_html_format = filter_format_load('full_html');
+    $this->admin_user = $this->drupalCreateUser(array(
+      'administer filters',
+      filter_permission_name($filtered_html_format),
+      filter_permission_name($full_html_format),
+    ));
+
+    $this->web_user = $this->drupalCreateUser(array('create page content', 'edit own page content'));
+    $this->drupalLogin($this->admin_user);
+  }
+
+  function testFormatAdmin() {
+    // Add text format.
+    $this->drupalGet('admin/config/content/formats');
+    $this->clickLink('Add text format');
+    $format_id = drupal_strtolower($this->randomName());
+    $name = $this->randomName();
+    $edit = array(
+      'format' => $format_id,
+      'name' => $name,
+    );
+    $this->drupalPost(NULL, $edit, t('Save configuration'));
+
+    // Verify default weight of the text format.
+    $this->drupalGet('admin/config/content/formats');
+    $this->assertFieldByName("formats[$format_id][weight]", 0, t('Text format weight was saved.'));
+
+    // Change the weight of the text format.
+    $edit = array(
+      "formats[$format_id][weight]" => 5,
+    );
+    $this->drupalPost('admin/config/content/formats', $edit, t('Save changes'));
+    $this->assertFieldByName("formats[$format_id][weight]", 5, t('Text format weight was saved.'));
+
+    // Edit text format.
+    $this->drupalGet('admin/config/content/formats');
+    $this->assertLinkByHref('admin/config/content/formats/' . $format_id);
+    $this->drupalGet('admin/config/content/formats/' . $format_id);
+    $this->drupalPost(NULL, array(), t('Save configuration'));
+
+    // Verify that the custom weight of the text format has been retained.
+    $this->drupalGet('admin/config/content/formats');
+    $this->assertFieldByName("formats[$format_id][weight]", 5, t('Text format weight was retained.'));
+
+    // Disable text format.
+    $this->assertLinkByHref('admin/config/content/formats/' . $format_id . '/disable');
+    $this->drupalGet('admin/config/content/formats/' . $format_id . '/disable');
+    $this->drupalPost(NULL, array(), t('Disable'));
+
+    // Verify that disabled text format no longer exists.
+    $this->drupalGet('admin/config/content/formats/' . $format_id);
+    $this->assertResponse(404, t('Disabled text format no longer exists.'));
+
+    // Attempt to create a format of the same machine name as the disabled
+    // format but with a different human readable name.
+    $edit = array(
+      'format' => $format_id,
+      'name' => 'New format',
+    );
+    $this->drupalPost('admin/config/content/formats/add', $edit, t('Save configuration'));
+    $this->assertText('The machine-readable name is already in use. It must be unique.');
+
+    // Attempt to create a format of the same human readable name as the
+    // disabled format but with a different machine name.
+    $edit = array(
+      'format' => 'new_format',
+      'name' => $name,
+    );
+    $this->drupalPost('admin/config/content/formats/add', $edit, t('Save configuration'));
+    $this->assertRaw(t('Text format names must be unique. A format named %name already exists.', array(
+      '%name' => $name,
+    )));
+  }
+
+  /**
+   * Test filter administration functionality.
+   */
+  function testFilterAdmin() {
+    // URL filter.
+    $first_filter = 'filter_url';
+    // Line filter.
+    $second_filter = 'filter_autop';
+
+    $filtered = 'filtered_html';
+    $full = 'full_html';
+    $plain = 'plain_text';
+
+    // Check that the fallback format exists and cannot be disabled.
+    $this->assertTrue($plain == filter_fallback_format(), t('The fallback format is set to plain text.'));
+    $this->drupalGet('admin/config/content/formats');
+    $this->assertNoRaw('admin/config/content/formats/' . $plain . '/disable', t('Disable link for the fallback format not found.'));
+    $this->drupalGet('admin/config/content/formats/' . $plain . '/disable');
+    $this->assertResponse(403, t('The fallback format cannot be disabled.'));
+
+    // Verify access permissions to Full HTML format.
+    $this->assertTrue(filter_access(filter_format_load($full), $this->admin_user), t('Admin user may use Full HTML.'));
+    $this->assertFalse(filter_access(filter_format_load($full), $this->web_user), t('Web user may not use Full HTML.'));
+
+    // Add an additional tag.
+    $edit = array();
+    $edit['filters[filter_html][settings][allowed_html]'] = '<a> <em> <strong> <cite> <code> <ul> <ol> <li> <dl> <dt> <dd> <quote>';
+    $this->drupalPost('admin/config/content/formats/' . $filtered, $edit, t('Save configuration'));
+    $this->assertFieldByName('filters[filter_html][settings][allowed_html]', $edit['filters[filter_html][settings][allowed_html]'], t('Allowed HTML tag added.'));
+
+    $result = db_query('SELECT * FROM {cache_filter}')->fetchObject();
+    $this->assertFalse($result, t('Cache cleared.'));
+
+    $elements = $this->xpath('//select[@name=:first]/following::select[@name=:second]', array(
+      ':first' => 'filters[' . $first_filter . '][weight]',
+      ':second' => 'filters[' . $second_filter . '][weight]',
+    ));
+    $this->assertTrue(!empty($elements), t('Order confirmed in admin interface.'));
+
+    // Reorder filters.
+    $edit = array();
+    $edit['filters[' . $second_filter . '][weight]'] = 1;
+    $edit['filters[' . $first_filter . '][weight]'] = 2;
+    $this->drupalPost(NULL, $edit, t('Save configuration'));
+    $this->assertFieldByName('filters[' . $second_filter . '][weight]', 1, t('Order saved successfully.'));
+    $this->assertFieldByName('filters[' . $first_filter . '][weight]', 2, t('Order saved successfully.'));
+
+    $elements = $this->xpath('//select[@name=:first]/following::select[@name=:second]', array(
+      ':first' => 'filters[' . $second_filter . '][weight]',
+      ':second' => 'filters[' . $first_filter . '][weight]',
+    ));
+    $this->assertTrue(!empty($elements), t('Reorder confirmed in admin interface.'));
+
+    $result = db_query('SELECT * FROM {filter} WHERE format = :format ORDER BY weight ASC', array(':format' => $filtered));
+    $filters = array();
+    foreach ($result as $filter) {
+      if ($filter->name == $second_filter || $filter->name == $first_filter) {
+        $filters[] = $filter;
+      }
+    }
+    $this->assertTrue(($filters[0]->name == $second_filter && $filters[1]->name == $first_filter), t('Order confirmed in database.'));
+
+    // Add format.
+    $edit = array();
+    $edit['format'] = drupal_strtolower($this->randomName());
+    $edit['name'] = $this->randomName();
+    $edit['roles[' . DRUPAL_AUTHENTICATED_RID . ']'] = 1;
+    $edit['filters[' . $second_filter . '][status]'] = TRUE;
+    $edit['filters[' . $first_filter . '][status]'] = TRUE;
+    $this->drupalPost('admin/config/content/formats/add', $edit, t('Save configuration'));
+    $this->assertRaw(t('Added text format %format.', array('%format' => $edit['name'])), t('New filter created.'));
+
+    drupal_static_reset('filter_formats');
+    $format = filter_format_load($edit['format']);
+    $this->assertNotNull($format, t('Format found in database.'));
+
+    $this->assertFieldByName('roles[' . DRUPAL_AUTHENTICATED_RID . ']', '', t('Role found.'));
+    $this->assertFieldByName('filters[' . $second_filter . '][status]', '', t('Line break filter found.'));
+    $this->assertFieldByName('filters[' . $first_filter . '][status]', '', t('Url filter found.'));
+
+    // Disable new filter.
+    $this->drupalPost('admin/config/content/formats/' . $format->format . '/disable', array(), t('Disable'));
+    $this->assertRaw(t('Disabled text format %format.', array('%format' => $edit['name'])), t('Format successfully disabled.'));
+
+    // Allow authenticated users on full HTML.
+    $format = filter_format_load($full);
+    $edit = array();
+    $edit['roles[' . DRUPAL_ANONYMOUS_RID . ']'] = 0;
+    $edit['roles[' . DRUPAL_AUTHENTICATED_RID . ']'] = 1;
+    $this->drupalPost('admin/config/content/formats/' . $full, $edit, t('Save configuration'));
+    $this->assertRaw(t('The text format %format has been updated.', array('%format' => $format->name)), t('Full HTML format successfully updated.'));
+
+    // Switch user.
+    $this->drupalLogout();
+    $this->drupalLogin($this->web_user);
+
+    $this->drupalGet('node/add/page');
+    $this->assertRaw('<option value="' . $full . '">Full HTML</option>', t('Full HTML filter accessible.'));
+
+    // Use filtered HTML and see if it removes tags that are not allowed.
+    $body = '<em>' . $this->randomName() . '</em>';
+    $extra_text = 'text';
+    $text = $body . '<random>' . $extra_text . '</random>';
+
+    $edit = array();
+    $langcode = LANGUAGE_NOT_SPECIFIED;
+    $edit["title"] = $this->randomName();
+    $edit["body[$langcode][0][value]"] = $text;
+    $edit["body[$langcode][0][format]"] = $filtered;
+    $this->drupalPost('node/add/page', $edit, t('Save'));
+    $this->assertRaw(t('Basic page %title has been created.', array('%title' => $edit["title"])), t('Filtered node created.'));
+
+    $node = $this->drupalGetNodeByTitle($edit["title"]);
+    $this->assertTrue($node, t('Node found in database.'));
+
+    $this->drupalGet('node/' . $node->nid);
+    $this->assertRaw($body . $extra_text, t('Filter removed invalid tag.'));
+
+    // Use plain text and see if it escapes all tags, whether allowed or not.
+    $edit = array();
+    $edit["body[$langcode][0][format]"] = $plain;
+    $this->drupalPost('node/' . $node->nid . '/edit', $edit, t('Save'));
+    $this->drupalGet('node/' . $node->nid);
+    $this->assertText(check_plain($text), t('The "Plain text" text format escapes all HTML tags.'));
+
+    // Switch user.
+    $this->drupalLogout();
+    $this->drupalLogin($this->admin_user);
+
+    // Clean up.
+    // Allowed tags.
+    $edit = array();
+    $edit['filters[filter_html][settings][allowed_html]'] = '<a> <em> <strong> <cite> <code> <ul> <ol> <li> <dl> <dt> <dd>';
+    $this->drupalPost('admin/config/content/formats/' . $filtered, $edit, t('Save configuration'));
+    $this->assertFieldByName('filters[filter_html][settings][allowed_html]', $edit['filters[filter_html][settings][allowed_html]'], t('Changes reverted.'));
+
+    // Full HTML.
+    $edit = array();
+    $edit['roles[' . DRUPAL_AUTHENTICATED_RID . ']'] = FALSE;
+    $this->drupalPost('admin/config/content/formats/' . $full, $edit, t('Save configuration'));
+    $this->assertRaw(t('The text format %format has been updated.', array('%format' => $format->name)), t('Full HTML format successfully reverted.'));
+    $this->assertFieldByName('roles[' . DRUPAL_AUTHENTICATED_RID . ']', $edit['roles[' . DRUPAL_AUTHENTICATED_RID . ']'], t('Changes reverted.'));
+
+    // Filter order.
+    $edit = array();
+    $edit['filters[' . $second_filter . '][weight]'] = 2;
+    $edit['filters[' . $first_filter . '][weight]'] = 1;
+    $this->drupalPost('admin/config/content/formats/' . $filtered, $edit, t('Save configuration'));
+    $this->assertFieldByName('filters[' . $second_filter . '][weight]', $edit['filters[' . $second_filter . '][weight]'], t('Changes reverted.'));
+    $this->assertFieldByName('filters[' . $first_filter . '][weight]', $edit['filters[' . $first_filter . '][weight]'], t('Changes reverted.'));
+  }
+
+  /**
+   * Tests the URL filter settings form is properly validated.
+   */
+  function testUrlFilterAdmin() {
+    // The form does not save with an invalid filter URL length.
+    $edit = array(
+      'filters[filter_url][settings][filter_url_length]' => $this->randomName(4),
+    );
+    $this->drupalPost('admin/config/content/formats/filtered_html', $edit, t('Save configuration'));
+    $this->assertNoRaw(t('The text format %format has been updated.', array('%format' => 'Filtered HTML')));
+  }
+}

core/modules/filter/lib/Drupal/filter/Tests/FilterCrudTest.php

+<?php
+
+/**
+ * @file
+ * Definition of Drupal\filter\Tests\FilterCrudTest.
+ */
+
+namespace Drupal\filter\Tests;
+
+use Drupal\simpletest\WebTestBase;
+use stdClass;
+
+/**
+ * Tests for text format and filter CRUD operations.
+ */
+class FilterCrudTest extends WebTestBase {
+  public static function getInfo() {
+    return array(
+      'name' => 'Filter CRUD operations',
+      'description' => 'Test creation, loading, updating, deleting of text formats and filters.',
+      'group' => 'Filter',
+    );
+  }
+
+  function setUp() {
+    parent::setUp('filter_test');
+  }
+
+  /**
+   * Test CRUD operations for text formats and filters.
+   */
+  function testTextFormatCrud() {
+    // Add a text format with minimum data only.
+    $format = new stdClass();
+    $format->format = 'empty_format';
+    $format->name = 'Empty format';
+    filter_format_save($format);
+    $this->verifyTextFormat($format);
+    $this->verifyFilters($format);
+
+    // Add another text format specifying all possible properties.
+    $format = new stdClass();
+    $format->format = 'custom_format';
+    $format->name = 'Custom format';
+    $format->filters = array(
+      'filter_url' => array(
+        'status' => 1,
+        'settings' => array(
+          'filter_url_length' => 30,
+        ),
+      ),
+    );
+    filter_format_save($format);
+    $this->verifyTextFormat($format);
+    $this->verifyFilters($format);
+
+    // Alter some text format properties and save again.
+    $format->name = 'Altered format';
+    $format->filters['filter_url']['status'] = 0;
+    $format->filters['filter_autop']['status'] = 1;
+    filter_format_save($format);
+    $this->verifyTextFormat($format);
+    $this->verifyFilters($format);
+
+    // Add a uncacheable filter and save again.
+    $format->filters['filter_test_uncacheable']['status'] = 1;
+    filter_format_save($format);
+    $this->verifyTextFormat($format);
+    $this->verifyFilters($format);
+
+    // Disable the text format.
+    filter_format_disable($format);
+
+    $db_format = db_query("SELECT * FROM {filter_format} WHERE format = :format", array(':format' => $format->format))->fetchObject();
+    $this->assertFalse($db_format->status, t('Database: Disabled text format is marked as disabled.'));
+    $formats = filter_formats();
+    $this->assertTrue(!isset($formats[$format->format]), t('filter_formats: Disabled text format no longer exists.'));
+  }
+
+  /**
+   * Verify that a text format is properly stored.
+   */
+  function verifyTextFormat($format) {
+    $t_args = array('%format' => $format->name);
+    // Verify text format database record.
+    $db_format = db_select('filter_format', 'ff')
+      ->fields('ff')
+      ->condition('format', $format->format)
+      ->execute()
+      ->fetchObject();
+    $this->assertEqual($db_format->format, $format->format, t('Database: Proper format id for text format %format.', $t_args));
+    $this->assertEqual($db_format->name, $format->name, t('Database: Proper title for text format %format.', $t_args));
+    $this->assertEqual($db_format->cache, $format->cache, t('Database: Proper cache indicator for text format %format.', $t_args));
+    $this->assertEqual($db_format->weight, $format->weight, t('Database: Proper weight for text format %format.', $t_args));
+
+    // Verify filter_format_load().
+    $filter_format = filter_format_load($format->format);
+    $this->assertEqual($filter_format->format, $format->format, t('filter_format_load: Proper format id for text format %format.', $t_args));
+    $this->assertEqual($filter_format->name, $format->name, t('filter_format_load: Proper title for text format %format.', $t_args));
+    $this->assertEqual($filter_format->cache, $format->cache, t('filter_format_load: Proper cache indicator for text format %format.', $t_args));
+    $this->assertEqual($filter_format->weight, $format->weight, t('filter_format_load: Proper weight for text format %format.', $t_args));
+
+    // Verify the 'cache' text format property according to enabled filters.
+    $filter_info = filter_get_filters();
+    $filters = filter_list_format($filter_format->format);
+    $cacheable = TRUE;
+    foreach ($filters as $name => $filter) {
+      // If this filter is not cacheable, update $cacheable accordingly, so we
+      // can verify $format->cache after iterating over all filters.
+      if ($filter->status && isset($filter_info[$name]['cache']) && !$filter_info[$name]['cache']) {
+        $cacheable = FALSE;
+        break;
+      }
+    }
+    $this->assertEqual($filter_format->cache, $cacheable, t('Text format contains proper cache property.'));
+  }
+
+  /**
+   * Verify that filters are properly stored for a text format.
+   */
+  function verifyFilters($format) {
+    // Verify filter database records.
+    $filters = db_query("SELECT * FROM {filter} WHERE format = :format", array(':format' => $format->format))->fetchAllAssoc('name');
+    $format_filters = $format->filters;
+    foreach ($filters as $name => $filter) {
+      $t_args = array('%format' => $format->name, '%filter' => $name);
+
+      // Verify that filter status is properly stored.
+      $this->assertEqual($filter->status, $format_filters[$name]['status'], t('Database: Proper status for %filter in text format %format.', $t_args));
+
+      // Verify that filter settings were properly stored.
+      $this->assertEqual(unserialize($filter->settings), isset($format_filters[$name]['settings']) ? $format_filters[$name]['settings'] : array(), t('Database: Proper filter settings for %filter in text format %format.', $t_args));
+
+      // Verify that each filter has a module name assigned.
+      $this->assertTrue(!empty($filter->module), t('Database: Proper module name for %filter in text format %format.', $t_args));
+
+      // Remove the filter from the copy of saved $format to check whether all
+      // filters have been processed later.
+      unset($format_filters[$name]);
+    }
+    // Verify that all filters have been processed.
+    $this->assertTrue(empty($format_filters), t('Database contains values for all filters in the saved format.'));
+
+    // Verify filter_list_format().
+    $filters = filter_list_format($format->format);
+    $format_filters = $format->filters;
+    foreach ($filters as $name => $filter) {
+      $t_args = array('%format' => $format->name, '%filter' => $name);
+
+      // Verify that filter status is properly stored.
+      $this->assertEqual($filter->status, $format_filters[$name]['status'], t('filter_list_format: Proper status for %filter in text format %format.', $t_args));
+
+      // Verify that filter settings were properly stored.
+      $this->assertEqual($filter->settings, isset($format_filters[$name]['settings']) ? $format_filters[$name]['settings'] : array(), t('filter_list_format: Proper filter settings for %filter in text format %format.', $t_args));
+
+      // Verify that each filter has a module name assigned.
+      $this->assertTrue(!empty($filter->module), t('filter_list_format: Proper module name for %filter in text format %format.', $t_args));
+
+      // Remove the filter from the copy of saved $format to check whether all
+      // filters have been processed later.
+      unset($format_filters[$name]);
+    }
+    // Verify that all filters have been processed.
+    $this->assertTrue(empty($format_filters), t('filter_list_format: Loaded filters contain values for all filters in the saved format.'));
+  }
+}

core/modules/filter/lib/Drupal/filter/Tests/FilterDefaultFormatTest.php

+<?php
+
+/**
+ * @file
+ * Definition of Drupal\filter\Tests\FilterDefaultFormatTest.
+ */
+
+namespace Drupal\filter\Tests;
+
+use Drupal\simpletest\WebTestBase;
+
+class FilterDefaultFormatTest extends WebTestBase {
+  public static function getInfo() {
+    return array(
+      'name' => 'Default text format functionality',
+      'description' => 'Test the default text formats for different users.',
+      'group' => 'Filter',
+    );
+  }
+
+  function testDefaultTextFormats() {
+    // Create two text formats, and two users. The first user has access to
+    // both formats, but the second user only has access to the second one.
+    $admin_user = $this->drupalCreateUser(array('administer filters'));
+    $this->drupalLogin($admin_user);
+    $formats = array();
+    for ($i = 0; $i < 2; $i++) {
+      $edit = array(
+        'format' => drupal_strtolower($this->randomName()),
+        'name' => $this->randomName(),
+      );
+      $this->drupalPost('admin/config/content/formats/add', $edit, t('Save configuration'));
+      $this->resetFilterCaches();
+      $formats[] = filter_format_load($edit['format']);
+    }
+    list($first_format, $second_format) = $formats;
+    $first_user = $this->drupalCreateUser(array(filter_permission_name($first_format), filter_permission_name($second_format)));
+    $second_user = $this->drupalCreateUser(array(filter_permission_name($second_format)));
+
+    // Adjust the weights so that the first and second formats (in that order)
+    // are the two lowest weighted formats available to any user.
+    $minimum_weight = db_query("SELECT MIN(weight) FROM {filter_format}")->fetchField();
+    $edit = array();
+    $edit['formats[' . $first_format->format . '][weight]'] = $minimum_weight - 2;
+    $edit['formats[' . $second_format->format . '][weight]'] = $minimum_weight - 1;
+    $this->drupalPost('admin/config/content/formats', $edit, t('Save changes'));
+    $this->resetFilterCaches();
+
+    // Check that each user's default format is the lowest weighted format that
+    // the user has access to.
+    $this->assertEqual(filter_default_format($first_user), $first_format->format, t("The first user's default format is the lowest weighted format that the user has access to."));
+    $this->assertEqual(filter_default_format($second_user), $second_format->format, t("The second user's default format is the lowest weighted format that the user has access to, and is different than the first user's."));
+
+    // Reorder the two formats, and check that both users now have the same
+    // default.
+    $edit = array();
+    $edit['formats[' . $second_format->format . '][weight]'] = $minimum_weight - 3;
+    $this->drupalPost('admin/config/content/formats', $edit, t('Save changes'));
+    $this->resetFilterCaches();
+    $this->assertEqual(filter_default_format($first_user), filter_default_format($second_user), t('After the formats are reordered, both users have the same default format.'));
+  }
+
+  /**
+   * Rebuild text format and permission caches in the thread running the tests.
+   */
+  protected function resetFilterCaches() {
+    filter_formats_reset();
+    $this->checkPermissions(array(), TRUE);
+  }
+}

core/modules/filter/lib/Drupal/filter/Tests/FilterFormatAccessTest.php

+<?php
+
+/**
+ * @file
+ * Definition of Drupal\filter\Tests\FilterFormatAccessTest.
+ */
+
+namespace Drupal\filter\Tests;
+
+use Drupal\simpletest\WebTestBase;
+
+class FilterFormatAccessTest extends WebTestBase {
+  protected $admin_user;
+  protected $filter_admin_user;
+  protected $web_user;
+  protected $allowed_format;
+  protected $disallowed_format;
+
+  public static function getInfo() {
+    return array(
+      'name' => 'Filter format access',
+      'description' => 'Tests access to text formats.',
+      'group' => 'Filter',
+    );
+  }
+
+  function setUp() {
+    parent::setUp();
+
+    $this->drupalCreateContentType(array('type' => 'page', 'name' => 'Basic page'));
+
+    // Create a user who can administer text formats, but does not have
+    // specific permission to use any of them.
+    $this->filter_admin_user = $this->drupalCreateUser(array(
+      'administer filters',
+      'create page content',
+      'edit any page content',
+    ));
+
+    // Create two text formats.
+    $this->drupalLogin($this->filter_admin_user);
+    $formats = array();
+    for ($i = 0; $i < 2; $i++) {
+      $edit = array(
+        'format' => drupal_strtolower($this->randomName()),
+        'name' => $this->randomName(),
+      );
+      $this->drupalPost('admin/config/content/formats/add', $edit, t('Save configuration'));
+      $this->resetFilterCaches();
+      $formats[] = filter_format_load($edit['format']);
+    }
+    list($this->allowed_format, $this->disallowed_format) = $formats;
+    $this->drupalLogout();
+
+    // Create a regular user with access to one of the formats.
+    $this->web_user = $this->drupalCreateUser(array(
+      'create page content',
+      'edit any page content',
+      filter_permission_name($this->allowed_format),
+    ));
+
+    // Create an administrative user who has access to use both formats.
+    $this->admin_user = $this->drupalCreateUser(array(
+      'administer filters',
+      'create page content',
+      'edit any page content',
+      filter_permission_name($this->allowed_format),
+      filter_permission_name($this->disallowed_format),
+    ));
+  }
+
+  function testFormatPermissions() {
+    // Make sure that a regular user only has access to the text format they
+    // were granted access to, as well to the fallback format.
+    $this->assertTrue(filter_access($this->allowed_format, $this->web_user), t('A regular user has access to a text format they were granted access to.'));
+    $this->assertFalse(filter_access($this->disallowed_format, $this->web_user), t('A regular user does not have access to a text format they were not granted access to.'));
+    $this->assertTrue(filter_access(filter_format_load(filter_fallback_format()), $this->web_user), t('A regular user has access to the fallback format.'));
+
+    // Perform similar checks as above, but now against the entire list of
+    // available formats for this user.
+    $this->assertTrue(in_array($this->allowed_format->format, array_keys(filter_formats($this->web_user))), t('The allowed format appears in the list of available formats for a regular user.'));
+    $this->assertFalse(in_array($this->disallowed_format->format, array_keys(filter_formats($this->web_user))), t('The disallowed format does not appear in the list of available formats for a regular user.'));
+    $this->assertTrue(in_array(filter_fallback_format(), array_keys(filter_formats($this->web_user))), t('The fallback format appears in the list of available formats for a regular user.'));
+
+    // Make sure that a regular user only has permission to use the format
+    // they were granted access to.
+    $this->assertTrue(user_access(filter_permission_name($this->allowed_format), $this->web_user), t('A regular user has permission to use the allowed text format.'));
+    $this->assertFalse(user_access(filter_permission_name($this->disallowed_format), $this->web_user), t('A regular user does not have permission to use the disallowed text format.'));
+
+    // Make sure that the allowed format appears on the node form and that
+    // the disallowed format does not.
+    $this->drupalLogin($this->web_user);
+    $this->drupalGet('node/add/page');
+    $langcode = LANGUAGE_NOT_SPECIFIED;
+    $elements = $this->xpath('//select[@name=:name]/option', array(
+      ':name' => "body[$langcode][0][format]",
+      ':option' => $this->allowed_format->format,
+    ));
+    $options = array();
+    foreach ($elements as $element) {
+      $options[(string) $element['value']] = $element;
+    }
+    $this->assertTrue(isset($options[$this->allowed_format->format]), t('The allowed text format appears as an option when adding a new node.'));
+    $this->assertFalse(isset($options[$this->disallowed_format->format]), t('The disallowed text format does not appear as an option when adding a new node.'));
+    $this->assertTrue(isset($options[filter_fallback_format()]), t('The fallback format appears as an option when adding a new node.'));
+  }
+
+  function testFormatRoles() {
+    // Get the role ID assigned to the regular user; it must be the maximum.
+    $rid = max(array_keys($this->web_user->roles));
+
+    // Check that this role appears in the list of roles that have access to an
+    // allowed text format, but does not appear in the list of roles that have
+    // access to a disallowed text format.
+    $this->assertTrue(in_array($rid, array_keys(filter_get_roles_by_format($this->allowed_format))), t('A role which has access to a text format appears in the list of roles that have access to that format.'));
+    $this->assertFalse(in_array($rid, array_keys(filter_get_roles_by_format($this->disallowed_format))), t('A role which does not have access to a text format does not appear in the list of roles that have access to that format.'));
+
+    // Check that the correct text format appears in the list of formats
+    // available to that role.
+    $this->assertTrue(in_array($this->allowed_format->format, array_keys(filter_get_formats_by_role($rid))), t('A text format which a role has access to appears in the list of formats available to that role.'));
+    $this->assertFalse(in_array($this->disallowed_format->format, array_keys(filter_get_formats_by_role($rid))), t('A text format which a role does not have access to does not appear in the list of formats available to that role.'));
+
+    // Check that the fallback format is always allowed.
+    $this->assertEqual(filter_get_roles_by_format(filter_format_load(filter_fallback_format())), user_roles(), t('All roles have access to the fallback format.'));
+    $this->assertTrue(in_array(filter_fallback_format(), array_keys(filter_get_formats_by_role($rid))), t('The fallback format appears in the list of allowed formats for any role.'));
+  }
+
+  /**
+   * Test editing a page using a disallowed text format.
+   *
+   * Verifies that regular users and administrators are able to edit a page,
+   * but not allowed to change the fields which use an inaccessible text
+   * format. Also verifies that fields which use a text format that does not
+   * exist can be edited by administrators only, but that the administrator is
+   * forced to choose a new format before saving the page.
+   */
+  function testFormatWidgetPermissions() {
+    $langcode = LANGUAGE_NOT_SPECIFIED;
+    $title_key = "title";
+    $body_value_key = "body[$langcode][0][value]";
+    $body_format_key = "body[$langcode][0][format]";
+
+    // Create node to edit.
+    $this->drupalLogin($this->admin_user);
+    $edit = array();
+    $edit['title'] = $this->randomName(8);
+    $edit[$body_value_key] = $this->randomName(16);
+    $edit[$body_format_key] = $this->disallowed_format->format;
+    $this->drupalPost('node/add/page', $edit, t('Save'));
+    $node = $this->drupalGetNodeByTitle($edit['title']);
+
+    // Try to edit with a less privileged user.
+    $this->drupalLogin($this->web_user);
+    $this->drupalGet('node/' . $node->nid);
+    $this->clickLink(t('Edit'));
+
+    // Verify that body field is read-only and contains replacement value.
+    $this->assertFieldByXPath("//textarea[@name='$body_value_key' and @disabled='disabled']", t('This field has been disabled because you do not have sufficient permissions to edit it.'), t('Text format access denied message found.'));
+
+    // Verify that title can be changed, but preview displays original body.
+    $new_edit = array();
+    $new_edit['title'] = $this->randomName(8);
+    $this->drupalPost(NULL, $new_edit, t('Preview'));
+    $this->assertText($edit[$body_value_key], t('Old body found in preview.'));
+
+    // Save and verify that only the title was changed.
+    $this->drupalPost(NULL, $new_edit, t('Save'));
+    $this->assertNoText($edit['title'], t('Old title not found.'));
+    $this->assertText($new_edit['title'], t('New title found.'));
+    $this->assertText($edit[$body_value_key], t('Old body found.'));
+
+    // Check that even an administrator with "administer filters" permission
+    // cannot edit the body field if they do not have specific permission to
+    // use its stored format. (This must be disallowed so that the
+    // administrator is never forced to switch the text format to something
+    // else.)
+    $this->drupalLogin($this->filter_admin_user);
+    $this->drupalGet('node/' . $node->nid . '/edit');
+    $this->assertFieldByXPath("//textarea[@name='$body_value_key' and @disabled='disabled']", t('This field has been disabled because you do not have sufficient permissions to edit it.'), t('Text format access denied message found.'));
+
+    // Disable the text format used above.
+    filter_format_disable($this->disallowed_format);
+    $this->resetFilterCaches();
+
+    // Log back in as the less privileged user and verify that the body field
+    // is still disabled, since the less privileged user should not be able to
+    // edit content that does not have an assigned format.
+    $this->drupalLogin($this->web_user);
+    $this->drupalGet('node/' . $node->nid . '/edit');
+    $this->assertFieldByXPath("//textarea[@name='$body_value_key' and @disabled='disabled']", t('This field has been disabled because you do not have sufficient permissions to edit it.'), t('Text format access denied message found.'));
+
+    // Log back in as the filter administrator and verify that the body field
+    // can be edited.
+    $this->drupalLogin($this->filter_admin_user);
+    $this->drupalGet('node/' . $node->nid . '/edit');
+    $this->assertNoFieldByXPath("//textarea[@name='$body_value_key' and @disabled='disabled']", NULL, t('Text format access denied message not found.'));
+    $this->assertFieldByXPath("//select[@name='$body_format_key']", NULL, t('Text format selector found.'));
+
+    // Verify that trying to save the node without selecting a new text format
+    // produces an error message, and does not result in the node being saved.
+    $old_title = $new_edit['title'];
+    $new_title = $this->randomName(8);
+    $edit = array('title' => $new_title);
+    $this->drupalPost('node/' . $node->nid . '/edit', $edit, t('Save'));
+    $this->assertText(t('!name field is required.', array('!name' => t('Text format'))), t('Error message is displayed.'));
+    $this->drupalGet('node/' . $node->nid);
+    $this->assertText($old_title, t('Old title found.'));
+    $this->assertNoText($new_title, t('New title not found.'));
+
+    // Now select a new text format and make sure the node can be saved.
+    $edit[$body_format_key] = filter_fallback_format();
+    $this->drupalPost('node/' . $node->nid . '/edit', $edit, t('Save'));
+    $this->assertUrl('node/' . $node->nid);
+    $this->assertText($new_title, t('New title found.'));
+    $this->assertNoText($old_title, t('Old title not found.'));
+
+    // Switch the text format to a new one, then disable that format and all
+    // other formats on the site (leaving only the fallback format).
+    $this->drupalLogin($this->admin_user);
+    $edit = array($body_format_key => $this->allowed_format->format);
+    $this->drupalPost('node/' . $node->nid . '/edit', $edit, t('Save'));
+    $this->assertUrl('node/' . $node->nid);
+    foreach (filter_formats() as $format) {
+      if ($format->format != filter_fallback_format()) {
+        filter_format_disable($format);
+      }
+    }
+
+    // Since there is now only one available text format, the widget for
+    // selecting a text format would normally not display when the content is
+    // edited. However, we need to verify that the filter administrator still
+    // is forced to make a conscious choice to reassign the text to a different
+    // format.
+    $this->drupalLogin($this->filter_admin_user);
+    $old_title = $new_title;
+    $new_title = $this->randomName(8);
+    $edit = array('title' => $new_title);
+    $this->drupalPost('node/' . $node->nid . '/edit', $edit, t('Save'));
+    $this->assertText(t('!name field is required.', array('!name' => t('Text format'))), t('Error message is displayed.'));
+    $this->drupalGet('node/' . $node->nid);
+    $this->assertText($old_title, t('Old title found.'));
+    $this->assertNoText($new_title, t('New title not found.'));
+    $edit[$body_format_key] = filter_fallback_format();
+    $this->drupalPost('node/' . $node->nid . '/edit', $edit, t('Save'));
+    $this->assertUrl('node/' . $node->nid);
+    $this->assertText($new_title, t('New title found.'));
+    $this->assertNoText($old_title, t('Old title not found.'));
+  }
+
+  /**
+   * Rebuild text format and permission caches in the thread running the tests.
+   */
+  protected function resetFilterCaches() {
+    filter_formats_reset();
+    $this->checkPermissions(array(), TRUE);
+  }
+}

core/modules/filter/lib/Drupal/filter/Tests/FilterHooksTest.php

+<?php
+
+/**
+ * @file
+ * Definition of Drupal\filter\Tests\FilterHooksTest.
+ */
+
+namespace Drupal\filter\Tests;
+
+use Drupal\simpletest\WebTestBase;
+
+/**
+ * Tests for filter hook invocation.
+ */
+class FilterHooksTest extends WebTestBase {
+  public static function getInfo() {
+    return array(
+      'name' => 'Filter format hooks',
+      'description' => 'Test hooks for text formats insert/update/disable.',
+      'group' => 'Filter',
+    );
+  }
+
+  function setUp() {
+    parent::setUp('block', 'filter_test');
+    $admin_user = $this->drupalCreateUser(array('administer filters', 'administer blocks'));
+    $this->drupalLogin($admin_user);
+  }
+
+  /**
+   * Test that hooks run correctly on creating, editing, and deleting a text format.
+   */
+  function testFilterHooks() {
+    // Add a text format.
+    $name = $this->randomName();
+    $edit = array();
+    $edit['format'] = drupal_strtolower($this->randomName());
+    $edit['name'] = $name;
+    $edit['roles[' . DRUPAL_ANONYMOUS_RID . ']'] = 1;
+    $this->drupalPost('admin/config/content/formats/add', $edit, t('Save configuration'));
+    $this->assertRaw(t('Added text format %format.', array('%format' => $name)), t('New format created.'));
+    $this->assertText('hook_filter_format_insert invoked.', t('hook_filter_format_insert was invoked.'));
+
+    $format_id = $edit['format'];
+
+    // Update text format.
+    $edit = array();
+    $edit['roles[' . DRUPAL_AUTHENTICATED_RID . ']'] = 1;
+    $this->drupalPost('admin/config/content/formats/' . $format_id, $edit, t('Save configuration'));
+    $this->assertRaw(t('The text format %format has been updated.', array('%format' => $name)), t('Format successfully updated.'));
+    $this->assertText('hook_filter_format_update invoked.', t('hook_filter_format_update() was invoked.'));
+
+    // Add a new custom block.
+    $custom_block = array();
+    $custom_block['info'] = $this->randomName(8);
+    $custom_block['title'] = $this->randomName(8);
+    $custom_block['body[value]'] = $this->randomName(32);
+    // Use the format created.
+    $custom_block['body[format]'] = $format_id;
+    $this->drupalPost('admin/structure/block/add', $custom_block, t('Save block'));
+    $this->assertText(t('The block has been created.'), t('New block successfully created.'));
+
+    // Verify the new block is in the database.
+    $bid = db_query("SELECT bid FROM {block_custom} WHERE info = :info", array(':info' => $custom_block['info']))->fetchField();
+    $this->assertNotNull($bid, t('New block found in database'));
+
+    // Disable the text format.
+    $this->drupalPost('admin/config/content/formats/' . $format_id . '/disable', array(), t('Disable'));
+    $this->assertRaw(t('Disabled text format %format.', array('%format' => $name)), t('Format successfully disabled.'));
+    $this->assertText('hook_filter_format_disable invoked.', t('hook_filter_format_disable() was invoked.'));
+  }
+}

core/modules/filter/lib/Drupal/filter/Tests/FilterNoFormatTest.php

+<?php
+
+/**
+ * @file
+ * Definition of Drupal\filter\Tests\FilterNoFormatTest.
+ */
+
+namespace Drupal\filter\Tests;
+
+use Drupal\simpletest\WebTestBase;
+
+class FilterNoFormatTest extends WebTestBase {
+  public static function getInfo() {
+    return array(
+      'name' => 'Unassigned text format functionality',
+      'description' => 'Test the behavior of check_markup() when it is called without a text format.',
+      'group' => 'Filter',
+    );
+  }
+
+  function testCheckMarkupNoFormat() {
+    // Create some text. Include some HTML and line breaks, so we get a good
+    // test of the filtering that is applied to it.
+    $text = "<strong>" . $this->randomName(32) . "</strong>\n\n<div>" . $this->randomName(32) . "</div>";
+
+    // Make sure that when this text is run through check_markup() with no text
+    // format, it is filtered as though it is in the fallback format.
+    $this->assertEqual(check_markup($text), check_markup($text, filter_fallback_format()), t('Text with no format is filtered the same as text in the fallback format.'));
+  }
+}

core/modules/filter/lib/Drupal/filter/Tests/FilterSecurityTest.php

+<?php
+
+/**
+ * @file
+ * Definition of Drupal\filter\Tests\FilterSecurityTest.
+ */
+
+namespace Drupal\filter\Tests;
+
+use Drupal\simpletest\WebTestBase;
+
+/**
+ * Security tests for missing/vanished text formats or filters.
+ */
+class FilterSecurityTest extends WebTestBase {
+  public static function getInfo() {
+    return array(
+      'name' => 'Security',
+      'description' => 'Test the behavior of check_markup() when a filter or text format vanishes.',
+      'group' => 'Filter',
+    );
+  }
+
+  function setUp() {
+    parent::setUp(array('node', 'php', 'filter_test'));
+
+    // Create Basic page node type.
+    $this->drupalCreateContentType(array('type' => 'page', 'name' => 'Basic page'));
+
+    // Create Filtered HTML format.
+    $filtered_html_format = array(
+      'format' => 'filtered_html',
+      'name' => 'Filtered HTML',
+    );
+    $filtered_html_format = (object) $filtered_html_format;
+    filter_format_save($filtered_html_format);
+
+    $filtered_html_permission = filter_permission_name($filtered_html_format);
+    user_role_grant_permissions(DRUPAL_ANONYMOUS_RID, array($filtered_html_permission));
+
+    $this->admin_user = $this->drupalCreateUser(array('administer modules', 'administer filters', 'administer site configuration'));
+    $this->drupalLogin($this->admin_user);
+  }
+
+  /**
+   * Test that filtered content is emptied when an actively used filter module is disabled.
+   */
+  function testDisableFilterModule() {
+    // Create a new node.
+    $node = $this->drupalCreateNode(array('promote' => 1));
+    $body_raw = $node->body[LANGUAGE_NOT_SPECIFIED][0]['value'];
+    $format_id = $node->body[LANGUAGE_NOT_SPECIFIED][0]['format'];
+    $this->drupalGet('node/' . $node->nid);
+    $this->assertText($body_raw, t('Node body found.'));
+
+    // Enable the filter_test_replace filter.
+    $edit = array(
+      'filters[filter_test_replace][status]' => 1,
+    );
+    $this->drupalPost('admin/config/content/formats/' . $format_id, $edit, t('Save configuration'));
+
+    // Verify that filter_test_replace filter replaced the content.
+    $this->drupalGet('node/' . $node->nid);
+    $this->assertNoText($body_raw, t('Node body not found.'));
+    $this->assertText('Filter: Testing filter', t('Testing filter output found.'));
+
+    // Disable the text format entirely.
+    $this->drupalPost('admin/config/content/formats/' . $format_id . '/disable', array(), t('Disable'));
+
+    // Verify that the content is empty, because the text format does not exist.
+    $this->drupalGet('node/' . $node->nid);
+    $this->assertNoText($body_raw, t('Node body not found.'));
+  }
+}

core/modules/filter/lib/Drupal/filter/Tests/FilterSettingsTest.php

+<?php
+
+/**
+ * @file
+ * Definition of Drupal\filter\Tests\FilterSettingsTest.
+ */
+
+namespace Drupal\filter\Tests;
+
+use Drupal\simpletest\WebTestBase;
+
+/**
+ * Tests filter settings.
+ */
+class FilterSettingsTest extends WebTestBase {
+  protected $profile = 'testing';
+
+  public static function getInfo() {
+    return array(
+      'name' => 'Filter settings',
+      'description' => 'Tests filter settings.',
+      'group' => 'Filter',
+    );
+  }
+
+  /**
+   * Tests explicit and implicit default settings for filters.
+   */
+  function testFilterDefaults() {
+    $filter_info = filter_filter_info();
+    $filters = array_fill_keys(array_keys($filter_info), array());
+
+    // Create text format using filter default settings.
+    $filter_defaults_format = (object) array(
+      'format' => 'filter_defaults',
+      'name' => 'Filter defaults',
+      'filters' => $filters,
+    );
+    filter_format_save($filter_defaults_format);
+
+    // Verify that default weights defined in hook_filter_info() were applied.
+    $saved_settings = array();
+    foreach ($filter_defaults_format->filters as $name => $settings) {
+      $expected_weight = (isset($filter_info[$name]['weight']) ? $filter_info[$name]['weight'] : 0);
+      $this->assertEqual($settings['weight'], $expected_weight, format_string('@name filter weight %saved equals %default', array(
+        '@name' => $name,
+        '%saved' => $settings['weight'],
+        '%default' => $expected_weight,
+      )));
+      $saved_settings[$name]['weight'] = $expected_weight;
+    }
+
+    // Re-save the text format.
+    filter_format_save($filter_defaults_format);
+    // Reload it from scratch.
+    filter_formats_reset();
+    $filter_defaults_format = filter_format_load($filter_defaults_format->format);
+    $filter_defaults_format->filters = filter_list_format($filter_defaults_format->format);
+
+    // Verify that saved filter settings have not been changed.
+    foreach ($filter_defaults_format->filters as $name => $settings) {
+      $this->assertEqual($settings->weight, $saved_settings[$name]['weight'], format_string('@name filter weight %saved equals %previous', array(
+        '@name' => $name,
+        '%saved' => $settings->weight,
+        '%previous' => $saved_settings[$name]['weight'],
+      )));
+    }
+  }
+}