vendor/symfony/panther/src/Client.php line 376

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Panther project.
  5.  *
  6.  * (c) Kévin Dunglas <dunglas@gmail.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. declare(strict_types=1);
  14. namespace Symfony\Component\Panther;
  16. use Facebook\WebDriver\Exception\NoSuchElementException;
  17. use Facebook\WebDriver\Exception\TimeoutException;
  18. use Facebook\WebDriver\JavaScriptExecutor;
  19. use Facebook\WebDriver\Remote\RemoteWebDriver;
  20. use Facebook\WebDriver\WebDriver;
  21. use Facebook\WebDriver\WebDriverBy;
  22. use Facebook\WebDriver\WebDriverCapabilities;
  23. use Facebook\WebDriver\WebDriverExpectedCondition;
  24. use Facebook\WebDriver\WebDriverHasInputDevices;
  25. use Symfony\Component\BrowserKit\AbstractBrowser;
  26. use Symfony\Component\BrowserKit\Request;
  27. use Symfony\Component\BrowserKit\Response;
  28. use Symfony\Component\DomCrawler\Form;
  29. use Symfony\Component\DomCrawler\Link;
  30. use Symfony\Component\Panther\Cookie\CookieJar;
  31. use Symfony\Component\Panther\DomCrawler\Crawler;
  32. use Symfony\Component\Panther\DomCrawler\Form as PantherForm;
  33. use Symfony\Component\Panther\DomCrawler\Link as PantherLink;
  34. use Symfony\Component\Panther\ProcessManager\BrowserManagerInterface;
  35. use Symfony\Component\Panther\ProcessManager\ChromeManager;
  36. use Symfony\Component\Panther\ProcessManager\FirefoxManager;
  37. use Symfony\Component\Panther\ProcessManager\SeleniumManager;
  38. use Symfony\Component\Panther\WebDriver\WebDriverMouse;
  40. /**
  41.  * @author Kévin Dunglas <dunglas@gmail.com>
  42.  * @author Dany Maillard <danymaillard93b@gmail.com>
  43.  *
  44.  * @method Crawler getCrawler()
  45.  */
  46. final class Client extends AbstractBrowser implements WebDriver, JavaScriptExecutor, WebDriverHasInputDevices
  47. {
  48.     use ExceptionThrower;
  50.     /**
  51.      * @var WebDriver|null
  52.      */
  53.     private $webDriver;
  54.     private $browserManager;
  55.     private $baseUri;
  56.     private $isFirefox = false;
  58.     /**
  59.      * @param string[]|null $arguments
  60.      */
  61.     public static function createChromeClient(?string $chromeDriverBinary = null, ?array $arguments = null, array $options = [], ?string $baseUri = null): self
  62.     {
  63.         return new self(new ChromeManager($chromeDriverBinary, $arguments, $options), $baseUri);
  64.     }
  66.     public static function createFirefoxClient(?string $geckodriverBinary = null, ?array $arguments = null, array $options = [], ?string $baseUri = null): self
  67.     {
  68.         return new self(new FirefoxManager($geckodriverBinary, $arguments, $options), $baseUri);
  69.     }
  71.     public static function createSeleniumClient(?string $host = null, ?WebDriverCapabilities $capabilities = null, ?string $baseUri = null, array $options = []): self
  72.     {
  73.         return new self(new SeleniumManager($host, $capabilities, $options), $baseUri);
  74.     }
  76.     public function __construct(BrowserManagerInterface $browserManager, ?string $baseUri = null)
  77.     {
  78.         $this->browserManager = $browserManager;
  79.         $this->baseUri = $baseUri;
  80.     }
  82.     public function getBrowserManager(): BrowserManagerInterface
  83.     {
  84.         return $this->browserManager;
  85.     }
  87.     public function __destruct()
  88.     {
  89.         $this->quit();
  90.     }
  92.     public function start()
  93.     {
  94.         if (null !== $this->webDriver) {
  95.             return;
  96.         }
  98.         $this->webDriver = $this->browserManager->start();
  99.         if ($this->browserManager instanceof FirefoxManager) {
  100.             $this->isFirefox = true;
  102.             return;
  103.         }
  105.         if ($this->browserManager instanceof ChromeManager) {
  106.             $this->isFirefox = false;
  108.             return;
  109.         }
  111.         if (method_exists($this->webDriver, 'getCapabilities')) {
  112.             $this->isFirefox = 'firefox' === $this->webDriver->getCapabilities()->getBrowserName();
  114.             return;
  115.         }
  117.         $this->isFirefox = false;
  118.     }
  120.     public function getRequest()
  121.     {
  122.         throw new \LogicException('HttpFoundation Request object is not available when using WebDriver.');
  123.     }
  125.     public function getResponse()
  126.     {
  127.         throw new \LogicException('HttpFoundation Response object is not available when using WebDriver.');
  128.     }
  130.     public function followRedirects($followRedirect = true): void
  131.     {
  132.         if (!$followRedirect) {
  133.             throw new \InvalidArgumentException('Redirects are always followed when using WebDriver.');
  134.         }
  135.     }
  137.     public function isFollowingRedirects(): bool
  138.     {
  139.         return true;
  140.     }
  142.     public function setMaxRedirects($maxRedirects): void
  143.     {
  144.         if (-1 !== $maxRedirects) {
  145.             throw new \InvalidArgumentException('There are no max redirects when using WebDriver.');
  146.         }
  147.     }
  149.     public function getMaxRedirects(): int
  150.     {
  151.         return -1;
  152.     }
  154.     public function insulate($insulated = true): void
  155.     {
  156.         if (!$insulated) {
  157.             throw new \InvalidArgumentException('Requests are always insulated when using WebDriver.');
  158.         }
  159.     }
  161.     public function setServerParameters(array $server): void
  162.     {
  163.         throw new \InvalidArgumentException('Server parameters cannot be set when using WebDriver.');
  164.     }
  166.     public function setServerParameter($key, $value): void
  167.     {
  168.         throw new \InvalidArgumentException('Server parameters cannot be set when using WebDriver.');
  169.     }
  171.     public function getServerParameter($key, $default = '')
  172.     {
  173.         throw new \InvalidArgumentException('Server parameters cannot be retrieved when using WebDriver.');
  174.     }
  176.     public function getHistory()
  177.     {
  178.         throw new \LogicException('History is not available when using WebDriver.');
  179.     }
  181.     public function click(Link $link)
  182.     {
  183.         if ($link instanceof PantherLink) {
  184.             $link->getElement()->click();
  186.             return $this->crawler = $this->createCrawler();
  187.         }
  189.         return parent::click($link);
  190.     }
  192.     public function submit(Form $form, array $values = [], array $serverParameters = [])
  193.     {
  194.         if ($form instanceof PantherForm) {
  195.             foreach ($values as $field => $value) {
  196.                 $form->get($field)->setValue($value);
  197.             }
  199.             $button = $form->getButton();
  201.             if ($this->isFirefox) {
  202.                 // For Firefox, we have to wait for the page to reload
  203.                 // https://github.com/SeleniumHQ/selenium/issues/4570#issuecomment-327473270
  204.                 $selector = WebDriverBy::cssSelector('html');
  205.                 $previousId = $this->webDriver->findElement($selector)->getID();
  207.                 null === $button ? $form->getElement()->submit() : $button->click();
  209.                 try {
  210.                     $this->webDriver->wait(5)->until(static function (WebDriver $driver) use ($previousId, $selector) {
  211.                         try {
  212.                             return $previousId !== $driver->findElement($selector)->getID();
  213.                         } catch (NoSuchElementException $e) {
  214.                             // The html element isn't already available
  215.                             return false;
  216.                         }
  217.                     });
  218.                 } catch (TimeoutException $e) {
  219.                     // Probably a form using AJAX, do nothing
  220.                 }
  221.             } else {
  222.                 null === $button ? $form->getElement()->submit() : $button->click();
  223.             }
  225.             return $this->crawler = $this->createCrawler();
  226.         }
  228.         return parent::submit($form, $values, $serverParameters);
  229.     }
  231.     public function refreshCrawler(): Crawler
  232.     {
  233.         return $this->crawler = $this->createCrawler();
  234.     }
  236.     public function request(string $method, string $uri, array $parameters = [], array $files = [], array $server = [], string $content = null, bool $changeHistory = true): Crawler
  237.     {
  238.         if ('GET' !== $method) {
  239.             throw new \InvalidArgumentException('Only the GET method is supported when using WebDriver.');
  240.         }
  241.         if (null !== $content) {
  242.             throw new \InvalidArgumentException('Setting a content is not supported when using WebDriver.');
  243.         }
  244.         if (!$changeHistory) {
  245.             throw new \InvalidArgumentException('The history always change when using WebDriver.');
  246.         }
  248.         foreach (['parameters', 'files', 'server'] as $arg) {
  249.             if ([] !== $$arg) {
  250.                 throw new \InvalidArgumentException(\sprintf('The parameter "$%s" is not supported when using WebDriver.', $arg));
  251.             }
  252.         }
  254.         $this->get($uri);
  256.         return $this->crawler;
  257.     }
  259.     protected function createCrawler(): Crawler
  260.     {
  261.         $this->start();
  262.         $elements = $this->webDriver->findElements(WebDriverBy::cssSelector('html'));
  264.         return new Crawler($elements, $this->webDriver, $this->webDriver->getCurrentURL());
  265.     }
  267.     protected function doRequest($request)
  268.     {
  269.         throw new \LogicException('Not useful in WebDriver mode.');
  270.     }
  272.     public function back()
  273.     {
  274.         $this->start();
  275.         $this->webDriver->navigate()->back();
  277.         return $this->crawler = $this->createCrawler();
  278.     }
  280.     public function forward()
  281.     {
  282.         $this->start();
  283.         $this->webDriver->navigate()->forward();
  285.         return $this->crawler = $this->createCrawler();
  286.     }
  288.     public function reload()
  289.     {
  290.         $this->start();
  291.         $this->webDriver->navigate()->refresh();
  293.         return $this->crawler = $this->createCrawler();
  294.     }
  296.     public function followRedirect()
  297.     {
  298.         throw new \LogicException('Redirects are always followed when using WebDriver.');
  299.     }
  301.     public function restart()
  302.     {
  303.         if (null !== $this->webDriver) {
  304.             $this->webDriver->manage()->deleteAllCookies();
  305.         }
  307.         $this->quit(false);
  308.         $this->start();
  309.     }
  311.     public function getCookieJar()
  312.     {
  313.         $this->start();
  315.         return new CookieJar($this->webDriver);
  316.     }
  318.     /**
  319.      * @param string $locator The path to an element to be waited for. Can be a CSS selector or Xpath expression.
  320.      *
  321.      * @throws NoSuchElementException
  322.      * @throws TimeoutException
  323.      *
  324.      * @return Crawler
  325.      */
  326.     public function waitFor(string $locator, int $timeoutInSecond = 30, int $intervalInMillisecond = 250)
  327.     {
  328.         $by = $this->createWebDriverByFromLocator($locator);
  330.         $this->wait($timeoutInSecond, $intervalInMillisecond)->until(
  331.             WebDriverExpectedCondition::presenceOfElementLocated($by)
  332.         );
  334.         return $this->crawler = $this->createCrawler();
  335.     }
  337.     /**
  338.      * @param string $locator The path to an element to be waited for. Can be a CSS selector or Xpath expression.
  339.      *
  340.      * @throws NoSuchElementException
  341.      * @throws TimeoutException
  342.      *
  343.      * @return Crawler
  344.      */
  345.     public function waitForVisibility(string $locator, int $timeoutInSecond = 30, int $intervalInMillisecond = 250)
  346.     {
  347.         $by = $this->createWebDriverByFromLocator($locator);
  349.         $this->wait($timeoutInSecond, $intervalInMillisecond)->until(
  350.             WebDriverExpectedCondition::visibilityOfElementLocated($by)
  351.         );
  353.         return $this->crawler = $this->createCrawler();
  354.     }
  356.     public function getWebDriver(): WebDriver
  357.     {
  358.         $this->start();
  360.         return $this->webDriver;
  361.     }
  363.     public function get($uri)
  364.     {
  365.         $this->start();
  367.         // Prepend the base URI to URIs without a host
  368.         if (null !== $this->baseUri && (false !== $components = \parse_url($uri)) && !isset($components['host'])) {
  369.             $uri = $this->baseUri.$uri;
  370.         }
  372.         $this->internalRequest = new Request($uri, 'GET');
  373.         $this->webDriver->get($uri);
  374.         $this->internalResponse = new Response($this->webDriver->getPageSource());
  376.         $this->crawler = $this->createCrawler();
  378.         return $this;
  379.     }
  381.     public function close()
  382.     {
  383.         $this->start();
  385.         return $this->webDriver->close();
  386.     }
  388.     public function getCurrentURL()
  389.     {
  390.         $this->start();
  392.         return $this->webDriver->getCurrentURL();
  393.     }
  395.     public function getPageSource()
  396.     {
  397.         $this->start();
  399.         return $this->webDriver->getPageSource();
  400.     }
  402.     public function getTitle()
  403.     {
  404.         $this->start();
  406.         return $this->webDriver->getTitle();
  407.     }
  409.     public function getWindowHandle()
  410.     {
  411.         $this->start();
  413.         return $this->webDriver->getWindowHandle();
  414.     }
  416.     public function getWindowHandles()
  417.     {
  418.         $this->start();
  420.         return $this->webDriver->getWindowHandles();
  421.     }
  423.     public function quit(bool $quitBrowserManager = true)
  424.     {
  425.         if (null !== $this->webDriver) {
  426.             $this->webDriver->quit();
  427.             $this->webDriver = null;
  428.         }
  430.         if ($quitBrowserManager) {
  431.             $this->browserManager->quit();
  432.         }
  433.     }
  435.     public function takeScreenshot($saveAs = null)
  436.     {
  437.         $this->start();
  439.         return $this->webDriver->takeScreenshot($saveAs);
  440.     }
  442.     public function wait($timeoutInSecond = 30, $intervalInMillisecond = 250)
  443.     {
  444.         $this->start();
  446.         return $this->webDriver->wait($timeoutInSecond, $intervalInMillisecond);
  447.     }
  449.     public function manage()
  450.     {
  451.         $this->start();
  453.         return $this->webDriver->manage();
  454.     }
  456.     public function navigate()
  457.     {
  458.         $this->start();
  460.         return $this->webDriver->navigate();
  461.     }
  463.     public function switchTo()
  464.     {
  465.         $this->start();
  467.         return $this->webDriver->switchTo();
  468.     }
  470.     public function execute($name, $params)
  471.     {
  472.         $this->start();
  474.         return $this->webDriver->execute($name, $params);
  475.     }
  477.     public function findElement(WebDriverBy $locator)
  478.     {
  479.         $this->start();
  481.         return $this->webDriver->findElement($locator);
  482.     }
  484.     public function findElements(WebDriverBy $locator)
  485.     {
  486.         $this->start();
  488.         return $this->webDriver->findElements($locator);
  489.     }
  491.     public function executeScript($script, array $arguments = [])
  492.     {
  493.         if (!$this->webDriver instanceof JavaScriptExecutor) {
  494.             throw $this->createException(JavaScriptExecutor::class);
  495.         }
  497.         return $this->webDriver->executeScript($script, $arguments);
  498.     }
  500.     public function executeAsyncScript($script, array $arguments = [])
  501.     {
  502.         if (!$this->webDriver instanceof JavaScriptExecutor) {
  503.             throw $this->createException(JavaScriptExecutor::class);
  504.         }
  506.         return $this->webDriver->executeAsyncScript($script, $arguments);
  507.     }
  509.     public function getKeyboard()
  510.     {
  511.         if (!$this->webDriver instanceof WebDriverHasInputDevices) {
  512.             throw $this->createException(WebDriverHasInputDevices::class);
  513.         }
  515.         return $this->webDriver->getKeyboard();
  516.     }
  518.     public function getMouse(): WebDriverMouse
  519.     {
  520.         if (!$this->webDriver instanceof WebDriverHasInputDevices) {
  521.             throw $this->createException(WebDriverHasInputDevices::class);
  522.         }
  524.         return new WebDriverMouse($this->webDriver->getMouse(), $this);
  525.     }
  527.     private function createWebDriverByFromLocator(string $locator): WebDriverBy
  528.     {
  529.         $locator = trim($locator);
  531.         return '' === $locator || '/' !== $locator[0]
  532.             ? WebDriverBy::cssSelector($locator)
  533.             : WebDriverBy::xpath($locator);
  534.     }
  536.     /**
  537.      * Checks the web driver connection (and logs "pong" into the DevTools console).
  538.      *
  539.      * @param int $timeout sets the connection/request timeout in ms
  540.      *
  541.      * @return bool true if connected, false otherwise
  542.      */
  543.     public function ping(int $timeout = 1000): bool
  544.     {
  545.         if (null === $this->webDriver) {
  546.             return false;
  547.         }
  549.         if ($this->webDriver instanceof RemoteWebDriver) {
  550.             $this
  551.                 ->webDriver
  552.                 ->getCommandExecutor()
  553.                 ->setConnectionTimeout($timeout)
  554.                 ->setRequestTimeout($timeout);
  555.         }
  557.         try {
  558.             if ($this->webDriver instanceof JavaScriptExecutor) {
  559.                 $this->webDriver->executeScript('console.log("pong");');
  560.             } else {
  561.                 $this->webDriver->findElement(WebDriverBy::tagName('html'));
  562.             }
  563.         } catch (\Exception $e) {
  564.             return false;
  565.         } finally {
  566.             if ($this->webDriver instanceof RemoteWebDriver) {
  567.                 $this
  568.                     ->webDriver
  569.                     ->getCommandExecutor()
  570.                     ->setConnectionTimeout(0)
  571.                     ->setRequestTimeout(0);
  572.             }
  573.         }
  575.         return true;
  576.     }
  578.     /**
  579.      * @return \LogicException|\RuntimeException
  580.      */
  581.     private function createException(string $implementableClass): \Exception
  582.     {
  583.         if (null === $this->webDriver) {
  584.             return new \LogicException(sprintf('WebDriver not started yet. Call method `start()` first before calling any `%s` method.', $implementableClass));
  585.         }
  587.         return new \RuntimeException(sprintf('"%s" does not implement "%s".', \get_class($this->webDriver), $implementableClass));
  588.     }
  589. }