SlugSiteRequestTest.php

Go to the documentation of this file.

<?php
declare(strict_types = 1);
namespace ‪TYPO3\CMS\Frontend\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\Core\Bootstrap;
use ‪TYPO3\CMS\Core\Error\Http\PageNotFoundException;
use ‪TYPO3\CMS\Core\Utility\PermutationUtility;
use TYPO3\TestingFramework\Core\Functional\Framework\DataHandling\Scenario\DataHandlerFactory;
use TYPO3\TestingFramework\Core\Functional\Framework\DataHandling\Scenario\DataHandlerWriter;
use TYPO3\TestingFramework\Core\Functional\Framework\Frontend\InternalRequest;
use TYPO3\TestingFramework\Core\Functional\Framework\Frontend\InternalRequestContext;
use TYPO3\TestingFramework\Core\Functional\Framework\Frontend\ResponseContent;
 
class ‪SlugSiteRequestTest extends ‪AbstractTestCase
{
    private ‪$siteTitle = 'A Company that Manufactures Everything Inc';
 
    private ‪$internalRequestContext;
 
    public static function ‪setUpBeforeClass()
    {
        parent::setUpBeforeClass();
        static::initializeDatabaseSnapshot();
    }
 
    public static function ‪tearDownAfterClass()
    {
        static::destroyDatabaseSnapshot();
        parent::tearDownAfterClass();
    }
 
    protected function ‪setUp()
    {
        parent::setUp();
 
        // these settings are forwarded to the frontend sub-request as well
        $this->internalRequestContext = (new InternalRequestContext())
            ->withGlobalSettings(['TYPO3_CONF_VARS' => static::TYPO3_CONF_VARS]);
 
        $this->withDatabaseSnapshot(function () {
            $this->‪setUpDatabase();
        });
    }
 
    protected function ‪setUpDatabase()
    {
        $backendUser = $this->setUpBackendUserFromFixture(1);
        ‪Bootstrap::initializeLanguageObject();
 
        $scenarioFile = __DIR__ . '/Fixtures/SlugScenario.yaml';
        $factory = DataHandlerFactory::fromYamlFile($scenarioFile);
        $writer = DataHandlerWriter::withBackendUser($backendUser);
        $writer->invokeFactory($factory);
        static::failIfArrayIsNotEmpty(
            $writer->getErrors()
        );
 
        $this->setUpFrontendRootPage(
            1000,
            [
                'typo3/sysext/core/Tests/Functional/Fixtures/Frontend/JsonRenderer.typoscript',
                'typo3/sysext/frontend/Tests/Functional/SiteHandling/Fixtures/JsonRenderer.typoscript',
            ],
            [
                'title' => 'ACME Root',
                'sitetitle' => $this->siteTitle,
            ]
        );
    }
 
    protected function ‪tearDown()
    {
        unset($this->internalRequestContext);
        parent::tearDown();
    }
 
    public function ‪requestsAreRedirectedWithoutHavingDefaultSiteLanguageDataProvider(): array
    {
        $domainPaths = [
            'https://website.local/',
            'https://website.local/?',
            'https://website.local//',
        ];
 
        return $this->wrapInArray(
            $this->keysFromValues($domainPaths)
        );
    }
 
    public function ‪requestsAreRedirectedWithoutHavingDefaultSiteLanguage(string $uri)
    {
        $this->‪writeSiteConfiguration(
            'website-local',
            $this->‪buildSiteConfiguration(1000, 'https://website.local/')
        );
 
        $expectedStatusCode = 307;
        $expectedHeaders = ['location' => ['https://website.local/welcome']];
 
        $response = $this->executeFrontendRequest(
            new InternalRequest($uri),
            $this->internalRequestContext
        );
        static::assertSame($expectedStatusCode, $response->getStatusCode());
        static::assertSame($expectedHeaders, $response->getHeaders());
    }
 
    public function ‪shortcutsAreRedirectedDataProvider(): array
    {
        $domainPaths = [
            'https://website.local/',
            'https://website.local/?',
            'https://website.local//',
        ];
 
        return $this->wrapInArray(
            $this->keysFromValues($domainPaths)
        );
    }
 
    public function ‪shortcutsAreRedirectedToDefaultSiteLanguage(string $uri)
    {
        $this->‪writeSiteConfiguration(
            'website-local',
            $this->‪buildSiteConfiguration(1000, 'https://website.local/'),
            [
                $this->‪buildDefaultLanguageConfiguration('EN', '/en-en/'),
            ]
        );
 
        $expectedStatusCode = 307;
        $expectedHeaders = [
            'location' => ['https://website.local/en-en/'],
        ];
 
        $response = $this->executeFrontendRequest(
            new InternalRequest($uri),
            $this->internalRequestContext
        );
        static::assertSame($expectedStatusCode, $response->getStatusCode());
        static::assertSame($expectedHeaders, $response->getHeaders());
    }
 
    public function ‪shortcutsAreRedirectedAndRenderFirstSubPage(string $uri)
    {
        $this->‪writeSiteConfiguration(
            'website-local',
            $this->‪buildSiteConfiguration(1000, 'https://website.local/'),
            [
                $this->‪buildDefaultLanguageConfiguration('EN', '/en-en/'),
            ]
        );
 
        $expectedStatusCode = 200;
        $expectedPageTitle = 'EN: Welcome';
 
        $response = $this->executeFrontendRequest(
            new InternalRequest($uri),
            $this->internalRequestContext,
            true
        );
        $responseStructure = ResponseContent::fromString(
            (string)$response->getBody()
        );
 
        static::assertSame(
            $expectedStatusCode,
            $response->getStatusCode()
        );
        static::assertSame(
            $this->siteTitle,
            $responseStructure->getScopePath('template/sitetitle')
        );
        static::assertSame(
            $expectedPageTitle,
            $responseStructure->getScopePath('page/title')
        );
    }
 
    public function ‪invalidSiteResultsInNotFoundResponse()
    {
        $this->‪writeSiteConfiguration(
            'website-local',
            $this->‪buildSiteConfiguration(1000, 'https://website.local/'),
            [
                $this->‪buildDefaultLanguageConfiguration('EN', '/en-en/'),
            ],
            $this->‪buildErrorHandlingConfiguration('Fluid', [404])
        );
 
        $expectedStatusCode = 307;
        $expectedHeaders = ['location' => ['https://website.local/en-en/welcome']];
 
        $uri = 'https://website.other/any/invalid/slug';
        $response = $this->executeFrontendRequest(
            new InternalRequest($uri),
            $this->internalRequestContext
        );
 
        static::assertSame(
            $expectedStatusCode,
            $response->getStatusCode()
        );
        static::assertSame(
            $expectedHeaders,
            $response->getHeaders()
        );
        // @todo Expected page not found response (404) instead
        // static::assertContains(
        //     'message: The requested page does not exist',
        //    (string)$response->getBody()
        // );
    }
 
    public function ‪invalidSlugOutsideSiteLanguageResultsInNotFoundResponse()
    {
        $this->‪writeSiteConfiguration(
            'website-local',
            $this->‪buildSiteConfiguration(1000, 'https://website.local/'),
            [
                $this->‪buildDefaultLanguageConfiguration('EN', '/en-en/')
            ],
            $this->‪buildErrorHandlingConfiguration('Fluid', [404])
        );
 
        $uri = 'https://website.local/any/invalid/slug';
        $response = $this->executeFrontendRequest(
            new InternalRequest($uri),
            $this->internalRequestContext
        );
 
        static::assertSame(
            404,
            $response->getStatusCode()
        );
        static::assertStringContainsString(
            'message: The requested page does not exist',
            (string)$response->getBody()
        );
    }
 
    public function ‪invalidSlugInsideSiteLanguageResultsInNotFoundResponse()
    {
        $this->‪writeSiteConfiguration(
            'website-local',
            $this->‪buildSiteConfiguration(1000, 'https://website.local/'),
            [
                $this->‪buildDefaultLanguageConfiguration('EN', '/en-en/')
            ],
            $this->‪buildErrorHandlingConfiguration('Fluid', [404])
        );
 
        $uri = 'https://website.local/en-en/any/invalid/slug';
        $response = $this->executeFrontendRequest(
            new InternalRequest($uri),
            $this->internalRequestContext
        );
 
        static::assertSame(
            404,
            $response->getStatusCode()
        );
        static::assertContains(
            'message: The requested page does not exist',
            (string)$response->getBody()
        );
    }
 
    public function ‪unconfiguredTypeNumResultsIn404Error()
    {
        $this->‪writeSiteConfiguration(
            'website-local',
            $this->‪buildSiteConfiguration(1000, 'https://website.local/'),
            [
                $this->‪buildDefaultLanguageConfiguration('EN', '/en-en/')
            ],
            $this->‪buildErrorHandlingConfiguration('Fluid', [404])
        );
 
        $uri = 'https://website.local/en-en/?type=13';
        $response = $this->executeFrontendRequest(
            new InternalRequest($uri),
            $this->internalRequestContext
        );
 
        self::assertSame(
            404,
            $response->getStatusCode()
        );
        self::assertStringContainsString(
            'message: The page is not configured',
            (string)$response->getBody()
        );
    }
 
    public function ‪pageIsRenderedWithPathsDataProvider(): array
    {
        $domainPaths = [
            'https://website.local/en-en/welcome',
            'https://website.local/fr-fr/bienvenue',
            'https://website.local/fr-ca/bienvenue',
        ];
 
        return array_map(
            function (string $uri) {
                if (strpos($uri, '/fr-fr/') !== false) {
                    $expectedPageTitle = 'FR: Welcome';
                } elseif (strpos($uri, '/fr-ca/') !== false) {
                    $expectedPageTitle = 'FR-CA: Welcome';
                } else {
                    $expectedPageTitle = 'EN: Welcome';
                }
                return [$uri, $expectedPageTitle];
            },
            $this->keysFromValues($domainPaths)
        );
    }
 
    public function ‪pageIsRenderedWithPaths(string $uri, string $expectedPageTitle)
    {
        $this->‪writeSiteConfiguration(
            'website-local',
            $this->‪buildSiteConfiguration(1000, 'https://website.local/'),
            [
                $this->‪buildDefaultLanguageConfiguration('EN', '/en-en/'),
                $this->‪buildLanguageConfiguration('FR', '/fr-fr/', ['EN']),
                $this->‪buildLanguageConfiguration('FR-CA', '/fr-ca/', ['FR', 'EN']),
            ]
        );
 
        $response = $this->executeFrontendRequest(
            new InternalRequest($uri),
            $this->internalRequestContext
        );
        $responseStructure = ResponseContent::fromString(
            (string)$response->getBody()
        );
 
        static::assertSame(
            200,
            $response->getStatusCode()
        );
        static::assertSame(
            $this->siteTitle,
            $responseStructure->getScopePath('template/sitetitle')
        );
        static::assertSame(
            $expectedPageTitle,
            $responseStructure->getScopePath('page/title')
        );
    }
 
    public function ‪pageIsRenderedWithDomainsDataProvider(): array
    {
        $domainPaths = [
            'https://website.us/welcome',
            'https://website.fr/bienvenue',
            'https://website.ca/bienvenue',
        ];
 
        return array_map(
            function (string $uri) {
                if (strpos($uri, '.fr/') !== false) {
                    $expectedPageTitle = 'FR: Welcome';
                } elseif (strpos($uri, '.ca/') !== false) {
                    $expectedPageTitle = 'FR-CA: Welcome';
                } else {
                    $expectedPageTitle = 'EN: Welcome';
                }
                return [$uri, $expectedPageTitle];
            },
            $this->keysFromValues($domainPaths)
        );
    }
 
    public function ‪pageIsRenderedWithDomains(string $uri, string $expectedPageTitle)
    {
        $this->‪writeSiteConfiguration(
            'website-local',
            $this->‪buildSiteConfiguration(1000, 'https://website.local/'),
            [
                $this->‪buildDefaultLanguageConfiguration('EN', 'https://website.us/'),
                $this->‪buildLanguageConfiguration('FR', 'https://website.fr/', ['EN']),
                $this->‪buildLanguageConfiguration('FR-CA', 'https://website.ca/', ['FR', 'EN']),
            ]
        );
 
        $response = $this->executeFrontendRequest(
            new InternalRequest($uri),
            $this->internalRequestContext
        );
        $responseStructure = ResponseContent::fromString(
            (string)$response->getBody()
        );
 
        static::assertSame(
            200,
            $response->getStatusCode()
        );
        static::assertSame(
            $this->siteTitle,
            $responseStructure->getScopePath('template/sitetitle')
        );
        static::assertSame(
            $expectedPageTitle,
            $responseStructure->getScopePath('page/title')
        );
    }
 
    public function ‪restrictedPageIsRenderedDataProvider(): array
    {
        $instructions = [
            // frontend user 1
            ['https://website.local/my-acme/whitepapers', 1, 'Whitepapers'],
            ['https://website.local/my-acme/whitepapers/products', 1, 'Products'],
            ['https://website.local/my-acme/whitepapers/solutions', 1, 'Solutions'],
            // frontend user 2
            ['https://website.local/my-acme/whitepapers', 2, 'Whitepapers'],
            ['https://website.local/my-acme/whitepapers/products', 2, 'Products'],
            ['https://website.local/my-acme/whitepapers/research', 2, 'Research'],
            ['https://website.local/my-acme/forecasts', 2, 'Forecasts'],
            ['https://website.local/my-acme/forecasts/current-year', 2, 'Current Year'],
            // frontend user 3
            ['https://website.local/my-acme/whitepapers', 3, 'Whitepapers'],
            ['https://website.local/my-acme/whitepapers/products', 3, 'Products'],
            ['https://website.local/my-acme/whitepapers/solutions', 3, 'Solutions'],
            ['https://website.local/my-acme/whitepapers/research', 3, 'Research'],
            ['https://website.local/my-acme/forecasts', 3, 'Forecasts'],
            ['https://website.local/my-acme/forecasts/current-year', 3, 'Current Year'],
        ];
 
        return $this->keysFromTemplate($instructions, '%1$s (user:%2$s)');
    }
 
    public function ‪restrictedPageIsRendered(string $uri, int $frontendUserId, string $expectedPageTitle)
    {
        $this->‪writeSiteConfiguration(
            'website-local',
            $this->‪buildSiteConfiguration(1000, 'https://website.local/')
        );
 
        $response = $this->executeFrontendRequest(
            new InternalRequest($uri),
            $this->internalRequestContext
                ->withFrontendUserId($frontendUserId)
        );
        $responseStructure = ResponseContent::fromString(
            (string)$response->getBody()
        );
 
        static::assertSame(
            200,
            $response->getStatusCode()
        );
        static::assertSame(
            $this->siteTitle,
            $responseStructure->getScopePath('template/sitetitle')
        );
        static::assertSame(
            $expectedPageTitle,
            $responseStructure->getScopePath('page/title')
        );
    }
 
    public function ‪restrictedPageSendsForbiddenResponseWithUnauthorizedVisitorDataProvider(): array
    {
        $instructions = [
            // no frontend user given
            ['https://website.local/my-acme/whitepapers', 0],
            // ['https://website.local/my-acme/whitepapers/products', 0], // @todo extendToSubpages currently missing
            ['https://website.local/my-acme/whitepapers/solutions', 0],
            ['https://website.local/my-acme/whitepapers/research', 0],
            ['https://website.local/my-acme/forecasts', 0],
            // ['https://website.local/my-acme/forecasts/current-year', 0], // @todo extendToSubpages currently missing
            // frontend user 1
            ['https://website.local/my-acme/whitepapers/research', 1],
            ['https://website.local/my-acme/forecasts', 1],
            // ['https://website.local/my-acme/forecasts/current-year', 1], // @todo extendToSubpages currently missing
            // frontend user 2
            ['https://website.local/my-acme/whitepapers/solutions', 2],
        ];
 
        return $this->keysFromTemplate($instructions, '%1$s (user:%2$s)');
    }
 
    public function ‪restrictedPageSendsForbiddenResponseWithUnauthorizedVisitorWithoutHavingErrorHandling(string $uri, int $frontendUserId)
    {
        $this->‪writeSiteConfiguration(
            'website-local',
            $this->‪buildSiteConfiguration(1000, 'https://website.local/')
        );
 
        $response = $this->executeFrontendRequest(
            new InternalRequest($uri),
            $this->internalRequestContext
                ->withFrontendUserId($frontendUserId)
        );
 
        static::assertSame(
            403,
            $response->getStatusCode()
        );
        static::assertThat(
            (string)$response->getBody(),
            static::logicalOr(
                static::stringContains('Reason: ID was not an accessible page'),
                static::stringContains('Reason: Subsection was found and not accessible')
            )
        );
    }
 
    public function ‪restrictedPageSendsForbiddenResponseWithUnauthorizedVisitorWithHavingFluidErrorHandling(string $uri, int $frontendUserId)
    {
        $this->‪writeSiteConfiguration(
            'website-local',
            $this->‪buildSiteConfiguration(1000, 'https://website.local/'),
            [],
            $this->‪buildErrorHandlingConfiguration('Fluid', [403])
        );
 
        $response = $this->executeFrontendRequest(
            new InternalRequest($uri),
            $this->internalRequestContext
                ->withFrontendUserId($frontendUserId)
        );
 
        static::assertSame(
            403,
            $response->getStatusCode()
        );
        static::assertContains(
            'reasons: code,fe_group',
            (string)$response->getBody()
        );
        static::assertThat(
            (string)$response->getBody(),
            static::logicalOr(
                static::stringContains('message: ID was not an accessible page'),
                static::stringContains('message: Subsection was found and not accessible')
            )
        );
    }
 
    public function ‪restrictedPageSendsForbiddenResponseWithUnauthorizedVisitorWithHavingPageErrorHandling(string $uri, int $frontendUserId)
    {
        $this->markTestSkipped('Skipped until PageContentErrorHandler::handlePageError does not use HTTP anymore');
 
        $this->‪writeSiteConfiguration(
            'website-local',
            $this->‪buildSiteConfiguration(1000, 'https://website.local/'),
            [],
            $this->‪buildErrorHandlingConfiguration('Page', [403])
        );
 
        $response = $this->executeFrontendRequest(
            new InternalRequest($uri),
            $this->internalRequestContext
                ->withFrontendUserId($frontendUserId)
        );
 
        static::assertSame(
            403,
            $response->getStatusCode()
        );
    }
 
    public function ‪restrictedPageSendsForbiddenResponseWithUnauthorizedVisitorWithHavingPhpErrorHandling(string $uri, int $frontendUserId)
    {
        $this->‪writeSiteConfiguration(
            'website-local',
            $this->‪buildSiteConfiguration(1000, 'https://website.local/'),
            [],
            $this->‪buildErrorHandlingConfiguration('PHP', [403])
        );
 
        $response = $this->executeFrontendRequest(
            new InternalRequest($uri),
            $this->internalRequestContext
                ->withFrontendUserId($frontendUserId)
        );
        $json = json_decode((string)$response->getBody(), true);
 
        static::assertSame(
            403,
            $response->getStatusCode()
        );
        static::assertThat(
            $json['message'] ?? null,
            static::logicalOr(
                static::identicalTo('ID was not an accessible page'),
                static::identicalTo('Subsection was found and not accessible')
            )
        );
    }
 
    public function ‪pageRenderingStopsWithInvalidCacheHashDataProvider(): array
    {
        $domainPaths = [
            'https://website.local/',
        ];
 
        $queries = [
            '',
            'welcome',
        ];
 
        $customQueries = [
            '?testing[value]=1',
            '?testing[value]=1&cHash=',
            '?testing[value]=1&cHash=WRONG',
        ];
 
        return $this->wrapInArray(
            $this->keysFromValues(
                ‪PermutationUtility::meltStringItems([$domainPaths, $queries, $customQueries])
            )
        );
    }
 
    public function ‪pageRequestThrowsExceptionWithInvalidCacheHashWithoutHavingErrorHandling(string $uri)
    {
        $this->‪writeSiteConfiguration(
            'website-local',
            $this->‪buildSiteConfiguration(1000, 'https://website.local/')
        );
 
        $this->expectExceptionCode(1518472189);
        $this->expectException(PageNotFoundException::class);
 
        $this->executeFrontendRequest(
            new InternalRequest($uri),
            $this->internalRequestContext
        );
    }
 
    public function ‪pageRequestSendsNotFoundResponseWithInvalidCacheHash(string $uri)
    {
        $response = $this->executeFrontendRequest(
            new InternalRequest($uri),
            $this->internalRequestContext->withMergedGlobalSettings([
                'TYPO3_CONF_VARS' => [
                    'FE' => [
                        'pageNotFound_handling' => 'READFILE:typo3/sysext/core/Tests/Functional/Fixtures/Frontend/PageError.txt',
                    ]
                ]
            ])
        );
 
        static::assertSame(
            404,
            $response->getStatusCode()
        );
        static::assertThat(
            (string)$response->getBody(),
            static::logicalOr(
                static::stringContains('reason: Request parameters could not be validated (&amp;cHash empty)'),
                static::stringContains('reason: Request parameters could not be validated (&amp;cHash comparison failed)')
            )
        );
    }
 
    public function ‪pageRequestSendsNotFoundResponseWithInvalidCacheHashWithHavingFluidErrorHandling(string $uri)
    {
        $this->‪writeSiteConfiguration(
            'website-local',
            $this->‪buildSiteConfiguration(1000, 'https://website.local/'),
            [],
            $this->‪buildErrorHandlingConfiguration('Fluid', [404])
        );
 
        $response = $this->executeFrontendRequest(
            new InternalRequest($uri),
            $this->internalRequestContext
        );
 
        static::assertSame(
            404,
            $response->getStatusCode()
        );
        static::assertThat(
            (string)$response->getBody(),
            static::logicalOr(
                static::stringContains('message: Request parameters could not be validated (&amp;cHash empty)'),
                static::stringContains('message: Request parameters could not be validated (&amp;cHash comparison failed)')
            )
        );
    }
 
    public function ‪pageRequestSendsNotFoundResponseWithInvalidCacheHashWithHavingPageErrorHandling(string $uri)
    {
        $this->markTestSkipped('Skipped until PageContentErrorHandler::handlePageError does not use HTTP anymore');
 
        $this->‪writeSiteConfiguration(
            'website-local',
            $this->‪buildSiteConfiguration(1000, 'https://website.local/'),
            [],
            $this->‪buildErrorHandlingConfiguration('Page', [404])
        );
 
        $response = $this->executeFrontendRequest(
            new InternalRequest($uri),
            $this->internalRequestContext
        );
 
        static::assertSame(
            404,
            $response->getStatusCode()
        );
    }
 
    public function ‪pageRequestSendsNotFoundResponseWithInvalidCacheHashWithHavingPhpErrorHandling(string $uri)
    {
        $this->‪writeSiteConfiguration(
            'website-local',
            $this->‪buildSiteConfiguration(1000, 'https://website.local/'),
            [],
            $this->‪buildErrorHandlingConfiguration('PHP', [404])
        );
 
        $response = $this->executeFrontendRequest(
            new InternalRequest($uri),
            $this->internalRequestContext
        );
        $json = json_decode((string)$response->getBody(), true);
 
        static::assertSame(
            404,
            $response->getStatusCode()
        );
        static::assertThat(
            $json['message'] ?? null,
            static::logicalOr(
                static::identicalTo('Request parameters could not be validated (&cHash empty)'),
                static::identicalTo('Request parameters could not be validated (&cHash comparison failed)')
            )
        );
    }
 
    public function ‪pageIsRenderedWithValidCacheHashDataProvider(): array
    {
        $domainPaths = [
            'https://website.local/',
        ];
 
        // cHash has been calculated with encryption key set to
        // '4408d27a916d51e624b69af3554f516dbab61037a9f7b9fd6f81b4d3bedeccb6'
        $queries = [
            // @todo Currently fails since cHash is verified after(!) redirect to page 1100
            // '?cHash=7d1f13fa91159dac7feb3c824936b39d',
            // '?cHash=7d1f13fa91159dac7feb3c824936b39d',
            'welcome?cHash=f42b850e435f0cedd366f5db749fc1af',
        ];
 
        $customQueries = [
            '&testing[value]=1',
        ];
 
        $dataSet = $this->wrapInArray(
            $this->keysFromValues(
                ‪PermutationUtility::meltStringItems([$domainPaths, $queries, $customQueries])
            )
        );
 
        return $dataSet;
    }
 
    public function ‪pageIsRenderedWithValidCacheHash($uri)
    {
        $this->‪writeSiteConfiguration(
            'website-local',
            $this->‪buildSiteConfiguration(1000, 'https://website.local/')
        );
 
        $response = $this->executeFrontendRequest(
            new InternalRequest($uri),
            $this->internalRequestContext
        );
        $responseStructure = ResponseContent::fromString(
            (string)$response->getBody()
        );
        static::assertSame(
            '1',
            $responseStructure->getScopePath('getpost/testing.value')
        );
    }
}