Light, fluffy, and always free - The AWS Local Emulator alternative
feat(s3): support Filter rules in PutBucketNotificationConfiguration (#178)
fgueryef06fc34933b
diff --git a/src/main/java/io/github/hectorvent/floci/core/common/XmlParser.java b/src/main/java/io/github/hectorvent/floci/core/common/XmlParser.javaindex 4ef4dd1a31..5ed1fa2881 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/XmlParser.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/XmlParser.java@@ -34,6 +34,41 @@ public final class XmlParser {private XmlParser() {}+ /**+ * Reads the text content of the current element if it is a leaf (contains only text).+ * If the element contains nested child elements, the entire subtree is skipped+ * and {@code null} is returned.+ *+ * <p>After this method returns, the reader is positioned on the END_ELEMENT+ * of the element that was open when the method was called.+ */+ private static String readLeafText(XMLStreamReader r) throws XMLStreamException {+ StringBuilder sb = new StringBuilder();+ while (r.hasNext()) {+ int event = r.next();+ if (event == XMLStreamConstants.CHARACTERS || event == XMLStreamConstants.CDATA) {+ sb.append(r.getText());+ } else if (event == XMLStreamConstants.START_ELEMENT) {+ // Not a leaf — skip the child subtree, then continue+ // consuming until we reach our own END_ELEMENT.+ // depth starts at 2: 1 for ourselves (the element readLeafText+ // was called for) + 1 for the child START we just saw.+ int depth = 2;+ while (r.hasNext()) {+ int e = r.next();+ if (e == XMLStreamConstants.START_ELEMENT) depth++;+ else if (e == XMLStreamConstants.END_ELEMENT) {+ if (--depth == 0) break;+ }+ }+ return null;+ } else if (event == XMLStreamConstants.END_ELEMENT) {+ break;+ }+ }+ return sb.toString();+ }+/*** Extracts the text content of every element whose local name matches {@code elementName}.*@@ -153,8 +188,10 @@ public final class XmlParser {current = new LinkedHashMap<>();depth = 1;} else if (current != null && depth == 1) {- String text = r.getElementText();- current.computeIfAbsent(local, k -> new ArrayList<>()).add(text);+ String text = readLeafText(r);+ if (text != null) {+ current.computeIfAbsent(local, k -> new ArrayList<>()).add(text);+ }} else if (current != null) {depth++;}@@ -201,8 +238,10 @@ public final class XmlParser {current = new LinkedHashMap<>();depth = 1;} else if (current != null && depth == 1) {- String text = r.getElementText();- current.put(local, text);+ String text = readLeafText(r);+ if (text != null) {+ current.put(local, text);+ }} else if (current != null) {depth++;}@@ -220,4 +259,60 @@ public final class XmlParser {} catch (XMLStreamException ignored) {}return result;}++ /**+ * Extracts key/value pairs from a repeating {@code pairElement} nested at any depth+ * inside each {@code parentElement} group, returning one map per group.+ *+ * <p>The outer list is index-aligned with the result of+ * {@link #extractGroupsMulti(String, String)} for the same {@code parentElement}.+ *+ * <p>Example — extracts S3 notification filter rules:+ * <pre>{@code+ * List<Map<String,String>> filters = XmlParser.extractPairsPerGroup(+ * body, "QueueConfiguration", "FilterRule", "Name", "Value");+ * // filters.get(0) → {prefix=images/, suffix=.jpg}+ * }</pre>+ */+ public static List<Map<String, String>> extractPairsPerGroup(+ String xml, String parentElement,+ String pairElement, String keyElement, String valueElement) {+ List<Map<String, String>> result = new ArrayList<>();+ if (xml == null || xml.isEmpty()) {+ return result;+ }+ try {+ XMLStreamReader r = FACTORY.createXMLStreamReader(new StringReader(xml));+ Map<String, String> current = null;+ boolean inPair = false;+ String pendingKey = null;+ while (r.hasNext()) {+ int event = r.next();+ if (event == XMLStreamConstants.START_ELEMENT) {+ String local = r.getLocalName();+ if (parentElement.equals(local)) {+ current = new LinkedHashMap<>();+ } else if (current != null && pairElement.equals(local)) {+ inPair = true;+ pendingKey = null;+ } else if (inPair && keyElement.equals(local)) {+ pendingKey = r.getElementText();+ } else if (inPair && valueElement.equals(local) && pendingKey != null) {+ current.put(pendingKey, r.getElementText());+ pendingKey = null;+ }+ } else if (event == XMLStreamConstants.END_ELEMENT) {+ String local = r.getLocalName();+ if (parentElement.equals(local) && current != null) {+ result.add(current);+ current = null;+ } else if (pairElement.equals(local)) {+ inPair = false;+ }+ }+ }+ r.close();+ } catch (XMLStreamException ignored) {}+ return result;+ }}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.javaindex 2a7aa9d61a..6ac38f740c 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@@ -9,6 +9,7 @@ import io.github.hectorvent.floci.services.s3.model.Bucket;import io.github.hectorvent.floci.services.s3.model.GetObjectAttributesParts;import io.github.hectorvent.floci.services.s3.model.GetObjectAttributesResult;import io.github.hectorvent.floci.services.s3.model.MultipartUpload;+import io.github.hectorvent.floci.services.s3.model.FilterRule;import io.github.hectorvent.floci.services.s3.model.NotificationConfiguration;import io.github.hectorvent.floci.services.s3.model.ObjectAttributeName;import io.github.hectorvent.floci.services.s3.model.QueueNotification;@@ -30,6 +31,7 @@ import java.nio.charset.StandardCharsets;import java.time.Instant;import java.time.ZoneId;import java.time.format.DateTimeFormatter;+import java.util.ArrayList;import java.util.Arrays;import java.util.LinkedHashMap;import java.util.List;@@ -848,6 +850,7 @@ public class S3Controller {for (String event : qn.events()) {xml.elem("Event", event);}+ appendFilterRules(xml, qn.filterRules());xml.end("QueueConfiguration");}for (TopicNotification tn : config.getTopicConfigurations()) {@@ -857,6 +860,7 @@ public class S3Controller {for (String event : tn.events()) {xml.elem("Event", event);}+ appendFilterRules(xml, tn.filterRules());xml.end("TopicConfiguration");}xml.end("NotificationConfiguration");@@ -871,24 +875,13 @@ public class S3Controller {String xml = new String(body, StandardCharsets.UTF_8);NotificationConfiguration config = new NotificationConfiguration();- var queueConfigs = XmlParser.extractGroupsMulti(xml, "QueueConfiguration");- for (var group : queueConfigs) {- String id = group.getOrDefault("Id", List.of("")).get(0);- List<String> queueArns = group.get("Queue");- List<String> events = group.get("Event");- if (queueArns != null && !queueArns.isEmpty() && events != null && !events.isEmpty()) {- config.getQueueConfigurations().add(new QueueNotification(id, queueArns.get(0), events));- }+ for (var parsed : parseNotificationGroups(xml, "QueueConfiguration", "Queue")) {+ config.getQueueConfigurations().add(+ new QueueNotification(parsed.id, parsed.arn, parsed.events, parsed.filterRules));}-- var topicConfigs = XmlParser.extractGroupsMulti(xml, "TopicConfiguration");- for (var group : topicConfigs) {- String id = group.getOrDefault("Id", List.of("")).get(0);- List<String> topicArns = group.get("Topic");- List<String> events = group.get("Event");- if (topicArns != null && !topicArns.isEmpty() && events != null && !events.isEmpty()) {- config.getTopicConfigurations().add(new TopicNotification(id, topicArns.get(0), events));- }+ for (var parsed : parseNotificationGroups(xml, "TopicConfiguration", "Topic")) {+ config.getTopicConfigurations().add(+ new TopicNotification(parsed.id, parsed.arn, parsed.events, parsed.filterRules));}s3Service.putBucketNotificationConfiguration(bucket, config);@@ -898,6 +891,44 @@ public class S3Controller {}}+ private record ParsedNotificationGroup(String id, String arn, List<String> events,+ List<FilterRule> filterRules) {}++ private static List<ParsedNotificationGroup> parseNotificationGroups(+ String xml, String groupElement, String arnElement) {+ var groups = XmlParser.extractGroupsMulti(xml, groupElement);+ var filters = XmlParser.extractPairsPerGroup(xml, groupElement,+ "FilterRule", "Name", "Value");+ List<ParsedNotificationGroup> result = new ArrayList<>();+ for (int i = 0; i < groups.size(); i++) {+ var group = groups.get(i);+ String id = group.getOrDefault("Id", List.of("")).getFirst();+ List<String> arns = group.get(arnElement);+ List<String> events = group.get("Event");+ if (arns != null && !arns.isEmpty() && events != null && !events.isEmpty()) {+ List<FilterRule> rules = i < filters.size()+ ? filters.get(i).entrySet().stream()+ .map(e -> new FilterRule(e.getKey(), e.getValue()))+ .toList()+ : List.of();+ result.add(new ParsedNotificationGroup(id, arns.getFirst(), events, rules));+ }+ }+ return result;+ }++ private static void appendFilterRules(XmlBuilder xml, List<FilterRule> rules) {+ if (rules == null || rules.isEmpty()) return;+ xml.start("Filter").start("S3Key");+ for (FilterRule rule : rules) {+ xml.start("FilterRule")+ .elem("Name", rule.name())+ .elem("Value", rule.value())+ .end("FilterRule");+ }+ xml.end("S3Key").end("Filter");+ }+/*** Strips the {@code aws-chunked} token from a {@code Content-Encoding} value before persisting it.* {@code aws-chunked} is a transfer-protocol marker used by AWS SDK v2 streaming uploads and is notdiff --git a/src/main/java/io/github/hectorvent/floci/services/s3/S3Service.java b/src/main/java/io/github/hectorvent/floci/services/s3/S3Service.javaindex 65f7349d66..dd47e55d03 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@@ -1143,7 +1143,7 @@ public class S3Service {String eventJson = buildS3EventJson(bucketName, key, eventName, obj, region, bucket.isVersioningEnabled());for (QueueNotification qn : config.getQueueConfigurations()) {- if (qn.events().stream().anyMatch(p -> matchesEvent(p, eventName))) {+ if (qn.events().stream().anyMatch(p -> matchesEvent(p, eventName)) && qn.matchesKey(key)) {try {sqsService.sendMessage(sqsUrlFromArn(qn.queueArn()), eventJson, 0);LOG.debugv("Fired S3 event {0} to SQS {1}", eventName, qn.queueArn());@@ -1154,7 +1154,7 @@ public class S3Service {}for (TopicNotification tn : config.getTopicConfigurations()) {- if (tn.events().stream().anyMatch(p -> matchesEvent(p, eventName))) {+ if (tn.events().stream().anyMatch(p -> matchesEvent(p, eventName)) && tn.matchesKey(key)) {try {snsService.publish(tn.topicArn(), null, eventJson, "Amazon S3 Notification", region);LOG.debugv("Fired S3 event {0} to SNS {1}", eventName, tn.topicArn());diff --git a/src/main/java/io/github/hectorvent/floci/services/s3/model/FilterRule.java b/src/main/java/io/github/hectorvent/floci/services/s3/model/FilterRule.javanew file mode 100644index 0000000000..49387e632d--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/s3/model/FilterRule.java@@ -0,0 +1,22 @@+package io.github.hectorvent.floci.services.s3.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++/**+ * A single S3 notification filter rule (prefix or suffix match on the object key).+ *+ * @param name "prefix" or "suffix"+ * @param value the value to match against+ */+@RegisterForReflection+public record FilterRule(String name, String value) {++ public boolean matches(String key) {+ if (key == null || name == null || value == null) return false;+ return switch (name.toLowerCase()) {+ case "prefix" -> key.startsWith(value);+ case "suffix" -> key.endsWith(value);+ default -> false;+ };+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/s3/model/QueueNotification.java b/src/main/java/io/github/hectorvent/floci/services/s3/model/QueueNotification.javaindex 1442e113ae..c8b0bf02f4 100644--- a/src/main/java/io/github/hectorvent/floci/services/s3/model/QueueNotification.java+++ b/src/main/java/io/github/hectorvent/floci/services/s3/model/QueueNotification.java@@ -5,4 +5,13 @@ import io.quarkus.runtime.annotations.RegisterForReflection;import java.util.List;@RegisterForReflection-public record QueueNotification(String id, String queueArn, List<String> events) {}+public record QueueNotification(String id, String queueArn, List<String> events, List<FilterRule> filterRules) {++ public QueueNotification(String id, String queueArn, List<String> events) {+ this(id, queueArn, events, List.of());+ }++ public boolean matchesKey(String key) {+ return filterRules == null || filterRules.isEmpty() || filterRules.stream().allMatch(r -> r.matches(key));+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/s3/model/TopicNotification.java b/src/main/java/io/github/hectorvent/floci/services/s3/model/TopicNotification.javaindex 6994da551d..328b2f29e1 100644--- a/src/main/java/io/github/hectorvent/floci/services/s3/model/TopicNotification.java+++ b/src/main/java/io/github/hectorvent/floci/services/s3/model/TopicNotification.java@@ -5,4 +5,13 @@ import io.quarkus.runtime.annotations.RegisterForReflection;import java.util.List;@RegisterForReflection-public record TopicNotification(String id, String topicArn, List<String> events) {}+public record TopicNotification(String id, String topicArn, List<String> events, List<FilterRule> filterRules) {++ public TopicNotification(String id, String topicArn, List<String> events) {+ this(id, topicArn, events, List.of());+ }++ public boolean matchesKey(String key) {+ return filterRules == null || filterRules.isEmpty() || filterRules.stream().allMatch(r -> r.matches(key));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/core/common/XmlParserTest.java b/src/test/java/io/github/hectorvent/floci/core/common/XmlParserTest.javanew file mode 100644index 0000000000..bbf0c74b33--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/core/common/XmlParserTest.java@@ -0,0 +1,216 @@+package io.github.hectorvent.floci.core.common;++import org.junit.jupiter.api.Test;++import java.util.List;+import java.util.Map;++import static org.junit.jupiter.api.Assertions.*;++class XmlParserTest {++ // --- extractGroupsMulti: nested element resilience ---++ @Test+ void extractGroupsMultiSkipsNestedElementsAndParsesLeaves() {+ String xml = """+ <Root>+ <Group>+ <Id>g1</Id>+ <Arn>arn:example</Arn>+ <Event>event:one</Event>+ <Nested>+ <Deep>value</Deep>+ </Nested>+ </Group>+ </Root>+ """;++ List<Map<String, List<String>>> groups = XmlParser.extractGroupsMulti(xml, "Group");++ assertEquals(1, groups.size());+ assertEquals(List.of("g1"), groups.get(0).get("Id"));+ assertEquals(List.of("arn:example"), groups.get(0).get("Arn"));+ assertEquals(List.of("event:one"), groups.get(0).get("Event"));+ assertNull(groups.get(0).get("Nested"));+ }++ @Test+ void extractGroupsMultiNestedElementBeforeLeaves() {+ String xml = """+ <Root>+ <Group>+ <Nested><Child>x</Child></Nested>+ <Name>after-nested</Name>+ </Group>+ </Root>+ """;++ List<Map<String, List<String>>> groups = XmlParser.extractGroupsMulti(xml, "Group");++ assertEquals(1, groups.size());+ assertEquals(List.of("after-nested"), groups.get(0).get("Name"));+ }++ @Test+ void extractGroupsMultiMultipleGroupsWithAndWithoutNested() {+ String xml = """+ <Root>+ <Group>+ <Key>a</Key>+ </Group>+ <Group>+ <Key>b</Key>+ <Container><Inner>skip</Inner></Container>+ </Group>+ </Root>+ """;++ List<Map<String, List<String>>> groups = XmlParser.extractGroupsMulti(xml, "Group");++ assertEquals(2, groups.size());+ assertEquals(List.of("a"), groups.get(0).get("Key"));+ assertEquals(List.of("b"), groups.get(1).get("Key"));+ }++ // --- extractGroups: same resilience for single-value variant ---++ @Test+ void extractGroupsSkipsNestedElements() {+ String xml = """+ <Root>+ <Group>+ <Name>test</Name>+ <Nested><Deep>skip</Deep></Nested>+ <Value>kept</Value>+ </Group>+ </Root>+ """;++ List<Map<String, String>> groups = XmlParser.extractGroups(xml, "Group");++ assertEquals(1, groups.size());+ assertEquals("test", groups.get(0).get("Name"));+ assertEquals("kept", groups.get(0).get("Value"));+ assertNull(groups.get(0).get("Nested"));+ }++ // --- extractPairsPerGroup ---++ @Test+ void extractPairsPerGroupBasic() {+ String xml = """+ <Root>+ <Group>+ <Leaf>text</Leaf>+ <Wrapper>+ <Pair>+ <Key>color</Key>+ <Val>red</Val>+ </Pair>+ </Wrapper>+ </Group>+ </Root>+ """;++ List<Map<String, String>> pairs =+ XmlParser.extractPairsPerGroup(xml, "Group", "Pair", "Key", "Val");++ assertEquals(1, pairs.size());+ assertEquals("red", pairs.get(0).get("color"));+ }++ @Test+ void extractPairsPerGroupMultiplePairsPerGroup() {+ String xml = """+ <Root>+ <Group>+ <Wrapper>+ <Rule><Name>prefix</Name><Value>images/</Value></Rule>+ <Rule><Name>suffix</Name><Value>.jpg</Value></Rule>+ </Wrapper>+ </Group>+ </Root>+ """;++ List<Map<String, String>> pairs =+ XmlParser.extractPairsPerGroup(xml, "Group", "Rule", "Name", "Value");++ assertEquals(1, pairs.size());+ assertEquals("images/", pairs.get(0).get("prefix"));+ assertEquals(".jpg", pairs.get(0).get("suffix"));+ }++ @Test+ void extractPairsPerGroupMultipleGroups() {+ String xml = """+ <Root>+ <Group>+ <Tag><Key>env</Key><Val>prod</Val></Tag>+ </Group>+ <Group>+ <Tag><Key>team</Key><Val>infra</Val></Tag>+ <Tag><Key>cost</Key><Val>shared</Val></Tag>+ </Group>+ </Root>+ """;++ List<Map<String, String>> pairs =+ XmlParser.extractPairsPerGroup(xml, "Group", "Tag", "Key", "Val");++ assertEquals(2, pairs.size());+ assertEquals(Map.of("env", "prod"), pairs.get(0));+ assertEquals(Map.of("team", "infra", "cost", "shared"), pairs.get(1));+ }++ @Test+ void extractPairsPerGroupEmptyWhenNoPairsFound() {+ String xml = """+ <Root>+ <Group>+ <Name>no-pairs-here</Name>+ </Group>+ </Root>+ """;++ List<Map<String, String>> pairs =+ XmlParser.extractPairsPerGroup(xml, "Group", "Pair", "Key", "Value");++ assertEquals(1, pairs.size());+ assertTrue(pairs.get(0).isEmpty());+ }++ @Test+ void extractPairsPerGroupNullAndEmptyXml() {+ assertTrue(XmlParser.extractPairsPerGroup(null, "G", "P", "K", "V").isEmpty());+ assertTrue(XmlParser.extractPairsPerGroup("", "G", "P", "K", "V").isEmpty());+ }++ @Test+ void extractPairsPerGroupIndexAlignedWithExtractGroupsMulti() {+ String xml = """+ <Conf>+ <QueueConfiguration>+ <Queue>arn:q1</Queue>+ <Event>s3:ObjectCreated:*</Event>+ </QueueConfiguration>+ <QueueConfiguration>+ <Queue>arn:q2</Queue>+ <Event>s3:ObjectRemoved:*</Event>+ <Filter><S3Key>+ <FilterRule><Name>prefix</Name><Value>logs/</Value></FilterRule>+ </S3Key></Filter>+ </QueueConfiguration>+ </Conf>+ """;++ var groups = XmlParser.extractGroupsMulti(xml, "QueueConfiguration");+ var filters = XmlParser.extractPairsPerGroup(xml, "QueueConfiguration",+ "FilterRule", "Name", "Value");++ assertEquals(2, groups.size());+ assertEquals(2, filters.size());+ assertTrue(filters.get(0).isEmpty());+ assertEquals("logs/", filters.get(1).get("prefix"));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/s3/S3IntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/s3/S3IntegrationTest.javaindex fa6f97708f..1c822f09c3 100644--- a/src/test/java/io/github/hectorvent/floci/services/s3/S3IntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/s3/S3IntegrationTest.java@@ -873,4 +873,112 @@ class S3IntegrationTest {given().delete("/encoding-test-bucket/composite-encoded.txt");given().delete("/encoding-test-bucket");}++ // --- S3 Notification Configuration with Filter ---++ @Test+ @Order(90)+ void createNotificationBucket() {+ given()+ .when()+ .put("/notif-test-bucket")+ .then()+ .statusCode(200);+ }++ @Test+ @Order(91)+ void putNotificationConfigWithFilterIsNotDropped() {+ String xml = """+ <NotificationConfiguration xmlns="http://s3.amazonaws.com/doc/2006-03-01/">+ <QueueConfiguration>+ <Id>my-notif</Id>+ <Queue>arn:aws:sqs:us-east-1:000000000000:test-queue</Queue>+ <Event>s3:ObjectCreated:*</Event>+ <Filter>+ <S3Key>+ <FilterRule>+ <Name>prefix</Name>+ <Value>incoming/</Value>+ </FilterRule>+ </S3Key>+ </Filter>+ </QueueConfiguration>+ </NotificationConfiguration>+ """;++ given()+ .contentType("application/xml")+ .queryParam("notification", "")+ .body(xml)+ .when()+ .put("/notif-test-bucket")+ .then()+ .statusCode(200);++ given()+ .queryParam("notification", "")+ .when()+ .get("/notif-test-bucket")+ .then()+ .statusCode(200)+ .body(containsString("QueueConfiguration"))+ .body(containsString("arn:aws:sqs:us-east-1:000000000000:test-queue"))+ .body(containsString("s3:ObjectCreated:*"))+ // Verify filter rules are preserved in round-trip+ .body(containsString("Filter"))+ .body(containsString("FilterRule"))+ .body(containsString("<Name>prefix</Name>"))+ .body(containsString("<Value>incoming/</Value>"));+ }++ @Test+ @Order(92)+ void putNotificationConfigWithFilterBeforeQueueIsNotDropped() {+ // Filter appears BEFORE Queue — ensures element order doesn't matter+ String xml = """+ <NotificationConfiguration xmlns="http://s3.amazonaws.com/doc/2006-03-01/">+ <QueueConfiguration>+ <Id>filter-first</Id>+ <Filter>+ <S3Key>+ <FilterRule>+ <Name>suffix</Name>+ <Value>.csv</Value>+ </FilterRule>+ </S3Key>+ </Filter>+ <Queue>arn:aws:sqs:us-east-1:000000000000:csv-queue</Queue>+ <Event>s3:ObjectCreated:Put</Event>+ </QueueConfiguration>+ </NotificationConfiguration>+ """;++ given()+ .contentType("application/xml")+ .queryParam("notification", "")+ .body(xml)+ .when()+ .put("/notif-test-bucket")+ .then()+ .statusCode(200);++ given()+ .queryParam("notification", "")+ .when()+ .get("/notif-test-bucket")+ .then()+ .statusCode(200)+ .body(containsString("QueueConfiguration"))+ .body(containsString("arn:aws:sqs:us-east-1:000000000000:csv-queue"))+ .body(containsString("s3:ObjectCreated:Put"))+ .body(containsString("<Name>suffix</Name>"))+ .body(containsString("<Value>.csv</Value>"));+ }++ @Test+ @Order(93)+ void cleanupNotificationBucket() {+ given().delete("/notif-test-bucket");+ }}diff --git a/src/test/java/io/github/hectorvent/floci/services/s3/S3NotificationModelTest.java b/src/test/java/io/github/hectorvent/floci/services/s3/S3NotificationModelTest.javanew file mode 100644index 0000000000..1c3f0ed961--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/s3/S3NotificationModelTest.java@@ -0,0 +1,70 @@+package io.github.hectorvent.floci.services.s3;++import io.github.hectorvent.floci.services.s3.model.FilterRule;+import io.github.hectorvent.floci.services.s3.model.QueueNotification;+import io.github.hectorvent.floci.services.s3.model.TopicNotification;+import org.junit.jupiter.api.Test;++import java.util.List;++import static org.junit.jupiter.api.Assertions.*;++class S3NotificationModelTest {++ // --- matchesKey ---++ @Test+ void matchesKeyWithNullFilterRulesFromJacksonDeserialization() {+ var qn = new QueueNotification("id", "arn:aws:sqs:us-east-1:000000000000:q",+ List.of("s3:ObjectCreated:*"), null);+ assertTrue(qn.matchesKey("anything"));++ var tn = new TopicNotification("id", "arn:aws:sns:us-east-1:000000000000:t",+ List.of("s3:ObjectCreated:*"), null);+ assertTrue(tn.matchesKey("anything"));+ }++ @Test+ void matchesKeyWithEmptyFilterRulesMatchesAll() {+ var qn = new QueueNotification("id", "arn", List.of("s3:ObjectCreated:*"));+ assertTrue(qn.matchesKey("anything"));+ }++ @Test+ void matchesKeyEnforcesAllRules() {+ var qn = new QueueNotification("id", "arn", List.of("s3:ObjectCreated:*"),+ List.of(new FilterRule("prefix", "images/"), new FilterRule("suffix", ".jpg")));+ assertTrue(qn.matchesKey("images/photo.jpg"));+ assertFalse(qn.matchesKey("images/photo.png"));+ assertFalse(qn.matchesKey("docs/photo.jpg"));+ }++ // --- FilterRule.matches ---++ @Test+ void filterRulePrefixMatch() {+ FilterRule rule = new FilterRule("prefix", "images/");+ assertTrue(rule.matches("images/photo.jpg"));+ assertFalse(rule.matches("docs/file.txt"));+ assertFalse(rule.matches(null));+ }++ @Test+ void filterRuleSuffixMatch() {+ FilterRule rule = new FilterRule("suffix", ".jpg");+ assertTrue(rule.matches("images/photo.jpg"));+ assertFalse(rule.matches("images/photo.png"));+ }++ @Test+ void filterRuleUnknownNameDoesNotMatch() {+ FilterRule rule = new FilterRule("extension", ".jpg");+ assertFalse(rule.matches("photo.jpg"));+ }++ @Test+ void filterRuleNameIsCaseInsensitive() {+ assertTrue(new FilterRule("Prefix", "images/").matches("images/photo.jpg"));+ assertTrue(new FilterRule("SUFFIX", ".jpg").matches("photo.jpg"));+ }+}