/** * {@inheritDoc} */ public function populateFromResponse(ResponseInterface $response) { $entries = $response->json()['access']['serviceCatalog']; foreach ($entries as $entry) { $this->entries[] = $this->model('Entry', $entry); } }
/** * Creates a response object * @param ResponseInterface $responseInterface * @throws ParseException */ public function __construct(ResponseInterface $responseInterface) { $this->response = $responseInterface->json(); $this->status = isset($this->response['meta']['code']) ? $this->response['meta']['code'] : 500; $this->errorCode = isset($this->response['meta']['error_code']) ? $this->response['meta']['error_code'] : null; $this->responseErrorCodes = new ResponseErrorCodes(); }
/** * @param ResponseInterface $response */ private function handleResponse(ResponseInterface $response, Request $request) { $context = $this->prepareBaseContext($request); $data = $response->json(); if (isset($data['results'])) { foreach ($data['results'] as $registrationIdIdx => $result) { $context['registrationId'] = $this->registrationIds[$registrationIdIdx]; $context['result'] = var_export($result, true); switch (key($result)) { case 'message_id': if (isset($result['registration_id'])) { $this->callback(EventsEnum::ON_PUSH_SUCCESS_BUT_NEED_NEW_ID, [$context]); } else { $this->callback(EventsEnum::ON_PUSH_SUCCESS, [$context]); } break; case 'error': $currentResult = current($result); switch ($currentResult) { case 'Unavailable': $this->callback(EventsEnum::ON_PUSH_UNAVAILABLE, [$context]); break; case 'InvalidRegistration': $this->callback(EventsEnum::ON_PUSH_INVALID_REGISTRATION, [$context]); break; case 'NotRegistered': $this->callback(EventsEnum::ON_PUSH_NOT_REGISTERED, [$context]); break; } break; } } } return ['success' => $data['success'], 'failure' => $data['failure']]; }
/** * Decode an HTTP Response. * @static * @throws Google_Service_Exception * @param GuzzleHttp\Message\RequestInterface $response The http response to be decoded. * @param GuzzleHttp\Message\ResponseInterface $response * @return mixed|null */ public static function decodeHttpResponse(ResponseInterface $response, RequestInterface $request = null) { $body = (string) $response->getBody(); $code = $response->getStatusCode(); $result = null; // return raw response when "alt" is "media" $isJson = !($request && 'media' == $request->getQuery()->get('alt')); // set the result to the body if it's not set to anything else if ($isJson) { try { $result = $response->json(); } catch (ParseException $e) { $result = $body; } } else { $result = $body; } // retry strategy if (intVal($code) >= 300) { $errors = null; // Specific check for APIs which don't return error details, such as Blogger. if (isset($result['error']) && isset($result['error']['errors'])) { $errors = $result['error']['errors']; } throw new Google_Service_Exception($body, $code, null, $errors); } return $result; }
public function it_handle_unexpected_oboom_response(Client $guzzleClient, ResponseInterface $response) { $url = 'http://example.com'; $response->json()->shouldBeCalled()->willReturn([400]); $guzzleClient->get($url, ['query' => []])->willReturn($response); $this->shouldThrow(new RuntimeException('API error', 400))->during('call', [$url]); }
public function getCount($content, ResponseInterface $response = null) { $data = $response->json(); if (empty($data)) { return false; } return (int) array_shift($data)['shares']; }
function it_should_return_results_as_an_object(ClientInterface $client, ResponseInterface $response) { $params = 'key=' . $this->test_key . '&hero_id=12345&skill=2'; $expectedUrl = $this->test_base_url . 'IDOTA2Match_570/GetMatchDetails/v001/?' . $params; $responseReturn = json_decode('{"result": {"status": 1, "num_results": 0, "total_results": 407, "results_remaining": 307} }'); $response->json(['object' => true])->shouldBeCalled()->willReturn($responseReturn); $client->get($expectedUrl)->shouldBeCalled()->willReturn($response); $this->endpoint('IDOTA2Match_570/GetMatchDetails/v001')->options(['hero_id' => 12345, 'skill' => 2])->get()->shouldReturn($responseReturn); }
public function before(CommandInterface $command, ResponseInterface $response, Parameter $model, &$result, array $context = []) { $this->json = $response->json() ?: []; // relocate named arrays, so that they have the same structure as // arrays nested in objects and visit can work on them in the same way if ($model->getType() == 'array' && ($name = $model->getName())) { $this->json = [$name => $this->json]; } }
/** * Populates the current resource from a response object. * * @param ResponseInterface $response * * @return $this|ResourceInterface */ public function populateFromResponse(ResponseInterface $response) { if (strpos($response->getHeader('Content-Type'), 'application/json') === 0) { $json = $response->json(); if (!empty($json)) { $this->populateFromArray($this->flatten($json)); } } return $this; }
public function __construct(ResponseInterface $response) { try { $this->details = $response->json(); $message = isset($this->details['error']['message']) ? $this->details['error']['message'] : $response->getReasonPhrase(); } catch (ParseException $e) { $message = $response->getReasonPhrase(); } parent::__construct(sprintf('The request failed and returned an invalid status code ("%d") : %s', $response->getStatusCode(), $message), $response->getStatusCode()); }
/** * Checks that response body contains JSON from PyString. * * Do not check that the response body /only/ contains the JSON from PyString, * * @param PyStringNode $jsonString * * @throws \RuntimeException * * @Then /^(?:the )?response should contain json:$/ */ public function theResponseShouldContainJson(PyStringNode $jsonString) { $etalon = json_decode($this->replacePlaceHolder($jsonString->getRaw()), true); $actual = $this->response->json(); if (null === $etalon) { throw new \RuntimeException("Can not convert etalon to json:\n" . $this->replacePlaceHolder($jsonString->getRaw())); } $factory = new SimpleFactory(); $matcher = $factory->createMatcher(); Assertions::assertTrue($matcher->match($actual, $etalon)); }
/** * Asserts response match with the response schema. * * @param ResponseInterface $response * @param SchemaManager $schemaManager * @param string $path percent-encoded path used on the request. * @param string $httpMethod * @param string $message */ public function assertResponseMatch(ResponseInterface $response, SchemaManager $schemaManager, $path, $httpMethod, $message = '') { $this->assertResponseMediaTypeMatch($response->getHeader('Content-Type'), $schemaManager, $path, $httpMethod, $message); $httpCode = $response->getStatusCode(); $headers = $response->getHeaders(); foreach ($headers as &$value) { $value = implode(', ', $value); } $this->assertResponseHeadersMatch($headers, $schemaManager, $path, $httpMethod, $httpCode, $message); $this->assertResponseBodyMatch($response->json(['object' => true]), $schemaManager, $path, $httpMethod, $httpCode, $message); }
public function __construct(RequestInterface $request, ResponseInterface $response) { $payload = $response->json(); $this->id = $payload['id']; $result = $payload['result']; $this->status = []; if (isset($result['status'])) { $this->status = $result['status']; unset($result['status']); } parent::__construct($result); }
/** * Checks that response body contains JSON from PyString. * * Do not check that the response body /only/ contains the JSON from PyString, * * @param PyStringNode $jsonString * * @throws \RuntimeException * * @Then /^(?:the )?response should contain json:$/ */ public function theResponseShouldContainJson(PyStringNode $jsonString) { $etalon = json_decode($this->replacePlaceHolder($jsonString->getRaw()), true); $actual = $this->response->json(); if (null === $etalon) { throw new \RuntimeException("Can not convert etalon to json:\n" . $this->replacePlaceHolder($jsonString->getRaw())); } Assertions::assertGreaterThanOrEqual(count($etalon), count($actual)); foreach ($etalon as $key => $needle) { Assertions::assertArrayHasKey($key, $actual); Assertions::assertEquals($etalon[$key], $actual[$key]); } }
/** * Creates a new Funnelback response. * * @param \GuzzleHttp\Message\ResponseInterface $http_response * The http response. */ public function __construct(ResponseInterface $http_response) { $this->httpResponse = $http_response; $this->responseJson = $http_response->json(); $this->query = $this->responseJson['question']['query']; $response = $this->responseJson['response']; $this->returnCode = $response['returnCode']; $this->totalTimeMillis = $response['performanceMetrics']['totalTimeMillis']; $result_packet = $response['resultPacket']; $this->resultsSummary = new ResultSummary($result_packet['resultsSummary']); $this->results = $this->buildResults($result_packet['results']); $this->facets = $this->buildFacets($response['facets']); }
/** * Create Job Search for $subscriptionId * * @param $subscriptionId * @param $search * @param $location * @param $createTime * * @return bool|mixed */ public function createJobSearch($subscriptionId, $search, $location, $createTime) { $request = ['search' => $search, 'location' => $location, 'create_time' => $createTime]; $url = 'subscriber/' . $subscriptionId . '/searches'; if ($this->isExpandedResults()) { $url .= '?expand_results=1'; } $this->response = $this->client->post($url, ['body' => $request]); if (201 == $this->response->getStatusCode()) { return $this->response->json(); } return false; }
/** * Sends a request with error handling * * @param RequestInterface $request */ protected function send(RequestInterface $request) { try { $this->response = $this->client->send($request); $this->jsonResponse = $this->response->json(); } catch (ClientException $e) { $this->response = $e->getResponse(); //when 404 or 401 or 403 or something else $this->jsonResponse = $this->response->getBody()->getContents(); if (null === $this->response) { throw $e; } } }
/** * @param CompleteEvent $event * * @throws \RuntimeException|ExceptionInterface */ protected function handleResponse(CompleteEvent $event) { $this->response = $event->getResponse(); if ($this->response->getStatusCode() >= 200 && $this->response->getStatusCode() <= 299) { return; } $body = $this->response->getBody(); $code = $this->response->getStatusCode(); if ($this->exception) { throw $this->exception->create($body, $code); } $content = $this->response->json(); throw new \RuntimeException(sprintf('[%d] %s (%s)', $code, $content->message, $content->id), $code); }
/** * Formats a multi-level, JSON-formatted response. * * @param ResponseInterface $response Guzzle response object. * @param OutputInterface $output Symfony Console output object. * @param string $key A response key to pull-out and highlight. Should be the most * important identifier for the result. * @return void * * @SuppressWarnings(PHPMD.ElseExpression) */ public static function handleArrayResponse(ResponseInterface $response, OutputInterface $output, $key = null) { $output->getFormatter()->setStyle('status', self::formatter()->info); if ($response->getBody()) { $data = $response->json(); foreach ($data as $i => $d) { $output->writeln(''); if ($key) { $output->writeln(sprintf('<status> Result #%s (%s: %s) </status>', $i + 1, $key, $d[$key])); } else { $output->writeln(sprintf('<status> Result #%s </status>', $i + 1)); } self::asTable($d, $output); } } }
/** * Makes sure the Diffbot response has all the fields it needs to work properly * * @todo: remove error avoidance when issue 12 is fixed: https://github.com/Swader/diffbot-php-client/issues/12 * @param Response $response * @throws DiffbotException */ protected function checkResponseFormat(Response $response) { set_error_handler(function () { /* ignore errors */ }); $arr = $response->json(['big_int_strings' => true]); restore_error_handler(); if (isset($arr['error'])) { throw new DiffbotException('Diffbot returned error ' . $arr['errorCode'] . ': ' . $arr['error']); } $required = ['objects' => 'Objects property missing - cannot extract entity values', 'request' => 'Request property not found in response!']; foreach ($required as $k => $v) { if (!isset($arr[$k])) { throw new DiffbotException($v); } } }
/** * Extract more detailed error message. * * @param Response $response * @return string */ protected function getErrorMessage(Response $response) { // This is the default: $error = $response->getReasonPhrase(); // e.g. "Bad Request" try { // We might be able to fetch an error message from the response $responseData = $response->json(); if (isset($responseData['title'])) { $error = $responseData['title']; } if (isset($responseData['detail'])) { $error .= ': ' . $responseData['detail']; } } catch (ParseException $e) { // Do nothing } return (string) $error; }
/** * Decode an HTTP Response. * @static * @throws Google_Service_Exception * @param GuzzleHttp\Message\RequestInterface $response The http response to be decoded. * @param GuzzleHttp\Message\ResponseInterface $response * @return mixed|null */ public static function decodeHttpResponse(ResponseInterface $response, RequestInterface $request = null) { $body = (string) $response->getBody(); $code = $response->getStatusCode(); // retry strategy if (intVal($code) >= 300) { $errors = null; $result = $response->json(); // Specific check for APIs which don't return error details, such as Blogger. if (isset($result['error']) && isset($result['error']['errors'])) { $errors = $result['error']['errors']; } throw new Google_Service_Exception($body, $code, null, $errors); } // return raw response when "alt" is "media" if ($request && $request->getQuery()->get('alt') == 'media') { return $body; } return $response->json(); }
/** * Extract more detailed error message. * * @param Response $response * @return string */ protected function extractErrorMessage(Response $response) { // This is the default $error = $response->getReasonPhrase(); // e.g. "Bad Request" try { // We might be able to fetch an error message from the response $responseData = $response->json(); if (isset($responseData['results'])) { $result = $responseData['results']; if (isset($result['errors']) && is_array($result['errors']) && count($result['errors']) > 0) { $error = current($result['errors']); } elseif (isset($result['error'])) { $error = $result['error']; } } } catch (ParseException $e) { // Do nothing } return (string) $error; }
public function normalize(ResponseInterface $response) { return $response->json(); }
public function it_should_return_suggestedQueries(ResponseInterface $mockedResponse) { $mockedResponse->json()->shouldBeCalled()->willReturn('searchSuggestedQueries'); $this->suggestedQueries('query')->shouldReturn('searchSuggestedQueries'); }
/** * Returns the response in the configured format. * * @param ResponseInterface $response * @param string $format * * @return mixed $response */ private function responseFormat($response, $format) { if ($format == 'json') { return $response->json(); } elseif ($format == 'xml') { return $response->xml(); } return $response; }
/** * @return mixed */ public function json() { return $this->response->json(); }
function it_sends_post_and_returns_result(MethodInterface $method, Client $client, RequestInterface $request, ResponseInterface $response) { $response->json()->shouldBeCalled()->willReturn(['foo' => 'bar']); $client->send($request)->shouldBeCalled()->willReturn($response); $this->sendRequest($method, 'POST', 'https://api.cardinity.com/v1/', [])->shouldReturn(['foo' => 'bar']); }
public function getCount($content, ResponseInterface $response = null) { $data = $response->json(); return (int) $data['count']; }
function it_creates_resource_with_body_for_a_specific_uri_with_uri_parameters($client, $adapterFactory, $paginatorFactory, ResponseInterface $response) { $this->beConstructedWith($client, 'parentUri/{parentId}/uri', $adapterFactory, $paginatorFactory); $response->getHeader('Content-Type')->willReturn('application/json'); $response->json()->willReturn(['id' => 1, 'field1' => 'field1Value', 'field2' => 'field2Value']); $client->post('parentUri/2/uri/', ['field1' => 'field1Value', 'field2' => 'field2Value'], [])->willReturn($response)->shouldBeCalled(); $this->create(['field1' => 'field1Value', 'field2' => 'field2Value'], ['parentId' => 2])->shouldReturn(['id' => 1, 'field1' => 'field1Value', 'field2' => 'field2Value']); }