9.5/_site_based_test_trait_8php_source.html

<?php

declare(strict_types = 1);

namespace ‪TYPO3\CMS\Core\Tests\Functional\SiteHandling;


/*

 * 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\Configuration\SiteConfiguration;

use ‪TYPO3\CMS\Core\Tests\Functional\Fixtures\Frontend\PhpError;

use ‪TYPO3\CMS\Core\Utility\GeneralUtility;

use TYPO3\TestingFramework\Core\Functional\Framework\Frontend\Internal\AbstractInstruction;

use TYPO3\TestingFramework\Core\Functional\Framework\Frontend\Internal\ArrayValueInstruction;

use TYPO3\TestingFramework\Core\Functional\Framework\Frontend\Internal\TypoScriptInstruction;

use TYPO3\TestingFramework\Core\Functional\Framework\Frontend\InternalRequest;


trait ‪SiteBasedTestTrait

{

    protected static function ‪failIfArrayIsNotEmpty(array $items): void

    {

        if (empty($items)) {

            return;

        }


        static::fail(

            'Array was not empty as expected, but contained these items:' . LF

            . '* ' . implode(LF . '* ', $items)

        );

    }


    protected function ‪writeSiteConfiguration(

        string $identifier,

        array $site = [],

        array $languages = [],

        array $errorHandling = []

    ) {

        $configuration = $site;

        if (!empty($languages)) {

            $configuration['languages'] = $languages;

        }

        if (!empty($errorHandling)) {

            $configuration['errorHandling'] = $errorHandling;

        }

        $siteConfiguration = new ‪SiteConfiguration(

            $this->instancePath . '/typo3conf/sites/'

        );


        try {

            // ensure no previous site configuration influences the test

            GeneralUtility::rmdir($this->instancePath . '/typo3conf/sites/' . $identifier, true);

            $siteConfiguration->write($identifier, $configuration);

        } catch (\‪Exception $exception) {

            $this->markTestSkipped($exception->getMessage());

        }

    }


    protected function ‪mergeSiteConfiguration(

        string $identifier,

        array $overrides

    ) {

        $siteConfiguration = new ‪SiteConfiguration(

            $this->instancePath . '/typo3conf/sites/'

        );

        $configuration = $siteConfiguration->load($identifier);

        $configuration = array_merge($configuration, $overrides);

        try {

            $siteConfiguration->write($identifier, $configuration);

        } catch (\‪Exception $exception) {

            $this->markTestSkipped($exception->getMessage());

        }

    }


    protected function ‪buildSiteConfiguration(

        int $rootPageId,

        string $base = ''

    ): array {

        return [

            'rootPageId' => $rootPageId,

            'base' => $base,

        ];

    }


    protected function ‪buildDefaultLanguageConfiguration(

        string $identifier,

        string $base

    ): array {

        $configuration = $this->buildLanguageConfiguration($identifier, $base);

        $configuration['typo3Language'] = 'default';

        $configuration['flag'] = 'global';

        unset($configuration['fallbackType'], $configuration['fallbacks']);

        return $configuration;

    }


    protected function ‪buildLanguageConfiguration(

        string $identifier,

        string $base,

        array $fallbackIdentifiers = [],

        string $fallbackType = null

    ): array {

        $preset = $this->resolveLanguagePreset($identifier);


        $configuration = [

            'languageId' => $preset['id'],

            'title' => $preset['title'],

            'navigationTitle' => $preset['title'],

            'base' => $base,

            'locale' => $preset['locale'],

            'iso-639-1' => $preset['iso'],

            'hreflang' => $preset['hrefLang'],

            'direction' => $preset['direction'],

            'typo3Language' => $preset['iso'],

            'flag' => $preset['iso'],

            'fallbackType' => $fallbackType ?? (empty($fallbackIdentifiers) ? 'strict' : 'fallback'),

        ];


        if (!empty($fallbackIdentifiers)) {

            $fallbackIds = array_map(

                function (string $fallbackIdentifier) {

                    $preset = $this->resolveLanguagePreset($fallbackIdentifier);

                    return $preset['id'];

                },

                $fallbackIdentifiers

            );

            $configuration['fallbackType'] = $fallbackType ?? 'fallback';

            $configuration['fallbacks'] = implode(',', $fallbackIds);

        }


        return $configuration;

    }


    protected function ‪buildErrorHandlingConfiguration(

        string $handler,

        array $codes

    ): array {

        if ($handler === 'Page') {

            $baseConfiguration = [

                'errorContentSource' => '404',

            ];

        } elseif ($handler === 'Fluid') {

            $baseConfiguration = [

                'errorFluidTemplate' => 'typo3/sysext/core/Tests/Functional/Fixtures/Frontend/FluidError.html',

                'errorFluidTemplatesRootPath' => '',

                'errorFluidLayoutsRootPath' => '',

                'errorFluidPartialsRootPath' => '',

            ];

        } elseif ($handler === 'PHP') {

            $baseConfiguration = [

                'errorPhpClassFQCN' => PhpError::class,

            ];

        } else {

            throw new \LogicException(

                sprintf('Invalid handler "%s"', $handler),

                1533894782

            );

        }


        $baseConfiguration['errorHandler'] = $handler;


        return array_map(

            function (int $code) use ($baseConfiguration) {

                $baseConfiguration['errorCode'] = $code;

                return $baseConfiguration;

            },

            $codes

        );

    }


    protected function ‪resolveLanguagePreset(string $identifier)

    {

        if (!isset(static::LANGUAGE_PRESETS[$identifier])) {

            throw new \LogicException(

                sprintf('Undefined preset identifier "%s"', $identifier),

                1533893665

            );

        }

        return static::LANGUAGE_PRESETS[$identifier];

    }


    protected function ‪applyInstructions(InternalRequest $request, AbstractInstruction ...$instructions): InternalRequest

    {

        $modifiedInstructions = [];


        foreach ($instructions as $instruction) {

            $identifier = $instruction->getIdentifier();

            if (isset($modifiedInstructions[$identifier]) || $request->getInstruction($identifier) !== null) {

                $modifiedInstructions[$identifier] = $this->mergeInstruction(

                    $modifiedInstructions[$identifier] ?? $request->getInstruction($identifier),

                    $instruction

                );

            } else {

                $modifiedInstructions[$identifier] = $instruction;

            }

        }


        return $request->withInstructions($modifiedInstructions);

    }


    protected function ‪mergeInstruction(AbstractInstruction $current, AbstractInstruction $other): AbstractInstruction

    {

        if (get_class($current) !== get_class($other)) {

            throw new \LogicException('Cannot merge different instruction types', 1565863174);

        }


        if ($current instanceof TypoScriptInstruction) {

            $typoScript = array_replace_recursive(

                $current->getTypoScript() ?? [],

                $other->getTypoScript() ?? []

            );

            $constants = array_replace_recursive(

                $current->getConstants() ?? [],

                $other->getConstants() ?? []

            );

            if ($typoScript !== []) {

                $current = $current->withTypoScript($typoScript);

            }

            if ($constants !== []) {

                $current = $current->withConstants($constants);

            }

            return $current;

        }


        if ($current instanceof ArrayValueInstruction) {

            $array = array_merge_recursive($current->getArray(), $other->getArray());

            return $current->withArray($array);

        }


        return $current;

    }

}