695 lines
22 KiB
PHP
695 lines
22 KiB
PHP
<?php
|
|
namespace GuzzleHttp\Promise\Tests;
|
|
|
|
use GuzzleHttp\Promise as P;
|
|
use GuzzleHttp\Promise\FulfilledPromise;
|
|
use GuzzleHttp\Promise\Promise;
|
|
use GuzzleHttp\Promise\RejectedPromise;
|
|
|
|
class FunctionsTest extends \PHPUnit_Framework_TestCase
|
|
{
|
|
public function testCreatesPromiseForValue()
|
|
{
|
|
$p = \GuzzleHttp\Promise\promise_for('foo');
|
|
$this->assertInstanceOf('GuzzleHttp\Promise\FulfilledPromise', $p);
|
|
}
|
|
|
|
public function testReturnsPromiseForPromise()
|
|
{
|
|
$p = new Promise();
|
|
$this->assertSame($p, \GuzzleHttp\Promise\promise_for($p));
|
|
}
|
|
|
|
public function testReturnsPromiseForThennable()
|
|
{
|
|
$p = new Thennable();
|
|
$wrapped = \GuzzleHttp\Promise\promise_for($p);
|
|
$this->assertNotSame($p, $wrapped);
|
|
$this->assertInstanceOf('GuzzleHttp\Promise\PromiseInterface', $wrapped);
|
|
$p->resolve('foo');
|
|
P\queue()->run();
|
|
$this->assertEquals('foo', $wrapped->wait());
|
|
}
|
|
|
|
public function testReturnsRejection()
|
|
{
|
|
$p = \GuzzleHttp\Promise\rejection_for('fail');
|
|
$this->assertInstanceOf('GuzzleHttp\Promise\RejectedPromise', $p);
|
|
$this->assertEquals('fail', $this->readAttribute($p, 'reason'));
|
|
}
|
|
|
|
public function testReturnsPromisesAsIsInRejectionFor()
|
|
{
|
|
$a = new Promise();
|
|
$b = \GuzzleHttp\Promise\rejection_for($a);
|
|
$this->assertSame($a, $b);
|
|
}
|
|
|
|
public function testWaitsOnAllPromisesIntoArray()
|
|
{
|
|
$e = new \Exception();
|
|
$a = new Promise(function () use (&$a) { $a->resolve('a'); });
|
|
$b = new Promise(function () use (&$b) { $b->reject('b'); });
|
|
$c = new Promise(function () use (&$c, $e) { $c->reject($e); });
|
|
$results = \GuzzleHttp\Promise\inspect_all([$a, $b, $c]);
|
|
$this->assertEquals([
|
|
['state' => 'fulfilled', 'value' => 'a'],
|
|
['state' => 'rejected', 'reason' => 'b'],
|
|
['state' => 'rejected', 'reason' => $e]
|
|
], $results);
|
|
}
|
|
|
|
/**
|
|
* @expectedException \GuzzleHttp\Promise\RejectionException
|
|
*/
|
|
public function testUnwrapsPromisesWithNoDefaultAndFailure()
|
|
{
|
|
$promises = [new FulfilledPromise('a'), new Promise()];
|
|
\GuzzleHttp\Promise\unwrap($promises);
|
|
}
|
|
|
|
public function testUnwrapsPromisesWithNoDefault()
|
|
{
|
|
$promises = [new FulfilledPromise('a')];
|
|
$this->assertEquals(['a'], \GuzzleHttp\Promise\unwrap($promises));
|
|
}
|
|
|
|
public function testUnwrapsPromisesWithKeys()
|
|
{
|
|
$promises = [
|
|
'foo' => new FulfilledPromise('a'),
|
|
'bar' => new FulfilledPromise('b'),
|
|
];
|
|
$this->assertEquals([
|
|
'foo' => 'a',
|
|
'bar' => 'b'
|
|
], \GuzzleHttp\Promise\unwrap($promises));
|
|
}
|
|
|
|
public function testAllAggregatesSortedArray()
|
|
{
|
|
$a = new Promise();
|
|
$b = new Promise();
|
|
$c = new Promise();
|
|
$d = \GuzzleHttp\Promise\all([$a, $b, $c]);
|
|
$b->resolve('b');
|
|
$a->resolve('a');
|
|
$c->resolve('c');
|
|
$d->then(
|
|
function ($value) use (&$result) { $result = $value; },
|
|
function ($reason) use (&$result) { $result = $reason; }
|
|
);
|
|
P\queue()->run();
|
|
$this->assertEquals(['a', 'b', 'c'], $result);
|
|
}
|
|
|
|
public function testAllThrowsWhenAnyRejected()
|
|
{
|
|
$a = new Promise();
|
|
$b = new Promise();
|
|
$c = new Promise();
|
|
$d = \GuzzleHttp\Promise\all([$a, $b, $c]);
|
|
$b->resolve('b');
|
|
$a->reject('fail');
|
|
$c->resolve('c');
|
|
$d->then(
|
|
function ($value) use (&$result) { $result = $value; },
|
|
function ($reason) use (&$result) { $result = $reason; }
|
|
);
|
|
P\queue()->run();
|
|
$this->assertEquals('fail', $result);
|
|
}
|
|
|
|
public function testSomeAggregatesSortedArrayWithMax()
|
|
{
|
|
$a = new Promise();
|
|
$b = new Promise();
|
|
$c = new Promise();
|
|
$d = \GuzzleHttp\Promise\some(2, [$a, $b, $c]);
|
|
$b->resolve('b');
|
|
$c->resolve('c');
|
|
$a->resolve('a');
|
|
$d->then(function ($value) use (&$result) { $result = $value; });
|
|
P\queue()->run();
|
|
$this->assertEquals(['b', 'c'], $result);
|
|
}
|
|
|
|
public function testSomeRejectsWhenTooManyRejections()
|
|
{
|
|
$a = new Promise();
|
|
$b = new Promise();
|
|
$d = \GuzzleHttp\Promise\some(2, [$a, $b]);
|
|
$a->reject('bad');
|
|
$b->resolve('good');
|
|
P\queue()->run();
|
|
$this->assertEquals($a::REJECTED, $d->getState());
|
|
$d->then(null, function ($reason) use (&$called) {
|
|
$called = $reason;
|
|
});
|
|
P\queue()->run();
|
|
$this->assertInstanceOf('GuzzleHttp\Promise\AggregateException', $called);
|
|
$this->assertContains('bad', $called->getReason());
|
|
}
|
|
|
|
public function testCanWaitUntilSomeCountIsSatisfied()
|
|
{
|
|
$a = new Promise(function () use (&$a) { $a->resolve('a'); });
|
|
$b = new Promise(function () use (&$b) { $b->resolve('b'); });
|
|
$c = new Promise(function () use (&$c) { $c->resolve('c'); });
|
|
$d = \GuzzleHttp\Promise\some(2, [$a, $b, $c]);
|
|
$this->assertEquals(['a', 'b'], $d->wait());
|
|
}
|
|
|
|
/**
|
|
* @expectedException \GuzzleHttp\Promise\AggregateException
|
|
* @expectedExceptionMessage Not enough promises to fulfill count
|
|
*/
|
|
public function testThrowsIfImpossibleToWaitForSomeCount()
|
|
{
|
|
$a = new Promise(function () use (&$a) { $a->resolve('a'); });
|
|
$d = \GuzzleHttp\Promise\some(2, [$a]);
|
|
$d->wait();
|
|
}
|
|
|
|
/**
|
|
* @expectedException \GuzzleHttp\Promise\AggregateException
|
|
* @expectedExceptionMessage Not enough promises to fulfill count
|
|
*/
|
|
public function testThrowsIfResolvedWithoutCountTotalResults()
|
|
{
|
|
$a = new Promise();
|
|
$b = new Promise();
|
|
$d = \GuzzleHttp\Promise\some(3, [$a, $b]);
|
|
$a->resolve('a');
|
|
$b->resolve('b');
|
|
$d->wait();
|
|
}
|
|
|
|
public function testAnyReturnsFirstMatch()
|
|
{
|
|
$a = new Promise();
|
|
$b = new Promise();
|
|
$c = \GuzzleHttp\Promise\any([$a, $b]);
|
|
$b->resolve('b');
|
|
$a->resolve('a');
|
|
//P\queue()->run();
|
|
//$this->assertEquals('fulfilled', $c->getState());
|
|
$c->then(function ($value) use (&$result) { $result = $value; });
|
|
P\queue()->run();
|
|
$this->assertEquals('b', $result);
|
|
}
|
|
|
|
public function testSettleFulfillsWithFulfilledAndRejected()
|
|
{
|
|
$a = new Promise();
|
|
$b = new Promise();
|
|
$c = new Promise();
|
|
$d = \GuzzleHttp\Promise\settle([$a, $b, $c]);
|
|
$b->resolve('b');
|
|
$c->resolve('c');
|
|
$a->reject('a');
|
|
P\queue()->run();
|
|
$this->assertEquals('fulfilled', $d->getState());
|
|
$d->then(function ($value) use (&$result) { $result = $value; });
|
|
P\queue()->run();
|
|
$this->assertEquals([
|
|
['state' => 'rejected', 'reason' => 'a'],
|
|
['state' => 'fulfilled', 'value' => 'b'],
|
|
['state' => 'fulfilled', 'value' => 'c']
|
|
], $result);
|
|
}
|
|
|
|
public function testCanInspectFulfilledPromise()
|
|
{
|
|
$p = new FulfilledPromise('foo');
|
|
$this->assertEquals([
|
|
'state' => 'fulfilled',
|
|
'value' => 'foo'
|
|
], \GuzzleHttp\Promise\inspect($p));
|
|
}
|
|
|
|
public function testCanInspectRejectedPromise()
|
|
{
|
|
$p = new RejectedPromise('foo');
|
|
$this->assertEquals([
|
|
'state' => 'rejected',
|
|
'reason' => 'foo'
|
|
], \GuzzleHttp\Promise\inspect($p));
|
|
}
|
|
|
|
public function testCanInspectRejectedPromiseWithNormalException()
|
|
{
|
|
$e = new \Exception('foo');
|
|
$p = new RejectedPromise($e);
|
|
$this->assertEquals([
|
|
'state' => 'rejected',
|
|
'reason' => $e
|
|
], \GuzzleHttp\Promise\inspect($p));
|
|
}
|
|
|
|
public function testCallsEachLimit()
|
|
{
|
|
$p = new Promise();
|
|
$aggregate = \GuzzleHttp\Promise\each_limit($p, 2);
|
|
$p->resolve('a');
|
|
P\queue()->run();
|
|
$this->assertEquals($p::FULFILLED, $aggregate->getState());
|
|
}
|
|
|
|
public function testEachLimitAllRejectsOnFailure()
|
|
{
|
|
$p = [new FulfilledPromise('a'), new RejectedPromise('b')];
|
|
$aggregate = \GuzzleHttp\Promise\each_limit_all($p, 2);
|
|
P\queue()->run();
|
|
$this->assertEquals(P\PromiseInterface::REJECTED, $aggregate->getState());
|
|
$result = \GuzzleHttp\Promise\inspect($aggregate);
|
|
$this->assertEquals('b', $result['reason']);
|
|
}
|
|
|
|
public function testIterForReturnsIterator()
|
|
{
|
|
$iter = new \ArrayIterator();
|
|
$this->assertSame($iter, \GuzzleHttp\Promise\iter_for($iter));
|
|
}
|
|
|
|
public function testKnowsIfFulfilled()
|
|
{
|
|
$p = new FulfilledPromise(null);
|
|
$this->assertTrue(P\is_fulfilled($p));
|
|
$this->assertFalse(P\is_rejected($p));
|
|
}
|
|
|
|
public function testKnowsIfRejected()
|
|
{
|
|
$p = new RejectedPromise(null);
|
|
$this->assertTrue(P\is_rejected($p));
|
|
$this->assertFalse(P\is_fulfilled($p));
|
|
}
|
|
|
|
public function testKnowsIfSettled()
|
|
{
|
|
$p = new RejectedPromise(null);
|
|
$this->assertTrue(P\is_settled($p));
|
|
$p = new Promise();
|
|
$this->assertFalse(P\is_settled($p));
|
|
}
|
|
|
|
public function testReturnsTrampoline()
|
|
{
|
|
$this->assertInstanceOf('GuzzleHttp\Promise\TaskQueue', P\queue());
|
|
$this->assertSame(P\queue(), P\queue());
|
|
}
|
|
|
|
public function testCanScheduleThunk()
|
|
{
|
|
$tramp = P\queue();
|
|
$promise = P\task(function () { return 'Hi!'; });
|
|
$c = null;
|
|
$promise->then(function ($v) use (&$c) { $c = $v; });
|
|
$this->assertNull($c);
|
|
$tramp->run();
|
|
$this->assertEquals('Hi!', $c);
|
|
}
|
|
|
|
public function testCanScheduleThunkWithRejection()
|
|
{
|
|
$tramp = P\queue();
|
|
$promise = P\task(function () { throw new \Exception('Hi!'); });
|
|
$c = null;
|
|
$promise->otherwise(function ($v) use (&$c) { $c = $v; });
|
|
$this->assertNull($c);
|
|
$tramp->run();
|
|
$this->assertEquals('Hi!', $c->getMessage());
|
|
}
|
|
|
|
public function testCanScheduleThunkWithWait()
|
|
{
|
|
$tramp = P\queue();
|
|
$promise = P\task(function () { return 'a'; });
|
|
$this->assertEquals('a', $promise->wait());
|
|
$tramp->run();
|
|
}
|
|
|
|
public function testYieldsFromCoroutine()
|
|
{
|
|
$promise = P\coroutine(function () {
|
|
$value = (yield new P\FulfilledPromise('a'));
|
|
yield $value . 'b';
|
|
});
|
|
$promise->then(function ($value) use (&$result) { $result = $value; });
|
|
P\queue()->run();
|
|
$this->assertEquals('ab', $result);
|
|
}
|
|
|
|
public function testCanCatchExceptionsInCoroutine()
|
|
{
|
|
$promise = P\coroutine(function () {
|
|
try {
|
|
yield new P\RejectedPromise('a');
|
|
$this->fail('Should have thrown into the coroutine!');
|
|
} catch (P\RejectionException $e) {
|
|
$value = (yield new P\FulfilledPromise($e->getReason()));
|
|
yield $value . 'b';
|
|
}
|
|
});
|
|
$promise->then(function ($value) use (&$result) { $result = $value; });
|
|
P\queue()->run();
|
|
$this->assertEquals(P\PromiseInterface::FULFILLED, $promise->getState());
|
|
$this->assertEquals('ab', $result);
|
|
}
|
|
|
|
public function testRejectsParentExceptionWhenException()
|
|
{
|
|
$promise = P\coroutine(function () {
|
|
yield new P\FulfilledPromise(0);
|
|
throw new \Exception('a');
|
|
});
|
|
$promise->then(
|
|
function () { $this->fail(); },
|
|
function ($reason) use (&$result) { $result = $reason; }
|
|
);
|
|
P\queue()->run();
|
|
$this->assertInstanceOf('Exception', $result);
|
|
$this->assertEquals('a', $result->getMessage());
|
|
}
|
|
|
|
public function testCanRejectFromRejectionCallback()
|
|
{
|
|
$promise = P\coroutine(function () {
|
|
yield new P\FulfilledPromise(0);
|
|
yield new P\RejectedPromise('no!');
|
|
});
|
|
$promise->then(
|
|
function () { $this->fail(); },
|
|
function ($reason) use (&$result) { $result = $reason; }
|
|
);
|
|
P\queue()->run();
|
|
$this->assertInstanceOf('GuzzleHttp\Promise\RejectionException', $result);
|
|
$this->assertEquals('no!', $result->getReason());
|
|
}
|
|
|
|
public function testCanAsyncReject()
|
|
{
|
|
$rej = new P\Promise();
|
|
$promise = P\coroutine(function () use ($rej) {
|
|
yield new P\FulfilledPromise(0);
|
|
yield $rej;
|
|
});
|
|
$promise->then(
|
|
function () { $this->fail(); },
|
|
function ($reason) use (&$result) { $result = $reason; }
|
|
);
|
|
$rej->reject('no!');
|
|
P\queue()->run();
|
|
$this->assertInstanceOf('GuzzleHttp\Promise\RejectionException', $result);
|
|
$this->assertEquals('no!', $result->getReason());
|
|
}
|
|
|
|
public function testCanCatchAndThrowOtherException()
|
|
{
|
|
$promise = P\coroutine(function () {
|
|
try {
|
|
yield new P\RejectedPromise('a');
|
|
$this->fail('Should have thrown into the coroutine!');
|
|
} catch (P\RejectionException $e) {
|
|
throw new \Exception('foo');
|
|
}
|
|
});
|
|
$promise->otherwise(function ($value) use (&$result) { $result = $value; });
|
|
P\queue()->run();
|
|
$this->assertEquals(P\PromiseInterface::REJECTED, $promise->getState());
|
|
$this->assertContains('foo', $result->getMessage());
|
|
}
|
|
|
|
public function testCanCatchAndYieldOtherException()
|
|
{
|
|
$promise = P\coroutine(function () {
|
|
try {
|
|
yield new P\RejectedPromise('a');
|
|
$this->fail('Should have thrown into the coroutine!');
|
|
} catch (P\RejectionException $e) {
|
|
yield new P\RejectedPromise('foo');
|
|
}
|
|
});
|
|
$promise->otherwise(function ($value) use (&$result) { $result = $value; });
|
|
P\queue()->run();
|
|
$this->assertEquals(P\PromiseInterface::REJECTED, $promise->getState());
|
|
$this->assertContains('foo', $result->getMessage());
|
|
}
|
|
|
|
public function createLotsOfSynchronousPromise()
|
|
{
|
|
return P\coroutine(function () {
|
|
$value = 0;
|
|
for ($i = 0; $i < 1000; $i++) {
|
|
$value = (yield new P\FulfilledPromise($i));
|
|
}
|
|
yield $value;
|
|
});
|
|
}
|
|
|
|
public function testLotsOfSynchronousDoesNotBlowStack()
|
|
{
|
|
$promise = $this->createLotsOfSynchronousPromise();
|
|
$promise->then(function ($v) use (&$r) { $r = $v; });
|
|
P\queue()->run();
|
|
$this->assertEquals(999, $r);
|
|
}
|
|
|
|
public function testLotsOfSynchronousWaitDoesNotBlowStack()
|
|
{
|
|
$promise = $this->createLotsOfSynchronousPromise();
|
|
$promise->then(function ($v) use (&$r) { $r = $v; });
|
|
$this->assertEquals(999, $promise->wait());
|
|
$this->assertEquals(999, $r);
|
|
}
|
|
|
|
private function createLotsOfFlappingPromise()
|
|
{
|
|
return P\coroutine(function () {
|
|
$value = 0;
|
|
for ($i = 0; $i < 1000; $i++) {
|
|
try {
|
|
if ($i % 2) {
|
|
$value = (yield new P\FulfilledPromise($i));
|
|
} else {
|
|
$value = (yield new P\RejectedPromise($i));
|
|
}
|
|
} catch (\Exception $e) {
|
|
$value = (yield new P\FulfilledPromise($i));
|
|
}
|
|
}
|
|
yield $value;
|
|
});
|
|
}
|
|
|
|
public function testLotsOfTryCatchingDoesNotBlowStack()
|
|
{
|
|
$promise = $this->createLotsOfFlappingPromise();
|
|
$promise->then(function ($v) use (&$r) { $r = $v; });
|
|
P\queue()->run();
|
|
$this->assertEquals(999, $r);
|
|
}
|
|
|
|
public function testLotsOfTryCatchingWaitingDoesNotBlowStack()
|
|
{
|
|
$promise = $this->createLotsOfFlappingPromise();
|
|
$promise->then(function ($v) use (&$r) { $r = $v; });
|
|
$this->assertEquals(999, $promise->wait());
|
|
$this->assertEquals(999, $r);
|
|
}
|
|
|
|
public function testAsyncPromisesWithCorrectlyYieldedValues()
|
|
{
|
|
$promises = [
|
|
new P\Promise(),
|
|
new P\Promise(),
|
|
new P\Promise()
|
|
];
|
|
|
|
$promise = P\coroutine(function () use ($promises) {
|
|
$value = null;
|
|
$this->assertEquals('skip', (yield new P\FulfilledPromise('skip')));
|
|
foreach ($promises as $idx => $p) {
|
|
$value = (yield $p);
|
|
$this->assertEquals($value, $idx);
|
|
$this->assertEquals('skip', (yield new P\FulfilledPromise('skip')));
|
|
}
|
|
$this->assertEquals('skip', (yield new P\FulfilledPromise('skip')));
|
|
yield $value;
|
|
});
|
|
|
|
$promises[0]->resolve(0);
|
|
$promises[1]->resolve(1);
|
|
$promises[2]->resolve(2);
|
|
|
|
$promise->then(function ($v) use (&$r) { $r = $v; });
|
|
P\queue()->run();
|
|
$this->assertEquals(2, $r);
|
|
}
|
|
|
|
public function testYieldFinalWaitablePromise()
|
|
{
|
|
$p1 = new P\Promise(function () use (&$p1) {
|
|
$p1->resolve('skip me');
|
|
});
|
|
$p2 = new P\Promise(function () use (&$p2) {
|
|
$p2->resolve('hello!');
|
|
});
|
|
$co = P\coroutine(function() use ($p1, $p2) {
|
|
yield $p1;
|
|
yield $p2;
|
|
});
|
|
P\queue()->run();
|
|
$this->assertEquals('hello!', $co->wait());
|
|
}
|
|
|
|
public function testCanYieldFinalPendingPromise()
|
|
{
|
|
$p1 = new P\Promise();
|
|
$p2 = new P\Promise();
|
|
$co = P\coroutine(function() use ($p1, $p2) {
|
|
yield $p1;
|
|
yield $p2;
|
|
});
|
|
$p1->resolve('a');
|
|
$p2->resolve('b');
|
|
$co->then(function ($value) use (&$result) { $result = $value; });
|
|
P\queue()->run();
|
|
$this->assertEquals('b', $result);
|
|
}
|
|
|
|
public function testCanNestYieldsAndFailures()
|
|
{
|
|
$p1 = new P\Promise();
|
|
$p2 = new P\Promise();
|
|
$p3 = new P\Promise();
|
|
$p4 = new P\Promise();
|
|
$p5 = new P\Promise();
|
|
$co = P\coroutine(function() use ($p1, $p2, $p3, $p4, $p5) {
|
|
try {
|
|
yield $p1;
|
|
} catch (\Exception $e) {
|
|
yield $p2;
|
|
try {
|
|
yield $p3;
|
|
yield $p4;
|
|
} catch (\Exception $e) {
|
|
yield $p5;
|
|
}
|
|
}
|
|
});
|
|
$p1->reject('a');
|
|
$p2->resolve('b');
|
|
$p3->resolve('c');
|
|
$p4->reject('d');
|
|
$p5->resolve('e');
|
|
$co->then(function ($value) use (&$result) { $result = $value; });
|
|
P\queue()->run();
|
|
$this->assertEquals('e', $result);
|
|
}
|
|
|
|
public function testCanYieldErrorsAndSuccessesWithoutRecursion()
|
|
{
|
|
$promises = [];
|
|
for ($i = 0; $i < 20; $i++) {
|
|
$promises[] = new P\Promise();
|
|
}
|
|
|
|
$co = P\coroutine(function() use ($promises) {
|
|
for ($i = 0; $i < 20; $i += 4) {
|
|
try {
|
|
yield $promises[$i];
|
|
yield $promises[$i + 1];
|
|
} catch (\Exception $e) {
|
|
yield $promises[$i + 2];
|
|
yield $promises[$i + 3];
|
|
}
|
|
}
|
|
});
|
|
|
|
for ($i = 0; $i < 20; $i += 4) {
|
|
$promises[$i]->resolve($i);
|
|
$promises[$i + 1]->reject($i + 1);
|
|
$promises[$i + 2]->resolve($i + 2);
|
|
$promises[$i + 3]->resolve($i + 3);
|
|
}
|
|
|
|
$co->then(function ($value) use (&$result) { $result = $value; });
|
|
P\queue()->run();
|
|
$this->assertEquals('19', $result);
|
|
}
|
|
|
|
public function testCanWaitOnPromiseAfterFulfilled()
|
|
{
|
|
$f = function () {
|
|
static $i = 0;
|
|
$i++;
|
|
return $p = new P\Promise(function () use (&$p, $i) {
|
|
$p->resolve($i . '-bar');
|
|
});
|
|
};
|
|
|
|
$promises = [];
|
|
for ($i = 0; $i < 20; $i++) {
|
|
$promises[] = $f();
|
|
}
|
|
|
|
$p = P\coroutine(function () use ($promises) {
|
|
yield new P\FulfilledPromise('foo!');
|
|
foreach ($promises as $promise) {
|
|
yield $promise;
|
|
}
|
|
});
|
|
|
|
$this->assertEquals('20-bar', $p->wait());
|
|
}
|
|
|
|
public function testCanWaitOnErroredPromises()
|
|
{
|
|
$p1 = new P\Promise(function () use (&$p1) { $p1->reject('a'); });
|
|
$p2 = new P\Promise(function () use (&$p2) { $p2->resolve('b'); });
|
|
$p3 = new P\Promise(function () use (&$p3) { $p3->resolve('c'); });
|
|
$p4 = new P\Promise(function () use (&$p4) { $p4->reject('d'); });
|
|
$p5 = new P\Promise(function () use (&$p5) { $p5->resolve('e'); });
|
|
$p6 = new P\Promise(function () use (&$p6) { $p6->reject('f'); });
|
|
|
|
$co = P\coroutine(function() use ($p1, $p2, $p3, $p4, $p5, $p6) {
|
|
try {
|
|
yield $p1;
|
|
} catch (\Exception $e) {
|
|
yield $p2;
|
|
try {
|
|
yield $p3;
|
|
yield $p4;
|
|
} catch (\Exception $e) {
|
|
yield $p5;
|
|
yield $p6;
|
|
}
|
|
}
|
|
});
|
|
|
|
$res = P\inspect($co);
|
|
$this->assertEquals('f', $res['reason']);
|
|
}
|
|
|
|
public function testCoroutineOtherwiseIntegrationTest()
|
|
{
|
|
$a = new P\Promise();
|
|
$b = new P\Promise();
|
|
$promise = P\coroutine(function () use ($a, $b) {
|
|
// Execute the pool of commands concurrently, and process errors.
|
|
yield $a;
|
|
yield $b;
|
|
})->otherwise(function (\Exception $e) {
|
|
// Throw errors from the operations as a specific Multipart error.
|
|
throw new \OutOfBoundsException('a', 0, $e);
|
|
});
|
|
$a->resolve('a');
|
|
$b->reject('b');
|
|
$reason = P\inspect($promise)['reason'];
|
|
$this->assertInstanceOf('OutOfBoundsException', $reason);
|
|
$this->assertInstanceOf('GuzzleHttp\Promise\RejectionException', $reason->getPrevious());
|
|
}
|
|
}
|