summaryrefslogtreecommitdiffstats
path: root/tests
diff options
context:
space:
mode:
Diffstat (limited to 'tests')
-rw-r--r--tests/Router/Middleware/BasePathTest.php235
-rw-r--r--tests/Router/Middleware/NotFoundTest.php265
-rw-r--r--tests/Router/Routes/GlobTest.php35
3 files changed, 535 insertions, 0 deletions
diff --git a/tests/Router/Middleware/BasePathTest.php b/tests/Router/Middleware/BasePathTest.php
new file mode 100644
index 0000000..eb9a2e8
--- /dev/null
+++ b/tests/Router/Middleware/BasePathTest.php
@@ -0,0 +1,235 @@
+<?php
+
+use Jasny\Router\Middleware\BasePath;
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\StreamInterface;
+use Psr\Http\Message\UriInterface;
+
+class BasePathTest extends PHPUnit_Framework_TestCase
+{
+ /**
+ * Test creating middleware with invalid parameter
+ *
+ * @dataProvider invalidConstructProvider
+ */
+ public function testInvalidConstruct($basePath)
+ {
+ $this->expectException(\InvalidArgumentException::class);
+
+ $pathHandler = new BasePath($basePath);
+ }
+
+ /**
+ * Provide data for testing invalid BasePath creation
+ *
+ * @return array
+ */
+ public function invalidConstructProvider()
+ {
+ return [
+ [''],
+ ['/'],
+ [null],
+ [false],
+ [['test']],
+ [(object)['test']],
+ [12345]
+ ];
+ }
+
+ /**
+ * Test creating BasePath instance
+ *
+ * @dataProvider validConstructProvider
+ * @param string $basePath
+ */
+ public function testValidConstruct($basePath, $validBasePath)
+ {
+ $pathHandler = new BasePath($basePath);
+
+ $this->assertNotEmpty($pathHandler->getBasePath(), "Empty base path");
+ $this->assertEquals($validBasePath, $pathHandler->getBasePath(), "Base path was not set correctly");
+ }
+
+ /**
+ * Provide data for testing BasePath creation
+ *
+ * @return array
+ */
+ public function validConstructProvider()
+ {
+ return [
+ ['/foo', '/foo'],
+ ['/foo/', '/foo/'],
+ ['foo/', '/foo/'],
+ ['/foo/bar', '/foo/bar'],
+ ['foo/bar', '/foo/bar'],
+ ['/foo/bar/', '/foo/bar/'],
+ ['/foo/bar-zet/', '/foo/bar-zet/']
+ ];
+ }
+
+ /**
+ * Test invoke with invalid 'next' param
+ */
+ public function testInvokeInvalidNext()
+ {
+ $middleware = new BasePath('/foo');
+ list($request, $response) = $this->getRequests();
+
+ $this->expectException(\InvalidArgumentException::class);
+
+ $result = $middleware($request, $response, 'not_callable');
+ }
+
+ /**
+ * Test case when given request path does not starts with given base path
+ *
+ * @dataProvider notFoundProvider
+ * @param string $basePath
+ * @param string $path
+ */
+ public function testNotFound($basePath, $path)
+ {
+ $middleware = new BasePath($basePath);
+ list($request, $response) = $this->getRequests();
+
+ $this->expectRequestGetPath($request, $path);
+ $this->expectNotFound($response);
+
+ $result = $middleware($request, $response, function($response, $request) {
+ $response->nextCalled = true;
+
+ return $response;
+ });
+
+ $this->assertEquals(get_class($response), get_class($result), "Middleware should return response object");
+ $this->assertFalse(isset($response->nextCalled), "'next' was called");
+ }
+
+ /**
+ * Provide data for testing BasePath creation
+ *
+ * @return array
+ */
+ public function notFoundProvider()
+ {
+ return [
+ ['/foo', '/bar'],
+ ['/foo', '/bar/foo'],
+ ['/foo/bar', '/zet/foo/bar'],
+ ['/foo/bar', '/foo/bar-/teta'],
+ ['/foo/bar', '/foo/bar-zet/teta'],
+ ['/foo/bar', '/foo/ba'],
+ ['/foo/bar', '/foo'],
+ ['/f', '/foo'],
+ ];
+ }
+
+ /**
+ * Test correct case, when path contains base path
+ *
+ * @dataProvider foundProvider
+ * @param string $basePath
+ * @param string $path
+ * @param string $noBasePath
+ */
+ public function testFound($basePath, $path, $noBasePath)
+ {
+ $middleware = new BasePath($basePath);
+ list($request, $response) = $this->getRequests();
+
+ $this->expectRequestSetBasePath($request, $basePath, $path, $noBasePath);
+
+ $result = $middleware($request, $response, function($request, $response) {
+ $response->nextCalled = true;
+
+ return $response;
+ });
+
+ $this->assertEquals(get_class($response), get_class($result), "Middleware should return response object");
+ $this->assertTrue($response->nextCalled, "'next' was not called");
+ }
+
+ /**
+ * Provide data for testing BasePath creation
+ *
+ * @return array
+ */
+ public function foundProvider()
+ {
+ return [
+ ['/foo', '/foo', '/'],
+ ['foo', '/foo', '/'],
+ ['/foo', '/foo/bar', '/bar'],
+ ['/foo/bar', '/foo/bar', '/'],
+ ['foo/bar', '/foo/bar', '/'],
+ ['/foo/bar', '/foo/bar/zet', '/zet'],
+ ['/f', '/f/foo', '/foo'],
+ ['f', '/f/foo', '/foo'],
+ ];
+ }
+
+ /**
+ * Get requests for testing
+ *
+ * @param string $path
+ * @return array
+ */
+ public function getRequests($path = null)
+ {
+ $request = $this->createMock(ServerRequestInterface::class);
+ $response = $this->createMock(ResponseInterface::class);
+
+ return [$request, $response];
+ }
+
+ /**
+ * Expect that request will return a path
+ *
+ * @param ServerRequestInterface $request
+ * @param string $path
+ */
+ public function expectRequestGetPath(ServerRequestInterface $request, $path)
+ {
+ $uri = $this->createMock(UriInterface::class);
+ $uri->expects($this->once())->method('getPath')->will($this->returnValue($path));
+ $request->expects($this->once())->method('getUri')->will($this->returnValue($uri));
+ }
+
+ /**
+ * Expect for setting base path for request
+ *
+ * @param ServerRequestInterface $request
+ * @param string $basePath
+ * @param string $path
+ * @param string $noBasePath
+ */
+ public function expectRequestSetBasePath(ServerRequestInterface $request, $basePath, $path, $noBasePath)
+ {
+ $uri = $this->createMock(UriInterface::class);
+ $uri->expects($this->once())->method('getPath')->will($this->returnValue($path));
+ $uri->expects($this->once())->method('withPath')->with($this->equalTo($noBasePath))->will($this->returnSelf());
+
+ $request->expects($this->once())->method('getUri')->will($this->returnValue($uri));
+ $request->expects($this->once())->method('withUri')->with($this->equalTo($uri))->will($this->returnSelf());
+ $request->expects($this->once())->method('withAttribute')->with($this->equalTo('original_uri'), $this->equalTo($uri))->will($this->returnSelf());
+ }
+
+ /**
+ * Expect for not found error
+ *
+ * @param ResponseInterface $response
+ */
+ public function expectNotFound(ResponseInterface $response)
+ {
+ $stream = $this->createMock(StreamInterface::class);
+ $stream->expects($this->once())->method('rewind');
+ $stream->expects($this->once())->method('write')->with($this->equalTo('Not Found'));
+
+ $response->method('getBody')->will($this->returnValue($stream));
+ $response->expects($this->once())->method('withBody')->with($this->equalTo($stream))->will($this->returnSelf());
+ $response->expects($this->once())->method('withStatus')->with($this->equalTo(404), $this->equalTo('Not Found'))->will($this->returnSelf());
+ }
+}
diff --git a/tests/Router/Middleware/NotFoundTest.php b/tests/Router/Middleware/NotFoundTest.php
new file mode 100644
index 0000000..0c40a68
--- /dev/null
+++ b/tests/Router/Middleware/NotFoundTest.php
@@ -0,0 +1,265 @@
+<?php
+
+use Jasny\Router\Routes;
+use Jasny\Router\Middleware\NotFound;
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\StreamInterface;
+
+class NotFoundTest extends PHPUnit_Framework_TestCase
+{
+ /**
+ * Test creating object with false parameters
+ *
+ * @dataProvider constructProvider
+ * @param string $notFound
+ * @param string $notAllowed
+ * @param boolean $positive
+ */
+ public function testConstruct($notFound, $notAllowed, $positive)
+ {
+ if (!$positive) $this->expectException(\InvalidArgumentException::class);
+
+ $middleware = new NotFound($this->getRoutes(), $notFound, $notAllowed);
+
+ if ($positive) $this->skipTest();
+ }
+
+ /**
+ * Provide data for testing '__contruct'
+ */
+ public function constructProvider()
+ {
+ return [
+ [null, 405, false],
+ [true, true, false],
+ [99, null, false],
+ [600, null, false],
+ [404, 99, false],
+ [404, 600, false],
+ [200, 405, true],
+ [404, 200, true]
+ ];
+ }
+
+ /**
+ * Test invoke with invalid 'next' param
+ */
+ public function testInvokeInvalidNext()
+ {
+ $middleware = new NotFound($this->getRoutes(), 404, 405);
+ list($request, $response) = $this->getRequests();
+
+ $this->expectException(\InvalidArgumentException::class);
+
+ $result = $middleware($request, $response, 'not_callable');
+ }
+
+ /**
+ * Test that 'next' callback is invoked when route is found
+ *
+ * @dataProvider invokeProvider
+ * @param callback|int $notFound
+ * @param callback|int $notAllowed
+ * @param callback $next
+ */
+ public function testInvokeFound($notFound, $notAllowed, $next)
+ {
+ if (!$next) return $this->skipTest();
+
+ list($request, $response) = $this->getRequests();
+ $routes = $this->getRoutes();
+ $middleware = new NotFound($routes, $notFound, $notAllowed);
+
+ $this->expectRoute($routes, $request, 'found');
+ $this->notExpectSimpleError($response);
+
+ $result = $middleware($request, $response, $next);
+
+ $this->assertEquals(get_class($response), get_class($result), "Result must be an instance of 'ResponseInterface'");
+ $this->assertTrue($result->nextCalled, "'next' was not called");
+ $this->assertFalse(isset($result->notAllowedCalled), "'Not allowed' callback was called");
+ $this->assertFalse(isset($result->notFoundCalled), "'Not found' callback was called");
+ }
+
+ /**
+ * Test __invoke method in case of route is found with another method
+ *
+ * @dataProvider invokeProvider
+ * @param callback|int $notFound
+ * @param callback|int $notAllowed
+ * @param callback $next
+ */
+ public function testInvokeNotAllowed($notFound, $notAllowed, $next)
+ {
+ if (!$notAllowed) return $this->skipTest();
+
+ list($request, $response) = $this->getRequests();
+ $routes = $this->getRoutes();
+ $middleware = new NotFound($routes, $notFound, $notAllowed);
+
+ $this->expectRoute($routes, $request, 'notAllowed');
+ if (is_numeric($notAllowed)) {
+ $this->expectSimpleError($response, $notAllowed);
+ }
+
+ $result = $middleware($request, $response, $next);
+
+ $this->assertEquals(get_class($response), get_class($result), "Result must be an instance of 'ResponseInterface'");
+ $this->assertFalse(isset($result->nextCalled), "'next' was called");
+
+ if (is_callable($notAllowed)) {
+ $this->assertTrue($result->notAllowedCalled, "'Not allowed' callback was not called");
+ }
+ }
+
+ /**
+ * Test __invoke method in case of route not found at all
+ *
+ * @dataProvider invokeProvider
+ * @param callback|int $notFound
+ * @param callback|int $notAllowed
+ * @param callback $next
+ */
+ public function testInvokeNotFound($notFound, $notAllowed, $next)
+ {
+ list($request, $response) = $this->getRequests();
+ $routes = $this->getRoutes();
+ $middleware = new NotFound($routes, $notFound, $notAllowed);
+
+ $case = $notAllowed ? 'notFoundTwice' : 'notFoundOnce';
+ $this->expectRoute($routes, $request, $case);
+
+ if (is_numeric($notFound)) {
+ $this->expectSimpleError($response, $notFound);
+ }
+
+ $result = $middleware($request, $response, $next);
+
+ $this->assertEquals(get_class($response), get_class($result), "Result must be an instance of 'ResponseInterface'");
+ $this->assertFalse(isset($result->nextCalled), "'next' was called");
+
+ if (is_callable($notAllowed)) {
+ $this->assertFalse(isset($result->notAllowedCalled), "'Not allowed' callback was called");
+ }
+ if (is_callable($notFound)) {
+ $this->assertTrue($result->notFoundCalled, "'Not found' callback was not called");
+ }
+ }
+
+ /**
+ * Set expectations on finding route
+ *
+ * @param Routes $routes
+ * @param ServerRequestInterface $request
+ * @param string $case
+ */
+ public function expectRoute($routes, $request, $case)
+ {
+ if ($case === 'found' || $case === 'notFoundOnce') {
+ $found = $case === 'found';
+
+ $routes->expects($this->once())->method('hasRoute')
+ ->with($this->equalTo($request))->will($this->returnValue($found));
+ } elseif ($case === 'notAllowed' || $case === 'notFoundTwice') {
+ $routes->expects($this->exactly(2))->method('hasRoute')
+ ->withConsecutive(
+ [$this->equalTo($request)],
+ [$this->equalTo($request), $this->equalTo(false)]
+ )->will($this->returnCallback(function($request, $searchMethod = true) use ($case) {
+ return $case === 'notFoundTwice' ? false : !$searchMethod;
+ }));
+ }
+ }
+
+ /**
+ * Provide data for testing invoke method
+ */
+ public function invokeProvider()
+ {
+ $callbacks = [];
+ foreach (['notFound', 'notAllowed', 'next'] as $type) {
+ $var = $type . 'Called';
+
+ $callbacks[$type] = function($request, $response) use ($var) {
+ $response->$var = true;
+ return $response;
+ };
+ }
+
+ return [
+ [404, 405, $callbacks['next']],
+ [404, 405, null],
+ [404, null, $callbacks['next']],
+ [404, null, null],
+ [$callbacks['notFound'], $callbacks['notAllowed'], $callbacks['next']],
+ [$callbacks['notFound'], $callbacks['notAllowed'], null],
+ [$callbacks['notFound'], null, $callbacks['next']],
+ [$callbacks['notFound'], null, null]
+ ];
+ }
+
+ /**
+ * Expect that response is set to simple deny answer
+ *
+ * @param ResponseInterface $response
+ * @param int $statusCode
+ */
+ public function expectSimpleError(ResponseInterface $response, $statusCode)
+ {
+ $stream = $this->createMock(StreamInterface::class);
+ $stream->expects($this->once())->method('rewind');
+ $stream->expects($this->once())->method('write')->with($this->equalTo('Not Found'));
+
+ $response->method('getBody')->will($this->returnValue($stream));
+ $response->expects($this->once())->method('withBody')->with($this->equalTo($stream))->will($this->returnSelf());
+ $response->expects($this->once())->method('withStatus')->with($this->equalTo($statusCode), $this->equalTo('Not Found'))->will($this->returnSelf());
+ }
+
+ /**
+ * Expect that there would be no simple error response
+ *
+ * @param ResponseInterface $response
+ */
+ public function notExpectSimpleError(ResponseInterface $response)
+ {
+ $stream = $this->createMock(StreamInterface::class);
+ $stream->expects($this->never())->method('rewind');
+ $stream->expects($this->never())->method('write');
+
+ $response->expects($this->never())->method('getBody');
+ $response->expects($this->never())->method('withBody');
+ $response->expects($this->never())->method('withStatus');
+ }
+
+ /**
+ * Get requests for testing
+ *
+ * @return array
+ */
+ public function getRequests()
+ {
+ $request = $this->createMock(ServerRequestInterface::class);
+ $response = $this->createMock(ResponseInterface::class);
+
+ return [$request, $response];
+ }
+
+ /**
+ * Get routes array
+ *
+ * @return Routes
+ */
+ public function getRoutes()
+ {
+ return $this->getMockBuilder(Routes::class)->disableOriginalConstructor()->getMock();
+ }
+
+ /**
+ * Skip the test pass
+ */
+ public function skipTest()
+ {
+ return $this->assertTrue(true);
+ }
+}
diff --git a/tests/Router/Routes/GlobTest.php b/tests/Router/Routes/GlobTest.php
index 565c51b..30ceddc 100644
--- a/tests/Router/Routes/GlobTest.php
+++ b/tests/Router/Routes/GlobTest.php
@@ -247,6 +247,41 @@ class GlobTest extends PHPUnit_Framework_TestCase
}
/**
+ * Test checking if route exists regardless of request method
+ *
+ * @dataProvider getHasRouteNoMethodProvider
+ */
+ public function testHasRouteNoMethod($uri, $method)
+ {
+ $values = [
+ '/' => ['controller' => 'value0'],
+ '/foo/bar' => ['controller' => 'value1'],
+ '/foo +GET' => ['controller' => 'value2'],
+ '/bar/foo/zet -POST' => ['controller' => 'value3']
+ ];
+
+ $glob = new Glob($values);
+ $request = $this->getServerRequest($uri, $method);
+
+ $this->assertTrue($glob->hasRoute($request, false), "Route not exists");
+ }
+
+ /**
+ * Provide data for creating ServerRequestInterface objects
+ */
+ public function getHasRouteNoMethodProvider()
+ {
+ return [
+ ['/', 'GET'],
+ ['/foo/bar', 'GET'],
+ ['/foo', 'GET'],
+ ['/foo', 'POST'],
+ ['/bar/foo/zet', 'GET'],
+ ['/bar/foo/zet', 'POST']
+ ];
+ }
+
+ /**
* Test binding simple string when getting route
*/
public function testBindVarString()
generated by cgit v1.1 at 2025-05-11 23:10:14 +0000