[HttpClient] resolve promise chains on HttplugClient::wait()

nicolas-grekas · nicolas-grekas · commit 670aed4b0cd4 · 2019-10-11T22:52:51.000+02:00
diff --git a/src/Symfony/Component/HttpClient/HttplugClient.php b/src/Symfony/Component/HttpClient/HttplugClient.php
@@ -68,7 +68,7 @@ public function __construct(HttpClientInterface $client = null, ResponseFactoryI
         $this->client = $client ?? HttpClient::create();
         $this->responseFactory = $responseFactory;
         $this->streamFactory = $streamFactory ?? ($responseFactory instanceof StreamFactoryInterface ? $responseFactory : null);
-        $this->promisePool = new \SplObjectStorage();
+        $this->promisePool = \function_exists('GuzzleHttp\Promise\queue') ? new \SplObjectStorage() : null;
 
         if (null !== $this->responseFactory && null !== $this->streamFactory) {
             return;
@@ -102,7 +102,7 @@ public function sendRequest(RequestInterface $request): Psr7ResponseInterface
      */
     public function sendAsyncRequest(RequestInterface $request): Promise
     {
-        if (!class_exists(GuzzlePromise::class)) {
+        if (!$this->promisePool) {
             throw new \LogicException(sprintf('You cannot use "%s()" as the "guzzlehttp/promises" package is not installed. Try running "composer require guzzlehttp/promises".', __METHOD__));
         }
 
@@ -112,19 +112,17 @@ public function sendAsyncRequest(RequestInterface $request): Promise
             return new RejectedPromise($e);
         }
 
-        $cancel = function () use ($response) {
-            $response->cancel();
-            unset($this->promisePool[$response]);
-        };
-
         $promise = new GuzzlePromise(function () use ($response) {
             $this->pendingResponse = $response;
             $this->wait();
-        }, $cancel);
+        }, function () use ($response) {
+            $response->cancel();
+            unset($this->promisePool[$response]);
+        });
 
         $this->promisePool[$response] = [$request, $promise];
 
-        return new HttplugPromise($promise, $cancel);
+        return new HttplugPromise($promise);
     }
 
     /**
@@ -136,13 +134,19 @@ public function sendAsyncRequest(RequestInterface $request): Promise
      */
     public function wait(float $maxDuration = null, float $idleTimeout = null): int
     {
+        if (!$this->promisePool) {
+            return 0;
+        }
+
         $pendingResponse = $this->pendingResponse;
         $this->pendingResponse = null;
+        $guzzleQueue = \GuzzleHttp\Promise\queue();
 
-        if (null !== $maxDuration) {
+        if (0.0 === $remainingDuration = $maxDuration) {
+            $idleTimeout = 0.0;
+        } elseif (null !== $maxDuration) {
             $startTime = microtime(true);
             $idleTimeout = max(0.0, min($maxDuration / 5, $idleTimeout ?? $maxDuration));
-            $remainingDuration = $maxDuration;
         }
 
         do {
@@ -177,8 +181,10 @@ public function wait(float $maxDuration = null, float $idleTimeout = null): int
                     }
                 }
 
+                $guzzleQueue->run();
+
                 if ($pendingResponse === $response) {
-                    return \count($this->promisePool);
+                    return $this->promisePool->count();
                 }
 
                 check_duration:
@@ -188,7 +194,7 @@ public function wait(float $maxDuration = null, float $idleTimeout = null): int
                 }
             }
 
-            if (!$count = \count($this->promisePool)) {
+            if (!$count = $this->promisePool->count()) {
                 return 0;
             }
         } while (null !== $maxDuration && 0 < $remainingDuration);
diff --git a/src/Symfony/Component/HttpClient/Response/HttplugPromise.php b/src/Symfony/Component/HttpClient/Response/HttplugPromise.php
@@ -23,12 +23,10 @@
 final class HttplugPromise implements HttplugPromiseInterface
 {
     private $promise;
-    private $cancel;
 
-    public function __construct(GuzzlePromiseInterface $promise, callable $cancel = null)
+    public function __construct(GuzzlePromiseInterface $promise)
     {
         $this->promise = $promise;
-        $this->cancel = $cancel;
     }
 
     public function then(callable $onFulfilled = null, callable $onRejected = null): self
@@ -58,16 +56,4 @@ public function wait($unwrap = true)
     {
         return $this->promise->wait($unwrap);
     }
-
-    public function __destruct()
-    {
-        if ($this->cancel) {
-            ($this->cancel)();
-        }
-    }
-
-    public function __wakeup()
-    {
-        throw new \BadMethodCallException('Cannot unserialize '.__CLASS__);
-    }
 }
diff --git a/src/Symfony/Component/HttpClient/Tests/HttplugClientTest.php b/src/Symfony/Component/HttpClient/Tests/HttplugClientTest.php
@@ -75,6 +75,31 @@ public function testSendAsyncRequest()
         $this->assertSame('HTTP/1.1', $body['SERVER_PROTOCOL']);
     }
 
+    public function testWait()
+    {
+        $client = new HttplugClient(new NativeHttpClient());
+
+        $successCallableCalled = false;
+        $failureCallableCalled = false;
+        $client->sendAsyncRequest($client->createRequest('GET', 'http://localhost:8057/timeout-body'))
+            ->then(function (ResponseInterface $response) use (&$successCallableCalled) {
+                $successCallableCalled = true;
+
+                return $response;
+            }, function (\Exception $exception) use (&$failureCallableCalled) {
+                $failureCallableCalled = true;
+
+                throw $exception;
+            });
+
+        $client->wait(0);
+        $this->assertFalse($successCallableCalled, '$promise->then() should not be called yet.');
+
+        $client->wait();
+        $this->assertTrue($successCallableCalled, '$promise->then() should have been called.');
+        $this->assertFalse($failureCallableCalled, 'Failure callable should not be called when request is successful.');
+    }
+
     public function testPostRequest()
     {
         $client = new HttplugClient(new NativeHttpClient());

Original file line number	Diff line number	Diff line change
`@@ -23,12 +23,10 @@`
`23`	`23`	`final class HttplugPromise implements HttplugPromiseInterface`
`24`	`24`	`{`
`25`	`25`	`private $promise;`
`26`		`- private $cancel;`
`27`	`26`
`28`		`- public function __construct(GuzzlePromiseInterface $promise, callable $cancel = null)`
	`27`	`+ public function __construct(GuzzlePromiseInterface $promise)`
`29`	`28`	`{`
`30`	`29`	`$this->promise = $promise;`
`31`		`- $this->cancel = $cancel;`
`32`	`30`	`}`
`33`	`31`
`34`	`32`	`public function then(callable $onFulfilled = null, callable $onRejected = null): self`
`@@ -58,16 +56,4 @@ public function wait($unwrap = true)`
`58`	`56`	`{`
`59`	`57`	`return $this->promise->wait($unwrap);`
`60`	`58`	`}`
`61`		`-`
`62`		`- public function __destruct()`
`63`		`- {`
`64`		`- if ($this->cancel) {`
`65`		`- ($this->cancel)();`
`66`		`- }`
`67`		`- }`
`68`		`-`
`69`		`- public function __wakeup()`
`70`		`- {`
`71`		`- throw new \BadMethodCallException('Cannot unserialize '.__CLASS__);`
`72`		`- }`
`73`	`59`	`}`