Code review

Author: fabianfett

Diff for: Tests/AsyncHTTPClientTests/HTTPClientTestUtils.swift

@@ -1149,14 +1149,27 @@ struct CollectEverythingLogHandler: LogHandler {
     }
 }
 
-class StreamDelegate: HTTPClientResponseDelegate {
+/// A ``HTTPClientResponseDelegate`` that buffers the incoming response parts for the consumer. The consumer can
+/// consume the bytes by calling ``next()`` on the delegate.
+///
+/// The sole purpose of this class is to enable straight-line stream tests.
+class ResponseStreamDelegate: HTTPClientResponseDelegate {
     typealias Response = Void
 
     enum State {
+        /// The delegate is in the idle state. There are no http response parts to be buffered
+        /// and the consumer did not signal a demand. Transitions to all other states are allowed.
         case idle
+        /// The consumer has signaled a demand for more bytes, but none where available. Can
+        /// transition to `.idle` (when new bytes arrive), `.finished` (when the stream finishes or fails)
         case waitingForBytes(EventLoopPromise<ByteBuffer?>)
+        /// The consumer has signaled no further demand but bytes keep arriving. Valid transitions
+        /// to `.idle` (when bytes are consumed), `.finished` (when bytes are consumed, and the
+        /// stream has ended), `.failed` (if an error is forwarded)
         case buffering(ByteBuffer, done: Bool)
+        /// Stores an error for consumption. Valid transitions are: `.finished`, when the error was consumed.
         case failed(Error)
+        /// The stream has finished and all bytes or errors where consumed.
         case finished
     }
 
@@ -1207,24 +1220,24 @@ class StreamDelegate: HTTPClientResponseDelegate {
     // MARK: HTTPClientResponseDelegate
 
     func didSendRequestHead(task: HTTPClient.Task<Response>, _ head: HTTPRequestHead) {
-        XCTAssert(self.eventLoop.inEventLoop)
+        self.eventLoop.preconditionInEventLoop()
     }
 
     func didSendRequestPart(task: HTTPClient.Task<Response>, _ part: IOData) {
-        XCTAssert(self.eventLoop.inEventLoop)
+        self.eventLoop.preconditionInEventLoop()
     }
 
     func didSendRequest(task: HTTPClient.Task<Response>) {
-        XCTAssert(self.eventLoop.inEventLoop)
+        self.eventLoop.preconditionInEventLoop()
     }
 
     func didReceiveHead(task: HTTPClient.Task<Response>, _ head: HTTPResponseHead) -> EventLoopFuture<Void> {
-        XCTAssert(self.eventLoop.inEventLoop)
+        self.eventLoop.preconditionInEventLoop()
         return task.eventLoop.makeSucceededVoidFuture()
     }
 
     func didReceiveBodyPart(task: HTTPClient.Task<Response>, _ buffer: ByteBuffer) -> EventLoopFuture<Void> {
-        XCTAssert(self.eventLoop.inEventLoop)
+        self.eventLoop.preconditionInEventLoop()
 
         switch self.state {
         case .idle:
@@ -1244,7 +1257,7 @@ class StreamDelegate: HTTPClientResponseDelegate {
     }
 
     func didReceiveError(task: HTTPClient.Task<Response>, _ error: Error) {
-        XCTAssert(self.eventLoop.inEventLoop)
+        self.eventLoop.preconditionInEventLoop()
 
         switch self.state {
         case .idle:
@@ -1260,7 +1273,7 @@ class StreamDelegate: HTTPClientResponseDelegate {
     }
 
     func didFinishRequest(task: HTTPClient.Task<Response>) throws {
-        XCTAssert(self.eventLoop.inEventLoop)
+        self.eventLoop.preconditionInEventLoop()
 
         switch self.state {
         case .idle:

Diff for: Tests/AsyncHTTPClientTests/HTTPClientTests.swift

@@ -2831,21 +2831,23 @@ class HTTPClientTests: XCTestCase {
         let httpClient = HTTPClient(eventLoopGroupProvider: .shared(eventLoopGroup))
         defer { XCTAssertNoThrow(try httpClient.syncShutdown()) }
 
-        let delegate = StreamDelegate(eventLoop: delegateEL)
+        let delegate = ResponseStreamDelegate(eventLoop: delegateEL)
 
         let body: HTTPClient.Body = .stream { writer in
             let finalPromise = writeEL.makePromise(of: Void.self)
 
             func writeLoop(_ writer: HTTPClient.Body.StreamWriter, index: Int) {
-                XCTAssert(writeEL.inEventLoop, "Always write from unexpected el")
+                // always invoke from the wrong el to test thread safety
+                writeEL.preconditionInEventLoop()
 
                 if index >= 30 {
                     return finalPromise.succeed(())
                 }
 
                 let sent = ByteBuffer(integer: index)
                 writer.write(.byteBuffer(sent)).flatMap { () -> EventLoopFuture<ByteBuffer?> in
-                    XCTAssert(delegateEL.inEventLoop, "Always dispatch back to delegate el")
+                    // ensure, that the writer dispatches back to the expected delegate el.
+                    delegateEL.preconditionInEventLoop()
                     return delegate.next()
                 }.whenComplete { result in
                     switch result {