tests: instead of pre-populating, make use of testOnly_exact (#223)

Author: weissi

Tests/AsyncHTTPClientTests/HTTPClientInternalTests+XCTest.swift

@@ -39,6 +39,8 @@ extension HTTPClientInternalTests {
             ("testRaceBetweenAsynchronousCloseAndChannelUsabilityDetection", testRaceBetweenAsynchronousCloseAndChannelUsabilityDetection),
             ("testResponseFutureIsOnCorrectEL", testResponseFutureIsOnCorrectEL),
             ("testUncleanCloseThrows", testUncleanCloseThrows),
+            ("testUploadStreamingIsCalledOnTaskEL", testUploadStreamingIsCalledOnTaskEL),
+            ("testWeCanActuallyExactlySetTheEventLoops", testWeCanActuallyExactlySetTheEventLoops),
         ]
     }
 }

Tests/AsyncHTTPClientTests/HTTPClientInternalTests.swift

@@ -806,4 +806,81 @@ class HTTPClientInternalTests: XCTestCase {
             }
         }
     }
+
+    func testUploadStreamingIsCalledOnTaskEL() throws {
+        let group = getDefaultEventLoopGroup(numberOfThreads: 4)
+        defer {
+            XCTAssertNoThrow(try group.syncShutdownGracefully())
+        }
+
+        let httpBin = HTTPBin()
+        let httpClient = HTTPClient(eventLoopGroupProvider: .shared(group))
+        defer {
+            XCTAssertNoThrow(try httpClient.syncShutdown())
+            XCTAssertNoThrow(try httpBin.shutdown())
+        }
+
+        let el1 = group.next()
+        let el2 = group.next()
+        XCTAssert(el1 !== el2)
+
+        let body: HTTPClient.Body = .stream(length: 8) { writer in
+            XCTAssert(el1.inEventLoop)
+            let buffer = ByteBuffer.of(string: "1234")
+            return writer.write(.byteBuffer(buffer)).flatMap {
+                XCTAssert(el1.inEventLoop)
+                let buffer = ByteBuffer.of(string: "4321")
+                return writer.write(.byteBuffer(buffer))
+            }
+        }
+        let request = try HTTPClient.Request(url: "http://localhost:\(httpBin.port)/post", method: .POST, body: body)
+        let response = httpClient.execute(request: request,
+                                          delegate: ResponseAccumulator(request: request),
+                                          eventLoop: HTTPClient.EventLoopPreference(.testOnly_exact(channelOn: el2,
+                                                                                                    delegateOn: el1)))
+        XCTAssert(el1 === response.eventLoop)
+        XCTAssertNoThrow(try response.wait())
+    }
+
+    func testWeCanActuallyExactlySetTheEventLoops() throws {
+        let group = getDefaultEventLoopGroup(numberOfThreads: 3)
+        defer {
+            XCTAssertNoThrow(try group.syncShutdownGracefully())
+        }
+
+        let httpBin = HTTPBin()
+        let httpClient = HTTPClient(eventLoopGroupProvider: .shared(group))
+        defer {
+            XCTAssertNoThrow(try httpClient.syncShutdown())
+            XCTAssertNoThrow(try httpBin.shutdown())
+        }
+
+        let el1 = group.next()
+        let el2 = group.next()
+        XCTAssert(el1 !== el2)
+
+        let taskPromise = group.next().makePromise(of: HTTPClient.Task<HTTPClient.Response>.self)
+        let body: HTTPClient.Body = .stream(length: 8) { writer in
+            XCTAssert(el1.inEventLoop)
+            let buffer = ByteBuffer.of(string: "1234")
+            return writer.write(.byteBuffer(buffer)).flatMap {
+                XCTAssert(el1.inEventLoop)
+                let buffer = ByteBuffer.of(string: "4321")
+                return taskPromise.futureResult.map { (task: HTTPClient.Task<HTTPClient.Response>) -> Void in
+                    XCTAssertNotNil(task.connection)
+                    XCTAssert(task.connection?.channel.eventLoop === el2)
+                }.flatMap {
+                    writer.write(.byteBuffer(buffer))
+                }
+            }
+        }
+        let request = try HTTPClient.Request(url: "http://localhost:\(httpBin.port)/post", method: .POST, body: body)
+        let response = httpClient.execute(request: request,
+                                          delegate: ResponseAccumulator(request: request),
+                                          eventLoop: HTTPClient.EventLoopPreference(.testOnly_exact(channelOn: el2,
+                                                                                                    delegateOn: el1)))
+        taskPromise.succeed(response)
+        XCTAssert(el1 === response.eventLoop)
+        XCTAssertNoThrow(try response.wait())
+    }
 }

Tests/AsyncHTTPClientTests/HTTPClientTests+XCTest.swift

@@ -99,7 +99,6 @@ extension HTTPClientTests {
             ("testValidationErrorsAreSurfaced", testValidationErrorsAreSurfaced),
             ("testUploadsReallyStream", testUploadsReallyStream),
             ("testUploadStreamingCallinToleratedFromOtsideEL", testUploadStreamingCallinToleratedFromOtsideEL),
-            ("testUploadStreamingIsCalledOnTaskEL", testUploadStreamingIsCalledOnTaskEL),
         ]
     }
 }

Tests/AsyncHTTPClientTests/HTTPClientTests.swift

@@ -1836,41 +1836,4 @@ class HTTPClientTests: XCTestCase {
         })
         XCTAssertNoThrow(try httpClient.execute(request: request).wait())
     }
-
-    func testUploadStreamingIsCalledOnTaskEL() throws {
-        let group = getDefaultEventLoopGroup(numberOfThreads: 4)
-        defer {
-            XCTAssertNoThrow(try group.syncShutdownGracefully())
-        }
-
-        let httpBin = HTTPBin()
-        let httpClient = HTTPClient(eventLoopGroupProvider: .shared(group))
-        defer {
-            XCTAssertNoThrow(try httpClient.syncShutdown())
-            XCTAssertNoThrow(try httpBin.shutdown())
-        }
-
-        let el1 = group.next()
-        let el2 = group.next()
-        XCTAssertFalse(el1 === el2)
-
-        do {
-            // Pre-populate pool with a connection on a different EL
-            let request = try HTTPClient.Request(url: "http://localhost:\(httpBin.port)/get", method: .GET)
-            XCTAssertNoThrow(try httpClient.execute(request: request, delegate: ResponseAccumulator(request: request), eventLoop: .delegateAndChannel(on: el2)).wait())
-        }
-
-        let body: HTTPClient.Body = .stream(length: 8) { writer in
-            XCTAssert(el1.inEventLoop)
-            let buffer = ByteBuffer.of(string: "1234")
-            return writer.write(.byteBuffer(buffer)).flatMap {
-                XCTAssert(el1.inEventLoop)
-                let buffer = ByteBuffer.of(string: "4321")
-                return writer.write(.byteBuffer(buffer))
-            }
-        }
-        let request = try HTTPClient.Request(url: "http://localhost:\(httpBin.port)/post", method: .POST, body: body)
-        let response = httpClient.execute(request: request, delegate: ResponseAccumulator(request: request), eventLoop: .delegate(on: el1))
-        XCTAssertNoThrow(try response.wait())
-    }
 }