Formatting and linux tests

Author: dnadoba

Sources/AsyncHTTPClient/ConnectionPool/HTTP1/HTTP1ClientChannelHandler.swift

@@ -186,10 +186,10 @@ final class HTTP1ClientChannelHandler: ChannelDuplexHandler {
         case .sendRequestHead(let head, let sendEnd):
             self.sendRequestHead(head, sendEnd: sendEnd, context: context)
         case .notifyRequestHeadSendSuccessfully(let resumeRequestBodyStream, let startIdleTimer):
-            
-            request!.requestHeadSent()
+
+            self.request!.requestHeadSent()
             if resumeRequestBodyStream {
-                request!.resumeRequestBodyStream()
+                self.request!.resumeRequestBodyStream()
             }
             if startIdleTimer {
                 if let timeoutAction = self.idleReadTimeoutStateMachine?.requestEndSent() {

Sources/AsyncHTTPClient/ConnectionPool/HTTP1/HTTP1ConnectionStateMachine.swift

@@ -354,9 +354,9 @@ struct HTTP1ConnectionStateMachine {
             return state.modify(with: action)
         }
     }
-    
+
     mutating func headSent() -> Action {
-        guard case .inRequest(var requestStateMachine, let close) = state else {
+        guard case .inRequest(var requestStateMachine, let close) = self.state else {
             return .wait
         }
         return self.avoidingStateMachineCoW { state in
@@ -479,7 +479,6 @@ extension HTTP1ConnectionStateMachine.State {
 
         case .failSendStreamFinished(let error, let writePromise):
             return .failSendStreamFinished(error, writePromise)
-
         }
     }
 }

Sources/AsyncHTTPClient/ConnectionPool/HTTP2/HTTP2ClientRequestHandler.swift

@@ -143,9 +143,9 @@ final class HTTP2ClientRequestHandler: ChannelDuplexHandler {
         case .sendRequestHead(let head, let sendEnd):
             self.sendRequestHead(head, sendEnd: sendEnd, context: context)
         case .notifyRequestHeadSendSuccessfully(let resumeRequestBodyStream, let startIdleTimer):
-            request!.requestHeadSent()
+            self.request!.requestHeadSent()
             if resumeRequestBodyStream {
-                request!.resumeRequestBodyStream()
+                self.request!.resumeRequestBodyStream()
             }
             if startIdleTimer {
                 if let timeoutAction = self.idleReadTimeoutStateMachine?.requestEndSent() {

Sources/AsyncHTTPClient/ConnectionPool/HTTPRequestStateMachine.swift

@@ -23,21 +23,21 @@ struct HTTPRequestStateMachine {
         ///  - `.waitForChannelToBecomeWritable` (if the channel becomes non writable while sending the header)
         ///  - `.sendingHead` if the channel is writable
         case initialized
-        
+
         /// Waiting for the channel to be writable. Valid transitions are:
         ///  - `.running(.streaming, .waitingForHead)` (once the Channel is writable again and if a request body is expected)
         ///  - `.running(.endSent, .waitingForHead)` (once the Channel is writable again and no request body is expected)
         ///  - `.failed` (if a connection error occurred)
         case waitForChannelToBecomeWritable(HTTPRequestHead, RequestFramingMetadata)
-        
+
         /// A request is on the wire. Valid transitions are:
         ///  - `.finished`
         ///  - `.failed`
         case running(RequestState, ResponseState)
-        
+
         /// The request has completed successfully
         case finished
-        
+
         /// The request has failed
         case failed(Error)
 
@@ -715,12 +715,12 @@ struct HTTPRequestStateMachine {
             return .sendRequestHead(head, sendEnd: false)
         }
     }
-    
+
     mutating func headSent() -> Action {
         switch self.state {
         case .initialized, .waitForChannelToBecomeWritable, .finished:
             preconditionFailure("Not a valid transition after `.sendingHeader`: \(self.state)")
-            
+
         case .running(.streaming(let expectedBodyLength, let sentBodyBytes, producer: .paused), let responseState):
             let startProducing = self.isChannelWritable && expectedBodyLength != sentBodyBytes
             self.state = .running(.streaming(
@@ -738,10 +738,9 @@ struct HTTPRequestStateMachine {
             preconditionFailure("request body producing can not start before we have successfully send the header \(self.state)")
         case .failed:
             return .wait
-            
+
         case .modifying:
             preconditionFailure("Invalid state: \(self.state)")
-        
         }
     }
 }

Tests/AsyncHTTPClientTests/HTTP1ConnectionStateMachineTests.swift

@@ -179,7 +179,7 @@ class HTTP1ConnectionStateMachineTests: XCTestCase {
         XCTAssertEqual(newRequestAction, .sendRequestHead(requestHead, sendEnd: true))
 
         XCTAssertEqual(state.channelInactive(), .failRequest(HTTPClientError.remoteConnectionClosed, .none))
-        
+
         XCTAssertEqual(state.headSent(), .wait)
     }
 
@@ -306,7 +306,7 @@ extension HTTP1ConnectionStateMachine.Action: Equatable {
 
         case (.sendRequestHead(let lhsHead, let lhsStartBody), .sendRequestHead(let rhsHead, let rhsStartBody)):
             return lhsHead == rhsHead && lhsStartBody == rhsStartBody
-            
+
         case (
             .notifyRequestHeadSendSuccessfully(let lhsResumeRequestBodyStream, let lhsStartIdleTimer),
             .notifyRequestHeadSendSuccessfully(let rhsResumeRequestBodyStream, let rhsStartIdleTimer)

Tests/AsyncHTTPClientTests/HTTP2ClientRequestHandlerTests+XCTest.swift

@@ -30,6 +30,7 @@ extension HTTP2ClientRequestHandlerTests {
             ("testIdleReadTimeout", testIdleReadTimeout),
             ("testIdleReadTimeoutIsCanceledIfRequestIsCanceled", testIdleReadTimeoutIsCanceledIfRequestIsCanceled),
             ("testWriteHTTPHeadFails", testWriteHTTPHeadFails),
+            ("testChannelBecomesNonWritableDuringHeaderWrite", testChannelBecomesNonWritableDuringHeaderWrite),
         ]
     }
 }

Tests/AsyncHTTPClientTests/HTTP2ClientRequestHandlerTests.swift

@@ -345,7 +345,7 @@ class HTTP2ClientRequestHandlerTests: XCTestCase {
             XCTAssertEqual(embedded.isActive, false)
         }
     }
-    
+
     func testChannelBecomesNonWritableDuringHeaderWrite() throws {
         final class ChangeWritabilityOnFlush: ChannelOutboundHandler {
             typealias OutboundIn = Any

Tests/AsyncHTTPClientTests/HTTPClientTestUtils.swift

@@ -343,7 +343,7 @@ internal final class HTTPBin<RequestHandler: ChannelInboundHandler> where
                 return compress
             }
         }
-        
+
         var httpSettings: HTTP2Settings {
             switch self {
             case .http1_1, .http2(_, nil), .refuse:

Tests/AsyncHTTPClientTests/HTTPClientTests+XCTest.swift

@@ -144,6 +144,7 @@ extension HTTPClientTests {
             ("testMassiveDownload", testMassiveDownload),
             ("testShutdownWithFutures", testShutdownWithFutures),
             ("testMassiveHeaderHTTP1", testMassiveHeaderHTTP1),
+            ("testMassiveHeaderHTTP2", testMassiveHeaderHTTP2),
         ]
     }
 }

Tests/AsyncHTTPClientTests/HTTPClientTests.swift

@@ -3377,22 +3377,22 @@ final class HTTPClientTests: XCTestCaseHTTPClientTestsBaseClass {
 
         XCTAssertNoThrow(try defaultClient.execute(request: request).wait())
     }
-    
+
     func testMassiveHeaderHTTP2() throws {
         let bin = HTTPBin(.http2(settings: [
             .init(parameter: .maxConcurrentStreams, value: 100),
             .init(parameter: .maxHeaderListSize, value: 1024 * 256),
             .init(parameter: .maxFrameSize, value: 1024 * 256),
         ]))
         defer { XCTAssertNoThrow(try bin.shutdown()) }
-        
+
         let client = HTTPClient(
             eventLoopGroupProvider: .shared(clientGroup),
             configuration: .init(certificateVerification: .none)
         )
-        
+
         defer { XCTAssertNoThrow(try client.syncShutdown()) }
-        
+
         var request = try HTTPClient.Request(url: bin.baseURL, method: .POST)
         // add ~200 KB header
         let headerValue = String(repeating: "0", count: 1024)