source: sipes/modules_contrib/pathauto/pathauto.test @ ef72343

<?php

/**
 * @file
 * Functionality tests for Pathauto.
 *
 * @ingroup pathauto
 */

/**
 * Helper test class with some added functions for testing.
 */
class PathautoTestHelper extends DrupalWebTestCase {
  function setUp(array $modules = array()) {
    $modules[] = 'path';
    $modules[] = 'token';
    $modules[] = 'pathauto';
    $modules[] = 'taxonomy';
    parent::setUp($modules);

    // Clear static caches.
    pathauto_static_reset();
  }

  function assertToken($type, $object, $token, $expected) {
    $this->assertTokens($type, $object, array($token => $expected));
  }

  function assertTokens($type, $object, array $tokens) {
    $values = pathauto_get_placeholders($type, $object);
    $values = $values['values'];
    foreach ($tokens as $token => $expected) {
      $this->assertIdentical($values[$token], $expected, t("Token value for [@token] was '@actual', expected value '@expected'.", array('@token' => $token, '@actual' => $values[$token], '@expected' => $expected)));
    }
  }

  function saveAlias($source, $alias, $language = '') {
    path_set_alias($source, $alias, NULL, $language);
    return db_fetch_array(db_query_range("SELECT * FROM {url_alias} WHERE src = '%s' AND dst = '%s' AND language = '%s' ORDER BY pid DESC", $source, $alias, $language, 0, 1));
  }

  function saveEntityAlias($entity_type, $entity, $alias, $language = '') {
    $uri = $this->entity_uri($entity_type, $entity);
    return $this->saveAlias($uri['path'], $alias, $language);
  }

  function assertEntityAlias($entity_type, $entity, $expected_alias, $language = '') {
    $uri = $this->entity_uri($entity_type, $entity);
    $this->assertAlias($uri['path'], $expected_alias, $language);
  }

  function assertEntityAliasExists($entity_type, $entity) {
    $uri = $this->entity_uri($entity_type, $entity);
    return $this->assertAliasExists(array('source' => $uri['path']));
  }

  function assertNoEntityAlias($entity_type, $entity, $language = '') {
    $uri = $this->entity_uri($entity_type, $entity);
    $this->assertEntityAlias($entity_type, $entity, $uri['path'], $language);
  }

  function assertNoEntityAliasExists($entity_type, $entity) {
    $uri = $this->entity_uri($entity_type, $entity);
    $this->assertNoAliasExists(array('source' => $uri['path']));
  }

  function assertAlias($source, $expected_alias, $language = '') {
    drupal_clear_path_cache();
    $alias = drupal_get_path_alias($source, $language);
    $this->assertIdentical($alias, $expected_alias, t("Alias for %source with language '@language' was %actual, expected %expected.", array('%source' => $source, '%actual' => $alias, '%expected' => $expected_alias, '@language' => $language)));
  }

  function assertAliasExists($conditions) {
    $path = $this->path_load($conditions);
    $this->assertTrue($path, t('Alias with conditions @conditions found.', array('@conditions' => var_export($conditions, TRUE))));
    return $path;
  }

  function assertNoAliasExists($conditions) {
    $alias = $this->path_load($conditions);
    $this->assertFalse($alias, t('Alias with conditions @conditions not found.', array('@conditions' => var_export($conditions, TRUE))));
  }

  /**
   * Backport of Drupal 7's entity_uri() function.
   */
  protected function entity_uri($entity_type, $entity) {
    $uri = array();

    switch ($entity_type) {
      case 'node':
        $uri['path'] = 'node/' . $entity->nid;
        break;
      case 'taxonomy_term':
        $uri['path'] = taxonomy_term_path($entity);
        break;
      case 'user':
        $uri['path'] = 'user/' . $entity->uid;
        break;
      default:
        return $this->fail(t('Unknown entity @type.', array('@type' => $entity_type)));
    }

    return $uri;
  }

  /**
   * Backport of Drupal 7's path_load() function.
   */
  protected function path_load($conditions) {
    if (is_numeric($conditions)) {
      $conditions = array('pid' => $conditions);
    }
    elseif (is_string($conditions)) {
      $conditions = array('src' => $conditions);
    }

    // Adjust for some D7 {url_alias} column name changes so we can keep
    // the test files in sync.
    if (isset($conditions['source'])) {
      $conditions['src'] = $conditions['source'];
      unset($conditions['source']);
    }
    if (isset($conditions['alias'])) {
      $conditions['dst'] = $conditions['alias'];
      unset($conditions['alias']);
    }

    $args = array();
    $schema = drupal_get_schema_unprocessed('system', 'url_alias');
    foreach ($conditions as $field => $value) {
      $field_type = $schema['fields'][$field]['type'];
      if (is_array($value)) {
        $conditions[$field] = "$field = " . db_placeholders($value, $field_type);
        $args = array_merge($args, $value);
      }
      else {
        $placeholder = db_type_placeholder($field_type);
        $conditions[$field] = "$field = $placeholder";
        $args[] = $value;
      }

    }

    $sql = "SELECT * FROM {url_alias} WHERE " . implode(' AND ', $conditions);
    return db_fetch_array(db_query_range($sql, $args, 0, 1));
  }

  function deleteAllAliases() {
    db_query("DELETE FROM {url_alias}");
    drupal_clear_path_cache();
  }

  function addVocabulary(array $vocabulary = array()) {
    $vocabulary += array(
      'name' => drupal_strtolower($this->randomName(5)),
      'nodes' => array('story' => 'story'),
    );
    taxonomy_save_vocabulary($vocabulary);
    return (object) $vocabulary;
  }

  function addTerm(stdClass $vocabulary, array $term = array()) {
    $term += array(
      'name' => drupal_strtolower($this->randomName(5)),
      'vid' => $vocabulary->vid,
    );
    taxonomy_save_term($term);
    return (object) $term;
  }

  function addNodeType(array $type) {
    if (!isset($type['name'])) {
      $type['name'] = $this->randomName(8);
    }

    $type += array(
      'type' => drupal_strtolower($type['name']),
      'module' => 'node',
      'description' => $this->randomName(40),
      'custom' => TRUE,
      'modified' => TRUE,
      'locked' => FALSE,
      'help' => '',
      'min_word_count' => '',
    );

    $type = (object) _node_type_set_defaults($type);
    node_type_save($type);
    node_types_rebuild();
    return $type;
  }

  function assertEntityPattern($entity_type, $bundle, $language = '', $expected) {
    pathauto_static_reset('pathauto_pattern_load_by_entity');
    $this->refreshVariables();
    $pattern = pathauto_pattern_load_by_entity($entity_type, $bundle, $language);
    $this->assertIdentical($expected, $pattern);
  }
}

/**
 * Unit tests for Pathauto functions.
 */
class PathautoUnitTestCase extends PathautoTestHelper {
  public static function getInfo() {
    return array(
      'name' => 'Pathauto unit tests',
      'description' => 'Unit tests for Pathauto functions.',
      'group' => 'Pathauto',
      'dependencies' => array('token'),
    );
  }

  function setUp(array $modules = array()) {
    parent::setUp($modules);
    module_load_include('inc', 'pathauto');
  }

  /**
   * Test _pathauto_get_schema_alias_maxlength().
   */
  function testGetSchemaAliasMaxLength() {
    $this->assertIdentical(_pathauto_get_schema_alias_maxlength(), 128);
  }

  /**
   * Test pathauto_pattern_load_by_entity().
   */
  function testPatternLoadByEntity() {
    variable_set('pathauto_node_story_en_pattern', ' story/en/[node:title] ');
    variable_set('pathauto_node_story_pattern', 'story/[node:title]');
    variable_set('pathauto_node_pattern', 'content/[node:title]');
    variable_set('pathauto_user_pattern', 'users/[user:name]');

    $tests = array(
      array('entity' => 'node', 'bundle' => 'story', 'language' => 'fr', 'expected' => 'story/[node:title]'),
      array('entity' => 'node', 'bundle' => 'story', 'language' => 'en', 'expected' => 'story/en/[node:title]'),
      array('entity' => 'node', 'bundle' => 'story', 'language' => '', 'expected' => 'story/[node:title]'),
      array('entity' => 'node', 'bundle' => 'page', 'language' => 'en', 'expected' => 'content/[node:title]'),
      array('entity' => 'user', 'bundle' => 'user', 'language' => '', 'expected' => 'users/[user:name]'),
      array('entity' => 'invalid-entity', 'bundle' => '', 'language' => '', 'expected' => ''),
    );
    foreach ($tests as $test) {
      $actual = pathauto_pattern_load_by_entity($test['entity'], $test['bundle'], $test['language']);
      $this->assertIdentical($actual, $test['expected'], t("pathauto_pattern_load_by_entity('@entity', '@bundle', '@language') returned '@actual', expected '@expected'", array('@entity' => $test['entity'], '@bundle' => $test['bundle'], '@language' => $test['language'], '@actual' => $actual, '@expected' => $test['expected'])));
    }
  }

  /**
   * Test pathauto_cleanstring().
   */
  function testCleanString() {
    $tests = array();
    variable_set('pathauto_ignore_words', ', in, is,that, the  , this, with, ');
    variable_set('pathauto_max_component_length', 35);

    // Test the 'ignored words' removal.
    $tests['this'] = 'this';
    $tests['this with that'] = 'this-with-that';
    $tests['this thing with that thing'] = 'thing-thing';

    // Test length truncation and duplicate separator removal.
    $tests[' - Pathauto is the greatest - module ever in Drupal history - '] = 'pathauto-greatest-module-ever';

    // Test that HTML tags are removed.
    $tests['This <span class="text">text</span> has <br /><a href="http://example.com"><strong>HTML tags</strong></a>.'] = 'text-has-html-tags';
    $tests[check_plain('This <span class="text">text</span> has <br /><a href="http://example.com"><strong>HTML tags</strong></a>.')] = 'text-has-html-tags';

    foreach ($tests as $input => $expected) {
      $output = pathauto_cleanstring($input);
      $this->assertEqual($output, $expected, t("pathauto_cleanstring('@input') expected '@expected', actual '@output'", array('@input' => $input, '@expected' => $expected, '@output' => $output)));
    }
  }

  /**
   * Test pathauto_path_delete_multiple().
   */
  function testPathDeleteMultiple() {
    $this->saveAlias('node/1', 'node-1-alias');
    $this->saveAlias('node/1/view', 'node-1-alias/view');
    $this->saveAlias('node/1', 'node-1-alias-en', 'en');
    $this->saveAlias('node/1', 'node-1-alias-fr', 'fr');
    $this->saveAlias('node/2', 'node-2-alias');

    pathauto_path_delete_all('node/1');
    $this->assertNoAliasExists(array('source' => "node/1"));
    $this->assertNoAliasExists(array('source' => "node/1/view"));
    $this->assertAliasExists(array('source' => "node/2"));
  }

  /**
   * Test _pathauto_get_raw_tokens().
   */
  function testGetRawTokens() {
    $raw_tokens = _pathauto_get_raw_tokens();
    $this->assertFalse(in_array('node-path', $raw_tokens), 'Non-raw tokens not included.');
    $this->assertTrue(in_array('node-path-raw', $raw_tokens), 'Token [catpath] has a matching raw token.');
    $this->assertFalse(in_array('node-url-raw', $raw_tokens), 'Token [catalias] does not have a matching raw token.');
  }

  /**
   * Test the different update actions in pathauto_create_alias().
   */
  function testUpdateActions() {
    // Test PATHAUTO_UPDATE_ACTION_NO_NEW with unaliased node and 'insert'.
    variable_set('pathauto_update_action', PATHAUTO_UPDATE_ACTION_NO_NEW);
    $node = $this->drupalCreateNode(array('title' => 'First title'));
    $this->assertEntityAlias('node', $node, 'content/first-title');

    // Default action is PATHAUTO_UPDATE_ACTION_DELETE.
    variable_set('pathauto_update_action', PATHAUTO_UPDATE_ACTION_DELETE);
    $node->title = 'Second title';
    pathauto_nodeapi($node, 'update');
    $this->assertEntityAlias('node', $node, 'content/second-title');
    $this->assertNoAliasExists(array('alias' => 'content/first-title'));

    // Test PATHAUTO_UPDATE_ACTION_LEAVE
    variable_set('pathauto_update_action', PATHAUTO_UPDATE_ACTION_LEAVE);
    $node->title = 'Third title';
    pathauto_nodeapi($node, 'update');
    $this->assertEntityAlias('node', $node, 'content/third-title');
    $this->assertAliasExists(array('source' => "node/{$node->nid}", 'alias' => 'content/second-title'));

    variable_set('pathauto_update_action', PATHAUTO_UPDATE_ACTION_DELETE);
    $node->title = 'Fourth title';
    pathauto_nodeapi($node, 'update');
    $this->assertEntityAlias('node', $node, 'content/fourth-title');
    $this->assertNoAliasExists(array('alias' => 'content/third-title'));
    // The older second alias is not deleted yet.
    $older_path = $this->assertAliasExists(array('source' => "node/{$node->nid}", 'alias' => 'content/second-title'));
    path_set_alias(NULL, NULL, $older_path['pid']);

    variable_set('pathauto_update_action', PATHAUTO_UPDATE_ACTION_NO_NEW);
    $node->title = 'Fifth title';
    pathauto_nodeapi($node, 'update');
    $this->assertEntityAlias('node', $node, 'content/fourth-title');
    $this->assertNoAliasExists(array('alias' => 'content/fith-title'));

    // Test PATHAUTO_UPDATE_ACTION_NO_NEW with unaliased node and 'update'.
    $this->deleteAllAliases();
    pathauto_nodeapi($node, 'update');
    $this->assertEntityAlias('node', $node, 'content/fifth-title');

    // Test PATHAUTO_UPDATE_ACTION_NO_NEW with unaliased node and 'bulkupdate'.
    $this->deleteAllAliases();
    $node->title = 'Sixth title';
    pathauto_node_update_alias($node, 'bulkupdate');
    $this->assertEntityAlias('node', $node, 'content/sixth-title');
  }

  /**
   * Test that pathauto_create_alias() will not create an alias for a pattern
   * that does not get any tokens replaced.
   */
  function testNoTokensNoAlias() {
    $node = $this->drupalCreateNode(array('title' => ''));
    $this->assertNoEntityAlias('node', $node);

    $node->title = 'hello';
    pathauto_nodeapi($node, 'update');
    $this->assertEntityAlias('node', $node, 'content/hello');
  }

  /**
   * Test the handling of path vs non-path tokens in pathauto_clean_token_values().
   *
   * @see PathautoBookTokenTestCase::testBookPathAlias()
   */
  //function testPathTokens() {
  //}

  function testEntityBundleRenamingDeleting() {
    // Create a vocabulary type.
    $vocabulary = $this->addVocabulary();
    variable_set('pathauto_taxonomy_pattern', 'base');
    variable_set('pathauto_taxonomy_' . $vocabulary->vid . '_pattern', 'bundle');
    $this->assertEntityPattern('taxonomy', $vocabulary->vid, '', 'bundle');

    // Delete the vocabulary, which should cause its pattern variable to also
    // be deleted.
    taxonomy_del_vocabulary($vocabulary->vid);
    $this->assertEntityPattern('taxonomy', $vocabulary->vid, '', 'base');

    // Create a node type and test that it's pattern variable works.
    $type = $this->addNodeType(array('type' => 'old_name'));
    variable_set('pathauto_node_pattern', 'base');
    variable_set("pathauto_node_old_name_pattern", 'bundle');
    $this->assertEntityPattern('node', 'old_name', '', 'bundle');

    // Rename the node type's machine name, which should cause its pattern
    // variable to also be renamed.
    $type->type = 'new_name';
    $type->old_type = 'old_name';
    node_type_save($type);
    node_types_rebuild();
    $this->assertEntityPattern('node', 'new_name', '', 'bundle');
    $this->assertEntityPattern('node', 'old_name', '', 'base');

    // Delete the node type, which should cause its pattern variable to also
    // be deleted.
    node_type_delete($type->type);
    $this->assertEntityPattern('node', 'new_name', '', 'base');
  }

  function testNoExistingPathAliases() {
    variable_set('pathauto_node_page_pattern', '[title-raw]');
    variable_set('pathauto_punctuation_period', PATHAUTO_PUNCTUATION_DO_NOTHING);

    // Check that Pathauto does not create an alias of '/admin'.
    $node = $this->drupalCreateNode(array('title' => 'Admin', 'type' => 'page'));
    $this->assertNoEntityAlias('node', $node);

    // Check that Pathauto does not create an alias of '/modules'.
    $node->title = 'Modules';
    node_save($node);
    $this->assertNoEntityAlias('node', $node);

    // Check that Pathauto does not create an alias of '/index.php'.
    $node->title = 'index.php';
    node_save($node);
    $this->assertNoEntityAlias('node', $node);

    // Check that a safe value gets an automatic alias. This is also a control
    // to ensure the above tests work properly.
    $node->title = 'Safe value';
    node_save($node);
    $this->assertEntityAlias('node', $node, 'safe-value');
  }

  /**
   * Test pathauto_clean_alias().
   */
  function testCleanAlias() {
    $tests = array();
    $tests['one/two/three'] = 'one/two/three';
    $tests['/one/two/three/'] = 'one/two/three';
    $tests['one//two///three'] = 'one/two/three';
    $tests['one/two--three/-/--/-/--/four---five'] = 'one/two-three/four-five';
    $tests['one/-//three--/four'] = 'one/three/four';
    foreach ($tests as $input => $expected) {
      $output = pathauto_clean_alias($input);
      $this->assertEqual($output, $expected, t("pathauto_clean_alias('@input') expected '@expected', actual '@output'", array('@input' => $input, '@expected' => $expected, '@output' => $output)));
    }
  }

  function testPathAliasUniquifyWordsafe() {
    variable_set('pathauto_max_length', 25);

    $node_1 = $this->drupalCreateNode(array('title' => 'thequick brownfox jumpedover thelazydog', 'type' => 'page'));
    $node_2 = $this->drupalCreateNode(array('title' => 'thequick brownfox jumpedover thelazydog', 'type' => 'page'));

    // Check that pathauto_alias_uniquify is calling truncate_utf8 with $wordsafe param set to TRUE.
    // If it doesn't path alias result would be content/thequick-brownf-0
    $this->assertEntityAlias('node', $node_1, 'content/thequick-brownfox');
    $this->assertEntityAlias('node', $node_2, 'content/thequick-0');
  }
}

/**
 * Helper test class with some added functions for testing.
 */
class PathautoFunctionalTestHelper extends PathautoTestHelper {
  protected $admin_user;

  function setUp(array $modules = array()) {
    parent::setUp($modules);

    // Set pathauto settings we assume to be as-is in this test.
    variable_set('pathauto_node_page_pattern', 'content/[title-raw]');

    // Allow other modules to add additional permissions for the admin user.
    $permissions = array(
      'administer pathauto',
      'administer url aliases',
      'create url aliases',
      'administer nodes',
      'administer users',
    );
    $args = func_get_args();
    if (isset($args[1]) && is_array($args[1])) {
      $permissions = array_merge($permissions, $args[1]);
    }
    $this->admin_user = $this->drupalCreateUser($permissions);

    $this->drupalLogin($this->admin_user);
  }
}

/**
 * Test basic pathauto functionality.
 */
class PathautoFunctionalTestCase extends PathautoFunctionalTestHelper {
  public static function getInfo() {
    return array(
      'name' => 'Pathauto basic tests',
      'description' => 'Test basic pathauto functionality.',
      'group' => 'Pathauto',
      'dependencies' => array('token'),
    );
  }

  /**
   * Basic functional testing of Pathauto.
   */
  function testNodeEditing() {
    // Create node for testing.
    $random_title = $this->randomName(10);
    $title = ' Simpletest title ' . $random_title . ' [';
    $automatic_alias = 'content/simpletest-title-' . strtolower($random_title);
    $node = $this->drupalCreateNode(array('title' => $title, 'type' => 'page'));

    // Look for alias generated in the form.
    $this->drupalGet('node/' . $node->nid . '/edit');
    $this->assertFieldChecked('edit-pathauto-perform-alias');
    $this->assertFieldByName('path', $automatic_alias, 'Proper automated alias generated.');

    // Check whether the alias actually works.
    $this->drupalGet($automatic_alias);
    $this->assertText($title, 'Node accessible through automatic alias.');

    // Manually set the node's alias.
    $manual_alias = 'content/' . $node->nid;
    $edit = array(
      'pathauto_perform_alias' => FALSE,
      'path' => $manual_alias,
    );
    $this->drupalPost('node/' . $node->nid . '/edit', $edit, t('Save'));
    $this->assertText(t('@type @title has been updated', array('@type' => 'Page', '@title' => $title)));

    // Check that the automatic alias checkbox is now unchecked by default.
    $this->drupalGet('node/' . $node->nid . '/edit');
    $this->assertNoFieldChecked('edit-pathauto-perform-alias');
    $this->assertFieldByName('path', $manual_alias);

    // Submit the node form with the default values.
    $this->drupalPost(NULL, array(), t('Save'));
    $this->assertText(t('@type @title has been updated', array('@type' => 'Page', '@title' => $title)));

    // Test that the old (automatic) alias has been deleted and only accessible
    // through the new (manual) alias.
    $this->drupalGet($automatic_alias);
    $this->assertResponse(404, 'Node not accessible through automatic alias.');
    $this->drupalGet($manual_alias);
    $this->assertText($title, 'Node accessible through manual alias.');
  }

  /**
   * Test node operations.
   */
  function testNodeOperations() {
    $node1 = $this->drupalCreateNode(array('title' => 'node1'));
    $node2 = $this->drupalCreateNode(array('title' => 'node2'));

    // Delete all current URL aliases.
    $this->deleteAllAliases();

    $edit = array(
      'operation' => 'pathauto_update_alias',
      "nodes[{$node1->nid}]" => TRUE,
    );
    $this->drupalPost('admin/content/node', $edit, t('Update'));
    $this->assertText('Updated URL alias for 1 node.');

    $this->assertEntityAlias('node', $node1, 'content/' . $node1->title);
    $this->assertEntityAlias('node', $node2, 'node/' . $node2->nid);
  }

  /**
   * Test user operations.
   */
  function testUserOperations() {
    $account = $this->drupalCreateUser();

    // Delete all current URL aliases.
    $this->deleteAllAliases();

    $edit = array(
      'operation' => 'pathauto_update_alias',
      "accounts[{$account->uid}]" => TRUE,
    );
    $this->drupalPost('admin/user/user', $edit, t('Update'));
    $this->assertText('Updated URL alias for 1 user account.');

    $this->assertEntityAlias('user', $account, 'users/' . drupal_strtolower($account->name));
    $this->assertEntityAlias('user', $this->admin_user, 'user/' . $this->admin_user->uid);
  }

  function testSettingsValidation() {
    $edit = array();
    $edit['pathauto_max_length'] = 'abc';
    $edit['pathauto_max_component_length'] = 'abc';
    $this->drupalPost('admin/build/path/settings', $edit, 'Save configuration');
    $this->assertText('The field Maximum alias length is not a valid number.');
    $this->assertText('The field Maximum component length is not a valid number.');
    $this->assertNoText('The configuration options have been saved.');

    $edit['pathauto_max_length'] = '0';
    $edit['pathauto_max_component_length'] = '0';
    $this->drupalPost('admin/build/path/settings', $edit, 'Save configuration');
    $this->assertText('The field Maximum alias length cannot be less than 1.');
    $this->assertText('The field Maximum component length cannot be less than 1.');
    $this->assertNoText('The configuration options have been saved.');

    $edit['pathauto_max_length'] = '999';
    $edit['pathauto_max_component_length'] = '999';
    $this->drupalPost('admin/build/path/settings', $edit, 'Save configuration');
    $this->assertText('The field Maximum alias length cannot be greater than 128.');
    $this->assertText('The field Maximum component length cannot be greater than 128.');
    $this->assertNoText('The configuration options have been saved.');

    $edit['pathauto_max_length'] = '50';
    $edit['pathauto_max_component_length'] = '50';
    $this->drupalPost('admin/build/path/settings', $edit, 'Save configuration');
    $this->assertText('The configuration options have been saved.');
  }

  function testPatternsValidation() {
    $edit = array();
    $edit['pathauto_node_pattern'] = '[title-raw]/[user-created-small]/[cat]/[term]';
    $edit['pathauto_node_page_pattern'] = 'page';
    $this->drupalPost('admin/build/path/patterns', $edit, 'Save configuration');
    $this->assertText('The Default path pattern (applies to all node types with blank patterns below) is using the following invalid tokens: [user-created-small], [cat].');
    $this->assertText('The Pattern for all Page paths cannot contain fewer than one token.');
    $this->assertNoText('The configuration options have been saved.');

    $edit['pathauto_node_pattern'] = '[title-raw]';
    $edit['pathauto_node_page_pattern'] = 'page/[title-raw]';
    $edit['pathauto_node_story_pattern'] = '';
    $this->drupalPost('admin/build/path/patterns', $edit, 'Save configuration');
    $this->assertText('The configuration options have been saved.');
  }
}

class PathautoLocaleTestCase extends PathautoFunctionalTestHelper {
  public static function getInfo() {
    return array(
      'name' => 'Pathauto localization tests',
      'description' => 'Test pathauto functionality with localization and translation.',
      'group' => 'Pathauto',
      'dependencies' => array('token'),
    );
  }

  function setUp(array $modules = array()) {
    $modules[] = 'locale';
    $modules[] = 'translation';
    parent::setUp($modules, array('administer languages'));

    // Add predefined French language and reset the locale cache.
    require_once './includes/locale.inc';
    locale_add_language('fr', NULL, NULL, LANGUAGE_LTR, '', 'fr');
    language_list('language', TRUE);
    drupal_init_language();
  }

  /**
   * Test that when an English node is updated, its old English alias is
   * updated and its newer French alias is left intact.
   */
  function testLanguageAliases() {
    $node = array(
      'title' => 'English node',
      'language' => 'en',
      'path' => 'english-node',
      'pathauto_perform_alias' => FALSE,
    );
    $node = $this->drupalCreateNode($node);
    $english_alias = $this->path_load(array('alias' => 'english-node'));
    $this->assertTrue($english_alias, 'Alias created with proper language.');

    // Also save a French alias that should not be left alone, even though
    // it is the newer alias.
    $this->saveEntityAlias('node', $node, 'french-node', 'fr');

    // Add an alias with the soon-to-be generated alias, causing the upcoming
    // alias update to generate a unique alias with the '-0' suffix.
    $this->saveAlias('node/invalid', 'content/english-node', '');

    // Update the node, triggering a change in the English alias.
    $node->pathauto_perform_alias = TRUE;
    pathauto_nodeapi($node, 'update');

    // Check that the new English alias replaced the old one.
    $this->assertEntityAlias('node', $node, 'content/english-node-0', 'en');
    $this->assertEntityAlias('node', $node, 'french-node', 'fr');
    $this->assertAliasExists(array('pid' => $english_alias['pid'], 'alias' => 'content/english-node-0'));
  }
}

/**
 * Bulk update functionality tests.
 */
class PathautoBulkUpdateTestCase extends PathautoFunctionalTestHelper {
  private $nodes;

  public static function getInfo() {
    return array(
      'name' => 'Pathauto bulk updating',
      'description' => 'Tests bulk updating of URL aliases.',
      'group' => 'Pathauto',
      'dependencies' => array('token'),
    );
  }

  function testBulkUpdate() {
    // Create some nodes.
    $this->nodes = array();
    for ($i = 1; $i <= 5; $i++) {
      $node = $this->drupalCreateNode();
      $this->nodes[$node->nid] = $node;
    }

    // Clear out all aliases.
    $this->deleteAllAliases();

    // Bulk create aliases.
    $edit = array(
      'update[node_pathauto_bulk_update_batch_process]' => TRUE,
      'update[user_pathauto_bulk_update_batch_process]' => TRUE,
    );
    $this->drupalPost('admin/build/path/update_bulk', $edit, t('Update'));
    $this->assertText('Generated 7 URL aliases.'); // 5 nodes + 2 users

    // Check that aliases have actually been created.
    foreach ($this->nodes as $node) {
      $this->assertEntityAliasExists('node', $node);
    }
    $this->assertEntityAliasExists('user', $this->admin_user);

    // Add a new node.
    $new_node = $this->drupalCreateNode(array('alias' => '', 'pathauto_perform_alias' => FALSE));

    // Run the update again which should only run against the new node.
    $this->drupalPost('admin/build/path/update_bulk', $edit, t('Update'));
    $this->assertText('Generated 1 URL alias.'); // 1 node + 0 users

    $this->assertEntityAliasExists('node', $new_node);
  }
}

/*
 * Unit tests for the book tokens provided by Pathauto.
 */
class PathautoBookTokenTestCase extends PathautoTestHelper {
  public static function getInfo() {
    return array(
      'name' => 'Pathauto book tokens',
      'description' => 'Unit tests for the book tokens provided by Pathauto.',
      'group' => 'Pathauto',
      'dependencies' => array('token'),
    );
  }

  function setUp(array $modules = array()) {
    $modules[] = 'book';
    parent::setUp($modules);

    variable_set('book_allowed_types', array('book', 'page'));
    variable_set('pathauto_node_book_pattern', '[bookpathalias]/[title-raw]');
  }

  function testBookPathAlias() {
    // Add a non-book node.
    $non_book_node = $this->drupalCreateNode(array('type' => 'book'));
    $this->assertToken('node', $non_book_node, 'bookpathalias', '');

    // Add a root book page.
    $parent_node = $this->drupalCreateNode(array(
      'type' => 'book',
      'title' => 'Root',
      'book' => array('bid' => 'new') + _book_link_defaults('new'),
    ));
    $tokens = array(
      'bookpathalias' => '',
    );
    $this->assertTokens('node', $parent_node, $tokens);

    // Add a first child page.
    $child_node1 = $this->drupalCreateNode(array(
      'type' => 'book',
      'title' => 'Sub page1',
      'book' => array(
        'bid' => $parent_node->book['bid'],
        'plid' => $parent_node->book['mlid'],
      ) + _book_link_defaults('new'),
    ));
    $tokens = array(
      'bookpathalias' => 'root',
    );
    $this->assertTokens('node', $child_node1, $tokens);

    // Add a second child page.
    $child_node2 = $this->drupalCreateNode(array(
      'type' => 'book',
      'title' => 'Sub page2',
      'book' => array(
        'bid' => $parent_node->book['bid'],
        'plid' => $parent_node->book['mlid'],
      ) + _book_link_defaults('new'),
    ));
    $tokens = array(
      'bookpathalias' => 'root',
    );
    $this->assertTokens('node', $child_node2, $tokens);

    // Add a child page on an existing child page.
    $sub_child_node1 = $this->drupalCreateNode(array(
      'type' => 'book',
      'title' => 'Sub-sub Page1',
      'book' => array(
        'bid' => $parent_node->book['bid'],
        'plid' => $child_node1->book['mlid'],
      ) + _book_link_defaults('new'),
    ));
    $tokens = array(
      'bookpathalias' => 'root/sub-page1',
    );
    $this->assertTokens('node', $sub_child_node1, $tokens);

    // Test that path tokens should not be altered.
    $this->saveEntityAlias('node', $child_node1, 'My Crazy/Alias/');
    pathauto_nodeapi($sub_child_node1, 'update');
    $this->assertEntityAlias('node', $sub_child_node1, 'My Crazy/Alias/sub-sub-page1');
  }
}

/*
 * Unit tests for the taxonomy tokens provided by Pathauto.
 */
class PathautoTaxonomyTokenTestCase extends PathautoFunctionalTestHelper {
  protected $vocab;

  public static function getInfo() {
    return array(
      'name' => 'Pathauto taxonomy tokens',
      'description' => 'Unit tests for the taxonomy tokens provided by Pathauto.',
      'group' => 'Pathauto',
      'dependencies' => array('token'),
    );
  }

  function setUp(array $modules = array()) {
    $modules[] = 'taxonomy';
    parent::setUp($modules);

    variable_set('pathauto_taxonomy_pattern', 'category/[vocab-raw]/[cat-raw]');
    // Reset the static taxonomy.module caches.
    taxonomy_vocabulary_load(0, TRUE);
    taxonomy_get_term(0, TRUE);
    $this->vocab = $this->addVocabulary();
  }

  /**
   * Test the [catpath] and [catalias] tokens.
   */
  function testCatTokens() {
    $term1 = $this->addTerm($this->vocab);
    $tokens = array(
      'catpath' => $term1->name,
      'catalias' => "category/{$this->vocab->name}/{$term1->name}",
    );
    $this->assertTokens('taxonomy', $term1, $tokens);

    // Change the term name to check that the alias is also changed.
    // Regression test for http://drupal.org/node/822174.
    $term1->oldname = $term1->name;
    $term1->name = drupal_strtolower($this->randomName());
    $form_values = (array) $term1;
    taxonomy_save_term($form_values);
    $tokens = array(
      'catpath' => $term1->name,
    );
    $this->assertTokens('taxonomy', $term1, $tokens);

    $term2 = $this->addTerm($this->vocab, array('parent' => $term1->tid));
    $tokens = array(
      'catpath' => "{$term1->name}/{$term2->name}",
      'catalias' => "category/{$this->vocab->name}/{$term2->name}",
    );
    $this->assertTokens('taxonomy', $term2, $tokens);

    $term3 = $this->addTerm($this->vocab, array('parent' => $term2->tid, 'name' => ' foo/bar fer|zle '));
    $tokens = array(
      'catpath' => "{$term1->name}/{$term2->name}/foobar-ferzle",
      'catalias' => "category/{$this->vocab->name}/foobar-ferzle",
    );
    $this->assertTokens('taxonomy', $term3, $tokens);
  }

  /**
   * Test the [termpath] token.
   */
  function testTermTokens() {
    $term1 = $this->addTerm($this->vocab, array('weight' => 5));
    $term2 = $this->addTerm($this->vocab, array('weight' => -5));
    $term3 = $this->addTerm($this->vocab, array('weight' => 0));

    $node = $this->drupalCreateNode(array(
      'type' => 'story',
      'taxonomy' => array($term1->tid, $term2->tid, $term3->tid),
    ));
    $tokens = array(
      'termpath' => $term2->name,
      'termalias' => "category/{$this->vocab->name}/{$term2->name}",
    );
    $this->assertTokens('node', $node, $tokens);
    $this->assertToken('node', $node, 'termpath', $term2->name);
    $this->assertToken('node', $node, 'termalias', "category/{$this->vocab->name}/{$term2->name}");

    $non_term_node = $this->drupalCreateNode(array('type' => 'story'));
    $tokens = array(
      'termpath' => '',
      'termalias' => '',
    );
    $this->assertTokens('node', $non_term_node, $tokens);
  }
}