Total Complexity | 59 |
Total Lines | 595 |
Duplicated Lines | 0 % |
Changes | 1 | ||
Bugs | 0 | Features | 0 |
Complex classes like FunctionsTest often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes.
Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.
While breaking up the class, it is a good idea to analyze how other classes use FunctionsTest, and based on these observations, apply Extract Interface, too.
1 | <?php |
||
8 | class FunctionsTest extends \PHPUnit_Framework_TestCase |
||
|
|||
9 | { |
||
10 | public function testCopiesToString() |
||
11 | { |
||
12 | $s = Psr7\stream_for('foobaz'); |
||
13 | $this->assertEquals('foobaz', Psr7\copy_to_string($s)); |
||
14 | $s->seek(0); |
||
15 | $this->assertEquals('foo', Psr7\copy_to_string($s, 3)); |
||
16 | $this->assertEquals('baz', Psr7\copy_to_string($s, 3)); |
||
17 | $this->assertEquals('', Psr7\copy_to_string($s)); |
||
18 | } |
||
19 | |||
20 | public function testCopiesToStringStopsWhenReadFails() |
||
21 | { |
||
22 | $s1 = Psr7\stream_for('foobaz'); |
||
23 | $s1 = FnStream::decorate($s1, array( |
||
24 | 'read' => function () { return ''; } |
||
25 | )); |
||
26 | $result = Psr7\copy_to_string($s1); |
||
27 | $this->assertEquals('', $result); |
||
28 | } |
||
29 | |||
30 | public function testCopiesToStream() |
||
31 | { |
||
32 | $s1 = Psr7\stream_for('foobaz'); |
||
33 | $s2 = Psr7\stream_for(''); |
||
34 | Psr7\copy_to_stream($s1, $s2); |
||
35 | $this->assertEquals('foobaz', (string) $s2); |
||
36 | $s2 = Psr7\stream_for(''); |
||
37 | $s1->seek(0); |
||
38 | Psr7\copy_to_stream($s1, $s2, 3); |
||
39 | $this->assertEquals('foo', (string) $s2); |
||
40 | Psr7\copy_to_stream($s1, $s2, 3); |
||
41 | $this->assertEquals('foobaz', (string) $s2); |
||
42 | } |
||
43 | |||
44 | public function testStopsCopyToStreamWhenWriteFails() |
||
45 | { |
||
46 | $s1 = Psr7\stream_for('foobaz'); |
||
47 | $s2 = Psr7\stream_for(''); |
||
48 | $s2 = FnStream::decorate($s2, array('write' => function () { return 0; })); |
||
49 | Psr7\copy_to_stream($s1, $s2); |
||
50 | $this->assertEquals('', (string) $s2); |
||
51 | } |
||
52 | |||
53 | public function testStopsCopyToSteamWhenWriteFailsWithMaxLen() |
||
54 | { |
||
55 | $s1 = Psr7\stream_for('foobaz'); |
||
56 | $s2 = Psr7\stream_for(''); |
||
57 | $s2 = FnStream::decorate($s2, array('write' => function () { return 0; })); |
||
58 | Psr7\copy_to_stream($s1, $s2, 10); |
||
59 | $this->assertEquals('', (string) $s2); |
||
60 | } |
||
61 | |||
62 | public function testStopsCopyToSteamWhenReadFailsWithMaxLen() |
||
63 | { |
||
64 | $s1 = Psr7\stream_for('foobaz'); |
||
65 | $s1 = FnStream::decorate($s1, array('read' => function () { return ''; })); |
||
66 | $s2 = Psr7\stream_for(''); |
||
67 | Psr7\copy_to_stream($s1, $s2, 10); |
||
68 | $this->assertEquals('', (string) $s2); |
||
69 | } |
||
70 | |||
71 | public function testReadsLines() |
||
72 | { |
||
73 | $s = Psr7\stream_for("foo\nbaz\nbar"); |
||
74 | $this->assertEquals("foo\n", Psr7\readline($s)); |
||
75 | $this->assertEquals("baz\n", Psr7\readline($s)); |
||
76 | $this->assertEquals("bar", Psr7\readline($s)); |
||
77 | } |
||
78 | |||
79 | public function testReadsLinesUpToMaxLength() |
||
80 | { |
||
81 | $s = Psr7\stream_for("12345\n"); |
||
82 | $this->assertEquals("123", Psr7\readline($s, 4)); |
||
83 | $this->assertEquals("45\n", Psr7\readline($s)); |
||
84 | } |
||
85 | |||
86 | public function testReadsLineUntilFalseReturnedFromRead() |
||
87 | { |
||
88 | $s = $this->getMockBuilder('RingCentral\Psr7\Stream') |
||
89 | ->setMethods(array('read', 'eof')) |
||
90 | ->disableOriginalConstructor() |
||
91 | ->getMock(); |
||
92 | $s->expects($this->exactly(2)) |
||
93 | ->method('read') |
||
94 | ->will($this->returnCallback(function () { |
||
95 | static $c = false; |
||
96 | if ($c) { |
||
97 | return false; |
||
98 | } |
||
99 | $c = true; |
||
100 | return 'h'; |
||
101 | })); |
||
102 | $s->expects($this->exactly(2)) |
||
103 | ->method('eof') |
||
104 | ->will($this->returnValue(false)); |
||
105 | $this->assertEquals("h", Psr7\readline($s)); |
||
106 | } |
||
107 | |||
108 | public function testCalculatesHash() |
||
109 | { |
||
110 | $s = Psr7\stream_for('foobazbar'); |
||
111 | $this->assertEquals(md5('foobazbar'), Psr7\hash($s, 'md5')); |
||
112 | } |
||
113 | |||
114 | /** |
||
115 | * @expectedException \RuntimeException |
||
116 | */ |
||
117 | public function testCalculatesHashThrowsWhenSeekFails() |
||
118 | { |
||
119 | $s = new NoSeekStream(Psr7\stream_for('foobazbar')); |
||
120 | $s->read(2); |
||
121 | Psr7\hash($s, 'md5'); |
||
122 | } |
||
123 | |||
124 | public function testCalculatesHashSeeksToOriginalPosition() |
||
125 | { |
||
126 | $s = Psr7\stream_for('foobazbar'); |
||
127 | $s->seek(4); |
||
128 | $this->assertEquals(md5('foobazbar'), Psr7\hash($s, 'md5')); |
||
129 | $this->assertEquals(4, $s->tell()); |
||
130 | } |
||
131 | |||
132 | public function testOpensFilesSuccessfully() |
||
133 | { |
||
134 | $r = Psr7\try_fopen(__FILE__, 'r'); |
||
135 | $this->assertInternalType('resource', $r); |
||
136 | fclose($r); |
||
137 | } |
||
138 | |||
139 | /** |
||
140 | * @expectedException \RuntimeException |
||
141 | * @expectedExceptionMessage Unable to open /path/to/does/not/exist using mode r |
||
142 | */ |
||
143 | public function testThrowsExceptionNotWarning() |
||
144 | { |
||
145 | Psr7\try_fopen('/path/to/does/not/exist', 'r'); |
||
146 | } |
||
147 | |||
148 | public function parseQueryProvider() |
||
149 | { |
||
150 | return array( |
||
151 | // Does not need to parse when the string is empty |
||
152 | array('', array()), |
||
153 | // Can parse mult-values items |
||
154 | array('q=a&q=b', array('q' => array('a', 'b'))), |
||
155 | // Can parse multi-valued items that use numeric indices |
||
156 | array('q[0]=a&q[1]=b', array('q[0]' => 'a', 'q[1]' => 'b')), |
||
157 | // Can parse duplicates and does not include numeric indices |
||
158 | array('q[]=a&q[]=b', array('q[]' => array('a', 'b'))), |
||
159 | // Ensures that the value of "q" is an array even though one value |
||
160 | array('q[]=a', array('q[]' => 'a')), |
||
161 | // Does not modify "." to "_" like PHP's parse_str() |
||
162 | array('q.a=a&q.b=b', array('q.a' => 'a', 'q.b' => 'b')), |
||
163 | // Can decode %20 to " " |
||
164 | array('q%20a=a%20b', array('q a' => 'a b')), |
||
165 | // Can parse funky strings with no values by assigning each to null |
||
166 | array('q&a', array('q' => null, 'a' => null)), |
||
167 | // Does not strip trailing equal signs |
||
168 | array('data=abc=', array('data' => 'abc=')), |
||
169 | // Can store duplicates without affecting other values |
||
170 | array('foo=a&foo=b&?µ=c', array('foo' => array('a', 'b'), '?µ' => 'c')), |
||
171 | // Sets value to null when no "=" is present |
||
172 | array('foo', array('foo' => null)), |
||
173 | // Preserves "0" keys. |
||
174 | array('0', array('0' => null)), |
||
175 | // Sets the value to an empty string when "=" is present |
||
176 | array('0=', array('0' => '')), |
||
177 | // Preserves falsey keys |
||
178 | array('var=0', array('var' => '0')), |
||
179 | array('a[b][c]=1&a[b][c]=2', array('a[b][c]' => array('1', '2'))), |
||
180 | array('a[b]=c&a[d]=e', array('a[b]' => 'c', 'a[d]' => 'e')), |
||
181 | // Ensure it doesn't leave things behind with repeated values |
||
182 | // Can parse mult-values items |
||
183 | array('q=a&q=b&q=c', array('q' => array('a', 'b', 'c'))), |
||
184 | ); |
||
185 | } |
||
186 | |||
187 | /** |
||
188 | * @dataProvider parseQueryProvider |
||
189 | */ |
||
190 | public function testParsesQueries($input, $output) |
||
191 | { |
||
192 | $result = Psr7\parse_query($input); |
||
193 | $this->assertSame($output, $result); |
||
194 | } |
||
195 | |||
196 | public function testDoesNotDecode() |
||
197 | { |
||
198 | $str = 'foo%20=bar'; |
||
199 | $data = Psr7\parse_query($str, false); |
||
200 | $this->assertEquals(array('foo%20' => 'bar'), $data); |
||
201 | } |
||
202 | |||
203 | /** |
||
204 | * @dataProvider parseQueryProvider |
||
205 | */ |
||
206 | public function testParsesAndBuildsQueries($input, $output) |
||
207 | { |
||
208 | $result = Psr7\parse_query($input, false); |
||
209 | $this->assertSame($input, Psr7\build_query($result, false)); |
||
210 | } |
||
211 | |||
212 | public function testEncodesWithRfc1738() |
||
213 | { |
||
214 | $str = Psr7\build_query(array('foo bar' => 'baz+'), PHP_QUERY_RFC1738); |
||
215 | $this->assertEquals('foo+bar=baz%2B', $str); |
||
216 | } |
||
217 | |||
218 | public function testEncodesWithRfc3986() |
||
219 | { |
||
220 | $str = Psr7\build_query(array('foo bar' => 'baz+'), PHP_QUERY_RFC3986); |
||
221 | $this->assertEquals('foo%20bar=baz%2B', $str); |
||
222 | } |
||
223 | |||
224 | public function testDoesNotEncode() |
||
225 | { |
||
226 | $str = Psr7\build_query(array('foo bar' => 'baz+'), false); |
||
227 | $this->assertEquals('foo bar=baz+', $str); |
||
228 | } |
||
229 | |||
230 | public function testCanControlDecodingType() |
||
231 | { |
||
232 | $result = Psr7\parse_query('var=foo+bar', PHP_QUERY_RFC3986); |
||
233 | $this->assertEquals('foo+bar', $result['var']); |
||
234 | $result = Psr7\parse_query('var=foo+bar', PHP_QUERY_RFC1738); |
||
235 | $this->assertEquals('foo bar', $result['var']); |
||
236 | } |
||
237 | |||
238 | public function testParsesRequestMessages() |
||
239 | { |
||
240 | $req = "GET /abc HTTP/1.0\r\nHost: foo.com\r\nFoo: Bar\r\nBaz: Bam\r\nBaz: Qux\r\n\r\nTest"; |
||
241 | $request = Psr7\parse_request($req); |
||
242 | $this->assertEquals('GET', $request->getMethod()); |
||
243 | $this->assertEquals('/abc', $request->getRequestTarget()); |
||
244 | $this->assertEquals('1.0', $request->getProtocolVersion()); |
||
245 | $this->assertEquals('foo.com', $request->getHeaderLine('Host')); |
||
246 | $this->assertEquals('Bar', $request->getHeaderLine('Foo')); |
||
247 | $this->assertEquals('Bam, Qux', $request->getHeaderLine('Baz')); |
||
248 | $this->assertEquals('Test', (string) $request->getBody()); |
||
249 | $this->assertEquals('http://foo.com/abc', (string) $request->getUri()); |
||
250 | } |
||
251 | |||
252 | public function testParsesRequestMessagesWithHttpsScheme() |
||
253 | { |
||
254 | $req = "PUT /abc?baz=bar HTTP/1.1\r\nHost: foo.com:443\r\n\r\n"; |
||
255 | $request = Psr7\parse_request($req); |
||
256 | $this->assertEquals('PUT', $request->getMethod()); |
||
257 | $this->assertEquals('/abc?baz=bar', $request->getRequestTarget()); |
||
258 | $this->assertEquals('1.1', $request->getProtocolVersion()); |
||
259 | $this->assertEquals('foo.com:443', $request->getHeaderLine('Host')); |
||
260 | $this->assertEquals('', (string) $request->getBody()); |
||
261 | $this->assertEquals('https://foo.com/abc?baz=bar', (string) $request->getUri()); |
||
262 | } |
||
263 | |||
264 | public function testParsesRequestMessagesWithUriWhenHostIsNotFirst() |
||
265 | { |
||
266 | $req = "PUT / HTTP/1.1\r\nFoo: Bar\r\nHost: foo.com\r\n\r\n"; |
||
267 | $request = Psr7\parse_request($req); |
||
268 | $this->assertEquals('PUT', $request->getMethod()); |
||
269 | $this->assertEquals('/', $request->getRequestTarget()); |
||
270 | $this->assertEquals('http://foo.com/', (string) $request->getUri()); |
||
271 | } |
||
272 | |||
273 | public function testParsesRequestMessagesWithFullUri() |
||
274 | { |
||
275 | $req = "GET https://www.google.com:443/search?q=foobar HTTP/1.1\r\nHost: www.google.com\r\n\r\n"; |
||
276 | $request = Psr7\parse_request($req); |
||
277 | $this->assertEquals('GET', $request->getMethod()); |
||
278 | $this->assertEquals('https://www.google.com:443/search?q=foobar', $request->getRequestTarget()); |
||
279 | $this->assertEquals('1.1', $request->getProtocolVersion()); |
||
280 | $this->assertEquals('www.google.com', $request->getHeaderLine('Host')); |
||
281 | $this->assertEquals('', (string) $request->getBody()); |
||
282 | $this->assertEquals('https://www.google.com/search?q=foobar', (string) $request->getUri()); |
||
283 | } |
||
284 | |||
285 | /** |
||
286 | * @expectedException \InvalidArgumentException |
||
287 | */ |
||
288 | public function testValidatesRequestMessages() |
||
289 | { |
||
290 | Psr7\parse_request("HTTP/1.1 200 OK\r\n\r\n"); |
||
291 | } |
||
292 | |||
293 | public function testParsesResponseMessages() |
||
294 | { |
||
295 | $res = "HTTP/1.0 200 OK\r\nFoo: Bar\r\nBaz: Bam\r\nBaz: Qux\r\n\r\nTest"; |
||
296 | $response = Psr7\parse_response($res); |
||
297 | $this->assertEquals(200, $response->getStatusCode()); |
||
298 | $this->assertEquals('OK', $response->getReasonPhrase()); |
||
299 | $this->assertEquals('1.0', $response->getProtocolVersion()); |
||
300 | $this->assertEquals('Bar', $response->getHeaderLine('Foo')); |
||
301 | $this->assertEquals('Bam, Qux', $response->getHeaderLine('Baz')); |
||
302 | $this->assertEquals('Test', (string) $response->getBody()); |
||
303 | } |
||
304 | |||
305 | /** |
||
306 | * @expectedException \InvalidArgumentException |
||
307 | */ |
||
308 | public function testValidatesResponseMessages() |
||
309 | { |
||
310 | Psr7\parse_response("GET / HTTP/1.1\r\n\r\n"); |
||
311 | } |
||
312 | |||
313 | public function testDetermineMimetype() |
||
314 | { |
||
315 | $this->assertNull(Psr7\mimetype_from_extension('not-a-real-extension')); |
||
316 | $this->assertEquals( |
||
317 | 'application/json', |
||
318 | Psr7\mimetype_from_extension('json') |
||
319 | ); |
||
320 | $this->assertEquals( |
||
321 | 'image/jpeg', |
||
322 | Psr7\mimetype_from_filename('/tmp/images/IMG034821.JPEG') |
||
323 | ); |
||
324 | } |
||
325 | |||
326 | public function testCreatesUriForValue() |
||
327 | { |
||
328 | $this->assertInstanceOf('RingCentral\Psr7\Uri', Psr7\uri_for('/foo')); |
||
329 | $this->assertInstanceOf( |
||
330 | 'RingCentral\Psr7\Uri', |
||
331 | Psr7\uri_for(new Psr7\Uri('/foo')) |
||
332 | ); |
||
333 | } |
||
334 | |||
335 | /** |
||
336 | * @expectedException \InvalidArgumentException |
||
337 | */ |
||
338 | public function testValidatesUri() |
||
339 | { |
||
340 | Psr7\uri_for(array()); |
||
341 | } |
||
342 | |||
343 | public function testKeepsPositionOfResource() |
||
344 | { |
||
345 | $h = fopen(__FILE__, 'r'); |
||
346 | fseek($h, 10); |
||
347 | $stream = Psr7\stream_for($h); |
||
348 | $this->assertEquals(10, $stream->tell()); |
||
349 | $stream->close(); |
||
350 | } |
||
351 | |||
352 | public function testCreatesWithFactory() |
||
353 | { |
||
354 | $stream = Psr7\stream_for('foo'); |
||
355 | $this->assertInstanceOf('RingCentral\Psr7\Stream', $stream); |
||
356 | $this->assertEquals('foo', $stream->getContents()); |
||
357 | $stream->close(); |
||
358 | } |
||
359 | |||
360 | public function testFactoryCreatesFromEmptyString() |
||
361 | { |
||
362 | $s = Psr7\stream_for(); |
||
363 | $this->assertInstanceOf('RingCentral\Psr7\Stream', $s); |
||
364 | } |
||
365 | |||
366 | public function testFactoryCreatesFromNull() |
||
367 | { |
||
368 | $s = Psr7\stream_for(null); |
||
369 | $this->assertInstanceOf('RingCentral\Psr7\Stream', $s); |
||
370 | } |
||
371 | |||
372 | public function testFactoryCreatesFromResource() |
||
373 | { |
||
374 | $r = fopen(__FILE__, 'r'); |
||
375 | $s = Psr7\stream_for($r); |
||
376 | $this->assertInstanceOf('RingCentral\Psr7\Stream', $s); |
||
377 | $this->assertSame(file_get_contents(__FILE__), (string) $s); |
||
378 | } |
||
379 | |||
380 | public function testFactoryCreatesFromObjectWithToString() |
||
381 | { |
||
382 | $r = new HasToString(); |
||
383 | $s = Psr7\stream_for($r); |
||
384 | $this->assertInstanceOf('RingCentral\Psr7\Stream', $s); |
||
385 | $this->assertEquals('foo', (string) $s); |
||
386 | } |
||
387 | |||
388 | public function testCreatePassesThrough() |
||
389 | { |
||
390 | $s = Psr7\stream_for('foo'); |
||
391 | $this->assertSame($s, Psr7\stream_for($s)); |
||
392 | } |
||
393 | |||
394 | /** |
||
395 | * @expectedException \InvalidArgumentException |
||
396 | */ |
||
397 | public function testThrowsExceptionForUnknown() |
||
398 | { |
||
399 | Psr7\stream_for(new \stdClass()); |
||
400 | } |
||
401 | |||
402 | public function testReturnsCustomMetadata() |
||
403 | { |
||
404 | $s = Psr7\stream_for('foo', array('metadata' => array('hwm' => 3))); |
||
405 | $this->assertEquals(3, $s->getMetadata('hwm')); |
||
406 | $this->assertArrayHasKey('hwm', $s->getMetadata()); |
||
407 | } |
||
408 | |||
409 | public function testCanSetSize() |
||
410 | { |
||
411 | $s = Psr7\stream_for('', array('size' => 10)); |
||
412 | $this->assertEquals(10, $s->getSize()); |
||
413 | } |
||
414 | |||
415 | public function testCanCreateIteratorBasedStream() |
||
416 | { |
||
417 | $a = new \ArrayIterator(array('foo', 'bar', '123')); |
||
418 | $p = Psr7\stream_for($a); |
||
419 | $this->assertInstanceOf('RingCentral\Psr7\PumpStream', $p); |
||
420 | $this->assertEquals('foo', $p->read(3)); |
||
421 | $this->assertFalse($p->eof()); |
||
422 | $this->assertEquals('b', $p->read(1)); |
||
423 | $this->assertEquals('a', $p->read(1)); |
||
424 | $this->assertEquals('r12', $p->read(3)); |
||
425 | $this->assertFalse($p->eof()); |
||
426 | $this->assertEquals('3', $p->getContents()); |
||
427 | $this->assertTrue($p->eof()); |
||
428 | $this->assertEquals(9, $p->tell()); |
||
429 | } |
||
430 | |||
431 | public function testConvertsRequestsToStrings() |
||
432 | { |
||
433 | $request = new Psr7\Request('PUT', 'http://foo.com/hi?123', array( |
||
434 | 'Baz' => 'bar', |
||
435 | 'Qux' => ' ipsum' |
||
436 | ), 'hello', '1.0'); |
||
437 | $this->assertEquals( |
||
438 | "PUT /hi?123 HTTP/1.0\r\nHost: foo.com\r\nBaz: bar\r\nQux: ipsum\r\n\r\nhello", |
||
439 | Psr7\str($request) |
||
440 | ); |
||
441 | } |
||
442 | |||
443 | public function testConvertsResponsesToStrings() |
||
444 | { |
||
445 | $response = new Psr7\Response(200, array( |
||
446 | 'Baz' => 'bar', |
||
447 | 'Qux' => ' ipsum' |
||
448 | ), 'hello', '1.0', 'FOO'); |
||
449 | $this->assertEquals( |
||
450 | "HTTP/1.0 200 FOO\r\nBaz: bar\r\nQux: ipsum\r\n\r\nhello", |
||
451 | Psr7\str($response) |
||
452 | ); |
||
453 | } |
||
454 | |||
455 | public function parseParamsProvider() |
||
456 | { |
||
457 | $res1 = array( |
||
458 | array( |
||
459 | '<http:/.../front.jpeg>', |
||
460 | 'rel' => 'front', |
||
461 | 'type' => 'image/jpeg', |
||
462 | ), |
||
463 | array( |
||
464 | '<http://.../back.jpeg>', |
||
465 | 'rel' => 'back', |
||
466 | 'type' => 'image/jpeg', |
||
467 | ), |
||
468 | ); |
||
469 | return array( |
||
470 | array( |
||
471 | '<http:/.../front.jpeg>; rel="front"; type="image/jpeg", <http://.../back.jpeg>; rel=back; type="image/jpeg"', |
||
472 | $res1 |
||
473 | ), |
||
474 | array( |
||
475 | '<http:/.../front.jpeg>; rel="front"; type="image/jpeg",<http://.../back.jpeg>; rel=back; type="image/jpeg"', |
||
476 | $res1 |
||
477 | ), |
||
478 | array( |
||
479 | 'foo="baz"; bar=123, boo, test="123", foobar="foo;bar"', |
||
480 | array( |
||
481 | array('foo' => 'baz', 'bar' => '123'), |
||
482 | array('boo'), |
||
483 | array('test' => '123'), |
||
484 | array('foobar' => 'foo;bar') |
||
485 | ) |
||
486 | ), |
||
487 | array( |
||
488 | '<http://.../side.jpeg?test=1>; rel="side"; type="image/jpeg",<http://.../side.jpeg?test=2>; rel=side; type="image/jpeg"', |
||
489 | array( |
||
490 | array('<http://.../side.jpeg?test=1>', 'rel' => 'side', 'type' => 'image/jpeg'), |
||
491 | array('<http://.../side.jpeg?test=2>', 'rel' => 'side', 'type' => 'image/jpeg') |
||
492 | ) |
||
493 | ), |
||
494 | array( |
||
495 | '', |
||
496 | array() |
||
497 | ) |
||
498 | ); |
||
499 | } |
||
500 | /** |
||
501 | * @dataProvider parseParamsProvider |
||
502 | */ |
||
503 | public function testParseParams($header, $result) |
||
506 | } |
||
507 | |||
508 | public function testParsesArrayHeaders() |
||
512 | } |
||
513 | |||
514 | public function testRewindsBody() |
||
515 | { |
||
516 | $body = Psr7\stream_for('abc'); |
||
517 | $res = new Psr7\Response(200, array(), $body); |
||
518 | Psr7\rewind_body($res); |
||
519 | $this->assertEquals(0, $body->tell()); |
||
520 | $body->rewind(1); |
||
521 | Psr7\rewind_body($res); |
||
522 | $this->assertEquals(0, $body->tell()); |
||
523 | } |
||
524 | |||
525 | /** |
||
526 | * @expectedException \RuntimeException |
||
527 | */ |
||
528 | public function testThrowsWhenBodyCannotBeRewound() |
||
537 | } |
||
538 | |||
539 | public function testCanModifyRequestWithUri() |
||
540 | { |
||
541 | $r1 = new Psr7\Request('GET', 'http://foo.com'); |
||
542 | $r2 = Psr7\modify_request($r1, array( |
||
543 | 'uri' => new Psr7\Uri('http://www.foo.com') |
||
544 | )); |
||
545 | $this->assertEquals('http://www.foo.com', (string) $r2->getUri()); |
||
546 | $this->assertEquals('www.foo.com', (string) $r2->getHeaderLine('host')); |
||
547 | } |
||
548 | |||
549 | public function testCanModifyRequestWithCaseInsensitiveHeader() |
||
550 | { |
||
551 | $r1 = new Psr7\Request('GET', 'http://foo.com', array('User-Agent' => 'foo')); |
||
552 | $r2 = Psr7\modify_request($r1, array('set_headers' => array('User-agent' => 'bar'))); |
||
553 | $this->assertEquals('bar', $r2->getHeaderLine('User-Agent')); |
||
554 | $this->assertEquals('bar', $r2->getHeaderLine('User-agent')); |
||
555 | } |
||
556 | |||
557 | public function testReturnsAsIsWhenNoChanges() |
||
558 | { |
||
559 | $request = new Psr7\Request('GET', 'http://foo.com'); |
||
560 | $this->assertSame($request, Psr7\modify_request($request, array())); |
||
561 | } |
||
562 | |||
563 | public function testReturnsUriAsIsWhenNoChanges() |
||
564 | { |
||
565 | $r1 = new Psr7\Request('GET', 'http://foo.com'); |
||
566 | $r2 = Psr7\modify_request($r1, array('set_headers' => array('foo' => 'bar'))); |
||
567 | $this->assertNotSame($r1, $r2); |
||
568 | $this->assertEquals('bar', $r2->getHeaderLine('foo')); |
||
569 | } |
||
570 | |||
571 | public function testRemovesHeadersFromMessage() |
||
572 | { |
||
573 | $r1 = new Psr7\Request('GET', 'http://foo.com', array('foo' => 'bar')); |
||
574 | $r2 = Psr7\modify_request($r1, array('remove_headers' => array('foo'))); |
||
575 | $this->assertNotSame($r1, $r2); |
||
576 | $this->assertFalse($r2->hasHeader('foo')); |
||
577 | } |
||
578 | |||
579 | public function testAddsQueryToUri() |
||
580 | { |
||
581 | $r1 = new Psr7\Request('GET', 'http://foo.com'); |
||
582 | $r2 = Psr7\modify_request($r1, array('query' => 'foo=bar')); |
||
583 | $this->assertNotSame($r1, $r2); |
||
584 | $this->assertEquals('foo=bar', $r2->getUri()->getQuery()); |
||
585 | } |
||
586 | |||
587 | public function testServerRequestWithServerParams() |
||
588 | { |
||
589 | $requestString = "GET /abc HTTP/1.1\r\nHost: foo.com\r\n\r\n"; |
||
590 | $request = Psr7\parse_server_request($requestString); |
||
591 | |||
592 | $this->assertEquals(array(), $request->getServerParams()); |
||
593 | } |
||
594 | |||
595 | public function testServerRequestWithoutServerParams() |
||
603 | } |
||
604 | } |
||
605 |
The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g.
excluded_paths: ["lib/*"]
, you can move it to the dependency path list as follows:For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths