public function testGetCurrentRequest()
{
$requestStack = new RequestStack();
$this->assertNull($requestStack->getCurrentRequest());
$request = Request::create('/foo');
$requestStack->push($request);
$this->assertSame($request, $requestStack->getCurrentRequest());
$this->assertSame($request, $requestStack->pop());
$this->assertNull($requestStack->getCurrentRequest());
$this->assertNull($requestStack->pop());
}
/**
* @covers ::__construct
* @covers ::getRouteObject
* @covers ::getCurrentRouteMatch
* @covers ::getRouteMatch
*/
public function testGetCurrentRouteObject()
{
$request_stack = new RequestStack();
$request = new Request();
$request_stack->push($request);
$current_route_match = new CurrentRouteMatch($request_stack);
// Before routing.
$this->assertNull($current_route_match->getRouteObject());
// After routing.
$route = new Route('/test-route/{foo}');
$request->attributes->set(RouteObjectInterface::ROUTE_NAME, 'test_route');
$request->attributes->set(RouteObjectInterface::ROUTE_OBJECT, $route);
$request->attributes->set('foo', '1');
$this->assertSame('1', $current_route_match->getParameter('foo'));
// Immutable for the same request once a route has been matched.
$request->attributes->set('foo', '2');
$this->assertSame('1', $current_route_match->getParameter('foo'));
// Subrequest.
$subrequest = new Request();
$subrequest->attributes->set(RouteObjectInterface::ROUTE_NAME, 'test_subrequest_route');
$subrequest->attributes->set(RouteObjectInterface::ROUTE_OBJECT, new Route('/test-subrequest-route/{foo}'));
$subrequest->attributes->set('foo', '2');
$request_stack->push($subrequest);
$this->assertSame('2', $current_route_match->getParameter('foo'));
// Restored original request.
$request_stack->pop();
$this->assertSame('1', $current_route_match->getParameter('foo'));
}
/**
* @param $params
* @return mixed|string
* @throws SmartyPluginException
*/
public function processRender($params)
{
if (null === $params["action"]) {
throw new SmartyPluginException("You must declare the 'action' parameter in the 'render' smarty function");
}
$request = $this->prepareRequest($params);
$this->requestStack->push($request);
$controller = $this->controllerResolver->getController($request);
$controllerParameters = $this->controllerResolver->getArguments($request, $controller);
$response = call_user_func_array($controller, $controllerParameters);
$this->requestStack->pop();
if ($response instanceof Response) {
return $response->getContent();
}
return $response;
}
/**
* Handles the response event.
*
* @param Response $response
* @return Response
*/
protected function handleResponse(Response $response)
{
$event = new KernelEvent('response', $this);
$this->events->trigger($event, [$this->getRequest(), $response]);
$this->stack->pop();
return $response;
}
protected function finishRequest(Request $request, $type)
{
if ($this->eventDispatcher !== null) {
$event = new FinishRequestEvent($this, $request, $type);
$this->eventDispatcher->dispatch(KernelEvents::FINISH_REQUEST, $event);
}
$this->requests->pop();
}
/**
* Filters the given embedded response, using the cumulative AJAX page state.
*
* @param \Symfony\Component\HttpFoundation\Request $fake_request
* A fake subrequest that contains the cumulative AJAX page state of the
* HTML document and all preceding Embedded HTML or AJAX responses.
* @param \Symfony\Component\HttpFoundation\Response|\Drupal\Core\Render\HtmlResponse|\Drupal\Core\Ajax\AjaxResponse $embedded_response
* Either a HTML response or an AJAX response that will be embedded in the
* overall HTML response.
*
* @return \Symfony\Component\HttpFoundation\Response
* The filtered response, which will load only the assets that $fake_request
* did not indicate to already have been loaded, plus the updated cumulative
* AJAX page state.
*/
protected function filterEmbeddedResponse(Request $fake_request, Response $embedded_response)
{
assert('$embedded_response instanceof \\Drupal\\Core\\Render\\HtmlResponse || $embedded_response instanceof \\Drupal\\Core\\Ajax\\AjaxResponse');
$this->requestStack->push($fake_request);
$event = new FilterResponseEvent($this->httpKernel, $fake_request, HttpKernelInterface::SUB_REQUEST, $embedded_response);
$this->eventDispatcher->dispatch(KernelEvents::RESPONSE, $event);
$filtered_response = $event->getResponse();
$this->requestStack->pop();
return $filtered_response;
}
/**
* Tests the request path condition.
*/
public function testConditions()
{
// Get the request path condition and test and configure it to check against
// different patterns and requests.
$pages = "/my/pass/page\r\n/my/pass/page2\r\n/foo";
$request = Request::create('/my/pass/page2');
$this->requestStack->push($request);
/* @var \Drupal\system\Plugin\Condition\RequestPath $condition */
$condition = $this->pluginManager->createInstance('request_path');
$condition->setConfig('pages', $pages);
$this->aliasManager->addAlias('/my/pass/page2', '/my/pass/page2');
$this->assertTrue($condition->execute(), 'The request path matches a standard path');
$this->assertEqual($condition->summary(), 'Return true on the following pages: /my/pass/page, /my/pass/page2, /foo', 'The condition summary matches for a standard path');
// Test an aliased path.
$this->currentPath->setPath('/my/aliased/page', $request);
$this->requestStack->pop();
$this->requestStack->push($request);
$this->aliasManager->addAlias('/my/aliased/page', '/my/pass/page');
$this->assertTrue($condition->execute(), 'The request path matches an aliased path');
$this->assertEqual($condition->summary(), 'Return true on the following pages: /my/pass/page, /my/pass/page2, /foo', 'The condition summary matches for an aliased path');
// Test a wildcard path.
$this->aliasManager->addAlias('/my/pass/page3', '/my/pass/page3');
$this->currentPath->setPath('/my/pass/page3', $request);
$this->requestStack->pop();
$this->requestStack->push($request);
$condition->setConfig('pages', '/my/pass/*');
$this->assertTrue($condition->evaluate(), 'The system_path my/pass/page3 passes for wildcard paths.');
$this->assertEqual($condition->summary(), 'Return true on the following pages: /my/pass/*', 'The condition summary matches for a wildcard path');
// Test a missing path.
$this->requestStack->pop();
$this->requestStack->push($request);
$this->currentPath->setPath('/my/fail/page4', $request);
$condition->setConfig('pages', '/my/pass/*');
$this->aliasManager->addAlias('/my/fail/page4', '/my/fail/page4');
$this->assertFalse($condition->evaluate(), 'The system_path /my/pass/page4 fails for a missing path.');
// Test a path of '/'.
$this->aliasManager->addAlias('/', '/my/pass/page3');
$this->currentPath->setPath('/', $request);
$this->requestStack->pop();
$this->requestStack->push($request);
$this->assertTrue($condition->evaluate(), 'The system_path my/pass/page3 passes for wildcard paths.');
$this->assertEqual($condition->summary(), 'Return true on the following pages: /my/pass/*', 'The condition summary matches for a wildcard path');
}
/**
* renders content with the real website controller.
*
* @param PageBridge $content
* @param bool $partial
*
* @return string
*/
public function render(PageBridge $content, $partial = false)
{
// set active theme
$webspace = $this->webspaceManager->findWebspaceByKey($content->getWebspaceKey());
$this->activeTheme->setName($webspace->getTheme()->getKey());
// get controller and invoke action
$request = new Request();
$request->attributes->set('_controller', $content->getController());
$controller = $this->controllerResolver->getController($request);
// prepare locale for translator and request
$request->setLocale($content->getLanguageCode());
$localeBefore = $this->translator->getLocale();
$this->translator->setLocale($content->getLanguageCode());
$this->requestStack->push($request);
/** @var Response $response */
$response = $controller[0]->{$controller[1]}($content, true, $partial);
// roll back
$this->requestStack->pop();
$this->translator->setLocale($localeBefore);
return $response->getContent();
}
public function testLegacyResultHasLayout()
{
$requestStack = new RequestStack();
$requestStack->push(new Request());
$manager = new LegacyResponseManager($this->templateEngine, $this->configResolver, $requestStack);
self::assertFalse($manager->legacyResultHasLayout(new ezpKernelResult()));
$resultWithLegacyLayout = new ezpKernelResult('', ['module_result' => ['pagelayout' => 'foo.tpl']]);
self::assertTrue($manager->legacyResultHasLayout($resultWithLegacyLayout));
$request = new Request();
$request->attributes->set('_route', '_ezpublishLegacyLayoutSet');
$requestStack->pop();
$requestStack->push($request);
self::assertTrue($manager->legacyResultHasLayout($resultWithLegacyLayout));
}
/**
* Sends BigPipe placeholders' replacements as embedded AJAX responses.
*
* @param array $placeholders
* Associative array; the BigPipe placeholders. Keys are the BigPipe
* selectors.
* @param array $placeholder_order
* Indexed array; the order in which the BigPipe placeholders must be sent.
* Values are the BigPipe selectors. (These values correspond to keys in
* $placeholders.)
* @param \Drupal\Core\Asset\AttachedAssetsInterface $cumulative_assets
* The cumulative assets sent so far; to be updated while rendering BigPipe
* placeholders.
*/
protected function sendPlaceholders(array $placeholders, array $placeholder_order, AttachedAssetsInterface $cumulative_assets)
{
// Return early if there are no BigPipe placeholders to send.
if (empty($placeholders)) {
return;
}
// Send a container and the start signal.
print "\n";
print '<script type="application/json" data-big-pipe-event="start"></script>' . "\n";
flush();
// A BigPipe response consists of a HTML response plus multiple embedded
// AJAX responses. To process the attachments of those AJAX responses, we
// need a fake request that is identical to the master request, but with
// one change: it must have the right Accept header, otherwise the work-
// around for a bug in IE9 will cause not JSON, but <textarea>-wrapped JSON
// to be returned.
// @see \Drupal\Core\EventSubscriber\AjaxResponseSubscriber::onResponse()
$fake_request = $this->requestStack->getMasterRequest()->duplicate();
$fake_request->headers->set('Accept', 'application/json');
foreach ($placeholder_order as $placeholder) {
if (!isset($placeholders[$placeholder])) {
continue;
}
// Render the placeholder.
$placeholder_render_array = $placeholders[$placeholder];
$elements = $this->renderPlaceholder($placeholder, $placeholder_render_array);
// Create a new AjaxResponse.
$ajax_response = new AjaxResponse();
// JavaScript's querySelector automatically decodes HTML entities in
// attributes, so we must decode the entities of the current BigPipe
// placeholder (which has HTML entities encoded since we use it to find
// the placeholders).
$big_pipe_js_selector = Html::decodeEntities($placeholder);
$ajax_response->addCommand(new ReplaceCommand(sprintf('[data-big-pipe-selector="%s"]', $big_pipe_js_selector), $elements['#markup']));
$ajax_response->setAttachments($elements['#attached']);
// Push a fake request with the asset libraries loaded so far and dispatch
// KernelEvents::RESPONSE event. This results in the attachments for the
// AJAX response being processed by AjaxResponseAttachmentsProcessor and
// hence:
// - the necessary AJAX commands to load the necessary missing asset
// libraries and updated AJAX page state are added to the AJAX response
// - the attachments associated with the response are finalized, which
// allows us to track the total set of asset libraries sent in the
// initial HTML response plus all embedded AJAX responses sent so far.
$fake_request->request->set('ajax_page_state', ['libraries' => implode(',', $cumulative_assets->getAlreadyLoadedLibraries())] + $cumulative_assets->getSettings()['ajaxPageState']);
$this->requestStack->push($fake_request);
$event = new FilterResponseEvent($this->httpKernel, $fake_request, HttpKernelInterface::SUB_REQUEST, $ajax_response);
$this->eventDispatcher->dispatch(KernelEvents::RESPONSE, $event);
$ajax_response = $event->getResponse();
$this->requestStack->pop();
// Send this embedded AJAX response.
$json = $ajax_response->getContent();
$output = <<<EOF
<script type="application/json" data-big-pipe-placeholder="{$placeholder}" data-drupal-ajax-processor="big_pipe">
{$json}
</script>
EOF;
print $output;
flush();
// Another placeholder was rendered and sent, track the set of asset
// libraries sent so far. Any new settings are already sent; we don't need
// to track those.
if (isset($ajax_response->getAttachments()['drupalSettings']['ajaxPageState']['libraries'])) {
$cumulative_assets->setAlreadyLoadedLibraries(explode(',', $ajax_response->getAttachments()['drupalSettings']['ajaxPageState']['libraries']));
}
}
// Send the stop signal.
print '<script type="application/json" data-big-pipe-event="stop"></script>' . "\n";
flush();
}
/**
* @return null|Request
*/
protected function popRequestFromStack()
{
return $this->requestStack->pop();
}