cleanup, testing.

Author: robotdan

src/main/java/io/fusionauth/http/server/io/HTTPInputStream.java

@@ -168,21 +168,6 @@ private void initialize() throws IOException {
     Long contentLength = request.getContentLength();
     boolean hasBody = (contentLength != null && contentLength > 0) || request.isChunked();
 
-    // Request order of operations:
-    //  - "hello world" -> compress -> chunked.
-
-    // Current:
-    //   Chunked:
-    //     HTTPInputStream > Chunked > Pushback > Throughput > Socket
-    //   Fixed:
-    //     HTTPInputStream > Pushback > Throughput > Socket
-
-    // New:
-    //   Chunked
-    //     HTTPInputStream > Chunked > Pushback > Decompress > Throughput > Socket
-    //   Fixed
-    //     HTTPInputStream > Pushback > Decompress > Throughput > Socket
-
     // Note that isChunked() should take precedence over the fact that we have a Content-Length.
     // - The client should not send both, but in the case they are both present we ignore Content-Length
     if (!hasBody) {
@@ -210,14 +195,16 @@ private void initialize() throws IOException {
       throw new ContentTooLargeException(maximumContentLength, detailedMessage);
     }
 
-    // The way it is currently coded
-    // HTTPInputStream (this) > Decompress > Fixed   > Pushback > Throughput > Socket
+    // Current state
+    // Chunked       HTTPInputStream (this) > Chunked > Pushback > Throughput > Socket
+    // Fixed length  HTTPInputStream (this) > Fixed   > Pushback > Throughput > Socket
 
-    // HTTPInputStream (this) > Chunked > Pushback > Throughput > Socket
-    //    > HTTPInputStream (this) > Decompress > Chunked > Pushback > Throughput > Socket
+    // When decompressing, the result will be something like this:
+    // Chunked       HTTPInputStream (this) > Decompress > Chunked > Pushback > Throughput > Socket
+    // Fixed length  HTTPInputStream (this) > Decompress> Fixed   > Pushback > Throughput > Socket
+    //
+    // You may have one or more Decompress InputStreams in the above diagram.
 
-    // TODO : Note I could leave this alone, but when we parse the header we can lower case these values and then remove the equalsIgnoreCase here?
-    //        Seems like ideally we would normalize them to lowercase earlier.
     if (hasBody) {
       // The request may contain more than one value, apply in reverse order.
       // - These are both using the default 512 buffer size.

src/test/java/io/fusionauth/http/BaseSocketTest.java

@@ -67,7 +67,7 @@ private void assertResponse(String request, String chunkedExtension, String resp
 
       if (request.contains("Transfer-Encoding: chunked")) {
         // Chunk in 100 byte increments. Using a smaller chunk size to ensure we don't end up with a single chunk.
-        body = chunkItUp(body, 100, chunkedExtension);
+        body = new String(chunkEncoded(body.getBytes(StandardCharsets.UTF_8), 100, chunkedExtension));
       }
 
       request = request.replace("{body}", body);

src/test/java/io/fusionauth/http/BaseTest.java

@@ -49,10 +49,8 @@
 import java.time.Instant;
 import java.time.ZonedDateTime;
 import java.time.format.DateTimeFormatter;
-import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Date;
-import java.util.List;
 import java.util.Map;
 import java.util.UUID;
 import java.util.stream.Collectors;
@@ -436,25 +434,29 @@ protected void assertHTTPResponseEquals(Socket socket, String expectedResponse)
     }
   }
 
-  protected String chunkItUp(String body, int chunkSize, String chunkedExtension) {
-    List<String> result = new ArrayList<>();
-    for (var i = 0; i < body.length(); i += chunkSize) {
-      var endIndex = Math.min(i + chunkSize, body.length());
-      var chunk = body.substring(i, endIndex);
-      var chunkLength = chunk.getBytes(StandardCharsets.UTF_8).length;
+  protected byte[] chunkEncoded(byte[] bytes, int chunkSize, String chunkedExtension) throws IOException {
+    ByteArrayOutputStream out = new ByteArrayOutputStream();
+    for (var i = 0; i < bytes.length; i += chunkSize) {
+      var endIndex = Math.min(i + chunkSize, bytes.length);
+
+      var chunk = Arrays.copyOfRange(bytes, i, endIndex);
+      var chunkLength = chunk.length;
 
       String hex = Integer.toHexString(chunkLength);
-      result.add(hex);
+      out.write(hex.getBytes(StandardCharsets.UTF_8));
 
       if (chunkedExtension != null) {
-        result.add(chunkedExtension);
+        out.write(chunkedExtension.getBytes(StandardCharsets.UTF_8));
       }
 
-      result.add(("\r\n" + chunk + "\r\n"));
+      out.write("\r\n".getBytes(StandardCharsets.UTF_8));
+      out.write(chunk);
+      out.write("\r\n".getBytes(StandardCharsets.UTF_8));
     }
 
-    result.add(("0\r\n\r\n"));
-    return String.join("", result);
+
+    out.write(("0\r\n\r\n".getBytes(StandardCharsets.UTF_8)));
+    return out.toByteArray();
   }
 
   protected byte[] deflate(byte[] bytes) throws Exception {

src/test/java/io/fusionauth/http/FormDataTest.java

@@ -286,7 +286,7 @@ public Builder expectResponse(String response) throws Exception {
 
           // Convert body to chunked
           // - Using a small chunk to ensure we end up with more than one chunk.
-          body = chunkItUp(body, 100, null);
+          body = new String(chunkEncoded(body.getBytes(StandardCharsets.UTF_8), 100, null));
         } else {
           var contentLength = body.getBytes(StandardCharsets.UTF_8).length;
           if (contentLength > 0) {

src/test/java/io/fusionauth/http/io/HTTPInputStreamTest.java

@@ -67,12 +67,7 @@ public void read_chunked_withPushback(String contentEncoding) throws Exception {
     }
 
     // Chunk the content, add part of the next request
-    var temp1 = payload;
-    var temp2 = new String(payload, StandardCharsets.UTF_8).getBytes(StandardCharsets.UTF_8);
-    assertEquals(temp1, temp2);
-
-    String chunked = chunkItUp(new String(payload, StandardCharsets.UTF_8), 38, null);
-    payload = chunked.getBytes(StandardCharsets.UTF_8);
+    payload = chunkEncoded(payload, 38, null);
 
     ByteArrayOutputStream out = new ByteArrayOutputStream();
     out.write(payload);