Light, fluffy, and always free - The AWS Local Emulator alternative
fix(stepfunctions): honor Wait Timestamp and TimestampPath (#4099)
Daniël van Ziel00cfcef8f947
diff --git a/docs/services/step-functions.md b/docs/services/step-functions.mdindex cf59569745..fd09eb7467 100644--- a/docs/services/step-functions.md+++ b/docs/services/step-functions.md@@ -205,8 +205,19 @@ workflows converge: the `framework-isComplete-task` throws on every not-yet-comp`JitterStrategy` supports `NONE` (the default) and `FULL`. `FULL` draws the delayuniformly between zero and the computed delay, as on AWS. One deviation. The delay-between attempts is capped at 30 seconds, the same cap Floci applies to `Wait` states,-so emulated runs stay fast.+between attempts is capped at `floci.services.stepfunctions.max-wait-seconds`+(default 30), the same ceiling Floci applies to `Wait` states, so emulated runs stay fast.++## Wait states++A `Wait` state honors `Seconds`, `SecondsPath`, `Timestamp`, and `TimestampPath`. The two+`Seconds` forms pause for the given number of seconds. The two `Timestamp` forms parse an+ISO-8601 instant and pause until it, or return promptly when it has already passed. An+unparseable timestamp fails the execution with `States.Runtime`. In a JSONata state machine,+`Seconds` and `Timestamp` each accept a literal or a JSONata expression that produces the value.++One deviation. Every pause is capped at `floci.services.stepfunctions.max-wait-seconds`+(default 30) so emulated runs stay fast, where AWS sleeps the full duration.## Timeouts@@ -629,6 +640,7 @@ no additional event is written.| Variable | Default | Description ||---|---|---|| `FLOCI_SERVICES_STEPFUNCTIONS_ENABLED` | `true` | Enable or disable the service |+| `FLOCI_SERVICES_STEPFUNCTIONS_MAX_WAIT_SECONDS` | `30` | Ceiling in seconds on a `Wait` state pause and a `Retry` backoff || `SFN_MOCK_CONFIG` | unset | Path to a Step Functions Local compatible mock configuration file (alias: `FLOCI_SERVICES_STEPFUNCTIONS_MOCK_CONFIG_FILE`) |## Examplesdiff --git a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.javaindex 5ea41b1c97..d2c43a87d9 100644--- a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java+++ b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java@@ -1765,6 +1765,13 @@ public interface EmulatorConfig {* compatibility with Step Functions Local.*/Optional<String> mockConfigFile();++ /**+ * Ceiling, in seconds, on a Wait state pause and a Retry backoff. AWS allows waits far longer+ * than this, but the emulator caps them to keep runs fast. Raise it to exercise longer waits.+ */+ @WithDefault("30")+ int maxWaitSeconds();}interface SwfServiceConfig {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.javaindex a8aa2fdcea..ee326284ed 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@@ -81,6 +81,8 @@ import java.net.URI;import java.nio.charset.StandardCharsets;import java.security.MessageDigest;import java.security.NoSuchAlgorithmException;+import java.time.Clock;+import java.time.Duration;import java.time.Instant;import java.time.ZoneOffset;import java.time.format.DateTimeFormatter;@@ -145,7 +147,6 @@ public class AslExecutor {}private static final Logger LOG = Logger.getLogger(AslExecutor.class);- private static final int MAX_WAIT_SECONDS = 30;// How long a Task waits for its token when the state declares no TimeoutSeconds. AWS lets it// run for a year; the emulator would rather free the worker thread.private static final int DEFAULT_TASK_TOKEN_TIMEOUT_SECONDS = 300;@@ -249,6 +250,10 @@ public class AslExecutor {private final WebClient webClient;private final EmulatorConfig config;private final CustomResourceLiveness customResourceLiveness;+ private final Clock clock;+ private final Sleeper sleeper;+ // Null in production, where the ceiling comes from the Step Functions config. Tests pin it.+ private final Integer maxWaitSecondsOverride;private final Map<String, ActiveMockExecution> activeMocks = new ConcurrentHashMap<>();private final ExecutorService executor = Executors.newCachedThreadPool(r -> {Thread t = new Thread(r, "sfn-executor");@@ -268,6 +273,26 @@ public class AslExecutor {ObjectMapper objectMapper, JsonataEvaluator jsonataEvaluator,Instance<StepFunctionsService> sfnService, EmulatorConfig config, Vertx vertx,CustomResourceLiveness customResourceLiveness) {+ this(lambdaExecutor, functionStore, dynamoDbService, dynamoDbJsonHandler,+ sqsJsonHandler, snsJsonHandler, cloudFormationHandler,+ ec2Service, s3Service, ecsService, ecsJsonHandler,+ eventBridgeHandler, schedulerService, schedulerController,+ objectMapper, jsonataEvaluator, sfnService, config, vertx, customResourceLiveness,+ Clock.systemUTC(), TimeUnit.NANOSECONDS::sleep, null);+ }++ AslExecutor(LambdaExecutorService lambdaExecutor, LambdaFunctionStore functionStore,+ DynamoDbService dynamoDbService, DynamoDbJsonHandler dynamoDbJsonHandler,+ SqsJsonHandler sqsJsonHandler, SnsJsonHandler snsJsonHandler,+ CloudFormationQueryHandler cloudFormationHandler,+ Ec2Service ec2Service, S3Service s3Service,+ EcsService ecsService, EcsJsonHandler ecsJsonHandler,+ EventBridgeHandler eventBridgeHandler, SchedulerService schedulerService,+ SchedulerController schedulerController,+ ObjectMapper objectMapper, JsonataEvaluator jsonataEvaluator,+ Instance<StepFunctionsService> sfnService, EmulatorConfig config, Vertx vertx,+ CustomResourceLiveness customResourceLiveness,+ Clock clock, Sleeper sleeper, Integer maxWaitSecondsOverride) {this.customResourceLiveness = customResourceLiveness;this.lambdaExecutor = lambdaExecutor;this.functionStore = functionStore;@@ -293,6 +318,9 @@ public class AslExecutor {this.jsonataEvaluator = jsonataEvaluator;this.sfnService = sfnService;this.config = config;+ this.clock = clock;+ this.sleeper = sleeper;+ this.maxWaitSecondsOverride = maxWaitSecondsOverride;if (vertx != null) {// This can be optimized further// TODO Set WebclientOptions useragent to Amazon|StepFunctions|HttpInvoke|{{{{region}}}}@@ -302,6 +330,12 @@ public class AslExecutor {}}+ /** Test seam: lets Wait states be exercised without real time passing. */+ @FunctionalInterface+ interface Sleeper {+ void sleep(long nanos) throws InterruptedException;+ }+@PreDestroyvoid stop() {executor.shutdownNow();@@ -627,7 +661,8 @@ public class AslExecutor {*/private void sleepBeforeRetry(JsonNode retrier, int attemptsUsed, long executionDeadlineNanos)throws InterruptedException {- var delaySeconds = retryDelaySeconds(retrier, attemptsUsed, ThreadLocalRandom.current().nextDouble());+ double delaySeconds = retryDelaySeconds(retrier, attemptsUsed, ThreadLocalRandom.current().nextDouble(),+ maxWaitSeconds());sleepOrTimeOutExecution((long) (delaySeconds * 1_000_000_000L), executionDeadlineNanos);}@@ -636,13 +671,13 @@ public class AslExecutor {* the retrier declares {@code JitterStrategy: FULL}, which draws the delay uniformly between* zero and the computed delay. Jitter applies after the caps, matching AWS.*/- static double retryDelaySeconds(JsonNode retrier, int attemptsUsed, double random) {+ static double retryDelaySeconds(JsonNode retrier, int attemptsUsed, double random, int maxWaitSeconds) {var interval = retrier.path("IntervalSeconds").asDouble(1.0);var backoffRate = retrier.path("BackoffRate").asDouble(2.0);var delaySeconds = interval * Math.pow(backoffRate, attemptsUsed - 1.0);- var maxDelay = retrier.path("MaxDelaySeconds").asDouble(MAX_WAIT_SECONDS);- // Like the Wait state, cap the delay at MAX_WAIT_SECONDS to keep emulated runs fast.- delaySeconds = Math.min(delaySeconds, Math.min(maxDelay, MAX_WAIT_SECONDS));+ double maxDelay = retrier.path("MaxDelaySeconds").asDouble(maxWaitSeconds);+ // Like the Wait state, cap the delay at the configured ceiling to keep emulated runs fast.+ delaySeconds = Math.min(delaySeconds, Math.min(maxDelay, maxWaitSeconds));if ("FULL".equals(retrier.path("JitterStrategy").asText(null))) {delaySeconds *= random;}@@ -2151,7 +2186,7 @@ public class AslExecutor {private StateResult executeWaitState(JsonNode stateDef, JsonNode input, boolean jsonata, JsonNode context,ObjectNode variables, long executionDeadlineNanos)throws InterruptedException {- int seconds = 0;+ long waitNanos = 0;JsonNode effectiveInput = input;if (jsonata) {if (stateDef.has("Seconds")) {@@ -2160,23 +2195,37 @@ public class AslExecutor {JsonNode statesVar = buildStatesVar(input, null, context);JsonNode result = jsonataEvaluator.evaluateField(secondsNode.asText(), "Seconds", statesVar, variables);- seconds = Math.min(result.asInt(), MAX_WAIT_SECONDS);+ waitNanos = secondsToNanos(result.asLong());+ } else {+ waitNanos = secondsToNanos(secondsNode.asLong());+ }+ } else if (stateDef.has("Timestamp")) {+ JsonNode timestampNode = stateDef.get("Timestamp");+ if (timestampNode.isTextual() && JsonataEvaluator.isExpression(timestampNode.asText())) {+ JsonNode statesVar = buildStatesVar(input, null, context);+ JsonNode result = jsonataEvaluator.evaluateField(+ timestampNode.asText(), "Timestamp", statesVar, variables);+ waitNanos = nanosUntil(result.asText());} else {- seconds = Math.min(secondsNode.asInt(), MAX_WAIT_SECONDS);+ waitNanos = nanosUntil(timestampNode.asText());}}} else {effectiveInput = applyInputPath(stateDef, input);if (stateDef.has("Seconds")) {- seconds = Math.min(stateDef.get("Seconds").asInt(), MAX_WAIT_SECONDS);+ waitNanos = secondsToNanos(stateDef.get("Seconds").asLong());} else if (stateDef.has("SecondsPath")) {JsonNode val = resolvePath(stateDef.get("SecondsPath").asText(), effectiveInput);- seconds = Math.min(val.asInt(), MAX_WAIT_SECONDS);+ waitNanos = secondsToNanos(val.asLong());+ } else if (stateDef.has("Timestamp")) {+ waitNanos = nanosUntil(stateDef.get("Timestamp").asText());+ } else if (stateDef.has("TimestampPath")) {+ JsonNode val = resolvePath(stateDef.get("TimestampPath").asText(), effectiveInput);+ waitNanos = nanosUntil(val.asText());}}- // Timestamp and TimestampPath: wait until that time or now, whichever is sooner- if (seconds > 0) {- sleepOrTimeOutExecution(TimeUnit.SECONDS.toNanos(seconds), executionDeadlineNanos);+ if (waitNanos > 0) {+ sleepOrTimeOutExecution(waitNanos, executionDeadlineNanos);}if (jsonata) {JsonNode output = applyJsonataOutput(stateDef, input, null, context, variables);@@ -2186,6 +2235,39 @@ public class AslExecutor {return new StateResult(output, stateDef.path("Next").asText(null));}+ private int maxWaitSeconds() {+ return maxWaitSecondsOverride != null+ ? maxWaitSecondsOverride+ : config.services().stepfunctions().maxWaitSeconds();+ }++ private long secondsToNanos(long seconds) {+ if (seconds <= 0) {+ return 0;+ }+ return TimeUnit.SECONDS.toNanos(Math.min(seconds, maxWaitSeconds()));+ }++ /**+ * Remaining pause for an absolute ASL {@code Timestamp}, floored at zero. The standard says to+ * sleep until that instant; the emulator caps the pause at the configured wait ceiling so a+ * future date cannot hold a worker for days. Tests raise that cap or inject a {@link Sleeper} to+ * exercise longer waits without real time passing.+ */+ private long nanosUntil(String timestamp) {+ Instant target;+ try {+ target = Instant.parse(timestamp);+ } catch (DateTimeParseException e) {+ throw new FailStateException("States.Runtime", "Invalid Timestamp: " + timestamp);+ }+ long remainingNanos = Duration.between(clock.instant(), target).toNanos();+ if (remainingNanos <= 0) {+ return 0;+ }+ return Math.min(remainingNanos, TimeUnit.SECONDS.toNanos(maxWaitSeconds()));+ }+/*** Sleeps out a pause the definition asked for, ending the execution instead when the state* machine's {@code TimeoutSeconds} budget runs out first. The two pauses long enough to@@ -2196,10 +2278,10 @@ public class AslExecutor {throws InterruptedException {long remainingNanos = executionDeadlineNanos - System.nanoTime();if (pauseNanos < remainingNanos) {- TimeUnit.NANOSECONDS.sleep(pauseNanos);+ sleeper.sleep(pauseNanos);return;}- TimeUnit.NANOSECONDS.sleep(Math.max(remainingNanos, 0));+ sleeper.sleep(Math.max(remainingNanos, 0));throw new ExecutionTimedOutException();}diff --git a/src/main/resources/application.yml b/src/main/resources/application.ymlindex e9dcbb1e86..addab7015d 100644--- a/src/main/resources/application.yml+++ b/src/main/resources/application.yml@@ -461,6 +461,7 @@ floci:enabled: trueallow-plaintext-http: falsemock-config-file: ${SFN_MOCK_CONFIG:}+ max-wait-seconds: 30swf:enabled: truetimeout-sweep-enabled: truediff --git a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorBranchHistoryEventsTest.java b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorBranchHistoryEventsTest.javaindex 1001017890..f6244ec5aa 100644--- a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorBranchHistoryEventsTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorBranchHistoryEventsTest.java@@ -31,6 +31,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.assertFalse;import static org.junit.jupiter.api.Assertions.assertNull;import static org.junit.jupiter.api.Assertions.assertTrue;+import static org.mockito.Mockito.RETURNS_DEEP_STUBS;import static org.mockito.Mockito.mock;import static org.mockito.Mockito.when;@@ -61,6 +62,8 @@ class AslExecutorBranchHistoryEventsTest {void setUp() {Instance<StepFunctionsService> sfnService = mock(Instance.class);when(sfnService.get()).thenReturn(mock(StepFunctionsService.class));+ EmulatorConfig config = mock(EmulatorConfig.class, RETURNS_DEEP_STUBS);+ when(config.services().stepfunctions().maxWaitSeconds()).thenReturn(30);executor = new AslExecutor(mock(LambdaExecutorService.class),mock(LambdaFunctionStore.class),@@ -77,7 +80,7 @@ class AslExecutorBranchHistoryEventsTest {mock(io.github.hectorvent.floci.services.scheduler.SchedulerController.class),objectMapper,new JsonataEvaluator(objectMapper),- sfnService, mock(EmulatorConfig.class), vertx,+ sfnService, config, vertx,mock(io.github.hectorvent.floci.core.common.CustomResourceLiveness.class));}diff --git a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorMockedResponsesTest.java b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorMockedResponsesTest.javaindex cfb549bb3d..bd200cf8da 100644--- a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorMockedResponsesTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorMockedResponsesTest.java@@ -28,8 +28,10 @@ import java.util.Map;import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.assertTrue;+import static org.mockito.Mockito.RETURNS_DEEP_STUBS;import static org.mockito.Mockito.mock;import static org.mockito.Mockito.verifyNoInteractions;+import static org.mockito.Mockito.when;@QuarkusTestclass AslExecutorMockedResponsesTest {@@ -48,6 +50,8 @@ class AslExecutorMockedResponsesTest {@BeforeEachvoid setUp() {lambdaExecutor = mock(LambdaExecutorService.class);+ EmulatorConfig config = mock(EmulatorConfig.class, RETURNS_DEEP_STUBS);+ when(config.services().stepfunctions().maxWaitSeconds()).thenReturn(30);executor = new AslExecutor(lambdaExecutor,@@ -65,7 +69,7 @@ class AslExecutorMockedResponsesTest {mock(io.github.hectorvent.floci.services.scheduler.SchedulerController.class),objectMapper,new JsonataEvaluator(objectMapper),- mock(Instance.class), mock(EmulatorConfig.class), vertx, null);+ mock(Instance.class), config, vertx, null);}@Testdiff --git a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorNestedStartExecutionTest.java b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorNestedStartExecutionTest.javaindex a7ac9db923..489c82e297 100644--- a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorNestedStartExecutionTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorNestedStartExecutionTest.java@@ -30,6 +30,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.assertNull;import static org.junit.jupiter.api.Assertions.assertTrue;import static org.mockito.ArgumentMatchers.any;+import static org.mockito.Mockito.RETURNS_DEEP_STUBS;import static org.mockito.Mockito.doThrow;import static org.mockito.Mockito.mock;import static org.mockito.Mockito.never;@@ -65,6 +66,9 @@ class AslExecutorNestedStartExecutionTest {childExec.setStartDate(1.0);when(childSfn.startExecution(any(), any(), any(), any())).thenReturn(childExec);+ EmulatorConfig config = mock(EmulatorConfig.class, RETURNS_DEEP_STUBS);+ when(config.services().stepfunctions().maxWaitSeconds()).thenReturn(30);+executor = new AslExecutor(mock(LambdaExecutorService.class),mock(LambdaFunctionStore.class),@@ -82,7 +86,7 @@ class AslExecutorNestedStartExecutionTest {mapper,new JsonataEvaluator(mapper),sfnInstance,- mock(EmulatorConfig.class),+ config,null, null);}diff --git a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorRetryTest.java b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorRetryTest.javaindex 1381a17006..474fa64ea1 100644--- a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorRetryTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorRetryTest.java@@ -66,6 +66,14 @@ class AslExecutorRetryTest {flakyFunction.setFunctionArn(FLAKY_FUNCTION_ARN);when(functionStore.get(REGION, FLAKY_FUNCTION_NAME)).thenReturn(Optional.of(flakyFunction));+ EmulatorConfig config = mock(EmulatorConfig.class);+ EmulatorConfig.ServicesConfig servicesConfig = mock(EmulatorConfig.ServicesConfig.class);+ EmulatorConfig.StepFunctionsServiceConfig stepFunctionsConfig =+ mock(EmulatorConfig.StepFunctionsServiceConfig.class);+ when(config.services()).thenReturn(servicesConfig);+ when(servicesConfig.stepfunctions()).thenReturn(stepFunctionsConfig);+ when(stepFunctionsConfig.maxWaitSeconds()).thenReturn(30);+executor = new AslExecutor(lambdaExecutor,functionStore,@@ -82,7 +90,7 @@ class AslExecutorRetryTest {mock(io.github.hectorvent.floci.services.scheduler.SchedulerController.class),objectMapper,new JsonataEvaluator(objectMapper),- mock(Instance.class), mock(EmulatorConfig.class), vertx, null);+ mock(Instance.class), config, vertx, null);}@Test@@ -399,8 +407,19 @@ class AslExecutorRetryTest {assertEquals(10.0, delay("{\"IntervalSeconds\": 10, \"BackoffRate\": 1.0, \"JitterStrategy\": \"NONE\"}", 1, 0.5));}+ @Test+ void theDelayCapIsTheConfiguredWaitCeiling() throws Exception {+ String retrier = "{\"IntervalSeconds\": 100, \"BackoffRate\": 2.0}";+ assertEquals(30.0, delay(retrier, 2, 0.5));+ assertEquals(120.0, delay(retrier, 2, 0.5, 120));+ }+private double delay(String retrierJson, int attemptsUsed, double random) throws Exception {- return AslExecutor.retryDelaySeconds(objectMapper.readTree(retrierJson), attemptsUsed, random);+ return delay(retrierJson, attemptsUsed, random, 30);+ }++ private double delay(String retrierJson, int attemptsUsed, double random, int maxWaitSeconds) throws Exception {+ return AslExecutor.retryDelaySeconds(objectMapper.readTree(retrierJson), attemptsUsed, random, maxWaitSeconds);}private void failOnceThenSucceed() {diff --git a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorTaskHistoryEventsTest.java b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorTaskHistoryEventsTest.javaindex c744a8492b..3d050de6e4 100644--- a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorTaskHistoryEventsTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorTaskHistoryEventsTest.java@@ -35,6 +35,7 @@ import static org.junit.jupiter.api.Assertions.assertFalse;import static org.junit.jupiter.api.Assertions.assertNull;import static org.mockito.ArgumentMatchers.any;import static org.mockito.ArgumentMatchers.eq;+import static org.mockito.Mockito.RETURNS_DEEP_STUBS;import static org.mockito.Mockito.mock;import static org.mockito.Mockito.when;@@ -62,6 +63,8 @@ class AslExecutorTaskHistoryEventsTest {void setUp() {lambdaExecutor = mock(LambdaExecutorService.class);functionStore = mock(LambdaFunctionStore.class);+ EmulatorConfig config = mock(EmulatorConfig.class, RETURNS_DEEP_STUBS);+ when(config.services().stepfunctions().maxWaitSeconds()).thenReturn(30);executor = new AslExecutor(lambdaExecutor,@@ -79,7 +82,7 @@ class AslExecutorTaskHistoryEventsTest {mock(io.github.hectorvent.floci.services.scheduler.SchedulerController.class),objectMapper,new JsonataEvaluator(objectMapper),- mock(Instance.class), mock(EmulatorConfig.class), vertx,+ mock(Instance.class), config, vertx,mock(io.github.hectorvent.floci.core.common.CustomResourceLiveness.class));}diff --git a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorWaitStateTest.java b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorWaitStateTest.javanew file mode 100644index 0000000000..1fcfa145df--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorWaitStateTest.java@@ -0,0 +1,230 @@+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.core.common.CustomResourceLiveness;+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.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.Test;++import java.time.Clock;+import java.time.Instant;+import java.time.ZoneOffset;+import java.util.ArrayList;+import java.util.List;+import java.util.concurrent.TimeUnit;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertTrue;+import static org.mockito.Mockito.mock;++/**+ * Wait states must honor {@code Seconds}, {@code SecondsPath}, {@code Timestamp}, and+ * {@code TimestampPath}. Timestamp support was missing: the state fell through with no pause and+ * ran early. With no {@code TimeoutSeconds}, the execution deadline is unbounded, so the injected+ * {@link AslExecutor.Sleeper} is the only thing that records the requested pause.+ */+class AslExecutorWaitStateTest {++ private static final Instant NOW = Instant.parse("2026-01-01T00:00:00Z");++ @Test+ void secondsAboveThirtyAreHonoredWhenTheCapIsRaised() {+ RecordingSleeper sleeper = new RecordingSleeper();+ AslExecutor executor = newExecutor(sleeper, 120);++ Execution execution = run(executor, """+ {"StartAt":"W","States":{"W":{"Type":"Wait","Seconds":45,"End":true}}}+ """, "{}");++ assertEquals("SUCCEEDED", execution.getStatus());+ assertEquals(TimeUnit.SECONDS.toNanos(45), sleeper.singleSleep());+ }++ @Test+ void secondsAreCappedAtTheConfiguredMaximum() {+ RecordingSleeper sleeper = new RecordingSleeper();+ AslExecutor executor = newExecutor(sleeper, 10);++ run(executor, """+ {"StartAt":"W","States":{"W":{"Type":"Wait","Seconds":100,"End":true}}}+ """, "{}");++ assertEquals(TimeUnit.SECONDS.toNanos(10), sleeper.singleSleep());+ }++ @Test+ void absoluteTimestampWaitsUntilThatInstant() {+ RecordingSleeper sleeper = new RecordingSleeper();+ AslExecutor executor = newExecutor(sleeper, 120);+ Instant wake = NOW.plusSeconds(45);++ run(executor, """+ {"StartAt":"W","States":{"W":{"Type":"Wait","Timestamp":"%s","End":true}}}+ """.formatted(wake), "{}");++ assertEquals(TimeUnit.SECONDS.toNanos(45), sleeper.singleSleep());+ }++ @Test+ void timestampPathResolvesTheWakeInstant() {+ RecordingSleeper sleeper = new RecordingSleeper();+ AslExecutor executor = newExecutor(sleeper, 120);+ Instant wake = NOW.plusSeconds(20);++ run(executor, """+ {"StartAt":"W","States":{"W":{"Type":"Wait","TimestampPath":"$.wake","End":true}}}+ """, "{\"wake\":\"" + wake + "\"}");++ assertEquals(TimeUnit.SECONDS.toNanos(20), sleeper.singleSleep());+ }++ @Test+ void jsonataLiteralTimestampWaitsUntilThatInstant() {+ RecordingSleeper sleeper = new RecordingSleeper();+ AslExecutor executor = newExecutor(sleeper, 120);+ Instant wake = NOW.plusSeconds(45);++ run(executor, """+ {"QueryLanguage":"JSONata","StartAt":"W","States":{"W":{"Type":"Wait","Timestamp":"%s","End":true}}}+ """.formatted(wake), "{}");++ assertEquals(TimeUnit.SECONDS.toNanos(45), sleeper.singleSleep());+ }++ @Test+ void jsonataTimestampExpressionResolvesTheWakeInstant() {+ RecordingSleeper sleeper = new RecordingSleeper();+ AslExecutor executor = newExecutor(sleeper, 120);+ Instant wake = NOW.plusSeconds(20);++ run(executor, """+ {"QueryLanguage":"JSONata","StartAt":"W","States":{"W":{"Type":"Wait","Timestamp":"{% $states.input.wake %}","End":true}}}+ """, "{\"wake\":\"" + wake + "\"}");++ assertEquals(TimeUnit.SECONDS.toNanos(20), sleeper.singleSleep());+ }++ @Test+ void timestampInThePastDoesNotSleep() {+ RecordingSleeper sleeper = new RecordingSleeper();+ AslExecutor executor = newExecutor(sleeper, 120);+ Instant past = NOW.minusSeconds(10);++ Execution execution = run(executor, """+ {"StartAt":"W","States":{"W":{"Type":"Wait","Timestamp":"%s","End":true}}}+ """.formatted(past), "{}");++ assertEquals("SUCCEEDED", execution.getStatus());+ assertTrue(sleeper.sleeps().isEmpty());+ }++ @Test+ void timestampExactlyNowDoesNotSleep() {+ RecordingSleeper sleeper = new RecordingSleeper();+ AslExecutor executor = newExecutor(sleeper, 120);++ run(executor, """+ {"StartAt":"W","States":{"W":{"Type":"Wait","Timestamp":"%s","End":true}}}+ """.formatted(NOW), "{}");++ assertTrue(sleeper.sleeps().isEmpty());+ }++ @Test+ void invalidTimestampFailsTheExecution() {+ RecordingSleeper sleeper = new RecordingSleeper();+ AslExecutor executor = newExecutor(sleeper, 120);++ Execution execution = run(executor, """+ {"StartAt":"W","States":{"W":{"Type":"Wait","Timestamp":"not-a-timestamp","End":true}}}+ """, "{}");++ assertEquals("FAILED", execution.getStatus());+ assertEquals("States.Runtime", execution.getError());+ assertTrue(sleeper.sleeps().isEmpty());+ }++ private static AslExecutor newExecutor(RecordingSleeper sleeper, int maxWaitSeconds) {+ ObjectMapper objectMapper = new ObjectMapper();+ return new AslExecutor(+ mock(LambdaExecutorService.class),+ mock(LambdaFunctionStore.class),+ mock(DynamoDbService.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),+ mock(Instance.class),+ mock(EmulatorConfig.class),+ null,+ mock(CustomResourceLiveness.class),+ Clock.fixed(NOW, ZoneOffset.UTC),+ sleeper,+ maxWaitSeconds);+ }++ private static Execution run(AslExecutor executor, String definition, String input) {+ StateMachine stateMachine = new StateMachine();+ stateMachine.setName("wait-state-test");+ stateMachine.setStateMachineArn(+ "arn:aws:states:us-east-1:000000000000:stateMachine:wait-state-test");+ stateMachine.setDefinition(definition);++ Execution execution = new Execution();+ execution.setName("wait-exec");+ execution.setExecutionArn(+ "arn:aws:states:us-east-1:000000000000:execution:wait-state-test:wait-exec");+ execution.setStateMachineArn(stateMachine.getStateMachineArn());+ execution.setInput(input);++ List<HistoryEvent> history = new ArrayList<>();+ executor.executeSync(stateMachine, execution, history, (updated, events) -> {+ });+ return execution;+ }++ private static final class RecordingSleeper implements AslExecutor.Sleeper {++ private final List<Long> sleeps = new ArrayList<>();++ @Override+ public void sleep(long nanos) {+ sleeps.add(nanos);+ }++ List<Long> sleeps() {+ return sleeps;+ }++ long singleSleep() {+ assertEquals(1, sleeps.size(), "expected exactly one recorded sleep");+ return sleeps.getFirst();+ }+ }+}\ No newline at end of filediff --git a/src/test/resources/application.yml b/src/test/resources/application.ymlindex c264c2014f..5909b86912 100644--- a/src/test/resources/application.yml+++ b/src/test/resources/application.yml@@ -249,6 +249,7 @@ floci:enabled: trueallow-plaintext-http: truemock-config-file: ${SFN_MOCK_CONFIG:src/test/resources/fixtures/sfn-mock-config.json}+ max-wait-seconds: 30swf:enabled: truetimeout-sweep-enabled: true