Fixes the DelayOnHeadDelegate test utility

Currently the DelayOnHeadDelegate test utility depends on correct timings. Right now, if a request is slower than 50ms in  `testErrorAfterCloseWhileBackpressureExerted` the test will fail, since the backpressure promise is failed, before a head was received. This pr fixes this, by giving the user a callback, when the head was received.

Author: fabianfett

Diff for: Tests/AsyncHTTPClientTests/HTTPClientTestUtils.swift

@@ -104,36 +104,44 @@ class CountingDelegate: HTTPClientResponseDelegate {
 class DelayOnHeadDelegate: HTTPClientResponseDelegate {
     typealias Response = ByteBuffer
 
-    let promise: EventLoopPromise<Void>
+    let eventLoop: EventLoop
+    let didReceiveHead: (HTTPResponseHead, EventLoopPromise<Void>) -> Void
 
     private var data: ByteBuffer
 
     private var mayReceiveData = false
 
     private var expectError = false
 
-    init(promise: EventLoopPromise<Void>) {
-        self.promise = promise
+    init(eventLoop: EventLoop, didReceiveHead: @escaping (HTTPResponseHead, EventLoopPromise<Void>) -> Void) {
+        self.eventLoop = eventLoop
+        self.didReceiveHead = didReceiveHead
         self.data = ByteBuffer()
-
-        self.promise.futureResult.whenSuccess {
-            self.mayReceiveData = true
-        }
-        self.promise.futureResult.whenFailure { (_: Error) in
-            self.expectError = true
-        }
     }
 
     func didReceiveHead(task: HTTPClient.Task<Response>, _ head: HTTPResponseHead) -> EventLoopFuture<Void> {
+        XCTAssertFalse(self.mayReceiveData)
         XCTAssertFalse(self.expectError)
-        return self.promise.futureResult.hop(to: task.eventLoop)
+
+        let promise = self.eventLoop.makePromise(of: Void.self)
+        promise.futureResult.whenComplete {
+            switch $0 {
+            case .success:
+                self.mayReceiveData = true
+            case .failure:
+                self.expectError = true
+            }
+        }
+
+        self.didReceiveHead(head, promise)
+        return promise.futureResult
     }
 
     func didReceiveBodyPart(task: HTTPClient.Task<Response>, _ buffer: ByteBuffer) -> EventLoopFuture<Void> {
         XCTAssertTrue(self.mayReceiveData)
         XCTAssertFalse(self.expectError)
         self.data.writeImmutableBuffer(buffer)
-        return self.promise.futureResult.hop(to: task.eventLoop)
+        return self.eventLoop.makeSucceededFuture(())
     }
 
     func didFinishRequest(task: HTTPClient.Task<Response>) throws -> Response {

Diff for: Tests/AsyncHTTPClientTests/HTTPClientTests.swift

@@ -2895,16 +2895,14 @@ class HTTPClientTests: XCTestCase {
 
     func testCloseWhileBackpressureIsExertedIsFine() throws {
         let request = try Request(url: self.defaultHTTPBinURLPrefix + "close-on-response")
-        let backpressurePromise = self.defaultClient.eventLoopGroup.next().makePromise(of: Void.self)
-
-        let resultFuture = self.defaultClient.execute(
-            request: request, delegate: DelayOnHeadDelegate(promise: backpressurePromise)
-        )
-
-        self.defaultClient.eventLoopGroup.next().scheduleTask(in: .milliseconds(50)) {
-            backpressurePromise.succeed(())
+        let delegate = DelayOnHeadDelegate(eventLoop: self.clientGroup.next()) { _, promise in
+            promise.futureResult.eventLoop.scheduleTask(in: .milliseconds(50)) {
+                promise.succeed(())
+            }
         }
 
+        let resultFuture = self.defaultClient.execute(request: request, delegate: delegate)
+
         // The full response must be correctly delivered.
         var data = try resultFuture.wait()
         guard let info = try data.readJSONDecodable(RequestInfo.self, length: data.readableBytes) else {
@@ -2920,16 +2918,12 @@ class HTTPClientTests: XCTestCase {
         }
 
         let request = try Request(url: self.defaultHTTPBinURLPrefix + "close-on-response")
-        let backpressurePromise = self.defaultClient.eventLoopGroup.next().makePromise(of: Void.self)
-
-        let resultFuture = self.defaultClient.execute(
-            request: request, delegate: DelayOnHeadDelegate(promise: backpressurePromise)
-        )
-
-        self.defaultClient.eventLoopGroup.next().scheduleTask(in: .milliseconds(50)) {
+        let delegate = DelayOnHeadDelegate(eventLoop: self.clientGroup.next()) { _, backpressurePromise in
             backpressurePromise.fail(ExpectedError.expected)
         }
 
+        let resultFuture = self.defaultClient.execute(request: request, delegate: delegate)
+
         // The task must be failed.
         XCTAssertThrowsError(try resultFuture.wait()) { error in
             XCTAssertEqual(error as? ExpectedError, .expected)