Issues in NodeHelperTest.php - New Issues - Inspection of "Merge pull request #2743 from acrobat/eventdispatc..." - Kunstmaan/KunstmaanBundlesCMS - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 1dbefb...c77374 )

by Jeroen
created 2020-09-16 07:41 UTC
NodeBundle/Tests/unit/Helper/NodeHelperTest.php (1 issue)

Labels

Documentation 1
Severity

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more
<?php

namespace Kunstmaan\NodeBundle\Tests\Helper;

use Doctrine\Common\Persistence\ObjectRepository;
use Doctrine\ORM\EntityManager;
use Doctrine\ORM\EntityManagerInterface;
use Kunstmaan\AdminBundle\Entity\User;
use Kunstmaan\AdminBundle\Helper\CloneHelper;
use Kunstmaan\AdminBundle\Helper\FormWidgets\Tabs\TabPane;
use Kunstmaan\NodeBundle\Entity\AbstractPage;
use Kunstmaan\NodeBundle\Entity\HasNodeInterface;
use Kunstmaan\NodeBundle\Entity\Node;
use Kunstmaan\NodeBundle\Entity\NodeTranslation;
use Kunstmaan\NodeBundle\Entity\NodeVersion;
use Kunstmaan\NodeBundle\Entity\PageTabInterface;
use Kunstmaan\NodeBundle\Event\AdaptFormEvent;
use Kunstmaan\NodeBundle\Event\CopyPageTranslationNodeEvent;
use Kunstmaan\NodeBundle\Event\Events;
use Kunstmaan\NodeBundle\Event\NodeEvent;
use Kunstmaan\NodeBundle\Event\RecopyPageTranslationNodeEvent;
use Kunstmaan\NodeBundle\EventListener\NodeTabListener;
use Kunstmaan\NodeBundle\Helper\NodeAdmin\NodeAdminPublisher;
use Kunstmaan\NodeBundle\Helper\NodeHelper;
use Kunstmaan\NodeBundle\Repository\NodeRepository;
use Kunstmaan\NodeBundle\Repository\NodeTranslationRepository;
use Kunstmaan\NodeBundle\Repository\NodeVersionRepository;
use Kunstmaan\NodeBundle\ValueObject\PageTab;
use PHPUnit\Framework\TestCase;
use Symfony\Component\EventDispatcher\EventDispatcher;
use Symfony\Component\EventDispatcher\LegacyEventDispatcherProxy;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\Extension\Core\Type\HiddenType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\Form\FormFactory;
use Symfony\Component\HttpFoundation\ParameterBag;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\OptionsResolver\OptionsResolver;
use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorage;
use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;

class TestPage extends AbstractPage implements HasNodeInterface, PageTabInterface
{
    /**
     * @return array
     */
    public function getPossibleChildTypes()
    {
        return [];
    }

    /**
     * @return PageTab[]
     */
    public function getTabs()
    {
        return [
            new PageTab('tab1_name', 'tab1_title', TestType::class),
        ];
    }
}

class TestType extends AbstractType
{
    /**
     * @param FormBuilderInterface $builder
     * @param array                $options
     */
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        $builder->add('id', HiddenType::class);
    }

    /**
     * @return string
     */
    public function getBlockPrefix()
    {
        return 'test';
    }

    public function configureOptions(OptionsResolver $resolver)
    {
        $resolver->setDefaults(array(
            'data_class' => TestPage::class,
        ));
    }
}

class NodeHelperTest extends TestCase
{
    /** @var \PHPUnit_Framework_MockObject_MockObject|EntityManagerInterface */
    private $em;

    /** @var \PHPUnit_Framework_MockObject_MockObject|NodeRepository */
    private $repository;

    /** @var NodeHelper */
    private $nodeHelper;

    /** @var \PHPUnit_Framework_MockObject_MockObject|NodeAdminPublisher */
    private $nodeAdminPublisher;

    /** @var \PHPUnit_Framework_MockObject_MockObject|EventDispatcher */
    private $eventDispatcher;

    /** @var \PHPUnit_Framework_MockObject_MockObject|TokenStorageInterface */
    private $tokenStorage;

    /** @var \PHPUnit_Framework_MockObject_MockObject|CloneHelper */
    private $cloneHelper;

    /** @var string */
    private $locale = 'en';

    /** @var User */
    private $user;

    public function setUp()
    {
        $this->createORM();
        $this->nodeHelper = $this->createNodeHelper();
    }

    public function testUpdatePage()
    {
        /**
         * @var TestPage
         * @var NodeTranslation $nodeTranslation
         */
        [$page, $nodeTranslation, $node] = $this->createNodeEntities();
        $nodeVersion = $nodeTranslation->getPublicNodeVersion();

        $this->em
            ->expects($this->exactly(3))
            ->method('persist')
            ->withConsecutive(
                [$this->equalTo($nodeTranslation)],
                [$this->equalTo($nodeVersion)],
                [$this->equalTo($node)]
            );

        $this->eventDispatcher
            ->expects($this->exactly(2))
            ->method('dispatch')
            ->withConsecutive(...$this->getEventDispatcherArgument(
                [$this->equalTo(new NodeEvent($node, $nodeTranslation, $nodeVersion, $page)), $this->equalTo(Events::PRE_PERSIST)],
                [$this->equalTo(new NodeEvent($node, $nodeTranslation, $nodeVersion, $page)), $this->equalTo(Events::POST_PERSIST)]
            ));

        $this->nodeHelper->updatePage(
            $node,
            $nodeTranslation,
            $nodeTranslation->getPublicNodeVersion(),
            $page,
            false,
            null
        );
    }

    public function testCreatePage()
    {
        $title = 'Test page';
        $user = new User();

        [$homePage, , $nodeHomePage] = $this->createNodeEntities('Homepage');

        /**
         * @var TestPage
         * @var NodeTranslation $nodeTranslationChildPage
         */
        [, $nodeTranslationChildPage, $nodeChildPage] = $this->createNodeEntities($title);

        $expectedTestPageCreateNodeFor = new TestPage();
        $expectedTestPageCreateNodeFor->setTitle($title);
        $expectedTestPageCreateNodeFor->setParent($homePage);

        $nodeRepository = $this->getMockBuilder(NodeRepository::class)
            ->disableOriginalConstructor()
            ->getMock();
        $nodeRepository
            ->expects($this->once())
            ->method('createNodeFor')
            ->with(
                $this->equalTo($expectedTestPageCreateNodeFor),
                $this->equalTo($this->locale),
                $this->equalTo($user)
            )
            ->willReturn($nodeChildPage);

        $nodeTranslationRepository = $this->getMockBuilder(NodeTranslationRepository::class)
            ->disableOriginalConstructor()
            ->getMock();
        $nodeTranslationRepository
            ->expects($this->once())
            ->method('getMaxChildrenWeight')
            ->willReturn(1);

        $this->em
            ->method('getRepository')
            ->withConsecutive(
                [$this->equalTo(Node::class)],
                [$this->equalTo(NodeTranslation::class)]
            )
            ->willReturnOnConsecutiveCalls(
                $nodeRepository,
                $nodeTranslationRepository
            );

        $expectedEvent = new NodeEvent(
            $nodeChildPage, $nodeTranslationChildPage, $nodeTranslationChildPage->getPublicNodeVersion(), $expectedTestPageCreateNodeFor
        );
        $this->eventDispatcher
            ->expects($this->once())
            ->method('dispatch')
            ->with(...$this->getEventDispatcherArgument([$this->equalTo($expectedEvent), $this->equalTo(Events::ADD_NODE)]))
        ;

        $result = $this->nodeHelper->createPage(TestPage::class, $title, $this->locale, $nodeHomePage);

        $this->assertInstanceOf(NodeTranslation::class, $result);
        $this->assertEquals(2, $result->getWeight());
        $this->assertEquals($title, $result->getTitle());
    }

    public function testDeletePage()
    {
        /**
         * @var Node
         * @var NodeTranslation $nodeTranslationHomePage
         */
        [$homePage, $nodeTranslationHomePage, $nodeHomePage] = $this->createNodeEntities('Homepage');
        $nodeVersionHomePage = $nodeTranslationHomePage->getPublicNodeVersion();

        /**
         * @var TestPage
         * @var NodeTranslation $nodeTranslationChildPage
         */
        [$page, $nodeTranslationChildPage, $nodeChildPage] = $this->createNodeEntities('Test page');
        $nodeVersionChildPage = $nodeTranslationChildPage->getPublicNodeVersion();
        $nodeHomePage->addNode($nodeChildPage);

        $this->eventDispatcher
            ->expects($this->exactly(4))
            ->method('dispatch')
            ->withConsecutive(...$this->getEventDispatcherArgument(
                [$this->equalTo(new NodeEvent($nodeHomePage, $nodeTranslationHomePage, $nodeVersionHomePage, $homePage)), $this->equalTo(Events::PRE_DELETE)],
                [$this->equalTo(new NodeEvent($nodeChildPage, $nodeTranslationChildPage, $nodeVersionChildPage, $page)), $this->equalTo(Events::PRE_DELETE)],
                [$this->equalTo(new NodeEvent($nodeChildPage, $nodeTranslationChildPage, $nodeVersionChildPage, $page)), $this->equalTo(Events::POST_DELETE)],
                [$this->equalTo(new NodeEvent($nodeHomePage, $nodeTranslationHomePage, $nodeVersionHomePage, $homePage)), $this->equalTo(Events::POST_DELETE)]
            ));

        $result = $this->nodeHelper->deletePage($nodeHomePage, $this->locale);

        $this->assertTrue($result->getNode()->isDeleted());
        $this->assertTrue($nodeHomePage->isDeleted());
        $this->assertTrue($nodeChildPage->isDeleted());
    }

    public function testPrepareNodeVersionForPublic()
    {
        $user = new User();

        $page = new TestPage();
        $page->setTitle('Test');
        $page->setId(1);

        $nodeVersion = new NodeVersion();
        $nodeVersion->setType(NodeVersion::PUBLIC_VERSION);
        $nodeVersion->setRef($page);

        $nodeVersion = $this->getMockBuilder(NodeVersion::class)->getMock();
        $nodeVersion
            ->method('getType')
            ->willReturn(NodeVersion::PUBLIC_VERSION);
        $nodeVersion
            ->expects($this->once())
            ->method('getRef')
            ->willReturn($page);
        $nodeVersion
            ->method('getUpdated')
            ->willReturn(new \DateTime('-1 hour'));

        $nodeTranslation = new NodeTranslation();
        $nodeTranslation->setLang($this->locale);
        $nodeTranslation->addNodeVersion($nodeVersion);

        $this->nodeAdminPublisher
            ->expects($this->once())
            ->method('createPublicVersion')
            ->with(
                $this->equalTo($page),
                $this->equalTo($nodeTranslation),
                $this->equalTo($nodeVersion),
                $this->equalTo($user)
            );

        $this->nodeHelper->prepareNodeVersion($nodeVersion, $nodeTranslation, 10, true);
    }

    public function testPrepareNodeVersionForDraft()
    {
        $page = new TestPage();
        $page->setTitle('Test');
        $page->setId(1);

        $nodeVersion = new NodeVersion();
        $nodeVersion->setType(NodeVersion::PUBLIC_VERSION);
        $nodeVersion->setRef($page);

        $nodeVersion = $this->getMockBuilder(NodeVersion::class)->getMock();
        $nodeVersion
            ->method('getType')
            ->willReturn(NodeVersion::DRAFT_VERSION);
        $nodeVersion
            ->expects($this->once())
            ->method('getRef')
            ->willReturn($page);
        $nodeVersion
            ->method('getUpdated')
            ->willReturn(new \DateTime('-1 hour'));

        $nodeTranslation = new NodeTranslation();
        $nodeTranslation->setLang($this->locale);
        $nodeTranslation->addNodeVersion($nodeVersion);

        /** @var \PHPUnit_Framework_MockObject_MockObject|NodeHelper $nodeHelper */
        $nodeHelper = $this->getMockBuilder(NodeHelper::class)
            ->setConstructorArgs([
                $this->em,
                $this->nodeAdminPublisher,
                $this->tokenStorage,
                $this->cloneHelper,
                $this->eventDispatcher,
            ])
            ->setMethods(['createDraftVersion'])
            ->getMock();
        $nodeHelper
            ->expects($this->once())
            ->method('createDraftVersion')
            ->willReturn(true);

        $nodeHelper->prepareNodeVersion($nodeVersion, $nodeTranslation, 10, true);
    }

    public function testCreateDraftVersion()
    {
        /**
         * @var TestPage
         * @var NodeTranslation $nodeTranslation
         */
        [$page, $nodeTranslation, $node] = $this->createNodeEntities();
        $originalNodeVersion = new NodeVersion();

        $this->cloneHelper
            ->expects($this->once())
            ->method('deepCloneAndSave')
            ->willReturn($page);

        $publicNodeVersion = new NodeVersion();
        $publicNodeVersion->setRef($page);
        $publicNodeVersion->setType(NodeVersion::PUBLIC_VERSION);

        $nodeVersionRepository = $this->getMockBuilder(NodeVersionRepository::class)
            ->disableOriginalConstructor()
            ->getMock();
        $nodeVersionRepository
            ->method('createNodeVersionFor')
            ->willReturn($publicNodeVersion);

        $this->em->method('getRepository')
            ->with(NodeVersion::class)
            ->willReturn($nodeVersionRepository);

        $this->eventDispatcher
            ->expects($this->once())
            ->method('dispatch')
            ->with(...$this->getEventDispatcherArgument([$this->equalTo(new NodeEvent($node, $nodeTranslation, $originalNodeVersion, $page)), $this->equalTo(Events::CREATE_DRAFT_VERSION)]));

        $result = $this->nodeHelper->createDraftVersion($page, $nodeTranslation, $originalNodeVersion);

        $this->assertInstanceOf(NodeVersion::class, $result);
        $this->assertEquals(NodeVersion::DRAFT_VERSION, $result->getType());
        $this->assertEquals($publicNodeVersion, $result->getOrigin());
    }

    public function testGetPageWithNodeInterface()
    {
        $refId = 10;

        $page = new TestPage();
        $page->setTitle('Test');
        $page->setId($refId);

        $nodeVersion = new NodeVersion();
        $nodeVersion->setType(NodeVersion::PUBLIC_VERSION);
        $nodeVersion->setRef($page);

        $nodeTranslation = new NodeTranslation();
        $nodeTranslation->setLang($this->locale);
        $nodeTranslation->addNodeVersion($nodeVersion);

        $node = new Node();
        $node->addNodeTranslation($nodeTranslation);

        $repository = $this->getMockBuilder(ObjectRepository::class)->getMock();
        $repository
            ->expects($this->once())
            ->method('find')
            ->with($refId)
            ->willReturn($page);

        $this->em
            ->expects($this->once())
            ->method('getRepository')
            ->with($this->equalTo(TestPage::class))
            ->willReturn($repository);

        $this->nodeHelper->getPageWithNodeInterface($node, $this->locale);
    }

    public function testCopyPageFromOtherLanguage()
    {
        $targetLocale = 'nl';
        $targetPage = new TestPage();

        /**
         * @var TestPage
         * @var NodeTranslation $sourceNodeTranslation
         */
        [$sourcePage, $sourceNodeTranslation, $node] = $this->createNodeEntities();
        $sourceNodeNodeVersion = $sourceNodeTranslation->getPublicNodeVersion();

        $this->cloneHelper
            ->expects($this->once())
            ->method('deepCloneAndSave')
            ->with($sourcePage)
            ->willReturn($targetPage);

        $expectedNodeVersion = new NodeVersion();
        $expectedNodeVersion->setType(NodeVersion::PUBLIC_VERSION);
        $expectedNodeVersion->setRef($targetPage);

        $expectedNodeTranslation = new NodeTranslation();
        $expectedNodeTranslation->setNode($node);
        $expectedNodeTranslation->setLang($targetLocale);
        $expectedNodeTranslation->setPublicNodeVersion($expectedNodeVersion);

        $repository = $this->getMockBuilder(NodeTranslationRepository::class)
            ->disableOriginalConstructor()
            ->getMock();
        $repository
            ->expects($this->once())
            ->method('createNodeTranslationFor')
            ->with($this->equalTo($targetPage), $this->equalTo($targetLocale), $this->equalTo($node), $this->equalTo($this->user))
            ->willReturn($expectedNodeTranslation);

        $this->em
            ->expects($this->once())
            ->method('getRepository')
            ->with(NodeTranslation::class)
            ->willReturn($repository);

        $this->eventDispatcher
            ->expects($this->once())
            ->method('dispatch')
            ->with(...$this->getEventDispatcherArgument([$this->equalTo(new CopyPageTranslationNodeEvent(
                $node,
                $expectedNodeTranslation,
                $expectedNodeVersion,
                $targetPage,
                $sourceNodeTranslation,
                $sourceNodeNodeVersion,
                $sourcePage,
                $this->locale)), $this->equalTo(Events::COPY_PAGE_TRANSLATION)]));

        $result = $this->nodeHelper->copyPageFromOtherLanguage($node, $this->locale, $targetLocale);

        $this->assertInstanceOf(NodeTranslation::class, $result);
        $this->assertEquals($expectedNodeTranslation, $result);
    }

    public function testDuplicatePage()
    {
        $targetPage = new TestPage();

        [, , $nodeHomePage] = $this->createNodeEntities('Homepage');

        /**
         * @var TestPage
         * @var NodeTranslation $sourceNodeTranslation
         * @var Node            $node
         */
        [$sourcePage, , $node] = $this->createNodeEntities();
        $node->setParent($nodeHomePage);

        $this->cloneHelper
            ->expects($this->once())
            ->method('deepCloneAndSave')
            ->with($sourcePage)
            ->willReturn($targetPage);

        $expectedNodeTranslation = new NodeTranslation();
        $expectedNodeTranslation->setLang($this->locale);

        $expectedNode = new Node();
        $expectedNode->addNodeTranslation($expectedNodeTranslation);

        $repository = $this->getMockBuilder(NodeRepository::class)
            ->disableOriginalConstructor()
            ->getMock();
        $repository
            ->expects($this->once())
            ->method('createNodeFor')
            ->willReturn($expectedNode);

        $this->em
            ->expects($this->once())
            ->method('getRepository')
            ->with(Node::class)
            ->willReturn($repository);

        $result = $this->nodeHelper->duplicatePage($node, $this->locale);

        $this->assertInstanceOf(NodeTranslation::class, $result);
    }

    public function testCreatePageDraftFromOtherLanguage()
    {
        $targetLocale = 'nl';
        $targetPage = new TestPage();

        /**
         * @var TestPage
         * @var NodeTranslation $sourceNodeTranslation
         */
        [$sourcePage, $sourceNodeTranslation, $node] = $this->createNodeEntities();
        $sourceNodeNodeVersion = $sourceNodeTranslation->getPublicNodeVersion();

        $this->cloneHelper
            ->expects($this->once())
            ->method('deepCloneAndSave')
            ->with($sourcePage)
            ->willReturn($targetPage);

        $expectedNodeVersion = new NodeVersion();
        $expectedNodeVersion->setType(NodeVersion::PUBLIC_VERSION);
        $expectedNodeVersion->setRef($targetPage);

        $expectedNodeTranslation = new NodeTranslation();
        $expectedNodeTranslation->setNode($node);
        $expectedNodeTranslation->setLang($targetLocale);
        $expectedNodeTranslation->setPublicNodeVersion($expectedNodeVersion);

        $repository = $this->getMockBuilder(NodeTranslationRepository::class)
            ->disableOriginalConstructor()
            ->getMock();
        $repository
            ->expects($this->once())
            ->method('find')
            ->with($this->equalTo(1))
            ->willReturn($sourceNodeTranslation);
        $repository
            ->expects($this->once())
            ->method('addDraftNodeVersionFor')
            ->with($this->equalTo($targetPage), $this->equalTo($targetLocale), $this->equalTo($node), $this->equalTo($this->user))
            ->willReturn($expectedNodeTranslation);

        $this->em
            ->expects($this->exactly(2))
            ->method('getRepository')
            ->with(NodeTranslation::class)
            ->willReturn($repository);

        $this->eventDispatcher
            ->expects($this->once())
            ->method('dispatch')
            ->with(...$this->getEventDispatcherArgument([$this->equalTo(new RecopyPageTranslationNodeEvent(
                $node,
                $expectedNodeTranslation,
                $expectedNodeVersion,
                $targetPage,
                $sourceNodeTranslation,
                $sourceNodeNodeVersion,
                $sourcePage,
                $this->locale)), $this->equalTo(Events::RECOPY_PAGE_TRANSLATION)]));

        $result = $this->nodeHelper->createPageDraftFromOtherLanguage($node, 1, $targetLocale);

        $this->assertInstanceOf(NodeTranslation::class, $result);
        $this->assertEquals($expectedNodeTranslation, $result);
    }

    public function testCreateEmptyPage()
    {
        $targetPage = new TestPage();
        $targetPage->setTitle('No title');
        $node = new Node();
        $node->setRef($targetPage);

        $expectedNodeVersion = new NodeVersion();
        $expectedNodeVersion->setType(NodeVersion::PUBLIC_VERSION);
        $expectedNodeVersion->setRef($targetPage);

        $expectedNodeTranslation = new NodeTranslation();
        $expectedNodeTranslation->setNode($node);
        $expectedNodeTranslation->setLang($this->locale);
        $expectedNodeTranslation->setPublicNodeVersion($expectedNodeVersion);

        $repository = $this->getMockBuilder(NodeTranslationRepository::class)
            ->disableOriginalConstructor()
            ->getMock();
        $repository
            ->expects($this->once())
            ->method('createNodeTranslationFor')
            ->with($this->equalTo($targetPage), $this->equalTo($this->locale), $this->equalTo($node), $this->equalTo($this->user))
            ->willReturn($expectedNodeTranslation);

        $this->em
            ->expects($this->once())
            ->method('getRepository')
            ->with(NodeTranslation::class)
            ->willReturn($repository);

        $this->eventDispatcher
            ->expects($this->once())
            ->method('dispatch')
            ->with(...$this->getEventDispatcherArgument([$this->equalTo(new NodeEvent(
                $node,
                $expectedNodeTranslation,
                $expectedNodeVersion,
                $targetPage)), $this->equalTo(Events::ADD_EMPTY_PAGE_TRANSLATION)]));

        $result = $this->nodeHelper->createEmptyPage($node, $this->locale);

        $this->assertInstanceOf(NodeTranslation::class, $result);
        $this->assertEquals($expectedNodeTranslation, $result);
    }

    private function createORM()
    {
        $this->repository = $this->getMockBuilder(ObjectRepository::class)
            ->disableOriginalConstructor()
            ->getMock();

        $this->em = $this->getMockBuilder(EntityManager::class)
            ->disableOriginalConstructor()
            ->getMock();
    }

    /**
     * @return NodeHelper
     */
    private function createNodeHelper()
    {
        $this->user = new User();

        $token = $this->getMockBuilder(TokenInterface::class)->getMock();
        $token->method('getUser')->willReturn($this->user);

        $this->tokenStorage = $this->getMockBuilder(TokenStorage::class)
            ->disableOriginalConstructor()
            ->getMock();
        $this->tokenStorage->method('getToken')->willReturn($token);
        $this->nodeAdminPublisher = $this->getMockBuilder(NodeAdminPublisher::class)
            ->disableOriginalConstructor()
            ->getMock();
        $this->cloneHelper = $this->getMockBuilder(CloneHelper::class)
            ->disableOriginalConstructor()
            ->getMock();
        $this->eventDispatcher = $this->getMockBuilder(EventDispatcher::class)
            ->disableOriginalConstructor()
            ->getMock();

        return new NodeHelper(
            $this->em,
            $this->nodeAdminPublisher,
            $this->tokenStorage,
            $this->cloneHelper,
            $this->eventDispatcher
        );
    }

    /**
     * @param string $title
     *
     * @return array
     */
    private function createNodeEntities($title = 'Test page')
    {
        $testPage = new TestPage();
        $testPage->setTitle($title);

        $nodeVersionNewPage = $this->getMockBuilder(NodeVersion::class)->getMock();
        $nodeVersionNewPage
            ->method('getRef')
            ->with($this->em)
            ->willReturn($testPage);
        $nodeVersionNewPage
            ->method('getType')
            ->willReturn(NodeVersion::PUBLIC_VERSION);

        $nodeTranslationNewPage = new NodeTranslation();
        $nodeTranslationNewPage->setTitle($title);
        $nodeTranslationNewPage->setLang($this->locale);
        $nodeTranslationNewPage->addNodeVersion($nodeVersionNewPage);
        $nodeTranslationNewPage->setOnline(true);

        $nodeNewPage = new Node();
        $nodeNewPage->setDeleted(false);
        $nodeNewPage->addNodeTranslation($nodeTranslationNewPage);

        return [$testPage, $nodeTranslationNewPage, $nodeNewPage];
    }

    public function testPageShouldHaveTab()
    {
        $request = new Request();
        $request->request = new ParameterBag();

        $formFactory = $this->getMockBuilder(FormFactory::class)
            ->disableOriginalConstructor()
            ->getMock();

        $entity = new TestPage();

        $tabPane = new TabPane('id', $request, $formFactory);
        $adaptFormEvent = new AdaptFormEvent($request, $tabPane, $entity);

        $nodeTabListener = new NodeTabListener();
        $nodeTabListener->adaptForm($adaptFormEvent);

        $tabs = $adaptFormEvent->getTabPane()->getTabs();
        $title = null;

        if (isset($tabs[0])) {
            $title = $tabs[0]->getTitle();
        }

        $this->assertEquals('tab1_title', $title);
    }

    /**
     * function to flip expected argument order for 3.4 event dispatcher instances.
     */
    private function getEventDispatcherArgument(...$arguments)

    {
        if (class_exists(LegacyEventDispatcherProxy::class)) {
            if (\count($arguments) === 1) {
                return $arguments[0];
            }

            return $arguments;
        }

        $newArguments = [];
        foreach ($arguments as $key => $args) {
            $newArgs = $args;
            array_splice($newArgs, 0, 2, array_reverse(array_slice($args, 0, 2)));
            $newArguments[$key] = $newArgs;
        }

        return \count($newArguments) === 1 ? $newArguments[0] : $newArguments;
    }
}

Kunstmaan / KunstmaanBundlesCMS

Push — master ( 1dbefb...c77374 )

NodeBundle/Tests/unit/Helper/NodeHelperTest.php (1 issue)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like
