add in a unit test to ensure that this behavior does not regress

Author: benrosen78

Tests/AWSLambdaRuntimeTests/LambdaRuntimeClientTests.swift

@@ -330,4 +330,78 @@ struct LambdaRuntimeClientTests {
             }
         }
     }
+
+    @Test(
+        "reportError() sends the correct errorType for different Error types",
+    )
+    @available(LambdaSwift 2.0, *)
+    func testReportErrorReturnsProperErrorType() async throws {
+        // Custom error types for testing
+        struct MyCustomError: Error {
+            let message: String
+        }
+
+        enum MyEnumError: Error {
+            case anotherCase(String)
+        }
+
+        struct ErrorReportingBehavior: LambdaServerBehavior {
+            let requestId = UUID().uuidString
+            let event = "error-testing"
+            let expectedErrorType: String
+
+            func getInvocation() -> GetInvocationResult {
+                .success((self.requestId, self.event))
+            }
+
+            func processResponse(requestId: String, response: String?) -> Result<String?, ProcessResponseError> {
+                Issue.record("should not process response, expecting error report")
+                return .failure(.internalServerError)
+            }
+
+            func processError(requestId: String, error: ErrorResponse) -> Result<Void, ProcessErrorError> {
+                #expect(self.requestId == requestId)
+                #expect(
+                    error.errorType == self.expectedErrorType,
+                    "Expected errorType '\(self.expectedErrorType)' but got '\(error.errorType)'"
+                )
+                return .success(())
+            }
+
+            func processInitError(error: ErrorResponse) -> Result<Void, ProcessErrorError> {
+                Issue.record("should not report init error")
+                return .failure(.internalServerError)
+            }
+        }
+
+        // Test with MyCustomError
+        try await withMockServer(behaviour: ErrorReportingBehavior(expectedErrorType: "MyCustomError")) { port in
+            let configuration = LambdaRuntimeClient.Configuration(ip: "127.0.0.1", port: port)
+
+            try await LambdaRuntimeClient.withRuntimeClient(
+                configuration: configuration,
+                eventLoop: NIOSingletons.posixEventLoopGroup.next(),
+                logger: self.logger
+            ) { runtimeClient in
+                let (_, writer) = try await runtimeClient.nextInvocation()
+                let error = MyCustomError(message: "Something went wrong")
+                try await writer.reportError(error)
+            }
+        }
+
+        // Test with MyEnumError
+        try await withMockServer(behaviour: ErrorReportingBehavior(expectedErrorType: "MyEnumError")) { port in
+            let configuration = LambdaRuntimeClient.Configuration(ip: "127.0.0.1", port: port)
+
+            try await LambdaRuntimeClient.withRuntimeClient(
+                configuration: configuration,
+                eventLoop: NIOSingletons.posixEventLoopGroup.next(),
+                logger: self.logger
+            ) { runtimeClient in
+                let (_, writer) = try await runtimeClient.nextInvocation()
+                let error = MyEnumError.anotherCase("test")
+                try await writer.reportError(error)
+            }
+        }
+    }
 }