Light, fluffy, and always free - The AWS Local Emulator alternative
fix(stepfunctions): fail the state when a JSONata expression returns nothing (#2689)
Facundo Paredesea11e6771948
diff --git a/docs/services/step-functions.md b/docs/services/step-functions.mdindex 39aad05413..1baaa580d2 100644--- a/docs/services/step-functions.md+++ b/docs/services/step-functions.md@@ -77,13 +77,34 @@ an array element:```The same `null` is a value inside the expression too: `$exists()` on it is true and `$type()` on it-is `"null"`. Only an expression that returns nothing loses its key, which is what-`$states.input.absent` and the functions listed below that evaluate to undefined do.+is `"null"`.-Two deviations. `$count()` on a JSON null answers `0`; AWS answers `1`. And dropping the key of an-expression that returned nothing is Floci's own behaviour: AWS fails the state instead, with-`States.QueryEvaluationError` and `The JSONata expression '$states.input.absent' specified for the-field 'Output/v' returned nothing (undefined).`+One deviation. `$count()` on a JSON null answers `0`; AWS answers `1`.++## An expression that returns nothing fails the state++An expression that returns nothing, which is what `$states.input.absent` and the functions listed+below that evaluate to undefined do, is not a missing value the state carries on without. It fails+the state with `States.QueryEvaluationError`, naming the field it was written in, and a `Catch` on+that error fires:++```+"Output": {"v": "{% $states.input.absent %}"}+ -> States.QueryEvaluationError+ The JSONata expression '$states.input.absent' specified for the field 'Output/v'+ returned nothing (undefined).+```++The field is named relative to the state, with `/` before each object key and `[i]` for each array+index: `Output`, `Output/a/b[0]`, `Assign/x`, `Arguments/MessageGroupId`, `Choices[1]/Condition`,+`Seconds`, `Error`, `Cause`, `Items`, `MaxConcurrency`. A matched `Choice` rule and a matching+`Catch` clause carry their own `Assign` and `Output`, which are named under the rule or clause:+`Choices[1]/Output/v`, `Choices[0]/Assign/x`, `Catch[1]/Output/v`. A `Choice` stops at the first rule+that matches, so an undefined condition in a later rule is never evaluated.++One deviation. AWS prefixes the cause of a real execution with+`An error occurred while executing the state '<name>' (entered at the event id #<n>).`; Floci+returns the cause without it, which is the form AWS's own `TestState` returns.## JSONata functions@@ -105,8 +126,8 @@ Three behaviours are worth knowing before reading an unexpected result, and all`$partition(items, 2.9)` chunks by 2.- Several arguments evaluate to undefined rather than failing: a chunk size of zero, an emptyarray, a `$range` with no `step` or with a step whose sign disagrees with the direction, and a- `$hash` with no algorithm. An undefined value is then dropped from the surrounding `Output`- object, so the field goes missing instead of the state failing.+ `$hash` with no algorithm. The argument itself does not fail; the field the expression was+ written in does, under `States.QueryEvaluationError`, as the section above records.- `$range` collapses a single-element range to the bare number, not a one-element array.JSONata's own `$string` follows AWS's number notation: a whole number is written out in full belowdiff --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 af39f5c4cb..a4c25f9728 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@@ -391,7 +391,16 @@ public class AslExecutor {currentStateName = null;}} catch (FailStateException e) {- StateResult caught = handleCatch(stateDef, currentInput, e, jsonata, execContext, variables);+ StateResult caught = null;+ FailStateException failure = e;+ try {+ caught = handleCatch(stateDef, currentInput, e, jsonata, execContext, variables);+ } catch (FailStateException catchClauseFailure) {+ // A matching Catch clause carries its own Assign and Output, and an+ // expression there can fail. AWS reports that failure, not the error the+ // clause was catching, and no later clause catches it.+ failure = catchClauseFailure;+ }if (caught != null) {addEvent(history, eventId, stateExitedEventType(type), eventId.get() - 1,Map.of("name", currentStateName, "output", caught.output().toString()));@@ -399,7 +408,7 @@ public class AslExecutor {currentStateName = caught.nextState();continue;}- failExecution(exec, history, eventId, e);+ failExecution(exec, history, eventId, failure);onUpdate.accept(exec, history);return;}@@ -593,7 +602,8 @@ public class AslExecutor {var effectiveInput = input;if (stateDef.has("Arguments")) {var statesVar = buildStatesVar(input, null, context);- effectiveInput = jsonataEvaluator.resolveTemplate(stateDef.get("Arguments"), statesVar, variables);+ effectiveInput = jsonataEvaluator.resolveTemplate(+ stateDef.get("Arguments"), "Arguments", statesVar, variables);}taskResult = mockedSteps != null? mockedTaskResult(mockedSteps, stateName, attempt)@@ -1650,14 +1660,17 @@ public class AslExecutor {if (jsonata) {JsonNode statesVar = buildStatesVar(input, null, context);JsonNode choices = stateDef.path("Choices");- for (JsonNode choice : choices) {+ for (int i = 0; i < choices.size(); i++) {+ JsonNode choice = choices.get(i);String condition = choice.path("Condition").asText(null);if (condition != null) {- JsonNode result = jsonataEvaluator.evaluate(condition, statesVar, variables);+ JsonNode result = jsonataEvaluator.evaluateField(+ condition, "Choices[" + i + "]/Condition", statesVar, variables);if (result.isBoolean() && result.asBoolean()) {// A matched rule carries its own Assign and Output; the state-level ones// belong to the Default path and do not run here.- JsonNode output = applyJsonataAssignAndOutput(choice, statesVar, input, variables);+ JsonNode output = applyJsonataAssignAndOutput(+ choice, "Choices[" + i + "]/", statesVar, input, variables);return new StateResult(output, choice.path("Next").asText());}}@@ -1665,7 +1678,7 @@ public class AslExecutor {String defaultState = stateDef.path("Default").asText(null);if (defaultState != null) {// No rule matched: the state-level Assign and Output apply on the Default path.- JsonNode output = applyJsonataAssignAndOutput(stateDef, statesVar, input, variables);+ JsonNode output = applyJsonataAssignAndOutput(stateDef, "", statesVar, input, variables);return new StateResult(output, defaultState);}throw new FailStateException("States.NoChoiceMatched", "No choice rule matched and no default state");@@ -1777,7 +1790,8 @@ public class AslExecutor {JsonNode secondsNode = stateDef.get("Seconds");if (secondsNode.isTextual() && JsonataEvaluator.isExpression(secondsNode.asText())) {JsonNode statesVar = buildStatesVar(input, null, context);- JsonNode result = jsonataEvaluator.evaluate(secondsNode.asText(), statesVar, variables);+ JsonNode result = jsonataEvaluator.evaluateField(+ secondsNode.asText(), "Seconds", statesVar, variables);seconds = Math.min(result.asInt(), MAX_WAIT_SECONDS);} else {seconds = Math.min(secondsNode.asInt(), MAX_WAIT_SECONDS);@@ -1818,10 +1832,10 @@ public class AslExecutor {if (jsonata) {JsonNode statesVar = buildStatesVar(input, null, context);if (error != null && JsonataEvaluator.isExpression(error)) {- error = jsonataEvaluator.evaluate(error, statesVar, variables).asText();+ error = jsonataEvaluator.evaluateField(error, "Error", statesVar, variables).asText();}if (cause != null && JsonataEvaluator.isExpression(cause)) {- cause = jsonataEvaluator.evaluate(cause, statesVar, variables).asText();+ cause = jsonataEvaluator.evaluateField(cause, "Cause", statesVar, variables).asText();}}throw new FailStateException(error, cause);@@ -2031,7 +2045,7 @@ public class AslExecutor {if (jsonata && value.isTextual() && JsonataEvaluator.isExpression(value.asText())) {jsonataExpression = true;JsonNode statesVar = buildStatesVar(mapInput, null, context);- value = jsonataEvaluator.evaluate(value.asText(), statesVar, variables);+ value = jsonataEvaluator.evaluateField(value.asText(), "MaxConcurrency", statesVar, variables);}} else {return 0;@@ -2118,19 +2132,8 @@ public class AslExecutor {// InputPath, which is supplied by executeMapState.JsonNode loc;if (jsonata && writer.has("Arguments")) {- JsonNode arguments = writer.get("Arguments");- loc = jsonataEvaluator.resolveTemplate(- arguments, buildStatesVar(input, null, context), variables);- if (arguments.isObject()) {- if (arguments.has("Bucket") && !loc.has("Bucket")) {- throw new FailStateException("States.QueryEvaluationError",- "ResultWriter Bucket must resolve to a string");- }- if (arguments.has("Prefix") && !loc.has("Prefix")) {- throw new FailStateException("States.QueryEvaluationError",- "ResultWriter Prefix must resolve to a string");- }- }+ loc = jsonataEvaluator.resolveTemplate(writer.get("Arguments"), "ResultWriter/Arguments",+ buildStatesVar(input, null, context), variables);} else if (writer.has("Parameters")) {loc = resolveParameters(writer.get("Parameters"), input, context);} else {@@ -2287,7 +2290,8 @@ public class AslExecutor {JsonNode itemsNode = stateDef.get("Items");if (itemsNode.isTextual() && JsonataEvaluator.isExpression(itemsNode.asText())) {JsonNode statesVar = buildStatesVar(input, null, context);- return new ResolvedMapItems(jsonataEvaluator.evaluate(itemsNode.asText(), statesVar, variables),+ return new ResolvedMapItems(+ jsonataEvaluator.evaluateField(itemsNode.asText(), "Items", statesVar, variables),MapItemsSource.DEFAULT);}return new ResolvedMapItems(itemsNode, MapItemsSource.DEFAULT);@@ -2323,7 +2327,8 @@ public class AslExecutor {JsonNode resolvedParameters;if (jsonata && itemReader.has("Arguments")) {JsonNode statesVar = buildStatesVar(input, null, context);- resolvedParameters = jsonataEvaluator.resolveTemplate(itemReader.get("Arguments"), statesVar, variables);+ resolvedParameters = jsonataEvaluator.resolveTemplate(+ itemReader.get("Arguments"), "ItemReader/Arguments", statesVar, variables);} else {JsonNode parameters = itemReader.path("Parameters");resolvedParameters = resolveParameters(parameters, input, context);@@ -2519,28 +2524,35 @@ public class AslExecutor {private JsonNode applyJsonataOutput(JsonNode holder, JsonNode input, JsonNode result, JsonNode context,ObjectNode variables) {JsonNode statesVar = buildStatesVar(input, result, context);- return applyJsonataAssignAndOutput(holder, statesVar, result != null ? result : input, variables);+ return applyJsonataAssignAndOutput(holder, "", statesVar, result != null ? result : input, variables);}/*** Apply the Assign and Output fields of anything that can carry them: a state, a Choice rule, or- * a Catch block. {@code fallbackOutput} is the value that becomes the output when Output is absent.+ * a Catch clause. {@code fallbackOutput} is the value that becomes the output when Output is absent.+ *+ * <p>{@code holderPrefix} is what AWS puts before the holder's own field names in the cause of a+ * States.QueryEvaluationError: empty for a state, {@code "Choices[1]/"} for the second Choice+ * rule, {@code "Catch[1]/"} for the second Catch clause. AWS names a rule's own Output+ * {@code Choices[1]/Output/v}, not {@code Output/v}.*/- private JsonNode applyJsonataAssignAndOutput(JsonNode holder, JsonNode statesVar, JsonNode fallbackOutput,- ObjectNode variables) {- JsonNode assigned = evaluateJsonataAssign(holder, statesVar, variables);+ private JsonNode applyJsonataAssignAndOutput(JsonNode holder, String holderPrefix, JsonNode statesVar,+ JsonNode fallbackOutput, ObjectNode variables) {+ JsonNode assigned = evaluateJsonataAssign(holder, holderPrefix, statesVar, variables);JsonNode output = holder.has("Output")- ? jsonataEvaluator.resolveTemplate(holder.get("Output"), statesVar, variables)+ ? jsonataEvaluator.resolveTemplate(holder.get("Output"), holderPrefix + "Output", statesVar, variables): fallbackOutput;commitJsonataAssign(assigned, variables);return output;}- private JsonNode evaluateJsonataAssign(JsonNode holder, JsonNode statesVar, ObjectNode variables) {+ private JsonNode evaluateJsonataAssign(JsonNode holder, String holderPrefix, JsonNode statesVar,+ ObjectNode variables) {if (!holder.has("Assign")) {return null;}- JsonNode assigned = jsonataEvaluator.resolveTemplate(holder.get("Assign"), statesVar, variables);+ JsonNode assigned = jsonataEvaluator.resolveTemplate(+ holder.get("Assign"), holderPrefix + "Assign", statesVar, variables);if (assigned == null || !assigned.isObject()) {throw new FailStateException("States.Runtime", "Assign must evaluate to an object");}@@ -3385,7 +3397,8 @@ public class AslExecutor {}String error = failure.error != null ? failure.error : "States.Runtime";String cause = failure.cause != null ? failure.cause : "";- for (JsonNode catcher : catchers) {+ for (int i = 0; i < catchers.size(); i++) {+ JsonNode catcher = catchers.get(i);if (!catchMatches(catcher, error)) {continue;}@@ -3401,7 +3414,8 @@ public class AslExecutor {// scope the catching state lives in — so for a Parallel or Map it lands in the outer// scope, not the branch scope that failed.JsonNode statesVar = buildCatchStatesVar(input, errorOutput, context);- JsonNode output = applyJsonataAssignAndOutput(catcher, statesVar, errorOutput, variables);+ JsonNode output = applyJsonataAssignAndOutput(+ catcher, "Catch[" + i + "]/", statesVar, errorOutput, variables);return new StateResult(output, next);}return new StateResult(mergeResult(catcher, input, errorOutput), next);diff --git a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/JsonataEvaluator.java b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/JsonataEvaluator.javaindex bfa2f02e72..61209dbeff 100644--- a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/JsonataEvaluator.java+++ b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/JsonataEvaluator.java@@ -256,33 +256,46 @@ public class JsonataEvaluator {}/**- * Walk a JSON template (Arguments or Output), evaluating any {% %} strings found.+ * Evaluate the single expression an ASL field holds, failing the state when it returns nothing.+ * AWS names the field in the cause and a {@code Catch} on States.QueryEvaluationError fires:+ * a Wait whose Seconds returned nothing does not wait zero seconds, it fails.+ *+ * <p>{@code field} is the field's path relative to the state, as AWS writes it: {@code Seconds},+ * {@code Choices[1]/Condition}, {@code Output/a/b}.+ */+ JsonNode evaluateField(String expression, String field, JsonNode statesVar, JsonNode variables) {+ JsonNode value = evaluate(expression, statesVar, variables);+ if (value.isMissingNode()) {+ throw new FailStateException("States.QueryEvaluationError",+ "The JSONata expression '" + (isExpression(expression) ? unwrap(expression) : expression)+ + "' specified for the field '" + field + "' returned nothing (undefined).");+ }+ return value;+ }++ /**+ * Walk a JSON template (Arguments, Output or Assign), evaluating any {% %} strings found.* Non-expression values pass through unchanged.** Only pure {% expression %} strings are evaluated (can return any JSON type).* All other strings pass through unchanged.+ *+ * <p>{@code field} is the template's own field name, which the walk extends with {@code /key}+ * per object key and {@code [i]} per array index so a failing expression is named the way AWS+ * names it: {@code Output/a/b[0][1]}.*/- JsonNode resolveTemplate(JsonNode template, JsonNode statesVar) {- return resolveTemplate(template, statesVar, null);+ JsonNode resolveTemplate(JsonNode template, String field, JsonNode statesVar) {+ return resolveTemplate(template, field, statesVar, null);}- JsonNode resolveTemplate(JsonNode template, JsonNode statesVar, JsonNode variables) {+ JsonNode resolveTemplate(JsonNode template, String field, JsonNode statesVar, JsonNode variables) {if (template == null || template.isMissingNode()) {return template;}- JsonNode resolved = resolveTemplateNode(template, statesVar, variables);- // A resolved Output or Arguments is serialized as it stands, and a missing node writes- // itself as the empty string, which no client can parse. "Returned nothing" is a value only- // in the positions resolveTemplateNode reads it in: an object field it drops, an array- // element it fails the state on. As the whole field there is nothing to drop it from.- return resolved.isMissingNode() ? NullNode.getInstance() : resolved;- }-- private JsonNode resolveTemplateNode(JsonNode template, JsonNode statesVar, JsonNode variables) {if (template.isTextual()) {String text = template.asText();if (isExpression(text)) {- return evaluate(text, statesVar, variables);+ return evaluateField(text, field, statesVar, variables);}return template;}@@ -291,30 +304,15 @@ public class JsonataEvaluator {Iterator<Map.Entry<String, JsonNode>> fields = template.fields();while (fields.hasNext()) {Map.Entry<String, JsonNode> entry = fields.next();- JsonNode value = resolveTemplateNode(entry.getValue(), statesVar, variables);- // Per JSONata spec: an expression that returned nothing is omitted from object- // output, matching real AWS Step Functions behavior. A JSON null is a value and- // keeps its key: AWS answers {"v":null} to Output {"v":"{% null %}"}.- if (!value.isMissingNode()) {- resolved.set(entry.getKey(), value);- }+ resolved.set(entry.getKey(),+ resolveTemplate(entry.getValue(), field + "/" + entry.getKey(), statesVar, variables));}return resolved;}if (template.isArray()) {ArrayNode resolved = objectMapper.createArrayNode();for (int i = 0; i < template.size(); i++) {- JsonNode element = template.get(i);- JsonNode value = resolveTemplateNode(element, statesVar, variables);- // Per real AWS behavior: an array element that returned nothing fails the execution.- // Unlike object fields (which are omitted), undefined in an array is a runtime error.- // A JSON null is a value and stays: AWS answers [null,1] to ["{% null %}",1].- if (value.isMissingNode()) {- String expr = element.isTextual() ? element.asText() : element.toString();- throw new FailStateException("States.Runtime",- "The JSONata expression '" + expr + "' at array index " + i + " returned nothing (undefined).");- }- resolved.add(value);+ resolved.add(resolveTemplate(template.get(i), field + "[" + i + "]", statesVar, variables));}return resolved;}@@ -336,9 +334,9 @@ public class JsonataEvaluator {/*** The evaluation result. A Java null is the expression returning nothing, which- * {@link #resolveTemplateNode} drops from an object; the JSONata null marker is a JSON null,- * which it keeps. Nested inside an object or an array there is no undefined, so every null- * there is a JSON null.+ * {@link #evaluateField} fails the state on; the JSONata null marker is a JSON null, which is a+ * value like any other. Nested inside an object or an array there is no undefined, so every+ * null there is a JSON null.*/private JsonNode toJsonNode(Object value) {return value == null ? MissingNode.getInstance() : fromJsonataValue(value);diff --git a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorErrorTerminationTest.java b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorErrorTerminationTest.javaindex 9c848a3902..4e42b7857a 100644--- a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorErrorTerminationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorErrorTerminationTest.java@@ -64,7 +64,7 @@ class AslExecutorErrorTerminationTest {}@Override- JsonNode resolveTemplate(JsonNode template, JsonNode statesVar, JsonNode variables) {+ JsonNode resolveTemplate(JsonNode template, String field, JsonNode statesVar, JsonNode variables) {throw new LinkageError(ERROR_MESSAGE);}}diff --git a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorHttpInvokeTest.java b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorHttpInvokeTest.javaindex 3bf6481789..4d51ec9ef9 100644--- a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorHttpInvokeTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorHttpInvokeTest.java@@ -288,7 +288,7 @@ class AslExecutorHttpInvokeTest {}@Test- void jsonataArgumentsSendAnExplicitNullAndOmitOnlyWhatReturnedNothing() throws Exception {+ void jsonataArgumentsSendAnExplicitNull() throws Exception {// AWS keeps the null in the arguments a Task is invoked with: TestState TRACE reports// afterArguments {"FunctionName":"nope","Payload":{"v":null}} for Payload {"v":"{% null %}"}.Execution execution = run("""@@ -307,7 +307,6 @@ class AslExecutorHttpInvokeTest {},"RequestBody": {"fromInput": "{%% $lookup($states.input, 'customerId') %%}",- "returnedNothing": "{%% $states.input.absent %%}","active": true}},@@ -324,7 +323,6 @@ class AslExecutorHttpInvokeTest {assertEquals("SUCCEEDED", execution.getStatus(), execution.getCause());JsonNode body = objectMapper.readTree(onlyRequest().body());assertTrue(body.path("fromInput").isNull(), body.toString());- assertTrue(body.path("returnedNothing").isMissingNode(), body.toString());assertTrue(body.path("active").asBoolean());}diff --git a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorResultWriterTest.java b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorResultWriterTest.javaindex e3e4f4a32e..4e7630eaf5 100644--- a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorResultWriterTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorResultWriterTest.java@@ -402,19 +402,27 @@ class AslExecutorResultWriterTest {assertEquals("States.QueryEvaluationError", nestedBucketFailure.error);assertTrue(nestedBucketFailure.getMessage().contains("Bucket must resolve to a string"));- JsonNode nestedPrefixStateDef = mapper.readTree("""+ verify(s3Service, org.mockito.Mockito.never())+ .putObject(anyString(), anyString(), any(byte[].class), anyString(), any());+ }++ @Test+ void aDestinationExpressionReturningNothingFailsBeforeWriting() throws Exception {+ JsonNode stateDef = mapper.readTree("""{"Type":"Map","ResultWriter":{"Resource":"arn:aws:states:::s3:putObject","Arguments":{"Bucket":"b","Prefix":"{% $states.input.missing %}"}}}""");- AslExecutor.FailStateException nestedPrefixFailure = assertThrows(++ AslExecutor.FailStateException failure = assertThrows(AslExecutor.FailStateException.class,- () -> executor.applyResultWriter("Process", nestedPrefixStateDef, mapper.createObjectNode(),+ () -> executor.applyResultWriter("Process", stateDef, mapper.createObjectNode(),arr("{\"ok\":true}"), mapper.createArrayNode(), List.of(),sm, context, true));- assertEquals("States.QueryEvaluationError", nestedPrefixFailure.error);- assertTrue(nestedPrefixFailure.getMessage().contains("Prefix must resolve to a string"));+ assertEquals("States.QueryEvaluationError", failure.error);+ assertEquals("The JSONata expression '$states.input.missing' specified for the field "+ + "'ResultWriter/Arguments/Prefix' returned nothing (undefined).", failure.cause);verify(s3Service, org.mockito.Mockito.never()).putObject(anyString(), anyString(), any(byte[].class), anyString(), any());}diff --git a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/JsonataEvaluatorTest.java b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/JsonataEvaluatorTest.javaindex a953eaa0cf..8715ea7ea2 100644--- a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/JsonataEvaluatorTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/JsonataEvaluatorTest.java@@ -6,6 +6,11 @@ import com.fasterxml.jackson.databind.node.NullNode;import org.junit.jupiter.api.BeforeEach;import org.junit.jupiter.api.Test;import org.junit.jupiter.api.Timeout;+import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.Arguments;+import org.junit.jupiter.params.provider.MethodSource;++import java.util.stream.Stream;import static org.junit.jupiter.api.Assertions.*;@@ -97,7 +102,7 @@ class JsonataEvaluatorTest {void resolveTemplate_nonExpressionStringPassesThrough() throws Exception {JsonNode template = objectMapper.readTree("\"plain text\"");JsonNode statesVar = objectMapper.createObjectNode();- JsonNode result = evaluator.resolveTemplate(template, statesVar);+ JsonNode result = evaluator.resolveTemplate(template, "Output", statesVar);assertEquals("plain text", result.asText());}@@ -105,7 +110,7 @@ class JsonataEvaluatorTest {void resolveTemplate_evaluatesExpressionInString() throws Exception {JsonNode template = objectMapper.readTree("\"{% 1 + 1 %}\"");JsonNode statesVar = objectMapper.createObjectNode();- JsonNode result = evaluator.resolveTemplate(template, statesVar);+ JsonNode result = evaluator.resolveTemplate(template, "Output", statesVar);assertEquals(2, result.asInt());}@@ -121,7 +126,7 @@ class JsonataEvaluatorTest {JsonNode statesVar = objectMapper.readTree("""{"input": {"name": "Bob"}}""");- JsonNode result = evaluator.resolveTemplate(template, statesVar);+ JsonNode result = evaluator.resolveTemplate(template, "Output", statesVar);assertTrue(result.isObject());assertEquals("Hello Bob", result.get("greeting").asText());assertEquals("unchanged", result.get("static").asText());@@ -136,7 +141,7 @@ class JsonataEvaluatorTest {JsonNode statesVar = objectMapper.readTree("""{"input": {"a": 1, "b": 2}}""");- JsonNode result = evaluator.resolveTemplate(template, statesVar);+ JsonNode result = evaluator.resolveTemplate(template, "Output", statesVar);assertTrue(result.isArray());assertEquals(1, result.get(0).asInt());assertEquals("static", result.get(1).asText());@@ -150,7 +155,7 @@ class JsonataEvaluatorTest {JsonNode statesVar = objectMapper.readTree("""{"input": {"name": "Alice", "age": 30}}""");- JsonNode result = evaluator.resolveTemplate(template, statesVar);+ JsonNode result = evaluator.resolveTemplate(template, "Output", statesVar);assertTrue(result.isTextual());assertEquals("Hello {% $states.input.name %}, you are {% $states.input.age %} years old", result.asText());}@@ -161,7 +166,7 @@ class JsonataEvaluatorTest {JsonNode statesVar = objectMapper.readTree("""{"input": {"name": "Alice", "age": 30}}""");- JsonNode result = evaluator.resolveTemplate(template, statesVar);+ JsonNode result = evaluator.resolveTemplate(template, "Output", statesVar);assertTrue(result.isObject());assertEquals("Alice", result.get("name").asText());}@@ -170,9 +175,9 @@ class JsonataEvaluatorTest {void resolveTemplate_primitivesPassThrough() throws Exception {JsonNode statesVar = objectMapper.createObjectNode();- assertEquals(42, evaluator.resolveTemplate(objectMapper.readTree("42"), statesVar).asInt());- assertTrue(evaluator.resolveTemplate(objectMapper.readTree("true"), statesVar).asBoolean());- assertTrue(evaluator.resolveTemplate(NullNode.getInstance(), statesVar).isNull());+ assertEquals(42, evaluator.resolveTemplate(objectMapper.readTree("42"), "Output", statesVar).asInt());+ assertTrue(evaluator.resolveTemplate(objectMapper.readTree("true"), "Output", statesVar).asBoolean());+ assertTrue(evaluator.resolveTemplate(NullNode.getInstance(), "Output", statesVar).isNull());}@Test@@ -804,18 +809,17 @@ class JsonataEvaluatorTest {}@Test- void anExplicitNullKeepsItsKeyAndOnlyWhatReturnedNothingIsDropped() throws Exception {+ void anExplicitNullKeepsItsKey() throws Exception {JsonNode statesVar = objectMapper.readTree("""{"input": {"bar": null}}""");JsonNode template = objectMapper.readTree("""{"fromInput": "{% $lookup($states.input, 'bar') %}",- "returnedNothing": "{% $states.input.absent %}","kept": 1}""");assertEquals("{\"fromInput\":null,\"kept\":1}",- evaluator.resolveTemplate(template, statesVar).toString());+ evaluator.resolveTemplate(template, "Output", statesVar).toString());}@Test@@ -826,34 +830,23 @@ class JsonataEvaluatorTest {""");assertEquals("{\"outer\":{\"fromExpression\":null,\"kept\":1}}",- evaluator.resolveTemplate(template, statesVar).toString());+ evaluator.resolveTemplate(template, "Output", statesVar).toString());}@Test- void aWholeTemplateIsANullWhetherItEvaluatedToNullOrReturnedNothing() throws Exception {+ void aWholeTemplateEvaluatingToNullIsANull() throws Exception {JsonNode statesVar = objectMapper.createObjectNode();- assertTrue(evaluator.resolveTemplate(objectMapper.readTree("\"{% null %}\""), statesVar).isNull());- // AWS fails the second one with States.QueryEvaluationError, which #2665 covers. Until then- // it is a null and not a missing node: an Output or Arguments is serialized as it stands,- // and a missing node writes itself as the empty string rather than as JSON.- assertTrue(evaluator.resolveTemplate(objectMapper.readTree("\"{% $states.input.absent %}\""), statesVar)- .isNull());+ assertTrue(evaluator.resolveTemplate(objectMapper.readTree("\"{% null %}\""), "Output", statesVar).isNull());}@Test- void anExplicitNullIsAnArrayElementWhileNothingStillFailsTheState() throws Exception {+ void anExplicitNullIsAnArrayElement() throws Exception {JsonNode statesVar = objectMapper.createObjectNode();assertEquals("{\"values\":[null,1]}", evaluator.resolveTemplate(objectMapper.readTree("""{"values": ["{% null %}", 1]}- """), statesVar).toString());-- AslExecutor.FailStateException failure = assertThrows(AslExecutor.FailStateException.class,- () -> evaluator.resolveTemplate(objectMapper.readTree("""- {"values": ["{% $states.input.absent %}"]}- """), statesVar));- assertTrue(failure.cause.contains("returned nothing (undefined)"), failure.cause);+ """), "Output", statesVar).toString());}@Test@@ -862,7 +855,7 @@ class JsonataEvaluatorTest {assertEquals("{\"literal\":null,\"kept\":1}", evaluator.resolveTemplate(objectMapper.readTree("""{"literal": null, "kept": 1}- """), statesVar).toString());+ """), "Output", statesVar).toString());}@Test@@ -885,4 +878,54 @@ class JsonataEvaluatorTest {assertTrue(evaluator.evaluate("{% $nullVariable %}", statesVar, variables).isNull());assertTrue(evaluator.evaluate("{% $exists($nullVariable) %}", statesVar, variables).asBoolean());}++ /**+ * The field path AWS names in the cause: the ASL field the template came from, a {@code /}+ * before every object key below it and {@code [i]} appended for every array index. Measured on+ * TestState, one Pass or one Assign per row.+ */+ static Stream<Arguments> templatesWhoseExpressionReturnsNothing() {+ return Stream.of(+ Arguments.of("{\"v\": \"{% $states.input.missing %}\"}", "Output", "Output/v"),+ Arguments.of("{\"a\": {\"b\": \"{% $states.input.missing %}\"}}", "Output", "Output/a/b"),+ Arguments.of("\"{% $states.input.missing %}\"", "Output", "Output"),+ Arguments.of("{\"values\": [\"{% $states.input.missing %}\", 1]}", "Output", "Output/values[0]"),+ Arguments.of("{\"a\": {\"b\": [[1, \"{% $states.input.missing %}\"]]}}", "Output", "Output/a/b[0][1]"),+ Arguments.of("{\"x\": {\"y\": \"{% $states.input.missing %}\"}}", "Assign", "Assign/x/y"));+ }++ @ParameterizedTest+ @MethodSource("templatesWhoseExpressionReturnsNothing")+ void anExpressionReturningNothingFailsTheStateNamingTheFieldPath(String template, String field,+ String expectedFieldPath) throws Exception {+ JsonNode statesVar = objectMapper.readTree("{\"input\": {}}");++ AslExecutor.FailStateException failure = assertThrows(AslExecutor.FailStateException.class,+ () -> evaluator.resolveTemplate(objectMapper.readTree(template), field, statesVar));++ assertEquals("States.QueryEvaluationError", failure.error);+ assertEquals("The JSONata expression '$states.input.missing' specified for the field '"+ + expectedFieldPath + "' returned nothing (undefined).", failure.cause);+ }++ @Test+ void evaluateFieldNamesTheFieldOfAPositionThatHoldsASingleExpression() throws Exception {+ JsonNode statesVar = objectMapper.readTree("{\"input\": {}}");++ AslExecutor.FailStateException failure = assertThrows(AslExecutor.FailStateException.class,+ () -> evaluator.evaluateField("{% $states.input.missing %}", "Seconds", statesVar, null));++ assertEquals("States.QueryEvaluationError", failure.error);+ assertEquals("The JSONata expression '$states.input.missing' specified for the field 'Seconds' "+ + "returned nothing (undefined).", failure.cause);+ }++ @Test+ void anExplicitNullIsAValueAndKeepsEveryPositionEvaluating() throws Exception {+ JsonNode statesVar = objectMapper.readTree("{\"input\": {\"bar\": null}}");++ assertTrue(evaluator.evaluateField("{% null %}", "Seconds", statesVar, null).isNull());+ assertEquals("{\"v\":null}", evaluator.resolveTemplate(+ objectMapper.readTree("{\"v\": \"{% $states.input.bar %}\"}"), "Output", statesVar).toString());+ }}diff --git a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsJsonataIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsJsonataIntegrationTest.javaindex 9587bd2a59..92f9e7139c 100644--- a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsJsonataIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsJsonataIntegrationTest.java@@ -1226,10 +1226,9 @@ class StepFunctionsJsonataIntegrationTest {}@Test- void outputKeepsAnExplicitNullInEveryPositionAndDropsOnlyWhatReturnedNothing() throws Exception {+ void outputKeepsAnExplicitNullInEveryPosition() throws Exception {// AWS returns {"v":null} for an expression that evaluates to JSON null, in an object field,- // nested, as an array element and as a literal. Only an expression that returned nothing- // loses its key.+ // nested, as an array element and as a literal.String definition = """{"QueryLanguage": "JSONata",@@ -1242,8 +1241,7 @@ class StepFunctionsJsonataIntegrationTest {"fromLiteralExpression": "{% null %}","literal": null,"nested": {"inner": "{% null %}", "kept": 1},- "values": ["{% null %}", 1],- "returnedNothing": "{% $states.input.absent %}"+ "values": ["{% null %}", 1]},"End": true}@@ -1260,7 +1258,381 @@ class StepFunctionsJsonataIntegrationTest {assertTrue(output.path("literal").isNull(), output.toString());assertTrue(output.path("nested").path("inner").isNull(), output.toString());assertEquals("[null,1]", output.path("values").toString());- assertTrue(output.path("returnedNothing").isMissingNode(), output.toString());+ }++ @Test+ void outputExpressionReturningNothingFailsTheStateAndIsCatchable() throws Exception {+ // Real AWS on the same definition: States.QueryEvaluationError, "An error occurred while+ // executing the state 'Transform' (entered at the event id #2). The JSONata expression+ // '$states.input.missing' specified for the field 'Output/v' returned nothing (undefined)."+ // Floci does not yet render the "An error occurred while executing the state" prefix (#2668).+ String definition = """+ {+ "QueryLanguage": "JSONata",+ "StartAt": "Transform",+ "States": {+ "Transform": {+ "Type": "Pass",+ "Output": {"v": "{% $states.input.missing %}"},+ "End": true+ }+ }+ }+ """;++ String smArn = createStateMachine("jsonata-output-returned-nothing-test", definition);+ Response failure = waitForExecutionFailure(startExecution(smArn, "{}"));++ assertEquals("States.QueryEvaluationError", failure.jsonPath().getString("error"));+ assertEquals("The JSONata expression '$states.input.missing' specified for the field 'Output/v' "+ + "returned nothing (undefined).", failure.jsonPath().getString("cause"));++ String catching = definition.replace("\"End\": true",+ """+ "Catch": [{"ErrorEquals": ["States.QueryEvaluationError"], "Next": "Caught"}],+ "Next": "Unreached"+ },+ "Unreached": {"Type": "Fail", "Error": "UnexpectedSuccess"},+ "Caught": {"Type": "Pass", "Output": {"caught": true}, "End": true""");+ String catchingArn = createStateMachine("jsonata-output-returned-nothing-catch-test", catching);+ JsonNode caught = objectMapper.readTree(waitForExecution(startExecution(catchingArn, "{}")));++ assertTrue(caught.path("caught").asBoolean(), caught.toString());+ }++ @Test+ void assignExpressionReturningNothingFailsTheState() throws Exception {+ // Real AWS names 'Assign/x' for this definition; before this guard the variable was never+ // bound and the next state read it as missing.+ String definition = """+ {+ "QueryLanguage": "JSONata",+ "StartAt": "Bind",+ "States": {+ "Bind": {+ "Type": "Pass",+ "Assign": {"x": "{% $states.input.missing %}"},+ "Next": "Read"+ },+ "Read": {"Type": "Pass", "Output": {"got": "{% $x %}"}, "End": true}+ }+ }+ """;++ String smArn = createStateMachine("jsonata-assign-returned-nothing-test", definition);+ Response failure = waitForExecutionFailure(startExecution(smArn, "{}"));++ assertEquals("States.QueryEvaluationError", failure.jsonPath().getString("error"));+ assertEquals("The JSONata expression '$states.input.missing' specified for the field 'Assign/x' "+ + "returned nothing (undefined).", failure.jsonPath().getString("cause"));+ }++ @Test+ void taskArgumentReturningNothingFailsTheStateBeforeTheRequestIsSent() throws Exception {+ // Real AWS names 'Arguments/MessageGroupId' and fails before reaching SQS, which is why the+ // queue url below never has to exist. Before this guard Floci sent the message without it.+ String definition = """+ {+ "QueryLanguage": "JSONata",+ "StartAt": "Send",+ "States": {+ "Send": {+ "Type": "Task",+ "Resource": "arn:aws:states:::sqs:sendMessage",+ "Arguments": {+ "QueueUrl": "http://localhost:4566/000000000000/absent-queue",+ "MessageBody": "m",+ "MessageGroupId": "{% $states.input.missing %}"+ },+ "End": true+ }+ }+ }+ """;++ String smArn = createStateMachine("jsonata-arguments-returned-nothing-test", definition);+ Response failure = waitForExecutionFailure(startExecution(smArn, "{}"));++ assertEquals("States.QueryEvaluationError", failure.jsonPath().getString("error"));+ assertEquals("The JSONata expression '$states.input.missing' specified for the field "+ + "'Arguments/MessageGroupId' returned nothing (undefined).",+ failure.jsonPath().getString("cause"));+ }++ @Test+ void choiceConditionReturningNothingFailsTheStateInsteadOfTakingDefault() throws Exception {+ // Real AWS names the rule by its index, 'Choices[1]/Condition', and evaluates the rules in+ // order, so the first rule being false is what makes the second one run.+ String definition = """+ {+ "QueryLanguage": "JSONata",+ "StartAt": "Pick",+ "States": {+ "Pick": {+ "Type": "Choice",+ "Choices": [+ {"Condition": "{% false %}", "Next": "First"},+ {"Condition": "{% $states.input.missing %}", "Next": "Second"}+ ],+ "Default": "Fallback"+ },+ "First": {"Type": "Pass", "Output": {"went": "First"}, "End": true},+ "Second": {"Type": "Pass", "Output": {"went": "Second"}, "End": true},+ "Fallback": {"Type": "Pass", "Output": {"went": "Fallback"}, "End": true}+ }+ }+ """;++ String smArn = createStateMachine("jsonata-condition-returned-nothing-test", definition);+ Response failure = waitForExecutionFailure(startExecution(smArn, "{}"));++ assertEquals("States.QueryEvaluationError", failure.jsonPath().getString("error"));+ assertEquals("The JSONata expression '$states.input.missing' specified for the field "+ + "'Choices[1]/Condition' returned nothing (undefined).", failure.jsonPath().getString("cause"));+ }++ @Test+ void aChoiceRuleAfterTheMatchingOneIsNeverEvaluated() throws Exception {+ // AWS succeeds on this definition: the first rule matches, so the undefined condition in the+ // second one is never reached. The guard must not turn rule order into a failure.+ String definition = """+ {+ "QueryLanguage": "JSONata",+ "StartAt": "Pick",+ "States": {+ "Pick": {+ "Type": "Choice",+ "Choices": [+ {"Condition": "{% true %}", "Next": "First"},+ {"Condition": "{% $states.input.missing %}", "Next": "Second"}+ ],+ "Default": "Fallback"+ },+ "First": {"Type": "Pass", "Output": {"went": "First"}, "End": true},+ "Second": {"Type": "Pass", "Output": {"went": "Second"}, "End": true},+ "Fallback": {"Type": "Pass", "Output": {"went": "Fallback"}, "End": true}+ }+ }+ """;++ String smArn = createStateMachine("jsonata-condition-short-circuit-test", definition);+ JsonNode output = objectMapper.readTree(waitForExecution(startExecution(smArn, "{}")));++ assertEquals("First", output.path("went").asText(), output.toString());+ }++ @Test+ void aMatchedChoiceRuleNamesItsOwnOutputUnderTheRuleIndex() throws Exception {+ // Real AWS names 'Choices[1]/Output/v': a rule's own Output is a field of the rule, not the+ // state-level Output, and the index is the rule's position in Choices.+ String definition = """+ {+ "QueryLanguage": "JSONata",+ "StartAt": "Pick",+ "States": {+ "Pick": {+ "Type": "Choice",+ "Choices": [+ {"Condition": "{% false %}", "Next": "First"},+ {"Condition": "{% true %}",+ "Output": {"v": "{% $states.input.missing %}"}, "Next": "First"}+ ],+ "Default": "Fallback"+ },+ "First": {"Type": "Pass", "End": true},+ "Fallback": {"Type": "Pass", "End": true}+ }+ }+ """;++ String smArn = createStateMachine("jsonata-choice-rule-output-nothing-test", definition);+ Response failure = waitForExecutionFailure(startExecution(smArn, "{}"));++ assertEquals("States.QueryEvaluationError", failure.jsonPath().getString("error"));+ assertEquals("The JSONata expression '$states.input.missing' specified for the field "+ + "'Choices[1]/Output/v' returned nothing (undefined).", failure.jsonPath().getString("cause"));+ }++ @Test+ void aMatchedChoiceRuleNamesItsOwnAssignUnderTheRuleIndex() throws Exception {+ // Real AWS names 'Choices[0]/Assign/x' for a rule's own Assign.+ String definition = """+ {+ "QueryLanguage": "JSONata",+ "StartAt": "Pick",+ "States": {+ "Pick": {+ "Type": "Choice",+ "Choices": [+ {"Condition": "{% true %}",+ "Assign": {"x": "{% $states.input.missing %}"}, "Next": "First"}+ ],+ "Default": "Fallback"+ },+ "First": {"Type": "Pass", "End": true},+ "Fallback": {"Type": "Pass", "End": true}+ }+ }+ """;++ String smArn = createStateMachine("jsonata-choice-rule-assign-nothing-test", definition);+ Response failure = waitForExecutionFailure(startExecution(smArn, "{}"));++ assertEquals("States.QueryEvaluationError", failure.jsonPath().getString("error"));+ assertEquals("The JSONata expression '$states.input.missing' specified for the field "+ + "'Choices[0]/Assign/x' returned nothing (undefined).", failure.jsonPath().getString("cause"));+ }++ @Test+ void aCatchClauseNamesItsOwnOutputUnderTheClauseIndex() throws Exception {+ // Real AWS names 'Catch[1]/Output/v': a clause's own Output is a field of the clause, and the+ // index is its position in Catch, not its position among the clauses that matched. Measured+ // with a real execution: TestState answers CAUGHT_ERROR and omits the output rather than+ // failing. Catch belongs to a Task, which AWS rejects on a Pass, so the state below fails on+ // its own Arguments and the clause catches that.+ String definition = """+ {+ "QueryLanguage": "JSONata",+ "StartAt": "Boom",+ "States": {+ "Boom": {+ "Type": "Task",+ "Resource": "arn:aws:states:::sqs:sendMessage",+ "Arguments": {+ "QueueUrl": "http://localhost:4566/000000000000/absent-queue",+ "MessageBody": "m",+ "MessageGroupId": "{% $states.input.missing %}"+ },+ "Catch": [+ {"ErrorEquals": ["States.Timeout"], "Next": "Caught"},+ {"ErrorEquals": ["States.QueryEvaluationError"],+ "Output": {"v": "{% $states.input.missing %}"}, "Next": "Caught"}+ ],+ "End": true+ },+ "Caught": {"Type": "Pass", "End": true}+ }+ }+ """;++ String smArn = createStateMachine("jsonata-catch-output-nothing-test", definition);+ Response failure = waitForExecutionFailure(startExecution(smArn, "{}"));++ assertEquals("States.QueryEvaluationError", failure.jsonPath().getString("error"));+ assertEquals("The JSONata expression '$states.input.missing' specified for the field "+ + "'Catch[1]/Output/v' returned nothing (undefined).", failure.jsonPath().getString("cause"));+ }++ @Test+ void waitSecondsReturningNothingFailsTheStateInsteadOfNotWaiting() throws Exception {+ // Real AWS names 'Seconds'. Before this guard the expression resolved to zero and the state+ // did not wait at all.+ String definition = """+ {+ "QueryLanguage": "JSONata",+ "StartAt": "Pause",+ "States": {+ "Pause": {"Type": "Wait", "Seconds": "{% $states.input.missing %}", "End": true}+ }+ }+ """;++ String smArn = createStateMachine("jsonata-wait-returned-nothing-test", definition);+ Response failure = waitForExecutionFailure(startExecution(smArn, "{}"));++ assertEquals("States.QueryEvaluationError", failure.jsonPath().getString("error"));+ assertEquals("The JSONata expression '$states.input.missing' specified for the field 'Seconds' "+ + "returned nothing (undefined).", failure.jsonPath().getString("cause"));+ }++ @Test+ void failErrorAndCauseReturningNothingFailTheStateWithTheQueryEvaluationError() throws Exception {+ // Real AWS names 'Error' and 'Cause'. The Fail state's own error is replaced by the+ // evaluation failure, so a Catch on States.QueryEvaluationError fires instead of one on the+ // error the definition meant to raise.+ String definition = """+ {+ "QueryLanguage": "JSONata",+ "StartAt": "Stop",+ "States": {+ "Stop": {"Type": "Fail", "Error": "%s", "Cause": "%s"}+ }+ }+ """;++ Response errorFailure = waitForExecutionFailure(startExecution(+ createStateMachine("jsonata-fail-error-returned-nothing-test",+ definition.formatted("{% $states.input.missing %}", "boom")), "{}"));+ assertEquals("States.QueryEvaluationError", errorFailure.jsonPath().getString("error"));+ assertEquals("The JSONata expression '$states.input.missing' specified for the field 'Error' "+ + "returned nothing (undefined).", errorFailure.jsonPath().getString("cause"));++ Response causeFailure = waitForExecutionFailure(startExecution(+ createStateMachine("jsonata-fail-cause-returned-nothing-test",+ definition.formatted("Boom", "{% $states.input.missing %}")), "{}"));+ assertEquals("States.QueryEvaluationError", causeFailure.jsonPath().getString("error"));+ assertEquals("The JSONata expression '$states.input.missing' specified for the field 'Cause' "+ + "returned nothing (undefined).", causeFailure.jsonPath().getString("cause"));+ }++ @Test+ void mapItemsReturningNothingFailsTheStateInsteadOfIteratingNothing() throws Exception {+ // Real AWS names 'Items'.+ String definition = """+ {+ "QueryLanguage": "JSONata",+ "StartAt": "Fan",+ "States": {+ "Fan": {+ "Type": "Map",+ "Items": "{% $states.input.missing %}",+ "ItemProcessor": {+ "StartAt": "P",+ "States": {"P": {"Type": "Pass", "End": true}}+ },+ "End": true+ }+ }+ }+ """;++ String smArn = createStateMachine("jsonata-map-items-returned-nothing-test", definition);+ Response failure = waitForExecutionFailure(startExecution(smArn, "{}"));++ assertEquals("States.QueryEvaluationError", failure.jsonPath().getString("error"));+ assertEquals("The JSONata expression '$states.input.missing' specified for the field 'Items' "+ + "returned nothing (undefined).", failure.jsonPath().getString("cause"));+ }++ @Test+ void mapMaxConcurrencyReturningNothingFailsTheStateNamingTheField() throws Exception {+ // Real AWS names 'MaxConcurrency'. Before this guard the undefined value reached the+ // non-negative-integer check and failed with Floci's own wording instead of AWS's.+ String definition = """+ {+ "QueryLanguage": "JSONata",+ "StartAt": "Fan",+ "States": {+ "Fan": {+ "Type": "Map",+ "Items": [1, 2],+ "MaxConcurrency": "{% $states.input.missing %}",+ "ItemProcessor": {+ "StartAt": "P",+ "States": {"P": {"Type": "Pass", "End": true}}+ },+ "End": true+ }+ }+ }+ """;++ String smArn = createStateMachine("jsonata-map-maxconcurrency-returned-nothing-test", definition);+ Response failure = waitForExecutionFailure(startExecution(smArn, "{}"));++ assertEquals("States.QueryEvaluationError", failure.jsonPath().getString("error"));+ assertEquals("The JSONata expression '$states.input.missing' specified for the field "+ + "'MaxConcurrency' returned nothing (undefined).", failure.jsonPath().getString("cause"));}@Test@@ -1298,10 +1670,9 @@ class StepFunctionsJsonataIntegrationTest {}@Test- void aWholeOutputThatReturnedNothingStaysReadableJson() throws Exception {- // AWS fails this state with States.QueryEvaluationError, which #2665 covers. Until then the- // execution succeeds, and what DescribeExecution hands back has to parse: an output field- // holding the empty string is not JSON any client can read.+ void aWholeOutputThatReturnedNothingFailsTheState() throws Exception {+ // Real AWS names the whole field, 'Output', with no path below it. There is no output to+ // serialize once the state fails, which is what the null this used to resolve to stood in for.String definition = """{"QueryLanguage": "JSONata",@@ -1309,7 +1680,7 @@ class StepFunctionsJsonataIntegrationTest {"States": {"Transform": {"Type": "Pass",- "Output": "{% $states.input.absent %}",+ "Output": "{% $states.input.missing %}","End": true}}@@ -1317,10 +1688,11 @@ class StepFunctionsJsonataIntegrationTest {""";String smArn = createStateMachine("jsonata-whole-output-nothing-test", definition);- String execArn = startExecution(smArn, "{}");- String output = waitForExecution(execArn);+ Response failure = waitForExecutionFailure(startExecution(smArn, "{}"));- assertTrue(objectMapper.readTree(output).isNull(), output);+ assertEquals("States.QueryEvaluationError", failure.jsonPath().getString("error"));+ assertEquals("The JSONata expression '$states.input.missing' specified for the field 'Output' "+ + "returned nothing (undefined).", failure.jsonPath().getString("cause"));}@Test