Addiks\SymfonyGenerics\Tests\Unit\Controllers\DefaultControllerHelperTest

Complexity

Total Complexity

17

Size/Duplication

Total Lines	311
Duplicated Lines	23.79 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

0

<?php

final class DefaultControllerHelperTest extends TestCase
{

    private DefaultControllerHelper $controllerHelper;

This code did not parse for me. Apparently, there is an error somewhere around this line:

Syntax error, unexpected T_STRING, expecting T_FUNCTION or T_CONST

    private EntityManagerInterface $entityManager;

    private Environment $twig;

    private AuthorizationCheckerInterface $authorization;

    private UrlGeneratorInterface $urlGenerator;

    private Session $session;

    private LoggerInterface $logger;

    private EventDispatcherInterface $eventDispatcher;

    private RequestStack $requestStack;

    public function setUp()
    {
        $this->entityManager = $this->createMock(EntityManagerInterface::class);
        $this->twig = $this->createMock(Environment::class);
        $this->authorization = $this->createMock(AuthorizationCheckerInterface::class);
        $this->urlGenerator = $this->createMock(UrlGeneratorInterface::class);
        $this->session = $this->createMock(Session::class);
        $this->logger = $this->createMock(LoggerInterface::class);
        $this->eventDispatcher = $this->createMock(EventDispatcherInterface::class);
        $this->requestStack = $this->createMock(RequestStack::class);

        $this->controllerHelper = new DefaultControllerHelper(
            $this->entityManager,
            $this->twig,
            $this->authorization,
            $this->urlGenerator,
            $this->session,
            $this->logger,
            $this->eventDispatcher,
            $this->requestStack
        );
    }

    /**
     * @test
     */
    public function shouldRenderTemplate()
    {
        $this->twig->expects($this->once())->method('render')->with(
            $this->equalTo('some-template'),
            $this->equalTo(['foo', 'bar'])
        )->willReturn('some-response');

        /** @var Response $actualResult */
        $actualResult = $this->controllerHelper->renderTemplate('some-template', ['foo', 'bar']);

        $this->assertEquals(new Response('some-response'), $actualResult);
    }

    /**
     * @test
     */
    public function shouldFindEntity()
    {
        $this->entityManager->expects($this->once())->method('find')->with(
            $this->equalTo('some-class'),
            $this->equalTo('foo')
        )->willReturn('some-entity');

        /** @var mixed $actualResult */
        $actualResult = $this->controllerHelper->findEntity('some-class', 'foo');

        $this->assertEquals('some-entity', $actualResult);
    }

    /**
     * @test
     */
    public function shouldFindEntities()
    {
        /** @var ObjectRepository $repository */
        $repository = $this->createMock(ObjectRepository::class);
        $repository->method('findBy')->with(
            $this->equalTo(['foo' => 'bar'])
        )->willReturn(['some-entity', 'some-other-entity']);

        $this->entityManager->expects($this->once())->method('getRepository')->with(
            $this->equalTo('some-class')
        )->willReturn($repository);

        /** @var mixed $actualResult */
        $actualResult = $this->controllerHelper->findEntities('some-class', ['foo' => 'bar']);

        $this->assertEquals(['some-entity', 'some-other-entity'], $actualResult);
    }

    /**
     * @test
     */
    public function shouldPersistEntity()
    {
        /** @var stdClass $entity */
        $entity = $this->createMock(stdClass::class);

        $this->entityManager->expects($this->once())->method('persist')->with($this->identicalTo($entity));

        $this->controllerHelper->persistEntity($entity);
    }

    /**
     * @test
     */
    public function shouldRemoveEntity()
    {
        /** @var stdClass $entity */
        $entity = $this->createMock(stdClass::class);

        $this->entityManager->expects($this->once())->method('remove')->with($this->identicalTo($entity));

        $this->controllerHelper->removeEntity($entity);
    }

    /**
     * @test
     */
    public function shouldFlushORM()
    {
        $this->entityManager->expects($this->once())->method('flush');
        $this->controllerHelper->flushORM();
    }

    /**
     * @test
     */
    public function shouldHaveRequestStack()
    {
        $this->assertSame($this->requestStack, $this->controllerHelper->getRequestStack());
    }

    /**
     * @test
     */
    public function shouldHaveCurrentRequest()
    {
        /** @var Request $request */
        $request = $this->createMock(Request::class);

        $this->requestStack->method("getCurrentRequest")->willReturn($request);

        $this->assertSame($request, $this->controllerHelper->getCurrentRequest());
    }

    /**
     * @test
     */
    public function shouldDispatchEvent()
    {
        /** @var Event $event */
        $event = $this->createMock(Event::class);

        $this->eventDispatcher->expects($this->once())->method('dispatch')->with(
            $this->equalTo($event),
            $this->equalTo('foo')
        )->willReturn($event);

        $this->assertSame($event, $this->controllerHelper->dispatchEvent("foo", $event));
    }

    /**
     * @test
     */
    public function shouldHandleException()
    {
        /** @var Exception $exception */
        $exception = $this->createMock('Exception');
        $exception->method('__toString')->willReturn("some-string");

        $this->logger->expects($this->once())->method('log')->with(
            $this->equalTo('error'),
            $this->identicalTo('some-string')
        );

        $this->controllerHelper->handleException($exception);
    }

    /**
     * @test
     */
    public function shouldAddFlashMessage()
    {
        /** @var FlashBagInterface $flashBag */
        $flashBag = $this->createMock(FlashBagInterface::class);
        $flashBag->expects($this->once())->method('add')->with(
            $this->equalTo('some-type'),
            $this->equalTo("Lorem ipsum dolor sit amet!")
        );

        $this->session->method('getFlashBag')->willReturn($flashBag);

        $this->controllerHelper->addFlashMessage("Lorem ipsum dolor sit amet!", "some-type");
    }

    /**
     * @test
     */
    public function shouldUseDefaultCodeWhenRedirectingToRoute()
    {
        $this->urlGenerator->expects($this->once())->method('generate')->with(
            $this->equalTo('some_route'),
            $this->equalTo(['foo' => 'bar']),
            $this->equalTo(UrlGeneratorInterface::ABSOLUTE_URL)
        )->willReturn("*this-is-some-url*");

        $expectedResponse = new RedirectResponse("*this-is-some-url*", 301);

        /** @var RedirectResponse $actualResponse */
        $actualResponse = $this->controllerHelper->redirectToRoute("some_route", ['foo' => 'bar']);

        $this->assertEquals($expectedResponse, $actualResponse);
    }

    /**
     * @test
     */
    public function shouldRedirectToRoute()
    {
        $this->urlGenerator->expects($this->once())->method('generate')->with(
            $this->equalTo('some_route'),
            $this->equalTo(['foo' => 'bar']),
            $this->equalTo(UrlGeneratorInterface::ABSOLUTE_URL)
        )->willReturn("*this-is-some-url*");

        $expectedResponse = new RedirectResponse("*this-is-some-url*", 302);

        /** @var RedirectResponse $actualResponse */
        $actualResponse = $this->controllerHelper->redirectToRoute("some_route", ['foo' => 'bar'], 302);

        $this->assertEquals($expectedResponse, $actualResponse);
    }

    /**
     * @test
     */
    public function shouldDenyAccessWhenNotGranted()
    {
        $this->expectException(AccessDeniedException::class);

        /** @var stdClass $subject */
        $subject = $this->createMock(stdClass::class);

        $this->authorization->expects($this->once())->method('isGranted')->with(
            $this->equalTo("foo"),
            $this->equalTo($subject)
        )->willReturn(false);

        try {
            $this->controllerHelper->denyAccessUnlessGranted("foo", $subject);

        } catch (AccessDeniedException $exception) {
            $this->assertEquals(["foo"], $exception->getAttributes());
            $this->assertSame($subject, $exception->getSubject());

            throw $exception;
        }
    }

    /**
     * @test
     */
    public function shouldNotDenyAccessWhenGranted()
    {
        /** @var stdClass $subject */
        $subject = $this->createMock(stdClass::class);

        $this->authorization->expects($this->once())->method('isGranted')->with(
            $this->equalTo("foo"),
            $this->equalTo($subject)
        )->willReturn(true);

        $this->controllerHelper->denyAccessUnlessGranted("foo", $subject);
    }

}