Your IP : 18.219.71.21
<?php
// Override curl_setopt_array() to get the last set curl options
namespace GuzzleHttp\Ring\Client {
function curl_setopt_array($handle, array $options) {
if (!empty($_SERVER['curl_test'])) {
$_SERVER['_curl'] = $options;
} else {
unset($_SERVER['_curl']);
}
\curl_setopt_array($handle, $options);
}
}
namespace GuzzleHttp\Tests\Ring\Client {
use GuzzleHttp\Ring\Client\CurlFactory;
use GuzzleHttp\Ring\Client\CurlMultiHandler;
use GuzzleHttp\Ring\Client\MockHandler;
use GuzzleHttp\Ring\Core;
use GuzzleHttp\Stream\FnStream;
use GuzzleHttp\Stream\NoSeekStream;
use GuzzleHttp\Stream\Stream;
class CurlFactoryTest extends \PHPUnit_Framework_TestCase
{
public static function setUpBeforeClass()
{
$_SERVER['curl_test'] = true;
unset($_SERVER['_curl']);
}
public static function tearDownAfterClass()
{
unset($_SERVER['_curl'], $_SERVER['curl_test']);
}
public function testCreatesCurlHandle()
{
Server::flush();
Server::enqueue([[
'status' => 200,
'headers' => [
'Foo' => ['Bar'],
'Baz' => ['bam'],
'Content-Length' => [2],
],
'body' => 'hi',
]]);
$stream = Stream::factory();
$request = [
'http_method' => 'PUT',
'headers' => [
'host' => [Server::$url],
'Hi' => [' 123'],
],
'body' => 'testing',
'client' => ['save_to' => $stream],
];
$f = new CurlFactory();
$result = $f($request);
$this->assertInternalType('array', $result);
$this->assertCount(3, $result);
$this->assertInternalType('resource', $result[0]);
$this->assertInternalType('array', $result[1]);
$this->assertSame($stream, $result[2]);
curl_close($result[0]);
$this->assertEquals('PUT', $_SERVER['_curl'][CURLOPT_CUSTOMREQUEST]);
$this->assertEquals(
'http://http://127.0.0.1:8125/',
$_SERVER['_curl'][CURLOPT_URL]
);
// Sends via post fields when the request is small enough
$this->assertEquals('testing', $_SERVER['_curl'][CURLOPT_POSTFIELDS]);
$this->assertEquals(0, $_SERVER['_curl'][CURLOPT_RETURNTRANSFER]);
$this->assertEquals(0, $_SERVER['_curl'][CURLOPT_HEADER]);
$this->assertEquals(150, $_SERVER['_curl'][CURLOPT_CONNECTTIMEOUT]);
$this->assertInstanceOf('Closure', $_SERVER['_curl'][CURLOPT_HEADERFUNCTION]);
if (defined('CURLOPT_PROTOCOLS')) {
$this->assertEquals(
CURLPROTO_HTTP | CURLPROTO_HTTPS,
$_SERVER['_curl'][CURLOPT_PROTOCOLS]
);
}
$this->assertContains('Expect:', $_SERVER['_curl'][CURLOPT_HTTPHEADER]);
$this->assertContains('Accept:', $_SERVER['_curl'][CURLOPT_HTTPHEADER]);
$this->assertContains('Content-Type:', $_SERVER['_curl'][CURLOPT_HTTPHEADER]);
$this->assertContains('Hi: 123', $_SERVER['_curl'][CURLOPT_HTTPHEADER]);
$this->assertContains('host: http://127.0.0.1:8125/', $_SERVER['_curl'][CURLOPT_HTTPHEADER]);
}
public function testSendsHeadRequests()
{
Server::flush();
Server::enqueue([['status' => 200]]);
$a = new CurlMultiHandler();
$response = $a([
'http_method' => 'HEAD',
'headers' => ['host' => [Server::$host]],
]);
$response->wait();
$this->assertEquals(true, $_SERVER['_curl'][CURLOPT_NOBODY]);
$checks = [CURLOPT_WRITEFUNCTION, CURLOPT_READFUNCTION, CURLOPT_FILE, CURLOPT_INFILE];
foreach ($checks as $check) {
$this->assertArrayNotHasKey($check, $_SERVER['_curl']);
}
$this->assertEquals('HEAD', Server::received()[0]['http_method']);
}
public function testCanAddCustomCurlOptions()
{
Server::flush();
Server::enqueue([['status' => 200]]);
$a = new CurlMultiHandler();
$a([
'http_method' => 'GET',
'headers' => ['host' => [Server::$host]],
'client' => ['curl' => [CURLOPT_LOW_SPEED_LIMIT => 10]],
]);
$this->assertEquals(10, $_SERVER['_curl'][CURLOPT_LOW_SPEED_LIMIT]);
}
/**
* @expectedException \InvalidArgumentException
* @expectedExceptionMessage SSL CA bundle not found: /does/not/exist
*/
public function testValidatesVerify()
{
$f = new CurlFactory();
$f([
'http_method' => 'GET',
'headers' => ['host' => ['foo.com']],
'client' => ['verify' => '/does/not/exist'],
]);
}
public function testCanSetVerifyToFile()
{
$f = new CurlFactory();
$f([
'http_method' => 'GET',
'headers' => ['host' => ['foo.com']],
'client' => ['verify' => __FILE__],
]);
$this->assertEquals(__FILE__, $_SERVER['_curl'][CURLOPT_CAINFO]);
$this->assertEquals(2, $_SERVER['_curl'][CURLOPT_SSL_VERIFYHOST]);
$this->assertEquals(true, $_SERVER['_curl'][CURLOPT_SSL_VERIFYPEER]);
}
public function testAddsVerifyAsTrue()
{
$f = new CurlFactory();
$f([
'http_method' => 'GET',
'headers' => ['host' => ['foo.com']],
'client' => ['verify' => true],
]);
$this->assertEquals(2, $_SERVER['_curl'][CURLOPT_SSL_VERIFYHOST]);
$this->assertEquals(true, $_SERVER['_curl'][CURLOPT_SSL_VERIFYPEER]);
$this->assertArrayNotHasKey(CURLOPT_CAINFO, $_SERVER['_curl']);
}
public function testCanDisableVerify()
{
$f = new CurlFactory();
$f([
'http_method' => 'GET',
'headers' => ['host' => ['foo.com']],
'client' => ['verify' => false],
]);
$this->assertEquals(0, $_SERVER['_curl'][CURLOPT_SSL_VERIFYHOST]);
$this->assertEquals(false, $_SERVER['_curl'][CURLOPT_SSL_VERIFYPEER]);
}
public function testAddsProxy()
{
$f = new CurlFactory();
$f([
'http_method' => 'GET',
'headers' => ['host' => ['foo.com']],
'client' => ['proxy' => 'http://bar.com'],
]);
$this->assertEquals('http://bar.com', $_SERVER['_curl'][CURLOPT_PROXY]);
}
public function testAddsViaScheme()
{
$f = new CurlFactory();
$f([
'http_method' => 'GET',
'scheme' => 'http',
'headers' => ['host' => ['foo.com']],
'client' => [
'proxy' => ['http' => 'http://bar.com', 'https' => 'https://t'],
],
]);
$this->assertEquals('http://bar.com', $_SERVER['_curl'][CURLOPT_PROXY]);
}
/**
* @expectedException \InvalidArgumentException
* @expectedExceptionMessage SSL private key not found: /does/not/exist
*/
public function testValidatesSslKey()
{
$f = new CurlFactory();
$f([
'http_method' => 'GET',
'headers' => ['host' => ['foo.com']],
'client' => ['ssl_key' => '/does/not/exist'],
]);
}
public function testAddsSslKey()
{
$f = new CurlFactory();
$f([
'http_method' => 'GET',
'headers' => ['host' => ['foo.com']],
'client' => ['ssl_key' => __FILE__],
]);
$this->assertEquals(__FILE__, $_SERVER['_curl'][CURLOPT_SSLKEY]);
}
public function testAddsSslKeyWithPassword()
{
$f = new CurlFactory();
$f([
'http_method' => 'GET',
'headers' => ['host' => ['foo.com']],
'client' => ['ssl_key' => [__FILE__, 'test']],
]);
$this->assertEquals(__FILE__, $_SERVER['_curl'][CURLOPT_SSLKEY]);
$this->assertEquals('test', $_SERVER['_curl'][CURLOPT_SSLKEYPASSWD]);
}
/**
* @expectedException \InvalidArgumentException
* @expectedExceptionMessage SSL certificate not found: /does/not/exist
*/
public function testValidatesCert()
{
$f = new CurlFactory();
$f([
'http_method' => 'GET',
'headers' => ['host' => ['foo.com']],
'client' => ['cert' => '/does/not/exist'],
]);
}
public function testAddsCert()
{
$f = new CurlFactory();
$f([
'http_method' => 'GET',
'headers' => ['host' => ['foo.com']],
'client' => ['cert' => __FILE__],
]);
$this->assertEquals(__FILE__, $_SERVER['_curl'][CURLOPT_SSLCERT]);
}
public function testAddsCertWithPassword()
{
$f = new CurlFactory();
$f([
'http_method' => 'GET',
'headers' => ['host' => ['foo.com']],
'client' => ['cert' => [__FILE__, 'test']],
]);
$this->assertEquals(__FILE__, $_SERVER['_curl'][CURLOPT_SSLCERT]);
$this->assertEquals('test', $_SERVER['_curl'][CURLOPT_SSLCERTPASSWD]);
}
/**
* @expectedException \InvalidArgumentException
* @expectedExceptionMessage progress client option must be callable
*/
public function testValidatesProgress()
{
$f = new CurlFactory();
$f([
'http_method' => 'GET',
'headers' => ['host' => ['foo.com']],
'client' => ['progress' => 'foo'],
]);
}
public function testEmitsDebugInfoToStream()
{
$res = fopen('php://memory', 'r+');
Server::flush();
Server::enqueue([['status' => 200]]);
$a = new CurlMultiHandler();
$response = $a([
'http_method' => 'HEAD',
'headers' => ['host' => [Server::$host]],
'client' => ['debug' => $res],
]);
$response->wait();
rewind($res);
$output = str_replace("\r", '', stream_get_contents($res));
$this->assertContains(
"> HEAD / HTTP/1.1\nhost: 127.0.0.1:8125\n\n",
$output
);
$this->assertContains("< HTTP/1.1 200", $output);
fclose($res);
}
public function testEmitsProgressToFunction()
{
Server::flush();
Server::enqueue([['status' => 200]]);
$a = new CurlMultiHandler();
$called = [];
$response = $a([
'http_method' => 'HEAD',
'headers' => ['host' => [Server::$host]],
'client' => [
'progress' => function () use (&$called) {
$called[] = func_get_args();
},
],
]);
$response->wait();
$this->assertNotEmpty($called);
foreach ($called as $call) {
$this->assertCount(4, $call);
}
}
private function addDecodeResponse($withEncoding = true)
{
$content = gzencode('test');
$response = [
'status' => 200,
'reason' => 'OK',
'headers' => ['Content-Length' => [strlen($content)]],
'body' => $content,
];
if ($withEncoding) {
$response['headers']['Content-Encoding'] = ['gzip'];
}
Server::flush();
Server::enqueue([$response]);
return $content;
}
public function testDecodesGzippedResponses()
{
$this->addDecodeResponse();
$handler = new CurlMultiHandler();
$response = $handler([
'http_method' => 'GET',
'headers' => ['host' => [Server::$host]],
'client' => ['decode_content' => true],
]);
$response->wait();
$this->assertEquals('test', Core::body($response));
$this->assertEquals('', $_SERVER['_curl'][CURLOPT_ENCODING]);
$sent = Server::received()[0];
$this->assertNull(Core::header($sent, 'Accept-Encoding'));
}
public function testDecodesGzippedResponsesWithHeader()
{
$this->addDecodeResponse();
$handler = new CurlMultiHandler();
$response = $handler([
'http_method' => 'GET',
'headers' => [
'host' => [Server::$host],
'Accept-Encoding' => ['gzip'],
],
'client' => ['decode_content' => true],
]);
$response->wait();
$this->assertEquals('gzip', $_SERVER['_curl'][CURLOPT_ENCODING]);
$sent = Server::received()[0];
$this->assertEquals('gzip', Core::header($sent, 'Accept-Encoding'));
$this->assertEquals('test', Core::body($response));
}
public function testDoesNotForceDecode()
{
$content = $this->addDecodeResponse();
$handler = new CurlMultiHandler();
$response = $handler([
'http_method' => 'GET',
'headers' => ['host' => [Server::$host]],
'client' => ['decode_content' => false],
]);
$response->wait();
$sent = Server::received()[0];
$this->assertNull(Core::header($sent, 'Accept-Encoding'));
$this->assertEquals($content, Core::body($response));
}
public function testProtocolVersion()
{
Server::flush();
Server::enqueue([['status' => 200]]);
$a = new CurlMultiHandler();
$a([
'http_method' => 'GET',
'headers' => ['host' => [Server::$host]],
'version' => 1.0,
]);
$this->assertEquals(CURL_HTTP_VERSION_1_0, $_SERVER['_curl'][CURLOPT_HTTP_VERSION]);
}
/**
* @expectedException \InvalidArgumentException
*/
public function testValidatesSaveTo()
{
$handler = new CurlMultiHandler();
$handler([
'http_method' => 'GET',
'headers' => ['host' => [Server::$host]],
'client' => ['save_to' => true],
]);
}
public function testSavesToStream()
{
$stream = fopen('php://memory', 'r+');
$this->addDecodeResponse();
$handler = new CurlMultiHandler();
$response = $handler([
'http_method' => 'GET',
'headers' => ['host' => [Server::$host]],
'client' => [
'decode_content' => true,
'save_to' => $stream,
],
]);
$response->wait();
rewind($stream);
$this->assertEquals('test', stream_get_contents($stream));
}
public function testSavesToGuzzleStream()
{
$stream = Stream::factory();
$this->addDecodeResponse();
$handler = new CurlMultiHandler();
$response = $handler([
'http_method' => 'GET',
'headers' => ['host' => [Server::$host]],
'client' => [
'decode_content' => true,
'save_to' => $stream,
],
]);
$response->wait();
$this->assertEquals('test', (string) $stream);
}
public function testSavesToFileOnDisk()
{
$tmpfile = tempnam(sys_get_temp_dir(), 'testfile');
$this->addDecodeResponse();
$handler = new CurlMultiHandler();
$response = $handler([
'http_method' => 'GET',
'headers' => ['host' => [Server::$host]],
'client' => [
'decode_content' => true,
'save_to' => $tmpfile,
],
]);
$response->wait();
$this->assertEquals('test', file_get_contents($tmpfile));
unlink($tmpfile);
}
/**
* @expectedException \InvalidArgumentException
*/
public function testValidatesBody()
{
$handler = new CurlMultiHandler();
$handler([
'http_method' => 'GET',
'headers' => ['host' => [Server::$host]],
'body' => false,
]);
}
public function testAddsLargePayloadFromStreamWithNoSizeUsingChunked()
{
$stream = Stream::factory('foo');
$stream = FnStream::decorate($stream, [
'getSize' => function () {
return null;
}
]);
$this->addDecodeResponse();
$handler = new CurlMultiHandler();
$response = $handler([
'http_method' => 'GET',
'headers' => ['host' => [Server::$host]],
'body' => $stream,
]);
$response->wait();
$sent = Server::received()[0];
$this->assertEquals('chunked', Core::header($sent, 'Transfer-Encoding'));
$this->assertNull(Core::header($sent, 'Content-Length'));
$this->assertEquals('foo', $sent['body']);
}
public function testAddsPayloadFromIterator()
{
$iter = new \ArrayIterator(['f', 'o', 'o']);
$this->addDecodeResponse();
$handler = new CurlMultiHandler();
$response = $handler([
'http_method' => 'GET',
'headers' => ['host' => [Server::$host]],
'body' => $iter,
]);
$response->wait();
$sent = Server::received()[0];
$this->assertEquals('chunked', Core::header($sent, 'Transfer-Encoding'));
$this->assertNull(Core::header($sent, 'Content-Length'));
$this->assertEquals('foo', $sent['body']);
}
public function testAddsPayloadFromResource()
{
$res = fopen('php://memory', 'r+');
$data = str_repeat('.', 1000000);
fwrite($res, $data);
rewind($res);
$this->addDecodeResponse();
$handler = new CurlMultiHandler();
$response = $handler([
'http_method' => 'GET',
'headers' => [
'host' => [Server::$host],
'content-length' => [1000000],
],
'body' => $res,
]);
$response->wait();
$sent = Server::received()[0];
$this->assertNull(Core::header($sent, 'Transfer-Encoding'));
$this->assertEquals(1000000, Core::header($sent, 'Content-Length'));
$this->assertEquals($data, $sent['body']);
}
public function testAddsContentLengthFromStream()
{
$stream = Stream::factory('foo');
$this->addDecodeResponse();
$handler = new CurlMultiHandler();
$response = $handler([
'http_method' => 'GET',
'headers' => ['host' => [Server::$host]],
'body' => $stream,
]);
$response->wait();
$sent = Server::received()[0];
$this->assertEquals(3, Core::header($sent, 'Content-Length'));
$this->assertNull(Core::header($sent, 'Transfer-Encoding'));
$this->assertEquals('foo', $sent['body']);
}
public function testDoesNotAddMultipleContentLengthHeaders()
{
$this->addDecodeResponse();
$handler = new CurlMultiHandler();
$response = $handler([
'http_method' => 'GET',
'headers' => [
'host' => [Server::$host],
'content-length' => [3],
],
'body' => 'foo',
]);
$response->wait();
$sent = Server::received()[0];
$this->assertEquals(3, Core::header($sent, 'Content-Length'));
$this->assertNull(Core::header($sent, 'Transfer-Encoding'));
$this->assertEquals('foo', $sent['body']);
}
public function testSendsPostWithNoBodyOrDefaultContentType()
{
Server::flush();
Server::enqueue([['status' => 200]]);
$handler = new CurlMultiHandler();
$response = $handler([
'http_method' => 'POST',
'uri' => '/',
'headers' => ['host' => [Server::$host]],
]);
$response->wait();
$received = Server::received()[0];
$this->assertEquals('POST', $received['http_method']);
$this->assertNull(Core::header($received, 'content-type'));
$this->assertSame('0', Core::firstHeader($received, 'content-length'));
}
public function testParseProtocolVersion()
{
$res = CurlFactory::createResponse(
function () {},
[],
['curl' => ['errno' => null]],
['HTTP/1.1 200 Ok'],
null
);
$this->assertSame('1.1', $res['version']);
}
public function testFailsWhenNoResponseAndNoBody()
{
$res = CurlFactory::createResponse(function () {}, [], [], [], null);
$this->assertInstanceOf('GuzzleHttp\Ring\Exception\RingException', $res['error']);
$this->assertContains(
'No response was received for a request with no body',
$res['error']->getMessage()
);
}
public function testFailsWhenCannotRewindRetry()
{
$res = CurlFactory::createResponse(function () {}, [
'body' => new NoSeekStream(Stream::factory('foo'))
], [], [], null);
$this->assertInstanceOf('GuzzleHttp\Ring\Exception\RingException', $res['error']);
$this->assertContains(
'rewind the request body failed',
$res['error']->getMessage()
);
}
public function testRetriesWhenBodyCanBeRewound()
{
$callHandler = $called = false;
$res = CurlFactory::createResponse(function () use (&$callHandler) {
$callHandler = true;
return ['status' => 200];
}, [
'body' => FnStream::decorate(Stream::factory('test'), [
'seek' => function () use (&$called) {
$called = true;
return true;
}
])
], [], [], null);
$this->assertTrue($callHandler);
$this->assertTrue($called);
$this->assertEquals('200', $res['status']);
}
public function testFailsWhenRetryMoreThanThreeTimes()
{
$call = 0;
$mock = new MockHandler(function (array $request) use (&$mock, &$call) {
$call++;
return CurlFactory::createResponse($mock, $request, [], [], null);
});
$response = $mock([
'http_method' => 'GET',
'body' => 'test',
]);
$this->assertEquals(3, $call);
$this->assertArrayHasKey('error', $response);
$this->assertContains(
'The cURL request was retried 3 times',
$response['error']->getMessage()
);
}
public function testHandles100Continue()
{
Server::flush();
Server::enqueue([
[
'status' => '200',
'reason' => 'OK',
'headers' => [
'Test' => ['Hello'],
'Content-Length' => ['4'],
],
'body' => 'test',
],
]);
$request = [
'http_method' => 'PUT',
'headers' => [
'Host' => [Server::$host],
'Expect' => ['100-Continue'],
],
'body' => 'test',
];
$handler = new CurlMultiHandler();
$response = $handler($request)->wait();
$this->assertEquals(200, $response['status']);
$this->assertEquals('OK', $response['reason']);
$this->assertEquals(['Hello'], $response['headers']['Test']);
$this->assertEquals(['4'], $response['headers']['Content-Length']);
$this->assertEquals('test', Core::body($response));
}
public function testCreatesConnectException()
{
$m = new \ReflectionMethod('GuzzleHttp\Ring\Client\CurlFactory', 'createErrorResponse');
$m->setAccessible(true);
$response = $m->invoke(
null,
function () {},
[],
[
'err_message' => 'foo',
'curl' => [
'errno' => CURLE_COULDNT_CONNECT,
]
]
);
$this->assertInstanceOf('GuzzleHttp\Ring\Exception\ConnectException', $response['error']);
}
public function testParsesLastResponseOnly()
{
$response1 = [
'status' => 301,
'headers' => [
'Content-Length' => ['0'],
'Location' => ['/foo']
]
];
$response2 = [
'status' => 200,
'headers' => [
'Content-Length' => ['0'],
'Foo' => ['bar']
]
];
Server::flush();
Server::enqueue([$response1, $response2]);
$a = new CurlMultiHandler();
$response = $a([
'http_method' => 'GET',
'headers' => ['Host' => [Server::$host]],
'client' => [
'curl' => [
CURLOPT_FOLLOWLOCATION => true
]
]
])->wait();
$this->assertEquals(1, $response['transfer_stats']['redirect_count']);
$this->assertEquals('http://127.0.0.1:8125/foo', $response['effective_url']);
$this->assertEquals(['bar'], $response['headers']['Foo']);
$this->assertEquals(200, $response['status']);
$this->assertFalse(Core::hasHeader($response, 'Location'));
}
public function testMaintainsMultiHeaderOrder()
{
Server::flush();
Server::enqueue([
[
'status' => 200,
'headers' => [
'Content-Length' => ['0'],
'Foo' => ['a', 'b'],
'foo' => ['c', 'd'],
]
]
]);
$a = new CurlMultiHandler();
$response = $a([
'http_method' => 'GET',
'headers' => ['Host' => [Server::$host]]
])->wait();
$this->assertEquals(
['a', 'b', 'c', 'd'],
Core::headerLines($response, 'Foo')
);
}
/**
* @expectedException \RuntimeException
* @expectedExceptionMessage Directory /path/to/does/not does not exist for save_to value of /path/to/does/not/exist.txt
*/
public function testThrowsWhenDirNotFound()
{
$request = [
'http_method' => 'GET',
'headers' => ['host' => [Server::$url]],
'client' => ['save_to' => '/path/to/does/not/exist.txt'],
];
$f = new CurlFactory();
$f($request);
}
}
}