public function __construct(\GuzzleHttp\Psr7\Response $response) { $json = false; $data = $response->getBody(); $this->rawData = $data; $this->response = $response; if ($response->hasHeader('Content-Type')) { // Let's see if it is JSON $contentType = $response->getHeader('Content-Type'); if (strstr($contentType[0], 'json')) { $json = true; $data = json_decode($data); } } if (!$json) { // We can do another test here $decoded = json_decode($response->getBody()); if ($decoded) { $json = true; $data = $decoded; } } $this->setData($data); $this->setIsJson($json); }
public function testCanConstructWithHeadersAsArray() { $r = new Response(200, ['Foo' => ['baz', 'bar']]); $this->assertSame(['Foo' => ['baz', 'bar']], $r->getHeaders()); $this->assertSame('baz, bar', $r->getHeaderLine('Foo')); $this->assertSame(['baz', 'bar'], $r->getHeader('Foo')); }
/** * {@inheritdoc} */ public function getLatestResponseHeaders() { if (null === $this->response) { return; } return ['reset' => (int) (string) $this->response->getHeader('RateLimit-Reset'), 'remaining' => (int) (string) $this->response->getHeader('RateLimit-Remaining'), 'limit' => (int) (string) $this->response->getHeader('RateLimit-Limit')]; }
/** * Response constructor * * @param HttpResponse $httpResponse * @return self */ public function __construct(HttpResponse $httpResponse) { $header = $httpResponse->getHeader('Content-Type'); if (!is_array($header) && stripos($header, 'text/javascript') !== false) { $this->_response = $this->processJson($httpResponse->getBody()); } else { $this->_response = $this->processXml($httpResponse->getBody()); } }
/** * Get cache ttl value * * @param Response $response * * @return int */ protected function getCacheTtl(Response $response) { if ($this->useHeaderTtl && $response->hasHeader('Cache-Control')) { $cacheControl = $response->getHeader('Cache-Control')[0]; if (preg_match('`max-age=(\\d+)`', $cacheControl, $match)) { return intval($match[1]); } } return $this->defaultTtl; }
/** * @param ObjectInterface $object * @param array $data * @param Response $response * @return ObjectInterface */ public function create(ObjectInterface $object, array $data, Response $response = null) { // If object had relationId, we pass it to new object if ($object->getAttribute("relationId")) { $relationId = $object->getAttribute("relationId"); $object = new $object($relationId); } else { $object = new $object(); } if (isset($data['items']) or isset($data[0])) { // If we have list of items $object = $this->createList($object, $data); } else { if (isset($data["id"])) { // TODO: Some things don't provide ID, possible BUG, that it isn't implemented in CREST $object->setAttribute("id", $data['id']); $uri = $object->getAttribute("uri") . $object->getAttribute("id") . "/"; $object->setAttribute("uri", $uri); } elseif (!empty($data['href']) && is_numeric(basename($data["href"]))) { // TODO: Meybe not bug, so we just take it from href $object->setAttribute("id", (int) basename($data["href"])); $uri = $object->getAttribute("uri") . $object->getAttribute("id") . "/"; $object->setAttribute("uri", $uri); } foreach ($data as $key => $value) { if (array_key_exists($key, $object->getRelations())) { // ˇˇ if (is_string($value)) { // TODO: Sometimes relationship is only a string with href, not array like usually. // TODO: When crest behaves as it should, remove this! // Seen in GET crest.../wars/21/ value "killmails" $object->setValue($key, $value); continue; } // ^^ // Create new relation object with relation_id $relation = $object->getRelations($key); $object->setValue($key, $this->create(new $relation($object->getAttribute("id")), $value)); } else { $object->setValue($key, $value); } } } // Add cache-control header to Object, but only if this Endpoint made request // we cant add cache-control for relationships, as we don't have data for them // Add HTTP Code, might be useful if ($response) { // On POST/PUT/DELETE responses cache-control isn't provided. if ($response->hasHeader("cache-control")) { $object->setAttribute("cache", $response->getHeader("cache-control")[0]); } $object->setAttribute("httpCode", $response->getStatusCode()); } return $object; }
public function parse(Response $response) { $collection = new Collection(); if (!$response->getBody()) { return $collection; } // help bad responses be more multipart compliant $body = "\r\n" . $response->getBody()->__toString() . "\r\n"; // multipart preg_match('/boundary\\=\\"(.*?)\\"/', $response->getHeader('Content-Type'), $matches); if (isset($matches[1])) { $boundary = $matches[1]; } else { preg_match('/boundary\\=(.*?)(\\s|$|\\;)/', $response->getHeader('Content-Type'), $matches); $boundary = $matches[1]; } // strip quotes off of the boundary $boundary = preg_replace('/^\\"(.*?)\\"$/', '\\1', $boundary); // clean up the body to remove a reamble and epilogue $body = preg_replace('/^(.*?)\\r\\n--' . $boundary . '\\r\\n/', "\r\n--{$boundary}\r\n", $body); // make the last one look like the rest for easier parsing $body = preg_replace('/\\r\\n--' . $boundary . '--/', "\r\n--{$boundary}\r\n", $body); // cut up the message $multi_parts = explode("\r\n--{$boundary}\r\n", $body); // take off anything that happens before the first boundary (the preamble) array_shift($multi_parts); // take off anything after the last boundary (the epilogue) array_pop($multi_parts); $message_parser = new MessageParser(); $parser = new Single(); // go through each part of the multipart message foreach ($multi_parts as $part) { // get Guzzle to parse this multipart section as if it's a whole HTTP message $parts = $message_parser->parseResponse("HTTP/1.1 200 OK\r\n" . $part); // now throw this single faked message through the Single GetObject response parser $single = new Response($parts['code'], $parts['headers'], Stream::factory($parts['body'])); $obj = $parser->parse($single); // add information about this multipart to the returned collection $collection->push($obj); } return $collection; }
public function testBase() { $response = new Response(200, ['Cache-Control' => ['max-age = 120', ' stale-while-revalidate= 60 ', ' private ', 'zero=0', 'nothing = ', 'false = false']]); $values = new KeyValueHttpHeader($response->getHeader('Cache-Control')); $this->assertTrue($values->has('max-age')); $this->assertTrue($values->has('stale-while-revalidate')); $this->assertTrue($values->has('private')); $this->assertTrue($values->has('zero')); $this->assertTrue($values->has('nothing')); $this->assertTrue($values->has('false')); $this->assertEquals(120, $values->get('max-age')); $this->assertEquals(60, $values->get('stale-while-revalidate')); $this->assertEquals(0, $values->get('zero')); $this->assertEquals('', $values->get('nothing')); $this->assertEquals('false', $values->get('false')); }
public function verifySubProtocol(Request $request, Response $response) { $subProtocolRequest = $request->getHeader('Sec-WebSocket-Protocol'); if (empty($subProtocolRequest)) { return true; } $subProtocolResponse = $response->getHeader('Sec-WebSocket-Protocol'); if (count($subProtocolResponse) !== 1) { // there should be exactly one subprotocol sent back if we requested return false; } if (in_array($subProtocolResponse[0], $subProtocolRequest)) { // the response is one of the requested subprotocols return true; } return false; }
/** * Validate the HTTP response and throw exceptions on errors * * @param HttpResponse $response * @throws ServerException */ private function validateResponse($response) { if ($response->getStatusCode() !== 200) { $statusCode = $response->getStatusCode(); throw new ServerException('Server responded with HTTP status ' . $statusCode, $statusCode); } else { if (strpos($response->getHeader('Content-Type')[0], 'application/json') === false) { throw new ServerException('Server did not respond with the expected content-type (application/json)'); } } try { $body = (string) $response->getBody(); $json = json_decode($body, true); if (json_last_error()) { throw new ServerException(json_last_error_msg()); } } catch (RuntimeException $e) { throw new ServerException($e->getMessage()); } }
public function testCanSetHeaderAsArray() { $r = new Response(200, ['foo' => ['baz ', ' bar ']]); $this->assertEquals('baz, bar', $r->getHeaderLine('foo')); $this->assertEquals(['baz', 'bar'], $r->getHeader('foo')); }
/** * @param RequestInterface $request * @param Response $response * @return \Guzzle\Http\EntityBodyInterface|mixed|string */ public function handleResponse(Request $request, Response $response) { $body = $response->getBody(true); $contentType = $response->getHeader('Content-Type')[0]; switch ($contentType) { case "application/json": $body = json_decode($body, true); break; } return [$response->getStatusCode(), $body]; }
/** * Builds a pretty failure message from the specified response's warning headers, using the specified request for * additional information. * @param \GuzzleHttp\Psr7\Request $request HTTP request object * @param \GuzzleHttp\Psr7\Response $response HTTP response object * @return string */ protected function buildFailureMessage(Request $request, Response $response) { $message = "Unsuccessful " . $request->getMethod() . " to " . $request->getUri() . " (" . $response->getStatusCode() . ")"; $warnings = $response->getHeader('Warning'); foreach ($warnings as $w) { $message .= "\nWarning: " . $w; } return $message; }
/** * Response contents type. * * @return string The response header content type. */ protected function type() { $type = $this->response->getHeader('Content-Type'); return strtolower(reset($type)); }
/** * After each request update the rate limits that are received in the headers */ private function _updateRateLimits() { App::getInstance()->getRateLimit()->update(current($this->_response->getHeader(ApiHelper::HEADER_RATE_LIMIT)), current($this->_response->getHeader(ApiHelper::HEADER_RATE_LIMIT_REMAINING)), current($this->_response->getHeader(ApiHelper::HEADER_RATE_LIMIT_RESET))); }
/** * * @return string */ public function getHeader($header) { return $this->response->getHeader($header); }
/** * Attempt to pull rate limit headers from response and add to client * * @param Response $response * * @return void */ private function parseRateLimitFromResponse(Response $response) { $this->rate_limit = new RateLimit($response->getHeader('X-Rate-Limit-Limit'), $response->getHeader('X-Rate-Limit-Remaining'), $response->getHeader('X-Rate-Limit-Reset')); }
/** * Attempts to pull rate limit headers from response and add to client. * * @param Response $response * * @return void */ private function parseRateLimitFromResponse(Response $response) { $rateLimitHeaders = array_filter([$response->getHeader('X-Rate-Limit-Limit'), $response->getHeader('X-Rate-Limit-Remaining'), $response->getHeader('X-Rate-Limit-Reset')]); if (count($rateLimitHeaders) == 3) { $rateLimitClass = new ReflectionClass(RateLimit::class); $this->rate_limit = $rateLimitClass->newInstanceArgs($rateLimitHeaders); } }
public function assertResponseHasContentType($expected, Response $response) { $this->assertContains($expected, $response->getHeader('Content-Type')); }
/** * Assert that the response can be parsed * * @param Request $request * @param Response $response * @param array $options */ protected function parseResponseAssert($request, $response, $options) { $parse = $options['parse']; list($contentType) = preg_replace('/\\s*;.*$/', '', $response->getHeader('Content-Type')) + [null]; // Only JSON is currently supported if ($parse !== 'application/json') { throw new \Exception("Parsing is only supported for 'application/json', not '{$parse}'"); } if (!isset($contentType)) { trigger_error("Server response doesn't specify the content type, assuming {$parse}", E_USER_NOTICE); } if (!in_array($contentType, [$parse, 'text/plain'])) { $message = "Server responded with '{$contentType}', while expecting '{$parse}'"; throw new InvalidContentException($message, $request, $response); } }