LAG\AdminBundle\Tests\Base

Complexity

Total Complexity

23

Size/Duplication

Total Lines	323
Duplicated Lines	8.67 %

Coupling/Cohesion

Components	2
Dependencies	8

Importance

Changes	11
Bugs	2	Features	2

17 Methods

Rating	Name	Duplication	Size	Complexity
B	initApplication()	0	26	3
A	assertExceptionRaised()	0	14	3
A	getAdminsConfiguration()	0	22	1
A	mockAdmin()	0	9	1
A	mockAction()	0	15	1
A	mockActionConfiguration()	0	15	1
A	mockAdminFactory()	0	16	1
A	mockSession()	14	14	2
A	mockLogger()	14	14	2
A	mockEntityRepository()	0	6	1
B	mockEntityManager()	0	24	1
A	mockActionFactory()	0	12	1
A	mockTokenStorage()	0	6	1
A	mockApplicationConfiguration()	0	12	1
A	mockMessageHandler()	0	9	1
A	mockTranslator()	0	6	1
A	mockDataProvider()	0	6	1

<?php

namespace LAG\AdminBundle\Tests;

use Closure;
use Doctrine\ORM\EntityManager;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\Mapping\ClassMetadata;
use Exception;
use LAG\AdminBundle\Admin\ActionInterface;
use LAG\AdminBundle\Admin\Admin;
use LAG\AdminBundle\Admin\Configuration\ActionConfiguration;
use LAG\AdminBundle\Admin\Configuration\ApplicationConfiguration;
use LAG\AdminBundle\Admin\Factory\ActionFactory;
use LAG\AdminBundle\Admin\Factory\AdminFactory;
use LAG\AdminBundle\DataProvider\DataProviderInterface;
use LAG\AdminBundle\Message\MessageHandlerInterface;
use LAG\DoctrineRepositoryBundle\Repository\RepositoryInterface;
use PHPUnit_Framework_MockObject_MockObject;
use Symfony\Bridge\Monolog\Logger;
use Symfony\Bundle\FrameworkBundle\Test\WebTestCase;
use Symfony\Component\DependencyInjection\ContainerInterface;
use Symfony\Component\EventDispatcher\EventDispatcher;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Session\Session;
use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
use Symfony\Component\Translation\TranslatorInterface;

class Base extends WebTestCase
{
    protected static $isDatabaseCreated = false;

    /**
     * @var ContainerInterface
     */
    protected $container;

    /**
     * @var Client
     */
    protected $client;

    /**
     * Initialize an application with a container and a client. Create database if required.
     *
     * @param string $url
     * @param null $method
     * @param array $parameters
     */
    public function initApplication($url = '/', $method = null, $parameters = [])
    {
        // creating kernel client
        $this->client = Client::initClient();
        // test client initialization
        $this->assertTrue($this->client != null, 'TestClient successfully initialized');

        // initialise database
        if (!self::$isDatabaseCreated) {
            // TODO remove database at the end of the tests
            exec(__DIR__ . '/app/console doctrine:database:create --if-not-exists', $output);
            exec(__DIR__ . '/app/console doctrine:schema:update --force', $output);

            foreach ($output as $line) {

The expression $output of type null|array is not guaranteed to be traversable. How about adding an additional type check?

                // TODO only in verbose mode
                fwrite(STDOUT, $line . "\n");
            }
            fwrite(STDOUT, "\n");
            self::$isDatabaseCreated = true;
        }
        // init a request
        $request = Request::create($url, $method, $parameters);
        // do request
        $this->client->doRequest($request);
        $this->container = $this->client->getContainer();
    }

    /**
     * Assert that an exception is raised in the given code.
     *
     * @param $exceptionClass
     * @param Closure $closure
     */
    protected function assertExceptionRaised($exceptionClass, Closure $closure)
    {
        $e = null;
        $isClassValid = false;

        try {
            $closure();
        } catch (Exception $e) {
            if (get_class($e) == $exceptionClass) {
                $isClassValid = true;
            }
        }
        $this->assertTrue($isClassValid, 'Expected ' . $exceptionClass . ', got ' . get_class($e));
    }

    /**
     * Return Admin configurations samples
     *
     * @return array
     */
    protected function getAdminsConfiguration()
    {
        return [
            'minimal_configuration' => [
                'entity' => 'Test\TestBundle\Entity\TestEntity',
                'form' => 'test'
            ],
            'full_configuration' => [
                'entity' => 'Test\TestBundle\Entity\TestEntity',
                'form' => 'test',
                'controller' => 'TestTestBundle:Test',
                'max_per_page' => 50,
                'actions' => [
                    'custom_list' => [],
                    'custom_edit' => [],
                ],
                'manager' => 'Test\TestBundle\Manager\TestManager',
                'routing_url_pattern' => 'lag.admin.{admin}',
                'routing_name_pattern' => 'lag.{admin}.{action}'
            ]
        ];
    }

    /**
     * @param $name
     * @param $configuration
     * @return Admin
     */
    protected function mockAdmin($name, $configuration)
    {
        return new Admin(
            $name,
            $this->mockDataProvider(),

It seems like $this->mockDataProvider() targeting LAG\AdminBundle\Tests\Base::mockDataProvider() can also be of type object<PHPUnit_Framework_MockObject_MockObject>; however, LAG\AdminBundle\Admin\Admin::__construct() does only seem to accept object<LAG\AdminBundle\DataProvider\DataProviderInterface>, maybe add an additional type check?

            $configuration,
            $this->mockMessageHandler()

It seems like $this->mockMessageHandler() targeting LAG\AdminBundle\Tests\Base::mockMessageHandler() can also be of type object<PHPUnit_Framework_MockObject_MockObject>; however, LAG\AdminBundle\Admin\Admin::__construct() does only seem to accept object<LAG\AdminBundle\Message\MessageHandlerInterface>, maybe add an additional type check?

        );
    }

    /**
     * @param $name
     * @return ActionInterface|PHPUnit_Framework_MockObject_MockObject
     */
    protected function mockAction($name)
    {
        $action = $this
            ->getMockBuilder('LAG\AdminBundle\Admin\ActionInterface')
            ->disableOriginalConstructor()
            ->getMock();
        $action
            ->method('getName')
            ->willReturn($name);
        $action
            ->method('getConfiguration')
            ->willReturn($this->mockActionConfiguration());

        return $action;
    }

    /**
     * @return ActionConfiguration|PHPUnit_Framework_MockObject_MockObject
     */
    protected function mockActionConfiguration()
    {
        $configuration = $this
            ->getMockBuilder('LAG\AdminBundle\Admin\Configuration\ActionConfiguration')
            ->disableOriginalConstructor()
            ->getMock();
        $configuration
            ->method('getLoadMethod')
            ->willReturn(Admin::LOAD_STRATEGY_MULTIPLE);
        $configuration
            ->method('getCriteria')
            ->willReturn([]);

        return $configuration;
    }

    /**
     * @param array $configuration
     * @return AdminFactory
     */
    protected function mockAdminFactory(array $configuration = [])
    {
        /** @var EventDispatcher $mockEventDispatcher */
        $mockEventDispatcher = $this
            ->getMockBuilder('Symfony\Component\EventDispatcher\EventDispatcher')
            ->getMock();

        return new AdminFactory(
            $mockEventDispatcher,
            $this->mockEntityManager(),

$this->mockEntityManager() is of type object<Doctrine\ORM\EntityManagerInterface>|object<PHPUnit_Framework_MockObject_MockObject>, but the function expects a object<Doctrine\ORM\EntityManager>.

            $this->mockApplicationConfiguration(),
            $configuration,
            $this->mockActionFactory(),

It seems like $this->mockActionFactory() targeting LAG\AdminBundle\Tests\Base::mockActionFactory() can also be of type object<PHPUnit_Framework_MockObject_MockObject>; however, LAG\AdminBundle\Admin\Factory\AdminFactory::__construct() does only seem to accept object<LAG\AdminBundle\Admin\Factory\ActionFactory>, maybe add an additional type check?

            $this->mockMessageHandler()

It seems like $this->mockMessageHandler() targeting LAG\AdminBundle\Tests\Base::mockMessageHandler() can also be of type object<PHPUnit_Framework_MockObject_MockObject>; however, LAG\AdminBundle\Admin\Factory\AdminFactory::__construct() does only seem to accept object<LAG\AdminBundle\Message\MessageHandlerInterface>, maybe add an additional type check?

        );
    }

    /**
     * @return Session|PHPUnit_Framework_MockObject_MockObject
     */
    protected function mockSession()
    {
        if ($this->container) {
            $session = $this
                ->container
                ->get('session');
        } else {
            $session = $this
                ->getMockBuilder('Symfony\Component\HttpFoundation\Session\Session')
                ->disableOriginalConstructor()
                ->getMock();
        }
        return $session;
    }

    /**
     * @return Logger|PHPUnit_Framework_MockObject_MockObject
     */
    protected function mockLogger()
    {
        if ($this->container) {
            $logger = $this
                ->container
                ->get('logger');
        } else {
            $logger = $this
                ->getMockBuilder('Monolog\Logger')
                ->disableOriginalConstructor()
                ->getMock();
        }
        return $logger;
    }

    /**
     * Return a mock of an entity repository
     *
     * @return RepositoryInterface|PHPUnit_Framework_MockObject_MockObject
     */
    protected function mockEntityRepository()
    {
        return $this
            ->getMockBuilder('LAG\DoctrineRepositoryBundle\Repository\RepositoryInterface')
            ->getMock();
    }

    /**
     * @return EntityManager|PHPUnit_Framework_MockObject_MockObject
     */
    protected function mockEntityManager()
    {
        /** @var EntityManagerInterface|PHPUnit_Framework_MockObject_MockObject $entityManager */
        $entityManager = $this
            ->getMockBuilder('Doctrine\ORM\EntityManager')
            ->disableOriginalConstructor()
            ->getMock();
        $repository = $this->mockEntityRepository();
        $repository
            ->method('getEntityPersister')
            ->willReturn( $this
                ->getMockBuilder('Doctrine\ORM\Persisters\Entity\BasicEntityPersister')
                ->disableOriginalConstructor()
                ->getMock());

        $entityManager
            ->method('getRepository')
            ->willReturn($repository);
        $entityManager
            ->method('getClassMetadata')
            ->willReturn(new ClassMetadata('LAG\AdminBundle\Tests\Entity\TestEntity'));

        return $entityManager;
    }

    /**
     * @return ActionFactory|PHPUnit_Framework_MockObject_MockObject
     */
    protected function mockActionFactory()
    {
        $actionFactory = $this
            ->getMockBuilder('LAG\AdminBundle\Admin\Factory\ActionFactory')
            ->disableOriginalConstructor()
            ->getMock();
        $actionFactory
            ->method('create')
            ->willReturn($this->mockAction('test'));

        return $actionFactory;
    }

    /**
     * @return TokenStorageInterface|PHPUnit_Framework_MockObject_MockObject
     */
    protected function mockTokenStorage()
    {
        return $this
            ->getMockBuilder('Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface')
            ->getMock();
    }

    /**
     * @return ApplicationConfiguration
     */
    protected function mockApplicationConfiguration()
    {
        $applicationConfiguration = $this
            ->getMockBuilder('LAG\AdminBundle\Admin\Configuration\ApplicationConfiguration')
            ->disableOriginalConstructor()
            ->getMock();
        $applicationConfiguration
            ->method('getMaxPerPage')
            ->willReturn(25);

        return $applicationConfiguration;
    }

    /**
     * @return MessageHandlerInterface|PHPUnit_Framework_MockObject_MockObject
     */
    protected function mockMessageHandler()
    {
        $messageHandler = $this
            ->getMockBuilder('LAG\AdminBundle\Message\MessageHandler')
            ->disableOriginalConstructor()
            ->getMock();

        return $messageHandler;
    }

    /**
     * @return TranslatorInterface|PHPUnit_Framework_MockObject_MockObject
     */
    protected function mockTranslator()
    {
        return $this
            ->getMockBuilder('Symfony\Component\Translation\TranslatorInterface')
            ->getMock();
    }

    /**
     * @return DataProviderInterface|PHPUnit_Framework_MockObject_MockObject
     */
    protected function mockDataProvider()
    {
        return $this
            ->getMockBuilder('LAG\AdminBundle\DataProvider\DataProviderInterface')
            ->getMock();
    }
}