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

 /**
  * Create the request exception.
  *
  * @param Request               $request
  * @param RequestException|null $previousException
  *
  * @throws HttpRequestException
  */
 protected function handleRequestException(Request $request, RequestException $previousException)
 {
     if (null !== $previousException && null == $previousException->getResponse()) {
         throw new NullResponseException($this->request, $previousException);
     }
     throw $this->createApiException($request, $this->createResponse($previousException->getResponse()), $previousException);
 }

 public function testWrapsConnectExceptions()
 {
     $e = new ConnectException('foo');
     $r = new Request('GET', 'http://www.oo.com');
     $ex = RequestException::wrapException($r, $e);
     $this->assertInstanceOf('GuzzleHttp\\Exception\\ConnectException', $ex);
 }

 public function __construct(RequestException $e)
 {
     $response = $e->getResponse();
     $message = $response->getReasonPhrase();
     $level = floor($response->getStatusCode() / 100);
     // Check if business-level error message
     // https://developer.zendesk.com/rest_api/docs/core/introduction#requests
     if ($response->getHeaderLine('Content-Type') == 'application/json; charset=UTF-8') {
         $responseBody = json_decode($response->getBody()->getContents());
         $this->errorDetails = $responseBody->details;
         $message = $responseBody->description . "\n" . 'Errors: ' . print_r($this->errorDetails, true);
     } elseif ($level == '5') {
         $message = 'Zendesk may be experiencing internal issues or undergoing scheduled maintenance.';
     }
     parent::__construct($message, $response->getStatusCode());
 }

 /**
  * Sends an HTTP request.
  *
  * @param RequestInterface $request Request to send.
  * @param array            $options Request transfer options.
  *
  * @return PromiseInterface
  */
 public function __invoke(RequestInterface $request, array $options)
 {
     // Sleep if there is a delay specified.
     if (isset($options['delay'])) {
         usleep($options['delay'] * 1000);
     }
     $startTime = isset($options['on_stats']) ? microtime(true) : null;
     try {
         // Does not support the expect header.
         $request = $request->withoutHeader('Expect');
         // Append a content-length header if body size is zero to match
         // cURL's behavior.
         if (0 === $request->getBody()->getSize()) {
             $request = $request->withHeader('Content-Length', 0);
         }
         return $this->createResponse($request, $options, $this->createStream($request, $options), $startTime);
     } catch (\InvalidArgumentException $e) {
         throw $e;
     } catch (\Exception $e) {
         // Determine if the error was a networking error.
         $message = $e->getMessage();
         // This list can probably get more comprehensive.
         if (strpos($message, 'getaddrinfo') || strpos($message, 'Connection refused') || strpos($message, "couldn't connect to host")) {
             $e = new ConnectException($e->getMessage(), $request, $e);
         }
         $e = RequestException::wrapException($request, $e);
         $this->invokeStats($options, $request, $startTime, null, $e);
         return new RejectedPromise($e);
     }
 }

 public function __construct(RequestException $e)
 {
     $response = $e->getResponse();
     $message = $response->getReasonPhrase() . " [status code] " . $response->getStatusCode();
     $level = floor($response->getStatusCode() / 100);
     // Check if business-level error message
     // https://developer.zendesk.com/rest_api/docs/core/introduction#requests
     if ($level == '4') {
         $responseBody = $response->getBody()->getContents();
         $this->errorDetails = $responseBody;
         $message .= ' [details] ' . $this->errorDetails;
     } elseif ($level == '5') {
         $message .= ' [details] Zendesk may be experiencing internal issues or undergoing scheduled maintenance.';
     }
     parent::__construct($message, $response->getStatusCode());
 }