Skip to content

armgit / floci

Public Imported from GitHub
0

Light, fluffy, and always free - The AWS Local Emulator alternative

feat(stepfunctions): implement States.JsonMerge intrinsic (#1662)

Alex Bannab245632a2e6b
diff --git a/compatibility-tests/sdk-test-java/src/main/java/com/floci/test/TestFixtures.java b/compatibility-tests/sdk-test-java/src/main/java/com/floci/test/TestFixtures.java
index 6c9112e5bc..5540ebd97b 100644
--- a/compatibility-tests/sdk-test-java/src/main/java/com/floci/test/TestFixtures.java
+++ b/compatibility-tests/sdk-test-java/src/main/java/com/floci/test/TestFixtures.java
@@ -39,6 +39,9 @@ import software.amazon.awssdk.services.sts.StsClient;
import software.amazon.awssdk.services.kafka.KafkaClient;
import software.amazon.awssdk.services.mq.MqClient;
import software.amazon.awssdk.services.athena.AthenaClient;
+import software.amazon.awssdk.services.athena.model.GetQueryExecutionRequest;
+import software.amazon.awssdk.services.athena.model.QueryExecutionState;
+import software.amazon.awssdk.services.athena.model.QueryExecutionStatus;
import software.amazon.awssdk.services.glue.GlueClient;
import software.amazon.awssdk.services.firehose.FirehoseClient;
import software.amazon.awssdk.services.resourcegroupstaggingapi.ResourceGroupsTaggingApiClient;
@@ -401,6 +404,30 @@ public final class TestFixtures {
.build();
}
+ static QueryExecutionStatus awaitAthenaQueryTerminal(
+ AthenaClient athena, String queryExecutionId, Duration timeout) throws InterruptedException {
+ long deadline = System.nanoTime() + timeout.toNanos();
+ while (true) {
+ QueryExecutionStatus status = athena.getQueryExecution(
+ GetQueryExecutionRequest.builder()
+ .queryExecutionId(queryExecutionId)
+ .build())
+ .queryExecution()
+ .status();
+ QueryExecutionState state = status.state();
+ if (state != QueryExecutionState.QUEUED && state != QueryExecutionState.RUNNING) {
+ return status;
+ }
+
+ long remainingNanos = deadline - System.nanoTime();
+ if (remainingNanos <= 0) {
+ return status;
+ }
+ long sleepMillis = Math.min(500, Math.max(1, Duration.ofNanos(remainingNanos).toMillis()));
+ Thread.sleep(sleepMillis);
+ }
+ }
+
public static GlueClient glueClient() {
return GlueClient.builder()
.endpointOverride(ENDPOINT)
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/AthenaTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/AthenaTest.java
index 167cc0ce1f..52880affaf 100644
--- a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/AthenaTest.java
+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/AthenaTest.java
@@ -5,6 +5,7 @@ import software.amazon.awssdk.services.athena.AthenaClient;
import software.amazon.awssdk.services.athena.model.*;
import software.amazon.awssdk.services.glue.GlueClient;
+import java.time.Duration;
import java.time.Instant;
import java.util.UUID;
@@ -66,20 +67,12 @@ class AthenaTest {
@Test
@Order(3)
@DisplayName("Get query results returns result set")
- void getQueryResults() {
- // Poll until succeeded (mock mode completes immediately, real duck may take a moment)
- QueryExecutionState state = QueryExecutionState.RUNNING;
- int attempts = 0;
- while (state == QueryExecutionState.RUNNING && attempts++ < 20) {
- GetQueryExecutionResponse exec = athena.getQueryExecution(
- GetQueryExecutionRequest.builder().queryExecutionId(queryExecutionId).build());
- state = exec.queryExecution().status().state();
- if (state == QueryExecutionState.RUNNING) {
- try { Thread.sleep(500); } catch (InterruptedException ignored) {}
- }
- }
-
- assertThat(state).isEqualTo(QueryExecutionState.SUCCEEDED);
+ void getQueryResults() throws InterruptedException {
+ QueryExecutionStatus status = TestFixtures.awaitAthenaQueryTerminal(
+ athena, queryExecutionId, Duration.ofSeconds(60));
+ assertThat(status.state())
+ .as("Athena query did not succeed: %s", status.stateChangeReason())
+ .isEqualTo(QueryExecutionState.SUCCEEDED);
GetQueryResultsResponse results = athena.getQueryResults(
GetQueryResultsRequest.builder()
@@ -177,4 +170,3 @@ class AthenaTest {
glue.close();
}
}
-
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/DataLakeTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/DataLakeTest.java
index baa205512c..b53e754d8e 100644
--- a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/DataLakeTest.java
+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/DataLakeTest.java
@@ -11,6 +11,7 @@ import software.amazon.awssdk.services.glue.GlueClient;
import software.amazon.awssdk.services.glue.model.*;
import java.nio.charset.StandardCharsets;
+import java.time.Duration;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
@@ -92,23 +93,11 @@ class DataLakeTest {
String queryId = startResp.queryExecutionId();
- // Wait for query
- int attempts = 0;
- QueryExecutionStatus status = null;
- while (attempts < 30) {
- GetQueryExecutionResponse getResp = athena.getQueryExecution(GetQueryExecutionRequest.builder()
- .queryExecutionId(queryId)
- .build());
- status = getResp.queryExecution().status();
- if (status.state() == QueryExecutionState.SUCCEEDED) break;
- if (status.state() == QueryExecutionState.FAILED) {
- Assertions.fail("Query failed: " + status.stateChangeReason());
- }
- Thread.sleep(1000);
- attempts++;
- }
-
- assertThat(status.state()).isEqualTo(QueryExecutionState.SUCCEEDED);
+ QueryExecutionStatus status = TestFixtures.awaitAthenaQueryTerminal(
+ athena, queryId, Duration.ofSeconds(60));
+ assertThat(status.state())
+ .as("Athena query did not succeed: %s", status.stateChangeReason())
+ .isEqualTo(QueryExecutionState.SUCCEEDED);
GetQueryResultsResponse results = athena.getQueryResults(GetQueryResultsRequest.builder()
.queryExecutionId(queryId)
diff --git a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutor.java b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutor.java
index 23ae450e2d..d85d47b752 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
@@ -2052,6 +2052,39 @@ public class AslExecutor {
case "States.UUID" -> {
yield objectMapper.getNodeFactory().textNode(java.util.UUID.randomUUID().toString());
}
+ case "States.JsonMerge" -> {
+ List<String> parts = splitIntrinsicArgs(argsStr);
+ if (parts.size() != 3 || argsStr.stripTrailing().endsWith(",")) {
+ throw new FailStateException("States.IntrinsicFailure",
+ "States.JsonMerge requires exactly 3 arguments");
+ }
+ JsonNode a = resolveIntrinsicArg(parts.get(0).trim(), root, context);
+ JsonNode b = resolveIntrinsicArg(parts.get(1).trim(), root, context);
+ JsonNode deepArg = resolveIntrinsicArg(parts.get(2).trim(), root, context);
+ if (!deepArg.isBoolean()) {
+ // AWS rejects a non-boolean third argument rather than coercing it to false.
+ throw new FailStateException("States.IntrinsicFailure",
+ "States.JsonMerge third argument must be a boolean");
+ }
+ boolean deep = deepArg.asBoolean();
+ // Validate argument types before rejecting the deep-merge flag, matching AWS error
+ // ordering: two non-objects passed with true yield "requires two JSON objects", not
+ // "shallow merge only".
+ if (!a.isObject() || !b.isObject()) {
+ throw new FailStateException("States.IntrinsicFailure",
+ "States.JsonMerge requires two JSON objects");
+ }
+ if (deep) {
+ // AWS Step Functions only supports the shallow merge (third argument false).
+ throw new FailStateException("States.IntrinsicFailure",
+ "States.JsonMerge supports only shallow merge (third argument must be false)");
+ }
+ // Shallow merge: second object's top-level fields override the first's.
+ var merged = objectMapper.createObjectNode();
+ a.fields().forEachRemaining(e -> merged.set(e.getKey(), e.getValue()));
+ b.fields().forEachRemaining(e -> merged.set(e.getKey(), e.getValue()));
+ yield merged;
+ }
default -> throw new FailStateException("States.Runtime",
"Unsupported intrinsic function: " + fnName);
};
@@ -2085,6 +2118,12 @@ public class AslExecutor {
if (arg.startsWith("\"") && arg.endsWith("\"")) {
return objectMapper.getNodeFactory().textNode(arg.substring(1, arg.length() - 1));
}
+ if ("true".equals(arg) || "false".equals(arg)) {
+ return objectMapper.getNodeFactory().booleanNode(Boolean.parseBoolean(arg));
+ }
+ if ("null".equals(arg)) {
+ return objectMapper.getNodeFactory().nullNode();
+ }
try {
return objectMapper.getNodeFactory().numberNode(Long.parseLong(arg));
} catch (NumberFormatException e1) {
diff --git a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorJsonMergeTest.java b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorJsonMergeTest.java
new file mode 100644
index 0000000000..97689185f5
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorJsonMergeTest.java
@@ -0,0 +1,113 @@
+package io.github.hectorvent.floci.services.stepfunctions;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.github.hectorvent.floci.services.cloudformation.CloudFormationQueryHandler;
+import io.github.hectorvent.floci.services.dynamodb.DynamoDbJsonHandler;
+import io.github.hectorvent.floci.services.dynamodb.DynamoDbService;
+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.lambda.LambdaExecutorService;
+import io.github.hectorvent.floci.services.lambda.LambdaFunctionStore;
+import io.github.hectorvent.floci.services.s3.S3Service;
+import io.github.hectorvent.floci.services.sqs.SqsJsonHandler;
+import jakarta.enterprise.inject.Instance;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.mock;
+
+/**
+ * Regression + functionality coverage for the {@code States.JsonMerge} intrinsic. AWS Step Functions
+ * supports only the shallow merge form {@code States.JsonMerge($.a, $.b, false)} where the second
+ * object's top-level fields win on a key conflict; deep-merge ({@code true}) and non-object arguments
+ * are rejected. A state machine using this intrinsic previously failed with
+ * "Unsupported intrinsic function: States.JsonMerge".
+ */
+class AslExecutorJsonMergeTest {
+
+ private final ObjectMapper mapper = new ObjectMapper();
+ private AslExecutor executor;
+
+ @BeforeEach
+ @SuppressWarnings("unchecked")
+ void setUp() {
+ executor = new AslExecutor(
+ mock(LambdaExecutorService.class),
+ mock(LambdaFunctionStore.class),
+ mock(DynamoDbService.class),
+ mock(DynamoDbJsonHandler.class),
+ mock(SqsJsonHandler.class),
+ mock(CloudFormationQueryHandler.class),
+ mock(Ec2Service.class),
+ mock(S3Service.class),
+ mock(EcsService.class),
+ mock(EcsJsonHandler.class),
+ mapper,
+ new JsonataEvaluator(mapper),
+ mock(Instance.class));
+ }
+
+ @Test
+ void shallowMergeSecondObjectWins() throws Exception {
+ JsonNode root = mapper.readTree("{\"a\":{\"x\":1,\"y\":2},\"b\":{\"y\":9,\"z\":3}}");
+ JsonNode out = executor.resolvePath("States.JsonMerge($.a, $.b, false)", root);
+ assertTrue(out.isObject());
+ assertEquals(1, out.path("x").asInt());
+ assertEquals(9, out.path("y").asInt(), "second object's value should win on key conflict");
+ assertEquals(3, out.path("z").asInt());
+ }
+
+ @Test
+ void deepMergeTrueIsRejected() throws Exception {
+ JsonNode root = mapper.readTree("{\"a\":{\"x\":1},\"b\":{\"y\":2}}");
+ assertThrows(RuntimeException.class,
+ () -> executor.resolvePath("States.JsonMerge($.a, $.b, true)", root));
+ }
+
+ @Test
+ void nonObjectArgumentsRejected() throws Exception {
+ JsonNode root = mapper.readTree("{\"a\":[1,2],\"b\":{\"y\":2}}");
+ assertThrows(RuntimeException.class,
+ () -> executor.resolvePath("States.JsonMerge($.a, $.b, false)", root));
+ }
+
+ @Test
+ void nonObjectArgumentsAreRejectedBeforeTheDeepMergeFlag() throws Exception {
+ // Two non-objects passed with deep=true must report the object-type error, not the
+ // "shallow merge only" error — AWS validates argument types before the deep-merge flag.
+ JsonNode root = mapper.readTree("{\"a\":[1,2],\"b\":[3,4]}");
+ RuntimeException ex = assertThrows(RuntimeException.class,
+ () -> executor.resolvePath("States.JsonMerge($.a, $.b, true)", root));
+ assertTrue(ex.getMessage().contains("requires two JSON objects"),
+ "expected the object-type error to take precedence, got: " + ex.getMessage());
+ }
+
+ @Test
+ void wrongArgumentCountUsesIntrinsicFailure() throws Exception {
+ JsonNode root = mapper.readTree("{\"a\":{\"x\":1},\"b\":{\"y\":2}}");
+ AslExecutor.FailStateException exception = assertThrows(AslExecutor.FailStateException.class,
+ () -> executor.resolvePath("States.JsonMerge($.a, $.b)", root));
+ assertEquals("States.IntrinsicFailure", exception.error);
+ }
+
+ @Test
+ void trailingCommaUsesIntrinsicFailure() throws Exception {
+ JsonNode root = mapper.readTree("{\"a\":{\"x\":1},\"b\":{\"y\":2}}");
+ AslExecutor.FailStateException exception = assertThrows(AslExecutor.FailStateException.class,
+ () -> executor.resolvePath("States.JsonMerge($.a, $.b, false,)", root));
+ assertEquals("States.IntrinsicFailure", exception.error);
+ }
+
+ @Test
+ void nonBooleanThirdArgumentRejected() throws Exception {
+ // A non-boolean third argument must be rejected, not silently coerced to false (shallow).
+ JsonNode root = mapper.readTree("{\"a\":{\"x\":1},\"b\":{\"y\":2},\"n\":3}");
+ assertThrows(RuntimeException.class,
+ () -> executor.resolvePath("States.JsonMerge($.a, $.b, $.n)", root));
+ }
+}