cleanup and refactoring

motivation: cleaner code base

changes:
* define generic Result type, and make LambdaResult a type alias
* rename RunLambdaResult to LambdaRunResult
* remove redundant test and dead code

Author: tomerd

Sources/SwiftAwsLambda/Lambda+Codable.swift

@@ -34,7 +34,7 @@ extension Lambda {
     }
 }
 
-public typealias LambdaCodableResult<Out> = LambdaResult<Out, String>
+public typealias LambdaCodableResult<Out> = Result<Out, String>
 
 public typealias LambdaCodableCallback<Out> = (LambdaCodableResult<Out>) -> Void
 
@@ -62,7 +62,7 @@ public class LambdaCodableCodec<In: Decodable, Out: Encodable> {
 }
 
 public extension LambdaCodableHandler {
-    func handle(context: LambdaContext, payload: [UInt8], callback: @escaping (LambdaResult<[UInt8], String>) -> Void) {
+    func handle(context: LambdaContext, payload: [UInt8], callback: @escaping (LambdaResult) -> Void) {
         guard let payloadAsCodable = codec.decode(payload) else {
             return callback(.failure("failed decoding payload (in)"))
         }

Sources/SwiftAwsLambda/Lambda+String.swift

@@ -32,7 +32,8 @@ extension Lambda {
     }
 }
 
-public typealias LambdaStringResult = LambdaResult<String, String>
+public typealias LambdaStringResult = Result<String, String>
+
 public typealias LambdaStringCallback = (LambdaStringResult) -> Void
 
 public typealias LambdaStringClosure = (LambdaContext, String, LambdaStringCallback) -> Void

Sources/SwiftAwsLambda/Lambda.swift

@@ -66,21 +66,27 @@ public final class Lambda {
     }
 }
 
-public enum LambdaResult<Value, Error> {
-    case success(Value)
-    case failure(Error)
-}
+public typealias LambdaResult = Result<[UInt8], String>
 
-public typealias LambdaLifecycleResult = LambdaResult<Int, Error>
+public typealias LambdaLifecycleResult = Result<Int, Error>
 
-public typealias LambdaCallback = (LambdaResult<[UInt8], String>) -> Void
+public typealias LambdaCallback = (LambdaResult) -> Void
 
 public typealias LambdaClosure = (LambdaContext, [UInt8], LambdaCallback) -> Void
 
 public protocol LambdaHandler {
     func handle(context: LambdaContext, payload: [UInt8], callback: @escaping LambdaCallback)
 }
 
+public struct LambdaContext {
+    public let requestId: String
+    public let traceId: String?
+    public let invokedFunctionArn: String?
+    public let cognitoIdentity: String?
+    public let clientContext: String?
+    public let deadlineNs: String?
+}
+
 private class LambdaClosureWrapper: LambdaHandler {
     private let closure: LambdaClosure
     init(_ closure: @escaping LambdaClosure) {

Sources/SwiftAwsLambda/LambdaContext.swift

@@ -28,7 +28,7 @@ internal final class LambdaRunner {
     }
 
     // TODO: should we move the event loop as an argument instead of instance variable?
-    func run() -> EventLoopFuture<RunLambdaResult> {
+    func run() -> EventLoopFuture<LambdaRunResult> {
         print("lambda invocation sequence starting")
         // 1. request work from lambda runtime engine
         return runtimeClient.requestWork().then { workRequestResult in
@@ -39,7 +39,7 @@ internal final class LambdaRunner {
             case let .success(context, payload):
                 // 2. send work to handler
                 print("sending work to lambda handler \(self.lambdaHandler)")
-                let promise: EventLoopPromise<LambdaResult<[UInt8], String>> = self.eventLoop.newPromise()
+                let promise: EventLoopPromise<LambdaResult> = self.eventLoop.newPromise()
                 self.lambdaHandler.handle(context: context, payload: payload, promise: promise)
                 return promise.futureResult.then { lambdaResult in
                     // 3. report results to runtime engine
@@ -64,13 +64,13 @@ internal final class LambdaRunner {
     }
 }
 
-internal typealias RunLambdaResult = LambdaResult<(), Error>
+internal typealias LambdaRunResult = Result<(), Error>
 
 private extension LambdaHandler {
-    func handle(context: LambdaContext, payload: [UInt8], promise: EventLoopPromise<LambdaResult<[UInt8], String>>) {
+    func handle(context: LambdaContext, payload: [UInt8], promise: EventLoopPromise<LambdaResult>) {
         // offloading so user code never blocks the eventloop
         DispatchQueue(label: "lambda-\(context.requestId)").async {
-            self.handle(context: context, payload: payload, callback: { (result: LambdaResult<[UInt8], String>) in
+            self.handle(context: context, payload: payload, callback: { (result: LambdaResult) in
                 promise.succeed(result: result)
             })
         }

Sources/SwiftAwsLambda/LambdaRunner.swift

@@ -45,7 +45,7 @@ internal class LambdaRuntimeClient {
         }
     }
 
-    func reportResults(context: LambdaContext, result: LambdaResult<[UInt8], String>) -> EventLoopFuture<PostResultsResult> {
+    func reportResults(context: LambdaContext, result: LambdaResult) -> EventLoopFuture<PostResultsResult> {
         var url = baseUrl + Consts.invokationURLPrefix + "/" + context.requestId
         var body: ByteBuffer
         switch result {
@@ -72,8 +72,8 @@ internal class LambdaRuntimeClient {
     }
 }
 
-internal typealias RequestWorkResult = LambdaResult<(LambdaContext, [UInt8]), LambdaRuntimeClientError>
-internal typealias PostResultsResult = LambdaResult<(), LambdaRuntimeClientError>
+internal typealias RequestWorkResult = Result<(LambdaContext, [UInt8]), LambdaRuntimeClientError>
+internal typealias PostResultsResult = Result<(), LambdaRuntimeClientError>
 
 internal enum LambdaRuntimeClientError: Error {
     case badStatusCode

Sources/SwiftAwsLambda/LambdaRuntimeClient.swift

@@ -14,6 +14,11 @@
 
 import NIO
 
+public enum Result<Value, Error> {
+    case success(Value)
+    case failure(Error)
+}
+
 internal enum Consts {
     static let hostPortEnvVariableName = "AWS_LAMBDA_RUNTIME_API"
 

Sources/SwiftAwsLambda/Utils.swift

@@ -15,7 +15,7 @@
 import SwiftAwsLambda
 
 // in this example we are receiving and responding with strings
-let result = Lambda.run { (context: LambdaContext, payload: String, callback: LambdaStringCallback) in
+let result = Lambda.run { (_: LambdaContext, payload: String, callback: LambdaStringCallback) in
     // as an example, respond with the reverse the input payload
     callback(.success(String(payload.reversed())))
 }

Sources/SwiftAwsLambdaStringSample/main.swift

@@ -30,7 +30,6 @@ extension LambdaTest {
                 ("testFailure", testFailure),
                 ("testClosureSuccess", testClosureSuccess),
                 ("testClosureFailure", testClosureFailure),
-                ("testStringSuceess", testStringSuceess),
            ]
    }
 }

Tests/SwiftAwsLambdaTests/LambdaTest+XCTest.swift

@@ -50,21 +50,6 @@ class LambdaTest: XCTestCase {
         try server.stop().wait()
         assertLambdaLifecycleResult(result: result, shouldFailWithError: LambdaRuntimeClientError.badStatusCode)
     }
-
-    // FIXME: seepraet test class?
-
-    func testStringSuceess() throws {
-        class EchoStringHandler: LambdaStringHandler {
-            func handle(context _: LambdaContext, payload: String, callback: @escaping LambdaStringCallback) {
-                callback(.success(payload))
-            }
-        }
-        let maxTimes = Int.random(in: 1 ... 10)
-        let server = try MockLambdaServer(behavior: GoodBehavior()).start().wait()
-        let result = Lambda.run(handler: EchoStringHandler(), maxTimes: maxTimes) // blocking
-        try server.stop().wait()
-        assertLambdaLifecycleResult(result: result, shoudHaveRun: maxTimes)
-    }
 }
 
 private func assertLambdaLifecycleResult(result: LambdaLifecycleResult, shoudHaveRun: Int = 0, shouldFailWithError: Error? = nil) {

Tests/SwiftAwsLambdaTests/LambdaTest.swift

@@ -135,7 +135,7 @@ internal final class HTTPHandler: ChannelInboundHandler {
         } else if requestHead.uri.hasSuffix(Consts.postResponseURLSuffix) {
             guard let requestId = requestHead.uri.split(separator: "/").dropFirst(2).first,
                 let response = requestBody
-                else {
+            else {
                 return writeResponse(ctx: ctx, version: requestHead.version, status: .badRequest)
             }
             switch behavior.processResponse(requestId: String(requestId), response: response) {
@@ -148,7 +148,7 @@ internal final class HTTPHandler: ChannelInboundHandler {
             guard let requestId = requestHead.uri.split(separator: "/").dropFirst(2).first,
                 let json = requestBody,
                 let error = ErrorResponse.fromJson(json)
-                else {
+            else {
                 return writeResponse(ctx: ctx, version: requestHead.version, status: .badRequest)
             }
             switch behavior.processError(requestId: String(requestId), error: error) {
@@ -189,7 +189,7 @@ internal protocol LambdaServerBehavior {
     func processError(requestId: String, error: ErrorResponse) -> ProcessErrorResult
 }
 
-internal typealias GetWorkResult = LambdaResult<(String, String), GetWorkError>
+internal typealias GetWorkResult = Result<(String, String), GetWorkError>
 
 internal enum GetWorkError: Int {
     case badRequest = 400
@@ -209,7 +209,7 @@ internal enum ProcessResponseError: Int {
     case internalServerError = 500
 }
 
-internal typealias ProcessErrorResult = LambdaResult<(), ProcessError>
+internal typealias ProcessErrorResult = Result<(), ProcessError>
 
 internal enum ProcessError: Int, Error {
     case invalidErrorShape = 299

Tests/SwiftAwsLambdaTests/MockLambdaServer.swift

@@ -16,27 +16,15 @@ import NIO
 @testable import SwiftAwsLambda
 import XCTest
 
-func runLambda(behavior: LambdaServerBehavior, handler: LambdaHandler) throws -> RunLambdaResult {
-    /* let eventLoop = MultiThreadedEventLoopGroup(numberOfThreads: 1).next()
-     let server = MockLambdaServer(behavior: behavior)
-     return server.start().hopTo(eventLoop: eventLoop).then { _ in
-     let runner = LambdaRunner(eventLoop: eventLoop, lambdaHandler: handler)
-     return runner.run().then { result in
-     server.stop().hopTo(eventLoop: eventLoop).then { _ in
-     print("\(server) stopped")
-     return eventLoop.newSucceededFuture(result: result)
-     }
-     }
-     } */
-
+func runLambda(behavior: LambdaServerBehavior, handler: LambdaHandler) throws -> LambdaRunResult {
     let runner = LambdaRunner(handler)
     let server = try MockLambdaServer(behavior: behavior).start().wait()
     let result = try runner.run().wait()
     try server.stop().wait()
     return result
 }
 
-func assertRunLambdaResult(result: RunLambdaResult, shouldFailWithError: Error? = nil) {
+func assertRunLambdaResult(result: LambdaRunResult, shouldFailWithError: Error? = nil) {
     switch result {
     case .success:
         if nil != shouldFailWithError {