Povs\ListerBundle\Service\RequestHandlerTest

Complexity

Total Complexity

7

Size/Duplication

Total Lines	120
Duplicated Lines	0 %

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	testHandlerRequest()	0	56	1
A	testGetValue()	0	5	1
A	getRequestHandler()	0	26	1
A	testGetLength()	0	5	1
A	testGetCurrentPage()	0	5	1
A	testGetRequest()	0	4	1
A	testGetName()	0	5	1

<?php

namespace Povs\ListerBundle\Service;

use Doctrine\Common\Collections\ArrayCollection;
use PHPUnit\Framework\TestCase;
use Povs\ListerBundle\Mapper\FilterField;
use Povs\ListerBundle\Mapper\FilterMapper;
use Povs\ListerBundle\Mapper\ListField;
use Povs\ListerBundle\Mapper\ListMapper;
use Symfony\Component\Form\FormInterface;
use Symfony\Component\HttpFoundation\ParameterBag;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\RequestStack;

/**
 * @author Povilas Margaiatis <p.margaitis@gmail.com>
 */
class RequestHandlerTest extends TestCase
{
    public function testHandlerRequest(): void
    {
        $listMapperMock = $this->createMock(ListMapper::class);
        $filterMapperMock = $this->createMock(FilterMapper::class);
        $formMock = $this->createMock(FormInterface::class);
        $listFieldMock = $this->createMock(ListField::class);
        $listFieldMock2 = $this->createMock(ListField::class);
        $listFieldMock->expects($this->exactly(2))
            ->method('setOption')
            ->withConsecutive(
                ['sort_value', 'DESC'],
                ['lazy', false]
            );
        $listFieldMock->expects($this->once())
            ->method('getId')
            ->willReturn('test_id');
        $listMapperMock->expects($this->once())
            ->method('getFields')
            ->willReturn(new ArrayCollection([$listFieldMock2]));
        $listFieldMock2->expects($this->once())
            ->method('getId')
            ->willReturn('another_id');
        $listFieldMock2->expects($this->once())
            ->method('setOption')
            ->with('sort_value', null);
        $listMapperMock->expects($this->once())
            ->method('get')
            ->willReturn($listFieldMock);
        $formMock->expects($this->once())
            ->method('handleRequest');
        $formMock->expects($this->once())
            ->method('isSubmitted')
            ->willReturn(true);
        $formMock->expects($this->once())
            ->method('isValid')
            ->willReturn(true);
        $formMock->expects($this->once())
            ->method('getData')
            ->willReturn(['field1' => 'val1', 'field2' => 'val2']);
        $filterFieldMock1 = $this->createMock(FilterField::class);
        $filterFieldMock2 = $this->createMock(FilterField::class);
        $filterFieldMock1->expects($this->once())
            ->method('setValue')
            ->with('val1');
        $filterFieldMock2->expects($this->once())
            ->method('setValue')
            ->with('val2');
        $filterMapperMock->expects($this->exactly(2))
            ->method('get')
            ->willReturnMap([
                ['field1', $filterFieldMock1],
                ['field2', $filterFieldMock2]
            ]);

        $requestHandler = $this->getRequestHandler([['sort', null, ['field2' => 'invalid_sort', 'field1' => 'desc']]], [], [['sort', 'sort']]);
        $requestHandler->handleRequest($listMapperMock, $filterMapperMock, $formMock);
    }

    public function testGetCurrentPage(): void
    {
        $handler = $this->getRequestHandler([['page', null, 20]], [], [['page', 'page']]);

        $this->assertEquals(20, $handler->getCurrentPage());
    }

    public function testGetLength(): void
    {
        $handler = $this->getRequestHandler([['length', null, 20]], [], [['length', 'length']]);

        $this->assertEquals(20, $handler->getLength());
    }

    public function testGetValue(): void
    {
        $handler = $this->getRequestHandler([['foo', null, 'custom_value']], [], [['custom_name', 'foo']]);

        $this->assertEquals('custom_value', $handler->getValue('custom_name'));
    }

    public function testGetName(): void
    {
        $handler = $this->getRequestHandler([], [], [['custom_name', 'foo']]);

        $this->assertEquals('foo', $handler->getName('custom_name'));
    }

    public function testGetRequest(): void
    {
        $handler = $this->getRequestHandler([], [], []);
        $this->assertNotNull($handler->getRequest());
    }

    private function getRequestHandler(array $query, array $attributes, array $configs): RequestHandler
    {
        $requestMock = $this->createMock(Request::class);
        $queryMock = $this->createMock(ParameterBag::class);
        $attributesMock = $this->createMock(ParameterBag::class);
        $configMock = $this->createMock(ConfigurationResolver::class);
        $requestStackMock = $this->createMock(RequestStack::class);

        $queryMock->expects($this->exactly(count($query)))
            ->method('get')
            ->willReturnMap($query);
        $attributesMock->expects($this->exactly(count($attributes)))
            ->method('get')
            ->willReturnMap($attributes);
        $configMock->expects($this->exactly(count($configs)))
            ->method('getRequestConfiguration')
            ->willReturnMap($configs);
        $configMock->method('isMultiColumnSortable')
            ->willReturn(false);
        $requestMock->query = $queryMock;

Accessing query on the interface PHPUnit\Framework\MockObject\MockObject suggest that you code against a concrete implementation. How about adding an instanceof check?

        $requestMock->attributes = $attributesMock;

Accessing attributes on the interface PHPUnit\Framework\MockObject\MockObject suggest that you code against a concrete implementation. How about adding an instanceof check?

        $requestStackMock->expects($this->once())
            ->method('getCurrentRequest')
            ->willReturn($requestMock);

        return new RequestHandler($requestStackMock, $configMock);
    }
}