Merge pull request #329 from clue-labs/size

Assign Content-Length response header automatically only when size is known

Author: WyriHaximus

README.md

@@ -593,12 +593,12 @@ $server = new Server(function (ServerRequestInterface $request) use ($loop) {
     $stream = new ThroughStream();
 
     $timer = $loop->addPeriodicTimer(0.5, function () use ($stream) {
-        $stream->emit('data', array(microtime(true) . PHP_EOL));
+        $stream->write(microtime(true) . PHP_EOL);
     });
 
     $loop->addTimer(5, function() use ($loop, $timer, $stream) {
         $loop->cancelTimer($timer);
-        $stream->emit('end');
+        $stream->end();
     });
 
     return new Response(
@@ -675,25 +675,41 @@ in this case (if applicable).
 
 #### Response length
 
-If the response body is a `string`, a `Content-Length` header will be added
-automatically.
+If the response body size is known, a `Content-Length` response header will be
+added automatically. This is the most common use case, for example when using
+a `string` response body like this:
 
-If the response body is a ReactPHP `ReadableStreamInterface` and you do not
-specify a `Content-Length` header, outgoing HTTP/1.1 response messages will
-automatically use `Transfer-Encoding: chunked` and send the respective header
-automatically.
-The server is responsible for handling `Transfer-Encoding`, so you SHOULD NOT
-pass this header yourself.
+```php 
+$server = new Server(function (ServerRequestInterface $request) {
+    return new Response(
+        200,
+        array(
+            'Content-Type' => 'text/plain'
+        ),
+        "Hello World!\n"
+    );
+});
+```
 
-If you know the length of your stream body, you MAY specify it like this instead:
+If the response body size is unknown, a `Content-Length` response header can not
+be added automatically. When using a [streaming response](#streaming-response)
+without an explicit `Content-Length` response header, outgoing HTTP/1.1 response
+messages will automatically use `Transfer-Encoding: chunked` while legacy HTTP/1.0
+response messages will contain the plain response body. If you know the length
+of your streaming response body, you MAY want to specify it explicitly like this:
 
 ```php
-$stream = new ThroughStream();
-$server = new Server(function (ServerRequestInterface $request) use ($stream) {
+$server = new Server(function (ServerRequestInterface $request) use ($loop) {
+    $stream = new ThroughStream();
+
+    $loop->addTimer(2.0, function () use ($stream) {
+        $stream->end("Hello World!\n");
+    });
+
     return new Response(
         200,
         array(
-            'Content-Length' => '5',
+            'Content-Length' => '13',
             'Content-Type' => 'text/plain',
         ),
         $stream

src/StreamingServer.php

@@ -359,7 +359,7 @@ public function handleResponse(ConnectionInterface $connection, ServerRequestInt
         if (($method === 'CONNECT' && $code >= 200 && $code < 300) || ($code >= 100 && $code < 200) || $code === 204) {
             // 2xx response to CONNECT and 1xx and 204 MUST NOT include Content-Length or Transfer-Encoding header
             $response = $response->withoutHeader('Content-Length')->withoutHeader('Transfer-Encoding');
-        } elseif (!$body instanceof HttpBodyStream) {
+        } elseif ($body->getSize() !== null) {
             // assign Content-Length header when using a "normal" buffered body string
             $response = $response->withHeader('Content-Length', (string)$body->getSize())->withoutHeader('Transfer-Encoding');
         } elseif (!$response->hasHeader('Content-Length') && $version === '1.1') {

tests/StreamingServerTest.php

@@ -2156,6 +2156,80 @@ function ($data) use (&$buffer) {
         $this->assertContains("hello", $buffer);
     }
 
+    public function testResponseContainsResponseBodyWithTransferEncodingChunkedForBodyWithUnknownSize()
+    {
+        $body = $this->getMockBuilder('Psr\Http\Message\StreamInterface')->getMock();
+        $body->expects($this->once())->method('getSize')->willReturn(null);
+        $body->expects($this->once())->method('__toString')->willReturn('body');
+
+        $server = new StreamingServer(function (ServerRequestInterface $request) use ($body) {
+            return new Response(
+                200,
+                array(),
+                $body
+            );
+        });
+
+        $buffer = '';
+        $this->connection
+            ->expects($this->any())
+            ->method('write')
+            ->will(
+                $this->returnCallback(
+                    function ($data) use (&$buffer) {
+                        $buffer .= $data;
+                    }
+                )
+            );
+
+        $server->listen($this->socket);
+        $this->socket->emit('connection', array($this->connection));
+
+        $data = "GET / HTTP/1.1\r\nHost: localhost\r\n\r\n";
+        $this->connection->emit('data', array($data));
+
+        $this->assertContains("Transfer-Encoding: chunked", $buffer);
+        $this->assertNotContains("Content-Length:", $buffer);
+        $this->assertContains("body", $buffer);
+    }
+
+    public function testResponseContainsResponseBodyWithPlainBodyWithUnknownSizeForLegacyHttp10()
+    {
+        $body = $this->getMockBuilder('Psr\Http\Message\StreamInterface')->getMock();
+        $body->expects($this->once())->method('getSize')->willReturn(null);
+        $body->expects($this->once())->method('__toString')->willReturn('body');
+
+        $server = new StreamingServer(function (ServerRequestInterface $request) use ($body) {
+            return new Response(
+                200,
+                array(),
+                $body
+            );
+        });
+
+        $buffer = '';
+        $this->connection
+            ->expects($this->any())
+            ->method('write')
+            ->will(
+                $this->returnCallback(
+                    function ($data) use (&$buffer) {
+                        $buffer .= $data;
+                    }
+                )
+            );
+
+        $server->listen($this->socket);
+        $this->socket->emit('connection', array($this->connection));
+
+        $data = "GET / HTTP/1.0\r\nHost: localhost\r\n\r\n";
+        $this->connection->emit('data', array($data));
+
+        $this->assertNotContains("Transfer-Encoding: chunked", $buffer);
+        $this->assertNotContains("Content-Length:", $buffer);
+        $this->assertContains("body", $buffer);
+    }
+
     public function testResponseWithCustomTransferEncodingWillBeIgnoredAndUseChunkedTransferEncodingInstead()
     {
         $stream = new ThroughStream();