vendor/symfony/browser-kit/AbstractBrowser.php line 141

  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\BrowserKit;
  14. use Symfony\Component\BrowserKit\Exception\BadMethodCallException;
  15. use Symfony\Component\DomCrawler\Crawler;
  16. use Symfony\Component\DomCrawler\Form;
  17. use Symfony\Component\DomCrawler\Link;
  18. use Symfony\Component\Process\PhpProcess;
  20. /**
  21.  * Simulates a browser.
  22.  *
  23.  * To make the actual request, you need to implement the doRequest() method.
  24.  *
  25.  * If you want to be able to run requests in their own process (insulated flag),
  26.  * you need to also implement the getScript() method.
  27.  *
  28.  * @author Fabien Potencier <fabien@symfony.com>
  29.  */
  30. abstract class AbstractBrowser
  31. {
  32.     protected $history;
  33.     protected $cookieJar;
  34.     protected $server = [];
  35.     protected $internalRequest;
  36.     protected $request;
  37.     protected $internalResponse;
  38.     protected $response;
  39.     protected $crawler;
  40.     protected $insulated = false;
  41.     protected $redirect;
  42.     protected $followRedirects = true;
  43.     protected $followMetaRefresh = false;
  45.     private int $maxRedirects = -1;
  46.     private int $redirectCount = 0;
  47.     private array $redirects = [];
  48.     private bool $isMainRequest = true;
  50.     /**
  51.      * @param array $server The server parameters (equivalent of $_SERVER)
  52.      */
  53.     public function __construct(array $server = [], History $history = null, CookieJar $cookieJar = null)
  54.     {
  55.         $this->setServerParameters($server);
  56.         $this->history = $history ?? new History();
  57.         $this->cookieJar = $cookieJar ?? new CookieJar();
  58.     }
  60.     /**
  61.      * Sets whether to automatically follow redirects or not.
  62.      */
  63.     public function followRedirects(bool $followRedirects = true)
  64.     {
  65.         $this->followRedirects = $followRedirects;
  66.     }
  68.     /**
  69.      * Sets whether to automatically follow meta refresh redirects or not.
  70.      */
  71.     public function followMetaRefresh(bool $followMetaRefresh = true)
  72.     {
  73.         $this->followMetaRefresh = $followMetaRefresh;
  74.     }
  76.     /**
  77.      * Returns whether client automatically follows redirects or not.
  78.      */
  79.     public function isFollowingRedirects(): bool
  80.     {
  81.         return $this->followRedirects;
  82.     }
  84.     /**
  85.      * Sets the maximum number of redirects that crawler can follow.
  86.      */
  87.     public function setMaxRedirects(int $maxRedirects)
  88.     {
  89.         $this->maxRedirects = $maxRedirects < 0 ? -1 : $maxRedirects;
  90.         $this->followRedirects = -1 !== $this->maxRedirects;
  91.     }
  93.     /**
  94.      * Returns the maximum number of redirects that crawler can follow.
  95.      */
  96.     public function getMaxRedirects(): int
  97.     {
  98.         return $this->maxRedirects;
  99.     }
  101.     /**
  102.      * Sets the insulated flag.
  103.      *
  104.      * @throws \RuntimeException When Symfony Process Component is not installed
  105.      */
  106.     public function insulate(bool $insulated = true)
  107.     {
  108.         if ($insulated && !class_exists(\Symfony\Component\Process\Process::class)) {
  109.             throw new \LogicException('Unable to isolate requests as the Symfony Process Component is not installed.');
  110.         }
  112.         $this->insulated = $insulated;
  113.     }
  115.     /**
  116.      * Sets server parameters.
  117.      */
  118.     public function setServerParameters(array $server)
  119.     {
  120.         $this->server = array_merge([
  121.             'HTTP_USER_AGENT' => 'Symfony BrowserKit',
  122.         ], $server);
  123.     }
  125.     /**
  126.      * Sets single server parameter.
  127.      */
  128.     public function setServerParameter(string $key, string $value)
  129.     {
  130.         $this->server[$key] = $value;
  131.     }
  133.     /**
  134.      * Gets single server parameter for specified key.
  135.      */
  136.     public function getServerParameter(string $key, mixed $default = ''): mixed
  137.     {
  138.         return $this->server[$key] ?? $default;
  139.     }
  141.     public function xmlHttpRequest(string $method, string $uri, array $parameters = [], array $files = [], array $server = [], string $content = null, bool $changeHistory = true): Crawler
  142.     {
  143.         $this->setServerParameter('HTTP_X_REQUESTED_WITH', 'XMLHttpRequest');
  145.         try {
  146.             return $this->request($method, $uri, $parameters, $files, $server, $content, $changeHistory);
  147.         } finally {
  148.             unset($this->server['HTTP_X_REQUESTED_WITH']);
  149.         }
  150.     }
  152.     /**
  153.      * Converts the request parameters into a JSON string and uses it as request content.
  154.      */
  155.     public function jsonRequest(string $method, string $uri, array $parameters = [], array $server = [], bool $changeHistory = true): Crawler
  156.     {
  157.         $content = json_encode($parameters);
  159.         $this->setServerParameter('CONTENT_TYPE', 'application/json');
  160.         $this->setServerParameter('HTTP_ACCEPT', 'application/json');
  162.         try {
  163.             return $this->request($method, $uri, [], [], $server, $content, $changeHistory);
  164.         } finally {
  165.             unset($this->server['CONTENT_TYPE']);
  166.             unset($this->server['HTTP_ACCEPT']);
  167.         }
  168.     }
  170.     /**
  171.      * Returns the History instance.
  172.      */
  173.     public function getHistory(): History
  174.     {
  175.         return $this->history;
  176.     }
  178.     /**
  179.      * Returns the CookieJar instance.
  180.      */
  181.     public function getCookieJar(): CookieJar
  182.     {
  183.         return $this->cookieJar;
  184.     }
  186.     /**
  187.      * Returns the current Crawler instance.
  188.      */
  189.     public function getCrawler(): Crawler
  190.     {
  191.         if (null === $this->crawler) {
  192.             throw new BadMethodCallException(sprintf('The "request()" method must be called before "%s()".', __METHOD__));
  193.         }
  195.         return $this->crawler;
  196.     }
  198.     /**
  199.      * Returns the current BrowserKit Response instance.
  200.      */
  201.     public function getInternalResponse(): Response
  202.     {
  203.         if (null === $this->internalResponse) {
  204.             throw new BadMethodCallException(sprintf('The "request()" method must be called before "%s()".', __METHOD__));
  205.         }
  207.         return $this->internalResponse;
  208.     }
  210.     /**
  211.      * Returns the current origin response instance.
  212.      *
  213.      * The origin response is the response instance that is returned
  214.      * by the code that handles requests.
  215.      *
  216.      * @see doRequest()
  217.      */
  218.     public function getResponse(): object
  219.     {
  220.         if (null === $this->response) {
  221.             throw new BadMethodCallException(sprintf('The "request()" method must be called before "%s()".', __METHOD__));
  222.         }
  224.         return $this->response;
  225.     }
  227.     /**
  228.      * Returns the current BrowserKit Request instance.
  229.      */
  230.     public function getInternalRequest(): Request
  231.     {
  232.         if (null === $this->internalRequest) {
  233.             throw new BadMethodCallException(sprintf('The "request()" method must be called before "%s()".', __METHOD__));
  234.         }
  236.         return $this->internalRequest;
  237.     }
  239.     /**
  240.      * Returns the current origin Request instance.
  241.      *
  242.      * The origin request is the request instance that is sent
  243.      * to the code that handles requests.
  244.      *
  245.      * @see doRequest()
  246.      */
  247.     public function getRequest(): object
  248.     {
  249.         if (null === $this->request) {
  250.             throw new BadMethodCallException(sprintf('The "request()" method must be called before "%s()".', __METHOD__));
  251.         }
  253.         return $this->request;
  254.     }
  256.     /**
  257.      * Clicks on a given link.
  258.      */
  259.     public function click(Link $link): Crawler
  260.     {
  261.         if ($link instanceof Form) {
  262.             return $this->submit($link);
  263.         }
  265.         return $this->request($link->getMethod(), $link->getUri());
  266.     }
  268.     /**
  269.      * Clicks the first link (or clickable image) that contains the given text.
  270.      *
  271.      * @param string $linkText The text of the link or the alt attribute of the clickable image
  272.      */
  273.     public function clickLink(string $linkText): Crawler
  274.     {
  275.         if (null === $this->crawler) {
  276.             throw new BadMethodCallException(sprintf('The "request()" method must be called before "%s()".', __METHOD__));
  277.         }
  279.         return $this->click($this->crawler->selectLink($linkText)->link());
  280.     }
  282.     /**
  283.      * Submits a form.
  284.      *
  285.      * @param array $values           An array of form field values
  286.      * @param array $serverParameters An array of server parameters
  287.      */
  288.     public function submit(Form $form, array $values = [], array $serverParameters = []): Crawler
  289.     {
  290.         $form->setValues($values);
  292.         return $this->request($form->getMethod(), $form->getUri(), $form->getPhpValues(), $form->getPhpFiles(), $serverParameters);
  293.     }
  295.     /**
  296.      * Finds the first form that contains a button with the given content and
  297.      * uses it to submit the given form field values.
  298.      *
  299.      * @param string $button           The text content, id, value or name of the form <button> or <input type="submit">
  300.      * @param array  $fieldValues      Use this syntax: ['my_form[name]' => '...', 'my_form[email]' => '...']
  301.      * @param string $method           The HTTP method used to submit the form
  302.      * @param array  $serverParameters These values override the ones stored in $_SERVER (HTTP headers must include an HTTP_ prefix as PHP does)
  303.      */
  304.     public function submitForm(string $button, array $fieldValues = [], string $method = 'POST', array $serverParameters = []): Crawler
  305.     {
  306.         if (null === $this->crawler) {
  307.             throw new BadMethodCallException(sprintf('The "request()" method must be called before "%s()".', __METHOD__));
  308.         }
  310.         $buttonNode = $this->crawler->selectButton($button);
  311.         $form = $buttonNode->form($fieldValues, $method);
  313.         return $this->submit($form, [], $serverParameters);
  314.     }
  316.     /**
  317.      * Calls a URI.
  318.      *
  319.      * @param string $method        The request method
  320.      * @param string $uri           The URI to fetch
  321.      * @param array  $parameters    The Request parameters
  322.      * @param array  $files         The files
  323.      * @param array  $server        The server parameters (HTTP headers are referenced with an HTTP_ prefix as PHP does)
  324.      * @param string $content       The raw body data
  325.      * @param bool   $changeHistory Whether to update the history or not (only used internally for back(), forward(), and reload())
  326.      */
  327.     public function request(string $method, string $uri, array $parameters = [], array $files = [], array $server = [], string $content = null, bool $changeHistory = true): Crawler
  328.     {
  329.         if ($this->isMainRequest) {
  330.             $this->redirectCount = 0;
  331.         } else {
  332.             ++$this->redirectCount;
  333.         }
  335.         $originalUri = $uri;
  337.         $uri = $this->getAbsoluteUri($uri);
  339.         $server = array_merge($this->server, $server);
  341.         if (!empty($server['HTTP_HOST']) && null === parse_url($originalUri, \PHP_URL_HOST)) {
  342.             $uri = preg_replace('{^(https?\://)'.preg_quote($this->extractHost($uri)).'}', '${1}'.$server['HTTP_HOST'], $uri);
  343.         }
  345.         if (isset($server['HTTPS']) && null === parse_url($originalUri, \PHP_URL_SCHEME)) {
  346.             $uri = preg_replace('{^'.parse_url($uri, \PHP_URL_SCHEME).'}', $server['HTTPS'] ? 'https' : 'http', $uri);
  347.         }
  349.         if (!isset($server['HTTP_REFERER']) && !$this->history->isEmpty()) {
  350.             $server['HTTP_REFERER'] = $this->history->current()->getUri();
  351.         }
  353.         if (empty($server['HTTP_HOST'])) {
  354.             $server['HTTP_HOST'] = $this->extractHost($uri);
  355.         }
  357.         $server['HTTPS'] = 'https' === parse_url($uri, \PHP_URL_SCHEME);
  359.         $this->internalRequest = new Request($uri, $method, $parameters, $files, $this->cookieJar->allValues($uri), $server, $content);
  361.         $this->request = $this->filterRequest($this->internalRequest);
  363.         if (true === $changeHistory) {
  364.             $this->history->add($this->internalRequest);
  365.         }
  367.         if ($this->insulated) {
  368.             $this->response = $this->doRequestInProcess($this->request);
  369.         } else {
  370.             $this->response = $this->doRequest($this->request);
  371.         }
  373.         $this->internalResponse = $this->filterResponse($this->response);
  375.         $this->cookieJar->updateFromResponse($this->internalResponse, $uri);
  377.         $status = $this->internalResponse->getStatusCode();
  379.         if ($status >= 300 && $status < 400) {
  380.             $this->redirect = $this->internalResponse->getHeader('Location');
  381.         } else {
  382.             $this->redirect = null;
  383.         }
  385.         if ($this->followRedirects && $this->redirect) {
  386.             $this->redirects[serialize($this->history->current())] = true;
  388.             return $this->crawler = $this->followRedirect();
  389.         }
  391.         $this->crawler = $this->createCrawlerFromContent($this->internalRequest->getUri(), $this->internalResponse->getContent(), $this->internalResponse->getHeader('Content-Type') ?? '');
  393.         // Check for meta refresh redirect
  394.         if ($this->followMetaRefresh && null !== $redirect = $this->getMetaRefreshUrl()) {
  395.             $this->redirect = $redirect;
  396.             $this->redirects[serialize($this->history->current())] = true;
  397.             $this->crawler = $this->followRedirect();
  398.         }
  400.         return $this->crawler;
  401.     }
  403.     /**
  404.      * Makes a request in another process.
  405.      *
  406.      * @return object
  407.      *
  408.      * @throws \RuntimeException When processing returns exit code
  409.      */
  410.     protected function doRequestInProcess(object $request)
  411.     {
  412.         $deprecationsFile = tempnam(sys_get_temp_dir(), 'deprec');
  413.         putenv('SYMFONY_DEPRECATIONS_SERIALIZE='.$deprecationsFile);
  414.         $_ENV['SYMFONY_DEPRECATIONS_SERIALIZE'] = $deprecationsFile;
  415.         $process = new PhpProcess($this->getScript($request), null, null);
  416.         $process->run();
  418.         if (file_exists($deprecationsFile)) {
  419.             $deprecations = file_get_contents($deprecationsFile);
  420.             unlink($deprecationsFile);
  421.             foreach ($deprecations ? unserialize($deprecations) : [] as $deprecation) {
  422.                 if ($deprecation[0]) {
  423.                     // unsilenced on purpose
  424.                     trigger_error($deprecation[1], \E_USER_DEPRECATED);
  425.                 } else {
  426.                     @trigger_error($deprecation[1], \E_USER_DEPRECATED);
  427.                 }
  428.             }
  429.         }
  431.         if (!$process->isSuccessful() || !preg_match('/^O\:\d+\:/', $process->getOutput())) {
  432.             throw new \RuntimeException(sprintf('OUTPUT: %s ERROR OUTPUT: %s.', $process->getOutput(), $process->getErrorOutput()));
  433.         }
  435.         return unserialize($process->getOutput());
  436.     }
  438.     /**
  439.      * Makes a request.
  440.      *
  441.      * @return object
  442.      */
  443.     abstract protected function doRequest(object $request);
  445.     /**
  446.      * Returns the script to execute when the request must be insulated.
  447.      *
  448.      * @param object $request An origin request instance
  449.      *
  450.      * @throws \LogicException When this abstract class is not implemented
  451.      */
  452.     protected function getScript(object $request)
  453.     {
  454.         throw new \LogicException('To insulate requests, you need to override the getScript() method.');
  455.     }
  457.     /**
  458.      * Filters the BrowserKit request to the origin one.
  459.      *
  460.      * @return object
  461.      */
  462.     protected function filterRequest(Request $request)
  463.     {
  464.         return $request;
  465.     }
  467.     /**
  468.      * Filters the origin response to the BrowserKit one.
  469.      *
  470.      * @return Response
  471.      */
  472.     protected function filterResponse(object $response)
  473.     {
  474.         return $response;
  475.     }
  477.     /**
  478.      * Creates a crawler.
  479.      *
  480.      * This method returns null if the DomCrawler component is not available.
  481.      */
  482.     protected function createCrawlerFromContent(string $uri, string $content, string $type): ?Crawler
  483.     {
  484.         if (!class_exists(Crawler::class)) {
  485.             return null;
  486.         }
  488.         $crawler = new Crawler(null, $uri);
  489.         $crawler->addContent($content, $type);
  491.         return $crawler;
  492.     }
  494.     /**
  495.      * Goes back in the browser history.
  496.      */
  497.     public function back(): Crawler
  498.     {
  499.         do {
  500.             $request = $this->history->back();
  501.         } while (\array_key_exists(serialize($request), $this->redirects));
  503.         return $this->requestFromRequest($request, false);
  504.     }
  506.     /**
  507.      * Goes forward in the browser history.
  508.      */
  509.     public function forward(): Crawler
  510.     {
  511.         do {
  512.             $request = $this->history->forward();
  513.         } while (\array_key_exists(serialize($request), $this->redirects));
  515.         return $this->requestFromRequest($request, false);
  516.     }
  518.     /**
  519.      * Reloads the current browser.
  520.      */
  521.     public function reload(): Crawler
  522.     {
  523.         return $this->requestFromRequest($this->history->current(), false);
  524.     }
  526.     /**
  527.      * Follow redirects?
  528.      *
  529.      * @throws \LogicException If request was not a redirect
  530.      */
  531.     public function followRedirect(): Crawler
  532.     {
  533.         if (empty($this->redirect)) {
  534.             throw new \LogicException('The request was not redirected.');
  535.         }
  537.         if (-1 !== $this->maxRedirects) {
  538.             if ($this->redirectCount > $this->maxRedirects) {
  539.                 $this->redirectCount = 0;
  540.                 throw new \LogicException(sprintf('The maximum number (%d) of redirections was reached.', $this->maxRedirects));
  541.             }
  542.         }
  544.         $request = $this->internalRequest;
  546.         if (\in_array($this->internalResponse->getStatusCode(), [301, 302, 303])) {
  547.             $method = 'GET';
  548.             $files = [];
  549.             $content = null;
  550.         } else {
  551.             $method = $request->getMethod();
  552.             $files = $request->getFiles();
  553.             $content = $request->getContent();
  554.         }
  556.         if ('GET' === strtoupper($method)) {
  557.             // Don't forward parameters for GET request as it should reach the redirection URI
  558.             $parameters = [];
  559.         } else {
  560.             $parameters = $request->getParameters();
  561.         }
  563.         $server = $request->getServer();
  564.         $server = $this->updateServerFromUri($server, $this->redirect);
  566.         $this->isMainRequest = false;
  568.         $response = $this->request($method, $this->redirect, $parameters, $files, $server, $content);
  570.         $this->isMainRequest = true;
  572.         return $response;
  573.     }
  575.     /**
  576.      * @see https://dev.w3.org/html5/spec-preview/the-meta-element.html#attr-meta-http-equiv-refresh
  577.      */
  578.     private function getMetaRefreshUrl(): ?string
  579.     {
  580.         $metaRefresh = $this->getCrawler()->filter('head meta[http-equiv="refresh"]');
  581.         foreach ($metaRefresh->extract(['content']) as $content) {
  582.             if (preg_match('/^\s*0\s*;\s*URL\s*=\s*(?|\'([^\']++)|"([^"]++)|([^\'"].*))/i', $content, $m)) {
  583.                 return str_replace("\t\r\n", '', rtrim($m[1]));
  584.             }
  585.         }
  587.         return null;
  588.     }
  590.     /**
  591.      * Restarts the client.
  592.      *
  593.      * It flushes history and all cookies.
  594.      */
  595.     public function restart()
  596.     {
  597.         $this->cookieJar->clear();
  598.         $this->history->clear();
  599.     }
  601.     /**
  602.      * Takes a URI and converts it to absolute if it is not already absolute.
  603.      */
  604.     protected function getAbsoluteUri(string $uri): string
  605.     {
  606.         // already absolute?
  607.         if (str_starts_with($uri, 'http://') || str_starts_with($uri, 'https://')) {
  608.             return $uri;
  609.         }
  611.         if (!$this->history->isEmpty()) {
  612.             $currentUri = $this->history->current()->getUri();
  613.         } else {
  614.             $currentUri = sprintf('http%s://%s/',
  615.                 isset($this->server['HTTPS']) ? 's' : '',
  616.                 $this->server['HTTP_HOST'] ?? 'localhost'
  617.             );
  618.         }
  620.         // protocol relative URL
  621.         if ('' !== trim($uri, '/') && str_starts_with($uri, '//')) {
  622.             return parse_url($currentUri, \PHP_URL_SCHEME).':'.$uri;
  623.         }
  625.         // anchor or query string parameters?
  626.         if (!$uri || '#' === $uri[0] || '?' === $uri[0]) {
  627.             return preg_replace('/[#?].*?$/', '', $currentUri).$uri;
  628.         }
  630.         if ('/' !== $uri[0]) {
  631.             $path = parse_url($currentUri, \PHP_URL_PATH);
  633.             if (!str_ends_with($path, '/')) {
  634.                 $path = substr($path, 0, strrpos($path, '/') + 1);
  635.             }
  637.             $uri = $path.$uri;
  638.         }
  640.         return preg_replace('#^(.*?//[^/]+)\/.*$#', '$1', $currentUri).$uri;
  641.     }
  643.     /**
  644.      * Makes a request from a Request object directly.
  645.      *
  646.      * @param bool $changeHistory Whether to update the history or not (only used internally for back(), forward(), and reload())
  647.      */
  648.     protected function requestFromRequest(Request $request, bool $changeHistory = true): Crawler
  649.     {
  650.         return $this->request($request->getMethod(), $request->getUri(), $request->getParameters(), $request->getFiles(), $request->getServer(), $request->getContent(), $changeHistory);
  651.     }
  653.     private function updateServerFromUri(array $server, string $uri): array
  654.     {
  655.         $server['HTTP_HOST'] = $this->extractHost($uri);
  656.         $scheme = parse_url($uri, \PHP_URL_SCHEME);
  657.         $server['HTTPS'] = null === $scheme ? $server['HTTPS'] : 'https' === $scheme;
  658.         unset($server['HTTP_IF_NONE_MATCH'], $server['HTTP_IF_MODIFIED_SINCE']);
  660.         return $server;
  661.     }
  663.     private function extractHost(string $uri): ?string
  664.     {
  665.         $host = parse_url($uri, \PHP_URL_HOST);
  667.         if ($port = parse_url($uri, \PHP_URL_PORT)) {
  668.             return $host.':'.$port;
  669.         }
  671.         return $host;
  672.     }
  673. }