/**
* @Given /^User "([^"]*)" moved file "([^"]*)" to "([^"]*)"$/
* @param string $user
* @param string $fileSource
* @param string $fileDestination
*/
public function userMovedFile($user, $fileSource, $fileDestination)
{
$fullUrl = substr($this->baseUrl, 0, -4) . $this->davPath;
$headers['Destination'] = $fullUrl . $fileDestination;
$this->response = $this->makeDavRequest($user, "MOVE", $fileSource, $headers);
PHPUnit_Framework_Assert::assertEquals(201, $this->response->getStatusCode());
}
private function isNotJsonError(HttpResponseInterface $httpResponse)
{
if ($httpResponse->getStatusCode() == ResponseInterface::HTTP_CODE_NOT_FOUND || $httpResponse->getStatusCode() == ResponseInterface::HTTP_CODE_INTERNAL_SERVER_ERROR || $httpResponse->getStatusCode() == ResponseInterface::HTTP_CODE_METHOD_NOT_ALLOWED) {
return true;
}
return false;
}
/**
* @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;
}
/**
* Asserts the HTTP response status code.
*
* @param string $status Expected status code
*
* @throws \RuntimeException If status code does not match
*
* @return self
*/
public function status($status)
{
$httpStatus = (string) $this->response->getStatusCode();
if ($httpStatus !== $status) {
throw new \RuntimeException("Unexpected response status code: {$httpStatus}");
}
return $this;
}
/**
* Set Http response in case of successful request
*
* @param GuzzleHttp\Message\ResponseInterface $response
* @return CurrencyExchange\HttpClient
* @throws CurrencyExchange\Exception\ResponseException
*/
public function setResponse(ResponseInterface $response)
{
if ($response->getStatusCode() != 200) {
throw new ResponseException('Unsuccessful HTTP request: ' . $response->getStatusCode() . ' on ' . $this->getUri());
}
$this->_response = $response;
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());
}
/**
* @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();
}
}
/**
* {@inheritdoc}
*/
protected function readNext()
{
if (!$this->iterator->valid()) {
return;
}
$message = $this->iterator->current();
$code = $this->response->getStatusCode();
$content = sprintf("HTTP/1.1 300\r\n %s", $message);
$element = $this->parser->parseResponse($content);
$current = $this->factory->createResponse($code, $element['headers'], $element['body']);
return $current;
}
/**
* @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);
}
/**
* 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;
}
/**
* @When /^Updating last share with$/
* @param \Behat\Gherkin\Node\TableNode|null $body
*/
public function updatingLastShare($body)
{
$share_id = $this->lastShareData->data[0]->id;
$fullUrl = $this->baseUrl . "v{$this->apiVersion}.php/apps/files_sharing/api/v{$this->sharingApiVersion}/shares/{$share_id}";
$client = new Client();
$options = [];
if ($this->currentUser === 'admin') {
$options['auth'] = $this->adminUser;
} else {
$options['auth'] = [$this->currentUser, $this->regularUser];
}
if ($body instanceof \Behat\Gherkin\Node\TableNode) {
$fd = $body->getRowsHash();
if (array_key_exists('expireDate', $fd)) {
$dateModification = $fd['expireDate'];
$fd['expireDate'] = date('Y-m-d', strtotime($dateModification));
}
$options['body'] = $fd;
}
try {
$this->response = $client->send($client->createRequest("PUT", $fullUrl, $options));
} catch (\GuzzleHttp\Exception\ClientException $ex) {
$this->response = $ex->getResponse();
}
PHPUnit_Framework_Assert::assertEquals(200, $this->response->getStatusCode());
}
private function modifyRedirectRequest(RequestInterface $request, ResponseInterface $response)
{
$config = $request->getConfig();
// Use a GET request if this is an entity enclosing request and we are
// not forcing RFC compliance, but rather emulating what all browsers
// would do.
$statusCode = $response->getStatusCode();
if ($statusCode == 303 || $statusCode <= 302 && $request->getBody() && !$config->getPath('redirect/strict')) {
$request->setMethod('GET');
$request->setBody(null);
}
$previousUrl = $request->getUrl();
$this->setRedirectUrl($request, $response);
$this->rewindEntityBody($request);
// Add the Referer header if it is told to do so and only
// add the header if we are not redirecting from https to http.
if ($config->getPath('redirect/referer') && ($request->getScheme() == 'https' || $request->getScheme() == $config['redirect_scheme'])) {
$url = Url::fromString($previousUrl);
$url->setUsername(null);
$url->setPassword(null);
$request->setHeader('Referer', (string) $url);
} else {
$request->removeHeader('Referer');
}
}
/**
* Checks that response has specific status code.
*
* @param string $code status code
*
* @Then /^(?:the )?response code should be (\d+)$/
*/
public function theResponseCodeShouldBe($code)
{
$expected = intval($code);
var_dump($this->response->getStatusCode());
$actual = intval($this->response->getStatusCode());
Assertions::assertSame($expected, $actual);
}
private function parseHeaders(ResponseInterface $response, array &$data)
{
$data['message'] = $response->getStatusCode() . ' ' . $response->getReasonPhrase();
if ($requestId = $response->getHeader('x-amz-request-id')) {
$data['request_id'] = $requestId;
$data['message'] .= " (Request-ID: {$requestId})";
}
}
/**
* Gets the relevant data from the Guzzle clients.
*
* @param RequestInterface $request
* @param ResponseInterface $response
*/
public function __construct(RequestInterface $request, ResponseInterface $response)
{
if ($response instanceof FutureResponse) {
$this->httpStatusCode = null;
} else {
$this->httpStatusCode = $response->getStatusCode();
}
$this->requestUrl = $request->getUrl();
}
/**
* @param RequestInterface $originalRequest
* @param ResponseInterface|null $response
*
* @return Span
*/
public function fromIncomingResponse(RequestInterface $originalRequest, ResponseInterface $response = null)
{
$span = $originalRequest->getHeader('X-B3-SpanId');
$trace = $originalRequest->getHeader('X-B3-TraceId');
if (empty($span) || empty($trace)) {
throw new \InvalidArgumentException('Unable to find the original request properties');
}
return new Span(Identifier::fromString($span), $this->getName($originalRequest), Identifier::fromString($trace), [new Annotation(Annotation::CLIENT_RECEIVE, $this->clock->microseconds(), $this->endpointResolver->resolve())], [new BinaryAnnotation('http.status', $response !== null ? $response->getStatusCode() : 0, BinaryAnnotation::TYPE_INTEGER_16)]);
}
/**
* @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 RequestInterface $request
* @param ResponseInterface $response
* @return string
*/
protected function buildMessage($request, $response)
{
$resource = $this->getResponseBody();
if (is_null($resource)) {
$resource = '';
}
$message = sprintf('[url] %s [http method] %s [status code] %s [reason phrase] %s: %s', $request->getUrl(), $request->getMethod(), $response->getStatusCode(), $response->getReasonPhrase(), $resource);
return $message;
}
/**
* @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;
}
/**
* Factory method to create a new exception with a normalized error message
*
* @param RequestInterface $request Request
* @param ResponseInterface $response Response received
* @param \Exception $previous Previous exception
*
* @return self
*/
public static function create(RequestInterface $request, ResponseInterface $response = null, \Exception $previous = null)
{
if (!$response) {
return new self('Error completing request', $request, null, $previous);
}
$level = floor($response->getStatusCode() / 100);
if ($level == '4') {
$label = 'Client error response';
$className = __NAMESPACE__ . '\\ClientException';
} elseif ($level == '5') {
$label = 'Server error response';
$className = __NAMESPACE__ . '\\ServerException';
} else {
$label = 'Unsuccessful response';
$className = __CLASS__;
}
$message = $label . ' [url] ' . $request->getUrl() . ' [status code] ' . $response->getStatusCode() . ' [reason phrase] ' . $response->getReasonPhrase();
return new $className($message, $request, $response, $previous);
}
/**
* 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;
}
/**
* @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;
}
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);
}
}
/**
* @Given /^group "([^"]*)" exists$/
*/
public function groupExists($group)
{
$fullUrl = $this->baseUrl . "v2.php/cloud/groups/{$group}";
$client = new Client();
$options = [];
if ($this->currentUser === 'admin') {
$options['auth'] = $this->adminUser;
}
$this->response = $client->get($fullUrl, $options);
PHPUnit_Framework_Assert::assertEquals(200, $this->response->getStatusCode());
}
/**
* @When /^creating the user "([^"]*)r"$/
*/
public function creatingTheUser($user)
{
$fullUrl = $this->baseUrl . "v2.php/cloud/users/{$user}";
$client = new Client();
$options = [];
if ($this->currentUser === 'admin') {
$options['auth'] = $this->adminUser;
}
$this->response = $client->post($fullUrl, ['form_params' => ['userid' => $user, 'password' => '123456']]);
PHPUnit_Framework_Assert::assertEquals(200, $this->response->getStatusCode());
}
/**
* 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);
}
/**
* @param string $message
* @param RequestInterface $request
* @param ResponseInterface $response
*/
public function __construct($message = null, RequestInterface $request = null, ResponseInterface $response = null)
{
$message = $message ?: $this->message;
if ($request !== null && $response !== null) {
$details = "[url] " . $request->getUrl();
$details .= " [status code] " . $response->getStatusCode();
$details .= " [reason phrase] " . $response->getReasonPhrase();
$details .= ApiResponseException::getErrorDetails($response);
$message .= "\nDetails:\n " . wordwrap($details);
}
parent::__construct($message, $this->code);
}
/**
* 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 {
if ($response->getStatusCode() >= 400 && $response->getStatusCode() < 500) {
// 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;
}
/**
* 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;
}
/**
* Checks the given response for error codes, throwing the appropriate
* exceptions if needed.
* @param ResponseInterface $response
*/
protected function checkResponseErrors(ResponseInterface $response)
{
$status = intval($response->getStatusCode());
if ($status === 200) {
return;
}
switch ($status) {
case 401:
throw new AuthorizationException($response);
default:
throw new RequestException($response);
}
}
