timeout interceptor to prevent hanging driver promises

itnelo · itnelo · commit 13cdf5e3e5b7 · 2020-12-01T14:13:23.000+03:00
diff --git a/README.md b/README.md
@@ -54,6 +54,7 @@ use React\EventLoop\Factory as LoopFactory;
 use React\Socket\Connector as SocketConnector;
 use React\Http\Browser;
 use Itnelo\React\WebDriver\Client\W3CClient;
+use Itnelo\React\WebDriver\Timeout\Interceptor as TimeoutInterceptor;
 use Itnelo\React\WebDriver\SeleniumHubDriver;
 
 $loop = LoopFactory::create();
@@ -82,14 +83,12 @@ $hubClient = new W3CClient(
     ]
 );
 
+$timeoutInterceptor = new TimeoutInterceptor($loop, 30);
+
 $webDriver = new SeleniumHubDriver(
     $loop,
     $hubClient,
-    [
-        'command' => [
-            'timeout' => 30,
-        ],
-    ]
+    $timeoutInterceptor
 );
 ```
 
diff --git a/src/ClientInterface.php b/src/ClientInterface.php
@@ -43,7 +43,7 @@ public function getSessionIdentifiers(): PromiseInterface;
      * Usage example:
      *
      * ```
-     * $sessionIdentifierPromise = $webdriver->createSession();
+     * $sessionIdentifierPromise = $webDriver->createSession();
      *
      * $sessionIdentifierPromise->then(
      *     function (string $sessionIdentifier) {
diff --git a/src/SeleniumHubDriver.php b/src/SeleniumHubDriver.php
@@ -15,15 +15,17 @@
 
 namespace Itnelo\React\WebDriver;
 
+use Itnelo\React\WebDriver\Timeout\Interceptor as TimeoutInterceptor;
 use React\EventLoop\LoopInterface;
 use React\Promise\PromiseInterface;
 use RuntimeException;
 use Symfony\Component\OptionsResolver\Exception\ExceptionInterface as ConfigurationExceptionInterface;
 use Symfony\Component\OptionsResolver\OptionsResolver;
-use Throwable;
 use function React\Promise\reject;
-use function React\Promise\Timer\timeout;
 
+/**
+ * Sends action requests to the Selenium Grid server (hub) and controls their async execution
+ */
 class SeleniumHubDriver implements WebDriverInterface
 {
     /**
@@ -40,6 +42,13 @@ class SeleniumHubDriver implements WebDriverInterface
      */
     private ClientInterface $hubClient;
 
+    /**
+     * Cancels a driver promise if it isn't resolved within the specified amount of time
+     *
+     * @var TimeoutInterceptor
+     */
+    private TimeoutInterceptor $timeoutInterceptor;
+
     /**
      * Array of options for the driver
      *
@@ -50,38 +59,26 @@ class SeleniumHubDriver implements WebDriverInterface
     /**
      * SeleniumHubDriver constructor.
      *
-     * @param LoopInterface   $loop      The event loop reference to manage promise timeouts and other async routines
-     * @param ClientInterface $hubClient Base client implementation for sending commands to the remote hub server
-     * @param array           $options   Array of options for the driver
+     * @param LoopInterface      $loop               The event loop reference to manage promise timeouts
+     * @param ClientInterface    $hubClient          Base client implementation for sending commands to the server
+     * @param TimeoutInterceptor $timeoutInterceptor Cancels a driver promise if it isn't resolved for too long
+     * @param array              $options            Array of options for the driver
      *
      * @throws ConfigurationExceptionInterface Whenever an error has been occurred during driver configuration
      */
-    public function __construct(LoopInterface $loop, ClientInterface $hubClient, array $options = [])
-    {
+    public function __construct(
+        LoopInterface $loop,
+        ClientInterface $hubClient,
+        TimeoutInterceptor $timeoutInterceptor,
+        array $options = []
+    ) {
         $optionsResolver = new OptionsResolver();
 
-        $optionsResolver
-            ->define('command')
-            ->info('Options to control behavior of the commands, which will be executed on the remote server')
-            ->default(
-                function (OptionsResolver $requestOptionsResolver) {
-                    $requestOptionsResolver
-                        ->define('timeout')
-                        ->info(
-                            'Maximum time to wait (in seconds) for command execution '
-                            . '(do not correlate with HTTP timeouts)'
-                        )
-                        ->allowedTypes('int')
-                        ->default(30)
-                    ;
-                }
-            )
-        ;
-
         $this->_options = $optionsResolver->resolve($options);
 
-        $this->loop      = $loop;
-        $this->hubClient = $hubClient;
+        $this->loop               = $loop;
+        $this->hubClient          = $hubClient;
+        $this->timeoutInterceptor = $timeoutInterceptor;
     }
 
     /**
@@ -111,20 +108,10 @@ public function createSession(): PromiseInterface
     {
         $sessionIdentifierPromise = $this->hubClient->createSession();
 
-        // applying command timeout.
-        $commandTimeoutInSeconds = $this->_options['command']['timeout'];
-
-        // global rejection handler for all internal side effects (timeout inclusive).
-        // todo: move to the separate service
-        $sessionIdentifierTimedPromise = timeout($sessionIdentifierPromise, $commandTimeoutInSeconds, $this->loop);
-
-        $sessionIdentifierTimedPromise = $sessionIdentifierTimedPromise->otherwise(
-            function (Throwable $rejectionReason) {
-                throw new RuntimeException('Unable to finish a session create command.', 0, $rejectionReason);
-            }
+        return $this->timeoutInterceptor->applyTimeout(
+            $sessionIdentifierPromise,
+            'Unable to complete a session create command.'
         );
-
-        return $sessionIdentifierTimedPromise;
     }
 
     /**
diff --git a/src/Timeout/Interceptor.php b/src/Timeout/Interceptor.php
@@ -0,0 +1,78 @@
+<?php
+
+/*
+ * This file is part of the ReactPHP WebDriver <https://github.com/itnelo/reactphp-webdriver>.
+ *
+ * (c) 2020 Pavel Petrov <itnelo@gmail.com>.
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @license https://opensource.org/licenses/mit MIT
+ */
+
+declare(strict_types=1);
+
+namespace Itnelo\React\WebDriver\Timeout;
+
+use React\EventLoop\LoopInterface;
+use React\Promise\PromiseInterface;
+use RuntimeException;
+use Throwable;
+use function React\Promise\Timer\timeout;
+
+/**
+ * Cancels a driver promise if it isn't resolved within the specified amount of time
+ */
+class Interceptor
+{
+    /**
+     * The event loop reference to track time
+     *
+     * @var LoopInterface
+     */
+    private LoopInterface $loop;
+
+    /**
+     * Time (in seconds) to wait until promise will be rejected
+     *
+     * @var float
+     */
+    private float $timeout;
+
+    /**
+     * Interceptor constructor.
+     *
+     * @param LoopInterface $loop    The event loop reference to track time
+     * @param float         $timeout Time (in seconds) to wait until promise will be rejected
+     */
+    public function __construct(LoopInterface $loop, float $timeout)
+    {
+        $this->loop    = $loop;
+        $this->timeout = $timeout;
+    }
+
+    /**
+     * Applies a timeout logic for the given promise
+     *
+     * @param PromiseInterface $promise          Promise to be timed out
+     * @param string           $rejectionMessage Message for rejection reason
+     *
+     * @return PromiseInterface<mixed>
+     */
+    public function applyTimeout(
+        PromiseInterface $promise,
+        string $rejectionMessage = 'Unable to complete a command.'
+    ): PromiseInterface {
+        $timedPromise = timeout($promise, $this->timeout, $this->loop);
+
+        $timedPromise = $timedPromise->then(
+            null,
+            function (Throwable $rejectionReason) use ($rejectionMessage) {
+                throw new RuntimeException($rejectionMessage, 0, $rejectionReason);
+            }
+        );
+
+        return $timedPromise;
+    }
+}
diff --git a/src/WebDriverFactory.php b/src/WebDriverFactory.php
@@ -16,6 +16,7 @@
 namespace Itnelo\React\WebDriver;
 
 use Itnelo\React\WebDriver\Client\W3CClient;
+use Itnelo\React\WebDriver\Timeout\Interceptor as TimeoutInterceptor;
 use React\EventLoop\LoopInterface;
 use React\Http\Browser;
 use React\Socket\Connector as SocketConnector;
@@ -101,7 +102,15 @@ function (OptionsResolver $hubOptionsResolver) {
             ->info('Options to control behavior of the commands, which will be executed on the remote server')
             ->default(
                 function (OptionsResolver $commandOptionsResolver) {
-                    $commandOptionsResolver->setDefined(['timeout']);
+                    $commandOptionsResolver
+                        ->define('timeout')
+                        ->info(
+                            'Maximum time to wait (in seconds) for command execution '
+                            . '(do not correlate with HTTP timeouts)'
+                        )
+                        ->allowedTypes('int')
+                        ->default(30)
+                    ;
                 }
             )
         ;
@@ -111,10 +120,11 @@ function (OptionsResolver $commandOptionsResolver) {
         $socketConnector = new SocketConnector($loop, $optionsResolved['browser']);
         $httpClient      = new Browser($loop, $socketConnector);
 
-        $hubClient = new W3CClient($httpClient, ['server' => $optionsResolved['hub']]);
+        $hubClient          = new W3CClient($httpClient, ['server' => $optionsResolved['hub']]);
+        $timeoutInterceptor = new TimeoutInterceptor($loop, $optionsResolved['command']['timeout']);
 
-        $webDriverOptions = array_replace_recursive([], ['command' => $optionsResolved['command']]);
-        $webDriver        = new SeleniumHubDriver($loop, $hubClient, $webDriverOptions);
+        $webDriverOptions = [];
+        $webDriver        = new SeleniumHubDriver($loop, $hubClient, $timeoutInterceptor, $webDriverOptions);
 
         return $webDriver;
     }
diff --git a/src/WebDriverInterface.php b/src/WebDriverInterface.php
@@ -31,26 +31,26 @@ interface WebDriverInterface extends ClientInterface
      * Usage example:
      *
      * ```
-     * $navigationPromise = $webdriver->openUri('https://github.com/itnelo');
+     * $navigationPromise = $webDriver->openUri('https://github.com/itnelo');
      *
      * $elementIdentifierPromise = $navigationPromise->then(
-     *     function () use ($webdriver) {
+     *     function () use ($webDriver) {
      *         // try-catch
-     *         $timeHasComePromise = $webdriver->wait(5.0);
+     *         $timeHasComePromise = $webDriver->wait(5.0);
      *
      *         return $timeHasComePromise->then(
-     *             function () use ($webdriver) {
-     *                 return $webdriver->getElementIdentifier('sessionIdentifier', 'xpathQuery');
+     *             function () use ($webDriver) {
+     *                 return $webDriver->getElementIdentifier('sessionIdentifier', 'xpathQuery');
      *             }
      *         );
      *     }
      *     // handle rejection reason (e.g. a connection timeout due to unexpected rate limiting)
      * );
      *
      * $elementClickPromise = $elementIdentifierPromise->then(
-     *     function (string $elementIdentifier) use ($webdriver) {
+     *     function (string $elementIdentifier) use ($webDriver) {
      *         // try-catch
-     *         return $webdriver->clickElement('sessionIdentifier', $elementIdentifier);
+     *         return $webDriver->clickElement('sessionIdentifier', $elementIdentifier);
      *     }
      *     // handle rejection reason (e.g. invalid xpath or element not found error)
      * );
@@ -78,27 +78,25 @@ public function wait(float $time): PromiseInterface;
      * Usage example:
      *
      * ```
-     * $becomeVisiblePromise = $webdriver->waitUntil(
+     * $becomeVisiblePromise = $webDriver->waitUntil(
      *     15.5,
-     *     function () use ($webdriver) {
-     *         $visibilityStatePromise = $webdriver->getElementVisibility(...);
+     *     function () use ($webDriver) {
+     *         $visibilityStatePromise = $webDriver->getElementVisibility(...);
      *
      *         return $visibilityStatePromise->then(
      *             function (bool $isVisible) {
      *                 if (!$isVisible) {
      *                     throw new RuntimeException("Not visible yet! Let's retry!");
      *                 }
-     *
-     *                 return true;
      *             }
      *         );
      *     }
      * );
      *
      * $becomeVisiblePromise->then(
-     *     function () use ($webdriver) {
+     *     function () use ($webDriver) {
      *         // try-catch
-     *         $webdriver->clickElement(...);    // sending a click command only if we are sure the target is visible.
+     *         $webDriver->clickElement(...);    // sending a click command only if we are sure the target is visible.
      *     }
      *     // handle case when the element is not visible on the page
      * );

Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@ public function getSessionIdentifiers(): PromiseInterface;`
`43`	`43`	`* Usage example:`
`44`	`44`	`*`
`45`	`45`	* ```
`46`		`- * $sessionIdentifierPromise = $webdriver->createSession();`
	`46`	`+ * $sessionIdentifierPromise = $webDriver->createSession();`
`47`	`47`	`*`
`48`	`48`	`* $sessionIdentifierPromise->then(`
`49`	`49`	`* function (string $sessionIdentifier) {`