RequestTest.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\Core\Tests\Unit\Http;
 
use ‪TYPO3\CMS\Core\Http\Request;
use ‪TYPO3\CMS\Core\Http\Stream;
use ‪TYPO3\CMS\Core\Http\Uri;
use TYPO3\TestingFramework\Core\Unit\UnitTestCase;
 
class ‪RequestTest extends UnitTestCase
{
    protected ‪$request;
 
    protected function ‪setUp(): void
    {
        parent::setUp();
        $this->request = new ‪Request();
    }
 
    public function ‪getMethodIsGetByDefault()
    {
        self::assertEquals('GET', $this->request->getMethod());
    }
 
    public function ‪getMethodMutatorReturnsCloneWithChangedMethod()
    {
        ‪$request = $this->request->‪withMethod('GET');
        self::assertNotSame($this->request, ‪$request);
        self::assertEquals('GET', ‪$request->‪getMethod());
    }
 
    public function ‪getUriIsNullByDefault()
    {
        self::assertNull($this->request->getUri());
    }
 
    public function ‪constructorRaisesExceptionForInvalidStream()
    {
        $this->expectException(\InvalidArgumentException::class);
        new Request(['TOTALLY INVALID']);
    }
 
    public function ‪withUriReturnsNewInstanceWithNewUri()
    {
        ‪$request = $this->request->‪withUri(new Uri('https://example.com:10082/foo/bar?baz=bat'));
        self::assertNotSame($this->request, ‪$request);
        $request2 = ‪$request->‪withUri(new Uri('/baz/bat?foo=bar'));
        self::assertNotSame($this->request, $request2);
        self::assertNotSame(‪$request, $request2);
        self::assertEquals('/baz/bat?foo=bar', (string)$request2->getUri());
    }
 
    public function ‪constructorCanAcceptAllMessageParts()
    {
        $uri = new Uri('http://example.com/');
        $body = new Stream('php://memory');
        $headers = [
            'x-foo' => ['bar'],
        ];
        ‪$request = new Request(
            $uri,
            'POST',
            $body,
            $headers
        );
 
        self::assertSame($uri, ‪$request->‪getUri());
        self::assertEquals('POST', ‪$request->‪getMethod());
        self::assertSame($body, ‪$request->‪getBody());
        $testHeaders = ‪$request->‪getHeaders();
        foreach ($headers as $key => $value) {
            self::assertArrayHasKey($key, $testHeaders);
            self::assertEquals($value, $testHeaders[$key]);
        }
    }
 
    public function ‪invalidRequestUriDataProvider()
    {
        return [
            'true'     => [true],
            'false'    => [false],
            'int'      => [1],
            'float'    => [1.1],
            'array'    => [['http://example.com']],
            'stdClass' => [(object)['href' => 'http://example.com']],
        ];
    }
 
    public function ‪constructorRaisesExceptionForInvalidUri($uri)
    {
        $this->expectException(\InvalidArgumentException::class);
        $this->expectExceptionCode(1436717272);
        new Request($uri);
    }
 
    public function ‪invalidRequestMethodDataProvider()
    {
        return [
            'true'       => [true],
            'false'      => [false],
            'int'        => [1],
            'float'      => [1.1],
            'array'      => [['POST']],
            'stdClass'   => [(object)['method' => 'POST']],
        ];
    }
 
    public function ‪constructorRaisesExceptionForInvalidMethodByType($method)
    {
        $this->expectException(\InvalidArgumentException::class);
        $this->expectExceptionCode(1436717274);
        new Request(null, $method);
    }
 
    public function ‪constructorRaisesExceptionForInvalidMethodByString()
    {
        $this->expectException(\InvalidArgumentException::class);
        $this->expectExceptionCode(1436717275);
        new Request(null, 'BOGUS-METHOD');
    }
 
    public function ‪invalidRequestBodyDataProvider()
    {
        return [
            'true'     => [true],
            'false'    => [false],
            'int'      => [1],
            'float'    => [1.1],
            'array'    => [['BODY']],
            'stdClass' => [(object)['body' => 'BODY']],
        ];
    }
 
    public function ‪constructorRaisesExceptionForInvalidBody($body)
    {
        $this->expectException(\InvalidArgumentException::class);
        $this->expectExceptionCode(1436717271);
        new Request(null, null, $body);
    }
 
    public function ‪constructorIgnoresInvalidHeaders()
    {
        $headers = [
            ['INVALID'],
            'x-invalid-null'   => null,
            'x-invalid-true'   => true,
            'x-invalid-false'  => false,
            'x-invalid-int'    => 1,
            'x-invalid-object' => (object)['INVALID'],
            'x-valid-string'   => 'VALID',
            'x-valid-array'    => ['VALID'],
        ];
        $expected = [
            'x-valid-string' => ['VALID'],
            'x-valid-array'  => ['VALID'],
        ];
        ‪$request = new Request(null, null, 'php://memory', $headers);
        self::assertEquals($expected, ‪$request->‪getHeaders());
    }
 
    public function ‪getRequestTargetIsSlashWhenNoUriPresent()
    {
        ‪$request = new Request();
        self::assertEquals('/', ‪$request->‪getRequestTarget());
    }
 
    public function ‪getRequestTargetIsSlashWhenUriHasNoPathOrQuery()
    {
        ‪$request = (new Request())
            ->withUri(new Uri('http://example.com'));
        self::assertEquals('/', ‪$request->‪getRequestTarget());
    }
 
    public function ‪requestsWithUriDataProvider()
    {
        return [
            'absolute-uri'            => [
                (new Request())
                    ->withUri(new Uri('https://api.example.com/user'))
                    ->withMethod('POST'),
                '/user'
            ],
            'absolute-uri-with-query' => [
                (new Request())
                    ->withUri(new Uri('https://api.example.com/user?foo=bar'))
                    ->withMethod('POST'),
                '/user?foo=bar'
            ],
            'relative-uri'            => [
                (new Request())
                    ->withUri(new Uri('/user'))
                    ->withMethod('GET'),
                '/user'
            ],
            'relative-uri-with-query' => [
                (new Request())
                    ->withUri(new Uri('/user?foo=bar'))
                    ->withMethod('GET'),
                '/user?foo=bar'
            ],
        ];
    }
 
    public function ‪getRequestTargetWhenUriIsPresent(‪$request, $expected)
    {
        self::assertEquals($expected, ‪$request->‪getRequestTarget());
    }
 
    public function ‪validRequestTargetsDataProvider()
    {
        return [
            'asterisk-form'         => ['*'],
            'authority-form'        => ['api.example.com'],
            'absolute-form'         => ['https://api.example.com/users'],
            'absolute-form-query'   => ['https://api.example.com/users?foo=bar'],
            'origin-form-path-only' => ['/users'],
            'origin-form'           => ['/users?id=foo'],
        ];
    }
 
    public function ‪getRequestTargetCanProvideARequestTarget($requestTarget)
    {
        ‪$request = (new Request())->withRequestTarget($requestTarget);
        self::assertEquals($requestTarget, ‪$request->‪getRequestTarget());
    }
 
    public function ‪withRequestTargetCannotContainWhitespace()
    {
        ‪$request = new Request();
        $this->expectException(\InvalidArgumentException::class);
        $this->expectExceptionCode(1436717273);
        ‪$request->‪withRequestTarget('foo bar baz');
    }
 
    public function ‪getRequestTargetDoesNotCacheBetweenInstances()
    {
        ‪$request = (new Request())->withUri(new Uri('https://example.com/foo/bar'));
        $original = ‪$request->‪getRequestTarget();
        $newRequest = ‪$request->‪withUri(new Uri('http://mwop.net/bar/baz'));
        self::assertNotEquals($original, $newRequest->getRequestTarget());
    }
 
    public function ‪getRequestTargetIsResetWithNewUri()
    {
        ‪$request = (new Request())->withUri(new Uri('https://example.com/foo/bar'));
        ‪$request->‪getRequestTarget();
        ‪$request->‪withUri(new Uri('http://mwop.net/bar/baz'));
    }
 
    public function ‪getHeadersContainsHostHeaderIfUriWithHostIsPresent()
    {
        ‪$request = new Request('http://example.com');
        $headers = ‪$request->‪getHeaders();
        self::assertArrayHasKey('host', $headers);
        self::assertTrue(in_array('example.com', $headers['host']));
    }
 
    public function ‪getHeadersContainsNoHostHeaderIfNoUriPresent()
    {
        ‪$request = new Request();
        $headers = ‪$request->‪getHeaders();
        self::assertArrayNotHasKey('host', $headers);
    }
 
    public function ‪getHeadersContainsNoHostHeaderIfUriDoesNotContainHost()
    {
        ‪$request = new Request(new Uri());
        $headers = ‪$request->‪getHeaders();
        self::assertArrayNotHasKey('host', $headers);
    }
 
    public function ‪getHeaderWithHostReturnsUriHostWhenPresent()
    {
        ‪$request = new Request('http://example.com');
        $header = ‪$request->‪getHeader('host');
        self::assertEquals(['example.com'], $header);
    }
 
    public function ‪getHeaderWithHostReturnsEmptyArrayIfNoUriPresent()
    {
        ‪$request = new Request();
        self::assertSame([], ‪$request->‪getHeader('host'));
    }
 
    public function ‪getHeaderWithHostReturnsEmptyArrayIfUriDoesNotContainHost()
    {
        ‪$request = new Request(new Uri());
        self::assertSame([], ‪$request->‪getHeader('host'));
    }
 
    public function ‪getHeaderLineWithHostReturnsUriHostWhenPresent()
    {
        ‪$request = new Request('http://example.com');
        $header = ‪$request->‪getHeaderLine('host');
        self::assertStringContainsString('example.com', $header);
    }
 
    public function ‪getHeaderLineWithHostReturnsEmptyStringIfNoUriPresent()
    {
        ‪$request = new Request();
        self::assertSame('', ‪$request->‪getHeaderLine('host'));
    }
 
    public function ‪getHeaderLineWithHostReturnsEmptyStringIfUriDoesNotContainHost()
    {
        ‪$request = new Request(new Uri());
        self::assertSame('', ‪$request->‪getHeaderLine('host'));
    }
 
    public function ‪getHeaderLineWithHostTakesPrecedenceOverModifiedUri()
    {
        ‪$request = (new Request())
            ->withAddedHeader('Host', 'example.com');
 
        $uri = (new Uri())->withHost('www.example.com');
        $new = ‪$request->‪withUri($uri, true);
 
        self::assertEquals('example.com', $new->getHeaderLine('Host'));
    }
 
    public function ‪getHeaderLineWithHostTakesPrecedenceOverEmptyUri()
    {
        ‪$request = (new Request())
            ->withAddedHeader('Host', 'example.com');
 
        $uri = new Uri();
        $new = ‪$request->‪withUri($uri);
 
        self::assertEquals('example.com', $new->getHeaderLine('Host'));
    }
 
    public function ‪getHeaderLineWithHostDoesNotTakePrecedenceOverHostWithPortFromUri()
    {
        ‪$request = (new Request())
            ->withAddedHeader('Host', 'example.com');
 
        $uri = (new Uri())
            ->withHost('www.example.com')
            ->withPort(10081);
        $new = ‪$request->‪withUri($uri);
 
        self::assertEquals('www.example.com:10081', $new->getHeaderLine('Host'));
    }
 
    public function ‪headersWithUpperAndLowerCaseValuesDataProvider()
    {
        // 'name' => [$headerName, $headerValue, $expectedValue]
        return [
            'Foo'             => ['Foo', 'bar', 'bar'],
            'foo'             => ['foo', 'bar', 'bar'],
            'Foo-with-array'  => ['Foo', ['bar'], 'bar'],
            'foo-with-array'  => ['foo', ['bar'], 'bar'],
        ];
    }
 
    public function ‪headerCanBeRetrieved($header, $value, $expected)
    {
        ‪$request = new Request(null, null, 'php://memory', [$header => $value]);
        self::assertEquals([$expected], ‪$request->‪getHeader(strtolower($header)));
        self::assertEquals([$expected], ‪$request->‪getHeader(strtoupper($header)));
    }
 
    public function ‪headersWithInjectionVectorsDataProvider()
    {
        return [
            'name-with-cr'           => ["X-Foo\r-Bar", 'value'],
            'name-with-lf'           => ["X-Foo\n-Bar", 'value'],
            'name-with-crlf'         => ["X-Foo\r\n-Bar", 'value'],
            'name-with-2crlf'        => ["X-Foo\r\n\r\n-Bar", 'value'],
            'value-with-cr'          => ['X-Foo-Bar', "value\rinjection"],
            'value-with-lf'          => ['X-Foo-Bar', "value\ninjection"],
            'value-with-crlf'        => ['X-Foo-Bar', "value\r\ninjection"],
            'value-with-2crlf'       => ['X-Foo-Bar', "value\r\n\r\ninjection"],
            'array-value-with-cr'    => ['X-Foo-Bar', ["value\rinjection"]],
            'array-value-with-lf'    => ['X-Foo-Bar', ["value\ninjection"]],
            'array-value-with-crlf'  => ['X-Foo-Bar', ["value\r\ninjection"]],
            'array-value-with-2crlf' => ['X-Foo-Bar', ["value\r\n\r\ninjection"]],
        ];
    }
 
    public function ‪constructorRaisesExceptionForHeadersWithCRLFVectors($name, $value)
    {
        $this->expectException(\InvalidArgumentException::class);
        new Request(null, null, 'php://memory', [$name => $value]);
    }
 
    public function ‪supportedRequestMethodsWork(): void
    {
        ‪$request = new Request('some-uri', 'PURGE');
        self::assertEquals('PURGE', ‪$request->‪getMethod());
    }
 
    public function ‪nonSupportedRequestMethodsRaisesException(): void
    {
        $this->expectException(\InvalidArgumentException::class);
        new Request('some-uri', 'UNSUPPORTED');
    }
}