pathauto.test in Pathauto 6
Same filename and directory in other branches
Functionality tests for Pathauto.
File
pathauto.testView source
<?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) {
$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) {
$this
->refreshVariables();
$variables = array(
"pathauto_{$entity_type}_{$bundle}_{$language}_pattern",
"pathauto_{$entity_type}_{$bundle}_pattern",
"pathauto_{$entity_type}_pattern",
);
$pattern = '';
foreach ($variables as $variable) {
if ($pattern = variable_get($variable, '')) {
break;
}
}
$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_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-drupa';
// 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 the feed alias functionality of pathauto_create_alias().
*/
function testFeedAliases() {
variable_set('pathauto_node_pattern', '[title-raw]');
variable_set('pathauto_node_applytofeeds', '');
// Create a node with an empty title, which should not create an alias.
$node = $this
->drupalCreateNode(array(
'title' => '',
));
$this
->assertNoAliasExists(array(
'source' => "node/{$node->nid}",
));
$this
->assertNoAliasExists(array(
'source' => "node/{$node->nid}/feed",
));
// Add a title to the node. This should still not generate a feed alias.
$node->title = 'Node title';
pathauto_nodeapi($node, 'update');
$this
->assertAliasExists(array(
'source' => "node/{$node->nid}",
'alias' => 'node-title',
));
$this
->assertNoAliasExists(array(
'source' => "node/{$node->nid}/feed",
));
// Enable feeds for nodes. A feed alias should now be generated.
variable_set('pathauto_node_applytofeeds', ' feed ');
pathauto_nodeapi($node, 'update');
$this
->assertAliasExists(array(
'source' => "node/{$node->nid}/feed",
'alias' => 'node-title/feed',
));
}
/**
* 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', 0);
$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', 2);
$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', 1);
$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', 2);
$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', 0);
$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', 2);
// Do not replace periods.
// 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');
}
}
/**
* 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/pathauto', $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/pathauto', $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/pathauto', $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/pathauto', $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/pathauto', $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 should contain at least one token to ensure unique URL aliases are created.');
$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/pathauto', $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',
));
}
}
/*
* 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);
}
}Classes
Name |
Description |
|---|---|
| PathautoBookTokenTestCase | |
| PathautoFunctionalTestCase | Test basic pathauto functionality. |
| PathautoFunctionalTestHelper | Helper test class with some added functions for testing. |
| PathautoLocaleTestCase | |
| PathautoTaxonomyTokenTestCase | |
| PathautoTestHelper | Helper test class with some added functions for testing. |
| PathautoUnitTestCase | Unit tests for Pathauto functions. |