File

modules/simpletest/drupal_web_test_case.php
View source
  1. <?php
  2. /**
  3. * Global variable that holds information about the tests being run.
  4. *
  5. * An array, with the following keys:
  6. * - 'test_run_id': the ID of the test being run, in the form 'simpletest_%"
  7. * - 'in_child_site': TRUE if the current request is a cURL request from
  8. * the parent site.
  9. *
  10. * @var array
  11. */
  12. global $drupal_test_info;
  13. /**
  14. * Base class for Drupal tests.
  15. *
  16. * Do not extend this class, use one of the subclasses in this file.
  17. */
  18. abstract class DrupalTestCase {
  19. /**
  20. * The test run ID.
  21. *
  22. * @var string
  23. */
  24. protected $testId;
  25. /**
  26. * The database prefix of this test run.
  27. *
  28. * @var string
  29. */
  30. protected $databasePrefix = NULL;
  31. /**
  32. * The original file directory, before it was changed for testing purposes.
  33. *
  34. * @var string
  35. */
  36. protected $originalFileDirectory = NULL;
  37. /**
  38. * Time limit for the test.
  39. */
  40. protected $timeLimit = 500;
  41. /**
  42. * Current results of this test case.
  43. *
  44. * @var Array
  45. */
  46. public $results = array(
  47. '#pass' => 0,
  48. '#fail' => 0,
  49. '#exception' => 0,
  50. '#debug' => 0,
  51. );
  52. /**
  53. * Assertions thrown in that test case.
  54. *
  55. * @var Array
  56. */
  57. protected $assertions = array();
  58. /**
  59. * This class is skipped when looking for the source of an assertion.
  60. *
  61. * When displaying which function an assert comes from, it's not too useful
  62. * to see "drupalWebTestCase->drupalLogin()', we would like to see the test
  63. * that called it. So we need to skip the classes defining these helper
  64. * methods.
  65. */
  66. protected $skipClasses = array(__CLASS__ => TRUE);
  67. /**
  68. * Flag to indicate whether the test has been set up.
  69. *
  70. * The setUp() method isolates the test from the parent Drupal site by
  71. * creating a random prefix for the database and setting up a clean file
  72. * storage directory. The tearDown() method then cleans up this test
  73. * environment. We must ensure that setUp() has been run. Otherwise,
  74. * tearDown() will act on the parent Drupal site rather than the test
  75. * environment, destroying live data.
  76. */
  77. protected $setup = FALSE;
  78. protected $setupDatabasePrefix = FALSE;
  79. protected $setupEnvironment = FALSE;
  80. /**
  81. * Constructor for DrupalTestCase.
  82. *
  83. * @param $test_id
  84. * Tests with the same id are reported together.
  85. */
  86. public function __construct($test_id = NULL) {
  87. $this->testId = $test_id;
  88. }
  89. /**
  90. * Internal helper: stores the assert.
  91. *
  92. * @param $status
  93. * Can be 'pass', 'fail', 'exception'.
  94. * TRUE is a synonym for 'pass', FALSE for 'fail'.
  95. * @param $message
  96. * The message string.
  97. * @param $group
  98. * Which group this assert belongs to.
  99. * @param $caller
  100. * By default, the assert comes from a function whose name starts with
  101. * 'test'. Instead, you can specify where this assert originates from
  102. * by passing in an associative array as $caller. Key 'file' is
  103. * the name of the source file, 'line' is the line number and 'function'
  104. * is the caller function itself.
  105. */
  106. protected function assert($status, $message = '', $group = 'Other', array $caller = NULL) {
  107. // Convert boolean status to string status.
  108. if (is_bool($status)) {
  109. $status = $status ? 'pass' : 'fail';
  110. }
  111. // Increment summary result counter.
  112. $this->results['#' . $status]++;
  113. // Get the function information about the call to the assertion method.
  114. if (!$caller) {
  115. $caller = $this->getAssertionCall();
  116. }
  117. // Creation assertion array that can be displayed while tests are running.
  118. $this->assertions[] = $assertion = array(
  119. 'test_id' => $this->testId,
  120. 'test_class' => get_class($this),
  121. 'status' => $status,
  122. 'message' => $message,
  123. 'message_group' => $group,
  124. 'function' => $caller['function'],
  125. 'line' => $caller['line'],
  126. 'file' => $caller['file'],
  127. );
  128. // Store assertion for display after the test has completed.
  129. self::getDatabaseConnection()
  130. ->insert('simpletest')
  131. ->fields($assertion)
  132. ->execute();
  133. // We do not use a ternary operator here to allow a breakpoint on
  134. // test failure.
  135. if ($status == 'pass') {
  136. return TRUE;
  137. }
  138. else {
  139. return FALSE;
  140. }
  141. }
  142. /**
  143. * Returns the database connection to the site running Simpletest.
  144. *
  145. * @return DatabaseConnection
  146. * The database connection to use for inserting assertions.
  147. */
  148. public static function getDatabaseConnection() {
  149. try {
  150. $connection = Database::getConnection('default', 'simpletest_original_default');
  151. }
  152. catch (DatabaseConnectionNotDefinedException $e) {
  153. // If the test was not set up, the simpletest_original_default
  154. // connection does not exist.
  155. $connection = Database::getConnection('default', 'default');
  156. }
  157. return $connection;
  158. }
  159. /**
  160. * Store an assertion from outside the testing context.
  161. *
  162. * This is useful for inserting assertions that can only be recorded after
  163. * the test case has been destroyed, such as PHP fatal errors. The caller
  164. * information is not automatically gathered since the caller is most likely
  165. * inserting the assertion on behalf of other code. In all other respects
  166. * the method behaves just like DrupalTestCase::assert() in terms of storing
  167. * the assertion.
  168. *
  169. * @return
  170. * Message ID of the stored assertion.
  171. *
  172. * @see DrupalTestCase::assert()
  173. * @see DrupalTestCase::deleteAssert()
  174. */
  175. public static function insertAssert($test_id, $test_class, $status, $message = '', $group = 'Other', array $caller = array()) {
  176. // Convert boolean status to string status.
  177. if (is_bool($status)) {
  178. $status = $status ? 'pass' : 'fail';
  179. }
  180. $caller += array(
  181. 'function' => t('Unknown'),
  182. 'line' => 0,
  183. 'file' => t('Unknown'),
  184. );
  185. $assertion = array(
  186. 'test_id' => $test_id,
  187. 'test_class' => $test_class,
  188. 'status' => $status,
  189. 'message' => $message,
  190. 'message_group' => $group,
  191. 'function' => $caller['function'],
  192. 'line' => $caller['line'],
  193. 'file' => $caller['file'],
  194. );
  195. return self::getDatabaseConnection()
  196. ->insert('simpletest')
  197. ->fields($assertion)
  198. ->execute();
  199. }
  200. /**
  201. * Delete an assertion record by message ID.
  202. *
  203. * @param $message_id
  204. * Message ID of the assertion to delete.
  205. * @return
  206. * TRUE if the assertion was deleted, FALSE otherwise.
  207. *
  208. * @see DrupalTestCase::insertAssert()
  209. */
  210. public static function deleteAssert($message_id) {
  211. return (bool) self::getDatabaseConnection()
  212. ->delete('simpletest')
  213. ->condition('message_id', $message_id)
  214. ->execute();
  215. }
  216. /**
  217. * Cycles through backtrace until the first non-assertion method is found.
  218. *
  219. * @return
  220. * Array representing the true caller.
  221. */
  222. protected function getAssertionCall() {
  223. $backtrace = debug_backtrace();
  224. // The first element is the call. The second element is the caller.
  225. // We skip calls that occurred in one of the methods of our base classes
  226. // or in an assertion function.
  227. while (($caller = $backtrace[1]) &&
  228. ((isset($caller['class']) && isset($this->skipClasses[$caller['class']])) ||
  229. substr($caller['function'], 0, 6) == 'assert')) {
  230. // We remove that call.
  231. array_shift($backtrace);
  232. }
  233. return _drupal_get_last_caller($backtrace);
  234. }
  235. /**
  236. * Check to see if a value is not false (not an empty string, 0, NULL, or FALSE).
  237. *
  238. * @param $value
  239. * The value on which the assertion is to be done.
  240. * @param $message
  241. * The message to display along with the assertion.
  242. * @param $group
  243. * The type of assertion - examples are "Browser", "PHP".
  244. * @return
  245. * TRUE if the assertion succeeded, FALSE otherwise.
  246. */
  247. protected function assertTrue($value, $message = '', $group = 'Other') {
  248. return $this->assert((bool) $value, $message ? $message : t('Value @value is TRUE.', array('@value' => var_export($value, TRUE))), $group);
  249. }
  250. /**
  251. * Check to see if a value is false (an empty string, 0, NULL, or FALSE).
  252. *
  253. * @param $value
  254. * The value on which the assertion is to be done.
  255. * @param $message
  256. * The message to display along with the assertion.
  257. * @param $group
  258. * The type of assertion - examples are "Browser", "PHP".
  259. * @return
  260. * TRUE if the assertion succeeded, FALSE otherwise.
  261. */
  262. protected function assertFalse($value, $message = '', $group = 'Other') {
  263. return $this->assert(!$value, $message ? $message : t('Value @value is FALSE.', array('@value' => var_export($value, TRUE))), $group);
  264. }
  265. /**
  266. * Check to see if a value is NULL.
  267. *
  268. * @param $value
  269. * The value on which the assertion is to be done.
  270. * @param $message
  271. * The message to display along with the assertion.
  272. * @param $group
  273. * The type of assertion - examples are "Browser", "PHP".
  274. * @return
  275. * TRUE if the assertion succeeded, FALSE otherwise.
  276. */
  277. protected function assertNull($value, $message = '', $group = 'Other') {
  278. return $this->assert(!isset($value), $message ? $message : t('Value @value is NULL.', array('@value' => var_export($value, TRUE))), $group);
  279. }
  280. /**
  281. * Check to see if a value is not NULL.
  282. *
  283. * @param $value
  284. * The value on which the assertion is to be done.
  285. * @param $message
  286. * The message to display along with the assertion.
  287. * @param $group
  288. * The type of assertion - examples are "Browser", "PHP".
  289. * @return
  290. * TRUE if the assertion succeeded, FALSE otherwise.
  291. */
  292. protected function assertNotNull($value, $message = '', $group = 'Other') {
  293. return $this->assert(isset($value), $message ? $message : t('Value @value is not NULL.', array('@value' => var_export($value, TRUE))), $group);
  294. }
  295. /**
  296. * Check to see if two values are equal.
  297. *
  298. * @param $first
  299. * The first value to check.
  300. * @param $second
  301. * The second value to check.
  302. * @param $message
  303. * The message to display along with the assertion.
  304. * @param $group
  305. * The type of assertion - examples are "Browser", "PHP".
  306. * @return
  307. * TRUE if the assertion succeeded, FALSE otherwise.
  308. */
  309. protected function assertEqual($first, $second, $message = '', $group = 'Other') {
  310. 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);
  311. }
  312. /**
  313. * Check to see if two values are not equal.
  314. *
  315. * @param $first
  316. * The first value to check.
  317. * @param $second
  318. * The second value to check.
  319. * @param $message
  320. * The message to display along with the assertion.
  321. * @param $group
  322. * The type of assertion - examples are "Browser", "PHP".
  323. * @return
  324. * TRUE if the assertion succeeded, FALSE otherwise.
  325. */
  326. protected function assertNotEqual($first, $second, $message = '', $group = 'Other') {
  327. 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);
  328. }
  329. /**
  330. * Check to see if two values are identical.
  331. *
  332. * @param $first
  333. * The first value to check.
  334. * @param $second
  335. * The second value to check.
  336. * @param $message
  337. * The message to display along with the assertion.
  338. * @param $group
  339. * The type of assertion - examples are "Browser", "PHP".
  340. * @return
  341. * TRUE if the assertion succeeded, FALSE otherwise.
  342. */
  343. protected function assertIdentical($first, $second, $message = '', $group = 'Other') {
  344. 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);
  345. }
  346. /**
  347. * Check to see if two values are not identical.
  348. *
  349. * @param $first
  350. * The first value to check.
  351. * @param $second
  352. * The second value to check.
  353. * @param $message
  354. * The message to display along with the assertion.
  355. * @param $group
  356. * The type of assertion - examples are "Browser", "PHP".
  357. * @return
  358. * TRUE if the assertion succeeded, FALSE otherwise.
  359. */
  360. protected function assertNotIdentical($first, $second, $message = '', $group = 'Other') {
  361. 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);
  362. }
  363. /**
  364. * Fire an assertion that is always positive.
  365. *
  366. * @param $message
  367. * The message to display along with the assertion.
  368. * @param $group
  369. * The type of assertion - examples are "Browser", "PHP".
  370. * @return
  371. * TRUE.
  372. */
  373. protected function pass($message = NULL, $group = 'Other') {
  374. return $this->assert(TRUE, $message, $group);
  375. }
  376. /**
  377. * Fire an assertion that is always negative.
  378. *
  379. * @param $message
  380. * The message to display along with the assertion.
  381. * @param $group
  382. * The type of assertion - examples are "Browser", "PHP".
  383. * @return
  384. * FALSE.
  385. */
  386. protected function fail($message = NULL, $group = 'Other') {
  387. return $this->assert(FALSE, $message, $group);
  388. }
  389. /**
  390. * Fire an error assertion.
  391. *
  392. * @param $message
  393. * The message to display along with the assertion.
  394. * @param $group
  395. * The type of assertion - examples are "Browser", "PHP".
  396. * @param $caller
  397. * The caller of the error.
  398. * @return
  399. * FALSE.
  400. */
  401. protected function error($message = '', $group = 'Other', array $caller = NULL) {
  402. if ($group == 'User notice') {
  403. // Since 'User notice' is set by trigger_error() which is used for debug
  404. // set the message to a status of 'debug'.
  405. return $this->assert('debug', $message, 'Debug', $caller);
  406. }
  407. return $this->assert('exception', $message, $group, $caller);
  408. }
  409. /**
  410. * Logs a verbose message in a text file.
  411. *
  412. * The link to the verbose message will be placed in the test results as a
  413. * passing assertion with the text '[verbose message]'.
  414. *
  415. * @param $message
  416. * The verbose message to be stored.
  417. *
  418. * @see simpletest_verbose()
  419. */
  420. protected function verbose($message) {
  421. if ($id = simpletest_verbose($message)) {
  422. $class_safe = str_replace('\\', '_', get_class($this));
  423. $url = file_create_url($this->originalFileDirectory . '/simpletest/verbose/' . $class_safe . '-' . $id . '.html');
  424. $this->error(l(t('Verbose message'), $url, array('attributes' => array('target' => '_blank'))), 'User notice');
  425. }
  426. }
  427. /**
  428. * Run all tests in this class.
  429. *
  430. * Regardless of whether $methods are passed or not, only method names
  431. * starting with "test" are executed.
  432. *
  433. * @param $methods
  434. * (optional) A list of method names in the test case class to run; e.g.,
  435. * array('testFoo', 'testBar'). By default, all methods of the class are
  436. * taken into account, but it can be useful to only run a few selected test
  437. * methods during debugging.
  438. */
  439. public function run(array $methods = array()) {
  440. // Initialize verbose debugging.
  441. $class = get_class($this);
  442. simpletest_verbose(NULL, variable_get('file_public_path', conf_path() . '/files'), str_replace('\\', '_', $class));
  443. // HTTP auth settings (<username>:<password>) for the simpletest browser
  444. // when sending requests to the test site.
  445. $this->httpauth_method = variable_get('simpletest_httpauth_method', CURLAUTH_BASIC);
  446. $username = variable_get('simpletest_httpauth_username', NULL);
  447. $password = variable_get('simpletest_httpauth_password', NULL);
  448. if ($username && $password) {
  449. $this->httpauth_credentials = $username . ':' . $password;
  450. }
  451. set_error_handler(array($this, 'errorHandler'));
  452. // Iterate through all the methods in this class, unless a specific list of
  453. // methods to run was passed.
  454. $class_methods = get_class_methods($class);
  455. if ($methods) {
  456. $class_methods = array_intersect($class_methods, $methods);
  457. }
  458. foreach ($class_methods as $method) {
  459. // If the current method starts with "test", run it - it's a test.
  460. if (strtolower(substr($method, 0, 4)) == 'test') {
  461. // Insert a fail record. This will be deleted on completion to ensure
  462. // that testing completed.
  463. $method_info = new ReflectionMethod($class, $method);
  464. $caller = array(
  465. 'file' => $method_info->getFileName(),
  466. 'line' => $method_info->getStartLine(),
  467. 'function' => $class . '->' . $method . '()',
  468. );
  469. $completion_check_id = DrupalTestCase::insertAssert($this->testId, $class, FALSE, t('The test did not complete due to a fatal error.'), 'Completion check', $caller);
  470. $this->setUp();
  471. if ($this->setup) {
  472. try {
  473. $this->$method();
  474. // Finish up.
  475. }
  476. catch (Exception $e) {
  477. $this->exceptionHandler($e);
  478. }
  479. $this->tearDown();
  480. }
  481. else {
  482. $this->fail(t("The test cannot be executed because it has not been set up properly."));
  483. }
  484. // Remove the completion check record.
  485. DrupalTestCase::deleteAssert($completion_check_id);
  486. }
  487. }
  488. // Clear out the error messages and restore error handler.
  489. drupal_get_messages();
  490. restore_error_handler();
  491. }
  492. /**
  493. * Handle errors during test runs.
  494. *
  495. * Because this is registered in set_error_handler(), it has to be public.
  496. * @see set_error_handler
  497. */
  498. public function errorHandler($severity, $message, $file = NULL, $line = NULL) {
  499. if ($severity & error_reporting()) {
  500. $error_map = array(
  501. E_STRICT => 'Run-time notice',
  502. E_WARNING => 'Warning',
  503. E_NOTICE => 'Notice',
  504. E_CORE_ERROR => 'Core error',
  505. E_CORE_WARNING => 'Core warning',
  506. E_USER_ERROR => 'User error',
  507. E_USER_WARNING => 'User warning',
  508. E_USER_NOTICE => 'User notice',
  509. E_RECOVERABLE_ERROR => 'Recoverable error',
  510. );
  511. // PHP 5.3 adds new error logging constants. Add these conditionally for
  512. // backwards compatibility with PHP 5.2.
  513. if (defined('E_DEPRECATED')) {
  514. $error_map += array(
  515. E_DEPRECATED => 'Deprecated',
  516. E_USER_DEPRECATED => 'User deprecated',
  517. );
  518. }
  519. $backtrace = debug_backtrace();
  520. $this->error($message, $error_map[$severity], _drupal_get_last_caller($backtrace));
  521. }
  522. return TRUE;
  523. }
  524. /**
  525. * Handle exceptions.
  526. *
  527. * @see set_exception_handler
  528. */
  529. protected function exceptionHandler($exception) {
  530. $backtrace = $exception->getTrace();
  531. // Push on top of the backtrace the call that generated the exception.
  532. array_unshift($backtrace, array(
  533. 'line' => $exception->getLine(),
  534. 'file' => $exception->getFile(),
  535. ));
  536. require_once DRUPAL_ROOT . '/includes/errors.inc';
  537. // The exception message is run through check_plain() by _drupal_decode_exception().
  538. $this->error(t('%type: !message in %function (line %line of %file).', _drupal_decode_exception($exception)), 'Uncaught exception', _drupal_get_last_caller($backtrace));
  539. }
  540. /**
  541. * Generates a random string of ASCII characters of codes 32 to 126.
  542. *
  543. * The generated string includes alpha-numeric characters and common
  544. * miscellaneous characters. Use this method when testing general input
  545. * where the content is not restricted.
  546. *
  547. * Do not use this method when special characters are not possible (e.g., in
  548. * machine or file names that have already been validated); instead,
  549. * use DrupalWebTestCase::randomName().
  550. *
  551. * @param $length
  552. * Length of random string to generate.
  553. *
  554. * @return
  555. * Randomly generated string.
  556. *
  557. * @see DrupalWebTestCase::randomName()
  558. */
  559. public static function randomString($length = 8) {
  560. $str = '';
  561. for ($i = 0; $i < $length; $i++) {
  562. $str .= chr(mt_rand(32, 126));
  563. }
  564. return $str;
  565. }
  566. /**
  567. * Generates a random string containing letters and numbers.
  568. *
  569. * The string will always start with a letter. The letters may be upper or
  570. * lower case. This method is better for restricted inputs that do not
  571. * accept certain characters. For example, when testing input fields that
  572. * require machine readable values (i.e. without spaces and non-standard
  573. * characters) this method is best.
  574. *
  575. * Do not use this method when testing unvalidated user input. Instead, use
  576. * DrupalWebTestCase::randomString().
  577. *
  578. * @param $length
  579. * Length of random string to generate.
  580. *
  581. * @return
  582. * Randomly generated string.
  583. *
  584. * @see DrupalWebTestCase::randomString()
  585. */
  586. public static function randomName($length = 8) {
  587. $values = array_merge(range(65, 90), range(97, 122), range(48, 57));
  588. $max = count($values) - 1;
  589. $str = chr(mt_rand(97, 122));
  590. for ($i = 1; $i < $length; $i++) {
  591. $str .= chr($values[mt_rand(0, $max)]);
  592. }
  593. return $str;
  594. }
  595. /**
  596. * Converts a list of possible parameters into a stack of permutations.
  597. *
  598. * Takes a list of parameters containing possible values, and converts all of
  599. * them into a list of items containing every possible permutation.
  600. *
  601. * Example:
  602. * @code
  603. * $parameters = array(
  604. * 'one' => array(0, 1),
  605. * 'two' => array(2, 3),
  606. * );
  607. * $permutations = DrupalTestCase::generatePermutations($parameters)
  608. * // Result:
  609. * $permutations == array(
  610. * array('one' => 0, 'two' => 2),
  611. * array('one' => 1, 'two' => 2),
  612. * array('one' => 0, 'two' => 3),
  613. * array('one' => 1, 'two' => 3),
  614. * )
  615. * @endcode
  616. *
  617. * @param $parameters
  618. * An associative array of parameters, keyed by parameter name, and whose
  619. * values are arrays of parameter values.
  620. *
  621. * @return
  622. * A list of permutations, which is an array of arrays. Each inner array
  623. * contains the full list of parameters that have been passed, but with a
  624. * single value only.
  625. */
  626. public static function generatePermutations($parameters) {
  627. $all_permutations = array(array());
  628. foreach ($parameters as $parameter => $values) {
  629. $new_permutations = array();
  630. // Iterate over all values of the parameter.
  631. foreach ($values as $value) {
  632. // Iterate over all existing permutations.
  633. foreach ($all_permutations as $permutation) {
  634. // Add the new parameter value to existing permutations.
  635. $new_permutations[] = $permutation + array($parameter => $value);
  636. }
  637. }
  638. // Replace the old permutations with the new permutations.
  639. $all_permutations = $new_permutations;
  640. }
  641. return $all_permutations;
  642. }
  643. }
  644. /**
  645. * Test case for Drupal unit tests.
  646. *
  647. * These tests can not access the database nor files. Calling any Drupal
  648. * function that needs the database will throw exceptions. These include
  649. * watchdog(), module_implements(), module_invoke_all() etc.
  650. */
  651. class DrupalUnitTestCase extends DrupalTestCase {
  652. /**
  653. * Constructor for DrupalUnitTestCase.
  654. */
  655. function __construct($test_id = NULL) {
  656. parent::__construct($test_id);
  657. $this->skipClasses[__CLASS__] = TRUE;
  658. }
  659. /**
  660. * Sets up unit test environment.
  661. *
  662. * Unlike DrupalWebTestCase::setUp(), DrupalUnitTestCase::setUp() does not
  663. * install modules because tests are performed without accessing the database.
  664. * Any required files must be explicitly included by the child class setUp()
  665. * method.
  666. */
  667. protected function setUp() {
  668. global $conf;
  669. // Store necessary current values before switching to the test environment.
  670. $this->originalFileDirectory = variable_get('file_public_path', conf_path() . '/files');
  671. // Reset all statics so that test is performed with a clean environment.
  672. drupal_static_reset();
  673. // Generate temporary prefixed database to ensure that tests have a clean starting point.
  674. $this->databasePrefix = Database::getConnection()->prefixTables('{simpletest' . mt_rand(1000, 1000000) . '}');
  675. // Create test directory.
  676. $public_files_directory = $this->originalFileDirectory . '/simpletest/' . substr($this->databasePrefix, 10);
  677. file_prepare_directory($public_files_directory, FILE_CREATE_DIRECTORY | FILE_MODIFY_PERMISSIONS);
  678. $conf['file_public_path'] = $public_files_directory;
  679. // Clone the current connection and replace the current prefix.
  680. $connection_info = Database::getConnectionInfo('default');
  681. Database::renameConnection('default', 'simpletest_original_default');
  682. foreach ($connection_info as $target => $value) {
  683. $connection_info[$target]['prefix'] = array(
  684. 'default' => $value['prefix']['default'] . $this->databasePrefix,
  685. );
  686. }
  687. Database::addConnectionInfo('default', 'default', $connection_info['default']);
  688. // Set user agent to be consistent with web test case.
  689. $_SERVER['HTTP_USER_AGENT'] = $this->databasePrefix;
  690. // If locale is enabled then t() will try to access the database and
  691. // subsequently will fail as the database is not accessible.
  692. $module_list = module_list();
  693. if (isset($module_list['locale'])) {
  694. // Transform the list into the format expected as input to module_list().
  695. foreach ($module_list as &$module) {
  696. $module = array('filename' => drupal_get_filename('module', $module));
  697. }
  698. $this->originalModuleList = $module_list;
  699. unset($module_list['locale']);
  700. module_list(TRUE, FALSE, FALSE, $module_list);
  701. }
  702. $this->setup = TRUE;
  703. }
  704. protected function tearDown() {
  705. global $conf;
  706. // Get back to the original connection.
  707. Database::removeConnection('default');
  708. Database::renameConnection('simpletest_original_default', 'default');
  709. $conf['file_public_path'] = $this->originalFileDirectory;
  710. // Restore modules if necessary.
  711. if (isset($this->originalModuleList)) {
  712. module_list(TRUE, FALSE, FALSE, $this->originalModuleList);
  713. }
  714. }
  715. }
  716. /**
  717. * Test case for typical Drupal tests.
  718. */
  719. class DrupalWebTestCase extends DrupalTestCase {
  720. /**
  721. * The profile to install as a basis for testing.
  722. *
  723. * @var string
  724. */
  725. protected $profile = 'standard';
  726. /**
  727. * The URL currently loaded in the internal browser.
  728. *
  729. * @var string
  730. */
  731. protected $url;
  732. /**
  733. * The handle of the current cURL connection.
  734. *
  735. * @var resource
  736. */
  737. protected $curlHandle;
  738. /**
  739. * The headers of the page currently loaded in the internal browser.
  740. *
  741. * @var Array
  742. */
  743. protected $headers;
  744. /**
  745. * The content of the page currently loaded in the internal browser.
  746. *
  747. * @var string
  748. */
  749. protected $content;
  750. /**
  751. * The content of the page currently loaded in the internal browser (plain text version).
  752. *
  753. * @var string
  754. */
  755. protected $plainTextContent;
  756. /**
  757. * The value of the Drupal.settings JavaScript variable for the page currently loaded in the internal browser.
  758. *
  759. * @var Array
  760. */
  761. protected $drupalSettings;
  762. /**
  763. * The parsed version of the page.
  764. *
  765. * @var SimpleXMLElement
  766. */
  767. protected $elements = NULL;
  768. /**
  769. * The current user logged in using the internal browser.
  770. *
  771. * @var bool
  772. */
  773. protected $loggedInUser = FALSE;
  774. /**
  775. * The current cookie file used by cURL.
  776. *
  777. * We do not reuse the cookies in further runs, so we do not need a file
  778. * but we still need cookie handling, so we set the jar to NULL.
  779. */
  780. protected $cookieFile = NULL;
  781. /**
  782. * Additional cURL options.
  783. *
  784. * DrupalWebTestCase itself never sets this but always obeys what is set.
  785. */
  786. protected $additionalCurlOptions = array();
  787. /**
  788. * The original user, before it was changed to a clean uid = 1 for testing purposes.
  789. *
  790. * @var object
  791. */
  792. protected $originalUser = NULL;
  793. /**
  794. * The original shutdown handlers array, before it was cleaned for testing purposes.
  795. *
  796. * @var array
  797. */
  798. protected $originalShutdownCallbacks = array();
  799. /**
  800. * HTTP authentication method
  801. */
  802. protected $httpauth_method = CURLAUTH_BASIC;
  803. /**
  804. * HTTP authentication credentials (<username>:<password>).
  805. */
  806. protected $httpauth_credentials = NULL;
  807. /**
  808. * The current session name, if available.
  809. */
  810. protected $session_name = NULL;
  811. /**
  812. * The current session ID, if available.
  813. */
  814. protected $session_id = NULL;
  815. /**
  816. * Whether the files were copied to the test files directory.
  817. */
  818. protected $generatedTestFiles = FALSE;
  819. /**
  820. * The number of redirects followed during the handling of a request.
  821. */
  822. protected $redirect_count;
  823. /**
  824. * Constructor for DrupalWebTestCase.
  825. */
  826. function __construct($test_id = NULL) {
  827. parent::__construct($test_id);
  828. $this->skipClasses[__CLASS__] = TRUE;
  829. }
  830. /**
  831. * Get a node from the database based on its title.
  832. *
  833. * @param $title
  834. * A node title, usually generated by $this->randomName().
  835. * @param $reset
  836. * (optional) Whether to reset the internal node_load() cache.
  837. *
  838. * @return
  839. * A node object matching $title.
  840. */
  841. function drupalGetNodeByTitle($title, $reset = FALSE) {
  842. $nodes = node_load_multiple(array(), array('title' => $title), $reset);
  843. // Load the first node returned from the database.
  844. $returned_node = reset($nodes);
  845. return $returned_node;
  846. }
  847. /**
  848. * Creates a node based on default settings.
  849. *
  850. * @param $settings
  851. * An associative array of settings to change from the defaults, keys are
  852. * node properties, for example 'title' => 'Hello, world!'.
  853. * @return
  854. * Created node object.
  855. */
  856. protected function drupalCreateNode($settings = array()) {
  857. // Populate defaults array.
  858. $settings += array(
  859. 'body' => array(LANGUAGE_NONE => array(array())),
  860. 'title' => $this->randomName(8),
  861. 'comment' => 2,
  862. 'changed' => REQUEST_TIME,
  863. 'moderate' => 0,
  864. 'promote' => 0,
  865. 'revision' => 1,
  866. 'log' => '',
  867. 'status' => 1,
  868. 'sticky' => 0,
  869. 'type' => 'page',
  870. 'revisions' => NULL,
  871. 'language' => LANGUAGE_NONE,
  872. );
  873. // Use the original node's created time for existing nodes.
  874. if (isset($settings['created']) && !isset($settings['date'])) {
  875. $settings['date'] = format_date($settings['created'], 'custom', 'Y-m-d H:i:s O');
  876. }
  877. // If the node's user uid is not specified manually, use the currently
  878. // logged in user if available, or else the user running the test.
  879. if (!isset($settings['uid'])) {
  880. if ($this->loggedInUser) {
  881. $settings['uid'] = $this->loggedInUser->uid;
  882. }
  883. else {
  884. global $user;
  885. $settings['uid'] = $user->uid;
  886. }
  887. }
  888. // Merge body field value and format separately.
  889. $body = array(
  890. 'value' => $this->randomName(32),
  891. 'format' => filter_default_format(),
  892. );
  893. $settings['body'][$settings['language']][0] += $body;
  894. $node = (object) $settings;
  895. node_save($node);
  896. // Small hack to link revisions to our test user.
  897. db_update('node_revision')
  898. ->fields(array('uid' => $node->uid))
  899. ->condition('vid', $node->vid)
  900. ->execute();
  901. return $node;
  902. }
  903. /**
  904. * Creates a custom content type based on default settings.
  905. *
  906. * @param $settings
  907. * An array of settings to change from the defaults.
  908. * Example: 'type' => 'foo'.
  909. * @return
  910. * Created content type.
  911. */
  912. protected function drupalCreateContentType($settings = array()) {
  913. // Find a non-existent random type name.
  914. do {
  915. $name = strtolower($this->randomName(8));
  916. } while (node_type_get_type($name));
  917. // Populate defaults array.
  918. $defaults = array(
  919. 'type' => $name,
  920. 'name' => $name,
  921. 'base' => 'node_content',
  922. 'description' => '',
  923. 'help' => '',
  924. 'title_label' => 'Title',
  925. 'body_label' => 'Body',
  926. 'has_title' => 1,
  927. 'has_body' => 1,
  928. );
  929. // Imposed values for a custom type.
  930. $forced = array(
  931. 'orig_type' => '',
  932. 'old_type' => '',
  933. 'module' => 'node',
  934. 'custom' => 1,
  935. 'modified' => 1,
  936. 'locked' => 0,
  937. );
  938. $type = $forced + $settings + $defaults;
  939. $type = (object) $type;
  940. $saved_type = node_type_save($type);
  941. node_types_rebuild();
  942. menu_rebuild();
  943. node_add_body_field($type);
  944. $this->assertEqual($saved_type, SAVED_NEW, t('Created content type %type.', array('%type' => $type->type)));
  945. // Reset permissions so that permissions for this content type are available.
  946. $this->checkPermissions(array(), TRUE);
  947. return $type;
  948. }
  949. /**
  950. * Get a list files that can be used in tests.
  951. *
  952. * @param $type
  953. * File type, possible values: 'binary', 'html', 'image', 'javascript', 'php', 'sql', 'text'.
  954. * @param $size
  955. * File size in bytes to match. Please check the tests/files folder.
  956. * @return
  957. * List of files that match filter.
  958. */
  959. protected function drupalGetTestFiles($type, $size = NULL) {
  960. if (empty($this->generatedTestFiles)) {
  961. // Generate binary test files.
  962. $lines = array(64, 1024);
  963. $count = 0;
  964. foreach ($lines as $line) {
  965. simpletest_generate_file('binary-' . $count++, 64, $line, 'binary');
  966. }
  967. // Generate text test files.
  968. $lines = array(16, 256, 1024, 2048, 20480);
  969. $count = 0;
  970. foreach ($lines as $line) {
  971. simpletest_generate_file('text-' . $count++, 64, $line);
  972. }
  973. // Copy other test files from simpletest.
  974. $original = drupal_get_path('module', 'simpletest') . '/files';
  975. $files = file_scan_directory($original, '/(html|image|javascript|php|sql)-.*/');
  976. foreach ($files as $file) {
  977. file_unmanaged_copy($file->uri, variable_get('file_public_path', conf_path() . '/files'));
  978. }
  979. $this->generatedTestFiles = TRUE;
  980. }
  981. $files = array();
  982. // Make sure type is valid.
  983. if (in_array($type, array('binary', 'html', 'image', 'javascript', 'php', 'sql', 'text'))) {
  984. $files = file_scan_directory('public://', '/' . $type . '\-.*/');
  985. // If size is set then remove any files that are not of that size.
  986. if ($size !== NULL) {
  987. foreach ($files as $file) {
  988. $stats = stat($file->uri);
  989. if ($stats['size'] != $size) {
  990. unset($files[$file->uri]);
  991. }
  992. }
  993. }
  994. }
  995. usort($files, array($this, 'drupalCompareFiles'));
  996. return $files;
  997. }
  998. /**
  999. * Compare two files based on size and file name.
  1000. */
  1001. protected function drupalCompareFiles($file1, $file2) {
  1002. $compare_size = filesize($file1->uri) - filesize($file2->uri);
  1003. if ($compare_size) {
  1004. // Sort by file size.
  1005. return $compare_size;
  1006. }
  1007. else {
  1008. // The files were the same size, so sort alphabetically.
  1009. return strnatcmp($file1->name, $file2->name);
  1010. }
  1011. }
  1012. /**
  1013. * Create a user with a given set of permissions.
  1014. *
  1015. * @param array $permissions
  1016. * Array of permission names to assign to user. Note that the user always
  1017. * has the default permissions derived from the "authenticated users" role.
  1018. *
  1019. * @return object|false
  1020. * A fully loaded user object with pass_raw property, or FALSE if account
  1021. * creation fails.
  1022. */
  1023. protected function drupalCreateUser(array $permissions = array()) {
  1024. // Create a role with the given permission set, if any.
  1025. $rid = FALSE;
  1026. if ($permissions) {
  1027. $rid = $this->drupalCreateRole($permissions);
  1028. if (!$rid) {
  1029. return FALSE;
  1030. }
  1031. }
  1032. // Create a user assigned to that role.
  1033. $edit = array();
  1034. $edit['name'] = $this->randomName();
  1035. $edit['mail'] = $edit['name'] . '@example.com';
  1036. $edit['pass'] = user_password();
  1037. $edit['status'] = 1;
  1038. if ($rid) {
  1039. $edit['roles'] = array($rid => $rid);
  1040. }
  1041. $account = user_save(drupal_anonymous_user(), $edit);
  1042. $this->assertTrue(!empty($account->uid), t('User created with name %name and pass %pass', array('%name' => $edit['name'], '%pass' => $edit['pass'])), t('User login'));
  1043. if (empty($account->uid)) {
  1044. return FALSE;
  1045. }
  1046. // Add the raw password so that we can log in as this user.
  1047. $account->pass_raw = $edit['pass'];
  1048. return $account;
  1049. }
  1050. /**
  1051. * Creates a role with specified permissions.
  1052. *
  1053. * @param $permissions
  1054. * Array of permission names to assign to role.
  1055. * @param $name
  1056. * (optional) String for the name of the role. Defaults to a random string.
  1057. * @return
  1058. * Role ID of newly created role, or FALSE if role creation failed.
  1059. */
  1060. protected function drupalCreateRole(array $permissions, $name = NULL) {
  1061. // Generate random name if it was not passed.
  1062. if (!$name) {
  1063. $name = $this->randomName();
  1064. }
  1065. // Check the all the permissions strings are valid.
  1066. if (!$this->checkPermissions($permissions)) {
  1067. return FALSE;
  1068. }
  1069. // Create new role.
  1070. $role = new stdClass();
  1071. $role->name = $name;
  1072. user_role_save($role);
  1073. user_role_grant_permissions($role->rid, $permissions);
  1074. $this->assertTrue(isset($role->rid), t('Created role of name: @name, id: @rid', array('@name' => $name, '@rid' => (isset($role->rid) ? $role->rid : t('-n/a-')))), t('Role'));
  1075. if ($role && !empty($role->rid)) {
  1076. $count = db_query('SELECT COUNT(*) FROM {role_permission} WHERE rid = :rid', array(':rid' => $role->rid))->fetchField();
  1077. $this->assertTrue($count == count($permissions), t('Created permissions: @perms', array('@perms' => implode(', ', $permissions))), t('Role'));
  1078. return $role->rid;
  1079. }
  1080. else {
  1081. return FALSE;
  1082. }
  1083. }
  1084. /**
  1085. * Check to make sure that the array of permissions are valid.
  1086. *
  1087. * @param $permissions
  1088. * Permissions to check.
  1089. * @param $reset
  1090. * Reset cached available permissions.
  1091. * @return
  1092. * TRUE or FALSE depending on whether the permissions are valid.
  1093. */
  1094. protected function checkPermissions(array $permissions, $reset = FALSE) {
  1095. $available = &drupal_static(__FUNCTION__);
  1096. if (!isset($available) || $reset) {
  1097. $available = array_keys(module_invoke_all('permission'));
  1098. }
  1099. $valid = TRUE;
  1100. foreach ($permissions as $permission) {
  1101. if (!in_array($permission, $available)) {
  1102. $this->fail(t('Invalid permission %permission.', array('%permission' => $permission)), t('Role'));
  1103. $valid = FALSE;
  1104. }
  1105. }
  1106. return $valid;
  1107. }
  1108. /**
  1109. * Log in a user with the internal browser.
  1110. *
  1111. * If a user is already logged in, then the current user is logged out before
  1112. * logging in the specified user.
  1113. *
  1114. * Please note that neither the global $user nor the passed-in user object is
  1115. * populated with data of the logged in user. If you need full access to the
  1116. * user object after logging in, it must be updated manually. If you also need
  1117. * access to the plain-text password of the user (set by drupalCreateUser()),
  1118. * e.g. to log in the same user again, then it must be re-assigned manually.
  1119. * For example:
  1120. * @code
  1121. * // Create a user.
  1122. * $account = $this->drupalCreateUser(array());
  1123. * $this->drupalLogin($account);
  1124. * // Load real user object.
  1125. * $pass_raw = $account->pass_raw;
  1126. * $account = user_load($account->uid);
  1127. * $account->pass_raw = $pass_raw;
  1128. * @endcode
  1129. *
  1130. * @param $account
  1131. * User object representing the user to log in.
  1132. *
  1133. * @see drupalCreateUser()
  1134. */
  1135. protected function drupalLogin(stdClass $account) {
  1136. if ($this->loggedInUser) {
  1137. $this->drupalLogout();
  1138. }
  1139. $edit = array(
  1140. 'name' => $account->name,
  1141. 'pass' => $account->pass_raw
  1142. );
  1143. $this->drupalPost('user', $edit, t('Log in'));
  1144. // If a "log out" link appears on the page, it is almost certainly because
  1145. // the login was successful.
  1146. $pass = $this->assertLink(t('Log out'), 0, t('User %name successfully logged in.', array('%name' => $account->name)), t('User login'));
  1147. if ($pass) {
  1148. $this->loggedInUser = $account;
  1149. }
  1150. }
  1151. /**
  1152. * Generate a token for the currently logged in user.
  1153. */
  1154. protected function drupalGetToken($value = '') {
  1155. $private_key = drupal_get_private_key();
  1156. return drupal_hmac_base64($value, $this->session_id . $private_key);
  1157. }
  1158. /*
  1159. * Logs a user out of the internal browser, then check the login page to confirm logout.
  1160. */
  1161. protected function drupalLogout() {
  1162. // Make a request to the logout page, and redirect to the user page, the
  1163. // idea being if you were properly logged out you should be seeing a login
  1164. // screen.
  1165. $this->drupalGet('user/logout');
  1166. $this->drupalGet('user');
  1167. $pass = $this->assertField('name', t('Username field found.'), t('Logout'));
  1168. $pass = $pass && $this->assertField('pass', t('Password field found.'), t('Logout'));
  1169. if ($pass) {
  1170. $this->loggedInUser = FALSE;
  1171. }
  1172. }
  1173. /**
  1174. * Generates a database prefix for running tests.
  1175. *
  1176. * The generated database table prefix is used for the Drupal installation
  1177. * being performed for the test. It is also used as user agent HTTP header
  1178. * value by the cURL-based browser of DrupalWebTestCase, which is sent
  1179. * to the Drupal installation of the test. During early Drupal bootstrap, the
  1180. * user agent HTTP header is parsed, and if it matches, all database queries
  1181. * use the database table prefix that has been generated here.
  1182. *
  1183. * @see DrupalWebTestCase::curlInitialize()
  1184. * @see drupal_valid_test_ua()
  1185. * @see DrupalWebTestCase::setUp()
  1186. */
  1187. protected function prepareDatabasePrefix() {
  1188. $this->databasePrefix = 'simpletest' . mt_rand(1000, 1000000);
  1189. // As soon as the database prefix is set, the test might start to execute.
  1190. // All assertions as well as the SimpleTest batch operations are associated
  1191. // with the testId, so the database prefix has to be associated with it.
  1192. db_update('simpletest_test_id')
  1193. ->fields(array('last_prefix' => $this->databasePrefix))
  1194. ->condition('test_id', $this->testId)
  1195. ->execute();
  1196. }
  1197. /**
  1198. * Changes the database connection to the prefixed one.
  1199. *
  1200. * @see DrupalWebTestCase::setUp()
  1201. */
  1202. protected function changeDatabasePrefix() {
  1203. if (empty($this->databasePrefix)) {
  1204. $this->prepareDatabasePrefix();
  1205. // If $this->prepareDatabasePrefix() failed to work, return without
  1206. // setting $this->setupDatabasePrefix to TRUE, so setUp() methods will
  1207. // know to bail out.
  1208. if (empty($this->databasePrefix)) {
  1209. return;
  1210. }
  1211. }
  1212. // Clone the current connection and replace the current prefix.
  1213. $connection_info = Database::getConnectionInfo('default');
  1214. Database::renameConnection('default', 'simpletest_original_default');
  1215. foreach ($connection_info as $target => $value) {
  1216. $connection_info[$target]['prefix'] = array(
  1217. 'default' => $value['prefix']['default'] . $this->databasePrefix,
  1218. );
  1219. }
  1220. Database::addConnectionInfo('default', 'default', $connection_info['default']);
  1221. // Indicate the database prefix was set up correctly.
  1222. $this->setupDatabasePrefix = TRUE;
  1223. }
  1224. /**
  1225. * Prepares the current environment for running the test.
  1226. *
  1227. * Backups various current environment variables and resets them, so they do
  1228. * not interfere with the Drupal site installation in which tests are executed
  1229. * and can be restored in tearDown().
  1230. *
  1231. * Also sets up new resources for the testing environment, such as the public
  1232. * filesystem and configuration directories.
  1233. *
  1234. * @see DrupalWebTestCase::setUp()
  1235. * @see DrupalWebTestCase::tearDown()
  1236. */
  1237. protected function prepareEnvironment() {
  1238. global $user, $language, $conf;
  1239. // Store necessary current values before switching to prefixed database.
  1240. $this->originalLanguage = $language;
  1241. $this->originalLanguageDefault = variable_get('language_default');
  1242. $this->originalFileDirectory = variable_get('file_public_path', conf_path() . '/files');
  1243. $this->originalProfile = drupal_get_profile();
  1244. $this->originalCleanUrl = variable_get('clean_url', 0);
  1245. $this->originalUser = $user;
  1246. // Set to English to prevent exceptions from utf8_truncate() from t()
  1247. // during install if the current language is not 'en'.
  1248. // The following array/object conversion is copied from language_default().
  1249. $language = (object) array('language' => 'en', 'name' => 'English', 'native' => 'English', 'direction' => 0, 'enabled' => 1, 'plurals' => 0, 'formula' => '', 'domain' => '', 'prefix' => '', 'weight' => 0, 'javascript' => '');
  1250. // Save and clean the shutdown callbacks array because it is static cached
  1251. // and will be changed by the test run. Otherwise it will contain callbacks
  1252. // from both environments and the testing environment will try to call the
  1253. // handlers defined by the original one.
  1254. $callbacks = &drupal_register_shutdown_function();
  1255. $this->originalShutdownCallbacks = $callbacks;
  1256. $callbacks = array();
  1257. // Create test directory ahead of installation so fatal errors and debug
  1258. // information can be logged during installation process.
  1259. // Use temporary files directory with the same prefix as the database.
  1260. $this->public_files_directory = $this->originalFileDirectory . '/simpletest/' . substr($this->databasePrefix, 10);
  1261. $this->private_files_directory = $this->public_files_directory . '/private';
  1262. $this->temp_files_directory = $this->private_files_directory . '/temp';
  1263. // Create the directories
  1264. file_prepare_directory($this->public_files_directory, FILE_CREATE_DIRECTORY | FILE_MODIFY_PERMISSIONS);
  1265. file_prepare_directory($this->private_files_directory, FILE_CREATE_DIRECTORY);
  1266. file_prepare_directory($this->temp_files_directory, FILE_CREATE_DIRECTORY);
  1267. $this->generatedTestFiles = FALSE;
  1268. // Log fatal errors.
  1269. ini_set('log_errors', 1);
  1270. ini_set('error_log', $this->public_files_directory . '/error.log');
  1271. // Set the test information for use in other parts of Drupal.
  1272. $test_info = &$GLOBALS['drupal_test_info'];
  1273. $test_info['test_run_id'] = $this->databasePrefix;
  1274. $test_info['in_child_site'] = FALSE;
  1275. // Indicate the environment was set up correctly.
  1276. $this->setupEnvironment = TRUE;
  1277. }
  1278. /**
  1279. * Sets up a Drupal site for running functional and integration tests.
  1280. *
  1281. * Generates a random database prefix and installs Drupal with the specified
  1282. * installation profile in DrupalWebTestCase::$profile into the
  1283. * prefixed database. Afterwards, installs any additional modules specified by
  1284. * the test.
  1285. *
  1286. * After installation all caches are flushed and several configuration values
  1287. * are reset to the values of the parent site executing the test, since the
  1288. * default values may be incompatible with the environment in which tests are
  1289. * being executed.
  1290. *
  1291. * @param ...
  1292. * List of modules to enable for the duration of the test. This can be
  1293. * either a single array or a variable number of string arguments.
  1294. *
  1295. * @see DrupalWebTestCase::prepareDatabasePrefix()
  1296. * @see DrupalWebTestCase::changeDatabasePrefix()
  1297. * @see DrupalWebTestCase::prepareEnvironment()
  1298. */
  1299. protected function setUp() {
  1300. global $user, $language, $conf;
  1301. // Create the database prefix for this test.
  1302. $this->prepareDatabasePrefix();
  1303. // Prepare the environment for running tests.
  1304. $this->prepareEnvironment();
  1305. if (!$this->setupEnvironment) {
  1306. return FALSE;
  1307. }
  1308. // Reset all statics and variables to perform tests in a clean environment.
  1309. $conf = array();
  1310. drupal_static_reset();
  1311. // Change the database prefix.
  1312. // All static variables need to be reset before the database prefix is
  1313. // changed, since DrupalCacheArray implementations attempt to
  1314. // write back to persistent caches when they are destructed.
  1315. $this->changeDatabasePrefix();
  1316. if (!$this->setupDatabasePrefix) {
  1317. return FALSE;
  1318. }
  1319. // Preset the 'install_profile' system variable, so the first call into
  1320. // system_rebuild_module_data() (in drupal_install_system()) will register
  1321. // the test's profile as a module. Without this, the installation profile of
  1322. // the parent site (executing the test) is registered, and the test
  1323. // profile's hook_install() and other hook implementations are never invoked.
  1324. $conf['install_profile'] = $this->profile;
  1325. // Perform the actual Drupal installation.
  1326. include_once DRUPAL_ROOT . '/includes/install.inc';
  1327. drupal_install_system();
  1328. $this->preloadRegistry();
  1329. // Set path variables.
  1330. variable_set('file_public_path', $this->public_files_directory);
  1331. variable_set('file_private_path', $this->private_files_directory);
  1332. variable_set('file_temporary_path', $this->temp_files_directory);
  1333. // Set the 'simpletest_parent_profile' variable to add the parent profile's
  1334. // search path to the child site's search paths.
  1335. // @see drupal_system_listing()
  1336. // @todo This may need to be primed like 'install_profile' above.
  1337. variable_set('simpletest_parent_profile', $this->originalProfile);
  1338. // Include the testing profile.
  1339. variable_set('install_profile', $this->profile);
  1340. $profile_details = install_profile_info($this->profile, 'en');
  1341. // Install the modules specified by the testing profile.
  1342. module_enable($profile_details['dependencies'], FALSE);
  1343. // Install modules needed for this test. This could have been passed in as
  1344. // either a single array argument or a variable number of string arguments.
  1345. // @todo Remove this compatibility layer in Drupal 8, and only accept
  1346. // $modules as a single array argument.
  1347. $modules = func_get_args();
  1348. if (isset($modules[0]) && is_array($modules[0])) {
  1349. $modules = $modules[0];
  1350. }
  1351. if ($modules) {
  1352. $success = module_enable($modules, TRUE);
  1353. $this->assertTrue($success, t('Enabled modules: %modules', array('%modules' => implode(', ', $modules))));
  1354. }
  1355. // Run the profile tasks.
  1356. $install_profile_module_exists = db_query("SELECT 1 FROM {system} WHERE type = 'module' AND name = :name", array(
  1357. ':name' => $this->profile,
  1358. ))->fetchField();
  1359. if ($install_profile_module_exists) {
  1360. module_enable(array($this->profile), FALSE);
  1361. }
  1362. // Reset/rebuild all data structures after enabling the modules.
  1363. $this->resetAll();
  1364. // Run cron once in that environment, as install.php does at the end of
  1365. // the installation process.
  1366. drupal_cron_run();
  1367. // Ensure that the session is not written to the new environment and replace
  1368. // the global $user session with uid 1 from the new test site.
  1369. drupal_save_session(FALSE);
  1370. // Login as uid 1.
  1371. $user = user_load(1);
  1372. // Restore necessary variables.
  1373. variable_set('install_task', 'done');
  1374. variable_set('clean_url', $this->originalCleanUrl);
  1375. variable_set('site_mail', 'simpletest@example.com');
  1376. variable_set('date_default_timezone', date_default_timezone_get());
  1377. // Set up English language.
  1378. unset($conf['language_default']);
  1379. $language = language_default();
  1380. // Use the test mail class instead of the default mail handler class.
  1381. variable_set('mail_system', array('default-system' => 'TestingMailSystem'));
  1382. drupal_set_time_limit($this->timeLimit);
  1383. $this->setup = TRUE;
  1384. }
  1385. /**
  1386. * Preload the registry from the testing site.
  1387. *
  1388. * This method is called by DrupalWebTestCase::setUp(), and preloads the
  1389. * registry from the testing site to cut down on the time it takes to
  1390. * set up a clean environment for the current test run.
  1391. */
  1392. protected function preloadRegistry() {
  1393. // Use two separate queries, each with their own connections: copy the
  1394. // {registry} and {registry_file} tables over from the parent installation
  1395. // to the child installation.
  1396. $original_connection = Database::getConnection('default', 'simpletest_original_default');
  1397. $test_connection = Database::getConnection();
  1398. foreach (array('registry', 'registry_file') as $table) {
  1399. // Find the records from the parent database.
  1400. $source_query = $original_connection
  1401. ->select($table, array(), array('fetch' => PDO::FETCH_ASSOC))
  1402. ->fields($table);
  1403. $dest_query = $test_connection->insert($table);
  1404. $first = TRUE;
  1405. foreach ($source_query->execute() as $row) {
  1406. if ($first) {
  1407. $dest_query->fields(array_keys($row));
  1408. $first = FALSE;
  1409. }
  1410. // Insert the records into the child database.
  1411. $dest_query->values($row);
  1412. }
  1413. $dest_query->execute();
  1414. }
  1415. }
  1416. /**
  1417. * Reset all data structures after having enabled new modules.
  1418. *
  1419. * This method is called by DrupalWebTestCase::setUp() after enabling
  1420. * the requested modules. It must be called again when additional modules
  1421. * are enabled later.
  1422. */
  1423. protected function resetAll() {
  1424. // Reset all static variables.
  1425. drupal_static_reset();
  1426. // Reset the list of enabled modules.
  1427. module_list(TRUE);
  1428. // Reset cached schema for new database prefix. This must be done before
  1429. // drupal_flush_all_caches() so rebuilds can make use of the schema of
  1430. // modules enabled on the cURL side.
  1431. drupal_get_schema(NULL, TRUE);
  1432. // Perform rebuilds and flush remaining caches.
  1433. drupal_flush_all_caches();
  1434. // Reload global $conf array and permissions.
  1435. $this->refreshVariables();
  1436. $this->checkPermissions(array(), TRUE);
  1437. }
  1438. /**
  1439. * Refresh the in-memory set of variables. Useful after a page request is made
  1440. * that changes a variable in a different thread.
  1441. *
  1442. * In other words calling a settings page with $this->drupalPost() with a changed
  1443. * value would update a variable to reflect that change, but in the thread that
  1444. * made the call (thread running the test) the changed variable would not be
  1445. * picked up.
  1446. *
  1447. * This method clears the variables cache and loads a fresh copy from the database
  1448. * to ensure that the most up-to-date set of variables is loaded.
  1449. */
  1450. protected function refreshVariables() {
  1451. global $conf;
  1452. cache_clear_all('variables', 'cache_bootstrap');
  1453. $conf = variable_initialize();
  1454. }
  1455. /**
  1456. * Delete created files and temporary files directory, delete the tables created by setUp(),
  1457. * and reset the database prefix.
  1458. */
  1459. protected function tearDown() {
  1460. global $user, $language;
  1461. // In case a fatal error occurred that was not in the test process read the
  1462. // log to pick up any fatal errors.
  1463. simpletest_log_read($this->testId, $this->databasePrefix, get_class($this), TRUE);
  1464. $emailCount = count(variable_get('drupal_test_email_collector', array()));
  1465. if ($emailCount) {
  1466. $message = format_plural($emailCount, '1 e-mail was sent during this test.', '@count e-mails were sent during this test.');
  1467. $this->pass($message, t('E-mail'));
  1468. }
  1469. // Delete temporary files directory.
  1470. file_unmanaged_delete_recursive($this->originalFileDirectory . '/simpletest/' . substr($this->databasePrefix, 10));
  1471. // Remove all prefixed tables.
  1472. $tables = db_find_tables($this->databasePrefix . '%');
  1473. $connection_info = Database::getConnectionInfo('default');
  1474. $tables = db_find_tables($connection_info['default']['prefix']['default'] . '%');
  1475. if (empty($tables)) {
  1476. $this->fail('Failed to find test tables to drop.');
  1477. }
  1478. $prefix_length = strlen($connection_info['default']['prefix']['default']);
  1479. foreach ($tables as $table) {
  1480. if (db_drop_table(substr($table, $prefix_length))) {
  1481. unset($tables[$table]);
  1482. }
  1483. }
  1484. if (!empty($tables)) {
  1485. $this->fail('Failed to drop all prefixed tables.');
  1486. }
  1487. // Get back to the original connection.
  1488. Database::removeConnection('default');
  1489. Database::renameConnection('simpletest_original_default', 'default');
  1490. // Restore original shutdown callbacks array to prevent original
  1491. // environment of calling handlers from test run.
  1492. $callbacks = &drupal_register_shutdown_function();
  1493. $callbacks = $this->originalShutdownCallbacks;
  1494. // Return the user to the original one.
  1495. $user = $this->originalUser;
  1496. drupal_save_session(TRUE);
  1497. // Ensure that internal logged in variable and cURL options are reset.
  1498. $this->loggedInUser = FALSE;
  1499. $this->additionalCurlOptions = array();
  1500. // Reload module list and implementations to ensure that test module hooks
  1501. // aren't called after tests.
  1502. module_list(TRUE);
  1503. module_implements('', FALSE, TRUE);
  1504. // Reset the Field API.
  1505. field_cache_clear();
  1506. // Rebuild caches.
  1507. $this->refreshVariables();
  1508. // Reset public files directory.
  1509. $GLOBALS['conf']['file_public_path'] = $this->originalFileDirectory;
  1510. // Reset language.
  1511. $language = $this->originalLanguage;
  1512. if ($this->originalLanguageDefault) {
  1513. $GLOBALS['conf']['language_default'] = $this->originalLanguageDefault;
  1514. }
  1515. // Close the CURL handler.
  1516. $this->curlClose();
  1517. }
  1518. /**
  1519. * Initializes the cURL connection.
  1520. *
  1521. * If the simpletest_httpauth_credentials variable is set, this function will
  1522. * add HTTP authentication headers. This is necessary for testing sites that
  1523. * are protected by login credentials from public access.
  1524. * See the description of $curl_options for other options.
  1525. */
  1526. protected function curlInitialize() {
  1527. global $base_url;
  1528. if (!isset($this->curlHandle)) {
  1529. $this->curlHandle = curl_init();
  1530. // Some versions/configurations of cURL break on a NULL cookie jar, so
  1531. // supply a real file.
  1532. if (empty($this->cookieFile)) {
  1533. $this->cookieFile = $this->public_files_directory . '/cookie.jar';
  1534. }
  1535. $curl_options = array(
  1536. CURLOPT_COOKIEJAR => $this->cookieFile,
  1537. CURLOPT_URL => $base_url,
  1538. CURLOPT_FOLLOWLOCATION => FALSE,
  1539. CURLOPT_RETURNTRANSFER => TRUE,
  1540. CURLOPT_SSL_VERIFYPEER => FALSE, // Required to make the tests run on HTTPS.
  1541. CURLOPT_SSL_VERIFYHOST => FALSE, // Required to make the tests run on HTTPS.
  1542. CURLOPT_HEADERFUNCTION => array(&$this, 'curlHeaderCallback'),
  1543. CURLOPT_USERAGENT => $this->databasePrefix,
  1544. );
  1545. if (isset($this->httpauth_credentials)) {
  1546. $curl_options[CURLOPT_HTTPAUTH] = $this->httpauth_method;
  1547. $curl_options[CURLOPT_USERPWD] = $this->httpauth_credentials;
  1548. }
  1549. // curl_setopt_array() returns FALSE if any of the specified options
  1550. // cannot be set, and stops processing any further options.
  1551. $result = curl_setopt_array($this->curlHandle, $this->additionalCurlOptions + $curl_options);
  1552. if (!$result) {
  1553. throw new Exception('One or more cURL options could not be set.');
  1554. }
  1555. // By default, the child session name should be the same as the parent.
  1556. $this->session_name = session_name();
  1557. }
  1558. // We set the user agent header on each request so as to use the current
  1559. // time and a new uniqid.
  1560. if (preg_match('/simpletest\d+/', $this->databasePrefix, $matches)) {
  1561. curl_setopt($this->curlHandle, CURLOPT_USERAGENT, drupal_generate_test_ua($matches[0]));
  1562. }
  1563. }
  1564. /**
  1565. * Initializes and executes a cURL request.
  1566. *
  1567. * @param $curl_options
  1568. * An associative array of cURL options to set, where the keys are constants
  1569. * defined by the cURL library. For a list of valid options, see
  1570. * http://www.php.net/manual/function.curl-setopt.php
  1571. * @param $redirect
  1572. * FALSE if this is an initial request, TRUE if this request is the result
  1573. * of a redirect.
  1574. *
  1575. * @return
  1576. * The content returned from the call to curl_exec().
  1577. *
  1578. * @see curlInitialize()
  1579. */
  1580. protected function curlExec($curl_options, $redirect = FALSE) {
  1581. $this->curlInitialize();
  1582. // cURL incorrectly handles URLs with a fragment by including the
  1583. // fragment in the request to the server, causing some web servers
  1584. // to reject the request citing "400 - Bad Request". To prevent
  1585. // this, we strip the fragment from the request.
  1586. // TODO: Remove this for Drupal 8, since fixed in curl 7.20.0.
  1587. if (!empty($curl_options[CURLOPT_URL]) && strpos($curl_options[CURLOPT_URL], '#')) {
  1588. $original_url = $curl_options[CURLOPT_URL];
  1589. $curl_options[CURLOPT_URL] = strtok($curl_options[CURLOPT_URL], '#');
  1590. }
  1591. $url = empty($curl_options[CURLOPT_URL]) ? curl_getinfo($this->curlHandle, CURLINFO_EFFECTIVE_URL) : $curl_options[CURLOPT_URL];
  1592. if (!empty($curl_options[CURLOPT_POST])) {
  1593. // This is a fix for the Curl library to prevent Expect: 100-continue
  1594. // headers in POST requests, that may cause unexpected HTTP response
  1595. // codes from some webservers (like lighttpd that returns a 417 error
  1596. // code). It is done by setting an empty "Expect" header field that is
  1597. // not overwritten by Curl.
  1598. $curl_options[CURLOPT_HTTPHEADER][] = 'Expect:';
  1599. }
  1600. curl_setopt_array($this->curlHandle, $this->additionalCurlOptions + $curl_options);
  1601. if (!$redirect) {
  1602. // Reset headers, the session ID and the redirect counter.
  1603. $this->session_id = NULL;
  1604. $this->headers = array();
  1605. $this->redirect_count = 0;
  1606. }
  1607. $content = curl_exec($this->curlHandle);
  1608. $status = curl_getinfo($this->curlHandle, CURLINFO_HTTP_CODE);
  1609. // cURL incorrectly handles URLs with fragments, so instead of
  1610. // letting cURL handle redirects we take of them ourselves to
  1611. // to prevent fragments being sent to the web server as part
  1612. // of the request.
  1613. // TODO: Remove this for Drupal 8, since fixed in curl 7.20.0.
  1614. if (in_array($status, array(300, 301, 302, 303, 305, 307)) && $this->redirect_count < variable_get('simpletest_maximum_redirects', 5)) {
  1615. if ($this->drupalGetHeader('location')) {
  1616. $this->redirect_count++;
  1617. $curl_options = array();
  1618. $curl_options[CURLOPT_URL] = $this->drupalGetHeader('location');
  1619. $curl_options[CURLOPT_HTTPGET] = TRUE;
  1620. return $this->curlExec($curl_options, TRUE);
  1621. }
  1622. }
  1623. $this->drupalSetContent($content, isset($original_url) ? $original_url : curl_getinfo($this->curlHandle, CURLINFO_EFFECTIVE_URL));
  1624. $message_vars = array(
  1625. '!method' => !empty($curl_options[CURLOPT_NOBODY]) ? 'HEAD' : (empty($curl_options[CURLOPT_POSTFIELDS]) ? 'GET' : 'POST'),
  1626. '@url' => isset($original_url) ? $original_url : $url,
  1627. '@status' => $status,
  1628. '!length' => format_size(strlen($this->drupalGetContent()))
  1629. );
  1630. $message = t('!method @url returned @status (!length).', $message_vars);
  1631. $this->assertTrue($this->drupalGetContent() !== FALSE, $message, t('Browser'));
  1632. return $this->drupalGetContent();
  1633. }
  1634. /**
  1635. * Reads headers and registers errors received from the tested site.
  1636. *
  1637. * @see _drupal_log_error().
  1638. *
  1639. * @param $curlHandler
  1640. * The cURL handler.
  1641. * @param $header
  1642. * An header.
  1643. */
  1644. protected function curlHeaderCallback($curlHandler, $header) {
  1645. // Header fields can be extended over multiple lines by preceding each
  1646. // extra line with at least one SP or HT. They should be joined on receive.
  1647. // Details are in RFC2616 section 4.
  1648. if ($header[0] == ' ' || $header[0] == "\t") {
  1649. // Normalize whitespace between chucks.
  1650. $this->headers[] = array_pop($this->headers) . ' ' . trim($header);
  1651. }
  1652. else {
  1653. $this->headers[] = $header;
  1654. }
  1655. // Errors are being sent via X-Drupal-Assertion-* headers,
  1656. // generated by _drupal_log_error() in the exact form required
  1657. // by DrupalWebTestCase::error().
  1658. if (preg_match('/^X-Drupal-Assertion-[0-9]+: (.*)$/', $header, $matches)) {
  1659. // Call DrupalWebTestCase::error() with the parameters from the header.
  1660. call_user_func_array(array(&$this, 'error'), unserialize(urldecode($matches[1])));
  1661. }
  1662. // Save cookies.
  1663. if (preg_match('/^Set-Cookie: ([^=]+)=(.+)/', $header, $matches)) {
  1664. $name = $matches[1];
  1665. $parts = array_map('trim', explode(';', $matches[2]));
  1666. $value = array_shift($parts);
  1667. $this->cookies[$name] = array('value' => $value, 'secure' => in_array('secure', $parts));
  1668. if ($name == $this->session_name) {
  1669. if ($value != 'deleted') {
  1670. $this->session_id = $value;
  1671. }
  1672. else {
  1673. $this->session_id = NULL;
  1674. }
  1675. }
  1676. }
  1677. // This is required by cURL.
  1678. return strlen($header);
  1679. }
  1680. /**
  1681. * Close the cURL handler and unset the handler.
  1682. */
  1683. protected function curlClose() {
  1684. if (isset($this->curlHandle)) {
  1685. curl_close($this->curlHandle);
  1686. unset($this->curlHandle);
  1687. }
  1688. }
  1689. /**
  1690. * Parse content returned from curlExec using DOM and SimpleXML.
  1691. *
  1692. * @return
  1693. * A SimpleXMLElement or FALSE on failure.
  1694. */
  1695. protected function parse() {
  1696. if (!$this->elements) {
  1697. // DOM can load HTML soup. But, HTML soup can throw warnings, suppress
  1698. // them.
  1699. $htmlDom = new DOMDocument();
  1700. @$htmlDom->loadHTML($this->drupalGetContent());
  1701. if ($htmlDom) {
  1702. $this->pass(t('Valid HTML found on "@path"', array('@path' => $this->getUrl())), t('Browser'));
  1703. // It's much easier to work with simplexml than DOM, luckily enough
  1704. // we can just simply import our DOM tree.
  1705. $this->elements = simplexml_import_dom($htmlDom);
  1706. }
  1707. }
  1708. if (!$this->elements) {
  1709. $this->fail(t('Parsed page successfully.'), t('Browser'));
  1710. }
  1711. return $this->elements;
  1712. }
  1713. /**
  1714. * Retrieves a Drupal path or an absolute path.
  1715. *
  1716. * @param $path
  1717. * Drupal path or URL to load into internal browser
  1718. * @param $options
  1719. * Options to be forwarded to url().
  1720. * @param $headers
  1721. * An array containing additional HTTP request headers, each formatted as
  1722. * "name: value".
  1723. * @return
  1724. * The retrieved HTML string, also available as $this->drupalGetContent()
  1725. */
  1726. protected function drupalGet($path, array $options = array(), array $headers = array()) {
  1727. $options['absolute'] = TRUE;
  1728. // We re-using a CURL connection here. If that connection still has certain
  1729. // options set, it might change the GET into a POST. Make sure we clear out
  1730. // previous options.
  1731. $out = $this->curlExec(array(CURLOPT_HTTPGET => TRUE, CURLOPT_URL => url($path, $options), CURLOPT_NOBODY => FALSE, CURLOPT_HTTPHEADER => $headers));
  1732. $this->refreshVariables(); // Ensure that any changes to variables in the other thread are picked up.
  1733. // Replace original page output with new output from redirected page(s).
  1734. if ($new = $this->checkForMetaRefresh()) {
  1735. $out = $new;
  1736. }
  1737. $this->verbose('GET request to: ' . $path .
  1738. '<hr />Ending URL: ' . $this->getUrl() .
  1739. '<hr />' . $out);
  1740. return $out;
  1741. }
  1742. /**
  1743. * Retrieve a Drupal path or an absolute path and JSON decode the result.
  1744. */
  1745. protected function drupalGetAJAX($path, array $options = array(), array $headers = array()) {
  1746. return drupal_json_decode($this->drupalGet($path, $options, $headers));
  1747. }
  1748. /**
  1749. * Execute a POST request on a Drupal page.
  1750. * It will be done as usual POST request with SimpleBrowser.
  1751. *
  1752. * @param $path
  1753. * Location of the post form. Either a Drupal path or an absolute path or
  1754. * NULL to post to the current page. For multi-stage forms you can set the
  1755. * path to NULL and have it post to the last received page. Example:
  1756. *
  1757. * @code
  1758. * // First step in form.
  1759. * $edit = array(...);
  1760. * $this->drupalPost('some_url', $edit, t('Save'));
  1761. *
  1762. * // Second step in form.
  1763. * $edit = array(...);
  1764. * $this->drupalPost(NULL, $edit, t('Save'));
  1765. * @endcode
  1766. * @param $edit
  1767. * Field data in an associative array. Changes the current input fields
  1768. * (where possible) to the values indicated. A checkbox can be set to
  1769. * TRUE to be checked and FALSE to be unchecked. Note that when a form
  1770. * contains file upload fields, other fields cannot start with the '@'
  1771. * character.
  1772. *
  1773. * Multiple select fields can be set using name[] and setting each of the
  1774. * possible values. Example:
  1775. * @code
  1776. * $edit = array();
  1777. * $edit['name[]'] = array('value1', 'value2');
  1778. * @endcode
  1779. * @param $submit
  1780. * Value of the submit button whose click is to be emulated. For example,
  1781. * t('Save'). The processing of the request depends on this value. For
  1782. * example, a form may have one button with the value t('Save') and another
  1783. * button with the value t('Delete'), and execute different code depending
  1784. * on which one is clicked.
  1785. *
  1786. * This function can also be called to emulate an Ajax submission. In this
  1787. * case, this value needs to be an array with the following keys:
  1788. * - path: A path to submit the form values to for Ajax-specific processing,
  1789. * which is likely different than the $path parameter used for retrieving
  1790. * the initial form. Defaults to 'system/ajax'.
  1791. * - triggering_element: If the value for the 'path' key is 'system/ajax' or
  1792. * another generic Ajax processing path, this needs to be set to the name
  1793. * of the element. If the name doesn't identify the element uniquely, then
  1794. * this should instead be an array with a single key/value pair,
  1795. * corresponding to the element name and value. The callback for the
  1796. * generic Ajax processing path uses this to find the #ajax information
  1797. * for the element, including which specific callback to use for
  1798. * processing the request.
  1799. *
  1800. * This can also be set to NULL in order to emulate an Internet Explorer
  1801. * submission of a form with a single text field, and pressing ENTER in that
  1802. * textfield: under these conditions, no button information is added to the
  1803. * POST data.
  1804. * @param $options
  1805. * Options to be forwarded to url().
  1806. * @param $headers
  1807. * An array containing additional HTTP request headers, each formatted as
  1808. * "name: value".
  1809. * @param $form_html_id
  1810. * (optional) HTML ID of the form to be submitted. On some pages
  1811. * there are many identical forms, so just using the value of the submit
  1812. * button is not enough. For example: 'trigger-node-presave-assign-form'.
  1813. * Note that this is not the Drupal $form_id, but rather the HTML ID of the
  1814. * form, which is typically the same thing but with hyphens replacing the
  1815. * underscores.
  1816. * @param $extra_post
  1817. * (optional) A string of additional data to append to the POST submission.
  1818. * This can be used to add POST data for which there are no HTML fields, as
  1819. * is done by drupalPostAJAX(). This string is literally appended to the
  1820. * POST data, so it must already be urlencoded and contain a leading "&"
  1821. * (e.g., "&extra_var1=hello+world&extra_var2=you%26me").
  1822. */
  1823. protected function drupalPost($path, $edit, $submit, array $options = array(), array $headers = array(), $form_html_id = NULL, $extra_post = NULL) {
  1824. $submit_matches = FALSE;
  1825. $ajax = is_array($submit);
  1826. if (isset($path)) {
  1827. $this->drupalGet($path, $options);
  1828. }
  1829. if ($this->parse()) {
  1830. $edit_save = $edit;
  1831. // Let's iterate over all the forms.
  1832. $xpath = "//form";
  1833. if (!empty($form_html_id)) {
  1834. $xpath .= "[@id='" . $form_html_id . "']";
  1835. }
  1836. $forms = $this->xpath($xpath);
  1837. foreach ($forms as $form) {
  1838. // We try to set the fields of this form as specified in $edit.
  1839. $edit = $edit_save;
  1840. $post = array();
  1841. $upload = array();
  1842. $submit_matches = $this->handleForm($post, $edit, $upload, $ajax ? NULL : $submit, $form);
  1843. $action = isset($form['action']) ? $this->getAbsoluteUrl((string) $form['action']) : $this->getUrl();
  1844. if ($ajax) {
  1845. $action = $this->getAbsoluteUrl(!empty($submit['path']) ? $submit['path'] : 'system/ajax');
  1846. // Ajax callbacks verify the triggering element if necessary, so while
  1847. // we may eventually want extra code that verifies it in the
  1848. // handleForm() function, it's not currently a requirement.
  1849. $submit_matches = TRUE;
  1850. }
  1851. // We post only if we managed to handle every field in edit and the
  1852. // submit button matches.
  1853. if (!$edit && ($submit_matches || !isset($submit))) {
  1854. $post_array = $post;
  1855. if ($upload) {
  1856. // TODO: cURL handles file uploads for us, but the implementation
  1857. // is broken. This is a less than elegant workaround. Alternatives
  1858. // are being explored at #253506.
  1859. foreach ($upload as $key => $file) {
  1860. $file = drupal_realpath($file);
  1861. if ($file && is_file($file)) {
  1862. // Use the new CurlFile class for file uploads when using PHP
  1863. // 5.5 or higher.
  1864. if (class_exists('CurlFile')) {
  1865. $post[$key] = curl_file_create($file);
  1866. }
  1867. else {
  1868. $post[$key] = '@' . $file;
  1869. }
  1870. }
  1871. }
  1872. }
  1873. else {
  1874. foreach ($post as $key => $value) {
  1875. // Encode according to application/x-www-form-urlencoded
  1876. // Both names and values needs to be urlencoded, according to
  1877. // http://www.w3.org/TR/html4/interact/forms.html#h-17.13.4.1
  1878. $post[$key] = urlencode($key) . '=' . urlencode($value);
  1879. }
  1880. $post = implode('&', $post) . $extra_post;
  1881. }
  1882. $out = $this->curlExec(array(CURLOPT_URL => $action, CURLOPT_POST => TRUE, CURLOPT_POSTFIELDS => $post, CURLOPT_HTTPHEADER => $headers));
  1883. // Ensure that any changes to variables in the other thread are picked up.
  1884. $this->refreshVariables();
  1885. // Replace original page output with new output from redirected page(s).
  1886. if ($new = $this->checkForMetaRefresh()) {
  1887. $out = $new;
  1888. }
  1889. $this->verbose('POST request to: ' . $path .
  1890. '<hr />Ending URL: ' . $this->getUrl() .
  1891. '<hr />Fields: ' . highlight_string('<?php ' . var_export($post_array, TRUE), TRUE) .
  1892. '<hr />' . $out);
  1893. return $out;
  1894. }
  1895. }
  1896. // We have not found a form which contained all fields of $edit.
  1897. foreach ($edit as $name => $value) {
  1898. $this->fail(t('Failed to set field @name to @value', array('@name' => $name, '@value' => $value)));
  1899. }
  1900. if (!$ajax && isset($submit)) {
  1901. $this->assertTrue($submit_matches, t('Found the @submit button', array('@submit' => $submit)));
  1902. }
  1903. $this->fail(t('Found the requested form fields at @path', array('@path' => $path)));
  1904. }
  1905. }
  1906. /**
  1907. * Execute an Ajax submission.
  1908. *
  1909. * This executes a POST as ajax.js does. It uses the returned JSON data, an
  1910. * array of commands, to update $this->content using equivalent DOM
  1911. * manipulation as is used by ajax.js. It also returns the array of commands.
  1912. *
  1913. * @param $path
  1914. * Location of the form containing the Ajax enabled element to test. Can be
  1915. * either a Drupal path or an absolute path or NULL to use the current page.
  1916. * @param $edit
  1917. * Field data in an associative array. Changes the current input fields
  1918. * (where possible) to the values indicated.
  1919. * @param $triggering_element
  1920. * The name of the form element that is responsible for triggering the Ajax
  1921. * functionality to test. May be a string or, if the triggering element is
  1922. * a button, an associative array where the key is the name of the button
  1923. * and the value is the button label. i.e.) array('op' => t('Refresh')).
  1924. * @param $ajax_path
  1925. * (optional) Override the path set by the Ajax settings of the triggering
  1926. * element. In the absence of both the triggering element's Ajax path and
  1927. * $ajax_path 'system/ajax' will be used.
  1928. * @param $options
  1929. * (optional) Options to be forwarded to url().
  1930. * @param $headers
  1931. * (optional) An array containing additional HTTP request headers, each
  1932. * formatted as "name: value". Forwarded to drupalPost().
  1933. * @param $form_html_id
  1934. * (optional) HTML ID of the form to be submitted, use when there is more
  1935. * than one identical form on the same page and the value of the triggering
  1936. * element is not enough to identify the form. Note this is not the Drupal
  1937. * ID of the form but rather the HTML ID of the form.
  1938. * @param $ajax_settings
  1939. * (optional) An array of Ajax settings which if specified will be used in
  1940. * place of the Ajax settings of the triggering element.
  1941. *
  1942. * @return
  1943. * An array of Ajax commands.
  1944. *
  1945. * @see drupalPost()
  1946. * @see ajax.js
  1947. */
  1948. protected function drupalPostAJAX($path, $edit, $triggering_element, $ajax_path = NULL, array $options = array(), array $headers = array(), $form_html_id = NULL, $ajax_settings = NULL) {
  1949. // Get the content of the initial page prior to calling drupalPost(), since
  1950. // drupalPost() replaces $this->content.
  1951. if (isset($path)) {
  1952. $this->drupalGet($path, $options);
  1953. }
  1954. $content = $this->content;
  1955. $drupal_settings = $this->drupalSettings;
  1956. // Get the Ajax settings bound to the triggering element.
  1957. if (!isset($ajax_settings)) {
  1958. if (is_array($triggering_element)) {
  1959. $xpath = '//*[@name="' . key($triggering_element) . '" and @value="' . current($triggering_element) . '"]';
  1960. }
  1961. else {
  1962. $xpath = '//*[@name="' . $triggering_element . '"]';
  1963. }
  1964. if (isset($form_html_id)) {
  1965. $xpath = '//form[@id="' . $form_html_id . '"]' . $xpath;
  1966. }
  1967. $element = $this->xpath($xpath);
  1968. $element_id = (string) $element[0]['id'];
  1969. $ajax_settings = $drupal_settings['ajax'][$element_id];
  1970. }
  1971. // Add extra information to the POST data as ajax.js does.
  1972. $extra_post = '';
  1973. if (isset($ajax_settings['submit'])) {
  1974. foreach ($ajax_settings['submit'] as $key => $value) {
  1975. $extra_post .= '&' . urlencode($key) . '=' . urlencode($value);
  1976. }
  1977. }
  1978. foreach ($this->xpath('//*[@id]') as $element) {
  1979. $id = (string) $element['id'];
  1980. $extra_post .= '&' . urlencode('ajax_html_ids[]') . '=' . urlencode($id);
  1981. }
  1982. if (isset($drupal_settings['ajaxPageState'])) {
  1983. $extra_post .= '&' . urlencode('ajax_page_state[theme]') . '=' . urlencode($drupal_settings['ajaxPageState']['theme']);
  1984. $extra_post .= '&' . urlencode('ajax_page_state[theme_token]') . '=' . urlencode($drupal_settings['ajaxPageState']['theme_token']);
  1985. foreach ($drupal_settings['ajaxPageState']['css'] as $key => $value) {
  1986. $extra_post .= '&' . urlencode("ajax_page_state[css][$key]") . '=1';
  1987. }
  1988. foreach ($drupal_settings['ajaxPageState']['js'] as $key => $value) {
  1989. $extra_post .= '&' . urlencode("ajax_page_state[js][$key]") . '=1';
  1990. }
  1991. }
  1992. // Unless a particular path is specified, use the one specified by the
  1993. // Ajax settings, or else 'system/ajax'.
  1994. if (!isset($ajax_path)) {
  1995. $ajax_path = isset($ajax_settings['url']) ? $ajax_settings['url'] : 'system/ajax';
  1996. }
  1997. // Submit the POST request.
  1998. $return = drupal_json_decode($this->drupalPost(NULL, $edit, array('path' => $ajax_path, 'triggering_element' => $triggering_element), $options, $headers, $form_html_id, $extra_post));
  1999. // Change the page content by applying the returned commands.
  2000. if (!empty($ajax_settings) && !empty($return)) {
  2001. // ajax.js applies some defaults to the settings object, so do the same
  2002. // for what's used by this function.
  2003. $ajax_settings += array(
  2004. 'method' => 'replaceWith',
  2005. );
  2006. // DOM can load HTML soup. But, HTML soup can throw warnings, suppress
  2007. // them.
  2008. $dom = new DOMDocument();
  2009. @$dom->loadHTML($content);
  2010. // XPath allows for finding wrapper nodes better than DOM does.
  2011. $xpath = new DOMXPath($dom);
  2012. foreach ($return as $command) {
  2013. switch ($command['command']) {
  2014. case 'settings':
  2015. $drupal_settings = drupal_array_merge_deep($drupal_settings, $command['settings']);
  2016. break;
  2017. case 'insert':
  2018. $wrapperNode = NULL;
  2019. // When a command doesn't specify a selector, use the
  2020. // #ajax['wrapper'] which is always an HTML ID.
  2021. if (!isset($command['selector'])) {
  2022. $wrapperNode = $xpath->query('//*[@id="' . $ajax_settings['wrapper'] . '"]')->item(0);
  2023. }
  2024. // @todo Ajax commands can target any jQuery selector, but these are
  2025. // hard to fully emulate with XPath. For now, just handle 'head'
  2026. // and 'body', since these are used by ajax_render().
  2027. elseif (in_array($command['selector'], array('head', 'body'))) {
  2028. $wrapperNode = $xpath->query('//' . $command['selector'])->item(0);
  2029. }
  2030. if ($wrapperNode) {
  2031. // ajax.js adds an enclosing DIV to work around a Safari bug.
  2032. $newDom = new DOMDocument();
  2033. $newDom->loadHTML('<div>' . $command['data'] . '</div>');
  2034. $newNode = $dom->importNode($newDom->documentElement->firstChild->firstChild, TRUE);
  2035. $method = isset($command['method']) ? $command['method'] : $ajax_settings['method'];
  2036. // The "method" is a jQuery DOM manipulation function. Emulate
  2037. // each one using PHP's DOMNode API.
  2038. switch ($method) {
  2039. case 'replaceWith':
  2040. $wrapperNode->parentNode->replaceChild($newNode, $wrapperNode);
  2041. break;
  2042. case 'append':
  2043. $wrapperNode->appendChild($newNode);
  2044. break;
  2045. case 'prepend':
  2046. // If no firstChild, insertBefore() falls back to
  2047. // appendChild().
  2048. $wrapperNode->insertBefore($newNode, $wrapperNode->firstChild);
  2049. break;
  2050. case 'before':
  2051. $wrapperNode->parentNode->insertBefore($newNode, $wrapperNode);
  2052. break;
  2053. case 'after':
  2054. // If no nextSibling, insertBefore() falls back to
  2055. // appendChild().
  2056. $wrapperNode->parentNode->insertBefore($newNode, $wrapperNode->nextSibling);
  2057. break;
  2058. case 'html':
  2059. foreach ($wrapperNode->childNodes as $childNode) {
  2060. $wrapperNode->removeChild($childNode);
  2061. }
  2062. $wrapperNode->appendChild($newNode);
  2063. break;
  2064. }
  2065. }
  2066. break;
  2067. case 'updateBuildId':
  2068. $buildId = $xpath->query('//input[@name="form_build_id" and @value="' . $command['old'] . '"]')->item(0);
  2069. if ($buildId) {
  2070. $buildId->setAttribute('value', $command['new']);
  2071. }
  2072. break;
  2073. // @todo Add suitable implementations for these commands in order to
  2074. // have full test coverage of what ajax.js can do.
  2075. case 'remove':
  2076. break;
  2077. case 'changed':
  2078. break;
  2079. case 'css':
  2080. break;
  2081. case 'data':
  2082. break;
  2083. case 'restripe':
  2084. break;
  2085. case 'add_css':
  2086. break;
  2087. }
  2088. }
  2089. $content = $dom->saveHTML();
  2090. }
  2091. $this->drupalSetContent($content);
  2092. $this->drupalSetSettings($drupal_settings);
  2093. $verbose = 'AJAX POST request to: ' . $path;
  2094. $verbose .= '<br />AJAX callback path: ' . $ajax_path;
  2095. $verbose .= '<hr />Ending URL: ' . $this->getUrl();
  2096. $verbose .= '<hr />' . $this->content;
  2097. $this->verbose($verbose);
  2098. return $return;
  2099. }
  2100. /**
  2101. * Runs cron in the Drupal installed by Simpletest.
  2102. */
  2103. protected function cronRun() {
  2104. $this->drupalGet($GLOBALS['base_url'] . '/cron.php', array('external' => TRUE, 'query' => array('cron_key' => variable_get('cron_key', 'drupal'))));
  2105. }
  2106. /**
  2107. * Check for meta refresh tag and if found call drupalGet() recursively. This
  2108. * function looks for the http-equiv attribute to be set to "Refresh"
  2109. * and is case-sensitive.
  2110. *
  2111. * @return
  2112. * Either the new page content or FALSE.
  2113. */
  2114. protected function checkForMetaRefresh() {
  2115. if (strpos($this->drupalGetContent(), '<meta ') && $this->parse()) {
  2116. $refresh = $this->xpath('//meta[@http-equiv="Refresh"]');
  2117. if (!empty($refresh)) {
  2118. // Parse the content attribute of the meta tag for the format:
  2119. // "[delay]: URL=[page_to_redirect_to]".
  2120. if (preg_match('/\d+;\s*URL=(?P<url>.*)/i', $refresh[0]['content'], $match)) {
  2121. return $this->drupalGet($this->getAbsoluteUrl(decode_entities($match['url'])));
  2122. }
  2123. }
  2124. }
  2125. return FALSE;
  2126. }
  2127. /**
  2128. * Retrieves only the headers for a Drupal path or an absolute path.
  2129. *
  2130. * @param $path
  2131. * Drupal path or URL to load into internal browser
  2132. * @param $options
  2133. * Options to be forwarded to url().
  2134. * @param $headers
  2135. * An array containing additional HTTP request headers, each formatted as
  2136. * "name: value".
  2137. * @return
  2138. * The retrieved headers, also available as $this->drupalGetContent()
  2139. */
  2140. protected function drupalHead($path, array $options = array(), array $headers = array()) {
  2141. $options['absolute'] = TRUE;
  2142. $out = $this->curlExec(array(CURLOPT_NOBODY => TRUE, CURLOPT_URL => url($path, $options), CURLOPT_HTTPHEADER => $headers));
  2143. $this->refreshVariables(); // Ensure that any changes to variables in the other thread are picked up.
  2144. return $out;
  2145. }
  2146. /**
  2147. * Handle form input related to drupalPost(). Ensure that the specified fields
  2148. * exist and attempt to create POST data in the correct manner for the particular
  2149. * field type.
  2150. *
  2151. * @param $post
  2152. * Reference to array of post values.
  2153. * @param $edit
  2154. * Reference to array of edit values to be checked against the form.
  2155. * @param $submit
  2156. * Form submit button value.
  2157. * @param $form
  2158. * Array of form elements.
  2159. * @return
  2160. * Submit value matches a valid submit input in the form.
  2161. */
  2162. protected function handleForm(&$post, &$edit, &$upload, $submit, $form) {
  2163. // Retrieve the form elements.
  2164. $elements = $form->xpath('.//input[not(@disabled)]|.//textarea[not(@disabled)]|.//select[not(@disabled)]');
  2165. $submit_matches = FALSE;
  2166. foreach ($elements as $element) {
  2167. // SimpleXML objects need string casting all the time.
  2168. $name = (string) $element['name'];
  2169. // This can either be the type of <input> or the name of the tag itself
  2170. // for <select> or <textarea>.
  2171. $type = isset($element['type']) ? (string) $element['type'] : $element->getName();
  2172. $value = isset($element['value']) ? (string) $element['value'] : '';
  2173. $done = FALSE;
  2174. if (isset($edit[$name])) {
  2175. switch ($type) {
  2176. case 'text':
  2177. case 'tel':
  2178. case 'textarea':
  2179. case 'url':
  2180. case 'number':
  2181. case 'range':
  2182. case 'color':
  2183. case 'hidden':
  2184. case 'password':
  2185. case 'email':
  2186. case 'search':
  2187. $post[$name] = $edit[$name];
  2188. unset($edit[$name]);
  2189. break;
  2190. case 'radio':
  2191. if ($edit[$name] == $value) {
  2192. $post[$name] = $edit[$name];
  2193. unset($edit[$name]);
  2194. }
  2195. break;
  2196. case 'checkbox':
  2197. // To prevent checkbox from being checked.pass in a FALSE,
  2198. // otherwise the checkbox will be set to its value regardless
  2199. // of $edit.
  2200. if ($edit[$name] === FALSE) {
  2201. unset($edit[$name]);
  2202. continue 2;
  2203. }
  2204. else {
  2205. unset($edit[$name]);
  2206. $post[$name] = $value;
  2207. }
  2208. break;
  2209. case 'select':
  2210. $new_value = $edit[$name];
  2211. $options = $this->getAllOptions($element);
  2212. if (is_array($new_value)) {
  2213. // Multiple select box.
  2214. if (!empty($new_value)) {
  2215. $index = 0;
  2216. $key = preg_replace('/\[\]$/', '', $name);
  2217. foreach ($options as $option) {
  2218. $option_value = (string) $option['value'];
  2219. if (in_array($option_value, $new_value)) {
  2220. $post[$key . '[' . $index++ . ']'] = $option_value;
  2221. $done = TRUE;
  2222. unset($edit[$name]);
  2223. }
  2224. }
  2225. }
  2226. else {
  2227. // No options selected: do not include any POST data for the
  2228. // element.
  2229. $done = TRUE;
  2230. unset($edit[$name]);
  2231. }
  2232. }
  2233. else {
  2234. // Single select box.
  2235. foreach ($options as $option) {
  2236. if ($new_value == $option['value']) {
  2237. $post[$name] = $new_value;
  2238. unset($edit[$name]);
  2239. $done = TRUE;
  2240. break;
  2241. }
  2242. }
  2243. }
  2244. break;
  2245. case 'file':
  2246. $upload[$name] = $edit[$name];
  2247. unset($edit[$name]);
  2248. break;
  2249. }
  2250. }
  2251. if (!isset($post[$name]) && !$done) {
  2252. switch ($type) {
  2253. case 'textarea':
  2254. $post[$name] = (string) $element;
  2255. break;
  2256. case 'select':
  2257. $single = empty($element['multiple']);
  2258. $first = TRUE;
  2259. $index = 0;
  2260. $key = preg_replace('/\[\]$/', '', $name);
  2261. $options = $this->getAllOptions($element);
  2262. foreach ($options as $option) {
  2263. // For single select, we load the first option, if there is a
  2264. // selected option that will overwrite it later.
  2265. if ($option['selected'] || ($first && $single)) {
  2266. $first = FALSE;
  2267. if ($single) {
  2268. $post[$name] = (string) $option['value'];
  2269. }
  2270. else {
  2271. $post[$key . '[' . $index++ . ']'] = (string) $option['value'];
  2272. }
  2273. }
  2274. }
  2275. break;
  2276. case 'file':
  2277. break;
  2278. case 'submit':
  2279. case 'image':
  2280. if (isset($submit) && $submit == $value) {
  2281. $post[$name] = $value;
  2282. $submit_matches = TRUE;
  2283. }
  2284. break;
  2285. case 'radio':
  2286. case 'checkbox':
  2287. if (!isset($element['checked'])) {
  2288. break;
  2289. }
  2290. // Deliberate no break.
  2291. default:
  2292. $post[$name] = $value;
  2293. }
  2294. }
  2295. }
  2296. return $submit_matches;
  2297. }
  2298. /**
  2299. * Builds an XPath query.
  2300. *
  2301. * Builds an XPath query by replacing placeholders in the query by the value
  2302. * of the arguments.
  2303. *
  2304. * XPath 1.0 (the version supported by libxml2, the underlying XML library
  2305. * used by PHP) doesn't support any form of quotation. This function
  2306. * simplifies the building of XPath expression.
  2307. *
  2308. * @param $xpath
  2309. * An XPath query, possibly with placeholders in the form ':name'.
  2310. * @param $args
  2311. * An array of arguments with keys in the form ':name' matching the
  2312. * placeholders in the query. The values may be either strings or numeric
  2313. * values.
  2314. * @return
  2315. * An XPath query with arguments replaced.
  2316. */
  2317. protected function buildXPathQuery($xpath, array $args = array()) {
  2318. // Replace placeholders.
  2319. foreach ($args as $placeholder => $value) {
  2320. // XPath 1.0 doesn't support a way to escape single or double quotes in a
  2321. // string literal. We split double quotes out of the string, and encode
  2322. // them separately.
  2323. if (is_string($value)) {
  2324. // Explode the text at the quote characters.
  2325. $parts = explode('"', $value);
  2326. // Quote the parts.
  2327. foreach ($parts as &$part) {
  2328. $part = '"' . $part . '"';
  2329. }
  2330. // Return the string.
  2331. $value = count($parts) > 1 ? 'concat(' . implode(', \'"\', ', $parts) . ')' : $parts[0];
  2332. }
  2333. $xpath = preg_replace('/' . preg_quote($placeholder) . '\b/', $value, $xpath);
  2334. }
  2335. return $xpath;
  2336. }
  2337. /**
  2338. * Perform an xpath search on the contents of the internal browser. The search
  2339. * is relative to the root element (HTML tag normally) of the page.
  2340. *
  2341. * @param $xpath
  2342. * The xpath string to use in the search.
  2343. * @return
  2344. * The return value of the xpath search. For details on the xpath string
  2345. * format and return values see the SimpleXML documentation,
  2346. * http://us.php.net/manual/function.simplexml-element-xpath.php.
  2347. */
  2348. protected function xpath($xpath, array $arguments = array()) {
  2349. if ($this->parse()) {
  2350. $xpath = $this->buildXPathQuery($xpath, $arguments);
  2351. $result = $this->elements->xpath($xpath);
  2352. // Some combinations of PHP / libxml versions return an empty array
  2353. // instead of the documented FALSE. Forcefully convert any falsish values
  2354. // to an empty array to allow foreach(...) constructions.
  2355. return $result ? $result : array();
  2356. }
  2357. else {
  2358. return FALSE;
  2359. }
  2360. }
  2361. /**
  2362. * Get all option elements, including nested options, in a select.
  2363. *
  2364. * @param $element
  2365. * The element for which to get the options.
  2366. * @return
  2367. * Option elements in select.
  2368. */
  2369. protected function getAllOptions(SimpleXMLElement $element) {
  2370. $options = array();
  2371. // Add all options items.
  2372. foreach ($element->option as $option) {
  2373. $options[] = $option;
  2374. }
  2375. // Search option group children.
  2376. if (isset($element->optgroup)) {
  2377. foreach ($element->optgroup as $group) {
  2378. $options = array_merge($options, $this->getAllOptions($group));
  2379. }
  2380. }
  2381. return $options;
  2382. }
  2383. /**
  2384. * Pass if a link with the specified label is found, and optional with the
  2385. * specified index.
  2386. *
  2387. * @param $label
  2388. * Text between the anchor tags.
  2389. * @param $index
  2390. * Link position counting from zero.
  2391. * @param $message
  2392. * Message to display.
  2393. * @param $group
  2394. * The group this message belongs to, defaults to 'Other'.
  2395. * @return
  2396. * TRUE if the assertion succeeded, FALSE otherwise.
  2397. */
  2398. protected function assertLink($label, $index = 0, $message = '', $group = 'Other') {
  2399. $links = $this->xpath('//a[normalize-space(text())=:label]', array(':label' => $label));
  2400. $message = ($message ? $message : t('Link with label %label found.', array('%label' => $label)));
  2401. return $this->assert(isset($links[$index]), $message, $group);
  2402. }
  2403. /**
  2404. * Pass if a link with the specified label is not found.
  2405. *
  2406. * @param $label
  2407. * Text between the anchor tags.
  2408. * @param $message
  2409. * Message to display.
  2410. * @param $group
  2411. * The group this message belongs to, defaults to 'Other'.
  2412. * @return
  2413. * TRUE if the assertion succeeded, FALSE otherwise.
  2414. */
  2415. protected function assertNoLink($label, $message = '', $group = 'Other') {
  2416. $links = $this->xpath('//a[normalize-space(text())=:label]', array(':label' => $label));
  2417. $message = ($message ? $message : t('Link with label %label not found.', array('%label' => $label)));
  2418. return $this->assert(empty($links), $message, $group);
  2419. }
  2420. /**
  2421. * Pass if a link containing a given href (part) is found.
  2422. *
  2423. * @param $href
  2424. * The full or partial value of the 'href' attribute of the anchor tag.
  2425. * @param $index
  2426. * Link position counting from zero.
  2427. * @param $message
  2428. * Message to display.
  2429. * @param $group
  2430. * The group this message belongs to, defaults to 'Other'.
  2431. *
  2432. * @return
  2433. * TRUE if the assertion succeeded, FALSE otherwise.
  2434. */
  2435. protected function assertLinkByHref($href, $index = 0, $message = '', $group = 'Other') {
  2436. $links = $this->xpath('//a[contains(@href, :href)]', array(':href' => $href));
  2437. $message = ($message ? $message : t('Link containing href %href found.', array('%href' => $href)));
  2438. return $this->assert(isset($links[$index]), $message, $group);
  2439. }
  2440. /**
  2441. * Pass if a link containing a given href (part) is not found.
  2442. *
  2443. * @param $href
  2444. * The full or partial value of the 'href' attribute of the anchor tag.
  2445. * @param $message
  2446. * Message to display.
  2447. * @param $group
  2448. * The group this message belongs to, defaults to 'Other'.
  2449. *
  2450. * @return
  2451. * TRUE if the assertion succeeded, FALSE otherwise.
  2452. */
  2453. protected function assertNoLinkByHref($href, $message = '', $group = 'Other') {
  2454. $links = $this->xpath('//a[contains(@href, :href)]', array(':href' => $href));
  2455. $message = ($message ? $message : t('No link containing href %href found.', array('%href' => $href)));
  2456. return $this->assert(empty($links), $message, $group);
  2457. }
  2458. /**
  2459. * Follows a link by name.
  2460. *
  2461. * Will click the first link found with this link text by default, or a later
  2462. * one if an index is given. Match is case sensitive with normalized space.
  2463. * The label is translated label.
  2464. *
  2465. * If the link is discovered and clicked, the test passes. Fail otherwise.
  2466. *
  2467. * @param $label
  2468. * Text between the anchor tags.
  2469. * @param $index
  2470. * Link position counting from zero.
  2471. * @return
  2472. * Page contents on success, or FALSE on failure.
  2473. */
  2474. protected function clickLink($label, $index = 0) {
  2475. $url_before = $this->getUrl();
  2476. $urls = $this->xpath('//a[normalize-space(text())=:label]', array(':label' => $label));
  2477. if (isset($urls[$index])) {
  2478. $url_target = $this->getAbsoluteUrl($urls[$index]['href']);
  2479. $this->pass(t('Clicked link %label (@url_target) from @url_before', array('%label' => $label, '@url_target' => $url_target, '@url_before' => $url_before)), 'Browser');
  2480. return $this->drupalGet($url_target);
  2481. }
  2482. $this->fail(t('Link %label does not exist on @url_before', array('%label' => $label, '@url_before' => $url_before)), 'Browser');
  2483. return FALSE;
  2484. }
  2485. /**
  2486. * Takes a path and returns an absolute path.
  2487. *
  2488. * @param $path
  2489. * A path from the internal browser content.
  2490. * @return
  2491. * The $path with $base_url prepended, if necessary.
  2492. */
  2493. protected function getAbsoluteUrl($path) {
  2494. global $base_url, $base_path;
  2495. $parts = parse_url($path);
  2496. if (empty($parts['host'])) {
  2497. // Ensure that we have a string (and no xpath object).
  2498. $path = (string) $path;
  2499. // Strip $base_path, if existent.
  2500. $length = strlen($base_path);
  2501. if (substr($path, 0, $length) === $base_path) {
  2502. $path = substr($path, $length);
  2503. }
  2504. // Ensure that we have an absolute path.
  2505. if ($path[0] !== '/') {
  2506. $path = '/' . $path;
  2507. }
  2508. // Finally, prepend the $base_url.
  2509. $path = $base_url . $path;
  2510. }
  2511. return $path;
  2512. }
  2513. /**
  2514. * Get the current URL from the cURL handler.
  2515. *
  2516. * @return
  2517. * The current URL.
  2518. */
  2519. protected function getUrl() {
  2520. return $this->url;
  2521. }
  2522. /**
  2523. * Gets the HTTP response headers of the requested page. Normally we are only
  2524. * interested in the headers returned by the last request. However, if a page
  2525. * is redirected or HTTP authentication is in use, multiple requests will be
  2526. * required to retrieve the page. Headers from all requests may be requested
  2527. * by passing TRUE to this function.
  2528. *
  2529. * @param $all_requests
  2530. * Boolean value specifying whether to return headers from all requests
  2531. * instead of just the last request. Defaults to FALSE.
  2532. * @return
  2533. * A name/value array if headers from only the last request are requested.
  2534. * If headers from all requests are requested, an array of name/value
  2535. * arrays, one for each request.
  2536. *
  2537. * The pseudonym ":status" is used for the HTTP status line.
  2538. *
  2539. * Values for duplicate headers are stored as a single comma-separated list.
  2540. */
  2541. protected function drupalGetHeaders($all_requests = FALSE) {
  2542. $request = 0;
  2543. $headers = array($request => array());
  2544. foreach ($this->headers as $header) {
  2545. $header = trim($header);
  2546. if ($header === '') {
  2547. $request++;
  2548. }
  2549. else {
  2550. if (strpos($header, 'HTTP/') === 0) {
  2551. $name = ':status';
  2552. $value = $header;
  2553. }
  2554. else {
  2555. list($name, $value) = explode(':', $header, 2);
  2556. $name = strtolower($name);
  2557. }
  2558. if (isset($headers[$request][$name])) {
  2559. $headers[$request][$name] .= ',' . trim($value);
  2560. }
  2561. else {
  2562. $headers[$request][$name] = trim($value);
  2563. }
  2564. }
  2565. }
  2566. if (!$all_requests) {
  2567. $headers = array_pop($headers);
  2568. }
  2569. return $headers;
  2570. }
  2571. /**
  2572. * Gets the value of an HTTP response header. If multiple requests were
  2573. * required to retrieve the page, only the headers from the last request will
  2574. * be checked by default. However, if TRUE is passed as the second argument,
  2575. * all requests will be processed from last to first until the header is
  2576. * found.
  2577. *
  2578. * @param $name
  2579. * The name of the header to retrieve. Names are case-insensitive (see RFC
  2580. * 2616 section 4.2).
  2581. * @param $all_requests
  2582. * Boolean value specifying whether to check all requests if the header is
  2583. * not found in the last request. Defaults to FALSE.
  2584. * @return
  2585. * The HTTP header value or FALSE if not found.
  2586. */
  2587. protected function drupalGetHeader($name, $all_requests = FALSE) {
  2588. $name = strtolower($name);
  2589. $header = FALSE;
  2590. if ($all_requests) {
  2591. foreach (array_reverse($this->drupalGetHeaders(TRUE)) as $headers) {
  2592. if (isset($headers[$name])) {
  2593. $header = $headers[$name];
  2594. break;
  2595. }
  2596. }
  2597. }
  2598. else {
  2599. $headers = $this->drupalGetHeaders();
  2600. if (isset($headers[$name])) {
  2601. $header = $headers[$name];
  2602. }
  2603. }
  2604. return $header;
  2605. }
  2606. /**
  2607. * Gets the current raw HTML of requested page.
  2608. */
  2609. protected function drupalGetContent() {
  2610. return $this->content;
  2611. }
  2612. /**
  2613. * Gets the value of the Drupal.settings JavaScript variable for the currently loaded page.
  2614. */
  2615. protected function drupalGetSettings() {
  2616. return $this->drupalSettings;
  2617. }
  2618. /**
  2619. * Gets an array containing all e-mails sent during this test case.
  2620. *
  2621. * @param $filter
  2622. * An array containing key/value pairs used to filter the e-mails that are returned.
  2623. * @return
  2624. * An array containing e-mail messages captured during the current test.
  2625. */
  2626. protected function drupalGetMails($filter = array()) {
  2627. $captured_emails = variable_get('drupal_test_email_collector', array());
  2628. $filtered_emails = array();
  2629. foreach ($captured_emails as $message) {
  2630. foreach ($filter as $key => $value) {
  2631. if (!isset($message[$key]) || $message[$key] != $value) {
  2632. continue 2;
  2633. }
  2634. }
  2635. $filtered_emails[] = $message;
  2636. }
  2637. return $filtered_emails;
  2638. }
  2639. /**
  2640. * Sets the raw HTML content. This can be useful when a page has been fetched
  2641. * outside of the internal browser and assertions need to be made on the
  2642. * returned page.
  2643. *
  2644. * A good example would be when testing drupal_http_request(). After fetching
  2645. * the page the content can be set and page elements can be checked to ensure
  2646. * that the function worked properly.
  2647. */
  2648. protected function drupalSetContent($content, $url = 'internal:') {
  2649. $this->content = $content;
  2650. $this->url = $url;
  2651. $this->plainTextContent = FALSE;
  2652. $this->elements = FALSE;
  2653. $this->drupalSettings = array();
  2654. if (preg_match('/jQuery\.extend\(Drupal\.settings, (.*?)\);/', $content, $matches)) {
  2655. $this->drupalSettings = drupal_json_decode($matches[1]);
  2656. }
  2657. }
  2658. /**
  2659. * Sets the value of the Drupal.settings JavaScript variable for the currently loaded page.
  2660. */
  2661. protected function drupalSetSettings($settings) {
  2662. $this->drupalSettings = $settings;
  2663. }
  2664. /**
  2665. * Pass if the internal browser's URL matches the given path.
  2666. *
  2667. * @param $path
  2668. * The expected system path.
  2669. * @param $options
  2670. * (optional) Any additional options to pass for $path to url().
  2671. * @param $message
  2672. * Message to display.
  2673. * @param $group
  2674. * The group this message belongs to, defaults to 'Other'.
  2675. *
  2676. * @return
  2677. * TRUE on pass, FALSE on fail.
  2678. */
  2679. protected function assertUrl($path, array $options = array(), $message = '', $group = 'Other') {
  2680. if (!$message) {
  2681. $message = t('Current URL is @url.', array(
  2682. '@url' => var_export(url($path, $options), TRUE),
  2683. ));
  2684. }
  2685. $options['absolute'] = TRUE;
  2686. return $this->assertEqual($this->getUrl(), url($path, $options), $message, $group);
  2687. }
  2688. /**
  2689. * Pass if the raw text IS found on the loaded page, fail otherwise. Raw text
  2690. * refers to the raw HTML that the page generated.
  2691. *
  2692. * @param $raw
  2693. * Raw (HTML) string to look for.
  2694. * @param $message
  2695. * Message to display.
  2696. * @param $group
  2697. * The group this message belongs to, defaults to 'Other'.
  2698. * @return
  2699. * TRUE on pass, FALSE on fail.
  2700. */
  2701. protected function assertRaw($raw, $message = '', $group = 'Other') {
  2702. if (!$message) {
  2703. $message = t('Raw "@raw" found', array('@raw' => $raw));
  2704. }
  2705. return $this->assert(strpos($this->drupalGetContent(), $raw) !== FALSE, $message, $group);
  2706. }
  2707. /**
  2708. * Pass if the raw text is NOT found on the loaded page, fail otherwise. Raw text
  2709. * refers to the raw HTML that the page generated.
  2710. *
  2711. * @param $raw
  2712. * Raw (HTML) string to look for.
  2713. * @param $message
  2714. * Message to display.
  2715. * @param $group
  2716. * The group this message belongs to, defaults to 'Other'.
  2717. * @return
  2718. * TRUE on pass, FALSE on fail.
  2719. */
  2720. protected function assertNoRaw($raw, $message = '', $group = 'Other') {
  2721. if (!$message) {
  2722. $message = t('Raw "@raw" not found', array('@raw' => $raw));
  2723. }
  2724. return $this->assert(strpos($this->drupalGetContent(), $raw) === FALSE, $message, $group);
  2725. }
  2726. /**
  2727. * Pass if the text IS found on the text version of the page. The text version
  2728. * is the equivalent of what a user would see when viewing through a web browser.
  2729. * In other words the HTML has been filtered out of the contents.
  2730. *
  2731. * @param $text
  2732. * Plain text to look for.
  2733. * @param $message
  2734. * Message to display.
  2735. * @param $group
  2736. * The group this message belongs to, defaults to 'Other'.
  2737. * @return
  2738. * TRUE on pass, FALSE on fail.
  2739. */
  2740. protected function assertText($text, $message = '', $group = 'Other') {
  2741. return $this->assertTextHelper($text, $message, $group, FALSE);
  2742. }
  2743. /**
  2744. * Pass if the text is NOT found on the text version of the page. The text version
  2745. * is the equivalent of what a user would see when viewing through a web browser.
  2746. * In other words the HTML has been filtered out of the contents.
  2747. *
  2748. * @param $text
  2749. * Plain text to look for.
  2750. * @param $message
  2751. * Message to display.
  2752. * @param $group
  2753. * The group this message belongs to, defaults to 'Other'.
  2754. * @return
  2755. * TRUE on pass, FALSE on fail.
  2756. */
  2757. protected function assertNoText($text, $message = '', $group = 'Other') {
  2758. return $this->assertTextHelper($text, $message, $group, TRUE);
  2759. }
  2760. /**
  2761. * Helper for assertText and assertNoText.
  2762. *
  2763. * It is not recommended to call this function directly.
  2764. *
  2765. * @param $text
  2766. * Plain text to look for.
  2767. * @param $message
  2768. * Message to display.
  2769. * @param $group
  2770. * The group this message belongs to.
  2771. * @param $not_exists
  2772. * TRUE if this text should not exist, FALSE if it should.
  2773. * @return
  2774. * TRUE on pass, FALSE on fail.
  2775. */
  2776. protected function assertTextHelper($text, $message = '', $group, $not_exists) {
  2777. if ($this->plainTextContent === FALSE) {
  2778. $this->plainTextContent = filter_xss($this->drupalGetContent(), array());
  2779. }
  2780. if (!$message) {
  2781. $message = !$not_exists ? t('"@text" found', array('@text' => $text)) : t('"@text" not found', array('@text' => $text));
  2782. }
  2783. return $this->assert($not_exists == (strpos($this->plainTextContent, $text) === FALSE), $message, $group);
  2784. }
  2785. /**
  2786. * Pass if the text is found ONLY ONCE on the text version of the page.
  2787. *
  2788. * The text version is the equivalent of what a user would see when viewing
  2789. * through a web browser. In other words the HTML has been filtered out of
  2790. * the contents.
  2791. *
  2792. * @param $text
  2793. * Plain text to look for.
  2794. * @param $message
  2795. * Message to display.
  2796. * @param $group
  2797. * The group this message belongs to, defaults to 'Other'.
  2798. * @return
  2799. * TRUE on pass, FALSE on fail.
  2800. */
  2801. protected function assertUniqueText($text, $message = '', $group = 'Other') {
  2802. return $this->assertUniqueTextHelper($text, $message, $group, TRUE);
  2803. }
  2804. /**
  2805. * Pass if the text is found MORE THAN ONCE on the text version of the page.
  2806. *
  2807. * The text version is the equivalent of what a user would see when viewing
  2808. * through a web browser. In other words the HTML has been filtered out of
  2809. * the contents.
  2810. *
  2811. * @param $text
  2812. * Plain text to look for.
  2813. * @param $message
  2814. * Message to display.
  2815. * @param $group
  2816. * The group this message belongs to, defaults to 'Other'.
  2817. * @return
  2818. * TRUE on pass, FALSE on fail.
  2819. */
  2820. protected function assertNoUniqueText($text, $message = '', $group = 'Other') {
  2821. return $this->assertUniqueTextHelper($text, $message, $group, FALSE);
  2822. }
  2823. /**
  2824. * Helper for assertUniqueText and assertNoUniqueText.
  2825. *
  2826. * It is not recommended to call this function directly.
  2827. *
  2828. * @param $text
  2829. * Plain text to look for.
  2830. * @param $message
  2831. * Message to display.
  2832. * @param $group
  2833. * The group this message belongs to.
  2834. * @param $be_unique
  2835. * TRUE if this text should be found only once, FALSE if it should be found more than once.
  2836. * @return
  2837. * TRUE on pass, FALSE on fail.
  2838. */
  2839. protected function assertUniqueTextHelper($text, $message = '', $group, $be_unique) {
  2840. if ($this->plainTextContent === FALSE) {
  2841. $this->plainTextContent = filter_xss($this->drupalGetContent(), array());
  2842. }
  2843. if (!$message) {
  2844. $message = '"' . $text . '"' . ($be_unique ? ' found only once' : ' found more than once');
  2845. }
  2846. $first_occurance = strpos($this->plainTextContent, $text);
  2847. if ($first_occurance === FALSE) {
  2848. return $this->assert(FALSE, $message, $group);
  2849. }
  2850. $offset = $first_occurance + strlen($text);
  2851. $second_occurance = strpos($this->plainTextContent, $text, $offset);
  2852. return $this->assert($be_unique == ($second_occurance === FALSE), $message, $group);
  2853. }
  2854. /**
  2855. * Will trigger a pass if the Perl regex pattern is found in the raw content.
  2856. *
  2857. * @param $pattern
  2858. * Perl regex to look for including the regex delimiters.
  2859. * @param $message
  2860. * Message to display.
  2861. * @param $group
  2862. * The group this message belongs to.
  2863. * @return
  2864. * TRUE on pass, FALSE on fail.
  2865. */
  2866. protected function assertPattern($pattern, $message = '', $group = 'Other') {
  2867. if (!$message) {
  2868. $message = t('Pattern "@pattern" found', array('@pattern' => $pattern));
  2869. }
  2870. return $this->assert((bool) preg_match($pattern, $this->drupalGetContent()), $message, $group);
  2871. }
  2872. /**
  2873. * Will trigger a pass if the perl regex pattern is not present in raw content.
  2874. *
  2875. * @param $pattern
  2876. * Perl regex to look for including the regex delimiters.
  2877. * @param $message
  2878. * Message to display.
  2879. * @param $group
  2880. * The group this message belongs to.
  2881. * @return
  2882. * TRUE on pass, FALSE on fail.
  2883. */
  2884. protected function assertNoPattern($pattern, $message = '', $group = 'Other') {
  2885. if (!$message) {
  2886. $message = t('Pattern "@pattern" not found', array('@pattern' => $pattern));
  2887. }
  2888. return $this->assert(!preg_match($pattern, $this->drupalGetContent()), $message, $group);
  2889. }
  2890. /**
  2891. * Pass if the page title is the given string.
  2892. *
  2893. * @param $title
  2894. * The string the title should be.
  2895. * @param $message
  2896. * Message to display.
  2897. * @param $group
  2898. * The group this message belongs to.
  2899. * @return
  2900. * TRUE on pass, FALSE on fail.
  2901. */
  2902. protected function assertTitle($title, $message = '', $group = 'Other') {
  2903. $actual = (string) current($this->xpath('//title'));
  2904. if (!$message) {
  2905. $message = t('Page title @actual is equal to @expected.', array(
  2906. '@actual' => var_export($actual, TRUE),
  2907. '@expected' => var_export($title, TRUE),
  2908. ));
  2909. }
  2910. return $this->assertEqual($actual, $title, $message, $group);
  2911. }
  2912. /**
  2913. * Pass if the page title is not the given string.
  2914. *
  2915. * @param $title
  2916. * The string the title should not be.
  2917. * @param $message
  2918. * Message to display.
  2919. * @param $group
  2920. * The group this message belongs to.
  2921. * @return
  2922. * TRUE on pass, FALSE on fail.
  2923. */
  2924. protected function assertNoTitle($title, $message = '', $group = 'Other') {
  2925. $actual = (string) current($this->xpath('//title'));
  2926. if (!$message) {
  2927. $message = t('Page title @actual is not equal to @unexpected.', array(
  2928. '@actual' => var_export($actual, TRUE),
  2929. '@unexpected' => var_export($title, TRUE),
  2930. ));
  2931. }
  2932. return $this->assertNotEqual($actual, $title, $message, $group);
  2933. }
  2934. /**
  2935. * Asserts themed output.
  2936. *
  2937. * @param $callback
  2938. * The name of the theme function to invoke; e.g. 'links' for theme_links().
  2939. * @param $variables
  2940. * (optional) An array of variables to pass to the theme function.
  2941. * @param $expected
  2942. * The expected themed output string.
  2943. * @param $message
  2944. * (optional) A message to display with the assertion. Do not translate
  2945. * messages: use format_string() to embed variables in the message text, not
  2946. * t(). If left blank, a default message will be displayed.
  2947. * @param $group
  2948. * (optional) The group this message is in, which is displayed in a column
  2949. * in test output. Use 'Debug' to indicate this is debugging output. Do not
  2950. * translate this string. Defaults to 'Other'; most tests do not override
  2951. * this default.
  2952. *
  2953. * @return
  2954. * TRUE on pass, FALSE on fail.
  2955. */
  2956. protected function assertThemeOutput($callback, array $variables = array(), $expected, $message = '', $group = 'Other') {
  2957. $output = theme($callback, $variables);
  2958. $this->verbose('Variables:' . '<pre>' . check_plain(var_export($variables, TRUE)) . '</pre>'
  2959. . '<hr />' . 'Result:' . '<pre>' . check_plain(var_export($output, TRUE)) . '</pre>'
  2960. . '<hr />' . 'Expected:' . '<pre>' . check_plain(var_export($expected, TRUE)) . '</pre>'
  2961. . '<hr />' . $output
  2962. );
  2963. if (!$message) {
  2964. $message = '%callback rendered correctly.';
  2965. }
  2966. $message = format_string($message, array('%callback' => 'theme_' . $callback . '()'));
  2967. return $this->assertIdentical($output, $expected, $message, $group);
  2968. }
  2969. /**
  2970. * Asserts that a field exists in the current page by the given XPath.
  2971. *
  2972. * @param $xpath
  2973. * XPath used to find the field.
  2974. * @param $value
  2975. * (optional) Value of the field to assert. You may pass in NULL (default)
  2976. * to skip checking the actual value, while still checking that the field
  2977. * exists.
  2978. * @param $message
  2979. * (optional) Message to display.
  2980. * @param $group
  2981. * (optional) The group this message belongs to.
  2982. *
  2983. * @return
  2984. * TRUE on pass, FALSE on fail.
  2985. */
  2986. protected function assertFieldByXPath($xpath, $value = NULL, $message = '', $group = 'Other') {
  2987. $fields = $this->xpath($xpath);
  2988. // If value specified then check array for match.
  2989. $found = TRUE;
  2990. if (isset($value)) {
  2991. $found = FALSE;
  2992. if ($fields) {
  2993. foreach ($fields as $field) {
  2994. if (isset($field['value']) && $field['value'] == $value) {
  2995. // Input element with correct value.
  2996. $found = TRUE;
  2997. }
  2998. elseif (isset($field->option)) {
  2999. // Select element found.
  3000. if ($this->getSelectedItem($field) == $value) {
  3001. $found = TRUE;
  3002. }
  3003. else {
  3004. // No item selected so use first item.
  3005. $items = $this->getAllOptions($field);
  3006. if (!empty($items) && $items[0]['value'] == $value) {
  3007. $found = TRUE;
  3008. }
  3009. }
  3010. }
  3011. elseif ((string) $field == $value) {
  3012. // Text area with correct text.
  3013. $found = TRUE;
  3014. }
  3015. }
  3016. }
  3017. }
  3018. return $this->assertTrue($fields && $found, $message, $group);
  3019. }
  3020. /**
  3021. * Get the selected value from a select field.
  3022. *
  3023. * @param $element
  3024. * SimpleXMLElement select element.
  3025. * @return
  3026. * The selected value or FALSE.
  3027. */
  3028. protected function getSelectedItem(SimpleXMLElement $element) {
  3029. foreach ($element->children() as $item) {
  3030. if (isset($item['selected'])) {
  3031. return $item['value'];
  3032. }
  3033. elseif ($item->getName() == 'optgroup') {
  3034. if ($value = $this->getSelectedItem($item)) {
  3035. return $value;
  3036. }
  3037. }
  3038. }
  3039. return FALSE;
  3040. }
  3041. /**
  3042. * Asserts that a field doesn't exist or its value doesn't match, by XPath.
  3043. *
  3044. * @param $xpath
  3045. * XPath used to find the field.
  3046. * @param $value
  3047. * (optional) Value for the field, to assert that the field's value on the
  3048. * page doesn't match it. You may pass in NULL to skip checking the
  3049. * value, while still checking that the field doesn't exist.
  3050. * @param $message
  3051. * (optional) Message to display.
  3052. * @param $group
  3053. * (optional) The group this message belongs to.
  3054. *
  3055. * @return
  3056. * TRUE on pass, FALSE on fail.
  3057. */
  3058. protected function assertNoFieldByXPath($xpath, $value = NULL, $message = '', $group = 'Other') {
  3059. $fields = $this->xpath($xpath);
  3060. // If value specified then check array for match.
  3061. $found = TRUE;
  3062. if (isset($value)) {
  3063. $found = FALSE;
  3064. if ($fields) {
  3065. foreach ($fields as $field) {
  3066. if ($field['value'] == $value) {
  3067. $found = TRUE;
  3068. }
  3069. }
  3070. }
  3071. }
  3072. return $this->assertFalse($fields && $found, $message, $group);
  3073. }
  3074. /**
  3075. * Asserts that a field exists in the current page with the given name and value.
  3076. *
  3077. * @param $name
  3078. * Name of field to assert.
  3079. * @param $value
  3080. * (optional) Value of the field to assert. You may pass in NULL (default)
  3081. * to skip checking the actual value, while still checking that the field
  3082. * exists.
  3083. * @param $message
  3084. * Message to display.
  3085. * @param $group
  3086. * The group this message belongs to.
  3087. * @return
  3088. * TRUE on pass, FALSE on fail.
  3089. */
  3090. protected function assertFieldByName($name, $value = NULL, $message = NULL) {
  3091. if (!isset($message)) {
  3092. if (!isset($value)) {
  3093. $message = t('Found field with name @name', array(
  3094. '@name' => var_export($name, TRUE),
  3095. ));
  3096. }
  3097. else {
  3098. $message = t('Found field with name @name and value @value', array(
  3099. '@name' => var_export($name, TRUE),
  3100. '@value' => var_export($value, TRUE),
  3101. ));
  3102. }
  3103. }
  3104. return $this->assertFieldByXPath($this->constructFieldXpath('name', $name), $value, $message, t('Browser'));
  3105. }
  3106. /**
  3107. * Asserts that a field does not exist with the given name and value.
  3108. *
  3109. * @param $name
  3110. * Name of field to assert.
  3111. * @param $value
  3112. * (optional) Value for the field, to assert that the field's value on the
  3113. * page doesn't match it. You may pass in NULL to skip checking the
  3114. * value, while still checking that the field doesn't exist. However, the
  3115. * default value ('') asserts that the field value is not an empty string.
  3116. * @param $message
  3117. * (optional) Message to display.
  3118. * @param $group
  3119. * The group this message belongs to.
  3120. * @return
  3121. * TRUE on pass, FALSE on fail.
  3122. */
  3123. protected function assertNoFieldByName($name, $value = '', $message = '') {
  3124. return $this->assertNoFieldByXPath($this->constructFieldXpath('name', $name), $value, $message ? $message : t('Did not find field by name @name', array('@name' => $name)), t('Browser'));
  3125. }
  3126. /**
  3127. * Asserts that a field exists in the current page with the given ID and value.
  3128. *
  3129. * @param $id
  3130. * ID of field to assert.
  3131. * @param $value
  3132. * (optional) Value for the field to assert. You may pass in NULL to skip
  3133. * checking the value, while still checking that the field exists.
  3134. * However, the default value ('') asserts that the field value is an empty
  3135. * string.
  3136. * @param $message
  3137. * (optional) Message to display.
  3138. * @param $group
  3139. * The group this message belongs to.
  3140. * @return
  3141. * TRUE on pass, FALSE on fail.
  3142. */
  3143. protected function assertFieldById($id, $value = '', $message = '') {
  3144. return $this->assertFieldByXPath($this->constructFieldXpath('id', $id), $value, $message ? $message : t('Found field by id @id', array('@id' => $id)), t('Browser'));
  3145. }
  3146. /**
  3147. * Asserts that a field does not exist with the given ID and value.
  3148. *
  3149. * @param $id
  3150. * ID of field to assert.
  3151. * @param $value
  3152. * (optional) Value for the field, to assert that the field's value on the
  3153. * page doesn't match it. You may pass in NULL to skip checking the value,
  3154. * while still checking that the field doesn't exist. However, the default
  3155. * value ('') asserts that the field value is not an empty string.
  3156. * @param $message
  3157. * (optional) Message to display.
  3158. * @param $group
  3159. * The group this message belongs to.
  3160. * @return
  3161. * TRUE on pass, FALSE on fail.
  3162. */
  3163. protected function assertNoFieldById($id, $value = '', $message = '') {
  3164. return $this->assertNoFieldByXPath($this->constructFieldXpath('id', $id), $value, $message ? $message : t('Did not find field by id @id', array('@id' => $id)), t('Browser'));
  3165. }
  3166. /**
  3167. * Asserts that a checkbox field in the current page is checked.
  3168. *
  3169. * @param $id
  3170. * ID of field to assert.
  3171. * @param $message
  3172. * (optional) Message to display.
  3173. * @return
  3174. * TRUE on pass, FALSE on fail.
  3175. */
  3176. protected function assertFieldChecked($id, $message = '') {
  3177. $elements = $this->xpath('//input[@id=:id]', array(':id' => $id));
  3178. return $this->assertTrue(isset($elements[0]) && !empty($elements[0]['checked']), $message ? $message : t('Checkbox field @id is checked.', array('@id' => $id)), t('Browser'));
  3179. }
  3180. /**
  3181. * Asserts that a checkbox field in the current page is not checked.
  3182. *
  3183. * @param $id
  3184. * ID of field to assert.
  3185. * @param $message
  3186. * (optional) Message to display.
  3187. * @return
  3188. * TRUE on pass, FALSE on fail.
  3189. */
  3190. protected function assertNoFieldChecked($id, $message = '') {
  3191. $elements = $this->xpath('//input[@id=:id]', array(':id' => $id));
  3192. return $this->assertTrue(isset($elements[0]) && empty($elements[0]['checked']), $message ? $message : t('Checkbox field @id is not checked.', array('@id' => $id)), t('Browser'));
  3193. }
  3194. /**
  3195. * Asserts that a select option in the current page is checked.
  3196. *
  3197. * @param $id
  3198. * ID of select field to assert.
  3199. * @param $option
  3200. * Option to assert.
  3201. * @param $message
  3202. * (optional) Message to display.
  3203. * @return
  3204. * TRUE on pass, FALSE on fail.
  3205. *
  3206. * @todo $id is unusable. Replace with $name.
  3207. */
  3208. protected function assertOptionSelected($id, $option, $message = '') {
  3209. $elements = $this->xpath('//select[@id=:id]//option[@value=:option]', array(':id' => $id, ':option' => $option));
  3210. return $this->assertTrue(isset($elements[0]) && !empty($elements[0]['selected']), $message ? $message : t('Option @option for field @id is selected.', array('@option' => $option, '@id' => $id)), t('Browser'));
  3211. }
  3212. /**
  3213. * Asserts that a select option in the current page is not checked.
  3214. *
  3215. * @param $id
  3216. * ID of select field to assert.
  3217. * @param $option
  3218. * Option to assert.
  3219. * @param $message
  3220. * (optional) Message to display.
  3221. * @return
  3222. * TRUE on pass, FALSE on fail.
  3223. */
  3224. protected function assertNoOptionSelected($id, $option, $message = '') {
  3225. $elements = $this->xpath('//select[@id=:id]//option[@value=:option]', array(':id' => $id, ':option' => $option));
  3226. return $this->assertTrue(isset($elements[0]) && empty($elements[0]['selected']), $message ? $message : t('Option @option for field @id is not selected.', array('@option' => $option, '@id' => $id)), t('Browser'));
  3227. }
  3228. /**
  3229. * Asserts that a field exists with the given name or ID.
  3230. *
  3231. * @param $field
  3232. * Name or ID of field to assert.
  3233. * @param $message
  3234. * (optional) Message to display.
  3235. * @param $group
  3236. * The group this message belongs to.
  3237. * @return
  3238. * TRUE on pass, FALSE on fail.
  3239. */
  3240. protected function assertField($field, $message = '', $group = 'Other') {
  3241. return $this->assertFieldByXPath($this->constructFieldXpath('name', $field) . '|' . $this->constructFieldXpath('id', $field), NULL, $message, $group);
  3242. }
  3243. /**
  3244. * Asserts that a field does not exist with the given name or ID.
  3245. *
  3246. * @param $field
  3247. * Name or ID of field to assert.
  3248. * @param $message
  3249. * (optional) Message to display.
  3250. * @param $group
  3251. * The group this message belongs to.
  3252. * @return
  3253. * TRUE on pass, FALSE on fail.
  3254. */
  3255. protected function assertNoField($field, $message = '', $group = 'Other') {
  3256. return $this->assertNoFieldByXPath($this->constructFieldXpath('name', $field) . '|' . $this->constructFieldXpath('id', $field), NULL, $message, $group);
  3257. }
  3258. /**
  3259. * Asserts that each HTML ID is used for just a single element.
  3260. *
  3261. * @param $message
  3262. * Message to display.
  3263. * @param $group
  3264. * The group this message belongs to.
  3265. * @param $ids_to_skip
  3266. * An optional array of ids to skip when checking for duplicates. It is
  3267. * always a bug to have duplicate HTML IDs, so this parameter is to enable
  3268. * incremental fixing of core code. Whenever a test passes this parameter,
  3269. * it should add a "todo" comment above the call to this function explaining
  3270. * the legacy bug that the test wishes to ignore and including a link to an
  3271. * issue that is working to fix that legacy bug.
  3272. * @return
  3273. * TRUE on pass, FALSE on fail.
  3274. */
  3275. protected function assertNoDuplicateIds($message = '', $group = 'Other', $ids_to_skip = array()) {
  3276. $status = TRUE;
  3277. foreach ($this->xpath('//*[@id]') as $element) {
  3278. $id = (string) $element['id'];
  3279. if (isset($seen_ids[$id]) && !in_array($id, $ids_to_skip)) {
  3280. $this->fail(t('The HTML ID %id is unique.', array('%id' => $id)), $group);
  3281. $status = FALSE;
  3282. }
  3283. $seen_ids[$id] = TRUE;
  3284. }
  3285. return $this->assert($status, $message, $group);
  3286. }
  3287. /**
  3288. * Helper function: construct an XPath for the given set of attributes and value.
  3289. *
  3290. * @param $attribute
  3291. * Field attributes.
  3292. * @param $value
  3293. * Value of field.
  3294. * @return
  3295. * XPath for specified values.
  3296. */
  3297. protected function constructFieldXpath($attribute, $value) {
  3298. $xpath = '//textarea[@' . $attribute . '=:value]|//input[@' . $attribute . '=:value]|//select[@' . $attribute . '=:value]';
  3299. return $this->buildXPathQuery($xpath, array(':value' => $value));
  3300. }
  3301. /**
  3302. * Asserts the page responds with the specified response code.
  3303. *
  3304. * @param $code
  3305. * Response code. For example 200 is a successful page request. For a list
  3306. * of all codes see http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html.
  3307. * @param $message
  3308. * Message to display.
  3309. * @return
  3310. * Assertion result.
  3311. */
  3312. protected function assertResponse($code, $message = '') {
  3313. $curl_code = curl_getinfo($this->curlHandle, CURLINFO_HTTP_CODE);
  3314. $match = is_array($code) ? in_array($curl_code, $code) : $curl_code == $code;
  3315. return $this->assertTrue($match, $message ? $message : t('HTTP response expected !code, actual !curl_code', array('!code' => $code, '!curl_code' => $curl_code)), t('Browser'));
  3316. }
  3317. /**
  3318. * Asserts the page did not return the specified response code.
  3319. *
  3320. * @param $code
  3321. * Response code. For example 200 is a successful page request. For a list
  3322. * of all codes see http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html.
  3323. * @param $message
  3324. * Message to display.
  3325. *
  3326. * @return
  3327. * Assertion result.
  3328. */
  3329. protected function assertNoResponse($code, $message = '') {
  3330. $curl_code = curl_getinfo($this->curlHandle, CURLINFO_HTTP_CODE);
  3331. $match = is_array($code) ? in_array($curl_code, $code) : $curl_code == $code;
  3332. return $this->assertFalse($match, $message ? $message : t('HTTP response not expected !code, actual !curl_code', array('!code' => $code, '!curl_code' => $curl_code)), t('Browser'));
  3333. }
  3334. /**
  3335. * Asserts that the most recently sent e-mail message has the given value.
  3336. *
  3337. * The field in $name must have the content described in $value.
  3338. *
  3339. * @param $name
  3340. * Name of field or message property to assert. Examples: subject, body, id, ...
  3341. * @param $value
  3342. * Value of the field to assert.
  3343. * @param $message
  3344. * Message to display.
  3345. *
  3346. * @return
  3347. * TRUE on pass, FALSE on fail.
  3348. */
  3349. protected function assertMail($name, $value = '', $message = '') {
  3350. $captured_emails = variable_get('drupal_test_email_collector', array());
  3351. $email = end($captured_emails);
  3352. return $this->assertTrue($email && isset($email[$name]) && $email[$name] == $value, $message, t('E-mail'));
  3353. }
  3354. /**
  3355. * Asserts that the most recently sent e-mail message has the string in it.
  3356. *
  3357. * @param $field_name
  3358. * Name of field or message property to assert: subject, body, id, ...
  3359. * @param $string
  3360. * String to search for.
  3361. * @param $email_depth
  3362. * Number of emails to search for string, starting with most recent.
  3363. *
  3364. * @return
  3365. * TRUE on pass, FALSE on fail.
  3366. */
  3367. protected function assertMailString($field_name, $string, $email_depth) {
  3368. $mails = $this->drupalGetMails();
  3369. $string_found = FALSE;
  3370. for ($i = sizeof($mails) -1; $i >= sizeof($mails) - $email_depth && $i >= 0; $i--) {
  3371. $mail = $mails[$i];
  3372. // Normalize whitespace, as we don't know what the mail system might have
  3373. // done. Any run of whitespace becomes a single space.
  3374. $normalized_mail = preg_replace('/\s+/', ' ', $mail[$field_name]);
  3375. $normalized_string = preg_replace('/\s+/', ' ', $string);
  3376. $string_found = (FALSE !== strpos($normalized_mail, $normalized_string));
  3377. if ($string_found) {
  3378. break;
  3379. }
  3380. }
  3381. return $this->assertTrue($string_found, t('Expected text found in @field of email message: "@expected".', array('@field' => $field_name, '@expected' => $string)));
  3382. }
  3383. /**
  3384. * Asserts that the most recently sent e-mail message has the pattern in it.
  3385. *
  3386. * @param $field_name
  3387. * Name of field or message property to assert: subject, body, id, ...
  3388. * @param $regex
  3389. * Pattern to search for.
  3390. *
  3391. * @return
  3392. * TRUE on pass, FALSE on fail.
  3393. */
  3394. protected function assertMailPattern($field_name, $regex, $message) {
  3395. $mails = $this->drupalGetMails();
  3396. $mail = end($mails);
  3397. $regex_found = preg_match("/$regex/", $mail[$field_name]);
  3398. return $this->assertTrue($regex_found, t('Expected text found in @field of email message: "@expected".', array('@field' => $field_name, '@expected' => $regex)));
  3399. }
  3400. /**
  3401. * Outputs to verbose the most recent $count emails sent.
  3402. *
  3403. * @param $count
  3404. * Optional number of emails to output.
  3405. */
  3406. protected function verboseEmail($count = 1) {
  3407. $mails = $this->drupalGetMails();
  3408. for ($i = sizeof($mails) -1; $i >= sizeof($mails) - $count && $i >= 0; $i--) {
  3409. $mail = $mails[$i];
  3410. $this->verbose(t('Email:') . '<pre>' . print_r($mail, TRUE) . '</pre>');
  3411. }
  3412. }
  3413. }
  3414. /**
  3415. * Logs verbose message in a text file.
  3416. *
  3417. * If verbose mode is enabled then page requests will be dumped to a file and
  3418. * presented on the test result screen. The messages will be placed in a file
  3419. * located in the simpletest directory in the original file system.
  3420. *
  3421. * @param $message
  3422. * The verbose message to be stored.
  3423. * @param $original_file_directory
  3424. * The original file directory, before it was changed for testing purposes.
  3425. * @param $test_class
  3426. * The active test case class.
  3427. *
  3428. * @return
  3429. * The ID of the message to be placed in related assertion messages.
  3430. *
  3431. * @see DrupalTestCase->originalFileDirectory
  3432. * @see DrupalWebTestCase->verbose()
  3433. */
  3434. function simpletest_verbose($message, $original_file_directory = NULL, $test_class = NULL) {
  3435. static $file_directory = NULL, $class = NULL, $id = 1, $verbose = NULL;
  3436. // Will pass first time during setup phase, and when verbose is TRUE.
  3437. if (!isset($original_file_directory) && !$verbose) {
  3438. return FALSE;
  3439. }
  3440. if ($message && $file_directory) {
  3441. $message = '<hr />ID #' . $id . ' (<a href="' . $class . '-' . ($id - 1) . '.html">Previous</a> | <a href="' . $class . '-' . ($id + 1) . '.html">Next</a>)<hr />' . $message;
  3442. file_put_contents($file_directory . "/simpletest/verbose/$class-$id.html", $message, FILE_APPEND);
  3443. return $id++;
  3444. }
  3445. if ($original_file_directory) {
  3446. $file_directory = $original_file_directory;
  3447. $class = $test_class;
  3448. $verbose = variable_get('simpletest_verbose', TRUE);
  3449. $directory = $file_directory . '/simpletest/verbose';
  3450. $writable = file_prepare_directory($directory, FILE_CREATE_DIRECTORY);
  3451. if ($writable && !file_exists($directory . '/.htaccess')) {
  3452. file_put_contents($directory . '/.htaccess', "<IfModule mod_expires.c>\nExpiresActive Off\n</IfModule>\n");
  3453. }
  3454. return $writable;
  3455. }
  3456. return FALSE;
  3457. }

Functions

Namesort descending Description
simpletest_verbose Logs verbose message in a text file.

Globals

Namesort descending Description
$drupal_test_info Global variable that holds information about the tests being run.

Classes

Namesort descending Description
DrupalTestCase Base class for Drupal tests.
DrupalUnitTestCase Test case for Drupal unit tests.
DrupalWebTestCase Test case for typical Drupal tests.