AbstractMenuContentObjectTest.php

Go to the documentation of this file.

<?php
declare(strict_types = 1);
namespace ‪TYPO3\CMS\Frontend\Tests\Unit\ContentObject\Menu;
 
/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */
use Doctrine\DBAL\Driver\Statement;
use Prophecy\Argument;
use ‪TYPO3\CMS\Core\Cache\Frontend\VariableFrontend;
use ‪TYPO3\CMS\Core\Context\Context;
use ‪TYPO3\CMS\Core\Context\LanguageAspect;
use ‪TYPO3\CMS\Core\Database\Connection;
use ‪TYPO3\CMS\Core\Database\ConnectionPool;
use ‪TYPO3\CMS\Core\Database\Query\Expression\ExpressionBuilder;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Frontend\ContentObject\ContentObjectRenderer;
use ‪TYPO3\CMS\Frontend\ContentObject\Menu\AbstractMenuContentObject;
use ‪TYPO3\CMS\Frontend\Page\PageRepository;
use TYPO3\TestingFramework\Core\Unit\UnitTestCase;
 
class ‪AbstractMenuContentObjectTest extends UnitTestCase
{
    protected ‪$subject;
 
    protected function ‪setUp()
    {
        $proxyClassName = $this->buildAccessibleProxy(AbstractMenuContentObject::class);
        $this->subject = $this->getMockForAbstractClass($proxyClassName);
        ‪$GLOBALS['TSFE'] = $this->getMockBuilder(\‪TYPO3\CMS\Frontend\Controller\TypoScriptFrontendController::class)
            ->setConstructorArgs([‪$GLOBALS['TYPO3_CONF_VARS'], 1, 1])
            ->setMethods(['initCaches'])
            ->getMock();
        ‪$GLOBALS['TSFE']->cObj = new ‪ContentObjectRenderer();
        ‪$GLOBALS['TSFE']->page = [];
    }
 
    protected function ‪tearDown()
    {
        GeneralUtility::purgeInstances();
        parent::tearDown();
    }
 
    // Tests concerning sectionIndex
 
    protected function ‪prepareSectionIndexTest()
    {
        $connectionProphet = $this->prophesize(Connection::class);
        $connectionProphet->getExpressionBuilder()->willReturn(new ‪ExpressionBuilder($connectionProphet->reveal()));
        $connectionProphet->quoteIdentifier(Argument::cetera())->willReturnArgument(0);
 
        $connectionPoolProphet = $this->prophesize(ConnectionPool::class);
        $connectionPoolProphet->getConnectionForTable('tt_content')->willReturn($connectionProphet->reveal());
        GeneralUtility::addInstance(ConnectionPool::class, $connectionPoolProphet->reveal());
    }
 
    public function ‪sectionIndexReturnsEmptyArrayIfTheRequestedPageCouldNotBeFetched()
    {
        $this->‪prepareSectionIndexTest();
        $pageRepository = $this->getMockBuilder(PageRepository::class)->getMock();
        $pageRepository->expects($this->once())->method('getPage')->will($this->returnValue(null));
        $this->subject->_set('sys_page', $pageRepository);
        $result = $this->subject->_call('sectionIndex', 'field');
        $this->assertEquals($result, []);
    }
 
    public function ‪sectionIndexUsesTheInternalIdIfNoPageIdWasGiven()
    {
        $this->‪prepareSectionIndexTest();
        $pageRepository = $this->getMockBuilder(PageRepository::class)->getMock();
        $pageRepository->expects($this->once())->method('getPage')->will($this->returnValue(null))->with(10);
        $this->subject->_set('sys_page', $pageRepository);
        $this->subject->_set('id', 10);
        $result = $this->subject->_call('sectionIndex', 'field');
        $this->assertEquals($result, []);
    }
 
    public function ‪sectionIndexThrowsAnExceptionIfTheInternalQueryFails()
    {
        $this->expectException(\UnexpectedValueException::class);
        $this->expectExceptionCode(1337334849);
        $this->‪prepareSectionIndexTest();
        $pageRepository = $this->getMockBuilder(PageRepository::class)->getMock();
        $pageRepository->expects($this->once())->method('getPage')->will($this->returnValue([]));
        $this->subject->_set('sys_page', $pageRepository);
        $this->subject->_set('id', 10);
 
        $cObject = $this->getMockBuilder(ContentObjectRenderer::class)->getMock();
        $cObject->expects($this->once())->method('exec_getQuery')->will($this->returnValue(0));
        $this->subject->_set('parent_cObj', $cObject);
 
        $this->subject->_call('sectionIndex', 'field');
    }
 
    public function ‪sectionIndexReturnsOverlaidRowBasedOnTheLanguageOfTheGivenPage()
    {
        $statementProphet = $this->prophesize(Statement::class);
        $statementProphet->fetch()->shouldBeCalledTimes(2)->willReturn(['uid' => 0, 'header' => 'NOT_OVERLAID'], false);
 
        $this->‪prepareSectionIndexTest();
        $this->subject->_set('mconf', [
            'sectionIndex.' => [
                'type' => 'all'
            ]
        ]);
        $context = GeneralUtility::makeInstance(Context::class);
        $context->setAspect('language', new ‪LanguageAspect(1, 1, ‪LanguageAspect::OVERLAYS_MIXED));
 
        $pageRepository = $this->getMockBuilder(PageRepository::class)->setConstructorArgs([$context])->getMock();
        $pageRepository->expects($this->once())->method('getPage')->will($this->returnValue(['_PAGES_OVERLAY_LANGUAGE' => 1]));
        $pageRepository->expects($this->once())->method('getRecordOverlay')->will($this->returnValue(['uid' => 0, 'header' => 'OVERLAID']));
        $this->subject->_set('sys_page', $pageRepository);
 
        $cObject = $this->getMockBuilder(ContentObjectRenderer::class)->getMock();
        $cObject->expects($this->once())->method('exec_getQuery')->willReturn($statementProphet->reveal());
        $this->subject->_set('parent_cObj', $cObject);
 
        $result = $this->subject->_call('sectionIndex', 'field');
        $this->assertEquals($result[0]['title'], 'OVERLAID');
    }
 
    public function ‪sectionIndexFiltersDataProvider()
    {
        return [
            'unfiltered fields' => [
                1,
                [
                    'sectionIndex' => 1,
                    'header' => 'foo',
                    'header_layout' => 1
                ]
            ],
            'with unset section index' => [
                0,
                [
                    'sectionIndex' => 0,
                    'header' => 'foo',
                    'header_layout' => 1
                ]
            ],
            'with unset header' => [
                0,
                [
                    'sectionIndex' => 1,
                    'header' => '',
                    'header_layout' => 1
                ]
            ],
            'with header layout 100' => [
                0,
                [
                    'sectionIndex' => 1,
                    'header' => 'foo',
                    'header_layout' => 100
                ]
            ]
        ];
    }
 
    public function ‪sectionIndexFilters($expectedAmount, array $dataRow)
    {
        $statementProphet = $this->prophesize(Statement::class);
        $statementProphet->fetch()->willReturn($dataRow, false);
 
        $this->‪prepareSectionIndexTest();
        $this->subject->_set('mconf', [
            'sectionIndex.' => [
                'type' => 'header'
            ]
        ]);
 
        $pageRepository = $this->getMockBuilder(PageRepository::class)->getMock();
        $pageRepository->expects($this->once())->method('getPage')->will($this->returnValue(['_PAGES_OVERLAY_LANGUAGE' => 1]));
        $pageRepository->expects($this->once())->method('getPage')->will($this->returnValue([]));
        $this->subject->_set('sys_page', $pageRepository);
 
        $cObject = $this->getMockBuilder(ContentObjectRenderer::class)->getMock();
        $cObject->expects($this->once())->method('exec_getQuery')->willReturn($statementProphet->reveal());
        $this->subject->_set('parent_cObj', $cObject);
 
        $result = $this->subject->_call('sectionIndex', 'field');
        $this->assertCount($expectedAmount, $result);
    }
 
    public function ‪sectionIndexQueriesWithDifferentColPosDataProvider()
    {
        return [
            'no configuration' => [
                [],
                'colPos = 0'
            ],
            'with useColPos 2' => [
                ['useColPos' => 2],
                'colPos = 2'
            ],
            'with useColPos -1' => [
                ['useColPos' => -1],
                ''
            ],
            'with stdWrap useColPos' => [
                [
                    'useColPos.' => [
                        'wrap' => '2|'
                    ]
                ],
                'colPos = 2'
            ]
        ];
    }
 
    public function ‪sectionIndexQueriesWithDifferentColPos($configuration, $whereClausePrefix)
    {
        $statementProphet = $this->prophesize(Statement::class);
        $statementProphet->fetch()->willReturn([]);
 
        $this->‪prepareSectionIndexTest();
        $this->subject->_set('mconf', ['sectionIndex.' => $configuration]);
 
        $pageRepository = $this->getMockBuilder(PageRepository::class)->getMock();
        $pageRepository->expects($this->once())->method('getPage')->will($this->returnValue([]));
        $this->subject->_set('sys_page', $pageRepository);
 
        $queryConfiguration = [
            'pidInList' => 12,
            'orderBy' => 'field',
            'languageField' => 'sys_language_uid',
            'where' => $whereClausePrefix
        ];
 
        $cObject = $this->getMockBuilder(ContentObjectRenderer::class)->getMock();
        $cObject->expects($this->once())->method('exec_getQuery')
            ->with('tt_content', $queryConfiguration)->willReturn($statementProphet->reveal());
        $this->subject->_set('parent_cObj', $cObject);
 
        $this->subject->_call('sectionIndex', 'field', 12);
    }
 
    // Tests concerning menu item states
 
    public function ‪ifsubHasToCheckExcludeUidListDataProvider()
    {
        return [
            'none excluded' => [
                [12, 34, 56],
                '1, 23, 456',
                true
            ],
            'one excluded' => [
                [1, 234, 567],
                '1, 23, 456',
                true
            ],
            'three excluded' => [
                [1, 23, 456],
                '1, 23, 456',
                false
            ],
            'empty excludeList' => [
                [1, 123, 45],
                '',
                true
            ],
            'empty menu' => [
                [],
                '1, 23, 456',
                false
            ],
        ];
    }
 
    public function ‪ifsubHasToCheckExcludeUidList($menuItems, $excludeUidList, $expectedResult)
    {
        $menu = [];
        foreach ($menuItems as $page) {
            $menu[] = ['uid' => $page];
        }
        $runtimeCacheMock = $this->getMockBuilder(VariableFrontend::class)->setMethods(['get', 'set'])->disableOriginalConstructor()->getMock();
        $runtimeCacheMock->expects($this->once())->method('get')->with($this->anything())->willReturn(false);
        $runtimeCacheMock->expects($this->once())->method('set')->with($this->anything(), ['result' => $expectedResult]);
 
        $proxyClassName = $this->buildAccessibleProxy(AbstractMenuContentObject::class);
        $this->subject = $this->getMockForAbstractClass($proxyClassName, [], '', true, true, true, ['getRuntimeCache']);
        $this->subject->expects($this->once())->method('getRuntimeCache')->willReturn($runtimeCacheMock);
        $this->‪prepareSectionIndexTest();
 
        $pageRepository = $this->getMockBuilder(PageRepository::class)->getMock();
        $pageRepository->expects($this->once())->method('getMenu')->will($this->returnValue($menu));
        $this->subject->_set('sys_page', $pageRepository);
        $this->subject->_set('menuArr', [
            0 => ['uid' => 1]
        ]);
        $this->subject->_set('conf', ['excludeUidList' => $excludeUidList]);
 
        $this->assertEquals($expectedResult, $this->subject->_call('isItemState', 'IFSUB', 0));
    }
 
    public function ‪menuTypoLinkCreatesExpectedTypoLinkConfiurationDataProvider()
    {
        return [
            'standard parameter without access protected setting' => [
                [
                    'parameter' => 1,
                    'linkAccessRestrictedPages' => false,
                    'useCacheHash' => true
                ],
                [
                    'showAccessRestrictedPages' => false
                ],
                true,
                ['uid' => 1],
                '',
                0,
                '',
                '',
                '',
                ''
            ],
            'standard parameter with access protected setting' => [
                [
                    'parameter' => 10,
                    'linkAccessRestrictedPages' => true,
                    'useCacheHash' => true
                ],
                [
                    'showAccessRestrictedPages' => true
                ],
                true,
                ['uid' => 10],
                '',
                0,
                '',
                '',
                '',
                ''
            ],
            'standard parameter with access protected setting "NONE" casts to boolean linkAccessRestrictedPages (delegates resolving to typoLink method internals)' => [
                [
                    'parameter' => 10,
                    'linkAccessRestrictedPages' => true,
                    'useCacheHash' => true
                ],
                [
                    'showAccessRestrictedPages' => 'NONE'
                ],
                true,
                ['uid' => 10],
                '',
                0,
                '',
                '',
                '',
                ''
            ],
            'standard parameter with access protected setting (int)67 casts to boolean linkAccessRestrictedPages (delegates resolving to typoLink method internals)' => [
                [
                    'parameter' => 10,
                    'linkAccessRestrictedPages' => true,
                    'useCacheHash' => true
                ],
                [
                    'showAccessRestrictedPages' => 67
                ],
                true,
                ['uid' => 10],
                '',
                0,
                '',
                '',
                '',
                ''
            ],
            'standard parameter with target' => [
                [
                    'parameter' => 1,
                    'target' => '_blank',
                    'linkAccessRestrictedPages' => false,
                    'useCacheHash' => true
                ],
                [
                    'showAccessRestrictedPages' => false
                ],
                true,
                ['uid' => 1],
                '_blank',
                0,
                '',
                '',
                '',
                ''
            ],
            'parameter with typeOverride=10' => [
                [
                    'parameter' => '10,10',
                    'linkAccessRestrictedPages' => false,
                    'useCacheHash' => true
                ],
                [
                    'showAccessRestrictedPages' => false
                ],
                true,
                ['uid' => 10],
                '',
                0,
                '',
                '',
                '',
                10
            ],
            'parameter with target and typeOverride=10' => [
                [
                    'parameter' => '10,10',
                    'linkAccessRestrictedPages' => false,
                    'useCacheHash' => true,
                    'target' => '_self'
                ],
                [
                    'showAccessRestrictedPages' => false
                ],
                true,
                ['uid' => 10],
                '_self',
                0,
                '',
                '',
                '',
                10
            ],
            'parameter with invalid value in typeOverride=foobar ignores typeOverride' => [
                [
                    'parameter' => 20,
                    'linkAccessRestrictedPages' => false,
                    'useCacheHash' => true,
                    'target' => '_self'
                ],
                [
                    'showAccessRestrictedPages' => false
                ],
                true,
                ['uid' => 20],
                '_self',
                0,
                '',
                '',
                '',
                'foobar'
            ],
            'standard parameter with section name' => [
                [
                    'parameter' => 10,
                    'target' => '_blank',
                    'linkAccessRestrictedPages' => false,
                    'no_cache' => true,
                    'section' => 'section-name'
                ],
                [
                    'showAccessRestrictedPages' => false
                ],
                true,
                [
                    'uid' => 10,
                    'sectionIndex_uid' => 'section-name'
                ],
                '_blank',
                1,
                '',
                '',
                '',
                ''
            ],
            'standard parameter with additional parameters' => [
                [
                    'parameter' => 10,
                    'linkAccessRestrictedPages' => false,
                    'no_cache' => true,
                    'section' => 'section-name',
                    'additionalParams' => '&test=foobar'
                ],
                [
                    'showAccessRestrictedPages' => false
                ],
                true,
                [
                    'uid' => 10,
                    'sectionIndex_uid' => 'section-name'
                ],
                '',
                1,
                '',
                '',
                '&test=foobar',
                ''
            ],
            'overridden page array uid value gets used as parameter' => [
                [
                    'parameter' => 99,
                    'linkAccessRestrictedPages' => false,
                    'no_cache' => true,
                    'section' => 'section-name'
                ],
                [
                    'showAccessRestrictedPages' => false
                ],
                true,
                [
                    'uid' => 10,
                    'sectionIndex_uid' => 'section-name'
                ],
                '',
                1,
                '',
                ['uid' => 99],
                '',
                ''
            ],
        ];
    }
 
    public function ‪menuTypoLinkCreatesExpectedTypoLinkConfiguration(array $expected, array $mconf, $useCacheHash, array $page, $oTarget, $no_cache, $script, $overrideArray = '', $addParams = '', $typeOverride = '')
    {
        $cObject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->setMethods(['typoLink'])
            ->getMock();
        $cObject->expects($this->once())->method('typoLink')->with('|', $expected);
        $this->subject->_set('parent_cObj', $cObject);
        $this->subject->_set('mconf', $mconf);
        $this->subject->_set('useCacheHash', $useCacheHash);
        $this->subject->_call('menuTypoLink', $page, $oTarget, $no_cache, $script, $overrideArray, $addParams, $typeOverride);
    }
}