This handler demonstrates a human approval workflow: + * + *
External systems respond using AWS Lambda APIs: + * + *
Submits an approval request to an external system via a callback. If the callback fails (e.g., the external system + * rejects the request), the helper retries the entire waitForCallback cycle — creating a fresh callback with a new ID + * each time. + * + *
Each attempt uses a unique callback name ({@code "approval-1"}, {@code "approval-2"}, etc.) so the execution
+ * history stays clean and replay-safe. A {@code null} name is used, so attempts are grouped under a default-named child
+ * context.
+ */
+public class RetryWaitForCallbackExample extends DurableHandler This handler runs three concurrent child contexts using {@code runInChildContextAsync}:
+ *
+ * All three child contexts run concurrently. Results are collected with {@link DurableFuture#allOf} and combined
+ * into a summary string.
+ */
+public class ChildContextExample extends DurableHandler This example tests the SDK's ability to handle many concurrent operations:
+ *
+ * This handler runs three concurrent child contexts using {@code runInChildContextAsync}:
+ *
+ * All three child contexts run concurrently. Results are collected with {@link DurableFuture#allOf} and combined
+ * into a summary string.
+ */
+public class VirtualChildContextExample extends DurableHandler This example demonstrates:
+ *
+ * The polling strategy controls how the SDK polls for async operation results. By default, the SDK uses exponential
+ * backoff (1s base, 2x rate, full jitter). This example shows how to customize the polling behavior.
+ *
+ * This example configures:
+ *
+ * This example shows how to handle:
+ *
+ * Note: {@code NonDeterministicExecutionException} is thrown by the SDK when code changes between executions (e.g.,
+ * step order/names changed). It should be fixed in code, not caught.
+ */
+public class ErrorHandlingExample extends DurableHandler This example shows how to use TypeToken to work with generic types like {@code List This example shows how to use TypeToken to work with generic types like {@code List The logger automatically includes execution metadata (durableExecutionArn, requestId, operationId, operationName)
+ * in log entries via MDC. By default, logs are suppressed during replay to avoid duplicates.
+ */
+public class LoggingExample extends DurableHandler This handler processes a greeting request and returns a greeting message
+ */
+public class NoopExample extends DurableHandler This handler configures the OTel plugin with:
+ *
+ * In production, replace {@code LoggingSpanExporter} with {@code OtlpGrpcSpanExporter} to send spans to an OTLP
+ * collector (X-Ray, Datadog, etc.).
+ *
+ * Expected trace structure:
+ *
+ * This handler registers a simple logging plugin that prints lifecycle events to stdout (which appears in CloudWatch
+ * Logs when deployed). Deploy this and check CloudWatch to verify all hooks fire at the right times.
+ *
+ * Expected output for a successful run:
+ *
+ * Retries a chained Lambda invocation up to 3 times with a fixed 2-second backoff between attempts. Each attempt
+ * uses a unique operation name ({@code "call-greeting-1"}, {@code "call-greeting-2"}, etc.) so the execution history
+ * stays clean and replay-safe.
+ *
+ * A {@code null} name is used, so attempts are grouped under a default-named child context.
+ */
+public class RetryInvokeExample extends DurableHandler This handler invokes another Lambda function, such as simple-step-example.
+ */
+public class SimpleInvokeExample extends DurableHandler The operation completes successfully once enough providers respond, or completes unsuccessfully once too many
+ * providers fail. The custom decision chooses both when the map completes and which completion status the caller sees.
+ */
+public class CustomShouldCompleteMapExample
+ extends DurableHandler This handler processes a list of names concurrently using {@code map()}, where each item runs in its own child
+ * context with full checkpoint-and-replay support.
+ *
+ * This handler processes a list of names concurrently using {@code map()}, where each item runs in its own child
+ * context with full checkpoint-and-replay support.
+ *
+ * {@link ExecutionOtelPlugin#ExecutionOtelPlugin()} uses the global provider initialized by the ADOT Java agent. The
+ * ExecutionOtelPlugin renders the Workflow span as the trace root with operations as siblings of the invocation span.
+ */
+@ExampleTemplate(tracing = true, javaAgent = true)
+public class OtelXRayExecutionStepExample extends DurableHandler Exercises the multi-invocation tracing scenario with the workflow-rooted trace structure. The Workflow span is
+ * only exported on the terminal invocation, producing a clean single-execution trace.
+ */
+@ExampleTemplate(tracing = true, javaAgent = true)
+public class OtelXRayExecutionWaitExample extends DurableHandler Exports spans through the ADOT Java agent global OpenTelemetry provider. Requires:
+ *
+ * Expected trace structure in X-Ray:
+ *
+ * This handler exercises the critical multi-invocation tracing scenario:
+ *
+ * Exports spans through the ADOT Java agent global OpenTelemetry provider. Requires:
+ *
+ * Expected trace structure in X-Ray (all under one trace ID — backend propagates same Root):
+ *
+ * This handler processes a list of items concurrently using {@code parallel()}:
+ *
+ * The {@link ParallelDurableFuture} implements {@link AutoCloseable}, so try-with-resources guarantees
+ * {@code join()} is called even if an exception occurs.
+ */
+public class DeserializationFailedParallelExample
+ extends DurableHandler This handler processes a list of items concurrently using {@code parallel()}:
+ *
+ * The {@link ParallelDurableFuture} implements {@link AutoCloseable}, so try-with-resources guarantees
+ * {@code join()} is called even if an exception occurs.
+ */
+public class ParallelExample extends DurableHandler When {@code toleratedFailureCount} is set, the parallel operation completes successfully even if some branches
+ * fail — as long as the number of failures does not exceed the threshold. Failed branches produce {@code null} results
+ * that callers can filter out.
+ *
+ * Use this pattern when partial success is acceptable, for example: sending notifications to multiple channels where
+ * some channels may be unavailable.
+ */
+public class ParallelFailureToleranceExample
+ extends DurableHandler This models a notification fan-out pattern where different channels have different delivery delays:
+ *
+ * All three branches run concurrently. Branches with waits suspend without consuming compute resources and resume
+ * automatically once the wait elapses. The parallel operation completes once all branches finish.
+ */
+public class ParallelWithWaitExample
+ extends DurableHandler This example tests the SDK's ability to handle many concurrent operations:
+ *
+ * This example shows:
+ *
+ * This example shows:
+ *
+ * This handler processes a greeting request through three sequential steps:
+ *
+ * This example tests the SDK's ability to handle many concurrent operations:
+ *
+ * Runs many (totalOperations) waitForCondition operations concurrently (maxConcurrency). Each operation:
+ *
+ * This handler starts a wait and a step concurrently, then collects both results. The wait acts as a minimum
+ * duration guarantee — the step runs in parallel, and the handler only proceeds once both the step completes and the
+ * wait elapses.
+ *
+ * This example shows suspension behavior with pending async steps:
+ *
+ * This example shows in-process wait behavior:
+ *
+ * This handler processes a request through steps with delays:
+ *
+ * This handler polls a condition function until it signals completion:
+ *
+ * These verify that the OTel plugin doesn't break execution for map, parallel, and nested context scenarios.
+ */
+class OtelXRayExamplesTest {
+
+ @Test
+ void mapExample_executesSuccessfully() {
+ var handler = new OtelXRayExamples.MapExample();
+ var runner = LocalDurableTestRunner.create(GreetingRequest.class, handler);
+
+ var result = runner.runUntilComplete(new GreetingRequest("test"));
+
+ assertEquals(ExecutionStatus.SUCCEEDED, result.getStatus());
+ assertEquals("Mapped 3 items", result.getResult(String.class));
+ }
+
+ @Test
+ void parallelExample_executesSuccessfully() {
+ var handler = new OtelXRayExamples.ParallelExample();
+ var runner = LocalDurableTestRunner.create(GreetingRequest.class, handler);
+
+ var result = runner.runUntilComplete(new GreetingRequest("test"));
+
+ assertEquals(ExecutionStatus.SUCCEEDED, result.getStatus());
+ assertTrue(result.getResult(String.class).contains("Parallel completed: 2 branches"));
+ }
+
+ @Test
+ void nestedContextExample_executesSuccessfully() {
+ var handler = new OtelXRayExamples.NestedContextExample();
+ var runner = LocalDurableTestRunner.create(GreetingRequest.class, handler);
+
+ var result = runner.runUntilComplete(new GreetingRequest("World"));
+
+ assertEquals(ExecutionStatus.SUCCEEDED, result.getStatus());
+ assertEquals("HELLO, WORLD!", result.getResult(String.class));
+ }
+}
diff --git a/examples/src/test/java/software/amazon/lambda/durable/examples/operation/otel/OtelXRayExecutionStepExampleTest.java b/examples/src/test/java/software/amazon/lambda/durable/examples/operation/otel/OtelXRayExecutionStepExampleTest.java
new file mode 100644
index 000000000..f2b4cfb03
--- /dev/null
+++ b/examples/src/test/java/software/amazon/lambda/durable/examples/operation/otel/OtelXRayExecutionStepExampleTest.java
@@ -0,0 +1,48 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+package software.amazon.lambda.durable.examples.operation.otel;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+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;
+
+class OtelXRayExecutionStepExampleTest {
+
+ @BeforeEach
+ void setUp() {
+ OtelXRayExampleTestSupport.installGlobalOpenTelemetry();
+ }
+
+ @AfterEach
+ void tearDown() {
+ OtelXRayExampleTestSupport.resetGlobalOpenTelemetry();
+ }
+
+ @Test
+ void testSimpleSteps_succeeds() {
+ var handler = new OtelXRayExecutionStepExample();
+ var runner = LocalDurableTestRunner.create(GreetingRequest.class, handler);
+
+ var result = runner.runUntilComplete(new GreetingRequest("Alice"));
+
+ assertEquals(ExecutionStatus.SUCCEEDED, result.getStatus());
+ assertEquals("HELLO, ALICE!", result.getResult(String.class));
+ }
+
+ @Test
+ void testReplay_returnsSameResult() {
+ var handler = new OtelXRayExecutionStepExample();
+ var runner = LocalDurableTestRunner.create(GreetingRequest.class, handler);
+
+ var input = new GreetingRequest("Bob");
+ var result1 = runner.runUntilComplete(input);
+ var result2 = runner.runUntilComplete(input);
+
+ assertEquals(result1.getResult(String.class), result2.getResult(String.class));
+ }
+}
diff --git a/examples/src/test/java/software/amazon/lambda/durable/examples/operation/otel/OtelXRayExecutionWaitExampleTest.java b/examples/src/test/java/software/amazon/lambda/durable/examples/operation/otel/OtelXRayExecutionWaitExampleTest.java
new file mode 100644
index 000000000..fd7ed672d
--- /dev/null
+++ b/examples/src/test/java/software/amazon/lambda/durable/examples/operation/otel/OtelXRayExecutionWaitExampleTest.java
@@ -0,0 +1,48 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+package software.amazon.lambda.durable.examples.operation.otel;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+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;
+
+class OtelXRayExecutionWaitExampleTest {
+
+ @BeforeEach
+ void setUp() {
+ OtelXRayExampleTestSupport.installGlobalOpenTelemetry();
+ }
+
+ @AfterEach
+ void tearDown() {
+ OtelXRayExampleTestSupport.resetGlobalOpenTelemetry();
+ }
+
+ @Test
+ void testFirstInvocation_suspendsOnWait() {
+ var handler = new OtelXRayExecutionWaitExample();
+ var runner = LocalDurableTestRunner.create(GreetingRequest.class, handler);
+
+ var result = runner.run(new GreetingRequest("Alice"));
+
+ assertEquals(ExecutionStatus.PENDING, result.getStatus());
+ }
+
+ @Test
+ void testFullExecution_completesAfterWait() {
+ var handler = new OtelXRayExecutionWaitExample();
+ var runner = LocalDurableTestRunner.create(GreetingRequest.class, handler);
+
+ var result = runner.runUntilComplete(new GreetingRequest("Alice"));
+
+ assertEquals(ExecutionStatus.SUCCEEDED, result.getStatus());
+ assertTrue(
+ result.getResult(String.class).contains("Resumed and completed"),
+ "Expected result to contain 'Resumed and completed', got: " + result.getResult(String.class));
+ }
+}
diff --git a/examples/src/test/java/software/amazon/lambda/durable/examples/operation/otel/OtelXRayStepExampleTest.java b/examples/src/test/java/software/amazon/lambda/durable/examples/operation/otel/OtelXRayStepExampleTest.java
new file mode 100644
index 000000000..322968d87
--- /dev/null
+++ b/examples/src/test/java/software/amazon/lambda/durable/examples/operation/otel/OtelXRayStepExampleTest.java
@@ -0,0 +1,59 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+package software.amazon.lambda.durable.examples.operation.otel;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+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;
+
+class OtelXRayStepExampleTest {
+
+ @BeforeEach
+ void setUp() {
+ OtelXRayExampleTestSupport.installGlobalOpenTelemetry();
+ }
+
+ @AfterEach
+ void tearDown() {
+ OtelXRayExampleTestSupport.resetGlobalOpenTelemetry();
+ }
+
+ @Test
+ void testSimpleSteps_succeeds() {
+ var handler = new OtelXRayStepExample();
+ var runner = LocalDurableTestRunner.create(GreetingRequest.class, handler);
+
+ var result = runner.run(new GreetingRequest("Alice"));
+
+ assertEquals(ExecutionStatus.SUCCEEDED, result.getStatus());
+ assertEquals("HELLO, ALICE!", result.getResult(String.class));
+ }
+
+ @Test
+ void testReplay_returnsSameResult() {
+ var handler = new OtelXRayStepExample();
+ var runner = LocalDurableTestRunner.create(GreetingRequest.class, handler);
+
+ var input = new GreetingRequest("Bob");
+ var result1 = runner.run(input);
+ var result2 = runner.run(input);
+
+ assertEquals(result1.getResult(String.class), result2.getResult(String.class));
+ }
+
+ @Test
+ void testDefaultName() {
+ var handler = new OtelXRayStepExample();
+ var runner = LocalDurableTestRunner.create(GreetingRequest.class, handler);
+
+ var result = runner.run(new GreetingRequest());
+
+ assertEquals(ExecutionStatus.SUCCEEDED, result.getStatus());
+ assertEquals("HELLO, WORLD!", result.getResult(String.class));
+ }
+}
diff --git a/examples/src/test/java/software/amazon/lambda/durable/examples/operation/otel/OtelXRayWaitExampleTest.java b/examples/src/test/java/software/amazon/lambda/durable/examples/operation/otel/OtelXRayWaitExampleTest.java
new file mode 100644
index 000000000..5a98fd778
--- /dev/null
+++ b/examples/src/test/java/software/amazon/lambda/durable/examples/operation/otel/OtelXRayWaitExampleTest.java
@@ -0,0 +1,61 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+package software.amazon.lambda.durable.examples.operation.otel;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+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;
+
+class OtelXRayWaitExampleTest {
+
+ @BeforeEach
+ void setUp() {
+ OtelXRayExampleTestSupport.installGlobalOpenTelemetry();
+ }
+
+ @AfterEach
+ void tearDown() {
+ OtelXRayExampleTestSupport.resetGlobalOpenTelemetry();
+ }
+
+ @Test
+ void testFirstInvocation_suspendsOnWait() {
+ var handler = new OtelXRayWaitExample();
+ var runner = LocalDurableTestRunner.create(GreetingRequest.class, handler);
+
+ var result = runner.run(new GreetingRequest("Alice"));
+
+ // First invocation hits the wait and suspends
+ assertEquals(ExecutionStatus.PENDING, result.getStatus());
+ }
+
+ @Test
+ void testFullExecution_completesAfterWait() {
+ var handler = new OtelXRayWaitExample();
+ var runner = LocalDurableTestRunner.create(GreetingRequest.class, handler);
+
+ var result = runner.runUntilComplete(new GreetingRequest("Alice"));
+
+ assertEquals(ExecutionStatus.SUCCEEDED, result.getStatus());
+ assertTrue(
+ result.getResult(String.class).contains("Resumed and completed"),
+ "Expected result to contain 'Resumed and completed', got: " + result.getResult(String.class));
+ }
+
+ @Test
+ void testReplay_returnsSameResult() {
+ var handler = new OtelXRayWaitExample();
+ var runner = LocalDurableTestRunner.create(GreetingRequest.class, handler);
+
+ var input = new GreetingRequest("Bob");
+ var result1 = runner.runUntilComplete(input);
+ var result2 = runner.runUntilComplete(input);
+
+ assertEquals(result1.getResult(String.class), result2.getResult(String.class));
+ }
+}
diff --git a/examples/src/test/java/software/amazon/lambda/durable/examples/operation/parallel/DeserializationFailedParallelExampleTest.java b/examples/src/test/java/software/amazon/lambda/durable/examples/operation/parallel/DeserializationFailedParallelExampleTest.java
new file mode 100644
index 000000000..13b1ac876
--- /dev/null
+++ b/examples/src/test/java/software/amazon/lambda/durable/examples/operation/parallel/DeserializationFailedParallelExampleTest.java
@@ -0,0 +1,29 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+package software.amazon.lambda.durable.examples.operation.parallel;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.util.List;
+import org.junit.jupiter.api.Test;
+import software.amazon.lambda.durable.model.ExecutionStatus;
+import software.amazon.lambda.durable.testing.LocalDurableTestRunner;
+
+class DeserializationFailedParallelExampleTest {
+
+ @Test
+ void testDeserializationFailedParallelExample() {
+ var handler = new DeserializationFailedParallelExample();
+ var runner = LocalDurableTestRunner.create(DeserializationFailedParallelExample.Input.class, handler);
+
+ var input = new DeserializationFailedParallelExample.Input(List.of("apple", "banana", "cherry"));
+ var result = runner.runUntilComplete(input);
+
+ assertEquals(ExecutionStatus.SUCCEEDED, result.getStatus());
+
+ var output = result.getResult(String.class);
+ assertEquals(
+ "Parallel branch failed with error of type java.lang.RuntimeException. Message: Intentional failure for transform",
+ output);
+ }
+}
diff --git a/examples/src/test/java/software/amazon/lambda/durable/examples/operation/parallel/ParallelExampleTest.java b/examples/src/test/java/software/amazon/lambda/durable/examples/operation/parallel/ParallelExampleTest.java
new file mode 100644
index 000000000..02b132ba7
--- /dev/null
+++ b/examples/src/test/java/software/amazon/lambda/durable/examples/operation/parallel/ParallelExampleTest.java
@@ -0,0 +1,60 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+package software.amazon.lambda.durable.examples.operation.parallel;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.List;
+import org.junit.jupiter.api.Test;
+import software.amazon.lambda.durable.model.ExecutionStatus;
+import software.amazon.lambda.durable.testing.LocalDurableTestRunner;
+
+class ParallelExampleTest {
+
+ @Test
+ void testParallelExampleRunsSuccessfully() {
+ var handler = new ParallelExample();
+ var runner = LocalDurableTestRunner.create(ParallelExample.Input.class, handler);
+
+ var input = new ParallelExample.Input(List.of("apple", "banana", "cherry"));
+ var result = runner.runUntilComplete(input);
+
+ assertEquals(ExecutionStatus.SUCCEEDED, result.getStatus());
+
+ var output = result.getResult(ParallelExample.Output.class);
+ assertEquals(3, output.totalProcessed());
+ assertTrue(output.results().contains("APPLE"));
+ assertTrue(output.results().contains("BANANA"));
+ assertTrue(output.results().contains("CHERRY"));
+ }
+
+ @Test
+ void testParallelExampleWithSingleItem() {
+ var handler = new ParallelExample();
+ var runner = LocalDurableTestRunner.create(ParallelExample.Input.class, handler);
+
+ var input = new ParallelExample.Input(List.of("hello"));
+ var result = runner.runUntilComplete(input);
+
+ assertEquals(ExecutionStatus.SUCCEEDED, result.getStatus());
+
+ var output = result.getResult(ParallelExample.Output.class);
+ assertEquals(1, output.totalProcessed());
+ assertEquals(List.of("HELLO"), output.results());
+ }
+
+ @Test
+ void testParallelExampleWithEmptyInput() {
+ var handler = new ParallelExample();
+ var runner = LocalDurableTestRunner.create(ParallelExample.Input.class, handler);
+
+ var input = new ParallelExample.Input(List.of());
+ var result = runner.runUntilComplete(input);
+
+ assertEquals(ExecutionStatus.SUCCEEDED, result.getStatus());
+
+ var output = result.getResult(ParallelExample.Output.class);
+ assertEquals(0, output.totalProcessed());
+ assertTrue(output.results().isEmpty());
+ }
+}
diff --git a/examples/src/test/java/software/amazon/lambda/durable/examples/operation/parallel/ParallelFailureToleranceExampleTest.java b/examples/src/test/java/software/amazon/lambda/durable/examples/operation/parallel/ParallelFailureToleranceExampleTest.java
new file mode 100644
index 000000000..ee45f4222
--- /dev/null
+++ b/examples/src/test/java/software/amazon/lambda/durable/examples/operation/parallel/ParallelFailureToleranceExampleTest.java
@@ -0,0 +1,59 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+package software.amazon.lambda.durable.examples.operation.parallel;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.List;
+import org.junit.jupiter.api.Test;
+import software.amazon.lambda.durable.model.ExecutionStatus;
+import software.amazon.lambda.durable.testing.LocalDurableTestRunner;
+
+class ParallelFailureToleranceExampleTest {
+
+ @Test
+ void succeedsWhenFailuresAreWithinTolerance() {
+ var handler = new ParallelFailureToleranceExample();
+ var runner = LocalDurableTestRunner.create(ParallelFailureToleranceExample.Input.class, handler);
+
+ // 2 good services, 1 bad — toleratedFailureCount=1 so the parallel op still succeeds
+ var input = new ParallelFailureToleranceExample.Input(List.of("svc-a", "bad-svc-b", "svc-c"), 1, null);
+ var result = runner.runUntilComplete(input);
+
+ assertEquals(ExecutionStatus.SUCCEEDED, result.getStatus());
+
+ var output = result.getResult(ParallelFailureToleranceExample.Output.class);
+ assertEquals(2, output.succeeded());
+ assertEquals(1, output.failed());
+ }
+
+ @Test
+ void succeedsWhenAllBranchesSucceed() {
+ var handler = new ParallelFailureToleranceExample();
+ var runner = LocalDurableTestRunner.create(ParallelFailureToleranceExample.Input.class, handler);
+
+ var input = new ParallelFailureToleranceExample.Input(List.of("svc-a", "svc-b", "svc-c"), 2, null);
+ var result = runner.runUntilComplete(input);
+
+ assertEquals(ExecutionStatus.SUCCEEDED, result.getStatus());
+
+ var output = result.getResult(ParallelFailureToleranceExample.Output.class);
+ assertEquals(3, output.succeeded());
+ }
+
+ @Test
+ void failsWhenFailuresExceedTolerance() {
+ var handler = new ParallelFailureToleranceExample();
+ var runner = LocalDurableTestRunner.create(ParallelFailureToleranceExample.Input.class, handler);
+
+ // 2 bad services, toleratedFailureCount=1 — second failure exceeds tolerance
+ var input = new ParallelFailureToleranceExample.Input(List.of("svc-a", "bad-svc-b", "bad-svc-c"), 1, 2);
+ var result = runner.runUntilComplete(input);
+
+ assertEquals(ExecutionStatus.SUCCEEDED, result.getStatus());
+
+ var output = result.getResult(ParallelFailureToleranceExample.Output.class);
+ assertEquals(2, output.failed());
+ assertEquals(1, output.succeeded());
+ }
+}
diff --git a/examples/src/test/java/software/amazon/lambda/durable/examples/operation/parallel/ParallelWithWaitExampleTest.java b/examples/src/test/java/software/amazon/lambda/durable/examples/operation/parallel/ParallelWithWaitExampleTest.java
new file mode 100644
index 000000000..49523b9e6
--- /dev/null
+++ b/examples/src/test/java/software/amazon/lambda/durable/examples/operation/parallel/ParallelWithWaitExampleTest.java
@@ -0,0 +1,34 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+package software.amazon.lambda.durable.examples.operation.parallel;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.List;
+import org.junit.jupiter.api.Test;
+import software.amazon.lambda.durable.model.ExecutionStatus;
+import software.amazon.lambda.durable.testing.LocalDurableTestRunner;
+
+class ParallelWithWaitExampleTest {
+ @Test
+ void completesAfterManuallyAdvancingWaits() {
+ var handler = new ParallelWithWaitExample();
+ var runner = LocalDurableTestRunner.create(ParallelWithWaitExample.Input.class, handler);
+
+ var input = new ParallelWithWaitExample.Input("user-456", "world");
+
+ // First run suspends on wait branches
+ var first = runner.run(input);
+ assertEquals(ExecutionStatus.PENDING, first.getStatus());
+
+ // Advance waits and re-run to completion
+ runner.advanceTime();
+ var result = runner.runUntilComplete(input);
+
+ assertEquals(ExecutionStatus.SUCCEEDED, result.getStatus());
+
+ var output = result.getResult(ParallelWithWaitExample.Output.class);
+ assertEquals(List.of("email:world", "sms:world", "push:world"), output.deliveries());
+ assertEquals(3, output.success());
+ }
+}
diff --git a/examples/src/test/java/software/amazon/lambda/durable/examples/operation/step/DeserializationFailureExampleTest.java b/examples/src/test/java/software/amazon/lambda/durable/examples/operation/step/DeserializationFailureExampleTest.java
new file mode 100644
index 000000000..1e09296ce
--- /dev/null
+++ b/examples/src/test/java/software/amazon/lambda/durable/examples/operation/step/DeserializationFailureExampleTest.java
@@ -0,0 +1,31 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+package software.amazon.lambda.durable.examples.operation.step;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.Test;
+import software.amazon.lambda.durable.model.ExecutionStatus;
+import software.amazon.lambda.durable.testing.LocalDurableTestRunner;
+
+class DeserializationFailureExampleTest {
+
+ @Test
+ void testDeserializationExample() {
+ var handler = new DeserializationFailureExample();
+
+ // Create test runner from handler (automatically extracts config)
+ var runner = LocalDurableTestRunner.create(String.class, handler);
+
+ // Run with input
+ var result = runner.runUntilComplete("test-input");
+
+ // Verify result
+ assertEquals(ExecutionStatus.SUCCEEDED, result.getStatus());
+
+ // assert StepFailedException is thrown when SerDes fails to deserialize the exception
+ assertEquals(
+ "StepFailedException:Step failed with error of type java.lang.RuntimeException. Message: this is a test",
+ result.getResult(String.class));
+ }
+}
diff --git a/examples/src/test/java/software/amazon/lambda/durable/examples/operation/step/ManyAsyncStepsExampleTest.java b/examples/src/test/java/software/amazon/lambda/durable/examples/operation/step/ManyAsyncStepsExampleTest.java
new file mode 100644
index 000000000..203f885ac
--- /dev/null
+++ b/examples/src/test/java/software/amazon/lambda/durable/examples/operation/step/ManyAsyncStepsExampleTest.java
@@ -0,0 +1,60 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+package software.amazon.lambda.durable.examples.operation.step;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import org.junit.jupiter.api.Test;
+import software.amazon.lambda.durable.examples.types.ManyAsyncStepsInput;
+import software.amazon.lambda.durable.examples.types.ManyAsyncStepsOutput;
+import software.amazon.lambda.durable.model.ExecutionStatus;
+import software.amazon.lambda.durable.testing.LocalDurableTestRunner;
+
+class ManyAsyncStepsExampleTest {
+
+ @Test
+ void testManyAsyncSteps() {
+ var handler = new ManyAsyncStepsExample();
+ var runner = LocalDurableTestRunner.create(ManyAsyncStepsInput.class, handler);
+
+ var input = new ManyAsyncStepsInput(2, 500);
+ var result = runner.runUntilComplete(input);
+
+ assertEquals(ExecutionStatus.SUCCEEDED, result.getStatus());
+
+ var output = result.getResult(ManyAsyncStepsOutput.class);
+ assertNotNull(output);
+
+ // Sum of 0..499 * 2 = 499 * 500 / 2 * 2 = 249500
+ assertEquals(249500, result.getResult(ManyAsyncStepsOutput.class).result());
+ }
+
+ @Test
+ void testManyAsyncStepsWithDefaultMultiplier() {
+ var handler = new ManyAsyncStepsExample();
+ var runner = LocalDurableTestRunner.create(ManyAsyncStepsInput.class, handler);
+
+ var input = new ManyAsyncStepsInput(1, 500);
+ var result = runner.runUntilComplete(input);
+
+ assertEquals(ExecutionStatus.SUCCEEDED, result.getStatus());
+
+ // Sum of 0..499 = 499 * 500 / 2 = 124750
+ assertEquals(124750, result.getResult(ManyAsyncStepsOutput.class).result());
+ }
+
+ @Test
+ void testOperationsAreTracked() {
+ var handler = new ManyAsyncStepsExample();
+ var runner = LocalDurableTestRunner.create(ManyAsyncStepsInput.class, handler);
+
+ var result = runner.runUntilComplete(new ManyAsyncStepsInput(1, 500));
+
+ assertEquals(ExecutionStatus.SUCCEEDED, result.getStatus());
+
+ // Verify some operations are tracked
+ assertNotNull(result.getOperation("compute-0"));
+ assertNotNull(result.getOperation("compute-499"));
+ assertNotNull(result.getOperation("compute-250"));
+ }
+}
diff --git a/examples/src/test/java/software/amazon/lambda/durable/examples/operation/step/RetryExampleTest.java b/examples/src/test/java/software/amazon/lambda/durable/examples/operation/step/RetryExampleTest.java
new file mode 100644
index 000000000..58fba3f84
--- /dev/null
+++ b/examples/src/test/java/software/amazon/lambda/durable/examples/operation/step/RetryExampleTest.java
@@ -0,0 +1,67 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+package software.amazon.lambda.durable.examples.operation.step;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import org.junit.jupiter.api.Test;
+import software.amazon.lambda.durable.testing.LocalDurableTestRunner;
+
+class RetryExampleTest {
+
+ @Test
+ void testRetryExampleWithTimeBasedFailure() {
+ var handler = new RetryExample();
+
+ // Test the retry example with time-based failure simulation
+ var runner = LocalDurableTestRunner.create(Object.class, handler);
+
+ var result = runner.run("test-input");
+
+ // The test will likely result in PENDING due to the time-based failure
+ // This demonstrates the retry mechanism in action
+ System.out.println("Test result status: " + result.getStatus());
+
+ // In a real scenario with actual time delays, this would eventually succeed
+ // The LocalDurableTestRunner simulates the retry behavior
+ assertNotNull(result);
+ }
+
+ @Test
+ void testRetryExampleDemonstration() {
+ // This test demonstrates the retry behavior without strict assertions
+ // It's useful for observing the retry mechanism in action
+ var handler = new RetryExample();
+
+ // Test the retry example with time-based failure simulation
+ var runner = LocalDurableTestRunner.create(Object.class, handler);
+
+ var result = runner.run("demo-input");
+
+ System.out.println("Demo execution status: " + result.getStatus());
+
+ // This test always passes - it's just for demonstration
+ assertNotNull(result);
+ assertTrue(result.getStatus().toString().matches("PENDING|FAILED|SUCCEEDED"));
+ }
+
+ @Test
+ void testRetryExampleShowsRetryBehavior() {
+ // Test that shows the different retry behaviors
+ var handler = new RetryExample();
+
+ // Test the retry example with time-based failure simulation
+ var runner = LocalDurableTestRunner.create(Object.class, handler);
+
+ var result = runner.run("retry-behavior-test");
+
+ System.out.println("Retry behavior test status: " + result.getStatus());
+
+ // The example demonstrates:
+ // 1. No-retry step that fails immediately
+ // 2. Retry step that uses default exponential backoff
+ // 3. Time-based failure that would eventually succeed with retries
+
+ assertNotNull(result);
+ }
+}
diff --git a/examples/src/test/java/software/amazon/lambda/durable/examples/operation/step/SimpleStepExampleTest.java b/examples/src/test/java/software/amazon/lambda/durable/examples/operation/step/SimpleStepExampleTest.java
new file mode 100644
index 000000000..380f4e834
--- /dev/null
+++ b/examples/src/test/java/software/amazon/lambda/durable/examples/operation/step/SimpleStepExampleTest.java
@@ -0,0 +1,77 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+package software.amazon.lambda.durable.examples.operation.step;
+
+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;
+
+class SimpleStepExampleTest {
+
+ @Test
+ void testSimpleStepExample() {
+ // Create handler
+ var handler = new SimpleStepExample();
+
+ // Create test runner
+ var runner = LocalDurableTestRunner.create(GreetingRequest.class, handler);
+
+ // Run with input
+ var input = new GreetingRequest("Alice");
+ var result = runner.run(input);
+
+ // Verify result
+ assertEquals(ExecutionStatus.SUCCEEDED, result.getStatus());
+ assertEquals("HELLO, ALICE!", result.getResult(String.class));
+ }
+
+ @Test
+ void testWithLargePayload() {
+ // Create handler
+ var handler = new SimpleStepExample();
+
+ // Create test runner
+ var runner = LocalDurableTestRunner.create(GreetingRequest.class, handler);
+ // 6MB large input
+ var largeInput = "A".repeat(1024).repeat(1024).repeat(6);
+
+ // Run with input
+ var input = new GreetingRequest(largeInput);
+ var result = runner.run(input);
+
+ // Verify result
+ assertEquals(ExecutionStatus.SUCCEEDED, result.getStatus());
+ assertEquals("HELLO, " + largeInput + "!", result.getResult(String.class));
+ }
+
+ @Test
+ void testWithDefaultName() {
+ var handler = new SimpleStepExample();
+ var runner = LocalDurableTestRunner.create(GreetingRequest.class, handler);
+
+ var input = new GreetingRequest();
+ var result = runner.run(input);
+
+ assertEquals(ExecutionStatus.SUCCEEDED, result.getStatus());
+ assertEquals("HELLO, WORLD!", result.getResult(String.class));
+ }
+
+ @Test
+ void testReplay() {
+ var handler = new SimpleStepExample();
+ var runner = LocalDurableTestRunner.create(GreetingRequest.class, handler);
+
+ // First execution
+ var input = new GreetingRequest("Bob");
+ var result1 = runner.run(input);
+ assertEquals("HELLO, BOB!", result1.getResult(String.class));
+
+ // Second execution (replay) - should use cached results
+ var result2 = runner.run(input);
+ assertEquals("HELLO, BOB!", result2.getResult(String.class));
+ assertEquals(result1.getResult(String.class), result2.getResult(String.class));
+ }
+}
diff --git a/examples/src/test/java/software/amazon/lambda/durable/examples/operation/vt/ManyAsyncStepsVirtualThreadPoolExampleTest.java b/examples/src/test/java/software/amazon/lambda/durable/examples/operation/vt/ManyAsyncStepsVirtualThreadPoolExampleTest.java
new file mode 100644
index 000000000..2d66744e5
--- /dev/null
+++ b/examples/src/test/java/software/amazon/lambda/durable/examples/operation/vt/ManyAsyncStepsVirtualThreadPoolExampleTest.java
@@ -0,0 +1,64 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+package software.amazon.lambda.durable.examples.operation.vt;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.condition.EnabledForJreRange;
+import org.junit.jupiter.api.condition.JRE;
+import software.amazon.lambda.durable.examples.types.ManyAsyncStepsInput;
+import software.amazon.lambda.durable.examples.types.ManyAsyncStepsOutput;
+import software.amazon.lambda.durable.model.ExecutionStatus;
+import software.amazon.lambda.durable.testing.LocalDurableTestRunner;
+
+@EnabledForJreRange(min = JRE.JAVA_21)
+class ManyAsyncStepsVirtualThreadPoolExampleTest {
+
+ @Test
+ void testManyAsyncSteps() {
+ var handler = new ManyAsyncStepsVirtualThreadPoolExample();
+ var runner = LocalDurableTestRunner.create(ManyAsyncStepsInput.class, handler);
+
+ var input = new ManyAsyncStepsInput(2, 500);
+ var result = runner.runUntilComplete(input);
+
+ assertEquals(ExecutionStatus.SUCCEEDED, result.getStatus());
+
+ var output = result.getResult(ManyAsyncStepsOutput.class);
+ assertNotNull(output);
+
+ // Sum of 0..499 * 2 = 499 * 500 / 2 * 2 = 249500
+ assertEquals(249500, result.getResult(ManyAsyncStepsOutput.class).result());
+ }
+
+ @Test
+ void testManyAsyncStepsWithDefaultMultiplier() {
+ var handler = new ManyAsyncStepsVirtualThreadPoolExample();
+ var runner = LocalDurableTestRunner.create(ManyAsyncStepsInput.class, handler);
+
+ var input = new ManyAsyncStepsInput(1, 500);
+ var result = runner.runUntilComplete(input);
+
+ assertEquals(ExecutionStatus.SUCCEEDED, result.getStatus());
+
+ // Sum of 0..499 = 499 * 500 / 2 = 124750
+ assertEquals(124750, result.getResult(ManyAsyncStepsOutput.class).result());
+ }
+
+ @Test
+ void testOperationsAreTracked() {
+ var handler = new ManyAsyncStepsVirtualThreadPoolExample();
+ var runner = LocalDurableTestRunner.create(ManyAsyncStepsInput.class, handler);
+
+ var result = runner.runUntilComplete(new ManyAsyncStepsInput(1, 500));
+
+ assertEquals(ExecutionStatus.SUCCEEDED, result.getStatus());
+
+ // Verify some operations are tracked
+ assertNotNull(result.getOperation("compute-0"));
+ assertNotNull(result.getOperation("compute-499"));
+ assertNotNull(result.getOperation("compute-250"));
+ }
+}
diff --git a/examples/src/test/java/software/amazon/lambda/durable/examples/operation/wait/ConcurrentWaitForConditionExampleTest.java b/examples/src/test/java/software/amazon/lambda/durable/examples/operation/wait/ConcurrentWaitForConditionExampleTest.java
new file mode 100644
index 000000000..8c140a501
--- /dev/null
+++ b/examples/src/test/java/software/amazon/lambda/durable/examples/operation/wait/ConcurrentWaitForConditionExampleTest.java
@@ -0,0 +1,29 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+package software.amazon.lambda.durable.examples.operation.wait;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.Test;
+import software.amazon.lambda.durable.model.ExecutionStatus;
+import software.amazon.lambda.durable.testing.LocalDurableTestRunner;
+
+class ConcurrentWaitForConditionExampleTest {
+
+ @Test
+ void testConcurrentWaitForConditionExample() {
+ var handler = new ConcurrentWaitForConditionExample();
+ var runner = LocalDurableTestRunner.create(ConcurrentWaitForConditionExample.Input.class, handler);
+
+ var result = runner.runUntilComplete(new ConcurrentWaitForConditionExample.Input(3, 100, 50));
+
+ assertEquals(ExecutionStatus.SUCCEEDED, result.getStatus());
+
+ var allOperationsOutput = result.getResult(String.class);
+ var operationResults = allOperationsOutput.split(" \\| ");
+ assertEquals(100, operationResults.length);
+ for (var operationResult : operationResults) {
+ assertEquals("3", operationResult);
+ }
+ }
+}
diff --git a/examples/src/test/java/software/amazon/lambda/durable/examples/operation/wait/WaitAsyncExampleTest.java b/examples/src/test/java/software/amazon/lambda/durable/examples/operation/wait/WaitAsyncExampleTest.java
new file mode 100644
index 000000000..f679c6a37
--- /dev/null
+++ b/examples/src/test/java/software/amazon/lambda/durable/examples/operation/wait/WaitAsyncExampleTest.java
@@ -0,0 +1,41 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+package software.amazon.lambda.durable.examples.operation.wait;
+
+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;
+
+class WaitAsyncExampleTest {
+
+ @Test
+ void testWaitAsyncExampleCompletesSuccessfully() {
+ var handler = new WaitAsyncExample();
+ var runner = LocalDurableTestRunner.create(GreetingRequest.class, handler);
+
+ var result = runner.runUntilComplete(new GreetingRequest("Alice"));
+
+ assertEquals(ExecutionStatus.SUCCEEDED, result.getStatus());
+ assertEquals("Processed: Alice", result.getResult(String.class));
+ }
+
+ @Test
+ void testWaitAsyncExampleSuspendsOnFirstRun() {
+ var handler = new WaitAsyncExample();
+ var runner = LocalDurableTestRunner.create(GreetingRequest.class, handler);
+
+ // First run suspends because the wait hasn't elapsed yet
+ var result = runner.run(new GreetingRequest("Bob"));
+ assertEquals(ExecutionStatus.PENDING, result.getStatus());
+
+ // Advance time so the wait completes, then re-run to finish
+ runner.advanceTime();
+
+ var result2 = runner.runUntilComplete(new GreetingRequest("Bob"));
+ assertEquals(ExecutionStatus.SUCCEEDED, result2.getStatus());
+ assertEquals("Processed: Bob", result2.getResult(String.class));
+ }
+}
diff --git a/examples/src/test/java/software/amazon/lambda/durable/examples/operation/wait/WaitExampleTest.java b/examples/src/test/java/software/amazon/lambda/durable/examples/operation/wait/WaitExampleTest.java
new file mode 100644
index 000000000..d1ac0ea5a
--- /dev/null
+++ b/examples/src/test/java/software/amazon/lambda/durable/examples/operation/wait/WaitExampleTest.java
@@ -0,0 +1,30 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+package software.amazon.lambda.durable.examples.operation.wait;
+
+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;
+
+class WaitExampleTest {
+
+ @Test
+ void testWaitExampleStartsAndWaits() {
+ var handler = new WaitExample();
+ var runner = LocalDurableTestRunner.create(GreetingRequest.class, handler);
+
+ var input = new GreetingRequest("Bob");
+
+ // First run - executes first step and hits first wait
+ var result = runner.run(input);
+
+ // Should be PENDING because of wait operation
+ assertEquals(ExecutionStatus.PENDING, result.getStatus());
+
+ // Note: In real Lambda, the function would be re-invoked after the wait period
+ // The LocalDurableTestRunner demonstrates the wait behavior but doesn't simulate time
+ }
+}
diff --git a/examples/src/test/java/software/amazon/lambda/durable/examples/operation/wait/WaitForConditionExampleTest.java b/examples/src/test/java/software/amazon/lambda/durable/examples/operation/wait/WaitForConditionExampleTest.java
new file mode 100644
index 000000000..30a531961
--- /dev/null
+++ b/examples/src/test/java/software/amazon/lambda/durable/examples/operation/wait/WaitForConditionExampleTest.java
@@ -0,0 +1,23 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+package software.amazon.lambda.durable.examples.operation.wait;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.Test;
+import software.amazon.lambda.durable.model.ExecutionStatus;
+import software.amazon.lambda.durable.testing.LocalDurableTestRunner;
+
+class WaitForConditionExampleTest {
+
+ @Test
+ void testWaitForConditionExample() {
+ var handler = new WaitForConditionExample();
+ var runner = LocalDurableTestRunner.create(Integer.class, handler);
+
+ var result = runner.runUntilComplete(3);
+
+ assertEquals(ExecutionStatus.SUCCEEDED, result.getStatus());
+ assertEquals(3, result.getResult(Integer.class));
+ }
+}
diff --git a/sdk-integration-tests/src/test/java/software/amazon/lambda/durable/ExtensionConcurrencyIntegrationTest.java b/sdk-integration-tests/src/test/java/software/amazon/lambda/durable/ExtensionConcurrencyIntegrationTest.java
new file mode 100644
index 000000000..4730790bb
--- /dev/null
+++ b/sdk-integration-tests/src/test/java/software/amazon/lambda/durable/ExtensionConcurrencyIntegrationTest.java
@@ -0,0 +1,30 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+package software.amazon.lambda.durable;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.Test;
+import software.amazon.lambda.durable.model.ExecutionStatus;
+import software.amazon.lambda.durable.testing.LocalDurableTestRunner;
+
+class ExtensionConcurrencyIntegrationTest {
+ @Test
+ void anyOfSuspendsWhileCallbacksArePending() {
+ var runner = LocalDurableTestRunner.create(String.class, (input, context) -> {
+ var first = context.createCallback("first", String.class);
+ var second = context.createCallback("second", String.class);
+ return (String) DurableFuture.anyOf(first, second);
+ });
+
+ var pending = runner.run("input");
+
+ assertEquals(ExecutionStatus.PENDING, pending.getStatus());
+
+ runner.completeCallback(runner.getCallbackId("second"), "\"second-result\"");
+ var completed = runner.run("input");
+
+ assertEquals(ExecutionStatus.SUCCEEDED, completed.getStatus());
+ assertEquals("second-result", completed.getResult(String.class));
+ }
+}
diff --git a/sdk-integration-tests/src/test/java/software/amazon/lambda/durable/ExtensionOperationIntegrationTest.java b/sdk-integration-tests/src/test/java/software/amazon/lambda/durable/ExtensionOperationIntegrationTest.java
new file mode 100644
index 000000000..26e8c5584
--- /dev/null
+++ b/sdk-integration-tests/src/test/java/software/amazon/lambda/durable/ExtensionOperationIntegrationTest.java
@@ -0,0 +1,273 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+package software.amazon.lambda.durable;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotSame;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static software.amazon.lambda.durable.extension.PairOperations.customOperationsAsync;
+import static software.amazon.lambda.durable.extension.PairOperations.pairAsync;
+import static software.amazon.lambda.durable.operation.DurableStepOperation.step;
+
+import java.nio.charset.StandardCharsets;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.time.Duration;
+import java.util.HexFormat;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+import org.junit.jupiter.api.Test;
+import software.amazon.awssdk.services.lambda.model.OperationType;
+import software.amazon.lambda.durable.extension.ExtensionContext;
+import software.amazon.lambda.durable.extension.ExtensionContextConfig;
+import software.amazon.lambda.durable.extension.ExtensionContextReplayContext;
+import software.amazon.lambda.durable.extension.ExtensionContextResult;
+import software.amazon.lambda.durable.extension.ExtensionStepConfig;
+import software.amazon.lambda.durable.extension.ExtensionStepResult;
+import software.amazon.lambda.durable.model.ExecutionStatus;
+import software.amazon.lambda.durable.model.OperationSubType;
+import software.amazon.lambda.durable.testing.LocalDurableTestRunner;
+
+class ExtensionOperationIntegrationTest {
+ @Test
+ void reservedOperationsReplayWhenLaunchOrderChanges() {
+ var extensionExecutions = new AtomicInteger();
+ var runner =
+ LocalDurableTestRunner.create(String.class, (input, context) -> pairAsync("pair", extensionExecutions)
+ .get());
+
+ var result = runner.runUntilComplete("input");
+
+ assertEquals(ExecutionStatus.SUCCEEDED, result.getStatus());
+ assertEquals("LR", result.getResult(String.class));
+ assertTrue(extensionExecutions.get() >= 2);
+
+ assertEquals(hash("1"), result.getOperation("pair-left").getId());
+ assertEquals(hash("2"), result.getOperation("pair-right").getId());
+ assertEquals(hash("3"), result.getOperation("pair-pause").getId());
+ }
+
+ @Test
+ void customExtensionFixtureSupportsLocalIdsAndSubtypesAcrossReplay() {
+ var extensionExecutions = new AtomicInteger();
+ var runner = LocalDurableTestRunner.create(
+ String.class, (input, context) -> customOperationsAsync("custom", extensionExecutions)
+ .get());
+
+ var result = runner.runUntilComplete("input");
+
+ assertEquals(ExecutionStatus.SUCCEEDED, result.getStatus());
+ assertEquals("step:context", result.getResult(String.class));
+ assertTrue(extensionExecutions.get() >= 2);
+ assertEquals(hash("custom-step-id"), result.getOperation("custom-step").getId());
+ assertEquals(OperationType.STEP, result.getOperation("custom-step").getType());
+ assertEquals("AcmeStep", result.getOperation("custom-step").getSubtype());
+ assertEquals(hash("custom-wait-id"), result.getOperation("custom-wait").getId());
+ assertEquals(OperationType.WAIT, result.getOperation("custom-wait").getType());
+ assertEquals("AcmeWait", result.getOperation("custom-wait").getSubtype());
+ assertEquals(
+ hash("custom-context-id"), result.getOperation("custom-context").getId());
+ assertEquals(
+ OperationType.CONTEXT, result.getOperation("custom-context").getType());
+ assertEquals("AcmeContext", result.getOperation("custom-context").getSubtype());
+ }
+
+ @Test
+ void staticOperationsUseCurrentContextAndRejectStepThreads() {
+ var runner = LocalDurableTestRunner.create(String.class, (input, context) -> {
+ assertSame(context, DurableContext.getCurrentContext());
+ assertSame(context, ExtensionContext.getCurrentContext());
+ return step("current-context", String.class, () -> {
+ var stepContext = StepContext.getCurrentContext();
+ assertSame(stepContext, StepContext.getCurrentContext());
+ return assertThrows(IllegalStateException.class, DurableContext::getCurrentContext)
+ .getMessage();
+ });
+ });
+
+ var result = runner.runUntilComplete("input");
+
+ assertEquals(ExecutionStatus.SUCCEEDED, result.getStatus());
+ assertTrue(result.getResult(String.class).contains("step thread"));
+ assertNull(DurableContext.getCurrentContext());
+ }
+
+ @Test
+ void extensionCanExplicitlyCreateChildContext() {
+ var runner = LocalDurableTestRunner.create(String.class, (input, context) -> {
+ var outer = ExtensionContext.getCurrentContext();
+ return outer.reserve("child")
+ .runInChildContextAsync(
+ OperationSubType.RUN_IN_CHILD_CONTEXT.getValue(),
+ TypeToken.get(String.class),
+ () -> {
+ var child = ExtensionContext.getCurrentContext();
+ assertNotSame(outer, child);
+ var nested = child.reserve("value", "node")
+ .stepAsync(
+ OperationSubType.STEP.getValue(),
+ TypeToken.get(String.class),
+ state -> ExtensionStepResult.succeed("nested"),
+ ExtensionStepConfig.
+ *
+ *
+ *
+ *
+ */
+public class ManyAsyncChildContextExample extends DurableHandler
+ *
+ *
+ *
+ *
+ */
+public class CustomConfigExample extends DurableHandler
+ *
+ */
+public class CustomPollingExample extends DurableHandler
+ *
+ *
+ *
+ *
+ *
+ *
+ * durable.invocation
+ * ├── durable.step:create-greeting [attempt 1]
+ * ├── durable.step:create-greeting (operation, backfilled)
+ * ├── durable.step:transform [attempt 1]
+ * └── durable.step:transform (operation, backfilled)
+ *
+ */
+public class OtelExample extends DurableHandler
+ * [PLUGIN] onInvocationStart: requestId=..., durableExecutionArn=..., firstInvocation=true
+ * [PLUGIN] onOperationStart: name=create-greeting, type=STEP
+ * [PLUGIN] onUserFunctionStart: name=create-greeting, attempt=1
+ * [PLUGIN] onUserFunctionEnd: name=create-greeting, succeeded=true
+ * [PLUGIN] onOperationEnd: name=create-greeting
+ * [PLUGIN] onOperationStart: name=transform, type=STEP
+ * [PLUGIN] onUserFunctionStart: name=transform, attempt=1
+ * [PLUGIN] onUserFunctionEnd: name=transform, succeeded=true
+ * [PLUGIN] onOperationEnd: name=transform
+ * [PLUGIN] onInvocationEnd: status=SUCCEEDED
+ *
+ */
+public class PluginExample extends DurableHandler
+ *
+ */
+public class ComplexFlatMapExample extends DurableHandler
+ *
+ */
+public class ComplexMapExample extends DurableHandler
+ *
+ */
+public class DeserializationFailedMapExample extends DurableHandler
+ *
+ */
+public class SimpleMapExample extends DurableHandler
+ *
+ *
+ *
+ * invocation
+ * ├── create-greeting
+ * │ └── create-greeting attempt 1
+ * └── transform
+ * └── transform attempt 1
+ *
+ */
+@ExampleTemplate(tracing = true, javaAgent = true)
+public class OtelXRayStepExample extends DurableHandler
+ *
+ *
+ *
+ *
+ *
+ *
+ * Trace (single trace ID across both invocations)
+ * ├── invocation (invocation 1)
+ * │ ├── before-wait
+ * │ │ └── before-wait attempt 1
+ * │ └── pause (ended as PENDING)
+ * └── invocation (invocation 2)
+ * ├── pause (completed)
+ * └── after-wait
+ * └── after-wait attempt 1
+ *
+ */
+@ExampleTemplate(tracing = true, javaAgent = true)
+public class OtelXRayWaitExample extends DurableHandler
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ */
+public class ManyAsyncStepsExample extends DurableHandler
+ *
+ */
+public class RetryExample extends DurableHandler
+ *
+ */
+public class RetryInProcessExample extends DurableHandler
+ *
+ */
+public class SimpleStepExample extends DurableHandler
+ *
+ */
+@ExampleTemplate(condition = "IsJava21OrLater")
+public class ManyAsyncStepsVirtualThreadPoolExample extends DurableHandler
+ *
+ */
+public class ConcurrentWaitForConditionExample extends DurableHandler
+ *
+ */
+public class WaitAsyncExample extends DurableHandler
+ *
+ */
+public class WaitAtLeastExample extends DurableHandler
+ *
+ */
+public class WaitAtLeastInProcessExample extends DurableHandler
+ *
+ */
+public class WaitExample extends DurableHandler
+ *
+ */
+public class WaitForConditionExample extends DurableHandler