PHP Exception\RequestException类代码示例

 public function testInterceptsWithEvent()
 {
     $client = new Client();
     $request = new Request('GET', '/');
     $response = new Response(404);
     $transaction = new Transaction($client, $request);
     $except = new RequestException('foo', $request, $response);
     $event = new ErrorEvent($transaction, $except);
     $event->throwImmediately(true);
     $this->assertTrue($except->getThrowImmediately());
     $event->throwImmediately(false);
     $this->assertFalse($except->getThrowImmediately());
     $this->assertSame($except, $event->getException());
     $this->assertSame($response, $event->getResponse());
     $this->assertSame($request, $event->getRequest());
     $res = null;
     $request->getEmitter()->on('complete', function ($e) use(&$res) {
         $res = $e;
     });
     $good = new Response(200);
     $event->intercept($good);
     $this->assertTrue($event->isPropagationStopped());
     $this->assertSame($res->getClient(), $event->getClient());
     $this->assertSame($good, $res->getResponse());
 }

 /**
  * @internal
  * @param RequestException $e
  * @return AccessDeniedException|ApiException|AuthenticationException|ConflictingStateException|
  * MethodNotAllowedException|NotFoundException|RateLimitExceededException|UnsupportedAcceptHeaderException|
  * UnsupportedContentTypeException|ValidationException
  */
 public static function create(RequestException $e)
 {
     if ($response = $e->getResponse()) {
         switch ($response->getStatusCode()) {
             case 400:
                 return new ValidationException($e);
             case 401:
                 return new AuthenticationException($e);
             case 403:
                 return new AccessDeniedException($e);
             case 404:
                 return new NotFoundException($e);
             case 405:
                 return new MethodNotAllowedException($e);
             case 406:
                 return new UnsupportedAcceptHeaderException($e);
             case 409:
                 return new ConflictingStateException($e);
             case 415:
                 return new UnsupportedContentTypeException($e);
             case 429:
                 return new RateLimitExceededException($e);
         }
     }
     return new ApiException($e);
 }

 /**
  * Handles a Request Exception.
  *
  * @param RequestException $e The request exception.
  *
  * @return void
  */
 protected function onRequestException(RequestException $e)
 {
     $request = $e->getRequest();
     $response = $e->getResponse();
     $statusCode = $response->getStatusCode();
     $isClientError = $response->isClientError();
     $isServerError = $response->isServerError();
     if ($isClientError || $isServerError) {
         $content = $response->getContent();
         $error = $response->getError();
         $description = $response->getErrorDescription();
         if (400 === $statusCode) {
             throw new BadRequestException($description, $error, $statusCode, $response, $request);
         }
         if (401 === $statusCode) {
             $otp = (string) $response->getHeader('X-Bitreserve-OTP');
             if ('required' === $otp) {
                 $description = 'Two factor authentication is enabled on this account';
                 throw new TwoFactorAuthenticationRequiredException($description, $error, $statusCode, $response, $request);
             }
             throw new AuthenticationRequiredException($description, $error, $statusCode, $response, $request);
         }
         if (404 === $statusCode) {
             $description = sprintf('Object or route not found: %s', $request->getPath());
             throw new NotFoundException($description, 'not_found', $statusCode, $response, $request);
         }
         if (429 === $statusCode) {
             $rateLimit = $response->getApiRateLimit();
             $description = sprintf('You have reached Bitreserve API limit. API limit is: %s. Your remaining requests will be reset at %s.', $rateLimit['limit'], date('Y-m-d H:i:s', $rateLimit['reset']));
             throw new ApiLimitExceedException($description, $error, $statusCode, $response, $request);
         }
         throw new RuntimeException($description, $error, $statusCode, $response, $request);
     }
 }

 private function handleException(RequestException $exception)
 {
     if ($exception instanceof BadResponseException) {
         return $exception->getResponse();
     }
     throw new Exception($exception->getMessage());
 }

 private function manejar_excepcion_request(RequestException $e)
 {
     $msg = $e->getRequest() . "\n";
     if ($e->hasResponse()) {
         $msg .= $e->getResponse() . "\n";
     }
     throw new toba_error($msg);
 }

    protected function failBecauseOfHttpError(RequestException $e)
    {
        $this->fail(sprintf(<<<'EOL'
failed to create user: HTTP ERROR
%s
EOL
, $e->getMessage()));
    }

 protected function handleError(RequestException $e)
 {
     $response = $e->getResponse();
     switch ($response->getStatusCode()) {
         case 404:
             throw new Exceptions\NotFoundException($this->getResponseError($response));
         default:
             throw new Exceptions\MeshException($this->getResponseError($response));
     }
 }

 /**
  * throwRequestException
  *
  * @param \GuzzleHttp\Exception\RequestException $e
  * @param string $className
  * @throws Exceptions\RequestException
  */
 protected function throwRequestException($e, $className)
 {
     $response = $e->getResponse();
     $rawBody = (string) $response->getBody();
     $body = json_decode((string) $rawBody);
     $body = $body === null ? $rawBody : $body;
     $exception = new $className($e->getMessage(), $e->getCode());
     $exception->setBody($body);
     throw $exception;
 }

 public function __construct(RequestException $e, $message = '')
 {
     $prefix = $message ?: "Bad response from the WIU API";
     if ($e->getCode()) {
         $prefix .= " (HTTP status {$e->getCode()})";
     }
     $response = $e->getResponse();
     $body = $response->json();
     $message = isset($body['message']) ? $body['message'] : $response->getReasonPhrase();
     parent::__construct("{$prefix}: {$message}", $e->getCode(), null);
 }

 /**
  * @param GuzzleHttpRequestException $exception
  * @return Client\ClientException
  */
 private static function createClientException(GuzzleHttpRequestException $exception)
 {
     $exceptionArray = array(400 => 'BadRequest', 401 => 'Unauthorized', 403 => 'Forbidden', 404 => 'NotFound', 405 => 'MethodNotAllowed', 406 => 'NotAcceptable');
     foreach ($exceptionArray as $item => $value) {
         if ($item === $exception->getCode()) {
             $exceptionName = __NAMESPACE__ . '\\Client\\' . $value . 'Exception';
             return new $exceptionName($exception);
         }
     }
     return new RequestException($exception);
 }

 /**
  * Captch known exceptions
  * @param RequestException $e
  * @throws BolException
  * @throws \Exception
  */
 public function handle(RequestException $e)
 {
     $response = $e->getResponse();
     $statusCode = $response->getStatusCode();
     $this->handleStatusCode($statusCode);
     $body = $response->getBody(true);
     $message = $this->xmlParser->parse($body);
     if (isset($message['ErrorCode'])) {
         throw new BolException($message['ErrorMessage'], $message['ErrorCode']);
     }
     throw new \Exception("Unknown error occurred. Status code: {$response->getStatusCode()}.");
 }

 /**
  * Wraps an API exception in the appropriate domain exception.
  *
  * @param RequestException $e The API exception
  *
  * @return HttpException
  */
 public static function wrap(RequestException $e)
 {
     $response = $e->getResponse();
     if ($errors = self::errors($response)) {
         $class = self::exceptionClass($response, $errors[0]);
         $message = implode(', ', array_map('strval', $errors));
     } else {
         $class = self::exceptionClass($response);
         $message = $e->getMessage();
     }
     return new $class($message, $errors, $e->getRequest(), $response, $e);
 }

 /**
  * @param RequestException $exception
  *
  * @return ApnsException
  */
 private static function factoryException(RequestException $exception)
 {
     $response = $exception->getResponse();
     if (null === $response) {
         return new ApnsException('Unknown network error', 0, $exception);
     }
     try {
         $contents = $response->getBody()->getContents();
     } catch (\Exception $e) {
         return new ApnsException('Unknown network error', 0, $e);
     }
     return ExceptionFactory::factoryException($response->getStatusCode(), $contents, $exception);
 }

 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 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());
     }
 }