notify delegate about connect errors

Sources/AsyncHTTPClient/ConnectionPool.swift

@@ -562,7 +562,7 @@ class HTTP1ConnectionProvider {
                     error = HTTPClient.NWErrorHandler.translateError(error)
                 }
             #endif
-            return self.eventLoop.makeFailedFuture(error)
+            return eventLoop.makeFailedFuture(error)
         }
     }
 

Sources/AsyncHTTPClient/HTTPClient.swift

@@ -511,6 +511,14 @@ public class HTTPClient {
                                                  deadline: deadline,
                                                  setupComplete: setupComplete.futureResult,
                                                  logger: logger)
+
+        let taskHandler = TaskHandler(task: task,
+                                      kind: request.kind,
+                                      delegate: delegate,
+                                      redirectHandler: redirectHandler,
+                                      ignoreUncleanSSLShutdown: self.configuration.ignoreUncleanSSLShutdown,
+                                      logger: logger)
+
         connection.flatMap { connection -> EventLoopFuture<Void> in
             logger.debug("got connection for request",
                          metadata: ["ahc-connection": "\(connection)",
@@ -527,12 +535,6 @@ public class HTTPClient {
             }
 
             return future.flatMap {
-                let taskHandler = TaskHandler(task: task,
-                                              kind: request.kind,
-                                              delegate: delegate,
-                                              redirectHandler: redirectHandler,
-                                              ignoreUncleanSSLShutdown: self.configuration.ignoreUncleanSSLShutdown,
-                                              logger: logger)
                 return channel.pipeline.addHandler(taskHandler)
             }.flatMap {
                 task.setConnection(connection)
@@ -556,7 +558,12 @@ public class HTTPClient {
             }
         }.always { _ in
             setupComplete.succeed(())
-        }.cascadeFailure(to: task.promise)
+        }.whenFailure { error in
+            taskHandler.callOutToDelegateFireAndForget { task in
+                delegate.didReceiveError(task: task, error)
+            }
+            task.promise.fail(error)
+        }
 
         return task
     }

Tests/AsyncHTTPClientTests/HTTPClientInternalTests+XCTest.swift

@@ -43,6 +43,7 @@ extension HTTPClientInternalTests {
             ("testUploadStreamingIsCalledOnTaskEL", testUploadStreamingIsCalledOnTaskEL),
             ("testWeCanActuallyExactlySetTheEventLoops", testWeCanActuallyExactlySetTheEventLoops),
             ("testTaskPromiseBoundToEL", testTaskPromiseBoundToEL),
+            ("testConnectErrorCalloutOnCorrectEL", testConnectErrorCalloutOnCorrectEL),
         ]
     }
 }

Tests/AsyncHTTPClientTests/HTTPClientInternalTests.swift

@@ -959,4 +959,43 @@ class HTTPClientInternalTests: XCTestCase {
         XCTAssertTrue(task.futureResult.eventLoop === el2)
         XCTAssertNoThrow(try task.wait())
     }
+
+    func testConnectErrorCalloutOnCorrectEL() throws {
+        class TestDelegate: HTTPClientResponseDelegate {
+            typealias Response = Void
+
+            let expectedEL: EventLoop
+            var receivedError: Bool = false
+
+            init(expectedEL: EventLoop) {
+                self.expectedEL = expectedEL
+            }
+
+            func didFinishRequest(task: HTTPClient.Task<Void>) throws {}
+
+            func didReceiveError(task: HTTPClient.Task<Void>, _ error: Error) {
+                self.receivedError = true
+                XCTAssertTrue(self.expectedEL.inEventLoop)
+            }
+        }
+
+        let elg = getDefaultEventLoopGroup(numberOfThreads: 2)
+        let el1 = elg.next()
+        let el2 = elg.next()
+
+        let httpBin = HTTPBin(refusesConnections: true)
+        let client = HTTPClient(eventLoopGroupProvider: .shared(elg))
+
+        defer {
+            XCTAssertNoThrow(try client.syncShutdown())
+            XCTAssertNoThrow(try elg.syncShutdownGracefully())
+        }
+
+        let request = try HTTPClient.Request(url: "http://localhost:\(httpBin.port)/get")
+        let delegate = TestDelegate(expectedEL: el1)
+        XCTAssertNoThrow(try httpBin.shutdown())
+        let task = client.execute(request: request, delegate: delegate, eventLoop: .init(.testOnly_exact(channelOn: el2, delegateOn: el1)))
+        XCTAssertThrowsError(try task.wait())
+        XCTAssertTrue(delegate.receivedError)
+    }
 }

Tests/AsyncHTTPClientTests/HTTPClientTests+XCTest.swift

@@ -109,6 +109,7 @@ extension HTTPClientTests {
             ("testNothingIsLoggedAtInfoOrHigher", testNothingIsLoggedAtInfoOrHigher),
             ("testAllMethodsLog", testAllMethodsLog),
             ("testClosingIdleConnectionsInPoolLogsInTheBackground", testClosingIdleConnectionsInPoolLogsInTheBackground),
+            ("testConnectErrorPropagatedToDelegate", testConnectErrorPropagatedToDelegate),
             ("testDelegateCallinsTolerateRandomEL", testDelegateCallinsTolerateRandomEL),
             ("testContentLengthTooLongFails", testContentLengthTooLongFails),
             ("testContentLengthTooShortFails", testContentLengthTooShortFails),

Tests/AsyncHTTPClientTests/HTTPClientTests.swift

@@ -2008,6 +2008,40 @@ class HTTPClientTests: XCTestCase {
         self.defaultClient = nil // so it doesn't get shut down again.
     }
 
+    func testConnectErrorPropagatedToDelegate() throws {
+        class TestDelegate: HTTPClientResponseDelegate {
+            typealias Response = Void
+            var error: Error?
+            func didFinishRequest(task: HTTPClient.Task<Void>) throws {}
+            func didReceiveError(task: HTTPClient.Task<Response>, _ error: Error) {
+                self.error = error
+            }
+        }
+
+        let httpBin = HTTPBin()
+        let httpClient = HTTPClient(eventLoopGroupProvider: .shared(self.clientGroup))
+        defer {
+            XCTAssertNoThrow(try httpClient.syncShutdown())
+        }
+
+        let delegate = TestDelegate()
+        let request = try HTTPClient.Request(url: "http://localhost:\(httpBin.port)/get")
+        do {
+            try httpBin.shutdown()
+            _ = try httpClient.execute(request: request, delegate: delegate).wait()
+            XCTFail("Should fail")
+        } catch {
+            switch (error, delegate.error) {
+            case (_ as NIOConnectionError, _ as NIOConnectionError):
+                break
+            case (_ as NIOConnectionError, .none):
+                XCTFail("Delegate error is not \(error)")
+            default:
+                XCTFail("Unexpected error: \(error)")
+            }
+        }
+    }
+
     func testDelegateCallinsTolerateRandomEL() throws {
         class TestDelegate: HTTPClientResponseDelegate {
             typealias Response = Void