PHP Response::getReasonPhrase方法代码示例

 public function testCanConstructWithReason()
 {
     $r = new Response(200, [], null, '1.1', 'bar');
     $this->assertSame('bar', $r->getReasonPhrase());
     $r = new Response(200, [], null, '1.1', '0');
     $this->assertSame('0', $r->getReasonPhrase(), 'Falsey reason works');
 }

 public function testCanCreateNewResponseWithStatusAndReason()
 {
     $r = new Response(200);
     $r2 = $r->withStatus(201, 'Foo');
     $this->assertEquals(200, $r->getStatusCode());
     $this->assertEquals('OK', $r->getReasonPhrase());
     $this->assertEquals(201, $r2->getStatusCode());
     $this->assertEquals('Foo', $r2->getReasonPhrase());
 }

/**
 * @param Response $response
 */
function out(Response $response)
{
    header(sprintf('%s %s %s', $response->getProtocolVersion(), $response->getStatusCode(), $response->getReasonPhrase()));
    foreach ($response->getHeaders() as $name => $values) {
        foreach ($values as $value) {
            header(sprintf('%s: %s', $name, $value), false);
        }
    }
    stream_copy_to_stream(\GuzzleHttp\Psr7\StreamWrapper::getResource($response->getBody()), fopen('php://output', 'w'));
}

 protected function getSerializedResponse(Response $response)
 {
     $cached = new \SplFixedArray(5);
     $cached[0] = $response->getStatusCode();
     $cached[1] = $response->getHeaders();
     $cached[2] = $response->getBody()->__toString();
     $cached[3] = $response->getProtocolVersion();
     $cached[4] = $response->getReasonPhrase();
     return serialize($cached);
 }

 /**
  * @param Response $response
  *
  * @throws \LogicException
  */
 protected static function createException(Response $response)
 {
     $content = json_decode($response->getBody()->getContents(), true);
     if (is_array($content) && array_key_exists('errors', $content)) {
         $message = json_encode($content['errors'], JSON_UNESCAPED_UNICODE);
     } else {
         $message = $response->getReasonPhrase();
     }
     throw new \LogicException($message, $response->getStatusCode());
 }

 /**
  * @param Response $response
  *
  * @throws FenrirApiException When Fenrir Api return a non success status code.
  */
 private static function checkResponse(Response $response)
 {
     $statusCode = $response->getStatusCode();
     if ($statusCode >= 400 && $statusCode < 600) {
         $reason = $response->getReasonPhrase();
         $body = json_decode($response->getBody());
         if (isset($body->error->exception[0]->message)) {
             $reason = $body->error->exception[0]->message;
         }
         throw new FenrirApiException($statusCode, $reason);
     }
 }

 public static function make(Response $response)
 {
     $code = $response->getStatusCode();
     $body = json_decode($response->getBody(), true);
     if ($response->getStatusCode() == 200) {
         if (!is_array($body) && is_string($body)) {
             $body = ['message' => $body];
         }
     } else {
         if (!$body['message']) {
             $body = ['message' => $response->getReasonPhrase(), 'details' => $body];
         }
     }
     return new RuleResponse($code, $body);
 }

 /**
  * Executes a Psr\Http\Message\RequestInterface
  *
  * @param Google_Client $client
  * @param Psr\Http\Message\RequestInterface $request
  * @return array decoded result
  * @throws Google_Service_Exception on server side error (ie: not authenticated,
  *  invalid or malformed post body, invalid url)
  */
 public static function doExecute(ClientInterface $client, RequestInterface $request, $expectedClass = null)
 {
     try {
         $httpHandler = HttpHandlerFactory::build($client);
         $response = $httpHandler($request);
     } catch (RequestException $e) {
         // if Guzzle throws an exception, catch it and handle the response
         if (!$e->hasResponse()) {
             throw $e;
         }
         $response = $e->getResponse();
         // specific checking for Guzzle 5: convert to PSR7 response
         if ($response instanceof \GuzzleHttp\Message\ResponseInterface) {
             $response = new Response($response->getStatusCode(), $response->getHeaders() ?: [], $response->getBody(), $response->getProtocolVersion(), $response->getReasonPhrase());
         }
     }
     return self::decodeHttpResponse($response, $request, $expectedClass);
 }

 /**
  * Will send the response, standard PHP way
  * 
  * @param Response $response
  * @return null
  */
 public function sendResponse($response)
 {
     header("HTTP/" . $response->getProtocolVersion() . " " . $response->getStatusCode() . " " . $response->getReasonPhrase());
     foreach ($response->getHeaders() as $name => $values) {
         foreach ($values as $value) {
             header(sprintf('%s: %s', $name, $value), false);
         }
     }
     $body = $response->getBody();
     while (!$body->eof()) {
         $buf = $body->read(1048576);
         // Using a loose equality here to match on '' and false.
         if ($buf == null) {
             break;
         } else {
             echo $buf;
         }
     }
 }

 /**
  * @internal
  *
  * @param $response
  *
  * @return bool
  */
 public function isValidResponse(GuzzleResponse $response)
 {
     return $response->getReasonPhrase() != 'OK' || $response->getStatusCode() != 200;
 }

 /**
  * Formate guzzle response data.
  *
  * @param $response \GuzzleHttp\Psr7\Response
  *
  * @return stdClass
  */
 public function formatGuzzleResponse(\GuzzleHttp\Psr7\Response $response)
 {
     return (object) array('statusCode' => $response->getStatusCode(), 'reasonPhrase' => $response->getReasonPhrase(), 'content' => $response->getBody()->getContents());
 }

 public function __construct(Response $response)
 {
     parent::__construct($response->getReasonPhrase());
     $this->response = $response;
 }

 /**
  * Gets the response reason phrase associated with the status code.
  *
  * @return string
  */
 public function getReasonPhrase()
 {
     return $this->response->getReasonPhrase();
 }

 /**
  * Cache response
  *
  * @param RequestInterface $request
  * @param Response         $response
  * @param int              $ttl
  *
  * @return booelan
  */
 protected function cacheResponse(RequestInterface $request, Response $response, $ttl = null)
 {
     if (!$this->isSupportedMethod($request)) {
         return;
     }
     // copy response in array to  store
     $cached = new \SplFixedArray(5);
     $cached[0] = $response->getStatusCode();
     $cached[1] = $response->getHeaders();
     $cached[2] = $response->getBody()->__toString();
     $cached[3] = $response->getProtocolVersion();
     $cached[4] = $response->getReasonPhrase();
     return $this->cache->set(self::getKey($request), serialize($cached), $ttl ?: $this->getCachettl($response));
 }

 /**
  * @param Response $response
  */
 protected function assertResponse(Response $response)
 {
     Assertion::inArray($response->getStatusCode(), [200, 201, 202, 409], sprintf('Failed request [%s]: %s', $response->getStatusCode(), $response->getReasonPhrase()));
 }