drupal_web_test_case.php 56.3 KB
Newer Older
1
2
3
4
5
6
<?php
// $Id$

/**
 * Test case for typical Drupal tests.
 */
7
class DrupalWebTestCase {
8
9
  protected $_logged_in = FALSE;
  protected $_content;
10
  protected $_url;
11
12
  protected $plain_text;
  protected $ch;
13
  protected $elements;
14
15
16
17
18
  // We do not reuse the cookies in further runs, so we do not need a file
  // but we still need cookie handling, so we set the jar to NULL
  protected $cookie_file = NULL;
  // Overwrite this any time to supply cURL options as necessary,
  // DrupalTestCase itself never sets this but always obeys whats set.
19
20
  protected $curl_options = array();
  protected $db_prefix_original;
21
22
  protected $original_file_directory;

23
  var $_results = array('#pass' => 0, '#fail' => 0, '#exception' => 0);
24
  var $_assertions = array();
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

  /**
   * Constructor for DrupalWebTestCase.
   *
   * @param @test_id
   *   Tests with the same id are reported together.
   */
  function __construct($test_id = NULL) {
    $this->test_id = $test_id;
  }

  /**
   * This function stores the assert. Do not call directly.
   *
   * @param $status
   *   Can be 'pass', 'fail', 'exception'. TRUE is a synonym for 'pass', FALSE
   *   for 'fail'.
   * @param $message
   *   The message string.
   * @param $group
   *   WHich group this assert belongs to.
46
   * @param $caller
47
48
   *   By default, the assert comes from a function which names start with
   *   'test'. Instead, you can specify where this assert originates from
49
   *   by passing in an associative array as $caller. Key 'file' is
50
51
52
   *   the name of the source file, 'line' is the line number and 'function'
   *   is the caller function itself.
   */
53
  protected function _assert($status, $message = '', $group = 'Other', $caller = NULL) {
54
    global $db_prefix;
55
56

    // Convert boolean status to string status.
57
58
59
    if (is_bool($status)) {
      $status = $status ? 'pass' : 'fail';
    }
60
61

    // Increment summary result counter.
62
    $this->_results['#' . $status]++;
63
64
65
66

    // Get the function information about the call to the assertion method.
    if (!$caller) {
      $caller = $this->getAssertionCall();
67
    }
68
69

    // Switch to non-testing database to store results in.
70
71
    $current_db_prefix = $db_prefix;
    $db_prefix = $this->db_prefix_original;
72
73
74

    // Creation assertion array that can be displayed while tests are running.
    $this->_assertions[] = $assertion = array(
75
      'test_id' => $this->test_id,
76
      'test_class' => get_class($this),
77
78
      'status' => $status,
      'message' => $message,
79
80
81
82
      'message_group' => $group,
      'function' => $caller['function'],
      'line' => $caller['line'],
      'file' => $caller['file'],
83
    );
84
85
86
87
88

    // Store assertion for display after the test has completed.
    db_insert('simpletest')->fields($assertion)->execute();

    // Return to testing prefix.
89
90
91
92
    $db_prefix = $current_db_prefix;
    return $status;
  }

93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
  /**
   * Cycles through backtrace until the first non-assertion method is found.
   *
   * @return
   *   Array representing the true caller.
   */
  protected function getAssertionCall() {
    $backtrace = debug_backtrace();

    // The first element is the call. The second element is the caller.
    // We skip calls that occured in one of the methods of DrupalWebTestCase
    // or in an assertion function.
    while (($caller = $backtrace[1]) &&
          ((isset($caller['class']) && $caller['class'] == 'DrupalWebTestCase') ||
            substr($caller['function'], 0, 6) == 'assert')) {
      // We remove that call.
      array_shift($backtrace);
    }

    return _drupal_get_last_caller($backtrace);
  }

115
116
117
118
119
120
121
122
123
124
125
126
127
  /**
   * Check to see if a value is not false (not an empty string, 0, NULL, or FALSE).
   *
   * @param $value
   *   The value on which the assertion is to be done.
   * @param $message
   *   The message to display along with the assertion.
   * @param $group
   *   The type of assertion - examples are "Browser", "PHP".
   * @return
   *   The status passed in.
   */
  protected function assertTrue($value, $message = '', $group = 'Other') {
128
    return $this->_assert((bool) $value, $message ? $message : t('Value is TRUE'), $group);
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
  }

  /**
   * Check to see if a value is false (an empty string, 0, NULL, or FALSE).
   *
   * @param $value
   *   The value on which the assertion is to be done.
   * @param $message
   *   The message to display along with the assertion.
   * @param $group
   *   The type of assertion - examples are "Browser", "PHP".
   * @return
   *   The status passed in.
   */
  protected function assertFalse($value, $message = '', $group = 'Other') {
144
    return $this->_assert(!$value, $message ? $message : t('Value is FALSE'), $group);
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
  }

  /**
   * Check to see if a value is NULL.
   *
   * @param $value
   *   The value on which the assertion is to be done.
   * @param $message
   *   The message to display along with the assertion.
   * @param $group
   *   The type of assertion - examples are "Browser", "PHP".
   * @return
   *   The status passed in.
   */
  protected function assertNull($value, $message = '', $group = 'Other') {
160
    return $this->_assert(!isset($value), $message ? $message : t('Value is NULL'), $group);
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
  }

  /**
   * Check to see if a value is not NULL.
   *
   * @param $value
   *   The value on which the assertion is to be done.
   * @param $message
   *   The message to display along with the assertion.
   * @param $group
   *   The type of assertion - examples are "Browser", "PHP".
   * @return
   *   The status passed in.
   */
  protected function assertNotNull($value, $message = '', $group = 'Other') {
176
    return $this->_assert(isset($value), $message ? $message : t('Value is not NULL'), $group);
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
  }

  /**
   * Check to see if two values are equal.
   *
   * @param $first
   *   The first value to check.
   * @param $second
   *   The second value to check.
   * @param $message
   *   The message to display along with the assertion.
   * @param $group
   *   The type of assertion - examples are "Browser", "PHP".
   * @return
   *   The status passed in.
   */
  protected function assertEqual($first, $second, $message = '', $group = 'Other') {
194
    return $this->_assert($first == $second, $message ? $message : t('First value is equal to second value'), $group);
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
  }

  /**
   * Check to see if two values are not equal.
   *
   * @param $first
   *   The first value to check.
   * @param $second
   *   The second value to check.
   * @param $message
   *   The message to display along with the assertion.
   * @param $group
   *   The type of assertion - examples are "Browser", "PHP".
   * @return
   *   The status passed in.
   */
  protected function assertNotEqual($first, $second, $message = '', $group = 'Other') {
212
    return $this->_assert($first != $second, $message ? $message : t('First value is not equal to second value'), $group);
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
  }

  /**
   * Check to see if two values are identical.
   *
   * @param $first
   *   The first value to check.
   * @param $second
   *   The second value to check.
   * @param $message
   *   The message to display along with the assertion.
   * @param $group
   *   The type of assertion - examples are "Browser", "PHP".
   * @return
   *   The status passed in.
   */
  protected function assertIdentical($first, $second, $message = '', $group = 'Other') {
230
    return $this->_assert($first === $second, $message ? $message : t('First value is identical to second value'), $group);
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
  }

  /**
   * Check to see if two values are not identical.
   *
   * @param $first
   *   The first value to check.
   * @param $second
   *   The second value to check.
   * @param $message
   *   The message to display along with the assertion.
   * @param $group
   *   The type of assertion - examples are "Browser", "PHP".
   * @return
   *   The status passed in.
   */
  protected function assertNotIdentical($first, $second, $message = '', $group = 'Other') {
248
    return $this->_assert($first !== $second, $message ? $message : t('First value is not identical to second value'), $group);
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
  }

  /**
   * Fire an assertion that is always positive.
   *
   * @param $message
   *   The message to display along with the assertion.
   * @param $group
   *   The type of assertion - examples are "Browser", "PHP".
   * @return
   *   TRUE.
   */
  protected function pass($message = NULL, $group = 'Other') {
    return $this->_assert(TRUE, $message, $group);
  }

265
  /**
266
   * Fire an assertion that is always negative.
267
   *
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
   * @param $message
   *   The message to display along with the assertion.
   * @param $group
   *   The type of assertion - examples are "Browser", "PHP".
   * @return
   *   FALSE.
   */
  protected function fail($message = NULL, $group = 'Other') {
    return $this->_assert(FALSE, $message, $group);
  }

  /**
   * Fire an error assertion.
   *
   * @param $message
   *   The message to display along with the assertion.
   * @param $group
   *   The type of assertion - examples are "Browser", "PHP".
286
   * @param $caller
287
288
   *   The caller of the error.
   */
289
290
  protected function error($message = '', $group = 'Other', $caller = NULL) {
    return $this->_assert('exception', $message, $group, $caller);
291
292
293
294
  }

  /**
   * Run all tests in this class.
295
   */
296
297
298
299
300
301
302
  function run() {
    set_error_handler(array($this, 'errorHandler'));
    $methods = array();
    // Iterate through all the methods in this class.
    foreach (get_class_methods(get_class($this)) as $method) {
      // If the current method starts with "test", run it - it's a test.
      if (strtolower(substr($method, 0, 4)) == 'test') {
303
        $this->setUp();
304
305
306
307
308
309
310
        try {
          $this->$method();
          // Finish up.
        }
        catch (Exception $e) {
          $this->exceptionHandler($e);
        }
311
        $this->tearDown();
312
313
      }
    }
314
315
    // Clear out the error messages and restore error handler.
    drupal_get_messages();
316
317
318
319
320
321
322
323
324
    restore_error_handler();
  }

  /**
   * Handle errors.
   *
   * @see set_error_handler
   */
  function errorHandler($severity, $message, $file = NULL, $line = NULL) {
325
    if ($severity & error_reporting()) {
326
327
328
329
330
331
332
333
334
335
336
      $error_map = array(
        E_STRICT => 'Run-time notice',
        E_WARNING => 'Warning',
        E_NOTICE => 'Notice',
        E_CORE_ERROR => 'Core error',
        E_CORE_WARNING => 'Core warning',
        E_USER_ERROR => 'User error',
        E_USER_WARNING => 'User warning',
        E_USER_NOTICE => 'User notice',
        E_RECOVERABLE_ERROR => 'Recoverable error',
      );
337
338
339

      $backtrace = debug_backtrace();
      $this->error($message, $error_map[$severity], _drupal_get_last_caller($backtrace));
340
341
    }
    return TRUE;
342
343
  }

344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
  /**
   * Handle exceptions.
   *
   * @see set_exception_handler
   */
  function exceptionHandler($exception) {
    $backtrace = $exception->getTrace();
    // Push on top of the backtrace the call that generated the exception.
    array_unshift($backtrace, array(
      'line' => $exception->getLine(),
      'file' => $exception->getFile(),
    ));
    $this->error($exception->getMessage(), 'Uncaught exception', _drupal_get_last_caller($backtrace));
  }

359
360
361
  /**
   * Creates a node based on default settings.
   *
362
363
   * @param $settings
   *   An associative array of settings to change from the defaults, keys are
364
365
366
367
368
369
370
371
372
   *   node properties, for example 'body' => 'Hello, world!'.
   * @return object Created node object.
   */
  function drupalCreateNode($settings = array()) {
    // Populate defaults array
    $defaults = array(
      'body'      => $this->randomName(32),
      'title'     => $this->randomName(8),
      'comment'   => 2,
373
      'changed'   => REQUEST_TIME,
374
375
376
377
378
379
380
381
382
383
384
385
386
      'format'    => FILTER_FORMAT_DEFAULT,
      'moderate'  => 0,
      'promote'   => 0,
      'revision'  => 1,
      'log'       => '',
      'status'    => 1,
      'sticky'    => 0,
      'type'      => 'page',
      'revisions' => NULL,
      'taxonomy'  => NULL,
    );
    $defaults['teaser'] = $defaults['body'];
    // If we already have a node, we use the original node's created time, and this
387
388
    if (isset($defaults['created'])) {
      $defaults['date'] = format_date($defaults['created'], 'custom', 'Y-m-d H:i:s O');
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
    }
    if (empty($settings['uid'])) {
      global $user;
      $defaults['uid'] = $user->uid;
    }
    $node = ($settings + $defaults);
    $node = (object)$node;

    node_save($node);

    // small hack to link revisions to our test user
    db_query('UPDATE {node_revisions} SET uid = %d WHERE vid = %d', $node->uid, $node->vid);
    return $node;
  }

  /**
   * Creates a custom content type based on default settings.
   *
407
   * @param $settings
408
409
   *   An array of settings to change from the defaults.
   *   Example: 'type' => 'foo'.
410
411
   * @return
   *   Created content type.
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
   */
  function drupalCreateContentType($settings = array()) {
    // find a non-existent random type name.
    do {
      $name = strtolower($this->randomName(3, 'type_'));
    } while (node_get_types('type', $name));

    // Populate defaults array
    $defaults = array(
      'type' => $name,
      'name' => $name,
      'description' => '',
      'help' => '',
      'min_word_count' => 0,
      'title_label' => 'Title',
      'body_label' => 'Body',
      'has_title' => 1,
      'has_body' => 1,
    );
    // imposed values for a custom type
    $forced = array(
      'orig_type' => '',
      'old_type' => '',
      'module' => 'node',
      'custom' => 1,
      'modified' => 1,
      'locked' => 0,
    );
    $type = $forced + $settings + $defaults;
    $type = (object)$type;

443
    $saved_type = node_type_save($type);
444
445
    node_types_rebuild();

446
    $this->assertEqual($saved_type, SAVED_NEW, t('Created content type %type.', array('%type' => $type->type)));
447

448
449
450
    // Reset permissions so that permissions for this content type are available.
    $this->checkPermissions(array(), TRUE);

451
452
453
454
455
456
    return $type;
  }

  /**
   * Get a list files that can be used in tests.
   *
457
458
459
460
461
462
   * @param $type
   *   File type, possible values: 'binary', 'html', 'image', 'javascript', 'php', 'sql', 'text'.
   * @param $size
   *   File size in bytes to match. Please check the tests/files folder.
   * @return
   *   List of files that match filter.
463
464
465
466
467
468
469
   */
  function drupalGetTestFiles($type, $size = NULL) {
    $files = array();

    // Make sure type is valid.
    if (in_array($type, array('binary', 'html', 'image', 'javascript', 'php', 'sql', 'text'))) {
     // Use original file directory instead of one created during setUp().
470
      $path = $this->original_file_directory . '/simpletest';
471
      $files = file_scan_directory($path, '/' . $type . '\-.*/');
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487

      // If size is set then remove any files that are not of that size.
      if ($size !== NULL) {
        foreach ($files as $file) {
          $stats = stat($file->filename);
          if ($stats['size'] != $size) {
            unset($files[$file->filename]);
          }
        }
      }
    }
    usort($files, array($this, 'drupalCompareFiles'));
    return $files;
  }

  /**
488
   * Compare two files based on size and file name.
489
490
   */
  function drupalCompareFiles($file1, $file2) {
491
492
493
494
495
496
497
498
499
    // Determine which file is larger.
    $compare_size = (filesize($file1->filename) > filesize($file2->filename));
    if (!$compare_size) {
      // Both files were the same size, so return whichever one is alphabetically greater.
      return strnatcmp($file1->name, $file2->name);
    }
    else {
      // Return TRUE if $file1 is larger than $file2.
      return $compare_size;
500
501
502
503
504
505
    }
  }

  /**
   * Generates a random string.
   *
506
507
508
509
510
511
   * @param $number
   *   Number of characters in length to append to the prefix.
   * @param $prefix
   *   Prefix to use.
   * @return
   *   Randomly generated string.
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
   */
  function randomName($number = 4, $prefix = 'simpletest_') {
    $chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_';
    for ($x = 0; $x < $number; $x++) {
      $prefix .= $chars{mt_rand(0, strlen($chars) - 1)};
      if ($x == 0) {
        $chars .= '0123456789';
      }
    }
    return $prefix;
  }

  /**
   * Create a user with a given set of permissions. The permissions correspond to the
   * names given on the privileges page.
   *
528
529
530
531
   * @param $permissions
   *   Array of permission names to assign to user.
   * @return
   *   A fully loaded user object with pass_raw property, or FALSE if account
532
533
534
535
   *   creation fails.
   */
  function drupalCreateUser($permissions = NULL) {
    // Create a role with the given permission set.
536
    if (!($rid = $this->_drupalCreateRole($permissions))) {
537
538
539
540
541
542
      return FALSE;
    }

    // Create a user assigned to that role.
    $edit = array();
    $edit['name']   = $this->randomName();
543
    $edit['mail']   = $edit['name'] . '@example.com';
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
    $edit['roles']  = array($rid => $rid);
    $edit['pass']   = user_password();
    $edit['status'] = 1;

    $account = user_save('', $edit);

    $this->assertTrue(!empty($account->uid), t('User created with name %name and pass %pass', array('%name' => $edit['name'], '%pass' => $edit['pass'])), t('User login'));
    if (empty($account->uid)) {
      return FALSE;
    }

    // Add the raw password so that we can log in as this user.
    $account->pass_raw = $edit['pass'];
    return $account;
  }

  /**
   * Internal helper function; Create a role with specified permissions.
   *
563
564
565
566
   * @param $permissions
   *   Array of permission names to assign to role.
   * @return
   *   Role ID of newly created role, or FALSE if role creation failed.
567
568
569
570
   */
  private function _drupalCreateRole($permissions = NULL) {
    // Generate string version of permissions list.
    if ($permissions === NULL) {
571
      $permissions = array('access comments', 'access content', 'post comments', 'post comments without approval');
572
573
    }

574
575
576
577
    if (!$this->checkPermissions($permissions)) {
      return FALSE;
    }

578
579
580
581
582
583
584
    // Create new role.
    $role_name = $this->randomName();
    db_query("INSERT INTO {role} (name) VALUES ('%s')", $role_name);
    $role = db_fetch_object(db_query("SELECT * FROM {role} WHERE name = '%s'", $role_name));
    $this->assertTrue($role, t('Created role of name: @role_name, id: @rid', array('@role_name' => $role_name, '@rid' => (isset($role->rid) ? $role->rid : t('-n/a-')))), t('Role'));
    if ($role && !empty($role->rid)) {
      // Assign permissions to role and mark it for clean-up.
585
586
587
588
589
      foreach ($permissions as $permission_string) {
        db_query("INSERT INTO {role_permission} (rid, permission) VALUES (%d, '%s')", $role->rid, $permission_string);
      }
      $count = db_result(db_query("SELECT COUNT(*) FROM {role_permission} WHERE rid = %d", $role->rid));
      $this->assertTrue($count == count($permissions), t('Created permissions: @perms', array('@perms' => implode(', ', $permissions))), t('Role'));
590
591
592
593
594
595
596
      return $role->rid;
    }
    else {
      return FALSE;
    }
  }

597
598
599
  /**
   * Check to make sure that the array of permissions are valid.
   *
600
601
602
603
604
605
   * @param $permissions
   *   Permissions to check.
   * @param $reset
   *   Reset cached available permissions.
   * @return
   *   TRUE or FALSE depending on whether the permissions are valid.
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
   */
  private function checkPermissions(array $permissions, $reset = FALSE) {
    static $available;

    if (!isset($available) || $reset) {
      $available = array_keys(module_invoke_all('perm'));
    }

    $valid = TRUE;
    foreach ($permissions as $permission) {
      if (!in_array($permission, $available)) {
        $this->fail(t('Invalid permission %permission.', array('%permission' => $permission)), t('Role'));
        $valid = FALSE;
      }
    }
    return $valid;
  }

624
625
626
627
628
  /**
   * Logs in a user with the internal browser. If already logged in then logs the current
   * user out before logging in the specified user. If no user is specified then a new
   * user will be created and logged in.
   *
629
630
631
632
633
   * @param $user
   *   User object representing the user to login.
   * @return
   *   User that was logged in. Useful if no user was passed in order to retrieve
   *   the created user.
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
   */
  function drupalLogin($user = NULL) {
    if ($this->_logged_in) {
      $this->drupalLogout();
    }

    if (!isset($user)) {
      $user = $this->_drupalCreateRole();
    }

    $edit = array(
      'name' => $user->name,
      'pass' => $user->pass_raw
    );
    $this->drupalPost('user', $edit, t('Log in'));

    $pass = $this->assertText($user->name, t('Found name: %name', array('%name' => $user->name)), t('User login'));
    $pass = $pass && $this->assertNoText(t('The username %name has been blocked.', array('%name' => $user->name)), t('No blocked message at login page'), t('User login'));
    $pass = $pass && $this->assertNoText(t('The name %name is a reserved username.', array('%name' => $user->name)), t('No reserved message at login page'), t('User login'));

    $this->_logged_in = $pass;

    return $user;
  }

  /*
   * Logs a user out of the internal browser, then check the login page to confirm logout.
   */
  function drupalLogout() {
    // Make a request to the logout page.
    $this->drupalGet('logout');

    // Load the user page, the idea being if you were properly logged out you should be seeing a login screen.
    $this->drupalGet('user');
    $pass = $this->assertField('name', t('Username field found.'), t('Logout'));
    $pass = $pass && $this->assertField('pass', t('Password field found.'), t('Logout'));

    $this->_logged_in = !$pass;
  }

  /**
675
676
677
678
   * Generates a random database prefix, runs the install scripts on the
   * prefixed database and enable the specified modules. After installation
   * many caches are flushed and the internal browser is setup so that the
   * page requests will run on the new prefix. A temporary files directory
679
   * is created with the same name as the database prefix.
680
   *
681
   * @param ...
682
   *   List of modules to enable for the duration of the test.
683
684
685
   */
  function setUp() {
    global $db_prefix;
686
687

    // Store necessary current values before switching to prefixed database.
688
689
    $this->db_prefix_original = $db_prefix;
    $clean_url_original = variable_get('clean_url', 0);
690
691

    // Generate temporary prefixed database to ensure that tests have a clean starting point.
692
    $db_prefix = Database::getActiveConnection()->prefixTables('{simpletest' . mt_rand(1000, 1000000) . '}');
693

694
    include_once DRUPAL_ROOT . '/includes/install.inc';
695
    drupal_install_system();
696
697

    // Add the specified modules to the list of modules in the default profile.
698
    $args = func_get_args();
699
    $modules = array_unique(array_merge(drupal_get_profile_modules('default', 'en'), $args));
700
    drupal_install_modules($modules);
701

702
703
704
705
706
    // Because the schema is static cached, we need to flush
    // it between each run.  If we don't, then it will contain
    // stale data for the previous run's database prefix and all
    // calls to it will fail.
    drupal_get_schema(NULL, TRUE);
707

708
    // Run default profile tasks.
709
710
    $task = 'profile';
    default_profile_tasks($task, '');
711
712

    // Rebuild caches.
713
714
715
    menu_rebuild();
    actions_synchronize();
    _drupal_flush_css_js();
716
    $this->refreshVariables();
717
    $this->checkPermissions(array(), TRUE);
718
719

    // Restore necessary variables.
720
721
722
723
724
725
    variable_set('install_profile', 'default');
    variable_set('install_task', 'profile-finished');
    variable_set('clean_url', $clean_url_original);

    // Use temporary files directory with the same prefix as database.
    $this->original_file_directory = file_directory_path();
726
    variable_set('file_directory_path', file_directory_path() . '/' . $db_prefix);
727
    $directory = file_directory_path();
728
    file_check_directory($directory, FILE_CREATE_DIRECTORY); // Create the files directory.
729
730
  }

731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
  /**
   * Refresh the in-memory set of variables. Useful after a page request is made
   * that changes a variable in a different thread.
   *
   * In other words calling a settings page with $this->drupalPost() with a changed
   * value would update a variable to reflect that change, but in the thread that
   * made the call (thread running the test) the changed variable would not be
   * picked up.
   *
   * This method clears the variables cache and loads a fresh copy from the database
   * to ensure that the most up-to-date set of variables is loaded.
   */
  function refreshVariables() {
    global $conf;
    cache_clear_all('variables', 'cache');
    $conf = variable_init();
  }

749
750
751
752
753
754
755
756
  /**
   * Delete created files and temporary files directory, delete the tables created by setUp(),
   * and reset the database prefix.
   */
  function tearDown() {
    global $db_prefix;
    if (preg_match('/simpletest\d+/', $db_prefix)) {
      // Delete temporary files directory and reset files directory path.
757
      simpletest_clean_temporary_directory(file_directory_path());
758
759
      variable_set('file_directory_path', $this->original_file_directory);

760
      // Remove all prefixed tables (all the tables in the schema).
761
762
763
764
765
      $schema = drupal_get_schema(NULL, TRUE);
      $ret = array();
      foreach ($schema as $name => $table) {
        db_drop_table($ret, $name);
      }
766
767

      // Return the database prefix to the original.
768
      $db_prefix = $this->db_prefix_original;
769
770

      // Ensure that the internal logged in variable is reset.
771
      $this->_logged_in = FALSE;
772

773
774
      // Reload module list and implementations to ensure that test module hooks
      // aren't called after tests.
775
      module_list(TRUE);
776
      module_implements(MODULE_IMPLEMENTS_CLEAR_CACHE);
777
778
779
780

      // Rebuild caches.
      $this->refreshVariables();

781
      // Close the CURL handler.
782
783
784
785
786
      $this->curlClose();
    }
  }

  /**
787
   * Initializes the cURL connection.
788
   *
789
790
791
   * This function will add authentication headers as specified in the
   * simpletest_httpauth_username and simpletest_httpauth_pass variables. Also,
   * see the description of $curl_options among the properties.
792
   */
793
  protected function curlInitialize() {
794
795
796
797
798
799
800
801
    global $base_url, $db_prefix;
    if (!isset($this->ch)) {
      $this->ch = curl_init();
      $curl_options = $this->curl_options + array(
        CURLOPT_COOKIEJAR => $this->cookie_file,
        CURLOPT_URL => $base_url,
        CURLOPT_FOLLOWLOCATION => TRUE,
        CURLOPT_RETURNTRANSFER => TRUE,
802
803
        CURLOPT_SSL_VERIFYPEER => FALSE,  // Required to make the tests run on https://
        CURLOPT_SSL_VERIFYHOST => FALSE,  // Required to make the tests run on https://
804
        CURLOPT_HEADERFUNCTION => array(&$this, 'curlHeaderCallback'),
805
      );
806
807
      if (preg_match('/simpletest\d+/', $db_prefix, $matches)) {
        $curl_options[CURLOPT_USERAGENT] = $matches[0];
808
809
810
      }
      if (!isset($curl_options[CURLOPT_USERPWD]) && ($auth = variable_get('simpletest_httpauth_username', ''))) {
        if ($pass = variable_get('simpletest_httpauth_pass', '')) {
811
          $auth .= ':' . $pass;
812
813
814
        }
        $curl_options[CURLOPT_USERPWD] = $auth;
      }
815
      curl_setopt_array($this->ch, $this->curl_options + $curl_options);
816
817
818
819
    }
  }

  /**
820
   * Performs a cURL exec with the specified options after calling curlConnect().
821
   *
822
823
824
825
   * @param
   *   $curl_options Custom cURL options.
   * @return
   *   Content returned from the exec.
826
827
   */
  protected function curlExec($curl_options) {
828
    $this->curlInitialize();
829
830
    $url = empty($curl_options[CURLOPT_URL]) ? curl_getinfo($this->ch, CURLINFO_EFFECTIVE_URL) : $curl_options[CURLOPT_URL];
    curl_setopt_array($this->ch, $this->curl_options + $curl_options);
831
    $this->drupalSetContent(curl_exec($this->ch), curl_getinfo($this->ch, CURLINFO_EFFECTIVE_URL));
832
    $this->assertTrue($this->_content !== FALSE, t('!method to !url, response is !length bytes.', array('!method' => !empty($curl_options[CURLOPT_NOBODY]) ? 'HEAD' : (empty($curl_options[CURLOPT_POSTFIELDS]) ? 'GET' : 'POST'), '!url' => $url, '!length' => strlen($this->_content))), t('Browser'));
833
    return $this->drupalGetContent();
834
835
  }

836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
  /**
   * Reads headers and registers errors received from the tested site.
   *
   * @see _drupal_log_error().
   *
   * @param $ch the cURL handler.
   * @param $header a header.
   */
  protected function curlHeaderCallback($ch, $header) {
    // Errors are being sent via X-Drupal-Assertion-* headers,
    // generated by _drupal_log_error() in the exact form required
    // by DrupalWebTestCase::error().
    if (preg_match('/^X-Drupal-Assertion-[0-9]+: (.*)$/', $header, $matches)) {
      // Call DrupalWebTestCase::error() with the parameters from the header.
      call_user_func_array(array(&$this, 'error'), unserialize(urldecode($matches[1])));
    }
    // This is required by cURL.
    return strlen($header);
  }

856
857
858
859
860
861
862
863
864
865
866
  /**
   * Close the cURL handler and unset the handler.
   */
  protected function curlClose() {
    if (isset($this->ch)) {
      curl_close($this->ch);
      unset($this->ch);
    }
  }

  /**
867
   * Parse content returned from curlExec using DOM and SimpleXML.
868
   *
869
870
   * @return
   *   A SimpleXMLElement or FALSE on failure.
871
872
873
874
875
876
877
   */
  protected function parse() {
    if (!$this->elements) {
      // DOM can load HTML soup. But, HTML soup can throw warnings, supress
      // them.
      @$htmlDom = DOMDocument::loadHTML($this->_content);
      if ($htmlDom) {
878
        $this->pass(t('Valid HTML found on "@path"', array('@path' => $this->getUrl())), t('Browser'));
879
880
881
882
883
        // It's much easier to work with simplexml than DOM, luckily enough
        // we can just simply import our DOM tree.
        $this->elements = simplexml_import_dom($htmlDom);
      }
    }
884
885
886
    if (!$this->elements) {
      $this->fail(t('Parsed page successfully.'), t('Browser'));
    }
887

888
889
890
891
892
893
    return $this->elements;
  }

  /**
   * Retrieves a Drupal path or an absolute path.
   *
894
   * @param $path
895
   *   Drupal path or URL to load into internal browser
896
897
898
899
   * @param $options
   *  Options to be forwarded to url().
   * @return
   *  The retrieved HTML string, also available as $this->drupalGetContent()
900
901
902
   */
  function drupalGet($path, $options = array()) {
    $options['absolute'] = TRUE;
903
904
905
906

    // We re-using a CURL connection here.  If that connection still has certain
    // options set, it might change the GET into a POST.  Make sure we clear out
    // previous options.
907
    $out = $this->curlExec(array(CURLOPT_HTTPGET => TRUE, CURLOPT_URL => url($path, $options), CURLOPT_HEADER => FALSE, CURLOPT_NOBODY => FALSE));
908
    $this->refreshVariables(); // Ensure that any changes to variables in the other thread are picked up.
909
910
911
912
913

    // Replace original page output with new output from redirected page(s).
    if (($new = $this->checkForMetaRefresh())) {
      $out = $new;
    }
914
    return $out;
915
916
917
  }

  /**
918
919
   * Execute a POST request on a Drupal page.
   * It will be done as usual POST request with SimpleBrowser.
920
   *
921
   * @param $path
922
   *   Location of the post form. Either a Drupal path or an absolute path or
923
924
925
926
927
928
929
930
931
932
   *   NULL to post to the current page. For multi-stage forms you can set the
   *   path to NULL and have it post to the last received page. Example:
   *
   *   // First step in form.
   *   $edit = array(...);
   *   $this->drupalPost('some_url', $edit, t('Save'));
   *
   *   // Second step in form.
   *   $edit = array(...);
   *   $this->drupalPost(NULL, $edit, t('Save'));
933
   * @param  $edit
934
935
   *   Field data in an assocative array. Changes the current input fields
   *   (where possible) to the values indicated. A checkbox can be set to
936
937
938
   *   TRUE to be checked and FALSE to be unchecked. Note that when a form
   *   contains file upload fields, other fields cannot start with the '@'
   *   character.
939
940
941
942
943
   *
   *   Multiple select fields can be set using name[] and setting each of the
   *   possible values. Example:
   *   $edit = array();
   *   $edit['name[]'] = array('value1', 'value2');
944
   * @param $submit
945
   *   Value of the submit button.
946
947
   * @param $options
   *   Options to be forwarded to url().
948
   */
949
  function drupalPost($path, $edit, $submit, $options = array()) {
950
951
    $submit_matches = FALSE;
    if (isset($path)) {
952
      $html = $this->drupalGet($path, $options);
953
954
955
956
    }
    if ($this->parse()) {
      $edit_save = $edit;
      // Let's iterate over all the forms.
957
      $forms = $this->xpath('//form');
958
      foreach ($forms as $form) {
959
960
961
962
963
964
        // We try to set the fields of this form as specified in $edit.
        $edit = $edit_save;
        $post = array();
        $upload = array();
        $submit_matches = $this->handleForm($post, $edit, $upload, $submit, $form);
        $action = isset($form['action']) ? $this->getAbsoluteUrl($form['action']) : $this->getUrl();
965

966
        // We post only if we managed to handle every field in edit and the
967
        // submit button matches.
968
        if (!$edit && $submit_matches) {
969
970
971
972
973
          if ($upload) {
            // TODO: cURL handles file uploads for us, but the implementation
            // is broken. This is a less than elegant workaround. Alternatives
            // are being explored at #253506.
            foreach ($upload as $key => $file) {
974
975
976
977
              $file = realpath($file);
              if ($file && is_file($file)) {
                $post[$key] = '@' . $file;
              }
978
979
980
981
982
983
984
985
986
987
            }
          }
          else {
            foreach ($post as $key => $value) {
              // Encode according to application/x-www-form-urlencoded
              // Both names and values needs to be urlencoded, according to
              // http://www.w3.org/TR/html4/interact/forms.html#h-17.13.4.1
              $post[$key] = urlencode($key) . '=' . urlencode($value);
            }
            $post = implode('&', $post);
988
          }
989
          $out = $this->curlExec(array(CURLOPT_URL => $action, CURLOPT_POST => TRUE, CURLOPT_POSTFIELDS => $post, CURLOPT_HEADER => FALSE));
990
          // Ensure that any changes to variables in the other thread are picked up.
991
          $this->refreshVariables();
992
993
994
995
996

          // Replace original page output with new output from redirected page(s).
          if (($new = $this->checkForMetaRefresh())) {
            $out = $new;
          }
997
          return $out;
998
999
1000
1001
1002
1003
        }
      }
      // We have not found a form which contained all fields of $edit.
      foreach ($edit as $name => $value) {
        $this->fail(t('Failed to set field @name to @value', array('@name' => $name, '@value' => $value)));
      }
1004
1005
      $this->assertTrue($submit_matches, t('Found the @submit button', array('@submit' => $submit)));
      $this->fail(t('Found the requested form fields at @path', array('@path' => $path)));
1006
1007
1008
    }
  }

1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
  /**
   * Check for meta refresh tag and if found call drupalGet() recursively. This
   * function looks for the http-equiv attribute to be set to "Refresh"
   * and is case-sensitive.
   *
   * @return
   *   Either the new page content or FALSE.
   */
  private function checkForMetaRefresh() {
    if ($this->drupalGetContent() != '' && $this->parse()) {
      $refresh = $this->xpath('//meta[@http-equiv="Refresh"]');
      if (!empty($refresh)) {
        // Parse the content attribute of the meta tag for the format:
        // "[delay]: URL=[page_to_redirect_to]".
        if (preg_match('/\d+;\s*URL=(?P<url>.*)/i', $refresh[0]['content'], $match)) {
          return $this->drupalGet($this->getAbsoluteUrl(decode_entities($match['url'])));
        }
      }
    }
    return FALSE;
  }

1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
  /**
   * Retrieves only the headers for a Drupal path or an absolute path.
   *
   * @param $path
   *   Drupal path or URL to load into internal browser
   * @param $options
   *   Options to be forwarded to url().
   * @return
   *   The retrieved headers, also available as $this->drupalGetContent()
   */
  function drupalHead($path, $options = array()) {
    $options['absolute'] = TRUE;
    $out = $this->curlExec(array(CURLOPT_HEADER => TRUE, CURLOPT_NOBODY => TRUE, CURLOPT_URL => url($path, $options)));
    $this->refreshVariables(); // Ensure that any changes to variables in the other thread are picked up.
    return $out;
  }

1048
1049
  /**
   * Handle form input related to drupalPost(). Ensure that the specified fields
1050
   * exist and attempt to create POST data in the correct manner for the particular
1051
1052
   * field type.
   *
1053
   * @param $post
1054
   *   Reference to array of post values.
1055
   * @param $edit
1056
   *   Reference to array of edit values to be checked against the form.
1057
   * @param $submit
1058
   *   Form submit button value.
1059
   * @param $form
1060
   *   Array of form elements.
1061
   * @return
1062
   *   Submit value matches a valid submit input in the form.
1063
1064
1065
1066
1067
1068
1069
   */
  protected function handleForm(&$post, &$edit, &$upload, $submit, $form) {
    // Retrieve the form elements.
    $elements = $form->xpath('.//input|.//textarea|.//select');
    $submit_matches = FALSE;
    foreach ($elements as $element) {
      // SimpleXML objects need string casting all the time.
1070
      $name = (string) $element['name'];
1071
1072
1073
1074
1075
      // This can either be the type of <input> or the name of the tag itself
      // for <select> or <textarea>.
      $type = isset($element['type']) ? (string)$element['type'] : $element->getName();
      $value = isset($element['value']) ? (string)$element['value'] : '';
      $done = FALSE;
1076
      if (isset($edit[$name])) {
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
        switch ($type) {
          case 'text':
          case 'textarea':
          case 'password':
            $post[$name] = $edit[$name];
            unset($edit[$name]);
            break;
          case 'radio':
            if ($edit[$name] == $value) {
              $post[$name] = $edit[$name];
              unset($edit[$name]);
            }
            break;
          case 'checkbox':
            // To prevent checkbox from being checked.pass in a FALSE,
            // otherwise the checkbox will be set to its value regardless
            // of $edit.
            if ($edit[$name] === FALSE) {
              unset($edit[$name]);
              continue 2;
            }
            else {
              unset($edit[$name]);
              $post[$name] = $value;
            }
            break;
          case 'select':
            $new_value = $edit[$name];
            $index = 0;
            $key = preg_replace('/\[\]$/', '', $name);
            $options = $this->getAllOptions($element);
            foreach ($options as $option) {
              if (is_array($new_value)) {
                $option_value= (string)$option['value'];
                if (in_array($option_value, $new_value)) {
1112
                  $post[$key . '[' . $index++ . ']'] = $option_value;
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
                  $done = TRUE;
                  unset($edit[$name]);
                }
              }
              elseif ($new_value == $option['value']) {
                $post[$name] = $new_value;
                unset($edit[$name]);
                $done = TRUE;
              }
            }
            break;
          case 'file':
            $upload[$name] = $edit[$name];
            unset($edit[$name]);
            break;
        }
      }
      if (!isset($post[$name]) && !$done) {
        switch ($type) {
          case 'textarea':
            $post[$name] = (string)$element;
            break;
          case 'select':
            $single = empty($element['multiple']);
            $first = TRUE;
            $index = 0;
            $key = preg_replace('/\[\]$/', '', $name);
            $options = $this->getAllOptions($element);
            foreach ($options as $option) {
              // For single select, we load the first option, if there is a
              // selected option that will overwrite it later.
              if ($option['selected'] || ($first && $single)) {
                $first = FALSE;
                if ($single) {
                  $post[$name] = (string)$option['value'];
                }
                else {
1150
                  $post[$key . '[' . $index++ . ']'] = (string)$option['value'];
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
                }
              }
            }
            break;
          case 'file':
            break;
          case 'submit':
          case 'image':
            if ($submit == $value) {
              $post[$name] = $value;
              $submit_matches = TRUE;
            }
            break;
          case 'radio':
          case 'checkbox':
            if (!isset($element['checked'])) {
              break;
            }
            // Deliberate no break.
          default:
            $post[$name] = $value;
        }
      }
    }
    return $submit_matches;
  }

1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
  /**
   * Peform an xpath search on the contents of the internal browser. The search
   * is relative to the root element (HTML tag normally) of the page.
   *
   * @param $xpath
   *   The xpath string to use in the search.
   * @return
   *   The return value of the xpath search. For details on the xpath string
   *   format and return values see the SimpleXML documentation.
   *   http://us.php.net/manual/function.simplexml-element-xpath.php
   */
  public function xpath($xpath) {
    if ($this->parse()) {
      return $this->elements->xpath($xpath);
    }
    return FALSE;
  }

1196
1197
1198
  /**
   * Get all option elements, including nested options, in a select.
   *
1199
1200
1201
1202
   * @param $element
   *   The element for which to get the options.
   * @return
   *   Option elements in select.
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
   */
  private function getAllOptions(SimpleXMLElement $element) {
    $options = array();
    // Add all options items.
    foreach ($element->option as $option) {
      $options[] = $option;
    }

    // Search option group children.
    if (isset($element->optgroup)) {
1213
1214
1215
      foreach ($element->optgroup as $group) {
        $options = array_merge($options, $this->getAllOptions($group));
      }
1216
1217
1218
1219
    }
    return $options;
  }

1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
  /**
   * Pass if a link with the specified label is found, and optional with the
   * specified index.
   *
   * @param $label
   *   Text between the anchor tags.
   * @param $index
   *   Link position counting from zero.
   * @param $message
   *   Message to display.
   * @param $group
   *   The group this message belongs to, defaults to 'Other'.
   */
  public function assertLink($label, $index = 0, $message = '', $group = 'Other') {
    $links = $this->xpath('//a[text()="' . $label . '"]');
    $message = ($message ?  $message : t('Link with label "!label" found.', array('!label' => $label)));
    $this->_assert(isset($links[$index]), $message, $group);
  }

  /**
   * Pass if a link with the specified label is not found.
   *
   * @param $label
   *   Text between the anchor tags.
   * @param $index
   *   Link position counting from zero.
   * @param $message
   *   Message to display.
   * @param $group
   *   The group this message belongs to, defaults to 'Other'.
   */
  public function assertNoLink($label, $message = '', $group = 'Other') {
    $links = $this->xpath('//a[text()="' . $label . '"]');
    $message = ($message ?  $message : t('Link with label "!label" not found.', array('!label' => $label)));
    $this->_assert(empty($links), $message, $group);
  }

1257
1258
1259
1260
1261
1262
1263
1264
  /**
   * Follows a link by name.
   *
   * Will click the first link found with this link text by default, or a
   * later one if an index is given. Match is case insensitive with
   * normalized space. The label is translated label. There is an assert
   * for successful click.
   *
1265
1266
1267
1268
1269
1270
   * @param $label
   *   Text between the anchor tags.
   * @param $index
   *   Link position counting from zero.
   * @return
   *   Page on success, or FALSE on failure.
1271
1272
1273
   */
  function clickLink($label, $index = 0) {
    $url_before = $this->getUrl();
1274
    $urls = $this->xpath('//a[text()="' . $label . '"]');
1275

1276
1277
    if (isset($urls[$index])) {
      $url_target = $this->getAbsoluteUrl($urls[$index]['href']);
1278
    }
1279
1280
1281
1282
1283
1284
1285

    $this->assertTrue(isset($urls[$index]), t('Clicked link "!label" (!url_target) from !url_before', array('!label' => $label, '!url_target' => $url_target, '!url_before' => $url_before)), t('Browser'));

    if (isset($urls[$index])) {
      return $this->drupalGet($url_target);
    }
    return FALSE;
1286
1287
1288
1289
1290
  }

  /**
   * Takes a path and returns an absolute path.
   *
1291
   * @param $path
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
   *   The path, can be a Drupal path or a site-relative path. It might have a
   *   query, too. Can even be an absolute path which is just passed through.
   * @return
   *   An absolute path.
   */
  function getAbsoluteUrl($path) {
    $options = array('absolute' => TRUE);
    $parts = parse_url($path);
    // This is more crude than the menu_is_external but enough here.
    if (empty($parts['host'])) {
      $path = $parts['path'];
      $base_path = base_path();
      $n = strlen($base_path);
      if (substr($path, 0, $n) == $base_path) {
        $path = substr($path, $n);
      }
      if (isset($parts['query'])) {
        $options['query'] = $parts['query'];
      }
      $path = url($path, $options);
    }
    return $path;
  }

  /**
   * Get the current url from the cURL handler.
   *
1319
1320
   * @return
   *   The current url.
1321
1322
   */
  function getUrl() {
1323
    return $this->_url;
1324
1325
1326
1327
1328
1329
1330
1331
1332
  }

  /**
   * Gets the current raw HTML of requested page.
   */
  function drupalGetContent() {
    return $this->_content;
  }

1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
  /**
   * Sets the raw HTML content. This can be useful when a page has been fetched
   * outside of the internal browser and assertions need to be made on the
   * returned page.
   *
   * A good example would be when testing drupal_http_request(). After fetching
   * the page the content can be set and page elements can be checked to ensure
   * that the function worked properly.
   */
  function drupalSetContent($content, $url = 'internal:') {
    $this->_content = $content;
    $this->_url = $url;
    $this->plain_text = FALSE;
    $this->elements = FALSE;
  }

1349
1350
1351
1352
  /**
   * Pass if the raw text IS found on the loaded page, fail otherwise. Raw text
   * refers to the raw HTML that the page generated.
   *
1353
1354
1355
1356
1357
1358
1359
1360
   * @param $raw
   *  Raw (HTML) string to look for.
   * @param $message
   *   Message to display.
   * @param $group
   *   The group this message belongs to, defaults to 'Other'.
   * @return
   *   TRUE on pass, FALSE on fail.
1361
   */
1362
  function assertRaw($raw, $message = '%s found', $group = 'Other') {
1363
    return $this->_assert(strpos($this->_content, $raw) !== FALSE, $message, $group);
1364
1365
1366
1367
1368
1369
  }

  /**
   * Pass if the raw text is NOT found on the loaded page, fail otherwise. Raw text
   * refers to the raw HTML that the page generated.
   *
1370
1371
1372
1373
1374
1375
1376
1377
   * @param $raw
   *   Raw (HTML) string to look for.
   * @param $message
   *   Message to display.
   * @param $group
   *   The group this message belongs to, defaults to 'Other'.
   * @return
   *   TRUE on pass, FALSE on fail.
1378
   */
1379
  function assertNoRaw($raw, $message = '%s found', $group = 'Other') {
1380
    return $this->_assert(strpos($this->_content, $raw) === FALSE, $message, $group);
1381
1382
1383
1384
1385
1386
1387
  }

  /**
   * Pass if the text IS found on the text version of the page. The text version
   * is the equivilent of what a user would see when viewing through a web browser.
   * In other words the HTML has been filtered out of the contents.
   *
1388
1389
1390
1391
1392
1393
1394
1395
   * @param $text
   *  Plain text to look for.
   * @param $message
   *   Message to display.
   * @param $group
   *   The group this message belongs to, defaults to 'Other'.
   * @return
   *   TRUE on pass, FALSE on fail.
1396
1397
   */
  function assertText($text, $message = '', $group = 'Other') {
1398
    return $this->assertTextHelper($text, $message, $group, FALSE);
1399
1400
1401
1402
1403
1404
1405
  }

  /**
   * Pass if the text is NOT found on the text version of the page. The text version
   * is the equivilent of what a user would see when viewing through a web browser.
   * In other words the HTML has been filtered out of the contents.
   *
1406
1407
1408
1409
1410
1411
1412
1413
   * @param $text
   *   Plain text to look for.
   * @param $message
   *   Message to display.
   * @param $group
   *   The group this message belongs to, defaults to 'Other'.
   * @return
   *   TRUE on pass, FALSE on fail.
1414
1415
1416
1417
1418
1419
   */
  function assertNoText($text, $message = '', $group = 'Other') {
    return $this->assertTextHelper($text, $message, $group, TRUE);
  }

  /**
1420
1421
1422
   * Helper for assertText and assertNoText.
   *
   * It is not recommended to call this function directly.
1423
   *
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
   * @param $text
   *   Plain text to look for.
   * @param $message
   *   Message to display.
   * @param $group
   *   The group this message belongs to.
   * @param $not_exists
   *   TRUE if this text should not exist, FALSE if it should.
   * @return
   *   TRUE on pass, FALSE on fail.
1434
1435
1436
1437
1438
1439
   */
  protected function assertTextHelper($text, $message, $group, $not_exists) {
    if ($this->plain_text === FALSE) {
      $this->plain_text = filter_xss($this->_content, array());
    }
    if (!$message) {
1440
      $message = '"' . $text . '"' . ($not_exists ? ' not found' : ' found');
1441
    }
1442
    return $this->_assert($not_exists == (strpos($this->plain_text, $text) === FALSE), $message, $group);
1443
1444
1445
1446
1447
  }

  /**
   * Will trigger a pass if the Perl regex pattern is found in the raw content.
   *
1448
1449
1450
1451
1452
1453
1454
1455
   * @param $pattern
   *   Perl regex to look for including the regex delimiters.
   * @param $message
   *   Message to display.
   * @param $group
   *   The group this message belongs to.
   * @return
   *   TRUE on pass, FALSE on fail.
1456
   */
1457
  function assertPattern($pattern, $message = 'Pattern %s found', $group = 'Other') {
1458
    return $this->_assert((bool) preg_match($pattern, $this->drupalGetContent()), $message, $group);
1459
1460
1461
1462
1463
  }

  /**
   * Will trigger a pass if the perl regex pattern is not present in raw content.
   *
1464
1465
1466
1467
1468
1469
1470
1471
   * @param $pattern
   *   Perl regex to look for including the regex delimiters.
   * @param $message
   *   Message to display.
   * @param $group
   *   The group this message belongs to.
   * @return
   *   TRUE on pass, FALSE on fail.
1472
   */
1473
  function assertNoPattern($pattern, $message = 'Pattern %s not found', $group = 'Other') {
1474
    return $this->_assert(!preg_match($pattern, $this->drupalGetContent()), $message, $group);
1475
1476
1477
1478
1479
  }

  /**
   * Pass if the page title is the given string.
   *
1480
1481
1482
1483
1484
1485
1486
1487
   * @param $title
   *  The string the title should be.
   * @param $message
   *   Message to display.
   * @param $group
   *   The group this message belongs to.
   * @return
   *   TRUE on pass, FALSE on fail.
1488
1489
   */
  function assertTitle($title, $message, $group = 'Other') {
1490
    return $this->_assert($this->xpath('//title[text()="' . $title . '"]') !== FALSE, $message, $group);
1491
1492
1493
1494
1495
  }

  /**
   * Assert that a field exists in the current page by the given XPath.
   *
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
   * @param $xpath
   *   XPath used to find the field.
   * @param $value
   *   Value of the field to assert.
   * @param $message
   *   Message to display.
   * @param $group
   *   The group this message belongs to.
   * @return
   *   TRUE on pass, FALSE on fail.
1506
1507
   */
  function assertFieldByXPath($xpath, $value, $message, $group = 'Other') {
1508
    $fields = $this->xpath($xpath);
1509
1510
1511
1512
1513

    // If value specified then check array for match.
    $found = TRUE;
    if ($value) {
      $found = FALSE;
1514
1515
      if ($fields) {
        foreach ($fields as $field) {