DefaultControllerHelperTest::shouldDispatchEvent() - Code Metrics - Inspection of "tests" - addiks/symfony_generics - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 8dcf4e...d684ef )

by Gerrit

created 2019-05-18 09:57 UTC

DefaultControllerHelperTest::shouldDispatchEvent() A

↳ Parent: DefaultControllerHelperTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	12
rs	9.8666
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php
/**
 * Copyright (C) 2017  Gerrit Addiks.
 * This package (including this file) was released under the terms of the GPL-3.0.
 * You should have received a copy of the GNU General Public License along with this program.
 * If not, see <http://www.gnu.org/licenses/> or send me a mail so i can send you a copy.
 * @license GPL-3.0
 * @author Gerrit Addiks <[email protected]>
 */

namespace Addiks\SymfonyGenerics\Tests\Unit\Controllers;

use PHPUnit\Framework\TestCase;
use Addiks\SymfonyGenerics\Controllers\DefaultControllerHelper;
use Doctrine\ORM\EntityManagerInterface;
use Twig_Environment;
use Symfony\Component\Security\Core\Authorization\AuthorizationCheckerInterface;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
use Symfony\Component\HttpFoundation\Session\Session;
use Psr\Log\LoggerInterface;
use Symfony\Component\Security\Core\Exception\AccessDeniedException;
use stdClass;
use Symfony\Component\HttpFoundation\RedirectResponse;
use Symfony\Component\HttpFoundation\Session\Flash\FlashBagInterface;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
use Symfony\Component\HttpFoundation\RequestStack;
use Symfony\Component\HttpFoundation\Response;
use Doctrine\Common\Persistence\ObjectRepository;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\EventDispatcher\Event;

final class DefaultControllerHelperTest extends TestCase
{

    /**
     * @var DefaultControllerHelper
     */
    private $controllerHelper;

    /**
     * @var EntityManagerInterface
     */
    private $entityManager;

    /**
     * @var Twig_Environment
     */
    private $twig;

    /**
     * @var AuthorizationCheckerInterface
     */
    private $authorization;

    /**
     * @var UrlGeneratorInterface
     */
    private $urlGenerator;

    /**
     * @var Session
     */
    private $session;

    /**
     * @var LoggerInterface
     */
    private $logger;

    /**
     * @var EventDispatcherInterface
     */
    private $eventDispatcher;

    /**
     * @var RequestStack
     */
    private $requestStack;

    public function setUp()
    {
        $this->entityManager = $this->createMock(EntityManagerInterface::class);

        $this->twig = $this->createMock(Twig_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,
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            $this->twig,
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            $this->authorization,
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            $this->urlGenerator,
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            $this->session,
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            $this->logger,
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            $this->eventDispatcher,
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            $this->requestStack
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        );
    }

    /**
     * @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('foo'),
            $this->equalTo($event)
        )->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 shouldDenyAccessUnlessGranted()
    {
        $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;
        }
    }

}


1			<?php
2			/**
3			* Copyright (C) 2017 Gerrit Addiks.
4			* This package (including this file) was released under the terms of the GPL-3.0.
5			* You should have received a copy of the GNU General Public License along with this program.
6			* If not, see <http://www.gnu.org/licenses/> or send me a mail so i can send you a copy.
7			* @license GPL-3.0
8			* @author Gerrit Addiks <[email protected]>
9			*/
10
11			namespace Addiks\SymfonyGenerics\Tests\Unit\Controllers;
12
13			use PHPUnit\Framework\TestCase;
14			use Addiks\SymfonyGenerics\Controllers\DefaultControllerHelper;
15			use Doctrine\ORM\EntityManagerInterface;
16			use Twig_Environment;
17			use Symfony\Component\Security\Core\Authorization\AuthorizationCheckerInterface;
18			use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
19			use Symfony\Component\HttpFoundation\Session\Session;
20			use Psr\Log\LoggerInterface;
21			use Symfony\Component\Security\Core\Exception\AccessDeniedException;
22			use stdClass;
23			use Symfony\Component\HttpFoundation\RedirectResponse;
24			use Symfony\Component\HttpFoundation\Session\Flash\FlashBagInterface;
25			use Symfony\Component\EventDispatcher\EventDispatcherInterface;
26			use Symfony\Component\HttpFoundation\RequestStack;
27			use Symfony\Component\HttpFoundation\Response;
28			use Doctrine\Common\Persistence\ObjectRepository;
29			use Symfony\Component\HttpFoundation\Request;
30			use Symfony\Component\EventDispatcher\Event;
31
32			final class DefaultControllerHelperTest extends TestCase
33			{
34
35			/**
36			* @var DefaultControllerHelper
37			*/
38			private $controllerHelper;
39
40			/**

addiks / symfony_generics

Push — master ( 8dcf4e...d684ef )

DefaultControllerHelperTest::shouldDispatchEvent() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like