BackendUtilityTest.php

Go to the documentation of this file.

<?php
 
/*
 * 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!
 */
 
namespace ‪TYPO3\CMS\Backend\Tests\Unit\Utility;
 
use Doctrine\DBAL\Driver\Statement;
use Prophecy\Argument;
use Prophecy\Prophecy\ObjectProphecy;
use Psr\EventDispatcher\EventDispatcherInterface;
use ‪TYPO3\CMS\Backend\Configuration\TypoScript\ConditionMatching\ConditionMatcher;
use ‪TYPO3\CMS\Backend\Tests\Unit\Utility\Fixtures\LabelFromItemListMergedReturnsCorrectFieldsFixture;
use ‪TYPO3\CMS\Backend\Tests\Unit\Utility\Fixtures\ProcessedValueForGroupWithMultipleAllowedTablesFixture;
use ‪TYPO3\CMS\Backend\Tests\Unit\Utility\Fixtures\ProcessedValueForGroupWithOneAllowedTableFixture;
use ‪TYPO3\CMS\Backend\Tests\Unit\Utility\Fixtures\ProcessedValueForSelectWithMMRelationFixture;
use ‪TYPO3\CMS\Backend\Utility\BackendUtility;
use ‪TYPO3\CMS\Core\Cache\CacheManager;
use ‪TYPO3\CMS\Core\Cache\Frontend\FrontendInterface;
use ‪TYPO3\CMS\Core\Configuration\Event\ModifyLoadedPageTsConfigEvent;
use ‪TYPO3\CMS\Core\Configuration\Loader\PageTsConfigLoader;
use ‪TYPO3\CMS\Core\Configuration\Parser\PageTsConfigParser;
use ‪TYPO3\CMS\Core\Database\Connection;
use ‪TYPO3\CMS\Core\Database\ConnectionPool;
use ‪TYPO3\CMS\Core\Database\Query\Expression\ExpressionBuilder;
use ‪TYPO3\CMS\Core\Database\Query\QueryBuilder;
use ‪TYPO3\CMS\Core\Database\Query\Restriction\DefaultRestrictionContainer;
use ‪TYPO3\CMS\Core\Database\RelationHandler;
use ‪TYPO3\CMS\Core\Localization\LanguageService;
use ‪TYPO3\CMS\Core\Site\Entity\Site;
use ‪TYPO3\CMS\Core\Site\SiteFinder;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\TestingFramework\Core\Unit\UnitTestCase;
 
class ‪BackendUtilityTest extends UnitTestCase
{
    protected ‪$resetSingletonInstances = true;
 
    // Tests concerning calcAge
 
    public function ‪calcAgeDataProvider()
    {
        return [
            'Single year' => [
                'seconds' => 60 * 60 * 24 * 365,
                'expectedLabel' => '1 year'
            ],
            'Plural years' => [
                'seconds' => 60 * 60 * 24 * 365 * 2,
                'expectedLabel' => '2 yrs'
            ],
            'Single negative year' => [
                'seconds' => 60 * 60 * 24 * 365 * -1,
                'expectedLabel' => '-1 year'
            ],
            'Plural negative years' => [
                'seconds' => 60 * 60 * 24 * 365 * 2 * -1,
                'expectedLabel' => '-2 yrs'
            ],
            'Single day' => [
                'seconds' => 60 * 60 * 24,
                'expectedLabel' => '1 day'
            ],
            'Plural days' => [
                'seconds' => 60 * 60 * 24 * 2,
                'expectedLabel' => '2 days'
            ],
            'Single negative day' => [
                'seconds' => 60 * 60 * 24 * -1,
                'expectedLabel' => '-1 day'
            ],
            'Plural negative days' => [
                'seconds' => 60 * 60 * 24 * 2 * -1,
                'expectedLabel' => '-2 days'
            ],
            'Single hour' => [
                'seconds' => 60 * 60,
                'expectedLabel' => '1 hour'
            ],
            'Plural hours' => [
                'seconds' => 60 * 60 * 2,
                'expectedLabel' => '2 hrs'
            ],
            'Single negative hour' => [
                'seconds' => 60 * 60 * -1,
                'expectedLabel' => '-1 hour'
            ],
            'Plural negative hours' => [
                'seconds' => 60 * 60 * 2 * -1,
                'expectedLabel' => '-2 hrs'
            ],
            'Single minute' => [
                'seconds' => 60,
                'expectedLabel' => '1 min'
            ],
            'Plural minutes' => [
                'seconds' => 60 * 2,
                'expectedLabel' => '2 min'
            ],
            'Single negative minute' => [
                'seconds' => 60 * -1,
                'expectedLabel' => '-1 min'
            ],
            'Plural negative minutes' => [
                'seconds' => 60 * 2 * -1,
                'expectedLabel' => '-2 min'
            ],
            'Zero seconds' => [
                'seconds' => 0,
                'expectedLabel' => '0 min'
            ]
        ];
    }
 
    public function ‪calcAgeReturnsExpectedValues($seconds, $expectedLabel)
    {
        self::assertSame($expectedLabel, ‪BackendUtility::calcAge($seconds));
    }
 
    // Tests concerning getProcessedValue
 
    public function ‪getProcessedValueForZeroStringIsZero()
    {
        ‪$GLOBALS['TCA'] = [
            'tt_content' => [
                'columns' => [
                    'header' => [
                        'config' => [
                            'type' => 'input',
                        ],
                    ],
                ],
            ],
        ];
        ‪$GLOBALS['LANG'] = [];
        self::assertEquals('0', ‪BackendUtility::getProcessedValue('tt_content', 'header', '0'));
    }
 
    public function ‪getProcessedValueForGroup()
    {
        ‪$GLOBALS['TCA'] = [
            'tt_content' => [
                'columns' => [
                    'multimedia' => [
                        'config' => [
                            'type' => 'group',
                        ],
                    ],
                ],
            ],
        ];
        ‪$GLOBALS['LANG'] = [];
        self::assertSame('1, 2', ‪BackendUtility::getProcessedValue('tt_content', 'multimedia', '1,2'));
    }
 
    public function ‪getProcessedValueForGroupWithOneAllowedTable()
    {
        ‪$GLOBALS['TCA'] = [
            'tt_content' => [
                'columns' => [
                    'pages' => [
                        'config' => [
                            'type' => 'group',
                            'allowed' => 'pages',
                            'internal_type' => 'db',
                            'maxitems' => 22,
                            'minitems' => 0,
                            'size' => 3,
                        ],
                    ],
                ],
            ],
        ];
        ‪$GLOBALS['LANG'] = [];
        self::assertSame('Page 1, Page 2', ‪ProcessedValueForGroupWithOneAllowedTableFixture::getProcessedValue('tt_content', 'pages', '1,2'));
    }
 
    public function ‪getProcessedValueForGroupWithMultipleAllowedTables()
    {
        ‪$GLOBALS['TCA'] = [
            'index_config' => [
                'columns' => [
                    'indexcfgs' => [
                        'config' => [
                            'type' => 'group',
                            'internal_type' => 'db',
                            'allowed' => 'index_config,pages',
                            'size' => 5,
                        ],
                    ],
                ],
            ],
        ];
        ‪$GLOBALS['LANG'] = [];
        self::assertSame('Page 1, Configuration 2', ‪ProcessedValueForGroupWithMultipleAllowedTablesFixture::getProcessedValue('index_config', 'indexcfgs', 'pages_1,index_config_2'));
    }
 
    protected function ‪mockDatabaseConnection($tableName = 'sys_category')
    {
        $connectionProphet = $this->prophesize(Connection::class);
        $connectionProphet->quote(Argument::cetera())->will(function ($arguments) {
            return "'" . $arguments[0] . "'";
        });
        $connectionProphet->quoteIdentifier(Argument::cetera())->will(function ($arguments) {
            return '`' . $arguments[0] . '`';
        });
 
        $restrictionProphet = $this->prophesize(DefaultRestrictionContainer::class);
        $restrictionProphet->removeAll()->willReturn($restrictionProphet->reveal());
        $restrictionProphet->add(Argument::cetera())->willReturn($restrictionProphet->reveal());
 
        $queryBuilderProphet = $this->prophesize(QueryBuilder::class);
        $queryBuilderProphet->expr()->willReturn(
            GeneralUtility::makeInstance(ExpressionBuilder::class, $connectionProphet->reveal())
        );
        $queryBuilderProphet->getRestrictions()->willReturn($restrictionProphet->reveal());
        $queryBuilderProphet->quoteIdentifier(Argument::cetera())->will(function ($arguments) {
            return '`' . $arguments[0] . '`';
        });
 
        $connectionPoolProphet = $this->prophesize(ConnectionPool::class);
        $connectionPoolProphet->getConnectionForTable($tableName)
            ->willReturn($connectionProphet->reveal());
        $connectionPoolProphet->getQueryBuilderForTable($tableName)
            ->shouldBeCalled()
            ->willReturn($queryBuilderProphet->reveal());
 
        return [$queryBuilderProphet, $connectionPoolProphet, $connectionProphet, $restrictionProphet];
    }
 
    public function ‪getProcessedValueForSelectWithMMRelation()
    {
        $relationHandlerProphet = $this->prophesize(RelationHandler::class);
        $relationHandlerProphet->start(Argument::cetera())->shouldBeCalled();
 
        $relationHandlerInstance = $relationHandlerProphet->reveal();
        $relationHandlerInstance->tableArray['sys_category'] = [1, 2];
 
        [$queryBuilderProphet, $connectionPoolProphet] = $this->‪mockDatabaseConnection('sys_category');
        $statementProphet = $this->prophesize(Statement::class);
        $statementProphet->fetch()->shouldBeCalled()->willReturn(
            [
                'uid' => 1,
                'title' => 'Category 1',
            ],
            [
                'uid' => 2,
                'title' => 'Category 2',
            ],
            false
        );
 
        $queryBuilderProphet->select('uid', 'sys_category.title')->willReturn($queryBuilderProphet->reveal());
        $queryBuilderProphet->from('sys_category')->willReturn($queryBuilderProphet->reveal());
        $queryBuilderProphet->where('`uid` IN (:dcValue1)')->willReturn($queryBuilderProphet->reveal());
        $queryBuilderProphet->createNamedParameter([1, 2], Connection::PARAM_INT_ARRAY)->willReturn(':dcValue1');
        $queryBuilderProphet->execute()->willReturn($statementProphet->reveal());
 
        GeneralUtility::addInstance(RelationHandler::class, $relationHandlerInstance);
        GeneralUtility::addInstance(ConnectionPool::class, $connectionPoolProphet->reveal());
 
        ‪$GLOBALS['TCA'] = [
            'pages' => [
                'columns' => [
                    'categories' => [
                        'config' => [
                            'type' => 'select',
                            'foreign_table' => 'sys_category',
                            'MM' => 'sys_category_record_mm',
                            'MM_match_fields' => [
                                'fieldname' => 'categories',
                                'tablesnames' => 'pages',
                            ],
                            'MM_opposite_field' => 'items',
                        ],
                    ],
                ],
            ],
            'sys_category' => [
                'ctrl' => ['label' => 'title'],
                'columns' => [
                    'items' => [
                        'config' => [
                            'type' => 'group',
                            'internal_type' => 'db',
                            'allowed' => '*',
                            'MM' => 'sys_category_record_mm',
                            'MM_oppositeUsage' => [],
                        ]
                    ]
                ],
            ],
        ];
        ‪$GLOBALS['LANG'] = [];
 
        self::assertSame(
            'Category 1; Category 2',
            ‪ProcessedValueForSelectWithMMRelationFixture::getProcessedValue(
                'pages',
                'categories',
                '2',
                0,
                false,
                false,
                1
            )
        );
    }
 
    public function ‪getProcessedValueDisplaysAgeForDateInputFieldsIfSettingAbsent()
    {
        $languageServiceProphecy = $this->prophesize(LanguageService::class);
        $languageServiceProphecy->sL(Argument::cetera())->willReturn(' min| hrs| days| yrs| min| hour| day| year');
        ‪$GLOBALS['LANG'] = $languageServiceProphecy->reveal();
 
        ‪$GLOBALS['EXEC_TIME'] = mktime(0, 0, 0, 8, 30, 2015);
 
        ‪$GLOBALS['TCA'] = [
            'tt_content' => [
                'columns' => [
                    'date' => [
                        'config' => [
                            'type' => 'input',
                            'eval' => 'date',
                        ],
                    ],
                ],
            ],
        ];
        self::assertSame('28-08-15 (-2 days)', ‪BackendUtility::getProcessedValue('tt_content', 'date', mktime(0, 0, 0, 8, 28, 2015)));
    }
 
    public function ‪inputTypeDateDisplayOptions()
    {
        return [
            'typeSafe Setting' => [
                true,
                '28-08-15',
            ],
            'non typesafe setting' => [
                1,
                '28-08-15',
            ],
            'setting disabled typesafe' => [
                false,
                '28-08-15 (-2 days)',
            ],
            'setting disabled not typesafe' => [
                0,
                '28-08-15 (-2 days)',
            ],
        ];
    }
 
    public function ‪getProcessedValueHandlesAgeDisplayCorrectly($input, $expected)
    {
        $languageServiceProphecy = $this->prophesize(LanguageService::class);
        $languageServiceProphecy->sL(Argument::cetera())->willReturn(' min| hrs| days| yrs| min| hour| day| year');
        ‪$GLOBALS['LANG'] = $languageServiceProphecy->reveal();
 
        ‪$GLOBALS['EXEC_TIME'] = mktime(0, 0, 0, 8, 30, 2015);
 
        ‪$GLOBALS['TCA'] = [
            'tt_content' => [
                'columns' => [
                    'date' => [
                        'config' => [
                            'type' => 'input',
                            'eval' => 'date',
                            'disableAgeDisplay' => $input,
                        ],
                    ],
                ],
            ],
        ];
        self::assertSame($expected, ‪BackendUtility::getProcessedValue('tt_content', 'date', mktime(0, 0, 0, 8, 28, 2015)));
    }
 
    public function ‪getProcessedValueForCheckWithSingleItem()
    {
        ‪$GLOBALS['TCA'] = [
            'tt_content' => [
                'columns' => [
                    'hide' => [
                        'config' => [
                            'type' => 'check',
                            'items' => [
                                [
                                    0 => '',
                                    1 => '',
                                ]
                            ]
                        ]
                    ]
                ]
            ]
        ];
        $languageServiceProphecy = $this->prophesize(LanguageService::class);
        $languageServiceProphecy->sL('LLL:EXT:core/Resources/Private/Language/locallang_common.xlf:yes')->willReturn('Yes');
        $languageServiceProphecy->sL('LLL:EXT:core/Resources/Private/Language/locallang_common.xlf:no')->willReturn('No');
        ‪$GLOBALS['LANG'] = $languageServiceProphecy->reveal();
        self::assertSame('Yes', ‪BackendUtility::getProcessedValue('tt_content', 'hide', 1));
    }
 
    public function ‪getProcessedValueForCheckWithSingleItemInvertStateDisplay()
    {
        ‪$GLOBALS['TCA'] = [
            'tt_content' => [
                'columns' => [
                    'hide' => [
                        'config' => [
                            'type' => 'check',
                            'items' => [
                                [
                                    0 => '',
                                    1 => '',
                                    'invertStateDisplay' => true,
                                ]
                            ]
                        ]
                    ]
                ]
            ]
        ];
        $languageServiceProphecy = $this->prophesize(LanguageService::class);
        $languageServiceProphecy->sL('LLL:EXT:core/Resources/Private/Language/locallang_common.xlf:yes')->willReturn('Yes');
        $languageServiceProphecy->sL('LLL:EXT:core/Resources/Private/Language/locallang_common.xlf:no')->willReturn('No');
        ‪$GLOBALS['LANG'] = $languageServiceProphecy->reveal();
        self::assertSame('No', ‪BackendUtility::getProcessedValue('tt_content', 'hide', 1));
    }
 
    public function ‪getCommonSelectFieldsReturnsCorrectFieldsDataProvider()
    {
        return [
            'only uid' => [
                'table' => 'test_table',
                'prefix' => '',
                'presetFields' => [],
                'tca' => [],
                'expectedFields' => 'uid'
            ],
            'label set' => [
                'table' => 'test_table',
                'prefix' => '',
                'presetFields' => [],
                'tca' => [
                    'ctrl' => [
                        'label' => 'label'
                    ]
                ],
                'expectedFields' => 'uid,label'
            ],
            'label_alt set' => [
                'table' => 'test_table',
                'prefix' => '',
                'presetFields' => [],
                'tca' => [
                    'ctrl' => [
                        'label_alt' => 'label,label2'
                    ]
                ],
                'expectedFields' => 'uid,label,label2'
            ],
            'versioningWS set' => [
                'table' => 'test_table',
                'prefix' => '',
                'presetFields' => [],
                'tca' => [
                    'ctrl' => [
                        'versioningWS' => true
                    ]
                ],
                'expectedFields' => 'uid,t3ver_state,t3ver_wsid,t3ver_count'
            ],
            'selicon_field set' => [
                'table' => 'test_table',
                'prefix' => '',
                'presetFields' => [],
                'tca' => [
                    'ctrl' => [
                        'selicon_field' => 'field'
                    ]
                ],
                'expectedFields' => 'uid,field'
            ],
            'typeicon_column set' => [
                'table' => 'test_table',
                'prefix' => '',
                'presetFields' => [],
                'tca' => [
                    'ctrl' => [
                        'typeicon_column' => 'field'
                    ]
                ],
                'expectedFields' => 'uid,field'
            ],
            'enablecolumns set' => [
                'table' => 'test_table',
                'prefix' => '',
                'presetFields' => [],
                'tca' => [
                    'ctrl' => [
                        'enablecolumns' => [
                            'disabled' => 'hidden',
                            'starttime' => 'start',
                            'endtime' => 'stop',
                            'fe_group' => 'groups'
                        ]
                    ]
                ],
                'expectedFields' => 'uid,hidden,start,stop,groups'
            ],
            'label set to uid' => [
                'table' => 'test_table',
                'prefix' => '',
                'presetFields' => [],
                'tca' => [
                    'ctrl' => [
                        'label' => 'uid'
                    ]
                ],
                'expectedFields' => 'uid'
            ]
        ];
    }
 
    public function ‪getCommonSelectFieldsReturnsCorrectFields($table, $prefix = '', array $presetFields, array ‪$tca, $expectedFields = '')
    {
        ‪$GLOBALS['TCA'][$table] = ‪$tca;
        $selectFields = ‪BackendUtility::getCommonSelectFields($table, $prefix, $presetFields);
        self::assertEquals($selectFields, $expectedFields);
    }
 
    public function ‪getLabelFromItemlistReturnsCorrectFieldsDataProvider()
    {
        return [
            'item set' => [
                'table' => 'tt_content',
                'col' => 'menu_type',
                'key' => '1',
                'tca' => [
                    'columns' => [
                        'menu_type' => [
                            'config' => [
                                'items' => [
                                    ['Item 1', '0'],
                                    ['Item 2', '1'],
                                    ['Item 3', '3']
                                ]
                            ]
                        ]
                    ]
                ],
                'expectedLabel' => 'Item 2'
            ],
            'item set twice' => [
                'table' => 'tt_content',
                'col' => 'menu_type',
                'key' => '1',
                'tca' => [
                    'columns' => [
                        'menu_type' => [
                            'config' => [
                                'items' => [
                                    ['Item 1', '0'],
                                    ['Item 2a', '1'],
                                    ['Item 2b', '1'],
                                    ['Item 3', '3']
                                ]
                            ]
                        ]
                    ]
                ],
                'expectedLabel' => 'Item 2a'
            ],
            'item not found' => [
                'table' => 'tt_content',
                'col' => 'menu_type',
                'key' => '5',
                'tca' => [
                    'columns' => [
                        'menu_type' => [
                            'config' => [
                                'items' => [
                                    ['Item 1', '0'],
                                    ['Item 2', '1'],
                                    ['Item 3', '2']
                                ]
                            ]
                        ]
                    ]
                ],
                'expectedLabel' => null
            ]
        ];
    }
 
    public function ‪getLabelFromItemlistReturnsCorrectFields($table, $col = '', $key = '', array ‪$tca, $expectedLabel = '')
    {
        ‪$GLOBALS['TCA'][$table] = ‪$tca;
        $label = ‪BackendUtility::getLabelFromItemlist($table, $col, $key);
        self::assertEquals($label, $expectedLabel);
    }
 
    public function ‪getLabelFromItemListMergedReturnsCorrectFieldsDataProvider()
    {
        return [
            'no field found' => [
                'pageId' => '123',
                'table' => 'tt_content',
                'col' => 'menu_type',
                'key' => '10',
                'tca' => [
                    'columns' => [
                        'menu_type' => [
                            'config' => [
                                'items' => [
                                    ['Item 1', '0'],
                                    ['Item 2', '1'],
                                    ['Item 3', '3']
                                ]
                            ]
                        ]
                    ]
                ],
                'expectedLabel' => ''
            ],
            'no tsconfig set' => [
                'pageId' => '123',
                'table' => 'tt_content',
                'col' => 'menu_type',
                'key' => '1',
                'tca' => [
                    'columns' => [
                        'menu_type' => [
                            'config' => [
                                'items' => [
                                    ['Item 1', '0'],
                                    ['Item 2', '1'],
                                    ['Item 3', '3']
                                ]
                            ]
                        ]
                    ]
                ],
                'expectedLabel' => 'Item 2'
            ]
        ];
    }
 
    public function ‪getLabelFromItemListMergedReturnsCorrectFields($pageId, $table, $column = '', $key = '', array ‪$tca, $expectedLabel = '')
    {
        ‪$GLOBALS['TCA'][$table] = ‪$tca;
 
        self::assertEquals($expectedLabel, ‪LabelFromItemListMergedReturnsCorrectFieldsFixture::getLabelFromItemListMerged($pageId, $table, $column, $key));
    }
 
    public function ‪getFuncCheckReturnsInputTagWithValueAttribute()
    {
        self::assertStringMatchesFormat('<input %Svalue="1"%S/>', ‪BackendUtility::getFuncCheck('params', 'test', true));
    }
 
    /*
     * Tests concerning getLabelsFromItemsList
     */
 
    public function ‪getLabelsFromItemsListDataProvider()
    {
        return [
            'return value if found' => [
                'foobar', // table
                'someColumn', // col
                'foo, bar', // keyList
                [ // TCA
                    'columns' => [
                        'someColumn' => [
                            'config' => [
                                'items' => [
                                    '0' => ['aFooLabel', 'foo'],
                                    '1' => ['aBarLabel', 'bar']
                                ]
                            ]
                        ]
                    ]
                ],
                [], // page TSconfig
                'aFooLabel, aBarLabel' // expected
            ],
            'page TSconfig overrules TCA' => [
                'foobar', // table
                'someColumn', // col
                'foo,bar, add', // keyList
                [ // TCA
                    'columns' => [
                        'someColumn' => [
                            'config' => [
                                'items' => [
                                    '0' => ['aFooLabel', 'foo'],
                                    '1' => ['aBarLabel', 'bar']
                                ]
                            ]
                        ]
                    ]
                ],
                [ // page TSconfig
                    'addItems.' => ['add' => 'aNewLabel'],
                    'altLabels.' => ['bar' => 'aBarDiffLabel'],
                ],
                'aFooLabel, aBarDiffLabel, aNewLabel' // expected
            ]
        ];
    }
 
    public function ‪getLabelsFromItemsListReturnsCorrectValue($table, $col, $keyList, ‪$tca, array $pageTsConfig, $expectedLabel)
    {
        // Stub LanguageService and let sL() return the same value that came in again
        ‪$GLOBALS['LANG'] = $this->createMock(LanguageService::class);
        ‪$GLOBALS['LANG']->expects(self::any())->method('sL')->willReturnArgument(0);
 
        ‪$GLOBALS['TCA'][$table] = ‪$tca;
        $label = ‪BackendUtility::getLabelsFromItemsList($table, $col, $keyList, $pageTsConfig);
        self::assertEquals($expectedLabel, $label);
    }
 
    public function ‪getProcessedValueReturnsLabelsForExistingValuesSolely()
    {
        $table = 'foobar';
        $col = 'someColumn';
        ‪$tca = [
            'columns' => [
                'someColumn' => [
                    'config' => [
                        'type' => 'select',
                        'items' => [
                            '0' => ['aFooLabel', 'foo'],
                            '1' => ['aBarLabel', 'bar']
                        ]
                    ]
                ]
            ]
        ];
        // Stub LanguageService and let sL() return the same value that came in again
        ‪$GLOBALS['LANG'] = $this->createMock(LanguageService::class);
        ‪$GLOBALS['LANG']->expects(self::any())->method('sL')->willReturnArgument(0);
 
        ‪$GLOBALS['TCA'][$table] = ‪$tca;
        $label = ‪BackendUtility::getProcessedValue($table, $col, 'foo,invalidKey,bar');
        self::assertEquals('aFooLabel, aBarLabel', $label);
    }
 
    public function ‪getProcessedValueReturnsPlainValueIfItemIsNotFound()
    {
        $table = 'foobar';
        $col = 'someColumn';
        ‪$tca = [
            'columns' => [
                'someColumn' => [
                    'config' => [
                        'type' => 'select',
                        'items' => [
                            '0' => ['aFooLabel', 'foo']
                        ]
                    ]
                ]
            ]
        ];
        // Stub LanguageService and let sL() return the same value that came in again
        ‪$GLOBALS['LANG'] = $this->createMock(LanguageService::class);
        ‪$GLOBALS['LANG']->expects(self::any())->method('sL')->willReturnArgument(0);
 
        ‪$GLOBALS['TCA'][$table] = ‪$tca;
        $label = ‪BackendUtility::getProcessedValue($table, $col, 'invalidKey');
        self::assertEquals('invalidKey', $label);
    }
 
    public function ‪viewOnClickReturnsOnClickCodeWithAlternativeUrl()
    {
        // Make sure the hook inside viewOnClick is not fired. This may be removed if unit tests
        // bootstrap does not initialize TYPO3_CONF_VARS anymore.
        unset(‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_befunc.php']['viewOnClickClass']);
 
        $alternativeUrl = 'https://typo3.org/about/typo3-the-cms/the-history-of-typo3/#section';
        $onclickCode = 'var previewWin = window.open(' . GeneralUtility::quoteJSvalue($alternativeUrl) . ',\'newTYPO3frontendWindow\');' . LF
            . 'if (previewWin.location.href === ' . GeneralUtility::quoteJSvalue($alternativeUrl) . ') { previewWin.location.reload(); };';
        self::assertStringMatchesFormat(
            $onclickCode,
            ‪BackendUtility::viewOnClick(null, null, null, null, $alternativeUrl, null, false)
        );
    }
 
    public function ‪dateTimeAgeReturnsCorrectValues()
    {
        $languageServiceProphecy = $this->prophesize(LanguageService::class);
        $languageServiceProphecy->sL(Argument::cetera())->willReturn(' min| hrs| days| yrs| min| hour| day| year');
        ‪$GLOBALS['LANG'] = $languageServiceProphecy->reveal();
        ‪$GLOBALS['EXEC_TIME'] = mktime(0, 0, 0, 3, 23, 2016);
 
        self::assertSame('24-03-16 00:00 (-1 day)', ‪BackendUtility::dateTimeAge(‪$GLOBALS['EXEC_TIME'] + 86400));
        self::assertSame('24-03-16 (-1 day)', ‪BackendUtility::dateTimeAge(‪$GLOBALS['EXEC_TIME'] + 86400, 1, 'date'));
    }
 
    public function ‪purgeComputedPropertyNamesRemovesPropertiesStartingWithUnderscore()
    {
        $propertyNames = [
            'uid',
            'pid',
            '_ORIG_PID'
        ];
        $computedPropertyNames = ‪BackendUtility::purgeComputedPropertyNames($propertyNames);
        self::assertSame(['uid', 'pid'], $computedPropertyNames);
    }
 
    public function ‪purgeComputedPropertiesFromRecordRemovesPropertiesStartingWithUnderscore()
    {
        $record = [
            'uid'       => 1,
            'pid'       => 2,
            '_ORIG_PID' => 1
        ];
        $expected = [
            'uid' => 1,
            'pid' => 2
        ];
        $computedProperties = ‪BackendUtility::purgeComputedPropertiesFromRecord($record);
        self::assertSame($expected, $computedProperties);
    }
 
    public function ‪splitTableUidDataProvider()
    {
        return [
            'simple' => [
                'pages_23',
                ['pages', '23']
            ],
            'complex' => [
                'tt_content_13',
                ['tt_content', '13']
            ],
            'multiple underscores' => [
                'tx_runaway_domain_model_crime_scene_1234',
                ['tx_runaway_domain_model_crime_scene', '1234']
            ]
        ];
    }
 
    public function ‪splitTableUid($input, $expected)
    {
        $result = ‪BackendUtility::splitTable_Uid($input);
        self::assertSame($expected, $result);
    }
 
    public function ‪getPagesTSconfigWorksWithoutInitializedBackendUser()
    {
        $expected = ['called.' => ['config']];
        $pageId = 13;
        $eventDispatcherProphecy = $this->prophesize(EventDispatcherInterface::class);
        $eventDispatcherProphecy->dispatch(Argument::any())->willReturn(new ModifyLoadedPageTsConfigEvent([], []));
        $loader = new PageTsConfigLoader($eventDispatcherProphecy->reveal());
        GeneralUtility::addInstance(PageTsConfigLoader::class, $loader);
        $parserProphecy = $this->prophesize(PageTsConfigParser::class);
        $parserProphecy->parse(Argument::cetera())->willReturn($expected);
        GeneralUtility::addInstance(PageTsConfigParser::class, $parserProphecy->reveal());
 
        $matcherProphecy = $this->prophesize(ConditionMatcher::class);
        GeneralUtility::addInstance(ConditionMatcher::class, $matcherProphecy->reveal());
 
        $siteFinder = $this->prophesize(SiteFinder::class);
        $siteFinder->getSiteByPageId($pageId)->willReturn(
            new Site('dummy', $pageId, ['base' => 'https://example.com'])
        );
        GeneralUtility::addInstance(SiteFinder::class, $siteFinder->reveal());
 
        $cacheManagerProphecy = $this->prophesize(CacheManager::class);
        $cacheProphecy = $this->prophesize(FrontendInterface::class);
        $cacheManagerProphecy->getCache('runtime')->willReturn($cacheProphecy->reveal());
        $cacheHashProphecy = $this->prophesize(FrontendInterface::class);
        $cacheManagerProphecy->getCache('hash')->willReturn($cacheHashProphecy->reveal());
        $cacheProphecy->has(Argument::cetera())->willReturn(false);
        $cacheProphecy->get(Argument::cetera())->willReturn(false);
        $cacheProphecy->set(Argument::cetera())->willReturn(false);
        $cacheProphecy->get('backendUtilityBeGetRootLine')->willReturn(['13--1' => []]);
        GeneralUtility::setSingletonInstance(CacheManager::class, $cacheManagerProphecy->reveal());
 
        $result = ‪BackendUtility::getPagesTSconfig($pageId);
        self::assertEquals($expected, $result);
    }
 
    public function ‪returnNullForMissingTcaConfigInResolveFileReferences()
    {
        $tableName = 'table_a';
        $fieldName = 'field_a';
        ‪$GLOBALS['TCA'][$tableName]['columns'][$fieldName]['config'] = [];
        self::assertNull(‪BackendUtility::resolveFileReferences($tableName, $fieldName, []));
    }
 
    public function ‪fixVersioningPidDoesNotChangeValuesForNoBeUserAvailable()
    {
        ‪$GLOBALS['BE_USER'] = null;
        $tableName = 'table_a';
        ‪$GLOBALS['TCA'][$tableName]['ctrl']['versioningWS'] = 'not_empty';
        $rr = [
            'pid' => -1,
            't3ver_oid' => 7,
            't3ver_wsid' => 42,
            't3ver_state' => 0
        ];
        $reference = $rr;
        ‪BackendUtility::fixVersioningPid($tableName, $rr);
        self::assertSame($reference, $rr);
    }
 
    public function ‪returnNullForUnfitTableConfigInResolveFileReferences(array $config)
    {
        $tableName = 'table_a';
        $fieldName = 'field_a';
        ‪$GLOBALS['TCA'][$tableName]['columns'][$fieldName]['config'] = $config;
        self::assertNull(‪BackendUtility::resolveFileReferences($tableName, $fieldName, []));
    }
 
    public function ‪unfitResolveFileReferencesTableConfig(): array
    {
        return [
            'invalid table' => [
                [
                    'type' => 'inline',
                    'foreign_table' => 'table_b',
                ],
            ],
            'empty table' => [
                [
                    'type' => 'inline',
                    'foreign_table' => '',
                ],
            ],
            'invalid type' => [
                [
                    'type' => 'select',
                    'foreign_table' => 'sys_file_reference',
                ],
            ],
            'empty type' => [
                [
                    'type' => '',
                    'foreign_table' => 'sys_file_reference',
                ],
            ],
            'empty' => [
                [
                    'type' => '',
                    'foreign_table' => '',
                ],
            ],
        ];
    }
 
    public function ‪workspaceOLDoesNotChangeValuesForNoBeUserAvailable()
    {
        ‪$GLOBALS['BE_USER'] = null;
        $tableName = 'table_a';
        $row = [
            'uid' => 1,
            'pid' => 17,
        ];
        $reference = $row;
        ‪BackendUtility::workspaceOL($tableName, $row);
        self::assertSame($reference, $row);
    }
 
    public function ‪versioningPlaceholderClauseReturnsEmptyIfNoBeUserIsAvailable()
    {
        ‪$GLOBALS['BE_USER'] = null;
        $tableName = 'table_a';
        ‪$GLOBALS['TCA'][$tableName]['ctrl']['versioningWS'] = 'not_empty';
        self::assertSame('', ‪BackendUtility::versioningPlaceholderClause($tableName));
    }
 
    public function ‪resolveFileReferencesReturnsEmptyResultForNoReferencesAvailable()
    {
        $tableName = 'table_a';
        $fieldName = 'field_a';
        $relationHandler = $this->prophesize(RelationHandler::class);
        $relationHandler->start(
            'foo',
            'sys_file_reference',
            '',
            42,
            $tableName,
            ['type' => 'inline', 'foreign_table' => 'sys_file_reference']
        )->shouldBeCalled();
        $relationHandler->tableArray = ['sys_file_reference' => []];
        $relationHandler->processDeletePlaceholder()->shouldBeCalled();
        GeneralUtility::addInstance(RelationHandler::class, $relationHandler->reveal());
        ‪$GLOBALS['TCA'][$tableName]['columns'][$fieldName]['config'] = [
            'type' => 'inline',
            'foreign_table' => 'sys_file_reference',
        ];
        $elementData = [
            $fieldName => 'foo',
            'uid' => 42,
        ];
 
        self::assertEmpty(‪BackendUtility::resolveFileReferences($tableName, $fieldName, $elementData));
    }
 
    public function ‪getWorkspaceWhereClauseReturnsEmptyIfNoBeUserIsAvailable()
    {
        ‪$GLOBALS['BE_USER'] = null;
        $tableName = 'table_a';
        ‪$GLOBALS['TCA'][$tableName]['ctrl']['versioningWS'] = 'not_empty';
        self::assertSame('', ‪BackendUtility::getWorkspaceWhereClause($tableName));
    }
 
    public function ‪wsMapIdReturnsLiveIdIfNoBeUserIsAvailable()
    {
        ‪$GLOBALS['BE_USER'] = null;
        $tableName = 'table_a';
        $uid = 42;
        self::assertSame(42, ‪BackendUtility::wsMapId($tableName, $uid));
    }
 
    public function ‪getMovePlaceholderReturnsFalseIfNoBeUserIsAvailable()
    {
        ‪$GLOBALS['BE_USER'] = null;
        $tableName = 'table_a';
        self::assertFalse(‪BackendUtility::getMovePlaceholder($tableName, 42));
    }
}