add tests

tests/Http/Handlers/GetHelloHandlerTest.php

@@ -0,0 +1,36 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Http\Handlers;
+
+use PHPUnit\Framework\TestCase;
+use Zend\Diactoros\ServerRequest;
+
+class GetHelloHandlerTest extends TestCase
+{
+    public function test_handle_with_no_name_attribute()
+    {
+        $handler = new GetHelloHandler();
+        $request = new ServerRequest();
+
+        $response = $handler->handle($request);
+
+        $this->assertEquals(200, $response->getStatusCode());
+        $this->assertEquals('application/json', $response->getHeaderLine('Content-Type'));
+        $this->assertEquals('["Hello, world!"]', $response->getBody()->__toString());
+
+    }
+
+    public function test_handle_with_name_attribute()
+    {
+        $handler = new GetHelloHandler();
+        $request = (new ServerRequest())
+            ->withAttribute('name', 'Tom');
+
+        $response = $handler->handle($request);
+
+        $this->assertEquals(200, $response->getStatusCode());
+        $this->assertEquals('application/json', $response->getHeaderLine('Content-Type'));
+        $this->assertEquals('["Hello, Tom!"]', $response->getBody()->__toString());
+    }
+}

tests/Http/Middleware/BasicAuthTest.php

@@ -0,0 +1,81 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Http\Middleware;
+
+use Interop\Http\Server\RequestHandlerInterface;
+use PHPUnit\Framework\MockObject\MockObject;
+use PHPUnit\Framework\TestCase;
+use Psr\Log\LoggerInterface;
+use Zend\Diactoros\Response;
+use Zend\Diactoros\ServerRequest;
+
+class BasicAuthTest extends TestCase
+{
+    public function test_process_returns_delegated_response_with_valid_authorization_header()
+    {
+        $url = 'https://example.com/admin';
+        $request = (new ServerRequest([], [], $url))
+            ->withHeader('Authorization', 'Basic dXNlcjpwYXNzd29yZA==');
+        $response = new Response();
+
+        $userName = 'user';
+        $password = 'password';
+        $realm = 'secret';
+        $middleware = new BasicAuth($userName, $password, $realm);
+
+        /** @var RequestHandlerInterface|MockObject $delegate */
+        $delegate = $this->getMockBuilder(RequestHandlerInterface::class)->getMock();
+        $delegate->expects($this->once())
+            ->method('handle')
+            ->with($request)
+            ->willReturn($response);
+
+        $result = $middleware->process($request, $delegate);
+
+        $this->assertSame($response, $result);
+    }
+
+    public function test_process_returns_unauthorized_response_with_no_authorization_header()
+    {
+        $url = 'https://example.com/admin';
+        $request = (new ServerRequest([], [], $url));
+
+        $userName = 'user';
+        $password = 'password';
+        $realm = 'secret';
+        $middleware = new BasicAuth($userName, $password, $realm);
+
+        /** @var RequestHandlerInterface|MockObject $delegate */
+        $delegate = $this->getMockBuilder(RequestHandlerInterface::class)->getMock();
+        $delegate->expects($this->never())
+            ->method('handle');
+
+        $result = $middleware->process($request, $delegate);
+
+        $this->assertEquals(401, $result->getStatusCode());
+        $this->assertEquals('Basic realm="secret"', $result->getHeaderLine('WWW-Authenticate'));
+    }
+
+    public function test_process_returns_unauthorized_response_with_invalid_authorization_header()
+    {
+        $url = 'https://example.com/admin';
+        $request = (new ServerRequest([], [], $url))
+            ->withHeader('Authorization', 'Basic dXNlcjpwYXNzd29yZA');
+
+        $userName = 'user';
+        $password = 'password';
+        $realm = 'secret';
+        $middleware = new BasicAuth($userName, $password, $realm);
+
+        /** @var RequestHandlerInterface|MockObject $delegate */
+        $delegate = $this->getMockBuilder(RequestHandlerInterface::class)->getMock();
+        $delegate->expects($this->never())
+            ->method('handle');
+
+        $result = $middleware->process($request, $delegate);
+
+        $this->assertEquals(401, $result->getStatusCode());
+        $this->assertEquals('Basic realm="secret"', $result->getHeaderLine('WWW-Authenticate'));
+    }
+}

tests/Http/Middleware/BenchMarkTest.php

@@ -0,0 +1,40 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Http\Middleware;
+
+use Interop\Http\Server\RequestHandlerInterface;
+use PHPUnit\Framework\MockObject\MockObject;
+use PHPUnit\Framework\TestCase;
+use Psr\Log\LoggerInterface;
+use Zend\Diactoros\Response;
+use Zend\Diactoros\ServerRequest;
+
+class BenchMarkTest extends TestCase
+{
+    public function test_process()
+    {
+        $url = 'https://example.com/hello';
+        $request = new ServerRequest([], [], $url);
+        $response = new Response();
+
+        /** @var LoggerInterface|MockObject $logger */
+        $logger = $this->getMockBuilder(LoggerInterface::class)->getMock();
+        $logger->expects($this->once())
+            ->method('info')
+            ->with($this->matchesRegularExpression("|GET https://example\.com/hello \(200\) : processed in \d\.\d ms\.|"));
+
+        $middleware = new BenchMark($logger);
+
+        /** @var RequestHandlerInterface|MockObject $delegate */
+        $delegate = $this->getMockBuilder(RequestHandlerInterface::class)->getMock();
+        $delegate->expects($this->once())
+            ->method('handle')
+            ->with($request)
+            ->willReturn($response);
+
+        $result = $middleware->process($request, $delegate);
+
+        $this->assertSame($response, $result);
+    }
+}

tests/Http/Routing/RoutingErrorResponderTest.php

@@ -0,0 +1,26 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Http\Routing;
+
+use N1215\Http\Router\RoutingError;
+use PHPUnit\Framework\TestCase;
+use Zend\Diactoros\ServerRequest;
+
+class RoutingErrorResponderTest extends TestCase
+{
+    public function test_respond()
+    {
+        $request = new ServerRequest();
+        $responder = new RoutingErrorResponder();
+        $statusCode = 404;
+        $message = 'route not found';
+        $routingError = new RoutingError($statusCode, $message);
+
+        $response = $responder->respond($request, $routingError);
+
+        $this->assertEquals($statusCode, $response->getStatusCode());
+        $this->assertEquals('application/json', $response->getHeaderLine('Content-Type'));
+        $this->assertEquals("{\"message\":\"{$message}\"}", $response->getBody()->__toString());
+    }
+}

tests/Providers/EventServiceProviderTest.php

@@ -0,0 +1,41 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Providers;
+
+use Illuminate\Container\Container;
+use N1215\Tsukuyomi\Event\AppTerminating;
+use N1215\Tsukuyomi\Event\EventManager;
+use N1215\Tsukuyomi\Event\EventManagerInterface;
+use PHPUnit\Framework\TestCase;
+use Psr\Log\LoggerInterface;
+use Zend\Diactoros\Response;
+use Zend\Diactoros\ServerRequest;
+
+class EventServiceProviderTest extends TestCase
+{
+    public function test_register()
+    {
+        $container = new Container();
+        $container->bind(LoggerInterface::class, function () {
+           $logger = $this->getMockBuilder(LoggerInterface::class)->getMock();
+
+           $logger->expects($this->once())
+               ->method('info')
+               ->with('Event: app.terminating');
+
+           return $logger;
+        });
+
+        $provider = new EventServiceProvider();
+        $provider->register($container);
+
+        $eventManager = $container->get(EventManagerInterface::class);
+
+        $this->assertInstanceOf(EventManager::class, $eventManager);
+
+        $request = new ServerRequest();
+        $response = new Response();
+        $eventManager->trigger(new AppTerminating($request, $response));
+    }
+}

tests/Providers/HandlerServiceProviderTest.php

@@ -0,0 +1,24 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Providers;
+
+use App\Http\Handlers\GetHelloHandler;
+use Illuminate\Container\Container;
+use PHPUnit\Framework\TestCase;
+
+class HandlerServiceProviderTest extends TestCase
+{
+    public function test_register()
+    {
+        $container = new Container();
+        $provider = new HandlerServiceProvider();
+        $provider->register($container);
+
+        $first = $container->get(GetHelloHandler::class);
+        $this->assertInstanceOf(GetHelloHandler::class, $first);
+
+        $second = $container->get(GetHelloHandler::class);
+        $this->assertSame($first, $second);
+    }
+}

tests/Providers/LogServiceProviderTest.php

@@ -0,0 +1,27 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Providers;
+
+use Illuminate\Container\Container;
+use Monolog\Logger;
+use N1215\Tsukuyomi\Framework;
+use N1215\Tsukuyomi\FrameworkInterface;
+use PHPUnit\Framework\TestCase;
+use Psr\Log\LoggerInterface;
+
+class LogServiceProviderTest extends TestCase
+{
+    public function test_register()
+    {
+        $container = new Container();
+        $container->bind(FrameworkInterface::class, function (Container $container) {
+            return new Framework($container, dirname(dirname(__DIR__)));
+        });
+
+        $provider = new LogServiceProvider();
+        $provider->register($container);
+
+        $this->assertInstanceOf(Logger::class, $container->get(LoggerInterface::class));
+    }
+}

tests/Providers/MiddlewareServiceProviderTest.php

@@ -0,0 +1,41 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Providers;
+
+use App\Http\Middleware\BasicAuth;
+use App\Http\Middleware\BenchMark;
+use Illuminate\Container\Container;
+use PHPUnit\Framework\TestCase;
+use Psr\Log\LoggerInterface;
+
+class MiddlewareServiceProviderTest extends TestCase
+{
+    private $middlewareClasses = [
+        BasicAuth::class,
+        BenchMark::class
+    ];
+
+    public function test_register()
+    {
+        putenv('BASIC_AUTH_USER=user');
+        putenv('BASIC_AUTH_PASSWORD=password');
+        putenv('BASIC_AUTH_REALM=secret');
+
+        $container = new Container();
+        $container->bind(LoggerInterface::class, function () {
+            return $this->createMock(LoggerInterface::class);
+        });
+
+        $provider = new MiddlewareServiceProvider();
+        $provider->register($container);
+
+        foreach ($this->middlewareClasses as $middlewareClass) {
+            $first = $container->get($middlewareClass);
+            $this->assertInstanceOf($middlewareClass, $first);
+
+            $second = $container->get($middlewareClass);
+            $this->assertSame($first, $second);
+        }
+    }
+}

tests/Providers/RouteServiceProviderTest.php

@@ -0,0 +1,35 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Providers;
+
+use App\Http\Routing\RoutingErrorResponder;
+use Illuminate\Container\Container;
+use N1215\Hakudo\Router;
+use N1215\Http\Router\RouterInterface;
+use N1215\Http\Router\RoutingErrorResponderInterface;
+use N1215\Jugoya\LazyRequestHandlerBuilder;
+use N1215\Jugoya\RequestHandlerBuilderInterface;
+use N1215\Tsukuyomi\Framework;
+use N1215\Tsukuyomi\FrameworkInterface;
+use PHPUnit\Framework\TestCase;
+
+class RouteServiceProviderTest extends TestCase
+{
+    public function test_register()
+    {
+        $container = new Container();
+        $container->bind(FrameworkInterface::class, function (Container $container) {
+            return new Framework($container, dirname(dirname(__DIR__)));
+        });
+        $container->bind(RequestHandlerBuilderInterface::class, function (Container $container) {
+            return LazyRequestHandlerBuilder::fromContainer($container);
+        });
+
+        $provider = new RouteServiceProvider();
+        $provider->register($container);
+
+        $this->assertInstanceOf(Router::class, $container->get(RouterInterface::class));
+        $this->assertInstanceOf(RoutingErrorResponder::class, $container->get(RoutingErrorResponderInterface::class));
+    }
+}