Fix test

Author: fabianfett

Package.swift

@@ -18,9 +18,9 @@ let package = Package(
         .library(name: "AWSLambdaTesting", targets: ["AWSLambdaTesting"]),
     ],
     dependencies: [
-        .package(url: "https://github.com/weissi/swift-nio.git", .branch("jw-single-threaded-nio")),
-        .package(url: "https://github.com/apple/swift-log.git", from: "1.0.0"),
-        .package(url: "https://github.com/swift-server/swift-backtrace.git", from: "1.1.0"),
+        .package(url: "https://github.com/apple/swift-nio.git", .upToNextMajor(from: "2.17.0")),
+        .package(url: "https://github.com/apple/swift-log.git", .upToNextMajor(from: "1.0.0")),
+        .package(url: "https://github.com/swift-server/swift-backtrace.git", .upToNextMajor(from: "1.1.0")),
     ],
     targets: [
         .target(name: "AWSLambdaRuntime", dependencies: [

Sources/AWSLambdaRuntimeCore/Lambda.swift

@@ -81,6 +81,8 @@ public enum Lambda {
     internal static func run(configuration: Configuration = .init(), factory: @escaping (EventLoop) throws -> Handler) -> Result<Int, Error> {
         self.run(configuration: configuration, factory: { eventloop -> EventLoopFuture<Handler> in
             let promise = eventloop.makePromise(of: Handler.self)
+            // if we have a callback based handler factory, we offload the creation of the handler
+            // onto the default offload queue, to ensure that the eventloop is never blocked.
             Lambda.defaultOffloadQueue.async {
                 do {
                     promise.succeed(try factory(eventloop))

Tests/AWSLambdaRuntimeCoreTests/LambdaTest.swift

@@ -128,30 +128,30 @@ class LambdaTest: XCTestCase {
         assertLambdaLifecycleResult(result, shouldFailWithError: TestError("kaboom"))
     }
 
-    #if false
-    func testStartStop() {
+    func testStartStopInDebugMode() {
         let server = MockLambdaServer(behavior: Behavior())
         XCTAssertNoThrow(try server.start().wait())
         defer { XCTAssertNoThrow(try server.stop().wait()) }
 
         let signal = Signal.ALRM
         let maxTimes = 1000
         let configuration = Lambda.Configuration(lifecycle: .init(maxTimes: maxTimes, stopSignal: signal))
-        let eventLoopGroup = MultiThreadedEventLoopGroup(numberOfThreads: System.coreCount)
-        defer { XCTAssertNoThrow(try eventLoopGroup.syncShutdownGracefully()) }
 
-        let future = Lambda.runAsync(eventLoopGroup: eventLoopGroup, configuration: configuration, factory: { $0.makeSucceededFuture(EchoHandler()) })
         DispatchQueue(label: "test").async {
+            // we need to schedule the signal before we start the long running `Lambda.run`, since
+            // `Lambda.run` will block the main thread.
             usleep(100_000)
             kill(getpid(), signal.rawValue)
         }
-        future.whenSuccess { result in
-            XCTAssertGreaterThan(result, 0, "should have stopped before any request made")
-            XCTAssertLessThan(result, maxTimes, "should have stopped before \(maxTimes)")
+        let result = Lambda.run(configuration: configuration, factory: { $0.makeSucceededFuture(EchoHandler()) })
+
+        guard case .success(let invocationCount) = result else {
+            return XCTFail("expected to have not failed")
         }
-        XCTAssertNoThrow(try future.wait())
+
+        XCTAssertGreaterThan(invocationCount, 0, "should have stopped before any request made")
+        XCTAssertLessThan(invocationCount, maxTimes, "should have stopped before \(maxTimes)")
     }
-    #endif
 
     func testTimeout() {
         let timeout: Int64 = 100