Support parsing HTTP responses where the body length is not known

tests/standalone/src/io/HttpParserTest.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #source("../../../../runtime/bin/http_parser.dart");
 
 class HttpParserTest {
   static void runAllTests() {
     testParseRequest();
     testParseResponse();
@@ skipping 83 matching lines @@
     testWrite(requestData, 10);
     testWrite(requestData, 1);
   }
 
   static void _testParseResponse(String response,
                                  int expectedStatusCode,
                                  String expectedReasonPhrase,
                                  [int expectedContentLength = 0,
                                   int expectedBytesReceived = 0,
                                   Map expectedHeaders = null,
-                                  bool chunked = false]) {
+                                  bool chunked = false,
+                                  bool close = false]) {
     _HttpParser httpParser;
     bool headersCompleteCalled;
     bool dataEndCalled;
     int statusCode;
     String reasonPhrase;
     Map headers;
     int contentLength;
     int bytesReceived;
 
     void reset() {
       httpParser = new _HttpParser();
       httpParser.requestStart = (m, u) => Expect.fail("Expected response");
       httpParser.responseStart = (s, r) {
         statusCode = s;
         reasonPhrase = r;
       };
       httpParser.headerReceived = (f, v) {
         Expect.isFalse(headersCompleteCalled);
         headers[f] = v;
       };
       httpParser.headersComplete = () {
         Expect.isFalse(headersCompleteCalled);
-        if (!chunked) {
+        if (!chunked && !close) {
           Expect.equals(expectedContentLength, httpParser.contentLength);
         } else {
           Expect.equals(-1, httpParser.contentLength);
         }
         if (expectedHeaders != null) {
           expectedHeaders.forEach((String name, String value) {
             Expect.equals(value, headers[name]);
           });
         }
         headersCompleteCalled = true;
@@ skipping 21 matching lines @@
     }
 
     void testWrite(List<int> requestData, [int chunkSize = -1]) {
       if (chunkSize == -1) chunkSize = requestData.length;
       reset();
       for (int pos = 0; pos < requestData.length; pos += chunkSize) {
         int remaining = requestData.length - pos;
         int writeLength = Math.min(chunkSize, remaining);
         httpParser.writeList(requestData, pos, writeLength);
       }
+      if (close) httpParser.connectionClosed();
       checkExpectations();
     }
 
     void testWriteAll(List<int> requestData) {
       reset();
       httpParser.writeList(requestData, 0, requestData.length);
       checkExpectations();
     }
 
     // Test parsing the request three times delivering the data in
     // different chunks.
     List<int> responseData = response.charCodes();
     testWrite(responseData);
     testWrite(responseData, 10);
     testWrite(responseData, 1);
   }
 
   static void testParseRequest() {
     String request;
     Map headers;
-    request = "GET / HTTP/1.1\r\n\r\n";
+    request = "GET / HTTP/1.1\r\nContent-Length: 0\r\n\r\n";
     _testParseRequest(request, "GET", "/");
 
-    request = "POST / HTTP/1.1\r\n\r\n";
+    request = "POST / HTTP/1.1\r\nContent-Length: 0\r\n\r\n";
     _testParseRequest(request, "POST", "/");
 
-    request = "GET /index.html HTTP/1.1\r\n\r\n";
+    request = "GET /index.html HTTP/1.1\r\nContent-Length: 0\r\n\r\n";
     _testParseRequest(request, "GET", "/index.html");
 
-    request = "POST /index.html HTTP/1.1\r\n\r\n";
+    request = "POST /index.html HTTP/1.1\r\nContent-Length: 0\r\n\r\n";
     _testParseRequest(request, "POST", "/index.html");
 
-    request = "H /index.html HTTP/1.1\r\n\r\n";
+    request = "H /index.html HTTP/1.1\r\nContent-Length: 0\r\n\r\n";
     _testParseRequest(request, "H", "/index.html");
 
-    request = "HT /index.html HTTP/1.1\r\n\r\n";
+    request = "HT /index.html HTTP/1.1\r\nContent-Length: 0\r\n\r\n";
     _testParseRequest(request, "HT", "/index.html");
 
-    request = "HTT /index.html HTTP/1.1\r\n\r\n";
+    request = "HTT /index.html HTTP/1.1\r\nContent-Length: 0\r\n\r\n";
     _testParseRequest(request, "HTT", "/index.html");
 
-    request = "HTTP /index.html HTTP/1.1\r\n\r\n";
+    request = "HTTP /index.html HTTP/1.1\r\nContent-Length: 0\r\n\r\n";
     _testParseRequest(request, "HTTP", "/index.html");
 
     request = """
 POST /test HTTP/1.1\r
 AAA: AAA\r
 Content-Length: 0\r
 \r
 """;
     _testParseRequest(request, "POST", "/test");
 
     request = """
 POST /test HTTP/1.1\r
 content-length: 0\r
 \r
 """;
     _testParseRequest(request, "POST", "/test");
 
     request = """
 POST /test HTTP/1.1\r
+Content-Length: 0\r
 Header-A: AAA\r
 X-Header-B: bbb\r
 \r
 """;
     headers = new Map();
     headers["header-a"] = "AAA";
     headers["x-header-b"] = "bbb";
-    _testParseRequest(request, "POST", "/test", 0, 0, headers);
+    _testParseRequest(request, "POST", "/test", expectedHeaders: headers);
 
     request = """
 POST /test HTTP/1.1\r
+Content-Length: 0\r
 Header-A:   AAA\r
 X-Header-B:\t \t bbb\r
 \r
 """;
     headers = new Map();
     headers["header-a"] = "AAA";
     headers["x-header-b"] = "bbb";
-    _testParseRequest(request, "POST", "/test", 0, 0, headers);
+    _testParseRequest(request, "POST", "/test", expectedHeaders: headers);
 
     request = """
 POST /test HTTP/1.1\r
+Content-Length: 0\r
 Header-A:   AA\r
  A\r
 X-Header-B:           b\r
   b\r
 \t    b\r
 \r
 """;
     headers = new Map();
     headers["header-a"] = "AAA";
     headers["x-header-b"] = "bbb";
-    _testParseRequest(request, "POST", "/test", 0, 0, headers);
+    _testParseRequest(request, "POST", "/test", expectedHeaders: headers);
 
     request = """
 POST /test HTTP/1.1\r
 Content-Length: 10\r
 \r
 0123456789""";
-    _testParseRequest(request, "POST", "/test", 10, 10);
+    _testParseRequest(request,
+                      "POST",
+                      "/test",
+                      expectedContentLength: 10,
+                      expectedBytesReceived: 10);
 
     // Test chunked encoding.
     request = """
 POST /test HTTP/1.1\r
 Transfer-Encoding: chunked\r
 \r
 5\r
 01234\r
 5\r
 56789\r
 0\r\n\r\n""";
-    _testParseRequest(request, "POST", "/test", -1, 10, null, true);
+    _testParseRequest(request,
+                      "POST",
+                      "/test",
+                      expectedContentLength: -1,
+                      expectedBytesReceived: 10,
+                      chunked: true);
 
     // Test mixing chunked encoding and content length (content length
     // is ignored).
     request = """
 POST /test HTTP/1.1\r
 Content-Length: 7\r
 Transfer-Encoding: chunked\r
 \r
 5\r
 01234\r
 5\r
 56789\r
 0\r\n\r\n""";
-    _testParseRequest(request, "POST", "/test", -1, 10, null, true);
+    _testParseRequest(request,
+                      "POST",
+                      "/test",
+                      expectedContentLength: -1,
+                      expectedBytesReceived: 10,
+                      chunked: true);
 
     // Test mixing chunked encoding and content length (content length
     // is ignored).
     request = """
 POST /test HTTP/1.1\r
 Transfer-Encoding: chunked\r
 Content-Length: 3\r
 \r
 5\r
 01234\r
 5\r
 56789\r
 0\r\n\r\n""";
-    _testParseRequest(request, "POST", "/test", -1, 10, null, true);
+    _testParseRequest(request,
+                      "POST",
+                      "/test",
+                      expectedContentLength: -1,
+                      expectedBytesReceived: 10,
+                      chunked: true);
 
     // Test upper and lower case hex digits in chunked encoding.
     request = """
 POST /test HTTP/1.1\r
 Transfer-Encoding: chunked\r
 \r
 1E\r
 012345678901234567890123456789\r
 1e\r
 012345678901234567890123456789\r
 0\r\n\r\n""";
-    _testParseRequest(request, "POST", "/test", -1, 60, null, true);
+    _testParseRequest(request,
+                      "POST",
+                      "/test",
+                      expectedContentLength: -1,
+                      expectedBytesReceived: 60,
+                      chunked: true);
   }
 
   static void testParseResponse() {
     String response;
     Map headers;
-    response = "HTTP/1.1 200 OK\r\n\r\n";
+    response = "HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n";
     _testParseResponse(response, 200, "OK");
 
-    response = "HTTP/1.1 404 Not found\r\n\r\n";
+    response = "HTTP/1.1 404 Not found\r\nContent-Length: 0\r\n\r\n";
     _testParseResponse(response, 404, "Not found");
 
-    response = "HTTP/1.1 500 Server error\r\n\r\n";
+    response = "HTTP/1.1 500 Server error\r\nContent-Length: 0\r\n\r\n";
     _testParseResponse(response, 500, "Server error");
 
     // Test content.
     response = """
 HTTP/1.1 200 OK\r
 Content-Length: 20\r
 \r
 01234567890123456789""";
 
-    _testParseResponse(response, 200, "OK", 20, 20);
+    _testParseResponse(response,
+                       200,
+                       "OK",
+                       expectedContentLength: 20,
+                       expectedBytesReceived: 20);
+
     // Test upper and lower case hex digits in chunked encoding.
     response = """
 HTTP/1.1 200 OK\r
 Transfer-Encoding: chunked\r
 \r
 1A\r
 01234567890123456789012345\r
 1f\r
 0123456789012345678901234567890\r
 0\r\n\r\n""";
-    _testParseResponse(response, 200, "OK", -1, 57, null, true);
+    _testParseResponse(response,
+                       200,
+                       "OK",
+                       expectedContentLength: -1,
+                       expectedBytesReceived: 57,
+                       chunked: true);
+
+    // Test HTTP response without any transfer length indications
+    // where closing the connections indicated end of body.
+    response = """
+HTTP/1.1 200 OK\r
+\r
+01234567890123456789012345
+0123456789012345678901234567890
+""";
+  _testParseResponse(response,
+                     200,
+                     "OK",
+                     expectedContentLength: -1,
+                     expectedBytesReceived: 59,
+                     close: true);
   }
 }
 
 
 void main() {
   HttpParserTest.runAllTests();
 }