Sonata\AdminBundle\Tests\Controller\CRUDControllerTest::setUp()

Complexity

Conditions	53
Paths	16

Size

Total Lines	315
Code Lines	223

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

<?php
    protected function setUp()
    {
        $this->container = $this->createMock('Symfony\Component\DependencyInjection\ContainerInterface');

        $this->request = new Request();
        $this->pool = new Pool($this->container, 'title', 'logo.png');
        $this->pool->setAdminServiceIds(['foo.admin']);
        $this->request->attributes->set('_sonata_admin', 'foo.admin');
        $this->admin = $this->getMockBuilder('Sonata\AdminBundle\Admin\AbstractAdmin')
            ->disableOriginalConstructor()
            ->getMock();
        $this->translator = $this->createMock('Symfony\Component\Translation\TranslatorInterface');
        $this->parameters = [];
        $this->template = '';

        $templating = $this->getMockBuilder('Symfony\Bundle\FrameworkBundle\Templating\DelegatingEngine')
            ->setConstructorArgs([$this->container, []])
            ->getMock();

        $templatingRenderReturnCallback = $this->returnCallback(function (
            $view,
            array $parameters = [],
            Response $response = null
        ) {
            $this->template = $view;

            if (null === $response) {
                $response = new Response();
            }

            $this->parameters = $parameters;

            return $response;
        });

        // SF < 3.3.10 BC
        $templating->expects($this->any())
            ->method('renderResponse')
            ->will($templatingRenderReturnCallback);

        $templating->expects($this->any())
            ->method('render')
            ->will($templatingRenderReturnCallback);

        $this->session = new Session(new MockArraySessionStorage());

        $twig = $this->getMockBuilder('Twig_Environment')
            ->disableOriginalConstructor()
            ->getMock();

        $twig->expects($this->any())
            ->method('getExtension')
            ->will($this->returnCallback(function ($name) {
                switch ($name) {
                    case FormExtension::class:
                        return new FormExtension($this->createMock(TwigRenderer::class));
                }
            }));

        $twig->expects($this->any())
            ->method('getRuntime')
            ->will($this->returnCallback(function ($name) {
                switch ($name) {
                    case TwigRenderer::class:
                        return $this->createMock(TwigRenderer::class);
                    case FormRenderer::class:
                        return $this->createMock(FormRenderer::class);
                }
            }));

        // NEXT_MAJOR : require sonata/exporter ^1.7 and remove conditional
        if (class_exists('Exporter\Exporter')) {
            $exporter = new Exporter([new JsonWriter('/tmp/sonataadmin/export.json')]);
        } else {
            $exporter = $this->createMock('Sonata\AdminBundle\Export\Exporter');

            $exporter->expects($this->any())
                ->method('getResponse')
                ->will($this->returnValue(new StreamedResponse()));
        }

        $this->auditManager = $this->getMockBuilder('Sonata\AdminBundle\Model\AuditManager')
            ->disableOriginalConstructor()
            ->getMock();

        $this->adminObjectAclManipulator = $this->getMockBuilder('Sonata\AdminBundle\Util\AdminObjectAclManipulator')
            ->disableOriginalConstructor()
            ->getMock();

        // Prefer Symfony 2.x interfaces
        if (interface_exists('Symfony\Component\Form\Extension\Csrf\CsrfProvider\CsrfProviderInterface')) {
            $this->csrfProvider = $this->getMockBuilder(
                'Symfony\Component\Form\Extension\Csrf\CsrfProvider\CsrfProviderInterface'
            )
                ->getMock();

            $this->csrfProvider->expects($this->any())
                ->method('generateCsrfToken')
                ->will($this->returnCallback(function ($intention) {
                    return 'csrf-token-123_'.$intention;
                }));

            $this->csrfProvider->expects($this->any())
                ->method('isCsrfTokenValid')
                ->will($this->returnCallback(function ($intention, $token) {
                    if ($token == 'csrf-token-123_'.$intention) {
                        return true;
                    }

                    return false;
                }));
        } else {
            $this->csrfProvider = $this->getMockBuilder(
                'Symfony\Component\Security\Csrf\CsrfTokenManagerInterface'
            )
                ->getMock();

            $this->csrfProvider->expects($this->any())
                ->method('getToken')
                ->will($this->returnCallback(function ($intention) {
                    return new CsrfToken($intention, 'csrf-token-123_'.$intention);
                }));

            $this->csrfProvider->expects($this->any())
                ->method('isTokenValid')
                ->will($this->returnCallback(function (CsrfToken $token) {
                    if ($token->getValue() == 'csrf-token-123_'.$token->getId()) {
                        return true;
                    }

                    return false;
                }));
        }

        $this->logger = $this->createMock('Psr\Log\LoggerInterface');

        $requestStack = null;
        if (class_exists('Symfony\Component\HttpFoundation\RequestStack')) {
            $requestStack = new RequestStack();
            $requestStack->push($this->request);
        }

        $this->kernel = $this->createMock('Symfony\Component\HttpKernel\KernelInterface');

        $this->container->expects($this->any())
            ->method('get')
            ->will($this->returnCallback(function ($id) use (
                $templating,
                $twig,
                $exporter,
                $requestStack
            ) {
                switch ($id) {
                    case 'sonata.admin.pool':
                        return $this->pool;
                    case 'request':
                        return $this->request;
                    case 'request_stack':
                        return $requestStack;
                    case 'foo.admin':
                        return $this->admin;
                    case 'templating':
                        return $templating;
                    case 'twig':
                        return $twig;
                    case 'session':
                        return $this->session;
                    case 'sonata.admin.exporter':
                        return $exporter;
                    case 'sonata.admin.audit.manager':
                        return $this->auditManager;
                    case 'sonata.admin.object.manipulator.acl.admin':
                        return $this->adminObjectAclManipulator;
                    case 'form.csrf_provider':
                    case 'security.csrf.token_manager':
                        return $this->csrfProvider;
                    case 'logger':
                        return $this->logger;
                    case 'kernel':
                        return $this->kernel;
                    case 'translator':
                        return $this->translator;
                }
            }));

        $this->container->expects($this->any())
            ->method('has')
            ->will($this->returnCallback(function ($id) {
                if ('form.csrf_provider' == $id && Kernel::MAJOR_VERSION == 2 && null !== $this->getCsrfProvider()) {
                    return true;
                }

                if ('security.csrf.token_manager' == $id && Kernel::MAJOR_VERSION >= 3 && null !== $this->getCsrfProvider()) {
                    return true;
                }

                if ('logger' == $id) {
                    return true;
                }

                if ('session' == $id) {
                    return true;
                }

                if ('templating' == $id) {
                    return true;
                }

                if ('translator' == $id) {
                    return true;
                }

                return false;
            }));

        $this->container->expects($this->any())
            ->method('getParameter')
            ->will($this->returnCallback(function ($name) {
                switch ($name) {
                    case 'security.role_hierarchy.roles':
                       return ['ROLE_SUPER_ADMIN' => ['ROLE_USER', 'ROLE_SONATA_ADMIN', 'ROLE_ADMIN']];
                }
            }));

        $this->admin->expects($this->any())
            ->method('getTemplate')
            ->will($this->returnCallback(function ($name) {
                switch ($name) {
                    case 'ajax':
                        return 'SonataAdminBundle::ajax_layout.html.twig';
                    case 'layout':
                        return 'SonataAdminBundle::standard_layout.html.twig';
                    case 'show':
                        return 'SonataAdminBundle:CRUD:show.html.twig';
                    case 'show_compare':
                        return 'SonataAdminBundle:CRUD:show_compare.html.twig';
                    case 'edit':
                        return 'SonataAdminBundle:CRUD:edit.html.twig';
                    case 'dashboard':
                        return 'SonataAdminBundle:Core:dashboard.html.twig';
                    case 'search':
                        return 'SonataAdminBundle:Core:search.html.twig';
                    case 'list':
                        return 'SonataAdminBundle:CRUD:list.html.twig';
                    case 'preview':
                        return 'SonataAdminBundle:CRUD:preview.html.twig';
                    case 'history':
                        return 'SonataAdminBundle:CRUD:history.html.twig';
                    case 'acl':
                        return 'SonataAdminBundle:CRUD:acl.html.twig';
                    case 'delete':
                        return 'SonataAdminBundle:CRUD:delete.html.twig';
                    case 'batch':
                        return 'SonataAdminBundle:CRUD:list__batch.html.twig';
                    case 'batch_confirmation':
                        return 'SonataAdminBundle:CRUD:batch_confirmation.html.twig';
                }
            }));

        $this->admin->expects($this->any())
            ->method('getIdParameter')
            ->will($this->returnValue('id'));

        $this->admin->expects($this->any())
            ->method('getAccessMapping')
            ->will($this->returnValue([]));

        $this->admin->expects($this->any())
            ->method('generateUrl')
            ->will(
                $this->returnCallback(
                    function ($name, array $parameters = [], $absolute = false) {

The parameter $absolute is not used and could be removed.

                        $result = $name;
                        if (!empty($parameters)) {
                            $result .= '?'.http_build_query($parameters);
                        }

                        return $result;
                    }
                )
            );

        $this->admin->expects($this->any())
            ->method('generateObjectUrl')
            ->will(
                $this->returnCallback(
                    function ($name, $object, array $parameters = [], $absolute = false) {

The parameter $absolute is not used and could be removed.

                        $result = get_class($object).'_'.$name;
                        if (!empty($parameters)) {
                            $result .= '?'.http_build_query($parameters);
                        }

                        return $result;
                    }
                )
            );

        $this->controller = new CRUDController();
        $this->controller->setContainer($this->container);

        // Make some methods public to test them
        $testedMethods = [
            'renderJson',
            'isXmlHttpRequest',
            'configure',
            'getBaseTemplate',
            'redirectTo',
            'addFlash',
        ];
        foreach ($testedMethods as $testedMethod) {
            $method = new \ReflectionMethod('Sonata\\AdminBundle\\Controller\\CRUDController', $testedMethod);
            $method->setAccessible(true);
            $this->protectedTestedMethods[$testedMethod] = $method;
        }
    }