PHP RequestException::create方法代码示例

 /**
  * Throw a RequestException if the response is not marked as successful.
  *
  * @param \GuzzleHttp\Event\CompleteEvent $event
  *
  * @throws \GuzzleHttp\Exception\RequestException
  *
  * @return void
  */
 public function onComplete(CompleteEvent $event)
 {
     $json = $event->getResponse()->json();
     if (array_get($json, 'result') !== 'success' || array_key_exists('response', $json) === false) {
         throw RequestException::create($event->getRequest(), $event->getResponse());
     }
 }

 public function testHasThrowState()
 {
     $e = RequestException::create(new Request('GET', '/'), new Response(442));
     $this->assertFalse($e->getThrowImmediately());
     $e->setThrowImmediately(true);
     $this->assertTrue($e->getThrowImmediately());
 }

 /**
  * Throw a RequestException on an HTTP protocol error
  *
  * @param CompleteEvent $event Emitted event
  * @throws RequestException
  */
 public function onComplete(CompleteEvent $event)
 {
     $code = (string) $event->getResponse()->getStatusCode();
     // Throw an exception for an unsuccessful response
     if ($code[0] === '4' || $code[0] === '5') {
         throw RequestException::create($event->getRequest(), $event->getResponse());
     }
 }

 /**
  * @test
  * @expectedException \GuzzleHttp\Exception\RequestException
  */
 public function magicCallResponseNotReceived()
 {
     $this->deferredHttpBinding = new FulfilledPromise($this->httpBindingMock);
     $this->httpBindingMock->method('request')->willReturn(new Request('POST', 'www.endpoint.com'))->with('someSoapMethod', [['some-key' => 'some-value']]);
     $this->httpBindingMock->expects($this->never())->method('response');
     $this->handlerMock->append(GuzzleRequestException::create(new Request('POST', 'www.endpoint.com')));
     $client = new SoapClient($this->clientMock, $this->deferredHttpBinding);
     $client->someSoapMethod(['some-key' => 'some-value'])->wait();
 }

 /**
  * @test
  * @expectedException \Jsor\HalClient\Exception\BadResponseException
  */
 public function it_will_transform_exception_with_404_response()
 {
     $guzzleClient = $this->getMock('GuzzleHttp\\ClientInterface');
     $guzzleClient->expects($this->once())->method('send')->will($this->returnCallback(function ($request) {
         throw GuzzleRequestException::create($request, new Response(404));
     }));
     $client = new HalClient('http://propilex.herokuapp.com', new Guzzle6HttpClient($guzzleClient));
     $client->request('GET', '/');
 }

 public function testBuild()
 {
     $request = new Request('GET', '/');
     $this->assertInstanceOf('\\keika299\\ConohaAPI\\Common\\Exceptions\\Network\\Client\\BadRequestException', ExceptionFactory::build(RequestException::create($request, new Response('400'))));
     $this->assertInstanceOf('\\keika299\\ConohaAPI\\Common\\Exceptions\\Network\\Client\\UnauthorizedException', ExceptionFactory::build(RequestException::create($request, new Response('401'))));
     $this->assertInstanceOf('\\keika299\\ConohaAPI\\Common\\Exceptions\\Network\\Client\\ForbiddenException', ExceptionFactory::build(RequestException::create($request, new Response('403'))));
     $this->assertInstanceOf('\\keika299\\ConohaAPI\\Common\\Exceptions\\Network\\Client\\NotFoundException', ExceptionFactory::build(RequestException::create($request, new Response('404'))));
     $this->assertInstanceOf('\\keika299\\ConohaAPI\\Common\\Exceptions\\Network\\Client\\MethodNotAllowedException', ExceptionFactory::build(RequestException::create($request, new Response('405'))));
     $this->assertInstanceOf('\\keika299\\ConohaAPI\\Common\\Exceptions\\Network\\Client\\NotAcceptableException', ExceptionFactory::build(RequestException::create($request, new Response('406'))));
     $this->assertInstanceOf('\\keika299\\ConohaAPI\\Common\\Exceptions\\Network\\RequestException', ExceptionFactory::build(RequestException::create($request, new Response('499'))));
 }

 /**
  * Middleware that throws exceptions for 4xx or 5xx responses when the
  * "http_error" request option is set to true.
  *
  * @return callable Returns a function that accepts the next handler.
  */
 public static function httpErrors()
 {
     return function (callable $handler) {
         return function ($request, array $options) use($handler) {
             if (empty($options['http_errors'])) {
                 return $handler($request, $options);
             }
             return $handler($request, $options)->then(function (ResponseInterface $response) use($request, $handler) {
                 $code = $response->getStatusCode();
                 if ($code < 400) {
                     return $response;
                 }
                 throw RequestException::create($request, $response);
             });
         };
     };
 }

 /**
  * {@inheritdoc}
  */
 public static function create(HttpRequestInterface $request, HttpResponseInterface $response = null, Exception $previous = null, array $handlerContext = null)
 {
     if ($request instanceof RequestInterface && $response instanceof ResponseInterface) {
         static $clientErrorCodes = [-32600, -32601, -32602, -32700];
         $errorCode = $response->getRpcErrorCode();
         if (in_array($errorCode, $clientErrorCodes)) {
             $label = 'Client RPC error response';
             $className = __NAMESPACE__ . '\\ClientException';
         } else {
             $label = 'Server RPC error response';
             $className = __NAMESPACE__ . '\\ServerException';
         }
         $message = $label . ' [uri] ' . $request->getRequestTarget() . ' [method] ' . $request->getRpcMethod() . ' [error code] ' . $errorCode . ' [error message] ' . $response->getRpcErrorMessage();
         return new $className($message, $request, $response, $previous);
     }
     return parent::create($request, $response, $previous);
 }

 /**
  * @param RequestInterface $request
  * @param array            $options
  *
  * @return PromiseInterface
  */
 public function __invoke(RequestInterface $request, array $options)
 {
     $nextHandler = $this->nextHandler;
     if ($request->hasHeader('Authorization')) {
         return $nextHandler($request, $options);
     }
     $request = $request->withHeader('Authorization', sprintf('Bearer %s', $this->session->getToken()));
     return $nextHandler($request, $options)->then(function (ResponseInterface $response) use($request, $options) {
         $code = $response->getStatusCode();
         if ($code < 400) {
             return $response;
         }
         if ($response->hasHeader("WWW-Authenticate")) {
             throw BearerErrorResponseException::create($request, $response);
         }
         throw RequestException::create($request, $response);
     });
 }

 /**
  * Use the send method to call every endpoint except for oauth/tokens
  *
  * @param HttpClient $client
  * @param string     $endPoint E.g. "/tickets.json"
  * @param array      $options
  *                             Available options are listed below:
  *                             array $queryParams Array of unencoded key-value pairs, e.g. ["ids" => "1,2,3,4"]
  *                             array $postFields Array of unencoded key-value pairs, e.g. ["filename" => "blah.png"]
  *                             string $method "GET", "POST", etc. Default is GET.
  *                             string $contentType Default is "application/json"
  *
  * @return \stdClass | null The response body, parsed from JSON into an object. Also returns null if something went wrong
  * @throws ApiResponseException
  * @throws AuthException
  */
 public static function send(HttpClient $client, $endPoint, $options = [])
 {
     $options = array_merge(['method' => 'GET', 'contentType' => 'application/json', 'postFields' => null, 'queryParams' => null], $options);
     $headers = array_merge(['Accept' => 'application/json', 'Content-Type' => $options['contentType'], 'User-Agent' => $client->getUserAgent()], $client->getHeaders());
     $request = new Request($options['method'], $client->getApiUrl() . $client->getApiBasePath() . $endPoint, $headers);
     $requestOptions = [];
     if (!empty($options['multipart'])) {
         $request = $request->withoutHeader('Content-Type');
         $requestOptions['multipart'] = $options['multipart'];
     } elseif (!empty($options['postFields'])) {
         $request = $request->withBody(\GuzzleHttp\Psr7\stream_for(json_encode($options['postFields'])));
     } elseif (!empty($options['file'])) {
         if (is_file($options['file'])) {
             $fileStream = new LazyOpenStream($options['file'], 'r');
             $request = $request->withBody($fileStream);
         }
     }
     if (!empty($options['queryParams'])) {
         foreach ($options['queryParams'] as $queryKey => $queryValue) {
             $uri = $request->getUri();
             $uri = $uri->withQueryValue($uri, $queryKey, $queryValue);
             $request = $request->withUri($uri, true);
         }
     }
     // \RockstarGames\Cake\Log\Log::debug($request);
     // \RockstarGames\Cake\Log\Log::debug($options);
     try {
         list($request, $requestOptions) = $client->getAuth()->prepareRequest($request, $requestOptions);
         $response = $client->guzzle->send($request, $requestOptions);
     } catch (RequestException $e) {
         $requestException = RequestException::create($e->getRequest(), $e->getResponse());
         throw new ApiResponseException($requestException);
     } finally {
         $client->setDebug($request->getHeaders(), $request->getBody()->getContents(), isset($response) ? $response->getStatusCode() : null, isset($response) ? $response->getHeaders() : null, isset($e) ? $e : null);
         $request->getBody()->rewind();
     }
     if (isset($file)) {
         fclose($file);
     }
     $client->setSideload(null);
     return json_decode($response->getBody()->getContents());
 }

 /**
  * Test we can handle api exceptions when no response is returned from the API
  *
  * @expectedException Zendesk\API\Exceptions\ApiResponseException
  * @expectedExceptionMessage Error completing request
  */
 public function testHandlesEmptyResponse()
 {
     // Create an exception object which is thrown when a response couldn't be retrieved
     $unsuccessfulResponse = RequestException::create(new Request('GET', 'foo'), null);
     $this->mockApiResponses($unsuccessfulResponse);
     $this->dummyResource->create(['foo' => 'bar']);
 }

 public function testHasStatusCodeAsExceptionCode()
 {
     $e = RequestException::create(new Request('GET', '/'), new Response(442));
     $this->assertEquals(442, $e->getCode());
 }

 /**
  * Check if a document exists.
  * 
  * {@internal It would be nice to do a HEAD requests here, but APIs often don't support it}}
  * 
  * @param string|array $id   ID or filter
  * @param array        $opts
  * @return boolean
  */
 public static function exists($id, array $opts = [])
 {
     $filter = is_array($id) ? $id : static::idToFilter($id);
     $query = static::filterToQuery($filter);
     $opts['parse'] = false;
     $opts['http_errors'] = false;
     $method = static::getExistsMethod();
     $response = static::getDB()->request($method, static::getUri(), compact('query') + $opts);
     $statusCode = $response->getStatusCode();
     if ($statusCode >= 400 && $statusCode != 404) {
         $request = static::getDB()->createRequest($method, static::getUri(), $query);
         throw RequestException::create($request, $response);
     }
     return $statusCode < 300;
     // Any 2xx code
 }

 /**
  * Handles all api calls
  * 
  * @param string $uri
  * @param array $params
  * @return array
  * @throws \Exception
  */
 public function getRequest($uri, array $params = [])
 {
     // validate uri
     if (!is_string($uri)) {
         throw new InvalidArgumentException("Invalid uri {$uri} submitted.");
     }
     // make sure uri isn't absolute - remove first / if there
     if ($uri[0] == '/') {
         $uri = substr($uri, 1);
     }
     try {
         $request = $this->client->createRequest('GET', $uri, ['query' => $params]);
         $response = $this->client->send($request)->json();
         // cairo returns 200 even for errors so check response for error
         // errors array can have multiple, which do we show? create one string for all?
         if (!empty($response['errors'])) {
             throw RequestException::create($request, new Response($response['errors'][0]['code'], [], null, ['reason_phrase' => $response['errors'][0]['messages'][0]]));
         }
     } catch (RequestException $e) {
         $message = $e->getRequest() . "\n";
         if ($e->hasResponse()) {
             $message .= $e->getResponse() . "\n";
         }
         throw new Exception($message, $e->getCode());
     }
     return $response;
 }