Merge pull request reactphp#30 from clue-labs/the-future-is-now

Improve `async()` to avoid unneeded `futureTick()` calls

src/functions.php

@@ -164,7 +164,7 @@ function async(callable $function): callable
             }
         });
 
-        Loop::futureTick(static fn() => $fiber->start());
+        $fiber->start();
     });
 }
 

tests/AsyncTest.php

@@ -8,25 +8,35 @@
 use function React\Async\async;
 use function React\Async\await;
 use function React\Promise\all;
+use function React\Promise\reject;
+use function React\Promise\resolve;
 
 class AsyncTest extends TestCase
 {
-    public function testAsyncReturnsPendingPromise()
+    public function testAsyncReturnsPromiseThatFulfillsWithValueWhenCallbackReturnsValue()
     {
         $promise = async(function () {
             return 42;
         })();
 
-        $promise->then($this->expectCallableNever(), $this->expectCallableNever());
+        $value = null;
+        $promise->then(function ($v) use (&$value) {
+            $value = $v;
+        });
+
+        $this->assertEquals(42, $value);
     }
 
-    public function testAsyncReturnsPromiseThatFulfillsWithValueWhenCallbackReturns()
+    public function testAsyncReturnsPromiseThatFulfillsWithValueWhenCallbackReturnsPromiseThatFulfillsWithValue()
     {
         $promise = async(function () {
-            return 42;
+            return resolve(42);
         })();
 
-        $value = await($promise);
+        $value = null;
+        $promise->then(function ($v) use (&$value) {
+            $value = $v;
+        });
 
         $this->assertEquals(42, $value);
     }
@@ -37,10 +47,41 @@ public function testAsyncReturnsPromiseThatRejectsWithExceptionWhenCallbackThrow
             throw new \RuntimeException('Foo', 42);
         })();
 
-        $this->expectException(\RuntimeException::class);
-        $this->expectExceptionMessage('Foo');
-        $this->expectExceptionCode(42);
-        await($promise);
+        $exception = null;
+        $promise->then(null, function ($reason) use (&$exception) {
+            $exception = $reason;
+        });
+
+        assert($exception instanceof \RuntimeException);
+        $this->assertInstanceOf(\RuntimeException::class, $exception);
+        $this->assertEquals('Foo', $exception->getMessage());
+        $this->assertEquals(42, $exception->getCode());
+    }
+
+    public function testAsyncReturnsPromiseThatRejectsWithExceptionWhenCallbackReturnsPromiseThatRejectsWithException()
+    {
+        $promise = async(function () {
+            return reject(new \RuntimeException('Foo', 42));
+        })();
+
+        $exception = null;
+        $promise->then(null, function ($reason) use (&$exception) {
+            $exception = $reason;
+        });
+
+        assert($exception instanceof \RuntimeException);
+        $this->assertInstanceOf(\RuntimeException::class, $exception);
+        $this->assertEquals('Foo', $exception->getMessage());
+        $this->assertEquals(42, $exception->getCode());
+    }
+
+    public function testAsyncReturnsPendingPromiseWhenCallbackReturnsPendingPromise()
+    {
+        $promise = async(function () {
+            return new Promise(function () { });
+        })();
+
+        $promise->then($this->expectCallableNever(), $this->expectCallableNever());
     }
 
     public function testAsyncReturnsPromiseThatFulfillsWithValueWhenCallbackReturnsAfterAwaitingPromise()