BrowserTestBase.php 23 KB
Newer Older
1
2
3
4
<?php

namespace Drupal\Tests;

5
use Behat\Mink\Driver\BrowserKitDriver;
6
7
8
use Behat\Mink\Driver\GoutteDriver;
use Behat\Mink\Element\Element;
use Behat\Mink\Mink;
9
use Behat\Mink\Selector\SelectorsHandler;
10
use Behat\Mink\Session;
11
use Drupal\Component\Serialization\Json;
12
use Drupal\Core\Database\Database;
13
14
use Drupal\Core\Test\FunctionalTestSetupTrait;
use Drupal\Core\Test\TestSetupTrait;
15
use Drupal\Core\Url;
16
use Drupal\Core\Utility\Error;
17
use Drupal\FunctionalTests\AssertLegacyTrait;
18
19
20
use Drupal\Tests\block\Traits\BlockCreationTrait;
use Drupal\Tests\node\Traits\ContentTypeCreationTrait;
use Drupal\Tests\node\Traits\NodeCreationTrait;
21
use Drupal\Tests\Traits\PhpUnitWarnings;
22
use Drupal\Tests\user\Traits\UserCreationTrait;
23
use Drupal\TestTools\Comparator\MarkupInterfaceComparator;
24
use Drupal\TestTools\TestVarDumper;
25
use GuzzleHttp\Cookie\CookieJar;
26
use PHPUnit\Framework\TestCase;
27
use Symfony\Bridge\PhpUnit\ExpectDeprecationTrait;
28
use Symfony\Component\VarDumper\VarDumper;
29
30
31
32
33
34

/**
 * Provides a test case for functional Drupal tests.
 *
 * Tests extending BrowserTestBase must exist in the
 * Drupal\Tests\yourmodule\Functional namespace and live in the
35
 * modules/yourmodule/tests/src/Functional directory.
36
 *
37
38
39
40
 * Tests extending this base class should only translate text when testing
 * translation functionality. For example, avoid wrapping test text with t()
 * or TranslatableMarkup().
 *
41
42
43
44
45
 * Using Symfony's dump() function in functional test test code will produce
 * output on the command line; using dump() in site code will produce output in
 * the requested web page, which can then be inspected in the HTML output from
 * the test.
 *
46
47
 * @ingroup testing
 */
48
abstract class BrowserTestBase extends TestCase {
49
50

  use FunctionalTestSetupTrait;
51
52
53
  use UiHelperTrait {
    FunctionalTestSetupTrait::refreshVariables insteadof UiHelperTrait;
  }
54
  use TestSetupTrait;
55
56
57
  use BlockCreationTrait {
    placeBlock as drupalPlaceBlock;
  }
58
  use AssertLegacyTrait;
59
  use RandomGeneratorTrait;
60
  use NodeCreationTrait {
61
    getNodeByTitle as drupalGetNodeByTitle;
62
63
    createNode as drupalCreateNode;
  }
64
65
66
  use ContentTypeCreationTrait {
    createContentType as drupalCreateContentType;
  }
67
  use ConfigTestTrait;
68
  use TestRequirementsTrait;
69
70
71
72
  use UserCreationTrait {
    createRole as drupalCreateRole;
    createUser as drupalCreateUser;
  }
73
  use XdebugRequestTrait;
74
  use PhpUnitWarnings;
75
  use PhpUnitCompatibilityTrait;
76
  use ExpectDeprecationTrait;
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

  /**
   * The database prefix of this test run.
   *
   * @var string
   */
  protected $databasePrefix;

  /**
   * Time limit in seconds for the test.
   *
   * @var int
   */
  protected $timeLimit = 500;

  /**
   * The translation file directory for the test environment.
   *
   * This is set in BrowserTestBase::prepareEnvironment().
   *
   * @var string
   */
  protected $translationFilesDirectory;

  /**
   * The config importer that can be used in a test.
   *
   * @var \Drupal\Core\Config\ConfigImporter
   */
  protected $configImporter;

108
109
110
111
112
113
114
115
116
117
118
  /**
   * Modules to enable.
   *
   * The test runner will merge the $modules lists from this class, the class
   * it extends, and so on up the class hierarchy. It is not necessary to
   * include modules in your list that a parent class has already declared.
   *
   * @var string[]
   *
   * @see \Drupal\Tests\BrowserTestBase::installDrupal()
   */
119
  protected static $modules = [];
120

121
122
123
124
125
126
127
  /**
   * The profile to install as a basis for testing.
   *
   * @var string
   */
  protected $profile = 'testing';

128
129
130
131
132
133
134
135
136
  /**
   * The theme to install as the default for testing.
   *
   * Defaults to the install profile's default theme, if it specifies any.
   *
   * @var string
   */
  protected $defaultTheme;

137
138
139
140
141
142
143
  /**
   * An array of custom translations suitable for drupal_rewrite_settings().
   *
   * @var array
   */
  protected $customTranslations;

144
  /*
145
146
   * Mink class for the default driver to use.
   *
147
   * Should be a fully-qualified class name that implements
148
   * Behat\Mink\Driver\DriverInterface.
149
150
151
   *
   * Value can be overridden using the environment variable MINK_DRIVER_CLASS.
   *
152
   * @var string
153
   */
154
  protected $minkDefaultDriverClass = BrowserKitDriver::class;
155

156
  /*
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
   * Mink default driver params.
   *
   * If it's an array its contents are used as constructor params when default
   * Mink driver class is instantiated.
   *
   * Can be overridden using the environment variable MINK_DRIVER_ARGS. In this
   * case that variable should be a JSON array, for example:
   * '["firefox", null, "http://localhost:4444/wd/hub"]'.
   *
   *
   * @var array
   */
  protected $minkDefaultDriverArgs;

  /**
   * Mink session manager.
   *
174
175
176
   * This will not be initialized if there was an error during the test setup.
   *
   * @var \Behat\Mink\Mink|null
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
   */
  protected $mink;

  /**
   * {@inheritdoc}
   *
   * Browser tests are run in separate processes to prevent collisions between
   * code that may be loaded by tests.
   */
  protected $runTestInSeparateProcess = TRUE;

  /**
   * {@inheritdoc}
   */
  protected $preserveGlobalState = FALSE;

  /**
   * The base URL.
   *
   * @var string
   */
  protected $baseUrl;

200
201
202
203
204
205
206
  /**
   * The original array of shutdown function callbacks.
   *
   * @var array
   */
  protected $originalShutdownCallbacks = [];

207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
  /**
   * The app root.
   *
   * @var string
   */
  protected $root;

  /**
   * The original container.
   *
   * Move this to \Drupal\Core\Test\FunctionalTestSetupTrait once TestBase no
   * longer provides the same value.
   *
   * @var \Symfony\Component\DependencyInjection\ContainerInterface
   */
  protected $originalContainer;

224
225
226
227
228
229
230
231
  /**
   * {@inheritdoc}
   */
  public static function setUpBeforeClass() {
    parent::setUpBeforeClass();
    VarDumper::setHandler(TestVarDumper::class . '::cliHandler');
  }

232
233
234
235
236
237
  /**
   * Initializes Mink sessions.
   */
  protected function initMink() {
    $driver = $this->getDefaultDriverInstance();
    if ($driver instanceof GoutteDriver) {
238
239
240
241
      @trigger_error('Using \Behat\Mink\Driver\GoutteDriver is deprecated in drupal:9.2.0 and is removed from drupal:10.0.0. The dependencies behat/mink-goutte-driver and fabpot/goutte will be removed. See https://www.drupal.org/node/3177235', E_USER_DEPRECATED);
    }

    if ($driver instanceof BrowserKitDriver) {
242
      // Turn off curl timeout. Having a timeout is not a problem in a normal
243
244
      // test running, but it is a problem when debugging. Also, disable SSL
      // peer verification so that testing under HTTPS always works.
245
      /** @var \GuzzleHttp\Client $client */
246
247
248
249
      $client = $this->container->get('http_client_factory')->fromOptions([
        'timeout' => NULL,
        'verify' => FALSE,
      ]);
250
251
252
253
254
255
256

      // Inject a Guzzle middleware to generate debug output for every request
      // performed in the test.
      $handler_stack = $client->getConfig('handler');
      $handler_stack->push($this->getResponseLogHandler());

      $driver->getClient()->setClient($client);
257
258
    }

259
    $selectors_handler = new SelectorsHandler([
260
      'hidden_field_selector' => new HiddenFieldSelector(),
261
262
    ]);
    $session = new Session($driver, $selectors_handler);
263
264
265
266
267
    $this->mink = new Mink();
    $this->mink->registerSession('default', $session);
    $this->mink->setDefaultSessionName('default');
    $this->registerSessions();

268
    $this->initFrontPage();
269

270
271
272
273
274
275
276
277
278
279
    // Copies cookies from the current environment, for example, XDEBUG_SESSION
    // in order to support Xdebug.
    // @see BrowserTestBase::initFrontPage()
    $cookies = $this->extractCookiesFromRequest(\Drupal::request());
    foreach ($cookies as $cookie_name => $values) {
      foreach ($values as $value) {
        $session->setCookie($cookie_name, $value);
      }
    }

280
281
282
    return $session;
  }

283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
  /**
   * Visits the front page when initializing Mink.
   *
   * According to the W3C WebDriver specification a cookie can only be set if
   * the cookie domain is equal to the domain of the active document. When the
   * browser starts up the active document is not our domain but 'about:blank'
   * or similar. To be able to set our User-Agent and Xdebug cookies at the
   * start of the test we now do a request to the front page so the active
   * document matches the domain.
   *
   * @see https://w3c.github.io/webdriver/webdriver-spec.html#add-cookie
   * @see https://www.w3.org/Bugs/Public/show_bug.cgi?id=20975
   */
  protected function initFrontPage() {
    $session = $this->getSession();
    $session->visit($this->baseUrl);
  }

301
302
303
  /**
   * Gets an instance of the default Mink driver.
   *
304
   * @return Behat\Mink\Driver\DriverInterface
305
306
307
308
309
310
   *   Instance of default Mink driver.
   *
   * @throws \InvalidArgumentException
   *   When provided default Mink driver class can't be instantiated.
   */
  protected function getDefaultDriverInstance() {
311
312
    // Get default driver params from environment if available.
    if ($arg_json = $this->getMinkDriverArgs()) {
313
      $this->minkDefaultDriverArgs = json_decode($arg_json, TRUE);
314
315
    }

316
    // Get and check default driver class from environment if available.
317
318
319
320
321
322
323
324
325
    if ($minkDriverClass = getenv('MINK_DRIVER_CLASS')) {
      if (class_exists($minkDriverClass)) {
        $this->minkDefaultDriverClass = $minkDriverClass;
      }
      else {
        throw new \InvalidArgumentException("Can't instantiate provided $minkDriverClass class by environment as default driver class.");
      }
    }

326
327
328
329
    if ($this->minkDefaultDriverClass === BrowserKitDriver::class) {
      $driver = new $this->minkDefaultDriverClass(new DrupalTestBrowser());
    }
    elseif (is_array($this->minkDefaultDriverArgs)) {
330
      // Use ReflectionClass to instantiate class with received params.
331
332
333
334
      $reflector = new \ReflectionClass($this->minkDefaultDriverClass);
      $driver = $reflector->newInstanceArgs($this->minkDefaultDriverArgs);
    }
    else {
335
      $driver = new $this->minkDefaultDriverClass();
336
337
338
339
    }
    return $driver;
  }

340
341
342
343
344
  /**
   * Get the Mink driver args from an environment variable, if it is set. Can
   * be overridden in a derived class so it is possible to use a different
   * value for a subset of tests, e.g. the JavaScript tests.
   *
345
   * @return string|false
346
347
348
349
350
351
   *   The JSON-encoded argument string. False if it is not set.
   */
  protected function getMinkDriverArgs() {
    return getenv('MINK_DRIVER_ARGS');
  }

352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
  /**
   * Registers additional Mink sessions.
   *
   * Tests wishing to use a different driver or change the default driver should
   * override this method.
   *
   * @code
   *   // Register a new session that uses the MinkPonyDriver.
   *   $pony = new MinkPonyDriver();
   *   $session = new Session($pony);
   *   $this->mink->registerSession('pony', $session);
   * @endcode
   */
  protected function registerSessions() {}

  /**
   * {@inheritdoc}
   */
  protected function setUp() {
    parent::setUp();

373
374
    $this->setUpAppRoot();

375
376
377
    // Allow tests to compare MarkupInterface objects via assertEquals().
    $this->registerComparator(new MarkupInterfaceComparator());

378
    $this->setupBaseUrl();
379
380
381
382
383
384

    // Install Drupal test site.
    $this->prepareEnvironment();
    $this->installDrupal();

    // Setup Mink.
385
    $this->initMink();
386

387
388
    // Set up the browser test output file.
    $this->initBrowserOutputFile();
389
390
391
392
393

    // Ensure that the test is not marked as risky because of no assertions. In
    // PHPUnit 6 tests that only make assertions using $this->assertSession()
    // can be marked as risky.
    $this->addToAssertionCount(1);
394
395
  }

396
397
398
399
400
  /**
   * Sets up the root application path.
   */
  protected function setUpAppRoot(): void {
    if ($this->root === NULL) {
401
      $this->root = dirname(substr(__DIR__, 0, -strlen(__NAMESPACE__)), 2);
402
403
404
    }
  }

405
  /**
406
   * Ensures test files are deletable.
407
408
409
410
411
412
413
   *
   * Some tests chmod generated files to be read only. During
   * BrowserTestBase::cleanupEnvironment() and other cleanup operations,
   * these files need to get deleted too.
   *
   * @param string $path
   *   The file path.
414
415
   *
   * @see \Drupal\Core\File\FileSystemInterface::deleteRecursive()
416
417
   */
  public static function filePreDeleteCallback($path) {
418
419
420
421
422
    // When the webserver runs with the same system user as phpunit, we can
    // make read-only files writable again. If not, chmod will fail while the
    // file deletion still works if file permissions have been configured
    // correctly. Thus, we ignore any problems while running chmod.
    @chmod($path, 0700);
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
  }

  /**
   * Clean up the Simpletest environment.
   */
  protected function cleanupEnvironment() {
    // Remove all prefixed tables.
    $original_connection_info = Database::getConnectionInfo('simpletest_original_default');
    $original_prefix = $original_connection_info['default']['prefix']['default'];
    $test_connection_info = Database::getConnectionInfo('default');
    $test_prefix = $test_connection_info['default']['prefix']['default'];
    if ($original_prefix != $test_prefix) {
      $tables = Database::getConnection()->schema()->findTables('%');
      foreach ($tables as $table) {
        if (Database::getConnection()->schema()->dropTable($table)) {
          unset($tables[$table]);
        }
      }
    }

    // Delete test site directory.
444
    \Drupal::service('file_system')->deleteRecursive($this->siteDirectory, [$this, 'filePreDeleteCallback']);
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
  }

  /**
   * {@inheritdoc}
   */
  protected function tearDown() {
    parent::tearDown();

    // Destroy the testing kernel.
    if (isset($this->kernel)) {
      $this->cleanupEnvironment();
      $this->kernel->shutdown();
    }

    // Ensure that internal logged in variable is reset.
    $this->loggedInUser = FALSE;

    if ($this->mink) {
      $this->mink->stopSessions();
    }
465
466

    // Restore original shutdown callbacks.
467
468
469
470
    if (function_exists('drupal_register_shutdown_function')) {
      $callbacks = &drupal_register_shutdown_function();
      $callbacks = $this->originalShutdownCallbacks;
    }
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
  }

  /**
   * Returns Mink session.
   *
   * @param string $name
   *   (optional) Name of the session. Defaults to the active session.
   *
   * @return \Behat\Mink\Session
   *   The active Mink session object.
   */
  public function getSession($name = NULL) {
    return $this->mink->getSession($name);
  }

486
487
488
489
490
491
492
493
494
495
496
497
498
499
  /**
   * Get session cookies from current session.
   *
   * @return \GuzzleHttp\Cookie\CookieJar
   *   A cookie jar with the current session.
   */
  protected function getSessionCookies() {
    $domain = parse_url($this->getUrl(), PHP_URL_HOST);
    $session_id = $this->getSession()->getCookie($this->getSessionName());
    $cookies = CookieJar::fromArray([$this->getSessionName() => $session_id], $domain);

    return $cookies;
  }

500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
  /**
   * Obtain the HTTP client for the system under test.
   *
   * Use this method for arbitrary HTTP requests to the site under test. For
   * most tests, you should not get the HTTP client and instead use navigation
   * methods such as drupalGet() and clickLink() in order to benefit from
   * assertions.
   *
   * Subclasses which substitute a different Mink driver should override this
   * method and provide a Guzzle client if the Mink driver provides one.
   *
   * @return \GuzzleHttp\ClientInterface
   *   The client with BrowserTestBase configuration.
   *
   * @throws \RuntimeException
   *   If the Mink driver does not support a Guzzle HTTP client, throw an
   *   exception.
   */
  protected function getHttpClient() {
    /* @var $mink_driver \Behat\Mink\Driver\DriverInterface */
    $mink_driver = $this->getSession()->getDriver();
521
    if ($this->isTestUsingGuzzleClient()) {
522
523
524
525
526
      return $mink_driver->getClient()->getClient();
    }
    throw new \RuntimeException('The Mink client type ' . get_class($mink_driver) . ' does not support getHttpClient().');
  }

527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
  /**
   * Helper function to get the options of select field.
   *
   * @param \Behat\Mink\Element\NodeElement|string $select
   *   Name, ID, or Label of select field to assert.
   * @param \Behat\Mink\Element\Element $container
   *   (optional) Container element to check against. Defaults to current page.
   *
   * @return array
   *   Associative array of option keys and values.
   */
  protected function getOptions($select, Element $container = NULL) {
    if (is_string($select)) {
      $select = $this->assertSession()->selectExists($select, $container);
    }
    $options = [];
    /* @var \Behat\Mink\Element\NodeElement $option */
    foreach ($select->findAll('xpath', '//option') as $option) {
      $label = $option->getText();
      $value = $option->getAttribute('value') ?: $label;
      $options[$value] = $label;
    }
    return $options;
  }

  /**
   * Installs Drupal into the Simpletest site.
   */
  public function installDrupal() {
556
557
558
559
    $this->initUserSession();
    $this->prepareSettings();
    $this->doInstall();
    $this->initSettings();
560
    $this->container = $container = $this->initKernel(\Drupal::request());
561
    $this->initConfig($container);
562
    $this->installDefaultThemeFromClassProperty($container);
563
    $this->installModulesFromClassProperty($container);
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581

    // Clear the static cache so that subsequent cache invalidations will work
    // as expected.
    $this->container->get('cache_tags.invalidator')->resetChecksums();

    // Set the dummy query string added to all CSS and JavaScript files.
    // @todo Remove in https://www.drupal.org/project/drupal/issues/3207893.
    _drupal_flush_css_js();

    // Generate a route to prime the url generator with the correct base url.
    // @todo Remove in https://www.drupal.org/project/drupal/issues/3207896.
    Url::fromRoute('<front>')->setAbsolute()->toString();

    // Explicitly call register() again on the container registered in \Drupal.
    // @todo This should already be called through
    //   DrupalKernel::prepareLegacyRequest() -> DrupalKernel::boot() but that
    //   appears to be calling a different container.
    $this->container->get('stream_wrapper_manager')->register();
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
  }

  /**
   * Prevents serializing any properties.
   *
   * Browser tests are run in a separate process. To do this PHPUnit creates a
   * script to run the test. If it fails, the test result object will contain a
   * stack trace which includes the test object. It will attempt to serialize
   * it. Returning an empty array prevents it from serializing anything it
   * should not.
   *
   * @return array
   *   An empty array.
   *
   * @see vendor/phpunit/phpunit/src/Util/PHP/Template/TestCaseMethod.tpl.dist
   */
  public function __sleep() {
    return [];
  }

602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
  /**
   * Performs 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 string $xpath
   *   The xpath string to use in the search.
   * @param array $arguments
   *   An array of arguments with keys in the form ':name' matching the
   *   placeholders in the query. The values may be either strings or numeric
   *   values.
   *
   * @return \Behat\Mink\Element\NodeElement[]
   *   The list of elements matching the xpath expression.
   */
  protected function xpath($xpath, array $arguments = []) {
618
    $xpath = $this->assertSession()->buildXPathQuery($xpath, $arguments);
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
    return $this->getSession()->getPage()->findAll('xpath', $xpath);
  }

  /**
   * Configuration accessor for tests. Returns non-overridden configuration.
   *
   * @param string $name
   *   Configuration name.
   *
   * @return \Drupal\Core\Config\Config
   *   The configuration object with original configuration data.
   */
  protected function config($name) {
    return $this->container->get('config.factory')->getEditable($name);
  }

  /**
   * Gets the value of an HTTP response header.
   *
   * If multiple requests were required to retrieve the page, only the headers
   * from the last request will be checked by default.
   *
   * @param string $name
   *   The name of the header to retrieve. Names are case-insensitive (see RFC
   *   2616 section 4.2).
   *
   * @return string|null
   *   The HTTP header value or NULL if not found.
647
648
649
650
651
   *
   * @deprecated in drupal:9.2.0 and is removed from drupal:10.0.0. Use
   *   $this->getSession()->getResponseHeader() instead.
   *
   * @see https://www.drupal.org/node/3168383
652
653
   */
  protected function drupalGetHeader($name) {
654
    @trigger_error('BrowserTestBase::drupalGetHeader() is deprecated in drupal:9.2.0 and is removed from drupal:10.0.0. Use $this->getSession()->getResponseHeader() instead. See https://www.drupal.org/node/3168383', E_USER_DEPRECATED);
655
656
657
    return $this->getSession()->getResponseHeader($name);
  }

658
659
660
661
662
663
664
  /**
   * Gets the JavaScript drupalSettings variable for the currently-loaded page.
   *
   * @return array
   *   The JSON decoded drupalSettings value from the current page.
   */
  protected function getDrupalSettings() {
665
    $html = $this->getSession()->getPage()->getContent();
666
667
668
669
670
671
    if (preg_match('@<script type="application/json" data-drupal-selector="drupal-settings-json">([^<]*)</script>@', $html, $matches)) {
      return Json::decode($matches[1]);
    }
    return [];
  }

672
673
674
675
676
677
678
679
  /**
   * Retrieves the current calling line in the class under test.
   *
   * @return array
   *   An associative array with keys 'file', 'line' and 'function'.
   */
  protected function getTestMethodCaller() {
    $backtrace = debug_backtrace();
680
681
    // Find the test class that has the test method.
    while ($caller = Error::getLastCaller($backtrace)) {
682
683
684
685
686
      // If we match PHPUnit's TestCase::runTest, then the previously processed
      // caller entry is where our test method sits.
      if (isset($last_caller) && isset($caller['function']) && $caller['function'] === 'PHPUnit\Framework\TestCase->runTest()') {
        // Return the last caller since that has to be the test class.
        $caller = $last_caller;
687
688
        break;
      }
689

690
691
692
693
694
695
696
697
698
      // If the test method is implemented by a test class's parent then the
      // class name of $this will not be part of the backtrace.
      // In that case we process the backtrace until the caller is not a
      // subclass of $this and return the previous caller.
      if (isset($last_caller) && (!isset($caller['class']) || !is_subclass_of($this, $caller['class']))) {
        // Return the last caller since that has to be the test class.
        $caller = $last_caller;
        break;
      }
699

700
      if (isset($caller['class']) && $caller['class'] === static::class) {
701
702
703
        break;
      }

704
705
706
      // Otherwise we have not reached our test class yet: save the last caller
      // and remove an element from to backtrace to process the next call.
      $last_caller = $caller;
707
708
709
      array_shift($backtrace);
    }

710
    return $caller;
711
712
  }

713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
  /**
   * Transforms a nested array into a flat array suitable for drupalPostForm().
   *
   * @param array $values
   *   A multi-dimensional form values array to convert.
   *
   * @return array
   *   The flattened $edit array suitable for BrowserTestBase::drupalPostForm().
   */
  protected function translatePostValues(array $values) {
    $edit = [];
    // The easiest and most straightforward way to translate values suitable for
    // BrowserTestBase::drupalPostForm() is to actually build the POST data
    // string and convert the resulting key/value pairs back into a flat array.
    $query = http_build_query($values);
    foreach (explode('&', $query) as $item) {
      list($key, $value) = explode('=', $item);
      $edit[urldecode($key)] = urldecode($value);
    }
    return $edit;
  }

735
}