1250 lines
44 KiB
Plaintext
1250 lines
44 KiB
Plaintext
<?php
|
|
// $Id$
|
|
|
|
/**
|
|
* Helper class for module test cases.
|
|
*/
|
|
class ModuleTestCase extends DrupalWebTestCase {
|
|
protected $admin_user;
|
|
|
|
function setUp() {
|
|
parent::setUp('system_test');
|
|
|
|
$this->admin_user = $this->drupalCreateUser(array('access administration pages', 'administer site configuration'));
|
|
$this->drupalLogin($this->admin_user);
|
|
}
|
|
|
|
/**
|
|
* Assert there are tables that begin with the specified base table name.
|
|
*
|
|
* @param $base_table
|
|
* Beginning of table name to look for.
|
|
* @param $count
|
|
* (optional) Whether or not to assert that there are tables that match the
|
|
* specified base table. Defaults to TRUE.
|
|
*/
|
|
function assertTableCount($base_table, $count = TRUE) {
|
|
$tables = db_find_tables(Database::getConnection()->prefixTables('{' . $base_table . '}') . '%');
|
|
|
|
if ($count) {
|
|
return $this->assertTrue($tables, t('Tables matching "@base_table" found.', array('@base_table' => $base_table)));
|
|
}
|
|
return $this->assertFalse($tables, t('Tables matching "@base_table" not found.', array('@base_table' => $base_table)));
|
|
}
|
|
|
|
/**
|
|
* Assert the list of modules are enabled or disabled.
|
|
*
|
|
* @param $modules
|
|
* Module list to check.
|
|
* @param $enabled
|
|
* Expected module state.
|
|
*/
|
|
function assertModules(array $modules, $enabled) {
|
|
module_list(TRUE);
|
|
foreach ($modules as $module) {
|
|
if ($enabled) {
|
|
$message = 'Module "@module" is enabled.';
|
|
}
|
|
else {
|
|
$message = 'Module "@module" is not enabled.';
|
|
}
|
|
$this->assertEqual(module_exists($module), $enabled, t($message, array('@module' => $module)));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Verify a log entry was entered for a module's status change.
|
|
* Called in the same way of the expected original watchdog() execution.
|
|
*
|
|
* @param $type
|
|
* The category to which this message belongs.
|
|
* @param $message
|
|
* The message to store in the log. Keep $message translatable
|
|
* by not concatenating dynamic values into it! Variables in the
|
|
* message should be added by using placeholder strings alongside
|
|
* the variables argument to declare the value of the placeholders.
|
|
* See t() for documentation on how $message and $variables interact.
|
|
* @param $variables
|
|
* Array of variables to replace in the message on display or
|
|
* NULL if message is already translated or not possible to
|
|
* translate.
|
|
* @param $severity
|
|
* The severity of the message, as per RFC 3164.
|
|
* @param $link
|
|
* A link to associate with the message.
|
|
*/
|
|
function assertLogMessage($type, $message, $variables = array(), $severity = WATCHDOG_NOTICE, $link = '') {
|
|
$count = db_select('watchdog', 'w')
|
|
->condition('type', $type)
|
|
->condition('message', $message)
|
|
->condition('variables', serialize($variables))
|
|
->condition('severity', $severity)
|
|
->condition('link', $link)
|
|
->countQuery()
|
|
->execute()
|
|
->fetchField();
|
|
$this->assertTrue($count > 0, t('watchdog table contains @count rows for @message', array('@count' => $count, '@message' => $message)));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test module enabling/disabling functionality.
|
|
*/
|
|
class EnableDisableTestCase extends ModuleTestCase {
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'Enable/disable modules',
|
|
'description' => 'Enable/disable core module and confirm table creation/deletion.',
|
|
'group' => 'Module',
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Enable a module, check the database for related tables, disable module,
|
|
* check for related tables, uninstall module, check for related tables.
|
|
* Also check for invocation of the hook_module_action hook.
|
|
*/
|
|
function testEnableDisable() {
|
|
// Enable aggregator, and check tables.
|
|
$this->assertModules(array('aggregator'), FALSE);
|
|
$this->assertTableCount('aggregator', FALSE);
|
|
|
|
// Install (and enable) aggregator module.
|
|
$edit = array();
|
|
$edit['modules[Core][aggregator][enable]'] = 'aggregator';
|
|
$edit['modules[Core][forum][enable]'] = 'forum';
|
|
$this->drupalPost('admin/config/modules', $edit, t('Save configuration'));
|
|
$this->assertText(t('The configuration options have been saved.'), t('Modules status has been updated.'));
|
|
|
|
// Check that hook_modules_installed and hook_modules_enabled hooks were invoked and check tables.
|
|
$this->assertText(t('hook_modules_installed fired for aggregator'), t('hook_modules_installed fired.'));
|
|
$this->assertText(t('hook_modules_enabled fired for aggregator'), t('hook_modules_enabled fired.'));
|
|
$this->assertModules(array('aggregator'), TRUE);
|
|
$this->assertTableCount('aggregator', TRUE);
|
|
$this->assertLogMessage('system', "%module module enabled.", array('%module' => 'aggregator'), WATCHDOG_INFO);
|
|
|
|
// Disable aggregator, check tables, uninstall aggregator, check tables.
|
|
$edit = array();
|
|
$edit['modules[Core][aggregator][enable]'] = FALSE;
|
|
$this->drupalPost('admin/config/modules', $edit, t('Save configuration'));
|
|
$this->assertText(t('The configuration options have been saved.'), t('Modules status has been updated.'));
|
|
|
|
// Check that hook_modules_disabled hook was invoked and check tables.
|
|
$this->assertText(t('hook_modules_disabled fired for aggregator'), t('hook_modules_disabled fired.'));
|
|
$this->assertModules(array('aggregator'), FALSE);
|
|
$this->assertTableCount('aggregator', TRUE);
|
|
$this->assertLogMessage('system', "%module module disabled.", array('%module' => 'aggregator'), WATCHDOG_INFO);
|
|
|
|
// Uninstall the module.
|
|
$edit = array();
|
|
$edit['uninstall[aggregator]'] = 'aggregator';
|
|
$this->drupalPost('admin/config/modules/uninstall', $edit, t('Uninstall'));
|
|
|
|
$this->drupalPost(NULL, NULL, t('Uninstall'));
|
|
$this->assertText(t('The selected modules have been uninstalled.'), t('Modules status has been updated.'));
|
|
|
|
// Check that hook_modules_uninstalled hook was invoked and check tables.
|
|
$this->assertText(t('hook_modules_uninstalled fired for aggregator'), t('hook_modules_uninstalled fired.'));
|
|
$this->assertModules(array('aggregator'), FALSE);
|
|
$this->assertTableCount('aggregator', FALSE);
|
|
$this->assertLogMessage('system', "%module module uninstalled.", array('%module' => 'aggregator'), WATCHDOG_INFO);
|
|
|
|
// Reinstall (and enable) aggregator module.
|
|
$edit = array();
|
|
$edit['modules[Core][aggregator][enable]'] = 'aggregator';
|
|
$this->drupalPost('admin/config/modules', $edit, t('Save configuration'));
|
|
$this->assertText(t('The configuration options have been saved.'), t('Modules status has been updated.'));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test module dependency functionality.
|
|
*/
|
|
class ModuleDependencyTestCase extends ModuleTestCase {
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'Module dependencies',
|
|
'description' => 'Enable module without dependency enabled.',
|
|
'group' => 'Module',
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Attempt to enable translation module without locale enabled.
|
|
*/
|
|
function testEnableWithoutDependency() {
|
|
// Attempt to enable content translation without locale enabled.
|
|
$edit = array();
|
|
$edit['modules[Core][translation][enable]'] = 'translation';
|
|
$this->drupalPost('admin/config/modules', $edit, t('Save configuration'));
|
|
$this->assertText(t('Some required modules must be enabled'), t('Dependecy required.'));
|
|
|
|
$this->assertModules(array('translation', 'locale'), FALSE);
|
|
|
|
// Assert that the locale tables weren't enabled.
|
|
$this->assertTableCount('languages', FALSE);
|
|
$this->assertTableCount('locale', FALSE);
|
|
|
|
$this->drupalPost(NULL, NULL, t('Continue'));
|
|
$this->assertText(t('The configuration options have been saved.'), t('Modules status has been updated.'));
|
|
|
|
$this->assertModules(array('translation', 'locale'), TRUE);
|
|
|
|
// Assert that the locale tables were enabled.
|
|
$this->assertTableCount('languages', TRUE);
|
|
$this->assertTableCount('locale', TRUE);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test module dependency on specific versions.
|
|
*/
|
|
class ModuleVersionTestCase extends ModuleTestCase {
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'Module versions',
|
|
'description' => 'Check module version dependencies.',
|
|
'group' => 'Module',
|
|
);
|
|
}
|
|
|
|
function setup() {
|
|
parent::setUp('module_test');
|
|
}
|
|
|
|
/**
|
|
* Test version dependencies.
|
|
*/
|
|
function testModuleVersions() {
|
|
$dependencies = array(
|
|
// Alternating between being compatible and incompatible with 7.x-2.4-beta3.
|
|
// The first is always a compatible.
|
|
'common_test',
|
|
// Branch incompatibility.
|
|
'common_test (1.x)',
|
|
// Branch compatibility.
|
|
'common_test (2.x)',
|
|
// Another branch incompatibility.
|
|
'common_test (>2.x)',
|
|
// Another branch compatibility.
|
|
'common_test (<=2.x)',
|
|
// Another branch incompatibility.
|
|
'common_test (<2.x)',
|
|
// Another branch compatibility.
|
|
'common_test (>=2.x)',
|
|
// Nonsense, misses a dash. Incompatible with everything.
|
|
'common_test (=7.x2.x, >=2.4)',
|
|
// Core version is optional. Compatible.
|
|
'common_test (=7.x-2.x, >=2.4-alpha2)',
|
|
// Test !=, explicitly incompatible.
|
|
'common_test (=2.x, !=2.4-beta3)',
|
|
// Three operations. Compatible.
|
|
'common_test (=2.x, !=2.3, <2.5)',
|
|
// Testing extra version. Incompatible.
|
|
'common_test (<=2.4-beta2)',
|
|
// Testing extra version. Compatible.
|
|
'common_test (>2.4-beta2)',
|
|
// Testing extra version. Incompatible.
|
|
'common_test (>2.4-rc0)',
|
|
);
|
|
variable_set('dependencies', $dependencies);
|
|
$n = count($dependencies);
|
|
for ($i = 0; $i < $n; $i++) {
|
|
$this->drupalGet('admin/config/modules');
|
|
$checkbox = $this->xpath('//input[@id="edit-modules-Testing-module-test-enable"]');
|
|
$this->assertEqual(!empty($checkbox[0]['disabled']), $i % 2, $dependencies[$i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test required modules functionality.
|
|
*/
|
|
class ModuleRequiredTestCase extends ModuleTestCase {
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'Required modules',
|
|
'description' => 'Attempt disabling of required modules.',
|
|
'group' => 'Module',
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Assert that core required modules cannot be disabled.
|
|
*/
|
|
function testDisableRequired() {
|
|
$required_modules = drupal_required_modules();
|
|
$this->drupalGet('admin/config/modules');
|
|
foreach ($required_modules as $module) {
|
|
// Check to make sure the checkbox for required module is not found.
|
|
$this->assertNoFieldByName('modules[Core][' . $module . '][enable]');
|
|
}
|
|
}
|
|
}
|
|
|
|
class IPAddressBlockingTestCase extends DrupalWebTestCase {
|
|
protected $blocking_user;
|
|
|
|
/**
|
|
* Implement getInfo().
|
|
*/
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'IP address blocking',
|
|
'description' => 'Test IP address blocking.',
|
|
'group' => 'System'
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Implement setUp().
|
|
*/
|
|
function setUp() {
|
|
parent::setUp();
|
|
|
|
// Create user.
|
|
$this->blocking_user = $this->drupalCreateUser(array('block IP addresses'));
|
|
$this->drupalLogin($this->blocking_user);
|
|
}
|
|
|
|
/**
|
|
* Test a variety of user input to confirm correct validation and saving of data.
|
|
*/
|
|
function testIPAddressValidation() {
|
|
$this->drupalGet('admin/settings/ip-blocking');
|
|
|
|
// Block a valid IP address.
|
|
$edit = array();
|
|
$edit['ip'] = '192.168.1.1';
|
|
$this->drupalPost('admin/settings/ip-blocking', $edit, t('Save'));
|
|
$ip = db_query("SELECT iid from {blocked_ips} WHERE ip = :ip", array(':ip' => $edit['ip']))->fetchField();
|
|
$this->assertNotNull($ip, t('IP address found in database'));
|
|
$this->assertRaw(t('The IP address %ip has been blocked.', array('%ip' => $edit['ip'])), t('IP address was blocked.'));
|
|
|
|
// Try to block an IP address that's already blocked.
|
|
$edit = array();
|
|
$edit['ip'] = '192.168.1.1';
|
|
$this->drupalPost('admin/settings/ip-blocking', $edit, t('Save'));
|
|
$this->assertText(t('This IP address is already blocked.'));
|
|
|
|
// Try to block a reserved IP address.
|
|
$edit = array();
|
|
$edit['ip'] = '255.255.255.255';
|
|
$this->drupalPost('admin/settings/ip-blocking', $edit, t('Save'));
|
|
$this->assertText(t('Please enter a valid IP address.'));
|
|
|
|
// Try to block a reserved IP address.
|
|
$edit = array();
|
|
$edit['ip'] = 'test.example.com';
|
|
$this->drupalPost('admin/settings/ip-blocking', $edit, t('Save'));
|
|
$this->assertText(t('Please enter a valid IP address.'));
|
|
|
|
// Submit an empty form.
|
|
$edit = array();
|
|
$edit['ip'] = '';
|
|
$this->drupalPost('admin/settings/ip-blocking', $edit, t('Save'));
|
|
$this->assertText(t('Please enter a valid IP address.'));
|
|
|
|
// Submit your own IP address. This fails, although it works when testing manually.
|
|
// TODO: on some systems this test fails due to a bug or inconsistency in cURL.
|
|
// $edit = array();
|
|
// $edit['ip'] = ip_address();
|
|
// $this->drupalPost('admin/settings/ip-blocking', $edit, t('Save'));
|
|
// $this->assertText(t('You may not block your own IP address.'));
|
|
}
|
|
}
|
|
|
|
class CronRunTestCase extends DrupalWebTestCase {
|
|
/**
|
|
* Implement getInfo().
|
|
*/
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'Cron run',
|
|
'description' => 'Test cron run.',
|
|
'group' => 'System'
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Test cron runs.
|
|
*/
|
|
function testCronRun() {
|
|
global $base_url;
|
|
|
|
// Run cron anonymously without any cron key.
|
|
$this->drupalGet($base_url . '/cron.php', array('external' => TRUE));
|
|
$this->assertResponse(403);
|
|
|
|
// Run cron anonymously with a random cron key.
|
|
$key = $this->randomName(16);
|
|
$this->drupalGet($base_url . '/cron.php', array('external' => TRUE, 'query' => 'cron_key=' . $key));
|
|
$this->assertResponse(403);
|
|
|
|
// Run cron anonymously with the valid cron key.
|
|
$key = variable_get('cron_key', 'drupal');
|
|
$this->drupalGet($base_url . '/cron.php', array('external' => TRUE, 'query' => 'cron_key=' . $key));
|
|
$this->assertResponse(200);
|
|
|
|
// Execute cron directly.
|
|
$this->assertTrue(drupal_cron_run(), t('Cron ran successfully.'));
|
|
}
|
|
|
|
/**
|
|
* Follow every image paths in the previously retrieved content.
|
|
*/
|
|
function drupalGetAllImages() {
|
|
foreach ($this->xpath('//img') as $image) {
|
|
$this->drupalGet($this->getAbsoluteUrl($image['src']));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Ensure that the cron image callback to run it automatically is working.
|
|
*
|
|
* In these tests we do not use REQUEST_TIME to track start time, because we
|
|
* need the exact time when cron is triggered.
|
|
*/
|
|
function testCronThreshold() {
|
|
// Ensure cron does not run when the cron threshold is enabled and was
|
|
// not passed.
|
|
$start_cron_last = time();
|
|
variable_set('cron_last', $start_cron_last);
|
|
variable_set('cron_safe_threshold', 10);
|
|
$this->drupalGet('');
|
|
// Follow every image path on the page.
|
|
$this->drupalGetAllImages();
|
|
$this->assertTrue($start_cron_last == variable_get('cron_last', NULL), t('Cron does not run when the cron threshold is not passed.'));
|
|
|
|
// Test if cron runs when the cron threshold was passed.
|
|
$start_cron_last = time() - 15;
|
|
variable_set('cron_last', $start_cron_last);
|
|
$this->drupalGet('');
|
|
// Follow every image path on the page.
|
|
$this->drupalGetAllImages();
|
|
$this->assertTrue(variable_get('cron_last', NULL) > $start_cron_last, t('Cron runs when the cron threshold is passed.'));
|
|
|
|
// Test if cron does not run when the cron threshold was is disabled.
|
|
$start_cron_last = time() - 15;
|
|
variable_set('cron_safe_threshold', 0);
|
|
variable_set('cron_last', $start_cron_last);
|
|
$this->drupalGet('');
|
|
// Follow every image path on the page.
|
|
$this->drupalGetAllImages();
|
|
$this->assertTrue($start_cron_last == variable_get('cron_last', NULL), t('Cron does not run when the cron threshold is disabled.'));
|
|
}
|
|
|
|
/**
|
|
* Ensure that temporary files are removed.
|
|
*
|
|
* Create files for all the possible combinations of age and status. We are
|
|
* using UPDATE statments rather than file_save() because it would set the
|
|
* timestamp.
|
|
*/
|
|
function testTempFileCleanup() {
|
|
// Temporary file that is older than DRUPAL_MAXIMUM_TEMP_FILE_AGE.
|
|
$temp_old = file_save_data('');
|
|
db_update('file')
|
|
->fields(array(
|
|
'status' => 0,
|
|
'timestamp' => 1,
|
|
))
|
|
->condition('fid', $temp_old->fid)
|
|
->execute();
|
|
$this->assertTrue(file_exists($temp_old->uri), t('Old temp file was created correctly.'));
|
|
|
|
// Temporary file that is less than DRUPAL_MAXIMUM_TEMP_FILE_AGE.
|
|
$temp_new = file_save_data('');
|
|
db_update('file')
|
|
->fields(array('status' => 0))
|
|
->condition('fid', $temp_new->fid)
|
|
->execute();
|
|
$this->assertTrue(file_exists($temp_new->uri), t('New temp file was created correctly.'));
|
|
|
|
// Permanent file that is older than DRUPAL_MAXIMUM_TEMP_FILE_AGE.
|
|
$perm_old = file_save_data('');
|
|
db_update('file')
|
|
->fields(array('timestamp' => 1))
|
|
->condition('fid', $temp_old->fid)
|
|
->execute();
|
|
$this->assertTrue(file_exists($perm_old->uri), t('Old permanent file was created correctly.'));
|
|
|
|
// Permanent file that is newer than DRUPAL_MAXIMUM_TEMP_FILE_AGE.
|
|
$perm_new = file_save_data('');
|
|
$this->assertTrue(file_exists($perm_new->uri), t('New permanent file was created correctly.'));
|
|
|
|
// Run cron and then ensure that only the old, temp file was deleted.
|
|
$this->assertTrue(drupal_cron_run(), t('Cron ran successfully.'));
|
|
$this->assertFalse(file_exists($temp_old->uri), t('Old temp file was correctly removed.'));
|
|
$this->assertTrue(file_exists($temp_new->uri), t('New temp file was correctly ignored.'));
|
|
$this->assertTrue(file_exists($perm_old->uri), t('Old permanent file was correctly ignored.'));
|
|
$this->assertTrue(file_exists($perm_new->uri), t('New permanent file was correctly ignored.'));
|
|
}
|
|
}
|
|
|
|
class AdminMetaTagTestCase extends DrupalWebTestCase {
|
|
/**
|
|
* Implement getInfo().
|
|
*/
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'Fingerprinting meta tag',
|
|
'description' => 'Confirm that the fingerprinting meta tag appears as expected.',
|
|
'group' => 'System'
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Verify that the meta tag HTML is generated correctly.
|
|
*/
|
|
public function testMetaTag() {
|
|
list($version, ) = explode('.', VERSION);
|
|
$string = '<meta name="Generator" content="Drupal ' . $version . ' (http://drupal.org)" />';
|
|
$this->drupalGet('node');
|
|
$this->assertRaw($string, t('Fingerprinting meta tag generated correctly.'), t('System'));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests custom access denied functionality.
|
|
*/
|
|
class AccessDeniedTestCase extends DrupalWebTestCase {
|
|
protected $admin_user;
|
|
|
|
/**
|
|
* Implement getInfo().
|
|
*/
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => '403 functionality',
|
|
'description' => "Tests page access denied functionality, including custom 403 pages.",
|
|
'group' => 'System'
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Implement setUp().
|
|
*/
|
|
function setUp() {
|
|
parent::setUp();
|
|
|
|
// Create an administrative user.
|
|
$this->admin_user = $this->drupalCreateUser(array('administer site configuration', 'administer blocks'));
|
|
$this->drupalLogin($this->admin_user);
|
|
}
|
|
|
|
function testAccessDenied() {
|
|
$this->drupalGet('admin');
|
|
$this->assertText(t('Access denied'), t('Found the default 403 page'));
|
|
|
|
$edit = array(
|
|
'title' => $this->randomName(10),
|
|
'body' => array(FIELD_LANGUAGE_NONE => array(array('value' => $this->randomName(100)))),
|
|
);
|
|
$node = $this->drupalCreateNode($edit);
|
|
|
|
// Use a custom 403 page.
|
|
$this->drupalPost('admin/settings/site-information', array('site_403' => 'node/' . $node->nid), t('Save configuration'));
|
|
|
|
$this->drupalGet('admin');
|
|
$this->assertText($node->title, t('Found the custom 403 page'));
|
|
|
|
// Logout and check that the user login block is shown on custom 403 pages.
|
|
$this->drupalLogout();
|
|
|
|
$this->drupalGet('admin');
|
|
$this->assertText($node->title, t('Found the custom 403 page'));
|
|
$this->assertText(t('User login'), t('Blocks are shown on the custom 403 page'));
|
|
|
|
// Log back in and remove the custom 403 page.
|
|
$this->drupalLogin($this->admin_user);
|
|
$this->drupalPost('admin/settings/site-information', array('site_403' => ''), t('Save configuration'));
|
|
|
|
// Logout and check that the user login block is shown on default 403 pages.
|
|
$this->drupalLogout();
|
|
|
|
$this->drupalGet('admin');
|
|
$this->assertText(t('Access denied'), t('Found the default 403 page'));
|
|
$this->assertText(t('User login'), t('Blocks are shown on the default 403 page'));
|
|
|
|
// Log back in, set the custom 403 page to /user and remove the block
|
|
$this->drupalLogin($this->admin_user);
|
|
variable_set('site_403', 'user');
|
|
$this->drupalPost('admin/structure/block', array('user_login[region]' => '-1'), t('Save blocks'));
|
|
|
|
// Check that we can log in from the 403 page.
|
|
$this->drupalLogout();
|
|
$edit = array(
|
|
'name' => $this->admin_user->name,
|
|
'pass' => $this->admin_user->pass_raw,
|
|
);
|
|
$this->drupalPost('admin/settings/site-information', $edit, t('Log in'));
|
|
|
|
// Check that we're still on the same page.
|
|
$this->assertText(t('Site information'));
|
|
}
|
|
}
|
|
|
|
class PageNotFoundTestCase extends DrupalWebTestCase {
|
|
protected $admin_user;
|
|
|
|
/**
|
|
* Implement getInfo().
|
|
*/
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => '404 functionality',
|
|
'description' => "Tests page not found functionality, including custom 404 pages.",
|
|
'group' => 'System'
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Implement setUp().
|
|
*/
|
|
function setUp() {
|
|
parent::setUp();
|
|
|
|
// Create an administrative user.
|
|
$this->admin_user = $this->drupalCreateUser(array('administer site configuration'));
|
|
$this->drupalLogin($this->admin_user);
|
|
}
|
|
|
|
function testPageNotFound() {
|
|
$this->drupalGet($this->randomName(10));
|
|
$this->assertText(t('Page not found'), t('Found the default 404 page'));
|
|
|
|
$edit = array(
|
|
'title' => $this->randomName(10),
|
|
'body' => array(FIELD_LANGUAGE_NONE => array(array('value' => $this->randomName(100)))),
|
|
);
|
|
$node = $this->drupalCreateNode($edit);
|
|
|
|
// Use a custom 404 page.
|
|
$this->drupalPost('admin/settings/site-information', array('site_404' => 'node/' . $node->nid), t('Save configuration'));
|
|
|
|
$this->drupalGet($this->randomName(10));
|
|
$this->assertText($node->title, t('Found the custom 404 page'));
|
|
|
|
// Logout and check that the user login block is not shown on custom 404 pages.
|
|
$this->drupalLogout();
|
|
|
|
$this->drupalGet($this->randomName(10));
|
|
$this->assertText($node->title, t('Found the custom 404 page'));
|
|
$this->assertNoText(t('User login'), t('Blocks are not shown on the custom 404 page'));
|
|
|
|
// Log back in and remove the custom 404 page.
|
|
$this->drupalLogin($this->admin_user);
|
|
$this->drupalPost('admin/settings/site-information', array('site_404' => ''), t('Save configuration'));
|
|
|
|
// Logout and check that the user login block is not shown on default 404 pages.
|
|
$this->drupalLogout();
|
|
|
|
$this->drupalGet($this->randomName(10));
|
|
$this->assertText(t('Page not found'), t('Found the default 404 page'));
|
|
$this->assertNoText(t('User login'), t('Blocks are not shown on the default 404 page'));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests site maintenance functionality.
|
|
*/
|
|
class SiteMaintenanceTestCase extends DrupalWebTestCase {
|
|
protected $admin_user;
|
|
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'Site maintenance mode functionality',
|
|
'description' => 'Test access to site while in maintenance mode.',
|
|
'group' => 'System',
|
|
);
|
|
}
|
|
|
|
function setUp() {
|
|
parent::setUp();
|
|
|
|
// Create a user allowed to access site in maintenance mode.
|
|
$this->user = $this->drupalCreateUser(array('access site in maintenance mode'));
|
|
// Create an administrative user.
|
|
$this->admin_user = $this->drupalCreateUser(array('administer site configuration', 'access site in maintenance mode'));
|
|
$this->drupalLogin($this->admin_user);
|
|
}
|
|
|
|
/**
|
|
* Verify site maintenance mode functionality.
|
|
*/
|
|
function testSiteMaintenance() {
|
|
// Turn on maintenance mode.
|
|
$edit = array(
|
|
'maintenance_mode' => 1,
|
|
);
|
|
$this->drupalPost('admin/config/development/maintenance', $edit, t('Save configuration'));
|
|
|
|
$admin_message = t('Operating in maintenance mode. <a href="@url">Go online.</a>', array('@url' => url('admin/config/development/maintenance')));
|
|
$user_message = t('Operating in maintenance mode.');
|
|
$offline_message = t('@site is currently under maintenance. We should be back shortly. Thank you for your patience.', array('@site' => variable_get('site_name', 'Drupal')));
|
|
|
|
$this->drupalGet('');
|
|
$this->assertRaw($admin_message, t('Found the site maintenance mode message.'));
|
|
|
|
// Logout and verify that offline message is displayed.
|
|
$this->drupalLogout();
|
|
$this->drupalGet('');
|
|
$this->assertText($offline_message);
|
|
$this->drupalGet('node');
|
|
$this->assertText($offline_message);
|
|
$this->drupalGet('user/register');
|
|
$this->assertText($offline_message);
|
|
$this->drupalGet('user/password');
|
|
$this->assertText($offline_message);
|
|
|
|
// Verify that user is able to log in.
|
|
$this->drupalGet('user');
|
|
$this->assertNoText($offline_message);
|
|
$this->drupalGet('user/login');
|
|
$this->assertNoText($offline_message);
|
|
|
|
// Log in user and verify that maintenance mode message is displayed
|
|
// directly after login.
|
|
$edit = array(
|
|
'name' => $this->user->name,
|
|
'pass' => $this->user->pass_raw,
|
|
);
|
|
$this->drupalPost(NULL, $edit, t('Log in'));
|
|
$this->assertText($user_message);
|
|
|
|
// Log in administrative user and configure a custom site offline message.
|
|
$this->drupalLogout();
|
|
$this->drupalLogin($this->admin_user);
|
|
$this->drupalGet('admin/config/development/maintenance');
|
|
$this->assertNoRaw($admin_message, t('Site maintenance mode message not displayed.'));
|
|
|
|
$offline_message = 'Sorry, not online.';
|
|
$edit = array(
|
|
'maintenance_mode_message' => $offline_message,
|
|
);
|
|
$this->drupalPost(NULL, $edit, t('Save configuration'));
|
|
|
|
// Logout and verify that custom site offline message is displayed.
|
|
$this->drupalLogout();
|
|
$this->drupalGet('');
|
|
$this->assertRaw($offline_message, t('Found the site offline message.'));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests generic date and time handling capabilities of Drupal.
|
|
*/
|
|
class DateTimeFunctionalTest extends DrupalWebTestCase {
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'Date and time',
|
|
'description' => 'Configure date and time settings. Test date formatting and time zone handling, including daylight saving time.',
|
|
'group' => 'System',
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Test time zones and DST handling.
|
|
*/
|
|
function testTimeZoneHandling() {
|
|
// Setup date/time settings for Honolulu time.
|
|
variable_set('date_default_timezone', 'Pacific/Honolulu');
|
|
variable_set('configurable_timezones', 0);
|
|
variable_set('date_format_medium', 'Y-m-d H:i:s O');
|
|
|
|
// Create some nodes with different authored-on dates.
|
|
$date1 = '2007-01-31 21:00:00 -1000';
|
|
$date2 = '2007-07-31 21:00:00 -1000';
|
|
$node1 = $this->drupalCreateNode(array('created' => strtotime($date1), 'type' => 'article'));
|
|
$node2 = $this->drupalCreateNode(array('created' => strtotime($date2), 'type' => 'article'));
|
|
|
|
// Confirm date format and time zone.
|
|
$this->drupalGet("node/$node1->nid");
|
|
$this->assertText('2007-01-31 21:00:00 -1000', t('Date should be identical, with GMT offset of -10 hours.'));
|
|
$this->drupalGet("node/$node2->nid");
|
|
$this->assertText('2007-07-31 21:00:00 -1000', t('Date should be identical, with GMT offset of -10 hours.'));
|
|
|
|
// Set time zone to Los Angeles time.
|
|
variable_set('date_default_timezone', 'America/Los_Angeles');
|
|
|
|
// Confirm date format and time zone.
|
|
$this->drupalGet("node/$node1->nid");
|
|
$this->assertText('2007-01-31 23:00:00 -0800', t('Date should be two hours ahead, with GMT offset of -8 hours.'));
|
|
$this->drupalGet("node/$node2->nid");
|
|
$this->assertText('2007-08-01 00:00:00 -0700', t('Date should be three hours ahead, with GMT offset of -7 hours.'));
|
|
}
|
|
}
|
|
|
|
class PageTitleFiltering extends DrupalWebTestCase {
|
|
protected $content_user;
|
|
protected $saved_title;
|
|
|
|
/**
|
|
* Implement getInfo().
|
|
*/
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'HTML in page titles',
|
|
'description' => 'Tests correct handling or conversion by drupal_set_title() and drupal_get_title().',
|
|
'group' => 'System'
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Implement setUp().
|
|
*/
|
|
function setUp() {
|
|
parent::setUp();
|
|
|
|
$this->content_user = $this->drupalCreateUser(array('create page content', 'access content'));
|
|
$this->drupalLogin($this->content_user);
|
|
$this->saved_title = drupal_get_title();
|
|
}
|
|
|
|
/**
|
|
* Reset page title.
|
|
*/
|
|
function tearDown() {
|
|
// Restore the page title.
|
|
drupal_set_title($this->saved_title, PASS_THROUGH);
|
|
|
|
parent::tearDown();
|
|
}
|
|
|
|
/**
|
|
* Tests the handling of HTML by drupal_set_title() and drupal_get_title()
|
|
*/
|
|
function testTitleTags() {
|
|
$title = "string with <em>HTML</em>";
|
|
// drupal_set_title's $filter is CHECK_PLAIN by default, so the title should be
|
|
// returned with check_plain().
|
|
drupal_set_title($title, CHECK_PLAIN);
|
|
$this->assertTrue(strpos(drupal_get_title(), '<em>') === FALSE, t('Tags in title converted to entities when $output is CHECK_PLAIN.'));
|
|
// drupal_set_title's $filter is passed as PASS_THROUGH, so the title should be
|
|
// returned with HTML.
|
|
drupal_set_title($title, PASS_THROUGH);
|
|
$this->assertTrue(strpos(drupal_get_title(), '<em>') !== FALSE, t('Tags in title are not converted to entities when $output is PASS_THROUGH.'));
|
|
// Generate node content.
|
|
$langcode = FIELD_LANGUAGE_NONE;
|
|
$edit = array(
|
|
'title' => '!SimpleTest! ' . $title . $this->randomName(20),
|
|
"body[$langcode][0][value]" => '!SimpleTest! test body' . $this->randomName(200),
|
|
);
|
|
// Create the node with HTML in the title.
|
|
$this->drupalPost('node/add/page', $edit, t('Save'));
|
|
|
|
$node = $this->drupalGetNodeByTitle($edit['title']);
|
|
$this->assertNotNull($node, 'Node created and found in database');
|
|
$this->drupalGet("node/" . $node->nid);
|
|
$this->assertText(check_plain($edit['title']), 'Check to make sure tags in the node title are converted.');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test front page functionality and administration.
|
|
*/
|
|
class FrontPageTestCase extends DrupalWebTestCase {
|
|
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'Front page',
|
|
'description' => 'Tests front page functionality and administration.',
|
|
'group' => 'System',
|
|
);
|
|
}
|
|
|
|
function setUp() {
|
|
parent::setUp('system_test');
|
|
|
|
// Create admin user, log in admin user, and create one node.
|
|
$this->admin_user = $this->drupalCreateUser(array('access content', 'administer site configuration'));
|
|
$this->drupalLogin($this->admin_user);
|
|
$this->node_path = "node/" . $this->drupalCreateNode(array('promote' => 1))->nid;
|
|
|
|
// Enable front page logging in system_test.module.
|
|
variable_set('front_page_output', 1);
|
|
}
|
|
|
|
/**
|
|
* Test front page functionality.
|
|
*/
|
|
function testDrupalIsFrontPage() {
|
|
$this->drupalGet('');
|
|
$this->assertText(t('On front page.'), t('Path is the front page.'));
|
|
$this->drupalGet('node');
|
|
$this->assertText(t('On front page.'), t('Path is the front page.'));
|
|
$this->drupalGet($this->node_path);
|
|
$this->assertNoText(t('On front page.'), t('Path is not the front page.'));
|
|
|
|
// Change the front page to an invalid path.
|
|
$edit = array('site_frontpage' => 'kittens');
|
|
$this->drupalPost('admin/settings/site-information', $edit, t('Save configuration'));
|
|
$this->assertText(t("The path '@path' is either invalid or you do not have access to it.", array('@path' => $edit['site_frontpage'])));
|
|
|
|
// Change the front page to a valid path.
|
|
$edit['site_frontpage'] = $this->node_path;
|
|
$this->drupalPost('admin/settings/site-information', $edit, t('Save configuration'));
|
|
$this->assertText(t('The configuration options have been saved.'), t('The front page path has been saved.'));
|
|
|
|
$this->drupalGet('');
|
|
$this->assertText(t('On front page.'), t('Path is the front page.'));
|
|
$this->drupalGet('node');
|
|
$this->assertNoText(t('On front page.'), t('Path is not the front page.'));
|
|
$this->drupalGet($this->node_path);
|
|
$this->assertText(t('On front page.'), t('Path is the front page.'));
|
|
}
|
|
}
|
|
|
|
class SystemBlockTestCase extends DrupalWebTestCase {
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'Block functionality',
|
|
'description' => 'Configure and move powered-by block.',
|
|
'group' => 'System',
|
|
);
|
|
}
|
|
|
|
function setUp() {
|
|
parent::setUp();
|
|
|
|
// Create and login user
|
|
$admin_user = $this->drupalCreateUser(array('administer blocks'));
|
|
$this->drupalLogin($admin_user);
|
|
}
|
|
|
|
/**
|
|
* Test displaying and hiding the powered-by block.
|
|
*/
|
|
function testPoweredByBlock() {
|
|
// Set block title and some settings to confirm that the interface is availble.
|
|
$this->drupalPost('admin/structure/block/configure/system/powered-by', array('title' => $this->randomName(8), 'color' => 'powered-black', 'size' => '135x42'), t('Save block'));
|
|
$this->assertText(t('The block configuration has been saved.'), t('Block configuration set.'));
|
|
|
|
// Set the powered-by block to the footer region.
|
|
$edit = array();
|
|
$edit['system_powered-by[region]'] = 'footer';
|
|
$this->drupalPost('admin/structure/block', $edit, t('Save blocks'));
|
|
$this->assertText(t('The block settings have been updated.'), t('Block successfully move to footer region.'));
|
|
|
|
// Confirm that the block is being displayed.
|
|
$this->assertRaw('id="block-system-powered-by"', t('Block successfully being displayed on the page.'));
|
|
|
|
// Set the block to the disabled region.
|
|
$edit = array();
|
|
$edit['system_powered-by[region]'] = '-1';
|
|
$this->drupalPost('admin/structure/block', $edit, t('Save blocks'));
|
|
|
|
// Confirm that the block is hidden.
|
|
$this->assertNoRaw('id="block-system-powered-by"', t('Block no longer appears on page.'));
|
|
|
|
// For convenience of developers, set the block to it's default settings.
|
|
$edit = array();
|
|
$edit['system_powered-by[region]'] = 'footer';
|
|
$this->drupalPost('admin/structure/block', $edit, t('Save blocks'));
|
|
$this->drupalPost('admin/structure/block/configure/system/powered-by', array('title' => '', 'color' => 'powered-blue', 'size' => '80x15'), t('Save block'));
|
|
}
|
|
|
|
}
|
|
|
|
class SystemSettingsForm extends DrupalWebTestCase {
|
|
/**
|
|
* Implement getInfo().
|
|
*/
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'System setting forms',
|
|
'description' => 'Tests correctness of system_settings_form() processing.',
|
|
'group' => 'System'
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Implement setUp().
|
|
*/
|
|
function setUp() {
|
|
parent::setUp();
|
|
|
|
variable_set('system_settings_form_test', TRUE);
|
|
variable_set('system_settings_form_test_4', TRUE);
|
|
}
|
|
|
|
/**
|
|
* Reset page title.
|
|
*/
|
|
function tearDown() {
|
|
variable_del('system_settings_form_test');
|
|
variable_del('system_settings_form_test_4');
|
|
|
|
parent::tearDown();
|
|
}
|
|
|
|
/**
|
|
* Tests the handling of automatic defaults in systems_settings_form().
|
|
*/
|
|
function testAutomaticDefaults() {
|
|
$form = array();
|
|
|
|
$form['system_settings_form_test'] = array(
|
|
'#type' => 'checkbox',
|
|
'#default_value' => FALSE,
|
|
);
|
|
|
|
$form['system_settings_form_test_2'] = array(
|
|
'#type' => 'checkbox',
|
|
'#default_value' => FALSE,
|
|
);
|
|
|
|
$form['system_settings_form_test_3'] = array(
|
|
'#type' => 'checkbox',
|
|
'#default_value' => TRUE,
|
|
);
|
|
|
|
$form['has_children']['system_settings_form_test_4'] = array(
|
|
'#type' => 'checkbox',
|
|
'#default_value' => FALSE,
|
|
);
|
|
|
|
$form['has_children']['system_settings_form_test_5'] = array(
|
|
'#type' => 'checkbox',
|
|
'#default_value' => TRUE,
|
|
);
|
|
|
|
$automatic = system_settings_form($form, FALSE);
|
|
$this->assertFalse($automatic['system_settings_form_test']['#default_value']);
|
|
$this->assertFalse($automatic['system_settings_form_test_2']['#default_value']);
|
|
$this->assertTrue($automatic['system_settings_form_test_3']['#default_value']);
|
|
$this->assertFalse($automatic['has_children']['system_settings_form_test_4']['#default_value']);
|
|
$this->assertTrue($automatic['has_children']['system_settings_form_test_5']['#default_value']);
|
|
|
|
$no_automatic = system_settings_form($form);
|
|
$this->assertTrue($no_automatic['system_settings_form_test']['#default_value']);
|
|
$this->assertFalse($no_automatic['system_settings_form_test_2']['#default_value']);
|
|
$this->assertTrue($no_automatic['system_settings_form_test_3']['#default_value']);
|
|
$this->assertTrue($no_automatic['has_children']['system_settings_form_test_4']['#default_value']);
|
|
$this->assertTrue($no_automatic['has_children']['system_settings_form_test_5']['#default_value']);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests for the theme interface functionality.
|
|
*/
|
|
class SystemThemeFunctionalTest extends DrupalWebTestCase {
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'Theme interface functionality',
|
|
'description' => 'Tests the theme interface functionality by enabling and switching themes, and using an administration theme.',
|
|
'group' => 'System',
|
|
);
|
|
}
|
|
|
|
function setUp() {
|
|
parent::setUp();
|
|
|
|
$this->admin_user = $this->drupalCreateUser(array('access administration pages', 'administer site configuration', 'bypass node access'));
|
|
$this->drupalLogin($this->admin_user);
|
|
$this->node = $this->drupalCreateNode();
|
|
}
|
|
|
|
/**
|
|
* Test the administration theme functionality.
|
|
*/
|
|
function testAdministrationTheme() {
|
|
// Enable an administration theme and show it on the node admin pages.
|
|
$edit = array(
|
|
'theme_default' => 'stark',
|
|
'admin_theme' => 'garland',
|
|
'node_admin_theme' => TRUE,
|
|
);
|
|
$this->drupalPost('admin/appearance', $edit, t('Save configuration'));
|
|
|
|
$this->drupalGet('admin');
|
|
$this->assertRaw('themes/garland', t('Administration theme used on an administration page.'));
|
|
|
|
$this->drupalGet('node/' . $this->node->nid);
|
|
$this->assertRaw('themes/stark', t('Site default theme used on node page.'));
|
|
|
|
$this->drupalGet('node/add');
|
|
$this->assertRaw('themes/garland', t('Administration theme used on the add content page.'));
|
|
|
|
$this->drupalGet('node/' . $this->node->nid . '/edit');
|
|
$this->assertRaw('themes/garland', t('Administration theme used on the edit content page.'));
|
|
|
|
// Disable the admin theme on the node admin pages.
|
|
$edit = array(
|
|
'node_admin_theme' => FALSE,
|
|
);
|
|
$this->drupalPost('admin/appearance', $edit, t('Save configuration'));
|
|
|
|
$this->drupalGet('admin');
|
|
$this->assertRaw('themes/garland', t('Administration theme used on an administration page.'));
|
|
|
|
$this->drupalGet('node/add');
|
|
$this->assertRaw('themes/stark', t('Site default theme used on the add content page.'));
|
|
|
|
// Reset to the default theme settings.
|
|
$edit = array(
|
|
'theme_default' => 'garland',
|
|
'admin_theme' => '0',
|
|
'node_admin_theme' => FALSE,
|
|
);
|
|
$this->drupalPost('admin/appearance', $edit, t('Save configuration'));
|
|
|
|
$this->drupalGet('admin');
|
|
$this->assertRaw('themes/garland', t('Site default theme used on administration page.'));
|
|
|
|
$this->drupalGet('node/add');
|
|
$this->assertRaw('themes/garland', t('Site default theme used on the add content page.'));
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Test the basic queue functionality.
|
|
*/
|
|
class QueueTestCase extends DrupalWebTestCase {
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'Queue functionality',
|
|
'description' => 'Queues and dequeues a set of items to check the basic queue functionality.',
|
|
'group' => 'System',
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Queues and dequeues a set of items to check the basic queue functionality.
|
|
*/
|
|
function testQueue() {
|
|
// Create two queues.
|
|
$queue1 = DrupalQueue::get($this->randomName());
|
|
$queue1->createQueue();
|
|
$queue2 = DrupalQueue::get($this->randomName());
|
|
$queue2->createQueue();
|
|
|
|
// Create four items.
|
|
$data = array();
|
|
for ($i = 0; $i < 4; $i++) {
|
|
$data[] = array($this->randomName() => $this->randomName());
|
|
}
|
|
|
|
// Queue items 1 and 2 in the queue1.
|
|
$queue1->createItem($data[0]);
|
|
$queue1->createItem($data[1]);
|
|
|
|
// Retrieve two items from queue1.
|
|
$items = array();
|
|
$new_items = array();
|
|
|
|
$items[] = $item = $queue1->claimItem();
|
|
$new_items[] = $item->data;
|
|
|
|
$items[] = $item = $queue1->claimItem();
|
|
$new_items[] = $item->data;
|
|
|
|
// First two dequeued items should match the first two items we queued.
|
|
$this->assertEqual($this->queueScore($data, $new_items), 2, t('Two items matched'));
|
|
|
|
// Add two more items.
|
|
$queue1->createItem($data[2]);
|
|
$queue1->createItem($data[3]);
|
|
|
|
$this->assertTrue($queue1->numberOfItems(), t('Queue 1 is not empty after adding items.'));
|
|
$this->assertFalse($queue2->numberOfItems(), t('Queue 2 is empty while Queue 1 has items'));
|
|
|
|
$items[] = $item = $queue1->claimItem();
|
|
$new_items[] = $item->data;
|
|
|
|
$items[] = $item = $queue1->claimItem();
|
|
$new_items[] = $item->data;
|
|
|
|
// All dequeued items should match the items we queued exactly once,
|
|
// therefore the score must be exactly 4.
|
|
$this->assertEqual($this->queueScore($data, $new_items), 4, t('Four items matched'));
|
|
|
|
// There should be no duplicate items.
|
|
$this->assertEqual($this->queueScore($new_items, $new_items), 4, t('Four items matched'));
|
|
|
|
// Delete all items from queue1.
|
|
foreach ($items as $item) {
|
|
$queue1->deleteItem($item);
|
|
}
|
|
|
|
// Check that both queues are empty.
|
|
$this->assertFalse($queue1->numberOfItems(), t('Queue 1 is empty'));
|
|
$this->assertFalse($queue2->numberOfItems(), t('Queue 2 is empty'));
|
|
}
|
|
|
|
/**
|
|
* This function returns the number of equal items in two arrays.
|
|
*/
|
|
function queueScore($items, $new_items) {
|
|
$score = 0;
|
|
foreach ($items as $item) {
|
|
foreach ($new_items as $new_item) {
|
|
if ($item === $new_item) {
|
|
$score++;
|
|
}
|
|
}
|
|
}
|
|
return $score;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test token replacement in strings.
|
|
*/
|
|
class TokenReplaceTestCase extends DrupalWebTestCase {
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'Token replacement',
|
|
'description' => 'Generates text using placeholders for dummy content to check token replacement.',
|
|
'group' => 'System',
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Creates a user and a node, then tests the tokens generated from them.
|
|
*/
|
|
function testTokenReplacement() {
|
|
// Create the initial objects.
|
|
$account = $this->drupalCreateUser();
|
|
$node = $this->drupalCreateNode(array('uid' => $account->uid));
|
|
$node->title = '<blink>Blinking Text</blink>';
|
|
global $user;
|
|
|
|
$source = '[node:title]'; // Title of the node we passed in
|
|
$source .= '[node:author:name]'; // Node author's name
|
|
$source .= '[node:created:since]'; // Time since the node was created
|
|
$source .= '[current-user:name]'; // Current user's name
|
|
$source .= '[user:name]'; // No user passed in, should be untouched
|
|
$source .= '[date:small]'; // Small date format of REQUEST_TIME
|
|
$source .= '[bogus:token]'; // Nonexistent token, should be untouched
|
|
|
|
$target = check_plain($node->title);
|
|
$target .= check_plain($account->name);
|
|
$target .= format_interval(REQUEST_TIME - $node->created, 2);
|
|
$target .= check_plain($user->name);
|
|
$target .= '[user:name]';
|
|
$target .= format_date(REQUEST_TIME, 'small');
|
|
$target .= '[bogus:token]';
|
|
|
|
$result = token_replace($source, array('node' => $node));
|
|
|
|
// Check that the results of token_generate are sanitized properly. This does NOT
|
|
// test the cleanliness of every token -- just that the $sanitize flag is being
|
|
// passed properly through the call stack and being handled correctly by a 'known'
|
|
// token, [node:title].
|
|
$this->assertFalse(strcmp($target, $result), t('Basic placeholder tokens replaced.'));
|
|
|
|
$raw_tokens = array(
|
|
'node' => array('title' => '[node:title]'),
|
|
);
|
|
$generated = token_generate($raw_tokens, array('node' => $node));
|
|
$this->assertFalse(strcmp($generated['[node:title]'], check_plain($node->title)), t('Token sanitized.'));
|
|
|
|
$generated = token_generate($raw_tokens, array('node' => $node), array('sanitize' => FALSE));
|
|
$this->assertFalse(strcmp($generated['[node:title]'], $node->title), t('Unsanitized token generated properly.'));
|
|
}
|
|
}
|