Address review comments

Author: dnadoba

Sources/AsyncHTTPClient/HTTPHandler.swift

@@ -368,7 +368,10 @@ public final class ResponseAccumulator: HTTPClientResponseDelegate {
     }
 
     public struct ResponseTooBigError: Error, CustomStringConvertible {
-        var maxBodySize: Int
+        public var maxBodySize: Int
+        public init(maxBodySize: Int) {
+            self.maxBodySize = maxBodySize
+        }
 
         public var description: String {
             return "ResponseTooBigError: received response body exceeds maximum accepted size of \(self.maxBodySize) bytes"
@@ -385,24 +388,35 @@ public final class ResponseAccumulator: HTTPClientResponseDelegate {
     ///
     /// Default is 2^32.
     /// - precondition: not allowed to exceed 2^32 because ``ByteBuffer`` can not store more bytes
-    public var maxBodySize: Int = maxByteBufferSize {
-        didSet {
-            precondition(self.maxBodySize >= 0, "maxBodyLength is not allowed to be negative")
-            precondition(
-                self.maxBodySize <= Self.maxByteBufferSize,
-                "maxBodyLength is not allowed to exceed 2^32 because ByteBuffer can not store more bytes"
-            )
-        }
-    }
+    public let maxBodySize: Int
 
-    public init(request: HTTPClient.Request) {
+    public convenience init(request: HTTPClient.Request) {
+        self.init(request: request, maxBodySize: Self.maxByteBufferSize)
+    }
+    
+    /// - Parameters:
+    ///   - request: The corresponding request of the response this delegate will be accumulating.
+    ///   - maxBodySize: Maximum size in bytes of the HTTP response body that ``ResponseAccumulator`` will accept
+    ///   until it will abort the request and throw an ``ResponseTooBigError``.
+    ///   Default is 2^32.
+    /// - precondition: maxBodySize is not allowed to exceed 2^32 because ``ByteBuffer`` can not store more bytes
+    /// - warning: You can use ``ResponseAccumulator`` for just one request.
+    /// If you start another request, you need to initiate another ``ResponseAccumulator``.
+    public init(request: HTTPClient.Request, maxBodySize: Int) {
+        precondition(maxBodySize >= 0, "maxBodyLength is not allowed to be negative")
+        precondition(
+            maxBodySize <= Self.maxByteBufferSize,
+            "maxBodyLength is not allowed to exceed 2^32 because ByteBuffer can not store more bytes"
+        )
         self.request = request
+        self.maxBodySize = maxBodySize
     }
 
     public func didReceiveHead(task: HTTPClient.Task<Response>, _ head: HTTPResponseHead) -> EventLoopFuture<Void> {
         switch self.state {
         case .idle:
-            if let contentLength = head.headers.first(name: "Content-Length"),
+            if request.method != .HEAD,
+               let contentLength = head.headers.first(name: "Content-Length"),
                let announcedBodySize = Int(contentLength),
                announcedBodySize > self.maxBodySize {
                 let error = ResponseTooBigError(maxBodySize: maxBodySize)

Tests/AsyncHTTPClientTests/HTTPClientTestUtils.swift

@@ -1331,6 +1331,25 @@ class HTTPEchoHandler: ChannelInboundHandler {
     }
 }
 
+final class HTTPEchoHeaders: ChannelInboundHandler {
+    typealias InboundIn = HTTPServerRequestPart
+    typealias OutboundOut = HTTPServerResponsePart
+
+    func channelRead(context: ChannelHandlerContext, data: NIOAny) {
+        let request = self.unwrapInboundIn(data)
+        switch request {
+        case .head(let requestHead):
+            context.writeAndFlush(self.wrapOutboundOut(.head(.init(version: .http1_1, status: .ok, headers: requestHead.headers))), promise: nil)
+        case .body:
+            break
+        case .end:
+            context.writeAndFlush(self.wrapOutboundOut(.end(nil))).whenSuccess {
+                context.close(promise: nil)
+            }
+        }
+    }
+}
+
 final class HTTP200DelayedHandler: ChannelInboundHandler {
     typealias InboundIn = HTTPServerRequestPart
     typealias OutboundOut = HTTPServerResponsePart

Tests/AsyncHTTPClientTests/HTTPClientTests.swift

@@ -3100,11 +3100,9 @@ class HTTPClientTests: XCTestCase {
 
         var request = try Request(url: httpBin.baseURL)
         request.body = .byteBuffer(body)
-        let delegate = ResponseAccumulator(request: request)
-        delegate.maxBodySize = 10
         XCTAssertThrowsError(try self.defaultClient.execute(
             request: request,
-            delegate: delegate
+            delegate: ResponseAccumulator(request: request, maxBodySize: 10)
         ).wait()) { error in
             XCTAssertTrue(error is ResponseAccumulator.ResponseTooBigError, "unexpected error \(error)")
         }
@@ -3118,15 +3116,29 @@ class HTTPClientTests: XCTestCase {
 
         var request = try Request(url: httpBin.baseURL)
         request.body = .byteBuffer(body)
-        let delegate = ResponseAccumulator(request: request)
-        delegate.maxBodySize = 10
         let response = try self.defaultClient.execute(
             request: request,
-            delegate: delegate
+            delegate: ResponseAccumulator(request: request, maxBodySize: 10)
         ).wait()
 
         XCTAssertEqual(response.body, body)
     }
+    
+    func testResponseAccumulatorMaxBodySizeLimitExceedingWithContentLengthButMethodIsHead() throws {
+        let httpBin = HTTPBin(.http1_1(ssl: false, compress: false)) { _ in HTTPEchoHeaders() }
+        defer { XCTAssertNoThrow(try httpBin.shutdown()) }
+
+        let body = ByteBuffer(bytes: 0..<11)
+
+        var request = try Request(url: httpBin.baseURL, method: .HEAD)
+        request.body = .byteBuffer(body)
+        let response = try self.defaultClient.execute(
+            request: request,
+            delegate: ResponseAccumulator(request: request, maxBodySize: 10)
+        ).wait()
+
+        XCTAssertEqual(response.body ?? ByteBuffer(), ByteBuffer())
+    }
 
     func testResponseAccumulatorMaxBodySizeLimitExceedingWithTransferEncodingChuncked() throws {
         let httpBin = HTTPBin(.http1_1(ssl: false, compress: false)) { _ in HTTPEchoHandler() }
@@ -3138,11 +3150,9 @@ class HTTPClientTests: XCTestCase {
         request.body = .stream { writer in
             writer.write(.byteBuffer(body))
         }
-        let delegate = ResponseAccumulator(request: request)
-        delegate.maxBodySize = 10
         XCTAssertThrowsError(try self.defaultClient.execute(
             request: request,
-            delegate: delegate
+            delegate: ResponseAccumulator(request: request, maxBodySize: 10)
         ).wait()) { error in
             XCTAssertTrue(error is ResponseAccumulator.ResponseTooBigError, "unexpected error \(error)")
         }
@@ -3158,11 +3168,9 @@ class HTTPClientTests: XCTestCase {
         request.body = .stream { writer in
             writer.write(.byteBuffer(body))
         }
-        let delegate = ResponseAccumulator(request: request)
-        delegate.maxBodySize = 10
         let response = try self.defaultClient.execute(
             request: request,
-            delegate: delegate
+            delegate: ResponseAccumulator(request: request, maxBodySize: 10)
         ).wait()
 
         XCTAssertEqual(response.body, body)