Subversion Repositories php-qbpwcf

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
3 liveuser 1 
<?php
2 
 
3 
namespace React\Tests\Stream;
4 
 
5 
use React\Stream\BufferedSink;
6 
use React\Stream\ReadableStream;
7 
 
8 
/**
9 
 * @covers React\Stream\BufferedSink
10 
 */
11 
class BufferedSinkTest extends TestCase
12 
{
13 
    /** @test */
14 
    public function promiseShouldReturnPromise()
15 
    {
16 
        $sink = new BufferedSink();
17 
        $contents = $sink->promise();
18 
 
19 
        $this->assertInstanceOf('React\Promise\PromiseInterface', $contents);
20 
    }
21 
 
22 
    /** @test */
23 
    public function endShouldResolvePromiseWithBufferContents()
24 
    {
25 
        $callback = $this->expectCallableOnceWith('foo');
26 
 
27 
        $sink = new BufferedSink();
28 
        $sink
29 
            ->promise()
30 
            ->then($callback);
31 
 
32 
        $sink->write('foo');
33 
        $sink->end();
34 
    }
35 
 
36 
    /** @test */
37 
    public function closeWithEmptyBufferShouldResolveToEmptyString()
38 
    {
39 
        $callback = $this->expectCallableOnceWith('');
40 
 
41 
        $sink = new BufferedSink();
42 
        $sink
43 
            ->promise()
44 
            ->then($callback);
45 
 
46 
        $sink->close();
47 
        $sink->close();
48 
    }
49 
 
50 
    /** @test */
51 
    public function closeTwiceShouldBeFine()
52 
    {
53 
        $callback = $this->expectCallableOnce();
54 
 
55 
        $sink = new BufferedSink();
56 
        $sink
57 
            ->promise()
58 
            ->then($callback);
59 
 
60 
        $sink->close();
61 
        $sink->close();
62 
    }
63 
 
64 
    /** @test */
65 
    public function resovedValueShouldContainMultipleWrites()
66 
    {
67 
        $callback = $this->expectCallableOnceWith('foobarbaz');
68 
 
69 
        $sink = new BufferedSink();
70 
        $sink
71 
            ->promise()
72 
            ->then($callback);
73 
 
74 
        $sink->write('foo');
75 
        $sink->write('bar');
76 
        $sink->write('baz');
77 
        $sink->end();
78 
    }
79 
 
80 
    /** @test */
81 
    public function dataWrittenOnEndShouldBeBuffered()
82 
    {
83 
        $callback = $this->expectCallableOnceWith('foobar');
84 
 
85 
        $sink = new BufferedSink();
86 
        $sink
87 
            ->promise()
88 
            ->then($callback);
89 
 
90 
        $sink->write('foo');
91 
        $sink->end('bar');
92 
    }
93 
 
94 
    /** @test */
95 
    public function errorsShouldRejectPromise()
96 
    {
97 
        $errback = $this->expectCallableOnceWith($this->callback(function ($e) {
98 
            return $e instanceof \Exception && 'Shit happens' === $e->getMessage();
99 
        }));
100 
 
101 
        $sink = new BufferedSink();
102 
        $sink
103 
            ->promise()
104 
            ->then($this->expectCallableNever(), $errback);
105 
 
106 
        $sink->emit('error', array(new \Exception('Shit happens')));
107 
    }
108 
 
109 
    /** @test */
110 
    public function writeShouldTriggerProgressOnPromise()
111 
    {
112 
        $callback = $this->createCallableMock();
113 
        $callback
114 
            ->expects($this->at(0))
115 
            ->method('__invoke')
116 
            ->with('foo');
117 
        $callback
118 
            ->expects($this->at(1))
119 
            ->method('__invoke')
120 
            ->with('bar');
121 
        $callback
122 
            ->expects($this->at(2))
123 
            ->method('__invoke')
124 
            ->with('baz');
125 
 
126 
        $sink = new BufferedSink();
127 
        $sink
128 
            ->promise()
129 
            ->then(null, null, $callback);
130 
 
131 
        $sink->write('foo');
132 
        $sink->write('bar');
133 
        $sink->end('baz');
134 
    }
135 
 
136 
    /** @test */
137 
    public function forwardedErrorsFromPipeShouldRejectPromise()
138 
    {
139 
        $errback = $this->expectCallableOnceWith($this->callback(function ($e) {
140 
            return $e instanceof \Exception && 'Shit happens' === $e->getMessage();
141 
        }));
142 
 
143 
        $sink = new BufferedSink();
144 
        $sink
145 
            ->promise()
146 
            ->then($this->expectCallableNever(), $errback);
147 
 
148 
        $readable = new ReadableStream();
149 
        $readable->pipe($sink);
150 
        $readable->emit('error', array(new \Exception('Shit happens')));
151 
    }
152 
 
153 
    /** @test */
154 
    public function pipeShouldSucceedAndResolve()
155 
    {
156 
        $callback = $this->expectCallableOnceWith('foobar');
157 
 
158 
        $sink = new BufferedSink();
159 
        $sink
160 
            ->promise()
161 
            ->then($callback);
162 
 
163 
        $readable = new ReadableStream();
164 
        $readable->pipe($sink);
165 
        $readable->emit('data', array('foo'));
166 
        $readable->emit('data', array('bar'));
167 
        $readable->close();
168 
    }
169 
 
170 
    /** @test */
171 
    public function factoryMethodShouldImplicitlyPipeAndPromise()
172 
    {
173 
        $callback = $this->expectCallableOnceWith('foo');
174 
 
175 
        $readable = new ReadableStream();
176 
 
177 
        BufferedSink::createPromise($readable)
178 
            ->then($callback);
179 
 
180 
        $readable->emit('data', array('foo'));
181 
        $readable->close();
182 
    }
183 
 
184 
    private function expectCallableOnceWith($value)
185 
    {
186 
        $callback = $this->createCallableMock();
187 
        $callback
188 
            ->expects($this->once())
189 
            ->method('__invoke')
190 
            ->with($value);
191 
 
192 
        return $callback;
193 
    }
194 
}