├── .gitignore
├── test
    ├── UriFactoryTest.php
    ├── StreamFactoryTest.php
    ├── ResponseFactoryTest.php
    ├── RequestFactoryTest.php
    ├── UploadedFileFactoryTest.php
    ├── ServerRequestFactoryTest.php
    ├── UriFactoryTestCase.php
    ├── StreamHelper.php
    ├── ResponseFactoryTestCase.php
    ├── RequestFactoryTestCase.php
    ├── UploadedFileFactoryTestCase.php
    ├── ServerRequestFactoryTestCase.php
    └── StreamFactoryTestCase.php
├── CHANGELOG.md
├── composer.json
├── README.md
└── LICENSE


/.gitignore:
--------------------------------------------------------------------------------
1 | composer.phar
2 | composer.lock
3 | phpunit.xml
4 | build/
5 | vendor/
6 | 


--------------------------------------------------------------------------------
/test/UriFactoryTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * @noinspection PhpUndefinedConstantInspection
 4 |  */
 5 | 
 6 | namespace Interop\Http\Factory;
 7 | 
 8 | use function class_exists;
 9 | use function defined;
10 | 
11 | final class UriFactoryTest extends UriFactoryTestCase
12 | {
13 |     /**
14 |      * {@inheritdoc}
15 |      */
16 |     protected function createUriFactory()
17 |     {
18 |         if (!defined('URI_FACTORY') || !class_exists(URI_FACTORY)) {
19 |             self::markTestSkipped('URI_FACTORY class name not provided');
20 |         }
21 | 
22 |         return new (URI_FACTORY);
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/test/StreamFactoryTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * @noinspection PhpUndefinedConstantInspection
 4 |  */
 5 | 
 6 | namespace Interop\Http\Factory;
 7 | 
 8 | use function class_exists;
 9 | use function defined;
10 | 
11 | final class StreamFactoryTest extends StreamFactoryTestCase
12 | {
13 |     /**
14 |      * {@inheritdoc}
15 |      */
16 |     protected function createStreamFactory()
17 |     {
18 |         if (!defined('STREAM_FACTORY') || !class_exists(STREAM_FACTORY)) {
19 |             self::markTestSkipped('STREAM_FACTORY class name not provided');
20 |         }
21 | 
22 |         return new (STREAM_FACTORY);
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/test/ResponseFactoryTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * @noinspection PhpUndefinedConstantInspection
 4 |  */
 5 | 
 6 | namespace Interop\Http\Factory;
 7 | 
 8 | use function class_exists;
 9 | use function defined;
10 | 
11 | final class ResponseFactoryTest extends ResponseFactoryTestCase
12 | {
13 |     /**
14 |      * {@inheritdoc}
15 |      */
16 |     protected function createResponseFactory()
17 |     {
18 |         if (!defined('RESPONSE_FACTORY') || !class_exists(RESPONSE_FACTORY)) {
19 |             self::markTestSkipped('RESPONSE_FACTORY class name not provided');
20 |         }
21 | 
22 |         return new (RESPONSE_FACTORY);
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
 1 | # Changelog
 2 | 
 3 | All notable changes to this project will be documented in this file.
 4 | 
 5 | The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 6 | and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 7 | 
 8 | ## [2.2.0] - 2024-06-10
 9 | 
10 | - Allow PHPUnit 11.x #51
11 | 
12 | ## [2.1.0] - 2023-11-25
13 | 
14 | - Clean up testing changes #48, #49
15 | 
16 | ## [2.0.0] - 2023-10-21
17 | 
18 | - Require PHP 8.x and PHPUnit 10.x #47
19 | 
20 | ## [1.1.0] - 2023-10-21
21 | 
22 | - Final release that supports PHP 7.x.
23 | 
24 | ## [1.0.0] - 2023-10-10
25 | 
26 | - Add tests for streams #39
27 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "http-interop/http-factory-tests",
 3 |     "description": "Unit tests for HTTP factories",
 4 |     "keywords": [
 5 |         "psr-7",
 6 |         "psr-17",
 7 |         "http",
 8 |         "factory",
 9 |         "test"
10 |     ],
11 |     "license": "MIT",
12 |     "authors": [
13 |         {
14 |             "name": "PHP-FIG",
15 |             "homepage": "https://www.php-fig.org/"
16 |         },
17 |         {
18 |             "name": "Contributors",
19 |             "homepage": "https://github.com/http-interop/http-factory-tests/graphs/contributors"
20 |         }
21 |     ],
22 |     "require": {
23 |         "php": "^8.1",
24 |         "psr/http-factory": "^1.0",
25 |         "phpunit/phpunit": "^10.0 || ^11.0 || ^12.0"
26 |     },
27 |     "autoload": {
28 |         "psr-4": {
29 |             "Interop\\Http\\Factory\\": "test/"
30 |         }
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Unit tests for HTTP Factory implementations
 2 | 
 3 | To use these unit tests you need to add some config to phpunit.xml. 
 4 | 
 5 | ```xml
 6 | <phpunit backupGlobals="true">
 7 |     <testsuites>
 8 |         <testsuite name="Integration tests">
 9 |             <directory>./vendor/http-interop/http-factory-tests/test</directory>
10 |         </testsuite>
11 |     </testsuites>
12 |     <php>
13 |       <!-- Fully qualified class names to your classes -->
14 |       <const name="REQUEST_FACTORY" value="Acme\Factory\RequestFactory"/>
15 |       <const name="RESPONSE_FACTORY" value="Acme\Factory\ResponseFactory"/>
16 |       <const name="SERVER_REQUEST_FACTORY" value="Acme\Factory\ServerRequestFactory"/>
17 |       <const name="STREAM_FACTORY" value="Acme\Factory\StreamFactory"/>
18 |       <const name="UPLOADED_FILE_FACTORY" value="Acme\Factory\UploadedFileFactory"/>
19 |       <const name="URI_FACTORY" value="Acme\Factory\UriFactory"/>
20 |     </php>
21 | </phpunit>
22 | 
23 | ```
24 | 


--------------------------------------------------------------------------------
/test/RequestFactoryTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * @noinspection PhpUndefinedConstantInspection
 4 |  */
 5 | 
 6 | namespace Interop\Http\Factory;
 7 | 
 8 | use function class_exists;
 9 | use function defined;
10 | 
11 | final class RequestFactoryTest extends RequestFactoryTestCase
12 | {
13 |     /**
14 |      * {@inheritdoc}
15 |      */
16 |     protected function createRequestFactory()
17 |     {
18 |         if (!defined('REQUEST_FACTORY') || !class_exists(REQUEST_FACTORY)) {
19 |             self::markTestSkipped('REQUEST_FACTORY class name not provided');
20 |         }
21 | 
22 |         return new (REQUEST_FACTORY);
23 |     }
24 | 
25 |     /**
26 |      * {@inheritdoc}
27 |      */
28 |     protected function createUri($uri)
29 |     {
30 |         if (!defined('URI_FACTORY') || !class_exists(URI_FACTORY)) {
31 |             self::markTestSkipped('URI_FACTORY class name not provided');
32 |         }
33 | 
34 |         return (new (URI_FACTORY))->createUri($uri);
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/test/UploadedFileFactoryTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * @noinspection PhpUndefinedConstantInspection
 4 |  */
 5 | 
 6 | namespace Interop\Http\Factory;
 7 | 
 8 | use function class_exists;
 9 | use function defined;
10 | 
11 | final class UploadedFileFactoryTest extends UploadedFileFactoryTestCase
12 | {
13 |     /**
14 |      * {@inheritdoc}
15 |      */
16 |     protected function createUploadedFileFactory()
17 |     {
18 |         if (!defined('UPLOADED_FILE_FACTORY') || !class_exists(UPLOADED_FILE_FACTORY)) {
19 |             self::markTestSkipped('UPLOADED_FILE_FACTORY class name not provided');
20 |         }
21 | 
22 |         return new (UPLOADED_FILE_FACTORY);
23 |     }
24 | 
25 |     protected function createStream($content)
26 |     {
27 |         if (!defined('STREAM_FACTORY') || !class_exists(STREAM_FACTORY)) {
28 |             self::markTestSkipped('STREAM_FACTORY class name not provided');
29 |         }
30 | 
31 |         return (new (STREAM_FACTORY))->createStream($content);
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/test/ServerRequestFactoryTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * @noinspection PhpUndefinedConstantInspection
 4 |  */
 5 | 
 6 | namespace Interop\Http\Factory;
 7 | 
 8 | use function class_exists;
 9 | use function defined;
10 | 
11 | final class ServerRequestFactoryTest extends ServerRequestFactoryTestCase
12 | {
13 |     /**
14 |      * {@inheritdoc}
15 |      */
16 |     protected function createServerRequestFactory()
17 |     {
18 |         if (!defined('SERVER_REQUEST_FACTORY') || !class_exists(SERVER_REQUEST_FACTORY)) {
19 |             self::markTestSkipped('SERVER_REQUEST_FACTORY class name not provided');
20 |         }
21 | 
22 |         return new (SERVER_REQUEST_FACTORY);
23 |     }
24 | 
25 |     /**
26 |      * {@inheritdoc}
27 |      */
28 |     protected function createUri($uri)
29 |     {
30 |         if (!defined('URI_FACTORY') || !class_exists(URI_FACTORY)) {
31 |             self::markTestSkipped('URI_FACTORY class name not provided');
32 |         }
33 | 
34 |         return (new (URI_FACTORY))->createUri($uri);
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2016 Woody Gilk
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/test/UriFactoryTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Interop\Http\Factory;
 4 | 
 5 | use InvalidArgumentException;
 6 | use PHPUnit\Framework\TestCase;
 7 | use Psr\Http\Message\UriFactoryInterface;
 8 | use Psr\Http\Message\UriInterface;
 9 | 
10 | abstract class UriFactoryTestCase extends TestCase
11 | {
12 |     /**
13 |      * @var UriFactoryInterface
14 |      */
15 |     protected $factory;
16 | 
17 |     /**
18 |      * @return UriFactoryInterface
19 |      */
20 |     abstract protected function createUriFactory();
21 | 
22 |     public function setUp(): void
23 |     {
24 |         $this->factory = $this->createUriFactory();
25 |     }
26 | 
27 |     protected function assertUri($uri, $uriString)
28 |     {
29 |         static::assertInstanceOf(UriInterface::class, $uri);
30 |         static::assertSame($uriString, (string) $uri);
31 |     }
32 | 
33 |     public function testCreateUri()
34 |     {
35 |         $uriString = 'http://example.com/';
36 | 
37 |         $uri = $this->factory->createUri($uriString);
38 | 
39 |         $this->assertUri($uri, $uriString);
40 |     }
41 | 
42 |     public function testExceptionWhenUriIsInvalid()
43 |     {
44 |         $this->expectException(InvalidArgumentException::class);
45 |         $this->factory->createUri(':');
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/test/StreamHelper.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Interop\Http\Factory;
 4 | 
 5 | use RuntimeException;
 6 | use function fopen;
 7 | use function fwrite;
 8 | use function is_file;
 9 | use function rewind;
10 | use function sys_get_temp_dir;
11 | use function tempnam;
12 | use function unlink;
13 | 
14 | trait StreamHelper
15 | {
16 |     protected static $tempFiles = [];
17 | 
18 |     protected function createTemporaryFile()
19 |     {
20 |         $file = tempnam(sys_get_temp_dir(), 'http_factory_tests_');
21 | 
22 |         if($file === false){
23 |             throw new RuntimeException('could not create temp file');
24 |         }
25 | 
26 |         static::$tempFiles[] = $file;
27 | 
28 |         return $file;
29 |     }
30 | 
31 |     protected function createTemporaryResource($content = null)
32 |     {
33 |         $file = $this->createTemporaryFile();
34 |         $resource = fopen($file, 'r+');
35 | 
36 |         if ($content) {
37 |             fwrite($resource, $content);
38 |             rewind($resource);
39 |         }
40 | 
41 |         return $resource;
42 |     }
43 | 
44 |     public static function tearDownAfterClass(): void
45 |     {
46 |         foreach (static::$tempFiles as $tempFile) {
47 |             if (is_file($tempFile)) {
48 |                 unlink($tempFile);
49 |             }
50 |         }
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/test/ResponseFactoryTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Interop\Http\Factory;
 4 | 
 5 | use PHPUnit\Framework\Attributes\DataProvider;
 6 | use PHPUnit\Framework\TestCase;
 7 | use Psr\Http\Message\ResponseFactoryInterface;
 8 | use Psr\Http\Message\ResponseInterface;
 9 | 
10 | abstract class ResponseFactoryTestCase extends TestCase
11 | {
12 |     /**
13 |      * @var ResponseFactoryInterface
14 |      */
15 |     protected $factory;
16 | 
17 |     /**
18 |      * @return ResponseFactoryInterface
19 |      */
20 |     abstract protected function createResponseFactory();
21 | 
22 |     public function setUp(): void
23 |     {
24 |         $this->factory = $this->createResponseFactory();
25 |     }
26 | 
27 |     protected function assertResponse($response, $code)
28 |     {
29 |         static::assertInstanceOf(ResponseInterface::class, $response);
30 |         static::assertSame($code, $response->getStatusCode());
31 |     }
32 | 
33 |     public static function dataCodes()
34 |     {
35 |         return [
36 |             'HTTP/200' => [200],
37 |             'HTTP/301' => [301],
38 |             'HTTP/404' => [404],
39 |             'HTTP/500' => [500],
40 |         ];
41 |     }
42 | 
43 |     #[DataProvider('dataCodes')]
44 |     public function testCreateResponse($code)
45 |     {
46 |         $response = $this->factory->createResponse($code);
47 | 
48 |         $this->assertResponse($response, $code);
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/test/RequestFactoryTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Interop\Http\Factory;
 4 | 
 5 | use PHPUnit\Framework\Attributes\DataProvider;
 6 | use PHPUnit\Framework\TestCase;
 7 | use Psr\Http\Message\RequestFactoryInterface;
 8 | use Psr\Http\Message\RequestInterface;
 9 | use Psr\Http\Message\UriInterface;
10 | 
11 | abstract class RequestFactoryTestCase extends TestCase
12 | {
13 |     /**
14 |      * @var RequestFactoryInterface
15 |      */
16 |     protected $factory;
17 | 
18 |     /**
19 |      * @return RequestFactoryInterface
20 |      */
21 |     abstract protected function createRequestFactory();
22 | 
23 |     /**
24 |      * @param string $uri
25 |      *
26 |      * @return UriInterface
27 |      */
28 |     abstract protected function createUri($uri);
29 | 
30 |     public function setUp(): void
31 |     {
32 |         $this->factory = $this->createRequestFactory();
33 |     }
34 | 
35 |     protected function assertRequest($request, $method, $uri)
36 |     {
37 |         static::assertInstanceOf(RequestInterface::class, $request);
38 |         static::assertSame($method, $request->getMethod());
39 |         static::assertSame($uri, (string) $request->getUri());
40 |     }
41 | 
42 |     public static function dataMethods()
43 |     {
44 |         return [
45 |             'GET'     => ['GET'],
46 |             'POST'    => ['POST'],
47 |             'PUT'     => ['PUT'],
48 |             'DELETE'  => ['DELETE'],
49 |             'OPTIONS' => ['OPTIONS'],
50 |             'HEAD'    => ['HEAD'],
51 |         ];
52 |     }
53 | 
54 |     #[DataProvider('dataMethods')]
55 |     public function testCreateRequest($method)
56 |     {
57 |         $uri = 'http://example.com/';
58 | 
59 |         $request = $this->factory->createRequest($method, $uri);
60 | 
61 |         $this->assertRequest($request, $method, $uri);
62 |     }
63 | 
64 |     public function testCreateRequestWithUri()
65 |     {
66 |         $method = 'GET';
67 |         $uri = 'http://example.com/';
68 | 
69 |         $request = $this->factory->createRequest($method, $this->createUri($uri));
70 | 
71 |         $this->assertRequest($request, $method, $uri);
72 |     }
73 | }
74 | 


--------------------------------------------------------------------------------
/test/UploadedFileFactoryTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Interop\Http\Factory;
 4 | 
 5 | use PHPUnit\Framework\TestCase;
 6 | use Psr\Http\Message\StreamInterface;
 7 | use Psr\Http\Message\UploadedFileFactoryInterface;
 8 | use Psr\Http\Message\UploadedFileInterface;
 9 | use function strlen;
10 | use const UPLOAD_ERR_NO_FILE;
11 | use const UPLOAD_ERR_OK;
12 | 
13 | abstract class UploadedFileFactoryTestCase extends TestCase
14 | {
15 |     /**
16 |      * @var UploadedFileFactoryInterface
17 |      */
18 |     protected $factory;
19 | 
20 |     /**
21 |      * @return UploadedFileFactoryInterface
22 |      */
23 |     abstract protected function createUploadedFileFactory();
24 | 
25 |     /**
26 |      * @return StreamInterface
27 |      */
28 |     abstract protected function createStream($content);
29 | 
30 |     public function setUp(): void
31 |     {
32 |         $this->factory = $this->createUploadedFileFactory();
33 |     }
34 | 
35 |     protected function assertUploadedFile(
36 |         $file,
37 |         $content,
38 |         $size = null,
39 |         $error = null,
40 |         $clientFilename = null,
41 |         $clientMediaType = null
42 |     ) {
43 |         static::assertInstanceOf(UploadedFileInterface::class, $file);
44 |         static::assertSame($content, (string) $file->getStream());
45 |         static::assertSame(($size ?? strlen($content)), $file->getSize());
46 |         static::assertSame(($error ?? UPLOAD_ERR_OK), $file->getError());
47 |         static::assertSame($clientFilename, $file->getClientFilename());
48 |         static::assertSame($clientMediaType, $file->getClientMediaType());
49 |     }
50 | 
51 |     public function testCreateUploadedFileWithClientFilenameAndMediaType()
52 |     {
53 |         $content = 'this is your capitan speaking';
54 |         $upload = $this->createStream($content);
55 |         $error = UPLOAD_ERR_OK;
56 |         $clientFilename = 'test.txt';
57 |         $clientMediaType = 'text/plain';
58 | 
59 |         $file = $this->factory->createUploadedFile($upload, null, $error, $clientFilename, $clientMediaType);
60 | 
61 |         $this->assertUploadedFile($file, $content, null, $error, $clientFilename, $clientMediaType);
62 |     }
63 | 
64 |     public function testCreateUploadedFileWithError()
65 |     {
66 |         $upload = $this->createStream('foobar');
67 |         $error = UPLOAD_ERR_NO_FILE;
68 | 
69 |         $file = $this->factory->createUploadedFile($upload, null, $error);
70 | 
71 |         // Cannot use assertUploadedFile() here because the error prevents
72 |         // fetching the content stream.
73 |         static::assertInstanceOf(UploadedFileInterface::class, $file);
74 |         static::assertSame($error, $file->getError());
75 |     }
76 | }
77 | 


--------------------------------------------------------------------------------
/test/ServerRequestFactoryTestCase.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * @noinspection PhpArrayWriteIsNotUsedInspection
  4 |  */
  5 | 
  6 | namespace Interop\Http\Factory;
  7 | 
  8 | use PHPUnit\Framework\Attributes\BackupGlobals;
  9 | use PHPUnit\Framework\Attributes\DataProvider;
 10 | use PHPUnit\Framework\TestCase;
 11 | use Psr\Http\Message\ServerRequestFactoryInterface;
 12 | use Psr\Http\Message\ServerRequestInterface;
 13 | use Psr\Http\Message\UriInterface;
 14 | use const UPLOAD_ERR_OK;
 15 | 
 16 | abstract class ServerRequestFactoryTestCase extends TestCase
 17 | {
 18 |     /**
 19 |      * @var ServerRequestFactoryInterface
 20 |      */
 21 |     protected $factory;
 22 | 
 23 |     /**
 24 |      * @return ServerRequestFactoryInterface
 25 |      */
 26 |     abstract protected function createServerRequestFactory();
 27 | 
 28 |     /**
 29 |      * @param string $uri
 30 |      *
 31 |      * @return UriInterface
 32 |      */
 33 |     abstract protected function createUri($uri);
 34 | 
 35 |     public function setUp(): void
 36 |     {
 37 |         $this->factory = $this->createServerRequestFactory();
 38 |     }
 39 | 
 40 |     protected function assertServerRequest($request, $method, $uri)
 41 |     {
 42 |         static::assertInstanceOf(ServerRequestInterface::class, $request);
 43 |         static::assertSame($method, $request->getMethod());
 44 |         static::assertSame($uri, (string) $request->getUri());
 45 |     }
 46 | 
 47 |     public static function dataMethods()
 48 |     {
 49 |         return [
 50 |             ['GET'],
 51 |             ['POST'],
 52 |             ['PUT'],
 53 |             ['DELETE'],
 54 |             ['OPTIONS'],
 55 |             ['HEAD'],
 56 |         ];
 57 |     }
 58 | 
 59 |     public static function dataServer()
 60 |     {
 61 |         $data = [];
 62 | 
 63 |         foreach (static::dataMethods() as $methodData) {
 64 |             $data[$methodData[0]] = [
 65 |                 [
 66 |                     'REQUEST_METHOD' => $methodData[0],
 67 |                     'REQUEST_URI' => '/test',
 68 |                     'QUERY_STRING' => 'foo=1&bar=true',
 69 |                     'HTTP_HOST' => 'example.org',
 70 |                 ]
 71 |             ];
 72 |         }
 73 | 
 74 |         return $data;
 75 |     }
 76 | 
 77 |     #[DataProvider('dataServer')]
 78 |     public function testCreateServerRequest($server)
 79 |     {
 80 |         $method = $server['REQUEST_METHOD'];
 81 |         $uri = "http://{$server['HTTP_HOST']}{$server['REQUEST_URI']}?{$server['QUERY_STRING']}";
 82 | 
 83 |         $request = $this->factory->createServerRequest($method, $uri);
 84 | 
 85 |         $this->assertServerRequest($request, $method, $uri);
 86 |     }
 87 | 
 88 |     #[DataProvider('dataServer')]
 89 |     public function testCreateServerRequestFromArray(array $server)
 90 |     {
 91 |         $method = $server['REQUEST_METHOD'];
 92 |         $uri = "http://{$server['HTTP_HOST']}{$server['REQUEST_URI']}?{$server['QUERY_STRING']}";
 93 | 
 94 |         $request = $this->factory->createServerRequest($method, $uri, $server);
 95 | 
 96 |         $this->assertServerRequest($request, $method, $uri);
 97 |     }
 98 | 
 99 |     #[DataProvider('dataServer')]
100 |     public function testCreateServerRequestWithUriObject($server)
101 |     {
102 |         $method = $server['REQUEST_METHOD'];
103 |         $uri = "http://{$server['HTTP_HOST']}{$server['REQUEST_URI']}?{$server['QUERY_STRING']}";
104 | 
105 |         $request = $this->factory->createServerRequest($method, $this->createUri($uri));
106 | 
107 |         $this->assertServerRequest($request, $method, $uri);
108 |     }
109 | 
110 |     #[BackupGlobals(true)]
111 |     public function testCreateServerRequestDoesNotReadServerSuperglobal()
112 |     {
113 |         $_SERVER = ['HTTP_X_FOO' => 'bar'];
114 | 
115 |         $server = [
116 |             'REQUEST_METHOD' => 'PUT',
117 |             'REQUEST_URI' => '/test',
118 |             'QUERY_STRING' => 'super=0',
119 |             'HTTP_HOST' => 'example.org',
120 |         ];
121 | 
122 |         $request = $this->factory->createServerRequest('PUT', '/test', $server);
123 | 
124 |         $serverParams = $request->getServerParams();
125 | 
126 |         static::assertNotEquals($_SERVER, $serverParams);
127 |         static::assertArrayNotHasKey('HTTP_X_FOO', $serverParams);
128 |     }
129 | 
130 |     public function testCreateServerRequestDoesNotReadCookieSuperglobal()
131 |     {
132 |         $_COOKIE = ['foo' => 'bar'];
133 | 
134 |         $request = $this->factory->createServerRequest('POST', 'http://example.org/test');
135 | 
136 |         static::assertEmpty($request->getCookieParams());
137 |     }
138 | 
139 |     public function testCreateServerRequestDoesNotReadGetSuperglobal()
140 |     {
141 |         $_GET = ['foo' => 'bar'];
142 | 
143 |         $request = $this->factory->createServerRequest('POST', 'http://example.org/test');
144 | 
145 |         static::assertEmpty($request->getQueryParams());
146 |     }
147 | 
148 |     public function testCreateServerRequestDoesNotReadFilesSuperglobal()
149 |     {
150 |         $_FILES = [['name' => 'foobar.dat', 'type' => 'application/octet-stream', 'tmp_name' => '/tmp/php45sd3f', 'error' => UPLOAD_ERR_OK, 'size' => 4]];
151 | 
152 |         $request = $this->factory->createServerRequest('POST', 'http://example.org/test');
153 | 
154 |         static::assertEmpty($request->getUploadedFiles());
155 |     }
156 | 
157 |     public function testCreateServerRequestDoesNotReadPostSuperglobal()
158 |     {
159 |         $_POST = ['foo' => 'bar'];
160 | 
161 |         $request = $this->factory->createServerRequest('POST', 'http://example.org/test');
162 | 
163 |         static::assertEmpty($request->getParsedBody());
164 |     }
165 | }
166 | 


--------------------------------------------------------------------------------
/test/StreamFactoryTestCase.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Interop\Http\Factory;
  4 | 
  5 | use Exception;
  6 | use RuntimeException;
  7 | use PHPUnit\Framework\TestCase;
  8 | use Psr\Http\Message\StreamFactoryInterface;
  9 | use Psr\Http\Message\StreamInterface;
 10 | use function fclose;
 11 | use function file_put_contents;
 12 | use function fopen;
 13 | use function fseek;
 14 | use function ftell;
 15 | use function strlen;
 16 | use function unlink;
 17 | use const SEEK_END;
 18 | use const SEEK_SET;
 19 | 
 20 | abstract class StreamFactoryTestCase extends TestCase
 21 | {
 22 |     use StreamHelper;
 23 | 
 24 |     /**
 25 |      * @var StreamFactoryInterface
 26 |      */
 27 |     protected $factory;
 28 | 
 29 |     /**
 30 |      * @return StreamFactoryInterface
 31 |      */
 32 |     abstract protected function createStreamFactory();
 33 | 
 34 |     public function setUp(): void
 35 |     {
 36 |         $this->factory = $this->createStreamFactory();
 37 |     }
 38 | 
 39 |     protected function assertStream($stream, $content)
 40 |     {
 41 |         static::assertInstanceOf(StreamInterface::class, $stream);
 42 |         static::assertSame($content, (string) $stream);
 43 |     }
 44 | 
 45 |     public function testCreateStreamWithoutArgument()
 46 |     {
 47 |         $stream = $this->factory->createStream();
 48 | 
 49 |         $this->assertStream($stream, '');
 50 |     }
 51 | 
 52 |     public function testCreateStreamWithEmptyString()
 53 |     {
 54 |         $string = '';
 55 | 
 56 |         $stream = $this->factory->createStream($string);
 57 | 
 58 |         $this->assertStream($stream, $string);
 59 |     }
 60 | 
 61 |     public function testCreateStreamWithASCIIString()
 62 |     {
 63 |         $string = 'would you like some crumpets?';
 64 | 
 65 |         $stream = $this->factory->createStream($string);
 66 | 
 67 |         $this->assertStream($stream, $string);
 68 |     }
 69 | 
 70 |     public function testCreateStreamWithMultiByteMultiLineString()
 71 |     {
 72 |         $string = "would you\r\nlike some\n\u{1F950}?";
 73 | 
 74 |         $stream = $this->factory->createStream($string);
 75 | 
 76 |         $this->assertStream($stream, $string);
 77 |     }
 78 | 
 79 |     /**
 80 |      * @noinspection PhpUnreachableStatementInspection
 81 |      */
 82 |     public function testCreateStreamCursorPosition()
 83 |     {
 84 |         $this->markTestIncomplete('This behaviour has not been specified by PHP-FIG yet.');
 85 | 
 86 |         $string = 'would you like some crumpets?';
 87 | 
 88 |         $stream = $this->factory->createStream($string);
 89 | 
 90 |         static::assertSame(strlen($string), $stream->tell());
 91 |     }
 92 | 
 93 |     public function testCreateStreamFromFile()
 94 |     {
 95 |         $string = 'would you like some crumpets?';
 96 |         $filename = $this->createTemporaryFile();
 97 | 
 98 |         file_put_contents($filename, $string);
 99 | 
100 |         $stream = $this->factory->createStreamFromFile($filename);
101 | 
102 |         $this->assertStream($stream, $string);
103 |     }
104 | 
105 |     public function testCreateStreamFromNonExistingFile()
106 |     {
107 |         $filename = $this->createTemporaryFile();
108 |         unlink($filename);
109 | 
110 |         $this->expectException(RuntimeException::class);
111 |         $this->factory->createStreamFromFile($filename);
112 |     }
113 | 
114 |     public function testCreateStreamFromInvalidFileName()
115 |     {
116 |         $this->expectException(RuntimeException::class);
117 |         $this->factory->createStreamFromFile('');
118 |     }
119 | 
120 |     public function testCreateStreamFromFileIsReadOnlyByDefault()
121 |     {
122 |         $string = 'would you like some crumpets?';
123 |         $filename = $this->createTemporaryFile();
124 | 
125 |         $stream = $this->factory->createStreamFromFile($filename);
126 | 
127 |         $this->expectException(RuntimeException::class);
128 |         $stream->write($string);
129 |     }
130 | 
131 |     public function testCreateStreamFromFileWithWriteOnlyMode()
132 |     {
133 |         $filename = $this->createTemporaryFile();
134 | 
135 |         $stream = $this->factory->createStreamFromFile($filename, 'w');
136 | 
137 |         $this->expectException(RuntimeException::class);
138 |         $stream->read(1);
139 |     }
140 | 
141 |     public function testCreateStreamFromFileWithNoMode()
142 |     {
143 |         $filename = $this->createTemporaryFile();
144 | 
145 |         $this->expectException(Exception::class);
146 |         $this->factory->createStreamFromFile($filename, '');
147 |     }
148 | 
149 |     public function testCreateStreamFromFileWithInvalidMode()
150 |     {
151 |         $filename = $this->createTemporaryFile();
152 | 
153 |         $this->expectException(Exception::class);
154 |         $this->factory->createStreamFromFile($filename, "\u{2620}");
155 |     }
156 | 
157 |     public function testCreateStreamFromFileCursorPosition()
158 |     {
159 |         $string = 'would you like some crumpets?';
160 |         $filename = $this->createTemporaryFile();
161 | 
162 |         file_put_contents($filename, $string);
163 | 
164 |         $resource = fopen($filename, 'r');
165 |         $fopenTell = ftell($resource);
166 |         fclose($resource);
167 | 
168 |         $stream = $this->factory->createStreamFromFile($filename);
169 | 
170 |         static::assertSame($fopenTell, $stream->tell());
171 |     }
172 | 
173 |     public function testCreateStreamFromResource()
174 |     {
175 |         $string = 'would you like some crumpets?';
176 |         $resource = $this->createTemporaryResource($string);
177 | 
178 |         $stream = $this->factory->createStreamFromResource($resource);
179 | 
180 |         $this->assertStream($stream, $string);
181 |     }
182 | 
183 |     public function testCreateStreamFromResourceCursorPosition()
184 |     {
185 |         $string = 'would you like some crumpets?';
186 | 
187 |         $resource1 = $this->createTemporaryResource($string);
188 |         fseek($resource1, 0, SEEK_SET);
189 |         $stream1 = $this->factory->createStreamFromResource($resource1);
190 |         static::assertSame(0, $stream1->tell());
191 | 
192 |         $resource2 = $this->createTemporaryResource($string);
193 |         fseek($resource2, 0, SEEK_END);
194 |         $stream2 = $this->factory->createStreamFromResource($resource2);
195 |         static::assertSame(strlen($string), $stream2->tell());
196 | 
197 |         $resource3 = $this->createTemporaryResource($string);
198 |         fseek($resource3, 15, SEEK_SET);
199 |         $stream3 = $this->factory->createStreamFromResource($resource3);
200 |         static::assertSame(15, $stream3->tell());
201 |     }
202 | }
203 | 


--------------------------------------------------------------------------------