/**
* @param ResponseInterface $response
*
* @return ApiResult
*/
protected function _getResult($response)
{
if (!$response instanceof ResponseInterface) {
throw new \InvalidArgumentException("{$response} should be an instance of ResponseInterface");
}
$result = new ApiResult();
$result->setStatusCode($response->getStatusCode());
$callId = $response->getHeader('X-Call-Id');
if (!empty($callId)) {
$result->setCallId($callId);
}
$decoded = json_decode((string) $response->getBody());
if (isset($decoded->meta) && isset($decoded->data) && isset($decoded->meta->code) && $decoded->meta->code == $response->getStatusCode()) {
$meta = $decoded->meta;
$data = $decoded->data;
if (isset($meta->message)) {
$result->setStatusMessage($meta->message);
}
$result->setContent(json_encode($data));
} else {
$result->setContent((string) $response->getBody());
}
$result->setHeaders($response->getHeaders());
return $result;
}
public function save(RequestInterface $request, ResponseInterface $response)
{
$ttl = (int) $request->getConfig()->get('cache.ttl');
$key = $this->getCacheKey($request);
// Persist the response body if needed
if ($response->getBody() && $response->getBody()->getSize() > 0) {
$this->cache->save($key, array('code' => $response->getStatusCode(), 'headers' => $response->getHeaders(), 'body' => (string) $response->getBody()), $ttl);
$request->getConfig()->set('cache.key', $key);
}
}
/**
* @Then The CalDAV HTTP status code should be :code
*/
public function theCaldavHttpStatusCodeShouldBe($code)
{
if ((int) $code !== $this->response->getStatusCode()) {
throw new \Exception(sprintf('Expected %s got %s', (int) $code, $this->response->getStatusCode()));
}
$body = $this->response->getBody()->getContents();
if ($body && substr($body, 0, 1) === '<') {
$reader = new Sabre\Xml\Reader();
$reader->xml($body);
$this->responseXml = $reader->parse();
}
}
/**
* @param RequestInterface|ResponseInterface $message
* @return string
*/
protected function formatBody($message)
{
$header = $message->getHeader('Content-Type');
if (JsonStringFormatter::isJsonHeader($header)) {
$formatter = new JsonStringFormatter();
return $formatter->format($message->getBody());
} elseif (XmlStringFormatter::isXmlHeader($header)) {
$formatter = new XmlStringFormatter();
return $formatter->format($message->getBody());
}
$factory = new StringFactoryFormatter();
return $factory->format($message->getBody());
}
protected function setStatusTestingApp($enabled)
{
$this->sendingTo($enabled ? 'post' : 'delete', '/cloud/apps/testing');
$this->theHTTPStatusCodeShouldBe('200');
$this->theOCSStatusCodeShouldBe('100');
$this->sendingTo('get', '/cloud/apps?filter=enabled');
$this->theHTTPStatusCodeShouldBe('200');
if ($enabled) {
PHPUnit_Framework_Assert::assertContains('testing', $this->response->getBody()->getContents());
} else {
PHPUnit_Framework_Assert::assertNotContains('testing', $this->response->getBody()->getContents());
}
}
/**
* @throws HttpException
*/
protected function handleError()
{
$body = (string) $this->response->getBody();
$code = (int) $this->response->getStatusCode();
$content = json_decode($body);
throw new HttpException(isset($content->message) ? $content->message : 'Request not processed.', $code);
}
public function decode(ResponseInterface $raw, $totalTime = 0)
{
$executionTime = $callTime = 0;
if ($raw->hasHeader('X-Execution-Time')) {
$executionTime = $raw->getHeader('X-Execution-Time');
}
if ($raw->hasHeader('X-Call-Time')) {
$callTime = $raw->getHeader('X-Call-Time');
}
$body = '';
try {
$body = (string) $raw->getBody();
$result = $this->_getDecoder()->decode($body, self::FORMAT, $this->_getDecodeContext());
} catch (\Exception $e) {
if (!empty($body)) {
$body = ' (' . $body . ')';
}
error_log("Invalid API Response: " . $body);
throw new InvalidApiResponseException("Unable to decode raw api response.", 500, $e);
}
if (!property_exists($result, 'type') || !property_exists($result, 'status') || !property_exists($result, 'result') || !property_exists($result->status, 'message') || !property_exists($result->status, 'code')) {
error_log("Invalid API Result: " . json_encode($result));
throw new InvalidApiResponseException("Invalid api result", 500);
}
if ($executionTime === 0) {
$executionTime = $totalTime;
}
if ($callTime === 0) {
$callTime = $executionTime;
}
return ResponseBuilder::create(ApiCallData::create($result->type, $result->result, $result->status->code, $result->status->message, (double) str_replace([',', 'ms'], '', $totalTime), (double) str_replace([',', 'ms'], '', $executionTime), (double) str_replace([',', 'ms'], '', $callTime)));
}
/**
* 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;
}
/**
* Returns all tags for a given user
*
* @param string $user
* @return array
*/
private function requestTagsForUser($user)
{
try {
$request = $this->client->createRequest('PROPFIND', $this->baseUrl . '/remote.php/dav/systemtags/', ['body' => '<?xml version="1.0"?>
<d:propfind xmlns:d="DAV:" xmlns:oc="http://owncloud.org/ns">
<d:prop>
<oc:id />
<oc:display-name />
<oc:user-visible />
<oc:user-assignable />
</d:prop>
</d:propfind>', 'auth' => [$user, $this->getPasswordForUser($user)], 'headers' => ['Content-Type' => 'application/json']]);
$this->response = $this->client->send($request);
} catch (\GuzzleHttp\Exception\ClientException $e) {
$this->response = $e->getResponse();
}
$tags = [];
$service = new Sabre\Xml\Service();
$parsed = $service->parse($this->response->getBody()->getContents());
foreach ($parsed as $entry) {
$singleEntry = $entry['value'][1]['value'][0]['value'];
if (empty($singleEntry[0]['value'])) {
continue;
}
$tags[$singleEntry[0]['value']] = ['display-name' => $singleEntry[1]['value'], 'user-visible' => $singleEntry[2]['value'], 'user-assignable' => $singleEntry[3]['value']];
}
return $tags;
}
function it_should_make_post_request(ResponseInterface $responce)
{
$responce->getHeader("Content-Type")->willReturn('blablaxmlblabla');
$responce->getBody()->willReturn('<xml></xml>');
$this->client->post(Argument::any(), Argument::any())->willReturn($responce);
$responce->xml()->willReturn(new \SimpleXMLElement('<xml></xml>'));
$this->post(Argument::type('string'))->shouldBeAnInstanceOf('Bxav\\Component\\ResellerClub\\Model\\XmlResponse');
}
/**
* @param ResponseInterface $response raw json response
* @param bool $throw Should throw API errors as exceptions
*
* @throws \Exception
*/
public function __construct(ResponseInterface $response = null, $throw = true)
{
if ($response !== null) {
$this->_executionTime = $response->getHeader('X-Execution-Time');
$this->_callTime = $response->getHeader('X-Call-Time');
$this->readJson((string) $response->getBody(), $throw);
}
}
function it_should_return_a_service_response_when_verifying_an_ipn_message(Client $httpClient, Message $message, ResponseInterface $response)
{
$response->getBody()->willReturn('foo');
$httpClient->post(Argument::type('string'), Argument::type('array'))->willReturn($response);
$message->getAll()->willReturn(['foo' => 'bar']);
$response = $this->verifyIpnMessage($message);
$response->shouldHaveType('Mdb\\PayPal\\Ipn\\ServiceResponse');
$response->getBody()->shouldReturn('foo');
}
/**
* @param ResponseInterface|Response6Interface $response
*
* @return string
*
* @throws CommunicationException
*/
public static function getRawResponseBody($response)
{
$statusCode = $response->getStatusCode();
$rawResponse = $response->getBody()->getContents();
if ($statusCode != 200) {
throw CommunicationException::createFromHTTPResponse($statusCode, $rawResponse);
}
return $rawResponse;
}
/**
* @throws ApiException
*/
protected function handleError($getCode = false)
{
$code = (int) $this->response->getStatusCode();
if ($getCode) {
return $code;
}
$content = (string) $this->response->getBody();
$this->reportError($code, $content);
}
/**
* @param \GuzzleHttp\Message\ResponseInterface $response
* @return Language[]
*/
public function processResponse(\GuzzleHttp\Message\ResponseInterface $response)
{
$xml = simplexml_load_string($response->getBody()->getContents());
$languages = [];
foreach ($xml->string as $language) {
$languages[] = new Language($language);
}
return $languages;
}
private function getExpected(ResponseInterface $response)
{
if (!($body = $response->getBody())) {
return false;
} elseif ($response->hasHeader('Transfer-Encoding') || $response->hasHeader('Content-Encoding')) {
// Currently does not support un-gzipping or inflating responses
return false;
}
return call_user_func($this->expectedFn, $response);
}
/**
* @param ResponseInterface|Response6Interface $response
*
* @return string
*
* @throws CommunicationException
*/
public static function getRawResponseBody($response)
{
$statusCode = $response->getStatusCode();
$rawResponse = $response->getBody()->getContents();
if ($statusCode != 200) {
throw new CommunicationException("StatusCode: {$statusCode}, Contents: {$rawResponse}", CommunicationException::GENERAL_HTTP_ERROR);
}
static::checkForErrors($rawResponse);
return $rawResponse;
}
/**
* Create the response object
*
* @param ResponseInterface $adapterResponse
* @return \Tmdb\HttpClient\Response
*/
private function createResponse(ResponseInterface $adapterResponse = null)
{
$response = new Response();
if ($adapterResponse !== null) {
$response->setCode($adapterResponse->getStatusCode());
$response->setHeaders(new ParameterBag($adapterResponse->getHeaders()));
$response->setBody((string) $adapterResponse->getBody());
}
return $response;
}
/**
* @When :user requests addressbook :addressBook with statuscode :statusCode
*/
public function requestsAddressbookWithStatuscode($user, $addressBook, $statusCode)
{
$davUrl = $this->baseUrl . '/remote.php/dav/addressbooks/users/' . $addressBook;
$password = $user === 'admin' ? 'admin' : '123456';
try {
$this->response = $this->client->get($davUrl, ['auth' => [$user, $password]]);
} catch (\GuzzleHttp\Exception\ClientException $e) {
$this->response = $e->getResponse();
}
if ((int) $statusCode !== $this->response->getStatusCode()) {
throw new \Exception(sprintf('Expected %s got %s', (int) $statusCode, $this->response->getStatusCode()));
}
$body = $this->response->getBody()->getContents();
if (substr($body, 0, 1) === '<') {
$reader = new Sabre\Xml\Reader();
$reader->xml($body);
$this->responseXml = $reader->parse();
}
}
public function parse(ResponseInterface $response)
{
$collection = new Collection();
if (!$response->getBody()) {
return $collection;
}
// help bad responses be more multipart compliant
$body = "\r\n" . $response->getBody()->__toString() . "\r\n";
// multipart
preg_match('/boundary\\=\\"(.*?)\\"/', $response->getHeader('Content-Type'), $matches);
if (isset($matches[1])) {
$boundary = $matches[1];
} else {
preg_match('/boundary\\=(.*?)(\\s|$|\\;)/', $response->getHeader('Content-Type'), $matches);
$boundary = $matches[1];
}
// strip quotes off of the boundary
$boundary = preg_replace('/^\\"(.*?)\\"$/', '\\1', $boundary);
// clean up the body to remove a reamble and epilogue
$body = preg_replace('/^(.*?)\\r\\n--' . $boundary . '\\r\\n/', "\r\n--{$boundary}\r\n", $body);
// make the last one look like the rest for easier parsing
$body = preg_replace('/\\r\\n--' . $boundary . '--/', "\r\n--{$boundary}\r\n", $body);
// cut up the message
$multi_parts = explode("\r\n--{$boundary}\r\n", $body);
// take off anything that happens before the first boundary (the preamble)
array_shift($multi_parts);
// take off anything after the last boundary (the epilogue)
array_pop($multi_parts);
$message_parser = new MessageParser();
$parser = new Single();
// go through each part of the multipart message
foreach ($multi_parts as $part) {
// get Guzzle to parse this multipart section as if it's a whole HTTP message
$parts = $message_parser->parseResponse("HTTP/1.1 200 OK\r\n" . $part);
// now throw this single faked message through the Single GetObject response parser
$single = new Response($parts['code'], $parts['headers'], Stream::factory($parts['body']));
$obj = $parser->parse($single);
// add information about this multipart to the returned collection
$collection->push($obj);
}
return $collection;
}
protected function getResponse(GuzzleResponse $response)
{
if (strpos($response->getHeader('Content-Type'), 'json')) {
$returnResponse = new JsonResponse($response->getBody());
} elseif (strpos($response->getHeader('Content-Type'), 'xml')) {
$returnResponse = new XmlResponse($response->xml());
} else {
throw new \Exception('Unknow return type');
}
return $returnResponse;
}
public function __invoke(ResponseInterface $response)
{
$code = (string) $response->getStatusCode();
$data = ['type' => $code[0] == '4' ? 'client' : 'server', 'request_id' => null, 'code' => null, 'message' => null, 'parsed' => null];
if ($body = $response->getBody()) {
$this->parseBody(new \SimpleXMLElement($body), $data);
} else {
$this->parseHeaders($response, $data);
}
return $data;
}
/**
* @param GuzzleResponseInterface $response
*/
public function __construct(GuzzleResponseInterface $response)
{
$this->response = $response;
$this->body = json_decode($response->getBody());
$this->errorCode = (int) $this->popField('errorCode');
$this->errorMessage = $this->popField('errorMessage');
$this->errorDetails = $this->popField('errorDetails');
$this->statusCode = (int) $this->popField('statusCode');
$this->statusReason = $this->popField('statusReason');
$this->callId = $this->popField('callId');
$this->time = DateTimeImmutable::createFromFormat(DateTime::ATOM, $this->popField('time'));
}
public function parse(ResponseInterface $response)
{
$headers = $response->getHeaders();
$obj = new Object();
$obj->setContent($response->getBody() ? $response->getBody()->__toString() : null);
$obj->setContentDescription(\array_get($headers, 'Content-Description', [null])[0]);
$obj->setContentSubDescription(\array_get($headers, 'Content-Sub-Description', [null])[0]);
$obj->setContentId(\array_get($headers, 'Content-ID', [null])[0]);
$obj->setObjectId(\array_get($headers, 'Object-ID', [null])[0]);
$obj->setContentType(\array_get($headers, 'Content-Type', [null])[0]);
$obj->setLocation(\array_get($headers, 'Location', [null])[0]);
$obj->setMimeVersion(\array_get($headers, 'MIME-Version', [null])[0]);
$obj->setPreferred(\array_get($headers, 'Preferred', [null])[0]);
if ($this->isError($response)) {
$xml = $response->xml();
$error = new RETSError();
$error->setCode((string) \array_get($xml, 'ReplyCode'));
$error->setMessage((string) \array_get($xml, 'ReplyText'));
$obj->setError($error);
}
return $obj;
}
/**
* @param \GuzzleHttp\Message\ResponseInterface $response
* @param \GuzzleHttp\Message\MessageParser $parser
* @param \GuzzleHttp\Message\MessageFactoryInterface $messageFactory
*/
public function __construct(ResponseInterface $response, MessageParser $parser = null, MessageFactoryInterface $messageFactory = null)
{
$matches = null;
$body = $response->getBody();
$header = $response->getHeader('Content-Type');
if (!preg_match('/boundary=(.*)$/', $header, $matches) || !isset($matches[1])) {
throw new InvalidArgumentException("Unable to parse boundary from content type : '{$header}'");
}
$this->response = $response;
$this->parser = $parser ?: new MessageParser();
$this->factory = $messageFactory ?: new MessageFactory();
$this->iterator = new MultipartStreamIterator($body, $matches[1]);
}
/**
* 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 = json_decode((string) $this->response->getBody(), true);
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]);
}
}
/**
* @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);
}
function let(SiteConfigBuilder $siteConfigBuilder, SiteConfig $siteConfig, Factory $authenticatorFactory, ClientInterface $guzzle, Emitter $emitter, BeforeEvent $beforeEvent, CompleteEvent $completeEvent, RequestInterface $request, ResponseInterface $response, Factory $authenticatorFactory)
{
$siteConfig->getHost()->willReturn('example.com');
$siteConfigBuilder->buildForHost('example.com')->willReturn($siteConfig);
$guzzle->getEmitter()->willReturn($emitter);
$request->getHost()->willReturn('example.com');
$beforeEvent->getRequest()->willReturn($request);
$beforeEvent->getClient()->willReturn($guzzle);
$response->getBody()->willReturn('<html></html>');
$completeEvent->getResponse()->willReturn($response);
$completeEvent->getRequest()->willReturn($request);
$completeEvent->getClient()->willReturn($guzzle);
$this->beConstructedWith($siteConfigBuilder, $authenticatorFactory);
}
/**
* @When I send a access token request
*/
public function iMakeAAccessTokenRequest()
{
$url = $this->parameters['token_url'];
$this->response = $this->getPostResponseFromUrl($url, $this->requestBody);
$contentType = (string) $this->response->getHeader('Content-type');
if ($contentType !== 'application/json') {
throw new \Exception(sprintf("Content-type must be application/json %s", $this->echoLastResponse()));
}
$this->data = json_decode($this->response->getBody(true));
$this->lastErrorJson = json_last_error();
if ($this->lastErrorJson != JSON_ERROR_NONE) {
throw new \Exception(sprintf("Error parsing response JSON " . "\n\n %s", $this->echoLastResponse()));
}
}
/**
* @Then The webdav checksum should be empty
*/
public function theWebdavChecksumShouldBeEmpty()
{
$service = new Sabre\Xml\Service();
$parsed = $service->parse($this->response->getBody()->getContents());
/*
* Fetch the checksum array
* Maybe we want to do this a bit cleaner ;)
*/
$status = $parsed[0]['value'][1]['value'][1]['value'];
if ($status !== 'HTTP/1.1 404 Not Found') {
throw new \Exception("Expected 'HTTP/1.1 404 Not Found', got " . $status);
}
}
