Light, fluffy, and always free - The AWS Local Emulator alternative
feat(ses): apply suppression list during send with per-CS SuppressionOptions override (#1109)
Kenshin Okinaka19b0432b8c9e
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/SesConfigurationSetTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/SesConfigurationSetTest.javaindex c386f2d851..8c44927a9a 100644--- a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/SesConfigurationSetTest.java+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/SesConfigurationSetTest.java@@ -21,6 +21,8 @@ import software.amazon.awssdk.services.ses.model.ListConfigurationSetsResponse;import software.amazon.awssdk.services.sesv2.SesV2Client;import software.amazon.awssdk.services.sesv2.model.GetConfigurationSetRequest;import software.amazon.awssdk.services.sesv2.model.GetConfigurationSetResponse;+import software.amazon.awssdk.services.sesv2.model.PutConfigurationSetSuppressionOptionsRequest;+import software.amazon.awssdk.services.sesv2.model.SuppressionListReason;import software.amazon.awssdk.services.sesv2.model.Tag;import static org.assertj.core.api.Assertions.assertThat;@@ -38,6 +40,7 @@ class SesConfigurationSetTest {private static SesV2Client sesV2;private static String v1Name;private static String v2Name;+ private static String suppressionCsName;@BeforeAllstatic void setup() {@@ -46,6 +49,7 @@ class SesConfigurationSetTest {String suffix = TestFixtures.uniqueName();v1Name = "sdk-v1-cs-" + suffix;v2Name = "sdk-v2-cs-" + suffix;+ suppressionCsName = "sdk-v2-cs-supp-" + suffix;}@AfterAll@@ -56,6 +60,7 @@ class SesConfigurationSetTest {}if (sesV2 != null) {safelyDeleteV2(v2Name);+ safelyDeleteV2(suppressionCsName);sesV2.close();}}@@ -208,6 +213,99 @@ class SesConfigurationSetTest {.isEqualTo(400);}+ // ─────────────────── V2 SuppressionOptions (per-CS) ───────────────────++ @Test+ @Order(30)+ void v2SuppressionOptions_setup_createsSuppressionConfigurationSet() {+ sesV2.createConfigurationSet(software.amazon.awssdk.services.sesv2.model.CreateConfigurationSetRequest.builder()+ .configurationSetName(suppressionCsName)+ .build());++ // Before any PutSuppressionOptions, the response has no SuppressionOptions block.+ GetConfigurationSetResponse before = sesV2.getConfigurationSet(GetConfigurationSetRequest.builder()+ .configurationSetName(suppressionCsName)+ .build());+ assertThat(before.suppressionOptions()).isNull();+ }++ @Test+ @Order(31)+ void v2PutSuppressionOptions_bounceOnly_visibleOnGet() {+ sesV2.putConfigurationSetSuppressionOptions(PutConfigurationSetSuppressionOptionsRequest.builder()+ .configurationSetName(suppressionCsName)+ .suppressedReasons(SuppressionListReason.BOUNCE)+ .build());++ GetConfigurationSetResponse after = sesV2.getConfigurationSet(GetConfigurationSetRequest.builder()+ .configurationSetName(suppressionCsName)+ .build());+ assertThat(after.suppressionOptions()).isNotNull();+ assertThat(after.suppressionOptions().suppressedReasons())+ .containsExactly(SuppressionListReason.BOUNCE);+ }++ @Test+ @Order(32)+ void v2PutSuppressionOptions_bothReasons() {+ sesV2.putConfigurationSetSuppressionOptions(PutConfigurationSetSuppressionOptionsRequest.builder()+ .configurationSetName(suppressionCsName)+ .suppressedReasons(SuppressionListReason.BOUNCE, SuppressionListReason.COMPLAINT)+ .build());++ GetConfigurationSetResponse after = sesV2.getConfigurationSet(GetConfigurationSetRequest.builder()+ .configurationSetName(suppressionCsName)+ .build());+ assertThat(after.suppressionOptions().suppressedReasons())+ .containsExactlyInAnyOrder(SuppressionListReason.BOUNCE, SuppressionListReason.COMPLAINT);+ }++ @Test+ @Order(33)+ void v2PutSuppressionOptions_emptyList_explicitlyDisablesFiltering() {+ // Per the AWS V2 contract, an empty SuppressedReasons list is the documented way+ // to disable suppression filtering for a configuration set.+ sesV2.putConfigurationSetSuppressionOptions(PutConfigurationSetSuppressionOptionsRequest.builder()+ .configurationSetName(suppressionCsName)+ .suppressedReasons(java.util.Collections.emptyList())+ .build());++ GetConfigurationSetResponse after = sesV2.getConfigurationSet(GetConfigurationSetRequest.builder()+ .configurationSetName(suppressionCsName)+ .build());+ assertThat(after.suppressionOptions()).isNotNull();+ assertThat(after.suppressionOptions().suppressedReasons()).isEmpty();+ }++ @Test+ @Order(34)+ void v2PutSuppressionOptions_invalidReason_rejectedAt400() {+ // The typed enum (SuppressionListReason) prevents passing an unknown value through+ // the SDK, so use the WithStrings variant to round-trip the literal "INVALID" to+ // the wire and exercise server-side validation.+ assertThatThrownBy(() -> sesV2.putConfigurationSetSuppressionOptions(+ PutConfigurationSetSuppressionOptionsRequest.builder()+ .configurationSetName(suppressionCsName)+ .suppressedReasonsWithStrings("BOUNCE", "INVALID")+ .build()))+ .isInstanceOf(AwsServiceException.class)+ .extracting(e -> ((AwsServiceException) e).statusCode())+ .isEqualTo(400);+ }++ @Test+ @Order(35)+ void v2PutSuppressionOptions_unknownConfigurationSet_rejectedAt404() {+ assertThatThrownBy(() -> sesV2.putConfigurationSetSuppressionOptions(+ PutConfigurationSetSuppressionOptionsRequest.builder()+ .configurationSetName(suppressionCsName + "-does-not-exist")+ .suppressedReasons(SuppressionListReason.BOUNCE)+ .build()))+ .isInstanceOf(AwsServiceException.class)+ .extracting(e -> ((AwsServiceException) e).statusCode())+ .isEqualTo(404);+ }+// ─────────────────────────── Helpers ───────────────────────────private static void safelyDeleteV1(String name) {diff --git a/docs/services/ses.md b/docs/services/ses.mdindex 0490d3d015..49f1d9cd22 100644--- a/docs/services/ses.md+++ b/docs/services/ses.md@@ -187,6 +187,7 @@ Alongside the classic Query API, Floci implements a subset of the SES v2 REST JS| `GET` | `/v2/email/configuration-sets/{name}/event-destinations` | `GetConfigurationSetEventDestinations` || `PUT` | `/v2/email/configuration-sets/{name}/event-destinations/{eventDestinationName}` | `UpdateConfigurationSetEventDestination` || `DELETE` | `/v2/email/configuration-sets/{name}/event-destinations/{eventDestinationName}` | `DeleteConfigurationSetEventDestination` |+| `PUT` | `/v2/email/configuration-sets/{name}/suppression-options` | `PutConfigurationSetSuppressionOptions` || `PUT` | `/v2/email/suppression/addresses` | `PutSuppressedDestination` || `GET` | `/v2/email/suppression/addresses/{EmailAddress}` | `GetSuppressedDestination` || `DELETE` | `/v2/email/suppression/addresses/{EmailAddress}` | `DeleteSuppressedDestination` |@@ -210,7 +211,9 @@ Floci recognises the AWS [mailbox simulator addresses](https://docs.aws.amazon.cA successful send without a simulator-address recipient emits only the `Send` event.-Suppression list entries are stored per region. `Reason` is `BOUNCE` or `COMPLAINT`. `SendEmail` is not yet integrated with the suppression list, so suppressed addresses are still delivered locally.+Suppression list entries are stored per region with `Reason` ∈ {`BOUNCE`, `COMPLAINT`}. At send time, a recipient is suppressed when it appears on the suppression list AND its stored `Reason` is contained in the **effective** `SuppressedReasons` for the send. The effective list is the configuration set's `SuppressionOptions.SuppressedReasons` (set via `PutConfigurationSetSuppressionOptions`) when present — an **empty list is preserved as an explicit "no suppression filtering for this configuration set"** — otherwise it falls back to the account-level `AccountSuppressionAttributes.SuppressedReasons` (set via `PutAccountSuppressionAttributes`, default `[BOUNCE, COMPLAINT]`). Following the AWS V2 contract, there is no dedicated `GetConfigurationSetSuppressionOptions` action; once set, the block is read back through `GetConfigurationSet`'s response (the field is omitted when the configuration set has no override).++Suppressed recipients are filtered out of the SMTP relay step (non-suppressed recipients on the same send still reach the relay normally), and the configuration set's event destinations receive a synthetic `Bounce` or `Complaint` event alongside the always-emitted `Send` event. The `SendEmail` API response (`200` + `MessageId`), the stored `SentEmail` visible at `GET /_aws/ses`, and the published event's `mail.destination` all retain the original recipient list — matching the AWS contract that the message is "accepted, just not sent" for suppressed addresses.Tag operations support these ARN forms: `arn:aws:ses:<region>:<account>:configuration-set/<name>`, `arn:aws:ses:<region>:<account>:template/<name>`, and `arn:aws:ses:<region>:<account>:identity/<email-or-domain>`. Tags supplied to `CreateConfigurationSet`, `CreateEmailTemplate`, and `CreateEmailIdentity` are reachable through `ListTagsForResource`; `UpdateEmailTemplate` does not modify tags. Other resource types return `NotFoundException`.diff --git a/src/main/java/io/github/hectorvent/floci/services/ses/SesController.java b/src/main/java/io/github/hectorvent/floci/services/ses/SesController.javaindex 7d0ae7fd96..05fd55fdc3 100644--- a/src/main/java/io/github/hectorvent/floci/services/ses/SesController.java+++ b/src/main/java/io/github/hectorvent/floci/services/ses/SesController.java@@ -648,12 +648,55 @@ public class SesController {tagNode.put("Value", t.value());tags.add(tagNode);}+ if (cs.getSuppressionOptions() != null) {+ ObjectNode suppressionNode = result.putObject("SuppressionOptions");+ ArrayNode reasons = suppressionNode.putArray("SuppressedReasons");+ for (String r : cs.getSuppressionOptions().getSuppressedReasons()) {+ reasons.add(r);+ }+ }return Response.ok(result).build();} catch (AwsException e) {throw remapV1Exception(e);}}+ @PUT+ @Path("/configuration-sets/{configurationSetName}/suppression-options")+ public Response putConfigurationSetSuppressionOptions(@Context HttpHeaders headers,+ @PathParam("configurationSetName") String name,+ String body) {+ String region = regionResolver.resolveRegion(headers);+ try {+ JsonNode request = (body == null || body.isBlank())+ ? objectMapper.createObjectNode()+ : objectMapper.readTree(body);+ requireJsonObject(request);+ JsonNode reasonsNode = request.path("SuppressedReasons");+ List<String> reasons = new ArrayList<>();+ if (!reasonsNode.isMissingNode() && !reasonsNode.isNull()) {+ if (!reasonsNode.isArray()) {+ throw new AwsException("BadRequestException",+ "SuppressedReasons must be an array.", 400);+ }+ for (JsonNode r : reasonsNode) {+ if (r.isNull() || !r.isTextual()) {+ throw new AwsException("BadRequestException",+ "SuppressedReasons entries must be strings.", 400);+ }+ reasons.add(r.asText());+ }+ }+ sesService.putConfigurationSetSuppressionOptions(name, reasons, region);+ LOG.infov("SES V2 PutConfigurationSetSuppressionOptions: {0} on {1}", reasons, name);+ return Response.ok(objectMapper.createObjectNode()).build();+ } catch (AwsException e) {+ throw remapV1Exception(e);+ } catch (com.fasterxml.jackson.core.JsonProcessingException e) {+ throw new AwsException("BadRequestException", e.getMessage(), 400);+ }+ }+@DELETE@Path("/configuration-sets/{configurationSetName}")public Response deleteConfigurationSet(@Context HttpHeaders headers,diff --git a/src/main/java/io/github/hectorvent/floci/services/ses/SesEventPayload.java b/src/main/java/io/github/hectorvent/floci/services/ses/SesEventPayload.javaindex cef427f00f..0948fcb4c5 100644--- a/src/main/java/io/github/hectorvent/floci/services/ses/SesEventPayload.java+++ b/src/main/java/io/github/hectorvent/floci/services/ses/SesEventPayload.java@@ -9,6 +9,7 @@ import io.github.hectorvent.floci.services.ses.model.MessageTag;import java.time.Instant;import java.time.ZoneOffset;import java.time.format.DateTimeFormatter;+import java.util.LinkedHashSet;import java.util.List;import java.util.Locale;@@ -35,6 +36,8 @@ final class SesEventPayload {String sourceArn, String sendingAccountId, String subject,List<String> toAddresses, List<String> ccAddresses,List<String> bccAddresses, List<String> envelopeDestinations,+ List<String> suppressionBounceRecipients,+ List<String> suppressionComplaintRecipients,String configurationSetName, List<MessageTag> emailTags,List<MessageHeader> additionalHeaders, Instant timestamp) {ObjectNode root = mapper.createObjectNode();@@ -43,7 +46,8 @@ final class SesEventPayload {subject, toAddresses, ccAddresses, bccAddresses, envelopeDestinations,configurationSetName, emailTags, additionalHeaders, timestamp));root.set(blockName(eventType),- buildEventBlock(mapper, eventType, messageId, envelopeDestinations, timestamp));+ buildEventBlock(mapper, eventType, messageId, envelopeDestinations,+ suppressionBounceRecipients, suppressionComplaintRecipients, timestamp));return root;}@@ -146,7 +150,10 @@ final class SesEventPayload {}private static ObjectNode buildEventBlock(ObjectMapper mapper, String eventType, String messageId,- List<String> destination, Instant timestamp) {+ List<String> destination,+ List<String> suppressionBounceRecipients,+ List<String> suppressionComplaintRecipients,+ Instant timestamp) {ObjectNode body = mapper.createObjectNode();switch (eventType) {case "DELIVERY" -> {@@ -164,24 +171,16 @@ final class SesEventPayload {case "BOUNCE" -> {body.put("bounceType", "Permanent");body.put("bounceSubType", "General");- ArrayNode bounced = body.putArray("bouncedRecipients");- for (String d : destination) {- if (SimulatorAddresses.isBounce(d)) {- ObjectNode br = bounced.addObject();- br.put("emailAddress", d.trim());- }- }+ emitDedupedRecipientObjects(body.putArray("bouncedRecipients"),+ destination, SimulatorAddresses::isBounce,+ suppressionBounceRecipients);body.put("timestamp", ISO_MILLIS.format(timestamp));body.put("feedbackId", "feedback-" + messageId);}case "COMPLAINT" -> {- ArrayNode complained = body.putArray("complainedRecipients");- for (String d : destination) {- if (SimulatorAddresses.isComplaint(d)) {- ObjectNode cr = complained.addObject();- cr.put("emailAddress", d.trim());- }- }+ emitDedupedRecipientObjects(body.putArray("complainedRecipients"),+ destination, SimulatorAddresses::isComplaint,+ suppressionComplaintRecipients);body.put("timestamp", ISO_MILLIS.format(timestamp));body.put("feedbackId", "feedback-" + messageId);}@@ -193,6 +192,33 @@ final class SesEventPayload {return body;}+ /**+ * Emit `{emailAddress: ...}` objects into {@code arr} for every recipient that either+ * matches {@code simulatorPredicate} in {@code envelope} or is listed in+ * {@code suppressionRecipients}. Addresses are trimmed and deduplicated by trimmed+ * form so the same address never appears twice when both inputs claim it.+ */+ private static void emitDedupedRecipientObjects(ArrayNode arr,+ List<String> envelope,+ java.util.function.Predicate<String> simulatorPredicate,+ List<String> suppressionRecipients) {+ LinkedHashSet<String> emitted = new LinkedHashSet<>();+ if (envelope != null) {+ for (String d : envelope) {+ if (d != null && simulatorPredicate.test(d) && emitted.add(d.trim())) {+ arr.addObject().put("emailAddress", d.trim());+ }+ }+ }+ if (suppressionRecipients != null) {+ for (String d : suppressionRecipients) {+ if (d != null && emitted.add(d.trim())) {+ arr.addObject().put("emailAddress", d.trim());+ }+ }+ }+ }+private static String eventTypeLabel(String eventType) {return switch (eventType) {case "SEND" -> "Send";diff --git a/src/main/java/io/github/hectorvent/floci/services/ses/SesEventPublisher.java b/src/main/java/io/github/hectorvent/floci/services/ses/SesEventPublisher.javaindex 679cc65fdd..f561d52c20 100644--- a/src/main/java/io/github/hectorvent/floci/services/ses/SesEventPublisher.java+++ b/src/main/java/io/github/hectorvent/floci/services/ses/SesEventPublisher.java@@ -39,6 +39,8 @@ public class SesEventPublisher {String source, String sourceArn, String sendingAccountId,String subject, List<String> toAddresses, List<String> ccAddresses,List<String> bccAddresses, List<String> envelopeDestinations,+ List<String> suppressionBounceRecipients,+ List<String> suppressionComplaintRecipients,List<MessageTag> emailTags, List<MessageHeader> additionalHeaders,Instant timestamp, String defaultRegion) {if (configurationSet == null || configurationSet.getEventDestinations().isEmpty()) {@@ -47,6 +49,7 @@ public class SesEventPublisher {ObjectNode payload = SesEventPayload.build(objectMapper, eventType, messageId, source,sourceArn, sendingAccountId, subject,toAddresses, ccAddresses, bccAddresses, envelopeDestinations,+ suppressionBounceRecipients, suppressionComplaintRecipients,configurationSet.getName(), emailTags, additionalHeaders, timestamp);String payloadJson = payload.toString();for (EventDestination ed : configurationSet.getEventDestinations()) {diff --git a/src/main/java/io/github/hectorvent/floci/services/ses/SesService.java b/src/main/java/io/github/hectorvent/floci/services/ses/SesService.javaindex 13b204d4ca..e88088c110 100644--- a/src/main/java/io/github/hectorvent/floci/services/ses/SesService.java+++ b/src/main/java/io/github/hectorvent/floci/services/ses/SesService.java@@ -17,6 +17,7 @@ import io.github.hectorvent.floci.services.ses.model.MessageHeader;import io.github.hectorvent.floci.services.ses.model.MessageTag;import io.github.hectorvent.floci.services.ses.model.SentEmail;import io.github.hectorvent.floci.services.ses.model.SuppressedDestination;+import io.github.hectorvent.floci.services.ses.model.SuppressionOptions;import io.github.hectorvent.floci.services.ses.model.Tag;import com.fasterxml.jackson.core.type.TypeReference;import com.fasterxml.jackson.databind.JsonNode;@@ -32,6 +33,7 @@ import java.time.ZoneOffset;import java.time.ZonedDateTime;import java.time.format.DateTimeFormatter;import java.util.ArrayList;+import java.util.Collection;import java.util.Collections;import java.util.Comparator;import java.util.HexFormat;@@ -202,15 +204,25 @@ public class SesService {bccAddresses, replyToAddresses, subject, bodyText, bodyHtml);emailStore.put("email::" + region + "::" + messageId, email);- smtpRelay.relay(source, toAddresses, ccAddresses, bccAddresses,- replyToAddresses, subject, bodyText, bodyHtml);+ List<String> envelope = allRecipients(toAddresses, ccAddresses, bccAddresses);+ Map<String, String> suppressedReasons = collectSuppressedReasons(envelope, configurationSetName, region);++ List<String> relayedTo = filterUnsuppressed(toAddresses, suppressedReasons);+ List<String> relayedCc = filterUnsuppressed(ccAddresses, suppressedReasons);+ List<String> relayedBcc = filterUnsuppressed(bccAddresses, suppressedReasons);+ if (sizeOf(relayedTo) + sizeOf(relayedCc) + sizeOf(relayedBcc) > 0) {+ smtpRelay.relay(source, relayedTo, relayedCc, relayedBcc,+ replyToAddresses, subject, bodyText, bodyHtml);+ } else {+ LOG.infov("SES email accepted but not relayed (all recipients suppressed): messageId={0}",+ messageId);+ }LOG.infov("SES email sent: from={0}, to={1}, subject={2}, messageId={3}",source, toAddresses, subject, messageId);publishSendEvents(configurationSetName, messageId, source, subject,- toAddresses, ccAddresses, bccAddresses,- allRecipients(toAddresses, ccAddresses, bccAddresses),- emailTags, additionalHeaders, region);+ toAddresses, ccAddresses, bccAddresses, envelope,+ suppressedReasons, emailTags, additionalHeaders, region);return messageId;}@@ -237,7 +249,15 @@ public class SesService {SentEmail email = new SentEmail(messageId, region, source, effectiveDestinations, rawMessage);emailStore.put("email::" + region + "::" + messageId, email);- smtpRelay.relayRaw(source, effectiveDestinations, rawMessage);+ Map<String, String> suppressedReasons = collectSuppressedReasons(effectiveDestinations, configurationSetName, region);++ List<String> relayedDestinations = filterUnsuppressed(effectiveDestinations, suppressedReasons);+ if (!relayedDestinations.isEmpty()) {+ smtpRelay.relayRaw(source, relayedDestinations, rawMessage);+ } else {+ LOG.infov("SES raw email accepted but not relayed (all recipients suppressed): messageId={0}",+ messageId);+ }LOG.infov("SES raw email sent: from={0}, messageId={1}", source, messageId);publishSendEvents(configurationSetName, messageId, source,@@ -246,7 +266,7 @@ public class SesService {headers != null ? headers.cc() : List.of(),headers != null ? headers.bcc() : List.of(),effectiveDestinations,- emailTags, List.of(), region);+ suppressedReasons, emailTags, List.of(), region);return messageId;}@@ -286,6 +306,7 @@ public class SesService {String subject, List<String> toAddresses,List<String> ccAddresses, List<String> bccAddresses,List<String> envelopeDestinations,+ Map<String, String> suppressedReasons,List<MessageTag> emailTags,List<MessageHeader> additionalHeaders, String region) {if (eventPublisher == null) {@@ -312,14 +333,28 @@ public class SesService {? null: AwsArnUtils.Arn.of("ses", region, sendingAccountId, "identity/" + source).toString();- for (String eventType : determineSendEventTypes(envelope)) {+ List<String> suppressionBounceRecipients = new ArrayList<>();+ List<String> suppressionComplaintRecipients = new ArrayList<>();+ for (Map.Entry<String, String> e : suppressedReasons.entrySet()) {+ if ("BOUNCE".equals(e.getValue())) {+ suppressionBounceRecipients.add(e.getKey());+ } else if ("COMPLAINT".equals(e.getValue())) {+ suppressionComplaintRecipients.add(e.getKey());+ }+ }++ for (String eventType : determineSendEventTypes(envelope,+ suppressionBounceRecipients, suppressionComplaintRecipients)) {eventPublisher.publish(cs, eventType, messageId, source, sourceArn, sendingAccountId,subject, toAddresses, ccAddresses, bccAddresses, envelope,+ suppressionBounceRecipients, suppressionComplaintRecipients,emailTags, additionalHeaders, timestamp, region);}}- private static List<String> determineSendEventTypes(List<String> destinations) {+ private static List<String> determineSendEventTypes(List<String> destinations,+ List<String> suppressionBounceRecipients,+ List<String> suppressionComplaintRecipients) {List<String> events = new ArrayList<>();events.add("SEND");for (String d : destinations) {@@ -336,6 +371,12 @@ public class SesService {events.add("REJECT");}}+ if (!suppressionBounceRecipients.isEmpty() && !events.contains("BOUNCE")) {+ events.add("BOUNCE");+ }+ if (!suppressionComplaintRecipients.isEmpty() && !events.contains("COMPLAINT")) {+ events.add("COMPLAINT");+ }return events;}@@ -686,6 +727,53 @@ public class SesService {eventDestinationName, configSetName, region);}+ /**+ * Stores per-configuration-set suppression overrides. Mirrors the AWS V2+ * {@code PutConfigurationSetSuppressionOptions} contract: {@code reasons} may+ * be {@code null} or empty (explicit "no filtering" for this set) or a subset+ * of {@code [BOUNCE, COMPLAINT]}. Once set, the value is returned through+ * {@link #getConfigurationSet}; downstream callers can resolve the effective+ * reasons for a given send via {@link #getEffectiveSuppressedReasons}.+ */+ public void putConfigurationSetSuppressionOptions(String configSetName,+ List<String> reasons, String region) {+ List<String> sanitized = new ArrayList<>();+ if (reasons != null) {+ for (String r : reasons) {+ validateConfigSetSuppressionReason(r);+ sanitized.add(r);+ }+ }+ ConfigurationSet cs = getConfigurationSet(configSetName, region);+ SuppressionOptions options = new SuppressionOptions();+ options.setSuppressedReasons(sanitized);+ cs.setSuppressionOptions(options);+ configSetStore.put(configSetKey(region, configSetName), cs);+ LOG.infov("Updated SuppressionOptions on configuration set {0} in region {1}: {2}",+ configSetName, region, sanitized);+ }++ /**+ * Returns the effective suppression reasons for a send that is using+ * {@code configurationSetName}. Per the AWS V2 contract, a configuration+ * set's {@code SuppressionOptions} (when present) overrides the+ * account-level reasons — including an empty list, which explicitly+ * disables suppression filtering for that set. Falls back to the+ * account-level reasons when the configuration set has no override, or+ * when {@code configurationSetName} is null/blank (i.e. the caller didn't+ * specify a configuration set).+ */+ public List<String> getEffectiveSuppressedReasons(String configurationSetName, String region) {+ if (configurationSetName != null && !configurationSetName.isBlank()) {+ ConfigurationSet cs = getConfigurationSet(configurationSetName, region);+ SuppressionOptions options = cs.getSuppressionOptions();+ if (options != null) {+ return List.copyOf(options.getSuppressedReasons());+ }+ }+ return List.copyOf(getAccountSuppressionAttributes(region).getSuppressedReasons());+ }+private static int indexOfEventDestination(List<EventDestination> destinations, String name) {for (int i = 0; i < destinations.size(); i++) {if (name != null && name.equals(destinations.get(i).getName())) {@@ -1100,6 +1188,101 @@ public class SesService {return "suppression::" + region + "::" + emailAddress;}+ /**+ * Resolve the effective suppression reason for each address in a single pass over the+ * store and the effective settings. The returned map only contains entries for+ * addresses that ARE suppressed (i.e., on the list AND whose reason matches the+ * effective {@code suppressedReasons} — the configuration set's+ * {@code SuppressionOptions} override if present, else the account-level reasons).+ * Callers reuse this map for both the SMTP relay filter and the event-publishing+ * partitioning so the store is read once per send regardless of the number of+ * consumers.+ */+ Map<String, String> collectSuppressedReasons(Collection<String> addresses,+ String configurationSetName, String region) {+ if (addresses == null || addresses.isEmpty()) {+ return Map.of();+ }+ List<String> effectiveReasons = getEffectiveSuppressedReasons(configurationSetName, region);+ if (effectiveReasons == null || effectiveReasons.isEmpty()) {+ return Map.of();+ }+ Set<String> reasonFilter = Set.copyOf(effectiveReasons);+ Map<String, String> result = new LinkedHashMap<>();+ for (String address : addresses) {+ if (address == null || address.isBlank() || result.containsKey(address)) {+ continue;+ }+ String normalized = normalizeSuppressionEmail(address);+ SuppressedDestination entry = suppressionStore.get(suppressionKey(region, normalized))+ .orElse(null);+ if (entry != null && entry.getReason() != null+ && reasonFilter.contains(entry.getReason())) {+ result.put(address, entry.getReason());+ }+ }+ return result;+ }++ /**+ * Filter out recipients whose effective suppression reason is non-null. Returns a new+ * list containing only the addresses that should reach the SMTP relay, mirroring AWS+ * SES's "accept the message, but doesn't send it" behaviour for suppressed addresses.+ * Returns the original reference when {@code addresses} is {@code null} or empty.+ */+ static List<String> filterUnsuppressed(List<String> addresses, Map<String, String> suppressedReasons) {+ if (addresses == null || addresses.isEmpty()) {+ return addresses;+ }+ if (suppressedReasons.isEmpty()) {+ return addresses;+ }+ List<String> kept = new ArrayList<>(addresses.size());+ for (String a : addresses) {+ if (!suppressedReasons.containsKey(a)) {+ kept.add(a);+ }+ }+ return kept;+ }++ /**+ * Resolve the suppression reason that applies to a given recipient in the given region+ * for sends using {@code configurationSetName}, or {@code null} if the recipient is not+ * suppressed. The recipient is suppressed only when it appears in the address-level+ * suppression list AND its stored reason intersects the effective {@code suppressedReasons}+ * — the configuration set's {@code SuppressionOptions} override if present, else the+ * account-level reasons. {@code configurationSetName} may be {@code null} or blank to+ * scope the check to account-level reasons only.+ *+ * <p>The returned value is one of {@code "BOUNCE"} / {@code "COMPLAINT"}, allowing+ * callers (publishSendEvents) to map the recipient to a synthetic Bounce / Complaint+ * event without consulting the store again. Both the per-address suppression entries+ * and the account-level / per-CS {@code suppressedReasons} go through+ * {@link #validateSuppressionReason} / {@link #validateConfigSetSuppressionReason},+ * which enforce exact case-sensitive equality with the two canonical values, so+ * {@code entry.getReason()} is guaranteed to be canonical and downstream+ * {@code .equals("BOUNCE")} / {@code .equals("COMPLAINT")} checks are safe.+ */+ String resolveSuppressionReason(String emailAddress, String configurationSetName, String region) {+ if (emailAddress == null || emailAddress.isBlank()) {+ return null;+ }+ // Share the same normalization used when entries are stored+ // (`normalizeSuppressionEmail`) so lookups can't drift apart from inserts.+ String normalized = normalizeSuppressionEmail(emailAddress);+ SuppressedDestination entry = suppressionStore.get(suppressionKey(region, normalized))+ .orElse(null);+ if (entry == null || entry.getReason() == null) {+ return null;+ }+ List<String> effective = getEffectiveSuppressedReasons(configurationSetName, region);+ if (effective == null || effective.isEmpty()) {+ return null;+ }+ return effective.contains(entry.getReason()) ? entry.getReason() : null;+ }+private static String normalizeSuppressionEmail(String emailAddress) {if (emailAddress == null || emailAddress.isBlank()) {throw new AwsException("BadRequestException", "EmailAddress is required.", 400);@@ -1108,6 +1291,17 @@ public class SesService {return emailAddress.trim();}+ /**+ * Validation message used by PutAccountSuppressionAttributes,+ * PutSuppressedDestination, and ListSuppressedDestinations — all three+ * return the AWS "1 validation error detected: Value at '<fieldName>'+ * failed to satisfy constraint: ..." V1-style nested message verbatim.+ * (Verified against real AWS V2 SES on 2026-06-03.) The {@code nested}+ * flag controls whether the inner enum constraint is wrapped in+ * {@code Member must satisfy constraint: [...]} — PutSuppressedDestination+ * (single Reason field) returns the unwrapped form; the two list-bearing+ * APIs return the wrapped form.+ */private static void validateSuppressionReason(String reason, String fieldName, boolean nested) {if (reason == null || (!"BOUNCE".equals(reason) && !"COMPLAINT".equals(reason))) {String constraint = nested@@ -1119,6 +1313,20 @@ public class SesService {}}+ /**+ * Validation message used by PutConfigurationSetSuppressionOptions. AWS+ * V2 SES uses a different, simpler natural-language sentence on this+ * endpoint than on the three older suppression APIs above:+ * "Reason <X> is invalid, must be one of [BOUNCE, COMPLAINT]."+ * (Verified against real AWS V2 SES on 2026-06-03.)+ */+ private static void validateConfigSetSuppressionReason(String reason) {+ if (reason == null || (!"BOUNCE".equals(reason) && !"COMPLAINT".equals(reason))) {+ throw new AwsException("BadRequestException",+ "Reason " + reason + " is invalid, must be one of [BOUNCE, COMPLAINT].", 400);+ }+ }+static void validateTag(Tag tag) {if (tag == null) {throw new AwsException("InvalidParameterValue", "Tag must not be null.", 400);diff --git a/src/main/java/io/github/hectorvent/floci/services/ses/model/ConfigurationSet.java b/src/main/java/io/github/hectorvent/floci/services/ses/model/ConfigurationSet.javaindex 619ca66b01..25f0728531 100644--- a/src/main/java/io/github/hectorvent/floci/services/ses/model/ConfigurationSet.java+++ b/src/main/java/io/github/hectorvent/floci/services/ses/model/ConfigurationSet.java@@ -24,6 +24,9 @@ public class ConfigurationSet {@JsonProperty("EventDestinations")private List<EventDestination> eventDestinations = new ArrayList<>();+ @JsonProperty("SuppressionOptions")+ private SuppressionOptions suppressionOptions;+public ConfigurationSet() {}public ConfigurationSet(String name) {@@ -44,4 +47,9 @@ public class ConfigurationSet {public void setEventDestinations(List<EventDestination> eventDestinations) {this.eventDestinations = eventDestinations != null ? eventDestinations : new ArrayList<>();}++ public SuppressionOptions getSuppressionOptions() { return suppressionOptions; }+ public void setSuppressionOptions(SuppressionOptions suppressionOptions) {+ this.suppressionOptions = suppressionOptions;+ }}diff --git a/src/main/java/io/github/hectorvent/floci/services/ses/model/SuppressionOptions.java b/src/main/java/io/github/hectorvent/floci/services/ses/model/SuppressionOptions.javanew file mode 100644index 0000000000..07d87a2482--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ses/model/SuppressionOptions.java@@ -0,0 +1,33 @@+package io.github.hectorvent.floci.services.ses.model;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import com.fasterxml.jackson.annotation.JsonInclude;+import com.fasterxml.jackson.annotation.JsonProperty;+import io.quarkus.runtime.annotations.RegisterForReflection;++import java.util.ArrayList;+import java.util.List;++/**+ * Per-configuration-set override of the account-level suppression reasons.+ * Mirrors the AWS SES V2 {@code SuppressionOptions} shape. When present on a+ * {@link ConfigurationSet}, its {@code SuppressedReasons} take precedence over+ * the account-level {@link AccountSuppressionAttributes} for any send using+ * that configuration set; an empty list explicitly disables suppression+ * filtering for the set.+ */+@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+@JsonInclude(JsonInclude.Include.NON_NULL)+public class SuppressionOptions {++ @JsonProperty("SuppressedReasons")+ private List<String> suppressedReasons = new ArrayList<>();++ public SuppressionOptions() {}++ public List<String> getSuppressedReasons() { return suppressedReasons; }+ public void setSuppressedReasons(List<String> suppressedReasons) {+ this.suppressedReasons = suppressedReasons != null ? suppressedReasons : new ArrayList<>();+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/ses/SesConfigurationSetSuppressionOptionsV2IntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/ses/SesConfigurationSetSuppressionOptionsV2IntegrationTest.javanew file mode 100644index 0000000000..71dcb6cf2e--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/ses/SesConfigurationSetSuppressionOptionsV2IntegrationTest.java@@ -0,0 +1,280 @@+package io.github.hectorvent.floci.services.ses;++import io.github.hectorvent.floci.core.common.AwsException;+import io.quarkus.test.junit.QuarkusTest;+import jakarta.inject.Inject;+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.util.List;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.contains;+import static org.hamcrest.Matchers.empty;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.hasSize;+import static org.hamcrest.Matchers.nullValue;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.junit.jupiter.api.Assertions.assertTrue;++/**+ * Integration test for the SES V2 per-configuration-set SuppressionOptions+ * endpoint: PUT /v2/email/configuration-sets/{name}/suppression-options and the+ * matching GET /v2/email/configuration-sets/{name} response shape.+ */+@QuarkusTest+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)+class SesConfigurationSetSuppressionOptionsV2IntegrationTest {++ private static final String AUTH =+ "AWS4-HMAC-SHA256 Credential=AKID/20260101/us-east-1/ses/aws4_request";+ private static final String REGION = "us-east-1";+ private static final String CS = "cs-suppression-options";++ @Inject+ SesService sesService;++ @Test+ @Order(1)+ void createConfigurationSet() {+ given()+ .contentType("application/json")+ .header("Authorization", AUTH)+ .body("{\"ConfigurationSetName\":\"" + CS + "\"}")+ .when()+ .post("/v2/email/configuration-sets")+ .then()+ .statusCode(200);+ }++ @Test+ @Order(2)+ void getConfigurationSetBeforePut_doesNotIncludeSuppressionOptions() {+ given()+ .header("Authorization", AUTH)+ .when()+ .get("/v2/email/configuration-sets/" + CS)+ .then()+ .statusCode(200)+ .body("ConfigurationSetName", equalTo(CS))+ .body("SuppressionOptions", nullValue());+ }++ @Test+ @Order(3)+ void putSuppressionOptions_bounceOnly() {+ given()+ .contentType("application/json")+ .header("Authorization", AUTH)+ .body("{\"SuppressedReasons\":[\"BOUNCE\"]}")+ .when()+ .put("/v2/email/configuration-sets/" + CS + "/suppression-options")+ .then()+ .statusCode(200);+ }++ @Test+ @Order(4)+ void getConfigurationSet_afterPut_reflectsSuppressionOptions() {+ given()+ .header("Authorization", AUTH)+ .when()+ .get("/v2/email/configuration-sets/" + CS)+ .then()+ .statusCode(200)+ .body("SuppressionOptions.SuppressedReasons", contains("BOUNCE"))+ .body("SuppressionOptions.SuppressedReasons", hasSize(1));+ }++ @Test+ @Order(5)+ void putSuppressionOptions_emptyList_explicitlyDisablesFiltering() {+ given()+ .contentType("application/json")+ .header("Authorization", AUTH)+ .body("{\"SuppressedReasons\":[]}")+ .when()+ .put("/v2/email/configuration-sets/" + CS + "/suppression-options")+ .then()+ .statusCode(200);++ given()+ .header("Authorization", AUTH)+ .when()+ .get("/v2/email/configuration-sets/" + CS)+ .then()+ .statusCode(200)+ .body("SuppressionOptions.SuppressedReasons", empty());+ }++ @Test+ @Order(6)+ void putSuppressionOptions_bothReasons() {+ given()+ .contentType("application/json")+ .header("Authorization", AUTH)+ .body("{\"SuppressedReasons\":[\"BOUNCE\",\"COMPLAINT\"]}")+ .when()+ .put("/v2/email/configuration-sets/" + CS + "/suppression-options")+ .then()+ .statusCode(200);++ given()+ .header("Authorization", AUTH)+ .when()+ .get("/v2/email/configuration-sets/" + CS)+ .then()+ .statusCode(200)+ .body("SuppressionOptions.SuppressedReasons", contains("BOUNCE", "COMPLAINT"));+ }++ @Test+ @Order(7)+ void putSuppressionOptions_invalidReason_rejected() {+ // Message verified against real AWS V2 SES on 2026-06-03:+ // "Reason INVALID is invalid, must be one of [BOUNCE, COMPLAINT]."+ given()+ .contentType("application/json")+ .header("Authorization", AUTH)+ .body("{\"SuppressedReasons\":[\"BOUNCE\",\"INVALID\"]}")+ .when()+ .put("/v2/email/configuration-sets/" + CS + "/suppression-options")+ .then()+ .statusCode(400)+ .body("__type", org.hamcrest.Matchers.equalTo("BadRequestException"))+ .body("message", org.hamcrest.Matchers.equalTo(+ "Reason INVALID is invalid, must be one of [BOUNCE, COMPLAINT]."));+ }++ @Test+ @Order(8)+ void putSuppressionOptions_nonArrayReasons_rejected() {+ given()+ .contentType("application/json")+ .header("Authorization", AUTH)+ .body("{\"SuppressedReasons\":\"BOUNCE\"}")+ .when()+ .put("/v2/email/configuration-sets/" + CS + "/suppression-options")+ .then()+ .statusCode(400);+ }++ @Test+ @Order(9)+ void putSuppressionOptions_unknownConfigSet_returns404() {+ given()+ .contentType("application/json")+ .header("Authorization", AUTH)+ .body("{\"SuppressedReasons\":[\"BOUNCE\"]}")+ .when()+ .put("/v2/email/configuration-sets/does-not-exist/suppression-options")+ .then()+ .statusCode(404);+ }++ @Test+ @Order(10)+ void putSuppressionOptions_omittedSuppressedReasons_treatedAsEmptyList() {+ given()+ .contentType("application/json")+ .header("Authorization", AUTH)+ .body("{}")+ .when()+ .put("/v2/email/configuration-sets/" + CS + "/suppression-options")+ .then()+ .statusCode(200);++ given()+ .header("Authorization", AUTH)+ .when()+ .get("/v2/email/configuration-sets/" + CS)+ .then()+ .statusCode(200)+ .body("SuppressionOptions.SuppressedReasons", empty());+ }++ // ─── getEffectiveSuppressedReasons helper (forward-looking integration with #1109) ───++ @Test+ @Order(20)+ void effectiveReasons_csWithoutOverride_fallsBackToAccountLevel() {+ String csNoOverride = "cs-suppression-no-override";+ given()+ .contentType("application/json")+ .header("Authorization", AUTH)+ .body("{\"ConfigurationSetName\":\"" + csNoOverride + "\"}")+ .when()+ .post("/v2/email/configuration-sets")+ .then()+ .statusCode(200);++ List<String> effective = sesService.getEffectiveSuppressedReasons(csNoOverride, REGION);+ // Account defaults to [BOUNCE, COMPLAINT]; matches account state when no per-CS override.+ assertEquals(sesService.getAccountSuppressionAttributes(REGION).getSuppressedReasons(), effective);+ }++ @Test+ @Order(21)+ void effectiveReasons_csWithBounceOverride_returnsBounceOnly() {+ String csBounceOnly = "cs-suppression-bounce-only";+ given()+ .contentType("application/json")+ .header("Authorization", AUTH)+ .body("{\"ConfigurationSetName\":\"" + csBounceOnly + "\"}")+ .when()+ .post("/v2/email/configuration-sets")+ .then()+ .statusCode(200);++ sesService.putConfigurationSetSuppressionOptions(csBounceOnly, List.of("BOUNCE"), REGION);++ List<String> effective = sesService.getEffectiveSuppressedReasons(csBounceOnly, REGION);+ assertEquals(List.of("BOUNCE"), effective);+ }++ @Test+ @Order(22)+ void effectiveReasons_csWithEmptyOverride_explicitlyDisablesFiltering() {+ String csEmpty = "cs-suppression-empty";+ given()+ .contentType("application/json")+ .header("Authorization", AUTH)+ .body("{\"ConfigurationSetName\":\"" + csEmpty + "\"}")+ .when()+ .post("/v2/email/configuration-sets")+ .then()+ .statusCode(200);++ sesService.putConfigurationSetSuppressionOptions(csEmpty, List.of(), REGION);++ List<String> effective = sesService.getEffectiveSuppressedReasons(csEmpty, REGION);+ assertTrue(effective.isEmpty(),+ "An empty SuppressedReasons override must defeat the account-level reasons, "+ + "matching the AWS V2 contract: \"If you specify an empty list, "+ + "Amazon SES doesn't apply any suppression filtering ...\"");+ }++ @Test+ @Order(23)+ void effectiveReasons_nullConfigSetName_returnsAccountLevel() {+ List<String> effective = sesService.getEffectiveSuppressedReasons(null, REGION);+ assertEquals(sesService.getAccountSuppressionAttributes(REGION).getSuppressedReasons(), effective);+ }++ @Test+ @Order(24)+ void effectiveReasons_blankConfigSetName_returnsAccountLevel() {+ List<String> effective = sesService.getEffectiveSuppressedReasons(" ", REGION);+ assertEquals(sesService.getAccountSuppressionAttributes(REGION).getSuppressedReasons(), effective);+ }++ @Test+ @Order(25)+ void effectiveReasons_nonExistentConfigSet_throws() {+ assertThrows(AwsException.class,+ () -> sesService.getEffectiveSuppressedReasons("never-created", REGION));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/ses/SesEventPayloadTest.java b/src/test/java/io/github/hectorvent/floci/services/ses/SesEventPayloadTest.javaindex afa2ffc38f..21f1bf99cb 100644--- a/src/test/java/io/github/hectorvent/floci/services/ses/SesEventPayloadTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/ses/SesEventPayloadTest.java@@ -30,7 +30,7 @@ class SesEventPayloadTest {ObjectNode node = SesEventPayload.build(mapper, "SEND", "msg-1", "[email protected]","arn:aws:ses:us-east-1:000000000000:identity/[email protected]","000000000000", "Hello", List.of("[email protected]"), List.of("[email protected]"),- List.of(), List.of("[email protected]", "[email protected]"), "my-cs", List.of(), List.of(), ts);+ List.of(), List.of("[email protected]", "[email protected]"), List.of(), List.of(), "my-cs", List.of(), List.of(), ts);assertEquals("Send", node.get("eventType").asText());assertTrue(node.has("send"));@@ -68,7 +68,7 @@ class SesEventPayloadTest {ObjectNode node = SesEventPayload.build(mapper, "DELIVERY", "msg-1", "[email protected]",null, "000000000000", "",List.of("[email protected]"), List.of(), List.of(),- List.of("[email protected]"), "cs", List.of(), List.of(), ts);+ List.of("[email protected]"), List.of(), List.of(), "cs", List.of(), List.of(), ts);assertEquals("Delivery", node.get("eventType").asText());ObjectNode delivery = (ObjectNode) node.get("delivery");@@ -83,7 +83,7 @@ class SesEventPayloadTest {ObjectNode node = SesEventPayload.build(mapper, "BOUNCE", "msg-1", "[email protected]",null, "000000000000", "",List.of("[email protected]"), List.of(), List.of(),- List.of("[email protected]"), "cs", List.of(), List.of(), ts);+ List.of("[email protected]"), List.of(), List.of(), "cs", List.of(), List.of(), ts);assertEquals("Bounce", node.get("eventType").asText());ObjectNode bounce = (ObjectNode) node.get("bounce");@@ -98,7 +98,7 @@ class SesEventPayloadTest {ObjectNode node = SesEventPayload.build(mapper, "COMPLAINT", "msg-1", "[email protected]",null, "000000000000", "",List.of("[email protected]"), List.of(), List.of(),- List.of("[email protected]"), "cs", List.of(), List.of(), ts);+ List.of("[email protected]"), List.of(), List.of(), "cs", List.of(), List.of(), ts);assertEquals("Complaint", node.get("eventType").asText());assertEquals("[email protected]",@@ -112,7 +112,7 @@ class SesEventPayloadTest {List.of("[email protected]", "[email protected]"),List.of(), List.of(),List.of("[email protected]", "[email protected]"),- "cs", List.of(), List.of(), ts);+ List.of(), List.of(), "cs", List.of(), List.of(), ts);var bounced = (com.fasterxml.jackson.databind.node.ArrayNode)node.get("bounce").get("bouncedRecipients");@@ -130,7 +130,7 @@ class SesEventPayloadTest {List.of("[email protected]", "[email protected]"),List.of(), List.of(),List.of("[email protected]", "[email protected]"),- "cs", List.of(), List.of(), ts);+ List.of(), List.of(), "cs", List.of(), List.of(), ts);var recipients = node.get("delivery").get("recipients");assertEquals(1, recipients.size());@@ -144,7 +144,7 @@ class SesEventPayloadTest {List.of("[email protected]", "[email protected]"),List.of(), List.of(),List.of("[email protected]", "[email protected]"),- "cs", List.of(), List.of(), ts);+ List.of(), List.of(), "cs", List.of(), List.of(), ts);var complained = node.get("complaint").get("complainedRecipients");assertEquals(1, complained.size());@@ -158,6 +158,7 @@ class SesEventPayloadTest {null, "000000000000", "Hello",List.of("[email protected]"), List.of(), List.of(),List.of("[email protected]"),+ List.of(), List.of(),"my-cs",List.of(new MessageTag("campaign", "launch"), new MessageTag("env", "prod")),List.of(),@@ -175,6 +176,7 @@ class SesEventPayloadTest {null, "000000000000", "",List.of("[email protected]"), List.of(), List.of(),List.of("[email protected]"),+ List.of(), List.of(),"cs",List.of(new MessageTag("k", null), new MessageTag("k", "v2")),List.of(),@@ -192,6 +194,7 @@ class SesEventPayloadTest {null, "000000000000", "Hi",List.of("[email protected]"), List.of(), List.of(),List.of("[email protected]"),+ List.of(), List.of(),"cs",List.of(),List.of(@@ -215,6 +218,7 @@ class SesEventPayloadTest {null, "000000000000", "Hi",List.of("[email protected]"), List.of(), List.of(),List.of("[email protected]"),+ List.of(), List.of(),"cs",List.of(),List.of(@@ -236,12 +240,70 @@ class SesEventPayloadTest {assertTrue(hasXReal);}+ @Test+ void bounce_unionsSimulatorAndSuppressionRecipients() {+ // simulator-bounce@... is detected from the envelope, while+ // suppressed-bounce@... comes from the suppression-list group.+ // The emitted bouncedRecipients list contains both, deduplicated.+ ObjectNode node = SesEventPayload.build(mapper, "BOUNCE", "msg-1", "[email protected]",+ null, "000000000000", "",+ List.of("[email protected]", "[email protected]"),+ List.of(), List.of(),+ List.of("[email protected]", "[email protected]"),+ List.of("[email protected]"),+ List.of(),+ "cs", List.of(), List.of(), ts);++ var bounced = node.get("bounce").get("bouncedRecipients");+ assertEquals(2, bounced.size());+ assertEquals("[email protected]",+ bounced.get(0).get("emailAddress").asText());+ assertEquals("[email protected]",+ bounced.get(1).get("emailAddress").asText());+ }++ @Test+ void complaint_unionsSimulatorAndSuppressionRecipients() {+ ObjectNode node = SesEventPayload.build(mapper, "COMPLAINT", "msg-1", "[email protected]",+ null, "000000000000", "",+ List.of("[email protected]", "[email protected]"),+ List.of(), List.of(),+ List.of("[email protected]", "[email protected]"),+ List.of(),+ List.of("[email protected]"),+ "cs", List.of(), List.of(), ts);++ var complained = node.get("complaint").get("complainedRecipients");+ assertEquals(2, complained.size());+ assertEquals("[email protected]",+ complained.get(0).get("emailAddress").asText());+ assertEquals("[email protected]",+ complained.get(1).get("emailAddress").asText());+ }++ @Test+ void bounce_simulatorAndSuppressionSameAddressNotDuplicated() {+ // If an address is both a bounce simulator AND on the suppression list with+ // reason BOUNCE, it should appear once in bouncedRecipients.+ ObjectNode node = SesEventPayload.build(mapper, "BOUNCE", "msg-1", "[email protected]",+ null, "000000000000", "",+ List.of("[email protected]"),+ List.of(), List.of(),+ List.of("[email protected]"),+ List.of("[email protected]"),+ List.of(),+ "cs", List.of(), List.of(), ts);++ var bounced = node.get("bounce").get("bouncedRecipients");+ assertEquals(1, bounced.size());+ }+@Testvoid reject_hasReason() {ObjectNode node = SesEventPayload.build(mapper, "REJECT", "msg-1", "[email protected]",null, "000000000000", "",List.of("[email protected]"), List.of(), List.of(),- List.of("[email protected]"), "cs", List.of(), List.of(), ts);+ List.of("[email protected]"), List.of(), List.of(), "cs", List.of(), List.of(), ts);assertEquals("Reject", node.get("eventType").asText());assertNotNull(node.get("reject").get("reason"));diff --git a/src/test/java/io/github/hectorvent/floci/services/ses/SesEventPublishingV2IntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/ses/SesEventPublishingV2IntegrationTest.javaindex 381a109dbd..0f5ad028b6 100644--- a/src/test/java/io/github/hectorvent/floci/services/ses/SesEventPublishingV2IntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/ses/SesEventPublishingV2IntegrationTest.java@@ -445,6 +445,111 @@ class SesEventPublishingV2IntegrationTest {assertTrue(hasUnsubscribe, "expected List-Unsubscribe header in event mail.headers");}+ @Test+ @Order(12)+ void sendToSuppressedAddress_withBounceReason_publishesSyntheticBounceEvent() throws Exception {+ String suppressed = "bounce-suppressed-" + System.nanoTime() + "@example.com";+ // Pre-register the address in the account-level suppression list with reason BOUNCE.+ given()+ .contentType("application/json")+ .header("Authorization", SES_AUTH)+ .body("{\"EmailAddress\":\"" + suppressed + "\",\"Reason\":\"BOUNCE\"}")+ .when()+ .put("/v2/email/suppression/addresses")+ .then()+ .statusCode(200);++ try {+ drainQueue();+ given()+ .contentType("application/json")+ .header("Authorization", SES_AUTH)+ .body("""+ {+ "FromEmailAddress": "%s",+ "Destination": {"ToAddresses": ["%s"]},+ "ConfigurationSetName": "%s",+ "Content": {+ "Simple": {+ "Subject": {"Data": "evt"},+ "Body": {"Text": {"Data": "hi"}}+ }+ }+ }+ """.formatted(SENDER, suppressed, CS))+ .when()+ .post("/v2/email/outbound-emails")+ .then()+ .statusCode(200);++ List<JsonNode> events = receiveSesEvents(2);+ assertEquals(2, events.size(), "expected Send and synthetic Bounce events");+ assertTrue(events.stream().anyMatch(e -> "Send".equals(e.path("eventType").asText())));+ JsonNode bounce = events.stream()+ .filter(e -> "Bounce".equals(e.path("eventType").asText()))+ .findFirst().orElseThrow();+ assertEquals(suppressed,+ bounce.path("bounce").path("bouncedRecipients").get(0).path("emailAddress").asText());+ } finally {+ // Always run cleanup so the suppression list doesn't leak into subsequent tests.+ given()+ .header("Authorization", SES_AUTH)+ .when()+ .delete("/v2/email/suppression/addresses/" + suppressed);+ }+ }++ @Test+ @Order(13)+ void sendToSuppressedAddress_withComplaintReason_publishesSyntheticComplaintEvent() throws Exception {+ String suppressed = "complaint-suppressed-" + System.nanoTime() + "@example.com";+ given()+ .contentType("application/json")+ .header("Authorization", SES_AUTH)+ .body("{\"EmailAddress\":\"" + suppressed + "\",\"Reason\":\"COMPLAINT\"}")+ .when()+ .put("/v2/email/suppression/addresses")+ .then()+ .statusCode(200);++ try {+ drainQueue();+ given()+ .contentType("application/json")+ .header("Authorization", SES_AUTH)+ .body("""+ {+ "FromEmailAddress": "%s",+ "Destination": {"ToAddresses": ["%s"]},+ "ConfigurationSetName": "%s",+ "Content": {+ "Simple": {+ "Subject": {"Data": "evt"},+ "Body": {"Text": {"Data": "hi"}}+ }+ }+ }+ """.formatted(SENDER, suppressed, CS))+ .when()+ .post("/v2/email/outbound-emails")+ .then()+ .statusCode(200);++ List<JsonNode> events = receiveSesEvents(2);+ assertEquals(2, events.size(), "expected Send and synthetic Complaint events");+ JsonNode complaint = events.stream()+ .filter(e -> "Complaint".equals(e.path("eventType").asText()))+ .findFirst().orElseThrow();+ assertEquals(suppressed,+ complaint.path("complaint").path("complainedRecipients").get(0).path("emailAddress").asText());+ } finally {+ given()+ .header("Authorization", SES_AUTH)+ .when()+ .delete("/v2/email/suppression/addresses/" + suppressed);+ }+ }+private void sendEmail(String to) {given().contentType("application/json")diff --git a/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceSmtpTest.java b/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceSmtpTest.javaindex fca8961c3c..bd9d46cbb4 100644--- a/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceSmtpTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceSmtpTest.java@@ -105,4 +105,140 @@ class SesServiceSmtpTest {null, null, null,"Subject", null, "<p>html only</p>");}++ @Test+ void sendEmail_allRecipientsSuppressed_skipsRelayButStillStores() {+ service.putSuppressedDestination("us-east-1", "[email protected]", "BOUNCE");+ service.putSuppressedDestination("us-east-1", "[email protected]", "COMPLAINT");++ String messageId = service.sendEmail("[email protected]",+ List.of("[email protected]"),+ List.of("[email protected]"),+ null, null,+ "Subject", "text body", null, null, List.of(), List.of(), "us-east-1");++ assertNotNull(messageId);+ assertFalse(emailStore.scan(k -> true).isEmpty(),+ "stored SentEmail should still record the original recipient list");+ verify(smtpRelay, never()).relay(any(), any(), any(), any(), any(), any(), any(), any());+ }++ @Test+ void sendEmail_partialSuppression_relayCalledWithFilteredRecipients() {+ // Only suppress one of the To recipients; the other should still reach the relay.+ service.putSuppressedDestination("us-east-1", "[email protected]", "BOUNCE");++ service.sendEmail("[email protected]",+ List.of("[email protected]", "[email protected]"),+ List.of("[email protected]"),+ null, null,+ "Subject", "text body", null, null, List.of(), List.of(), "us-east-1");++ verify(smtpRelay).relay(+ "[email protected]",+ List.of("[email protected]"),+ List.of("[email protected]"),+ null,+ null,+ "Subject", "text body", null);+ }++ @Test+ void sendRawEmail_allRecipientsSuppressed_skipsRelayRawButStillStores() {+ service.putSuppressedDestination("us-east-1", "[email protected]", "BOUNCE");++ String messageId = service.sendRawEmail("[email protected]",+ List.of("[email protected]"), "raw MIME", null, List.of(), "us-east-1");++ assertNotNull(messageId);+ assertFalse(emailStore.scan(k -> true).isEmpty());+ verify(smtpRelay, never()).relayRaw(any(), any(), any());+ }++ @Test+ void sendRawEmail_partialSuppression_relayRawCalledWithFilteredRecipients() {+ service.putSuppressedDestination("us-east-1", "[email protected]", "COMPLAINT");++ service.sendRawEmail("[email protected]",+ List.of("[email protected]", "[email protected]"),+ "raw MIME", null, List.of(), "us-east-1");++ verify(smtpRelay).relayRaw(+ "[email protected]",+ List.of("[email protected]"),+ "raw MIME");+ }++ // ─────────── Per-CS SuppressionOptions override at send time ───────────++ @Test+ void sendEmail_csOverridesAccountToEmptyList_suppressionListIsIgnored() {+ // Account defaults to [BOUNCE, COMPLAINT] suppression. The CS explicitly+ // overrides to an empty list, which is the AWS V2 contract for "disable+ // suppression filtering for this configuration set". A recipient on the+ // suppression list with reason=BOUNCE should still reach the SMTP relay.+ service.putSuppressedDestination("us-east-1", "[email protected]", "BOUNCE");+ service.createConfigurationSet(new ConfigurationSet("cs-no-suppression"), "us-east-1");+ service.putConfigurationSetSuppressionOptions("cs-no-suppression", List.of(), "us-east-1");++ service.sendEmail("[email protected]",+ List.of("[email protected]"), null, null, null,+ "Subject", "text body", null, "cs-no-suppression", List.of(), List.of(), "us-east-1");++ verify(smtpRelay).relay(+ "[email protected]",+ List.of("[email protected]"),+ null, null, null,+ "Subject", "text body", null);+ }++ @Test+ void sendEmail_csOverridesAccountToBounceOnly_complaintSuppressedAddressStillRelayed() {+ // Account-level reasons include both BOUNCE and COMPLAINT by default.+ // The CS narrows the effective reasons to [BOUNCE] only — so a recipient+ // suppressed for COMPLAINT is NOT filtered when sending through this CS.+ service.putSuppressedDestination("us-east-1", "[email protected]", "COMPLAINT");+ service.createConfigurationSet(new ConfigurationSet("cs-bounce-only"), "us-east-1");+ service.putConfigurationSetSuppressionOptions("cs-bounce-only", List.of("BOUNCE"), "us-east-1");++ service.sendEmail("[email protected]",+ List.of("[email protected]"), null, null, null,+ "Subject", "text body", null, "cs-bounce-only", List.of(), List.of(), "us-east-1");++ verify(smtpRelay).relay(+ "[email protected]",+ List.of("[email protected]"),+ null, null, null,+ "Subject", "text body", null);+ }++ @Test+ void sendEmail_csWithoutOverride_fallsBackToAccountLevelSuppression() {+ // A configuration set whose SuppressionOptions block was never PUT must+ // fall back to account-level reasons — same filtering behaviour as a+ // send without any configuration set.+ service.putSuppressedDestination("us-east-1", "[email protected]", "BOUNCE");+ service.createConfigurationSet(new ConfigurationSet("cs-default"), "us-east-1");++ service.sendEmail("[email protected]",+ List.of("[email protected]"), null, null, null,+ "Subject", "text body", null, "cs-default", List.of(), List.of(), "us-east-1");++ verify(smtpRelay, never()).relay(any(), any(), any(), any(), any(), any(), any(), any());+ }++ @Test+ void sendRawEmail_csOverridesAccountToEmptyList_suppressionListIsIgnored() {+ service.putSuppressedDestination("us-east-1", "[email protected]", "BOUNCE");+ service.createConfigurationSet(new ConfigurationSet("cs-no-suppression-raw"), "us-east-1");+ service.putConfigurationSetSuppressionOptions("cs-no-suppression-raw", List.of(), "us-east-1");++ service.sendRawEmail("[email protected]",+ List.of("[email protected]"), "raw MIME", "cs-no-suppression-raw", List.of(), "us-east-1");++ verify(smtpRelay).relayRaw(+ "[email protected]",+ List.of("[email protected]"),+ "raw MIME");+ }}diff --git a/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceSuppressionReasonTest.java b/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceSuppressionReasonTest.javanew file mode 100644index 0000000000..6341e7e94d--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceSuppressionReasonTest.java@@ -0,0 +1,97 @@+package io.github.hectorvent.floci.services.ses;++import com.fasterxml.jackson.databind.ObjectMapper;+import io.github.hectorvent.floci.core.storage.InMemoryStorage;+import io.github.hectorvent.floci.services.ses.model.AccountSuppressionAttributes;+import io.github.hectorvent.floci.services.ses.model.ConfigurationSet;+import io.github.hectorvent.floci.services.ses.model.EmailTemplate;+import io.github.hectorvent.floci.services.ses.model.Identity;+import io.github.hectorvent.floci.services.ses.model.SentEmail;+import io.github.hectorvent.floci.services.ses.model.SuppressedDestination;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;++import java.util.ArrayList;+import java.util.List;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertNull;+import static org.mockito.Mockito.mock;++/**+ * Covers {@link SesService#resolveSuppressionReason(String, String)} — the per-recipient+ * lookup that publishSendEvents uses to map suppressed addresses to synthetic Bounce or+ * Complaint events.+ *+ * <p>The helper returns a reason only when the address is on the suppression list AND+ * the address's stored reason intersects {@link AccountSuppressionAttributes#getSuppressedReasons()}.+ */+class SesServiceSuppressionReasonTest {++ private static final String REGION = "us-east-1";++ private SesService service;+ private InMemoryStorage<String, SuppressedDestination> suppressionStore;+ private InMemoryStorage<String, AccountSuppressionAttributes> accountSuppressionStore;++ @BeforeEach+ void setUp() {+ suppressionStore = new InMemoryStorage<>();+ accountSuppressionStore = new InMemoryStorage<>();+ service = new SesService(+ new InMemoryStorage<String, Identity>(),+ new InMemoryStorage<String, SentEmail>(),+ new InMemoryStorage<String, Boolean>(),+ new InMemoryStorage<String, EmailTemplate>(),+ new InMemoryStorage<String, ConfigurationSet>(),+ suppressionStore,+ accountSuppressionStore,+ mock(SmtpRelay.class),+ new ObjectMapper());+ }++ @Test+ void notOnList_returnsNull() {+ // Default fresh account: suppressedReasons defaults to [BOUNCE, COMPLAINT], but the+ // address is not on the list, so resolution returns null.+ assertNull(service.resolveSuppressionReason("[email protected]", null, REGION));+ }++ @Test+ void onListAndReasonInAccountSettings_returnsReason() {+ service.putSuppressedDestination(REGION, "[email protected]", "BOUNCE");+ // Account-level suppressedReasons defaults to [BOUNCE, COMPLAINT].+ assertEquals("BOUNCE", service.resolveSuppressionReason("[email protected]", null, REGION));+ }++ @Test+ void onListButReasonNotInAccountSettings_returnsNull() {+ service.putSuppressedDestination(REGION, "[email protected]", "COMPLAINT");+ // Narrow the account settings to BOUNCE only.+ service.putAccountSuppressionAttributes(REGION, List.of("BOUNCE"));+ assertNull(service.resolveSuppressionReason("[email protected]", null, REGION));+ }++ @Test+ void accountSettingsEmpty_returnsNull() {+ service.putSuppressedDestination(REGION, "[email protected]", "BOUNCE");+ // Disable account-level suppression by passing an empty list.+ service.putAccountSuppressionAttributes(REGION, new ArrayList<>());+ assertNull(service.resolveSuppressionReason("[email protected]", null, REGION));+ }++ @Test+ void leadingTrailingWhitespaceIsNormalized() {+ service.putSuppressedDestination(REGION, "[email protected]", "BOUNCE");+ // Caller may pass the recipient with surrounding whitespace (e.g. from a header).+ assertEquals("BOUNCE",+ service.resolveSuppressionReason(" [email protected] ", null, REGION));+ }++ @Test+ void nullOrBlankInput_returnsNull() {+ assertNull(service.resolveSuppressionReason(null, null, REGION));+ assertNull(service.resolveSuppressionReason("", null, REGION));+ assertNull(service.resolveSuppressionReason(" ", null, REGION));+ }+}