ShlinkioTest\Shlink\Rest\Middleware\BodyParserMiddlewareTest

Complexity

Total Complexity

7

Size/Duplication

Total Lines	101
Duplicated Lines	0 %

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	3	1
A	assertHandlingRequestJustFallsBackToNext()	0	8	1
A	requestsFromOtherMethodsJustFallbackToNextMiddleware()	0	4	1
A	regularRequestsAreUrlDecoded()	0	26	1
A	requestsWithNonEmptyBodyJustFallbackToNextMiddleware()	0	4	1
A	provideIgnoredRequestMethods()	0	5	1
A	jsonRequestsAreJsonDecoded()	0	27	1

<?php
declare(strict_types=1);

namespace ShlinkioTest\Shlink\Rest\Middleware;

use PHPUnit\Framework\TestCase;
use Prophecy\Argument;
use Prophecy\Prophecy\MethodProphecy;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\RequestHandlerInterface;
use Shlinkio\Shlink\Rest\Middleware\BodyParserMiddleware;
use Zend\Diactoros\Response;
use Zend\Diactoros\ServerRequest;
use Zend\Diactoros\Stream;
use function array_shift;

class BodyParserMiddlewareTest extends TestCase
{
    /** @var BodyParserMiddleware */
    private $middleware;

    public function setUp(): void
    {
        $this->middleware = new BodyParserMiddleware();
    }

    /**
     * @test
     * @dataProvider provideIgnoredRequestMethods
     */
    public function requestsFromOtherMethodsJustFallbackToNextMiddleware(string $method): void
    {
        $request = (new ServerRequest())->withMethod($method);
        $this->assertHandlingRequestJustFallsBackToNext($request);
    }

    public function provideIgnoredRequestMethods(): iterable
    {
        yield 'with GET' => ['GET'];
        yield 'with HEAD' => ['HEAD'];
        yield 'with OPTIONS' => ['OPTIONS'];
    }

    /** @test */
    public function requestsWithNonEmptyBodyJustFallbackToNextMiddleware(): void
    {
        $request = (new ServerRequest())->withParsedBody(['foo' => 'bar'])->withMethod('POST');
        $this->assertHandlingRequestJustFallsBackToNext($request);
    }

    private function assertHandlingRequestJustFallsBackToNext(ServerRequestInterface $request): void
    {
        $nextHandler = $this->prophesize(RequestHandlerInterface::class);
        $handle = $nextHandler->handle($request)->willReturn(new Response());

        $this->middleware->process($request, $nextHandler->reveal());

        $handle->shouldHaveBeenCalledOnce();
    }

    /** @test */
    public function jsonRequestsAreJsonDecoded(): void
    {
        $test = $this;
        $body = new Stream('php://temp', 'wr');
        $body->write('{"foo": "bar", "bar": ["one", 5]}');
        $request = (new ServerRequest())->withMethod('PUT')
                                        ->withBody($body)
                                        ->withHeader('content-type', 'application/json');
        $delegate = $this->prophesize(RequestHandlerInterface::class);
        /** @var MethodProphecy $process */
        $process = $delegate->handle(Argument::type(ServerRequestInterface::class))->will(
            function (array $args) use ($test) {
                /** @var ServerRequestInterface $req */
                $req = array_shift($args);

                $test->assertEquals([
                    'foo' => 'bar',
                    'bar' => ['one', 5],
                ], $req->getParsedBody());

                return new Response();
            }
        );

        $this->middleware->process($request, $delegate->reveal());

        $process->shouldHaveBeenCalledOnce();
    }

    /** @test */
    public function regularRequestsAreUrlDecoded(): void
    {
        $test = $this;
        $body = new Stream('php://temp', 'wr');
        $body->write('foo=bar&bar[]=one&bar[]=5');
        $request = (new ServerRequest())->withMethod('PUT')
                                        ->withBody($body);
        $delegate = $this->prophesize(RequestHandlerInterface::class);
        /** @var MethodProphecy $process */
        $process = $delegate->handle(Argument::type(ServerRequestInterface::class))->will(
            function (array $args) use ($test) {
                /** @var ServerRequestInterface $req */
                $req = array_shift($args);

                $test->assertEquals([
                    'foo' => 'bar',
                    'bar' => ['one', 5],
                ], $req->getParsedBody());

                return new Response();
            }
        );

        $this->middleware->process($request, $delegate->reveal());

        $process->shouldHaveBeenCalledOnce();
    }
}