Allow an empty EachPromise to be resolved by running the queue (#178)

* Allow an empty EachPromise to be resolved by running the queue. Fix #176

* Remove unused import

* fix typing doc comments

* Add whitespace to please php-cs-fixer

For #176

* more php-cs-fixer changes

Author: madelson

src/EachPromise.php

@@ -28,7 +28,7 @@ class EachPromise implements PromisorInterface
     /** @var callable|null */
     private $onRejected;
 
-    /** @var Promise|null */
+    /** @var PromiseInterface|null */
     private $aggregate;
 
     /** @var bool|null */
@@ -80,9 +80,9 @@ public function promise(): PromiseInterface
         }
 
         try {
+            $this->iterable->rewind();
             $this->createPromise();
             /** @psalm-assert Promise $this->aggregate */
-            $this->iterable->rewind();
             $this->refillPending();
         } catch (\Throwable $e) {
             $this->aggregate->reject($e);
@@ -96,6 +96,23 @@ public function promise(): PromiseInterface
 
     private function createPromise(): void
     {
+        // Clear the references when the promise is resolved.
+        $clearFn = function (): void {
+            $this->iterable = $this->concurrency = $this->pending = null;
+            $this->onFulfilled = $this->onRejected = null;
+            $this->nextPendingIndex = 0;
+        };
+
+        // In the case of empty, create a promise that will immediately become resolved via wait() or
+        // via Utils::queue()->run() (https://github.com/guzzle/promises/issues/176). We could simply
+        // create a fulfilled promise here, but that would be an observable behavioral change (see
+        // EachPromiseTest::testResolvesInCaseOfAnEmptyListAndInvokesFulfilled)
+        if (!$this->iterable->valid()) {
+            $this->aggregate = Create::promiseFor(null)->then($clearFn);
+
+            return;
+        }
+
         $this->mutex = false;
         $this->aggregate = new Promise(function (): void {
             if ($this->checkIfFinished()) {
@@ -113,13 +130,6 @@ private function createPromise(): void
             }
         });
 
-        // Clear the references when the promise is resolved.
-        $clearFn = function (): void {
-            $this->iterable = $this->concurrency = $this->pending = null;
-            $this->onFulfilled = $this->onRejected = null;
-            $this->nextPendingIndex = 0;
-        };
-
         $this->aggregate->then($clearFn, $clearFn);
     }
 

tests/EachPromiseTest.php

@@ -31,6 +31,17 @@ public function testResolvesInCaseOfAnEmptyList(): void
         $this->assertTrue(P\Is::fulfilled($p));
     }
 
+    // See https://github.com/guzzle/promises/issues/176
+    public function testResolvesWithQueueInCaseOfEmptyList(): void
+    {
+        $promises = [];
+        $each = new EachPromise($promises);
+        $p = $each->promise();
+        P\Utils::queue()->run();
+        $this->assertTrue(P\Is::fulfilled($p));
+        $this->assertNull($p->wait());
+    }
+
     public function testResolvesInCaseOfAnEmptyListAndInvokesFulfilled(): void
     {
         $promises = [];
@@ -430,4 +441,25 @@ public function testIsWaitableWhenLimited(): void
         $this->assertSame(['a', 'c', 'b', 'd'], $called);
         $this->assertTrue(P\Is::fulfilled($p));
     }
+
+    public function testRewindsExhaustedIterator(): void
+    {
+        $promises = P\Create::iterFor([
+            $this->createSelfResolvingPromise('a'),
+            $this->createSelfResolvingPromise('b'),
+        ]);
+        while ($promises->valid()) {
+            $promises->next();
+        }
+        $called = [];
+        $each = new EachPromise($promises, [
+            'fulfilled' => function ($value) use (&$called): void {
+                $called[] = $value;
+            },
+        ]);
+        $p = $each->promise();
+        $this->assertNull($p->wait());
+        $this->assertSame(['a', 'b'], $called);
+        $this->assertTrue(P\Is::fulfilled($p));
+    }
 }