add Cloud runner support for invoke operation (#44)

Author: zhongkechen

examples/src/test/java/com/amazonaws/lambda/durable/examples/CloudBasedIntegrationTest.java

@@ -68,6 +68,19 @@ void testSimpleStepExample() {
         assertEquals("create-greeting", createGreetingOp.getName());
     }
 
+    @Test
+    void testSimpleInvokeExample() {
+        var runner = CloudDurableTestRunner.create(arn("simple-invoke-example"), Map.class, String.class);
+        var result = runner.run(Map.of("message", "test"));
+
+        assertEquals(ExecutionStatus.SUCCEEDED, result.getStatus());
+        assertNotNull(result.getResult(String.class));
+
+        var createGreetingOp = runner.getOperation("invoke-greeting1");
+        assertNotNull(createGreetingOp);
+        assertEquals("invoke-greeting1", createGreetingOp.getName());
+    }
+
     @Test
     void testRetryExample() {
         var runner = CloudDurableTestRunner.create(arn("retry-example"), String.class, String.class);

sdk-testing/src/main/java/com/amazonaws/lambda/durable/testing/HistoryEventProcessor.java

@@ -8,6 +8,7 @@
 import java.util.HashMap;
 import java.util.List;
 import software.amazon.awssdk.services.lambda.model.CallbackDetails;
+import software.amazon.awssdk.services.lambda.model.ChainedInvokeDetails;
 import software.amazon.awssdk.services.lambda.model.ErrorObject;
 import software.amazon.awssdk.services.lambda.model.Event;
 import software.amazon.awssdk.services.lambda.model.Operation;
@@ -150,8 +151,12 @@ public <O> TestResult<O> processEvents(List<Event> events, Class<O> outputType)
                         CHAINED_INVOKE_FAILED,
                         CHAINED_INVOKE_TIMED_OUT,
                         CHAINED_INVOKE_STOPPED -> {
-                    throw new UnsupportedOperationException("Context operations currently not supported");
+                    if (operationId != null) {
+                        operations.putIfAbsent(operationId, createInvokeOperation(operationId, event));
+                    }
                 }
+
+                default -> throw new UnsupportedOperationException("Unknown operation: " + eventType);
             }
         }
 
@@ -230,4 +235,61 @@ private Operation createCallbackOperation(String id, String name, OperationStatu
                 .callbackDetails(builder.build())
                 .build();
     }
+
+    private Operation createInvokeOperation(String id, Event event) {
+        var builder = ChainedInvokeDetails.builder();
+
+        OperationStatus status =
+                switch (event.eventType()) {
+                    case CHAINED_INVOKE_STARTED -> OperationStatus.STARTED;
+                    case CHAINED_INVOKE_SUCCEEDED -> {
+                        var details = event.callbackSucceededDetails();
+                        if (details != null
+                                && details.result() != null
+                                && details.result().payload() != null) {
+                            builder.result(details.result().payload());
+                        }
+                        yield OperationStatus.SUCCEEDED;
+                    }
+                    case CHAINED_INVOKE_FAILED -> {
+                        var details = event.callbackFailedDetails();
+                        if (details != null
+                                && details.error() != null
+                                && details.error().payload() != null) {
+                            builder.error(details.error().payload());
+                        }
+                        yield OperationStatus.FAILED;
+                    }
+                    case CHAINED_INVOKE_STOPPED -> {
+                        var details = event.chainedInvokeStoppedDetails();
+                        if (details != null
+                                && details.error() != null
+                                && details.error().payload() != null) {
+                            builder.error(details.error().payload());
+                        }
+
+                        yield OperationStatus.STOPPED;
+                    }
+                    case CHAINED_INVOKE_TIMED_OUT -> {
+                        var details = event.chainedInvokeTimedOutDetails();
+                        if (details != null
+                                && details.error() != null
+                                && details.error().payload() != null) {
+                            builder.error(details.error().payload());
+                        }
+                        yield OperationStatus.TIMED_OUT;
+                    }
+                    default ->
+                        throw new UnsupportedOperationException(
+                                "Unknown chained invocation operation: " + event.eventType());
+                };
+
+        return Operation.builder()
+                .id(id)
+                .name(event.name())
+                .status(status)
+                .type(OperationType.CHAINED_INVOKE)
+                .chainedInvokeDetails(builder.build())
+                .build();
+    }
 }