Skip to content

armgit / floci

Public Imported from GitHub
0

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

feat(eventbridge): add InputTransformer support and S3 event notifications (#294)

Hector Ventura9ca82e5748cb
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/EventBridgeTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/EventBridgeTest.java
new file mode 100644
index 0000000000..e78d70ddf0
--- /dev/null
+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/EventBridgeTest.java
@@ -0,0 +1,306 @@
+package com.floci.test;
+
+import org.junit.jupiter.api.*;
+import software.amazon.awssdk.services.eventbridge.EventBridgeClient;
+import software.amazon.awssdk.services.eventbridge.model.*;
+import software.amazon.awssdk.services.sqs.SqsClient;
+import software.amazon.awssdk.services.sqs.model.*;
+
+import java.util.List;
+import java.util.Map;
+
+import static org.assertj.core.api.Assertions.*;
+
+@DisplayName("EventBridge")
+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+class EventBridgeTest {
+
+ private static EventBridgeClient eb;
+ private static SqsClient sqs;
+
+ private static String ruleName;
+ private static String busName;
+ private static String sinkQueueUrl;
+ private static String sinkQueueArn;
+ private static String transformerQueueUrl;
+ private static String transformerQueueArn;
+
+ @BeforeAll
+ static void setup() {
+ eb = TestFixtures.eventBridgeClient();
+ sqs = TestFixtures.sqsClient();
+ ruleName = TestFixtures.uniqueName("eb-rule");
+ busName = TestFixtures.uniqueName("eb-bus");
+ }
+
+ @AfterAll
+ static void cleanup() {
+ try {
+ eb.removeTargets(RemoveTargetsRequest.builder().rule(ruleName).ids("sqs-target", "transformer-target").build());
+ } catch (Exception ignored) {}
+ try {
+ eb.deleteRule(DeleteRuleRequest.builder().name(ruleName).build());
+ } catch (Exception ignored) {}
+ try {
+ eb.deleteEventBus(DeleteEventBusRequest.builder().name(busName).build());
+ } catch (Exception ignored) {}
+ try {
+ sqs.deleteQueue(DeleteQueueRequest.builder().queueUrl(sinkQueueUrl).build());
+ } catch (Exception ignored) {}
+ try {
+ sqs.deleteQueue(DeleteQueueRequest.builder().queueUrl(transformerQueueUrl).build());
+ } catch (Exception ignored) {}
+ eb.close();
+ sqs.close();
+ }
+
+ // ──────────────────────────── Event Buses ────────────────────────────
+
+ @Test
+ @Order(1)
+ void createEventBus() {
+ CreateEventBusResponse response = eb.createEventBus(
+ CreateEventBusRequest.builder().name(busName).build());
+ assertThat(response.eventBusArn()).contains(busName);
+ }
+
+ @Test
+ @Order(2)
+ void describeEventBus() {
+ DescribeEventBusResponse response = eb.describeEventBus(
+ DescribeEventBusRequest.builder().name(busName).build());
+ assertThat(response.name()).isEqualTo(busName);
+ assertThat(response.arn()).contains(busName);
+ }
+
+ @Test
+ @Order(3)
+ void listEventBuses() {
+ ListEventBusesResponse response = eb.listEventBuses(
+ ListEventBusesRequest.builder().build());
+ assertThat(response.eventBuses()).extracting(EventBus::name).contains("default", busName);
+ }
+
+ // ──────────────────────────── Rules ────────────────────────────
+
+ @Test
+ @Order(10)
+ void putRule() {
+ PutRuleResponse response = eb.putRule(PutRuleRequest.builder()
+ .name(ruleName)
+ .eventPattern("{\"source\":[\"com.myapp\"]}")
+ .state(RuleState.ENABLED)
+ .description("Test rule")
+ .build());
+ assertThat(response.ruleArn()).contains(ruleName);
+ }
+
+ @Test
+ @Order(11)
+ void describeRule() {
+ DescribeRuleResponse response = eb.describeRule(
+ DescribeRuleRequest.builder().name(ruleName).build());
+ assertThat(response.name()).isEqualTo(ruleName);
+ assertThat(response.state()).isEqualTo(RuleState.ENABLED);
+ assertThat(response.eventPattern()).contains("com.myapp");
+ }
+
+ @Test
+ @Order(12)
+ void listRules() {
+ ListRulesResponse response = eb.listRules(ListRulesRequest.builder().build());
+ assertThat(response.rules()).extracting(Rule::name).contains(ruleName);
+ }
+
+ @Test
+ @Order(13)
+ void disableAndEnableRule() {
+ eb.disableRule(DisableRuleRequest.builder().name(ruleName).build());
+ assertThat(eb.describeRule(DescribeRuleRequest.builder().name(ruleName).build()).state())
+ .isEqualTo(RuleState.DISABLED);
+
+ eb.enableRule(EnableRuleRequest.builder().name(ruleName).build());
+ assertThat(eb.describeRule(DescribeRuleRequest.builder().name(ruleName).build()).state())
+ .isEqualTo(RuleState.ENABLED);
+ }
+
+ // ──────────────────────────── Targets + PutEvents ────────────────────────────
+
+ @Test
+ @Order(20)
+ void createSinkQueue() {
+ sinkQueueUrl = sqs.createQueue(CreateQueueRequest.builder()
+ .queueName(TestFixtures.uniqueName("eb-sink")).build()).queueUrl();
+ sinkQueueArn = sqs.getQueueAttributes(GetQueueAttributesRequest.builder()
+ .queueUrl(sinkQueueUrl).attributeNamesWithStrings("QueueArn").build())
+ .attributesAsStrings().get("QueueArn");
+ assertThat(sinkQueueArn).contains("eb-sink");
+ }
+
+ @Test
+ @Order(21)
+ void putSqsTarget() {
+ PutTargetsResponse response = eb.putTargets(PutTargetsRequest.builder()
+ .rule(ruleName)
+ .targets(Target.builder().id("sqs-target").arn(sinkQueueArn).build())
+ .build());
+ assertThat(response.failedEntryCount()).isZero();
+ }
+
+ @Test
+ @Order(22)
+ void listTargetsByRule() {
+ ListTargetsByRuleResponse response = eb.listTargetsByRule(
+ ListTargetsByRuleRequest.builder().rule(ruleName).build());
+ assertThat(response.targets()).extracting(Target::id).contains("sqs-target");
+ }
+
+ @Test
+ @Order(23)
+ void putEventsDeliveredToSqsTarget() {
+ eb.putEvents(PutEventsRequest.builder()
+ .entries(PutEventsRequestEntry.builder()
+ .source("com.myapp")
+ .detailType("OrderPlaced")
+ .detail("{\"orderId\":\"123\"}")
+ .build())
+ .build());
+
+ ReceiveMessageResponse msg = sqs.receiveMessage(ReceiveMessageRequest.builder()
+ .queueUrl(sinkQueueUrl)
+ .maxNumberOfMessages(1)
+ .waitTimeSeconds(2)
+ .build());
+ assertThat(msg.messages()).hasSize(1);
+ assertThat(msg.messages().get(0).body()).contains("com.myapp").contains("OrderPlaced");
+ }
+
+ @Test
+ @Order(24)
+ void putEventsNoMatchingRuleNotDelivered() {
+ eb.putEvents(PutEventsRequest.builder()
+ .entries(PutEventsRequestEntry.builder()
+ .source("other.app")
+ .detailType("Ignored")
+ .detail("{}")
+ .build())
+ .build());
+
+ ReceiveMessageResponse msg = sqs.receiveMessage(ReceiveMessageRequest.builder()
+ .queueUrl(sinkQueueUrl)
+ .maxNumberOfMessages(1)
+ .build());
+ assertThat(msg.messages()).isEmpty();
+ }
+
+ // ──────────────────────────── InputTransformer ────────────────────────────
+
+ @Test
+ @Order(30)
+ void createTransformerQueue() {
+ transformerQueueUrl = sqs.createQueue(CreateQueueRequest.builder()
+ .queueName(TestFixtures.uniqueName("eb-xform")).build()).queueUrl();
+ transformerQueueArn = sqs.getQueueAttributes(GetQueueAttributesRequest.builder()
+ .queueUrl(transformerQueueUrl).attributeNamesWithStrings("QueueArn").build())
+ .attributesAsStrings().get("QueueArn");
+ assertThat(transformerQueueArn).contains("eb-xform");
+ }
+
+ @Test
+ @Order(31)
+ void putInputTransformerTarget() {
+ PutTargetsResponse response = eb.putTargets(PutTargetsRequest.builder()
+ .rule(ruleName)
+ .targets(Target.builder()
+ .id("transformer-target")
+ .arn(transformerQueueArn)
+ .inputTransformer(InputTransformer.builder()
+ .inputPathsMap(Map.of("src", "$.source", "type", "$.detail-type"))
+ .inputTemplate("{\"source\":\"<src>\",\"type\":\"<type>\"}")
+ .build())
+ .build())
+ .build());
+ assertThat(response.failedEntryCount()).isZero();
+ }
+
+ @Test
+ @Order(32)
+ void inputTransformerTargetStoredCorrectly() {
+ ListTargetsByRuleResponse response = eb.listTargetsByRule(
+ ListTargetsByRuleRequest.builder().rule(ruleName).build());
+ Target xformTarget = response.targets().stream()
+ .filter(t -> "transformer-target".equals(t.id()))
+ .findFirst().orElseThrow();
+ assertThat(xformTarget.inputTransformer()).isNotNull();
+ assertThat(xformTarget.inputTransformer().inputPathsMap()).containsKey("src");
+ assertThat(xformTarget.inputTransformer().inputTemplate()).contains("<src>");
+ }
+
+ @Test
+ @Order(33)
+ void putEventsInputTransformerTransformsPayload() {
+ // Drain any prior messages
+ sqs.receiveMessage(ReceiveMessageRequest.builder()
+ .queueUrl(transformerQueueUrl).maxNumberOfMessages(10).build());
+
+ eb.putEvents(PutEventsRequest.builder()
+ .entries(PutEventsRequestEntry.builder()
+ .source("com.myapp")
+ .detailType("OrderShipped")
+ .detail("{\"orderId\":\"456\"}")
+ .build())
+ .build());
+
+ ReceiveMessageResponse msg = sqs.receiveMessage(ReceiveMessageRequest.builder()
+ .queueUrl(transformerQueueUrl)
+ .maxNumberOfMessages(1)
+ .waitTimeSeconds(2)
+ .build());
+ assertThat(msg.messages()).hasSize(1);
+ String body = msg.messages().get(0).body();
+ assertThat(body).contains("com.myapp").contains("OrderShipped");
+ assertThat(body).doesNotContain("orderId");
+ }
+
+ // ──────────────────────────── Tags ────────────────────────────
+
+ @Test
+ @Order(40)
+ void listTagsForResource() {
+ String ruleArn = eb.describeRule(DescribeRuleRequest.builder().name(ruleName).build()).arn();
+ ListTagsForResourceResponse response = eb.listTagsForResource(
+ ListTagsForResourceRequest.builder().resourceARN(ruleArn).build());
+ assertThat(response.tags()).isNotNull();
+ }
+
+ // ──────────────────────────── Cleanup ────────────────────────────
+
+ @Test
+ @Order(90)
+ void removeTargets() {
+ RemoveTargetsResponse response = eb.removeTargets(RemoveTargetsRequest.builder()
+ .rule(ruleName)
+ .ids("sqs-target", "transformer-target")
+ .build());
+ assertThat(response.failedEntryCount()).isZero();
+ assertThat(eb.listTargetsByRule(ListTargetsByRuleRequest.builder().rule(ruleName).build())
+ .targets()).isEmpty();
+ }
+
+ @Test
+ @Order(91)
+ void deleteRule() {
+ eb.deleteRule(DeleteRuleRequest.builder().name(ruleName).build());
+ assertThatThrownBy(() ->
+ eb.describeRule(DescribeRuleRequest.builder().name(ruleName).build()))
+ .isInstanceOf(software.amazon.awssdk.services.eventbridge.model.ResourceNotFoundException.class);
+ }
+
+ @Test
+ @Order(92)
+ void deleteEventBus() {
+ eb.deleteEventBus(DeleteEventBusRequest.builder().name(busName).build());
+ ListEventBusesResponse response = eb.listEventBuses(ListEventBusesRequest.builder().build());
+ assertThat(response.eventBuses()).extracting(EventBus::name).doesNotContain(busName);
+ }
+}
diff --git a/compatibility-tests/sdk-test-node/package.json b/compatibility-tests/sdk-test-node/package.json
index 19e6cad906..9c1343ce8b 100644
--- a/compatibility-tests/sdk-test-node/package.json
+++ b/compatibility-tests/sdk-test-node/package.json
@@ -8,6 +8,7 @@
},
"dependencies": {
"@aws-sdk/client-acm": "^3.500.0",
+ "@aws-sdk/client-eventbridge": "^3.500.0",
"@aws-sdk/client-cloudformation": "^3.500.0",
"@aws-sdk/client-cloudwatch": "^3.500.0",
"@aws-sdk/client-cognito-identity-provider": "^3.500.0",
diff --git a/compatibility-tests/sdk-test-node/tests/eventbridge.test.ts b/compatibility-tests/sdk-test-node/tests/eventbridge.test.ts
new file mode 100644
index 0000000000..28c4a80e9f
--- /dev/null
+++ b/compatibility-tests/sdk-test-node/tests/eventbridge.test.ts
@@ -0,0 +1,275 @@
+/**
+ * EventBridge integration tests.
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import {
+ EventBridgeClient,
+ CreateEventBusCommand,
+ DeleteEventBusCommand,
+ DescribeEventBusCommand,
+ ListEventBusesCommand,
+ PutRuleCommand,
+ DeleteRuleCommand,
+ DescribeRuleCommand,
+ ListRulesCommand,
+ EnableRuleCommand,
+ DisableRuleCommand,
+ PutTargetsCommand,
+ RemoveTargetsCommand,
+ ListTargetsByRuleCommand,
+ PutEventsCommand,
+ ListTagsForResourceCommand,
+} from '@aws-sdk/client-eventbridge';
+import {
+ SQSClient,
+ CreateQueueCommand,
+ DeleteQueueCommand,
+ GetQueueAttributesCommand,
+ ReceiveMessageCommand,
+} from '@aws-sdk/client-sqs';
+import { makeClient, uniqueName } from './setup';
+
+describe('EventBridge', () => {
+ let eb: EventBridgeClient;
+ let sqs: SQSClient;
+ let ruleName: string;
+ let busName: string;
+ let ruleArn: string;
+ let sinkQueueUrl: string;
+ let sinkQueueArn: string;
+ let transformerQueueUrl: string;
+ let transformerQueueArn: string;
+
+ beforeAll(() => {
+ eb = makeClient(EventBridgeClient);
+ sqs = makeClient(SQSClient);
+ ruleName = uniqueName('eb-rule');
+ busName = uniqueName('eb-bus');
+ });
+
+ afterAll(async () => {
+ try {
+ await eb.send(new RemoveTargetsCommand({ Rule: ruleName, Ids: ['sqs-target', 'transformer-target'] }));
+ } catch { /* ignore */ }
+ try {
+ await eb.send(new DeleteRuleCommand({ Name: ruleName }));
+ } catch { /* ignore */ }
+ try {
+ await eb.send(new DeleteEventBusCommand({ Name: busName }));
+ } catch { /* ignore */ }
+ try {
+ if (sinkQueueUrl) await sqs.send(new DeleteQueueCommand({ QueueUrl: sinkQueueUrl }));
+ } catch { /* ignore */ }
+ try {
+ if (transformerQueueUrl) await sqs.send(new DeleteQueueCommand({ QueueUrl: transformerQueueUrl }));
+ } catch { /* ignore */ }
+ });
+
+ // ──────────────────────────── Event Buses ────────────────────────────
+
+ it('should create an event bus', async () => {
+ const response = await eb.send(new CreateEventBusCommand({ Name: busName }));
+ expect(response.EventBusArn).toContain(busName);
+ });
+
+ it('should describe an event bus', async () => {
+ const response = await eb.send(new DescribeEventBusCommand({ Name: busName }));
+ expect(response.Name).toBe(busName);
+ expect(response.Arn).toContain(busName);
+ });
+
+ it('should list event buses including default', async () => {
+ const response = await eb.send(new ListEventBusesCommand({}));
+ const names = response.EventBuses!.map(b => b.Name);
+ expect(names).toContain('default');
+ expect(names).toContain(busName);
+ });
+
+ // ──────────────────────────── Rules ────────────────────────────
+
+ it('should create a rule', async () => {
+ const response = await eb.send(new PutRuleCommand({
+ Name: ruleName,
+ EventPattern: JSON.stringify({ source: ['com.myapp'] }),
+ State: 'ENABLED',
+ Description: 'Test rule',
+ }));
+ ruleArn = response.RuleArn!;
+ expect(ruleArn).toContain(ruleName);
+ });
+
+ it('should describe the rule', async () => {
+ const response = await eb.send(new DescribeRuleCommand({ Name: ruleName }));
+ expect(response.Name).toBe(ruleName);
+ expect(response.State).toBe('ENABLED');
+ expect(response.EventPattern).toContain('com.myapp');
+ });
+
+ it('should list rules', async () => {
+ const response = await eb.send(new ListRulesCommand({}));
+ const names = response.Rules!.map(r => r.Name);
+ expect(names).toContain(ruleName);
+ });
+
+ it('should disable and re-enable a rule', async () => {
+ await eb.send(new DisableRuleCommand({ Name: ruleName }));
+ expect((await eb.send(new DescribeRuleCommand({ Name: ruleName }))).State).toBe('DISABLED');
+
+ await eb.send(new EnableRuleCommand({ Name: ruleName }));
+ expect((await eb.send(new DescribeRuleCommand({ Name: ruleName }))).State).toBe('ENABLED');
+ });
+
+ // ──────────────────────────── Targets + PutEvents ────────────────────────────
+
+ it('should create sink SQS queue', async () => {
+ sinkQueueUrl = (await sqs.send(new CreateQueueCommand({ QueueName: uniqueName('eb-sink') }))).QueueUrl!;
+ const attrs = await sqs.send(new GetQueueAttributesCommand({
+ QueueUrl: sinkQueueUrl, AttributeNames: ['QueueArn'],
+ }));
+ sinkQueueArn = attrs.Attributes!['QueueArn'];
+ expect(sinkQueueArn).toBeTruthy();
+ });
+
+ it('should put SQS target on rule', async () => {
+ const response = await eb.send(new PutTargetsCommand({
+ Rule: ruleName,
+ Targets: [{ Id: 'sqs-target', Arn: sinkQueueArn }],
+ }));
+ expect(response.FailedEntryCount).toBe(0);
+ });
+
+ it('should list targets by rule', async () => {
+ const response = await eb.send(new ListTargetsByRuleCommand({ Rule: ruleName }));
+ const ids = response.Targets!.map(t => t.Id);
+ expect(ids).toContain('sqs-target');
+ });
+
+ it('should deliver matching event to SQS target', async () => {
+ await eb.send(new PutEventsCommand({
+ Entries: [{
+ Source: 'com.myapp',
+ DetailType: 'OrderPlaced',
+ Detail: JSON.stringify({ orderId: '123' }),
+ }],
+ }));
+
+ const msg = await sqs.send(new ReceiveMessageCommand({
+ QueueUrl: sinkQueueUrl,
+ MaxNumberOfMessages: 1,
+ WaitTimeSeconds: 2,
+ }));
+ expect(msg.Messages).toHaveLength(1);
+ expect(msg.Messages![0].Body).toContain('com.myapp');
+ expect(msg.Messages![0].Body).toContain('OrderPlaced');
+ });
+
+ it('should not deliver non-matching event', async () => {
+ await eb.send(new PutEventsCommand({
+ Entries: [{
+ Source: 'other.app',
+ DetailType: 'Ignored',
+ Detail: '{}',
+ }],
+ }));
+
+ const msg = await sqs.send(new ReceiveMessageCommand({
+ QueueUrl: sinkQueueUrl,
+ MaxNumberOfMessages: 1,
+ }));
+ expect(msg.Messages ?? []).toHaveLength(0);
+ });
+
+ // ──────────────────────────── InputTransformer ────────────────────────────
+
+ it('should create transformer SQS queue', async () => {
+ transformerQueueUrl = (await sqs.send(new CreateQueueCommand({ QueueName: uniqueName('eb-xform') }))).QueueUrl!;
+ const attrs = await sqs.send(new GetQueueAttributesCommand({
+ QueueUrl: transformerQueueUrl, AttributeNames: ['QueueArn'],
+ }));
+ transformerQueueArn = attrs.Attributes!['QueueArn'];
+ expect(transformerQueueArn).toBeTruthy();
+ });
+
+ it('should put target with InputTransformer', async () => {
+ const response = await eb.send(new PutTargetsCommand({
+ Rule: ruleName,
+ Targets: [{
+ Id: 'transformer-target',
+ Arn: transformerQueueArn,
+ InputTransformer: {
+ InputPathsMap: { src: '$.source', type: '$.detail-type' },
+ InputTemplate: '{"source":"<src>","type":"<type>"}',
+ },
+ }],
+ }));
+ expect(response.FailedEntryCount).toBe(0);
+ });
+
+ it('should store InputTransformer correctly on target', async () => {
+ const response = await eb.send(new ListTargetsByRuleCommand({ Rule: ruleName }));
+ const xformTarget = response.Targets!.find(t => t.Id === 'transformer-target');
+ expect(xformTarget).toBeDefined();
+ expect(xformTarget!.InputTransformer).toBeDefined();
+ expect(xformTarget!.InputTransformer!.InputPathsMap).toHaveProperty('src');
+ expect(xformTarget!.InputTransformer!.InputTemplate).toContain('<src>');
+ });
+
+ it('should transform event payload before delivery', async () => {
+ // Drain any prior messages
+ await sqs.send(new ReceiveMessageCommand({
+ QueueUrl: transformerQueueUrl, MaxNumberOfMessages: 10,
+ }));
+
+ await eb.send(new PutEventsCommand({
+ Entries: [{
+ Source: 'com.myapp',
+ DetailType: 'OrderShipped',
+ Detail: JSON.stringify({ orderId: '456' }),
+ }],
+ }));
+
+ const msg = await sqs.send(new ReceiveMessageCommand({
+ QueueUrl: transformerQueueUrl,
+ MaxNumberOfMessages: 1,
+ WaitTimeSeconds: 2,
+ }));
+ expect(msg.Messages).toHaveLength(1);
+ const body = msg.Messages![0].Body!;
+ expect(body).toContain('com.myapp');
+ expect(body).toContain('OrderShipped');
+ expect(body).not.toContain('orderId');
+ });
+
+ // ──────────────────────────── Tags ────────────────────────────
+
+ it('should list tags for a rule resource', async () => {
+ const response = await eb.send(new ListTagsForResourceCommand({ ResourceARN: ruleArn }));
+ expect(response.Tags).toBeDefined();
+ });
+
+ // ──────────────────────────── Cleanup ────────────────────────────
+
+ it('should remove targets', async () => {
+ const response = await eb.send(new RemoveTargetsCommand({
+ Rule: ruleName,
+ Ids: ['sqs-target', 'transformer-target'],
+ }));
+ expect(response.FailedEntryCount).toBe(0);
+
+ const list = await eb.send(new ListTargetsByRuleCommand({ Rule: ruleName }));
+ expect(list.Targets ?? []).toHaveLength(0);
+ });
+
+ it('should delete the rule', async () => {
+ await eb.send(new DeleteRuleCommand({ Name: ruleName }));
+ await expect(eb.send(new DescribeRuleCommand({ Name: ruleName })))
+ .rejects.toThrow();
+ });
+
+ it('should delete the event bus', async () => {
+ await eb.send(new DeleteEventBusCommand({ Name: busName }));
+ const list = await eb.send(new ListEventBusesCommand({}));
+ expect(list.EventBuses!.map(b => b.Name)).not.toContain(busName);
+ });
+});
diff --git a/src/main/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeHandler.java b/src/main/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeHandler.java
index 171e319ed2..209b47161d 100644
--- a/src/main/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeHandler.java
+++ b/src/main/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeHandler.java
@@ -6,6 +6,7 @@ import io.github.hectorvent.floci.core.common.AwsJson11Controller;
import io.github.hectorvent.floci.services.eventbridge.model.EventBus;
import io.github.hectorvent.floci.services.eventbridge.model.Rule;
import io.github.hectorvent.floci.services.eventbridge.model.RuleState;
+import io.github.hectorvent.floci.services.eventbridge.model.InputTransformer;
import io.github.hectorvent.floci.services.eventbridge.model.Target;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
@@ -178,6 +179,16 @@ public class EventBridgeHandler {
input.isEmpty() ? null : input,
inputPath.isEmpty() ? null : inputPath
);
+ JsonNode transformerNode = t.path("InputTransformer");
+ if (!transformerNode.isMissingNode() && transformerNode.isObject()) {
+ Map<String, String> pathsMap = new HashMap<>();
+ JsonNode pathsNode = transformerNode.path("InputPathsMap");
+ if (pathsNode.isObject()) {
+ pathsNode.fields().forEachRemaining(e -> pathsMap.put(e.getKey(), e.getValue().asText()));
+ }
+ String template = transformerNode.path("InputTemplate").asText(null);
+ target.setInputTransformer(new InputTransformer(pathsMap, template));
+ }
targets.add(target);
}
}
@@ -224,6 +235,14 @@ public class EventBridgeHandler {
if (t.getInputPath() != null) {
node.put("InputPath", t.getInputPath());
}
+ if (t.getInputTransformer() != null) {
+ ObjectNode transformerNode = node.putObject("InputTransformer");
+ ObjectNode pathsNode = transformerNode.putObject("InputPathsMap");
+ t.getInputTransformer().getInputPathsMap().forEach(pathsNode::put);
+ if (t.getInputTransformer().getInputTemplate() != null) {
+ transformerNode.put("InputTemplate", t.getInputTransformer().getInputTemplate());
+ }
+ }
targetsArray.add(node);
}
return Response.ok(response).build();
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 acba6654e9..34fc8d20d6 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
@@ -1,7 +1,10 @@
package io.github.hectorvent.floci.services.eventbridge;
+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.services.eventbridge.model.InputTransformer;
import io.github.hectorvent.floci.services.eventbridge.model.Target;
import io.github.hectorvent.floci.services.lambda.LambdaService;
import io.github.hectorvent.floci.services.lambda.model.InvocationType;
@@ -19,22 +22,32 @@ public class EventBridgeInvoker {
private final LambdaService lambdaService;
private final SqsService sqsService;
private final SnsService snsService;
+ private final ObjectMapper objectMapper;
private final String baseUrl;
@Inject
public EventBridgeInvoker(LambdaService lambdaService,
SqsService sqsService,
SnsService snsService,
+ ObjectMapper objectMapper,
EmulatorConfig config) {
this.lambdaService = lambdaService;
this.sqsService = sqsService;
this.snsService = snsService;
+ this.objectMapper = objectMapper;
this.baseUrl = config.baseUrl();
}
public void invokeTarget(Target target, String eventJson, String region) {
String arn = target.getArn();
- String payload = target.getInput() != null ? target.getInput() : eventJson;
+ String payload;
+ if (target.getInput() != null) {
+ payload = target.getInput();
+ } else if (target.getInputTransformer() != null) {
+ payload = applyInputTransformer(target.getInputTransformer(), eventJson);
+ } else {
+ payload = eventJson;
+ }
try {
if (arn.contains(":lambda:") || arn.contains(":function:")) {
@@ -58,6 +71,37 @@ public class EventBridgeInvoker {
}
}
+ String applyInputTransformer(InputTransformer transformer, String eventJson) {
+ String template = transformer.getInputTemplate();
+ if (template == null) {
+ return eventJson;
+ }
+ String result = template;
+ for (var e : transformer.getInputPathsMap().entrySet()) {
+ String value = extractJsonPath(e.getValue(), eventJson);
+ result = result.replace("<" + e.getKey() + ">", value != null ? value : "");
+ }
+ return result;
+ }
+
+ String extractJsonPath(String jsonPath, String eventJson) {
+ if (jsonPath == null || eventJson == null) {
+ return null;
+ }
+ try {
+ String pointer = (jsonPath.startsWith("$") ? jsonPath.substring(1) : jsonPath)
+ .replace('.', '/');
+ JsonNode node = objectMapper.readTree(eventJson).at(pointer);
+ if (node.isMissingNode() || node.isNull()) {
+ return null;
+ }
+ return node.isTextual() ? node.asText() : node.toString();
+ } catch (Exception e) {
+ LOG.warnv("Failed to extract JSONPath {0}: {1}", jsonPath, e.getMessage());
+ return null;
+ }
+ }
+
private static String extractRegionFromArn(String arn, String defaultRegion) {
String[] parts = arn.split(":");
return parts.length >= 4 && !parts[3].isEmpty() ? parts[3] : defaultRegion;
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 8b75cd3f87..937b1cfe77 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
@@ -458,6 +458,7 @@ public class EventBridgeService {
// ──────────────────────────── Target Routing ────────────────────────────
+
private String buildEventEnvelope(Map<String, Object> entry, String busName, String eventId) {
try {
String source = (String) entry.getOrDefault("Source", "");
diff --git a/src/main/java/io/github/hectorvent/floci/services/eventbridge/model/InputTransformer.java b/src/main/java/io/github/hectorvent/floci/services/eventbridge/model/InputTransformer.java
new file mode 100644
index 0000000000..a81d4eb0fb
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/eventbridge/model/InputTransformer.java
@@ -0,0 +1,30 @@
+package io.github.hectorvent.floci.services.eventbridge.model;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import io.quarkus.runtime.annotations.RegisterForReflection;
+
+import java.util.HashMap;
+import java.util.Map;
+
+@RegisterForReflection
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class InputTransformer {
+
+ private Map<String, String> inputPathsMap = new HashMap<>();
+ private String inputTemplate;
+
+ public InputTransformer() {}
+
+ public InputTransformer(Map<String, String> inputPathsMap, String inputTemplate) {
+ this.inputPathsMap = inputPathsMap != null ? inputPathsMap : new HashMap<>();
+ this.inputTemplate = inputTemplate;
+ }
+
+ public Map<String, String> getInputPathsMap() { return inputPathsMap; }
+ public void setInputPathsMap(Map<String, String> inputPathsMap) {
+ this.inputPathsMap = inputPathsMap != null ? inputPathsMap : new HashMap<>();
+ }
+
+ public String getInputTemplate() { return inputTemplate; }
+ public void setInputTemplate(String inputTemplate) { this.inputTemplate = inputTemplate; }
+}
diff --git a/src/main/java/io/github/hectorvent/floci/services/eventbridge/model/Target.java b/src/main/java/io/github/hectorvent/floci/services/eventbridge/model/Target.java
index d303714a2e..d022913ac7 100644
--- a/src/main/java/io/github/hectorvent/floci/services/eventbridge/model/Target.java
+++ b/src/main/java/io/github/hectorvent/floci/services/eventbridge/model/Target.java
@@ -1,14 +1,17 @@
package io.github.hectorvent.floci.services.eventbridge.model;
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import io.quarkus.runtime.annotations.RegisterForReflection;
@RegisterForReflection
+@JsonIgnoreProperties(ignoreUnknown = true)
public class Target {
private String id;
private String arn;
private String input;
private String inputPath;
+ private InputTransformer inputTransformer;
public Target() {}
@@ -30,4 +33,7 @@ public class Target {
public String getInputPath() { return inputPath; }
public void setInputPath(String inputPath) { this.inputPath = inputPath; }
+
+ public InputTransformer getInputTransformer() { return inputTransformer; }
+ public void setInputTransformer(InputTransformer inputTransformer) { this.inputTransformer = inputTransformer; }
}
diff --git a/src/main/java/io/github/hectorvent/floci/services/s3/S3Controller.java b/src/main/java/io/github/hectorvent/floci/services/s3/S3Controller.java
index 61941df51a..e8a3e3da1d 100644
--- a/src/main/java/io/github/hectorvent/floci/services/s3/S3Controller.java
+++ b/src/main/java/io/github/hectorvent/floci/services/s3/S3Controller.java
@@ -995,6 +995,8 @@ public class S3Controller {
new TopicNotification(parsed.id, parsed.arn, parsed.events, parsed.filterRules));
}
+ config.setEventBridgeEnabled(xml.contains("<EventBridgeConfiguration"));
+
s3Service.putBucketNotificationConfiguration(bucket, config);
return Response.ok().build();
} catch (AwsException e) {
diff --git a/src/main/java/io/github/hectorvent/floci/services/s3/S3Service.java b/src/main/java/io/github/hectorvent/floci/services/s3/S3Service.java
index 6eda76d050..e845d57281 100644
--- a/src/main/java/io/github/hectorvent/floci/services/s3/S3Service.java
+++ b/src/main/java/io/github/hectorvent/floci/services/s3/S3Service.java
@@ -9,6 +9,7 @@ import io.github.hectorvent.floci.core.common.XmlParser;
import io.github.hectorvent.floci.core.storage.StorageBackend;
import io.github.hectorvent.floci.core.storage.StorageFactory;
import io.github.hectorvent.floci.services.s3.model.*;
+import io.github.hectorvent.floci.services.eventbridge.EventBridgeService;
import io.github.hectorvent.floci.services.sns.SnsService;
import io.github.hectorvent.floci.services.sqs.SqsService;
import com.fasterxml.jackson.core.type.TypeReference;
@@ -45,13 +46,16 @@ public class S3Service {
private final SqsService sqsService;
private final SnsService snsService;
+ private final EventBridgeService eventBridgeService;
private final RegionResolver regionResolver;
private final String baseUrl;
private final ObjectMapper objectMapper;
@Inject
public S3Service(StorageFactory storageFactory, EmulatorConfig config,
- SqsService sqsService, SnsService snsService, RegionResolver regionResolver,
+ SqsService sqsService, SnsService snsService,
+ EventBridgeService eventBridgeService,
+ RegionResolver regionResolver,
ObjectMapper objectMapper) {
this(
storageFactory.create("s3", "s3-buckets.json",
@@ -62,7 +66,7 @@ public class S3Service {
}),
Path.of(config.storage().persistentPath()).resolve("s3"),
"memory".equals(config.storage().services().s3().mode().orElse(config.storage().mode())),
- sqsService, snsService, regionResolver, config.effectiveBaseUrl(), objectMapper
+ sqsService, snsService, eventBridgeService, regionResolver, config.effectiveBaseUrl(), objectMapper
);
}
@@ -72,13 +76,14 @@ public class S3Service {
S3Service(StorageBackend<String, Bucket> bucketStore,
StorageBackend<String, S3Object> objectStore,
Path dataRoot, boolean inMemory) {
- this(bucketStore, objectStore, dataRoot, inMemory, null, null, null, "http://localhost:4566",
+ this(bucketStore, objectStore, dataRoot, inMemory, null, null, null, null, "http://localhost:4566",
new ObjectMapper());
}
private S3Service(StorageBackend<String, Bucket> bucketStore,
StorageBackend<String, S3Object> objectStore,
Path dataRoot, boolean inMemory, SqsService sqsService, SnsService snsService,
+ EventBridgeService eventBridgeService,
RegionResolver regionResolver, String baseUrl, ObjectMapper objectMapper) {
this.bucketStore = bucketStore;
this.objectStore = objectStore;
@@ -86,6 +91,7 @@ public class S3Service {
this.inMemory = inMemory;
this.sqsService = sqsService;
this.snsService = snsService;
+ this.eventBridgeService = eventBridgeService;
this.regionResolver = regionResolver;
this.baseUrl = baseUrl;
this.objectMapper = objectMapper;
@@ -1292,7 +1298,7 @@ public class S3Service {
}
private void fireNotifications(String bucketName, String key, String eventName, S3Object obj) {
- if (sqsService == null && snsService == null) {
+ if (sqsService == null && snsService == null && eventBridgeService == null) {
return;
}
Bucket bucket = bucketStore.get(bucketName).orElse(null);
@@ -1328,6 +1334,43 @@ public class S3Service {
}
}
}
+
+ if (config.isEventBridgeEnabled() && eventBridgeService != null) {
+ try {
+ String detailType = eventName.startsWith("ObjectCreated") ? "Object Created" : "Object Deleted";
+ Map<String, Object> entry = new java.util.HashMap<>();
+ entry.put("Source", "aws.s3");
+ entry.put("DetailType", detailType);
+ entry.put("Detail", buildS3EventBridgeDetail(bucketName, key, eventName, obj, region));
+ eventBridgeService.putEvents(List.of(entry), region);
+ LOG.debugv("Fired S3 event {0} to EventBridge default bus", eventName);
+ } catch (Exception e) {
+ LOG.warnv("Failed to deliver S3 event to EventBridge: {0}", e.getMessage());
+ }
+ }
+ }
+
+ private String buildS3EventBridgeDetail(String bucketName, String key, String eventName,
+ S3Object obj, String region) {
+ try {
+ long size = obj != null ? obj.getSize() : 0;
+ String eTag = obj != null && obj.getETag() != null ? obj.getETag().replace("\"", "") : "";
+ ObjectNode detail = objectMapper.createObjectNode();
+ detail.put("version", "0");
+ ObjectNode bucketNode = detail.putObject("bucket");
+ bucketNode.put("name", bucketName);
+ ObjectNode objectNode = detail.putObject("object");
+ objectNode.put("key", key);
+ objectNode.put("size", size);
+ objectNode.put("etag", eTag);
+ detail.put("request-id", UUID.randomUUID().toString());
+ detail.put("requester", "aws:emulator");
+ detail.put("source-ip-address", "127.0.0.1");
+ detail.put("reason", eventName);
+ return objectMapper.writeValueAsString(detail);
+ } catch (Exception e) {
+ return "{}";
+ }
}
private boolean matchesEvent(String pattern, String eventName) {
diff --git a/src/main/java/io/github/hectorvent/floci/services/s3/model/NotificationConfiguration.java b/src/main/java/io/github/hectorvent/floci/services/s3/model/NotificationConfiguration.java
index 24c1b13ea4..47741cd7ec 100644
--- a/src/main/java/io/github/hectorvent/floci/services/s3/model/NotificationConfiguration.java
+++ b/src/main/java/io/github/hectorvent/floci/services/s3/model/NotificationConfiguration.java
@@ -12,6 +12,7 @@ public class NotificationConfiguration {
private List<QueueNotification> queueConfigurations = new ArrayList<>();
private List<TopicNotification> topicConfigurations = new ArrayList<>();
+ private boolean eventBridgeEnabled;
public NotificationConfiguration() {}
@@ -25,7 +26,10 @@ public class NotificationConfiguration {
this.topicConfigurations = topicConfigurations != null ? topicConfigurations : new ArrayList<>();
}
+ public boolean isEventBridgeEnabled() { return eventBridgeEnabled; }
+ public void setEventBridgeEnabled(boolean eventBridgeEnabled) { this.eventBridgeEnabled = eventBridgeEnabled; }
+
public boolean isEmpty() {
- return queueConfigurations.isEmpty() && topicConfigurations.isEmpty();
+ return queueConfigurations.isEmpty() && topicConfigurations.isEmpty() && !eventBridgeEnabled;
}
}
diff --git a/src/test/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeIntegrationTest.java
index 6e291892ea..db93361bc5 100644
--- a/src/test/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeIntegrationTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeIntegrationTest.java
@@ -7,6 +7,7 @@ import org.junit.jupiter.api.*;
import static io.restassured.RestAssured.given;
import static org.hamcrest.Matchers.hasSize;
import static org.hamcrest.Matchers.matchesPattern;
+import static org.hamcrest.Matchers.notNullValue;
@QuarkusTest
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
@@ -16,6 +17,7 @@ class EventBridgeIntegrationTest {
private static final String EVENT_BRIDGE_CONTENT_TYPE = "application/x-amz-json-1.1";
private static String sinkQueueUrl;
+ private static String transformerQueueUrl;
@BeforeAll
static void configureRestAssured() {
@@ -25,10 +27,10 @@ class EventBridgeIntegrationTest {
@Test
@Order(1)
void createSinkQueue() {
- sinkQueueUrl = given()
- .contentType("application/x-amz-json-1.0")
+ sinkQueueUrl = given()
+ .contentType(SQS_CONTENT_TYPE)
.header("X-Amz-Target", "AmazonSQS.CreateQueue")
- .body("{\"QueueName\":\"integration-test-queue\"}")
+ .body("{\"QueueName\":\"eb-integration-sink-queue\"}")
.when()
.post("/")
.then()
@@ -38,11 +40,25 @@ class EventBridgeIntegrationTest {
@Test
@Order(2)
+ void createTransformerQueue() {
+ transformerQueueUrl = given()
+ .contentType(SQS_CONTENT_TYPE)
+ .header("X-Amz-Target", "AmazonSQS.CreateQueue")
+ .body("{\"QueueName\":\"eb-integration-xform-queue\"}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .extract().jsonPath().getString("QueueUrl");
+ }
+
+ @Test
+ @Order(3)
void createEventBridgeRule() {
given()
- .contentType("application/x-amz-json-1.1")
+ .contentType(EVENT_BRIDGE_CONTENT_TYPE)
.header("X-Amz-Target", "AWSEvents.PutRule")
- .body("{\"Name\":\"integration-test-rule\"}")
+ .body("{\"Name\":\"eb-integration-test-rule\",\"EventPattern\":\"{\\\"source\\\":[\\\"com.mycompany.myapp\\\"]}\"}")
.when().post("/")
.then().statusCode(200);
@@ -51,24 +67,57 @@ class EventBridgeIntegrationTest {
.header("X-Amz-Target", "AmazonSQS.GetQueueAttributes")
.body("{\"QueueUrl\":\"" + sinkQueueUrl + "\",\"AttributeNames\":[\"All\"]}")
.when()
- .post("/0000000000/integration-test-queue")
+ .post("/0000000000/eb-integration-sink-queue")
.then()
.statusCode(200)
.extract().jsonPath().getString("Attributes.QueueArn");
given()
- .contentType("application/x-amz-json-1.1")
+ .contentType(EVENT_BRIDGE_CONTENT_TYPE)
.header("X-Amz-Target", "AWSEvents.PutTargets")
- .body("{\"Rule\":\"integration-test-rule\",\"Targets\":[{\"Arn\":\"" + queueArn+"\"}]}")
+ .body("{\"Rule\":\"eb-integration-test-rule\",\"Targets\":[{\"Id\":\"1\",\"Arn\":\"" + queueArn + "\"}]}")
.when().post("/")
.then().statusCode(200);
}
@Test
- @Order(3)
+ @Order(4)
+ void createInputTransformerTarget() {
+ String queueArn = given()
+ .contentType(SQS_CONTENT_TYPE)
+ .header("X-Amz-Target", "AmazonSQS.GetQueueAttributes")
+ .body("{\"QueueUrl\":\"" + transformerQueueUrl + "\",\"AttributeNames\":[\"All\"]}")
+ .when()
+ .post("/0000000000/eb-integration-xform-queue")
+ .then()
+ .statusCode(200)
+ .extract().jsonPath().getString("Attributes.QueueArn");
+
+ given()
+ .contentType(EVENT_BRIDGE_CONTENT_TYPE)
+ .header("X-Amz-Target", "AWSEvents.PutTargets")
+ .body("""
+ {
+ "Rule": "eb-integration-test-rule",
+ "Targets": [{
+ "Id": "2",
+ "Arn": "%s",
+ "InputTransformer": {
+ "InputPathsMap": {"src": "$.source", "detail": "$.detail-type"},
+ "InputTemplate": "{\\"source\\":\\"<src>\\",\\"type\\":\\"<detail>\\"}"
+ }
+ }]
+ }
+ """.formatted(queueArn))
+ .when().post("/")
+ .then().statusCode(200);
+ }
+
+ @Test
+ @Order(5)
void publishEventAndExpectMessageInQueue() {
given()
- .contentType("application/x-amz-json-1.1")
+ .contentType(EVENT_BRIDGE_CONTENT_TYPE)
.header("X-Amz-Target", "AWSEvents.PutEvents")
.body("""
{
@@ -89,7 +138,7 @@ class EventBridgeIntegrationTest {
.then().statusCode(200);
String expectedMessage = "\\{\"version\":\"0\",\"id\":\"[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\",\"source\":\"com.mycompany.myapp\"," +
- "\"detail-type\":\"myDetailType\",\"account\":\"000000000000\",\"time\":\"[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}.[0-9]{9}Z\"," +
+ "\"detail-type\":\"myDetailType\",\"account\":\"000000000000\",\"time\":\"[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}\\.[0-9]+Z\"," +
"\"region\":\"us-east-1\",\"resources\":\\[\"resource1\",\"resource2\"],\"detail\":\\{\"key1\":\"value1\",\"key2\":\"value2\"},\"event-bus-name\":\"default\"}";
given()
@@ -97,10 +146,48 @@ class EventBridgeIntegrationTest {
.header("X-Amz-Target", "AmazonSQS.ReceiveMessage")
.body("{\"QueueUrl\":\"" + sinkQueueUrl + "\",\"MaxNumberOfMessages\":1}")
.when()
- .post("/0000000000/integration-test-queue")
+ .post("/0000000000/eb-integration-sink-queue")
.then()
.statusCode(200)
.body("Messages", hasSize(1))
.body("Messages[0].Body", matchesPattern(expectedMessage));
}
+
+ @Test
+ @Order(6)
+ void putEvents_inputTransformer_transformsPayload() {
+ // Drain any prior messages from the transformer queue
+ given()
+ .contentType(SQS_CONTENT_TYPE)
+ .header("X-Amz-Target", "AmazonSQS.ReceiveMessage")
+ .body("{\"QueueUrl\":\"" + transformerQueueUrl + "\",\"MaxNumberOfMessages\":10}")
+ .when()
+ .post("/0000000000/eb-integration-xform-queue");
+
+ given()
+ .contentType(EVENT_BRIDGE_CONTENT_TYPE)
+ .header("X-Amz-Target", "AWSEvents.PutEvents")
+ .body("""
+ {
+ "Entries": [{
+ "Source": "com.mycompany.myapp",
+ "Detail": "{\\"orderId\\":\\"456\\"}",
+ "DetailType": "OrderPlaced"
+ }]
+ }
+ """)
+ .when().post("/")
+ .then().statusCode(200);
+
+ given()
+ .contentType(SQS_CONTENT_TYPE)
+ .header("X-Amz-Target", "AmazonSQS.ReceiveMessage")
+ .body("{\"QueueUrl\":\"" + transformerQueueUrl + "\",\"MaxNumberOfMessages\":1}")
+ .when()
+ .post("/0000000000/eb-integration-xform-queue")
+ .then()
+ .statusCode(200)
+ .body("Messages", hasSize(1))
+ .body("Messages[0].Body", notNullValue());
+ }
}
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
new file mode 100644
index 0000000000..a1e701fb55
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeInvokerTest.java
@@ -0,0 +1,80 @@
+package io.github.hectorvent.floci.services.eventbridge;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.github.hectorvent.floci.services.eventbridge.model.InputTransformer;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.mock;
+
+class EventBridgeInvokerTest {
+
+ private EventBridgeInvoker invoker;
+
+ @BeforeEach
+ void setUp() {
+ invoker = new EventBridgeInvoker(
+ mock(io.github.hectorvent.floci.services.lambda.LambdaService.class),
+ mock(io.github.hectorvent.floci.services.sqs.SqsService.class),
+ mock(io.github.hectorvent.floci.services.sns.SnsService.class),
+ new ObjectMapper(),
+ mock(io.github.hectorvent.floci.config.EmulatorConfig.class)
+ );
+ }
+
+ @Test
+ void extractJsonPath_topLevelField() {
+ String event = "{\"source\":\"aws.s3\",\"detail-type\":\"Object Created\"}";
+ assertEquals("aws.s3", invoker.extractJsonPath("$.source", event));
+ }
+
+ @Test
+ void extractJsonPath_nestedField() {
+ String event = "{\"detail\":{\"bucket\":{\"name\":\"my-bucket\"},\"object\":{\"key\":\"file.txt\"}}}";
+ assertEquals("my-bucket", invoker.extractJsonPath("$.detail.bucket.name", event));
+ assertEquals("file.txt", invoker.extractJsonPath("$.detail.object.key", event));
+ }
+
+ @Test
+ void extractJsonPath_missingField_returnsNull() {
+ String event = "{\"source\":\"aws.s3\"}";
+ assertNull(invoker.extractJsonPath("$.detail.bucket.name", event));
+ }
+
+ @Test
+ void extractJsonPath_nonTextualValueReturnsRawJson() {
+ String event = "{\"detail\":{\"size\":42}}";
+ assertEquals("42", invoker.extractJsonPath("$.detail.size", event));
+ }
+
+ @Test
+ void applyInputTransformer_substitutesVariables() {
+ String eventJson = "{\"source\":\"aws.s3\",\"detail\":{\"bucket\":{\"name\":\"my-bucket\"},\"object\":{\"key\":\"photos/cat.jpg\"}}}";
+ InputTransformer transformer = new InputTransformer(
+ Map.of("bucket", "$.detail.bucket.name", "key", "$.detail.object.key"),
+ "{\"bucket\": \"<bucket>\", \"key\": \"<key>\"}"
+ );
+ String result = invoker.applyInputTransformer(transformer, eventJson);
+ assertEquals("{\"bucket\": \"my-bucket\", \"key\": \"photos/cat.jpg\"}", result);
+ }
+
+ @Test
+ void applyInputTransformer_missingPath_substituteEmpty() {
+ String eventJson = "{\"source\":\"aws.s3\"}";
+ InputTransformer transformer = new InputTransformer(
+ Map.of("bucket", "$.detail.bucket.name"),
+ "bucket=<bucket>"
+ );
+ assertEquals("bucket=", invoker.applyInputTransformer(transformer, eventJson));
+ }
+
+ @Test
+ void applyInputTransformer_nullTemplate_returnsEventJson() {
+ String eventJson = "{\"source\":\"aws.s3\"}";
+ InputTransformer transformer = new InputTransformer(Map.of(), null);
+ assertEquals(eventJson, invoker.applyInputTransformer(transformer, eventJson));
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeSchedulerIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeSchedulerIntegrationTest.java
index 4016974815..0f747761bb 100644
--- a/src/test/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeSchedulerIntegrationTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeSchedulerIntegrationTest.java
@@ -37,7 +37,7 @@ class EventBridgeSchedulerIntegrationTest {
StorageBackend<String, Rule> ruleStore = new InMemoryStorage<>();
StorageBackend<String, List<Target>> targetStore = new InMemoryStorage<>();
- EventBridgeInvoker invoker = new EventBridgeInvoker(null, null, null, createConfig());
+ EventBridgeInvoker invoker = new EventBridgeInvoker(null, null, null, new ObjectMapper(), createConfig());
scheduler = new RuleScheduler(vertx, createConfig(), new ObjectMapper(), invoker);
eventBridgeService = new EventBridgeService(
diff --git a/src/test/java/io/github/hectorvent/floci/services/s3/S3EventBridgeIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/s3/S3EventBridgeIntegrationTest.java
new file mode 100644
index 0000000000..8d2195a9e0
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/s3/S3EventBridgeIntegrationTest.java
@@ -0,0 +1,251 @@
+package io.github.hectorvent.floci.services.s3;
+
+import io.quarkus.test.junit.QuarkusTest;
+import io.restassured.RestAssured;
+import io.restassured.config.EncoderConfig;
+import io.restassured.http.ContentType;
+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 static io.restassured.RestAssured.given;
+import static org.hamcrest.Matchers.*;
+
+@QuarkusTest
+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+class S3EventBridgeIntegrationTest {
+
+ private static final String EB_CONTENT_TYPE = "application/x-amz-json-1.1";
+ private static final String EB_TARGET = "AWSEvents.";
+
+ private static String ruleArn;
+ private static String queueUrl;
+
+ @BeforeAll
+ static void configureRestAssured() {
+ RestAssured.config = RestAssured.config().encoderConfig(
+ EncoderConfig.encoderConfig()
+ .encodeContentTypeAs(EB_CONTENT_TYPE, ContentType.TEXT));
+ }
+
+ @Test
+ @Order(1)
+ void createBucket_forEventBridgeTest() {
+ given()
+ .when()
+ .put("/eb-s3-test-bucket")
+ .then()
+ .statusCode(200);
+ }
+
+ @Test
+ @Order(2)
+ void createQueue_forEventBridgeDelivery() {
+ queueUrl = given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "CreateQueue")
+ .formParam("QueueName", "s3-eb-delivery-queue")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .extract().xmlPath().getString("CreateQueueResponse.CreateQueueResult.QueueUrl");
+ }
+
+ @Test
+ @Order(3)
+ void putRule_forS3Events() {
+ ruleArn = given()
+ .contentType(EB_CONTENT_TYPE)
+ .header("X-Amz-Target", EB_TARGET + "PutRule")
+ .body("""
+ {
+ "Name": "s3-event-rule",
+ "EventPattern": "{\\"source\\":[\\"aws.s3\\"]}",
+ "State": "ENABLED"
+ }
+ """)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("RuleArn", notNullValue())
+ .extract().path("RuleArn");
+ }
+
+ @Test
+ @Order(4)
+ void putTarget_sqsForS3Rule() {
+ String queueArn = given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "GetQueueAttributes")
+ .formParam("QueueUrl", queueUrl)
+ .formParam("AttributeName.1", "QueueArn")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .extract().xmlPath().getString("**.find { it.Name == 'QueueArn' }.Value");
+
+ given()
+ .contentType(EB_CONTENT_TYPE)
+ .header("X-Amz-Target", EB_TARGET + "PutTargets")
+ .body("""
+ {
+ "Rule": "s3-event-rule",
+ "Targets": [{"Id": "1", "Arn": "%s"}]
+ }
+ """.formatted(queueArn))
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("FailedEntryCount", equalTo(0));
+ }
+
+ @Test
+ @Order(5)
+ void putBucketNotification_enableEventBridge() {
+ given()
+ .contentType("application/xml")
+ .body("""
+ <NotificationConfiguration>
+ <EventBridgeConfiguration/>
+ </NotificationConfiguration>
+ """)
+ .when()
+ .put("/eb-s3-test-bucket?notification")
+ .then()
+ .statusCode(200);
+ }
+
+ @Test
+ @Order(6)
+ void putObject_triggersEventBridgeDelivery() {
+ given()
+ .contentType("text/plain")
+ .body("hello from s3 eventbridge test")
+ .when()
+ .put("/eb-s3-test-bucket/test-object.txt")
+ .then()
+ .statusCode(200);
+
+ String messageBody = given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "ReceiveMessage")
+ .formParam("QueueUrl", queueUrl)
+ .formParam("MaxNumberOfMessages", "1")
+ .formParam("WaitTimeSeconds", "0")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .extract().xmlPath().getString("ReceiveMessageResponse.ReceiveMessageResult.Message.Body");
+
+ assert messageBody != null : "Expected a message in the queue after S3 put";
+ assert messageBody.contains("aws.s3") : "Expected source aws.s3 in: " + messageBody;
+ assert messageBody.contains("Object Created") : "Expected detail-type 'Object Created' in: " + messageBody;
+ assert messageBody.contains("eb-s3-test-bucket") : "Expected bucket name in: " + messageBody;
+ assert messageBody.contains("test-object.txt") : "Expected object key in: " + messageBody;
+ }
+
+ @Test
+ @Order(7)
+ void deleteObject_triggersEventBridgeDelivery() {
+ given()
+ .when()
+ .delete("/eb-s3-test-bucket/test-object.txt")
+ .then()
+ .statusCode(anyOf(equalTo(204), equalTo(200)));
+
+ String messageBody = given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "ReceiveMessage")
+ .formParam("QueueUrl", queueUrl)
+ .formParam("MaxNumberOfMessages", "1")
+ .formParam("WaitTimeSeconds", "0")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .extract().xmlPath().getString("ReceiveMessageResponse.ReceiveMessageResult.Message.Body");
+
+ assert messageBody != null : "Expected a message in the queue after S3 delete";
+ assert messageBody.contains("aws.s3") : "Expected source aws.s3 in: " + messageBody;
+ assert messageBody.contains("Object Deleted") : "Expected detail-type 'Object Deleted' in: " + messageBody;
+ }
+
+ @Test
+ @Order(8)
+ void disableEventBridge_noMoreNotifications() {
+ // Replace notification config with empty — no EventBridgeConfiguration
+ given()
+ .contentType("application/xml")
+ .body("<NotificationConfiguration/>")
+ .when()
+ .put("/eb-s3-test-bucket?notification")
+ .then()
+ .statusCode(200);
+
+ // Drain any leftover messages
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "ReceiveMessage")
+ .formParam("QueueUrl", queueUrl)
+ .formParam("MaxNumberOfMessages", "10")
+ .when()
+ .post("/");
+
+ // Put a new object — should NOT deliver to EventBridge
+ given()
+ .contentType("text/plain")
+ .body("quiet upload")
+ .when()
+ .put("/eb-s3-test-bucket/quiet.txt")
+ .then()
+ .statusCode(200);
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "ReceiveMessage")
+ .formParam("QueueUrl", queueUrl)
+ .formParam("MaxNumberOfMessages", "1")
+ .formParam("WaitTimeSeconds", "0")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body(not(containsString("aws.s3")));
+ }
+
+ @Test
+ @Order(100)
+ void cleanup() {
+ given()
+ .contentType(EB_CONTENT_TYPE)
+ .header("X-Amz-Target", EB_TARGET + "RemoveTargets")
+ .body("""
+ {"Rule": "s3-event-rule", "Ids": ["1"]}
+ """)
+ .when()
+ .post("/");
+
+ given()
+ .contentType(EB_CONTENT_TYPE)
+ .header("X-Amz-Target", EB_TARGET + "DeleteRule")
+ .body("""
+ {"Name": "s3-event-rule"}
+ """)
+ .when()
+ .post("/");
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "DeleteQueue")
+ .formParam("QueueUrl", queueUrl)
+ .when()
+ .post("/");
+ }
+}