test immediat request execution on required event loop

Author: dnadoba

Diff for: Sources/AsyncHTTPClient/ConnectionPool/State Machine/HTTPConnectionPool+HTTP2Connections.swift

@@ -576,6 +576,11 @@ extension HTTPConnectionPool {
             /// true if no stream is leased
             var isIdle: Bool
         }
+        
+        struct LeasedStreamContext {
+            /// true if the connection was idle before leasing the stream
+            var wasIdle: Bool
+        }
 
         struct LeasedStreamContext {
             /// true if the connection was idle before leasing the stream

Diff for: Sources/AsyncHTTPClient/ConnectionPool/State Machine/HTTPConnectionPool+HTTP2StateMachine.swift

@@ -102,12 +102,19 @@ extension HTTPConnectionPool {
             _ request: Request,
             onRequired eventLoop: EventLoop
         ) -> Action {
-            if let connection = self.connections.leaseStream(onRequired: eventLoop) {
+            if let (connection, context) = self.connections.leaseStream(onRequired: eventLoop) {
                 /// 1. we have a stream available and can execute the request immediately
-                return .init(
-                    request: .executeRequest(request, connection, cancelTimeout: false),
-                    connection: .cancelTimeoutTimer(connection.id)
-                )
+                if context.wasIdle {
+                    return .init(
+                        request: .executeRequest(request, connection, cancelTimeout: false),
+                        connection: .cancelTimeoutTimer(connection.id)
+                    )
+                } else {
+                    return .init(
+                        request: .executeRequest(request, connection, cancelTimeout: false),
+                        connection: .none
+                    )
+                }
             }
             /// 2. No available stream so we definitely need to wait until we have one
             self.requests.push(request)
@@ -132,12 +139,19 @@ extension HTTPConnectionPool {
             _ request: Request,
             onPreferred eventLoop: EventLoop
         ) -> Action {
-            if let connection = self.connections.leaseStream(onPreferred: eventLoop) {
+            if let (connection, context) = self.connections.leaseStream(onPreferred: eventLoop) {
                 /// 1. we have a stream available and can execute the request immediately
-                return .init(
-                    request: .executeRequest(request, connection, cancelTimeout: false),
-                    connection: .cancelTimeoutTimer(connection.id)
-                )
+                if context.wasIdle {
+                    return .init(
+                        request: .executeRequest(request, connection, cancelTimeout: false),
+                        connection: .cancelTimeoutTimer(connection.id)
+                    )
+                } else {
+                    return .init(
+                        request: .executeRequest(request, connection, cancelTimeout: false),
+                        connection: .none
+                    )
+                }
             }
             /// 2. No available stream so we definitely need to wait until we have one
             self.requests.push(request)
@@ -182,7 +196,7 @@ extension HTTPConnectionPool {
                 let remainingAvailableStreams = context.availableStreams - requestsToExecute.count
                 // use the remaining available streams for requests without a required event loop
                 requestsToExecute += self.requests.popFirst(max: remainingAvailableStreams, for: nil)
-                let connection = self.connections.leaseStreams(at: index, count: requestsToExecute.count)
+                let (connection, _) = self.connections.leaseStreams(at: index, count: requestsToExecute.count)
 
                 let requestAction = { () -> RequestAction in
                     if requestsToExecute.isEmpty {

Diff for: Tests/AsyncHTTPClientTests/HTTPConnectionPool+HTTP2StateMachineTests.swift

@@ -90,6 +90,23 @@ class HTTPConnectionPool_HTTP2StateMachineTests: XCTestCase {
         }
         XCTAssertTrue(queuer.isEmpty)
 
+        /// closing streams without any queued requests shouldn't do anything if it's *not* the last stream
+        for _ in 0..<4 {
+            let action = state.http2ConnectionStreamClosed(connID)
+            XCTAssertEqual(action.request, .none)
+            XCTAssertEqual(action.connection, .none)
+        }
+        
+        /// 4 streams are available and therefore request should be executed immediately
+        for _ in 0..<4 {
+            let mockRequest = MockHTTPRequest(eventLoop: el1, requiresEventLoopForChannel: true)
+            let request = HTTPConnectionPool.Request(mockRequest)
+            let action = state.executeRequest(request)
+
+            XCTAssertEqual(action.connection, .none)
+            XCTAssertEqual(action.request, .executeRequest(request, conn, cancelTimeout: false))
+        }
+        
         /// closing streams without any queued requests shouldn't do anything if it's *not* the last stream
         for _ in 0..<4 {
             let action = state.http2ConnectionStreamClosed(connID)