/vendor/guzzlehttp/guzzle/tests/Message/MessageFactoryTest.php |
@@ -0,0 +1,597 @@ |
<?php |
|
namespace GuzzleHttp\Tests\Message; |
|
use GuzzleHttp\Client; |
use GuzzleHttp\Cookie\CookieJar; |
use GuzzleHttp\Message\MessageFactory; |
use GuzzleHttp\Message\Response; |
use GuzzleHttp\Post\PostFile; |
use GuzzleHttp\Query; |
use GuzzleHttp\Stream\Stream; |
use GuzzleHttp\Subscriber\Cookie; |
use GuzzleHttp\Subscriber\History; |
use GuzzleHttp\Subscriber\Mock; |
|
/** |
* @covers GuzzleHttp\Message\MessageFactory |
*/ |
class MessageFactoryTest extends \PHPUnit_Framework_TestCase |
{ |
public function testCreatesResponses() |
{ |
$f = new MessageFactory(); |
$response = $f->createResponse(200, ['foo' => 'bar'], 'test', [ |
'protocol_version' => 1.0 |
]); |
$this->assertEquals(200, $response->getStatusCode()); |
$this->assertEquals(['foo' => ['bar']], $response->getHeaders()); |
$this->assertEquals('test', $response->getBody()); |
$this->assertEquals(1.0, $response->getProtocolVersion()); |
} |
|
public function testCreatesRequestFromMessage() |
{ |
$f = new MessageFactory(); |
$req = $f->fromMessage("GET / HTTP/1.1\r\nBaz: foo\r\n\r\n"); |
$this->assertEquals('GET', $req->getMethod()); |
$this->assertEquals('/', $req->getPath()); |
$this->assertEquals('foo', $req->getHeader('Baz')); |
$this->assertNull($req->getBody()); |
} |
|
public function testCreatesRequestFromMessageWithBody() |
{ |
$req = (new MessageFactory())->fromMessage("GET / HTTP/1.1\r\nBaz: foo\r\n\r\ntest"); |
$this->assertEquals('test', $req->getBody()); |
} |
|
public function testCreatesRequestWithPostBody() |
{ |
$req = (new MessageFactory())->createRequest('GET', 'http://www.foo.com', ['body' => ['abc' => '123']]); |
$this->assertEquals('abc=123', $req->getBody()); |
} |
|
public function testCreatesRequestWithPostBodyScalars() |
{ |
$req = (new MessageFactory())->createRequest( |
'GET', |
'http://www.foo.com', |
['body' => [ |
'abc' => true, |
'123' => false, |
'foo' => null, |
'baz' => 10, |
'bam' => 1.5, |
'boo' => [1]] |
] |
); |
$this->assertEquals( |
'abc=1&123=&foo&baz=10&bam=1.5&boo%5B0%5D=1', |
(string) $req->getBody() |
); |
} |
|
public function testCreatesRequestWithPostBodyAndPostFiles() |
{ |
$pf = fopen(__FILE__, 'r'); |
$pfi = new PostFile('ghi', 'abc', __FILE__); |
$req = (new MessageFactory())->createRequest('GET', 'http://www.foo.com', [ |
'body' => [ |
'abc' => '123', |
'def' => $pf, |
'ghi' => $pfi |
] |
]); |
$this->assertInstanceOf('GuzzleHttp\Post\PostBody', $req->getBody()); |
$s = (string) $req; |
$this->assertContains('testCreatesRequestWithPostBodyAndPostFiles', $s); |
$this->assertContains('multipart/form-data', $s); |
$this->assertTrue(in_array($pfi, $req->getBody()->getFiles(), true)); |
} |
|
public function testCreatesResponseFromMessage() |
{ |
$response = (new MessageFactory())->fromMessage("HTTP/1.1 200 OK\r\nContent-Length: 4\r\n\r\ntest"); |
$this->assertEquals(200, $response->getStatusCode()); |
$this->assertEquals('OK', $response->getReasonPhrase()); |
$this->assertEquals('4', $response->getHeader('Content-Length')); |
$this->assertEquals('test', $response->getBody(true)); |
} |
|
public function testCanCreateHeadResponses() |
{ |
$response = (new MessageFactory())->fromMessage("HTTP/1.1 200 OK\r\nContent-Length: 4\r\n\r\n"); |
$this->assertEquals(200, $response->getStatusCode()); |
$this->assertEquals('OK', $response->getReasonPhrase()); |
$this->assertEquals(null, $response->getBody()); |
$this->assertEquals('4', $response->getHeader('Content-Length')); |
} |
|
/** |
* @expectedException \InvalidArgumentException |
*/ |
public function testFactoryRequiresMessageForRequest() |
{ |
(new MessageFactory())->fromMessage(''); |
} |
|
/** |
* @expectedException \InvalidArgumentException |
* @expectedExceptionMessage foo |
*/ |
public function testValidatesOptionsAreImplemented() |
{ |
(new MessageFactory())->createRequest('GET', 'http://test.com', ['foo' => 'bar']); |
} |
|
public function testOptionsAddsRequestOptions() |
{ |
$request = (new MessageFactory())->createRequest( |
'GET', 'http://test.com', ['config' => ['baz' => 'bar']] |
); |
$this->assertEquals('bar', $request->getConfig()->get('baz')); |
} |
|
public function testCanDisableRedirects() |
{ |
$request = (new MessageFactory())->createRequest('GET', '/', ['allow_redirects' => false]); |
$this->assertEmpty($request->getEmitter()->listeners('complete')); |
} |
|
/** |
* @expectedException \InvalidArgumentException |
*/ |
public function testValidatesRedirects() |
{ |
(new MessageFactory())->createRequest('GET', '/', ['allow_redirects' => []]); |
} |
|
public function testCanEnableStrictRedirectsAndSpecifyMax() |
{ |
$request = (new MessageFactory())->createRequest('GET', '/', [ |
'allow_redirects' => ['max' => 10, 'strict' => true] |
]); |
$this->assertTrue($request->getConfig()['redirect']['strict']); |
$this->assertEquals(10, $request->getConfig()['redirect']['max']); |
} |
|
public function testCanAddCookiesFromHash() |
{ |
$request = (new MessageFactory())->createRequest('GET', 'http://www.test.com/', [ |
'cookies' => ['Foo' => 'Bar'] |
]); |
$cookies = null; |
foreach ($request->getEmitter()->listeners('before') as $l) { |
if ($l[0] instanceof Cookie) { |
$cookies = $l[0]; |
break; |
} |
} |
if (!$cookies) { |
$this->fail('Did not add cookie listener'); |
} else { |
$this->assertCount(1, $cookies->getCookieJar()); |
} |
} |
|
public function testAddsCookieUsingTrue() |
{ |
$factory = new MessageFactory(); |
$request1 = $factory->createRequest('GET', '/', ['cookies' => true]); |
$request2 = $factory->createRequest('GET', '/', ['cookies' => true]); |
$listeners = function ($r) { |
return array_filter($r->getEmitter()->listeners('before'), function ($l) { |
return $l[0] instanceof Cookie; |
}); |
}; |
$this->assertSame($listeners($request1), $listeners($request2)); |
} |
|
public function testAddsCookieFromCookieJar() |
{ |
$jar = new CookieJar(); |
$request = (new MessageFactory())->createRequest('GET', '/', ['cookies' => $jar]); |
foreach ($request->getEmitter()->listeners('before') as $l) { |
if ($l[0] instanceof Cookie) { |
$this->assertSame($jar, $l[0]->getCookieJar()); |
} |
} |
} |
|
/** |
* @expectedException \InvalidArgumentException |
*/ |
public function testValidatesCookies() |
{ |
(new MessageFactory())->createRequest('GET', '/', ['cookies' => 'baz']); |
} |
|
public function testCanAddQuery() |
{ |
$request = (new MessageFactory())->createRequest('GET', 'http://foo.com', [ |
'query' => ['Foo' => 'Bar'] |
]); |
$this->assertEquals('Bar', $request->getQuery()->get('Foo')); |
} |
|
/** |
* @expectedException \InvalidArgumentException |
*/ |
public function testValidatesQuery() |
{ |
(new MessageFactory())->createRequest('GET', 'http://foo.com', [ |
'query' => 'foo' |
]); |
} |
|
public function testCanSetDefaultQuery() |
{ |
$request = (new MessageFactory())->createRequest('GET', 'http://foo.com?test=abc', [ |
'query' => ['Foo' => 'Bar', 'test' => 'def'] |
]); |
$this->assertEquals('Bar', $request->getQuery()->get('Foo')); |
$this->assertEquals('abc', $request->getQuery()->get('test')); |
} |
|
public function testCanSetDefaultQueryWithObject() |
{ |
$request = (new MessageFactory())->createRequest('GET', 'http://foo.com?test=abc', [ |
'query' => new Query(['Foo' => 'Bar', 'test' => 'def']) |
]); |
$this->assertEquals('Bar', $request->getQuery()->get('Foo')); |
$this->assertEquals('abc', $request->getQuery()->get('test')); |
} |
|
public function testCanAddBasicAuth() |
{ |
$request = (new MessageFactory())->createRequest('GET', 'http://foo.com', [ |
'auth' => ['michael', 'test'] |
]); |
$this->assertTrue($request->hasHeader('Authorization')); |
} |
|
public function testCanAddDigestAuth() |
{ |
$request = (new MessageFactory())->createRequest('GET', 'http://foo.com', [ |
'auth' => ['michael', 'test', 'digest'] |
]); |
$this->assertEquals('michael:test', $request->getConfig()->getPath('curl/' . CURLOPT_USERPWD)); |
$this->assertEquals(CURLAUTH_DIGEST, $request->getConfig()->getPath('curl/' . CURLOPT_HTTPAUTH)); |
} |
|
public function testCanDisableAuth() |
{ |
$request = (new MessageFactory())->createRequest('GET', 'http://foo.com', [ |
'auth' => false |
]); |
$this->assertFalse($request->hasHeader('Authorization')); |
} |
|
public function testCanSetCustomAuth() |
{ |
$request = (new MessageFactory())->createRequest('GET', 'http://foo.com', [ |
'auth' => 'foo' |
]); |
$this->assertEquals('foo', $request->getConfig()['auth']); |
} |
|
public function testCanAddEvents() |
{ |
$foo = null; |
$client = new Client(); |
$client->getEmitter()->attach(new Mock([new Response(200)])); |
$client->get('http://test.com', [ |
'events' => [ |
'before' => function () use (&$foo) { $foo = true; } |
] |
]); |
$this->assertTrue($foo); |
} |
|
public function testCanAddEventsWithPriority() |
{ |
$foo = null; |
$client = new Client(); |
$client->getEmitter()->attach(new Mock(array(new Response(200)))); |
$request = $client->createRequest('GET', 'http://test.com', [ |
'events' => [ |
'before' => [ |
'fn' => function () use (&$foo) { $foo = true; }, |
'priority' => 123 |
] |
] |
]); |
$client->send($request); |
$this->assertTrue($foo); |
$l = $this->readAttribute($request->getEmitter(), 'listeners'); |
$this->assertArrayHasKey(123, $l['before']); |
} |
|
public function testCanAddEventsOnce() |
{ |
$foo = 0; |
$client = new Client(); |
$client->getEmitter()->attach(new Mock([ |
new Response(200), |
new Response(200), |
])); |
$fn = function () use (&$foo) { ++$foo; }; |
$request = $client->createRequest('GET', 'http://test.com', [ |
'events' => ['before' => ['fn' => $fn, 'once' => true]] |
]); |
$client->send($request); |
$this->assertEquals(1, $foo); |
$client->send($request); |
$this->assertEquals(1, $foo); |
} |
|
/** |
* @expectedException \InvalidArgumentException |
*/ |
public function testValidatesEventContainsFn() |
{ |
$client = new Client(['base_url' => 'http://test.com']); |
$client->createRequest('GET', '/', ['events' => ['before' => ['foo' => 'bar']]]); |
} |
|
/** |
* @expectedException \InvalidArgumentException |
*/ |
public function testValidatesEventIsArray() |
{ |
$client = new Client(['base_url' => 'http://test.com']); |
$client->createRequest('GET', '/', ['events' => ['before' => '123']]); |
} |
|
public function testCanAddSubscribers() |
{ |
$mock = new Mock([new Response(200)]); |
$client = new Client(); |
$client->getEmitter()->attach($mock); |
$request = $client->get('http://test.com', ['subscribers' => [$mock]]); |
} |
|
public function testCanDisableExceptions() |
{ |
$client = new Client(); |
$this->assertEquals(500, $client->get('http://test.com', [ |
'subscribers' => [new Mock([new Response(500)])], |
'exceptions' => false |
])->getStatusCode()); |
} |
|
public function testCanChangeSaveToLocation() |
{ |
$saveTo = Stream::factory(); |
$request = (new MessageFactory())->createRequest('GET', '/', ['save_to' => $saveTo]); |
$this->assertSame($saveTo, $request->getConfig()->get('save_to')); |
} |
|
public function testCanSetProxy() |
{ |
$request = (new MessageFactory())->createRequest('GET', '/', ['proxy' => '192.168.16.121']); |
$this->assertEquals('192.168.16.121', $request->getConfig()->get('proxy')); |
} |
|
public function testCanSetHeadersOption() |
{ |
$request = (new MessageFactory())->createRequest('GET', '/', ['headers' => ['Foo' => 'Bar']]); |
$this->assertEquals('Bar', (string) $request->getHeader('Foo')); |
} |
|
public function testCanSetHeaders() |
{ |
$request = (new MessageFactory())->createRequest('GET', '/', [ |
'headers' => ['Foo' => ['Baz', 'Bar'], 'Test' => '123'] |
]); |
$this->assertEquals('Baz, Bar', $request->getHeader('Foo')); |
$this->assertEquals('123', $request->getHeader('Test')); |
} |
|
public function testCanSetTimeoutOption() |
{ |
$request = (new MessageFactory())->createRequest('GET', '/', ['timeout' => 1.5]); |
$this->assertEquals(1.5, $request->getConfig()->get('timeout')); |
} |
|
public function testCanSetConnectTimeoutOption() |
{ |
$request = (new MessageFactory())->createRequest('GET', '/', ['connect_timeout' => 1.5]); |
$this->assertEquals(1.5, $request->getConfig()->get('connect_timeout')); |
} |
|
public function testCanSetDebug() |
{ |
$request = (new MessageFactory())->createRequest('GET', '/', ['debug' => true]); |
$this->assertTrue($request->getConfig()->get('debug')); |
} |
|
public function testCanSetVerifyToOff() |
{ |
$request = (new MessageFactory())->createRequest('GET', '/', ['verify' => false]); |
$this->assertFalse($request->getConfig()->get('verify')); |
} |
|
public function testCanSetVerifyToOn() |
{ |
$request = (new MessageFactory())->createRequest('GET', '/', ['verify' => true]); |
$this->assertTrue($request->getConfig()->get('verify')); |
} |
|
public function testCanSetVerifyToPath() |
{ |
$request = (new MessageFactory())->createRequest('GET', '/', ['verify' => '/foo.pem']); |
$this->assertEquals('/foo.pem', $request->getConfig()->get('verify')); |
} |
|
public function inputValidation() |
{ |
return array_map(function ($option) { return array($option); }, array( |
'headers', 'events', 'subscribers', 'params' |
)); |
} |
|
/** |
* @dataProvider inputValidation |
* @expectedException \InvalidArgumentException |
*/ |
public function testValidatesInput($option) |
{ |
(new MessageFactory())->createRequest('GET', '/', [$option => 'foo']); |
} |
|
public function testCanAddSslKey() |
{ |
$request = (new MessageFactory())->createRequest('GET', '/', ['ssl_key' => '/foo.pem']); |
$this->assertEquals('/foo.pem', $request->getConfig()->get('ssl_key')); |
} |
|
public function testCanAddSslKeyPassword() |
{ |
$request = (new MessageFactory())->createRequest('GET', '/', ['ssl_key' => ['/foo.pem', 'bar']]); |
$this->assertEquals(['/foo.pem', 'bar'], $request->getConfig()->get('ssl_key')); |
} |
|
public function testCanAddSslCert() |
{ |
$request = (new MessageFactory())->createRequest('GET', '/', ['cert' => '/foo.pem']); |
$this->assertEquals('/foo.pem', $request->getConfig()->get('cert')); |
} |
|
public function testCanAddSslCertPassword() |
{ |
$request = (new MessageFactory())->createRequest('GET', '/', ['cert' => ['/foo.pem', 'bar']]); |
$this->assertEquals(['/foo.pem', 'bar'], $request->getConfig()->get('cert')); |
} |
|
public function testCreatesBodyWithoutZeroString() |
{ |
$request = (new MessageFactory())->createRequest('PUT', 'http://test.com', ['body' => '0']); |
$this->assertSame('0', (string) $request->getBody()); |
} |
|
public function testCanSetProtocolVersion() |
{ |
$request = (new MessageFactory())->createRequest('GET', 'http://t.com', ['version' => 1.0]); |
$this->assertEquals(1.0, $request->getProtocolVersion()); |
} |
|
public function testCanAddJsonData() |
{ |
$request = (new MessageFactory())->createRequest('PUT', 'http://f.com', [ |
'json' => ['foo' => 'bar'] |
]); |
$this->assertEquals( |
'application/json', |
$request->getHeader('Content-Type') |
); |
$this->assertEquals('{"foo":"bar"}', (string) $request->getBody()); |
} |
|
public function testCanAddJsonDataToAPostRequest() |
{ |
$request = (new MessageFactory())->createRequest('POST', 'http://f.com', [ |
'json' => ['foo' => 'bar'] |
]); |
$this->assertEquals( |
'application/json', |
$request->getHeader('Content-Type') |
); |
$this->assertEquals('{"foo":"bar"}', (string) $request->getBody()); |
} |
|
public function testCanAddJsonDataAndNotOverwriteContentType() |
{ |
$request = (new MessageFactory())->createRequest('PUT', 'http://f.com', [ |
'headers' => ['Content-Type' => 'foo'], |
'json' => null |
]); |
$this->assertEquals('foo', $request->getHeader('Content-Type')); |
$this->assertEquals('null', (string) $request->getBody()); |
} |
|
public function testCanUseCustomSubclassesWithMethods() |
{ |
(new ExtendedFactory())->createRequest('PUT', 'http://f.com', [ |
'headers' => ['Content-Type' => 'foo'], |
'foo' => 'bar' |
]); |
try { |
$f = new MessageFactory(); |
$f->createRequest('PUT', 'http://f.com', [ |
'headers' => ['Content-Type' => 'foo'], |
'foo' => 'bar' |
]); |
} catch (\InvalidArgumentException $e) { |
$this->assertContains('foo config', $e->getMessage()); |
} |
} |
|
/** |
* @ticket https://github.com/guzzle/guzzle/issues/706 |
*/ |
public function testDoesNotApplyPostBodyRightAway() |
{ |
$request = (new MessageFactory())->createRequest('POST', 'http://f.cn', [ |
'body' => ['foo' => ['bar', 'baz']] |
]); |
$this->assertEquals('', $request->getHeader('Content-Type')); |
$this->assertEquals('', $request->getHeader('Content-Length')); |
$request->getBody()->setAggregator(Query::duplicateAggregator()); |
$request->getBody()->applyRequestHeaders($request); |
$this->assertEquals('foo=bar&foo=baz', $request->getBody()); |
} |
|
public function testCanForceMultipartUploadWithContentType() |
{ |
$client = new Client(); |
$client->getEmitter()->attach(new Mock([new Response(200)])); |
$history = new History(); |
$client->getEmitter()->attach($history); |
$client->post('http://foo.com', [ |
'headers' => ['Content-Type' => 'multipart/form-data'], |
'body' => ['foo' => 'bar'] |
]); |
$this->assertContains( |
'multipart/form-data; boundary=', |
$history->getLastRequest()->getHeader('Content-Type') |
); |
$this->assertContains( |
"Content-Disposition: form-data; name=\"foo\"\r\n\r\nbar", |
(string) $history->getLastRequest()->getBody() |
); |
} |
|
public function testDecodeDoesNotForceAcceptHeader() |
{ |
$request = (new MessageFactory())->createRequest('POST', 'http://f.cn', [ |
'decode_content' => true |
]); |
$this->assertEquals('', $request->getHeader('Accept-Encoding')); |
$this->assertTrue($request->getConfig()->get('decode_content')); |
} |
|
public function testDecodeCanAddAcceptHeader() |
{ |
$request = (new MessageFactory())->createRequest('POST', 'http://f.cn', [ |
'decode_content' => 'gzip' |
]); |
$this->assertEquals('gzip', $request->getHeader('Accept-Encoding')); |
$this->assertTrue($request->getConfig()->get('decode_content')); |
} |
|
public function testCanDisableDecoding() |
{ |
$request = (new MessageFactory())->createRequest('POST', 'http://f.cn', [ |
'decode_content' => false |
]); |
$this->assertEquals('', $request->getHeader('Accept-Encoding')); |
$this->assertNull($request->getConfig()->get('decode_content')); |
} |
} |
|
class ExtendedFactory extends MessageFactory |
{ |
protected function add_foo() {} |
} |