Light, fluffy, and always free - The AWS Local Emulator alternative
fix(eventbridge): propagate PutEvents call region and account through pattern matching and delivered envelope (#1125)
Kenshin Okinakac576d3341b92
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.javaindex 1a903e6999..522571b8e4 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@@ -618,7 +618,22 @@ public class EventBridgeService {int failed = 0;List<Map<String, String>> resultEntries = new ArrayList<>();- for (Map<String, Object> entry : entries) {+ for (Map<String, Object> originalEntry : entries) {+ // Defensive copy: callers may pass Map.of(...) (immutable) and we don't want to+ // mutate caller state regardless. Normalize Region / Account from the PutEvents+ // call context up front so matchesPattern, buildEventEnvelope, and the archive+ // capture all see the same values — without this, a pattern's region/account+ // filter would fall back to the resolver default in matchesPattern while the+ // delivered envelope would correctly carry the call's region/account, giving an+ // inconsistent observable.+ Map<String, Object> entry = new HashMap<>(originalEntry);+ if (isBlank(entry.get("Region"))) {+ entry.put("Region", isBlank(region) ? regionResolver.getDefaultRegion() : region);+ }+ if (isBlank(entry.get("Account"))) {+ entry.put("Account", isBlank(accountId) ? regionResolver.getAccountId() : accountId);+ }+String eventBusNameRaw = (String) entry.get("EventBusName");String effectiveBus = resolvedBusName(eventBusNameRaw);String busStoreKey = busKey(region, effectiveBus);@@ -645,7 +660,7 @@ public class EventBridgeService {if (matchesPattern(entry, rule.getEventPattern())) {String ruleKey = ruleKey(region, effectiveBus, rule.getName());List<Target> targets = accountGet(targetStore, accountId, ruleKey).orElse(List.of());- String eventJson = buildEventEnvelope(entry, effectiveBus, eventId);+ String eventJson = buildEventEnvelope(entry, effectiveBus, eventId, region, accountId);for (Target target : targets) {invoker.invokeTarget(target, eventJson, region);}@@ -900,20 +915,35 @@ public class EventBridgeService {// ──────────────────────────── Target Routing ────────────────────────────- private String buildEventEnvelope(Map<String, Object> entry, String busName, String eventId) {+ private String buildEventEnvelope(Map<String, Object> entry, String busName, String eventId,+ String callRegion, String callAccountId) {try {String source = (String) entry.getOrDefault("Source", "");String detailType = (String) entry.getOrDefault("DetailType", "");String detail = (String) entry.getOrDefault("Detail", "{}");ArrayNode resources = (ArrayNode) entry.getOrDefault("Resources", objectMapper.createArrayNode());+ // Envelope region/account precedence: entry-supplied "Region"/"Account" (set by+ // archive replay paths and cross-region producers) wins; otherwise stamp the+ // region/account the PutEvents call was made against. Only when neither is+ // available do we fall back to the RegionResolver defaults. This keeps the+ // envelope consistent with matchesPattern() which also reads entry.Region with+ // the same fallback chain.+ String envelopeRegion = (String) entry.get("Region");+ if (isBlank(envelopeRegion)) {+ envelopeRegion = isBlank(callRegion) ? regionResolver.getDefaultRegion() : callRegion;+ }+ String envelopeAccount = (String) entry.get("Account");+ if (isBlank(envelopeAccount)) {+ envelopeAccount = isBlank(callAccountId) ? regionResolver.getAccountId() : callAccountId;+ }ObjectNode node = objectMapper.createObjectNode();node.put("version", "0");node.put("id", eventId);node.put("source", source);node.put("detail-type", detailType);- node.put("account", regionResolver.getAccountId());+ node.put("account", envelopeAccount);node.put("time", Instant.now().toString());- node.put("region", regionResolver.getDefaultRegion());+ node.put("region", envelopeRegion);node.putArray("resources").addAll(resources);node.set("detail", objectMapper.readTree(detail));node.put("event-bus-name", busName);@@ -941,6 +971,10 @@ public class EventBridgeService {"EventBus not found: " + busName, 404));}+ private static boolean isBlank(Object value) {+ return !(value instanceof String s) || s.isBlank();+ }+private static String resolvedBusName(String busName) {if (busName == null || busName.isBlank()) {return "default";diff --git a/src/test/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeServiceTest.javaindex bda1af8b42..c057a9f3b0 100644--- a/src/test/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeServiceTest.java@@ -618,4 +618,127 @@ class EventBridgeServiceTest {assertFalse(service.matchesPattern(event,"{\"source\":[\"my.app\"],\"account\":[\"999999999999\"],\"detail\":{\"status\":[\"CONFIRMED\"]}}"));}++ // ─────────────── Envelope region/account propagation ───────────────++ @Test+ void putEvents_envelopeRegionMatchesPutEventsCallRegion() throws Exception {+ service.putRule("my-rule", null, "{\"source\":[\"my.app\"]}", null, RuleState.ENABLED,+ "A test rule", null, null, "eu-west-1");+ Target target = new Target();+ target.setId("t1");+ target.setArn("arn:aws:sqs:eu-west-1:000000000000:my-queue");+ service.putTargets("my-rule", null, List.of(target), "eu-west-1");++ List<Map<String, Object>> entries = List.of(+ Map.of("Source", "my.app", "DetailType", "Test", "Detail", "{}")+ );++ EventBridgeService.PutEventsResult result = service.putEvents(entries, "eu-west-1");+ assertEquals(0, result.failedCount());++ org.mockito.ArgumentCaptor<String> json = org.mockito.ArgumentCaptor.forClass(String.class);+ verify(invokerMock).invokeTarget(eq(target), json.capture(), eq("eu-west-1"));+ com.fasterxml.jackson.databind.JsonNode envelope = OBJECT_MAPPER.readTree(json.getValue());+ assertEquals("eu-west-1", envelope.path("region").asText(),+ "envelope.region should reflect the PutEvents call's region, not the resolver default");+ assertEquals("000000000000", envelope.path("account").asText());+ }++ @Test+ void putEvents_envelopeRegionFromEntryWinsOverCallRegion() throws Exception {+ // Simulates the archive-replay path which stamps "Region" / "Account" on the+ // re-emitted entry from the originating event's envelope.+ service.putRule("my-rule", null, "{\"source\":[\"my.app\"]}", null, RuleState.ENABLED,+ null, null, null, "us-west-2");+ Target target = new Target();+ target.setId("t1");+ target.setArn("arn:aws:sqs:us-west-2:000000000000:replay-queue");+ service.putTargets("my-rule", null, List.of(target), "us-west-2");++ java.util.Map<String, Object> entry = new java.util.HashMap<>();+ entry.put("Source", "my.app");+ entry.put("DetailType", "Test");+ entry.put("Detail", "{}");+ entry.put("Region", "ap-northeast-1");+ entry.put("Account", "111111111111");++ service.putEvents(List.of(entry), "us-west-2");++ org.mockito.ArgumentCaptor<String> json = org.mockito.ArgumentCaptor.forClass(String.class);+ verify(invokerMock).invokeTarget(eq(target), json.capture(), eq("us-west-2"));+ com.fasterxml.jackson.databind.JsonNode envelope = OBJECT_MAPPER.readTree(json.getValue());+ assertEquals("ap-northeast-1", envelope.path("region").asText(),+ "entry.Region should win over the PutEvents call region");+ assertEquals("111111111111", envelope.path("account").asText(),+ "entry.Account should win over the resolver default");+ }++ @Test+ void putEvents_matchesPatternUsesCallRegionForRegionFilter() throws Exception {+ // A rule with a region-filter for the call region (eu-west-1) must match a+ // PutEvents entry that didn't supply Region — the entry should be normalized to+ // the call region before matchesPattern() sees it. Without the normalization the+ // pattern's region filter would compare against the resolver default (us-east-1)+ // and the rule would miss.+ service.putRule("region-filtered", null,+ "{\"source\":[\"my.app\"],\"region\":[\"eu-west-1\"]}",+ null, RuleState.ENABLED, null, null, null, "eu-west-1");+ Target target = new Target();+ target.setId("t1");+ target.setArn("arn:aws:sqs:eu-west-1:000000000000:filtered-queue");+ service.putTargets("region-filtered", null, List.of(target), "eu-west-1");++ service.putEvents(List.of(+ Map.of("Source", "my.app", "DetailType", "Test", "Detail", "{}")), "eu-west-1");++ org.mockito.ArgumentCaptor<String> json = org.mockito.ArgumentCaptor.forClass(String.class);+ verify(invokerMock).invokeTarget(eq(target), json.capture(), eq("eu-west-1"));+ com.fasterxml.jackson.databind.JsonNode envelope = OBJECT_MAPPER.readTree(json.getValue());+ assertEquals("eu-west-1", envelope.path("region").asText(),+ "envelope and pattern matching must agree on the entry's effective region");+ }++ @Test+ void putEvents_matchesPatternRejectsWrongRegionFilterUnderNonDefaultCall() {+ // The mirror of the above: a rule whose region-filter does NOT match the call+ // region must not fire. Pre-fix, an entry without Region would default to+ // resolver-default us-east-1 in matchesPattern, accidentally satisfying a filter+ // like {"region":["us-east-1"]} even when PutEvents was called against+ // eu-west-1.+ service.putRule("default-region-filtered", null,+ "{\"source\":[\"my.app\"],\"region\":[\"us-east-1\"]}",+ null, RuleState.ENABLED, null, null, null, "eu-west-1");+ Target target = new Target();+ target.setId("t1");+ target.setArn("arn:aws:sqs:eu-west-1:000000000000:wrong-region-queue");+ service.putTargets("default-region-filtered", null, List.of(target), "eu-west-1");++ service.putEvents(List.of(+ Map.of("Source", "my.app", "DetailType", "Test", "Detail", "{}")), "eu-west-1");++ verify(invokerMock, org.mockito.Mockito.never()).invokeTarget(eq(target), any(), any());+ }++ @Test+ void putEvents_envelopeDefaultsRegressionForDefaultRegionCall() throws Exception {+ // Regression: when neither the entry nor the call carries a region (callers in+ // the default region), the envelope still stamps the resolver default — same+ // behavior as before the fix.+ service.putRule("my-rule", null, "{\"source\":[\"my.app\"]}", null, RuleState.ENABLED,+ null, null, null, REGION);+ Target target = new Target();+ target.setId("t1");+ target.setArn("arn:aws:sqs:us-east-1:000000000000:default-queue");+ service.putTargets("my-rule", null, List.of(target), REGION);++ service.putEvents(List.of(+ Map.of("Source", "my.app", "DetailType", "Test", "Detail", "{}")), REGION);++ org.mockito.ArgumentCaptor<String> json = org.mockito.ArgumentCaptor.forClass(String.class);+ verify(invokerMock).invokeTarget(eq(target), json.capture(), eq(REGION));+ com.fasterxml.jackson.databind.JsonNode envelope = OBJECT_MAPPER.readTree(json.getValue());+ assertEquals(REGION, envelope.path("region").asText());+ assertEquals("000000000000", envelope.path("account").asText());+ }}