diff --git a/core/modules/simpletest/lib/Drupal/simpletest/TestBase.php b/core/modules/simpletest/lib/Drupal/simpletest/TestBase.php index 560afb1..78602c9 100644 --- a/core/modules/simpletest/lib/Drupal/simpletest/TestBase.php +++ b/core/modules/simpletest/lib/Drupal/simpletest/TestBase.php @@ -95,10 +95,17 @@ */ protected $setup = FALSE; + /** + * Indicates whether or not the database prefix has been set up for the test. + * + * This is checked in TestBase::tearDown() before deleting the tables of the + * test site. In case the database prefix was never set up properly this + * ensures that the tables of the parent site are not deleted. + * + * @var bool + */ protected $setupDatabasePrefix = FALSE; - protected $setupEnvironment = FALSE; - /** * TRUE if verbose debugging is enabled. * @@ -780,31 +787,47 @@ public function run(array $methods = array()) { foreach ($class_methods as $method) { // If the current method starts with "test", run it - it's a test. if (strtolower(substr($method, 0, 4)) == 'test') { - // Insert a fail record. This will be deleted on completion to ensure - // that testing completed. - $method_info = new \ReflectionMethod($class, $method); - $caller = array( - 'file' => $method_info->getFileName(), - 'line' => $method_info->getStartLine(), - 'function' => $class . '->' . $method . '()', - ); - $completion_check_id = TestBase::insertAssert($this->testId, $class, FALSE, t('The test did not complete due to a fatal error.'), 'Completion check', $caller); - $this->setUp(); - if ($this->setup) { - try { - $this->$method(); - // Finish up. - } - catch (\Exception $e) { - $this->exceptionHandler($e); - } + try { + // Insert a fail record. This will be deleted on completion to ensure + // that testing completed. + $method_info = new \ReflectionMethod($class, $method); + $caller = array( + 'file' => $method_info->getFileName(), + 'line' => $method_info->getStartLine(), + 'function' => $class . '->' . $method . '()', + ); + $completion_check_id = TestBase::insertAssert($this->testId, $class, FALSE, t('The test did not complete due to a fatal error.'), 'Completion check', $caller); + $this->setUp(); + $this->$method(); $this->tearDown(); + // Remove the completion check record. + TestBase::deleteAssert($completion_check_id); + } + catch (TestSetUpException $e) { + // Remove the completion check record. + TestBase::deleteAssert($completion_check_id); + $caller = array( + 'file' => $e->getFile(), + 'line' => $e->getLine(), + ); + $message = $e->getMessage() ?: t("The test cannot be executed because it has not been set up properly."); + TestBase::insertAssert($this->testId, $class, FALSE, $message, 'Setup', $caller); } - else { - $this->fail(t("The test cannot be executed because it has not been set up properly.")); + catch (TestTearDownException $e) { + // Remove the completion check record. + TestBase::deleteAssert($completion_check_id); + $caller = array( + 'file' => $e->getFile(), + 'line' => $e->getLine(), + ); + $message = $e->getMessage() ?: t("The test could not be teared down properly."); + TestBase::insertAssert($this->testId, $class, FALSE, $message, 'Tear down', $caller); + } + catch (\Exception $e) { + // Remove the completion check record. + TestBase::deleteAssert($completion_check_id); + $this->exceptionHandler($e); } - // Remove the completion check record. - TestBase::deleteAssert($completion_check_id); } } } @@ -856,12 +879,6 @@ protected function prepareDatabasePrefix() { protected function changeDatabasePrefix() { if (empty($this->databasePrefix)) { $this->prepareDatabasePrefix(); - // If $this->prepareDatabasePrefix() failed to work, return without - // setting $this->setupDatabasePrefix to TRUE, so setUp() methods will - // know to bail out. - if (empty($this->databasePrefix)) { - return; - } } // Clone the current connection and replace the current prefix. @@ -953,10 +970,21 @@ protected function prepareEnvironment() { $this->translation_files_directory = $this->public_files_directory . '/translations'; // Create the directories - file_prepare_directory($this->public_files_directory, FILE_CREATE_DIRECTORY | FILE_MODIFY_PERMISSIONS); - file_prepare_directory($this->private_files_directory, FILE_CREATE_DIRECTORY); - file_prepare_directory($this->temp_files_directory, FILE_CREATE_DIRECTORY); - file_prepare_directory($this->translation_files_directory, FILE_CREATE_DIRECTORY); + $is_dir = is_dir('sites'); + $is_readable = is_readable('sites'); + $is_writable = is_writable('sites'); + if (!file_prepare_directory($this->public_files_directory, FILE_CREATE_DIRECTORY | FILE_MODIFY_PERMISSIONS)) { + throw new TestSetUpException('Could not prepare the public files directory of the test site.'); + }; + if (!file_prepare_directory($this->private_files_directory, FILE_CREATE_DIRECTORY)) { + throw new TestSetUpException('Could not prepare the private files directory of the test site.'); + } + if (!file_prepare_directory($this->temp_files_directory, FILE_CREATE_DIRECTORY)) { + throw new TestSetUpException('Could not prepare the temporary files directory of the test site.'); + } + if (!file_prepare_directory($this->translation_files_directory, FILE_CREATE_DIRECTORY)) { + throw new TestSetUpException('Could not prepare the translation files directory of the test site.'); + } $this->generatedTestFiles = FALSE; // Create and set new configuration directories. @@ -993,9 +1021,6 @@ protected function prepareEnvironment() { $test_info = &$GLOBALS['drupal_test_info']; $test_info['test_run_id'] = $this->databasePrefix; $test_info['in_child_site'] = FALSE; - - // Indicate the environment was set up correctly. - $this->setupEnvironment = TRUE; } /** @@ -1017,7 +1042,7 @@ protected function prepareConfigDirectories() { $GLOBALS['config_directories'][$type] = $path; // Ensure the directory can be created and is writeable. if (!install_ensure_config_directory($type)) { - return FALSE; + throw new TestSetUpException("Could not prepare the $type configuration directory of the test site."); } // Provide the already resolved path for tests. $this->configDirectories[$type] = $path; diff --git a/core/modules/simpletest/lib/Drupal/simpletest/TestBase.php.orig b/core/modules/simpletest/lib/Drupal/simpletest/TestBase.php.orig new file mode 100644 index 0000000..560afb1 --- /dev/null +++ b/core/modules/simpletest/lib/Drupal/simpletest/TestBase.php.orig @@ -0,0 +1,1427 @@ + 0, + '#fail' => 0, + '#exception' => 0, + '#debug' => 0, + ); + + /** + * Assertions thrown in that test case. + * + * @var Array + */ + protected $assertions = array(); + + /** + * This class is skipped when looking for the source of an assertion. + * + * When displaying which function an assert comes from, it's not too useful + * to see "WebTestBase->drupalLogin()', we would like to see the test + * that called it. So we need to skip the classes defining these helper + * methods. + */ + protected $skipClasses = array(__CLASS__ => TRUE); + + /** + * Flag to indicate whether the test has been set up. + * + * The setUp() method isolates the test from the parent Drupal site by + * creating a random prefix for the database and setting up a clean file + * storage directory. The tearDown() method then cleans up this test + * environment. We must ensure that setUp() has been run. Otherwise, + * tearDown() will act on the parent Drupal site rather than the test + * environment, destroying live data. + */ + protected $setup = FALSE; + + protected $setupDatabasePrefix = FALSE; + + protected $setupEnvironment = FALSE; + + /** + * TRUE if verbose debugging is enabled. + * + * @var boolean + */ + protected $verbose = FALSE; + + /** + * Incrementing identifier for verbose output filenames. + * + * @var integer + */ + protected $verboseId = 0; + + /** + * Safe class name for use in verbose output filenames. + * + * Namespaces separator (\) replaced with _. + * + * @var string + */ + protected $verboseClassName; + + /** + * Directory where verbose output files are put. + * + * @var string + */ + protected $verboseDirectory; + + /** + * The original database prefix when running inside Simpletest. + * + * @var string + */ + protected $originalPrefix; + + /** + * URL to the verbose output file directory. + * + * @var string + */ + protected $verboseDirectoryUrl; + + /** + * The settings array. + */ + protected $originalSettings; + + /** + * The public file directory for the test environment. + * + * This is set in TestBase::prepareEnvironment(). + * + * @var string + */ + protected $public_files_directory; + + /** + * Whether to die in case any test assertion fails. + * + * @var boolean + * + * @see run-tests.sh + */ + public $dieOnFail = FALSE; + + /** + * The dependency injection container used in the test. + * + * @var \Symfony\Component\DependencyInjection\ContainerInterface + */ + protected $container; + + /** + * The config importer that can used in a test. + * + * @var \Drupal\Core\Config\ConfigImporter + */ + protected $configImporter; + + /** + * The random generator. + * + * @var \Drupal\Component\Utility\Random + */ + protected $randomGenerator; + + /** + * Constructor for Test. + * + * @param $test_id + * Tests with the same id are reported together. + */ + public function __construct($test_id = NULL) { + $this->testId = $test_id; + } + + /** + * Provides meta information about this test case, such as test name. + * + * @return array + * An array of untranslated strings with the following keys: + * - name: An overview of what is tested by the class; for example, "User + * access rules". + * - description: One sentence describing the test, starting with a verb. + * - group: The human-readable name of the module ("Node", "Statistics"), or + * the human-readable name of the Drupal facility tested (e.g. "Form API" + * or "XML-RPC"). + */ + public static function getInfo() { + // PHP does not allow us to declare this method as abstract public static, + // so we simply throw an exception here if this has not been implemented by + // a child class. + throw new \RuntimeException("Sub-class must implement the getInfo method!"); + } + + /** + * Performs setup tasks before each individual test method is run. + */ + abstract protected function setUp(); + + /** + * Checks the matching requirements for Test. + * + * @return + * Array of errors containing a list of unmet requirements. + */ + protected function checkRequirements() { + return array(); + } + + /** + * Internal helper: stores the assert. + * + * @param $status + * Can be 'pass', 'fail', 'exception', 'debug'. + * TRUE is a synonym for 'pass', FALSE for 'fail'. + * @param $message + * (optional) A message to display with the assertion. Do not translate + * messages: use format_string() to embed variables in the message text, not + * t(). If left blank, a default message will be displayed. + * @param $group + * (optional) The group this message is in, which is displayed in a column + * in test output. Use 'Debug' to indicate this is debugging output. Do not + * translate this string. Defaults to 'Other'; most tests do not override + * this default. + * @param $caller + * By default, the assert comes from a function whose name starts with + * 'test'. Instead, you can specify where this assert originates from + * by passing in an associative array as $caller. Key 'file' is + * the name of the source file, 'line' is the line number and 'function' + * is the caller function itself. + */ + protected function assert($status, $message = '', $group = 'Other', array $caller = NULL) { + // Convert boolean status to string status. + if (is_bool($status)) { + $status = $status ? 'pass' : 'fail'; + } + + // Increment summary result counter. + $this->results['#' . $status]++; + + // Get the function information about the call to the assertion method. + if (!$caller) { + $caller = $this->getAssertionCall(); + } + + // Creation assertion array that can be displayed while tests are running. + $this->assertions[] = $assertion = array( + 'test_id' => $this->testId, + 'test_class' => get_class($this), + 'status' => $status, + 'message' => $message, + 'message_group' => $group, + 'function' => $caller['function'], + 'line' => $caller['line'], + 'file' => $caller['file'], + ); + + // Store assertion for display after the test has completed. + self::getDatabaseConnection() + ->insert('simpletest') + ->fields($assertion) + ->execute(); + + // We do not use a ternary operator here to allow a breakpoint on + // test failure. + if ($status == 'pass') { + return TRUE; + } + else { + if ($this->dieOnFail && ($status == 'fail' || $status == 'exception')) { + exit(1); + } + return FALSE; + } + } + + /** + * Store an assertion from outside the testing context. + * + * This is useful for inserting assertions that can only be recorded after + * the test case has been destroyed, such as PHP fatal errors. The caller + * information is not automatically gathered since the caller is most likely + * inserting the assertion on behalf of other code. In all other respects + * the method behaves just like \Drupal\simpletest\TestBase::assert() in terms + * of storing the assertion. + * + * @return + * Message ID of the stored assertion. + * + * @see \Drupal\simpletest\TestBase::assert() + * @see \Drupal\simpletest\TestBase::deleteAssert() + */ + public static function insertAssert($test_id, $test_class, $status, $message = '', $group = 'Other', array $caller = array()) { + // Convert boolean status to string status. + if (is_bool($status)) { + $status = $status ? 'pass' : 'fail'; + } + + $caller += array( + 'function' => t('Unknown'), + 'line' => 0, + 'file' => t('Unknown'), + ); + + $assertion = array( + 'test_id' => $test_id, + 'test_class' => $test_class, + 'status' => $status, + 'message' => $message, + 'message_group' => $group, + 'function' => $caller['function'], + 'line' => $caller['line'], + 'file' => $caller['file'], + ); + + return self::getDatabaseConnection() + ->insert('simpletest') + ->fields($assertion) + ->execute(); + } + + /** + * Delete an assertion record by message ID. + * + * @param $message_id + * Message ID of the assertion to delete. + * + * @return + * TRUE if the assertion was deleted, FALSE otherwise. + * + * @see \Drupal\simpletest\TestBase::insertAssert() + */ + public static function deleteAssert($message_id) { + return (bool) self::getDatabaseConnection() + ->delete('simpletest') + ->condition('message_id', $message_id) + ->execute(); + } + + /** + * Returns the database connection to the site running Simpletest. + * + * @return \Drupal\Core\Database\Connection + * The database connection to use for inserting assertions. + */ + public static function getDatabaseConnection() { + try { + $connection = Database::getConnection('default', 'simpletest_original_default'); + } + catch (ConnectionNotDefinedException $e) { + // If the test was not set up, the simpletest_original_default + // connection does not exist. + $connection = Database::getConnection('default', 'default'); + } + return $connection; + } + + /** + * Cycles through backtrace until the first non-assertion method is found. + * + * @return + * Array representing the true caller. + */ + protected function getAssertionCall() { + $backtrace = debug_backtrace(); + + // The first element is the call. The second element is the caller. + // We skip calls that occurred in one of the methods of our base classes + // or in an assertion function. + while (($caller = $backtrace[1]) && + ((isset($caller['class']) && isset($this->skipClasses[$caller['class']])) || + substr($caller['function'], 0, 6) == 'assert')) { + // We remove that call. + array_shift($backtrace); + } + + return Error::getLastCaller($backtrace); + } + + /** + * Check to see if a value is not false. + * + * False values are: empty string, 0, NULL, and FALSE. + * + * @param $value + * The value on which the assertion is to be done. + * @param $message + * (optional) A message to display with the assertion. Do not translate + * messages: use format_string() to embed variables in the message text, not + * t(). If left blank, a default message will be displayed. + * @param $group + * (optional) The group this message is in, which is displayed in a column + * in test output. Use 'Debug' to indicate this is debugging output. Do not + * translate this string. Defaults to 'Other'; most tests do not override + * this default. + * + * @return + * TRUE if the assertion succeeded, FALSE otherwise. + */ + protected function assertTrue($value, $message = '', $group = 'Other') { + return $this->assert((bool) $value, $message ? $message : t('Value @value is TRUE.', array('@value' => var_export($value, TRUE))), $group); + } + + /** + * Check to see if a value is false. + * + * False values are: empty string, 0, NULL, and FALSE. + * + * @param $value + * The value on which the assertion is to be done. + * @param $message + * (optional) A message to display with the assertion. Do not translate + * messages: use format_string() to embed variables in the message text, not + * t(). If left blank, a default message will be displayed. + * @param $group + * (optional) The group this message is in, which is displayed in a column + * in test output. Use 'Debug' to indicate this is debugging output. Do not + * translate this string. Defaults to 'Other'; most tests do not override + * this default. + * + * @return + * TRUE if the assertion succeeded, FALSE otherwise. + */ + protected function assertFalse($value, $message = '', $group = 'Other') { + return $this->assert(!$value, $message ? $message : t('Value @value is FALSE.', array('@value' => var_export($value, TRUE))), $group); + } + + /** + * Check to see if a value is NULL. + * + * @param $value + * The value on which the assertion is to be done. + * @param $message + * (optional) A message to display with the assertion. Do not translate + * messages: use format_string() to embed variables in the message text, not + * t(). If left blank, a default message will be displayed. + * @param $group + * (optional) The group this message is in, which is displayed in a column + * in test output. Use 'Debug' to indicate this is debugging output. Do not + * translate this string. Defaults to 'Other'; most tests do not override + * this default. + * + * @return + * TRUE if the assertion succeeded, FALSE otherwise. + */ + protected function assertNull($value, $message = '', $group = 'Other') { + return $this->assert(!isset($value), $message ? $message : t('Value @value is NULL.', array('@value' => var_export($value, TRUE))), $group); + } + + /** + * Check to see if a value is not NULL. + * + * @param $value + * The value on which the assertion is to be done. + * @param $message + * (optional) A message to display with the assertion. Do not translate + * messages: use format_string() to embed variables in the message text, not + * t(). If left blank, a default message will be displayed. + * @param $group + * (optional) The group this message is in, which is displayed in a column + * in test output. Use 'Debug' to indicate this is debugging output. Do not + * translate this string. Defaults to 'Other'; most tests do not override + * this default. + * + * @return + * TRUE if the assertion succeeded, FALSE otherwise. + */ + protected function assertNotNull($value, $message = '', $group = 'Other') { + return $this->assert(isset($value), $message ? $message : t('Value @value is not NULL.', array('@value' => var_export($value, TRUE))), $group); + } + + /** + * Check to see if two values are equal. + * + * @param $first + * The first value to check. + * @param $second + * The second value to check. + * @param $message + * (optional) A message to display with the assertion. Do not translate + * messages: use format_string() to embed variables in the message text, not + * t(). If left blank, a default message will be displayed. + * @param $group + * (optional) The group this message is in, which is displayed in a column + * in test output. Use 'Debug' to indicate this is debugging output. Do not + * translate this string. Defaults to 'Other'; most tests do not override + * this default. + * + * @return + * TRUE if the assertion succeeded, FALSE otherwise. + */ + protected function assertEqual($first, $second, $message = '', $group = 'Other') { + return $this->assert($first == $second, $message ? $message : t('Value @first is equal to value @second.', array('@first' => var_export($first, TRUE), '@second' => var_export($second, TRUE))), $group); + } + + /** + * Check to see if two values are not equal. + * + * @param $first + * The first value to check. + * @param $second + * The second value to check. + * @param $message + * (optional) A message to display with the assertion. Do not translate + * messages: use format_string() to embed variables in the message text, not + * t(). If left blank, a default message will be displayed. + * @param $group + * (optional) The group this message is in, which is displayed in a column + * in test output. Use 'Debug' to indicate this is debugging output. Do not + * translate this string. Defaults to 'Other'; most tests do not override + * this default. + * + * @return + * TRUE if the assertion succeeded, FALSE otherwise. + */ + protected function assertNotEqual($first, $second, $message = '', $group = 'Other') { + return $this->assert($first != $second, $message ? $message : t('Value @first is not equal to value @second.', array('@first' => var_export($first, TRUE), '@second' => var_export($second, TRUE))), $group); + } + + /** + * Check to see if two values are identical. + * + * @param $first + * The first value to check. + * @param $second + * The second value to check. + * @param $message + * (optional) A message to display with the assertion. Do not translate + * messages: use format_string() to embed variables in the message text, not + * t(). If left blank, a default message will be displayed. + * @param $group + * (optional) The group this message is in, which is displayed in a column + * in test output. Use 'Debug' to indicate this is debugging output. Do not + * translate this string. Defaults to 'Other'; most tests do not override + * this default. + * + * @return + * TRUE if the assertion succeeded, FALSE otherwise. + */ + protected function assertIdentical($first, $second, $message = '', $group = 'Other') { + return $this->assert($first === $second, $message ? $message : t('Value @first is identical to value @second.', array('@first' => var_export($first, TRUE), '@second' => var_export($second, TRUE))), $group); + } + + /** + * Check to see if two values are not identical. + * + * @param $first + * The first value to check. + * @param $second + * The second value to check. + * @param $message + * (optional) A message to display with the assertion. Do not translate + * messages: use format_string() to embed variables in the message text, not + * t(). If left blank, a default message will be displayed. + * @param $group + * (optional) The group this message is in, which is displayed in a column + * in test output. Use 'Debug' to indicate this is debugging output. Do not + * translate this string. Defaults to 'Other'; most tests do not override + * this default. + * + * @return + * TRUE if the assertion succeeded, FALSE otherwise. + */ + protected function assertNotIdentical($first, $second, $message = '', $group = 'Other') { + return $this->assert($first !== $second, $message ? $message : t('Value @first is not identical to value @second.', array('@first' => var_export($first, TRUE), '@second' => var_export($second, TRUE))), $group); + } + + /** + * Checks to see if two objects are identical. + * + * @param object $object1 + * The first object to check. + * @param object $object2 + * The second object to check. + * @param $message + * (optional) A message to display with the assertion. Do not translate + * messages: use format_string() to embed variables in the message text, not + * t(). If left blank, a default message will be displayed. + * @param $group + * (optional) The group this message is in, which is displayed in a column + * in test output. Use 'Debug' to indicate this is debugging output. Do not + * translate this string. Defaults to 'Other'; most tests do not override + * this default. + * + * @return + * TRUE if the assertion succeeded, FALSE otherwise. + */ + protected function assertIdenticalObject($object1, $object2, $message = '', $group = 'Other') { + $message = $message ?: format_string('!object1 is identical to !object2', array( + '!object1' => var_export($object1, TRUE), + '!object2' => var_export($object2, TRUE), + )); + $identical = TRUE; + foreach ($object1 as $key => $value) { + $identical = $identical && isset($object2->$key) && $object2->$key === $value; + } + return $this->assertTrue($identical, $message, $group); + } + + + + /** + * Fire an assertion that is always positive. + * + * @param $message + * (optional) A message to display with the assertion. Do not translate + * messages: use format_string() to embed variables in the message text, not + * t(). If left blank, a default message will be displayed. + * @param $group + * (optional) The group this message is in, which is displayed in a column + * in test output. Use 'Debug' to indicate this is debugging output. Do not + * translate this string. Defaults to 'Other'; most tests do not override + * this default. + * + * @return + * TRUE. + */ + protected function pass($message = NULL, $group = 'Other') { + return $this->assert(TRUE, $message, $group); + } + + /** + * Fire an assertion that is always negative. + * + * @param $message + * (optional) A message to display with the assertion. Do not translate + * messages: use format_string() to embed variables in the message text, not + * t(). If left blank, a default message will be displayed. + * @param $group + * (optional) The group this message is in, which is displayed in a column + * in test output. Use 'Debug' to indicate this is debugging output. Do not + * translate this string. Defaults to 'Other'; most tests do not override + * this default. + * + * @return + * FALSE. + */ + protected function fail($message = NULL, $group = 'Other') { + return $this->assert(FALSE, $message, $group); + } + + /** + * Fire an error assertion. + * + * @param $message + * (optional) A message to display with the assertion. Do not translate + * messages: use format_string() to embed variables in the message text, not + * t(). If left blank, a default message will be displayed. + * @param $group + * (optional) The group this message is in, which is displayed in a column + * in test output. Use 'Debug' to indicate this is debugging output. Do not + * translate this string. Defaults to 'Other'; most tests do not override + * this default. + * @param $caller + * The caller of the error. + * + * @return + * FALSE. + */ + protected function error($message = '', $group = 'Other', array $caller = NULL) { + if ($group == 'User notice') { + // Since 'User notice' is set by trigger_error() which is used for debug + // set the message to a status of 'debug'. + return $this->assert('debug', $message, 'Debug', $caller); + } + + return $this->assert('exception', $message, $group, $caller); + } + + /** + * Logs verbose message in a text file. + * + * The a link to the vebose message will be placed in the test results via + * as a passing assertion with the text '[verbose message]'. + * + * @param $message + * The verbose message to be stored. + * + * @see simpletest_verbose() + */ + protected function verbose($message) { + // Do nothing if verbose debugging is disabled. + if (!$this->verbose) { + return; + } + + $message = '
ID #' . $this->verboseId . ' (Previous | Next)
' . $message; + $verbose_filename = $this->verboseDirectory . '/' . $this->verboseClassName . '-' . $this->verboseId . '.html'; + if (file_put_contents($verbose_filename, $message, FILE_APPEND)) { + $url = $this->verboseDirectoryUrl . '/' . $this->verboseClassName . '-' . $this->verboseId . '.html'; + // Not using l() to avoid invoking the theme system, so that unit tests + // can use verbose() as well. + $url = '' . t('Verbose message') . ''; + $this->error($url, 'User notice'); + } + $this->verboseId++; + } + + /** + * Run all tests in this class. + * + * Regardless of whether $methods are passed or not, only method names + * starting with "test" are executed. + * + * @param $methods + * (optional) A list of method names in the test case class to run; e.g., + * array('testFoo', 'testBar'). By default, all methods of the class are + * taken into account, but it can be useful to only run a few selected test + * methods during debugging. + */ + public function run(array $methods = array()) { + TestServiceProvider::$currentTest = $this; + $simpletest_config = \Drupal::config('simpletest.settings'); + + $class = get_class($this); + if ($simpletest_config->get('verbose')) { + // Initialize verbose debugging. + $this->verbose = TRUE; + $this->verboseDirectory = PublicStream::basePath() . '/simpletest/verbose'; + $this->verboseDirectoryUrl = file_create_url($this->verboseDirectory); + if (file_prepare_directory($this->verboseDirectory, FILE_CREATE_DIRECTORY) && !file_exists($this->verboseDirectory . '/.htaccess')) { + file_put_contents($this->verboseDirectory . '/.htaccess', "\nExpiresActive Off\n\n"); + } + $this->verboseClassName = str_replace("\\", "_", $class); + } + // HTTP auth settings (:) for the simpletest browser + // when sending requests to the test site. + $this->httpauth_method = (int) $simpletest_config->get('httpauth.method'); + $username = $simpletest_config->get('httpauth.username'); + $password = $simpletest_config->get('httpauth.password'); + if (!empty($username) && !empty($password)) { + $this->httpauth_credentials = $username . ':' . $password; + } + + set_error_handler(array($this, 'errorHandler')); + // Iterate through all the methods in this class, unless a specific list of + // methods to run was passed. + $class_methods = get_class_methods($class); + if ($methods) { + $class_methods = array_intersect($class_methods, $methods); + } + $missing_requirements = $this->checkRequirements(); + if (!empty($missing_requirements)) { + $missing_requirements_object = new \ReflectionObject($this); + $caller = array( + 'file' => $missing_requirements_object->getFileName(), + ); + foreach ($missing_requirements as $missing_requirement) { + TestBase::insertAssert($this->testId, $class, FALSE, $missing_requirement, 'Requirements check.', $caller); + } + } + else { + if (defined("$class::SORT_METHODS")) { + sort($class_methods); + } + foreach ($class_methods as $method) { + // If the current method starts with "test", run it - it's a test. + if (strtolower(substr($method, 0, 4)) == 'test') { + // Insert a fail record. This will be deleted on completion to ensure + // that testing completed. + $method_info = new \ReflectionMethod($class, $method); + $caller = array( + 'file' => $method_info->getFileName(), + 'line' => $method_info->getStartLine(), + 'function' => $class . '->' . $method . '()', + ); + $completion_check_id = TestBase::insertAssert($this->testId, $class, FALSE, t('The test did not complete due to a fatal error.'), 'Completion check', $caller); + $this->setUp(); + if ($this->setup) { + try { + $this->$method(); + // Finish up. + } + catch (\Exception $e) { + $this->exceptionHandler($e); + } + $this->tearDown(); + } + else { + $this->fail(t("The test cannot be executed because it has not been set up properly.")); + } + // Remove the completion check record. + TestBase::deleteAssert($completion_check_id); + } + } + } + TestServiceProvider::$currentTest = NULL; + // Clear out the error messages and restore error handler. + drupal_get_messages(); + restore_error_handler(); + } + + /** + * Generates a database prefix for running tests. + * + * The database prefix is used by prepareEnvironment() to setup a public files + * directory for the test to be run, which also contains the PHP error log, + * which is written to in case of a fatal error. Since that directory is based + * on the database prefix, all tests (even unit tests) need to have one, in + * order to access and read the error log. + * + * @see TestBase::prepareEnvironment() + * + * The generated database table prefix is used for the Drupal installation + * being performed for the test. It is also used as user agent HTTP header + * value by the cURL-based browser of DrupalWebTestCase, which is sent to the + * Drupal installation of the test. During early Drupal bootstrap, the user + * agent HTTP header is parsed, and if it matches, all database queries use + * the database table prefix that has been generated here. + * + * @see WebTestBase::curlInitialize() + * @see drupal_valid_test_ua() + * @see WebTestBase::setUp() + */ + protected function prepareDatabasePrefix() { + $this->databasePrefix = 'simpletest' . mt_rand(1000, 1000000); + + // As soon as the database prefix is set, the test might start to execute. + // All assertions as well as the SimpleTest batch operations are associated + // with the testId, so the database prefix has to be associated with it. + db_update('simpletest_test_id') + ->fields(array('last_prefix' => $this->databasePrefix)) + ->condition('test_id', $this->testId) + ->execute(); + } + + /** + * Changes the database connection to the prefixed one. + * + * @see WebTestBase::setUp() + */ + protected function changeDatabasePrefix() { + if (empty($this->databasePrefix)) { + $this->prepareDatabasePrefix(); + // If $this->prepareDatabasePrefix() failed to work, return without + // setting $this->setupDatabasePrefix to TRUE, so setUp() methods will + // know to bail out. + if (empty($this->databasePrefix)) { + return; + } + } + + // Clone the current connection and replace the current prefix. + $connection_info = Database::getConnectionInfo('default'); + Database::renameConnection('default', 'simpletest_original_default'); + foreach ($connection_info as $target => $value) { + $connection_info[$target]['prefix'] = array( + 'default' => $value['prefix']['default'] . $this->databasePrefix, + ); + } + Database::addConnectionInfo('default', 'default', $connection_info['default']); + + // Additionally override global $databases, since the installer does not use + // the Database connection info. + // @see install_verify_database_settings() + // @see install_database_errors() + // @todo Fix installer to use Database connection info. + global $databases; + $databases['default']['default'] = $connection_info['default']; + + // Indicate the database prefix was set up correctly. + $this->setupDatabasePrefix = TRUE; + } + + /** + * Prepares the current environment for running the test. + * + * Backups various current environment variables and resets them, so they do + * not interfere with the Drupal site installation in which tests are executed + * and can be restored in TestBase::tearDown(). + * + * Also sets up new resources for the testing environment, such as the public + * filesystem and configuration directories. + * + * @see TestBase::tearDown() + */ + protected function prepareEnvironment() { + global $user, $conf; + $language_interface = language(Language::TYPE_INTERFACE); + + // When running the test runner within a test, back up the original database + // prefix and re-set the new/nested prefix in drupal_valid_test_ua(). + if (drupal_valid_test_ua()) { + $this->originalPrefix = drupal_valid_test_ua(); + drupal_valid_test_ua($this->databasePrefix); + } + + // Backup current in-memory configuration. + $this->originalSettings = settings()->getAll(); + $this->originalConf = $conf; + + // Backup statics and globals. + $this->originalContainer = clone \Drupal::getContainer(); + $this->originalLanguage = $language_interface; + $this->originalConfigDirectories = $GLOBALS['config_directories']; + if (isset($GLOBALS['theme_key'])) { + $this->originalThemeKey = $GLOBALS['theme_key']; + } + $this->originalTheme = isset($GLOBALS['theme']) ? $GLOBALS['theme'] : NULL; + + // Save further contextual information. + // Use the original files directory to avoid nesting it within an existing + // simpletest directory if a test is executed within a test. + $this->originalFileDirectory = settings()->get('file_public_path', conf_path() . '/files'); + $this->originalProfile = drupal_get_profile(); + $this->originalUser = isset($user) ? clone $user : NULL; + + // Ensure that the current session is not changed by the new environment. + require_once DRUPAL_ROOT . '/' . settings()->get('session_inc', 'core/includes/session.inc'); + drupal_save_session(FALSE); + // Run all tests as a anonymous user by default, web tests will replace that + // during the test set up. + $user = drupal_anonymous_user(); + + // Save and clean the shutdown callbacks array because it is static cached + // and will be changed by the test run. Otherwise it will contain callbacks + // from both environments and the testing environment will try to call the + // handlers defined by the original one. + $callbacks = &drupal_register_shutdown_function(); + $this->originalShutdownCallbacks = $callbacks; + $callbacks = array(); + + // Create test directory ahead of installation so fatal errors and debug + // information can be logged during installation process. + // Use temporary files directory with the same prefix as the database. + $this->public_files_directory = $this->originalFileDirectory . '/simpletest/' . substr($this->databasePrefix, 10); + $this->private_files_directory = $this->public_files_directory . '/private'; + $this->temp_files_directory = $this->private_files_directory . '/temp'; + $this->translation_files_directory = $this->public_files_directory . '/translations'; + + // Create the directories + file_prepare_directory($this->public_files_directory, FILE_CREATE_DIRECTORY | FILE_MODIFY_PERMISSIONS); + file_prepare_directory($this->private_files_directory, FILE_CREATE_DIRECTORY); + file_prepare_directory($this->temp_files_directory, FILE_CREATE_DIRECTORY); + file_prepare_directory($this->translation_files_directory, FILE_CREATE_DIRECTORY); + $this->generatedTestFiles = FALSE; + + // Create and set new configuration directories. + $this->prepareConfigDirectories(); + + // Reset statics before the old container is replaced so that objects with a + // __destruct() method still have access to it. + // @todo: Remove once they have been converted to services. + drupal_static_reset(); + + // Reset and create a new service container. + $this->container = new ContainerBuilder(); + // @todo Remove this once this class has no calls to t() and format_plural() + $this->container->register('string_translation', 'Drupal\Core\StringTranslation\TranslationManager'); + + // Register info parser. + $this->container->register('info_parser', 'Drupal\Core\Extension\InfoParser'); + + $request = Request::create('/'); + $this->container->set('request', $request); + $this->container->set('current_user', $GLOBALS['user']); + + \Drupal::setContainer($this->container); + + // Unset globals. + unset($GLOBALS['theme_key']); + unset($GLOBALS['theme']); + + // Log fatal errors. + ini_set('log_errors', 1); + ini_set('error_log', $this->public_files_directory . '/error.log'); + + // Set the test information for use in other parts of Drupal. + $test_info = &$GLOBALS['drupal_test_info']; + $test_info['test_run_id'] = $this->databasePrefix; + $test_info['in_child_site'] = FALSE; + + // Indicate the environment was set up correctly. + $this->setupEnvironment = TRUE; + } + + /** + * Create and set new configuration directories. + * + * The child site uses drupal_valid_test_ua() to adjust the config directory + * paths to a test-prefix-specific directory within the public files + * directory. + * + * @see config_get_config_directory() + */ + protected function prepareConfigDirectories() { + $GLOBALS['config_directories'] = array(); + $this->configDirectories = array(); + include_once DRUPAL_ROOT . '/core/includes/install.inc'; + foreach (array(CONFIG_ACTIVE_DIRECTORY, CONFIG_STAGING_DIRECTORY) as $type) { + // Assign the relative path to the global variable. + $path = conf_path() . '/files/simpletest/' . substr($this->databasePrefix, 10) . '/config_' . $type; + $GLOBALS['config_directories'][$type] = $path; + // Ensure the directory can be created and is writeable. + if (!install_ensure_config_directory($type)) { + return FALSE; + } + // Provide the already resolved path for tests. + $this->configDirectories[$type] = $path; + } + } + + /** + * Rebuild \Drupal::getContainer(). + * + * Use this to build a new kernel and service container. For example, when the + * list of enabled modules is changed via the internal browser, in which case + * the test process still contains an old kernel and service container with an + * old module list. + * + * @see TestBase::prepareEnvironment() + * @see TestBase::tearDown() + * + * @todo Fix http://drupal.org/node/1708692 so that module enable/disable + * changes are immediately reflected in \Drupal::getContainer(). Until then, + * tests can invoke this workaround when requiring services from newly + * enabled modules to be immediately available in the same request. + */ + protected function rebuildContainer() { + // Preserve the request object after the container rebuild. + $request = \Drupal::request(); + + $this->kernel = new DrupalKernel('testing', drupal_classloader(), FALSE); + $this->kernel->boot(); + // DrupalKernel replaces the container in \Drupal::getContainer() with a + // different object, so we need to replace the instance on this test class. + $this->container = \Drupal::getContainer(); + // The global $user is set in TestBase::prepareEnvironment(). + $this->container->set('request', $request); + $this->container->set('current_user', $GLOBALS['user']); + } + + /** + * Performs cleanup tasks after each individual test method has been run. + * + * Deletes created files, database tables, and reverts environment changes. + * + * This method needs to be invoked for both unit and integration tests. + * + * @see TestBase::prepareDatabasePrefix() + * @see TestBase::changeDatabasePrefix() + * @see TestBase::prepareEnvironment() + */ + protected function tearDown() { + global $user, $conf; + + // Reset all static variables. + // Unsetting static variables will potentially invoke destruct methods, + // which might call into functions that prime statics and caches again. + // In that case, all functions are still operating on the test environment, + // which means they may need to access its filesystem and database. + drupal_static_reset(); + + if ($this->container->has('state') && $state = $this->container->get('state')) { + $captured_emails = $state->get('system.test_mail_collector') ?: array(); + $emailCount = count($captured_emails); + if ($emailCount) { + $message = format_plural($emailCount, '1 e-mail was sent during this test.', '@count e-mails were sent during this test.'); + $this->pass($message, t('E-mail')); + } + } + + // Ensure that TestBase::changeDatabasePrefix() has run and TestBase::$setup + // was not tricked into TRUE, since the following code would delete the + // entire parent site otherwise. + if ($this->setupDatabasePrefix) { + // Remove all prefixed tables. + $connection_info = Database::getConnectionInfo('default'); + $tables = db_find_tables($connection_info['default']['prefix']['default'] . '%'); + $prefix_length = strlen($connection_info['default']['prefix']['default']); + foreach ($tables as $table) { + if (db_drop_table(substr($table, $prefix_length))) { + unset($tables[$table]); + } + } + if (!empty($tables)) { + $this->fail('Failed to drop all prefixed tables.'); + } + } + + // In case a fatal error occurred that was not in the test process read the + // log to pick up any fatal errors. + simpletest_log_read($this->testId, $this->databasePrefix, get_class($this), TRUE); + + // Delete temporary files directory. + file_unmanaged_delete_recursive($this->originalFileDirectory . '/simpletest/' . substr($this->databasePrefix, 10), array($this, 'filePreDeleteCallback')); + + // Restore original database connection. + Database::removeConnection('default'); + Database::renameConnection('simpletest_original_default', 'default'); + // @see TestBase::changeDatabasePrefix() + global $databases; + $connection_info = Database::getConnectionInfo('default'); + $databases['default']['default'] = $connection_info['default']; + + // Restore original globals. + if (isset($this->originalThemeKey)) { + $GLOBALS['theme_key'] = $this->originalThemeKey; + } + $GLOBALS['theme'] = $this->originalTheme; + + // Reset all static variables. + // All destructors of statically cached objects have been invoked above; + // this second reset is guaranteed to reset everything to nothing. + drupal_static_reset(); + + // Restore original in-memory configuration. + $conf = $this->originalConf; + new Settings($this->originalSettings); + + // Restore original statics and globals. + \Drupal::setContainer($this->originalContainer); + $GLOBALS['config_directories'] = $this->originalConfigDirectories; + if (isset($this->originalPrefix)) { + drupal_valid_test_ua($this->originalPrefix); + } + + // Restore original shutdown callbacks. + $callbacks = &drupal_register_shutdown_function(); + $callbacks = $this->originalShutdownCallbacks; + + // Restore original user session. + $user = $this->originalUser; + drupal_save_session(TRUE); + } + + /** + * Handle errors during test runs. + * + * Because this is registered in set_error_handler(), it has to be public. + * + * @see set_error_handler + */ + public function errorHandler($severity, $message, $file = NULL, $line = NULL) { + if ($severity & error_reporting()) { + require_once DRUPAL_ROOT . '/core/includes/errors.inc'; + $error_map = array( + E_STRICT => 'Run-time notice', + E_WARNING => 'Warning', + E_NOTICE => 'Notice', + E_CORE_ERROR => 'Core error', + E_CORE_WARNING => 'Core warning', + E_USER_ERROR => 'User error', + E_USER_WARNING => 'User warning', + E_USER_NOTICE => 'User notice', + E_RECOVERABLE_ERROR => 'Recoverable error', + E_DEPRECATED => 'Deprecated', + E_USER_DEPRECATED => 'User deprecated', + ); + + $backtrace = debug_backtrace(); + + // Add verbose backtrace for errors, but not for debug() messages. + if ($severity !== E_USER_NOTICE) { + $verbose_backtrace = $backtrace; + array_shift($verbose_backtrace); + $message .= '
' . Error::formatBacktrace($verbose_backtrace) . '
'; + } + + $this->error($message, $error_map[$severity], Error::getLastCaller($backtrace)); + } + return TRUE; + } + + /** + * Handle exceptions. + * + * @see set_exception_handler + */ + protected function exceptionHandler($exception) { + require_once DRUPAL_ROOT . '/core/includes/errors.inc'; + $backtrace = $exception->getTrace(); + $verbose_backtrace = $backtrace; + // Push on top of the backtrace the call that generated the exception. + array_unshift($backtrace, array( + 'line' => $exception->getLine(), + 'file' => $exception->getFile(), + )); + // The exception message is run through + // \Drupal\Component\Utility\checkPlain() by + // \Drupal\Core\Utility\decodeException(). + $decoded_exception = Error::decodeException($exception); + unset($decoded_exception['backtrace']); + $message = format_string('%type: !message in %function (line %line of %file). 
!backtrace
', $decoded_exception + array( + '!backtrace' => Error::formatBacktrace($verbose_backtrace), + )); + $this->error($message, 'Uncaught exception', Error::getLastCaller($backtrace)); + } + + /** + * Changes in memory settings. + * + * @param $name + * The name of the setting to return. + * @param $value + * The value of the setting. + * + * @see \Drupal\Component\Utility\Settings::get() + */ + protected function settingsSet($name, $value) { + $settings = settings()->getAll(); + $settings[$name] = $value; + new Settings($settings); + } + + /** + * Generates a unique random string of ASCII characters of codes 32 to 126. + * + * Do not use this method when special characters are not possible (e.g., in + * machine or file names that have already been validated); instead, use + * \Drupal\simpletest\TestBase::randomName(). + * + * @param int $length + * Length of random string to generate. + * + * @return string + * Randomly generated unique string. + * + * @see \Drupal\Component\Utility\Random::string() + */ + public function randomString($length = 8) { + return $this->getRandomGenerator()->string($length, TRUE, array($this, 'randomStringValidate')); + } + + /** + * Callback for random string validation. + * + * @see \Drupal\Component\Utility\Random::string() + * + * @param string $string + * The random string to validate. + * + * @return bool + * TRUE if the random string is valid, FALSE if not. + */ + public function randomStringValidate($string) { + // Consecutive spaces causes issues for + // Drupal\simpletest\WebTestBase::assertLink(). + if (preg_match('/\s{2,}/', $string)) { + return FALSE; + } + + // Starting with a space means that length might not be what is expected. + if (preg_match('/^\s/', $string)) { + return FALSE; + } + + // Ending with a space means that length might not be what is expected. + if (preg_match('/\s$/', $string)) { + return FALSE; + } + + return TRUE; + } + + /** + * Generates a unique random string containing letters and numbers. + * + * Do not use this method when testing unvalidated user input. Instead, use + * \Drupal\simpletest\TestBase::randomString(). + * + * @param int $length + * Length of random string to generate. + * + * @return string + * Randomly generated unique string. + * + * @see \Drupal\Component\Utility\Random::name() + */ + public function randomName($length = 8) { + return $this->getRandomGenerator()->name($length, TRUE); + } + + /** + * Generates a random PHP object. + * + * @param int $size + * The number of random keys to add to the object. + * + * @return \stdClass + * The generated object, with the specified number of random keys. Each key + * has a random string value. + * + * @see \Drupal\Component\Utility\Random::object() + */ + public function randomObject($size = 4) { + return $this->getRandomGenerator()->object($size); + } + + /** + * Gets the random generator for the utility methods. + * + * @return \Drupal\Component\Utility\Random + * The random generator + */ + protected function getRandomGenerator() { + if (!is_object($this->randomGenerator)) { + $this->randomGenerator = new Random(); + } + return $this->randomGenerator; + } + + /** + * Converts a list of possible parameters into a stack of permutations. + * + * Takes a list of parameters containing possible values, and converts all of + * them into a list of items containing every possible permutation. + * + * Example: + * @code + * $parameters = array( + * 'one' => array(0, 1), + * 'two' => array(2, 3), + * ); + * $permutations = TestBase::generatePermutations($parameters); + * // Result: + * $permutations == array( + * array('one' => 0, 'two' => 2), + * array('one' => 1, 'two' => 2), + * array('one' => 0, 'two' => 3), + * array('one' => 1, 'two' => 3), + * ) + * @endcode + * + * @param $parameters + * An associative array of parameters, keyed by parameter name, and whose + * values are arrays of parameter values. + * + * @return + * A list of permutations, which is an array of arrays. Each inner array + * contains the full list of parameters that have been passed, but with a + * single value only. + */ + public static function generatePermutations($parameters) { + $all_permutations = array(array()); + foreach ($parameters as $parameter => $values) { + $new_permutations = array(); + // Iterate over all values of the parameter. + foreach ($values as $value) { + // Iterate over all existing permutations. + foreach ($all_permutations as $permutation) { + // Add the new parameter value to existing permutations. + $new_permutations[] = $permutation + array($parameter => $value); + } + } + // Replace the old permutations with the new permutations. + $all_permutations = $new_permutations; + } + return $all_permutations; + } + + /** + * Ensures test files are deletable within file_unmanaged_delete_recursive(). + * + * Some tests chmod generated files to be read only. During tearDown() and + * other cleanup operations, these files need to get deleted too. + */ + public static function filePreDeleteCallback($path) { + chmod($path, 0700); + } + + /** + * Returns a ConfigImporter object to import test importing of configuration. + * + * @return \Drupal\Core\Config\ConfigImporter + * The ConfigImporter object. + */ + public function configImporter() { + if (!$this->configImporter) { + // Set up the ConfigImporter object for testing. + $storage_comparer = new StorageComparer( + $this->container->get('config.storage.staging'), + $this->container->get('config.storage') + ); + $this->configImporter = new ConfigImporter( + $storage_comparer, + $this->container->get('event_dispatcher'), + $this->container->get('config.factory'), + $this->container->get('entity.manager'), + $this->container->get('lock'), + $this->container->get('uuid'), + $this->container->get('config.typed') + ); + } + // Always recalculate the changelist when called. + return $this->configImporter->reset(); + } + + /** + * Copies configuration objects from source storage to target storage. + * + * @param \Drupal\Core\Config\StorageInterface $source_storage + * The source config storage service. + * @param \Drupal\Core\Config\StorageInterface $target_storage + * The target config storage service. + */ + public function copyConfig(StorageInterface $source_storage, StorageInterface $target_storage) { + $target_storage->deleteAll(); + foreach ($source_storage->listAll() as $name) { + $target_storage->write($name, $source_storage->read($name)); + } + } +} diff --git a/core/modules/simpletest/lib/Drupal/simpletest/TestSetUpException.php b/core/modules/simpletest/lib/Drupal/simpletest/TestSetUpException.php new file mode 100644 index 0000000..3b1dfb9 --- /dev/null +++ b/core/modules/simpletest/lib/Drupal/simpletest/TestSetUpException.php @@ -0,0 +1,14 @@ +prepareEnvironment(); - if (!$this->setupEnvironment) { - return FALSE; - } // Reset all statics and variables to perform tests in a clean environment. $conf = array(); @@ -745,7 +742,7 @@ protected function setUp() { // write back to persistent caches when they are destructed. $this->changeDatabasePrefix(); if (!$this->setupDatabasePrefix) { - return FALSE; + throw new TestSetUpException('The database prefix could not be changed for the test site.'); } // Set the 'simpletest_parent_profile' variable to add the parent profile's @@ -853,7 +850,6 @@ protected function setUp() { if (empty($path)) { _current_path('run-tests'); } - $this->setup = TRUE; } /** diff --git a/core/modules/simpletest/lib/Drupal/simpletest/WebTestBase.php.orig b/core/modules/simpletest/lib/Drupal/simpletest/WebTestBase.php.orig new file mode 100644 index 0000000..265012e --- /dev/null +++ b/core/modules/simpletest/lib/Drupal/simpletest/WebTestBase.php.orig @@ -0,0 +1,3587 @@ +:). + */ + protected $httpauth_credentials = NULL; + + /** + * The current session name, if available. + */ + protected $session_name = NULL; + + /** + * The current session ID, if available. + */ + protected $session_id = NULL; + + /** + * Whether the files were copied to the test files directory. + */ + protected $generatedTestFiles = FALSE; + + /** + * The maximum number of redirects to follow when handling responses. + */ + protected $maximumRedirects = 5; + + /** + * The number of redirects followed during the handling of a request. + */ + protected $redirect_count; + + /** + * The kernel used in this test. + */ + protected $kernel; + + /** + * Cookies to set on curl requests. + * + * @var array + */ + protected $curlCookies = array(); + + /** + * An array of custom translations suitable for drupal_rewrite_settings(). + * + * @var array + */ + protected $customTranslations; + + /** + * Constructor for \Drupal\simpletest\WebTestBase. + */ + function __construct($test_id = NULL) { + parent::__construct($test_id); + $this->skipClasses[__CLASS__] = TRUE; + } + + /** + * Get a node from the database based on its title. + * + * @param $title + * A node title, usually generated by $this->randomName(). + * @param $reset + * (optional) Whether to reset the entity cache. + * + * @return \Drupal\Core\Entity\EntityInterface + * A node entity matching $title. + */ + function drupalGetNodeByTitle($title, $reset = FALSE) { + if ($reset) { + \Drupal::entityManager()->getStorageController('node')->resetCache(); + } + $nodes = entity_load_multiple_by_properties('node', array('title' => $title)); + // Load the first node returned from the database. + $returned_node = reset($nodes); + return $returned_node; + } + + /** + * Creates a node based on default settings. + * + * @param array $settings + * (optional) An associative array of settings for the node, as used in + * entity_create(). Override the defaults by specifying the key and value + * in the array, for example: + * @code + * $this->drupalCreateNode(array( + * 'title' => t('Hello, world!'), + * 'type' => 'article', + * )); + * @endcode + * The following defaults are provided: + * - body: Random string using the default filter format: + * @code + * $settings['body'][0] = array( + * 'value' => $this->randomName(32), + * 'format' => filter_default_format(), + * ); + * @endcode + * - title: Random string. + * - comment: COMMENT_OPEN. + * - changed: REQUEST_TIME. + * - promote: NODE_NOT_PROMOTED. + * - log: Empty string. + * - status: NODE_PUBLISHED. + * - sticky: NODE_NOT_STICKY. + * - type: 'page'. + * - langcode: Language::LANGCODE_NOT_SPECIFIED. + * - uid: The currently logged in user, or the user running test. + * - revision: 1. (Backwards-compatible binary flag indicating whether a + * new revision should be created; use 1 to specify a new revision.) + * + * @return \Drupal\node\Entity\Node + * The created node entity. + */ + protected function drupalCreateNode(array $settings = array()) { + // Populate defaults array. + $settings += array( + 'body' => array(array()), + 'title' => $this->randomName(8), + 'changed' => REQUEST_TIME, + 'promote' => NODE_NOT_PROMOTED, + 'revision' => 1, + 'log' => '', + 'status' => NODE_PUBLISHED, + 'sticky' => NODE_NOT_STICKY, + 'type' => 'page', + 'langcode' => Language::LANGCODE_NOT_SPECIFIED, + ); + + // Use the original node's created time for existing nodes. + if (isset($settings['created']) && !isset($settings['date'])) { + $settings['date'] = format_date($settings['created'], 'custom', 'Y-m-d H:i:s O'); + } + + // If the node's user uid is not specified manually, use the currently + // logged in user if available, or else the user running the test. + if (!isset($settings['uid'])) { + if ($this->loggedInUser) { + $settings['uid'] = $this->loggedInUser->id(); + } + else { + $user = \Drupal::currentUser() ?: $GLOBALS['user']; + $settings['uid'] = $user->id(); + } + } + + // Merge body field value and format separately. + $settings['body'][0] += array( + 'value' => $this->randomName(32), + 'format' => filter_default_format(), + ); + + $node = entity_create('node', $settings); + if (!empty($settings['revision'])) { + $node->setNewRevision(); + } + $node->save(); + + return $node; + } + + /** + * Creates a custom content type based on default settings. + * + * @param array $values + * An array of settings to change from the defaults. + * Example: 'type' => 'foo'. + * + * @return \Drupal\node\Entity\NodeType + * Created content type. + */ + protected function drupalCreateContentType(array $values = array()) { + // Find a non-existent random type name. + if (!isset($values['type'])) { + do { + $id = strtolower($this->randomName(8)); + } while (node_type_load($id)); + } + else { + $id = $values['type']; + } + $values += array( + 'type' => $id, + 'name' => $id, + ); + $type = entity_create('node_type', $values); + $status = $type->save(); + menu_router_rebuild(); + + $this->assertEqual($status, SAVED_NEW, t('Created content type %type.', array('%type' => $type->id()))); + + // Reset permissions so that permissions for this content type are + // available. + $this->checkPermissions(array(), TRUE); + + return $type; + } + + /** + * Creates a block instance based on default settings. + * + * Note: Until this can be done programmatically, the active user account + * must have permission to administer blocks. + * + * @param string $plugin_id + * The plugin ID of the block type for this block instance. + * @param array $settings + * (optional) An associative array of settings for the block entity. + * Override the defaults by specifying the key and value in the array, for + * example: + * @code + * $this->drupalPlaceBlock('system_powered_by_block', array( + * 'label' => t('Hello, world!'), + * )); + * @endcode + * The following defaults are provided: + * - label: Random string. + * - id: Random string. + * - region: 'sidebar_first'. + * - theme: The default theme. + * - visibility: Empty array. + * + * @return \Drupal\block\Entity\Block + * The block entity. + * + * @todo + * Add support for creating custom block instances. + */ + protected function drupalPlaceBlock($plugin_id, array $settings = array()) { + $settings += array( + 'plugin' => $plugin_id, + 'region' => 'sidebar_first', + 'id' => strtolower($this->randomName(8)), + 'theme' => \Drupal::config('system.theme')->get('default'), + 'label' => $this->randomName(8), + 'visibility' => array(), + 'weight' => 0, + ); + foreach (array('region', 'id', 'theme', 'plugin', 'visibility', 'weight') as $key) { + $values[$key] = $settings[$key]; + // Remove extra values that do not belong in the settings array. + unset($settings[$key]); + } + $values['settings'] = $settings; + $block = entity_create('block', $values); + $block->save(); + return $block; + } + + /** + * Gets a list files that can be used in tests. + * + * @param $type + * File type, possible values: 'binary', 'html', 'image', 'javascript', + * 'php', 'sql', 'text'. + * @param $size + * File size in bytes to match. Please check the tests/files folder. + * + * @return + * List of files that match filter. + */ + protected function drupalGetTestFiles($type, $size = NULL) { + if (empty($this->generatedTestFiles)) { + // Generate binary test files. + $lines = array(64, 1024); + $count = 0; + foreach ($lines as $line) { + simpletest_generate_file('binary-' . $count++, 64, $line, 'binary'); + } + + // Generate text test files. + $lines = array(16, 256, 1024, 2048, 20480); + $count = 0; + foreach ($lines as $line) { + simpletest_generate_file('text-' . $count++, 64, $line); + } + + // Copy other test files from simpletest. + $original = drupal_get_path('module', 'simpletest') . '/files'; + $files = file_scan_directory($original, '/(html|image|javascript|php|sql)-.*/'); + foreach ($files as $file) { + file_unmanaged_copy($file->uri, PublicStream::basePath()); + } + + $this->generatedTestFiles = TRUE; + } + + $files = array(); + // Make sure type is valid. + if (in_array($type, array('binary', 'html', 'image', 'javascript', 'php', 'sql', 'text'))) { + $files = file_scan_directory('public://', '/' . $type . '\-.*/'); + + // If size is set then remove any files that are not of that size. + if ($size !== NULL) { + foreach ($files as $file) { + $stats = stat($file->uri); + if ($stats['size'] != $size) { + unset($files[$file->uri]); + } + } + } + } + usort($files, array($this, 'drupalCompareFiles')); + return $files; + } + + /** + * Compare two files based on size and file name. + */ + protected function drupalCompareFiles($file1, $file2) { + $compare_size = filesize($file1->uri) - filesize($file2->uri); + if ($compare_size) { + // Sort by file size. + return $compare_size; + } + else { + // The files were the same size, so sort alphabetically. + return strnatcmp($file1->name, $file2->name); + } + } + + /** + * Create a user with a given set of permissions. + * + * @param array $permissions + * Array of permission names to assign to user. Note that the user always + * has the default permissions derived from the "authenticated users" role. + * @param string $name + * The user name. + * + * @return \Drupal\user\Entity\User|false + * A fully loaded user object with pass_raw property, or FALSE if account + * creation fails. + */ + protected function drupalCreateUser(array $permissions = array(), $name = NULL) { + // Create a role with the given permission set, if any. + $rid = FALSE; + if ($permissions) { + $rid = $this->drupalCreateRole($permissions); + if (!$rid) { + return FALSE; + } + } + + // Create a user assigned to that role. + $edit = array(); + $edit['name'] = !empty($name) ? $name : $this->randomName(); + $edit['mail'] = $edit['name'] . '@example.com'; + $edit['pass'] = user_password(); + $edit['status'] = 1; + if ($rid) { + $edit['roles'] = array($rid); + } + + $account = entity_create('user', $edit); + $account->save(); + + $this->assertTrue($account->id(), String::format('User created with name %name and pass %pass', array('%name' => $edit['name'], '%pass' => $edit['pass'])), 'User login'); + if (!$account->id()) { + return FALSE; + } + + // Add the raw password so that we can log in as this user. + $account->pass_raw = $edit['pass']; + return $account; + } + + /** + * Internal helper function; Create a role with specified permissions. + * + * @param array $permissions + * Array of permission names to assign to role. + * @param string $rid + * (optional) The role ID (machine name). Defaults to a random name. + * @param string $name + * (optional) The label for the role. Defaults to a random string. + * @param integer $weight + * (optional) The weight for the role. Defaults NULL so that entity_create() + * sets the weight to maximum + 1. + * + * @return string + * Role ID of newly created role, or FALSE if role creation failed. + */ + protected function drupalCreateRole(array $permissions, $rid = NULL, $name = NULL, $weight = NULL) { + // Generate a random, lowercase machine name if none was passed. + if (!isset($rid)) { + $rid = strtolower($this->randomName(8)); + } + // Generate a random label. + if (!isset($name)) { + // In the role UI role names are trimmed and random string can start or + // end with a space. + $name = trim($this->randomString(8)); + } + + // Check the all the permissions strings are valid. + if (!$this->checkPermissions($permissions)) { + return FALSE; + } + + // Create new role. + $role = entity_create('user_role', array( + 'id' => $rid, + 'label' => $name, + )); + if (!is_null($weight)) { + $role->set('weight', $weight); + } + $result = $role->save(); + + $this->assertIdentical($result, SAVED_NEW, t('Created role ID @rid with name @name.', array( + '@name' => var_export($role->label(), TRUE), + '@rid' => var_export($role->id(), TRUE), + )), t('Role')); + + if ($result === SAVED_NEW) { + // Grant the specified permissions to the role, if any. + if (!empty($permissions)) { + user_role_grant_permissions($role->id(), $permissions); + $assigned_permissions = entity_load('user_role', $role->id())->permissions; + $missing_permissions = array_diff($permissions, $assigned_permissions); + if (!$missing_permissions) { + $this->pass(t('Created permissions: @perms', array('@perms' => implode(', ', $permissions))), t('Role')); + } + else { + $this->fail(t('Failed to create permissions: @perms', array('@perms' => implode(', ', $missing_permissions))), t('Role')); + } + } + return $role->id(); + } + else { + return FALSE; + } + } + + /** + * Check to make sure that the array of permissions are valid. + * + * @param $permissions + * Permissions to check. + * @param $reset + * Reset cached available permissions. + * + * @return + * TRUE or FALSE depending on whether the permissions are valid. + */ + protected function checkPermissions(array $permissions, $reset = FALSE) { + $available = &drupal_static(__FUNCTION__); + + if (!isset($available) || $reset) { + $available = array_keys(module_invoke_all('permission')); + } + + $valid = TRUE; + foreach ($permissions as $permission) { + if (!in_array($permission, $available)) { + $this->fail(t('Invalid permission %permission.', array('%permission' => $permission)), t('Role')); + $valid = FALSE; + } + } + return $valid; + } + + /** + * Log in a user with the internal browser. + * + * If a user is already logged in, then the current user is logged out before + * logging in the specified user. + * + * Please note that neither the global $user nor the passed-in user object is + * populated with data of the logged in user. If you need full access to the + * user object after logging in, it must be updated manually. If you also need + * access to the plain-text password of the user (set by drupalCreateUser()), + * e.g. to log in the same user again, then it must be re-assigned manually. + * For example: + * @code + * // Create a user. + * $account = $this->drupalCreateUser(array()); + * $this->drupalLogin($account); + * // Load real user object. + * $pass_raw = $account->pass_raw; + * $account = user_load($account->id()); + * $account->pass_raw = $pass_raw; + * @endcode + * + * @param \Drupal\Core\Session\AccountInterface $account + * User object representing the user to log in. + * + * @see drupalCreateUser() + */ + protected function drupalLogin(AccountInterface $account) { + if ($this->loggedInUser) { + $this->drupalLogout(); + } + + $edit = array( + 'name' => $account->getUsername(), + 'pass' => $account->pass_raw + ); + $this->drupalPostForm('user', $edit, t('Log in')); + + // @see WebTestBase::drupalUserIsLoggedIn() + if (isset($this->session_id)) { + $account->session_id = $this->session_id; + } + $pass = $this->assert($this->drupalUserIsLoggedIn($account), format_string('User %name successfully logged in.', array('%name' => $account->getUsername())), 'User login'); + if ($pass) { + $this->loggedInUser = $account; + $this->container->set('current_user', $account); + // @todo Temporary workaround for not being able to use synchronized + // services in non dumped container. + $this->container->get('access_subscriber')->setCurrentUser($account); + } + } + + /** + * Returns whether a given user account is logged in. + * + * @param \Drupal\user\UserInterface $account + * The user account object to check. + */ + protected function drupalUserIsLoggedIn($account) { + if (!isset($account->session_id)) { + return FALSE; + } + // @see _drupal_session_read() + return (bool) db_query("SELECT sid FROM {users} u INNER JOIN {sessions} s ON u.uid = s.uid WHERE s.sid = :sid", array(':sid' => $account->session_id))->fetchField(); + } + + /** + * Generate a token for the currently logged in user. + */ + protected function drupalGetToken($value = '') { + $private_key = drupal_get_private_key(); + return Crypt::hmacBase64($value, $this->session_id . $private_key); + } + + /** + * Logs a user out of the internal browser and confirms. + * + * Confirms logout by checking the login page. + */ + protected function drupalLogout() { + // Make a request to the logout page, and redirect to the user page, the + // idea being if you were properly logged out you should be seeing a login + // screen. + $this->drupalGet('user/logout', array('query' => array('destination' => 'user'))); + $this->assertResponse(200, 'User was logged out.'); + $pass = $this->assertField('name', 'Username field found.', 'Logout'); + $pass = $pass && $this->assertField('pass', 'Password field found.', 'Logout'); + + if ($pass) { + // @see WebTestBase::drupalUserIsLoggedIn() + unset($this->loggedInUser->session_id); + $this->loggedInUser = FALSE; + $this->container->set('current_user', drupal_anonymous_user()); + } + } + + /** + * Sets up a Drupal site for running functional and integration tests. + * + * Generates a random database prefix and installs Drupal with the specified + * installation profile in \Drupal\simpletest\WebTestBase::$profile into the + * prefixed database. Afterwards, installs any additional modules specified by + * the test. + * + * After installation all caches are flushed and several configuration values + * are reset to the values of the parent site executing the test, since the + * default values may be incompatible with the environment in which tests are + * being executed. + * + * @param ... + * List of modules to enable for the duration of the test. This can be + * either a single array or a variable number of string arguments. + * + * @see \Drupal\simpletest\WebTestBase::prepareDatabasePrefix() + * @see \Drupal\simpletest\WebTestBase::changeDatabasePrefix() + * @see \Drupal\simpletest\WebTestBase::prepareEnvironment() + */ + protected function setUp() { + global $conf; + + // When running tests through the Simpletest UI (vs. on the command line), + // Simpletest's batch conflicts with the installer's batch. Batch API does + // not support the concept of nested batches (in which the nested is not + // progressive), so we need to temporarily pretend there was no batch. + // Backup the currently running Simpletest batch. + $this->originalBatch = batch_get(); + + // Create the database prefix for this test. + $this->prepareDatabasePrefix(); + + // Prepare the environment for running tests. + $this->prepareEnvironment(); + if (!$this->setupEnvironment) { + return FALSE; + } + + // Reset all statics and variables to perform tests in a clean environment. + $conf = array(); + drupal_static_reset(); + + // Change the database prefix. + // All static variables need to be reset before the database prefix is + // changed, since \Drupal\Core\Utility\CacheArray implementations attempt to + // write back to persistent caches when they are destructed. + $this->changeDatabasePrefix(); + if (!$this->setupDatabasePrefix) { + return FALSE; + } + + // Set the 'simpletest_parent_profile' variable to add the parent profile's + // search path to the child site's search paths. + // @see drupal_system_listing() + $conf['simpletest_parent_profile'] = $this->originalProfile; + + // Define information about the user 1 account. + $this->root_user = new UserSession(array( + 'uid' => 1, + 'name' => 'admin', + 'mail' => 'admin@example.com', + 'pass_raw' => $this->randomName(), + )); + + // Reset the static batch to remove Simpletest's batch operations. + $batch = &batch_get(); + $batch = array(); + $variable_groups = array( + 'system.file' => array( + 'path.private' => $this->private_files_directory, + 'path.temporary' => $this->temp_files_directory, + ), + 'locale.settings' => array( + 'translation.path' => $this->translation_files_directory, + ), + ); + foreach ($variable_groups as $config_base => $variables) { + foreach ($variables as $name => $value) { + NestedArray::setValue($GLOBALS['conf'], array_merge(array($config_base), explode('.', $name)), $value); + } + } + $this->settingsSet('file_public_path', $this->public_files_directory); + // Execute the non-interactive installer. + require_once DRUPAL_ROOT . '/core/includes/install.core.inc'; + $this->settingsSet('cache', array('default' => 'cache.backend.memory')); + $parameters = $this->installParameters(); + install_drupal($parameters); + + // Set the install_profile so that web requests to the requests to the child + // site have the correct profile. + $settings = array( + 'settings' => array( + 'install_profile' => (object) array( + 'value' => $this->profile, + 'required' => TRUE, + ), + ), + ); + $this->writeSettings($settings); + // Override install profile in Settings to so the correct profile is used by + // tests. + $this->settingsSet('install_profile', $this->profile); + + $this->settingsSet('cache', array()); + $this->rebuildContainer(); + + // Restore the original Simpletest batch. + $batch = &batch_get(); + $batch = $this->originalBatch; + + // Set path variables. + + // Set 'parent_profile' of simpletest to add the parent profile's + // search path to the child site's search paths. + // @see drupal_system_listing() + \Drupal::config('simpletest.settings')->set('parent_profile', $this->originalProfile)->save(); + + // Collect modules to install. + $class = get_class($this); + $modules = array(); + while ($class) { + if (property_exists($class, 'modules')) { + $modules = array_merge($modules, $class::$modules); + } + $class = get_parent_class($class); + } + if ($modules) { + $modules = array_unique($modules); + $success = \Drupal::moduleHandler()->install($modules, TRUE); + $this->assertTrue($success, t('Enabled modules: %modules', array('%modules' => implode(', ', $modules)))); + $this->rebuildContainer(); + } + + // Reset/rebuild all data structures after enabling the modules. + $this->resetAll(); + + // Now make sure that the file path configurations are saved. This is done + // after we install the modules to override default values. + foreach ($variable_groups as $config_base => $variables) { + $config = \Drupal::config($config_base); + foreach ($variables as $name => $value) { + $config->set($name, $value); + } + $config->save(); + } + + // Use the test mail class instead of the default mail handler class. + \Drupal::config('system.mail')->set('interface.default', 'Drupal\Core\Mail\TestMailCollector')->save(); + + drupal_set_time_limit($this->timeLimit); + // Temporary fix so that when running from run-tests.sh we don't get an + // empty current path which would indicate we're on the home page. + $path = current_path(); + if (empty($path)) { + _current_path('run-tests'); + } + $this->setup = TRUE; + } + + /** + * Returns the parameters that will be used when Simpletest installs Drupal. + * + * @see install_drupal() + * @see install_state_defaults() + */ + protected function installParameters() { + $connection_info = Database::getConnectionInfo(); + $parameters = array( + 'interactive' => FALSE, + 'parameters' => array( + 'profile' => $this->profile, + 'langcode' => 'en', + ), + 'forms' => array( + 'install_settings_form' => $connection_info['default'], + 'install_configure_form' => array( + 'site_name' => 'Drupal', + 'site_mail' => 'simpletest@example.com', + 'account' => array( + 'name' => $this->root_user->name, + 'mail' => $this->root_user->getEmail(), + 'pass' => array( + 'pass1' => $this->root_user->pass_raw, + 'pass2' => $this->root_user->pass_raw, + ), + ), + // form_type_checkboxes_value() requires NULL instead of FALSE values + // for programmatic form submissions to disable a checkbox. + 'update_status_module' => array( + 1 => NULL, + 2 => NULL, + ), + ), + ), + ); + return $parameters; + } + + /** + * Writes a test-specific settings.php file for the child site. + * + * The child site loads this after the parent site's settings.php, so settings + * here override those. + * + * @param $settings An array of settings to write out, in the format expected + * by drupal_rewrite_settings(). + * + * @see _drupal_load_test_overrides() + * @see drupal_rewrite_settings() + */ + protected function writeSettings($settings) { + // drupal_rewrite_settings() sets the in-memory global variables in addition + // to writing the file. We'll want to restore the original globals. + foreach (array_keys($settings) as $variable_name) { + $original_globals[$variable_name] = isset($GLOBALS[$variable_name]) ? $GLOBALS[$variable_name] : NULL; + } + + include_once DRUPAL_ROOT . '/core/includes/install.inc'; + $filename = $this->public_files_directory . '/settings.php'; + file_put_contents($filename, " $value) { + $GLOBALS[$variable_name] = $value; + } + } + + /** + * Sets custom translations to the settings object and queues them to writing. + * + * In order for those custom translations to persist (being written in test + * site's settings.php) make sure to also call self::writeCustomTranslations() + * + * @param string $langcode + * The langcode to add translations for. + * @param array $values + * Array of values containing the untranslated string and its translation. + * For example: + * @code + * array( + * '' => array('Sunday' => 'domingo'), + * 'Long month name' => array('March' => 'marzo'), + * ); + * @endcode + */ + protected function addCustomTranslations($langcode, array $values) { + $this->settingsSet('locale_custom_strings_' . $langcode, $values); + foreach ($values as $key => $translations) { + foreach ($translations as $label => $value) { + $this->customTranslations['locale_custom_strings_' . $langcode][$key][$label] = (object) array( + 'value' => $value, + 'required' => TRUE, + ); + } + } + } + + /** + * Writes custom translations to test site's settings.php. + */ + protected function writeCustomTranslations() { + $this->writeSettings(array('settings' => $this->customTranslations)); + $this->customTranslations = array(); + } + + /** + * Overrides \Drupal\simpletest\TestBase::rebuildContainer(). + */ + protected function rebuildContainer() { + parent::rebuildContainer(); + // Make sure the url generator has a request object, otherwise calls to + // $this->drupalGet() will fail. + $this->prepareRequestForGenerator(); + } + + /** + * Resets all data structures after having enabled new modules. + * + * This method is called by \Drupal\simpletest\WebTestBase::setUp() after + * enabling the requested modules. It must be called again when additional + * modules are enabled later. + */ + protected function resetAll() { + // Clear all database and static caches and rebuild data structures. + drupal_flush_all_caches(); + $this->container = \Drupal::getContainer(); + + // Reload global $conf array and permissions. + $this->refreshVariables(); + $this->checkPermissions(array(), TRUE); + } + + /** + * Refreshes the in-memory set of variables. + * + * Useful after a page request is made that changes a variable in a different + * thread. + * + * In other words calling a settings page with $this->drupalPostForm() with a + * changed value would update a variable to reflect that change, but in the + * thread that made the call (thread running the test) the changed variable + * would not be picked up. + * + * This method clears the variables cache and loads a fresh copy from the + * database to ensure that the most up-to-date set of variables is loaded. + */ + protected function refreshVariables() { + global $conf; + cache('bootstrap')->delete('variables'); + $conf = variable_initialize(); + // Clear the tag cache. + drupal_static_reset('Drupal\Core\Cache\CacheBackendInterface::tagCache'); + \Drupal::service('config.factory')->reset(); + \Drupal::state()->resetCache(); + } + + /** + * Cleans up after testing. + * + * Deletes created files and temporary files directory, deletes the tables + * created by setUp(), and resets the database prefix. + */ + protected function tearDown() { + // Destroy the testing kernel. + if (isset($this->kernel)) { + $this->kernel->shutdown(); + } + parent::tearDown(); + + // Ensure that internal logged in variable and cURL options are reset. + $this->loggedInUser = FALSE; + $this->additionalCurlOptions = array(); + + // Close the CURL handler and reset the cookies array used for upgrade + // testing so test classes containing multiple tests are not polluted. + $this->curlClose(); + $this->curlCookies = array(); + } + + /** + * Initializes the cURL connection. + * + * If the simpletest_httpauth_credentials variable is set, this function will + * add HTTP authentication headers. This is necessary for testing sites that + * are protected by login credentials from public access. + * See the description of $curl_options for other options. + */ + protected function curlInitialize() { + global $base_url; + + if (!isset($this->curlHandle)) { + $this->curlHandle = curl_init(); + + // Some versions/configurations of cURL break on a NULL cookie jar, so + // supply a real file. + if (empty($this->cookieFile)) { + $this->cookieFile = $this->public_files_directory . '/cookie.jar'; + } + + $curl_options = array( + CURLOPT_COOKIEJAR => $this->cookieFile, + CURLOPT_URL => $base_url, + CURLOPT_FOLLOWLOCATION => FALSE, + CURLOPT_RETURNTRANSFER => TRUE, + // Required to make the tests run on HTTPS. + CURLOPT_SSL_VERIFYPEER => FALSE, + // Required to make the tests run on HTTPS. + CURLOPT_SSL_VERIFYHOST => FALSE, + CURLOPT_HEADERFUNCTION => array(&$this, 'curlHeaderCallback'), + CURLOPT_USERAGENT => $this->databasePrefix, + ); + if (isset($this->httpauth_credentials)) { + $curl_options[CURLOPT_HTTPAUTH] = $this->httpauth_method; + $curl_options[CURLOPT_USERPWD] = $this->httpauth_credentials; + } + // curl_setopt_array() returns FALSE if any of the specified options + // cannot be set, and stops processing any further options. + $result = curl_setopt_array($this->curlHandle, $this->additionalCurlOptions + $curl_options); + if (!$result) { + throw new \UnexpectedValueException('One or more cURL options could not be set.'); + } + + // By default, the child session name should be the same as the parent. + $this->session_name = session_name(); + } + // We set the user agent header on each request so as to use the current + // time and a new uniqid. + if (preg_match('/simpletest\d+/', $this->databasePrefix, $matches)) { + curl_setopt($this->curlHandle, CURLOPT_USERAGENT, drupal_generate_test_ua($matches[0])); + } + } + + /** + * Initializes and executes a cURL request. + * + * @param $curl_options + * An associative array of cURL options to set, where the keys are constants + * defined by the cURL library. For a list of valid options, see + * http://www.php.net/manual/function.curl-setopt.php + * @param $redirect + * FALSE if this is an initial request, TRUE if this request is the result + * of a redirect. + * + * @return + * The content returned from the call to curl_exec(). + * + * @see curlInitialize() + */ + protected function curlExec($curl_options, $redirect = FALSE) { + $this->curlInitialize(); + + if (!empty($curl_options[CURLOPT_URL])) { + // cURL incorrectly handles URLs with a fragment by including the + // fragment in the request to the server, causing some web servers + // to reject the request citing "400 - Bad Request". To prevent + // this, we strip the fragment from the request. + // TODO: Remove this for Drupal 8, since fixed in curl 7.20.0. + if (strpos($curl_options[CURLOPT_URL], '#')) { + $original_url = $curl_options[CURLOPT_URL]; + $curl_options[CURLOPT_URL] = strtok($curl_options[CURLOPT_URL], '#'); + } + } + + $url = empty($curl_options[CURLOPT_URL]) ? curl_getinfo($this->curlHandle, CURLINFO_EFFECTIVE_URL) : $curl_options[CURLOPT_URL]; + + if (!empty($curl_options[CURLOPT_POST])) { + // This is a fix for the Curl library to prevent Expect: 100-continue + // headers in POST requests, that may cause unexpected HTTP response + // codes from some webservers (like lighttpd that returns a 417 error + // code). It is done by setting an empty "Expect" header field that is + // not overwritten by Curl. + $curl_options[CURLOPT_HTTPHEADER][] = 'Expect:'; + } + + $cookies = array(); + if (!empty($this->curlCookies)) { + $cookies = $this->curlCookies; + } + // In order to debug web tests you need to either set a cookie, have the + // Xdebug session in the URL or set an environment variable in case of CLI + // requests. If the developer listens to connection on the parent site, by + // default the cookie is not forwarded to the client side, so you cannot + // debug the code running on the child site. In order to make debuggers work + // this bit of information is forwarded. Make sure that the debugger listens + // to at least three external connections. + $request = \Drupal::request(); + $cookie_params = $request->cookies; + if ($cookie_params->has('XDEBUG_SESSION')) { + $cookies[] = 'XDEBUG_SESSION=' . $cookie_params->get('XDEBUG_SESSION'); + } + // For CLI requests, the information is stored in $_SERVER. + $server = $request->server; + if ($server->has('XDEBUG_CONFIG')) { + // $_SERVER['XDEBUG_CONFIG'] has the form "key1=value1 key2=value2 ...". + $pairs = explode(' ', $server->get('XDEBUG_CONFIG')); + foreach ($pairs as $pair) { + list($key, $value) = explode('=', $pair); + // Account for key-value pairs being separated by multiple spaces. + if (trim($key, ' ') == 'idekey') { + $cookies[] = 'XDEBUG_SESSION=' . trim($value, ' '); + } + } + } + + // Merge additional cookies in. + if (!empty($cookies)) { + $curl_options += array( + CURLOPT_COOKIE => '', + ); + // Ensure any existing cookie data string ends with the correct separator. + if (!empty($curl_options[CURLOPT_COOKIE])) { + $curl_options[CURLOPT_COOKIE] = rtrim($curl_options[CURLOPT_COOKIE], '; ') . '; '; + } + $curl_options[CURLOPT_COOKIE] .= implode('; ', $cookies) . ';'; + } + + curl_setopt_array($this->curlHandle, $this->additionalCurlOptions + $curl_options); + + if (!$redirect) { + // Reset headers, the session ID and the redirect counter. + $this->session_id = NULL; + $this->headers = array(); + $this->redirect_count = 0; + } + + $content = curl_exec($this->curlHandle); + $status = curl_getinfo($this->curlHandle, CURLINFO_HTTP_CODE); + + // cURL incorrectly handles URLs with fragments, so instead of + // letting cURL handle redirects we take of them ourselves to + // to prevent fragments being sent to the web server as part + // of the request. + // TODO: Remove this for Drupal 8, since fixed in curl 7.20.0. + if (in_array($status, array(300, 301, 302, 303, 305, 307)) && $this->redirect_count < $this->maximumRedirects) { + if ($this->drupalGetHeader('location')) { + $this->redirect_count++; + $curl_options = array(); + $curl_options[CURLOPT_URL] = $this->drupalGetHeader('location'); + $curl_options[CURLOPT_HTTPGET] = TRUE; + return $this->curlExec($curl_options, TRUE); + } + } + + $this->drupalSetContent($content, isset($original_url) ? $original_url : curl_getinfo($this->curlHandle, CURLINFO_EFFECTIVE_URL)); + $message_vars = array( + '!method' => !empty($curl_options[CURLOPT_NOBODY]) ? 'HEAD' : (empty($curl_options[CURLOPT_POSTFIELDS]) ? 'GET' : 'POST'), + '@url' => isset($original_url) ? $original_url : $url, + '@status' => $status, + '!length' => format_size(strlen($this->drupalGetContent())) + ); + $message = String::format('!method @url returned @status (!length).', $message_vars); + $this->assertTrue($this->drupalGetContent() !== FALSE, $message, 'Browser'); + return $this->drupalGetContent(); + } + + /** + * Reads headers and registers errors received from the tested site. + * + * @param $curlHandler + * The cURL handler. + * @param $header + * An header. + * + * @see _drupal_log_error(). + */ + protected function curlHeaderCallback($curlHandler, $header) { + // Header fields can be extended over multiple lines by preceding each + // extra line with at least one SP or HT. They should be joined on receive. + // Details are in RFC2616 section 4. + if ($header[0] == ' ' || $header[0] == "\t") { + // Normalize whitespace between chucks. + $this->headers[] = array_pop($this->headers) . ' ' . trim($header); + } + else { + $this->headers[] = $header; + } + + // Errors are being sent via X-Drupal-Assertion-* headers, + // generated by _drupal_log_error() in the exact form required + // by \Drupal\simpletest\WebTestBase::error(). + if (preg_match('/^X-Drupal-Assertion-[0-9]+: (.*)$/', $header, $matches)) { + // Call \Drupal\simpletest\WebTestBase::error() with the parameters from + // the header. + call_user_func_array(array(&$this, 'error'), unserialize(urldecode($matches[1]))); + } + + // Save cookies. + if (preg_match('/^Set-Cookie: ([^=]+)=(.+)/', $header, $matches)) { + $name = $matches[1]; + $parts = array_map('trim', explode(';', $matches[2])); + $value = array_shift($parts); + $this->cookies[$name] = array('value' => $value, 'secure' => in_array('secure', $parts)); + if ($name == $this->session_name) { + if ($value != 'deleted') { + $this->session_id = $value; + } + else { + $this->session_id = NULL; + } + } + } + + // This is required by cURL. + return strlen($header); + } + + /** + * Close the cURL handler and unset the handler. + */ + protected function curlClose() { + if (isset($this->curlHandle)) { + curl_close($this->curlHandle); + unset($this->curlHandle); + } + } + + /** + * Parse content returned from curlExec using DOM and SimpleXML. + * + * @return + * A SimpleXMLElement or FALSE on failure. + */ + protected function parse() { + if (!$this->elements) { + // DOM can load HTML soup. But, HTML soup can throw warnings, suppress + // them. + $htmlDom = new \DOMDocument(); + @$htmlDom->loadHTML('' . $this->drupalGetContent()); + if ($htmlDom) { + $this->pass(t('Valid HTML found on "@path"', array('@path' => $this->getUrl())), t('Browser')); + // It's much easier to work with simplexml than DOM, luckily enough + // we can just simply import our DOM tree. + $this->elements = simplexml_import_dom($htmlDom); + } + } + if (!$this->elements) { + $this->fail(t('Parsed page successfully.'), t('Browser')); + } + + return $this->elements; + } + + /** + * Retrieves a Drupal path or an absolute path. + * + * @param $path + * Drupal path or URL to load into internal browser + * @param $options + * Options to be forwarded to the url generator. + * @param $headers + * An array containing additional HTTP request headers, each formatted as + * "name: value". + * + * @return + * The retrieved HTML string, also available as $this->drupalGetContent() + */ + protected function drupalGet($path, array $options = array(), array $headers = array()) { + $options['absolute'] = TRUE; + + // We re-using a CURL connection here. If that connection still has certain + // options set, it might change the GET into a POST. Make sure we clear out + // previous options. + $url = $this->container->get('url_generator')->generateFromPath($path, $options); + $out = $this->curlExec(array(CURLOPT_HTTPGET => TRUE, CURLOPT_URL => $url, CURLOPT_NOBODY => FALSE, CURLOPT_HTTPHEADER => $headers)); + // Ensure that any changes to variables in the other thread are picked up. + $this->refreshVariables(); + + // Replace original page output with new output from redirected page(s). + if ($new = $this->checkForMetaRefresh()) { + $out = $new; + } + + $verbose = 'GET request to: ' . $path . + '
Ending URL: ' . $this->getUrl(); + if ($this->dumpHeaders) { + $verbose .= '
Headers: 
' . check_plain(var_export(array_map('trim', $this->headers), TRUE)) . '
'; + } + $verbose .= '
' . $out; + + $this->verbose($verbose); + return $out; + } + + /** + * Retrieves a Drupal path or an absolute path and JSON decode the result. + * + * @param string $path + * Path to request AJAX from. + * @param array $options + * Array of options to pass to url(). + * @param array $headers + * Array of headers. Eg array('Accept: application/vnd.drupal-ajax'). + * + * @return array + * Decoded json. + * Requests a Drupal path in JSON format, and JSON decodes the response. + */ + protected function drupalGetJSON($path, array $options = array(), array $headers = array()) { + $headers[] = 'Accept: application/json'; + return drupal_json_decode($this->drupalGet($path, $options, $headers)); + } + + /** + * Requests a Drupal path in drupal_ajax format and JSON-decodes the response. + */ + protected function drupalGetAJAX($path, array $options = array(), array $headers = array()) { + $headers[] = 'Accept: application/vnd.drupal-ajax'; + return drupal_json_decode($this->drupalGet($path, $options, $headers)); + } + + /** + * Executes a form submission. + * + * It will be done as usual POST request with SimpleBrowser. + * + * @param $path + * Location of the post form. Either a Drupal path or an absolute path or + * NULL to post to the current page. For multi-stage forms you can set the + * path to NULL and have it post to the last received page. Example: + * + * @code + * // First step in form. + * $edit = array(...); + * $this->drupalPostForm('some_url', $edit, t('Save')); + * + * // Second step in form. + * $edit = array(...); + * $this->drupalPostForm(NULL, $edit, t('Save')); + * @endcode + * @param $edit + * Field data in an associative array. Changes the current input fields + * (where possible) to the values indicated. + * + * When working with form tests, the keys for an $edit element should match + * the 'name' parameter of the HTML of the form. For example, the 'body' + * field for a node has the following HTML: + * @code + * + * @endcode + * When testing this field using an $edit parameter, the code becomes: + * @code + * $edit["body[0][value]"] = 'My test value'; + * @endcode + * + * A checkbox can be set to TRUE to be checked and should be set to FALSE to + * be unchecked. Multiple select fields can be tested using 'name[]' and + * setting each of the desired values in an array: + * @code + * $edit = array(); + * $edit['name[]'] = array('value1', 'value2'); + * @endcode + * + * Note that when a form contains file upload fields, other + * fields cannot start with the '@' character. + * @param $submit + * Value of the submit button whose click is to be emulated. For example, + * t('Save'). The processing of the request depends on this value. For + * example, a form may have one button with the value t('Save') and another + * button with the value t('Delete'), and execute different code depending + * on which one is clicked. + * + * This function can also be called to emulate an Ajax submission. In this + * case, this value needs to be an array with the following keys: + * - path: A path to submit the form values to for Ajax-specific processing, + * which is likely different than the $path parameter used for retrieving + * the initial form. Defaults to 'system/ajax'. + * - triggering_element: If the value for the 'path' key is 'system/ajax' or + * another generic Ajax processing path, this needs to be set to the name + * of the element. If the name doesn't identify the element uniquely, then + * this should instead be an array with a single key/value pair, + * corresponding to the element name and value. The callback for the + * generic Ajax processing path uses this to find the #ajax information + * for the element, including which specific callback to use for + * processing the request. + * + * This can also be set to NULL in order to emulate an Internet Explorer + * submission of a form with a single text field, and pressing ENTER in that + * textfield: under these conditions, no button information is added to the + * POST data. + * @param $options + * Options to be forwarded to the url generator. + * @param $headers + * An array containing additional HTTP request headers, each formatted as + * "name: value". + * @param $form_html_id + * (optional) HTML ID of the form to be submitted. On some pages + * there are many identical forms, so just using the value of the submit + * button is not enough. For example: 'trigger-node-presave-assign-form'. + * Note that this is not the Drupal $form_id, but rather the HTML ID of the + * form, which is typically the same thing but with hyphens replacing the + * underscores. + * @param $extra_post + * (optional) A string of additional data to append to the POST submission. + * This can be used to add POST data for which there are no HTML fields, as + * is done by drupalPostAjaxForm(). This string is literally appended to the + * POST data, so it must already be urlencoded and contain a leading "&" + * (e.g., "&extra_var1=hello+world&extra_var2=you%26me"). + */ + protected function drupalPostForm($path, $edit, $submit, array $options = array(), array $headers = array(), $form_html_id = NULL, $extra_post = NULL) { + $submit_matches = FALSE; + $ajax = is_array($submit); + if (isset($path)) { + $this->drupalGet($path, $options); + } + if ($this->parse()) { + $edit_save = $edit; + // Let's iterate over all the forms. + $xpath = "//form"; + if (!empty($form_html_id)) { + $xpath .= "[@id='" . $form_html_id . "']"; + } + $forms = $this->xpath($xpath); + foreach ($forms as $form) { + // We try to set the fields of this form as specified in $edit. + $edit = $edit_save; + $post = array(); + $upload = array(); + $submit_matches = $this->handleForm($post, $edit, $upload, $ajax ? NULL : $submit, $form); + $action = isset($form['action']) ? $this->getAbsoluteUrl((string) $form['action']) : $this->getUrl(); + if ($ajax) { + $action = $this->getAbsoluteUrl(!empty($submit['path']) ? $submit['path'] : 'system/ajax'); + // Ajax callbacks verify the triggering element if necessary, so while + // we may eventually want extra code that verifies it in the + // handleForm() function, it's not currently a requirement. + $submit_matches = TRUE; + } + // We post only if we managed to handle every field in edit and the + // submit button matches. + if (!$edit && ($submit_matches || !isset($submit))) { + $post_array = $post; + if ($upload) { + foreach ($upload as $key => $file) { + $file = drupal_realpath($file); + if ($file && is_file($file)) { + // Use the new CurlFile class for file uploads when using PHP + // 5.5. + if (class_exists('CurlFile')) { + $post[$key] = curl_file_create($file); + } + else { + // @todo: Drop support for this when PHP 5.5 is required. + $post[$key] = '@' . $file; + } + } + } + } + else { + $post = $this->serializePostValues($post) . $extra_post; + } + $out = $this->curlExec(array(CURLOPT_URL => $action, CURLOPT_POST => TRUE, CURLOPT_POSTFIELDS => $post, CURLOPT_HTTPHEADER => $headers)); + // Ensure that any changes to variables in the other thread are picked + // up. + $this->refreshVariables(); + + // Replace original page output with new output from redirected + // page(s). + if ($new = $this->checkForMetaRefresh()) { + $out = $new; + } + + $verbose = 'POST request to: ' . $path; + $verbose .= '
Ending URL: ' . $this->getUrl(); + if ($this->dumpHeaders) { + $verbose .= '
Headers: 
' . check_plain(var_export(array_map('trim', $this->headers), TRUE)) . '
'; + } + $verbose .= '
Fields: ' . highlight_string('' . $out; + + $this->verbose($verbose); + return $out; + } + } + // We have not found a form which contained all fields of $edit. + foreach ($edit as $name => $value) { + $this->fail(t('Failed to set field @name to @value', array('@name' => $name, '@value' => $value))); + } + if (!$ajax && isset($submit)) { + $this->assertTrue($submit_matches, format_string('Found the @submit button', array('@submit' => $submit))); + } + $this->fail(format_string('Found the requested form fields at @path', array('@path' => $path))); + } + } + + /** + * Executes an Ajax form submission. + * + * This executes a POST as ajax.js does. The returned JSON data is used to + * update $this->content via drupalProcessAjaxResponse(). It also returns + * the array of AJAX commands received. + * + * @param $path + * Location of the form containing the Ajax enabled element to test. Can be + * either a Drupal path or an absolute path or NULL to use the current page. + * @param $edit + * Field data in an associative array. Changes the current input fields + * (where possible) to the values indicated. + * @param $triggering_element + * The name of the form element that is responsible for triggering the Ajax + * functionality to test. May be a string or, if the triggering element is + * a button, an associative array where the key is the name of the button + * and the value is the button label. i.e.) array('op' => t('Refresh')). + * @param $ajax_path + * (optional) Override the path set by the Ajax settings of the triggering + * element. In the absence of both the triggering element's Ajax path and + * $ajax_path 'system/ajax' will be used. + * @param $options + * (optional) Options to be forwarded to the url generator. + * @param $headers + * (optional) An array containing additional HTTP request headers, each + * formatted as "name: value". Forwarded to drupalPostForm(). + * @param $form_html_id + * (optional) HTML ID of the form to be submitted, use when there is more + * than one identical form on the same page and the value of the triggering + * element is not enough to identify the form. Note this is not the Drupal + * ID of the form but rather the HTML ID of the form. + * @param $ajax_settings + * (optional) An array of Ajax settings which if specified will be used in + * place of the Ajax settings of the triggering element. + * + * @return + * An array of Ajax commands. + * + * @see drupalPostForm() + * @see drupalProcessAjaxResponse() + * @see ajax.js + */ + protected function drupalPostAjaxForm($path, $edit, $triggering_element, $ajax_path = NULL, array $options = array(), array $headers = array(), $form_html_id = NULL, $ajax_settings = NULL) { + // Get the content of the initial page prior to calling drupalPostForm(), + // since drupalPostForm() replaces $this->content. + if (isset($path)) { + $this->drupalGet($path, $options); + } + $content = $this->content; + $drupal_settings = $this->drupalSettings; + + $headers[] = 'Accept: application/vnd.drupal-ajax'; + + // Get the Ajax settings bound to the triggering element. + if (!isset($ajax_settings)) { + if (is_array($triggering_element)) { + $xpath = '//*[@name="' . key($triggering_element) . '" and @value="' . current($triggering_element) . '"]'; + } + else { + $xpath = '//*[@name="' . $triggering_element . '"]'; + } + if (isset($form_html_id)) { + $xpath = '//form[@id="' . $form_html_id . '"]' . $xpath; + } + $element = $this->xpath($xpath); + $element_id = (string) $element[0]['id']; + $ajax_settings = $drupal_settings['ajax'][$element_id]; + } + + // Add extra information to the POST data as ajax.js does. + $extra_post = array(); + if (isset($ajax_settings['submit'])) { + foreach ($ajax_settings['submit'] as $key => $value) { + $extra_post[$key] = $value; + } + } + $ajax_html_ids = array(); + foreach ($this->xpath('//*[@id]') as $element) { + $ajax_html_ids[] = (string) $element['id']; + } + if (!empty($ajax_html_ids)) { + $extra_post['ajax_html_ids'] = implode(' ', $ajax_html_ids); + } + $extra_post += $this->getAjaxPageStatePostData(); + // Now serialize all the $extra_post values, and prepend it with an '&'. + $extra_post = '&' . $this->serializePostValues($extra_post); + + // Unless a particular path is specified, use the one specified by the + // Ajax settings, or else 'system/ajax'. + if (!isset($ajax_path)) { + $ajax_path = isset($ajax_settings['url']) ? $ajax_settings['url'] : 'system/ajax'; + } + + // Submit the POST request. + $return = drupal_json_decode($this->drupalPostForm(NULL, $edit, array('path' => $ajax_path, 'triggering_element' => $triggering_element), $options, $headers, $form_html_id, $extra_post)); + + // Change the page content by applying the returned commands. + if (!empty($ajax_settings) && !empty($return)) { + $this->drupalProcessAjaxResponse($content, $return, $ajax_settings, $drupal_settings); + } + + return $return; + } + + /** + * Processes an AJAX response into current content. + * + * This processes the AJAX response as ajax.js does. It uses the response's + * JSON data, an array of commands, to update $this->content using equivalent + * DOM manipulation as is used by ajax.js. + * It does not apply custom AJAX commands though, because emulation is only + * implemented for the AJAX commands that ship with Drupal core. + * + * @param string $content + * The current HTML content. + * @param array $ajax_response + * An array of AJAX commands. + * @param array $ajax_settings + * An array of AJAX settings which will be used to process the response. + * @param array $drupal_settings + * An array of settings to update the value of drupalSettings for the + * currently-loaded page. + * + * @see drupalPostAjaxForm() + * @see ajax.js + */ + protected function drupalProcessAjaxResponse($content, array $ajax_response, array $ajax_settings, array $drupal_settings) { + + // ajax.js applies some defaults to the settings object, so do the same + // for what's used by this function. + $ajax_settings += array( + 'method' => 'replaceWith', + ); + // DOM can load HTML soup. But, HTML soup can throw warnings, suppress + // them. + $dom = new \DOMDocument(); + @$dom->loadHTML($content); + // XPath allows for finding wrapper nodes better than DOM does. + $xpath = new \DOMXPath($dom); + foreach ($ajax_response as $command) { + switch ($command['command']) { + case 'settings': + $drupal_settings = drupal_merge_js_settings(array($drupal_settings, $command['settings'])); + break; + + case 'insert': + $wrapperNode = NULL; + // When a command doesn't specify a selector, use the + // #ajax['wrapper'] which is always an HTML ID. + if (!isset($command['selector'])) { + $wrapperNode = $xpath->query('//*[@id="' . $ajax_settings['wrapper'] . '"]')->item(0); + } + // @todo Ajax commands can target any jQuery selector, but these are + // hard to fully emulate with XPath. For now, just handle 'head' + // and 'body', since these are used by ajax_render(). + elseif (in_array($command['selector'], array('head', 'body'))) { + $wrapperNode = $xpath->query('//' . $command['selector'])->item(0); + } + if ($wrapperNode) { + // ajax.js adds an enclosing DIV to work around a Safari bug. + $newDom = new \DOMDocument(); + @$newDom->loadHTML('
' . $command['data'] . '
'); + $newNode = $dom->importNode($newDom->documentElement->firstChild->firstChild, TRUE); + $method = isset($command['method']) ? $command['method'] : $ajax_settings['method']; + // The "method" is a jQuery DOM manipulation function. Emulate + // each one using PHP's DOMNode API. + switch ($method) { + case 'replaceWith': + $wrapperNode->parentNode->replaceChild($newNode, $wrapperNode); + break; + case 'append': + $wrapperNode->appendChild($newNode); + break; + case 'prepend': + // If no firstChild, insertBefore() falls back to + // appendChild(). + $wrapperNode->insertBefore($newNode, $wrapperNode->firstChild); + break; + case 'before': + $wrapperNode->parentNode->insertBefore($newNode, $wrapperNode); + break; + case 'after': + // If no nextSibling, insertBefore() falls back to + // appendChild(). + $wrapperNode->parentNode->insertBefore($newNode, $wrapperNode->nextSibling); + break; + case 'html': + foreach ($wrapperNode->childNodes as $childNode) { + $wrapperNode->removeChild($childNode); + } + $wrapperNode->appendChild($newNode); + break; + } + } + break; + + // @todo Add suitable implementations for these commands in order to + // have full test coverage of what ajax.js can do. + case 'remove': + break; + case 'changed': + break; + case 'css': + break; + case 'data': + break; + case 'restripe': + break; + case 'add_css': + break; + } + } + $content = $dom->saveHTML(); + $this->drupalSetContent($content); + $this->drupalSetSettings($drupal_settings); + } + + /** + * Perform a POST HTTP request. + * + * @param string $path + * Drupal path where the request should be POSTed to. Will be transformed + * into an absolute path automatically. + * @param string $accept + * The value for the "Accept" header. Usually either 'application/json' or + * 'application/vnd.drupal-ajax'. + * @param array $post + * The POST data. When making a 'application/vnd.drupal-ajax' request, the + * Ajax page state data should be included. Use getAjaxPageStatePostData() + * for that. + * @param array $options + * (optional) Options to be forwarded to the url generator. The 'absolute' + * option will automatically be enabled. + * + * @return + * The content returned from the call to curl_exec(). + * + * @see WebTestBase::getAjaxPageStatePostData() + * @see WebTestBase::curlExec() + * @see url() + */ + protected function drupalPost($path, $accept, array $post, $options = array()) { + return $this->curlExec(array( + CURLOPT_URL => url($path, $options + array('absolute' => TRUE)), + CURLOPT_POST => TRUE, + CURLOPT_POSTFIELDS => $this->serializePostValues($post), + CURLOPT_HTTPHEADER => array( + 'Accept: ' . $accept, + 'Content-Type: application/x-www-form-urlencoded', + ), + )); + } + + /** + * Get the Ajax page state from drupalSettings and prepare it for POSTing. + * + * @return array + * The Ajax page state POST data. + */ + protected function getAjaxPageStatePostData() { + $post = array(); + $drupal_settings = $this->drupalSettings; + if (isset($drupal_settings['ajaxPageState'])) { + $post['ajax_page_state[theme]'] = $drupal_settings['ajaxPageState']['theme']; + $post['ajax_page_state[theme_token]'] = $drupal_settings['ajaxPageState']['theme_token']; + foreach ($drupal_settings['ajaxPageState']['css'] as $key => $value) { + $post["ajax_page_state[css][$key]"] = 1; + } + foreach ($drupal_settings['ajaxPageState']['js'] as $key => $value) { + $post["ajax_page_state[js][$key]"] = 1; + } + } + return $post; + } + + /** + * Serialize POST HTTP request values. + * + * Encode according to application/x-www-form-urlencoded. Both names and + * values needs to be urlencoded, according to + * http://www.w3.org/TR/html4/interact/forms.html#h-17.13.4.1 + * + * @param array $post + * The array of values to be POSTed. + * + * @return string + * The serialized result. + */ + protected function serializePostValues($post = array()) { + foreach ($post as $key => $value) { + $post[$key] = urlencode($key) . '=' . urlencode($value); + } + return implode('&', $post); + } + + /** + * Runs cron in the Drupal installed by Simpletest. + */ + protected function cronRun() { + $this->drupalGet('cron/' . \Drupal::state()->get('system.cron_key')); + } + + /** + * Checks for meta refresh tag and if found call drupalGet() recursively. + * + * This function looks for the http-equiv attribute to be set to "Refresh" and + * is case-sensitive. + * + * @return + * Either the new page content or FALSE. + */ + protected function checkForMetaRefresh() { + if (strpos($this->drupalGetContent(), 'parse()) { + $refresh = $this->xpath('//meta[@http-equiv="Refresh"]'); + if (!empty($refresh)) { + // Parse the content attribute of the meta tag for the format: + // "[delay]: URL=[page_to_redirect_to]". + if (preg_match('/\d+;\s*URL=(?.*)/i', $refresh[0]['content'], $match)) { + return $this->drupalGet($this->getAbsoluteUrl(decode_entities($match['url']))); + } + } + } + return FALSE; + } + + /** + * Retrieves only the headers for a Drupal path or an absolute path. + * + * @param $path + * Drupal path or URL to load into internal browser + * @param $options + * Options to be forwarded to the url generator. + * @param $headers + * An array containing additional HTTP request headers, each formatted as + * "name: value". + * + * @return + * The retrieved headers, also available as $this->drupalGetContent() + */ + protected function drupalHead($path, array $options = array(), array $headers = array()) { + $options['absolute'] = TRUE; + $url = $this->container->get('url_generator')->generateFromPath($path, $options); + $out = $this->curlExec(array(CURLOPT_NOBODY => TRUE, CURLOPT_URL => $url, CURLOPT_HTTPHEADER => $headers)); + // Ensure that any changes to variables in the other thread are picked up. + $this->refreshVariables(); + + if ($this->dumpHeaders) { + $this->verbose('GET request to: ' . $path . + '
Ending URL: ' . $this->getUrl() . + '
Headers: 
' . check_plain(var_export(array_map('trim', $this->headers), TRUE)) . '
'); + } + + return $out; + } + + /** + * Handles form input related to drupalPostForm(). + * + * Ensure that the specified fields exist and attempt to create POST data in + * the correct manner for the particular field type. + * + * @param $post + * Reference to array of post values. + * @param $edit + * Reference to array of edit values to be checked against the form. + * @param $submit + * Form submit button value. + * @param $form + * Array of form elements. + * + * @return + * Submit value matches a valid submit input in the form. + */ + protected function handleForm(&$post, &$edit, &$upload, $submit, $form) { + // Retrieve the form elements. + $elements = $form->xpath('.//input[not(@disabled)]|.//textarea[not(@disabled)]|.//select[not(@disabled)]'); + $submit_matches = FALSE; + foreach ($elements as $element) { + // SimpleXML objects need string casting all the time. + $name = (string) $element['name']; + // This can either be the type of or the name of the tag itself + // for