ResolverTest.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
/*
 * 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\Core\Tests\Unit\ExpressionLanguage;
 
use Prophecy\Argument;
use Prophecy\PhpUnit\ProphecyTrait;
use Symfony\Component\ExpressionLanguage\ExpressionFunction;
use ‪TYPO3\CMS\Core\Cache\Frontend\PhpFrontend;
use ‪TYPO3\CMS\Core\ExpressionLanguage\DefaultProvider;
use ‪TYPO3\CMS\Core\ExpressionLanguage\FunctionsProvider\DefaultFunctionsProvider;
use ‪TYPO3\CMS\Core\ExpressionLanguage\ProviderConfigurationLoader;
use ‪TYPO3\CMS\Core\ExpressionLanguage\Resolver;
use ‪TYPO3\CMS\Core\Package\PackageInterface;
use TYPO3\CMS\Core\Package\PackageManager;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\TestingFramework\Core\Unit\UnitTestCase;
 
class ‪ResolverTest extends UnitTestCase
{
    use ProphecyTrait;
 
    public function ‪setUp(): void
    {
        parent::setUp();
 
        $cacheFrontendProphecy = $this->prophesize(PhpFrontend::class);
        $cacheFrontendProphecy->require(Argument::any())->willReturn(false);
        $cacheFrontendProphecy->set(Argument::any(), Argument::any())->willReturn(null);
 
        $packageManagerProphecy = $this->prophesize(PackageManager::class);
        $corePackageProphecy = $this->prophesize(PackageInterface::class);
        $corePackageProphecy->getPackagePath()->willReturn(__DIR__ . '/../../../../../../../sysext/core/');
        $packageManagerProphecy->getActivePackages()->willReturn([
            $corePackageProphecy->reveal(),
        ]);
 
        GeneralUtility::addInstance(ProviderConfigurationLoader::class, new ‪ProviderConfigurationLoader(
            $packageManagerProphecy->reveal(),
            $cacheFrontendProphecy->reveal(),
            'ExpressionLanguageProviders'
        ));
    }
 
    public function ‪basicExpressionsDataHandler(): array
    {
        return [
            '1+1' => ['1+1', true],
            '1 < 2' => ['1 < 2', true],
            '2 < 1' => ['2 < 1', false],
            'true' => ['true', true],
            'false' => ['false', false],
            'true != false' => ['true != false', true],
            'true < false' => ['true < false', false],
        ];
    }
 
    public function ‪basicExpressionHandlingResultsWorksAsExpected(string $expression, $expectedResult): void
    {
        $expressionLanguageResolver = new Resolver('default', []);
        self::assertSame($expectedResult, $expressionLanguageResolver->evaluate($expression));
    }
 
    public function ‪basicExpressionsWithVariablesDataHandler(): array
    {
        return [
            'var1 + var2' => ['var1 + var2', true],
            'var1 < var2' => ['var1 < var2', true],
            'var2 < var1' => ['var2 < var1', false],
            'varTrue' => ['varTrue', true],
            'varFalse' => ['varFalse', false],
            'varTrue != varFalse' => ['varTrue != varFalse', true],
            'varTrue < varFalse' => ['varTrue < varFalse', false],
        ];
    }
 
    public function ‪basicExpressionHandlingWithCustomVariablesWorksAsExpected(string $expression, $expectedResult): void
    {
        $contextProphecy = $this->prophesize(DefaultProvider::class);
        $contextProphecy->getExpressionLanguageProviders()->willReturn([]);
        $contextProphecy->getExpressionLanguageVariables()->willReturn([
            'var1' => '1',
            'var2' => '2',
            'varTrue' => true,
            'varFalse' => false,
        ]);
        GeneralUtility::addInstance(DefaultProvider::class, $contextProphecy->reveal());
        $expressionLanguageResolver = new Resolver('default', []);
        self::assertSame($expectedResult, $expressionLanguageResolver->evaluate($expression));
    }
 
    public function ‪basicExpressionsWithVariablesAndExpressionLanguageProviderDataHandler(): array
    {
        return [
            'testMeLowercase(var1) == var2' => ['testMeLowercase(var1) == var2', true],
            'testMeLowercase(var2) == var1' => ['testMeLowercase(var2) == var1', false],
            'testMeLowercase(var1) == var1' => ['testMeLowercase(var1) == var1', false],
            'testMeLowercase(var2) == var2' => ['testMeLowercase(var2) == var2', true],
        ];
    }
 
    public function ‪basicExpressionHandlingWithCustomVariablesAndExpressionLanguageProviderWorksAsExpected(string $expression, $expectedResult): void
    {
        $expressionProvider = $this->prophesize(DefaultFunctionsProvider::class);
        $expressionProvider->getFunctions()->willReturn([
            new ExpressionFunction('testMeLowercase', static function ($str) {
                return sprintf('(is_string(%1$s) ? strtolower(%1$s) : %1$s)', $str);
            }, static function ($arguments, $str) {
                return is_string($str) ? strtolower($str) : $str;
            }),
        ]);
        $contextProphecy = $this->prophesize(DefaultProvider::class);
        $contextProphecy->getExpressionLanguageProviders()->willReturn([DefaultFunctionsProvider::class]);
        $contextProphecy->getExpressionLanguageVariables()->willReturn([
            'var1' => 'FOO',
            'var2' => 'foo',
        ]);
        GeneralUtility::addInstance(DefaultProvider::class, $contextProphecy->reveal());
        GeneralUtility::addInstance(DefaultFunctionsProvider::class, $expressionProvider->reveal());
        $expressionLanguageResolver = new Resolver('default', []);
        self::assertSame($expectedResult, $expressionLanguageResolver->evaluate($expression));
    }
}