← Back to branch summary

~tcuthbert/wordpress/openstack-objectstorage

« back to all changes in this revision

Viewing changes to vendor/guzzlehttp/guzzle/tests/Adapter/Curl/CurlFactoryTest.php

  • Committer: Jacek Nykis
  • Date: 2015-02-11 15:35:31 UTC
  • Revision ID: jacek.nykis@canonical.com-20150211153531-hmy6zi0ov2qfkl0b
Initial commit

Show diffs side-by-side

added added

removed removed

Lines of Context:
vendor/guzzlehttp/guzzle/tests/Adapter/Curl/CurlFactoryTest.php
 
1
<?php
 
2
 
 
3
// Override curl_setopt_array() to get the last set curl options
 
4
namespace GuzzleHttp\Adapter\Curl
 
5
{
 
6
    function curl_setopt_array($handle, array $options)
 
7
    {
 
8
        if (array_values($options) != [null, null, null, null]) {
 
9
            $_SERVER['last_curl'] = $options;
 
10
        }
 
11
        \curl_setopt_array($handle, $options);
 
12
    }
 
13
}
 
14
 
 
15
namespace GuzzleHttp\Tests\Adapter\Curl {
 
16
 
 
17
    use GuzzleHttp\Adapter\Curl\CurlFactory;
 
18
    use GuzzleHttp\Adapter\Curl\MultiAdapter;
 
19
    use GuzzleHttp\Adapter\Transaction;
 
20
    use GuzzleHttp\Client;
 
21
    use GuzzleHttp\Event\BeforeEvent;
 
22
    use GuzzleHttp\Exception\ServerException;
 
23
    use GuzzleHttp\Message\MessageFactory;
 
24
    use GuzzleHttp\Message\Request;
 
25
    use GuzzleHttp\Message\RequestInterface;
 
26
    use GuzzleHttp\Stream\Stream;
 
27
    use GuzzleHttp\Tests\Server;
 
28
 
 
29
    /**
 
30
     * @covers GuzzleHttp\Adapter\Curl\CurlFactory
 
31
     */
 
32
    class CurlFactoryTest extends \PHPUnit_Framework_TestCase
 
33
    {
 
34
        /** @var \GuzzleHttp\Tests\Server */
 
35
        static $server;
 
36
 
 
37
        public static function setUpBeforeClass()
 
38
        {
 
39
            unset($_SERVER['last_curl']);
 
40
        }
 
41
 
 
42
        public static function tearDownAfterClass()
 
43
        {
 
44
            unset($_SERVER['last_curl']);
 
45
        }
 
46
 
 
47
        public function testCreatesCurlHandle()
 
48
        {
 
49
            Server::flush();
 
50
            Server::enqueue(["HTTP/1.1 200 OK\r\nFoo: Bar\r\n Baz:  bam\r\nContent-Length: 2\r\n\r\nhi"]);
 
51
            $request = new Request(
 
52
                'PUT',
 
53
                Server::$url . 'haha',
 
54
                ['Hi' => ' 123'],
 
55
                Stream::factory('testing')
 
56
            );
 
57
            $stream = Stream::factory();
 
58
            $request->getConfig()->set('save_to', $stream);
 
59
            $request->getConfig()->set('verify', true);
 
60
            $this->emit($request);
 
61
 
 
62
            $t = new Transaction(new Client(), $request);
 
63
            $f = new CurlFactory();
 
64
            $h = $f($t, new MessageFactory());
 
65
            $this->assertInternalType('resource', $h);
 
66
            curl_exec($h);
 
67
            $response = $t->getResponse();
 
68
            $this->assertInstanceOf('GuzzleHttp\Message\ResponseInterface', $response);
 
69
            $this->assertEquals('hi', $response->getBody());
 
70
            $this->assertEquals('Bar', $response->getHeader('Foo'));
 
71
            $this->assertEquals('bam', $response->getHeader('Baz'));
 
72
            curl_close($h);
 
73
 
 
74
            $sent = Server::received(true)[0];
 
75
            $this->assertEquals('PUT', $sent->getMethod());
 
76
            $this->assertEquals('/haha', $sent->getPath());
 
77
            $this->assertEquals('123', $sent->getHeader('Hi'));
 
78
            $this->assertEquals('7', $sent->getHeader('Content-Length'));
 
79
            $this->assertEquals('testing', $sent->getBody());
 
80
            $this->assertEquals('1.1', $sent->getProtocolVersion());
 
81
            $this->assertEquals('hi', (string) $stream);
 
82
 
 
83
            $this->assertEquals(true, $_SERVER['last_curl'][CURLOPT_SSL_VERIFYPEER]);
 
84
            $this->assertEquals(2, $_SERVER['last_curl'][CURLOPT_SSL_VERIFYHOST]);
 
85
        }
 
86
 
 
87
        public function testSendsHeadRequests()
 
88
        {
 
89
            Server::flush();
 
90
            Server::enqueue(["HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\n"]);
 
91
            $request = new Request('HEAD', Server::$url);
 
92
            $this->emit($request);
 
93
 
 
94
            $t = new Transaction(new Client(), $request);
 
95
            $f = new CurlFactory();
 
96
            $h = $f($t, new MessageFactory());
 
97
            curl_exec($h);
 
98
            curl_close($h);
 
99
            $response = $t->getResponse();
 
100
            $this->assertEquals('2', $response->getHeader('Content-Length'));
 
101
            $this->assertEquals('', $response->getBody());
 
102
 
 
103
            $sent = Server::received(true)[0];
 
104
            $this->assertEquals('HEAD', $sent->getMethod());
 
105
            $this->assertEquals('/', $sent->getPath());
 
106
        }
 
107
 
 
108
        public function testSendsPostRequestWithNoBody()
 
109
        {
 
110
            Server::flush();
 
111
            Server::enqueue(["HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n"]);
 
112
            $request = new Request('POST', Server::$url);
 
113
            $this->emit($request);
 
114
            $t = new Transaction(new Client(), $request);
 
115
            $f = new CurlFactory();
 
116
            $h = $f($t, new MessageFactory());
 
117
            curl_exec($h);
 
118
            curl_close($h);
 
119
            $sent = Server::received(true)[0];
 
120
            $this->assertEquals('POST', $sent->getMethod());
 
121
            $this->assertEquals('', $sent->getBody());
 
122
        }
 
123
 
 
124
        public function testSendsChunkedRequests()
 
125
        {
 
126
            $stream = $this->getMockBuilder('GuzzleHttp\Stream\Stream')
 
127
                ->setConstructorArgs([fopen('php://temp', 'r+')])
 
128
                ->setMethods(['getSize'])
 
129
                ->getMock();
 
130
            $stream->expects($this->any())
 
131
                ->method('getSize')
 
132
                ->will($this->returnValue(null));
 
133
            $stream->write('foo');
 
134
            $stream->seek(0);
 
135
 
 
136
            Server::flush();
 
137
            Server::enqueue(["HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n"]);
 
138
            $request = new Request('PUT', Server::$url, [], $stream);
 
139
            $this->emit($request);
 
140
            $this->assertNull($request->getBody()->getSize());
 
141
            $t = new Transaction(new Client(), $request);
 
142
            $f = new CurlFactory();
 
143
            $h = $f($t, new MessageFactory());
 
144
            curl_exec($h);
 
145
            curl_close($h);
 
146
            $sent = Server::received(false)[0];
 
147
            $this->assertContains('PUT / HTTP/1.1', $sent);
 
148
            $this->assertContains('transfer-encoding: chunked', strtolower($sent));
 
149
            $this->assertContains("\r\n\r\nfoo", $sent);
 
150
        }
 
151
 
 
152
        public function testDecodesGzippedResponses()
 
153
        {
 
154
            Server::flush();
 
155
            $content = gzencode('test');
 
156
            $message = "HTTP/1.1 200 OK\r\n"
 
157
                . "Content-Encoding: gzip\r\n"
 
158
                . "Content-Length: " . strlen($content) . "\r\n\r\n"
 
159
                . $content;
 
160
            Server::enqueue($message);
 
161
            $client = new Client();
 
162
            $request = $client->createRequest('GET', Server::$url);
 
163
            $this->emit($request);
 
164
            $t = new Transaction($client, $request);
 
165
            $f = new CurlFactory();
 
166
            $h = $f($t, new MessageFactory());
 
167
            curl_exec($h);
 
168
            curl_close($h);
 
169
            $sent = Server::received(true)[0];
 
170
            $this->assertSame('', $sent->getHeader('Accept-Encoding'));
 
171
            $this->assertEquals('test', (string) $t->getResponse()->getBody());
 
172
        }
 
173
 
 
174
        public function testDecodesWithCustomAcceptHeader()
 
175
        {
 
176
            Server::flush();
 
177
            $content = gzencode('test');
 
178
            $message = "HTTP/1.1 200 OK\r\n"
 
179
                . "Content-Encoding: gzip\r\n"
 
180
                . "Content-Length: " . strlen($content) . "\r\n\r\n"
 
181
                . $content;
 
182
            Server::enqueue($message);
 
183
            $client = new Client();
 
184
            $request = $client->createRequest('GET', Server::$url, [
 
185
                'decode_content' => 'gzip'
 
186
            ]);
 
187
            $this->emit($request);
 
188
            $t = new Transaction($client, $request);
 
189
            $f = new CurlFactory();
 
190
            $h = $f($t, new MessageFactory());
 
191
            curl_exec($h);
 
192
            curl_close($h);
 
193
            $sent = Server::received(true)[0];
 
194
            $this->assertSame('gzip', $sent->getHeader('Accept-Encoding'));
 
195
            $this->assertEquals('test', (string) $t->getResponse()->getBody());
 
196
        }
 
197
 
 
198
        public function testDoesNotForceDecode()
 
199
        {
 
200
            Server::flush();
 
201
            $content = gzencode('test');
 
202
            $message = "HTTP/1.1 200 OK\r\n"
 
203
                . "Content-Encoding: gzip\r\n"
 
204
                . "Content-Length: " . strlen($content) . "\r\n\r\n"
 
205
                . $content;
 
206
            Server::enqueue($message);
 
207
            $client = new Client();
 
208
            $request = $client->createRequest('GET', Server::$url, [
 
209
                'headers'        => ['Accept-Encoding' => 'gzip'],
 
210
                'decode_content' => false
 
211
            ]);
 
212
            $this->emit($request);
 
213
            $t = new Transaction($client, $request);
 
214
            $f = new CurlFactory();
 
215
            $h = $f($t, new MessageFactory());
 
216
            curl_exec($h);
 
217
            curl_close($h);
 
218
            $sent = Server::received(true)[0];
 
219
            $this->assertSame('gzip', $sent->getHeader('Accept-Encoding'));
 
220
            $this->assertSame($content, (string) $t->getResponse()->getBody());
 
221
        }
 
222
 
 
223
        public function testAddsDebugInfoToBuffer()
 
224
        {
 
225
            $r = fopen('php://temp', 'r+');
 
226
            Server::flush();
 
227
            Server::enqueue(["HTTP/1.1 200 OK\r\nContent-Length: 3\r\n\r\nfoo"]);
 
228
            $request = new Request('GET', Server::$url);
 
229
            $request->getConfig()->set('debug', $r);
 
230
            $this->emit($request);
 
231
            $t = new Transaction(new Client(), $request);
 
232
            $f = new CurlFactory();
 
233
            $h = $f($t, new MessageFactory());
 
234
            curl_exec($h);
 
235
            curl_close($h);
 
236
            rewind($r);
 
237
            $this->assertNotEmpty(stream_get_contents($r));
 
238
        }
 
239
 
 
240
        public function testAddsProxyOptions()
 
241
        {
 
242
            $request = new Request('GET', Server::$url);
 
243
            $this->emit($request);
 
244
            $request->getConfig()->set('proxy', '123');
 
245
            $request->getConfig()->set('connect_timeout', 1);
 
246
            $request->getConfig()->set('timeout', 2);
 
247
            $request->getConfig()->set('cert', __FILE__);
 
248
            $request->getConfig()->set('ssl_key', [__FILE__, '123']);
 
249
            $request->getConfig()->set('verify', false);
 
250
            $t = new Transaction(new Client(), $request);
 
251
            $f = new CurlFactory();
 
252
            curl_close($f($t, new MessageFactory()));
 
253
            $this->assertEquals('123', $_SERVER['last_curl'][CURLOPT_PROXY]);
 
254
            $this->assertEquals(1000, $_SERVER['last_curl'][CURLOPT_CONNECTTIMEOUT_MS]);
 
255
            $this->assertEquals(2000, $_SERVER['last_curl'][CURLOPT_TIMEOUT_MS]);
 
256
            $this->assertEquals(__FILE__, $_SERVER['last_curl'][CURLOPT_SSLCERT]);
 
257
            $this->assertEquals(__FILE__, $_SERVER['last_curl'][CURLOPT_SSLKEY]);
 
258
            $this->assertEquals('123', $_SERVER['last_curl'][CURLOPT_SSLKEYPASSWD]);
 
259
            $this->assertEquals(0, $_SERVER['last_curl'][CURLOPT_SSL_VERIFYHOST]);
 
260
            $this->assertEquals(false, $_SERVER['last_curl'][CURLOPT_SSL_VERIFYPEER]);
 
261
        }
 
262
 
 
263
        /**
 
264
         * @expectedException \RuntimeException
 
265
         */
 
266
        public function testEnsuresCertExists()
 
267
        {
 
268
            $request = new Request('GET', Server::$url);
 
269
            $this->emit($request);
 
270
            $request->getConfig()->set('cert', __FILE__ . 'ewfwef');
 
271
            $f = new CurlFactory();
 
272
            $f(new Transaction(new Client(), $request), new MessageFactory());
 
273
        }
 
274
 
 
275
        /**
 
276
         * @expectedException \RuntimeException
 
277
         */
 
278
        public function testEnsuresKeyExists()
 
279
        {
 
280
            $request = new Request('GET', Server::$url);
 
281
            $this->emit($request);
 
282
            $request->getConfig()->set('ssl_key', __FILE__ . 'ewfwef');
 
283
            $f = new CurlFactory();
 
284
            $f(new Transaction(new Client(), $request), new MessageFactory());
 
285
        }
 
286
 
 
287
        /**
 
288
         * @expectedException \RuntimeException
 
289
         */
 
290
        public function testEnsuresCacertExists()
 
291
        {
 
292
            $request = new Request('GET', Server::$url);
 
293
            $this->emit($request);
 
294
            $request->getConfig()->set('verify', __FILE__ . 'ewfwef');
 
295
            $f = new CurlFactory();
 
296
            $f(new Transaction(new Client(), $request), new MessageFactory());
 
297
        }
 
298
 
 
299
        public function testClientUsesSslByDefault()
 
300
        {
 
301
            Server::flush();
 
302
            Server::enqueue(["HTTP/1.1 200 OK\r\nContent-Length: 3\r\n\r\nfoo"]);
 
303
            $f = new CurlFactory();
 
304
            $client = new Client([
 
305
                'base_url' => Server::$url,
 
306
                'adapter' => new MultiAdapter(new MessageFactory(), ['handle_factory' => $f])
 
307
            ]);
 
308
            $client->get();
 
309
            $this->assertEquals(2, $_SERVER['last_curl'][CURLOPT_SSL_VERIFYHOST]);
 
310
            $this->assertEquals(true, $_SERVER['last_curl'][CURLOPT_SSL_VERIFYPEER]);
 
311
            $this->assertFileExists($_SERVER['last_curl'][CURLOPT_CAINFO]);
 
312
        }
 
313
 
 
314
        public function testConvertsConstantNameKeysToValues()
 
315
        {
 
316
            $request = new Request('GET', Server::$url);
 
317
            $request->getConfig()->set('curl', ['CURLOPT_USERAGENT' => 'foo']);
 
318
            $this->emit($request);
 
319
            $f = new CurlFactory();
 
320
            curl_close($f(new Transaction(new Client(), $request), new MessageFactory()));
 
321
            $this->assertEquals('foo', $_SERVER['last_curl'][CURLOPT_USERAGENT]);
 
322
        }
 
323
 
 
324
        public function testStripsFragment()
 
325
        {
 
326
            $request = new Request('GET', Server::$url . '#foo');
 
327
            $this->emit($request);
 
328
            $f = new CurlFactory();
 
329
            curl_close($f(new Transaction(new Client(), $request), new MessageFactory()));
 
330
            $this->assertEquals(Server::$url, $_SERVER['last_curl'][CURLOPT_URL]);
 
331
        }
 
332
 
 
333
        public function testDoesNotSendSizeTwice()
 
334
        {
 
335
            $request = new Request('PUT', Server::$url, [], Stream::factory(str_repeat('a', 32769)));
 
336
            $this->emit($request);
 
337
            $f = new CurlFactory();
 
338
            curl_close($f(new Transaction(new Client(), $request), new MessageFactory()));
 
339
            $this->assertEquals(32769, $_SERVER['last_curl'][CURLOPT_INFILESIZE]);
 
340
            $this->assertNotContains('Content-Length', implode(' ', $_SERVER['last_curl'][CURLOPT_HTTPHEADER]));
 
341
        }
 
342
 
 
343
        public function testCanSendPayloadWithGet()
 
344
        {
 
345
            Server::flush();
 
346
            Server::enqueue(["HTTP/1.1 200 OK\r\n\r\n"]);
 
347
            $request = new Request(
 
348
                'GET',
 
349
                Server::$url,
 
350
                [],
 
351
                Stream::factory('foo')
 
352
            );
 
353
            $this->emit($request);
 
354
            $t = new Transaction(new Client(), $request);
 
355
            $f = new CurlFactory();
 
356
            $h = $f($t, new MessageFactory());
 
357
            curl_exec($h);
 
358
            curl_close($h);
 
359
            $sent = Server::received(true)[0];
 
360
            $this->assertEquals('foo', (string) $sent->getBody());
 
361
            $this->assertEquals(3, (string) $sent->getHeader('Content-Length'));
 
362
        }
 
363
 
 
364
        private function emit(RequestInterface $request)
 
365
        {
 
366
            $event = new BeforeEvent(new Transaction(new Client(), $request));
 
367
            $request->getEmitter()->emit('before', $event);
 
368
        }
 
369
 
 
370
        public function testDoesNotAlwaysAddContentType()
 
371
        {
 
372
            Server::flush();
 
373
            Server::enqueue(["HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n"]);
 
374
            $client = new Client();
 
375
            $client->put(Server::$url . '/foo', ['body' => 'foo']);
 
376
            $request = Server::received(true)[0];
 
377
            $this->assertEquals('', $request->getHeader('Content-Type'));
 
378
        }
 
379
 
 
380
        /**
 
381
         * @expectedException \GuzzleHttp\Exception\AdapterException
 
382
         */
 
383
        public function testThrowsForStreamOption()
 
384
        {
 
385
            $request = new Request('GET', Server::$url . 'haha');
 
386
            $request->getConfig()->set('stream', true);
 
387
            $t = new Transaction(new Client(), $request);
 
388
            $f = new CurlFactory();
 
389
            $f($t, new MessageFactory());
 
390
        }
 
391
    }
 
392
}