Some improvements

Author: fabianfett

Sources/AWSLambdaTesting/Lambda+Testing.swift

@@ -20,42 +20,46 @@ import NIO
 
 extension Lambda {
     public static func test(_ closure: @escaping StringLambdaClosure,
-                            with payload: String,
-                            _ body: @escaping (Result<String, Error>) -> Void) {
-        Self.test(StringLambdaClosureWrapper(closure), with: payload, body)
+                            with payload: String) throws -> String {
+        try Self.test(StringLambdaClosureWrapper(closure), with: payload)
     }
 
     public static func test(_ closure: @escaping StringVoidLambdaClosure,
-                            with payload: String,
-                            _ body: @escaping (Result<Void, Error>) -> Void) {
-        Self.test(StringVoidLambdaClosureWrapper(closure), with: payload, body)
+                            with payload: String) throws {
+        _ = try Self.test(StringVoidLambdaClosureWrapper(closure), with: payload)
     }
 
-    public static func test<In: Decodable, Out: Encodable>(_ closure: @escaping CodableLambdaClosure<In, Out>,
-                                                           with payload: In,
-                                                           _ body: @escaping (Result<Out, Error>) -> Void) {
-        Self.test(CodableLambdaClosureWrapper(closure), with: payload, body)
+    public static func test<In: Decodable, Out: Encodable>(
+        _ closure: @escaping CodableLambdaClosure<In, Out>,
+        with payload: In
+    ) throws -> Out {
+        try Self.test(CodableLambdaClosureWrapper(closure), with: payload)
     }
 
     public static func test<In: Decodable>(_ closure: @escaping CodableVoidLambdaClosure<In>,
-                                           with payload: In,
-                                           _ body: @escaping (Result<Void, Error>) -> Void) {
-        Self.test(CodableVoidLambdaClosureWrapper(closure), with: payload, body)
+                                           with payload: In) throws {
+        _ = try Self.test(CodableVoidLambdaClosureWrapper(closure), with: payload)
     }
 
-    public static func test<In, Out, Handler: EventLoopLambdaHandler>(_ handler: Handler,
-                                                                      with payload: In,
-                                                                      _ body: @escaping (Result<Out, Error>) -> Void) where Handler.In == In, Handler.Out == Out {
+    public static func test<In, Out, Handler: EventLoopLambdaHandler>(
+        _ handler: Handler,
+        with payload: In
+    ) throws -> Out where Handler.In == In, Handler.Out == Out {
         let logger = Logger(label: "test")
         let eventLoopGroup = MultiThreadedEventLoopGroup(numberOfThreads: 1)
+        let eventLoop = eventLoopGroup.next()
+
         let context = Context(requestId: "\(DispatchTime.now().uptimeNanoseconds)",
                               traceId: "Root=\(DispatchTime.now().uptimeNanoseconds);Parent=\(DispatchTime.now().uptimeNanoseconds);Sampled=1",
                               invokedFunctionArn: "arn:aws:lambda:us-west-1:\(DispatchTime.now().uptimeNanoseconds):function:custom-runtime",
                               deadline: .now() + 5,
                               logger: logger,
-                              eventLoop: eventLoopGroup.next())
-        handler.handle(context: context, payload: payload).whenComplete { result in
-            body(result)
+                              eventLoop: eventLoop)
+
+        let future = eventLoop.flatSubmit {
+            handler.handle(context: context, payload: payload)
         }
+
+        return try future.wait()
     }
 }

Tests/AWSLambdaTestingTests/Tests.swift

@@ -31,14 +31,9 @@ class LambdaTestingTests: XCTestCase {
         }
 
         let request = Request(name: UUID().uuidString)
-        Lambda.test(myLambda, with: request) { result in
-            switch result {
-            case .failure(let error):
-                XCTFail("expected to succeed but failed with \(error)")
-            case .success(let response):
-                XCTAssertEqual(response.message, "echo" + request.name)
-            }
-        }
+        var response: Response?
+        XCTAssertNoThrow(response = try Lambda.test(myLambda, with: request))
+        XCTAssertEqual(response?.message, "echo" + request.name)
     }
 
     func testCodableVoidClosure() {
@@ -51,14 +46,7 @@ class LambdaTestingTests: XCTestCase {
         }
 
         let request = Request(name: UUID().uuidString)
-        Lambda.test(myLambda, with: request) { result in
-            switch result {
-            case .failure(let error):
-                XCTFail("expected to succeed but failed with \(error)")
-            case .success:
-                break
-            }
-        }
+        XCTAssertNoThrow(try Lambda.test(myLambda, with: request))
     }
 
     func testLambdaHandler() {
@@ -80,14 +68,9 @@ class LambdaTestingTests: XCTestCase {
         }
 
         let request = Request(name: UUID().uuidString)
-        Lambda.test(MyLambda(), with: request) { result in
-            switch result {
-            case .failure(let error):
-                XCTFail("expected to succeed but failed with \(error)")
-            case .success(let response):
-                XCTAssertEqual(response.message, "echo" + request.name)
-            }
-        }
+        var response: Response?
+        XCTAssertNoThrow(response = try Lambda.test(MyLambda(), with: request))
+        XCTAssertEqual(response?.message, "echo" + request.name)
     }
 
     func testFailure() {
@@ -102,13 +85,24 @@ class LambdaTestingTests: XCTestCase {
             }
         }
 
-        Lambda.test(MyLambda(), with: UUID().uuidString) { result in
-            switch result {
-            case .failure(let error):
-                XCTAssert(error is MyError)
-            case .success:
-                XCTFail("expected to fail but succeeded")
+        XCTAssertThrowsError(try Lambda.test(MyLambda(), with: UUID().uuidString)) { error in
+            XCTAssert(error is MyError)
+        }
+    }
+
+    func testAsyncLongRunning() {
+        struct MyError: Error {}
+
+        var executed: Bool = false
+
+        let myLambda = { (_: Lambda.Context, _: String, callback: @escaping (Result<Void, Error>) -> Void) in
+            DispatchQueue.global(qos: .background).asyncAfter(deadline: .now() + 0.5) {
+                executed = true
+                callback(.success(()))
             }
         }
+
+        XCTAssertNoThrow(try Lambda.test(myLambda, with: UUID().uuidString))
+        XCTAssertTrue(executed)
     }
 }