add more iteration to map example (#267)

Author: zhongkechen

examples/src/main/java/software/amazon/lambda/durable/examples/map/ComplexMapExample.java

@@ -5,11 +5,11 @@
 import java.time.Duration;
 import java.util.List;
 import java.util.stream.Collectors;
+import java.util.stream.IntStream;
 import software.amazon.lambda.durable.DurableContext;
 import software.amazon.lambda.durable.DurableHandler;
 import software.amazon.lambda.durable.config.CompletionConfig;
 import software.amazon.lambda.durable.config.MapConfig;
-import software.amazon.lambda.durable.examples.types.GreetingRequest;
 
 /**
  * Example demonstrating advanced map features: wait operations inside branches, error handling, and early termination.
@@ -20,19 +20,18 @@
  *   <li>Early termination with {@code minSuccessful(2)} — finds 2 healthy servers then stops
  * </ol>
  */
-public class ComplexMapExample extends DurableHandler<GreetingRequest, String> {
+public class ComplexMapExample extends DurableHandler<Integer, String> {
 
     @Override
-    public String handleRequest(GreetingRequest input, DurableContext context) {
-        var name = input.getName();
-        context.getLogger().info("Starting complex map example for {}", name);
+    public String handleRequest(Integer input, DurableContext context) {
+        context.getLogger().info("Starting complex map example with {} items", input);
 
         // Part 1: Concurrent map with step + wait inside each branch
-        var orderIds = List.of("order-1", "order-2", "order-3");
+        var orderIds = IntStream.range(1, input + 1).mapToObj(x -> "order-" + x).collect(Collectors.toList());
 
         var orderResult = context.map("process-orders", orderIds, String.class, (orderId, index, ctx) -> {
             // Step 1: validate the order
-            var validated = ctx.step("validate-" + index, String.class, stepCtx -> "validated:" + orderId + ":" + name);
+            var validated = ctx.step("validate-" + index, String.class, stepCtx -> "validated:" + orderId);
 
             // Wait between stages (simulates a cooldown or external dependency)
             ctx.wait("cooldown-" + index, Duration.ofSeconds(1));

examples/src/test/java/software/amazon/lambda/durable/examples/CloudBasedIntegrationTest.java

@@ -578,17 +578,17 @@ void testSimpleMapExample() {
 
     @Test
     void testComplexMapExample() {
-        var runner = CloudDurableTestRunner.create(arn("complex-map-example"), GreetingRequest.class, String.class);
-        var result = runner.run(new GreetingRequest("Alice"));
+        var runner = CloudDurableTestRunner.create(arn("complex-map-example"), Integer.class, String.class);
+        var result = runner.run(100);
 
         assertEquals(ExecutionStatus.SUCCEEDED, result.getStatus());
         var output = result.getResult(String.class);
         assertNotNull(output);
 
         // Part 1: Concurrent order processing with step + wait + step
-        assertTrue(output.contains("done:validated:order-1:Alice"));
-        assertTrue(output.contains("done:validated:order-2:Alice"));
-        assertTrue(output.contains("done:validated:order-3:Alice"));
+        assertTrue(output.contains("done:validated:order-1"));
+        assertTrue(output.contains("done:validated:order-2"));
+        assertTrue(output.contains("done:validated:order-100"));
 
         // Part 2: Early termination — find 2 healthy servers then stop
         assertTrue(output.contains("healthy"));

examples/src/test/java/software/amazon/lambda/durable/examples/map/ComplexMapExampleTest.java

@@ -5,7 +5,6 @@
 import static org.junit.jupiter.api.Assertions.*;
 
 import org.junit.jupiter.api.Test;
-import software.amazon.lambda.durable.examples.types.GreetingRequest;
 import software.amazon.lambda.durable.model.ExecutionStatus;
 import software.amazon.lambda.durable.testing.LocalDurableTestRunner;
 
@@ -14,17 +13,17 @@ class ComplexMapExampleTest {
     @Test
     void testComplexMapExample() {
         var handler = new ComplexMapExample();
-        var runner = LocalDurableTestRunner.create(GreetingRequest.class, handler);
+        var runner = LocalDurableTestRunner.create(Integer.class, handler);
 
-        var result = runner.runUntilComplete(new GreetingRequest("Alice"));
+        var result = runner.runUntilComplete(50);
 
         assertEquals(ExecutionStatus.SUCCEEDED, result.getStatus());
         var output = result.getResult(String.class);
 
         // Part 1: all 3 orders processed with step + wait + step
-        assertTrue(output.contains("done:validated:order-1:Alice"));
-        assertTrue(output.contains("done:validated:order-2:Alice"));
-        assertTrue(output.contains("done:validated:order-3:Alice"));
+        assertTrue(output.contains("done:validated:order-1"));
+        assertTrue(output.contains("done:validated:order-2"));
+        assertTrue(output.contains("done:validated:order-50"));
 
         // Part 2: early termination after 2 healthy servers
         assertTrue(output.contains("reason=MIN_SUCCESSFUL_REACHED"));
@@ -34,21 +33,20 @@ void testComplexMapExample() {
     @Test
     void testReplay() {
         var handler = new ComplexMapExample();
-        var runner = LocalDurableTestRunner.create(GreetingRequest.class, handler);
+        var runner = LocalDurableTestRunner.create(Integer.class, handler);
 
-        var input = new GreetingRequest("Bob");
-        var result1 = runner.runUntilComplete(input);
+        var result1 = runner.runUntilComplete(50);
         assertEquals(ExecutionStatus.SUCCEEDED, result1.getStatus());
 
         // Replay — should use cached results.
         // Structural assertion because the first map has wait() inside branches with unlimited
         // concurrency, which can cause non-deterministic thread scheduling across invocations.
-        var result2 = runner.runUntilComplete(input);
+        var result2 = runner.runUntilComplete(50);
         assertEquals(ExecutionStatus.SUCCEEDED, result2.getStatus());
         var output = result2.getResult(String.class);
-        assertTrue(output.contains("done:validated:order-1:Bob"));
-        assertTrue(output.contains("done:validated:order-2:Bob"));
-        assertTrue(output.contains("done:validated:order-3:Bob"));
+        assertTrue(output.contains("done:validated:order-1"));
+        assertTrue(output.contains("done:validated:order-2"));
+        assertTrue(output.contains("done:validated:order-50"));
         assertTrue(output.contains("reason=MIN_SUCCESSFUL_REACHED"));
         assertTrue(output.contains("healthy"));
     }