/**
* @return ErrorResponse|SuccessResponse
*/
public function deduce()
{
/* @var array $response */
$response = (array) $this->response->json();
if (array_key_exists('type', $response) && $response['type'] === 'error') {
return new ErrorResponse($this->response->getStatusCode(), $this->response->getHeaders(), $this->response->getBody());
}
return new SuccessResponse($this->response->getStatusCode(), $this->response->getHeaders(), $this->response->getBody());
}
/**
* Constructor
*
* @param GuzzleResponse $response
*/
public function __construct(GuzzleResponse $response)
{
$headers = $response->getHeaders();
//-- this is a hack on my part and I'm terribly sorry it exists
//-- but deal with it.
foreach ($headers as $header => $value) {
$this->headers[$header] = implode(',', array_values((array) $value));
}
$this->url = $response->getEffectiveUrl();
$url_parts = explode('?', $this->url);
if (isset($url_parts[1])) {
$query = explode('&', $url_parts[1]);
foreach ($query as $params) {
$kv = explode('=', $params);
$this->params[$kv[0]] = isset($kv[1]) ? $kv[1] : '';
}
}
// $this->params = $response->request_parameters;
// $this->method = $response->request_method;
$this->json = $response->json();
// $json = json_decode($this->json, TRUE);
$this->data = isset($this->json['data']) ? $this->json['data'] : [];
$this->meta = isset($this->json['meta']) ? $this->json['meta'] : [];
if (isset($this->json['code']) && $this->json['code'] !== 200) {
$this->meta = $this->json;
}
$this->pagination = isset($this->json['pagination']) ? $this->json['pagination'] : [];
$this->user = isset($this->json['user']) ? $this->json['user'] : [];
$this->access_token = isset($this->json['access_token']) ? $this->json['access_token'] : NULL;
$this->limit = isset($this->headers[self::RATE_LIMIT_HEADER]) ? $this->headers[self::RATE_LIMIT_HEADER] : 0;
$this->remaining = isset($this->headers[self::RATE_LIMIT_REMAINING_HEADER]) ? $this->headers[self::RATE_LIMIT_REMAINING_HEADER] : 0;
}
/**
* Returns the SOAP headers from the last response.
*
* @return mix The last SOAP response headers.
*/
public function lastResponseHeaders()
{
if ($this->response instanceof Response) {
return $this->response->getHeaders();
}
return [];
}
/**
* Taken from Mink\BrowserKitDriver
*
* @param Response $response
*
* @return \Symfony\Component\BrowserKit\Response
*/
protected function createResponse(Response $response)
{
$contentType = $response->getHeader('Content-Type');
$matches = null;
if (!$contentType or strpos($contentType, 'charset=') === false) {
$body = $response->getBody(true);
if (preg_match('/\\<meta[^\\>]+charset *= *["\']?([a-zA-Z\\-0-9]+)/i', $body, $matches)) {
$contentType .= ';charset=' . $matches[1];
}
$response->setHeader('Content-Type', $contentType);
}
$headers = $response->getHeaders();
$status = $response->getStatusCode();
$matchesMeta = null;
$matchesHeader = null;
$isMetaMatch = preg_match('/\\<meta[^\\>]+http-equiv="refresh" content="(\\d*)\\s*;?\\s*url=(.*?)"/i', $response->getBody(true), $matchesMeta);
$isHeaderMatch = preg_match('~(\\d*);?url=(.*)~', (string) $response->getHeader('Refresh'), $matchesHeader);
$matches = $isMetaMatch ? $matchesMeta : $matchesHeader;
if (!empty($matches) && (empty($matches[1]) || $matches[1] < $this->refreshMaxInterval)) {
$uri = $this->getAbsoluteUri($matches[2]);
$partsUri = parse_url($uri);
$partsCur = parse_url($this->getHistory()->current()->getUri());
foreach ($partsCur as $key => $part) {
if ($key === 'fragment') {
continue;
}
if (!isset($partsUri[$key]) || $partsUri[$key] !== $part) {
$status = 302;
$headers['Location'] = $uri;
break;
}
}
}
return new BrowserKitResponse($response->getBody(), $status, $headers);
}
/**
* @param \GuzzleHttp\Message\Response $response
*/
function __construct($response)
{
parent::__construct($response->getStatusCode(), $response->getHeaders(), $response->getBody());
$jsonBody = $this->json();
if (array_key_exists("code", $jsonBody)) {
$this->internal_code = $jsonBody["code"];
$this->internal_message = $jsonBody["message"];
$this->internal_type = $jsonBody["type"];
}
if (array_key_exists("atoken", $jsonBody) || array_key_exists("uid", $jsonBody)) {
$this->internal_code = 200;
$this->internal_type = $jsonBody["type"] = "oauthResponse";
}
}
/**
* @param GuzzleResponse $guzzleResponse
*
* @return Response
*/
protected function createResponseFromGuzzleResponse(GuzzleResponse $guzzleResponse)
{
$content = null;
if ($guzzleResponse->getBody() !== null) {
$content = $guzzleResponse->getBody()->getContents();
}
$response = new Response($content, $guzzleResponse->getStatusCode());
$response->setHeaders($guzzleResponse->getHeaders());
$deniedHeaders = array('transfer-encoding', 'x-powered-by', 'content-length', 'content-encoding');
foreach ($deniedHeaders as $headerName) {
$response->removeHeader($headerName);
}
return $response;
}
public function testDoesTheSameAsResponseWhenDereferenced()
{
$str = Stream::factory('foo');
$response = new Response(200, ['Foo' => 'bar'], $str);
$future = MockTest::createFuture(function () use($response) {
return $response;
});
$this->assertFalse($this->readAttribute($future, 'isRealized'));
$this->assertEquals(200, $future->getStatusCode());
$this->assertTrue($this->readAttribute($future, 'isRealized'));
// Deref again does nothing.
$future->wait();
$this->assertTrue($this->readAttribute($future, 'isRealized'));
$this->assertEquals('bar', $future->getHeader('Foo'));
$this->assertEquals(['bar'], $future->getHeaderAsarray('Foo'));
$this->assertSame($response->getHeaders(), $future->getHeaders());
$this->assertSame($response->getBody(), $future->getBody());
$this->assertSame($response->getProtocolVersion(), $future->getProtocolVersion());
$this->assertSame($response->getEffectiveUrl(), $future->getEffectiveUrl());
$future->setEffectiveUrl('foo');
$this->assertEquals('foo', $response->getEffectiveUrl());
$this->assertSame($response->getReasonPhrase(), $future->getReasonPhrase());
$this->assertTrue($future->hasHeader('foo'));
$future->removeHeader('Foo');
$this->assertFalse($future->hasHeader('foo'));
$this->assertFalse($response->hasHeader('foo'));
$future->setBody(Stream::factory('true'));
$this->assertEquals('true', (string) $response->getBody());
$this->assertTrue($future->json());
$this->assertSame((string) $response, (string) $future);
$future->setBody(Stream::factory('<a><b>c</b></a>'));
$this->assertEquals('c', (string) $future->xml()->b);
$future->addHeader('a', 'b');
$this->assertEquals('b', $future->getHeader('a'));
$future->addHeaders(['a' => '2']);
$this->assertEquals('b, 2', $future->getHeader('a'));
$future->setHeader('a', '2');
$this->assertEquals('2', $future->getHeader('a'));
$future->setHeaders(['a' => '3']);
$this->assertEquals(['a' => ['3']], $future->getHeaders());
}
/**
* Taken from Mink\BrowserKitDriver
*
* @param Response $response
*
* @return \Symfony\Component\BrowserKit\Response
*/
protected function createResponse(Response $response)
{
$contentType = $response->getHeader('Content-Type');
if (!$contentType or strpos($contentType, 'charset=') === false) {
$body = $response->getBody(true);
if (preg_match('/\\<meta[^\\>]+charset *= *["\']?([a-zA-Z\\-0-9]+)/i', $body, $matches)) {
$contentType .= ';charset=' . $matches[1];
}
$response->setHeader('Content-Type', $contentType);
}
$headers = $response->getHeaders();
$status = $response->getStatusCode();
if (preg_match('/\\<meta[^\\>]+http-equiv="refresh" content=".*?url=(.*?)"/i', $response->getBody(true), $matches)) {
$status = 302;
$headers['Location'] = $matches[1];
}
if (preg_match('~url=(.*)~', (string) $response->getHeader('Refresh'), $matches)) {
$status = 302;
$headers['Location'] = $matches[1];
}
return new BrowserKitResponse($response->getBody(), $status, $headers);
}
/**
* @param $response HttpResponse
*
* @throws ServerException
*/
private function getGuzzleResponseData($response)
{
if (!is_a($response, 'GuzzleHttp\\Message\\Response')) {
$this->splitResponseToHeadersArrayAndBody($response);
$response = new Response($this->status, $this->headers, null, []);
$this->body = (string) $this->body;
// $this->status = (int) explode(' ', $this->status)[1];
$statusLineArray = explode(" ", trim($this->headers['status'][0]));
$this->status = (int) $statusLineArray[1];
} else {
$this->status = $response->getStatusCode();
$this->body = (string) $response->getBody();
$response->requestHandler = $this->request->requestHandler;
}
$this->headers = $response->getHeaders();
if ($this->verboseExtractStatusLine === true) {
$this->getVerboseStatusLine($response);
}
if (in_array(intval($this->status), $this->enabledHttpServerExceptions)) {
$this->getVerboseStatusLine($response);
throw new ServerException($this->statusPhrase, $this->status);
}
}
protected function createResponse(GuzzleResponse $response)
{
$headers = $response->getHeaders();
return new Response($response->getBody(true), $response->getStatusCode(), $headers);
}
/**
* @return array
*/
public function getHeaders()
{
return $this->response->getHeaders();
}
private static function convertResponse(Response $response)
{
$headers = array_map(function ($h) {
return implode(', ', $h);
}, $response->getHeaders());
return ['status' => $response->getStatusCode(), 'reason' => $response->getReasonPhrase(), 'headers' => $headers, 'body' => base64_encode((string) $response->getBody())];
}
/**
* Convert a Guzzle Response to a Symfony Response
*
* @param GuzzleResponse $prerenderedResponse
* @return SymfonyResponse
*/
private function buildSymfonyResponseFromGuzzleResponse(GuzzleResponse $prerenderedResponse)
{
$body = $prerenderedResponse->getBody();
$statusCode = $prerenderedResponse->getStatusCode();
$headers = $prerenderedResponse->getHeaders();
return new SymfonyResponse($body, $statusCode, $headers);
}
/**
* Error check by header
* @param \GuzzleHttp\Message\Response $metaData
* @return array
*/
private function hardCheckByHeader(\GuzzleHttp\Message\Response $metaData)
{
$headers = array_change_key_case($metaData->getHeaders());
$statusCode = (int) $metaData->getStatusCode();
$isErrorPageCode = ['40x' => [401, 403, 404], '50x' => [500, 502, 503], '30x' => [301, 302, 308]];
foreach ($isErrorPageCode as $errorType => $statuses) {
if (in_array($statusCode, $statuses)) {
return ['result' => false, 'status' => "NG : status code {$errorType}"];
}
}
if ($statusCode === 200 && $statusCode === 304) {
return ['result' => true];
}
if (array_key_exists('content-length', $headers) && $headers['content-length'][0] < $this->contentsSize) {
return ['result' => false, 'status' => 'NG : contentsSize'];
}
return ['result' => true];
}
/**
* @param GuzzleHttp\Message\Response
*/
public function proxyResponseHeaders(Response $response = null)
{
if (!$response) {
return;
}
$headers = $response->getHeaders();
foreach ($headers as $header_name => $header_values) {
$header_values = is_array($header_values) ? $header_values : (array) $header_values;
foreach ($header_values as $header_value) {
// Only attempt proxying when WF protocol is detected
if ($this->isLineWildfireProtocol($header_name)) {
$this->_proxy($header_value);
}
}
// foreach header_values
}
// foreach headers
}
