Light, fluffy, and always free - The AWS Local Emulator alternative
feat(eventbridge): start Step Functions targets (#4006)
vamsiak957542d1723e
diff --git a/docs/services/eventbridge.md b/docs/services/eventbridge.mdindex 6fcce827b9..6eda40d57e 100644--- a/docs/services/eventbridge.md+++ b/docs/services/eventbridge.md@@ -119,10 +119,18 @@ aws events put-targets \--endpoint-url $AWS_ENDPOINT_URL```+## Step Functions Targets++A matching rule can start an unqualified Step Functions state machine ARN. The target supports the+full event as the default input, plus `Input`, `InputPath`, and `InputTransformer`. Floci resolves+the state machine from the account and region in its ARN.++State machine aliases and versions are not supported as EventBridge targets.+## Current Behavior- `PutEvents` reports success once the source bus accepts an event, so target delivery failures surface only as a `WARN` in the Floci logs.- A `Detail` forwarded to an event bus must be a JSON object, as in AWS; anything else is dropped, including an `InputPath` selecting a scalar such as `$.detail.orderId` or an envelope carrying `"detail": null`.- A bus ARN naming another account is forwarded under that account, so the target bus and its rules resolve there.-- Onward delivery from that bus follows each target type: SQS resolves cross-account, while Lambda, SNS, Batch and Firehose resolve in the caller's account.+- Onward delivery from that bus follows each target type: SQS and Step Functions resolve cross-account, while Lambda, SNS, Batch and Firehose resolve in the caller's account.- An event is forwarded between buses only once, matching AWS: a bus that received an event from another bus does not forward it on to a third. The second hop is dropped with only a `WARN` rather than reported to the caller.diff --git a/src/main/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeInvoker.java b/src/main/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeInvoker.javaindex 5a929a9bb2..e5c6749bd0 100644--- a/src/main/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeInvoker.java+++ b/src/main/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeInvoker.java@@ -6,6 +6,7 @@ import com.fasterxml.jackson.databind.node.MissingNode;import io.github.hectorvent.floci.config.EmulatorConfig;import io.github.hectorvent.floci.core.common.AwsArnUtils;import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.core.common.RequestScopes;import io.github.hectorvent.floci.services.batch.BatchService;import io.github.hectorvent.floci.services.ecs.EcsJsonHandler;import io.github.hectorvent.floci.services.ecs.EcsService;@@ -20,6 +21,7 @@ import io.github.hectorvent.floci.services.lambda.LambdaService;import io.github.hectorvent.floci.services.lambda.model.InvocationType;import io.github.hectorvent.floci.services.sns.SnsService;import io.github.hectorvent.floci.services.sqs.SqsService;+import io.github.hectorvent.floci.services.stepfunctions.StepFunctionsService;import jakarta.enterprise.context.ApplicationScoped;import jakarta.inject.Inject;import org.jboss.logging.Logger;@@ -47,6 +49,7 @@ public class EventBridgeInvoker {private final EventBridgeService eventBridgeService;private final EcsService ecsService;private final EcsJsonHandler ecsJsonHandler;+ private final StepFunctionsService stepFunctionsService;private final RegionResolver regionResolver;private final ObjectMapper objectMapper;private final String baseUrl;@@ -60,6 +63,7 @@ public class EventBridgeInvoker {EventBridgeService eventBridgeService,EcsService ecsService,EcsJsonHandler ecsJsonHandler,+ StepFunctionsService stepFunctionsService,RegionResolver regionResolver,ObjectMapper objectMapper,EmulatorConfig config) {@@ -71,6 +75,7 @@ public class EventBridgeInvoker {this.eventBridgeService = eventBridgeService;this.ecsService = ecsService;this.ecsJsonHandler = ecsJsonHandler;+ this.stepFunctionsService = stepFunctionsService;this.regionResolver = regionResolver;this.objectMapper = objectMapper;this.baseUrl = config.baseUrl();@@ -83,7 +88,7 @@ public class EventBridgeInvoker {EmulatorConfig config) {this(lambdaService, sqsService, snsService,null /* batch */, null /* firehose */, null /* eventBridge */, null /* ecs */,- null /* ecsJsonHandler */, null /* regionResolver */, objectMapper, config);+ null /* ecsJsonHandler */, null /* stepFunctions */, null /* regionResolver */, objectMapper, config);}public void invokeTarget(Target target, String eventJson, String region) {@@ -156,6 +161,12 @@ public class EventBridgeInvoker {firehoseService.putRecord(streamArn.accountId(), streamArn.region(), streamName, record);}LOG.debugv("EventBridge delivered to Firehose: {0}", arn);+ } else if (isStateMachineArn(arn)) {+ String targetRegion = extractRegionFromArn(arn, region);+ String targetAccount = AwsArnUtils.parse(arn).accountId();+ RequestScopes.runAs(targetAccount,+ () -> stepFunctionsService.startExecution(arn, null, payload, targetRegion));+ LOG.debugv("EventBridge started Step Functions execution: {0}", arn);} else if (arn.contains(":events:") && arn.contains(":event-bus/")) {if (eventBridgeService == null) {LOG.warnv("EventBridge event-bus target missing EventBridge service: {0}", arn);@@ -424,4 +435,13 @@ public class EventBridgeInvoker {private static String extractRegionFromArn(String arn, String defaultRegion) {return AwsArnUtils.regionOrDefault(arn, defaultRegion);}++ private static boolean isStateMachineArn(String arn) {+ if (!AwsArnUtils.isArnFor(arn, "states")) {+ return false;+ }+ String resource = AwsArnUtils.parse(arn).resource();+ String prefix = "stateMachine:";+ return resource.startsWith(prefix) && resource.indexOf(':', prefix.length()) < 0;+ }}diff --git a/src/test/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeInvokerTest.java b/src/test/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeInvokerTest.javaindex c7d90bd9a2..28fc398a0d 100644--- a/src/test/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeInvokerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeInvokerTest.java@@ -22,6 +22,7 @@ import io.github.hectorvent.floci.services.lambda.LambdaService;import io.github.hectorvent.floci.services.lambda.model.InvocationType;import io.github.hectorvent.floci.services.sns.SnsService;import io.github.hectorvent.floci.services.sqs.SqsService;+import io.github.hectorvent.floci.services.stepfunctions.StepFunctionsService;import org.junit.jupiter.api.BeforeEach;import org.junit.jupiter.api.Test;import org.mockito.ArgumentCaptor;@@ -45,6 +46,7 @@ class EventBridgeInvokerTest {private FirehoseService firehoseService;private EventBridgeService eventBridgeService;private EcsService ecsService;+ private StepFunctionsService stepFunctionsService;private RegionResolver regionResolver;@BeforeEach@@ -56,6 +58,7 @@ class EventBridgeInvokerTest {firehoseService = mock(FirehoseService.class);eventBridgeService = mock(EventBridgeService.class);ecsService = mock(EcsService.class);+ stepFunctionsService = mock(StepFunctionsService.class);regionResolver = mock(RegionResolver.class);when(regionResolver.getAccountId()).thenReturn("000000000000");when(eventBridgeService.putEvents(anyList(), anyString(), any()))@@ -73,12 +76,58 @@ class EventBridgeInvokerTest {ecsService,new EcsJsonHandler(ecsService, new ObjectMapper(),new HostVolumePolicy(emulatorConfig)),+ stepFunctionsService,regionResolver,new ObjectMapper(),emulatorConfig);}+ @Test+ void invokeTarget_stateMachineTargetStartsExecutionWithDefaultEvent() {+ String arn = "arn:aws:states:eu-west-1:111122223333:stateMachine:orders";+ String event = "{\"detail\":{\"orderId\":\"o-42\"}}";+ Target target = new Target("id1", arn, null, null);++ invoker.invokeTarget(target, event, "us-east-1");++ verify(stepFunctionsService).startExecution(arn, null, event, "eu-west-1");+ }++ @Test+ void invokeTarget_stateMachineTargetUsesExplicitInput() {+ String arn = "arn:aws:states:us-east-1:000000000000:stateMachine:orders";+ Target target = new Target("id1", arn, "{\"source\":\"override\"}", null);++ invoker.invokeTarget(target, "{\"ignored\":true}", "us-east-1");++ verify(stepFunctionsService).startExecution(+ arn, null, "{\"source\":\"override\"}", "us-east-1");+ }++ @Test+ void invokeTarget_qualifiedStateMachineTargetRemainsUnsupported() {+ String versionArn = "arn:aws:states:us-east-1:000000000000:stateMachine:orders:1";+ String aliasArn = "arn:aws:states:us-east-1:000000000000:stateMachine:orders:PROD";++ invoker.invokeTarget(new Target("version", versionArn, "{}", null), "{}", "us-east-1");+ invoker.invokeTarget(new Target("alias", aliasArn, "{}", null), "{}", "us-east-1");++ verifyNoInteractions(stepFunctionsService);+ }++ @Test+ void invokeTarget_stateMachineStartFailureDoesNotEscapeDelivery() {+ String arn = "arn:aws:states:us-east-1:000000000000:stateMachine:missing";+ when(stepFunctionsService.startExecution(arn, null, "{}", "us-east-1"))+ .thenThrow(new IllegalStateException("missing state machine"));++ assertDoesNotThrow(() -> invoker.invokeTarget(+ new Target("id1", arn, "{}", null), "{\"ignored\":true}", "us-east-1"));++ verify(stepFunctionsService).startExecution(arn, null, "{}", "us-east-1");+ }+@Testvoid invokeTarget_lambdaTargetPreservesArnAccount() {String arn = "arn:aws:lambda:ap-south-1:100000000012:function:cross-account-function";diff --git a/src/test/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeStepFunctionsIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeStepFunctionsIntegrationTest.javanew file mode 100644index 0000000000..2941717bcd--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeStepFunctionsIntegrationTest.java@@ -0,0 +1,158 @@+package io.github.hectorvent.floci.services.eventbridge;++import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import io.github.hectorvent.floci.core.common.RequestScopes;+import io.github.hectorvent.floci.services.eventbridge.model.InputTransformer;+import io.github.hectorvent.floci.services.eventbridge.model.RuleState;+import io.github.hectorvent.floci.services.eventbridge.model.Target;+import io.github.hectorvent.floci.services.stepfunctions.StepFunctionsService;+import io.github.hectorvent.floci.services.stepfunctions.model.Execution;+import io.github.hectorvent.floci.services.stepfunctions.model.StateMachine;+import io.quarkus.test.junit.QuarkusTest;+import jakarta.inject.Inject;+import org.junit.jupiter.api.AfterEach;+import org.junit.jupiter.api.Test;++import java.util.ArrayList;+import java.util.List;+import java.util.Map;+import java.util.UUID;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertNotNull;++@QuarkusTest+class EventBridgeStepFunctionsIntegrationTest {++ private static final String SOURCE_REGION = "us-east-1";+ private static final String TARGET_REGION = "eu-west-1";+ private static final String TARGET_ACCOUNT = "111122223333";+ private static final String ROLE_ARN = "arn:aws:iam::111122223333:role/eventbridge-role";+ private static final String DEFINITION =+ "{\"StartAt\":\"Pass\",\"States\":{\"Pass\":{\"Type\":\"Pass\",\"End\":true}}}";++ @Inject+ EventBridgeService eventBridgeService;++ @Inject+ StepFunctionsService stepFunctionsService;++ @Inject+ ObjectMapper objectMapper;++ private final List<String> ruleNames = new ArrayList<>();+ private final List<String> stateMachineArns = new ArrayList<>();++ @AfterEach+ void cleanUp() {+ for (String ruleName : ruleNames) {+ List<String> targetIds = eventBridgeService.listTargetsByRule(ruleName, null, SOURCE_REGION)+ .stream()+ .map(Target::getId)+ .toList();+ eventBridgeService.removeTargets(ruleName, null, targetIds, SOURCE_REGION);+ eventBridgeService.deleteRule(ruleName, null, SOURCE_REGION);+ }+ RequestScopes.runAs(TARGET_ACCOUNT, () -> {+ for (String stateMachineArn : stateMachineArns) {+ stepFunctionsService.deleteStateMachine(stateMachineArn);+ }+ });+ }++ @Test+ void matchingRuleStartsStateMachinesWithEachInputMode() throws Exception {+ String defaultArn = createStateMachine("default");+ String explicitArn = createStateMachine("explicit");+ String pathArn = createStateMachine("path");+ String transformerArn = createStateMachine("transformer");+ String ruleName = createRule("input-modes", "{\"source\":[\"orders.created\"]}");++ Target defaultTarget = new Target("default", defaultArn, null, null);+ Target explicitTarget = new Target("explicit", explicitArn, "{\"mode\":\"explicit\"}", null);+ Target pathTarget = new Target("path", pathArn, null, "$.detail");+ Target transformerTarget = new Target("transformer", transformerArn, null, null);+ transformerTarget.setInputTransformer(new InputTransformer(+ Map.of("orderId", "$.detail.orderId"), "{\"order\":\"<orderId>\"}"));+ assertEquals(0, eventBridgeService.putTargets(+ ruleName, null,+ List.of(defaultTarget, explicitTarget, pathTarget, transformerTarget),+ SOURCE_REGION));++ EventBridgeService.PutEventsResult unmatched = eventBridgeService.putEvents(List.of(Map.of(+ "Source", "orders.ignored",+ "DetailType", "OrderCreated",+ "Detail", "{\"orderId\":\"o-42\"}")), SOURCE_REGION);+ assertEquals(0, unmatched.failedCount());+ assertEquals(0, executions(defaultArn).size());+ assertEquals(0, executions(explicitArn).size());+ assertEquals(0, executions(pathArn).size());+ assertEquals(0, executions(transformerArn).size());++ EventBridgeService.PutEventsResult matched = eventBridgeService.putEvents(List.of(Map.of(+ "Source", "orders.created",+ "DetailType", "OrderCreated",+ "Detail", "{\"orderId\":\"o-42\",\"total\":19}")), SOURCE_REGION);+ assertEquals(0, matched.failedCount());+ assertNotNull(matched.entries().getFirst().get("EventId"));++ Execution defaultExecution = onlyExecution(defaultArn);+ JsonNode defaultInput = objectMapper.readTree(defaultExecution.getInput());+ assertEquals("orders.created", defaultInput.path("source").asText());+ assertEquals("OrderCreated", defaultInput.path("detail-type").asText());+ assertEquals("o-42", defaultInput.path("detail").path("orderId").asText());+ assertEquals(SOURCE_REGION, defaultInput.path("region").asText());+ assertEquals("{\"mode\":\"explicit\"}", onlyExecution(explicitArn).getInput());+ assertEquals("{\"orderId\":\"o-42\",\"total\":19}", onlyExecution(pathArn).getInput());+ assertEquals("{\"order\":\"o-42\"}", onlyExecution(transformerArn).getInput());+ }++ @Test+ void startFailureDoesNotRejectAcceptedEvent() {+ String ruleName = createRule("missing-target", "{\"source\":[\"orders.failed\"]}");+ Target missingTarget = new Target(+ "missing",+ "arn:aws:states:eu-west-1:111122223333:stateMachine:missing",+ "{}",+ null);+ assertEquals(0, eventBridgeService.putTargets(+ ruleName, null, List.of(missingTarget), SOURCE_REGION));++ EventBridgeService.PutEventsResult result = eventBridgeService.putEvents(List.of(Map.of(+ "Source", "orders.failed",+ "DetailType", "OrderCreated",+ "Detail", "{}")), SOURCE_REGION);++ assertEquals(0, result.failedCount());+ assertNotNull(result.entries().getFirst().get("EventId"));+ }++ private String createStateMachine(String suffix) {+ String name = "eventbridge-" + suffix + "-" + UUID.randomUUID();+ StateMachine stateMachine = RequestScopes.callAs(TARGET_ACCOUNT,+ () -> stepFunctionsService.createStateMachine(+ name, DEFINITION, ROLE_ARN, "STANDARD", TARGET_REGION, Map.of()));+ stateMachineArns.add(stateMachine.getStateMachineArn());+ return stateMachine.getStateMachineArn();+ }++ private String createRule(String suffix, String eventPattern) {+ String name = "eventbridge-sfn-" + suffix + "-" + UUID.randomUUID();+ eventBridgeService.putRule(+ name, null, eventPattern, null, RuleState.ENABLED, null, null, null, SOURCE_REGION);+ ruleNames.add(name);+ return name;+ }++ private List<Execution> executions(String stateMachineArn) {+ return RequestScopes.callAs(+ TARGET_ACCOUNT, () -> stepFunctionsService.listExecutions(stateMachineArn));+ }++ private Execution onlyExecution(String stateMachineArn) {+ List<Execution> executions = executions(stateMachineArn);+ assertEquals(1, executions.size());+ return executions.getFirst();+ }+}