protected function getHostString(Message\MessageInterface $message) { if ($message->hasHeader('host')) { return ''; } return "\r\nHost: " . $message->getUri()->getHost(); }
/** * Store a message in the cache. * * @param string $key The message key * @param MessageInterface $message */ private function saveIntoCache($key, MessageInterface $message) { if ($this->cache) { $item = $this->cache->getItem($key); $item->set([$message->getHeaders(), (string) $message->getBody()]); $this->cache->save($item); } }
/** * @param Psr\Http\Message\MessageInterface $message * * @return string */ private static function printHeaders(MessageInterface $message) { $headers = []; foreach ($message->getHeaders() as $name => $values) { $headers[] = $name . ': ' . implode(', ', $values); } return implode("\n", $headers); }
private function addJsonToHttpMessage(MessageInterface $message, array $dataToTurnIntoJson, bool $castToObject = false) { if ($castToObject) { $dataToTurnIntoJson = (object) $dataToTurnIntoJson; } $json = json_encode($dataToTurnIntoJson); $message->getBody()->write($json); return $message; }
/** * @inheritdoc */ protected function deserialize(MessageInterface $message, $format) { if ($this->class) { $content = $message->getBody()->getContents(); $parsedResponse = SerializerBuilder::create()->build()->deserialize($content, $this->class, $format, $this->context); return $parsedResponse; } else { return null; } }
/** * Returns the "best match" of the given $priorities. Will return null in case * no match could be identified or a string containing the best matching Accept * header. * * @param MessageInterface $request * @param array $priorities A set of priorities. * @return null|string */ public function getBestMatch(MessageInterface $request, array $priorities = array()) { if (!$request->hasHeader('Accept')) { return null; } $header = $this->negotiator->getBest(implode(',', $request->getHeader('Accept')), $priorities); if ($header instanceof AcceptHeader) { return $header->getValue(); } return null; }
/** * Add the message body if the stream is seekable. * * @param MessageInterface $request * @param string $message * * @return string */ private function addBody(MessageInterface $request, $message) { $stream = $request->getBody(); if (!$stream->isSeekable() || $this->maxBodyLength === 0) { // Do not read the stream $message .= "\n"; } else { $message .= "\n" . mb_substr($stream->__toString(), 0, $this->maxBodyLength); $stream->rewind(); } return $message; }
/** * @inheritdoc */ public function parse(MessageInterface $message) { $content = $message->getBody()->getContents(); if ($this->removeNamespacePrefixes) { $content = preg_replace('/(<\\/?)(\\w+:)/', '$1', $content); } if ($this->class) { $parsedResponse = SerializerBuilder::create()->build()->deserialize($content, $this->class, 'xml', $this->context); } else { $parsedResponse = simplexml_load_string($content); } return $parsedResponse; }
/** * Validate an HTTP message content-type against a message definition * * @param MessageInterface $message * @param MessageDefinition $definition * * @return bool Is valid */ public function validateContentType(MessageInterface $message, MessageDefinition $definition) { $isValid = true; $contentType = $message->getHeaderLine('Content-Type'); if (!in_array($contentType, $definition->getContentTypes())) { $isValid = false; if ($contentType === '') { $violationMessage = 'Content-Type should not be empty'; $constraint = 'required'; } else { $violationMessage = sprintf('%s is not a supported content type, supported: %s', $message->getHeaderLine('Content-Type'), implode(', ', $definition->getContentTypes())); $constraint = 'enum'; } $this->addViolation(new ConstraintViolation('Content-Type', $violationMessage, $constraint, 'header')); } return $isValid; }
/** * @param MessageInterface $message * * @codeCoverageIgnore * @return string */ public function str(MessageInterface $message) : string { if ($message instanceof RequestInterface) { $msg = trim($message->getMethod() . ' ' . $message->getRequestTarget()) . ' HTTP/' . $message->getProtocolVersion(); if (!$message->hasHeader('host')) { $msg .= "\r\nHost: " . $message->getUri()->getHost(); } } elseif ($message instanceof ResponseInterface) { $msg = 'HTTP/' . $message->getProtocolVersion() . ' ' . $message->getStatusCode() . ' ' . $message->getReasonPhrase(); } foreach ($message->getHeaders() as $name => $values) { $msg .= "\r\n{$name}: " . implode(', ', $values); } if (ini_get('memory_limit') < 0 || $message->getBody()->getSize() < ini_get('memory_limit')) { $msg .= "\r\n\r\n" . $message->getBody(); } return $msg; }
public function testWithBody() { $mockBody = Mockery::mock(StreamInterface::class); $messageWithBody = $this->message->withBody($mockBody); static::assertNull($this->message->getBody()); // return null // The body MUST be a StreamInterface object. static::assertNotSame($this->message, $messageWithBody); // This method MUST be implemented in such a way as to retain the // immutability of the message, and MUST return a new instance that has the // new body stream. static::assertInstanceOf(StreamInterface::class, $messageWithBody->getBody()); static::assertSame($mockBody, $messageWithBody->getBody()); }
/** * Creates a Body instance to execute assertions in the body. * * @return Stream */ public function assertBody() { return new Stream($this->message->getBody(), $this); }
/** * Asserts that the response does not contain the specified header. * * @param MessageInterface $message * @param string $name */ public function assertHasNotHeader(MessageInterface $message, $name) { $this->assertFalse($message->hasHeader($name), "The message contains the header {$name}"); }
protected function runMatches(MessageInterface $message) { return $message->getProtocolVersion() == $this->expected; }
/** * Parse the response from the API. * * @param MessageInterface $response * @return Response * @codeCoverageIgnore */ public function toResponse(MessageInterface $response) { $json = $response->getBody()->getContents(); $toArray = json_decode($json, true); return new Response($toArray); }
/** * Adds request id to request/response and returns new instance. * * @param MessageInterface $message * * @return MessageInterface * * @throws \InvalidArgumentException */ public function decorate(MessageInterface $message) { return $message->withHeader($this->headerName, $this->idProvider->getRequestId()); }
public function set($header, $value) { $this->request = $this->request->withHeader($header, $value); }
/** * Method to add a Cache-Control header to the provided PSR-7 message. * * @link https://tools.ietf.org/html/rfc7234#section-5.2 * * @param MessageInterface $message PSR-7 message to add the Cache-Control header to * @param CacheControl $cacheControl Cache-Control object to add to the message * @return MessageInterface The PSR-7 message with the added Cache-Control header * @throws InvalidArgumentException If the Cache-Control header is invalid */ public function withCacheControl(MessageInterface $message, CacheControl $cacheControl) { return $message->withHeader('Cache-Control', (string) $cacheControl); }
protected function runMatches(MessageInterface $message) { return $this->expected == $message->getHeaderLine($this->key); }
private function addJsonToHttpMessage(MessageInterface $message, array $dataToTurnIntoJson) { $json = json_encode($dataToTurnIntoJson); $message->getBody()->write($json); return $message; }
/** * Marshal the host and port from HTTP headers and/or the PHP environment * * @param array $server * @param MessageInterface $request * @return array Array with two members, host and port, at indices 0 and 1, respectively * @deprecated as of 0.7.0; use marshalHostAndPortFromHeaders() instead. */ public static function marshalHostAndPort(stdClass $accumulator, array $server, MessageInterface $request) { return self::marshalHostAndPortFromHeaders($accumulator, $server, $request->getHeaders()); }
protected function runMatches(MessageInterface $message) { return (string) $message->getBody() == $this->expected; }
/** * @param MessageInterface $message * @param string $headerName * @param string $value * * @return bool */ private function hasHeaderContains(MessageInterface $message, $headerName, $value) { return strpos($message->getHeaderLine($headerName), $value) !== false; }
/** * Get body with headers. * * @param MessageInterface $stream * * @return string */ public function getBodyWithHeaders(MessageInterface $stream) { $result = sprintf('%s%s%s', $this->getString($stream->getHeaders()), PHP_EOL, $stream->getBody()->getContents()); return $result; }
private function headers(MessageInterface $message) { $result = ''; foreach ($message->getHeaders() as $name => $values) { $result .= $name . ': ' . implode(', ', $values) . "\r\n"; } return trim($result); }
/** * {@inheritdoc} */ public function withBody(StreamInterface $body) { $new = clone $this; $new->message = $this->message->withBody($body); return $new; }
public function testWithAddedHeaderAllowsHeaderContinuations() { $message = $this->message->withAddedHeader('X-Foo-Bar', "value,\r\n second value"); $this->assertEquals("value,\r\n second value", $message->getHeaderLine('X-Foo-Bar')); }
protected function runMatches(MessageInterface $message) { return $message->hasHeader($this->expected); }
/** * Attempts to rewind a message body and throws an exception on failure. * * The body of the message will only be rewound if a call to `tell()` returns a * value other than `0`. * * @param MessageInterface $message Message to rewind * * @throws \RuntimeException */ function rewind_body(MessageInterface $message) { $body = $message->getBody(); if ($body->tell()) { $body->rewind(); } }
/** * Parse the body of a PSR-7 message, into a PHP array. * TODO: We really need to find a package to do this. It is built into the * Guzzle client as helper methods, but this is not specifically a client * function. * * @param $message MessageInterface * @return array|mixed */ public static function parseBody(MessageInterface $message) { // If a ServerRequest object, then parsing will be handled (and cached if necessary) // by the implementation. if ($message instanceof ServerRequestInterface) { return $message->getParsedBody(); } $data = []; if ($message->hasHeader('Content-Type')) { // Sage Pay returns responses generally with JSON, but the notify callback is Form URL // encoded, so we need to parse both. if ($message->getHeaderLine('Content-Type') === 'application/x-www-form-urlencoded') { parse_str((string) $message->getBody(), $data); } elseif ($message->getHeaderLine('Content-Type') === 'application/json') { $data = json_decode((string) $message->getBody(), true); } } return $data; }