FH\Bundle\CookieGuardBundle\Tests\Twig\CookieGuardExtensionTest

Complexity

Total Complexity

16

Size/Duplication

Total Lines	148
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	testCookieSettingsAreAccepted()	0	8	1
A	testShowIfCookieIsNotAccepted()	0	9	1
A	createRequestStackMock()	0	6	1
A	createCookieGuardExtension()	0	6	1
A	testName()	0	7	1
A	testCookieSettingsAreNotSubmitted()	0	7	1
A	testCookieSettingsAreNotAccepted()	0	7	1
A	testFunctionExistence()	0	14	2
A	testShowIfCookieAccepted()	0	7	1
A	createTwigEnvironmentMock()	0	18	2
A	createRequestWithCookie()	0	4	1
A	testCookieSettingsAreSubmitted()	0	8	1
A	testFilterExistence()	0	13	2

<?php
declare(strict_types=1);

namespace FH\Bundle\CookieGuardBundle\Tests\Twig;

use FH\Bundle\CookieGuardBundle\Twig\CookieGuardExtension;
use PHPUnit\Framework\Assert;

The type PHPUnit\Framework\Assert was not found. Maybe you did not declare it correctly or list all dependencies?

use PHPUnit\Framework\MockObject\MockObject;

The type PHPUnit\Framework\MockObject\MockObject was not found. Maybe you did not declare it correctly or list all dependencies?

use PHPUnit\Framework\TestCase;

The type PHPUnit\Framework\TestCase was not found. Maybe you did not declare it correctly or list all dependencies?

use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\RequestStack;
use Twig\Environment;
use Twig\TwigFilter;
use Twig\TwigFunction;

/**
 * @author Evert Harmeling <evert@freshheads.com>
 */
final class CookieGuardExtensionTest extends TestCase
{
    private const COOKIE_NAME = 'test-cookie';

    public function testFilterExistence(): void
    {
        // arrange
        $extension = $this->createCookieGuardExtension();

        $filterNames = [];
        /** @var TwigFilter $filter */
        foreach ($extension->getFilters() as $filter) {
            Assert::assertInstanceOf(TwigFilter::class, $filter);
            $filterNames[] = $filter->getName();
        }

        Assert::assertContains('cookie_guard', $filterNames);
    }

    public function testFunctionExistence(): void
    {
        // arrange
        $extension = $this->createCookieGuardExtension();

        $functionNames = [];
        /** @var TwigFunction $filter */
        foreach ($extension->getFunctions() as $function) {
            Assert::assertInstanceOf(TwigFunction::class, $function);
            $functionNames[] = $function->getName();
        }

        Assert::assertContains('cookie_settings_submitted', $functionNames);
        Assert::assertContains('cookie_settings_accepted', $functionNames);
    }

    public function testCookieSettingsAreNotAccepted(): void
    {
        // arrange
        $extension = $this->createCookieGuardExtension();

        // act && assert
        Assert::assertFalse($extension->cookieSettingsAreAccepted());
    }

    public function testCookieSettingsAreAccepted(): void
    {
        // arrange
        $request = $this->createRequestWithCookie();
        $extension = $this->createCookieGuardExtension($this->createRequestStackMock($request));

        // act && assert
        Assert::assertTrue($extension->cookieSettingsAreAccepted());
    }

    public function testCookieSettingsAreNotSubmitted(): void
    {
        // arrange
        $extension = $this->createCookieGuardExtension();

        // act && assert
        Assert::assertFalse($extension->cookieSettingsSubmitted());
    }

    public function testCookieSettingsAreSubmitted(): void
    {
        // arrange
        $request = $this->createRequestWithCookie();
        $extension = $this->createCookieGuardExtension($this->createRequestStackMock($request));

        // act && assert
        Assert::assertTrue($extension->cookieSettingsSubmitted());
    }

    public function testShowIfCookieIsNotAccepted(): void
    {
        // arrange
        $extension = $this->createCookieGuardExtension();

        // act && assert
        Assert::assertEquals(
            sprintf('<meta class="js-cookie-guarded" data-content="%s" />', 'cookie not accepted'),
            $extension->showIfCookieAccepted('cookie not accepted')
        );
    }

    public function testShowIfCookieAccepted(): void
    {
        // arrange
        $extension = $this->createCookieGuardExtension(null, $this->createTwigEnvironmentMock('cookie accepted', true));

        // act && assert
        Assert::assertEquals('cookie accepted', $extension->showIfCookieAccepted('cookie accepted'));
    }

    public function testName(): void
    {
        // arrange
        $extension = $this->createCookieGuardExtension();

        // act && assert
        Assert::assertEquals(CookieGuardExtension::class, $extension->getName());
    }

    private function createRequestWithCookie(): Request
    {
        return new Request([], [], [], [
            self::COOKIE_NAME => true
        ]);
    }

    private function createCookieGuardExtension(RequestStack $requestStack = null, MockObject $twigEnvironment = null): CookieGuardExtension
    {
        return new CookieGuardExtension(
            $requestStack ?? $this->createRequestStackMock(),
            $twigEnvironment ?? $this->createTwigEnvironmentMock(),
            self::COOKIE_NAME
        );
    }

    private function createRequestStackMock(Request $request = null): RequestStack
    {
        $requestStack = new RequestStack();
        $requestStack->push($request ?? Request::createFromGlobals());

        return $requestStack;
    }

    /**
     * @return MockObject|Environment
     */
    private function createTwigEnvironmentMock(string $content = 'cookie not accepted', bool $show = false): MockObject
    {
        $twigEnvironmentMock = $this->getMockBuilder(Environment::class)
            ->disableOriginalConstructor()
            ->setMethods([
                'render'
            ])
            ->getMock();

        if (!$show) {
            $content = sprintf('<meta class="js-cookie-guarded" data-content="%s" />', $content);
        }

        $twigEnvironmentMock
            ->method('render')
            ->willReturn($content);

        return $twigEnvironmentMock;
    }
}