/**
* @test
*/
public function someWhiteListedSituationsFallbackToNextMiddleware()
{
$request = ServerRequestFactory::fromGlobals();
$response = new Response();
$isCalled = false;
$this->assertFalse($isCalled);
$this->middleware->__invoke($request, $response, function ($req, $resp) use(&$isCalled) {
$isCalled = true;
});
$this->assertTrue($isCalled);
$request = ServerRequestFactory::fromGlobals()->withAttribute(RouteResult::class, RouteResult::fromRouteFailure(['GET']));
$response = new Response();
$isCalled = false;
$this->assertFalse($isCalled);
$this->middleware->__invoke($request, $response, function ($req, $resp) use(&$isCalled) {
$isCalled = true;
});
$this->assertTrue($isCalled);
$request = ServerRequestFactory::fromGlobals()->withAttribute(RouteResult::class, RouteResult::fromRouteMatch('rest-authenticate', 'foo', []));
$response = new Response();
$isCalled = false;
$this->assertFalse($isCalled);
$this->middleware->__invoke($request, $response, function ($req, $resp) use(&$isCalled) {
$isCalled = true;
});
$this->assertTrue($isCalled);
$request = ServerRequestFactory::fromGlobals()->withAttribute(RouteResult::class, RouteResult::fromRouteMatch('bar', 'foo', []))->withMethod('OPTIONS');
$response = new Response();
$isCalled = false;
$this->assertFalse($isCalled);
$this->middleware->__invoke($request, $response, function ($req, $resp) use(&$isCalled) {
$isCalled = true;
});
$this->assertTrue($isCalled);
}
/**
* {@inheritdoc}
*/
public function match(Request $request)
{
$this->router->handle($request->getUri()->getPath());
if (!$this->router->wasMatched()) {
// TODO Is it worth to validate, if route matches but the method is incompatible?
return RouteResult::fromRouteFailure();
}
$matchedRoute = $this->router->getMatchedRoute();
return RouteResult::fromRouteMatch($matchedRoute->getName(), $this->router->getNamespaceName(), $this->collectParams($matchedRoute));
}
/**
* Attempt to match an incoming request to a registered route.
*
* @param PsrRequest $request
* @return RouteResult
*/
public function match(PsrRequest $request)
{
$match = $this->zf2Router->match(Psr7ServerRequest::toZend($request, true));
if (null === $match) {
return RouteResult::fromRouteFailure();
}
$allowedMethods = $this->getAllowedMethods($match->getMatchedRouteName());
if (!$this->methodIsAllowed($request->getMethod(), $allowedMethods)) {
return RouteResult::fromRouteFailure($allowedMethods);
}
return $this->marshalSuccessResultFromRouteMatch($match);
}
/**
* {@inheritdoc}
*/
public function match(ServerRequestInterface $request)
{
$this->injectRoutes();
$matchResult = $this->router->match($request);
if ($matchResult instanceof SuccessfulMatch) {
return RouteResult::fromRouteMatch($matchResult->getRouteName(), $matchResult->getParam('middleware'), $matchResult->getParams());
}
if ($matchResult instanceof MethodNotAllowed) {
return RouteResult::fromRouteFailure($matchResult->getAllowedMethods());
}
return RouteResult::fromRouteFailure();
}
/**
* Match a request against the known routes.
*
* Implementations will aggregate required information from the provided
* request instance, and pass them to the underlying router implementation;
* when done, they will then marshal a `RouteResult` instance indicating
* the results of the matching operation and return it to the caller.
*
* @param Request $request
* @return RouteResult
*/
public function match(Request $request)
{
$this->_forbidRouteAdd = true;
$params = $request->getServerParams();
$path = $params['PATH_INFO'];
// get the matched route
$matchedRoute = $this->_matchPathToRoutePath($path);
// check if route exists
if ($matchedRoute instanceof Route) {
return RouteResult::fromRouteMatch($matchedRoute->getName(), $matchedRoute->getMiddleware(), $params);
}
return RouteResult::fromRouteFailure();
}
/**
* @param Request $request
* @return RouteResult
*/
public function match(Request $request)
{
$matchedRoutes = $this->router->getMatchedRoutes($request->getMethod(), $request->getUri()->getPath());
if (count($matchedRoutes) === 0) {
return RouteResult::fromRouteFailure();
}
/** @var \Slim\Route $matchedRoute */
$matchedRoute = array_shift($matchedRoutes);
$params = $matchedRoute->getParams();
// Get the middleware from the route params and remove it
$middleware = $params['middleware'];
unset($params['middleware']);
return RouteResult::fromRouteMatch($matchedRoute->getName(), $middleware, $params);
}
public function testGeneralRoutingFailureCallsNextWithSameRequestAndResponse()
{
$request = new ServerRequest();
$response = new Response();
$result = RouteResult::fromRouteFailure();
$this->router->match($request)->willReturn($result);
$called = false;
$next = function ($req, $res) use(&$called, $request, $response) {
$this->assertSame($request, $req);
$this->assertSame($response, $res);
$called = true;
};
$app = $this->getApplication();
$app->routeMiddleware($request, $response, $next);
$this->assertTrue($called);
}
public function testComposedEmitterIsCalledByRun()
{
$routeResult = RouteResult::fromRouteFailure();
$this->router->match()->willReturn($routeResult);
$finalResponse = $this->prophesize('Psr\\Http\\Message\\ResponseInterface')->reveal();
$finalHandler = function ($req, $res, $err = null) use($finalResponse) {
return $finalResponse;
};
$emitter = $this->prophesize('Zend\\Diactoros\\Response\\EmitterInterface');
$emitter->emit(Argument::type('Psr\\Http\\Message\\ResponseInterface'))->shouldBeCalled();
$app = new Application($this->router->reveal(), null, $finalHandler, $emitter->reveal());
$request = new Request([], [], 'http://example.com/');
$response = $this->prophesize('Psr\\Http\\Message\\ResponseInterface');
$app->run($request, $response->reveal());
}
public function testInvokeRedirectResponseDisallowNotRoutedUrlAndRouteMatchIsFailure()
{
$config = ['allow_not_routed_url' => false, 'default_url' => '/default'];
$router = $this->prophesize(RouterInterface::class);
$middleware = new RedirectHandlerAction($config, $router->reveal());
$request = $this->prophesize(ServerRequest::class);
$uri = $this->prophesize(Uri::class);
$uri->getPath()->willReturn('/')->shouldBeCalled();
$request->getUri()->willReturn($uri)->shouldBeCalled();
$request->withUri(Argument::type(Uri::class))->willReturn($request);
$routeResult = RouteResult::fromRouteFailure();
$router->match($request)->willReturn($routeResult);
$response = new RedirectResponse('/foo?query');
$next = function ($req, $res, $err = null) use($response) {
return $response;
};
$this->assertInstanceOf(RedirectResponse::class, $response);
$response = $middleware->__invoke($request->reveal(), $response, $next);
$this->assertInstanceOf(Response::class, $response);
}
/**
* Marshals a route result based on the results of matching and the current HTTP method.
*
* @param array $result
* @param string $method
* @return RouteResult
*/
private function marshalMatchedRoute(array $result, $method)
{
$path = $result[1];
$route = array_reduce($this->routes, function ($matched, $route) use($path, $method) {
if ($matched) {
return $matched;
}
if ($path !== $route->getPath()) {
return $matched;
}
if (!$route->allowsMethod($method)) {
return $matched;
}
return $route;
}, false);
if (false === $route) {
// This likely should never occur, but is present for completeness.
return RouteResult::fromRouteFailure();
}
return RouteResult::fromRouteMatch($route->getName(), $route->getMiddleware(), $result[2]);
}
/**
* Marshal a routing failure result.
*
* If the failure was due to the HTTP method, passes the allowed HTTP
* methods to the factory.
*
* @return RouteResult
*/
private function marshalFailedRoute(array $result)
{
if ($result[0] === Dispatcher::METHOD_NOT_ALLOWED) {
return RouteResult::fromRouteFailure($result[1]);
}
return RouteResult::fromRouteFailure();
}
/**
* Marshal a RouteResult representing a route failure.
*
* If the route failure is due to the HTTP method, passes the allowed
* methods when creating the result.
*
* @param Request $request
* @return RouteResult
*/
private function marshalFailedRoute(Request $request)
{
$failedRoute = $this->router->getFailedRoute();
// Evidently, getFailedRoute() can sometimes return null; these are 404 conditions.
if (null === $failedRoute) {
return RouteResult::fromRouteFailure();
}
if ($failedRoute->failedMethod()) {
return RouteResult::fromRouteFailure($failedRoute->method);
}
// Check to see if the route regex matched; if so, and we have an entry
// for the path, register a 405.
list($path) = explode('^', $failedRoute->name);
if (isset($failedRoute->failed) && $failedRoute->failed !== AuraRoute::FAILED_REGEX && array_key_exists($path, $this->routes)) {
return RouteResult::fromRouteFailure($this->routes[$path]);
}
return RouteResult::fromRouteFailure();
}
/**
* Create a successful RouteResult from the given RouteMatch.
*
* @param RouteMatch $match
* @return RouteResult
*/
private function marshalSuccessResultFromRouteMatch(RouteMatch $match)
{
$params = $match->getParams();
if (array_key_exists(self::METHOD_NOT_ALLOWED_ROUTE, $params)) {
return RouteResult::fromRouteFailure($this->allowedMethodsByPath[$params[self::METHOD_NOT_ALLOWED_ROUTE]]);
}
return RouteResult::fromRouteMatch($this->getMatchedRouteName($match->getMatchedRouteName()), $params['middleware'], $params);
}
/**
* Marshal a RouteResult representing a route failure.
*
* If the route failure is due to the HTTP method, passes the allowed
* methods when creating the result.
*
* @return RouteResult
*/
private function marshalFailedRoute()
{
$failedRoute = $this->router->getFailedRoute();
if (!$failedRoute->failedMethod()) {
return RouteResult::fromRouteFailure();
}
return RouteResult::fromRouteFailure($failedRoute->method);
}
