9.5/_unit_2_mvc_2_controller_2_action_controller_test_8php_source.html

<?php

declare(strict_types = 1);

namespace ‪TYPO3\CMS\Extbase\Tests\Unit\Mvc\Controller;


/*

 * 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 ‪TYPO3\CMS\Core\Page\PageRenderer;

use ‪TYPO3\CMS\Extbase\Configuration\ConfigurationManagerInterface;

use ‪TYPO3\CMS\Extbase\Mvc\Controller\ActionController;

use ‪TYPO3\CMS\Extbase\Mvc\Controller\Arguments;

use ‪TYPO3\CMS\Extbase\Mvc\Controller\ControllerContext;

use ‪TYPO3\CMS\Extbase\Mvc\Exception\InvalidArgumentTypeException;

use ‪TYPO3\CMS\Extbase\Mvc\Exception\NoSuchActionException;

use ‪TYPO3\CMS\Extbase\Mvc\Request;

use ‪TYPO3\CMS\Extbase\Mvc\RequestInterface;

use ‪TYPO3\CMS\Extbase\Mvc\View\ViewInterface;

use ‪TYPO3\CMS\Extbase\Object\ObjectManager;

use ‪TYPO3\CMS\Extbase\Object\ObjectManagerInterface;

use ‪TYPO3\CMS\Extbase\Reflection\ClassSchema;

use ‪TYPO3\CMS\Extbase\Reflection\ReflectionService;

use ‪TYPO3\CMS\Fluid\View\TemplateView;

use TYPO3\TestingFramework\Core\Unit\UnitTestCase;

use TYPO3Fluid\Fluid\View\AbstractTemplateView;

use TYPO3Fluid\Fluid\View\TemplateView as FluidTemplateView;


class ‪ActionControllerTest extends UnitTestCase

{

    protected ‪$resetSingletonInstances = true;


    protected ‪$actionController;


    protected ‪$mockObjectManager;


    protected ‪$mockUriBuilder;


    protected ‪$mockMvcPropertyMappingConfigurationService;


    public function ‪resolveViewUsesFluidTemplateViewIfTemplateIsAvailable()

    {

        $mockControllerContext = $this->createMock(ControllerContext::class);

        $mockFluidTemplateView = $this->createMock(ViewInterface::class);

        $mockFluidTemplateView->expects($this->once())->method('setControllerContext')->with($mockControllerContext);

        $mockFluidTemplateView->expects($this->once())->method('canRender')->with($mockControllerContext)->will($this->returnValue(true));

        ‪$mockObjectManager = $this->createMock(ObjectManagerInterface::class);

        ‪$mockObjectManager->expects($this->at(0))->method('get')->with(TemplateView::class)->will($this->returnValue($mockFluidTemplateView));

        $mockController = $this->getAccessibleMock(ActionController::class, ['buildControllerContext', 'resolveViewObjectName', 'setViewConfiguration'], [], '', false);

        $mockController->expects($this->once())->method('resolveViewObjectName')->will($this->returnValue(false));

        $mockController->_set('objectManager', ‪$mockObjectManager);

        $mockController->_set('controllerContext', $mockControllerContext);

        $this->assertSame($mockFluidTemplateView, $mockController->_call('resolveView'));

    }


    public function ‪resolveViewObjectNameUsesViewObjectNamePatternToResolveViewObjectName()

    {

        $mockRequest = $this->createMock(Request::class);

        $mockRequest->expects($this->once())->method('getControllerVendorName')->will($this->returnValue('MyVendor'));

        $mockRequest->expects($this->once())->method('getControllerExtensionName')->will($this->returnValue('MyPackage'));

        $mockRequest->expects($this->once())->method('getControllerName')->will($this->returnValue('MyController'));

        $mockRequest->expects($this->once())->method('getControllerActionName')->will($this->returnValue('MyAction'));

        $mockRequest->expects($this->atLeastOnce())->method('getFormat')->will($this->returnValue('MyFormat'));

        ‪$mockObjectManager = $this->createMock(ObjectManagerInterface::class);

        $mockController = $this->getAccessibleMock(ActionController::class, ['dummy'], [], '', false);

        $mockController->_set('request', $mockRequest);

        $mockController->_set('objectManager', ‪$mockObjectManager);

        $mockController->_set('namespacesViewObjectNamePattern', 'RandomViewObject@vendor\@extension\View\@controller\@action@format');

        $mockController->_call('resolveViewObjectName');

    }


    public function ‪resolveViewObjectNameUsesNamespacedViewObjectNamePatternForExtensionsWithVendor()

    {

        eval('namespace MyVendor\MyPackage\View\MyController; class MyActionMyFormat {}');


        $mockRequest = $this->createMock(Request::class);

        $mockRequest->expects($this->once())->method('getControllerExtensionName')->will($this->returnValue('MyPackage'));

        $mockRequest->expects($this->once())->method('getControllerName')->will($this->returnValue('MyController'));

        $mockRequest->expects($this->once())->method('getControllerActionName')->will($this->returnValue('MyAction'));

        $mockRequest->expects($this->once())->method('getControllerVendorName')->will($this->returnValue('MyVendor'));

        $mockRequest->expects($this->atLeastOnce())->method('getFormat')->will($this->returnValue('MyFormat'));

        ‪$mockObjectManager = $this->createMock(ObjectManagerInterface::class);

        $mockController = $this->getAccessibleMock(ActionController::class, ['dummy'], [], '', false);

        $mockController->_set('request', $mockRequest);

        $mockController->_set('objectManager', ‪$mockObjectManager);


        $this->assertEquals(

            'MyVendor\MyPackage\View\MyController\MyActionMyFormat',

            $mockController->_call('resolveViewObjectName')

        );

    }


    public function ‪resolveActionMethodNameReturnsTheCurrentActionMethodNameFromTheRequest()

    {

        $mockRequest = $this->createMock(Request::class);

        $mockRequest->expects($this->once())->method('getControllerActionName')->will($this->returnValue('fooBar'));

        $mockController = $this->getAccessibleMock(ActionController::class, ['fooBarAction'], [], '', false);

        $mockController->_set('request', $mockRequest);

        $this->assertEquals('fooBarAction', $mockController->_call('resolveActionMethodName'));

    }


    public function ‪resolveActionMethodNameThrowsAnExceptionIfTheActionDefinedInTheRequestDoesNotExist()

    {

        $this->expectException(NoSuchActionException::class);

        $this->expectExceptionCode(1186669086);

        $mockRequest = $this->createMock(Request::class);

        $mockRequest->expects($this->once())->method('getControllerActionName')->will($this->returnValue('fooBar'));

        $mockController = $this->getAccessibleMock(ActionController::class, ['otherBarAction'], [], '', false);

        $mockController->_set('request', $mockRequest);

        $mockController->_call('resolveActionMethodName');

    }


    public function ‪initializeActionMethodArgumentsRegistersArgumentsFoundInTheSignatureOfTheCurrentActionMethod(): void

    {

        $mockRequest = $this->createMock(Request::class);

        $mockArguments = $this->getMockBuilder(Arguments::class)

            ->setMethods(['addNewArgument', 'removeAll'])

            ->getMock();

        $mockArguments->expects($this->at(0))->method('addNewArgument')->with('stringArgument', 'string', true);

        $mockArguments->expects($this->at(1))->method('addNewArgument')->with('integerArgument', 'integer', true);

        $mockArguments->expects($this->at(2))->method('addNewArgument')->with('objectArgument', 'F3_Foo_Bar', true);

        $mockController = $this->getAccessibleMock(ActionController::class, ['fooAction', 'evaluateDontValidateAnnotations'], [], '', false);

        $methodParameters = [

            'stringArgument' => [

                'position' => 0,

                'byReference' => false,

                'array' => false,

                'optional' => false,

                'allowsNull' => false,

                'type' => 'string',

                'hasDefaultValue' => false

            ],

            'integerArgument' => [

                'position' => 1,

                'byReference' => false,

                'array' => false,

                'optional' => false,

                'allowsNull' => false,

                'type' => 'integer',

                'hasDefaultValue' => false

            ],

            'objectArgument' => [

                'position' => 2,

                'byReference' => false,

                'array' => false,

                'optional' => false,

                'allowsNull' => false,

                'type' => 'F3_Foo_Bar',

                'hasDefaultValue' => false

            ]

        ];


        $classSchemaMock = $this->createMock(ClassSchema::class);

        $classSchemaMock

            ->expects($this->any())

            ->method('getMethod')

            ->with('fooAction')

            ->willReturn([

                'params' => $methodParameters

            ]);


        $mockReflectionService = $this->createMock(ReflectionService::class);

        $mockReflectionService

            ->expects($this->any())

            ->method('getClassSchema')

            ->with(get_class($mockController))

            ->willReturn($classSchemaMock);

        $mockController->_set('reflectionService', $mockReflectionService);

        $mockController->_set('request', $mockRequest);

        $mockController->_set('arguments', $mockArguments);

        $mockController->_set('actionMethodName', 'fooAction');

        $mockController->_call('initializeActionMethodArguments');

    }


    public function ‪initializeActionMethodArgumentsRegistersOptionalArgumentsAsSuch(): void

    {

        $mockRequest = $this->createMock(Request::class);

        $mockArguments = $this->createMock(Arguments::class);

        $mockArguments->expects($this->at(0))->method('addNewArgument')->with('arg1', 'string', true);

        $mockArguments->expects($this->at(1))->method('addNewArgument')->with('arg2', 'array', false, [21]);

        $mockArguments->expects($this->at(2))->method('addNewArgument')->with('arg3', 'string', false, 42);

        $mockController = $this->getAccessibleMock(ActionController::class, ['fooAction', 'evaluateDontValidateAnnotations'], [], '', false);

        $methodParameters = [

            'arg1' => [

                'position' => 0,

                'byReference' => false,

                'array' => false,

                'optional' => false,

                'allowsNull' => false,

                'type' => 'string',

                'hasDefaultValue' => false

            ],

            'arg2' => [

                'position' => 1,

                'byReference' => false,

                'array' => true,

                'optional' => true,

                'defaultValue' => [21],

                'allowsNull' => false,

                'hasDefaultValue' => true

            ],

            'arg3' => [

                'position' => 2,

                'byReference' => false,

                'array' => false,

                'optional' => true,

                'defaultValue' => 42,

                'allowsNull' => false,

                'type' => 'string',

                'hasDefaultValue' => true

            ]

        ];


        $classSchemaMock = $this->createMock(ClassSchema::class);

        $classSchemaMock

            ->expects($this->any())

            ->method('getMethod')

            ->with('fooAction')

            ->willReturn([

                'params' => $methodParameters

            ]);


        $mockReflectionService = $this->createMock(ReflectionService::class);

        $mockReflectionService

            ->expects($this->any())

            ->method('getClassSchema')

            ->with(get_class($mockController))

            ->willReturn($classSchemaMock);

        $mockController->_set('reflectionService', $mockReflectionService);

        $mockController->_set('request', $mockRequest);

        $mockController->_set('arguments', $mockArguments);

        $mockController->_set('actionMethodName', 'fooAction');

        $mockController->_call('initializeActionMethodArguments');

    }


    public function ‪initializeActionMethodArgumentsThrowsExceptionIfDataTypeWasNotSpecified(): void

    {

        $this->expectException(InvalidArgumentTypeException::class);

        $this->expectExceptionCode(1253175643);

        $mockRequest = $this->createMock(Request::class);

        $mockArguments = $this->createMock(Arguments::class);

        $mockController = $this->getAccessibleMock(ActionController::class, ['fooAction'], [], '', false);

        $methodParameters = [

            'arg1' => [

                'position' => 0,

                'byReference' => false,

                'array' => false,

                'optional' => false,

                'allowsNull' => false

            ]

        ];


        $classSchemaMock = $this->createMock(ClassSchema::class);

        $classSchemaMock

            ->expects($this->any())

            ->method('getMethod')

            ->with('fooAction')

            ->willReturn([

                'params' => $methodParameters

            ]);


        $mockReflectionService = $this->createMock(ReflectionService::class);

        $mockReflectionService

            ->expects($this->any())

            ->method('getClassSchema')

            ->with(get_class($mockController))

            ->willReturn($classSchemaMock);

        $mockController->_set('reflectionService', $mockReflectionService);

        $mockController->_set('request', $mockRequest);

        $mockController->_set('arguments', $mockArguments);

        $mockController->_set('actionMethodName', 'fooAction');

        $mockController->_call('initializeActionMethodArguments');

    }


    public function ‪setViewConfigurationResolvesTemplateRootPathsForTemplateRootPath($configuration, $expected)

    {

        $mockController = $this->getAccessibleMock(ActionController::class, ['dummy'], [], '', false);

        $mockConfigurationManager = $this->createMock(ConfigurationManagerInterface::class);

        $mockConfigurationManager->expects($this->any())->method('getConfiguration')->will($this->returnValue($configuration));

        $mockController->injectConfigurationManager($mockConfigurationManager);

        $mockController->_set('request', $this->createMock(Request::class), ['getControllerExtensionKey']);

        $view = $this->getMockBuilder(ViewInterface::class)

            ->setMethods(['setControllerContext', 'assign', 'assignMultiple', 'canRender', 'render', 'initializeView', 'setTemplateRootPaths'])

            ->getMock();

        $view->expects($this->once())->method('setTemplateRootPaths')->with($expected);

        $mockController->_call('setViewConfiguration', $view);

    }


    public function ‪templateRootPathDataProvider()

    {

        return [

            'text keys' => [

                [

                    'view' => [

                        'templateRootPaths' => [

                            'default' => 'some path',

                            'extended' => 'some other path'

                        ]

                    ]

                ],

                [

                    'extended' => 'some other path',

                    'default' => 'some path'

                ]

            ],

            'numerical keys' => [

                [

                    'view' => [

                        'templateRootPaths' => [

                            '10' => 'some path',

                            '20' => 'some other path',

                            '15' => 'intermediate specific path'

                        ]

                    ]

                ],

                [

                    '20' => 'some other path',

                    '15' => 'intermediate specific path',

                    '10' => 'some path'

                ]

            ],

            'mixed keys' => [

                [

                    'view' => [

                        'templateRootPaths' => [

                            '10' => 'some path',

                            'very_specific' => 'some other path',

                            '15' => 'intermediate specific path'

                        ]

                    ]

                ],

                [

                    '15' => 'intermediate specific path',

                    'very_specific' => 'some other path',

                    '10' => 'some path'

                ]

            ],

        ];

    }


    public function ‪setViewConfigurationResolvesLayoutRootPathsForLayoutRootPath($configuration, $expected)

    {

        $mockController = $this->getAccessibleMock(ActionController::class, ['dummy'], [], '', false);

        $mockConfigurationManager = $this->createMock(ConfigurationManagerInterface::class);

        $mockConfigurationManager->expects($this->any())->method('getConfiguration')->will($this->returnValue($configuration));

        $mockController->injectConfigurationManager($mockConfigurationManager);

        $mockController->_set('request', $this->createMock(Request::class), ['getControllerExtensionKey']);

        $view = $this->getMockBuilder(ViewInterface::class)

            ->setMethods(['setControllerContext', 'assign', 'assignMultiple', 'canRender', 'render', 'initializeView', 'setlayoutRootPaths'])

            ->getMock();

        $view->expects($this->once())->method('setlayoutRootPaths')->with($expected);

        $mockController->_call('setViewConfiguration', $view);

    }


    public function ‪layoutRootPathDataProvider()

    {

        return [

            'text keys' => [

                [

                    'view' => [

                        'layoutRootPaths' => [

                            'default' => 'some path',

                            'extended' => 'some other path'

                        ]

                    ]

                ],

                [

                    'extended' => 'some other path',

                    'default' => 'some path'

                ]

            ],

            'numerical keys' => [

                [

                    'view' => [

                        'layoutRootPaths' => [

                            '10' => 'some path',

                            '20' => 'some other path',

                            '15' => 'intermediate specific path'

                        ]

                    ]

                ],

                [

                    '20' => 'some other path',

                    '15' => 'intermediate specific path',

                    '10' => 'some path'

                ]

            ],

            'mixed keys' => [

                [

                    'view' => [

                        'layoutRootPaths' => [

                            '10' => 'some path',

                            'very_specific' => 'some other path',

                            '15' => 'intermediate specific path'

                        ]

                    ]

                ],

                [

                    '15' => 'intermediate specific path',

                    'very_specific' => 'some other path',

                    '10' => 'some path'

                ]

            ],

        ];

    }


    public function ‪setViewConfigurationResolvesPartialRootPathsForPartialRootPath($configuration, $expected)

    {

        $mockController = $this->getAccessibleMock(ActionController::class, ['dummy'], [], '', false);

        $mockConfigurationManager = $this->createMock(ConfigurationManagerInterface::class);

        $mockConfigurationManager->expects($this->any())->method('getConfiguration')->will($this->returnValue($configuration));

        $mockController->injectConfigurationManager($mockConfigurationManager);

        $mockController->_set('request', $this->createMock(Request::class), ['getControllerExtensionKey']);

        $view = $this->getMockBuilder(ViewInterface::class)

            ->setMethods(['setControllerContext', 'assign', 'assignMultiple', 'canRender', 'render', 'initializeView', 'setpartialRootPaths'])

            ->getMock();

        $view->expects($this->once())->method('setpartialRootPaths')->with($expected);

        $mockController->_call('setViewConfiguration', $view);

    }


    public function ‪partialRootPathDataProvider()

    {

        return [

            'text keys' => [

                [

                    'view' => [

                        'partialRootPaths' => [

                            'default' => 'some path',

                            'extended' => 'some other path'

                        ]

                    ]

                ],

                [

                    'extended' => 'some other path',

                    'default' => 'some path'

                ]

            ],

            'numerical keys' => [

                [

                    'view' => [

                        'partialRootPaths' => [

                            '10' => 'some path',

                            '20' => 'some other path',

                            '15' => 'intermediate specific path'

                        ]

                    ]

                ],

                [

                    '20' => 'some other path',

                    '15' => 'intermediate specific path',

                    '10' => 'some path'

                ]

            ],

            'mixed keys' => [

                [

                    'view' => [

                        'partialRootPaths' => [

                            '10' => 'some path',

                            'very_specific' => 'some other path',

                            '15' => 'intermediate specific path'

                        ]

                    ]

                ],

                [

                    '15' => 'intermediate specific path',

                    'very_specific' => 'some other path',

                    '10' => 'some path'

                ]

            ],

        ];

    }


    public function ‪rendersAndAssignsAssetsFromViewIntoPageRenderer($viewMock, $expectedHeader, $expectedFooter)

    {

        $this->mockObjectManager = $this->createMock(ObjectManager::class);

        $pageRendererMock = $this->getMockBuilder(PageRenderer::class)->setMethods(['addHeaderData', 'addFooterData'])->getMock();

        if (!$viewMock instanceof FluidTemplateView) {

            $this->mockObjectManager->expects($this->never())->method('get');

        } else {

            $this->mockObjectManager->expects($this->any())->method('get')->with(PageRenderer::class)->willReturn($pageRendererMock);

        }

        if (!empty(trim($expectedHeader ?? ''))) {

            $pageRendererMock->expects($this->once())->method('addHeaderData')->with($expectedHeader);

        } else {

            $pageRendererMock->expects($this->never())->method('addHeaderData');

        }

        if (!empty(trim($expectedFooter ?? ''))) {

            $pageRendererMock->expects($this->once())->method('addFooterData')->with($expectedFooter);

        } else {

            $pageRendererMock->expects($this->never())->method('addFooterData');

        }

        $requestMock = $this->getMockBuilder(RequestInterface::class)->getMockForAbstractClass();

        $subject = new ActionController();

        $viewProperty = new \ReflectionProperty($subject, 'view');

        $viewProperty->setAccessible(true);

        $viewProperty->setValue($subject, $viewMock);

        $objectManagerProperty = new \ReflectionProperty($subject, 'objectManager');

        $objectManagerProperty->setAccessible(true);

        $objectManagerProperty->setValue($subject, $this->mockObjectManager);


        $method = new \ReflectionMethod($subject, 'renderAssetsForRequest');

        $method->setAccessible(true);

        $method->invokeArgs($subject, [$requestMock]);

    }


    public function ‪headerAssetDataProvider()

    {

        $viewWithHeaderData = $this->getMockBuilder(FluidTemplateView::class)->setMethods(['renderSection'])->disableOriginalConstructor()->getMock();

        $viewWithHeaderData->expects($this->at(0))->method('renderSection')->with('HeaderAssets', $this->anything(), true)->willReturn('custom-header-data');

        $viewWithHeaderData->expects($this->at(1))->method('renderSection')->with('FooterAssets', $this->anything(), true)->willReturn(null);

        $viewWithFooterData = $this->getMockBuilder(FluidTemplateView::class)->setMethods(['renderSection'])->disableOriginalConstructor()->getMock();

        $viewWithFooterData->expects($this->at(0))->method('renderSection')->with('HeaderAssets', $this->anything(), true)->willReturn(null);

        $viewWithFooterData->expects($this->at(1))->method('renderSection')->with('FooterAssets', $this->anything(), true)->willReturn('custom-footer-data');

        $viewWithBothData = $this->getMockBuilder(FluidTemplateView::class)->setMethods(['renderSection'])->disableOriginalConstructor()->getMock();

        $viewWithBothData->expects($this->at(0))->method('renderSection')->with('HeaderAssets', $this->anything(), true)->willReturn('custom-header-data');

        $viewWithBothData->expects($this->at(1))->method('renderSection')->with('FooterAssets', $this->anything(), true)->willReturn('custom-footer-data');

        $invalidView = $this->getMockBuilder(AbstractTemplateView::class)->disableOriginalConstructor()->getMockForAbstractClass();

        return [

            [$viewWithHeaderData, 'custom-header-data', null],

            [$viewWithFooterData, null, 'custom-footer-data'],

            [$viewWithBothData, 'custom-header-data', 'custom-footer-data'],

            [$invalidView, null, null]

        ];

    }

}