Added simple tests

Author: fabianfett

Package.swift

@@ -38,7 +38,7 @@ let package = Package(
         .testTarget(name: "AWSLambdaRuntimeTests", dependencies: [
             .byName(name: "AWSLambdaRuntimeCore"),
             .byName(name: "AWSLambdaRuntime"),
-        ]),
+        ], swiftSettings: [.unsafeFlags(["-Xfrontend", "-enable-experimental-concurrency"])]),
         .target(name: "AWSLambdaEvents", dependencies: []),
         .testTarget(name: "AWSLambdaEventsTests", dependencies: ["AWSLambdaEvents"]),
         // testing helper

Sources/AWSLambdaRuntime/Lambda+Codable.swift

@@ -80,6 +80,7 @@ internal struct CodableVoidClosureWrapper<In: Decodable>: LambdaHandler {
 
 // MARK: - Async
 
+#if compiler(>=5.4) && $AsyncAwait
 extension Lambda {
 
     /// An async Lambda Closure that takes a `In: Decodable` and returns an `Out: Encodable`
@@ -138,6 +139,7 @@ internal struct CodableVoidAsyncWrapper<In: Decodable>: AsyncLambdaHandler {
         try await self.closure(context, event)
     }
 }
+#endif
 
 // MARK: - Codable support
 

Sources/AWSLambdaRuntimeCore/LambdaHandler.swift

@@ -85,6 +85,7 @@ extension LambdaHandler {
 
 // MARK: - AsyncLambdaHandler
 
+#if compiler(>=5.4) && $AsyncAwait
 /// Strongly typed, processing protocol for a Lambda that takes a user defined `In` and returns a user defined `Out` async.
 public protocol AsyncLambdaHandler: EventLoopLambdaHandler {
 
@@ -101,20 +102,21 @@ public protocol AsyncLambdaHandler: EventLoopLambdaHandler {
 
 extension AsyncLambdaHandler {
     public func handle(context: Lambda.Context, event: In) -> EventLoopFuture<Out> {
-        @asyncHandler func _run(context: Lambda.Context, event: In, promise: EventLoopPromise<Out>) {
-            do {
-                let result = try await handle(context: context, event: event)
-                promise.succeed(result)
-            } catch {
-                promise.fail(error)
-            }
-        }
-        
         let promise = context.eventLoop.makePromise(of: Out.self)
-        _run(context: context, event: event, promise: promise)
+        self._run(context: context, event: event, promise: promise)
         return promise.futureResult
     }
+    
+    @asyncHandler private func _run(context: Lambda.Context, event: In, promise: EventLoopPromise<Out>) {
+        do {
+            let result = try await handle(context: context, event: event)
+            promise.succeed(result)
+        } catch {
+            promise.fail(error)
+        }
+    }
 }
+#endif
 
 // MARK: - EventLoopLambdaHandler
 

Tests/AWSLambdaRuntimeTests/Lambda+CodeableTest.swift

@@ -53,7 +53,7 @@ class CodableLambdaTest: XCTestCase {
         var response: Response?
 
         let closureWrapper = CodableClosureWrapper { (_, req: Request, completion: (Result<Response, Error>) -> Void) in
-            XCTAssertEqual(request, request)
+            XCTAssertEqual(request, req)
             completion(.success(Response(requestId: req.requestId)))
         }
 
@@ -62,6 +62,39 @@ class CodableLambdaTest: XCTestCase {
         XCTAssertNoThrow(response = try JSONDecoder().decode(Response.self, from: XCTUnwrap(outputBuffer)))
         XCTAssertEqual(response?.requestId, request.requestId)
     }
+    
+    #if compiler(>=5.4) && $AsyncAwait
+    func testCodableVoidAsyncWrapper() {
+        let request = Request(requestId: UUID().uuidString)
+        var inputBuffer: ByteBuffer?
+        var outputBuffer: ByteBuffer?
+
+        let closureWrapper = CodableVoidAsyncWrapper { (context, req: Request) in
+            XCTAssertEqual(request, req)
+        }
+
+        XCTAssertNoThrow(inputBuffer = try JSONEncoder().encode(request, using: self.allocator))
+        XCTAssertNoThrow(outputBuffer = try closureWrapper.handle(context: self.newContext(), event: XCTUnwrap(inputBuffer)).wait())
+        XCTAssertNil(outputBuffer)
+    }
+
+    func testCodableAsyncWrapper() {
+        let request = Request(requestId: UUID().uuidString)
+        var inputBuffer: ByteBuffer?
+        var outputBuffer: ByteBuffer?
+        var response: Response?
+
+        let closureWrapper = CodableAsyncWrapper { (context, req: Request) -> Response in
+            XCTAssertEqual(req, request)
+            return Response(requestId: req.requestId)
+        }
+
+        XCTAssertNoThrow(inputBuffer = try JSONEncoder().encode(request, using: self.allocator))
+        XCTAssertNoThrow(outputBuffer = try closureWrapper.handle(context: self.newContext(), event: XCTUnwrap(inputBuffer)).wait())
+        XCTAssertNoThrow(response = try JSONDecoder().decode(Response.self, from: XCTUnwrap(outputBuffer)))
+        XCTAssertEqual(response?.requestId, request.requestId)
+    }
+    #endif
 
     // convencience method
     func newContext() -> Lambda.Context {