Skip to content

Commit 984382f

Browse files
clueWyriHaximus
clue
authored and
WyriHaximus
committed
Add Fiber-based async() function
1 parent 6f7f05b commit 984382f

File tree

3 files changed

+158
-16
lines changed

3 files changed

+158
-16
lines changed

‎src/functions.php

Lines changed: 25 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -10,6 +10,31 @@
1010
use function React\Promise\reject;
1111
use function React\Promise\resolve;
1212

13+
/**
14+
* Execute an async Fiber-based function to "await" promises.
15+
*
16+
* @param callable(mixed ...$args):mixed $function
17+
* @param mixed ...$args Optional list of additional arguments that will be passed to the given `$function` as is
18+
* @return PromiseInterface<mixed>
19+
* @since 4.0.0
20+
* @see coroutine()
21+
*/
22+
function async(callable $function, mixed ...$args): PromiseInterface
23+
{
24+
return new Promise(function (callable $resolve, callable $reject) use ($function, $args): void {
25+
$fiber = new \Fiber(function () use ($resolve, $reject, $function, $args): void {
26+
try {
27+
$resolve($function(...$args));
28+
} catch (\Throwable $exception) {
29+
$reject($exception);
30+
}
31+
});
32+
33+
Loop::futureTick(static fn() => $fiber->start());
34+
});
35+
}
36+
37+
1338
/**
1439
* Block waiting for the given `$promise` to be fulfilled.
1540
*

‎tests/AsyncTest.php

Lines changed: 87 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,87 @@
1+
<?php
2+
3+
namespace React\Tests\Async;
4+
5+
use React;
6+
use React\EventLoop\Loop;
7+
use React\Promise\Promise;
8+
use function React\Async\async;
9+
use function React\Async\await;
10+
use function React\Promise\all;
11+
12+
class AsyncTest extends TestCase
13+
{
14+
public function testAsyncReturnsPendingPromise()
15+
{
16+
$promise = async(function () {
17+
return 42;
18+
});
19+
20+
$promise->then($this->expectCallableNever(), $this->expectCallableNever());
21+
}
22+
23+
public function testAsyncReturnsPromiseThatFulfillsWithValueWhenCallbackReturns()
24+
{
25+
$promise = async(function () {
26+
return 42;
27+
});
28+
29+
$value = await($promise);
30+
31+
$this->assertEquals(42, $value);
32+
}
33+
34+
public function testAsyncReturnsPromiseThatRejectsWithExceptionWhenCallbackThrows()
35+
{
36+
$promise = async(function () {
37+
throw new \RuntimeException('Foo', 42);
38+
});
39+
40+
$this->expectException(\RuntimeException::class);
41+
$this->expectExceptionMessage('Foo');
42+
$this->expectExceptionCode(42);
43+
await($promise);
44+
}
45+
46+
public function testAsyncReturnsPromiseThatFulfillsWithValueWhenCallbackReturnsAfterAwaitingPromise()
47+
{
48+
$promise = async(function () {
49+
$promise = new Promise(function ($resolve) {
50+
Loop::addTimer(0.001, fn () => $resolve(42));
51+
});
52+
53+
return await($promise);
54+
});
55+
56+
$value = await($promise);
57+
58+
$this->assertEquals(42, $value);
59+
}
60+
61+
public function testAsyncReturnsPromiseThatFulfillsWithValueWhenCallbackReturnsAfterAwaitingTwoConcurrentPromises()
62+
{
63+
$promise1 = async(function () {
64+
$promise = new Promise(function ($resolve) {
65+
Loop::addTimer(0.11, fn () => $resolve(21));
66+
});
67+
68+
return await($promise);
69+
});
70+
71+
$promise2 = async(function () {
72+
$promise = new Promise(function ($resolve) {
73+
Loop::addTimer(0.11, fn () => $resolve(42));
74+
});
75+
76+
return await($promise);
77+
});
78+
79+
$time = microtime(true);
80+
$values = await(all([$promise1, $promise2]));
81+
$time = microtime(true) - $time;
82+
83+
$this->assertEquals([21, 42], $values);
84+
$this->assertGreaterThan(0.1, $time);
85+
$this->assertLessThan(0.12, $time);
86+
}
87+
}

‎tests/AwaitTest.php

Lines changed: 46 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -8,18 +8,24 @@
88

99
class AwaitTest extends TestCase
1010
{
11-
public function testAwaitThrowsExceptionWhenPromiseIsRejectedWithException()
11+
/**
12+
* @dataProvider provideAwaiters
13+
*/
14+
public function testAwaitThrowsExceptionWhenPromiseIsRejectedWithException(callable $await)
1215
{
1316
$promise = new Promise(function () {
1417
throw new \Exception('test');
1518
});
1619

1720
$this->expectException(\Exception::class);
1821
$this->expectExceptionMessage('test');
19-
React\Async\await($promise);
22+
$await($promise);
2023
}
2124

22-
public function testAwaitThrowsUnexpectedValueExceptionWhenPromiseIsRejectedWithFalse()
25+
/**
26+
* @dataProvider provideAwaiters
27+
*/
28+
public function testAwaitThrowsUnexpectedValueExceptionWhenPromiseIsRejectedWithFalse(callable $await)
2329
{
2430
if (!interface_exists('React\Promise\CancellablePromiseInterface')) {
2531
$this->markTestSkipped('Promises must be rejected with a \Throwable instance since Promise v3');
@@ -31,10 +37,13 @@ public function testAwaitThrowsUnexpectedValueExceptionWhenPromiseIsRejectedWith
3137

3238
$this->expectException(\UnexpectedValueException::class);
3339
$this->expectExceptionMessage('Promise rejected with unexpected value of type bool');
34-
React\Async\await($promise);
40+
$await($promise);
3541
}
3642

37-
public function testAwaitThrowsUnexpectedValueExceptionWhenPromiseIsRejectedWithNull()
43+
/**
44+
* @dataProvider provideAwaiters
45+
*/
46+
public function testAwaitThrowsUnexpectedValueExceptionWhenPromiseIsRejectedWithNull(callable $await)
3847
{
3948
if (!interface_exists('React\Promise\CancellablePromiseInterface')) {
4049
$this->markTestSkipped('Promises must be rejected with a \Throwable instance since Promise v3');
@@ -46,10 +55,13 @@ public function testAwaitThrowsUnexpectedValueExceptionWhenPromiseIsRejectedWith
4655

4756
$this->expectException(\UnexpectedValueException::class);
4857
$this->expectExceptionMessage('Promise rejected with unexpected value of type NULL');
49-
React\Async\await($promise);
58+
$await($promise);
5059
}
5160

52-
public function testAwaitThrowsErrorWhenPromiseIsRejectedWithError()
61+
/**
62+
* @dataProvider provideAwaiters
63+
*/
64+
public function testAwaitThrowsErrorWhenPromiseIsRejectedWithError(callable $await)
5365
{
5466
$promise = new Promise(function ($_, $reject) {
5567
throw new \Error('Test', 42);
@@ -58,19 +70,25 @@ public function testAwaitThrowsErrorWhenPromiseIsRejectedWithError()
5870
$this->expectException(\Error::class);
5971
$this->expectExceptionMessage('Test');
6072
$this->expectExceptionCode(42);
61-
React\Async\await($promise);
73+
$await($promise);
6274
}
6375

64-
public function testAwaitReturnsValueWhenPromiseIsFullfilled()
76+
/**
77+
* @dataProvider provideAwaiters
78+
*/
79+
public function testAwaitReturnsValueWhenPromiseIsFullfilled(callable $await)
6580
{
6681
$promise = new Promise(function ($resolve) {
6782
$resolve(42);
6883
});
6984

70-
$this->assertEquals(42, React\Async\await($promise));
85+
$this->assertEquals(42, $await($promise));
7186
}
7287

73-
public function testAwaitShouldNotCreateAnyGarbageReferencesForResolvedPromise()
88+
/**
89+
* @dataProvider provideAwaiters
90+
*/
91+
public function testAwaitShouldNotCreateAnyGarbageReferencesForResolvedPromise(callable $await)
7492
{
7593
if (class_exists('React\Promise\When')) {
7694
$this->markTestSkipped('Not supported on legacy Promise v1 API');
@@ -81,13 +99,16 @@ public function testAwaitShouldNotCreateAnyGarbageReferencesForResolvedPromise()
8199
$promise = new Promise(function ($resolve) {
82100
$resolve(42);
83101
});
84-
React\Async\await($promise);
102+
$await($promise);
85103
unset($promise);
86104

87105
$this->assertEquals(0, gc_collect_cycles());
88106
}
89107

90-
public function testAwaitShouldNotCreateAnyGarbageReferencesForRejectedPromise()
108+
/**
109+
* @dataProvider provideAwaiters
110+
*/
111+
public function testAwaitShouldNotCreateAnyGarbageReferencesForRejectedPromise(callable $await)
91112
{
92113
if (class_exists('React\Promise\When')) {
93114
$this->markTestSkipped('Not supported on legacy Promise v1 API');
@@ -99,7 +120,7 @@ public function testAwaitShouldNotCreateAnyGarbageReferencesForRejectedPromise()
99120
throw new \RuntimeException();
100121
});
101122
try {
102-
React\Async\await($promise);
123+
$await($promise);
103124
} catch (\Exception $e) {
104125
// no-op
105126
}
@@ -108,7 +129,10 @@ public function testAwaitShouldNotCreateAnyGarbageReferencesForRejectedPromise()
108129
$this->assertEquals(0, gc_collect_cycles());
109130
}
110131

111-
public function testAwaitShouldNotCreateAnyGarbageReferencesForPromiseRejectedWithNullValue()
132+
/**
133+
* @dataProvider provideAwaiters
134+
*/
135+
public function testAwaitShouldNotCreateAnyGarbageReferencesForPromiseRejectedWithNullValue(callable $await)
112136
{
113137
if (!interface_exists('React\Promise\CancellablePromiseInterface')) {
114138
$this->markTestSkipped('Promises must be rejected with a \Throwable instance since Promise v3');
@@ -124,12 +148,18 @@ public function testAwaitShouldNotCreateAnyGarbageReferencesForPromiseRejectedWi
124148
$reject(null);
125149
});
126150
try {
127-
React\Async\await($promise);
151+
$await($promise);
128152
} catch (\Exception $e) {
129153
// no-op
130154
}
131155
unset($promise, $e);
132156

133157
$this->assertEquals(0, gc_collect_cycles());
134158
}
159+
160+
public function provideAwaiters(): iterable
161+
{
162+
yield 'await' => [static fn (React\Promise\PromiseInterface $promise): mixed => React\Async\await($promise)];
163+
yield 'async' => [static fn (React\Promise\PromiseInterface $promise): mixed => React\Async\await(React\Async\async(static fn(): mixed => $promise))];
164+
}
135165
}

0 commit comments

Comments
 (0)