Light, fluffy, and always free - The AWS Local Emulator alternative
fix(stepfunctions): fail a .sync Task on its child with States.TaskFailed and the child's description (#4675)
mitsukado-shinagawa7ff6a7cfa7d4
diff --git a/docs/services/step-functions.md b/docs/services/step-functions.mdindex 186ca06eb4..cccfd7e92f 100644--- a/docs/services/step-functions.md+++ b/docs/services/step-functions.md@@ -432,6 +432,17 @@ integrations, and only the casing of the result tells them apart.SDK call itself succeeded, so the task result carries `Status`, `Error` and `Cause` and the parentdecides what to do next.+The two `.sync` modes fail the calling task with `States.TaskFailed` however the child ended+(`FAILED`, `TIMED_OUT` or `ABORTED`) and whatever its own error was, `States.Timeout` included, so+a `Catch` on the child's own error name never takes it. The cause is the child's `DescribeExecution`+response as JSON, PascalCase with its keys in alphabetical order: `Cause` and `Error` when the+child has them, then `ExecutionArn`, `Input`, `InputDetails`, `Name`, `RedriveCount`,+`RedriveStatus`, `StartDate`, `StateMachineArn`, `Status` and `StopDate`, with dates in epoch+milliseconds and no `Output`. A child started through an alias also carries `StateMachineAliasArn`+and `StateMachineVersionArn`, and one started through a version carries `StateMachineVersionArn`,+each in its alphabetical place. A parent that needs the child's error reads it from there, for+example with `States.StringToJson($.Cause)` after a `Catch`.+A `Name` a Standard child already used fails the calling task with the child's collision error, namedfor the integration that raised it: `StepFunctions.ExecutionAlreadyExistsException` through`states:startExecution` in any of its modes, and `Sfn.ExecutionAlreadyExistsException` throughdiff --git a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutor.java b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutor.javaindex 7c4133eb95..124f4f23c9 100644--- a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutor.java+++ b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutor.java@@ -1736,7 +1736,13 @@ public class AslExecutor {}io.github.hectorvent.floci.services.stepfunctions.model.Execution current =sfnService.get().describeExecution(execArn);- String status = current.getStatus();+ String status;+ // The child's worker and StopExecution write its terminal fields under this monitor,+ // status last. Reading the status under it makes everything written before it visible,+ // so a terminal status is never seen without the error, cause and stop date behind it.+ synchronized (current) {+ status = current.getStatus();+ }if ("RUNNING".equals(status)) {continue;}@@ -1763,13 +1769,50 @@ public class AslExecutor {}return envelope;}- throw new FailStateException(- current.getError() != null ? current.getError() : "States.TaskFailed",- current.getCause() != null ? current.getCause()- : "Nested execution ended with status: " + status);+ // However the child ended, FAILED, TIMED_OUT or ABORTED, and whatever its own error, the+ // parent sees States.TaskFailed (measured), so a Catch on the child's error never fires.+ throw new FailStateException("States.TaskFailed", nestedExecutionFailureCause(current));}}+ /**+ * The cause of a {@code .sync} Task whose child ended other than SUCCEEDED, as measured on AWS+ * for {@code .sync} and {@code .sync:2} alike: the child's DescribeExecution response in+ * PascalCase with its keys in alphabetical order, {@code Cause} and {@code Error} only when the+ * child has them, {@code StateMachineAliasArn} and {@code StateMachineVersionArn} only when it+ * was started through an alias or a version (an alias carries both), dates in epoch+ * milliseconds, and no {@code Output}. Floci does not implement+ * redrive, so the two redrive fields carry what AWS reports for a child never redriven.+ */+ private String nestedExecutionFailureCause(Execution child) {+ ObjectNode cause = objectMapper.createObjectNode();+ if (child.getCause() != null) {+ cause.put("Cause", child.getCause());+ }+ if (child.getError() != null) {+ cause.put("Error", child.getError());+ }+ cause.put("ExecutionArn", child.getExecutionArn());+ cause.put("Input", child.getInput() != null ? child.getInput() : "{}");+ cause.putObject("InputDetails").put("Included", true);+ cause.put("Name", child.getName());+ cause.put("RedriveCount", 0);+ cause.put("RedriveStatus", "REDRIVABLE");+ cause.put("StartDate", Math.round(child.getStartDate() * 1000));+ if (child.getStateMachineAliasArn() != null) {+ cause.put("StateMachineAliasArn", child.getStateMachineAliasArn());+ }+ cause.put("StateMachineArn", child.getStateMachineArn());+ if (child.getStateMachineVersionArn() != null) {+ cause.put("StateMachineVersionArn", child.getStateMachineVersionArn());+ }+ cause.put("Status", child.getStatus());+ if (child.getStopDate() != null) {+ cause.put("StopDate", Math.round(child.getStopDate() * 1000));+ }+ return cause.toString();+ }+/*** Optimized ECS RunTask integration. Step Functions passes PascalCase parameters* ({@code Cluster}, {@code TaskDefinition}, {@code Overrides.ContainerOverrides}, …)diff --git a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorNestedSyncFailureTest.java b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorNestedSyncFailureTest.javanew file mode 100644index 0000000000..3b5b3b3e40--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorNestedSyncFailureTest.java@@ -0,0 +1,293 @@+package io.github.hectorvent.floci.services.stepfunctions;++import com.fasterxml.jackson.databind.ObjectMapper;+import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.services.cloudformation.CloudFormationQueryHandler;+import io.github.hectorvent.floci.services.dynamodb.DynamoDbFacade;+import io.github.hectorvent.floci.services.dynamodb.DynamoDbJsonHandler;+import io.github.hectorvent.floci.services.ec2.Ec2Service;+import io.github.hectorvent.floci.services.ecs.EcsJsonHandler;+import io.github.hectorvent.floci.services.ecs.EcsService;+import io.github.hectorvent.floci.services.eventbridge.EventBridgeHandler;+import io.github.hectorvent.floci.services.lambda.LambdaExecutorService;+import io.github.hectorvent.floci.services.lambda.LambdaFunctionStore;+import io.github.hectorvent.floci.services.s3.S3Service;+import io.github.hectorvent.floci.services.scheduler.SchedulerController;+import io.github.hectorvent.floci.services.scheduler.SchedulerService;+import io.github.hectorvent.floci.services.sns.SnsJsonHandler;+import io.github.hectorvent.floci.services.sqs.SqsJsonHandler;+import io.github.hectorvent.floci.services.stepfunctions.model.Execution;+import io.github.hectorvent.floci.services.stepfunctions.model.HistoryEvent;+import io.github.hectorvent.floci.services.stepfunctions.model.StateMachine;+import jakarta.enterprise.inject.Instance;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.Arguments;+import org.junit.jupiter.params.provider.MethodSource;++import java.time.Clock;+import java.util.ArrayList;+import java.util.List;+import java.util.concurrent.CountDownLatch;+import java.util.stream.Stream;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.mockito.ArgumentMatchers.any;+import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.when;++/**+ * A {@code states:startExecution.sync} or {@code .sync:2} Task whose child ends other than+ * SUCCEEDED fails with {@code States.TaskFailed}, whatever the child's own error, and carries the+ * child's DescribeExecution response as its cause. Measured on AWS (ap-northeast-1, 2026-09-29) for+ * six endings under both modes: FAILED with a custom error with and without a cause, FAILED with+ * {@code States.Timeout} from a Task's own TimeoutSeconds, FAILED with {@code States.TaskFailed},+ * TIMED_OUT, and ABORTED by a StopExecution carrying an error and a cause.+ */+class AslExecutorNestedSyncFailureTest {++ private static final String REGION = "us-east-2";+ private static final String ACCOUNT = "000000000000";+ private static final String CHILD_SM_ARN =+ "arn:aws:states:%s:%s:stateMachine:child".formatted(REGION, ACCOUNT);+ private static final String CHILD_ARN =+ "arn:aws:states:%s:%s:execution:child:run-1".formatted(REGION, ACCOUNT);+ private static final String PARENT_ARN =+ "arn:aws:states:%s:%s:execution:parent:parent-run".formatted(REGION, ACCOUNT);+ private static final String CHILD_TAIL = """+ "ExecutionArn":"%s","Input":"{\\"k\\":1}","InputDetails":{"Included":true},"Name":"run-1",\+ "RedriveCount":0,"RedriveStatus":"REDRIVABLE","StartDate":1790676767025,\+ "StateMachineArn":"%s",""".formatted(CHILD_ARN, CHILD_SM_ARN);++ private final ObjectMapper objectMapper = new ObjectMapper();+ private StepFunctionsService sfnService;+ private List<HistoryEvent> history;++ @BeforeEach+ void setUp() {+ sfnService = mock(StepFunctionsService.class);+ when(sfnService.startExecution(any(), any(), any(), any())).thenReturn(child("RUNNING", null, null));+ Execution parent = new Execution();+ parent.setExecutionArn(PARENT_ARN);+ parent.setStatus("RUNNING");+ when(sfnService.describeExecution(PARENT_ARN)).thenReturn(parent);+ }++ static Stream<Arguments> childEndings() {+ List<Arguments> endings = List.of(+ Arguments.of("FAILED", "Boom", "custom cause",+ "{\"Cause\":\"custom cause\",\"Error\":\"Boom\"," + CHILD_TAIL+ + "\"Status\":\"FAILED\",\"StopDate\":1790676767071}"),+ Arguments.of("FAILED", "Boom", null,+ "{\"Error\":\"Boom\"," + CHILD_TAIL + "\"Status\":\"FAILED\",\"StopDate\":1790676767071}"),+ Arguments.of("FAILED", "States.Timeout", null,+ "{\"Error\":\"States.Timeout\"," + CHILD_TAIL+ + "\"Status\":\"FAILED\",\"StopDate\":1790676767071}"),+ Arguments.of("FAILED", "States.TaskFailed", "child says TaskFailed",+ "{\"Cause\":\"child says TaskFailed\",\"Error\":\"States.TaskFailed\"," + CHILD_TAIL+ + "\"Status\":\"FAILED\",\"StopDate\":1790676767071}"),+ Arguments.of("TIMED_OUT", null, null,+ "{" + CHILD_TAIL + "\"Status\":\"TIMED_OUT\",\"StopDate\":1790676767071}"),+ Arguments.of("ABORTED", "ManualStop", "stopped by test",+ "{\"Cause\":\"stopped by test\",\"Error\":\"ManualStop\"," + CHILD_TAIL+ + "\"Status\":\"ABORTED\",\"StopDate\":1790676767071}"));+ return Stream.of(".sync", ".sync:2").flatMap(mode -> endings.stream().map(ending -> {+ Object[] values = ending.get();+ return Arguments.of(mode, values[0], values[1], values[2], values[3]);+ }));+ }++ @ParameterizedTest(name = "{0} child {1} {2}")+ @MethodSource("childEndings")+ void aChildThatDoesNotSucceedFailsTheTaskWithStatesTaskFailedAndItsDescription(+ String mode, String status, String error, String cause, String expectedCause) {+ when(sfnService.describeExecution(CHILD_ARN)).thenReturn(child(status, error, cause));++ Execution execution = run(mode, "");++ assertEquals("FAILED", execution.getStatus());+ assertEquals("States.TaskFailed", execution.getError());+ assertEquals(expectedCause, execution.getCause());+ HistoryEvent taskFailed = history.stream().filter(event -> "TaskFailed".equals(event.getType()))+ .findFirst().orElseThrow(() -> new AssertionError("no TaskFailed in " + history));+ assertEquals("States.TaskFailed", taskFailed.getDetails().get("error"));+ assertEquals(expectedCause, taskFailed.getDetails().get("cause"));+ }++ @Test+ void aChildStartedThroughAnAliasCarriesTheAliasAndVersionInTheirAlphabeticalPlaces() {+ Execution failed = child("FAILED", "Boom", null);+ failed.setStateMachineAliasArn(CHILD_SM_ARN + ":live");+ failed.setStateMachineVersionArn(CHILD_SM_ARN + ":1");+ when(sfnService.describeExecution(CHILD_ARN)).thenReturn(failed);++ Execution execution = run(".sync:2", "");++ // Measured on AWS: an alias carries both ARNs, between StartDate and Status.+ assertEquals("{\"Error\":\"Boom\"," + CHILD_TAIL.replace(+ "\"StateMachineArn\":", "\"StateMachineAliasArn\":\"" + CHILD_SM_ARN + ":live\",\"StateMachineArn\":")+ + "\"StateMachineVersionArn\":\"" + CHILD_SM_ARN + ":1\","+ + "\"Status\":\"FAILED\",\"StopDate\":1790676767071}",+ execution.getCause());+ }++ @Test+ void aChildStartedThroughAVersionCarriesTheVersionOnly() {+ Execution failed = child("FAILED", "Boom", null);+ failed.setStateMachineVersionArn(CHILD_SM_ARN + ":1");+ when(sfnService.describeExecution(CHILD_ARN)).thenReturn(failed);++ Execution execution = run(".sync", "");++ assertEquals("{\"Error\":\"Boom\"," + CHILD_TAIL+ + "\"StateMachineVersionArn\":\"" + CHILD_SM_ARN + ":1\","+ + "\"Status\":\"FAILED\",\"StopDate\":1790676767071}",+ execution.getCause());+ }++ @Test+ void aTerminalStatusIsReadTogetherWithTheFieldsWrittenBeforeItsMonitorIsReleased() throws Exception {+ // The child's worker writes its terminal fields under the execution's monitor. This writer+ // publishes the status first and holds the monitor for 200 ms before writing the rest, and+ // the parent's first read of the child lands inside that window, so a reader that skipped+ // the monitor would build the cause from a half-written child.+ Execution live = child("RUNNING", null, null);+ CountDownLatch statusWritten = new CountDownLatch(1);+ Thread writer = new Thread(() -> {+ synchronized (live) {+ live.setStatus("FAILED");+ statusWritten.countDown();+ try {+ Thread.sleep(200);+ } catch (InterruptedException e) {+ Thread.currentThread().interrupt();+ }+ live.setError("Boom");+ live.setCause("custom cause");+ live.setStopDate(1790676767.071);+ }+ });+ when(sfnService.describeExecution(CHILD_ARN)).thenAnswer(invocation -> {+ if (writer.getState() == Thread.State.NEW) {+ writer.start();+ statusWritten.await();+ }+ return live;+ });++ Execution execution = run(".sync", "");+ writer.join();++ assertEquals("{\"Cause\":\"custom cause\",\"Error\":\"Boom\"," + CHILD_TAIL+ + "\"Status\":\"FAILED\",\"StopDate\":1790676767071}", execution.getCause());+ }++ @Test+ void aCatchOnTheChildsOwnErrorDoesNotFireButOneOnStatesTaskFailedDoes() throws Exception {+ when(sfnService.describeExecution(CHILD_ARN)).thenReturn(child("FAILED", "Boom", "custom cause"));++ Execution execution = run(".sync:2", """+ "Catch": [+ {"ErrorEquals": ["Boom"], "Next": "CaughtByName"},+ {"ErrorEquals": ["States.TaskFailed"], "Next": "CaughtAsTaskFailed"}+ ],""");++ assertEquals("SUCCEEDED", execution.getStatus(), execution.getCause());+ assertEquals("CaughtAsTaskFailed", objectMapper.readTree(execution.getOutput()).path("caughtBy").asText());+ }++ @Test+ void aChildThatTimedOutIsNotCaughtUnderStatesTimeout() throws Exception {+ when(sfnService.describeExecution(CHILD_ARN)).thenReturn(child("FAILED", "States.Timeout", null));++ Execution execution = run(".sync", """+ "Catch": [+ {"ErrorEquals": ["States.Timeout"], "Next": "CaughtByName"},+ {"ErrorEquals": ["States.ALL"], "Next": "CaughtAsTaskFailed"}+ ],""");++ assertEquals("SUCCEEDED", execution.getStatus(), execution.getCause());+ assertEquals("CaughtAsTaskFailed", objectMapper.readTree(execution.getOutput()).path("caughtBy").asText());+ }++ private static Execution child(String status, String error, String cause) {+ Execution current = new Execution();+ current.setExecutionArn(CHILD_ARN);+ current.setStateMachineArn(CHILD_SM_ARN);+ current.setName("run-1");+ current.setInput("{\"k\":1}");+ current.setStatus(status);+ current.setError(error);+ current.setCause(cause);+ current.setStartDate(1790676767.025);+ if (!"RUNNING".equals(status)) {+ current.setStopDate(1790676767.071);+ }+ return current;+ }++ @SuppressWarnings("unchecked")+ private AslExecutor newExecutor() {+ Instance<StepFunctionsService> instance = mock(Instance.class);+ when(instance.get()).thenReturn(sfnService);+ return new AslExecutor(+ mock(LambdaExecutorService.class),+ mock(LambdaFunctionStore.class),+ mock(DynamoDbFacade.class),+ mock(DynamoDbJsonHandler.class),+ mock(SqsJsonHandler.class), mock(SnsJsonHandler.class),+ mock(CloudFormationQueryHandler.class),+ mock(Ec2Service.class),+ mock(S3Service.class),+ mock(EcsService.class),+ mock(EcsJsonHandler.class),+ mock(EventBridgeHandler.class),+ mock(SchedulerService.class),+ mock(SchedulerController.class),+ objectMapper,+ new JsonataEvaluator(objectMapper),+ instance,+ mock(EmulatorConfig.class),+ null,+ null,+ Clock.systemUTC(),+ nanos -> { },+ null);+ }++ private Execution run(String mode, String catcher) {+ String definition = """+ {+ "StartAt": "Child",+ "States": {+ "Child": {+ "Type": "Task",+ "Resource": "arn:aws:states:::states:startExecution%s",+ %s+ "Parameters": { "StateMachineArn": "%s", "Input": {"k": 1} },+ "End": true+ },+ "CaughtByName": { "Type": "Pass", "Result": {"caughtBy": "CaughtByName"}, "End": true },+ "CaughtAsTaskFailed": { "Type": "Pass", "Result": {"caughtBy": "CaughtAsTaskFailed"}, "End": true }+ }+ }+ """.formatted(mode, catcher, CHILD_SM_ARN);++ StateMachine stateMachine = new StateMachine();+ stateMachine.setName("parent");+ stateMachine.setStateMachineArn("arn:aws:states:%s:%s:stateMachine:parent".formatted(REGION, ACCOUNT));+ stateMachine.setRoleArn("arn:aws:iam::%s:role/test-role".formatted(ACCOUNT));+ stateMachine.setDefinition(definition);++ Execution execution = new Execution();+ execution.setName("parent-run");+ execution.setExecutionArn(PARENT_ARN);+ execution.setStateMachineArn(stateMachine.getStateMachineArn());+ execution.setInput("{}");++ history = new ArrayList<>();+ newExecutor().executeSync(stateMachine, execution, history, (updated, events) -> { });+ return execution;+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsNestedSyncFailureIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsNestedSyncFailureIntegrationTest.javanew file mode 100644index 0000000000..69ffc51241--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsNestedSyncFailureIntegrationTest.java@@ -0,0 +1,172 @@+package io.github.hectorvent.floci.services.stepfunctions;++import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;+import io.quarkus.test.junit.QuarkusTest;+import io.restassured.response.Response;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.Test;++import java.util.ArrayList;+import java.util.Iterator;+import java.util.List;++import static io.restassured.RestAssured.given;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertFalse;+import static org.junit.jupiter.api.Assertions.assertTrue;+import static org.junit.jupiter.api.Assertions.fail;++/**+ * A {@code states:startExecution.sync} Task whose child does not succeed fails with+ * {@code States.TaskFailed} and the child's DescribeExecution response as its cause, whatever the+ * child's own error, the way AWS reports it (measured in ap-northeast-1 on 2026-09-29).+ */+@QuarkusTest+class StepFunctionsNestedSyncFailureIntegrationTest {++ private static final String SFN_CONTENT_TYPE = "application/x-amz-json-1.0";+ private static final String ROLE_ARN = "arn:aws:iam::000000000000:role/test-role";+ private static final ObjectMapper mapper = new ObjectMapper();++ @BeforeAll+ static void configureRestAssured() {+ RestAssuredJsonUtils.configureAwsContentTypes();+ }++ @Test+ void aFailedChildReachesTheParentAsStatesTaskFailedWithTheChildsDescription() throws Exception {+ String childArn = createStateMachine("nested-failure-child", """+ {"StartAt": "F", "States": {"F": {"Type": "Fail", "Error": "Boom", "Cause": "custom cause"}}}+ """);+ String parentArn = createStateMachine("nested-failure-parent", """+ {+ "StartAt": "RunChild",+ "States": {+ "RunChild": {+ "Type": "Task",+ "Resource": "arn:aws:states:::states:startExecution.sync:2",+ "Parameters": {"StateMachineArn": "%s", "Input": {"k": 1}},+ "End": true+ }+ }+ }+ """.formatted(childArn));++ Response failed = waitForTerminalExecution(startExecution(parentArn, "{}"));++ assertEquals("FAILED", failed.jsonPath().getString("status"), failed.body().asString());+ assertEquals("States.TaskFailed", failed.jsonPath().getString("error"));+ JsonNode cause = mapper.readTree(failed.jsonPath().getString("cause"));+ assertEquals(List.of("Cause", "Error", "ExecutionArn", "Input", "InputDetails", "Name", "RedriveCount",+ "RedriveStatus", "StartDate", "StateMachineArn", "Status", "StopDate"), fieldNames(cause));+ assertEquals("custom cause", cause.path("Cause").asText());+ assertEquals("Boom", cause.path("Error").asText());+ assertEquals("{\"k\":1}", cause.path("Input").asText());+ assertEquals(childArn, cause.path("StateMachineArn").asText());+ assertEquals("FAILED", cause.path("Status").asText());+ assertTrue(cause.path("StartDate").isIntegralNumber(), "epoch milliseconds: " + cause);+ Response child = describeExecution(cause.path("ExecutionArn").asText());+ assertEquals("Boom", child.jsonPath().getString("error"), child.body().asString());+ }++ @Test+ void aTimedOutChildIsCaughtUnderStatesTaskFailed() throws Exception {+ String childArn = createStateMachine("nested-timeout-child", """+ {"StartAt": "W", "TimeoutSeconds": 1, "States": {"W": {"Type": "Wait", "Seconds": 5, "End": true}}}+ """);+ String parentArn = createStateMachine("nested-timeout-parent", """+ {+ "StartAt": "RunChild",+ "States": {+ "RunChild": {+ "Type": "Task",+ "Resource": "arn:aws:states:::states:startExecution.sync",+ "Parameters": {"StateMachineArn": "%s"},+ "Catch": [{"ErrorEquals": ["States.TaskFailed"], "Next": "Handled"}],+ "End": true+ },+ "Handled": {"Type": "Pass", "End": true}+ }+ }+ """.formatted(childArn));++ Response done = waitForTerminalExecution(startExecution(parentArn, "{}"));++ assertEquals("SUCCEEDED", done.jsonPath().getString("status"), done.body().asString());+ JsonNode output = mapper.readTree(done.jsonPath().getString("output"));+ assertEquals("States.TaskFailed", output.path("Error").asText());+ JsonNode cause = mapper.readTree(output.path("Cause").asText());+ assertEquals("TIMED_OUT", cause.path("Status").asText());+ assertFalse(cause.has("Error"), "a TIMED_OUT child has no error: " + cause);+ }++ private static List<String> fieldNames(JsonNode node) {+ List<String> names = new ArrayList<>();+ Iterator<String> it = node.fieldNames();+ while (it.hasNext()) {+ names.add(it.next());+ }+ return names;+ }++ private static String createStateMachine(String name, String definition) {+ Response resp = given()+ .header("X-Amz-Target", "AWSStepFunctions.CreateStateMachine")+ .contentType(SFN_CONTENT_TYPE)+ .body("""+ {"name": "%s-%d", "definition": %s, "roleArn": "%s"}+ """.formatted(name, System.currentTimeMillis(), quote(definition), ROLE_ARN))+ .when()+ .post("/");+ resp.then().statusCode(200);+ return resp.jsonPath().getString("stateMachineArn");+ }++ private static String startExecution(String smArn, String input) {+ Response resp = given()+ .header("X-Amz-Target", "AWSStepFunctions.StartExecution")+ .contentType(SFN_CONTENT_TYPE)+ .body("""+ {"stateMachineArn": "%s", "input": %s}+ """.formatted(smArn, quote(input)))+ .when()+ .post("/");+ resp.then().statusCode(200);+ return resp.jsonPath().getString("executionArn");+ }++ private static Response describeExecution(String execArn) {+ return given()+ .header("X-Amz-Target", "AWSStepFunctions.DescribeExecution")+ .contentType(SFN_CONTENT_TYPE)+ .body("""+ {"executionArn": "%s"}+ """.formatted(execArn))+ .when()+ .post("/");+ }++ private static Response waitForTerminalExecution(String execArn) throws InterruptedException {+ for (int poll = 0; poll < 200; poll++) {+ Response resp = describeExecution(execArn);+ if (!"RUNNING".equals(resp.jsonPath().getString("status"))) {+ return resp;+ }+ Thread.sleep(100);+ }+ fail("Execution " + execArn + " was still RUNNING after 20 seconds");+ return null;+ }++ private static String quote(String raw) {+ return "\"" + raw+ .replace("\\", "\\\\")+ .replace("\"", "\\\"")+ .replace("\n", "\\n")+ .replace("\r", "\\r")+ .replace("\t", "\\t")+ + "\"";+ }+}