PHP Response::getStatusCode方法代码示例

 public function testResponseCanSetCustomStatusCode()
 {
     $response = new Response();
     $this->assertEquals(200, $response->getStatusCode());
     $response->setCustomStatusCode('999');
     $this->assertEquals(999, $response->getStatusCode());
 }

 public function testResponseCanSetStatusCode()
 {
     $response = new Response();
     $this->assertEquals(200, $response->getStatusCode());
     $response->setStatusCode('303');
     $this->assertEquals(303, $response->getStatusCode());
 }

 /**
  * Sets the default response values (server raw response, return code, return message and request name)
  *
  * @param ActionResponseInterface $actionResponse
  */
 protected function setDefaultResponseValues(ActionResponseInterface $actionResponse)
 {
     $this->serverRawResponse = $actionResponse->getResponse();
     $this->returnCode = $this->serverRawResponse->getStatusCode();
     $this->returnMessage = $this->serverRawResponse->getReasonPhrase();
     $this->requestName = $actionResponse->getRequestName();
 }

 /**
  * Build the API response from the given HTTP response
  *
  * @param Response $httpResponse
  */
 public function __construct(Response $httpResponse)
 {
     $this->setHttpResponse($httpResponse);
     // Looking for HTTP error
     $statusCode = $this->httpResponse->getStatusCode();
     if (!($statusCode > 199 && $statusCode < 300)) {
         $this->isError = true;
         $this->setErrorMessage($this->httpResponse->getReasonPhrase());
     }
     $contentType = $httpResponse->getHeaders()->get('content-type')->getFieldValue();
     if (strpos($contentType, 'application/vnd.zend.serverapi+xml') === 0) {
         // Looking for XML error
         libxml_use_internal_errors(true);
         $xml = simplexml_load_string($httpResponse->getBody());
         if (!$xml) {
             $errorMessage = '';
             foreach (libxml_get_errors() as $error) {
                 $errorMessage .= $error->message . "\n";
             }
             $this->isError = true;
             $this->setErrorMessage($errorMessage);
             return;
         }
         // Lookign for API error
         if ($xml->errorData) {
             $this->isError = true;
             $this->setErrorMessage((string) $xml->errorData->errorMessage);
             $this->setApiErrorCode((string) $xml->errorData->errorCode);
             return;
         }
         $this->setXml($xml);
     }
 }

 /**
  * {@inheritdoc}
  * @see \InoOicClient\Oic\AbstractResponseHandler::handleResponse()
  */
 public function handleResponse(\Zend\Http\Response $httpResponse)
 {
     $responseData = null;
     $decodeException = null;
     try {
         $responseData = $this->getJsonCoder()->decode($httpResponse->getBody());
     } catch (\Exception $e) {
         $decodeException = $e;
     }
     if (!$httpResponse->isSuccess()) {
         if (isset($responseData[Param::ERROR])) {
             $error = $this->getErrorFactory()->createErrorFromArray($responseData);
             $this->setError($error);
             return;
         } else {
             throw new HttpErrorStatusException(sprintf("Error code '%d' from server", $httpResponse->getStatusCode()));
         }
     }
     if (null !== $decodeException) {
         throw new InvalidResponseFormatException('The HTTP response does not contain valid JSON', null, $decodeException);
     }
     try {
         $this->response = $this->getResponseFactory()->createResponse($responseData);
     } catch (\Exception $e) {
         throw new Exception\InvalidResponseException(sprintf("Invalid response: [%s] %s", get_class($e), $e->getMessage()), null, $e);
     }
 }

 /**
  * @Then the status code should be :code
  */
 public function theStatusCodeShouldBe($code)
 {
     if ($this->response->getStatusCode() != $code) {
         echo $this->response->getBody();
     }
     \PHPUnit_Framework_Assert::assertEquals($code, $this->response->getStatusCode());
 }

 protected function dispatchRequestAndDecodeResponse($url, $method, $data = null)
 {
     $request = new Request();
     $this->lastResponse = null;
     $request->getHeaders()->addHeaders(array('Content-Type' => 'application/x-www-form-urlencoded; charset=UTF-8', 'Accept' => 'application/json', 'User-Agent' => 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:37.0) Gecko/20100101 Firefox/37.0'));
     if (!empty($this->host)) {
         $request->getHeaders()->addHeaders(array('Host' => $this->host));
     }
     if (!empty($this->key)) {
         $request->getHeaders()->addHeaders(array('Authorization' => 'Bearer ' . $this->key));
     }
     $request->setUri($url);
     $request->setMethod($method);
     if (is_null($data)) {
         $data = array();
     }
     if (isset($this->key)) {
         $data["auth"] = $this->key;
     }
     if ($method == "POST" || $method == "PUT") {
         $request->setPost(new Parameters($data));
         if (isset($this->key)) {
             $request->setQuery(new Parameters(array('auth' => $this->key)));
         }
     } else {
         $request->setQuery(new Parameters($data));
     }
     $this->lastResponse = $this->httpClient->send($request);
     if ($this->lastResponse->isSuccess()) {
         return json_decode($this->lastResponse->getBody(), true);
     } else {
         return array('error' => true, 'headers' => array("code" => $this->lastResponse->getStatusCode(), "reasons" => $this->lastResponse->getReasonPhrase()), 'body' => json_decode($this->lastResponse->getBody(), true));
     }
 }

 protected function setResponseContent(Response $response, array $data)
 {
     if ($response instanceof \Zend\Http\PhpEnvironment\Response) {
         $response->getHeaders()->addHeaderLine('Content-Type', 'application/json');
         $response->setContent(json_encode(array_merge(array('status' => $response->getStatusCode()), $data)));
     }
     return $response;
 }

 public function testSet201StatusCodeIfPost()
 {
     $request = new HttpRequest();
     $request->setMethod(HttpRequest::METHOD_POST);
     $this->event->setRequest($request);
     $this->response->setContent('foo');
     $this->resourceResponseListener->finishResponse($this->event);
     $this->assertEquals(201, $this->response->getStatusCode());
 }

 /**
  * Checks whether to handle this status code.
  *
  * @param  HttpResponse $response
  * @return boolean
  */
 public function checkStatusCode(HttpResponse $response)
 {
     // Only 200 responses are cached by default
     if (empty($this->config['http_codes_black_list'])) {
         return $response->isOk();
     }
     $statusCode = $response->getStatusCode();
     return !in_array($statusCode, (array) $this->config['http_codes_black_list']);
 }

 /**
  * Exception factory.
  *
  * Returns a RequestErrorException or RemoteErrorException depending on
  * the response's status code.
  *
  * @param Response $response Server response
  *
  * @return RequestErrorException|RemoteErrorException
  */
 public static function createFromResponse(Response $response)
 {
     $status = $response->getStatusCode();
     $phrase = $response->getReasonPhrase();
     if ($status >= 500) {
         return new RemoteErrorException($status . ' ' . $phrase, $status, $response);
     } else {
         return new RequestErrorException($status . ' ' . $phrase, $status, $response);
     }
 }

 /**
  * Construtor.
  *
  * @param Zend\Http\Client   $client
  * @param Zend\Http\Response $response
  */
 public function __construct(ZendHttpClient $client, ZendHttpResponse $response, $depth = 0)
 {
     $this->httpClient = $client;
     $this->httpResponse = $response;
     if (!$this->httpResponse->isSuccess()) {
         $error = json_decode($this->httpResponse->getBody());
         if (empty($error)) {
             $error = new \stdClass();
             $error->status = $this->httpResponse->getStatusCode();
             $error->title = $this->httpResponse->getReasonPhrase();
             $error->detail = '';
         }
         if (!isset($error->status)) {
             $error->status = 500;
         }
         if (!isset($error->detail)) {
             $error->detail = 'An error occurred.';
         }
         throw new RuntimeException(json_encode($error, null, 100), $error->status);
     }
     if (!$this->httpResponse->getHeaders()->has('Content-Type')) {
         throw new RuntimeException("Missing 'Content-Type' header.", 500);
     }
     $contentType = $this->httpResponse->getHeaders()->get('Content-Type')->getFieldValue();
     $pos = strpos($contentType, ';');
     if ($pos !== false) {
         $contentType = substr($contentType, 0, $pos);
     }
     if (empty($this->httpResponse->getBody())) {
         $this->content = null;
     } elseif ($contentType == 'application/hal+json' || $contentType == 'application/json') {
         $this->content = new Resource(Hal::fromJson($this->httpResponse->getBody(), $depth));
     } elseif ($contentType == 'application/hal+xml' || $contentType == 'application/xml') {
         $this->content = new Resource(Hal::fromXml($this->httpResponse->getBody(), $depth));
     } else {
         throw new RuntimeException("Unable to handle content type '{$contentType}' for response: '{$this->httpResponse->getBody()}'.", 500);
     }
 }

 /**
  * Construtor
  *
  * @param Zend\Http\Client   $client
  * @param Zend\Http\Response $response
  */
 public function __construct(ZendHttpClient $client, ZendHttpResponse $response)
 {
     $this->httpClient = $client;
     $this->httpResponse = $response;
     try {
         $this->checkResponseStatus();
         if (204 == $this->httpResponse->getStatusCode()) {
             $this->strategyContent = new EmptyContent($this->httpClient, $this->httpResponse);
         } else {
             $contentType = $this->httpResponse->getHeaders()->get('Content-Type')->getFieldValue();
             switch (trim($contentType)) {
                 case HalJson::CONTENT_TYPE:
                     $this->strategyContent = new HalJson($this->httpClient, $this->httpResponse);
                     break;
                 default:
                     $errorMessage = sprintf('The apigility server returned a mime type ("%s") that cannot be parsed by apigility client', $mimeType);
                     return new TriggerException($this->httpClient, $this->httpResponse, $errorMessage);
             }
         }
     } catch (RuntimeException $e) {
         throw $e;
     }
 }

 /**
  * Send Http request to retrieve datas
  * @access protected
  * @param  string                                $service    Service to call
  * @param  string                                $type       Resource type to retrieve (for search service)
  * @param  array                                 $parameters Parameters used for request
  * @throws \Zend\Http\Exception\RuntimeException
  * @return \stdClass
  */
 protected function send($service, $type, $parameters)
 {
     // reset old parameters
     $this->getHttpClient()->resetParameters();
     // setup Http headers
     $headers = array(ContentTypeHeader::fromString('Content-Type: ' . HttpClient::ENC_URLENCODED));
     // setup HttpClient
     $this->getHttpClient()->setMethod(HttpRequest::METHOD_GET);
     $this->getHttpClient()->setParameterGet($parameters);
     $this->getHttpClient()->setHeaders($headers);
     // generate URI and set to HttpClient
     $this->getHttpClient()->setUri($this->generateURI($service, $type));
     // get HttpResponse
     $this->response = $this->getHttpClient()->send();
     // is HttpRequest ok ?
     if (!$this->response->isOk()) {
         // throw RuntimeException
         throw new ZendRuntimeException(sprintf('Invalid status code: %d', $this->response->getStatusCode()));
     }
     // return decode object
     return \Zend\Json\Decoder::decode($this->response->getBody());
 }

 /**
  * Transforms a Zend\Http\Response into an HttpFoundation one.
  * 
  * @param ZendResponse $zresponse The Zend\Http\Response
  * 
  * @return HttpFoundationResponse
  */
 public static function toHttpFoundationResponse(ZendResponse $zresponse)
 {
     return HttpFoundationResponse::create($zresponse->getContent(), $zresponse->getStatusCode(), $zresponse->getHeaders()->toArray());
 }