Skip to content

armgit / floci

Public Imported from GitHub
0

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

feat(eventbridge): deliver events to event-bus targets (#1814)

Tim Gibson50fe67dde668
diff --git a/docs/services/eventbridge.md b/docs/services/eventbridge.md
index 8638cf5bf0..c0d1943604 100644
--- a/docs/services/eventbridge.md
+++ b/docs/services/eventbridge.md
@@ -98,3 +98,26 @@ aws events put-events \
--entries '[{"Source":"myapp","DetailType":"test","Detail":"{}"}]' \
--endpoint-url $AWS_ENDPOINT_URL
```
+
+## Event Bus Targets
+
+A rule can target another event bus by ARN: the event is republished there, and that bus's own rules evaluate it and fan out normally. `Source`, `DetailType`, `Resources` and the originating `account`/`region` carry over, and each hop gets a new event id.
+
+```bash
+aws events put-targets \
+ --rule order-placed-rule \
+ --event-bus-name my-bus \
+ --targets '[{
+ "Id": "forward-to-domain-bus",
+ "Arn": "arn:aws:events:us-east-1:000000000000:event-bus/domain-bus"
+ }]' \
+ --endpoint-url $AWS_ENDPOINT_URL
+```
+
+## 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.
+- 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.java
index 23a4ed0011..bfa69bbae2 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
@@ -4,6 +4,7 @@ import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
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.services.batch.BatchService;
import io.github.hectorvent.floci.services.eventbridge.model.InputTransformer;
import io.github.hectorvent.floci.services.eventbridge.model.Target;
@@ -18,7 +19,9 @@ import jakarta.inject.Inject;
import org.jboss.logging.Logger;
import java.nio.charset.StandardCharsets;
+import java.util.HashMap;
import java.util.LinkedHashMap;
+import java.util.List;
import java.util.Map;
@ApplicationScoped
@@ -26,11 +29,17 @@ public class EventBridgeInvoker {
private static final Logger LOG = Logger.getLogger(EventBridgeInvoker.class);
+ // AWS can't route an event from a sender bus on to a third bus; the second hop is dropped.
+ private static final int MAX_BUS_TO_BUS_DEPTH = 1;
+ private static final ThreadLocal<Integer> BUS_TO_BUS_DEPTH = ThreadLocal.withInitial(() -> 0);
+
private final LambdaService lambdaService;
private final SqsService sqsService;
private final SnsService snsService;
private final BatchService batchService;
private final FirehoseService firehoseService;
+ private final EventBridgeService eventBridgeService;
+ private final RegionResolver regionResolver;
private final ObjectMapper objectMapper;
private final String baseUrl;
@@ -40,6 +49,8 @@ public class EventBridgeInvoker {
SnsService snsService,
BatchService batchService,
FirehoseService firehoseService,
+ EventBridgeService eventBridgeService,
+ RegionResolver regionResolver,
ObjectMapper objectMapper,
EmulatorConfig config) {
this.lambdaService = lambdaService;
@@ -47,6 +58,8 @@ public class EventBridgeInvoker {
this.snsService = snsService;
this.batchService = batchService;
this.firehoseService = firehoseService;
+ this.eventBridgeService = eventBridgeService;
+ this.regionResolver = regionResolver;
this.objectMapper = objectMapper;
this.baseUrl = config.baseUrl();
}
@@ -56,7 +69,9 @@ public class EventBridgeInvoker {
SnsService snsService,
ObjectMapper objectMapper,
EmulatorConfig config) {
- this(lambdaService, sqsService, snsService, null, null, objectMapper, config);
+ this(lambdaService, sqsService, snsService,
+ null /* batch */, null /* firehose */, null /* eventBridge */, null /* regionResolver */,
+ objectMapper, config);
}
public void invokeTarget(Target target, String eventJson, String region) {
@@ -114,6 +129,82 @@ public class EventBridgeInvoker {
// without appending a newline; the delivery-side NDJSON flush handles separation.
firehoseService.putRecord(streamName, new Record(payload.getBytes(StandardCharsets.UTF_8)));
LOG.debugv("EventBridge delivered to Firehose: {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);
+ return;
+ }
+ // Relies on putEvents delivering targets synchronously.
+ int depth = BUS_TO_BUS_DEPTH.get();
+ if (depth >= MAX_BUS_TO_BUS_DEPTH) {
+ LOG.warnv("EventBridge bus-to-bus depth {0} exceeded at target {1}; dropping", depth, arn);
+ return;
+ }
+ String targetRegion = extractRegionFromArn(arn, region);
+ // Input overrides shape only Detail; the rest of the entry comes from the original
+ // event envelope, matching AWS event-bus target semantics.
+ JsonNode envelope = objectMapper.readTree(eventJson);
+ boolean inputOverridden = target.getInput() != null
+ || target.getInputPath() != null
+ || target.getInputTransformer() != null;
+ JsonNode detailNode;
+ if (inputOverridden) {
+ try {
+ detailNode = objectMapper.readTree(payload);
+ } catch (Exception e) {
+ LOG.warnv("EventBridge event-bus target {0} requires JSON Detail; dropping non-JSON input: {1}",
+ arn, e.getMessage());
+ return;
+ }
+ } else {
+ detailNode = envelope.get("detail");
+ if (detailNode == null) {
+ detailNode = objectMapper.createObjectNode();
+ }
+ }
+ // readTree accepts any well-formed JSON value; AWS emits an event only when
+ // Detail is an object, and both arms can produce a scalar or array.
+ if (!detailNode.isObject()) {
+ LOG.warnv("EventBridge event-bus target {0} requires a JSON object Detail; dropping: {1}",
+ arn, detailNode);
+ return;
+ }
+ String detailBody = detailNode.toString();
+ Map<String, Object> entry = new HashMap<>();
+ // putEvents accepts a full event-bus ARN as EventBusName and validates it.
+ entry.put("EventBusName", arn);
+ entry.put("Source", envelope.path("source").asText(""));
+ entry.put("DetailType", envelope.path("detail-type").asText(""));
+ entry.put("Detail", detailBody);
+ // AWS keeps the originating account/region; blank falls back inside putEvents.
+ entry.put("Region", envelope.path("region").asText(""));
+ entry.put("Account", envelope.path("account").asText(""));
+ if (envelope.hasNonNull("resources") && envelope.get("resources").isArray()) {
+ entry.put("Resources", envelope.get("resources"));
+ }
+ // null routes through RequestContext, the only path carrying the legacy-key
+ // fallback; Arn.accountId() is "" when the ARN omits the account segment.
+ String targetAccount = AwsArnUtils.parse(arn).accountId();
+ String currentAccount = regionResolver != null ? regionResolver.getAccountId() : null;
+ String forwardAccount = targetAccount == null || targetAccount.isBlank()
+ || targetAccount.equals(currentAccount)
+ ? null
+ : targetAccount;
+ BUS_TO_BUS_DEPTH.set(depth + 1);
+ try {
+ var result = eventBridgeService.putEvents(List.of(entry), targetRegion, forwardAccount);
+ if (result.failedCount() > 0) {
+ LOG.warnv("EventBridge event-bus target {0} rejected event: {1}", arn, result.entries());
+ } else {
+ LOG.debugv("EventBridge delivered to EventBus: {0}", arn);
+ }
+ } finally {
+ if (depth == 0) {
+ BUS_TO_BUS_DEPTH.remove();
+ } else {
+ BUS_TO_BUS_DEPTH.set(depth);
+ }
+ }
} else {
LOG.warnv("EventBridge: unsupported target ARN type: {0}", arn);
}
diff --git a/src/main/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeService.java b/src/main/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeService.java
index 20c138ad97..7e375bdc7b 100644
--- a/src/main/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeService.java
+++ b/src/main/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeService.java
@@ -650,7 +650,15 @@ public class EventBridgeService {
return putEvents(entries, region, null);
}
- private PutEventsResult putEvents(List<Map<String, Object>> entries, String region, String accountId) {
+ /**
+ * Publishes entries to a bus, optionally naming the account the bus lives in.
+ *
+ * @param accountId account owning the target bus, or {@code null} to resolve against the
+ * caller's request context. Only {@code null} carries the un-prefixed
+ * legacy-key fallback in {@link AccountAwareStorageBackend#get}, so pass
+ * {@code null} whenever the target is in the caller's own account.
+ */
+ public PutEventsResult putEvents(List<Map<String, Object>> entries, String region, String accountId) {
int failed = 0;
List<Map<String, String>> resultEntries = new ArrayList<>();
diff --git a/src/test/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeBusToBusIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeBusToBusIntegrationTest.java
new file mode 100644
index 0000000000..56da6ef43a
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeBusToBusIntegrationTest.java
@@ -0,0 +1,323 @@
+package io.github.hectorvent.floci.services.eventbridge;
+
+import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;
+import io.quarkus.test.junit.QuarkusTest;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Order;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
+
+import java.net.URI;
+
+import static io.restassured.RestAssured.given;
+import static org.hamcrest.Matchers.containsString;
+import static org.hamcrest.Matchers.anyOf;
+import static org.hamcrest.Matchers.hasSize;
+import static org.hamcrest.Matchers.nullValue;
+
+/**
+ * End-to-end EventBridge bus→bus target delivery: a rule on the source bus targets a
+ * second event bus by ARN, whose rule then delivers to SQS. Mirrors a two-bus routing
+ * topology where a shared bus forwards domain-scoped events to a domain-specific bus.
+ */
+@QuarkusTest
+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+class EventBridgeBusToBusIntegrationTest {
+
+ private static final String SQS_CT = "application/x-amz-json-1.0";
+ private static final String EB_CT = "application/x-amz-json-1.1";
+
+ private static final String SOURCE_BUS = "b2b-source-bus";
+ private static final String TARGET_BUS = "b2b-target-bus";
+ private static final String QUEUE = "b2b-sink-queue";
+ private static final String FORWARD_RULE = "b2b-forward-rule";
+ private static final String SINK_RULE = "b2b-sink-rule";
+
+ private static final String XA_SOURCE_BUS = "xa-source-bus";
+ private static final String XA_TARGET_BUS = "xa-target-bus";
+ private static final String XA_QUEUE = "xa-sink-queue";
+ private static final String XA_FORWARD_RULE = "xa-forward-rule";
+ private static final String XA_SINK_RULE = "xa-sink-rule";
+
+ private static final String AUTH_1_EVENTS = "AWS4-HMAC-SHA256 "
+ + "Credential=000000000001/20260805/us-east-1/events/aws4_request, "
+ + "SignedHeaders=host, Signature=abc";
+ private static final String AUTH_2_EVENTS = "AWS4-HMAC-SHA256 "
+ + "Credential=000000000002/20260805/us-east-1/events/aws4_request, "
+ + "SignedHeaders=host, Signature=abc";
+ private static final String AUTH_2_SQS = "AWS4-HMAC-SHA256 "
+ + "Credential=000000000002/20260805/us-east-1/sqs/aws4_request, "
+ + "SignedHeaders=host, Signature=abc";
+
+ private static String xaQueueUrl;
+ private static String xaQueuePath;
+ private static String xaTargetBusArn;
+
+ private static String queueUrl;
+ private static String queueArn;
+ private static String targetBusArn;
+
+ private static final String HOP_A = "hop-bus-a";
+ private static final String HOP_B = "hop-bus-b";
+ private static final String HOP_C = "hop-bus-c";
+ private static final String HOP_B_QUEUE = "hop-sink-b";
+ private static final String HOP_C_QUEUE = "hop-sink-c";
+
+ private static String hopBQueueUrl;
+ private static String hopBQueuePath;
+ private static String hopCQueueUrl;
+ private static String hopCQueuePath;
+
+ @BeforeAll
+ static void configureRestAssured() {
+ RestAssuredJsonUtils.configureAwsContentTypes();
+ }
+
+ @Test
+ @Order(1)
+ void setupBusesQueueAndRules() {
+ // Two custom buses
+ given().contentType(EB_CT).header("X-Amz-Target", "AWSEvents.CreateEventBus")
+ .body("{\"Name\":\"" + SOURCE_BUS + "\"}")
+ .when().post("/").then().statusCode(200);
+
+ targetBusArn = given().contentType(EB_CT).header("X-Amz-Target", "AWSEvents.CreateEventBus")
+ .body("{\"Name\":\"" + TARGET_BUS + "\"}")
+ .when().post("/").then().statusCode(200)
+ .extract().jsonPath().getString("EventBusArn");
+
+ // SQS sink
+ queueUrl = given().contentType(SQS_CT).header("X-Amz-Target", "AmazonSQS.CreateQueue")
+ .body("{\"QueueName\":\"" + QUEUE + "\"}")
+ .when().post("/").then().statusCode(200)
+ .extract().jsonPath().getString("QueueUrl");
+
+ queueArn = given().contentType(SQS_CT).header("X-Amz-Target", "AmazonSQS.GetQueueAttributes")
+ .body("{\"QueueUrl\":\"" + queueUrl + "\",\"AttributeNames\":[\"All\"]}")
+ .when().post("/0000000000/" + QUEUE).then().statusCode(200)
+ .extract().jsonPath().getString("Attributes.QueueArn");
+
+ // Rule on source bus → target bus (the branch under test)
+ given().contentType(EB_CT).header("X-Amz-Target", "AWSEvents.PutRule")
+ .body("{\"Name\":\"" + FORWARD_RULE + "\",\"EventBusName\":\"" + SOURCE_BUS + "\","
+ + "\"EventPattern\":\"{\\\"source\\\":[\\\"myapp.orders\\\"]}\"}")
+ .when().post("/").then().statusCode(200);
+
+ given().contentType(EB_CT).header("X-Amz-Target", "AWSEvents.PutTargets")
+ .body("{\"Rule\":\"" + FORWARD_RULE + "\",\"EventBusName\":\"" + SOURCE_BUS + "\","
+ + "\"Targets\":[{\"Id\":\"forward\",\"Arn\":\"" + targetBusArn + "\"}]}")
+ .when().post("/").then().statusCode(200);
+
+ // Rule on target bus → SQS
+ given().contentType(EB_CT).header("X-Amz-Target", "AWSEvents.PutRule")
+ .body("{\"Name\":\"" + SINK_RULE + "\",\"EventBusName\":\"" + TARGET_BUS + "\","
+ + "\"EventPattern\":\"{\\\"source\\\":[\\\"myapp.orders\\\"]}\"}")
+ .when().post("/").then().statusCode(200);
+
+ given().contentType(EB_CT).header("X-Amz-Target", "AWSEvents.PutTargets")
+ .body("{\"Rule\":\"" + SINK_RULE + "\",\"EventBusName\":\"" + TARGET_BUS + "\","
+ + "\"Targets\":[{\"Id\":\"sink\",\"Arn\":\"" + queueArn + "\"}]}")
+ .when().post("/").then().statusCode(200);
+ }
+
+ @Test
+ @Order(2)
+ void publishOnSourceBus_forwardsThroughTargetBus_toSqs() {
+ given().contentType(EB_CT).header("X-Amz-Target", "AWSEvents.PutEvents")
+ .body("""
+ {"Entries":[{
+ "EventBusName":"%s",
+ "Source":"myapp.orders",
+ "DetailType":"Order.Created",
+ "Resources":["arn:aws:s3:::b2b-bucket"],
+ "Detail":"{\\"orderId\\":\\"o-1\\"}"
+ }]}
+ """.formatted(SOURCE_BUS))
+ .when().post("/").then().statusCode(200);
+
+ given().contentType(SQS_CT).header("X-Amz-Target", "AmazonSQS.ReceiveMessage")
+ .body("{\"QueueUrl\":\"" + queueUrl + "\",\"MaxNumberOfMessages\":1,\"WaitTimeSeconds\":2}")
+ .when().post("/0000000000/" + QUEUE)
+ .then().statusCode(200)
+ .body("Messages", hasSize(1))
+ .body("Messages[0].Body", containsString("\"source\":\"myapp.orders\""))
+ .body("Messages[0].Body", containsString("\"detail-type\":\"Order.Created\""))
+ // Detail must be unwrapped, not the whole envelope re-wrapped.
+ .body("Messages[0].Body", containsString("\"detail\":{\"orderId\":\"o-1\"}"))
+ .body("Messages[0].Body", containsString("\"resources\":[\"arn:aws:s3:::b2b-bucket\"]"))
+ .body("Messages[0].Body", containsString("\"event-bus-name\":\"" + TARGET_BUS + "\""));
+ }
+
+ @Test
+ @Order(3)
+ void setupCrossAccountTopology() {
+ // Source bus in account 1.
+ given().contentType(EB_CT).header("X-Amz-Target", "AWSEvents.CreateEventBus")
+ .header("Authorization", AUTH_1_EVENTS)
+ .body("{\"Name\":\"" + XA_SOURCE_BUS + "\"}")
+ .when().post("/").then().statusCode(200);
+
+ // Target bus in account 2 — the ARN it returns carries account 2.
+ xaTargetBusArn = given().contentType(EB_CT).header("X-Amz-Target", "AWSEvents.CreateEventBus")
+ .header("Authorization", AUTH_2_EVENTS)
+ .body("{\"Name\":\"" + XA_TARGET_BUS + "\"}")
+ .when().post("/").then().statusCode(200)
+ .extract().jsonPath().getString("EventBusArn");
+
+ // SQS sink in account 2. SQS is the only target type that resolves
+ // cross-account today, so it is the only sink that can prove delivery here.
+ xaQueueUrl = given().contentType(SQS_CT).header("X-Amz-Target", "AmazonSQS.CreateQueue")
+ .header("Authorization", AUTH_2_SQS)
+ .body("{\"QueueName\":\"" + XA_QUEUE + "\"}")
+ .when().post("/").then().statusCode(200)
+ .extract().jsonPath().getString("QueueUrl");
+ xaQueuePath = URI.create(xaQueueUrl).getPath();
+
+ String xaQueueArn = given().contentType(SQS_CT).header("X-Amz-Target", "AmazonSQS.GetQueueAttributes")
+ .header("Authorization", AUTH_2_SQS)
+ .body("{\"QueueUrl\":\"" + xaQueueUrl + "\",\"AttributeNames\":[\"All\"]}")
+ .when().post(xaQueuePath).then().statusCode(200)
+ .extract().jsonPath().getString("Attributes.QueueArn");
+
+ // Rule on account 2's target bus → its own SQS queue.
+ given().contentType(EB_CT).header("X-Amz-Target", "AWSEvents.PutRule")
+ .header("Authorization", AUTH_2_EVENTS)
+ .body("{\"Name\":\"" + XA_SINK_RULE + "\",\"EventBusName\":\"" + XA_TARGET_BUS + "\","
+ + "\"EventPattern\":\"{\\\"source\\\":[\\\"myapp.xa\\\"]}\"}")
+ .when().post("/").then().statusCode(200);
+
+ given().contentType(EB_CT).header("X-Amz-Target", "AWSEvents.PutTargets")
+ .header("Authorization", AUTH_2_EVENTS)
+ .body("{\"Rule\":\"" + XA_SINK_RULE + "\",\"EventBusName\":\"" + XA_TARGET_BUS + "\","
+ + "\"Targets\":[{\"Id\":\"sink\",\"Arn\":\"" + xaQueueArn + "\"}]}")
+ .when().post("/").then().statusCode(200);
+
+ // Rule on account 1's source bus → account 2's bus, by ARN.
+ given().contentType(EB_CT).header("X-Amz-Target", "AWSEvents.PutRule")
+ .header("Authorization", AUTH_1_EVENTS)
+ .body("{\"Name\":\"" + XA_FORWARD_RULE + "\",\"EventBusName\":\"" + XA_SOURCE_BUS + "\","
+ + "\"EventPattern\":\"{\\\"source\\\":[\\\"myapp.xa\\\"]}\"}")
+ .when().post("/").then().statusCode(200);
+
+ given().contentType(EB_CT).header("X-Amz-Target", "AWSEvents.PutTargets")
+ .header("Authorization", AUTH_1_EVENTS)
+ .body("{\"Rule\":\"" + XA_FORWARD_RULE + "\",\"EventBusName\":\"" + XA_SOURCE_BUS + "\","
+ + "\"Targets\":[{\"Id\":\"forward\",\"Arn\":\"" + xaTargetBusArn + "\"}]}")
+ .when().post("/").then().statusCode(200);
+ }
+
+ @Test
+ @Order(4)
+ void publishInAccountOne_forwardsToAccountTwoBus_andReachesItsQueue() {
+ given().contentType(EB_CT).header("X-Amz-Target", "AWSEvents.PutEvents")
+ .header("Authorization", AUTH_1_EVENTS)
+ .body("""
+ {"Entries":[{
+ "EventBusName":"%s",
+ "Source":"myapp.xa",
+ "DetailType":"Order.Created",
+ "Detail":"{\\"orderId\\":\\"xa-1\\"}"
+ }]}
+ """.formatted(XA_SOURCE_BUS))
+ .when().post("/").then().statusCode(200);
+
+ given().contentType(SQS_CT).header("X-Amz-Target", "AmazonSQS.ReceiveMessage")
+ .header("Authorization", AUTH_2_SQS)
+ .body("{\"QueueUrl\":\"" + xaQueueUrl + "\",\"MaxNumberOfMessages\":1,\"WaitTimeSeconds\":2}")
+ .when().post(xaQueuePath)
+ .then().statusCode(200)
+ .body("Messages", hasSize(1))
+ .body("Messages[0].Body", containsString("\"detail\":{\"orderId\":\"xa-1\"}"))
+ .body("Messages[0].Body", containsString("\"event-bus-name\":\"" + XA_TARGET_BUS + "\""))
+ // The envelope keeps the originating account, not the target bus's.
+ .body("Messages[0].Body", containsString("\"account\":\"000000000001\""));
+ }
+
+ /**
+ * A -> B -> C with a sink on both B and C, so an empty C queue means the hop was capped
+ * rather than the chain never having been wired.
+ */
+ @Test
+ @Order(5)
+ void setupThreeBusChain() {
+ for (String bus : new String[]{HOP_A, HOP_B, HOP_C}) {
+ given().contentType(EB_CT).header("X-Amz-Target", "AWSEvents.CreateEventBus")
+ .body("{\"Name\":\"" + bus + "\"}")
+ .when().post("/").then().statusCode(200);
+ }
+
+ String busBArn = given().contentType(EB_CT).header("X-Amz-Target", "AWSEvents.DescribeEventBus")
+ .body("{\"Name\":\"" + HOP_B + "\"}")
+ .when().post("/").then().statusCode(200)
+ .extract().jsonPath().getString("Arn");
+ String busCArn = given().contentType(EB_CT).header("X-Amz-Target", "AWSEvents.DescribeEventBus")
+ .body("{\"Name\":\"" + HOP_C + "\"}")
+ .when().post("/").then().statusCode(200)
+ .extract().jsonPath().getString("Arn");
+
+ hopBQueueUrl = createQueue(HOP_B_QUEUE);
+ hopBQueuePath = URI.create(hopBQueueUrl).getPath();
+ hopCQueueUrl = createQueue(HOP_C_QUEUE);
+ hopCQueuePath = URI.create(hopCQueueUrl).getPath();
+
+ // A -> B, B -> C, plus an SQS sink on each of B and C.
+ putForwardRule(HOP_A, "hop-a-to-b", busBArn);
+ putForwardRule(HOP_B, "hop-b-to-c", busCArn);
+ putForwardRule(HOP_B, "hop-b-sink", queueArnFor(hopBQueueUrl, HOP_B_QUEUE));
+ putForwardRule(HOP_C, "hop-c-sink", queueArnFor(hopCQueueUrl, HOP_C_QUEUE));
+ }
+
+ @Test
+ @Order(6)
+ void forwardingStopsAfterOneHop() {
+ given().contentType(EB_CT).header("X-Amz-Target", "AWSEvents.PutEvents")
+ .body("""
+ {"Entries":[{
+ "EventBusName":"%s",
+ "Source":"myapp.hop",
+ "DetailType":"Order.Created",
+ "Detail":"{\\"orderId\\":\\"hop-1\\"}"
+ }]}
+ """.formatted(HOP_A))
+ .when().post("/").then().statusCode(200);
+
+ // Hop one delivered: B received the event.
+ given().contentType(SQS_CT).header("X-Amz-Target", "AmazonSQS.ReceiveMessage")
+ .body("{\"QueueUrl\":\"" + hopBQueueUrl + "\",\"MaxNumberOfMessages\":1,\"WaitTimeSeconds\":2}")
+ .when().post(hopBQueuePath).then().statusCode(200)
+ .body("Messages", hasSize(1))
+ .body("Messages[0].Body", containsString("\"detail\":{\"orderId\":\"hop-1\"}"));
+
+ // Hop two dropped: C never received it, even though B has a rule targeting C.
+ given().contentType(SQS_CT).header("X-Amz-Target", "AmazonSQS.ReceiveMessage")
+ .body("{\"QueueUrl\":\"" + hopCQueueUrl + "\",\"MaxNumberOfMessages\":1,\"WaitTimeSeconds\":2}")
+ .when().post(hopCQueuePath).then().statusCode(200)
+ .body("Messages", anyOf(nullValue(), hasSize(0)));
+ }
+
+ private static String createQueue(String name) {
+ return given().contentType(SQS_CT).header("X-Amz-Target", "AmazonSQS.CreateQueue")
+ .body("{\"QueueName\":\"" + name + "\"}")
+ .when().post("/").then().statusCode(200)
+ .extract().jsonPath().getString("QueueUrl");
+ }
+
+ private static String queueArnFor(String queueUrl, String name) {
+ return given().contentType(SQS_CT).header("X-Amz-Target", "AmazonSQS.GetQueueAttributes")
+ .body("{\"QueueUrl\":\"" + queueUrl + "\",\"AttributeNames\":[\"All\"]}")
+ .when().post(URI.create(queueUrl).getPath()).then().statusCode(200)
+ .extract().jsonPath().getString("Attributes.QueueArn");
+ }
+
+ private static void putForwardRule(String bus, String ruleName, String targetArn) {
+ given().contentType(EB_CT).header("X-Amz-Target", "AWSEvents.PutRule")
+ .body("{\"Name\":\"" + ruleName + "\",\"EventBusName\":\"" + bus + "\","
+ + "\"EventPattern\":\"{\\\"source\\\":[\\\"myapp.hop\\\"]}\"}")
+ .when().post("/").then().statusCode(200);
+ given().contentType(EB_CT).header("X-Amz-Target", "AWSEvents.PutTargets")
+ .body("{\"Rule\":\"" + ruleName + "\",\"EventBusName\":\"" + bus + "\","
+ + "\"Targets\":[{\"Id\":\"t\",\"Arn\":\"" + targetArn + "\"}]}")
+ .when().post("/").then().statusCode(200);
+ }
+}
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.java
index 3bcdfb1163..4fe4512978 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
@@ -2,6 +2,7 @@ package io.github.hectorvent.floci.services.eventbridge;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.JsonNode;
+import io.github.hectorvent.floci.core.common.RegionResolver;
import io.github.hectorvent.floci.services.batch.BatchService;
import io.github.hectorvent.floci.services.eventbridge.model.BatchParameters;
import io.github.hectorvent.floci.services.eventbridge.model.InputTransformer;
@@ -15,6 +16,7 @@ import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.nio.charset.StandardCharsets;
+import java.util.List;
import java.util.Map;
import org.mockito.ArgumentCaptor;
@@ -29,6 +31,8 @@ class EventBridgeInvokerTest {
private SqsService sqsService;
private BatchService batchService;
private FirehoseService firehoseService;
+ private EventBridgeService eventBridgeService;
+ private RegionResolver regionResolver;
@BeforeEach
void setUp() {
@@ -37,12 +41,19 @@ class EventBridgeInvokerTest {
SnsService snsService = mock(SnsService.class);
batchService = mock(BatchService.class);
firehoseService = mock(FirehoseService.class);
+ eventBridgeService = mock(EventBridgeService.class);
+ regionResolver = mock(RegionResolver.class);
+ when(regionResolver.getAccountId()).thenReturn("000000000000");
+ when(eventBridgeService.putEvents(anyList(), anyString(), any()))
+ .thenReturn(new EventBridgeService.PutEventsResult(0, List.of()));
invoker = new EventBridgeInvoker(
lambdaService,
sqsService,
snsService,
batchService,
firehoseService,
+ eventBridgeService,
+ regionResolver,
new ObjectMapper(),
mock(io.github.hectorvent.floci.config.EmulatorConfig.class)
);
@@ -236,4 +247,205 @@ class EventBridgeInvokerTest {
InputTransformer transformer = new InputTransformer(Map.of(), null);
assertEquals(eventJson, invoker.applyInputTransformer(transformer, eventJson));
}
+
+ @SuppressWarnings("unchecked")
+ @Test
+ void invokeTarget_eventBusTarget_republishesEventToTargetBus() {
+ Target target = new Target("id1",
+ "arn:aws:events:eu-west-1:000000000000:event-bus/my-target-bus",
+ null, null);
+ String event = "{\"source\":\"myapp.orders\",\"detail-type\":\"Order.Created\","
+ + "\"resources\":[\"arn:aws:s3:::b\"],\"detail\":{\"orderId\":\"o-1\"}}";
+
+ invoker.invokeTarget(target, event, "eu-west-1");
+
+ ArgumentCaptor<List<Map<String, Object>>> captor = ArgumentCaptor.forClass(List.class);
+ verify(eventBridgeService).putEvents(captor.capture(), eq("eu-west-1"), isNull());
+ List<Map<String, Object>> entries = captor.getValue();
+ assertEquals(1, entries.size());
+ Map<String, Object> entry = entries.get(0);
+ assertEquals("arn:aws:events:eu-west-1:000000000000:event-bus/my-target-bus",
+ entry.get("EventBusName"));
+ assertEquals("myapp.orders", entry.get("Source"));
+ assertEquals("Order.Created", entry.get("DetailType"));
+ assertEquals("{\"orderId\":\"o-1\"}", entry.get("Detail"));
+ assertEquals("[\"arn:aws:s3:::b\"]", entry.get("Resources").toString());
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ void invokeTarget_eventBusTargetWithInputTransformer_usesOriginalSourceAndTransformedDetail() {
+ InputTransformer transformer = new InputTransformer(
+ Map.of("id", "$.detail.orderId"),
+ "{\"remapped\":\"<id>\"}");
+ Target target = new Target("id1",
+ "arn:aws:events:eu-west-1:000000000000:event-bus/my-target-bus",
+ null, null);
+ target.setInputTransformer(transformer);
+ String event = "{\"source\":\"myapp.orders\",\"detail-type\":\"Order.Created\","
+ + "\"detail\":{\"orderId\":\"o-1\"}}";
+
+ invoker.invokeTarget(target, event, "eu-west-1");
+
+ ArgumentCaptor<List<Map<String, Object>>> captor = ArgumentCaptor.forClass(List.class);
+ verify(eventBridgeService).putEvents(captor.capture(), eq("eu-west-1"), isNull());
+ Map<String, Object> entry = captor.getValue().get(0);
+ assertEquals("myapp.orders", entry.get("Source"));
+ assertEquals("Order.Created", entry.get("DetailType"));
+ assertEquals("{\"remapped\":\"o-1\"}", entry.get("Detail"));
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ void invokeTarget_eventBusTarget_preservesOriginAccountAndRegion() {
+ Target target = new Target("id1",
+ "arn:aws:events:eu-west-1:000000000000:event-bus/my-target-bus",
+ null, null);
+ String event = "{\"source\":\"myapp.orders\",\"detail-type\":\"Order.Created\","
+ + "\"account\":\"111122223333\",\"region\":\"eu-central-1\","
+ + "\"detail\":{\"orderId\":\"o-1\"}}";
+
+ invoker.invokeTarget(target, event, "eu-west-1");
+
+ ArgumentCaptor<List<Map<String, Object>>> captor = ArgumentCaptor.forClass(List.class);
+ verify(eventBridgeService).putEvents(captor.capture(), eq("eu-west-1"), isNull());
+ Map<String, Object> entry = captor.getValue().get(0);
+ assertEquals("111122223333", entry.get("Account"));
+ assertEquals("eu-central-1", entry.get("Region"));
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ void invokeTarget_eventBusTargetWithNullResources_omitsResourcesEntry() {
+ Target target = new Target("id1",
+ "arn:aws:events:eu-west-1:000000000000:event-bus/my-target-bus",
+ null, null);
+ String event = "{\"source\":\"myapp.orders\",\"detail-type\":\"Order.Created\","
+ + "\"resources\":null,\"detail\":{\"orderId\":\"o-1\"}}";
+
+ invoker.invokeTarget(target, event, "eu-west-1");
+
+ ArgumentCaptor<List<Map<String, Object>>> captor = ArgumentCaptor.forClass(List.class);
+ verify(eventBridgeService).putEvents(captor.capture(), eq("eu-west-1"), isNull());
+ Map<String, Object> entry = captor.getValue().get(0);
+ assertFalse(entry.containsKey("Resources"));
+ assertEquals("{\"orderId\":\"o-1\"}", entry.get("Detail"));
+ }
+
+ @Test
+ void invokeTarget_eventBusTargetWithNonJsonInput_dropsWithoutPublishing() {
+ Target target = new Target("id1",
+ "arn:aws:events:eu-west-1:000000000000:event-bus/my-target-bus",
+ null, null);
+ target.setInputTransformer(new InputTransformer(
+ Map.of("bucket", "$.detail.bucket.name"),
+ "bucket=<bucket>"));
+
+ invoker.invokeTarget(target, "{\"source\":\"aws.s3\"}", "eu-west-1");
+
+ verify(eventBridgeService, never()).putEvents(anyList(), anyString(), any());
+ }
+
+ @Test
+ void invokeTarget_eventBusTargetWithoutEventBridgeService_skipsWithoutThrowing() {
+ EventBridgeInvoker bare = new EventBridgeInvoker(
+ mock(LambdaService.class),
+ sqsService,
+ mock(SnsService.class),
+ new ObjectMapper(),
+ mock(io.github.hectorvent.floci.config.EmulatorConfig.class));
+ Target target = new Target("id1",
+ "arn:aws:events:eu-west-1:000000000000:event-bus/my-target-bus",
+ null, null);
+
+ assertDoesNotThrow(() -> bare.invokeTarget(target, "{\"detail\":{}}", "eu-west-1"));
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ void invokeTarget_eventBusTargetInAnotherAccount_forwardsUnderArnAccount() {
+ Target target = new Target("id1",
+ "arn:aws:events:eu-west-1:000000000002:event-bus/other-account-bus",
+ null, null);
+ String event = "{\"source\":\"myapp.orders\",\"detail-type\":\"Order.Created\","
+ + "\"detail\":{\"orderId\":\"o-1\"}}";
+
+ invoker.invokeTarget(target, event, "eu-west-1");
+
+ ArgumentCaptor<List<Map<String, Object>>> captor = ArgumentCaptor.forClass(List.class);
+ verify(eventBridgeService).putEvents(captor.capture(), eq("eu-west-1"), eq("000000000002"));
+ assertEquals("arn:aws:events:eu-west-1:000000000002:event-bus/other-account-bus",
+ captor.getValue().get(0).get("EventBusName"));
+ }
+
+ @Test
+ void invokeTarget_eventBusTargetInSameAccount_forwardsWithNullAccount() {
+ Target target = new Target("id1",
+ "arn:aws:events:eu-west-1:000000000000:event-bus/my-target-bus",
+ null, null);
+
+ invoker.invokeTarget(target, "{\"source\":\"s\",\"detail\":{}}", "eu-west-1");
+
+ verify(eventBridgeService).putEvents(anyList(), eq("eu-west-1"), isNull());
+ }
+
+ @Test
+ void invokeTarget_eventBusTargetWithAccountlessArn_forwardsWithNullAccount() {
+ Target target = new Target("id1",
+ "arn:aws:events:eu-west-1::event-bus/my-target-bus",
+ null, null);
+
+ // Distinct from the same-account case: accountId() is "" here, not null.
+ invoker.invokeTarget(target, "{\"source\":\"s\",\"detail\":{}}", "eu-west-1");
+
+ verify(eventBridgeService).putEvents(anyList(), eq("eu-west-1"), isNull());
+ }
+
+ @Test
+ void invokeTarget_eventBusTargetWithScalarJsonInput_dropsWithoutPublishing() {
+ Target target = new Target("id1",
+ "arn:aws:events:eu-west-1:000000000000:event-bus/my-target-bus",
+ "\"hello\"", null);
+
+ invoker.invokeTarget(target, "{\"source\":\"myapp.orders\",\"detail\":{}}", "eu-west-1");
+
+ verify(eventBridgeService, never()).putEvents(anyList(), anyString(), any());
+ }
+
+ @Test
+ void invokeTarget_eventBusTargetWithArrayInput_dropsWithoutPublishing() {
+ Target target = new Target("id1",
+ "arn:aws:events:eu-west-1:000000000000:event-bus/my-target-bus",
+ "[1,2]", null);
+
+ invoker.invokeTarget(target, "{\"source\":\"myapp.orders\",\"detail\":{}}", "eu-west-1");
+
+ verify(eventBridgeService, never()).putEvents(anyList(), anyString(), any());
+ }
+
+ @Test
+ void invokeTarget_eventBusTargetWithNumericInput_dropsWithoutPublishing() {
+ Target target = new Target("id1",
+ "arn:aws:events:eu-west-1:000000000000:event-bus/my-target-bus",
+ "123", null);
+
+ invoker.invokeTarget(target, "{\"source\":\"myapp.orders\",\"detail\":{}}", "eu-west-1");
+
+ verify(eventBridgeService, never()).putEvents(anyList(), anyString(), any());
+ }
+
+ @Test
+ void invokeTarget_eventBusTargetWithScalarEnvelopeDetail_dropsWithoutPublishing() {
+ Target target = new Target("id1",
+ "arn:aws:events:eu-west-1:000000000000:event-bus/my-target-bus",
+ null, null);
+ // No input override: the scalar arrives on the envelope itself, which the
+ // PutEvents handler permits today.
+ String event = "{\"source\":\"myapp.orders\",\"detail-type\":\"Order.Created\","
+ + "\"detail\":\"hello\"}";
+
+ invoker.invokeTarget(target, event, "eu-west-1");
+
+ verify(eventBridgeService, never()).putEvents(anyList(), anyString(), any());
+ }
}