2865 lines
112 KiB
Plaintext
2865 lines
112 KiB
Plaintext
<?php
|
|
|
|
use Drupal\Core\Database\Database;
|
|
use Drupal\Component\Graph\Graph;
|
|
|
|
/**
|
|
* @file
|
|
* Tests for system.module.
|
|
*/
|
|
|
|
/**
|
|
* 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 modules'));
|
|
$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 that all tables defined in a module's hook_schema() exist.
|
|
*
|
|
* @param $module
|
|
* The name of the module.
|
|
*/
|
|
function assertModuleTablesExist($module) {
|
|
$tables = array_keys(drupal_get_schema_unprocessed($module));
|
|
$tables_exist = TRUE;
|
|
foreach ($tables as $table) {
|
|
if (!db_table_exists($table)) {
|
|
$tables_exist = FALSE;
|
|
}
|
|
}
|
|
return $this->assertTrue($tables_exist, t('All database tables defined by the @module module exist.', array('@module' => $module)));
|
|
}
|
|
|
|
/**
|
|
* Assert that none of the tables defined in a module's hook_schema() exist.
|
|
*
|
|
* @param $module
|
|
* The name of the module.
|
|
*/
|
|
function assertModuleTablesDoNotExist($module) {
|
|
$tables = array_keys(drupal_get_schema_unprocessed($module));
|
|
$tables_exist = FALSE;
|
|
foreach ($tables as $table) {
|
|
if (db_table_exists($table)) {
|
|
$tables_exist = TRUE;
|
|
}
|
|
}
|
|
return $this->assertFalse($tables_exist, t('None of the database tables defined by the @module module exist.', array('@module' => $module)));
|
|
}
|
|
|
|
/**
|
|
* Assert that a module's config files have been loaded.
|
|
*
|
|
* @param string $module
|
|
* The name of the module.
|
|
*
|
|
* @return bool
|
|
* TRUE if the module's config files exist, FALSE otherwise.
|
|
*/
|
|
function assertModuleConfigFilesExist($module) {
|
|
// Define test variable.
|
|
$files_exist = TRUE;
|
|
// Get the path to the module's config dir.
|
|
$module_config_dir = drupal_get_path('module', $module) . '/config';
|
|
if (is_dir($module_config_dir)) {
|
|
$files = glob($module_config_dir . '/' . '*.xml');
|
|
$config_dir = config_get_config_directory();
|
|
// Get the filename of each config file.
|
|
foreach ($files as $file) {
|
|
$parts = explode('/', $file);
|
|
$filename = array_pop($parts);
|
|
if (!file_exists($config_dir . '/' . $filename)) {
|
|
$files_exist = FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
return $this->assertTrue($files_exist, t('All config files defined by the @module module have been copied to the live config directory.', array('@module' => $module)));
|
|
}
|
|
|
|
/**
|
|
* Assert that none of a module's default config files are loaded.
|
|
*
|
|
* @param string $module
|
|
* The name of the module.
|
|
*
|
|
* @return bool
|
|
* TRUE if the module's config files do not exist, FALSE otherwise.
|
|
*/
|
|
function assertModuleConfigFilesDoNotExist($module) {
|
|
// Define test variable.
|
|
$files_exist = FALSE;
|
|
// Get the path to the module's config dir.
|
|
$module_config_dir = drupal_get_path('module', $module) . '/config';
|
|
if (is_dir($module_config_dir)) {
|
|
$files = glob($module_config_dir . '/' . '*.xml');
|
|
$config_dir = config_get_config_directory();
|
|
// Get the filename of each config file.
|
|
foreach ($files as $file) {
|
|
$parts = explode('/', $file);
|
|
$filename = array_pop($parts);
|
|
if (file_exists($config_dir . '/' . $filename)) {
|
|
$files_exist = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
return $this->assertFalse($files_exist, t('All config files defined by the @module module have been deleted from the live config directory.', array('@module' => $module)));
|
|
}
|
|
|
|
/**
|
|
* 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',
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Test that all core modules can be enabled, disabled and uninstalled.
|
|
*/
|
|
function testEnableDisable() {
|
|
// Try to enable, disable and uninstall all core modules, unless they are
|
|
// hidden or required.
|
|
$modules = system_rebuild_module_data();
|
|
foreach ($modules as $name => $module) {
|
|
if ($module->info['package'] != 'Core' || !empty($module->info['hidden']) || !empty($module->info['required'])) {
|
|
unset($modules[$name]);
|
|
}
|
|
}
|
|
|
|
// Throughout this test, some modules may be automatically enabled (due to
|
|
// dependencies). We'll keep track of them in an array, so we can handle
|
|
// them separately.
|
|
$automatically_enabled = array();
|
|
|
|
// Remove already enabled modules (via installation profile).
|
|
// @todo Remove this after removing all dependencies from Testing profile.
|
|
foreach (module_list() as $dependency) {
|
|
// Exclude required modules. Only installation profile "suggestions" can
|
|
// be disabled and uninstalled.
|
|
if (isset($modules[$dependency])) {
|
|
$automatically_enabled[$dependency] = TRUE;
|
|
}
|
|
}
|
|
|
|
$this->assertTrue(count($modules), t('Found @count modules that can be enabled: %modules', array(
|
|
'@count' => count($modules),
|
|
'%modules' => implode(', ', array_keys($modules)),
|
|
)));
|
|
|
|
// Enable the dblog module first, since we will be asserting the presence
|
|
// of log messages throughout the test.
|
|
if (isset($modules['dblog'])) {
|
|
$modules = array('dblog' => $modules['dblog']) + $modules;
|
|
}
|
|
|
|
// Set a variable so that the hook implementations in system_test.module
|
|
// will display messages via drupal_set_message().
|
|
variable_set('test_verbose_module_hooks', TRUE);
|
|
|
|
// Go through each module in the list and try to enable it (unless it was
|
|
// already enabled automatically due to a dependency).
|
|
foreach ($modules as $name => $module) {
|
|
if (empty($automatically_enabled[$name])) {
|
|
// Start a list of modules that we expect to be enabled this time.
|
|
$modules_to_enable = array($name);
|
|
|
|
// Find out if the module has any dependencies that aren't enabled yet;
|
|
// if so, add them to the list of modules we expect to be automatically
|
|
// enabled.
|
|
foreach (array_keys($module->requires) as $dependency) {
|
|
if (isset($modules[$dependency]) && empty($automatically_enabled[$dependency])) {
|
|
$modules_to_enable[] = $dependency;
|
|
$automatically_enabled[$dependency] = TRUE;
|
|
}
|
|
}
|
|
|
|
// Check that each module is not yet enabled and does not have any
|
|
// database tables yet.
|
|
foreach ($modules_to_enable as $module_to_enable) {
|
|
$this->assertModules(array($module_to_enable), FALSE);
|
|
$this->assertModuleTablesDoNotExist($module_to_enable);
|
|
}
|
|
|
|
// Install and enable the module.
|
|
$edit = array();
|
|
$edit['modules[Core][' . $name . '][enable]'] = $name;
|
|
$this->drupalPost('admin/modules', $edit, t('Save configuration'));
|
|
// Handle the case where modules were installed along with this one and
|
|
// where we therefore hit a confirmation screen.
|
|
if (count($modules_to_enable) > 1) {
|
|
$this->drupalPost(NULL, array(), t('Continue'));
|
|
}
|
|
$this->assertText(t('The configuration options have been saved.'), t('Modules status has been updated.'));
|
|
|
|
// Check that hook_modules_installed() and hook_modules_enabled() were
|
|
// invoked with the expected list of modules, that each module's
|
|
// database tables now exist, and that appropriate messages appear in
|
|
// the logs.
|
|
foreach ($modules_to_enable as $module_to_enable) {
|
|
$this->assertText(t('hook_modules_installed fired for @module', array('@module' => $module_to_enable)));
|
|
$this->assertText(t('hook_modules_enabled fired for @module', array('@module' => $module_to_enable)));
|
|
$this->assertModules(array($module_to_enable), TRUE);
|
|
$this->assertModuleTablesExist($module_to_enable);
|
|
$this->assertModuleConfigFilesExist($module_to_enable);
|
|
$this->assertLogMessage('system', "%module module installed.", array('%module' => $module_to_enable), WATCHDOG_INFO);
|
|
$this->assertLogMessage('system', "%module module enabled.", array('%module' => $module_to_enable), WATCHDOG_INFO);
|
|
}
|
|
|
|
// Disable and uninstall the original module, and check appropriate
|
|
// hooks, tables, and log messages. (Later, we'll go back and do the
|
|
// same thing for modules that were enabled automatically.) Skip this
|
|
// for the dblog module, because that is needed for the test; we'll go
|
|
// back and do that one at the end also.
|
|
if ($name != 'dblog') {
|
|
$this->assertSuccessfulDisableAndUninstall($name);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Go through all modules that were automatically enabled, and try to
|
|
// disable and uninstall them one by one.
|
|
while (!empty($automatically_enabled)) {
|
|
$initial_count = count($automatically_enabled);
|
|
foreach (array_keys($automatically_enabled) as $name) {
|
|
// If the module can't be disabled due to dependencies, skip it and try
|
|
// again the next time. Otherwise, try to disable it.
|
|
$this->drupalGet('admin/modules');
|
|
$disabled_checkbox = $this->xpath('//input[@type="checkbox" and @disabled="disabled" and @name="modules[Core][' . $name . '][enable]"]');
|
|
if (empty($disabled_checkbox) && $name != 'dblog') {
|
|
unset($automatically_enabled[$name]);
|
|
$this->assertSuccessfulDisableAndUninstall($name);
|
|
}
|
|
}
|
|
$final_count = count($automatically_enabled);
|
|
// If all checkboxes were disabled, something is really wrong with the
|
|
// test. Throw a failure and avoid an infinite loop.
|
|
if ($initial_count == $final_count) {
|
|
$this->fail(t('Remaining modules could not be disabled.'));
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Disable and uninstall the dblog module last, since we needed it for
|
|
// assertions in all the above tests.
|
|
if (isset($modules['dblog'])) {
|
|
$this->assertSuccessfulDisableAndUninstall('dblog');
|
|
}
|
|
|
|
// Now that all modules have been tested, go back and try to enable them
|
|
// all again at once. This tests two things:
|
|
// - That each module can be successfully enabled again after being
|
|
// uninstalled.
|
|
// - That enabling more than one module at the same time does not lead to
|
|
// any errors.
|
|
$edit = array();
|
|
foreach (array_keys($modules) as $name) {
|
|
$edit['modules[Core][' . $name . '][enable]'] = $name;
|
|
}
|
|
$this->drupalPost('admin/modules', $edit, t('Save configuration'));
|
|
$this->assertText(t('The configuration options have been saved.'), t('Modules status has been updated.'));
|
|
}
|
|
|
|
/**
|
|
* Disables and uninstalls a module and asserts that it was done correctly.
|
|
*
|
|
* @param $module
|
|
* The name of the module to disable and uninstall.
|
|
*/
|
|
function assertSuccessfulDisableAndUninstall($module) {
|
|
// Disable the module.
|
|
$edit = array();
|
|
$edit['modules[Core][' . $module . '][enable]'] = FALSE;
|
|
$this->drupalPost('admin/modules', $edit, t('Save configuration'));
|
|
$this->assertText(t('The configuration options have been saved.'), t('Modules status has been updated.'));
|
|
$this->assertModules(array($module), FALSE);
|
|
|
|
// Check that the appropriate hook was fired and the appropriate log
|
|
// message appears.
|
|
$this->assertText(t('hook_modules_disabled fired for @module', array('@module' => $module)));
|
|
$this->assertLogMessage('system', "%module module disabled.", array('%module' => $module), WATCHDOG_INFO);
|
|
|
|
// Check that the module's database tables still exist.
|
|
$this->assertModuleTablesExist($module);
|
|
// Check that the module's config files still exist.
|
|
$this->assertModuleConfigFilesExist($module);
|
|
|
|
// Uninstall the module.
|
|
$edit = array();
|
|
$edit['uninstall[' . $module . ']'] = $module;
|
|
$this->drupalPost('admin/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.'));
|
|
$this->assertModules(array($module), FALSE);
|
|
|
|
// Check that the appropriate hook was fired and the appropriate log
|
|
// message appears. (But don't check for the log message if the dblog
|
|
// module was just uninstalled, since the {watchdog} table won't be there
|
|
// anymore.)
|
|
$this->assertText(t('hook_modules_uninstalled fired for @module', array('@module' => $module)));
|
|
if ($module != 'dblog') {
|
|
$this->assertLogMessage('system', "%module module uninstalled.", array('%module' => $module), WATCHDOG_INFO);
|
|
}
|
|
|
|
// Check that the module's database tables no longer exist.
|
|
$this->assertModuleTablesDoNotExist($module);
|
|
// Check that the module's config files no longer exist.
|
|
$this->assertModuleConfigFilesDoNotExist($module);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests failure of hook_requirements('install').
|
|
*/
|
|
class HookRequirementsTestCase extends ModuleTestCase {
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'Requirements hook failure',
|
|
'description' => "Attempts enabling a module that fails hook_requirements('install').",
|
|
'group' => 'Module',
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Assert that a module cannot be installed if it fails hook_requirements().
|
|
*/
|
|
function testHookRequirementsFailure() {
|
|
$this->assertModules(array('requirements1_test'), FALSE);
|
|
|
|
// Attempt to install the requirements1_test module.
|
|
$edit = array();
|
|
$edit['modules[Testing][requirements1_test][enable]'] = 'requirements1_test';
|
|
$this->drupalPost('admin/modules', $edit, t('Save configuration'));
|
|
|
|
// Makes sure the module was NOT installed.
|
|
$this->assertText(t('Requirements 1 Test failed requirements'), t('Modules status has been updated.'));
|
|
$this->assertModules(array('requirements1_test'), FALSE);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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/modules', $edit, t('Save configuration'));
|
|
$this->assertText(t('Some required modules must be enabled'), t('Dependency required.'));
|
|
|
|
$this->assertModules(array('translation', 'locale', 'language'), FALSE);
|
|
|
|
// Assert that the locale tables weren't enabled.
|
|
$this->assertTableCount('language', 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('language', TRUE);
|
|
$this->assertTableCount('locale', TRUE);
|
|
}
|
|
|
|
/**
|
|
* Attempt to enable a module with a missing dependency.
|
|
*/
|
|
function testMissingModules() {
|
|
// Test that the system_dependencies_test module is marked
|
|
// as missing a dependency.
|
|
$this->drupalGet('admin/modules');
|
|
$this->assertRaw(t('@module (<span class="admin-missing">missing</span>)', array('@module' => drupal_ucfirst('_missing_dependency'))), t('A module with missing dependencies is marked as such.'));
|
|
$checkbox = $this->xpath('//input[@type="checkbox" and @disabled="disabled" and @name="modules[Testing][system_dependencies_test][enable]"]');
|
|
$this->assert(count($checkbox) == 1, t('Checkbox for the module is disabled.'));
|
|
|
|
// Force enable the system_dependencies_test module.
|
|
module_enable(array('system_dependencies_test'), FALSE);
|
|
|
|
// Verify that the module is forced to be disabled when submitting
|
|
// the module page.
|
|
$this->drupalPost('admin/modules', array(), t('Save configuration'));
|
|
$this->assertText(t('The @module module is missing, so the following module will be disabled: @depends.', array('@module' => '_missing_dependency', '@depends' => 'system_dependencies_test')), t('The module missing dependencies will be disabled.'));
|
|
|
|
// Confirm.
|
|
$this->drupalPost(NULL, NULL, t('Continue'));
|
|
|
|
// Verify that the module has been disabled.
|
|
$this->assertModules(array('system_dependencies_test'), FALSE);
|
|
}
|
|
|
|
/**
|
|
* Tests enabling a module that depends on an incompatible version of a module.
|
|
*/
|
|
function testIncompatibleModuleVersionDependency() {
|
|
// Test that the system_incompatible_module_version_dependencies_test is
|
|
// marked as having an incompatible dependency.
|
|
$this->drupalGet('admin/modules');
|
|
$this->assertRaw(t('@module (<span class="admin-missing">incompatible with</span> version @version)', array(
|
|
'@module' => 'System incompatible module version test (>2.0)',
|
|
'@version' => '1.0',
|
|
)), 'A module that depends on an incompatible version of a module is marked as such.');
|
|
$checkbox = $this->xpath('//input[@type="checkbox" and @disabled="disabled" and @name="modules[Testing][system_incompatible_module_version_dependencies_test][enable]"]');
|
|
$this->assert(count($checkbox) == 1, t('Checkbox for the module is disabled.'));
|
|
}
|
|
|
|
/**
|
|
* Tests enabling a module that depends on a module with an incompatible core version.
|
|
*/
|
|
function testIncompatibleCoreVersionDependency() {
|
|
// Test that the system_incompatible_core_version_dependencies_test is
|
|
// marked as having an incompatible dependency.
|
|
$this->drupalGet('admin/modules');
|
|
$this->assertRaw(t('@module (<span class="admin-missing">incompatible with</span> this version of Drupal core)', array(
|
|
'@module' => 'System incompatible core version test',
|
|
)), 'A module that depends on a module with an incompatible core version is marked as such.');
|
|
$checkbox = $this->xpath('//input[@type="checkbox" and @disabled="disabled" and @name="modules[Testing][system_incompatible_core_version_dependencies_test][enable]"]');
|
|
$this->assert(count($checkbox) == 1, t('Checkbox for the module is disabled.'));
|
|
}
|
|
|
|
/**
|
|
* Tests enabling a module that depends on a module which fails hook_requirements().
|
|
*/
|
|
function testEnableRequirementsFailureDependency() {
|
|
module_enable(array('comment'));
|
|
|
|
$this->assertModules(array('requirements1_test'), FALSE);
|
|
$this->assertModules(array('requirements2_test'), FALSE);
|
|
|
|
// Attempt to install both modules at the same time.
|
|
$edit = array();
|
|
$edit['modules[Testing][requirements1_test][enable]'] = 'requirements1_test';
|
|
$edit['modules[Testing][requirements2_test][enable]'] = 'requirements2_test';
|
|
$this->drupalPost('admin/modules', $edit, t('Save configuration'));
|
|
|
|
// Makes sure the modules were NOT installed.
|
|
$this->assertText(t('Requirements 1 Test failed requirements'), t('Modules status has been updated.'));
|
|
$this->assertModules(array('requirements1_test'), FALSE);
|
|
$this->assertModules(array('requirements2_test'), FALSE);
|
|
|
|
// Makes sure that already enabled modules the failing modules depend on
|
|
// were not disabled.
|
|
$this->assertModules(array('comment'), TRUE);
|
|
|
|
}
|
|
|
|
/**
|
|
* Tests that module dependencies are enabled in the correct order via the
|
|
* UI. Dependencies should be enabled before their dependents.
|
|
*/
|
|
function testModuleEnableOrder() {
|
|
module_enable(array('module_test'), FALSE);
|
|
$this->resetAll();
|
|
$this->assertModules(array('module_test'), TRUE);
|
|
variable_set('dependency_test', 'dependency');
|
|
// module_test creates a dependency chain:
|
|
// - forum depends on taxonomy, comment, and poll (via module_test)
|
|
// - taxonomy depends on options
|
|
// - poll depends on php (via module_test)
|
|
// The correct enable order is:
|
|
$expected_order = array('comment', 'options', 'taxonomy', 'php', 'poll', 'forum');
|
|
|
|
// Enable the modules through the UI, verifying that the dependency chain
|
|
// is correct.
|
|
$edit = array();
|
|
$edit['modules[Core][forum][enable]'] = 'forum';
|
|
$this->drupalPost('admin/modules', $edit, t('Save configuration'));
|
|
$this->assertModules(array('forum'), FALSE);
|
|
$this->assertText(t('You must enable the Taxonomy, Options, Comment, Poll, PHP Filter modules to install Forum.'));
|
|
$edit['modules[Core][options][enable]'] = 'options';
|
|
$edit['modules[Core][taxonomy][enable]'] = 'taxonomy';
|
|
$edit['modules[Core][comment][enable]'] = 'comment';
|
|
$edit['modules[Core][poll][enable]'] = 'poll';
|
|
$edit['modules[Core][php][enable]'] = 'php';
|
|
$this->drupalPost('admin/modules', $edit, t('Save configuration'));
|
|
$this->assertModules(array('forum', 'poll', 'php', 'comment', 'taxonomy', 'options'), TRUE);
|
|
|
|
// Check the actual order which is saved by module_test_modules_enabled().
|
|
$this->assertIdentical(variable_get('test_module_enable_order', array()), $expected_order);
|
|
}
|
|
|
|
/**
|
|
* Tests attempting to uninstall a module that has installed dependents.
|
|
*/
|
|
function testUninstallDependents() {
|
|
// Enable the forum module.
|
|
$edit = array('modules[Core][forum][enable]' => 'forum');
|
|
$this->drupalPost('admin/modules', $edit, t('Save configuration'));
|
|
$this->drupalPost(NULL, array(), t('Continue'));
|
|
$this->assertModules(array('forum'), TRUE);
|
|
|
|
// Disable forum and comment. Both should now be installed but disabled.
|
|
$edit = array('modules[Core][forum][enable]' => FALSE);
|
|
$this->drupalPost('admin/modules', $edit, t('Save configuration'));
|
|
$this->assertModules(array('forum'), FALSE);
|
|
$edit = array('modules[Core][comment][enable]' => FALSE);
|
|
$this->drupalPost('admin/modules', $edit, t('Save configuration'));
|
|
$this->assertModules(array('comment'), FALSE);
|
|
|
|
// Check that the taxonomy module cannot be uninstalled.
|
|
$this->drupalGet('admin/modules/uninstall');
|
|
$checkbox = $this->xpath('//input[@type="checkbox" and @disabled="disabled" and @name="uninstall[comment]"]');
|
|
$this->assert(count($checkbox) == 1, t('Checkbox for uninstalling the comment module is disabled.'));
|
|
|
|
// Uninstall the forum module, and check that taxonomy now can also be
|
|
// uninstalled.
|
|
$edit = array('uninstall[forum]' => 'forum');
|
|
$this->drupalPost('admin/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.'));
|
|
$edit = array('uninstall[comment]' => 'comment');
|
|
$this->drupalPost('admin/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.'));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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 8.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 (=8.x2.x, >=2.4)',
|
|
// Core version is optional. Compatible.
|
|
'common_test (=8.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/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() {
|
|
$module_info = system_get_info('module');
|
|
$this->drupalGet('admin/modules');
|
|
foreach ($module_info as $module => $info) {
|
|
// Check to make sure the checkbox for each required module is disabled
|
|
// and checked (or absent from the page if the module is also hidden).
|
|
if (!empty($info['required'])) {
|
|
$field_name = "modules[{$info['package']}][$module][enable]";
|
|
if (empty($info['hidden'])) {
|
|
$this->assertFieldByXPath("//input[@name='$field_name' and @disabled='disabled' and @checked='checked']", '', t('Field @name was disabled and checked.', array('@name' => $field_name)));
|
|
}
|
|
else {
|
|
$this->assertNoFieldByName($field_name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
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/config/people/ip-blocking');
|
|
|
|
// Block a valid IP address.
|
|
$edit = array();
|
|
$edit['ip'] = '192.168.1.1';
|
|
$this->drupalPost('admin/config/people/ip-blocking', $edit, t('Add'));
|
|
$ip = db_query("SELECT iid from {blocked_ips} WHERE ip = :ip", array(':ip' => $edit['ip']))->fetchField();
|
|
$this->assertTrue($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/config/people/ip-blocking', $edit, t('Add'));
|
|
$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/config/people/ip-blocking', $edit, t('Add'));
|
|
$this->assertText(t('Enter a valid IP address.'));
|
|
|
|
// Try to block a reserved IP address.
|
|
$edit = array();
|
|
$edit['ip'] = 'test.example.com';
|
|
$this->drupalPost('admin/config/people/ip-blocking', $edit, t('Add'));
|
|
$this->assertText(t('Enter a valid IP address.'));
|
|
|
|
// Submit an empty form.
|
|
$edit = array();
|
|
$edit['ip'] = '';
|
|
$this->drupalPost('admin/config/people/ip-blocking', $edit, t('Add'));
|
|
$this->assertText(t('Enter a valid IP address.'));
|
|
|
|
// Pass an IP address as a URL parameter and submit it.
|
|
$submit_ip = '1.2.3.4';
|
|
$this->drupalPost('admin/config/people/ip-blocking/' . $submit_ip, NULL, t('Add'));
|
|
$ip = db_query("SELECT iid from {blocked_ips} WHERE ip = :ip", array(':ip' => $submit_ip))->fetchField();
|
|
$this->assertTrue($ip, t('IP address found in database'));
|
|
$this->assertRaw(t('The IP address %ip has been blocked.', array('%ip' => $submit_ip)), t('IP address was blocked.'));
|
|
|
|
// 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/config/people/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'
|
|
);
|
|
}
|
|
|
|
function setUp() {
|
|
parent::setUp(array('common_test', 'common_test_cron_helper'));
|
|
}
|
|
|
|
/**
|
|
* Test cron runs.
|
|
*/
|
|
function testCronRun() {
|
|
global $base_url;
|
|
|
|
// Run cron anonymously without any cron key.
|
|
$this->drupalGet($base_url . '/core/cron.php', array('external' => TRUE));
|
|
$this->assertResponse(403);
|
|
|
|
// Run cron anonymously with a random cron key.
|
|
$key = $this->randomName(16);
|
|
$this->drupalGet($base_url . '/core/cron.php', array('external' => TRUE, 'query' => array('cron_key' => $key)));
|
|
$this->assertResponse(403);
|
|
|
|
// Run cron anonymously with the valid cron key.
|
|
$key = variable_get('cron_key', 'drupal');
|
|
$this->drupalGet($base_url . '/core/cron.php', array('external' => TRUE, 'query' => array('cron_key' => $key)));
|
|
$this->assertResponse(200);
|
|
}
|
|
|
|
/**
|
|
* Ensure that the automatic cron run feature 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 testAutomaticCron() {
|
|
// Ensure cron does not run when the cron threshold is enabled and was
|
|
// not passed.
|
|
$cron_last = time();
|
|
$cron_safe_threshold = 100;
|
|
variable_set('cron_last', $cron_last);
|
|
variable_set('cron_safe_threshold', $cron_safe_threshold);
|
|
$this->drupalGet('');
|
|
$this->assertTrue($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.
|
|
$cron_last = time() - 200;
|
|
variable_set('cron_last', $cron_last);
|
|
$this->drupalGet('');
|
|
sleep(1);
|
|
$this->assertTrue($cron_last < variable_get('cron_last', NULL), t('Cron runs when the cron threshold is passed.'));
|
|
|
|
// Disable the cron threshold through the interface.
|
|
$admin_user = $this->drupalCreateUser(array('administer site configuration'));
|
|
$this->drupalLogin($admin_user);
|
|
$this->drupalPost('admin/config/system/cron', array('cron_safe_threshold' => 0), t('Save configuration'));
|
|
$this->assertText(t('The configuration options have been saved.'));
|
|
$this->drupalLogout();
|
|
|
|
// Test if cron does not run when the cron threshold is disabled.
|
|
$cron_last = time() - 200;
|
|
variable_set('cron_last', $cron_last);
|
|
$this->drupalGet('');
|
|
$this->assertTrue($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 statements 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_managed')
|
|
->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_managed')
|
|
->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_managed')
|
|
->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->cronRun();
|
|
$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.'));
|
|
}
|
|
|
|
/**
|
|
* Make sure exceptions thrown on hook_cron() don't affect other modules.
|
|
*/
|
|
function testCronExceptions() {
|
|
variable_del('common_test_cron');
|
|
// The common_test module throws an exception. If it isn't caught, the tests
|
|
// won't finish successfully.
|
|
// The common_test_cron_helper module sets the 'common_test_cron' variable.
|
|
$this->cronRun();
|
|
$result = variable_get('common_test_cron');
|
|
$this->assertEqual($result, 'success', t('Cron correctly handles exceptions thrown during hook_cron() invocations.'));
|
|
}
|
|
}
|
|
|
|
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;
|
|
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => '403 functionality',
|
|
'description' => 'Tests page access denied functionality, including custom 403 pages.',
|
|
'group' => 'System'
|
|
);
|
|
}
|
|
|
|
function setUp() {
|
|
parent::setUp(array('block'));
|
|
|
|
// Create an administrative user.
|
|
$this->admin_user = $this->drupalCreateUser(array('access administration pages', 'administer site configuration', 'administer blocks'));
|
|
|
|
user_role_grant_permissions(DRUPAL_ANONYMOUS_RID, array('access user profiles'));
|
|
user_role_grant_permissions(DRUPAL_AUTHENTICATED_RID, array('access user profiles'));
|
|
}
|
|
|
|
function testAccessDenied() {
|
|
$this->drupalGet('admin');
|
|
$this->assertText(t('Access denied'), t('Found the default 403 page'));
|
|
$this->assertResponse(403);
|
|
|
|
// Use a custom 403 page.
|
|
$this->drupalLogin($this->admin_user);
|
|
$edit = array(
|
|
'site_403' => 'user/' . $this->admin_user->uid,
|
|
);
|
|
$this->drupalPost('admin/config/system/site-information', $edit, t('Save configuration'));
|
|
|
|
// Enable the user login block.
|
|
$edit = array(
|
|
'blocks[user_login][region]' => 'sidebar_first',
|
|
);
|
|
$this->drupalPost('admin/structure/block', $edit, t('Save blocks'));
|
|
|
|
// Logout and check that the user login block is shown on custom 403 pages.
|
|
$this->drupalLogout();
|
|
$this->drupalGet('admin');
|
|
$this->assertText($this->admin_user->name, 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);
|
|
$edit = array(
|
|
'site_403' => '',
|
|
);
|
|
$this->drupalPost('admin/config/system/site-information', $edit, 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->assertResponse(403);
|
|
$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('blocks[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/config/system/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;
|
|
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => '404 functionality',
|
|
'description' => "Tests page not found functionality, including custom 404 pages.",
|
|
'group' => 'System'
|
|
);
|
|
}
|
|
|
|
function setUp() {
|
|
parent::setUp();
|
|
|
|
// Create an administrative user.
|
|
$this->admin_user = $this->drupalCreateUser(array('administer site configuration'));
|
|
|
|
user_role_grant_permissions(DRUPAL_ANONYMOUS_RID, array('access user profiles'));
|
|
user_role_grant_permissions(DRUPAL_AUTHENTICATED_RID, array('access user profiles'));
|
|
}
|
|
|
|
function testPageNotFound() {
|
|
$this->drupalLogin($this->admin_user);
|
|
$this->drupalGet($this->randomName(10));
|
|
$this->assertText(t('Page not found'), t('Found the default 404 page'));
|
|
|
|
// Use a custom 404 page.
|
|
$edit = array(
|
|
'site_404' => 'user/' . $this->admin_user->uid,
|
|
);
|
|
$this->drupalPost('admin/config/system/site-information', $edit, t('Save configuration'));
|
|
|
|
$this->drupalGet($this->randomName(10));
|
|
$this->assertText($this->admin_user->name, t('Found the custom 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(array('node'));
|
|
|
|
// Configure 'node' as front page.
|
|
variable_set('site_frontpage', 'node');
|
|
|
|
// 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);
|
|
|
|
// 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.'));
|
|
|
|
// Verify that custom site offline message is not displayed on user/password.
|
|
$this->drupalGet('user/password');
|
|
$this->assertText(t('Username or e-mail address'), t('Anonymous users can access user/password'));
|
|
|
|
// Submit password reset form.
|
|
$edit = array(
|
|
'name' => $this->user->name,
|
|
);
|
|
$this->drupalPost('user/password', $edit, t('E-mail new password'));
|
|
$mails = $this->drupalGetMails();
|
|
$start = strpos($mails[0]['body'], 'user/reset/'. $this->user->uid);
|
|
$path = substr($mails[0]['body'], $start, 66 + strlen($this->user->uid));
|
|
|
|
// Log in with temporary login link.
|
|
$this->drupalPost($path, array(), t('Log in'));
|
|
$this->assertText($user_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',
|
|
);
|
|
}
|
|
|
|
function setUp() {
|
|
parent::setUp(array('locale'));
|
|
|
|
// Create admin user and log in admin user.
|
|
$this->admin_user = $this->drupalCreateUser(array('administer site configuration'));
|
|
$this->drupalLogin($this->admin_user);
|
|
}
|
|
|
|
|
|
/**
|
|
* 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.'));
|
|
}
|
|
|
|
/**
|
|
* Test date type configuration.
|
|
*/
|
|
function testDateTypeConfiguration() {
|
|
// Confirm system date types appear.
|
|
$this->drupalGet('admin/config/regional/date-time');
|
|
$this->assertText(t('Medium'), 'System date types appear in date type list.');
|
|
$this->assertNoRaw('href="/admin/config/regional/date-time/types/medium/delete"', 'No delete link appear for system date types.');
|
|
|
|
// Add custom date type.
|
|
$this->clickLink(t('Add date type'));
|
|
$date_type = strtolower($this->randomName(8));
|
|
$machine_name = 'machine_' . $date_type;
|
|
$date_format = 'd.m.Y - H:i';
|
|
$edit = array(
|
|
'date_type' => $date_type,
|
|
'machine_name' => $machine_name,
|
|
'date_format' => $date_format,
|
|
);
|
|
$this->drupalPost('admin/config/regional/date-time/types/add', $edit, t('Add date type'));
|
|
$this->assertEqual($this->getUrl(), url('admin/config/regional/date-time', array('absolute' => TRUE)), t('Correct page redirection.'));
|
|
$this->assertText(t('New date type added successfully.'), 'Date type added confirmation message appears.');
|
|
$this->assertText($date_type, 'Custom date type appears in the date type list.');
|
|
$this->assertText(t('delete'), 'Delete link for custom date type appears.');
|
|
|
|
// Delete custom date type.
|
|
$this->clickLink(t('delete'));
|
|
$this->drupalPost('admin/config/regional/date-time/types/' . $machine_name . '/delete', array(), t('Remove'));
|
|
$this->assertEqual($this->getUrl(), url('admin/config/regional/date-time', array('absolute' => TRUE)), t('Correct page redirection.'));
|
|
$this->assertText(t('Removed date type ' . $date_type), 'Custom date type removed.');
|
|
}
|
|
|
|
/**
|
|
* Test date format configuration.
|
|
*/
|
|
function testDateFormatConfiguration() {
|
|
// Confirm 'no custom date formats available' message appears.
|
|
$this->drupalGet('admin/config/regional/date-time/formats');
|
|
$this->assertText(t('No custom date formats available.'), 'No custom date formats message appears.');
|
|
|
|
// Add custom date format.
|
|
$this->clickLink(t('Add format'));
|
|
$edit = array(
|
|
'date_format' => 'Y',
|
|
);
|
|
$this->drupalPost('admin/config/regional/date-time/formats/add', $edit, t('Add format'));
|
|
$this->assertEqual($this->getUrl(), url('admin/config/regional/date-time/formats', array('absolute' => TRUE)), t('Correct page redirection.'));
|
|
$this->assertNoText(t('No custom date formats available.'), 'No custom date formats message does not appear.');
|
|
$this->assertText(t('Custom date format added.'), 'Custom date format added.');
|
|
|
|
// Ensure custom date format appears in date type configuration options.
|
|
$this->drupalGet('admin/config/regional/date-time');
|
|
$this->assertRaw('<option value="Y">', 'Custom date format appears in options.');
|
|
|
|
// Edit custom date format.
|
|
$this->drupalGet('admin/config/regional/date-time/formats');
|
|
$this->clickLink(t('edit'));
|
|
$edit = array(
|
|
'date_format' => 'Y m',
|
|
);
|
|
$this->drupalPost($this->getUrl(), $edit, t('Save format'));
|
|
$this->assertEqual($this->getUrl(), url('admin/config/regional/date-time/formats', array('absolute' => TRUE)), t('Correct page redirection.'));
|
|
$this->assertText(t('Custom date format updated.'), 'Custom date format successfully updated.');
|
|
|
|
// Delete custom date format.
|
|
$this->clickLink(t('delete'));
|
|
$this->drupalPost($this->getUrl(), array(), t('Remove'));
|
|
$this->assertEqual($this->getUrl(), url('admin/config/regional/date-time/formats', array('absolute' => TRUE)), t('Correct page redirection.'));
|
|
$this->assertText(t('Removed date format'), 'Custom date format removed successfully.');
|
|
}
|
|
|
|
/**
|
|
* Test if the date formats are stored properly.
|
|
*/
|
|
function testDateFormatStorage() {
|
|
$date_format = array(
|
|
'type' => 'short',
|
|
'format' => 'dmYHis',
|
|
'locked' => 0,
|
|
'is_new' => 1,
|
|
);
|
|
system_date_format_save($date_format);
|
|
|
|
$format = db_select('date_formats', 'df')
|
|
->fields('df', array('format'))
|
|
->condition('type', 'short')
|
|
->condition('format', 'dmYHis')
|
|
->execute()
|
|
->fetchField();
|
|
$this->verbose($format);
|
|
$this->assertEqual('dmYHis', $format, 'Unlocalized date format resides in general table.');
|
|
|
|
$format = db_select('date_format_locale', 'dfl')
|
|
->fields('dfl', array('format'))
|
|
->condition('type', 'short')
|
|
->condition('format', 'dmYHis')
|
|
->execute()
|
|
->fetchField();
|
|
$this->assertFalse($format, 'Unlocalized date format resides not in localized table.');
|
|
|
|
// Enable German language
|
|
$language = (object) array(
|
|
'langcode' => 'de',
|
|
'default' => TRUE,
|
|
);
|
|
language_save($language);
|
|
|
|
$date_format = array(
|
|
'type' => 'short',
|
|
'format' => 'YMDHis',
|
|
'locales' => array('de', 'tr'),
|
|
'locked' => 0,
|
|
'is_new' => 1,
|
|
);
|
|
system_date_format_save($date_format);
|
|
|
|
$format = db_select('date_format_locale', 'dfl')
|
|
->fields('dfl', array('format'))
|
|
->condition('type', 'short')
|
|
->condition('format', 'YMDHis')
|
|
->condition('language', 'de')
|
|
->execute()
|
|
->fetchField();
|
|
$this->assertEqual('YMDHis', $format, 'Localized date format resides in localized table.');
|
|
|
|
$format = db_select('date_formats', 'df')
|
|
->fields('df', array('format'))
|
|
->condition('type', 'short')
|
|
->condition('format', 'YMDHis')
|
|
->execute()
|
|
->fetchField();
|
|
$this->assertEqual('YMDHis', $format, 'Localized date format resides in general table too.');
|
|
|
|
$format = db_select('date_format_locale', 'dfl')
|
|
->fields('dfl', array('format'))
|
|
->condition('type', 'short')
|
|
->condition('format', 'YMDHis')
|
|
->condition('language', 'tr')
|
|
->execute()
|
|
->fetchColumn();
|
|
$this->assertFalse($format, 'Localized date format for disabled language is ignored.');
|
|
}
|
|
}
|
|
|
|
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() and checks the correct escaping of site name and slogan.',
|
|
'group' => 'System'
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Implement setUp().
|
|
*/
|
|
function setUp() {
|
|
parent::setUp(array('node'));
|
|
|
|
$this->drupalCreateContentType(array('type' => 'page', 'name' => 'Basic page'));
|
|
|
|
$this->content_user = $this->drupalCreateUser(array('create page content', 'access content', 'administer themes', 'administer site configuration'));
|
|
$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 = LANGUAGE_NOT_SPECIFIED;
|
|
$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 if the title of the site is XSS proof.
|
|
*/
|
|
function testTitleXSS() {
|
|
// Set some title with JavaScript and HTML chars to escape.
|
|
$title = '</title><script type="text/javascript">alert("Title XSS!");</script> & < > " \' ';
|
|
$title_filtered = check_plain($title);
|
|
|
|
$slogan = '<script type="text/javascript">alert("Slogan XSS!");</script>';
|
|
$slogan_filtered = filter_xss_admin($slogan);
|
|
|
|
// Activate needed appearance settings.
|
|
$edit = array(
|
|
'toggle_name' => TRUE,
|
|
'toggle_slogan' => TRUE,
|
|
'toggle_main_menu' => TRUE,
|
|
'toggle_secondary_menu' => TRUE,
|
|
);
|
|
$this->drupalPost('admin/appearance/settings', $edit, t('Save configuration'));
|
|
|
|
// Set title and slogan.
|
|
$edit = array(
|
|
'site_name' => $title,
|
|
'site_slogan' => $slogan,
|
|
);
|
|
$this->drupalPost('admin/config/system/site-information', $edit, t('Save configuration'));
|
|
|
|
// Load frontpage.
|
|
$this->drupalGet('');
|
|
|
|
// Test the title.
|
|
$this->assertNoRaw($title, 'Check for the unfiltered version of the title.');
|
|
// Adding </title> so we do not test the escaped version from drupal_set_title().
|
|
$this->assertRaw($title_filtered . '</title>', 'Check for the filtered version of the title.');
|
|
|
|
// Test the slogan.
|
|
$this->assertNoRaw($slogan, 'Check for the unfiltered version of the slogan.');
|
|
$this->assertRaw($slogan_filtered, 'Check for the filtered version of the slogan.');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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(array('node', '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;
|
|
|
|
// Configure 'node' as front page.
|
|
variable_set('site_frontpage', 'node');
|
|
// 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/config/system/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/config/system/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('block');
|
|
|
|
// Create and login user
|
|
$admin_user = $this->drupalCreateUser(array('administer blocks', 'access administration pages'));
|
|
$this->drupalLogin($admin_user);
|
|
}
|
|
|
|
/**
|
|
* Test displaying and hiding the powered-by and help blocks.
|
|
*/
|
|
function testSystemBlocks() {
|
|
// Set block title and some settings to confirm that the interface is available.
|
|
$this->drupalPost('admin/structure/block/manage/system/powered-by/configure', array('title' => $this->randomName(8)), 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['blocks[system_powered-by][region]'] = 'footer';
|
|
$edit['blocks[system_main][region]'] = 'content';
|
|
$this->drupalPost('admin/structure/block', $edit, t('Save blocks'));
|
|
$this->assertText(t('The block settings have been updated.'), t('Block successfully moved to footer region.'));
|
|
|
|
// Confirm that the block is being displayed.
|
|
$this->drupalGet('node');
|
|
$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['blocks[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 its default settings.
|
|
$edit = array();
|
|
$edit['blocks[system_powered-by][region]'] = 'footer';
|
|
$this->drupalPost('admin/structure/block', $edit, t('Save blocks'));
|
|
$this->drupalPost('admin/structure/block/manage/system/powered-by/configure', array('title' => ''), t('Save block'));
|
|
|
|
// Set the help block to the help region.
|
|
$edit = array();
|
|
$edit['blocks[system_help][region]'] = 'help';
|
|
$this->drupalPost('admin/structure/block', $edit, t('Save blocks'));
|
|
|
|
// Test displaying the help block with block caching enabled.
|
|
variable_set('block_cache', TRUE);
|
|
$this->drupalGet('admin/structure/block/add');
|
|
$this->assertRaw(t('Use this page to create a new custom block.'));
|
|
$this->drupalGet('admin/index');
|
|
$this->assertRaw(t('This page shows you all available administration tasks for each module.'));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test main content rendering fallback provided by system module.
|
|
*/
|
|
class SystemMainContentFallback extends DrupalWebTestCase {
|
|
protected $admin_user;
|
|
protected $web_user;
|
|
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'Main content rendering fallback',
|
|
'description' => ' Test system module main content rendering fallback.',
|
|
'group' => 'System',
|
|
);
|
|
}
|
|
|
|
function setUp() {
|
|
parent::setUp(array('block', 'system_test'));
|
|
|
|
// Create and login admin user.
|
|
$this->admin_user = $this->drupalCreateUser(array(
|
|
'access administration pages',
|
|
'administer site configuration',
|
|
'administer modules',
|
|
));
|
|
$this->drupalLogin($this->admin_user);
|
|
|
|
// Create a web user.
|
|
$this->web_user = $this->drupalCreateUser(array('access user profiles'));
|
|
}
|
|
|
|
/**
|
|
* Test availability of main content.
|
|
*/
|
|
function testMainContentFallback() {
|
|
$edit = array();
|
|
// Disable the block module.
|
|
$edit['modules[Core][block][enable]'] = FALSE;
|
|
$this->drupalPost('admin/modules', $edit, t('Save configuration'));
|
|
$this->assertText(t('The configuration options have been saved.'), t('Modules status has been updated.'));
|
|
module_list(TRUE);
|
|
$this->assertFalse(module_exists('block'), t('Block module disabled.'));
|
|
|
|
// At this point, no region is filled and fallback should be triggered.
|
|
$this->drupalGet('admin/config/system/site-information');
|
|
$this->assertField('site_name', t('Admin interface still available.'));
|
|
|
|
// Fallback should not trigger when another module is handling content.
|
|
$this->drupalGet('system-test/main-content-handling');
|
|
$this->assertRaw('id="system-test-content"', t('Content handled by another module'));
|
|
$this->assertText(t('Content to test main content fallback'), t('Main content still displayed.'));
|
|
|
|
// Fallback should trigger when another module
|
|
// indicates that it is not handling the content.
|
|
$this->drupalGet('system-test/main-content-fallback');
|
|
$this->assertText(t('Content to test main content fallback'), t('Main content fallback properly triggers.'));
|
|
|
|
// Fallback should not trigger when another module is handling content.
|
|
// Note that this test ensures that no duplicate
|
|
// content gets created by the fallback.
|
|
$this->drupalGet('system-test/main-content-duplication');
|
|
$this->assertNoText(t('Content to test main content fallback'), t('Main content not duplicated.'));
|
|
|
|
// Request a user* page and see if it is displayed.
|
|
$this->drupalLogin($this->web_user);
|
|
$this->drupalGet('user/' . $this->web_user->uid . '/edit');
|
|
$this->assertField('mail', t('User interface still available.'));
|
|
|
|
// Enable the block module again.
|
|
$this->drupalLogin($this->admin_user);
|
|
$edit = array();
|
|
$edit['modules[Core][block][enable]'] = 'block';
|
|
$this->drupalPost('admin/modules', $edit, t('Save configuration'));
|
|
$this->assertText(t('The configuration options have been saved.'), t('Modules status has been updated.'));
|
|
module_list(TRUE);
|
|
$this->assertTrue(module_exists('block'), t('Block module re-enabled.'));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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(array('node', 'block'));
|
|
|
|
$this->drupalCreateContentType(array('type' => 'page', 'name' => 'Basic page'));
|
|
|
|
$this->admin_user = $this->drupalCreateUser(array('access administration pages', 'view the administration theme', 'administer themes', 'bypass node access', 'administer blocks'));
|
|
$this->drupalLogin($this->admin_user);
|
|
$this->node = $this->drupalCreateNode();
|
|
}
|
|
|
|
/**
|
|
* Test the theme settings form.
|
|
*/
|
|
function testThemeSettings() {
|
|
// Specify a filesystem path to be used for the logo.
|
|
$file = current($this->drupalGetTestFiles('image'));
|
|
$file_relative = strtr($file->uri, array('public:/' => variable_get('file_public_path', conf_path() . '/files')));
|
|
$default_theme_path = 'core/themes/stark';
|
|
|
|
$supported_paths = array(
|
|
// Raw stream wrapper URI.
|
|
$file->uri => array(
|
|
'form' => file_uri_target($file->uri),
|
|
'src' => file_create_url($file->uri),
|
|
),
|
|
// Relative path within the public filesystem.
|
|
file_uri_target($file->uri) => array(
|
|
'form' => file_uri_target($file->uri),
|
|
'src' => file_create_url($file->uri),
|
|
),
|
|
// Relative path to a public file.
|
|
$file_relative => array(
|
|
'form' => $file_relative,
|
|
'src' => file_create_url($file->uri),
|
|
),
|
|
// Relative path to an arbitrary file.
|
|
'core/misc/druplicon.png' => array(
|
|
'form' => 'core/misc/druplicon.png',
|
|
'src' => $GLOBALS['base_url'] . '/' . 'core/misc/druplicon.png',
|
|
),
|
|
// Relative path to a file in a theme.
|
|
$default_theme_path . '/logo.png' => array(
|
|
'form' => $default_theme_path . '/logo.png',
|
|
'src' => $GLOBALS['base_url'] . '/' . $default_theme_path . '/logo.png',
|
|
),
|
|
);
|
|
foreach ($supported_paths as $input => $expected) {
|
|
$edit = array(
|
|
'default_logo' => FALSE,
|
|
'logo_path' => $input,
|
|
);
|
|
$this->drupalPost('admin/appearance/settings', $edit, t('Save configuration'));
|
|
$this->assertNoText('The custom logo path is invalid.');
|
|
$this->assertFieldByName('logo_path', $expected['form']);
|
|
|
|
// Verify logo path examples.
|
|
$elements = $this->xpath('//div[contains(@class, :item)]/div[@class=:description]/code', array(
|
|
':item' => 'form-item-logo-path',
|
|
':description' => 'description',
|
|
));
|
|
// Expected default values (if all else fails).
|
|
$implicit_public_file = 'logo.png';
|
|
$explicit_file = 'public://logo.png';
|
|
$local_file = $default_theme_path . '/logo.png';
|
|
// Adjust for fully qualified stream wrapper URI in public filesystem.
|
|
if (file_uri_scheme($input) == 'public') {
|
|
$implicit_public_file = file_uri_target($input);
|
|
$explicit_file = $input;
|
|
$local_file = strtr($input, array('public:/' => variable_get('file_public_path', conf_path() . '/files')));
|
|
}
|
|
// Adjust for fully qualified stream wrapper URI elsewhere.
|
|
elseif (file_uri_scheme($input) !== FALSE) {
|
|
$explicit_file = $input;
|
|
}
|
|
// Adjust for relative path within public filesystem.
|
|
elseif ($input == file_uri_target($file->uri)) {
|
|
$implicit_public_file = $input;
|
|
$explicit_file = 'public://' . $input;
|
|
$local_file = variable_get('file_public_path', conf_path() . '/files') . '/' . $input;
|
|
}
|
|
$this->assertEqual((string) $elements[0], $implicit_public_file);
|
|
$this->assertEqual((string) $elements[1], $explicit_file);
|
|
$this->assertEqual((string) $elements[2], $local_file);
|
|
|
|
// Verify the actual 'src' attribute of the logo being output.
|
|
$this->drupalGet('');
|
|
$elements = $this->xpath('//*[@id=:id]/img', array(':id' => 'logo'));
|
|
$this->assertEqual((string) $elements[0]['src'], $expected['src']);
|
|
}
|
|
|
|
$unsupported_paths = array(
|
|
// Stream wrapper URI to non-existing file.
|
|
'public://whatever.png',
|
|
'private://whatever.png',
|
|
'temporary://whatever.png',
|
|
// Bogus stream wrapper URIs.
|
|
'public:/whatever.png',
|
|
'://whatever.png',
|
|
':whatever.png',
|
|
'public://',
|
|
// Relative path within the public filesystem to non-existing file.
|
|
'whatever.png',
|
|
// Relative path to non-existing file in public filesystem.
|
|
variable_get('file_public_path', conf_path() . '/files') . '/whatever.png',
|
|
// Semi-absolute path to non-existing file in public filesystem.
|
|
'/' . variable_get('file_public_path', conf_path() . '/files') . '/whatever.png',
|
|
// Relative path to arbitrary non-existing file.
|
|
'core/misc/whatever.png',
|
|
// Semi-absolute path to arbitrary non-existing file.
|
|
'/core/misc/whatever.png',
|
|
// Absolute paths to any local file (even if it exists).
|
|
drupal_realpath($file->uri),
|
|
);
|
|
$this->drupalGet('admin/appearance/settings');
|
|
foreach ($unsupported_paths as $path) {
|
|
$edit = array(
|
|
'default_logo' => FALSE,
|
|
'logo_path' => $path,
|
|
);
|
|
$this->drupalPost(NULL, $edit, t('Save configuration'));
|
|
$this->assertText('The custom logo path is invalid.');
|
|
}
|
|
|
|
// Upload a file to use for the logo.
|
|
$edit = array(
|
|
'default_logo' => FALSE,
|
|
'logo_path' => '',
|
|
'files[logo_upload]' => drupal_realpath($file->uri),
|
|
);
|
|
$this->drupalPost('admin/appearance/settings', $edit, t('Save configuration'));
|
|
|
|
$fields = $this->xpath($this->constructFieldXpath('name', 'logo_path'));
|
|
$uploaded_filename = 'public://' . $fields[0]['value'];
|
|
|
|
$this->drupalGet('');
|
|
$elements = $this->xpath('//*[@id=:id]/img', array(':id' => 'logo'));
|
|
$this->assertEqual($elements[0]['src'], file_create_url($uploaded_filename));
|
|
}
|
|
|
|
/**
|
|
* Test the administration theme functionality.
|
|
*/
|
|
function testAdministrationTheme() {
|
|
theme_enable(array('stark'));
|
|
variable_set('theme_default', 'stark');
|
|
// Enable an administration theme and show it on the node admin pages.
|
|
$edit = array(
|
|
'admin_theme' => 'seven',
|
|
'node_admin_theme' => TRUE,
|
|
);
|
|
$this->drupalPost('admin/appearance', $edit, t('Save configuration'));
|
|
|
|
$this->drupalGet('admin/config');
|
|
$this->assertRaw('core/themes/seven', t('Administration theme used on an administration page.'));
|
|
|
|
$this->drupalGet('node/' . $this->node->nid);
|
|
$this->assertRaw('core/themes/stark', t('Site default theme used on node page.'));
|
|
|
|
$this->drupalGet('node/add');
|
|
$this->assertRaw('core/themes/seven', t('Administration theme used on the add content page.'));
|
|
|
|
$this->drupalGet('node/' . $this->node->nid . '/edit');
|
|
$this->assertRaw('core/themes/seven', 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/config');
|
|
$this->assertRaw('core/themes/seven', t('Administration theme used on an administration page.'));
|
|
|
|
$this->drupalGet('node/add');
|
|
$this->assertRaw('core/themes/stark', t('Site default theme used on the add content page.'));
|
|
|
|
// Reset to the default theme settings.
|
|
variable_set('theme_default', 'bartik');
|
|
$edit = array(
|
|
'admin_theme' => '0',
|
|
'node_admin_theme' => FALSE,
|
|
);
|
|
$this->drupalPost('admin/appearance', $edit, t('Save configuration'));
|
|
|
|
$this->drupalGet('admin');
|
|
$this->assertRaw('core/themes/bartik', t('Site default theme used on administration page.'));
|
|
|
|
$this->drupalGet('node/add');
|
|
$this->assertRaw('core/themes/bartik', t('Site default theme used on the add content page.'));
|
|
}
|
|
|
|
/**
|
|
* Test switching the default theme.
|
|
*/
|
|
function testSwitchDefaultTheme() {
|
|
// Enable Bartik and set it as the default theme.
|
|
theme_enable(array('bartik'));
|
|
$this->drupalGet('admin/appearance');
|
|
$this->clickLink(t('Set default'));
|
|
$this->assertEqual(variable_get('theme_default', ''), 'bartik');
|
|
|
|
// Test the default theme on the secondary links (blocks admin page).
|
|
$this->drupalGet('admin/structure/block');
|
|
$this->assertText('Bartik(' . t('active tab') . ')', t('Default local task on blocks admin page is the default theme.'));
|
|
// Switch back to Stark and test again to test that the menu cache is cleared.
|
|
$this->drupalGet('admin/appearance');
|
|
$this->clickLink(t('Set default'), 0);
|
|
$this->drupalGet('admin/structure/block');
|
|
$this->assertText('Stark(' . t('active tab') . ')', t('Default local task on blocks admin page has changed.'));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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, $language_interface;
|
|
|
|
$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 .= '[date:short]'; // Short date format of REQUEST_TIME
|
|
$source .= '[user:name]'; // No user passed in, should be untouched
|
|
$source .= '[bogus:token]'; // Non-existent token
|
|
|
|
$target = check_plain($node->title);
|
|
$target .= check_plain($account->name);
|
|
$target .= format_interval(REQUEST_TIME - $node->created, 2, $language_interface->langcode);
|
|
$target .= check_plain($user->name);
|
|
$target .= format_date(REQUEST_TIME, 'short', '', NULL, $language_interface->langcode);
|
|
|
|
// Test that the clear parameter cleans out non-existent tokens.
|
|
$result = token_replace($source, array('node' => $node), array('language' => $language_interface, 'clear' => TRUE));
|
|
$result = $this->assertEqual($target, $result, 'Valid tokens replaced while invalid tokens cleared out.');
|
|
|
|
// Test without using the clear parameter (non-existent token untouched).
|
|
$target .= '[user:name]';
|
|
$target .= '[bogus:token]';
|
|
$result = token_replace($source, array('node' => $node), array('language' => $language_interface));
|
|
$this->assertEqual($target, $result, 'Valid tokens replaced while invalid tokens ignored.');
|
|
|
|
// 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].
|
|
$raw_tokens = array('title' => '[node:title]');
|
|
$generated = token_generate('node', $raw_tokens, array('node' => $node));
|
|
$this->assertEqual($generated['[node:title]'], check_plain($node->title), t('Token sanitized.'));
|
|
|
|
$generated = token_generate('node', $raw_tokens, array('node' => $node), array('sanitize' => FALSE));
|
|
$this->assertEqual($generated['[node:title]'], $node->title, t('Unsanitized token generated properly.'));
|
|
|
|
// Test token replacement when the string contains no tokens.
|
|
$this->assertEqual(token_replace('No tokens here.'), 'No tokens here.');
|
|
}
|
|
|
|
/**
|
|
* Test whether token-replacement works in various contexts.
|
|
*/
|
|
function testSystemTokenRecognition() {
|
|
global $language_interface;
|
|
|
|
// Generate prefixes and suffixes for the token context.
|
|
$tests = array(
|
|
array('prefix' => 'this is the ', 'suffix' => ' site'),
|
|
array('prefix' => 'this is the', 'suffix' => 'site'),
|
|
array('prefix' => '[', 'suffix' => ']'),
|
|
array('prefix' => '', 'suffix' => ']]]'),
|
|
array('prefix' => '[[[', 'suffix' => ''),
|
|
array('prefix' => ':[:', 'suffix' => '--]'),
|
|
array('prefix' => '-[-', 'suffix' => ':]:'),
|
|
array('prefix' => '[:', 'suffix' => ']'),
|
|
array('prefix' => '[site:', 'suffix' => ':name]'),
|
|
array('prefix' => '[site:', 'suffix' => ']'),
|
|
);
|
|
|
|
// Check if the token is recognized in each of the contexts.
|
|
foreach ($tests as $test) {
|
|
$input = $test['prefix'] . '[site:name]' . $test['suffix'];
|
|
$expected = $test['prefix'] . 'Drupal' . $test['suffix'];
|
|
$output = token_replace($input, array(), array('language' => $language_interface));
|
|
$this->assertTrue($output == $expected, t('Token recognized in string %string', array('%string' => $input)));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the generation of all system site information tokens.
|
|
*/
|
|
function testSystemSiteTokenReplacement() {
|
|
global $language_interface;
|
|
$url_options = array(
|
|
'absolute' => TRUE,
|
|
'language' => $language_interface,
|
|
);
|
|
|
|
// Set a few site variables.
|
|
variable_set('site_name', '<strong>Drupal<strong>');
|
|
variable_set('site_slogan', '<blink>Slogan</blink>');
|
|
|
|
// Generate and test sanitized tokens.
|
|
$tests = array();
|
|
$tests['[site:name]'] = check_plain(variable_get('site_name', 'Drupal'));
|
|
$tests['[site:slogan]'] = check_plain(variable_get('site_slogan', ''));
|
|
$tests['[site:mail]'] = 'simpletest@example.com';
|
|
$tests['[site:url]'] = url('<front>', $url_options);
|
|
$tests['[site:url-brief]'] = preg_replace(array('!^https?://!', '!/$!'), '', url('<front>', $url_options));
|
|
$tests['[site:login-url]'] = url('user', $url_options);
|
|
|
|
// Test to make sure that we generated something for each token.
|
|
$this->assertFalse(in_array(0, array_map('strlen', $tests)), t('No empty tokens generated.'));
|
|
|
|
foreach ($tests as $input => $expected) {
|
|
$output = token_replace($input, array(), array('language' => $language_interface));
|
|
$this->assertEqual($output, $expected, t('Sanitized system site information token %token replaced.', array('%token' => $input)));
|
|
}
|
|
|
|
// Generate and test unsanitized tokens.
|
|
$tests['[site:name]'] = variable_get('site_name', 'Drupal');
|
|
$tests['[site:slogan]'] = variable_get('site_slogan', '');
|
|
|
|
foreach ($tests as $input => $expected) {
|
|
$output = token_replace($input, array(), array('language' => $language_interface, 'sanitize' => FALSE));
|
|
$this->assertEqual($output, $expected, t('Unsanitized system site information token %token replaced.', array('%token' => $input)));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the generation of all system date tokens.
|
|
*/
|
|
function testSystemDateTokenReplacement() {
|
|
global $language_interface;
|
|
|
|
// Set time to one hour before request.
|
|
$date = REQUEST_TIME - 3600;
|
|
|
|
// Generate and test tokens.
|
|
$tests = array();
|
|
$tests['[date:short]'] = format_date($date, 'short', '', NULL, $language_interface->langcode);
|
|
$tests['[date:medium]'] = format_date($date, 'medium', '', NULL, $language_interface->langcode);
|
|
$tests['[date:long]'] = format_date($date, 'long', '', NULL, $language_interface->langcode);
|
|
$tests['[date:custom:m/j/Y]'] = format_date($date, 'custom', 'm/j/Y', NULL, $language_interface->langcode);
|
|
$tests['[date:since]'] = format_interval((REQUEST_TIME - $date), 2, $language_interface->langcode);
|
|
$tests['[date:raw]'] = filter_xss($date);
|
|
|
|
// Test to make sure that we generated something for each token.
|
|
$this->assertFalse(in_array(0, array_map('strlen', $tests)), t('No empty tokens generated.'));
|
|
|
|
foreach ($tests as $input => $expected) {
|
|
$output = token_replace($input, array('date' => $date), array('language' => $language_interface));
|
|
$this->assertEqual($output, $expected, t('Date token %token replaced.', array('%token' => $input)));
|
|
}
|
|
}
|
|
}
|
|
|
|
class InfoFileParserTestCase extends DrupalUnitTestCase {
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'Info file format parser',
|
|
'description' => 'Tests proper parsing of a .info file formatted string.',
|
|
'group' => 'System',
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Test drupal_parse_info_format().
|
|
*/
|
|
function testDrupalParseInfoFormat() {
|
|
$config = '
|
|
simple = Value
|
|
quoted = " Value"
|
|
multiline = "Value
|
|
Value"
|
|
array[] = Value1
|
|
array[] = Value2
|
|
array_assoc[a] = Value1
|
|
array_assoc[b] = Value2
|
|
array_deep[][][] = Value
|
|
array_deep_assoc[a][b][c] = Value
|
|
array_space[a b] = Value';
|
|
|
|
$expected = array(
|
|
'simple' => 'Value',
|
|
'quoted' => ' Value',
|
|
'multiline' => "Value\n Value",
|
|
'array' => array(
|
|
0 => 'Value1',
|
|
1 => 'Value2',
|
|
),
|
|
'array_assoc' => array(
|
|
'a' => 'Value1',
|
|
'b' => 'Value2',
|
|
),
|
|
'array_deep' => array(
|
|
0 => array(
|
|
0 => array(
|
|
0 => 'Value',
|
|
),
|
|
),
|
|
),
|
|
'array_deep_assoc' => array(
|
|
'a' => array(
|
|
'b' => array(
|
|
'c' => 'Value',
|
|
),
|
|
),
|
|
),
|
|
'array_space' => array(
|
|
'a b' => 'Value',
|
|
),
|
|
);
|
|
|
|
$parsed = drupal_parse_info_format($config);
|
|
|
|
$this->assertEqual($parsed['simple'], $expected['simple'], t('Set a simple value.'));
|
|
$this->assertEqual($parsed['quoted'], $expected['quoted'], t('Set a simple value in quotes.'));
|
|
$this->assertEqual($parsed['multiline'], $expected['multiline'], t('Set a multiline value.'));
|
|
$this->assertEqual($parsed['array'], $expected['array'], t('Set a simple array.'));
|
|
$this->assertEqual($parsed['array_assoc'], $expected['array_assoc'], t('Set an associative array.'));
|
|
$this->assertEqual($parsed['array_deep'], $expected['array_deep'], t('Set a nested array.'));
|
|
$this->assertEqual($parsed['array_deep_assoc'], $expected['array_deep_assoc'], t('Set a nested associative array.'));
|
|
$this->assertEqual($parsed['array_space'], $expected['array_space'], t('Set an array with a whitespace in the key.'));
|
|
$this->assertEqual($parsed, $expected, t('Entire parsed .info string and expected array are identical.'));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the effectiveness of hook_system_info_alter().
|
|
*/
|
|
class SystemInfoAlterTestCase extends DrupalWebTestCase {
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'System info alter',
|
|
'description' => 'Tests the effectiveness of hook_system_info_alter().',
|
|
'group' => 'System',
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Tests that {system}.info is rebuilt after a module that implements
|
|
* hook_system_info_alter() is enabled. Also tests if core *_list() functions
|
|
* return freshly altered info.
|
|
*/
|
|
function testSystemInfoAlter() {
|
|
// Enable our test module. Flush all caches, which we assert is the only
|
|
// thing necessary to use the rebuilt {system}.info.
|
|
module_enable(array('module_test'), FALSE);
|
|
drupal_flush_all_caches();
|
|
$this->assertTrue(module_exists('module_test'), t('Test module is enabled.'));
|
|
|
|
$info = $this->getSystemInfo('seven', 'theme');
|
|
$this->assertTrue(isset($info['regions']['test_region']), t('Altered theme info was added to {system}.info.'));
|
|
$seven_regions = system_region_list('seven');
|
|
$this->assertTrue(isset($seven_regions['test_region']), t('Altered theme info was returned by system_region_list().'));
|
|
$system_list_themes = system_list('theme');
|
|
$info = $system_list_themes['seven']->info;
|
|
$this->assertTrue(isset($info['regions']['test_region']), t('Altered theme info was returned by system_list().'));
|
|
$list_themes = list_themes();
|
|
$this->assertTrue(isset($list_themes['seven']->info['regions']['test_region']), t('Altered theme info was returned by list_themes().'));
|
|
|
|
// Disable the module and verify that {system}.info is rebuilt without it.
|
|
module_disable(array('module_test'), FALSE);
|
|
drupal_flush_all_caches();
|
|
$this->assertFalse(module_exists('module_test'), t('Test module is disabled.'));
|
|
|
|
$info = $this->getSystemInfo('seven', 'theme');
|
|
$this->assertFalse(isset($info['regions']['test_region']), t('Altered theme info was removed from {system}.info.'));
|
|
$seven_regions = system_region_list('seven');
|
|
$this->assertFalse(isset($seven_regions['test_region']), t('Altered theme info was not returned by system_region_list().'));
|
|
$system_list_themes = system_list('theme');
|
|
$info = $system_list_themes['seven']->info;
|
|
$this->assertFalse(isset($info['regions']['test_region']), t('Altered theme info was not returned by system_list().'));
|
|
$list_themes = list_themes();
|
|
$this->assertFalse(isset($list_themes['seven']->info['regions']['test_region']), t('Altered theme info was not returned by list_themes().'));
|
|
}
|
|
|
|
/**
|
|
* Returns the info array as it is stored in {system}.
|
|
*
|
|
* @param $name
|
|
* The name of the record in {system}.
|
|
* @param $type
|
|
* The type of record in {system}.
|
|
*
|
|
* @return
|
|
* Array of info, or FALSE if the record is not found.
|
|
*/
|
|
function getSystemInfo($name, $type) {
|
|
$raw_info = db_query("SELECT info FROM {system} WHERE name = :name AND type = :type", array(':name' => $name, ':type' => $type))->fetchField();
|
|
return $raw_info ? unserialize($raw_info) : FALSE;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests for the update system functionality.
|
|
*/
|
|
class UpdateScriptFunctionalTest extends DrupalWebTestCase {
|
|
private $update_url;
|
|
private $update_user;
|
|
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'Update functionality',
|
|
'description' => 'Tests the update script access and functionality.',
|
|
'group' => 'System',
|
|
);
|
|
}
|
|
|
|
function setUp() {
|
|
parent::setUp(array('update_script_test', 'dblog'));
|
|
$this->update_url = $GLOBALS['base_url'] . '/core/update.php';
|
|
$this->update_user = $this->drupalCreateUser(array('administer software updates'));
|
|
}
|
|
|
|
/**
|
|
* Tests access to the update script.
|
|
*/
|
|
function testUpdateAccess() {
|
|
// Try accessing update.php without the proper permission.
|
|
$regular_user = $this->drupalCreateUser();
|
|
$this->drupalLogin($regular_user);
|
|
$this->drupalGet($this->update_url, array('external' => TRUE));
|
|
$this->assertResponse(403);
|
|
|
|
// Try accessing update.php as an anonymous user.
|
|
$this->drupalLogout();
|
|
$this->drupalGet($this->update_url, array('external' => TRUE));
|
|
$this->assertResponse(403);
|
|
|
|
// Access the update page with the proper permission.
|
|
$this->drupalLogin($this->update_user);
|
|
$this->drupalGet($this->update_url, array('external' => TRUE));
|
|
$this->assertResponse(200);
|
|
|
|
// Access the update page as user 1.
|
|
$user1 = user_load(1);
|
|
$user1->pass_raw = user_password();
|
|
require_once DRUPAL_ROOT . '/' . variable_get('password_inc', 'core/includes/password.inc');
|
|
$user1->pass = user_hash_password(trim($user1->pass_raw));
|
|
db_query("UPDATE {users} SET pass = :pass WHERE uid = :uid", array(':pass' => $user1->pass, ':uid' => $user1->uid));
|
|
$this->drupalLogin($user1);
|
|
$this->drupalGet($this->update_url, array('external' => TRUE));
|
|
$this->assertResponse(200);
|
|
}
|
|
|
|
/**
|
|
* Tests that requirements warnings and errors are correctly displayed.
|
|
*/
|
|
function testRequirements() {
|
|
$this->drupalLogin($this->update_user);
|
|
|
|
// If there are no requirements warnings or errors, we expect to be able to
|
|
// go through the update process uninterrupted.
|
|
$this->drupalGet($this->update_url, array('external' => TRUE));
|
|
$this->drupalPost(NULL, array(), t('Continue'));
|
|
$this->assertText(t('No pending updates.'), t('End of update process was reached.'));
|
|
// Confirm that all caches were cleared.
|
|
$this->assertText(t('hook_flush_caches() invoked for update_script_test.module.'), 'Caches were cleared when there were no requirements warnings or errors.');
|
|
|
|
// If there is a requirements warning, we expect it to be initially
|
|
// displayed, but clicking the link to proceed should allow us to go
|
|
// through the rest of the update process uninterrupted.
|
|
|
|
// First, run this test with pending updates to make sure they can be run
|
|
// successfully.
|
|
variable_set('update_script_test_requirement_type', REQUIREMENT_WARNING);
|
|
drupal_set_installed_schema_version('update_script_test', drupal_get_installed_schema_version('update_script_test') - 1);
|
|
$this->drupalGet($this->update_url, array('external' => TRUE));
|
|
$this->assertText('This is a requirements warning provided by the update_script_test module.');
|
|
$this->clickLink('try again');
|
|
$this->assertNoText('This is a requirements warning provided by the update_script_test module.');
|
|
$this->drupalPost(NULL, array(), t('Continue'));
|
|
$this->drupalPost(NULL, array(), t('Apply pending updates'));
|
|
$this->assertText(t('The update_script_test_update_8000() update was executed successfully.'), t('End of update process was reached.'));
|
|
// Confirm that all caches were cleared.
|
|
$this->assertText(t('hook_flush_caches() invoked for update_script_test.module.'), 'Caches were cleared after resolving a requirements warning and applying updates.');
|
|
|
|
// Now try again without pending updates to make sure that works too.
|
|
$this->drupalGet($this->update_url, array('external' => TRUE));
|
|
$this->assertText('This is a requirements warning provided by the update_script_test module.');
|
|
$this->clickLink('try again');
|
|
$this->assertNoText('This is a requirements warning provided by the update_script_test module.');
|
|
$this->drupalPost(NULL, array(), t('Continue'));
|
|
$this->assertText(t('No pending updates.'), t('End of update process was reached.'));
|
|
// Confirm that all caches were cleared.
|
|
$this->assertText(t('hook_flush_caches() invoked for update_script_test.module.'), 'Caches were cleared after applying updates and re-running the script.');
|
|
|
|
// If there is a requirements error, it should be displayed even after
|
|
// clicking the link to proceed (since the problem that triggered the error
|
|
// has not been fixed).
|
|
variable_set('update_script_test_requirement_type', REQUIREMENT_ERROR);
|
|
$this->drupalGet($this->update_url, array('external' => TRUE));
|
|
$this->assertText('This is a requirements error provided by the update_script_test module.');
|
|
$this->clickLink('try again');
|
|
$this->assertText('This is a requirements error provided by the update_script_test module.');
|
|
}
|
|
|
|
/**
|
|
* Tests the effect of using the update script on the theme system.
|
|
*/
|
|
function testThemeSystem() {
|
|
// Since visiting update.php triggers a rebuild of the theme system from an
|
|
// unusual maintenance mode environment, we check that this rebuild did not
|
|
// put any incorrect information about the themes into the database.
|
|
$original_theme_data = db_query("SELECT * FROM {system} WHERE type = 'theme' ORDER BY name")->fetchAll();
|
|
$this->drupalLogin($this->update_user);
|
|
$this->drupalGet($this->update_url, array('external' => TRUE));
|
|
$final_theme_data = db_query("SELECT * FROM {system} WHERE type = 'theme' ORDER BY name")->fetchAll();
|
|
$this->assertEqual($original_theme_data, $final_theme_data, t('Visiting update.php does not alter the information about themes stored in the database.'));
|
|
}
|
|
|
|
/**
|
|
* Tests update.php when there are no updates to apply.
|
|
*/
|
|
function testNoUpdateFunctionality() {
|
|
// Click through update.php with 'administer software updates' permission.
|
|
$this->drupalLogin($this->update_user);
|
|
$this->drupalPost($this->update_url, array(), t('Continue'), array('external' => TRUE));
|
|
$this->assertText(t('No pending updates.'));
|
|
$this->assertNoLink('Administration pages');
|
|
$this->clickLink('Front page');
|
|
$this->assertResponse(200);
|
|
|
|
// Click through update.php with 'access administration pages' permission.
|
|
$admin_user = $this->drupalCreateUser(array('administer software updates', 'access administration pages'));
|
|
$this->drupalLogin($admin_user);
|
|
$this->drupalPost($this->update_url, array(), t('Continue'), array('external' => TRUE));
|
|
$this->assertText(t('No pending updates.'));
|
|
$this->clickLink('Administration pages');
|
|
$this->assertResponse(200);
|
|
}
|
|
|
|
/**
|
|
* Tests update.php after performing a successful update.
|
|
*/
|
|
function testSuccessfulUpdateFunctionality() {
|
|
drupal_set_installed_schema_version('update_script_test', drupal_get_installed_schema_version('update_script_test') - 1);
|
|
// Click through update.php with 'administer software updates' permission.
|
|
$this->drupalLogin($this->update_user);
|
|
$this->drupalPost($this->update_url, array(), t('Continue'), array('external' => TRUE));
|
|
$this->drupalPost(NULL, array(), t('Apply pending updates'));
|
|
$this->assertText('Updates were attempted.');
|
|
$this->assertLink('site');
|
|
$this->assertNoLink('Administration pages');
|
|
$this->assertNoLink('logged');
|
|
$this->clickLink('Front page');
|
|
$this->assertResponse(200);
|
|
|
|
drupal_set_installed_schema_version('update_script_test', drupal_get_installed_schema_version('update_script_test') - 1);
|
|
// Click through update.php with 'access administration pages' and
|
|
// 'access site reports' permissions.
|
|
$admin_user = $this->drupalCreateUser(array('administer software updates', 'access administration pages', 'access site reports'));
|
|
$this->drupalLogin($admin_user);
|
|
$this->drupalPost($this->update_url, array(), t('Continue'), array('external' => TRUE));
|
|
$this->drupalPost(NULL, array(), t('Apply pending updates'));
|
|
$this->assertText('Updates were attempted.');
|
|
$this->assertLink('logged');
|
|
$this->clickLink('Administration pages');
|
|
$this->assertResponse(200);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Functional tests for the flood control mechanism.
|
|
*/
|
|
class FloodFunctionalTest extends DrupalWebTestCase {
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'Flood control mechanism',
|
|
'description' => 'Functional tests for the flood control mechanism.',
|
|
'group' => 'System',
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Test flood control mechanism clean-up.
|
|
*/
|
|
function testCleanUp() {
|
|
$threshold = 1;
|
|
$window_expired = -1;
|
|
$name = 'flood_test_cleanup';
|
|
|
|
// Register expired event.
|
|
flood_register_event($name, $window_expired);
|
|
// Verify event is not allowed.
|
|
$this->assertFalse(flood_is_allowed($name, $threshold));
|
|
// Run cron and verify event is now allowed.
|
|
$this->cronRun();
|
|
$this->assertTrue(flood_is_allowed($name, $threshold));
|
|
|
|
// Register unexpired event.
|
|
flood_register_event($name);
|
|
// Verify event is not allowed.
|
|
$this->assertFalse(flood_is_allowed($name, $threshold));
|
|
// Run cron and verify event is still not allowed.
|
|
$this->cronRun();
|
|
$this->assertFalse(flood_is_allowed($name, $threshold));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test HTTP file downloading capability.
|
|
*/
|
|
class RetrieveFileTestCase extends DrupalWebTestCase {
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'HTTP file retrieval',
|
|
'description' => 'Checks HTTP file fetching and error handling.',
|
|
'group' => 'System',
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Invokes system_retrieve_file() in several scenarios.
|
|
*/
|
|
function testFileRetrieving() {
|
|
// Test 404 handling by trying to fetch a randomly named file.
|
|
drupal_mkdir($sourcedir = 'public://' . $this->randomName());
|
|
$filename = 'Файл для тестирования ' . $this->randomName();
|
|
$url = file_create_url($sourcedir . '/' . $filename);
|
|
$retrieved_file = system_retrieve_file($url);
|
|
$this->assertFalse($retrieved_file, t('Non-existent file not fetched.'));
|
|
|
|
// Actually create that file, download it via HTTP and test the returned path.
|
|
file_put_contents($sourcedir . '/' . $filename, 'testing');
|
|
$retrieved_file = system_retrieve_file($url);
|
|
|
|
// URLs could not contains characters outside the ASCII set so $filename
|
|
// has to be encoded.
|
|
$encoded_filename = rawurlencode($filename);
|
|
|
|
$this->assertEqual($retrieved_file, 'public://' . $encoded_filename, t('Sane path for downloaded file returned (public:// scheme).'));
|
|
$this->assertTrue(is_file($retrieved_file), t('Downloaded file does exist (public:// scheme).'));
|
|
$this->assertEqual(filesize($retrieved_file), 7, t('File size of downloaded file is correct (public:// scheme).'));
|
|
file_unmanaged_delete($retrieved_file);
|
|
|
|
// Test downloading file to a different location.
|
|
drupal_mkdir($targetdir = 'temporary://' . $this->randomName());
|
|
$retrieved_file = system_retrieve_file($url, $targetdir);
|
|
$this->assertEqual($retrieved_file, "$targetdir/$encoded_filename", t('Sane path for downloaded file returned (temporary:// scheme).'));
|
|
$this->assertTrue(is_file($retrieved_file), t('Downloaded file does exist (temporary:// scheme).'));
|
|
$this->assertEqual(filesize($retrieved_file), 7, t('File size of downloaded file is correct (temporary:// scheme).'));
|
|
file_unmanaged_delete($retrieved_file);
|
|
|
|
file_unmanaged_delete_recursive($sourcedir);
|
|
file_unmanaged_delete_recursive($targetdir);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Functional tests shutdown functions.
|
|
*/
|
|
class ShutdownFunctionsTest extends DrupalWebTestCase {
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'Shutdown functions',
|
|
'description' => 'Functional tests for shutdown functions',
|
|
'group' => 'System',
|
|
);
|
|
}
|
|
|
|
function setUp() {
|
|
parent::setUp('system_test');
|
|
}
|
|
|
|
/**
|
|
* Test shutdown functions.
|
|
*/
|
|
function testShutdownFunctions() {
|
|
$arg1 = $this->randomName();
|
|
$arg2 = $this->randomName();
|
|
$this->drupalGet('system-test/shutdown-functions/' . $arg1 . '/' . $arg2);
|
|
$this->assertText(t('First shutdown function, arg1 : @arg1, arg2: @arg2', array('@arg1' => $arg1, '@arg2' => $arg2)));
|
|
$this->assertText(t('Second shutdown function, arg1 : @arg1, arg2: @arg2', array('@arg1' => $arg1, '@arg2' => $arg2)));
|
|
|
|
// Make sure exceptions displayed through _drupal_render_exception_safe()
|
|
// are correctly escaped.
|
|
$this->assertRaw('Drupal is &lt;blink&gt;awesome&lt;/blink&gt;.');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests administrative overview pages.
|
|
*/
|
|
class SystemAdminTestCase extends DrupalWebTestCase {
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'Administrative pages',
|
|
'description' => 'Tests output on administrative pages and compact mode functionality.',
|
|
'group' => 'System',
|
|
);
|
|
}
|
|
|
|
function setUp() {
|
|
// testAdminPages() requires Locale module.
|
|
parent::setUp(array('locale'));
|
|
|
|
// Create an administrator with all permissions, as well as a regular user
|
|
// who can only access administration pages and perform some Locale module
|
|
// administrative tasks, but not all of them.
|
|
$this->admin_user = $this->drupalCreateUser(array_keys(module_invoke_all('permission')));
|
|
$this->web_user = $this->drupalCreateUser(array(
|
|
'access administration pages',
|
|
'translate interface',
|
|
));
|
|
$this->drupalLogin($this->admin_user);
|
|
}
|
|
|
|
/**
|
|
* Tests output on administrative listing pages.
|
|
*/
|
|
function testAdminPages() {
|
|
// Go to Administration.
|
|
$this->drupalGet('admin');
|
|
|
|
// Verify that all visible, top-level administration links are listed on
|
|
// the main administration page.
|
|
foreach (menu_get_router() as $path => $item) {
|
|
if (strpos($path, 'admin/') === 0 && ($item['type'] & MENU_VISIBLE_IN_TREE) && $item['_number_parts'] == 2) {
|
|
$this->assertLink($item['title']);
|
|
$this->assertLinkByHref($path);
|
|
$this->assertText($item['description']);
|
|
}
|
|
}
|
|
|
|
// For each administrative listing page on which the Locale module appears,
|
|
// verify that there are links to the module's primary configuration pages,
|
|
// but no links to its individual sub-configuration pages. Also verify that
|
|
// a user with access to only some Locale module administration pages only
|
|
// sees links to the pages they have access to.
|
|
$admin_list_pages = array(
|
|
'admin/index',
|
|
'admin/config',
|
|
'admin/config/regional',
|
|
);
|
|
|
|
foreach ($admin_list_pages as $page) {
|
|
// For the administrator, verify that there are links to Locale's primary
|
|
// configuration pages, but no links to individual sub-configuration
|
|
// pages.
|
|
$this->drupalLogin($this->admin_user);
|
|
$this->drupalGet($page);
|
|
$this->assertLinkByHref('admin/config');
|
|
$this->assertLinkByHref('admin/config/regional/settings');
|
|
$this->assertLinkByHref('admin/config/regional/date-time');
|
|
$this->assertLinkByHref('admin/config/regional/language');
|
|
$this->assertNoLinkByHref('admin/config/regional/language/detection/session');
|
|
$this->assertNoLinkByHref('admin/config/regional/language/detection/url');
|
|
$this->assertLinkByHref('admin/config/regional/translate');
|
|
// On admin/index only, the administrator should also see a "Configure
|
|
// permissions" link for the Locale module.
|
|
if ($page == 'admin/index') {
|
|
$this->assertLinkByHref("admin/people/permissions#module-locale");
|
|
}
|
|
|
|
// For a less privileged user, verify that there are no links to Locale's
|
|
// primary configuration pages, but a link to the translate page exists.
|
|
$this->drupalLogin($this->web_user);
|
|
$this->drupalGet($page);
|
|
$this->assertLinkByHref('admin/config');
|
|
$this->assertNoLinkByHref('admin/config/regional/settings');
|
|
$this->assertNoLinkByHref('admin/config/regional/date-time');
|
|
$this->assertNoLinkByHref('admin/config/regional/language');
|
|
$this->assertNoLinkByHref('admin/config/regional/language/detection/session');
|
|
$this->assertNoLinkByHref('admin/config/regional/language/detection/url');
|
|
$this->assertLinkByHref('admin/config/regional/translate');
|
|
// This user cannot configure permissions, so even on admin/index should
|
|
// not see a "Configure permissions" link for the Locale module.
|
|
if ($page == 'admin/index') {
|
|
$this->assertNoLinkByHref("admin/people/permissions#module-locale");
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test compact mode.
|
|
*/
|
|
function testCompactMode() {
|
|
$this->drupalGet('admin/compact/on');
|
|
$this->assertTrue($this->cookies['Drupal.visitor.admin_compact_mode']['value'], t('Compact mode turns on.'));
|
|
$this->drupalGet('admin/compact/on');
|
|
$this->assertTrue($this->cookies['Drupal.visitor.admin_compact_mode']['value'], t('Compact mode remains on after a repeat call.'));
|
|
$this->drupalGet('');
|
|
$this->assertTrue($this->cookies['Drupal.visitor.admin_compact_mode']['value'], t('Compact mode persists on new requests.'));
|
|
|
|
$this->drupalGet('admin/compact/off');
|
|
$this->assertEqual($this->cookies['Drupal.visitor.admin_compact_mode']['value'], 'deleted', t('Compact mode turns off.'));
|
|
$this->drupalGet('admin/compact/off');
|
|
$this->assertEqual($this->cookies['Drupal.visitor.admin_compact_mode']['value'], 'deleted', t('Compact mode remains off after a repeat call.'));
|
|
$this->drupalGet('');
|
|
$this->assertTrue($this->cookies['Drupal.visitor.admin_compact_mode']['value'], t('Compact mode persists on new requests.'));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Unit tests for the graph handling features.
|
|
*
|
|
* @see Drupal\Component\Graph\Graph
|
|
*/
|
|
class GraphUnitTest extends DrupalUnitTestCase {
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'Directed acyclic graph manipulation',
|
|
'description' => 'Depth first search and sort unit tests.',
|
|
'group' => 'System',
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Test depth-first-search features.
|
|
*/
|
|
function testDepthFirstSearch() {
|
|
// The sample graph used is:
|
|
// 1 --> 2 --> 3 5 ---> 6
|
|
// | ^ ^
|
|
// | | |
|
|
// | | |
|
|
// +---> 4 <-- 7 8 ---> 9
|
|
$graph = $this->normalizeGraph(array(
|
|
1 => array(2),
|
|
2 => array(3, 4),
|
|
3 => array(),
|
|
4 => array(3),
|
|
5 => array(6),
|
|
7 => array(4, 5),
|
|
8 => array(9),
|
|
9 => array(),
|
|
));
|
|
$graph_object = new Graph($graph);
|
|
$graph = $graph_object->searchAndSort();
|
|
|
|
$expected_paths = array(
|
|
1 => array(2, 3, 4),
|
|
2 => array(3, 4),
|
|
3 => array(),
|
|
4 => array(3),
|
|
5 => array(6),
|
|
7 => array(4, 3, 5, 6),
|
|
8 => array(9),
|
|
9 => array(),
|
|
);
|
|
$this->assertPaths($graph, $expected_paths);
|
|
|
|
$expected_reverse_paths = array(
|
|
1 => array(),
|
|
2 => array(1),
|
|
3 => array(2, 1, 4, 7),
|
|
4 => array(2, 1, 7),
|
|
5 => array(7),
|
|
7 => array(),
|
|
8 => array(),
|
|
9 => array(8),
|
|
);
|
|
$this->assertReversePaths($graph, $expected_reverse_paths);
|
|
|
|
// Assert that DFS didn't created "missing" vertexes automatically.
|
|
$this->assertFALSE(isset($graph[6]), t('Vertex 6 has not been created'));
|
|
|
|
$expected_components = array(
|
|
array(1, 2, 3, 4, 5, 7),
|
|
array(8, 9),
|
|
);
|
|
$this->assertComponents($graph, $expected_components);
|
|
|
|
$expected_weights = array(
|
|
array(1, 2, 3),
|
|
array(2, 4, 3),
|
|
array(7, 4, 3),
|
|
array(7, 5),
|
|
array(8, 9),
|
|
);
|
|
$this->assertWeights($graph, $expected_weights);
|
|
}
|
|
|
|
/**
|
|
* Return a normalized version of a graph.
|
|
*/
|
|
function normalizeGraph($graph) {
|
|
$normalized_graph = array();
|
|
foreach ($graph as $vertex => $edges) {
|
|
// Create vertex even if it hasn't any edges.
|
|
$normalized_graph[$vertex] = array();
|
|
foreach ($edges as $edge) {
|
|
$normalized_graph[$vertex]['edges'][$edge] = TRUE;
|
|
}
|
|
}
|
|
return $normalized_graph;
|
|
}
|
|
|
|
/**
|
|
* Verify expected paths in a graph.
|
|
*
|
|
* @param $graph
|
|
* A graph array processed by
|
|
* Drupal\Component\Graph\Graph::searchAndSort().
|
|
* @param $expected_paths
|
|
* An associative array containing vertices with their expected paths.
|
|
*/
|
|
function assertPaths($graph, $expected_paths) {
|
|
foreach ($expected_paths as $vertex => $paths) {
|
|
// Build an array with keys = $paths and values = TRUE.
|
|
$expected = array_fill_keys($paths, TRUE);
|
|
$result = isset($graph[$vertex]['paths']) ? $graph[$vertex]['paths'] : array();
|
|
$this->assertEqual($expected, $result, t('Expected paths for vertex @vertex: @expected-paths, got @paths', array('@vertex' => $vertex, '@expected-paths' => $this->displayArray($expected, TRUE), '@paths' => $this->displayArray($result, TRUE))));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Verify expected reverse paths in a graph.
|
|
*
|
|
* @param $graph
|
|
* A graph array processed by Drupal\Component\Graph\Graph::searchAndSort().
|
|
* @param $expected_reverse_paths
|
|
* An associative array containing vertices with their expected reverse
|
|
* paths.
|
|
*/
|
|
function assertReversePaths($graph, $expected_reverse_paths) {
|
|
foreach ($expected_reverse_paths as $vertex => $paths) {
|
|
// Build an array with keys = $paths and values = TRUE.
|
|
$expected = array_fill_keys($paths, TRUE);
|
|
$result = isset($graph[$vertex]['reverse_paths']) ? $graph[$vertex]['reverse_paths'] : array();
|
|
$this->assertEqual($expected, $result, t('Expected reverse paths for vertex @vertex: @expected-paths, got @paths', array('@vertex' => $vertex, '@expected-paths' => $this->displayArray($expected, TRUE), '@paths' => $this->displayArray($result, TRUE))));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Verify expected components in a graph.
|
|
*
|
|
* @param $graph
|
|
* A graph array processed by Drupal\Component\Graph\Graph::searchAndSort().
|
|
* @param $expected_components
|
|
* An array containing of components defined as a list of their vertices.
|
|
*/
|
|
function assertComponents($graph, $expected_components) {
|
|
$unassigned_vertices = array_fill_keys(array_keys($graph), TRUE);
|
|
foreach ($expected_components as $component) {
|
|
$result_components = array();
|
|
foreach ($component as $vertex) {
|
|
$result_components[] = $graph[$vertex]['component'];
|
|
unset($unassigned_vertices[$vertex]);
|
|
}
|
|
$this->assertEqual(1, count(array_unique($result_components)), t('Expected one unique component for vertices @vertices, got @components', array('@vertices' => $this->displayArray($component), '@components' => $this->displayArray($result_components))));
|
|
}
|
|
$this->assertEqual(array(), $unassigned_vertices, t('Vertices not assigned to a component: @vertices', array('@vertices' => $this->displayArray($unassigned_vertices, TRUE))));
|
|
}
|
|
|
|
/**
|
|
* Verify expected order in a graph.
|
|
*
|
|
* @param $graph
|
|
* A graph array processed by Drupal\Component\Graph\Graph::searchAndSort().
|
|
* @param $expected_orders
|
|
* An array containing lists of vertices in their expected order.
|
|
*/
|
|
function assertWeights($graph, $expected_orders) {
|
|
foreach ($expected_orders as $order) {
|
|
$previous_vertex = array_shift($order);
|
|
foreach ($order as $vertex) {
|
|
$this->assertTrue($graph[$previous_vertex]['weight'] < $graph[$vertex]['weight'], t('Weights of @previous-vertex and @vertex are correct relative to each other', array('@previous-vertex' => $previous_vertex, '@vertex' => $vertex)));
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Helper function to output vertices as comma-separated list.
|
|
*
|
|
* @param $paths
|
|
* An array containing a list of vertices.
|
|
* @param $keys
|
|
* (optional) Whether to output the keys of $paths instead of the values.
|
|
*/
|
|
function displayArray($paths, $keys = FALSE) {
|
|
if (!empty($paths)) {
|
|
return implode(', ', $keys ? array_keys($paths) : $paths);
|
|
}
|
|
else {
|
|
return '(empty)';
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests authorize.php and related hooks.
|
|
*/
|
|
class SystemAuthorizeCase extends DrupalWebTestCase {
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'Authorize API',
|
|
'description' => 'Tests the authorize.php script and related API.',
|
|
'group' => 'System',
|
|
);
|
|
}
|
|
|
|
function setUp() {
|
|
parent::setUp(array('system_test'));
|
|
|
|
variable_set('allow_authorize_operations', TRUE);
|
|
|
|
// Create an administrator user.
|
|
$this->admin_user = $this->drupalCreateUser(array('administer software updates'));
|
|
$this->drupalLogin($this->admin_user);
|
|
}
|
|
|
|
/**
|
|
* Helper function to initialize authorize.php and load it via drupalGet().
|
|
*
|
|
* Initializing authorize.php needs to happen in the child Drupal
|
|
* installation, not the parent. So, we visit a menu callback provided by
|
|
* system_test.module which calls system_authorized_init() to initialize the
|
|
* $_SESSION inside the test site, not the framework site. This callback
|
|
* redirects to authorize.php when it's done initializing.
|
|
*
|
|
* @see system_authorized_init().
|
|
*/
|
|
function drupalGetAuthorizePHP($page_title = 'system-test-auth') {
|
|
$this->drupalGet('system-test/authorize-init/' . $page_title);
|
|
}
|
|
|
|
/**
|
|
* Tests the FileTransfer hooks
|
|
*/
|
|
function testFileTransferHooks() {
|
|
$page_title = $this->randomName(16);
|
|
$this->drupalGetAuthorizePHP($page_title);
|
|
$this->assertTitle(strtr('@title | Drupal', array('@title' => $page_title)), 'authorize.php page title is correct.');
|
|
$this->assertNoText('It appears you have reached this page in error.');
|
|
$this->assertText('To continue, provide your server connection details');
|
|
// Make sure we see the new connection method added by system_test.
|
|
$this->assertRaw('System Test FileTransfer');
|
|
// Make sure the settings form callback works.
|
|
$this->assertText('System Test Username');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test the handling of requests containing 'index.php'.
|
|
*/
|
|
class SystemIndexPhpTest extends DrupalWebTestCase {
|
|
public static function getInfo() {
|
|
return array(
|
|
'name' => 'Index.php handling',
|
|
'description' => "Test the handling of requests containing 'index.php'.",
|
|
'group' => 'System',
|
|
);
|
|
}
|
|
|
|
function setUp() {
|
|
parent::setUp();
|
|
}
|
|
|
|
/**
|
|
* Test index.php handling.
|
|
*/
|
|
function testIndexPhpHandling() {
|
|
$index_php = $GLOBALS['base_url'] . '/index.php';
|
|
|
|
$this->drupalGet($index_php, array('external' => TRUE));
|
|
$this->assertResponse(200, t('Make sure index.php returns a valid page.'));
|
|
|
|
$this->drupalGet($index_php, array('external' => TRUE, 'query' => array('q' => 'user')));
|
|
$this->assertResponse(200, t('Make sure index.php?q=user returns a valid page.'));
|
|
|
|
$this->drupalGet($index_php .'/user', array('external' => TRUE));
|
|
$this->assertResponse(404, t("Make sure index.php/user returns a 'page not found'."));
|
|
}
|
|
}
|