Yiisoft\Yii\Web\Tests\Middleware\CallbackTest

Complexity

Total Complexity

3

Size/Duplication

Total Lines	87
Duplicated Lines	0 %

Importance

Changes	3
Bugs	1	Features	2

13 Methods

Rating	Name	Duplication	Size	Complexity
A	handlerIsPassedToCallback()	0	8	1
A	callbackResultReturned()	0	8	1
	createRequest()	0	3	?
	createContainer()	0	10	?
A	hp$1 ➔ createRequestHandler()	0	6	1
A	hp$0 ➔ createContainer()	0	10	1
	createRequestHandler()	0	6	?
A	hp$0 ➔ has()	0	2	1
A	hp$0 ➔ get()	0	3	1
A	hp$1 ➔ handle()	0	3	1
A	hp$1 ➔ createRequest()	0	3	1
A	checkDiContainerCalled()	0	8	1
A	requestIsPassedToCallback()	0	13	1

<?php

namespace Yiisoft\Yii\Web\Tests\Middleware;

use Nyholm\Psr7\Response;
use Nyholm\Psr7\ServerRequest;
use PHPUnit\Framework\TestCase;
use Psr\Container\ContainerInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\RequestHandlerInterface;
use Yiisoft\Router\Method;
use Yiisoft\Yii\Web\Middleware\Callback;

final class CallbackTest extends TestCase
{
    /**
     * @test
     */
    public function handlerIsPassedToCallback()
    {
        $middleware = new Callback(function (ServerRequestInterface $request, RequestHandlerInterface $handler) {
            return $handler->handle($request);
        }, $this->createContainer());

        $response = $middleware->process($this->createRequest(), $this->createRequestHandler());
        $this->assertEquals(200, $response->getStatusCode());
    }

    /**
     * @test
     */
    public function callbackResultReturned()
    {
        $middleware = new Callback(function () {
            return new Response(400);
        }, $this->createContainer());

        $response = $middleware->process($this->createRequest(), $this->createRequestHandler());
        $this->assertEquals(400, $response->getStatusCode());
    }

    /**
     * @test
     */
    public function requestIsPassedToCallback()
    {
        $requestMethod = Method::PUT;
        $requestUri = '/test/request/uri';
        $middleware = new Callback(function (ServerRequestInterface $request, RequestHandlerInterface $handler) use ($requestMethod, $requestUri) {

            $this->assertEquals($request->getMethod(), $requestMethod);
            $this->assertEquals($request->getUri(), $requestUri);

            return $handler->handle($request);
        }, $this->createContainer());

        $middleware->process($this->createRequest($requestMethod, $requestUri), $this->createRequestHandler());
    }

    /**
     * @test
     */
    public function checkDiContainerCalled()
    {
        $middleware = new Callback(function (Response $response) {
            return $response;
        }, $this->createContainer());

        $response = $middleware->process($this->createRequest(), $this->createRequestHandler());
        $this->assertEquals(404, $response->getStatusCode());
    }

    private function createContainer(): ContainerInterface
    {
        return new class implements ContainerInterface {
            public function get($id)
            {
                return new Response(404);
            }

            public function has($id)
            {
                // do nothing
            }
        };
    }

    private function createRequestHandler(): RequestHandlerInterface
    {
        return new class implements RequestHandlerInterface {
            public function handle(ServerRequestInterface $request): ResponseInterface
            {
                return new Response(200);
            }
        };
    }

    private function createRequest(string $method = Method::GET, string $uri = '/'): ServerRequestInterface
    {
        return new ServerRequest($method, $uri);
    }
}