SiteBasedTestTrait.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\Functional\SiteHandling;
 
use Psr\EventDispatcher\EventDispatcherInterface;
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 = []
    ): void {
        $configuration = $site;
        if (!empty(‪$languages)) {
            $configuration['languages'] = ‪$languages;
        }
        if (!empty($errorHandling)) {
            $configuration['errorHandling'] = $errorHandling;
        }
        $siteConfiguration = new ‪SiteConfiguration(
            $this->instancePath . '/typo3conf/sites/',
            $this->get(EventDispatcherInterface::class),
            $this->get('cache.core')
        );
 
        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
    ): void {
        $siteConfiguration = new ‪SiteConfiguration(
            $this->instancePath . '/typo3conf/sites/',
            $this->get(EventDispatcherInterface::class),
            $this->get('cache.core')
        );
        $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['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'],
            'websiteTitle' => $preset['websiteTitle'] ?? '',
            'base' => $base,
            'locale' => $preset['locale'],
            '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') {
            // This implies you cannot test both 404 and 403 in the same test.
            // Fixing that requires much deeper changes to the testing harness,
            // as the structure here is only a portion of the config array structure.
            if (in_array(404, $codes, true)) {
                $baseConfiguration = [
                    'errorContentSource' => 't3://page?uid=404',
                ];
            } elseif (in_array(403, $codes, true)) {
                $baseConfiguration = [
                    'errorContentSource' => 't3://page?uid=403',
                ];
            }
        } 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(
            static 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;
    }
}