Responses are considered immutable; all methods that might change state are
implemented such that they retain the internal state of the current
message and return a new instance that contains the changed state.
public function index() { $promises = call_user_func(function () { foreach ($this->usernames as $username) { (yield $this->client->requestAsync('GET', 'https://api.github.com/users/' . $username)); } }); // Wait till all the requests are finished. \GuzzleHttp\Promise\all($promises)->then(function (array $responses) { $this->profiles = array_map(function ($response) { return json_decode($response->getBody(), true); }, $responses); })->wait(); // Return JSON response $response = new Response(); // StreamInterface objects are not immutable! $response->getBody()->write($this->html()); return $response->withHeader('Content-type', 'text/html'); }
/** * @param Request $request * @param array $routeParams * @return \Zend\Diactoros\Response */ public function handle(Request $request, array $routeParams = []) { $view = $this->render($request, $routeParams); $response = new Response(); $response->getBody()->write($view->render()); return $response; }
/** * @dataProvider mappedMiddlewaresProvider * * @param array|string $mappedMiddlewares * @param int $expectedCounter */ public function testDispatchesMappedMiddlewares($mappedMiddlewares, int $expectedCounter) { $container = $this->prophesize(ContainerInterface::class); $middleware = new WorkerMiddleware(['message-name' => $mappedMiddlewares], $container->reveal()); $request = $this->createRequest(); $response = new Response(); if (is_string($mappedMiddlewares)) { $mappedMiddlewares = (array) $mappedMiddlewares; } foreach ($mappedMiddlewares as $mappedMiddleware) { $container->get($mappedMiddleware)->shouldBeCalled()->willReturn([$this, 'incrementMiddleware']); } $out = function ($request, ResponseInterface $response) use($expectedCounter) { $this->assertEquals('default-queue', $request->getAttribute(WorkerMiddleware::MATCHED_QUEUE_ATTRIBUTE)); $this->assertEquals('123abc', $request->getAttribute(WorkerMiddleware::MESSAGE_ID_ATTRIBUTE)); $this->assertEquals('message-name', $request->getAttribute(WorkerMiddleware::MESSAGE_NAME_ATTRIBUTE)); $this->assertEquals(['id' => 123], $request->getAttribute(WorkerMiddleware::MESSAGE_PAYLOAD_ATTRIBUTE)); $this->assertEquals($expectedCounter, $request->getAttribute('counter', 0)); $this->assertEquals($expectedCounter, $response->hasHeader('counter') ? $response->getHeaderLine('counter') : 0); return $response->withAddedHeader('foo', 'bar'); }; /** @var ResponseInterface $returnedResponse */ $returnedResponse = $middleware($request, $response, $out); $this->assertEquals('bar', $returnedResponse->getHeaderLine('foo'), 'Make sure that $out was called'); $this->assertEquals('ZfrEbWorker', $returnedResponse->getHeaderLine('X-HANDLED-BY'), 'Make sure that it adds the X-HANDLED-BY header'); }
public function testToCakeBody() { $psr = new PsrResponse('php://memory', 200, ['X-testing' => ['value', 'value2']]); $psr->getBody()->write('A message for you'); $result = ResponseTransformer::toCake($psr); $this->assertSame('A message for you', $result->body()); }
public function createResponse(ApiProblem $apiProblem) { $response = new Response('php://memory', $apiProblem->getDetail('status'), ['Content-Type' => 'application/problem+json']); $json = Json::toJson($apiProblem); $response->getBody()->write($json); return $response; }
/** * Executes a http request. * * @param ServerRequestInterface $request * * @return ResponseInterface */ public function __invoke(ServerRequestInterface $request, Response $response) { $runner = new Runner(array_merge($this->queue, $this->sources, [function (ServerRequestInterface $request, Response $response, callable $next) { return $response->withStatus(404); }])); return $runner($request, $response); }
/** * @param Request $request * @return \Zend\Diactoros\Response */ public function handle(Request $request) { $view = $this->render($request); $response = new Response(); $response->getBody()->write($view->render()); return $response; }
/** * Return admin assets * @param Response $response * @param $asset * @return Response|static * @throws FileNotFoundException */ public function assets(Response $response, $asset) { $filesystem = new Filesystem(new Adapter(FS2ADMIN)); $expires = 8640000; try { // generate cache data $timestamp_string = gmdate('D, d M Y H:i:s ', $filesystem->getTimestamp($asset)) . 'GMT'; $etag = md5($filesystem->read($asset)); $mime_type = $filesystem->getMimetype($asset); if (0 !== strpos($mime_type, 'image')) { $mime_type = 'text/css'; } $if_modified_since = isset($_SERVER['HTTP_IF_MODIFIED_SINCE']) ? $_SERVER['HTTP_IF_MODIFIED_SINCE'] : false; $if_none_match = isset($_SERVER['HTTP_IF_NONE_MATCH']) ? $_SERVER['HTTP_IF_NONE_MATCH'] : false; if (($if_none_match && $if_none_match == "\"{$etag}\"" || !$if_none_match) && ($if_modified_since && $if_modified_since == $timestamp_string)) { return $response->withStatus('304'); } else { $response = $response->withHeader('Last-Modified', $timestamp_string)->withHeader('ETag', "\"{$etag}\""); } // send out content type, expire time and the file $response->getBody()->write($filesystem->read($asset)); return $response->withHeader('Expires', gmdate('D, d M Y H:i:s ', time() + $expires) . 'GMT')->withHeader('Content-Type', $mime_type)->withHeader('Pragma', 'cache')->withHeader('Cache-Control', 'cache'); } catch (FileNotFoundException $e) { throw $e; } }
public function testRunSingleCheckFromAttribute() { $this->runner->method('run')->with('group-name/label-name')->willReturn($this->collection); $this->request = $this->request->withAttribute('filter', 'group-name')->withAttribute('label', 'label-name'); $responseFromFactory = new Response(); $responseFromFactory->getBody()->write('foo'); $this->resultResponseFactory->method('createResponse')->with($this->request, $this->collection)->willReturn($responseFromFactory); $finalResponse = $this->middleware->__invoke($this->request, $this->response); $this->assertSame($responseFromFactory, $finalResponse); }
/** * Test that emit invokes the appropriate methods on the emitter. * * @return void */ public function testEmit() { $response = new Response('php://memory', 200, ['x-testing' => 'source header']); $final = $response->withHeader('X-First', 'first')->withHeader('X-Second', 'second'); $emitter = $this->getMock('Zend\\Diactoros\\Response\\EmitterInterface'); $emitter->expects($this->once())->method('emit')->with($final); $app = new MiddlewareApplication($this->config); $server = new Server($app); $server->emit($server->run(null, $response), $emitter); }
public function __invoke(ServerRequestInterface $request, ResponseInterface $response, callable $out = null) { if ($request->getUri()->getPath() === '/robots.txt') { $newReponse = new Response('php://memory', 200, ['Content-Type' => 'text/plain']); $newReponse->getBody()->write("User-Agent: *\nDisallow: /"); return $newReponse; } /* @var $out ResponseInterface */ $response = $out === null ? $response : $out($request, $response); return $response->withHeader(self::ROBOTS_HEADER, 'noindex, nofollow'); }
function make($status = 200, $content = '', $contentType = null, array $headers = []) { if ($contentType) { $headers['Content-Type'] = $contentType; } $response = new Response('php://memory', $status, $headers); if ($content) { $response->getBody()->write($content); } return $response; }
/** * @param string $content * @param string $filename * * @return \Psr\Http\Message\ResponseInterface */ private function fileDownload($content, $filename) { $contentDisposition = sprintf("attachment; filename*=utf-8''%s", rawurlencode($filename)); $response = new Response(); if (is_string($content)) { $body = $response->getBody(); $body->write($content); } elseif ($content instanceof StreamInterface) { $body = $content; } return $response->withBody($body)->withHeader('Content-Disposition', $contentDisposition); }
/** * User login * * @param Request $request * @param Response $response * @return Response */ public function login(Request $request = null, Response $response = null) { $app = $this->app($request); $user = new UserSession($app); $user->logout(); $assets = $this->getAssets(); $assets[] = 'view::Index/css/login.css'; $app->view->addData(['assets' => $assets]); $app->view->addData($this->getData($request)); $content = $app->view->render('view::Index/html/login.html.php'); $response->getBody()->write($content); return $response; }
public function process(ServerRequestInterface $request, DelegateInterface $delegate) : ResponseInterface { $feed = null; if ($this->cache->contains('blog:xml-feed')) { $feed = $this->cache->fetch('blog:xml-feed'); } if (!$feed) { $feed = $this->generateXmlFeed(); $this->cache->save('blog:xml-feed', $feed); } $response = new Response(); $response->getBody()->write($feed); return $response->withHeader('Content-Type', 'application/atom+xml')->withHeader('Cache-Control', ['public', 'max-age=3600']); }
public function index() { $promises = $this->getProfiles(); $profiles = []; // Wait till all the requests are finished. (new EachPromise($promises, ['concurrency' => 4, 'fulfilled' => function ($profile) use(&$profiles) { $profiles[] = $profile; }]))->promise()->wait(); // Return JSON response $response = new Response(); // StreamInterface objects are not immutable! $response->getBody()->write($this->html($profiles)); return $response->withHeader('Content-type', 'text/html'); }
public function testFourth() { $request = ServerRequestFactory::fromGlobals(); $response = new Response(); $stack = new Stack(); $stack->push(function (ServerRequestInterface $request, ResponseInterface $response, callable $next = null) { $response->getBody()->write(1); return $response; }); $stack->push(function (ServerRequestInterface $request, ResponseInterface $response, callable $next = null) { $response->getBody()->write(2); return $next ? $next($request, $response) : $response; }); $this->assertSame('1', (string) $stack->__invoke($request, $response)->getBody()); }
/** * Create a JSON response with the given data. * * Default JSON encoding is performed with the following options, which * produces RFC4627-compliant JSON, capable of embedding into HTML. * * - JSON_HEX_TAG * - JSON_HEX_APOS * - JSON_HEX_AMP * - JSON_HEX_QUOT * - JSON_UNESCAPED_SLASHES * * @param mixed $data Data to convert to JSON. * @param int $status Integer status code for the response; 200 by default. * @param array $headers Array of headers to use at initialization. * @param int $encodingOptions JSON encoding options to use. * @throws InvalidArgumentException if unable to encode the $data to JSON. */ public function __construct($data, $status = 200, array $headers = [], $encodingOptions = self::DEFAULT_JSON_FLAGS) { $body = new Stream('php://temp', 'wb+'); $body->write($this->jsonEncode($data, $encodingOptions)); $headers = $this->injectContentType('application/json', $headers); parent::__construct($body, $status, $headers); }
/** * Index action * * @param Request $request * @param Response $response * @return Response */ public function index(Request $request = null, Response $response = null) { $app = $this->app($request); // Increment counter $counter = $app->session->get('counter', 0); $counter++; $app->session->set('counter', $counter); // Add data to template $assets = $this->getAssets(['view::Index/js/index.js']); $text = $this->getText(['Loaded successfully!' => __('Loaded successfully!')]); $data = $this->getData($request, ['assets' => $assets, 'text' => $text, 'content' => 'view::Index/html/index.html.php', 'counter' => $counter]); // Render template $content = $app->view->render('view::Layout/html/layout.html.php', $data); $response->getBody()->write($content); return $response; }
public function testAttachToHtmlResponse() { $request = new ServerRequest([], [], null, null, 'php://input', ['Accept' => 'text/html']); $response = new Response('php://memory', 200, ['Content-Type' => 'text/html']); $response->getBody()->write('ResponseBody'); $calledOut = false; $outFunction = function ($request, $response) use(&$calledOut) { $calledOut = true; return $response; }; $this->debugbarRenderer->expects($this->once())->method('renderHead')->willReturn('RenderHead'); $this->debugbarRenderer->expects($this->once())->method('render')->willReturn('RenderBody'); $result = call_user_func($this->middleware, $request, $response, $outFunction); $this->assertTrue($calledOut, 'Out is not called'); $this->assertSame($response, $result); $this->assertSame("ResponseBodyRenderHeadRenderBody", (string) $result->getBody()); }
/** * Create a redirect response. * * Produces a redirect response with a Location header and the given status * (302 by default). * * Note: this method overwrites the `location` $headers value. * * @param string|UriInterface $uri URI for the Location header. * @param int $status Integer status code for the redirect; 302 by default. * @param array $headers Array of headers to use at initialization. */ public function __construct($uri, $status = 302, array $headers = array()) { if (!is_string($uri) && !$uri instanceof UriInterface) { throw new InvalidArgumentException(sprintf('Uri provided to %s MUST be a string or Psr\\Http\\Message\\UriInterface instance; received "%s"', __CLASS__, is_object($uri) ? get_class($uri) : gettype($uri))); } $headers['location'] = array((string) $uri); parent::__construct('php://temp', $status, $headers); }
/** * PsrApiResponse constructor. * * @param null $data * @param array $apiMessages * @param int $status * @param array $headers * @param int $encodingOptions */ public function __construct($data = null, $apiMessages = [], $status = 200, array $headers = [], $encodingOptions = 0) { $this->messages = new ApiMessages(); $this->setData($data); $this->addApiMessages($apiMessages); $this->encodingOptions = $encodingOptions; $headers = $this->injectContentType('application/json', $headers); parent::__construct($this->getBody(), $status, $headers); }
/** * Wrap the remaining middleware with error handling. * * @param Request $request The request. * @param Response $response The response. * @param callable $next Callback to invoke the next middleware. * @return Response A response */ public function __invoke(Request $request, Response $response, callable $next) { $uri = $this->getBaseUri($request); $route = $this->router->dispatch($request->getMethod(), $uri); if ($route[0] === Dispatcher::NOT_FOUND) { $stream = new Stream('php://temp', 'wb+'); $stream->write('Not found'); return $response->withStatus(404)->withBody($stream); } if ($route[0] === Dispatcher::METHOD_NOT_ALLOWED) { $stream = new Stream('php://temp', 'wb+'); $stream->write('Not allowed'); return $response->withStatus(405)->withBody($stream); } $request = $request->withAttribute('vars', $route[2]); $response = $this->executeCallable($route[1], $request, $response, $next); return $next($request, $response); }
/** * @param \OAuth2\Token\AccessTokenInterface|null $access_token On Symfony v3.1+ only, this argument is resolved through the new argument resolver feature * * @return \Psr\Http\Message\ResponseInterface */ public function userinfoAction(AccessTokenInterface $access_token = null) { if (null === $access_token) { $token = $this->token_storage->getToken(); if (!$token instanceof OAuth2Token) { throw new AuthenticationException('Unable to find an OAuth2 Access Token. Are you behind the OAuth2 Firewall?'); } $access_token = $token->getAccessToken(); } try { $info = $this->userinfo_endpoint->handle($access_token); $response = new Response('php://memory', 200, ['Content-Type' => sprintf('application/%s', is_array($info) ? 'json' : 'jwt'), 'Cache-Control' => 'no-store', 'Pragma' => 'no-cache']); $response->getBody()->write(is_array($info) ? json_encode($info) : $info); } catch (BaseException $e) { $response = new Response(); $e->getHttpResponse($response); } return $response; }
public function testRoutingFailureDueToHttpMethodCallsNextWithNotAllowedResponseAndError() { $request = new ServerRequest(); $response = new Response(); $result = RouteResult::fromRouteFailure(['GET', 'POST']); $this->router->match($request)->willReturn($result); $next = function ($request, $response, $error = false) { $this->assertEquals(405, $error); $this->assertEquals(405, $response->getStatusCode()); return $response; }; $app = $this->getApplication(); $test = $app->routeMiddleware($request, $response, $next); $this->assertInstanceOf('Psr\\Http\\Message\\ResponseInterface', $test); $this->assertEquals(405, $test->getStatusCode()); $allow = $test->getHeaderLine('Allow'); $this->assertContains('GET', $allow); $this->assertContains('POST', $allow); }
/** * Edit * * @param Request $request * @param Response $response * @return Response */ public function edit(Request $request = null, Response $response = null) { // All GET parameters $queryParams = $request->getQueryParams(); // All POST or PUT parameters $postParams = $request->getParsedBody(); // Single GET parameter //$title = $queryParams['title']; // // Single POST/PUT parameter //$data = $postParams['data']; // // Get routing arguments $vars = $request->getAttribute('vars'); $id = $vars['id']; // Get config value $app = $this->app($request); $env = $app->config['env']['name']; // Get GET parameter $id = $app->http->get('id'); // Increment counter $counter = $app->session->get('counter', 0); $counter++; $app->session->set('counter', $counter); $app->logger->info('My log message'); // Set locale //$app->session->set('user.locale', 'de_DE'); // //Model example //$user = new \App\Model\User($app); //$userRows = $user->getAll(); //$userRow = $user->getById($id); // // Add data to template $data = $this->getData($request, ['id' => $id, 'assets' => $this->getAssets(), 'content' => 'view::User/html/edit.html.php']); // Render template $content = $app->view->render('view::Layout/html/layout.html.php', $data); // Return new response $response->getBody()->write($content); return $response; }
/** * Create a JSONP response with the given data. * * @param mixed $data Data to convert to JSON. * @param string $callback The JSONP callback function. * @param int $status Integer status code for the response; 200 by default. * @param array $headers Array of headers to use at initialization. * @param int $encodingOptions JSON encoding options to use. * @throws InvalidArgumentException if $data pr $callback invalid. */ public function __construct($data, $callback, $status = 200, array $headers = [], $encodingOptions = JsonResponse::DEFAULT_JSON_FLAGS) { $this->validateCallback($callback); $body = new Stream('php://temp', 'wb+'); $body->write($callback); $body->write('('); $body->write($this->jsonEncode($data, $encodingOptions)); $body->write(');'); $body->rewind(); $headers = $this->injectContentType('application/javascript', $headers); parent::__construct($body, $status, $headers); }
/** * */ public function run() { $route = $this->getRoute(); if ($route !== null) { $queue = array_merge($this->_middleware->getArrayCopy(), $route->getMiddleware()); $queue[] = $route->getRequestHandler(); $relayBuilder = new RelayBuilder(); $relay = $relayBuilder->newInstance($queue); (new SapiEmitter())->emit($relay($this->_request, $this->_response)); return true; } (new SapiEmitter())->emit($this->_response->withStatus(404)); }
public function testSimulateRequest() { $simulatedRequest = "DELETE / HTTP/1.1\r\nBar: faz\r\nHost: php-middleware.com"; $postBody = http_build_query([RequestSimulatorMiddleware::PARAM => $simulatedRequest]); $stream = new Stream('php://memory', 'wb+'); $stream->write($postBody); $request = new ServerRequest([], [], new Uri(), 'POST', $stream, ['Content-type' => 'application/x-www-form-urlencoded']); $responseBody = json_encode(['boo' => 'foo']); $response = new Response('php://memory', 200, ['content-type' => 'application/json']); $response->getBody()->write($responseBody); $next = function (ServerRequestInterface $request, ResponseInterface $response) { $this->assertSame('DELETE', $request->getMethod()); $this->assertSame('faz', $request->getHeaderLine('Bar')); return $response; }; /* @var $result ResponseInterface */ $result = call_user_func($this->middleware, $request, $response, $next); $body = (string) $result->getBody(); $this->assertContains('text/html', $result->getHeaderLine('Content-type')); $this->assertContains('{"boo":"foo"}', $body); $this->assertContains('<html>', $body); $this->assertContains('DELETE / HTTP/1.1', $body); }
/** * Create a plain text response. * * Produces a text response with a Content-Type of text/plain and a default * status of 200. * * @param string|StreamInterface $text String or stream for the message body. * @param int $status Integer status code for the response; 200 by default. * @param array $headers Array of headers to use at initialization. * @throws InvalidArgumentException if $text is neither a string or stream. */ public function __construct($text, $status = 200, array $headers = []) { parent::__construct($this->createBody($text), $status, $this->injectContentType('text/plain; charset=utf-8', $headers)); }