Skip to content

Commit 5682224

Browse files
fenricfenric
committed
test improved
1 parent 802bd51 commit 5682224

17 files changed

+181
-90
lines changed

‎tests/Loader/DescriptorLoaderTest.php‎

Lines changed: 7 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -79,6 +79,8 @@ public function testCache() : void
7979
$cache = $this->getCache();
8080

8181
$loader = new DescriptorLoader();
82+
$loader->attach(Fixture\Controllers\Annotated\CacheableAnnotatedController::class);
83+
8284
$this->assertNull($loader->getCache());
8385
$this->assertNull($loader->getCacheKey());
8486

@@ -88,12 +90,10 @@ public function testCache() : void
8890
$loader->setCacheKey('foo');
8991
$this->assertSame('foo', $loader->getCacheKey());
9092

91-
$loader->attach(Fixture\Controllers\Annotated\CacheableAnnotatedController::class);
93+
$descriptor = new Route('controller-from-cached-descriptor', null, '/');
94+
$descriptor->holder = new ReflectionClass(Fixture\Controllers\BlankController::class);
9295

93-
// an expected route should be created from this descriptor...
94-
$cache->storage[$loader->getCacheKey()][0] = new Route('controller-from-cached-descriptor', null, '/');
95-
$cache->storage[$loader->getCacheKey()][0]->holder =
96-
new ReflectionClass(Fixture\Controllers\BlankController::class);
96+
$cache->storage[$loader->getCacheKey()][0] = $descriptor;
9797

9898
$routes = $loader->load();
9999
$this->assertTrue($routes->has($cache->storage[$loader->getCacheKey()][0]->name));
@@ -148,6 +148,7 @@ public function testLoadMinimallyAnnotatedClass() : void
148148
$this->assertSame('minimally-annotated-controller', $route->getName());
149149
$this->assertSame('/', $route->getPath());
150150
$this->assertSame(['GET'], $route->getMethods());
151+
$this->assertNotNull($route->getHolder());
151152
$this->assertSame($class, $route->getHolder()->getName());
152153
}
153154

@@ -173,6 +174,7 @@ public function testLoadMinimallyAttributedClass() : void
173174
$this->assertSame('minimally-attributed-controller', $route->getName());
174175
$this->assertSame('/', $route->getPath());
175176
$this->assertSame(['GET'], $route->getMethods());
177+
$this->assertNotNull($route->getHolder());
176178
$this->assertSame($class, $route->getHolder()->getName());
177179
}
178180

‎tests/Middleware/CallableMiddlewareTest.php‎

Lines changed: 7 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -22,8 +22,8 @@ class CallableMiddlewareTest extends TestCase
2222
*/
2323
public function testContracts() : void
2424
{
25-
$middleware = new CallableMiddleware(function () {
26-
});
25+
$callback = new Fixture\Middlewares\BlankMiddleware();
26+
$middleware = new CallableMiddleware($callback);
2727

2828
$this->assertInstanceOf(MiddlewareInterface::class, $middleware);
2929
}
@@ -33,12 +33,15 @@ public function testContracts() : void
3333
*/
3434
public function testRun() : void
3535
{
36-
$request = $this->createMock(ServerRequestInterface::class);
3736
$callback = new Fixture\Middlewares\BlankMiddleware();
3837
$middleware = new CallableMiddleware($callback);
38+
39+
$this->assertSame($callback, $middleware->getCallback());
40+
41+
$request = $this->createMock(ServerRequestInterface::class);
3942
$requestHandler = new Fixture\Controllers\BlankController();
4043
$middleware->process($request, $requestHandler);
44+
4145
$this->assertTrue($callback->isRunned());
42-
$this->assertTrue($requestHandler->isRunned());
4346
}
4447
}

‎tests/ReferenceResolverTest.php‎

Lines changed: 67 additions & 53 deletions
Original file line numberDiff line numberDiff line change
@@ -6,7 +6,6 @@
66
* Import classes
77
*/
88
use PHPUnit\Framework\TestCase;
9-
use Psr\Http\Message\ServerRequestInterface;
109
use Sunrise\Http\Router\Exception\UnresolvableReferenceException;
1110
use Sunrise\Http\Router\ReferenceResolver;
1211
use Sunrise\Http\Router\ReferenceResolverInterface;
@@ -35,96 +34,111 @@ public function testContracts() : void
3534
*/
3635
public function testContainer() : void
3736
{
38-
$container = $this->getContainer();
37+
$container = $this->getContainer([
38+
Fixture\Controllers\BlankController::class => new Fixture\Controllers\BlankController(),
39+
Fixture\Middlewares\BlankMiddleware::class => new Fixture\Middlewares\BlankMiddleware(),
40+
]);
41+
3942
$resolver = new ReferenceResolver();
4043
$resolver->setContainer($container);
4144

42-
$container->storage[Fixture\Controllers\BlankController::class] = new Fixture\Controllers\BlankController();
45+
$this->assertSame($container, $resolver->getContainer());
46+
47+
$requestHandler = $resolver->toRequestHandler(new ReflectionClass(Fixture\Controllers\BlankController::class));
48+
$this->assertSame($container->storage[Fixture\Controllers\BlankController::class], $requestHandler);
49+
50+
$requestHandler = $resolver->toRequestHandler(new ReflectionMethod(Fixture\Controllers\BlankController::class, '__invoke'));
51+
$this->assertSame($container->storage[Fixture\Controllers\BlankController::class], $requestHandler->getCallback()[0]);
52+
4353
$requestHandler = $resolver->toRequestHandler(Fixture\Controllers\BlankController::class);
4454
$this->assertSame($container->storage[Fixture\Controllers\BlankController::class], $requestHandler);
4555

46-
$container->storage[Fixture\Middlewares\BlankMiddleware::class] = new Fixture\Middlewares\BlankMiddleware();
56+
$requestHandler = $resolver->toRequestHandler([Fixture\Controllers\BlankController::class, '__invoke']);
57+
$this->assertSame($container->storage[Fixture\Controllers\BlankController::class], $requestHandler->getCallback()[0]);
58+
59+
$middleware = $resolver->toMiddleware(new ReflectionClass(Fixture\Middlewares\BlankMiddleware::class));
60+
$this->assertSame($container->storage[Fixture\Middlewares\BlankMiddleware::class], $middleware);
61+
62+
$middleware = $resolver->toMiddleware(new ReflectionMethod(Fixture\Middlewares\BlankMiddleware::class, '__invoke'));
63+
$this->assertSame($container->storage[Fixture\Middlewares\BlankMiddleware::class], $middleware->getCallback()[0]);
64+
4765
$middleware = $resolver->toMiddleware(Fixture\Middlewares\BlankMiddleware::class);
4866
$this->assertSame($container->storage[Fixture\Middlewares\BlankMiddleware::class], $middleware);
67+
68+
$middleware = $resolver->toMiddleware([Fixture\Middlewares\BlankMiddleware::class, '__invoke']);
69+
$this->assertSame($container->storage[Fixture\Middlewares\BlankMiddleware::class], $middleware->getCallback()[0]);
4970
}
5071

5172
/**
5273
* @return void
5374
*/
5475
public function testRequestHandler() : void
5576
{
56-
$request = $this->createMock(ServerRequestInterface::class);
5777
$resolver = new ReferenceResolver();
5878

59-
$requestHandler = new Fixture\Controllers\BlankController();
60-
$this->assertSame($requestHandler, $resolver->toRequestHandler($requestHandler));
79+
$reference = new Fixture\Controllers\BlankController();
80+
$requestHandler = $resolver->toRequestHandler($reference);
81+
$this->assertSame($reference, $requestHandler);
6182

62-
$requestHandler = $resolver->toRequestHandler(function ($request) {
63-
return (new Fixture\Controllers\BlankController)->handle($request);
64-
});
83+
$reference = function () {
84+
};
6585

66-
$response = $requestHandler->handle($request);
67-
$this->assertSame(200, $response->getStatusCode());
86+
$requestHandler = $resolver->toRequestHandler($reference);
87+
$this->assertSame($reference, $requestHandler->getCallback());
6888

69-
$requestHandler = $resolver->toRequestHandler(new ReflectionClass(Fixture\Controllers\BlankController::class));
70-
$response = $requestHandler->handle($request);
71-
$this->assertSame(200, $response->getStatusCode());
72-
73-
$requestHandler = $resolver->toRequestHandler(new ReflectionMethod(
74-
Fixture\Controllers\BlankController::class,
75-
'__invoke'
76-
));
89+
$reference = new ReflectionClass(Fixture\Controllers\BlankController::class);
90+
$requestHandler = $resolver->toRequestHandler($reference);
91+
$this->assertInstanceOf($reference->getName(), $requestHandler);
7792

78-
$response = $requestHandler->handle($request);
79-
$this->assertSame(200, $response->getStatusCode());
93+
$reference = new ReflectionMethod(Fixture\Controllers\BlankController::class, '__invoke');
94+
$requestHandler = $resolver->toRequestHandler($reference);
95+
$this->assertInstanceOf($reference->getDeclaringClass()->getName(), $requestHandler->getCallback()[0]);
96+
$this->assertSame($reference->getName(), $requestHandler->getCallback()[1]);
8097

81-
$requestHandler = $resolver->toRequestHandler([Fixture\Controllers\BlankController::class, '__invoke']);
82-
$response = $requestHandler->handle($request);
83-
$this->assertSame(200, $response->getStatusCode());
98+
$reference = Fixture\Controllers\BlankController::class;
99+
$requestHandler = $resolver->toRequestHandler($reference);
100+
$this->assertInstanceOf($reference, $requestHandler);
84101

85-
$requestHandler = $resolver->toRequestHandler(Fixture\Controllers\BlankController::class);
86-
$response = $requestHandler->handle($request);
87-
$this->assertSame(200, $response->getStatusCode());
102+
$reference = [Fixture\Controllers\BlankController::class, '__invoke'];
103+
$requestHandler = $resolver->toRequestHandler($reference);
104+
$this->assertInstanceOf($reference[0], $requestHandler->getCallback()[0]);
105+
$this->assertSame($reference[1], $requestHandler->getCallback()[1]);
88106
}
89107

90108
/**
91109
* @return void
92110
*/
93111
public function testMiddleware() : void
94112
{
95-
$request = $this->createMock(ServerRequestInterface::class);
96113
$resolver = new ReferenceResolver();
97-
$requestHandler = new Fixture\Controllers\BlankController();
98114

99-
$middleware = new Fixture\Middlewares\BlankMiddleware();
100-
$this->assertSame($middleware, $resolver->toMiddleware($middleware));
115+
$reference = new Fixture\Middlewares\BlankMiddleware();
116+
$requestHandler = $resolver->toMiddleware($reference);
117+
$this->assertSame($reference, $requestHandler);
101118

102-
$middleware = $resolver->toMiddleware(function ($request, $handler) {
103-
return (new Fixture\Middlewares\BlankMiddleware)->process($request, $handler);
104-
});
119+
$reference = function () {
120+
};
105121

106-
$response = $middleware->process($request, $requestHandler);
107-
$this->assertSame(200, $response->getStatusCode());
122+
$requestHandler = $resolver->toMiddleware($reference);
123+
$this->assertSame($reference, $requestHandler->getCallback());
108124

109-
$middleware = $resolver->toMiddleware(new ReflectionClass(Fixture\Middlewares\BlankMiddleware::class));
110-
$response = $middleware->process($request, $requestHandler);
111-
$this->assertSame(200, $response->getStatusCode());
125+
$reference = new ReflectionClass(Fixture\Middlewares\BlankMiddleware::class);
126+
$requestHandler = $resolver->toMiddleware($reference);
127+
$this->assertInstanceOf($reference->getName(), $requestHandler);
112128

113-
$middleware = $resolver->toMiddleware(new ReflectionMethod(
114-
Fixture\Middlewares\BlankMiddleware::class,
115-
'__invoke'
116-
));
129+
$reference = new ReflectionMethod(Fixture\Middlewares\BlankMiddleware::class, '__invoke');
130+
$requestHandler = $resolver->toMiddleware($reference);
131+
$this->assertInstanceOf($reference->getDeclaringClass()->getName(), $requestHandler->getCallback()[0]);
132+
$this->assertSame($reference->getName(), $requestHandler->getCallback()[1]);
117133

118-
$response = $middleware->process($request, $requestHandler);
119-
$this->assertSame(200, $response->getStatusCode());
134+
$reference = Fixture\Middlewares\BlankMiddleware::class;
135+
$requestHandler = $resolver->toMiddleware($reference);
136+
$this->assertInstanceOf($reference, $requestHandler);
120137

121-
$middleware = $resolver->toMiddleware([Fixture\Middlewares\BlankMiddleware::class, '__invoke']);
122-
$response = $middleware->process($request, $requestHandler);
123-
$this->assertSame(200, $response->getStatusCode());
124-
125-
$middleware = $resolver->toMiddleware(Fixture\Middlewares\BlankMiddleware::class);
126-
$response = $middleware->process($request, $requestHandler);
127-
$this->assertSame(200, $response->getStatusCode());
138+
$reference = [Fixture\Middlewares\BlankMiddleware::class, '__invoke'];
139+
$requestHandler = $resolver->toMiddleware($reference);
140+
$this->assertInstanceOf($reference[0], $requestHandler->getCallback()[0]);
141+
$this->assertSame($reference[1], $requestHandler->getCallback()[1]);
128142
}
129143

130144
/**

‎tests/RequestHandler/CallableRequestHandlerTest.php‎

Lines changed: 7 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -22,8 +22,8 @@ class CallableRequestHandlerTest extends TestCase
2222
*/
2323
public function testContracts() : void
2424
{
25-
$requestHandler = new CallableRequestHandler(function () {
26-
});
25+
$callback = new Fixture\Controllers\BlankController();
26+
$requestHandler = new CallableRequestHandler($callback);
2727

2828
$this->assertInstanceOf(RequestHandlerInterface::class, $requestHandler);
2929
}
@@ -33,10 +33,14 @@ public function testContracts() : void
3333
*/
3434
public function testRun() : void
3535
{
36-
$request = $this->createMock(ServerRequestInterface::class);
3736
$callback = new Fixture\Controllers\BlankController();
3837
$requestHandler = new CallableRequestHandler($callback);
38+
39+
$this->assertSame($callback, $requestHandler->getCallback());
40+
41+
$request = $this->createMock(ServerRequestInterface::class);
3942
$requestHandler->handle($request);
43+
4044
$this->assertTrue($callback->isRunned());
4145
}
4246
}

‎tests/RequestHandler/QueueableRequestHandlerTest.php‎

Lines changed: 11 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -33,10 +33,12 @@ public function testContracts() : void
3333
*/
3434
public function testRun() : void
3535
{
36-
$request = $this->createMock(ServerRequestInterface::class);
3736
$endpoint = new Fixture\Controllers\BlankController();
3837
$requestHandler = new QueueableRequestHandler($endpoint);
38+
39+
$request = $this->createMock(ServerRequestInterface::class);
3940
$requestHandler->handle($request);
41+
4042
$this->assertTrue($endpoint->isRunned());
4143
}
4244

@@ -45,19 +47,19 @@ public function testRun() : void
4547
*/
4648
public function testRunWithMiddlewares() : void
4749
{
48-
$request = $this->createMock(ServerRequestInterface::class);
49-
$endpoint = new Fixture\Controllers\BlankController();
50-
$requestHandler = new QueueableRequestHandler($endpoint);
51-
5250
$middlewares = [
5351
new Fixture\Middlewares\BlankMiddleware(),
5452
new Fixture\Middlewares\BlankMiddleware(),
5553
new Fixture\Middlewares\BlankMiddleware(),
5654
];
5755

56+
$endpoint = new Fixture\Controllers\BlankController();
57+
$requestHandler = new QueueableRequestHandler($endpoint);
5858
$requestHandler->add(...$middlewares);
5959

60+
$request = $this->createMock(ServerRequestInterface::class);
6061
$requestHandler->handle($request);
62+
6163
$this->assertTrue($middlewares[0]->isRunned());
6264
$this->assertTrue($middlewares[1]->isRunned());
6365
$this->assertTrue($middlewares[2]->isRunned());
@@ -69,19 +71,19 @@ public function testRunWithMiddlewares() : void
6971
*/
7072
public function testRunWithBrokenMiddleware() : void
7173
{
72-
$request = $this->createMock(ServerRequestInterface::class);
73-
$endpoint = new Fixture\Controllers\BlankController();
74-
$requestHandler = new QueueableRequestHandler($endpoint);
75-
7674
$middlewares = [
7775
new Fixture\Middlewares\BlankMiddleware(),
7876
new Fixture\Middlewares\BlankMiddleware(true),
7977
new Fixture\Middlewares\BlankMiddleware(),
8078
];
8179

80+
$endpoint = new Fixture\Controllers\BlankController();
81+
$requestHandler = new QueueableRequestHandler($endpoint);
8282
$requestHandler->add(...$middlewares);
8383

84+
$request = $this->createMock(ServerRequestInterface::class);
8485
$requestHandler->handle($request);
86+
8587
$this->assertTrue($middlewares[0]->isRunned());
8688
$this->assertTrue($middlewares[1]->isRunned());
8789
$this->assertFalse($middlewares[2]->isRunned());

‎tests/fixtures/ContainerAwareTrait.php‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -10,10 +10,10 @@ trait ContainerAwareTrait
1010
/**
1111
* @return ContainerInterface
1212
*/
13-
private function getContainer() : ContainerInterface
13+
private function getContainer(array $definitions = []) : ContainerInterface
1414
{
1515
$container = $this->createMock(ContainerInterface::class);
16-
$container->storage = [];
16+
$container->storage = $definitions;
1717

1818
$container->method('get')->will($this->returnCallback(function ($key) use ($container) {
1919
return $container->storage[$key] ?? null;

‎tests/fixtures/Controllers/AbstractController.php‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -18,9 +18,9 @@ abstract class AbstractController implements RequestHandlerInterface
1818
private $isRunned = false;
1919

2020
/**
21-
* The handled request
21+
* The request that was handled by the called method
2222
*
23-
* @var ServerRequestInterface
23+
* @var ServerRequestInterface|null
2424
*/
2525
private $request = null;
2626

@@ -35,7 +35,7 @@ public function isRunned() : bool
3535
}
3636

3737
/**
38-
* Gets the handled request
38+
* Gets the request that was handled by the called method
3939
*
4040
* @return ServerRequestInterface|null
4141
*/
@@ -52,6 +52,6 @@ public function handle(ServerRequestInterface $request) : ResponseInterface
5252
$this->isRunned = true;
5353
$this->request = $request;
5454

55-
return (new ResponseFactory)->createResponse();
55+
return (new ResponseFactory)->createResponse(200);
5656
}
5757
}

‎tests/fixtures/Controllers/BlankController.php‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -17,6 +17,6 @@ final class BlankController extends AbstractController
1717
*/
1818
public function __invoke(ServerRequestInterface $request) : ResponseInterface
1919
{
20-
return $this->handle($request);
20+
return $this->handle($request)->withStatus(305);
2121
}
2222
}

0 commit comments

Comments
 (0)