Implement Interop\Async\Promise

composer.json

@@ -6,7 +6,8 @@
         {"name": "Jan Sorgalla", "email": "jsorgalla@gmail.com"}
     ],
     "require": {
-        "php": ">=5.4.0"
+        "php": ">=5.4.0",
+        "async-interop/promise": "^0.2.0"
     },
     "autoload": {
         "psr-4": {

src/FulfilledPromise.php

@@ -2,13 +2,15 @@
 
 namespace React\Promise;
 
-class FulfilledPromise implements ExtendedPromiseInterface, CancellablePromiseInterface
+use Interop\Async\Promise as AsyncInteropPromise;
+
+class FulfilledPromise implements ExtendedPromiseInterface, CancellablePromiseInterface, AsyncInteropPromise
 {
     private $value;
 
     public function __construct($value = null)
     {
-        if ($value instanceof PromiseInterface) {
+        if ($value instanceof PromiseInterface || $value instanceof AsyncInteropPromise) {
             throw new \InvalidArgumentException('You cannot create React\Promise\FulfilledPromise with a promise. Use React\Promise\resolve($promiseOrValue) instead.');
         }
 
@@ -65,4 +67,9 @@ public function progress(callable $onProgress)
     public function cancel()
     {
     }
+
+    public function when(callable $onResolved)
+    {
+        $onResolved(null, $this->value);
+    }
 }

src/LazyPromise.php

@@ -2,7 +2,9 @@
 
 namespace React\Promise;
 
-class LazyPromise implements ExtendedPromiseInterface, CancellablePromiseInterface
+use Interop\Async\Promise as AsyncInteropPromise;
+
+class LazyPromise implements ExtendedPromiseInterface, CancellablePromiseInterface, AsyncInteropPromise
 {
     private $factory;
     private $promise;
@@ -42,6 +44,11 @@ public function cancel()
         return $this->promise()->cancel();
     }
 
+    public function when(callable $onResolved)
+    {
+        return $this->promise()->when($onResolved);
+    }
+
     /**
      * @internal
      * @see Promise::settle()

src/Promise.php

@@ -2,7 +2,9 @@
 
 namespace React\Promise;
 
-class Promise implements ExtendedPromiseInterface, CancellablePromiseInterface
+use Interop\Async\Promise as AsyncInteropPromise;
+
+class Promise implements ExtendedPromiseInterface, CancellablePromiseInterface, AsyncInteropPromise
 {
     private $canceller;
     private $result;
@@ -97,6 +99,18 @@ public function cancel()
         $this->call($canceller);
     }
 
+    public function when(callable $onResolved)
+    {
+        $this->done(function ($value) use ($onResolved) {
+            $onResolved(null, $value);
+        }, function ($reason) use ($onResolved) {
+            $onResolved(
+                UnhandledRejectionException::resolve($reason),
+                null
+            );
+        });
+    }
+
     private function resolver(callable $onFulfilled = null, callable $onRejected = null, callable $onProgress = null)
     {
         return function ($resolve, $reject, $notify) use ($onFulfilled, $onRejected, $onProgress) {

src/RejectedPromise.php

@@ -2,13 +2,15 @@
 
 namespace React\Promise;
 
-class RejectedPromise implements ExtendedPromiseInterface, CancellablePromiseInterface
+use Interop\Async\Promise as AsyncInteropPromise;
+
+class RejectedPromise implements ExtendedPromiseInterface, CancellablePromiseInterface, AsyncInteropPromise
 {
     private $reason;
 
     public function __construct($reason = null)
     {
-        if ($reason instanceof PromiseInterface) {
+        if ($reason instanceof PromiseInterface || $reason instanceof AsyncInteropPromise) {
             throw new \InvalidArgumentException('You cannot create React\Promise\RejectedPromise with a promise. Use React\Promise\reject($promiseOrValue) instead.');
         }
 
@@ -73,4 +75,12 @@ public function progress(callable $onProgress)
     public function cancel()
     {
     }
+
+    public function when(callable $onResolved)
+    {
+        $onResolved(
+            UnhandledRejectionException::resolve($this->reason),
+            null
+        );
+    }
 }

src/functions.php

@@ -2,12 +2,27 @@
 
 namespace React\Promise;
 
+use Interop\Async\Promise as AsyncInteropPromise;
+
 function resolve($promiseOrValue = null)
 {
     if ($promiseOrValue instanceof ExtendedPromiseInterface) {
         return $promiseOrValue;
     }
 
+    if ($promiseOrValue instanceof AsyncInteropPromise) {
+        return new Promise(function ($resolve, $reject) use ($promiseOrValue) {
+            $promiseOrValue->when(function ($reason = null, $value = null) use ($resolve, $reject) {
+                if ($reason) {
+                    $reject($reason);
+                    return;
+                }
+
+                $resolve($value);
+            });
+        });
+    }
+
     if (method_exists($promiseOrValue, 'then')) {
         $canceller = null;
 
@@ -31,6 +46,14 @@ function reject($promiseOrValue = null)
         });
     }
 
+    if ($promiseOrValue instanceof AsyncInteropPromise) {
+        return new Promise(function ($resolve, $reject) use ($promiseOrValue) {
+            $promiseOrValue->when(function ($reason = null, $value = null) use ($resolve, $reject) {
+                $reject($reason ? $reason : $value);
+            });
+        });
+    }
+
     return new RejectedPromise($promiseOrValue);
 }
 

tests/FulfilledPromiseTest.php

@@ -7,7 +7,8 @@
 class FulfilledPromiseTest extends TestCase
 {
     use PromiseTest\PromiseSettledTestTrait,
-        PromiseTest\PromiseFulfilledTestTrait;
+        PromiseTest\PromiseFulfilledTestTrait,
+        PromiseTest\AsyncInteropResolvedTestTrait;
 
     public function getPromiseTestAdapter(callable $canceller = null)
     {
@@ -47,4 +48,12 @@ public function shouldThrowExceptionIfConstructedWithAPromise()
 
         return new FulfilledPromise(new FulfilledPromise());
     }
+
+    /** @test */
+    public function shouldThrowExceptionIfConstructedWithAAsyncInteropPromise()
+    {
+        $this->setExpectedException('\InvalidArgumentException');
+
+        return new FulfilledPromise(new FulfilledPromise());
+    }
 }

tests/FunctionRejectTest.php

@@ -42,6 +42,24 @@ public function shouldRejectAFulfilledPromise()
             );
     }
 
+    /** @test */
+    public function shouldRejectAFulfilledAsyncInteropPromise()
+    {
+        $resolved = new SimpleFulfilledAsyncInteropTestPromise();
+
+        $mock = $this->createCallableMock();
+        $mock
+            ->expects($this->once())
+            ->method('__invoke')
+            ->with($this->identicalTo('foo'));
+
+        reject($resolved)
+            ->then(
+                $this->expectCallableNever(),
+                $mock
+            );
+    }
+
     /** @test */
     public function shouldRejectARejectedPromise()
     {
@@ -61,4 +79,23 @@ public function shouldRejectARejectedPromise()
                 $mock
             );
     }
+
+    /** @test */
+    public function shouldRejectARejectedAsyncInteropPromise()
+    {
+        $exception = new \Exception('foo');
+        $resolved = new SimpleRejectedAsyncInteropTestPromise($exception);
+
+        $mock = $this->createCallableMock();
+        $mock
+            ->expects($this->once())
+            ->method('__invoke')
+            ->with($this->identicalTo($exception));
+
+        reject($resolved)
+            ->then(
+                $this->expectCallableNever(),
+                $mock
+            );
+    }
 }

tests/FunctionResolveTest.php

@@ -71,6 +71,24 @@ public function shouldResolveACancellableThenable()
         $this->assertTrue($thenable->cancelCalled);
     }
 
+    /** @test */
+    public function shouldResolveAFulfilledAsyncInteropPromise()
+    {
+        $promise = new SimpleFulfilledAsyncInteropTestPromise();
+
+        $mock = $this->createCallableMock();
+        $mock
+            ->expects($this->once())
+            ->method('__invoke')
+            ->with($this->identicalTo('foo'));
+
+        resolve($promise)
+            ->then(
+                $mock,
+                $this->expectCallableNever()
+            );
+    }
+
     /** @test */
     public function shouldRejectARejectedPromise()
     {
@@ -91,6 +109,25 @@ public function shouldRejectARejectedPromise()
             );
     }
 
+    /** @test */
+    public function shouldRejectARejectedAsyncInteropPromise()
+    {
+        $exception = new \Exception('foo');
+        $promise = new SimpleRejectedAsyncInteropTestPromise($exception);
+
+        $mock = $this->createCallableMock();
+        $mock
+            ->expects($this->once())
+            ->method('__invoke')
+            ->with($this->identicalTo($exception));
+
+        resolve($promise)
+            ->then(
+                $this->expectCallableNever(),
+                $mock
+            );
+    }
+
     /** @test */
     public function shouldSupportDeepNestingInPromiseChains()
     {

tests/PromiseTest/AsyncInteropRejectedTestTrait.php

@@ -0,0 +1,51 @@
+<?php
+
+namespace React\Promise\PromiseTest;
+
+trait AsyncInteropRejectedTestTrait
+{
+    /**
+     * @return \React\Promise\PromiseAdapter\PromiseAdapterInterface
+     */
+    abstract public function getPromiseTestAdapter(callable $canceller = null);
+
+    public function testWhenOnExceptionFailedAsyncInteropPromise()
+    {
+        $adapter = $this->getPromiseTestAdapter();
+
+        $adapter->reject(new \RuntimeException);
+        $adapter->promise()->when(function ($e) use (&$invoked) {
+            $this->assertSame(get_class($e), "RuntimeException");
+            $invoked = true;
+        });
+        $this->assertTrue($invoked);
+    }
+
+    public function testWhenOnErrorFailedAsyncInteropPromise()
+    {
+        if (PHP_VERSION_ID < 70000) {
+            $this->markTestSkipped("Error only exists on PHP 7+");
+        }
+
+        $adapter = $this->getPromiseTestAdapter();
+        $adapter->reject(new \Error);
+        $adapter->promise()->when(function ($e) use (&$invoked) {
+            $this->assertSame(get_class($e), "Error");
+            $invoked = true;
+        });
+        $this->assertTrue($invoked);
+    }
+
+    public function testWhenOnExceptionFailedAsyncInteropPromiseWhenRejectedWithoutReason()
+    {
+        $adapter = $this->getPromiseTestAdapter();
+
+        $adapter->reject();
+        $adapter->promise()->when(function ($e, $value) use (&$invoked) {
+            $this->assertInstanceOf("Exception", $e);
+            $this->assertNull($value);
+            $invoked = true;
+        });
+        $this->assertTrue($invoked);
+    }
+}