Drop event label from handle method in LambdaHandlers

fabianfett · fabianfett · commit ac9dc0c33e22 · 2021-08-25T09:42:46.000+02:00
diff --git a/Sources/AWSLambdaRuntimeCore/LambdaHandler.swift b/Sources/AWSLambdaRuntimeCore/LambdaHandler.swift
@@ -38,15 +38,15 @@ public protocol LambdaHandler: EventLoopLambdaHandler {
     ///     - context: Runtime `Context`.
     ///
     /// - Returns: A Lambda result ot type `Out`.
-    func handle(event: In, context: Lambda.Context) async throws -> Out
+    func handle(_ event: In, context: Lambda.Context) async throws -> Out
 }
 
 @available(macOS 12, iOS 15, tvOS 15, watchOS 8, *)
 extension LambdaHandler {
-    public func handle(event: In, context: Lambda.Context) -> EventLoopFuture<Out> {
+    public func handle(_ event: In, context: Lambda.Context) -> EventLoopFuture<Out> {
         let promise = context.eventLoop.makePromise(of: Out.self)
         promise.completeWithTask {
-            try await self.handle(event: event, context: context)
+            try await self.handle(event, context: context)
         }
         return promise.futureResult
     }
@@ -82,7 +82,7 @@ public protocol EventLoopLambdaHandler: ByteBufferLambdaHandler {
     ///
     /// - Returns: An `EventLoopFuture` to report the result of the Lambda back to the runtime engine.
     ///            The `EventLoopFuture` should be completed with either a response of type `Out` or an `Error`
-    func handle(event: In, context: Lambda.Context) -> EventLoopFuture<Out>
+    func handle(_ event: In, context: Lambda.Context) -> EventLoopFuture<Out>
 
     /// Encode a response of type `Out` to `ByteBuffer`
     /// Concrete Lambda handlers implement this method to provide coding functionality.
@@ -106,15 +106,15 @@ public protocol EventLoopLambdaHandler: ByteBufferLambdaHandler {
 extension EventLoopLambdaHandler {
     /// Driver for `ByteBuffer` -> `In` decoding and `Out` -> `ByteBuffer` encoding
     @inlinable
-    public func handle(event: ByteBuffer, context: Lambda.Context) -> EventLoopFuture<ByteBuffer?> {
+    public func handle(_ event: ByteBuffer, context: Lambda.Context) -> EventLoopFuture<ByteBuffer?> {
         let input: In
         do {
             input = try self.decode(buffer: event)
         } catch {
             return context.eventLoop.makeFailedFuture(CodecError.requestDecoding(error))
         }
 
-        return self.handle(event: input, context: context).flatMapThrowing { output in
+        return self.handle(input, context: context).flatMapThrowing { output in
             do {
                 return try self.encode(allocator: context.allocator, value: output)
             } catch {
@@ -148,7 +148,7 @@ public protocol ByteBufferLambdaHandler {
     ///
     /// - Returns: An `EventLoopFuture` to report the result of the Lambda back to the runtime engine.
     ///            The `EventLoopFuture` should be completed with either a response encoded as `ByteBuffer` or an `Error`
-    func handle(event: ByteBuffer, context: Lambda.Context) -> EventLoopFuture<ByteBuffer?>
+    func handle(_ event: ByteBuffer, context: Lambda.Context) -> EventLoopFuture<ByteBuffer?>
 
     /// Clean up the Lambda resources asynchronously.
     /// Concrete Lambda handlers implement this method to shutdown resources like `HTTPClient`s and database connections.
diff --git a/Sources/AWSLambdaRuntimeCore/LambdaRunner.swift b/Sources/AWSLambdaRuntimeCore/LambdaRunner.swift
@@ -62,15 +62,15 @@ extension Lambda {
             self.isGettingNextInvocation = true
             return self.runtimeClient.getNextInvocation(logger: logger).peekError { error in
                 logger.error("could not fetch work from lambda runtime engine: \(error)")
-            }.flatMap { invocation, event in
+            }.flatMap { invocation, bytes in
                 // 2. send invocation to handler
                 self.isGettingNextInvocation = false
                 let context = Context(logger: logger,
                                       eventLoop: self.eventLoop,
                                       allocator: self.allocator,
                                       invocation: invocation)
                 logger.debug("sending invocation to lambda handler \(handler)")
-                return handler.handle(event: event, context: context)
+                return handler.handle(bytes, context: context)
                     // Hopping back to "our" EventLoop is important in case the handler returns a future that
                     // originiated from a foreign EventLoop/EventLoopGroup.
                     // This can happen if the handler uses a library (lets say a DB client) that manages its own threads/loops
diff --git a/Sources/AWSLambdaTesting/Lambda+Testing.swift b/Sources/AWSLambdaTesting/Lambda+Testing.swift
@@ -97,7 +97,7 @@ extension Lambda {
         let handler = try promise.futureResult.wait()
 
         return try eventLoop.flatSubmit {
-            handler.handle(event: event, context: context)
+            handler.handle(event, context: context)
         }.wait()
     }
 }
diff --git a/Sources/CodableSample/main.swift b/Sources/CodableSample/main.swift
@@ -29,7 +29,7 @@ struct Handler: EventLoopLambdaHandler {
     typealias In = Request
     typealias Out = Response
 
-    func handle(event: Request, context: Lambda.Context) -> EventLoopFuture<Response> {
+    func handle(_ event: Request, context: Lambda.Context) -> EventLoopFuture<Response> {
         // as an example, respond with the input event's reversed body
         context.eventLoop.makeSucceededFuture(Response(body: String(event.body.reversed())))
     }
diff --git a/Sources/StringSample/main.swift b/Sources/StringSample/main.swift
@@ -20,7 +20,7 @@ struct Handler: EventLoopLambdaHandler {
     typealias In = String
     typealias Out = String
 
-    func handle(event: String, context: Lambda.Context) -> EventLoopFuture<String> {
+    func handle(_ event: String, context: Lambda.Context) -> EventLoopFuture<String> {
         // as an example, respond with the event's reversed body
         context.eventLoop.makeSucceededFuture(String(event.reversed()))
     }
diff --git a/Tests/AWSLambdaRuntimeCoreTests/LambdaHandlerTest.swift b/Tests/AWSLambdaRuntimeCoreTests/LambdaHandlerTest.swift
@@ -39,7 +39,7 @@ class LambdaHandlerTest: XCTestCase {
                 self.initialized = true
             }
 
-            func handle(event: String, context: Lambda.Context) async throws -> String {
+            func handle(_ event: String, context: Lambda.Context) async throws -> String {
                 event
             }
         }
@@ -68,7 +68,7 @@ class LambdaHandlerTest: XCTestCase {
                 throw TestError("kaboom")
             }
 
-            func handle(event: String, context: Lambda.Context) async throws {
+            func handle(_ event: String, context: Lambda.Context) async throws {
                 XCTFail("How can this be called if init failed")
             }
         }
@@ -91,7 +91,7 @@ class LambdaHandlerTest: XCTestCase {
 
             init(context: Lambda.InitializationContext) {}
 
-            func handle(event: String, context: Lambda.Context) async throws -> String {
+            func handle(_ event: String, context: Lambda.Context) async throws -> String {
                 event
             }
         }
@@ -114,7 +114,7 @@ class LambdaHandlerTest: XCTestCase {
 
             init(context: Lambda.InitializationContext) {}
 
-            func handle(event: String, context: Lambda.Context) async throws {}
+            func handle(_ event: String, context: Lambda.Context) async throws {}
         }
 
         let maxTimes = Int.random(in: 1 ... 10)
@@ -136,7 +136,7 @@ class LambdaHandlerTest: XCTestCase {
 
             init(context: Lambda.InitializationContext) {}
 
-            func handle(event: String, context: Lambda.Context) async throws -> String {
+            func handle(_ event: String, context: Lambda.Context) async throws -> String {
                 throw TestError("boom")
             }
         }
@@ -159,7 +159,7 @@ class LambdaHandlerTest: XCTestCase {
             typealias In = String
             typealias Out = String
 
-            func handle(event: String, context: Lambda.Context) -> EventLoopFuture<String> {
+            func handle(_ event: String, context: Lambda.Context) -> EventLoopFuture<String> {
                 context.eventLoop.makeSucceededFuture(event)
             }
         }
@@ -181,7 +181,7 @@ class LambdaHandlerTest: XCTestCase {
             typealias In = String
             typealias Out = Void
 
-            func handle(event: String, context: Lambda.Context) -> EventLoopFuture<Void> {
+            func handle(_ event: String, context: Lambda.Context) -> EventLoopFuture<Void> {
                 context.eventLoop.makeSucceededFuture(())
             }
         }
@@ -203,7 +203,7 @@ class LambdaHandlerTest: XCTestCase {
             typealias In = String
             typealias Out = String
 
-            func handle(event: String, context: Lambda.Context) -> EventLoopFuture<String> {
+            func handle(_ event: String, context: Lambda.Context) -> EventLoopFuture<String> {
                 context.eventLoop.makeFailedFuture(TestError("boom"))
             }
         }
diff --git a/Tests/AWSLambdaRuntimeCoreTests/LambdaHandlers.swift b/Tests/AWSLambdaRuntimeCoreTests/LambdaHandlers.swift
@@ -19,7 +19,7 @@ struct EchoHandler: EventLoopLambdaHandler {
     typealias In = String
     typealias Out = String
 
-    func handle(event: String, context: Lambda.Context) -> EventLoopFuture<String> {
+    func handle(_ event: String, context: Lambda.Context) -> EventLoopFuture<String> {
         context.eventLoop.makeSucceededFuture(event)
     }
 }
@@ -34,7 +34,7 @@ struct FailedHandler: EventLoopLambdaHandler {
         self.reason = reason
     }
 
-    func handle(event: String, context: Lambda.Context) -> EventLoopFuture<Void> {
+    func handle(_ event: String, context: Lambda.Context) -> EventLoopFuture<Void> {
         context.eventLoop.makeFailedFuture(TestError(self.reason))
     }
 }
diff --git a/Tests/AWSLambdaRuntimeCoreTests/LambdaLifecycleTest.swift b/Tests/AWSLambdaRuntimeCoreTests/LambdaLifecycleTest.swift
@@ -54,7 +54,7 @@ class LambdaLifecycleTest: XCTestCase {
             self.shutdown = shutdown
         }
 
-        func handle(event: ByteBuffer, context: Lambda.Context) -> EventLoopFuture<ByteBuffer?> {
+        func handle(_ event: ByteBuffer, context: Lambda.Context) -> EventLoopFuture<ByteBuffer?> {
             self.handler(context, event)
         }
 
diff --git a/Tests/AWSLambdaRuntimeTests/Lambda+CodeableTest.swift b/Tests/AWSLambdaRuntimeTests/Lambda+CodeableTest.swift
@@ -43,7 +43,7 @@ class CodableLambdaTest: XCTestCase {
 
             let expected: Request
 
-            func handle(event: Request, context: Lambda.Context) -> EventLoopFuture<Void> {
+            func handle(_ event: Request, context: Lambda.Context) -> EventLoopFuture<Void> {
                 XCTAssertEqual(event, self.expected)
                 return context.eventLoop.makeSucceededVoidFuture()
             }
@@ -52,7 +52,7 @@ class CodableLambdaTest: XCTestCase {
         let handler = Handler(expected: request)
 
         XCTAssertNoThrow(inputBuffer = try JSONEncoder().encode(request, using: self.allocator))
-        XCTAssertNoThrow(outputBuffer = try handler.handle(event: XCTUnwrap(inputBuffer), context: self.newContext()).wait())
+        XCTAssertNoThrow(outputBuffer = try handler.handle(XCTUnwrap(inputBuffer), context: self.newContext()).wait())
         XCTAssertNil(outputBuffer)
     }
 
@@ -68,7 +68,7 @@ class CodableLambdaTest: XCTestCase {
 
             let expected: Request
 
-            func handle(event: Request, context: Lambda.Context) -> EventLoopFuture<Response> {
+            func handle(_ event: Request, context: Lambda.Context) -> EventLoopFuture<Response> {
                 XCTAssertEqual(event, self.expected)
                 return context.eventLoop.makeSucceededFuture(Response(requestId: event.requestId))
             }
@@ -77,7 +77,7 @@ class CodableLambdaTest: XCTestCase {
         let handler = Handler(expected: request)
 
         XCTAssertNoThrow(inputBuffer = try JSONEncoder().encode(request, using: self.allocator))
-        XCTAssertNoThrow(outputBuffer = try handler.handle(event: XCTUnwrap(inputBuffer), context: self.newContext()).wait())
+        XCTAssertNoThrow(outputBuffer = try handler.handle(XCTUnwrap(inputBuffer), context: self.newContext()).wait())
         XCTAssertNoThrow(response = try JSONDecoder().decode(Response.self, from: XCTUnwrap(outputBuffer)))
         XCTAssertEqual(response?.requestId, request.requestId)
     }
@@ -93,7 +93,7 @@ class CodableLambdaTest: XCTestCase {
 
             init(context: Lambda.InitializationContext) async throws {}
 
-            func handle(event: Request, context: Lambda.Context) async throws {
+            func handle(_ event: Request, context: Lambda.Context) async throws {
                 XCTAssertEqual(event, self.expected)
             }
         }
@@ -107,7 +107,7 @@ class CodableLambdaTest: XCTestCase {
             handler.expected = request
 
             XCTAssertNoThrow(inputBuffer = try JSONEncoder().encode(request, using: self.allocator))
-            XCTAssertNoThrow(outputBuffer = try handler.handle(event: XCTUnwrap(inputBuffer), context: self.newContext()).wait())
+            XCTAssertNoThrow(outputBuffer = try handler.handle(XCTUnwrap(inputBuffer), context: self.newContext()).wait())
             XCTAssertNil(outputBuffer)
         }
     }
@@ -122,7 +122,7 @@ class CodableLambdaTest: XCTestCase {
 
             init(context: Lambda.InitializationContext) async throws {}
 
-            func handle(event: Request, context: Lambda.Context) async throws -> Response {
+            func handle(_ event: Request, context: Lambda.Context) async throws -> Response {
                 XCTAssertEqual(event, self.expected)
                 return Response(requestId: event.requestId)
             }
@@ -138,7 +138,7 @@ class CodableLambdaTest: XCTestCase {
             handler.expected = request
 
             XCTAssertNoThrow(inputBuffer = try JSONEncoder().encode(request, using: self.allocator))
-            XCTAssertNoThrow(outputBuffer = try handler.handle(event: XCTUnwrap(inputBuffer), context: self.newContext()).wait())
+            XCTAssertNoThrow(outputBuffer = try handler.handle(XCTUnwrap(inputBuffer), context: self.newContext()).wait())
             XCTAssertNoThrow(response = try JSONDecoder().decode(Response.self, from: XCTUnwrap(outputBuffer)))
             XCTAssertEqual(response?.requestId, request.requestId)
         }
diff --git a/Tests/AWSLambdaTestingTests/Tests.swift b/Tests/AWSLambdaTestingTests/Tests.swift
@@ -35,7 +35,7 @@ class LambdaTestingTests: XCTestCase {
 
             init(context: Lambda.InitializationContext) {}
 
-            func handle(event: Request, context: Lambda.Context) async throws -> Response {
+            func handle(_ event: Request, context: Lambda.Context) async throws -> Response {
                 Response(message: "echo" + event.name)
             }
         }
@@ -59,7 +59,7 @@ class LambdaTestingTests: XCTestCase {
 
             init(context: Lambda.InitializationContext) {}
 
-            func handle(event: Request, context: Lambda.Context) async throws {
+            func handle(_ event: Request, context: Lambda.Context) async throws {
                 LambdaTestingTests.VoidLambdaHandlerInvokeCount += 1
             }
         }
@@ -79,7 +79,7 @@ class LambdaTestingTests: XCTestCase {
 
             init(context: Lambda.InitializationContext) {}
 
-            func handle(event: String, context: Lambda.Context) async throws {
+            func handle(_ event: String, context: Lambda.Context) async throws {
                 throw MyError()
             }
         }
@@ -96,7 +96,7 @@ class LambdaTestingTests: XCTestCase {
 
             init(context: Lambda.InitializationContext) {}
 
-            func handle(event: String, context: Lambda.Context) async throws -> String {
+            func handle(_ event: String, context: Lambda.Context) async throws -> String {
                 try await Task.sleep(nanoseconds: 500 * 1000 * 1000)
                 return event
             }

Original file line number	Diff line number	Diff line change
`@@ -97,7 +97,7 @@ extension Lambda {`
`97`	`97`	`let handler = try promise.futureResult.wait()`
`98`	`98`
`99`	`99`	`return try eventLoop.flatSubmit {`
`100`		`- handler.handle(event: event, context: context)`
	`100`	`+ handler.handle(event, context: context)`
`101`	`101`	`}.wait()`
`102`	`102`	`}`
`103`	`103`	`}`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ struct Handler: EventLoopLambdaHandler {`
`29`	`29`	`typealias In = Request`
`30`	`30`	`typealias Out = Response`
`31`	`31`
`32`		`- func handle(event: Request, context: Lambda.Context) -> EventLoopFuture<Response> {`
	`32`	`+ func handle(_ event: Request, context: Lambda.Context) -> EventLoopFuture<Response> {`
`33`	`33`	`// as an example, respond with the input event's reversed body`
`34`	`34`	`context.eventLoop.makeSucceededFuture(Response(body: String(event.body.reversed())))`
`35`	`35`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ struct Handler: EventLoopLambdaHandler {`
`20`	`20`	`typealias In = String`
`21`	`21`	`typealias Out = String`
`22`	`22`
`23`		`- func handle(event: String, context: Lambda.Context) -> EventLoopFuture<String> {`
	`23`	`+ func handle(_ event: String, context: Lambda.Context) -> EventLoopFuture<String> {`
`24`	`24`	`// as an example, respond with the event's reversed body`
`25`	`25`	`context.eventLoop.makeSucceededFuture(String(event.reversed()))`
`26`	`26`	`}`
Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,7 @@ class LambdaHandlerTest: XCTestCase {`
`39`	`39`	`self.initialized = true`
`40`	`40`	`}`
`41`	`41`
`42`		`- func handle(event: String, context: Lambda.Context) async throws -> String {`
	`42`	`+ func handle(_ event: String, context: Lambda.Context) async throws -> String {`
`43`	`43`	`event`
`44`	`44`	`}`
`45`	`45`	`}`
`@@ -68,7 +68,7 @@ class LambdaHandlerTest: XCTestCase {`
`68`	`68`	`throw TestError("kaboom")`
`69`	`69`	`}`
`70`	`70`
`71`		`- func handle(event: String, context: Lambda.Context) async throws {`
	`71`	`+ func handle(_ event: String, context: Lambda.Context) async throws {`
`72`	`72`	`XCTFail("How can this be called if init failed")`
`73`	`73`	`}`
`74`	`74`	`}`
`@@ -91,7 +91,7 @@ class LambdaHandlerTest: XCTestCase {`
`91`	`91`
`92`	`92`	`init(context: Lambda.InitializationContext) {}`
`93`	`93`
`94`		`- func handle(event: String, context: Lambda.Context) async throws -> String {`
	`94`	`+ func handle(_ event: String, context: Lambda.Context) async throws -> String {`
`95`	`95`	`event`
`96`	`96`	`}`
`97`	`97`	`}`
`@@ -114,7 +114,7 @@ class LambdaHandlerTest: XCTestCase {`
`114`	`114`
`115`	`115`	`init(context: Lambda.InitializationContext) {}`
`116`	`116`
`117`		`- func handle(event: String, context: Lambda.Context) async throws {}`
	`117`	`+ func handle(_ event: String, context: Lambda.Context) async throws {}`
`118`	`118`	`}`
`119`	`119`
`120`	`120`	`let maxTimes = Int.random(in: 1 ... 10)`
`@@ -136,7 +136,7 @@ class LambdaHandlerTest: XCTestCase {`
`136`	`136`
`137`	`137`	`init(context: Lambda.InitializationContext) {}`
`138`	`138`
`139`		`- func handle(event: String, context: Lambda.Context) async throws -> String {`
	`139`	`+ func handle(_ event: String, context: Lambda.Context) async throws -> String {`
`140`	`140`	`throw TestError("boom")`
`141`	`141`	`}`
`142`	`142`	`}`
`@@ -159,7 +159,7 @@ class LambdaHandlerTest: XCTestCase {`
`159`	`159`	`typealias In = String`
`160`	`160`	`typealias Out = String`
`161`	`161`
`162`		`- func handle(event: String, context: Lambda.Context) -> EventLoopFuture<String> {`
	`162`	`+ func handle(_ event: String, context: Lambda.Context) -> EventLoopFuture<String> {`
`163`	`163`	`context.eventLoop.makeSucceededFuture(event)`
`164`	`164`	`}`
`165`	`165`	`}`
`@@ -181,7 +181,7 @@ class LambdaHandlerTest: XCTestCase {`
`181`	`181`	`typealias In = String`
`182`	`182`	`typealias Out = Void`
`183`	`183`
`184`		`- func handle(event: String, context: Lambda.Context) -> EventLoopFuture<Void> {`
	`184`	`+ func handle(_ event: String, context: Lambda.Context) -> EventLoopFuture<Void> {`
`185`	`185`	`context.eventLoop.makeSucceededFuture(())`
`186`	`186`	`}`
`187`	`187`	`}`
`@@ -203,7 +203,7 @@ class LambdaHandlerTest: XCTestCase {`
`203`	`203`	`typealias In = String`
`204`	`204`	`typealias Out = String`
`205`	`205`
`206`		`- func handle(event: String, context: Lambda.Context) -> EventLoopFuture<String> {`
	`206`	`+ func handle(_ event: String, context: Lambda.Context) -> EventLoopFuture<String> {`
`207`	`207`	`context.eventLoop.makeFailedFuture(TestError("boom"))`
`208`	`208`	`}`
`209`	`209`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ struct EchoHandler: EventLoopLambdaHandler {`
`19`	`19`	`typealias In = String`
`20`	`20`	`typealias Out = String`
`21`	`21`
`22`		`- func handle(event: String, context: Lambda.Context) -> EventLoopFuture<String> {`
	`22`	`+ func handle(_ event: String, context: Lambda.Context) -> EventLoopFuture<String> {`
`23`	`23`	`context.eventLoop.makeSucceededFuture(event)`
`24`	`24`	`}`
`25`	`25`	`}`
`@@ -34,7 +34,7 @@ struct FailedHandler: EventLoopLambdaHandler {`
`34`	`34`	`self.reason = reason`
`35`	`35`	`}`
`36`	`36`
`37`		`- func handle(event: String, context: Lambda.Context) -> EventLoopFuture<Void> {`
	`37`	`+ func handle(_ event: String, context: Lambda.Context) -> EventLoopFuture<Void> {`
`38`	`38`	`context.eventLoop.makeFailedFuture(TestError(self.reason))`
`39`	`39`	`}`
`40`	`40`	`}`
Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,7 @@ class LambdaLifecycleTest: XCTestCase {`
`54`	`54`	`self.shutdown = shutdown`
`55`	`55`	`}`
`56`	`56`
`57`		`- func handle(event: ByteBuffer, context: Lambda.Context) -> EventLoopFuture<ByteBuffer?> {`
	`57`	`+ func handle(_ event: ByteBuffer, context: Lambda.Context) -> EventLoopFuture<ByteBuffer?> {`
`58`	`58`	`self.handler(context, event)`
`59`	`59`	`}`
`60`	`60`
Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@ class CodableLambdaTest: XCTestCase {`
`43`	`43`
`44`	`44`	`let expected: Request`
`45`	`45`
`46`		`- func handle(event: Request, context: Lambda.Context) -> EventLoopFuture<Void> {`
	`46`	`+ func handle(_ event: Request, context: Lambda.Context) -> EventLoopFuture<Void> {`
`47`	`47`	`XCTAssertEqual(event, self.expected)`
`48`	`48`	`return context.eventLoop.makeSucceededVoidFuture()`
`49`	`49`	`}`
`@@ -52,7 +52,7 @@ class CodableLambdaTest: XCTestCase {`
`52`	`52`	`let handler = Handler(expected: request)`
`53`	`53`
`54`	`54`	`XCTAssertNoThrow(inputBuffer = try JSONEncoder().encode(request, using: self.allocator))`
`55`		`- XCTAssertNoThrow(outputBuffer = try handler.handle(event: XCTUnwrap(inputBuffer), context: self.newContext()).wait())`
	`55`	`+ XCTAssertNoThrow(outputBuffer = try handler.handle(XCTUnwrap(inputBuffer), context: self.newContext()).wait())`
`56`	`56`	`XCTAssertNil(outputBuffer)`
`57`	`57`	`}`
`58`	`58`
`@@ -68,7 +68,7 @@ class CodableLambdaTest: XCTestCase {`
`68`	`68`
`69`	`69`	`let expected: Request`
`70`	`70`
`71`		`- func handle(event: Request, context: Lambda.Context) -> EventLoopFuture<Response> {`
	`71`	`+ func handle(_ event: Request, context: Lambda.Context) -> EventLoopFuture<Response> {`
`72`	`72`	`XCTAssertEqual(event, self.expected)`
`73`	`73`	`return context.eventLoop.makeSucceededFuture(Response(requestId: event.requestId))`
`74`	`74`	`}`
`@@ -77,7 +77,7 @@ class CodableLambdaTest: XCTestCase {`
`77`	`77`	`let handler = Handler(expected: request)`
`78`	`78`
`79`	`79`	`XCTAssertNoThrow(inputBuffer = try JSONEncoder().encode(request, using: self.allocator))`
`80`		`- XCTAssertNoThrow(outputBuffer = try handler.handle(event: XCTUnwrap(inputBuffer), context: self.newContext()).wait())`
	`80`	`+ XCTAssertNoThrow(outputBuffer = try handler.handle(XCTUnwrap(inputBuffer), context: self.newContext()).wait())`
`81`	`81`	`XCTAssertNoThrow(response = try JSONDecoder().decode(Response.self, from: XCTUnwrap(outputBuffer)))`
`82`	`82`	`XCTAssertEqual(response?.requestId, request.requestId)`
`83`	`83`	`}`
`@@ -93,7 +93,7 @@ class CodableLambdaTest: XCTestCase {`
`93`	`93`
`94`	`94`	`init(context: Lambda.InitializationContext) async throws {}`
`95`	`95`
`96`		`- func handle(event: Request, context: Lambda.Context) async throws {`
	`96`	`+ func handle(_ event: Request, context: Lambda.Context) async throws {`
`97`	`97`	`XCTAssertEqual(event, self.expected)`
`98`	`98`	`}`
`99`	`99`	`}`
`@@ -107,7 +107,7 @@ class CodableLambdaTest: XCTestCase {`
`107`	`107`	`handler.expected = request`
`108`	`108`
`109`	`109`	`XCTAssertNoThrow(inputBuffer = try JSONEncoder().encode(request, using: self.allocator))`
`110`		`- XCTAssertNoThrow(outputBuffer = try handler.handle(event: XCTUnwrap(inputBuffer), context: self.newContext()).wait())`
	`110`	`+ XCTAssertNoThrow(outputBuffer = try handler.handle(XCTUnwrap(inputBuffer), context: self.newContext()).wait())`
`111`	`111`	`XCTAssertNil(outputBuffer)`
`112`	`112`	`}`
`113`	`113`	`}`
`@@ -122,7 +122,7 @@ class CodableLambdaTest: XCTestCase {`
`122`	`122`
`123`	`123`	`init(context: Lambda.InitializationContext) async throws {}`
`124`	`124`
`125`		`- func handle(event: Request, context: Lambda.Context) async throws -> Response {`
	`125`	`+ func handle(_ event: Request, context: Lambda.Context) async throws -> Response {`
`126`	`126`	`XCTAssertEqual(event, self.expected)`
`127`	`127`	`return Response(requestId: event.requestId)`
`128`	`128`	`}`
`@@ -138,7 +138,7 @@ class CodableLambdaTest: XCTestCase {`
`138`	`138`	`handler.expected = request`
`139`	`139`
`140`	`140`	`XCTAssertNoThrow(inputBuffer = try JSONEncoder().encode(request, using: self.allocator))`
`141`		`- XCTAssertNoThrow(outputBuffer = try handler.handle(event: XCTUnwrap(inputBuffer), context: self.newContext()).wait())`
	`141`	`+ XCTAssertNoThrow(outputBuffer = try handler.handle(XCTUnwrap(inputBuffer), context: self.newContext()).wait())`
`142`	`142`	`XCTAssertNoThrow(response = try JSONDecoder().decode(Response.self, from: XCTUnwrap(outputBuffer)))`
`143`	`143`	`XCTAssertEqual(response?.requestId, request.requestId)`
`144`	`144`	`}`
Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ class LambdaTestingTests: XCTestCase {`
`35`	`35`
`36`	`36`	`init(context: Lambda.InitializationContext) {}`
`37`	`37`
`38`		`- func handle(event: Request, context: Lambda.Context) async throws -> Response {`
	`38`	`+ func handle(_ event: Request, context: Lambda.Context) async throws -> Response {`
`39`	`39`	`Response(message: "echo" + event.name)`
`40`	`40`	`}`
`41`	`41`	`}`
`@@ -59,7 +59,7 @@ class LambdaTestingTests: XCTestCase {`
`59`	`59`
`60`	`60`	`init(context: Lambda.InitializationContext) {}`
`61`	`61`
`62`		`- func handle(event: Request, context: Lambda.Context) async throws {`
	`62`	`+ func handle(_ event: Request, context: Lambda.Context) async throws {`
`63`	`63`	`LambdaTestingTests.VoidLambdaHandlerInvokeCount += 1`
`64`	`64`	`}`
`65`	`65`	`}`
`@@ -79,7 +79,7 @@ class LambdaTestingTests: XCTestCase {`
`79`	`79`
`80`	`80`	`init(context: Lambda.InitializationContext) {}`
`81`	`81`
`82`		`- func handle(event: String, context: Lambda.Context) async throws {`
	`82`	`+ func handle(_ event: String, context: Lambda.Context) async throws {`
`83`	`83`	`throw MyError()`
`84`	`84`	`}`
`85`	`85`	`}`
`@@ -96,7 +96,7 @@ class LambdaTestingTests: XCTestCase {`
`96`	`96`
`97`	`97`	`init(context: Lambda.InitializationContext) {}`
`98`	`98`
`99`		`- func handle(event: String, context: Lambda.Context) async throws -> String {`
	`99`	`+ func handle(_ event: String, context: Lambda.Context) async throws -> String {`
`100`	`100`	`try await Task.sleep(nanoseconds: 500 * 1000 * 1000)`
`101`	`101`	`return event`
`102`	`102`	`}`