getScreenshot method implementation (W3C client), with a saveScreenshot sugar (webdriver scope)

itnelo · itnelo · commit 08662cfaf596 · 2020-12-10T01:36:26.000+03:00
diff --git a/composer.json b/composer.json
@@ -26,6 +26,7 @@
         "react/http": "^1.1",
         "react/promise": "^2.8",
         "react/promise-timer": "^1.6",
+        "react/stream": "^1.1",
         "symfony/options-resolver": "^5.1"
     },
     "require-dev": {
diff --git a/src/Client/W3CClient.php b/src/Client/W3CClient.php
@@ -212,15 +212,8 @@ public function getTabIdentifiers(string $sessionIdentifier): PromiseInterface
         $responsePromise->then(
             function (ResponseInterface $response) use ($tabLookupDeferred) {
                 try {
-                    $responseBody     = (string) $response->getBody();
-                    $bodyDeserialized = json_decode($responseBody, true);
+                    $tabIdentifiers = $this->deserializeResponse($response);
 
-                    if (!array_key_exists('value', $bodyDeserialized) || !is_array($bodyDeserialized['value'])) {
-                        // todo: locate an error message or set it as "undefined error"
-                        throw new RuntimeException('Unable to locate tab identifiers in the response.');
-                    }
-
-                    $tabIdentifiers = $bodyDeserialized['value'];
                     $tabLookupDeferred->resolve($tabIdentifiers);
                 } catch (Throwable $exception) {
                     $reason = new RuntimeException(
@@ -295,7 +288,7 @@ function (ResponseInterface $response) {
             ->then(
                 null,
                 function (Throwable $rejectionReason) {
-                    throw new RuntimeException('Unable to open an URI (request).', 0, $rejectionReason);
+                    throw new RuntimeException('Unable to open an URI.', 0, $rejectionReason);
                 }
             )
         ;
@@ -366,7 +359,7 @@ function (ResponseInterface $response) {
             ->then(
                 null,
                 function (Throwable $rejectionReason) {
-                    throw new RuntimeException('Unable to get an element identifier (request).', 0, $rejectionReason);
+                    throw new RuntimeException('Unable to get an element identifier.', 0, $rejectionReason);
                 }
             )
         ;
@@ -456,7 +449,7 @@ function (ResponseInterface $response) {
             ->then(
                 null,
                 function (Throwable $rejectionReason) {
-                    throw new RuntimeException('Unable to confirm mouse move action (request).', 0, $rejectionReason);
+                    throw new RuntimeException('Unable to confirm mouse move action.', 0, $rejectionReason);
                 }
             )
         ;
@@ -493,7 +486,7 @@ function (ResponseInterface $response) {
             ->then(
                 null,
                 function (Throwable $rejectionReason) {
-                    throw new RuntimeException('Unable to confirm mouse click action (request).', 0, $rejectionReason);
+                    throw new RuntimeException('Unable to confirm mouse click action.', 0, $rejectionReason);
                 }
             )
         ;
@@ -506,9 +499,37 @@ function (Throwable $rejectionReason) {
      */
     public function getScreenshot(string $sessionIdentifier): PromiseInterface
     {
-        // TODO: Implement getScreenshot() method.
+        $requestUri = sprintf(
+            'http://%s:%d/wd/hub/session/%s/screenshot',
+            $this->_options['server']['host'],
+            $this->_options['server']['port'],
+            $sessionIdentifier
+        );
 
-        return reject(new RuntimeException('Not implemented.'));
+        $requestHeaders = [
+            'Content-Type' => 'application/json; charset=UTF-8',
+        ];
+
+        $responsePromise = $this->httpClient->get($requestUri, $requestHeaders);
+
+        $imageContentsPromise = $responsePromise
+            ->then(
+                function (ResponseInterface $response) {
+                    $imageContentsEncoded = $this->deserializeResponse($response);
+                    $imageContents        = base64_decode($imageContentsEncoded);
+
+                    return $imageContents;
+                }
+            )
+            ->then(
+                null,
+                function (Throwable $rejectionReason) {
+                    throw new RuntimeException('Unable to get a screenshot.', 0, $rejectionReason);
+                }
+            )
+        ;
+
+        return $imageContentsPromise;
     }
 
     /**
@@ -556,23 +577,43 @@ private function requestMouseActions(string $sessionIdentifier, array $mouseActi
     /**
      * Ensures that a related action is properly executed (confirmed) by the remote server, triggers an error otherwise.
      *
-     * Is used when no specific context to check is required (some methods will use more advanced confirmation checks
-     * instead this "default").
+     * It is used when no specific context is required to confirm successful command execution (some methods will use
+     * more advanced confirmation checks instead of this "default").
      *
      * @param ResponseInterface $response     PSR-7 response message from the Selenium hub with action results
      * @param string            $errorMessage Will be used if an error is registered during confirmation check
      *
      * @return void
      *
-     * @throws RuntimeException Whenever an error has occurred during confirmation check for a remote action
+     * @throws RuntimeException Whenever an error has been occurred during confirmation check for a remote action
      */
     private function onCommandConfirmation(ResponseInterface $response, string $errorMessage): void
     {
-        $responseBody = (string) $response->getBody();
+        $responseValueNode = $this->deserializeResponse($response);
 
         // todo: locate an error message or set it as "undefined error"
-        if ('{"value":null}' !== $responseBody) {
+        if (null !== $responseValueNode) {
             throw new RuntimeException($errorMessage);
         }
     }
+
+    /**
+     * Returns a "value" node contents, which will be extracted from the PSR-7 response message
+     *
+     * @param ResponseInterface $response PSR-7 response message from the Selenium hub with action results
+     *
+     * @return mixed
+     */
+    private function deserializeResponse(ResponseInterface $response)
+    {
+        $responseBody     = (string) $response->getBody();
+        $bodyDeserialized = json_decode($responseBody, true);
+
+        if (!array_key_exists('value', $bodyDeserialized)) {
+            // todo: locate an error message or set it as "undefined error"
+            throw new RuntimeException('Unable to locate "value" node (response deserialization).');
+        }
+
+        return $bodyDeserialized['value'];
+    }
 }
diff --git a/src/ClientInterface.php b/src/ClientInterface.php
@@ -110,7 +110,7 @@ public function setActiveTab(string $sessionIdentifier, string $tabIdentifier):
 
     /**
      * Returns a promise that will be resolved when the remote WebDriver service confirms URI navigation within
-     * currently active (focused) tab ({@link getActiveTabIdentifier()})
+     * currently active (focused) tab ({@link getActiveTabIdentifier()}).
      *
      * @param string $sessionIdentifier Session identifier for Selenium Grid server (hub)
      * @param string $uri               Website URL or any other resource identifier, to open in the active (focused)
@@ -193,8 +193,10 @@ public function getElementVisibility(string $sessionIdentifier, array $elementId
      * Returns a promise that will be resolved when the remote WebDriver service confirms element click operation
      * against active browser tab.
      *
-     * Note: if target element is a link, it may trigger an implicit tab(s) creation. In such case you need to take into
-     * consideration potentially new list of window handles for the current session (see {@link getTabIdentifiers()}).
+     * Note: if target element is a link, it may trigger an implicit tab(s) creation. In such case you need to take
+     * into consideration potentially new list of window handles for the current session (see {@link
+     * getTabIdentifiers()}). The remote webdriver service WILL NOT automatically perform tab switch operation if
+     * a command implicitly triggers new tab.
      *
      * @param string $sessionIdentifier Session identifier for Selenium Grid server (hub)
      * @param array  $elementIdentifier An internal WebDriver handle that refers to the element on the page
diff --git a/src/SeleniumHubDriver.php b/src/SeleniumHubDriver.php
@@ -17,10 +17,13 @@
 
 use Itnelo\React\WebDriver\Timeout\Interceptor as TimeoutInterceptor;
 use React\EventLoop\LoopInterface;
+use React\Promise\Deferred;
 use React\Promise\PromiseInterface;
+use React\Stream\WritableResourceStream;
 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\resolve;
 
@@ -82,26 +85,6 @@ public function __construct(
         $this->timeoutInterceptor = $timeoutInterceptor;
     }
 
-    /**
-     * {@inheritDoc}
-     */
-    public function wait(float $time): PromiseInterface
-    {
-        $idlePromise = resolve($time, $this->loop);
-
-        return $idlePromise;
-    }
-
-    /**
-     * {@inheritDoc}
-     */
-    public function waitUntil(float $time, callable $conditionMetCallback): PromiseInterface
-    {
-        // TODO: Implement waitUntil() method.
-
-        return reject(new RuntimeException('Not implemented.'));
-    }
-
     /**
      * {@inheritDoc}
      */
@@ -294,10 +277,89 @@ public function mouseLeftClick(string $sessionIdentifier): PromiseInterface
     /**
      * {@inheritDoc}
      */
-    public function getScreenshot(string $sessionIdentifier): PromiseInterface
+    public function wait(float $time): PromiseInterface
+    {
+        $idlePromise = resolve($time, $this->loop);
+
+        return $idlePromise;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function waitUntil(float $time, callable $conditionMetCallback): PromiseInterface
     {
-        // TODO: Implement getScreenshot() method.
+        // TODO: Implement waitUntil() method.
 
         return reject(new RuntimeException('Not implemented.'));
     }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getScreenshot(string $sessionIdentifier): PromiseInterface
+    {
+        $screenshotPromise = $this->hubClient->getScreenshot($sessionIdentifier);
+
+        return $this->timeoutInterceptor->applyTimeout(
+            $screenshotPromise,
+            'Unable to complete a get screenshot command.'
+        );
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function saveScreenshot(string $sessionIdentifier, string $filePath): PromiseInterface
+    {
+        $savingDeferred = new Deferred();
+
+        $screenshotPromise = $this->hubClient->getScreenshot($sessionIdentifier);
+
+        $screenshotPromise
+            ->then(
+                function (string $imageContents) use ($savingDeferred, $filePath) {
+                    $fileResource = fopen($filePath, 'w');
+                    $writeStream  = new WritableResourceStream($fileResource, $this->loop);
+
+                    $writeStream->end($imageContents);
+
+                    $writeStream->on(
+                        'drain',
+                        function () use ($savingDeferred, $writeStream) {
+                            // explicitly removing all listeners, because we don't have a contract with guarantees that
+                            // this handler will be triggered once, see https://github.com/reactphp/stream#drain-event.
+                            $writeStream->removeAllListeners('drain');
+
+                            $savingDeferred->resolve(null);
+                        }
+                    );
+
+                    $writeStream->on(
+                        'error',
+                        function (Throwable $exception) use ($savingDeferred) {
+                            $reason = new RuntimeException('Unable to save a screenshot (stream).', 0, $exception);
+
+                            $savingDeferred->reject($reason);
+                        }
+                    );
+                }
+            )
+            ->then(
+                null,
+                function (Throwable $rejectionReason) use ($savingDeferred) {
+                    $reason = new RuntimeException('Unable to save a screenshot.', 0, $rejectionReason);
+
+                    $savingDeferred->reject($reason);
+                }
+            )
+        ;
+
+        $saveConfirmationPromise = $savingDeferred->promise();
+
+        return $this->timeoutInterceptor->applyTimeout(
+            $saveConfirmationPromise,
+            'Unable to complete a save screenshot command.'
+        );
+    }
 }
diff --git a/src/WebDriverInterface.php b/src/WebDriverInterface.php
@@ -109,4 +109,15 @@ public function wait(float $time): PromiseInterface;
      * @return PromiseInterface<null>
      */
     public function waitUntil(float $time, callable $conditionMetCallback): PromiseInterface;
+
+    /**
+     * Returns a promise that will be resolved if a screenshot is successfully received and saved using the specified
+     * {filePath}, rejection reason with error message will be provided otherwise.
+     *
+     * @param string $sessionIdentifier Session identifier for Selenium Grid server (hub)
+     * @param string $filePath          Path where a screenshot image will be saved
+     *
+     * @return PromiseInterface<null>
+     */
+    public function saveScreenshot(string $sessionIdentifier, string $filePath): PromiseInterface;
 }
