/**
* Create new response.
*
* @param int $statusCode Response status code.
* @param array $headers Response headers.
* @param mixed $body Response body.
* @param array $options Options.
*
* @return Response
*/
public function createResponse($statusCode, array $headers = array(), $body = null, array $options = array())
{
if (null !== $body) {
$body = Stream::factory($body);
}
return new Response($statusCode, $headers, $body, $options);
}
function buildResponse($code, array $headers = [], $body = null)
{
if (class_exists('GuzzleHttp\\HandlerStack')) {
return new \GuzzleHttp\Psr7\Response($code, $headers, $body);
}
return new \GuzzleHttp\Message\Response($code, $headers, \GuzzleHttp\Stream\Stream::factory((string) $body));
}
/**
* {@inheritdoc}
*/
public function request(RequestInterface $request)
{
$url = (string) $request->getUri();
$body = $request->getBody();
$body->seek(0);
$headers = $request->getHeaders();
$headers['Accept'] = 'application/json';
$headers['Content-Type'] = 'application/json';
$req = $this->guzzle->createRequest($request->getMethod(), $url);
$req->setHeaders($headers);
$req->setBody(GStream::factory($body->getContents()));
try {
$res = $this->guzzle->send($req);
} catch (RequestException $e) {
// Guzzle will throw exceptions for 4xx and 5xx responses, so we catch
// them here and quietly get the response object.
$res = $e->getResponse();
if (!$res) {
throw $e;
}
}
$response = (new Response(new Stream('php://memory', 'w')))->withStatus($res->getStatusCode(), $res->getReasonPhrase());
$response->getBody()->write((string) $res->getBody());
return $response;
}
protected function getClientWithBody($body)
{
$client = new Client();
$mock = new Mock([new Response(200, [], Stream::factory($body))]);
$client->getEmitter()->attach($mock);
return $client;
}
public function testCastsToString()
{
$m = new Request('GET', 'http://foo.com');
$m->setHeader('foo', 'bar');
$m->setBody(Stream::factory('baz'));
$this->assertEquals("GET / HTTP/1.1\r\nHost: foo.com\r\nfoo: bar\r\n\r\nbaz", (string) $m);
}
public function after(GuzzleCommandInterface $command, RequestInterface $request, Operation $operation, array $context)
{
foreach ($this->buffered as $param) {
$this->visitWithValue($command[$param->getName()], $param, $command);
}
$this->buffered = array();
$additional = $operation->getAdditionalParameters();
if ($additional && $additional->getLocation() == $this->locationName) {
foreach ($command->toArray() as $key => $value) {
if (!$operation->hasParam($key)) {
$additional->setName($key);
$this->visitWithValue($value, $additional, $command);
}
}
$additional->setName(null);
}
// If data was found that needs to be serialized, then do so
$xml = null;
if ($this->writer) {
$xml = $this->finishDocument($this->writer);
} elseif ($operation->getData('xmlAllowEmpty')) {
// Check if XML should always be sent for the command
$writer = $this->createRootElement($operation);
$xml = $this->finishDocument($writer);
}
if ($xml) {
$request->setBody(Stream::factory($xml));
// Don't overwrite the Content-Type if one is set
if ($this->contentType && !$request->hasHeader('Content-Type')) {
$request->setHeader('Content-Type', $this->contentType);
}
}
$this->writer = null;
}
public function testRoomInstallCallbackSuccess()
{
$this->createTestConfig();
$data = ['oauthId' => '__oauthId__', 'oauthSecret' => '__oauthSecret__', 'groupId' => '34531', 'roomId' => '986531'];
$authResponse = new Response(200, [], Stream::factory(json_encode(['access_token' => '__authToken__', 'expires_in' => 3600])));
$httpClientMock = $this->getMock('GuzzleHttp\\Client', ['send']);
$httpClientMock->expects($this->once())->method('send')->will($this->returnValue($authResponse));
$clientMock = $this->getMock('Venyii\\HipChatCommander\\Api\\Client', null, ['__clientId__', $this->app['hc.config'], $this->app['hc.api_registry'], $httpClientMock, $this->app['logger']]);
$this->app['hc.api_client'] = $this->app->protect(function () use($clientMock) {
return $clientMock;
});
$client = $this->createClient();
$client->request('POST', '/cb/install', [], [], [], json_encode($data));
$response = $client->getResponse();
$this->assertLoggerHasRecord('Got authToken "__authToken__"', Logger::DEBUG);
$this->assertEquals(200, $response->getStatusCode());
$creds = $this->app['hc.api_registry']->getClient('__oauthId__');
$installDate = $creds['date'];
$expiresDate = $creds['credentials']['expires'];
unset($creds['date']);
unset($creds['credentials']['expires']);
$this->assertEquals(['groupId' => 34531, 'roomId' => 986531, 'credentials' => ['oauthId' => '__oauthId__', 'oauthSecret' => '__oauthSecret__', 'authToken' => '__authToken__']], $creds);
$this->assertInstanceOf('DateTime', $installDate);
$this->assertInstanceOf('DateTime', $expiresDate);
}
public function testSuccessfulTranslate()
{
$client = new Client();
$content = Stream::factory('{"access_token":"123"}');
$mock = new Mock([new Response(200, [], $content), new Response(200, [], Stream::factory($this->xmlResponse))]);
$client->getEmitter()->attach($mock);
$translator = new \badams\MicrosoftTranslator\MicrosoftTranslator($client);
$translator->setClient('client_id', 'client_secret');
$results = $translator->getTranslationsArray(['Hello', 'World'], 'de', 'en');
$this->assertTrue(is_array($results));
$this->assertEquals(2, count($results));
$this->assertInstanceOf('\\badams\\MicrosoftTranslator\\Responses\\GetTranslationsResponse', $results[0]);
$this->assertInstanceOf('\\badams\\MicrosoftTranslator\\Language', $results[0]->getFrom());
$this->assertEquals('en', (string) $results[0]->getFrom());
$translations = $results[0]->getTranslations();
$this->assertEquals(2, count($translations));
$this->assertInstanceOf('\\badams\\MicrosoftTranslator\\Responses\\TranslationMatch', $translations[0]);
$this->assertEquals('Hallo', $translations[0]->getTranslatedText());
$this->assertEquals(5, $translations[0]->getRating());
$this->assertEquals(100, $translations[0]->getMatchDegree());
$this->assertEquals(null, $translations[0]->getError());
$this->assertEquals(0, $translations[0]->getCount());
$this->assertEquals('', $translations[0]->getMatchedOriginalText());
$this->assertEquals('Hello', $translations[1]->getTranslatedText());
$this->assertEquals(4, $translations[1]->getRating());
$this->assertEquals(70, $translations[1]->getMatchDegree());
$this->assertEquals(null, $translations[1]->getError());
$this->assertEquals(1, $translations[1]->getCount());
$this->assertEquals('Hello', $translations[1]->getMatchedOriginalText());
}
public function testHandlesClose()
{
$s = Stream::factory('foo');
$wrapped = new NoSeekStream($s);
$wrapped->close();
$this->assertFalse($wrapped->write('foo'));
}
public function setUp()
{
$this->mock = new Mock([new Response(200, ['Content-Type' => 'javascript'], Stream::factory('{"status":"success"}')), new Response(200, ['Content-Type' => 'javascript'], Stream::factory('{"status":"error"}'))]);
$this->submail = new Submail('key', 'secret');
$client = Sender::getHttpClient();
$client->getEmitter()->attach($this->mock);
}
public function testGetRequestContent()
{
$putRequest = new PutRequest();
$stream = Stream::factory('[1,1,1]');
$query = $this->getMock('GuzzleHttp\\Query');
$httpRequest = $this->getMock('GuzzleHttp\\Message\\RequestInterface');
$httpResponse = $this->getMock('GuzzleHttp\\Message\\ResponseInterface');
$this->client->expects($this->once())->method('createRequest')->with($this->equalTo('PUT'), $this->equalTo('/types/default/buckets/test_bucket/keys/1'))->willReturn($httpRequest);
$this->client->expects($this->once())->method('send')->with($this->equalTo($httpRequest))->willReturn($httpResponse);
$httpRequest->expects($this->once())->method('getQuery')->willReturn($query);
$httpResponse->expects($this->any())->method('getStatusCode')->willReturn(200);
$httpResponse->expects($this->once())->method('getBody')->willReturn($stream);
$httpResponse->expects($this->once())->method('getHeader')->with($this->equalTo('X-Riak-Vclock'))->willReturn('vclock-hash');
$httpRequest->expects($this->exactly(3))->method('setHeader')->will($this->returnValueMap([['Accept', ['multipart/mixed', '*/*'], $query], ['Content-Type', 'application/json', $query], ['X-Riak-Vclock', 'vclock-hash', $query]]));
$httpRequest->expects($this->once())->method('setBody')->with($this->equalTo('[1,1,1]'));
$httpResponse->method('getHeaders')->willReturn(['Content-Type' => 'application/json', 'Last-Modified' => 'Sat, 03 Jan 2015 01:46:34 GMT']);
$content = new Content();
$putRequest->bucket = 'test_bucket';
$putRequest->type = 'default';
$putRequest->key = '1';
$putRequest->returnBody = true;
$putRequest->content = $content;
$putRequest->vClock = 'vclock-hash';
$content->contentType = 'application/json';
$content->value = '[1,1,1]';
$response = $this->instance->send($putRequest);
$this->assertInstanceOf('Riak\\Client\\Core\\Message\\Kv\\PutResponse', $response);
$this->assertEquals('vclock-hash', $response->vClock);
$this->assertCount(1, $response->contentList);
$this->assertEquals('[1,1,1]', $response->contentList[0]->value);
$this->assertEquals(1420249594, $response->contentList[0]->lastModified);
$this->assertEquals('application/json', $response->contentList[0]->contentType);
}
/**
* @inheritdoc
*/
protected function execute(InputInterface $input, OutputInterface $output)
{
$platformId = $input->getOption('platform_id');
/** @var Callable $clientFactory */
$clientFactory = $this->getContainer()['client_factory'];
/** @var Client $client */
$client = $clientFactory($platformId);
try {
$request = $client->createRequest($input->getOption('http_verb'), 'api/rest/' . ltrim($input->getArgument('http_resource'), '/'));
$output->writeln('Sending: ' . $request->getUrl());
if ($input->getOption('request_content')) {
if (!is_string($input->getOption('request_type'))) {
throw new Exception('request_type (-t) is a required parameter when request_content (-c) is used');
}
$body = Stream::factory($input->getOption('request_content'));
$request->setBody($body);
$request->setHeader('Content-Type', $this->parseContentType($input->getOption('request_type')));
$output->writeln('Request body: ' . $body);
}
/** @var ResponseInterface $response */
$response = $client->send($request);
$output->writeln(json_encode($response->json(), JSON_PRETTY_PRINT));
} catch (RequestException $e) {
$output->writeln('Request failed: ' . (string) $e->getResponse()->getBody());
throw $e;
} catch (Exception $e) {
$output->writeln('Invalid request: ' . (string) $e->getMessage());
}
}
private function sendRequest($uri, $postData = null)
{
try {
$fullUrl = $this->url . '/v3' . $uri;
// more info: https://curl.haxx.se/docs/caextract.html
$verify = __DIR__ . '/../../cacert.pem';
if (!file_exists($verify)) {
throw new RuntimeException('cacert.pem not found: ' . $verify);
}
$headers = array();
if ($postData) {
$stream = \GuzzleHttp\Stream\Stream::factory($postData);
$res = $this->httpClient->post($fullUrl, ['headers' => $headers, 'body' => $stream, 'auth' => [$this->username, $this->password], 'verify' => $verify]);
} else {
$res = $this->httpClient->get($fullUrl, ['headers' => $headers, 'auth' => [$this->username, $this->password], 'verify' => $verify]);
}
if ($res->getStatusCode() == 200) {
return (string) $res->getBody();
}
} catch (\GuzzleHttp\Exception\RequestException $e) {
if (!$e->getResponse()) {
throw new NoResponseException('NO_RESPONSE', 'No response / connection error requesting ' . $fullUrl);
}
ErrorResponseHandler::handle($e->getResponse());
}
}
/**
* @param IpnEntity $ipn
* @return bool
*/
public function forwardIpn(IpnEntity $ipn)
{
$urls = $ipn->getForwardUrls();
if (!empty($urls)) {
$requests = [];
foreach ($urls as $url) {
$request = $this->guzzle->createRequest('post', $url);
$request->setHeader($this->customHeader, $this->getKey());
if (in_array($url, $this->disabledJsonFormatting)) {
$request->getQuery()->merge($ipn->toArray());
} else {
$request->setHeader('content-type', 'application/json');
if ($this->formatter) {
$response = $this->formatter->formatJsonResponse($ipn);
} else {
$response = ['ipn' => $ipn->toArray()];
}
$request->setBody(Stream::factory(json_encode($response)));
}
$requests[] = $request;
}
$this->guzzle->sendAll($requests, ['parallel' => $this->maxRequests]);
return true;
}
return false;
}
/**
* @param string $url
* @param mixed[]|null $body
* @return \SlevomatZboziApi\Response\ZboziApiResponse
*/
public function sendPostRequest($url, array $body = null)
{
TypeValidator::checkString($url);
$options = ['allow_redirects' => false, 'verify' => true, 'decode_content' => true, 'expect' => false, 'timeout' => $this->timeoutInSeconds];
$request = $this->client->createRequest('POST', $url, $options);
$request->setHeaders([static::HEADER_PARTNER_TOKEN => $this->partnerToken, static::HEADER_API_SECRET => $this->apiSecret]);
if ($body !== null) {
$request->setBody(\GuzzleHttp\Stream\Stream::factory(json_encode($body)));
}
try {
try {
$response = $this->client->send($request);
$this->log($request, $response);
return $this->getZboziApiResponse($response);
} catch (\GuzzleHttp\Exception\RequestException $e) {
$response = $e->getResponse();
$this->log($request, $response);
if ($response !== null) {
return $this->getZboziApiResponse($response);
}
throw new \SlevomatZboziApi\Request\ConnectionErrorException('Connection to Slevomat API failed.', $e->getCode(), $e);
}
} catch (\GuzzleHttp\Exception\ParseException $e) {
$this->log($request, isset($response) ? $response : null, true);
throw new \SlevomatZboziApi\Response\ResponseErrorException('Slevomat API invalid response: invalid JSON data.', $e->getCode(), $e);
}
}
/**
* @param \Riak\Client\Core\Message\DataType\PutRequest $putRequest
*
* @return \GuzzleHttp\Message\RequestInterface
*/
private function createHttpRequest(PutRequest $putRequest)
{
$request = $this->createRequest('POST', $putRequest->type, $putRequest->bucket, $putRequest->key);
$data = $this->opConverter->convert($putRequest->op);
$query = $request->getQuery();
if ($putRequest->context !== null && is_array($data)) {
$data['context'] = $putRequest->context;
}
if ($putRequest->w !== null) {
$query->add('w', $putRequest->w);
}
if ($putRequest->dw !== null) {
$query->add('dw', $putRequest->dw);
}
if ($putRequest->pw !== null) {
$query->add('pw', $putRequest->pw);
}
if ($putRequest->returnBody !== null) {
$query->add('returnbody', $putRequest->returnBody ? 'true' : 'false');
}
if ($putRequest->includeContext !== null) {
$query->add('include_context', $putRequest->includeContext ? 'true' : 'false');
}
$request->setHeader('Accept', 'application/json');
$request->setHeader('Content-Type', 'application/json');
$request->setBody(Stream::factory(json_encode($data)));
return $request;
}
public function testInflatesStreams()
{
$content = gzencode('test');
$a = Stream::factory($content);
$b = new InflateStream($a);
$this->assertEquals('test', (string) $b);
}
public function formatProvider()
{
$request = new Request('PUT', '/', ['x-test' => 'abc'], Stream::factory('foo'));
$response = new Response(200, ['X-Baz' => 'Bar'], Stream::factory('baz'));
$err = new RequestException('Test', $request, $response);
return [['{request}', [$request], (string) $request], ['{response}', [$request, $response], (string) $response], ['{request} {response}', [$request, $response], $request . ' ' . $response], ['{request} {response}', [$request], $request . ' '], ['{req_headers}', [$request], "PUT / HTTP/1.1\r\nx-test: abc"], ['{res_headers}', [$request, $response], "HTTP/1.1 200 OK\r\nX-Baz: Bar"], ['{res_headers}', [$request], 'NULL'], ['{req_body}', [$request], 'foo'], ['{res_body}', [$request, $response], 'baz'], ['{res_body}', [$request], 'NULL'], ['{method}', [$request], $request->getMethod()], ['{url}', [$request], $request->getUrl()], ['{resource}', [$request], $request->getResource()], ['{req_version}', [$request], $request->getProtocolVersion()], ['{res_version}', [$request, $response], $response->getProtocolVersion()], ['{res_version}', [$request], 'NULL'], ['{host}', [$request], $request->getHost()], ['{hostname}', [$request, $response], gethostname()], ['{hostname}{hostname}', [$request, $response], gethostname() . gethostname()], ['{code}', [$request, $response], $response->getStatusCode()], ['{code}', [$request], 'NULL'], ['{phrase}', [$request, $response], $response->getReasonPhrase()], ['{phrase}', [$request], 'NULL'], ['{error}', [$request, $response, $err], 'Test'], ['{error}', [$request], 'NULL'], ['{req_header_x-test}', [$request], 'abc'], ['{req_header_x-not}', [$request], ''], ['{res_header_X-Baz}', [$request, $response], 'Bar'], ['{res_header_x-not}', [$request, $response], ''], ['{res_header_X-Baz}', [$request], 'NULL']];
}
/**
* @internal
*
* @param array $request
*
* @return array
*/
public function _invokeAsArray(array $request)
{
$factory = $this->factory;
// Ensure headers are by reference. They're updated elsewhere.
$result = $factory($request, curl_init());
$h = $result[0];
$hd =& $result[1];
$body = $result[2];
Core::doSleep($request);
try {
// override the default body stream with the request response
$safecurl = new SafeCurl($h);
$body = $safecurl->execute(Core::url($request));
} catch (Exception $e) {
// URL wasn't safe, return empty content
$body = '';
$safeCurlError = $e->getMessage();
}
$response = ['transfer_stats' => curl_getinfo($h)];
$response['curl']['error'] = curl_error($h);
$response['curl']['errno'] = curl_errno($h);
$response['transfer_stats'] = array_merge($response['transfer_stats'], $response['curl']);
curl_close($h);
// override default error message in case of SafeCurl error
if (isset($safeCurlError)) {
$response['err_message'] = $safeCurlError;
}
return CurlFactory::createResponse([$this, '_invokeAsArray'], $request, $response, $hd, Stream::factory($body));
}
public function testCastsToString()
{
$m = new Message();
$m->setHeader('foo', 'bar');
$m->setBody(Stream::factory('baz'));
$this->assertEquals("Foo!\r\nfoo: bar\r\n\r\nbaz", (string) $m);
}
/**
* @param string $uri
* @param string $method
* @param array $data
* @param array $query_params
* @param string $resource
* @param string $action
* @return mixed
* @throws StreamFeedException
*/
public function makeHttpRequest($uri, $method, $data = [], $query_params = [], $resource = '', $action = '')
{
$query_params['api_key'] = $this->api_key;
$client = $this->getHttpClient();
foreach ($this->guzzleOptions as $key => $value) {
$client->setDefaultOption($key, $value);
}
$request = $client->createRequest($method, $this->client->buildRequestUrl($uri), ['timeout' => $this->client->timeout]);
$request->setHeaders($this->getHttpRequestHeaders($resource, $action));
$query = $request->getQuery();
foreach ($query_params as $key => $value) {
$query[$key] = $value;
}
if ($method === 'POST' || $method === 'POST') {
$json_data = json_encode($data);
$request->setBody(Stream::factory($json_data));
}
try {
$response = $client->send($request);
} catch (Exception $e) {
if ($e instanceof ClientException) {
throw new StreamFeedException($e->getResponse()->getBody());
} else {
throw $e;
}
}
return $response->json();
}
/**
* Method to handle the Subscribe Request to the Hub
*/
public function subscribe()
{
// Start empty $hubUrl variable
$hubUrl = '';
// Check if the Hub URL finishes with a / or not to be able to create the correct subscribe URL
if (preg_match("/\\/\$/", $this->current_options['hub_url'])) {
$hubUrl = $this->current_options['hub_url'] . 'subscribe';
} else {
$hubUrl = $this->current_options['hub_url'] . '/subscribe';
}
// Json Data needed to send to the Hub for Subscription
$subscribeJson = json_encode(array("callbackUrl" => esc_url($this->callbackUrl), "topicId" => esc_url($this->current_options['topic_url'])), JSON_UNESCAPED_SLASHES);
$subscribeRequest = $this->guzzleClient->createRequest('POST', $hubUrl);
$subscribeRequest->setHeader('Content-Type', 'application/json');
$subscribeRequest->setBody(Stream::factory($subscribeJson));
$subscribeResponse = $this->guzzleClient->send($subscribeRequest);
// Check if Response is 200, 202 or 204 and add a log message otherwise log error message
if (in_array($subscribeResponse->getStatusCode(), array(200, 202, 204))) {
HubLogger::log('Your Subscription request is being processed. Check back later to see if you are fully Subscribed', $subscribeResponse->getStatusCode());
return true;
} else {
HubLogger::error('Error issuing Subscribe request to the Hub. Please make sure all your details are correct', $subscribeResponse->getStatusCode());
return false;
}
}
public function testCanSendNormalRequest()
{
$request = new Request('GET', 'http://foo.com');
$body = Stream::factory($this->fakeRawBody);
$response = new Response(200, $this->fakeHeadersAsArray, $body);
$this->guzzleMock->shouldReceive('createRequest')->once()->with('GET', 'http://foo.com/', m::on(function ($arg) {
// array_diff_assoc() will sometimes trigger error on child-arrays
if (['X-foo' => 'bar'] !== $arg['headers']) {
return false;
}
unset($arg['headers']);
$caInfo = array_diff_assoc($arg, ['body' => 'foo_body', 'timeout' => 123, 'connect_timeout' => 10]);
if (count($caInfo) !== 1) {
return false;
}
if (1 !== preg_match('/.+\\/certs\\/DigiCertHighAssuranceEVRootCA\\.pem$/', $caInfo['verify'])) {
return false;
}
return true;
}))->andReturn($request);
$this->guzzleMock->shouldReceive('send')->once()->with($request)->andReturn($response);
$response = $this->guzzleClient->send('http://foo.com/', 'GET', 'foo_body', ['X-foo' => 'bar'], 123);
$this->assertInstanceOf('Facebook\\Http\\GraphRawResponse', $response);
$this->assertEquals($this->fakeRawBody, $response->getBody());
$this->assertEquals($this->fakeHeadersAsArray, $response->getHeaders());
$this->assertEquals(200, $response->getHttpResponseCode());
}
/**
* Queues a mock response to be returned by guzzle
* @param int $code Return code to be returned by mock api
* @param string $body Http body to be returned by mock api
*/
private function getsData($code, $body)
{
if (!$this->mockData) {
throw new Exception('Can\'t have individual mocks when data is set to always return');
}
$this->mockData->addResponse(new Response($code, [], Stream::factory($body)));
}
public function testRepresentation()
{
$stream = Stream::factory('{
"errors": {
"contact": [
{
"error": {
"code": "E0001",
"field": "last_name",
"description": "Please provide contact\'s last name."
}
}
]
}
}');
$response = new Response(422, [], $stream);
$exception = new RepresentationErrorException('', new Request('POST', ''), $response);
$this->assertTrue($exception->hasErrors());
$this->assertTrue($exception->hasErrors('last_name'));
$this->assertFalse($exception->hasErrors('non_existing'));
$this->assertCount(1, $exception->getErrors());
$this->assertCount(1, $exception->getErrors('last_name'));
$this->assertCount(0, $exception->getErrors('non_existing'));
$this->assertEquals('E0001', $exception->getErrors()[0]->getCode());
$this->assertEquals('last_name', $exception->getErrors()[0]->getField());
$this->assertEquals('Please provide contact\'s last name.', $exception->getErrors()[0]->getDescription());
}
/**
* @test
*/
public function createShouldParseAsXmlWhenStatusCodeIs400()
{
$xml = <<<'XML'
<?xml version="1.0" encoding="UTF-8"?>
<errors>
<error>
<code>11004</code>
<message>Currency is required.</message>
</error>
<error>
<code>11005</code>
<message>Currency invalid value: 100</message>
</error>
</errors>
XML;
$message = <<<'MESSAGE'
Some errors occurred:
[11004] Currency is required.
[11005] Currency invalid value: 100
MESSAGE;
$response = new Response(400, [], Stream::factory($xml));
$exception = PagSeguroException::create($response);
$this->assertInstanceOf(PagSeguroException::class, $exception);
$this->assertEquals($message, $exception->getMessage());
}
public function testReadsFromRequestBody()
{
$body = Stream::factory('foo');
$t = new Transaction(new Client(), new Request('PUT', 'http://httbin.org', [], $body));
$m = new RequestMediator($t, new MessageFactory());
$this->assertEquals('foo', $m->readRequestBody(null, null, 3));
}
/**
* @param \Riak\Client\Core\Message\Kv\PutRequest $putRequest
*
* @return \GuzzleHttp\Message\RequestInterface
*/
public function createHttpRequest(PutRequest $putRequest)
{
$method = $putRequest->key ? 'PUT' : 'POST';
$request = $this->createRequest($method, $putRequest->type, $putRequest->bucket, $putRequest->key);
$query = $request->getQuery();
$content = $putRequest->content;
$contentType = $content->contentType;
$value = $content->value;
foreach ($content->indexes as $name => $indexes) {
$request->addHeader("X-Riak-Index-{$name}", $indexes);
}
foreach ($content->metas as $name => $meta) {
$request->addHeader("X-Riak-Meta-{$name}", $meta);
}
$request->setHeader('Accept', ['multipart/mixed', '*/*']);
$request->setHeader('Content-Type', $contentType);
$request->setBody(Stream::factory($value));
if ($putRequest->w !== null) {
$query->add('w', $putRequest->w);
}
if ($putRequest->dw !== null) {
$query->add('dw', $putRequest->dw);
}
if ($putRequest->pw !== null) {
$query->add('pw', $putRequest->pw);
}
if ($putRequest->returnBody !== null) {
$query->add('returnbody', $putRequest->returnBody ? 'true' : 'false');
}
if ($putRequest->vClock !== null) {
$request->setHeader('X-Riak-Vclock', $putRequest->vClock);
}
return $request;
}
public function testHasStream()
{
$s = Stream::factory('foo');
$e = new SeekException($s, 10);
$this->assertSame($s, $e->getStream());
$this->assertContains('10', $e->getMessage());
}
/**
*
*/
public function call($verb, $host, $port, $uri, $headers = null, $query = null, $body = null, $statusCode = null)
{
// Fix headers, query and body
$headers = \z\conf($headers);
$query = \z\conf($query);
if (is_null($body) === true) {
$body = '';
}
// Body must be a string
if (is_string($body) === false) {
\z\e(EXCEPTION_HTTP_BODY_NOT_VALID, ['body' => json_encode($body, true), 'type' => gettype($body)]);
}
// Build the HTTP client
$client = new \GuzzleHttp\Client(['base_url' => $host]);
// Build the request
$request = $client->createRequest($verb, $uri, ['exceptions' => false]);
// Setup the request
$request->setPort($port);
$request->setHeaders($headers);
$request->setQuery($query);
$request->setBody(\GuzzleHttp\Stream\Stream::factory($body));
// Log
\z\logger()->debug($request);
// Send the request
$response = $client->send($request);
// Log
\z\logger()->debug($response);
// Did it succeed?
if (is_null($statusCode) === false && (int) $statusCode !== (int) $response->getStatusCode()) {
\z\e(EXCEPTION_HTTP_STATUS_CODE_NOT_VALID, ['expected' => $statusCode, 'actual' => $response->getStatusCode(), 'request' => $request->__toString(), 'response' => $response->__toString()]);
}
// Build the result
$result = $response->getBody();
return $result;
}