async/tests/WaterfallTest.php at 963a5a1e9c15af565c7fc83c0b758929c47743a6 · clue-labs/async · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
<?php

namespace React\Tests\Async;

use React;
use React\EventLoop\Loop;
use React\Promise\Promise;

class WaterfallTest extends TestCase
{
    public function testWaterfallWithoutTasks()
    {
        $tasks = array();

        $promise = React\Async\waterfall($tasks);

        $promise->then($this->expectCallableOnceWith(null));
    }

    public function testWaterfallWithTasks()
    {
        $tasks = array(
            function ($foo = 'foo') {
                return new Promise(function ($resolve) use ($foo) {
                    Loop::addTimer(0.05, function () use ($resolve, $foo) {
                        $resolve($foo);
                    });
                });
            },
            function ($foo) {
                return new Promise(function ($resolve) use ($foo) {
                    Loop::addTimer(0.05, function () use ($resolve, $foo) {
                        $resolve($foo . 'bar');
                    });
                });
            },
            function ($bar) {
                return new Promise(function ($resolve) use ($bar) {
                    Loop::addTimer(0.05, function () use ($resolve, $bar) {
                        $resolve($bar . 'baz');
                    });
                });
            },
        );

        $promise = React\Async\waterfall($tasks);

        $promise->then($this->expectCallableOnceWith('foobarbaz'));

        $timer = new Timer($this);
        $timer->start();

        Loop::run();

        $timer->stop();
        $timer->assertInRange(0.15, 0.30);
    }

    public function testWaterfallWithError()
    {
        $called = 0;

        $tasks = array(
            function () use (&$called) {
                $called++;
                return new Promise(function ($resolve) {
                    $resolve('foo');
                });
            },
            function ($foo) {
                return new Promise(function () {
                    throw new \RuntimeException('whoops');
                });
            },
            function () use (&$called) {
                $called++;
                return new Promise(function ($resolve) {
                    $resolve('bar');
                });
            },
        );

        $promise = React\Async\waterfall($tasks);

        $promise->then(null, $this->expectCallableOnceWith(new \RuntimeException('whoops')));

        $this->assertSame(1, $called);
    }

    public function testWaterfallWillCancelFirstPendingPromiseWhenCallingCancelOnResultingPromise()
    {
        $cancelled = 0;

        $tasks = array(
            function () {
                return new Promise(function ($resolve) {
                    $resolve(null);
                });
            },
            function () use (&$cancelled) {
                return new Promise(function () { }, function () use (&$cancelled) {
                    $cancelled++;
                });
            }
        );

        $promise = React\Async\waterfall($tasks);
        $promise->cancel();

        $this->assertSame(1, $cancelled);
    }
}