Club Drupal

<?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);

  }

  function assertToken($type, $object, $token, $expected) {

    $tokens = token_generate($type, array($token => $token), array($type => $object));

    $tokens += array($token => '');

    $this->assertIdentical($tokens[$token], $expected, t("Token value for [@type:@token] was '@actual', expected value '@expected'.", array('@type' => $type, '@token' => $token, '@actual' => $tokens[$token], '@expected' => $expected)));

  }

  function saveAlias($source, $alias, $language = LANGUAGE_NONE) {

    $alias = array(

      'source' => $source,

      'alias' => $alias,

      'language' => $language,

    );

    path_save($alias);

    return $alias;

  }

  function saveEntityAlias($entity_type, $entity, $alias, $language = LANGUAGE_NONE) {

    $uri = entity_uri($entity_type, $entity);

    return $this->saveAlias($uri['path'], $alias, $language);

  }

  function assertEntityAlias($entity_type, $entity, $expected_alias, $language = LANGUAGE_NONE) {

    $uri = entity_uri($entity_type, $entity);

    $this->assertAlias($uri['path'], $expected_alias, $language);

  }

  function assertEntityAliasExists($entity_type, $entity) {

    $uri = entity_uri($entity_type, $entity);

    return $this->assertAliasExists(array('source' => $uri['path']));

  }

  function assertNoEntityAlias($entity_type, $entity, $language = LANGUAGE_NONE) {

    $uri = entity_uri($entity_type, $entity);

    $this->assertEntityAlias($entity_type, $entity, $uri['path'], $language);

  }

  function assertNoEntityAliasExists($entity_type, $entity, $alias = NULL) {

    $uri = entity_uri($entity_type, $entity);

    $path = array('source' => $uri['path']);

    if (!empty($alias)) {

      $path['alias'] = $alias;

    }

    $this->assertNoAliasExists($path);

  }

  function assertAlias($source, $expected_alias, $language = LANGUAGE_NONE) {

    drupal_clear_path_cache($source);

    $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 = path_load($conditions);

    $this->assertTrue($path, t('Alias with conditions @conditions found.', array('@conditions' => var_export($conditions, TRUE))));

    return $path;

  }

  function assertNoAliasExists($conditions) {

    $alias = path_load($conditions);

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

  }

  function deleteAllAliases() {

    db_delete('url_alias')->execute();

    drupal_clear_path_cache();

  }

  function addVocabulary(array $vocabulary = array()) {

    $name = drupal_strtolower($this->randomName(5));

    $vocabulary += array(

      'name' => $name,

      'machine_name' => $name,

      'nodes' => array('article' => 'article'),

    );

    $vocabulary = (object) $vocabulary;

    taxonomy_vocabulary_save($vocabulary);

    return $vocabulary;

  }

  function addTerm(stdClass $vocabulary, array $term = array()) {

    $term += array(

      'name' => drupal_strtolower($this->randomName(5)),

      'vocabulary_machine_name' => $vocabulary->machine_name,

      'vid' => $vocabulary->vid,

    );

    $term = (object) $term;

    taxonomy_term_save($term);

    return $term;

  }

  function assertEntityPattern($entity_type, $bundle, $language = LANGUAGE_NONE, $expected) {

    drupal_static_reset('pathauto_pattern_load_by_entity');

    $this->refreshVariables();

    $pattern = pathauto_pattern_load_by_entity($entity_type, $bundle, $language);

    $this->assertIdentical($expected, $pattern);

  }

  function drupalGetTermByName($name, $reset = FALSE) {

    $terms = entity_load('taxonomy_term', array(), array('name' => $name), $reset);

    return !empty($terms) ? reset($terms) : FALSE;

  }

}

/**

 * 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(), 255);

  }

  /**

   * 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' => LANGUAGE_NONE, 'expected' => 'story/[node:title]'),

      array('entity' => 'node', 'bundle' => 'page', 'language' => 'en', 'expected' => 'content/[node:title]'),

      array('entity' => 'user', 'bundle' => 'user', 'language' => LANGUAGE_NONE, 'expected' => 'users/[user:name]'),

      array('entity' => 'invalid-entity', 'bundle' => '', 'language' => LANGUAGE_NONE, '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_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)));

    }

  }

  /**

   * 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 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_node_update($node);

    $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_node_update($node);

    $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_node_update($node);

    $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_delete($older_path);

    variable_set('pathauto_update_action', PATHAUTO_UPDATE_ACTION_NO_NEW);

    $node->title = 'Fifth title';

    pathauto_node_update($node);

    $this->assertEntityAlias('node', $node, 'content/fourth-title');

    $this->assertNoAliasExists(array('alias' => 'content/fifth-title'));

    // Test PATHAUTO_UPDATE_ACTION_NO_NEW with unaliased node and 'update'.

    $this->deleteAllAliases();

    pathauto_node_update($node);

    $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->assertNoEntityAliasExists('node', $node);

    $node->title = 'hello';

    pathauto_node_update($node);

    $this->assertEntityAlias('node', $node, 'content/hello');

  }

  /**

   * Test the handling of path vs non-path tokens in pathauto_clean_token_values().

   */

  function testPathTokens() {

    variable_set('pathauto_taxonomy_term_pattern', '[term:parent:url:path]/[term:name]');

    $vocab = $this->addVocabulary();

    $term1 = $this->addTerm($vocab, array('name' => 'Parent term'));

    $this->assertEntityAlias('taxonomy_term', $term1, 'parent-term');

    $term2 = $this->addTerm($vocab, array('name' => 'Child term', 'parent' => $term1->tid));

    $this->assertEntityAlias('taxonomy_term', $term2, 'parent-term/child-term');

    $this->saveEntityAlias('taxonomy_term', $term1, 'My Crazy/Alias/');

    pathauto_taxonomy_term_update($term2);

    $this->assertEntityAlias('taxonomy_term', $term2, 'My Crazy/Alias/child-term');

  }

  /**

   * Test using fields for path structures.

   */

  function testParentChildPathTokens() {

    // First create a field which will be used to create the path. It must

    // begin with a letter.

    $fieldname = 'a' . drupal_strtolower($this->randomName());

    field_create_field(array('field_name' => $fieldname, 'type' => 'text'));

    field_create_instance(array('field_name' => $fieldname, 'entity_type' => 'taxonomy_term', 'bundle' => 'tags'));

    // Make the path pattern of a field use the value of this field appended

    // to the parent taxonomy term's pattern if there is one.

    variable_set('pathauto_taxonomy_term_tags_pattern', '[term:parents:join-path]/[term:' . $fieldname . ']');

    // Start by creating a parent term.

    $parent = new stdClass();

    $parent->$fieldname = array(LANGUAGE_NONE => array(array('value' => $parent->name = $this->randomName())));

    $parent->vid = 1;

    taxonomy_term_save($parent);

    // Create the child term.

    $child = new stdClass();

    $child->name = $this->randomName();

    $child->$fieldname = array(LANGUAGE_NONE => array(array('value' => $child->name = $this->randomName())));

    $child->vid = 1;

    $child->parent = $parent->tid;

    taxonomy_term_save($child);

    $this->assertEntityAlias('taxonomy_term', $child, drupal_strtolower($parent->name . '/' . $child->name));

    // Re-saving the parent term should not modify the child term's alias.

    taxonomy_term_save($parent);

    $this->assertEntityAlias('taxonomy_term', $child, drupal_strtolower($parent->name . '/' . $child->name));

  }

  function testEntityBundleRenamingDeleting() {

    // Create a vocabulary and test that it's pattern variable works.

    $vocab = $this->addVocabulary(array('machine_name' => 'old_name'));

    variable_set('pathauto_taxonomy_term_pattern', 'base');

    variable_set("pathauto_taxonomy_term_old_name_pattern", 'bundle');

    $this->assertEntityPattern('taxonomy_term', 'old_name', LANGUAGE_NONE, 'bundle');

    // Rename the vocabulary's machine name, which should cause its pattern

    // variable to also be renamed.

    $vocab->machine_name = 'new_name';

    taxonomy_vocabulary_save($vocab);

    $this->assertEntityPattern('taxonomy_term', 'new_name', LANGUAGE_NONE, 'bundle');

    $this->assertEntityPattern('taxonomy_term', 'old_name', LANGUAGE_NONE, 'base');

    // Delete the vocabulary, which should cause its pattern variable to also

    // be deleted.

    taxonomy_vocabulary_delete($vocab->vid);

    $this->assertEntityPattern('taxonomy_term', 'new_name', LANGUAGE_NONE, 'base');

  }

  function testNoExistingPathAliases() {

    variable_set('pathauto_node_page_pattern', '[node:title]');

    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->assertEntityAlias('node', $node, 'admin-0');

    // Check that Pathauto does not create an alias of '/modules'.

    $node->title = 'Modules';

    node_save($node);

    $this->assertEntityAlias('node', $node, 'modules-0');

    // Check that Pathauto does not create an alias of '/index.php'.

    $node->title = 'index.php';

    node_save($node);

    $this->assertEntityAlias('node', $node, 'index.php-0');

    // 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');

  }

  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/[node:title]');

    // Allow other modules to add additional permissions for the admin user.

    $permissions = array(

      'administer pathauto',

      'administer url aliases',

      'create url aliases',

      'administer nodes',

      'bypass node access',

      'access content overview',

      'administer taxonomy',

      '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() {

    // Delete the default node pattern. Only the page content type will have a pattern.

    variable_del('pathauto_node_pattern');

    // Ensure that the Pathauto checkbox is checked by default on the node add form.

    $this->drupalGet('node/add/page');

    $this->assertFieldChecked('edit-path-pathauto');

    // Create node for testing by previewing and saving the node form.

    $title = ' Testing: node title [';

    $automatic_alias = 'content/testing-node-title';

    $this->drupalPost(NULL, array('title' => $title), 'Preview');

    $this->drupalPost(NULL, array(), 'Save');

    $node = $this->drupalGetNodeByTitle($title);

    // Look for alias generated in the form.

    $this->drupalGet("node/{$node->nid}/edit");

    $this->assertFieldChecked('edit-path-pathauto');

    $this->assertFieldByName('path[alias]', $automatic_alias, 'Generated alias visible in the path alias field.');

    // Check whether the alias actually works.

    $this->drupalGet($automatic_alias);

    $this->assertText($title, 'Node accessible through automatic alias.');

    // Disable the update action. The checkbox should not be visible.

    variable_set('pathauto_update_action', 0);

    $this->drupalGet("node/{$node->nid}/edit");

    $this->assertNoFieldById('edit-path-pathauto');

    // Reset the update action back to default. The checkbox should be visible.

    variable_del('pathauto_update_action');

    $this->drupalGet("node/{$node->nid}/edit");

    $this->assertFieldChecked('edit-path-pathauto');

    // Manually set the node's alias.

    $manual_alias = 'content/' . $node->nid;

    $edit = array(

      'path[pathauto]' => FALSE,

      'path[alias]' => $manual_alias,

    );

    $this->drupalPost(NULL, $edit, t('Save'));

    $this->assertText("Basic page $title has been updated.");

    // Check that the automatic alias checkbox is now unchecked by default.

    $this->drupalGet("node/{$node->nid}/edit");

    $this->assertNoFieldChecked('edit-path-pathauto');

    $this->assertFieldByName('path[alias]', $manual_alias);

    // Submit the node form with the default values.

    $this->drupalPost(NULL, array(), t('Save'));

    $this->assertText("Basic page $title has been updated.");

    // 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.');

    // Now attempt to create a node that has no pattern (article content type).

    // The Pathauto checkbox should not exist.

    $this->drupalGet('node/add/article');

    $this->assertNoFieldById('edit-path-pathauto');

    $this->assertFieldByName('path[alias]', '');

    $edit = array();

    $edit['title'] = 'My test article';

    $this->drupalPost(NULL, $edit, t('Save'));

    $node = $this->drupalGetNodeByTitle($edit['title']);

    // Pathauto checkbox should still not exist.

    $this->drupalGet('node/' . $node->nid . '/edit');

    $this->assertNoFieldById('edit-path-pathauto');

    $this->assertFieldByName('path[alias]', '');

    $this->assertNoEntityAlias('node', $node);

    // Set the page pattern to use only tokens so we can test the checkbox

    // behavior if none of the tokens have a value currently.

    variable_set('pathauto_node_page_pattern', '[node:title]');

    // Create a node with an empty title. The Pathauto checkbox should still be

    // visible but unchecked.

    $node = $this->drupalCreateNode(array('type' => 'page', 'title' => ''));

    $this->drupalGet('node/' . $node->nid . '/edit');

    $this->assertNoFieldChecked('edit-path-pathauto');

    $this->assertFieldByName('path[alias]', '');

    $this->assertNoEntityAlias('node', $node);

    $edit = array();

    $edit['title'] = 'Valid title';

    $edit['path[pathauto]'] = TRUE;

    $this->drupalPost(NULL, $edit, t('Save'));

    $this->drupalGet('node/' . $node->nid . '/edit');

    $this->assertFieldChecked('edit-path-pathauto');

    $this->assertFieldByName('path[alias]', 'valid-title');

  }

  /**

   * 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', $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);

  }

  /**

   * @todo Merge this with existing node test methods?

   */

  public function testNodeState() {

    $nodeNoAliasUser = $this->drupalCreateUser(array('bypass node access'));

    $nodeAliasUser = $this->drupalCreateUser(array('bypass node access', 'create url aliases'));

    $node = $this->drupalCreateNode(array(

      'title' => 'Node version one',

      'type' => 'page',

      'path' => array(

        'pathauto' => FALSE,

      ),

    ));

    $this->assertNoEntityAlias('node', $node);

    // Set a manual path alias for the node.

    $node->path['alias'] = 'test-alias';

    node_save($node);

    // Ensure that the pathauto field was saved to the database.

    $node = node_load($node->nid, NULL, TRUE);

    $this->assertFalse($node->path['pathauto']);

    // Ensure that the manual path alias was saved and an automatic alias was not generated.

    $this->assertEntityAlias('node', $node, 'test-alias');

    $this->assertNoEntityAliasExists('node', $node, 'content/node-version-one');

    // Save the node as a user who does not have access to path fieldset.

    $this->drupalLogin($nodeNoAliasUser);

    $this->drupalGet('node/' . $node->nid . '/edit');

    $this->assertNoFieldByName('path[pathauto]');

    $edit = array('title' => 'Node version two');

    $this->drupalPost(NULL, $edit, 'Save');

    $this->assertText('Basic page Node version two has been updated.');

    $this->assertEntityAlias('node', $node, 'test-alias');

    $this->assertNoEntityAliasExists('node', $node, 'content/node-version-one');

    $this->assertNoEntityAliasExists('node', $node, 'content/node-version-two');

    // Load the edit node page and check that the Pathauto checkbox is unchecked.

    $this->drupalLogin($nodeAliasUser);

    $this->drupalGet('node/' . $node->nid . '/edit');

    $this->assertNoFieldChecked('edit-path-pathauto');

    // Edit the manual alias and save the node.

    $edit = array(

      'title' => 'Node version three',

      'path[alias]' => 'manually-edited-alias',

    );

    $this->drupalPost(NULL, $edit, 'Save');

    $this->assertText('Basic page Node version three has been updated.');

    $this->assertEntityAlias('node', $node, 'manually-edited-alias');

    $this->assertNoEntityAliasExists('node', $node, 'test-alias');

    $this->assertNoEntityAliasExists('node', $node, 'content/node-version-one');

    $this->assertNoEntityAliasExists('node', $node, 'content/node-version-two');

    $this->assertNoEntityAliasExists('node', $node, 'content/node-version-three');

    // Programatically save the node with an automatic alias.

    $node = node_load($node->nid, NULL, TRUE);

    $node->path['pathauto'] = TRUE;

    node_save($node);

    // Ensure that the pathauto field was saved to the database.

    $node = node_load($node->nid, NULL, TRUE);

    $this->assertTrue($node->path['pathauto']);

    $this->assertEntityAlias('node', $node, 'content/node-version-three');

    $this->assertNoEntityAliasExists('node', $node, 'manually-edited-alias');

    $this->assertNoEntityAliasExists('node', $node, 'test-alias');

    $this->assertNoEntityAliasExists('node', $node, 'content/node-version-one');

    $this->assertNoEntityAliasExists('node', $node, 'content/node-version-two');

  }

  /**

   * Basic functional testing of Pathauto with taxonomy terms.

   */

  function testTermEditing() {

    $this->drupalGet('admin/structure');

    $this->drupalGet('admin/structure/taxonomy');

    // Create term for testing.

    $name = ' Testing: term name [ ';

    $automatic_alias = 'tags/testing-term-name';

    $this->drupalPost('admin/structure/taxonomy/tags/add', array('name' => $name), 'Save');

    $name = trim($name);

    $this->assertText("Created new term $name.");

    $term = $this->drupalGetTermByName($name);

    // Look for alias generated in the form.

    $this->drupalGet("taxonomy/term/{$term->tid}/edit");

    $this->assertFieldChecked('edit-path-pathauto');

    $this->assertFieldByName('path[alias]', $automatic_alias, 'Generated alias visible in the path alias field.');

    // Check whether the alias actually works.

    $this->drupalGet($automatic_alias);

    $this->assertText($name, 'Term accessible through automatic alias.');

    // Manually set the term's alias.

    $manual_alias = 'tags/' . $term->tid;

    $edit = array(

      'path[pathauto]' => FALSE,

      'path[alias]' => $manual_alias,

    );

    $this->drupalPost("taxonomy/term/{$term->tid}/edit", $edit, t('Save'));

    $this->assertText("Updated term $name.");

    // Check that the automatic alias checkbox is now unchecked by default.

    $this->drupalGet("taxonomy/term/{$term->tid}/edit");

    $this->assertNoFieldChecked('edit-path-pathauto');

    $this->assertFieldByName('path[alias]', $manual_alias);

    // Submit the term form with the default values.

    $this->drupalPost(NULL, array(), t('Save'));

    $this->assertText("Updated term $name.");

    // Test that the old (automatic) alias has been deleted and only accessible

    // through the new (manual) alias.

    $this->drupalGet($automatic_alias);

    $this->assertResponse(404, 'Term not accessible through automatic alias.');

    $this->drupalGet($manual_alias);

    $this->assertText($name, 'Term accessible through manual alias.');

  }

  /**

   * Basic functional testing of Pathauto with users.

   */

  function testUserEditing() {

    // There should be no Pathauto checkbox on user forms.

    $this->drupalGet('user/' . $this->admin_user->uid . '/edit');

    $this->assertNoFieldById('edit-path-pathauto');

  }

  /**

   * 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/people', $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/config/search/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/config/search/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/config/search/path/settings', $edit, 'Save configuration');

    $this->assertText('The field Maximum alias length cannot be greater than 255.');

    $this->assertText('The field Maximum component length cannot be greater than 255.');

    $this->assertNoText('The configuration options have been saved.');

    $edit['pathauto_max_length'] = '50';

    $edit['pathauto_max_component_length'] = '50';

    $this->drupalPost('admin/config/search/path/settings', $edit, 'Save configuration');

    $this->assertText('The configuration options have been saved.');

  }

  function testPatternsValidation() {

    $edit = array();

    $edit['pathauto_node_pattern'] = '[node:title]/[user:name]/[term:name]';

    $edit['pathauto_node_page_pattern'] = 'page';

    $this->drupalPost('admin/config/search/path/patterns', $edit, 'Save configuration');

    $this->assertText('The Default path pattern (applies to all content types with blank patterns below) is using the following invalid tokens: [user:name], [term:name].');

    $this->assertText('The Pattern for all Basic page paths cannot contain fewer than one token.');

    $this->assertNoText('The configuration options have been saved.');

    $edit['pathauto_node_pattern'] = '[node:title]';

    $edit['pathauto_node_page_pattern'] = 'page/[node:title]';

    $edit['pathauto_node_article_pattern'] = '';

    $this->drupalPost('admin/config/search/path/patterns', $edit, 'Save configuration');

    $this->assertText('The configuration options have been saved.');

  }

  /**

   * Test programmatic entity creation for aliases.

   */

  function testProgrammaticEntityCreation() {

    $node = $this->drupalCreateNode(array('title' => 'Test node', 'path' => array('pathauto' => TRUE)));

    $this->assertEntityAlias('node', $node, 'content/test-node');

    $vocabulary = $this->addVocabulary(array('name' => 'Tags'));

    $term = $this->addTerm($vocabulary, array('name' => 'Test term', 'path' => array('pathauto' => TRUE)));

    $this->assertEntityAlias('taxonomy_term', $term, 'tags/test-term');

    $edit['name'] = 'Test user';

    $edit['mail'] = 'test-user@example.com';

    $edit['pass']   = user_password();

    $edit['path'] = array('pathauto' => TRUE);

    $edit['status'] = 1;

    $account = user_save(drupal_anonymous_user(), $edit);

    $this->assertEntityAlias('user', $account, 'users/test-user');

  }

}

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 DRUPAL_ROOT . '/includes/locale.inc';

    locale_add_language('fr', NULL, NULL, LANGUAGE_LTR, '', 'fr');

    drupal_language_initialize();

  }

  /**

   * 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',

      'body' => array('en' => array(array())),

      'path' => array(

        'alias' => 'english-node',

        'pathauto' => FALSE,

      ),

    );

    $node = $this->drupalCreateNode($node);

    $english_alias = path_load(array('alias' => 'english-node', 'language' => 'en'));

    $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', LANGUAGE_NONE);

    // Update the node, triggering a change in the English alias.

    $node->path['pathauto'] = TRUE;

    pathauto_node_update($node);

    // 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'));

    // Create a new node with the same title as before but without

    // specifying a language.

    $node = $this->drupalCreateNode(array('title' => 'English node'));

    // Check that the new node had a unique alias generated with the '-1'

    // suffix.

    $this->assertEntityAlias('node', $node, 'content/english-node-1');

  }

}

/**

 * 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/config/search/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('path' => array('alias' => '', 'pathauto' => FALSE)));

    // Run the update again which should not run against any nodes.

    $this->drupalPost('admin/config/search/path/update_bulk', $edit, t('Update'));

    $this->assertText('No new URL aliases to generate.');

    $this->assertNoEntityAliasExists('node', $new_node);

  }

}

/**

 * Token functionality tests.

 */

class PathautoTokenTestCase extends PathautoFunctionalTestHelper {

  public static function getInfo() {

    return array(

      'name' => 'Pathauto tokens',

      'description' => 'Tests tokens provided by Pathauto.',

      'group' => 'Pathauto',

      'dependencies' => array('token'),

    );

  }

  function testPathautoTokens() {

    $array = array(

      'test first arg',

      'The Array / value',

    );

    $tokens = array(

      'join-path' => 'test-first-arg/array-value',

    );

    $data['array'] = $array;

    $replacements = $this->assertTokens('array', $data, $tokens);

    // Ensure that the pathauto_clean_token_values() function does not alter

    // this token value.

    module_load_include('inc', 'pathauto');

    pathauto_clean_token_values($replacements, $data, array());

    $this->assertEqual($replacements['[array:join-path]'], 'test-first-arg/array-value');

  }

  /**

   * Function copied from TokenTestHelper::assertTokens().

   */

  function assertTokens($type, array $data, array $tokens, array $options = array()) {

    $input = $this->mapTokenNames($type, array_keys($tokens));

    $replacements = token_generate($type, $input, $data, $options);

    foreach ($tokens as $name => $expected) {

      $token = $input[$name];

      if (!isset($expected)) {

        $this->assertTrue(!isset($values[$token]), t("Token value for @token was not generated.", array('@type' => $type, '@token' => $token)));

      }

      elseif (!isset($replacements[$token])) {

        $this->fail(t("Token value for @token was not generated.", array('@type' => $type, '@token' => $token)));

      }

      elseif (!empty($options['regex'])) {

        $this->assertTrue(preg_match('/^' . $expected . '$/', $replacements[$token]), t("Token value for @token was '@actual', matching regular expression pattern '@expected'.", array('@type' => $type, '@token' => $token, '@actual' => $replacements[$token], '@expected' => $expected)));

      }

      else {

        $this->assertIdentical($replacements[$token], $expected, t("Token value for @token was '@actual', expected value '@expected'.", array('@type' => $type, '@token' => $token, '@actual' => $replacements[$token], '@expected' => $expected)));

      }

    }

    return $replacements;

  }

  function mapTokenNames($type, array $tokens = array()) {

    $return = array();

    foreach ($tokens as $token) {

      $return[$token] = "[$type:$token]";

    }

    return $return;

  }

}