Light, fluffy, and always free - The AWS Local Emulator alternative
feat(ses): support v2 tenant-scoped sending with association gate (#2815)
Kenshin Okinakab0fe8311a01a
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/SesTenantTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/SesTenantTest.javaindex 9a5098bb8f..98da12823e 100644--- a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/SesTenantTest.java+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/SesTenantTest.java@@ -31,6 +31,8 @@ import software.amazon.awssdk.services.sesv2.model.ListTenantResourcesResponse;import software.amazon.awssdk.services.sesv2.model.ListTenantsRequest;import software.amazon.awssdk.services.sesv2.model.ListTenantsResponse;import software.amazon.awssdk.services.sesv2.model.NotFoundException;+import software.amazon.awssdk.services.sesv2.model.SendEmailRequest;+import software.amazon.awssdk.services.sesv2.model.SesV2Exception;import software.amazon.awssdk.services.sesv2.model.SuppressionListReason;import software.amazon.awssdk.services.sesv2.model.Tag;@@ -326,6 +328,34 @@ class SesTenantTest {@Test@Order(22)+ void tenantSend_gatesOnAssociations() {+ // The domain identity is still associated (order 6); the config set's association was+ // removed in order 14, so using it in a tenant send must be refused with the 403.+ SendEmailRequest.Builder send = SendEmailRequest.builder()+ .fromEmailAddress("probe@" + IDENTITY)+ .destination(d -> d.toAddresses("[email protected]"))+ .content(c -> c.simple(s -> s+ .subject(sub -> sub.data("s"))+ .body(b -> b.text(t -> t.data("t")))));++ assertThat(sesV2.sendEmail(send.tenantName(TENANT).build()).messageId()).isNotNull();++ assertThatThrownBy(() -> sesV2.sendEmail(send.tenantName("compat-send-ghost").build()))+ .isInstanceOf(NotFoundException.class)+ .hasMessageContaining("Tenant compat-send-ghost for AwsAccountId")+ .hasMessageContaining("not found.");++ assertThatThrownBy(() -> sesV2.sendEmail(+ send.tenantName(TENANT).configurationSetName(CONFIG_SET).build()))+ .isInstanceOfSatisfying(SesV2Exception.class, e -> {+ assertThat(e.statusCode()).isEqualTo(403);+ assertThat(e.getMessage()).contains("Tenant not associated with resources [");+ assertThat(e.getMessage()).contains("configuration-set/" + CONFIG_SET);+ });+ }++ @Test+ @Order(23)void deleteTenant_cascadesAssociationsAndSuppressionEntries_thenGetIsNotFound() {sesV2.putSuppressedDestination(r -> r.emailAddress(TENANT_ADDR).reason(SuppressionListReason.COMPLAINT).tenantName(TENANT));@@ -340,7 +370,7 @@ class SesTenantTest {}@Test- @Order(23)+ @Order(24)void deleteTenant_missing_throwsNotFound() {assertThatThrownBy(() -> sesV2.deleteTenant(DeleteTenantRequest.builder().tenantName("compat-tenant-does-not-exist").build()))diff --git a/docs/services/ses.md b/docs/services/ses.mdindex 53a2314212..4475fe558b 100644--- a/docs/services/ses.md+++ b/docs/services/ses.md@@ -291,7 +291,9 @@ Account provisioning details are stored per region. `PutAccountDetails` sets `MaTenants (multi-tenancy) are stored per region. `CreateTenant` requires a `TenantName` (1–64 chars, `[A-Za-z0-9_-]`) and accepts optional `Tags`; it returns the tenant with a generated `TenantId` (`tn-` + 30 hex), a `TenantArn` (`arn:aws:ses:<region>:<account>:tenant/<name>/<id>`), a `CreatedTimestamp`, and `SendingStatus` `ENABLED`. The operations use RPC-style POST subpaths (`/tenants/get`, `/tenants/list`, `/tenants/delete`); `ListTenants` returns the `TenantInfo` subset (no `Tags`/`SendingStatus`) and currently returns every tenant in a single page — `PageSize`/`NextToken` pagination is not yet implemented. A duplicate name is `AlreadyExistsException`; an unknown tenant on get/delete is `NotFoundException`.-Tenant resource associations link a tenant to email identities, configuration sets, and email templates. Matching real AWS, the wire values for `ResourceType` — in responses and as the `Filter` `RESOURCE_TYPE` value — are the ARN segments `identity` / `configuration-set` / `template`; the SDK's `EMAIL_IDENTITY`-style enum constants are rejected, as AWS itself does. The resource must exist in the same account and region; a duplicate association is `AlreadyExistsException`, and deleting a missing one succeeds silently. Deleting a resource that still has associations is rejected, while `DeleteTenant` cascades its associations away. The list operations return a single page (no `PageSize`/`NextToken` pagination yet, like `ListTenants`); tenant-scoped sending is not yet implemented.+Tenant resource associations link a tenant to email identities, configuration sets, and email templates. Matching real AWS, the wire values for `ResourceType` — in responses and as the `Filter` `RESOURCE_TYPE` value — are the ARN segments `identity` / `configuration-set` / `template`; the SDK's `EMAIL_IDENTITY`-style enum constants are rejected, as AWS itself does. The resource must exist in the same account and region; a duplicate association is `AlreadyExistsException`, and deleting a missing one succeeds silently. Deleting a resource that still has associations is rejected, while `DeleteTenant` cascades its associations away. The list operations return a single page (no `PageSize`/`NextToken` pagination yet, like `ListTenants`).++A `TenantName` on `SendEmail`/`SendBulkEmail` makes the send tenant-scoped: the resources it uses — the From identity (the exact address identity, else its domain identity), the effective configuration set (an omitted name resolves to the identity's default), and a stored template — must all be associated with the tenant, or the send is refused with a 403 `AccessDeniedException` listing the missing ARNs. The send path has its own tenant-not-found wording ("Tenant \<name\> for AwsAccountId \<account\> not found."), reached only after the request shape validates. Not emulated: the `SendingStatus` gate (nothing can move the status off `ENABLED`) and tenant-scoped suppression filtering of sends (the account-level semantics apply).`PutTenantSuppressionAttributes` sets a tenant's `SuppressedReasons`/`SuppressionScope` pair on AWS's own singular `/v2/email/tenant/suppression` route. The pair is all-or-nothing: both members set the block (an empty reason list is valid), half a pair is rejected, and a bare `TenantName` clears it. A `TenantName` on the suppression-list operations (body member on put, query parameter on get/delete/list) routes them to the tenant's own list — separate from the account list, independent of `SuppressionScope`, cascaded away by `DeleteTenant`, and with a non-idempotent delete.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 55fceafb2a..a698544dae 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@@ -504,6 +504,7 @@ public class SesController {List<String> replyToAddresses = jsonArrayToList(request.path("ReplyToAddresses"));List<String> allDestinations = mergeLists(toAddresses, ccAddresses, bccAddresses);String configurationSetName = request.path("ConfigurationSetName").asText(null);+ String tenantName = stringMemberOrAbsent(request, "TenantName");List<MessageTag> emailTags = parseEmailTagsArray(request.path("EmailTags"), "EmailTags");ListManagementOptions listManagement =parseListManagementOptions(request.path("ListManagementOptions"));@@ -521,6 +522,8 @@ public class SesController {throw new AwsException("BadRequestException","At least one destination address is required.", 400);}+ sesService.checkTenantRawSendAccess(tenantName, fromEmailAddress, rawData,+ configurationSetName, regionResolver.getAccountId(), region);messageId = sesService.sendRawEmail(fromEmailAddress, allDestinations, rawData,configurationSetName, emailTags, listManagement, region);} else if (content.has("Simple")) {@@ -534,6 +537,8 @@ public class SesController {String bodyHtml = simple.path("Body").path("Html").path("Data").asText(null);List<MessageHeader> additionalHeaders =parseHeadersArray(simple.path("Headers"), "content.simple.headers");+ sesService.checkTenantSendAccess(tenantName, fromEmailAddress, configurationSetName,+ null, regionResolver.getAccountId(), region);messageId = sesService.sendEmail(fromEmailAddress, toAddresses, ccAddresses,bccAddresses, replyToAddresses, subject, bodyText, bodyHtml,configurationSetName, emailTags, additionalHeaders, listManagement, region);@@ -564,6 +569,8 @@ public class SesController {String resolvedName = hasName? templateName: SesService.templateNameFromArn(templateArn);+ sesService.checkTenantSendAccess(tenantName, fromEmailAddress,+ configurationSetName, resolvedName, regionResolver.getAccountId(), region);messageId = sesService.sendTemplatedEmail(fromEmailAddress, toAddresses, ccAddresses,bccAddresses, replyToAddresses, resolvedName, templateData,configurationSetName, emailTags, additionalHeaders, listManagement, region);@@ -572,6 +579,12 @@ public class SesController {String subject = inline.path("Subject").asText(null);String text = inline.path("Text").asText(null);String html = inline.path("Html").asText(null);+ // An empty inline template is reported before the tenant lookup on AWS; the+ // inline content is not a stored template resource, so only the identity and+ // configuration set pass through the gate.+ SesService.requireInlineTemplateContent(subject, text, html);+ sesService.checkTenantSendAccess(tenantName, fromEmailAddress,+ configurationSetName, null, regionResolver.getAccountId(), region);messageId = sesService.sendInlineTemplatedEmail(fromEmailAddress, toAddresses,ccAddresses, bccAddresses, replyToAddresses,subject, text, html, templateData,@@ -614,6 +627,7 @@ public class SesController {}List<String> replyToAddresses = jsonArrayToList(request.path("ReplyToAddresses"));String configurationSetName = request.path("ConfigurationSetName").asText(null);+ String tenantName = stringMemberOrAbsent(request, "TenantName");JsonNode template = request.path("DefaultContent").path("Template");if (template.isMissingNode() || template.isNull()) {@@ -639,15 +653,21 @@ public class SesController {String subject;String text;String html;+ // Inline template content is not a stored template resource, so it stays out of the+ // tenant gate below.+ String gateTemplateName = null;if (hasInline) {JsonNode inline = template.path("TemplateContent");subject = inline.path("Subject").asText(null);text = inline.path("Text").asText(null);html = inline.path("Html").asText(null);+ // Shape validation belongs before the tenant gate below, as on SendEmail.+ SesService.requireInlineTemplateContent(subject, text, html);} else {String resolvedName = hasName? templateName: SesService.templateNameFromArn(templateArn);+ gateTemplateName = resolvedName;EmailTemplate stored = sesService.getTemplate(resolvedName, region);subject = stored.getSubject();text = stored.getTextPart();@@ -686,6 +706,11 @@ public class SesController {entryIndex++;}+ // The tenant gate runs only after every part of the request has been parsed and+ // validated — AWS reports malformed content before a missing tenant (probe-confirmed).+ sesService.checkTenantSendAccess(tenantName, fromEmailAddress, configurationSetName,+ gateTemplateName, regionResolver.getAccountId(), region);+List<BulkEmailEntryResult> results = sesService.sendBulkTemplatedEmail(fromEmailAddress,replyToAddresses, subject, text, html,defaultTemplateData, entries, configurationSetName,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 94fbaa8460..0b153d845c 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@@ -1728,6 +1728,88 @@ public class SesService {return tenantService.listResourceTenants(ref, region);}+ /**+ * The tenant send gate (Phase 4): resolves the tenant with the send-flavored not-found wording,+ * then requires every resource the send uses to be associated with it. The tenant's+ * SendingStatus is not checked — no API can move it off ENABLED, so the DISABLED gate is not+ * emulated. Placement is probe-confirmed: request-shape validation (a missing Content, an empty+ * inline template, a missing FromEmailAddress on Simple, the bulk template-content checks) runs+ * before the tenant lookup, while the recipient checks, the raw MIME-From derivation, and+ * identity verification all lose to the tenant 404.+ */+ public void checkTenantSendAccess(String tenantName, String fromEmailAddress,+ String configurationSetName, String templateName,+ String accountId, String region) {+ if (tenantName == null) {+ return;+ }+ Tenant tenant = tenantService.tenantForSending(tenantName, region, accountId);+ String arnPrefix = "arn:aws:ses:" + region + ":" + accountId + ":";+ List<SesTenantService.AssociationResource> used = new ArrayList<>();+ if (fromEmailAddress != null && !fromEmailAddress.isBlank()) {+ String identityName = sendIdentityName(fromEmailAddress, region);+ used.add(new SesTenantService.AssociationResource(+ SesTenantService.RESOURCE_TYPE_IDENTITY, identityName,+ arnPrefix + "identity/" + identityName));+ }+ // The gate covers the EFFECTIVE configuration set: an omitted name resolves to the sender+ // identity's default, and that one needs the association just as an explicit one does.+ String effectiveConfigSet =+ resolveDefaultConfigurationSet(configurationSetName, fromEmailAddress, region);+ if (effectiveConfigSet != null && !effectiveConfigSet.isBlank()) {+ used.add(new SesTenantService.AssociationResource(+ SesTenantService.RESOURCE_TYPE_CONFIGURATION_SET, effectiveConfigSet,+ arnPrefix + "configuration-set/" + effectiveConfigSet));+ }+ if (templateName != null && !templateName.isBlank()) {+ used.add(new SesTenantService.AssociationResource(+ SesTenantService.RESOURCE_TYPE_TEMPLATE, templateName,+ arnPrefix + "template/" + templateName));+ }+ tenantService.requireResourcesAssociated(tenant, used, region);+ }++ /**+ * The raw-content variant of the tenant send gate: when {@code FromEmailAddress} is omitted,+ * the effective sender comes from the MIME {@code From} header — the same derivation+ * {@code sendRawEmail} applies — so the gate must resolve it the same way before checking.+ */+ public void checkTenantRawSendAccess(String tenantName, String fromEmailAddress,+ String rawMessage, String configurationSetName,+ String accountId, String region) {+ if (tenantName == null) {+ return;+ }+ String effectiveSource = fromEmailAddress;+ if (effectiveSource == null || effectiveSource.isBlank()) {+ SmtpRelay.RawMessageHeaders headers = SmtpRelay.parseRawHeaders(rawMessage);+ effectiveSource = headers != null && !headers.from().isBlank() ? headers.from() : null;+ }+ checkTenantSendAccess(tenantName, effectiveSource, configurationSetName, null,+ accountId, region);+ }++ // The gate names the identity the way AWS did in the probed error: the exact address identity+ // when one exists, otherwise the domain identity the address falls under. The sender may carry+ // display-name syntax ("Name <a@b>"), so the bare address is extracted first.+ private String sendIdentityName(String fromEmailAddress, String region) {+ String email = extractEmailAddress(fromEmailAddress);+ if (email.isBlank()) {+ return fromEmailAddress.trim();+ }+ if (identityStore.get(identityKey(region, email)).isPresent()) {+ return email;+ }+ int at = email.lastIndexOf('@');+ if (at >= 0) {+ String domain = email.substring(at + 1);+ if (identityStore.get(identityKey(region, domain)).isPresent()) {+ return domain;+ }+ }+ return email;+ }+// The association APIs 404 with a per-type message when the referenced resource is missing; the// trailing colon on the configuration-set variant is AWS's own.private void requireTenantResourceExists(SesTenantService.AssociationResource ref, String region) {@@ -2812,13 +2894,12 @@ public class SesService {return "===_floci_" + HexFormat.of().formatHex(bytes) + "_===";}- public String sendInlineTemplatedEmail(String source, List<String> toAddresses, List<String> ccAddresses,- List<String> bccAddresses, List<String> replyToAddresses,- String subject, String textPart, String htmlPart,- JsonNode templateData,- String configurationSetName, List<MessageTag> emailTags,- List<MessageHeader> additionalHeaders,- ListManagementOptions listManagement, String region) {+ /**+ * Also called by the controller ahead of the tenant send gate: AWS reports an empty inline+ * template before it looks the tenant up (probe-confirmed), so the check must not stay behind+ * the gate for tenant sends.+ */+ static void requireInlineTemplateContent(String subject, String textPart, String htmlPart) {boolean hasSubject = subject != null && !subject.isBlank();boolean hasText = textPart != null && !textPart.isBlank();boolean hasHtml = htmlPart != null && !htmlPart.isBlank();@@ -2826,6 +2907,16 @@ public class SesService {throw new AwsException("InvalidTemplate","Template must have at least a subject, text, or html part.", 400);}+ }++ public String sendInlineTemplatedEmail(String source, List<String> toAddresses, List<String> ccAddresses,+ List<String> bccAddresses, List<String> replyToAddresses,+ String subject, String textPart, String htmlPart,+ JsonNode templateData,+ String configurationSetName, List<MessageTag> emailTags,+ List<MessageHeader> additionalHeaders,+ ListManagementOptions listManagement, String region) {+ requireInlineTemplateContent(subject, textPart, htmlPart);return sendEmail(source, toAddresses, ccAddresses, bccAddresses, replyToAddresses,applyTemplateData(subject, templateData),applyTemplateData(textPart, templateData),@@ -2845,13 +2936,7 @@ public class SesService {if (source == null || source.isBlank()) {throw new AwsException("InvalidParameterValue", "Source email is required.", 400);}- boolean hasSubject = subject != null && !subject.isBlank();- boolean hasText = textPart != null && !textPart.isBlank();- boolean hasHtml = htmlPart != null && !htmlPart.isBlank();- if (!hasSubject && !hasText && !hasHtml) {- throw new AwsException("InvalidTemplate",- "Template must have at least a subject, text, or html part.", 400);- }+ requireInlineTemplateContent(subject, textPart, htmlPart);if (entries == null || entries.isEmpty()) {throw new AwsException("InvalidParameterValue","At least one destination entry is required.", 400);diff --git a/src/main/java/io/github/hectorvent/floci/services/ses/SesTenantService.java b/src/main/java/io/github/hectorvent/floci/services/ses/SesTenantService.javaindex bc6361c9f9..b0c349bc59 100644--- a/src/main/java/io/github/hectorvent/floci/services/ses/SesTenantService.java+++ b/src/main/java/io/github/hectorvent/floci/services/ses/SesTenantService.java@@ -193,6 +193,43 @@ public class SesTenantService {.orElseThrow(() -> tenantNotFound(tenantName));}+ // ──────────────────────── Tenant-scoped sending (Phase 4) ────────────────────────+ // Behavior and messages probe-confirmed against real AWS us-east-1, 2026-08-30.++ /**+ * Resolves the tenant for a send. The not-found wording differs from the management operations:+ * no angle brackets, and the account id is included.+ */+ public Tenant tenantForSending(String tenantName, String region, String accountId) {+ // Unreachable through the facade (which treats a null TenantName as a non-tenant send), but+ // a public helper should fail the AWS way — same guard as runWithTenant.+ if (tenantName == null || tenantName.isBlank()) {+ throw new AwsException("BadRequestException", "TenantName cannot be empty", 400);+ }+ return tenantStore.get(tenantKey(region, tenantName))+ .orElseThrow(() -> new AwsException("NotFoundException",+ "Tenant " + tenantName + " for AwsAccountId " + accountId + " not found.", 404));+ }++ /**+ * The send gate: every resource a tenant send uses (From identity, configuration set, template)+ * must be associated with the tenant, or AWS refuses the send with a 403. The bracket list+ * carries every missing ARN (the plural is AWS's own wording even for a single resource; on the+ * wire AWS spells the body key "Message" — Floci renders its usual error shape instead).+ */+ public void requireResourcesAssociated(Tenant tenant, List<AssociationResource> resources,+ String region) {+ List<String> missing = resources.stream()+ .filter(ref -> associationStore+ .get(associationKey(region, tenant.tenantId(), ref)).isEmpty())+ .map(AssociationResource::arn)+ .toList();+ if (!missing.isEmpty()) {+ throw new AwsException("AccessDeniedException",+ "Tenant not associated with resources [" + String.join(", ", missing) + "].", 403);+ }+ }+/*** Parses and format-validates a resource ARN for the association operations. Check order matches* the observed AWS precedence: not an ARN at all, then not an SES ARN, then an unsupported SESdiff --git a/src/test/java/io/github/hectorvent/floci/services/ses/SesTenantSendV2IntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/ses/SesTenantSendV2IntegrationTest.javanew file mode 100644index 0000000000..a50e98d168--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/ses/SesTenantSendV2IntegrationTest.java@@ -0,0 +1,277 @@+package io.github.hectorvent.floci.services.ses;++import io.quarkus.test.junit.QuarkusTest;+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.equalTo;+import static org.hamcrest.Matchers.notNullValue;++/**+ * Integration tests for SES v2 tenant-scoped sending (Phase 4): the {@code TenantName} member on+ * {@code SendEmail} and {@code SendBulkEmail}. A send whose resources are not associated with the+ * tenant is refused with a 403 {@code AccessDeniedException} listing every missing ARN — probed for+ * the From identity (exact-address precedence included) and the configuration set; the+ * stored-template gate is inferred from the association model, not observed. The send-path+ * tenant-not-found wording differs from the management operations (no angle brackets, account id+ * included, probe-confirmed). The tenant's SendingStatus is not checked — nothing can move it off+ * ENABLED in the emulator.+ */+@QuarkusTest+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)+class SesTenantSendV2IntegrationTest {++ private static final String AUTH =+ "AWS4-HMAC-SHA256 Credential=AKID/20260101/us-east-1/ses/aws4_request";+ private static final String TENANT = "floci-send-tenant";+ private static final String DOMAIN = "floci-send.example.com";+ private static final String FROM = "no-reply@" + DOMAIN;+ private static final String CONFIG_SET = "floci-send-cs";+ private static final String TEMPLATE = "floci-send-tpl";+ private static final String ARN_PREFIX = "arn:aws:ses:us-east-1:000000000000:";++ private static io.restassured.specification.RequestSpecification v2() {+ return given().contentType("application/json").header("Authorization", AUTH);+ }++ private static String simpleSend(String tenantName, String configSetLine) {+ return "{\"FromEmailAddress\":\"" + FROM + "\","+ + "\"Destination\":{\"ToAddresses\":[\"[email protected]\"]},"+ + (tenantName == null ? "" : "\"TenantName\":\"" + tenantName + "\",")+ + configSetLine+ + "\"Content\":{\"Simple\":{\"Subject\":{\"Data\":\"s\"},"+ + "\"Body\":{\"Text\":{\"Data\":\"t\"}}}}}";+ }++ private static void associate(String arn) {+ v2().body("{\"TenantName\":\"" + TENANT + "\",\"ResourceArn\":\"" + arn + "\"}")+ .when().post("/v2/email/tenants/resources").then().statusCode(200);+ }++ @Test+ @Order(1)+ void setup_tenantAndResources() {+ v2().body("{\"TenantName\":\"" + TENANT + "\"}")+ .when().post("/v2/email/tenants").then().statusCode(200);+ v2().body("{\"EmailIdentity\":\"" + DOMAIN + "\"}")+ .when().post("/v2/email/identities").then().statusCode(200);+ v2().body("{\"ConfigurationSetName\":\"" + CONFIG_SET + "\"}")+ .when().post("/v2/email/configuration-sets").then().statusCode(200);+ v2().body("{\"TemplateName\":\"" + TEMPLATE + "\",\"TemplateContent\":{\"Subject\":\"s\",\"Text\":\"t\"}}")+ .when().post("/v2/email/templates").then().statusCode(200);+ }++ @Test+ @Order(2)+ void send_ghostTenant_sendFlavoredNotFound() {+ v2().body(simpleSend("ghost-tenant", ""))+ .when().post("/v2/email/outbound-emails").then().statusCode(404)+ .body("__type", equalTo("NotFoundException"))+ .body("message", equalTo(+ "Tenant ghost-tenant for AwsAccountId 000000000000 not found."));+ }++ @Test+ @Order(3)+ void send_validationOrderMatchesAws() {+ // Probe-confirmed split: request-shape errors win over the ghost tenant...+ v2().body("{\"FromEmailAddress\":\"" + FROM + "\",\"TenantName\":\"ghost-tenant\","+ + "\"Destination\":{\"ToAddresses\":[\"[email protected]\"]}}")+ .when().post("/v2/email/outbound-emails").then().statusCode(400);+ v2().body("{\"FromEmailAddress\":\"" + FROM + "\",\"TenantName\":\"ghost-tenant\","+ + "\"Destination\":{\"ToAddresses\":[\"[email protected]\"]},"+ + "\"Content\":{\"Template\":{\"TemplateContent\":{},\"TemplateData\":\"{}\"}}}")+ .when().post("/v2/email/outbound-emails").then().statusCode(400);++ // ...while the recipient check and the raw sender derivation lose to the tenant 404.+ v2().body("{\"FromEmailAddress\":\"" + FROM + "\",\"TenantName\":\"ghost-tenant\","+ + "\"Destination\":{\"ToAddresses\":[]},"+ + "\"Content\":{\"Simple\":{\"Subject\":{\"Data\":\"s\"},"+ + "\"Body\":{\"Text\":{\"Data\":\"t\"}}}}}")+ .when().post("/v2/email/outbound-emails").then().statusCode(404)+ .body("message", equalTo(+ "Tenant ghost-tenant for AwsAccountId 000000000000 not found."));+ }++ @Test+ @Order(4)+ void send_unassociatedIdentity_is403() {+ // The domain identity backs the From address, so its ARN is the one in the message.+ v2().body(simpleSend(TENANT, ""))+ .when().post("/v2/email/outbound-emails").then().statusCode(403)+ .body("__type", equalTo("AccessDeniedException"))+ .body("message", equalTo("Tenant not associated with resources ["+ + ARN_PREFIX + "identity/" + DOMAIN + "]."));+ }++ @Test+ @Order(5)+ void send_associatedIdentity_succeeds_unassociatedConfigSetStill403() {+ associate(ARN_PREFIX + "identity/" + DOMAIN);+ v2().body(simpleSend(TENANT, ""))+ .when().post("/v2/email/outbound-emails").then().statusCode(200)+ .body("MessageId", notNullValue());++ v2().body(simpleSend(TENANT, "\"ConfigurationSetName\":\"" + CONFIG_SET + "\","))+ .when().post("/v2/email/outbound-emails").then().statusCode(403)+ .body("message", equalTo("Tenant not associated with resources ["+ + ARN_PREFIX + "configuration-set/" + CONFIG_SET + "]."));++ associate(ARN_PREFIX + "configuration-set/" + CONFIG_SET);+ v2().body(simpleSend(TENANT, "\"ConfigurationSetName\":\"" + CONFIG_SET + "\","))+ .when().post("/v2/email/outbound-emails").then().statusCode(200)+ .body("MessageId", notNullValue());+ }++ @Test+ @Order(6)+ void send_templated_requiresTemplateAssociation() {+ String templatedSend = "{\"FromEmailAddress\":\"" + FROM + "\","+ + "\"Destination\":{\"ToAddresses\":[\"[email protected]\"]},"+ + "\"TenantName\":\"" + TENANT + "\","+ + "\"Content\":{\"Template\":{\"TemplateName\":\"" + TEMPLATE + "\","+ + "\"TemplateData\":\"{}\"}}}";+ v2().body(templatedSend)+ .when().post("/v2/email/outbound-emails").then().statusCode(403)+ .body("message", equalTo("Tenant not associated with resources ["+ + ARN_PREFIX + "template/" + TEMPLATE + "]."));++ associate(ARN_PREFIX + "template/" + TEMPLATE);+ v2().body(templatedSend)+ .when().post("/v2/email/outbound-emails").then().statusCode(200)+ .body("MessageId", notNullValue());+ }++ @Test+ @Order(7)+ void send_nonStringTenantName_isSerializationError_displayNameFromResolves() {+ v2().body("{\"FromEmailAddress\":\"" + FROM + "\",\"TenantName\":123,"+ + "\"Destination\":{\"ToAddresses\":[\"[email protected]\"]},"+ + "\"Content\":{\"Simple\":{\"Subject\":{\"Data\":\"s\"},"+ + "\"Body\":{\"Text\":{\"Data\":\"t\"}}}}}")+ .when().post("/v2/email/outbound-emails").then().statusCode(400)+ .body("__type", equalTo("SerializationException"));++ // Display-name syntax must not break the identity resolution behind the gate.+ v2().body("{\"FromEmailAddress\":\"Floci <" + FROM + ">\","+ + "\"Destination\":{\"ToAddresses\":[\"[email protected]\"]},"+ + "\"TenantName\":\"" + TENANT + "\","+ + "\"Content\":{\"Simple\":{\"Subject\":{\"Data\":\"s\"},"+ + "\"Body\":{\"Text\":{\"Data\":\"t\"}}}}}")+ .when().post("/v2/email/outbound-emails").then().statusCode(200)+ .body("MessageId", notNullValue());++ // An exact-address identity takes precedence over the (associated) domain identity — the+ // probed AWS 403 named the address identity's ARN in exactly this setup.+ v2().body("{\"EmailIdentity\":\"" + FROM + "\"}")+ .when().post("/v2/email/identities").then().statusCode(200);+ v2().body(simpleSend(TENANT, ""))+ .when().post("/v2/email/outbound-emails").then().statusCode(403)+ .body("message", equalTo("Tenant not associated with resources ["+ + ARN_PREFIX + "identity/" + FROM + "]."));+ associate(ARN_PREFIX + "identity/" + FROM);+ v2().body(simpleSend(TENANT, ""))+ .when().post("/v2/email/outbound-emails").then().statusCode(200)+ .body("MessageId", notNullValue());+ }++ @Test+ @Order(8)+ void rawSend_gatesTheMimeDerivedSender() {+ v2().body("{\"EmailIdentity\":\"floci-raw.example.com\"}")+ .when().post("/v2/email/identities").then().statusCode(200);+ String mime = "From: [email protected]\r\nTo: [email protected]\r\n"+ + "Subject: s\r\n\r\nbody";+ String data = java.util.Base64.getEncoder().encodeToString(mime.getBytes(java.nio.charset.StandardCharsets.UTF_8));+ // FromEmailAddress omitted: the sender comes from the MIME From header, and that identity+ // is not associated with the tenant.+ v2().body("{\"TenantName\":\"" + TENANT + "\","+ + "\"Destination\":{\"ToAddresses\":[\"[email protected]\"]},"+ + "\"Content\":{\"Raw\":{\"Data\":\"" + data + "\"}}}")+ .when().post("/v2/email/outbound-emails").then().statusCode(403)+ .body("message", equalTo("Tenant not associated with resources ["+ + ARN_PREFIX + "identity/floci-raw.example.com]."));+ }++ @Test+ @Order(9)+ void send_gatesTheIdentityDefaultConfigurationSet() {+ v2().body("{\"ConfigurationSetName\":\"floci-send-default-cs\"}")+ .when().post("/v2/email/configuration-sets").then().statusCode(200);+ v2().body("{\"ConfigurationSetName\":\"floci-send-default-cs\"}")+ .when().put("/v2/email/identities/" + DOMAIN + "/configuration-set")+ .then().statusCode(200);++ // No explicit ConfigurationSetName — the identity's default is the effective one, and it+ // needs the association just the same.+ v2().body(simpleSend(TENANT, ""))+ .when().post("/v2/email/outbound-emails").then().statusCode(403)+ .body("message", equalTo("Tenant not associated with resources ["+ + ARN_PREFIX + "configuration-set/floci-send-default-cs]."));++ associate(ARN_PREFIX + "configuration-set/floci-send-default-cs");+ v2().body(simpleSend(TENANT, ""))+ .when().post("/v2/email/outbound-emails").then().statusCode(200)+ .body("MessageId", notNullValue());+ }++ @Test+ @Order(10)+ void bulkSend_contentValidationPrecedesTenantExistence() {+ // Probe-confirmed: a bulk send without template content fails on the content before the+ // ghost tenant is even looked at. The same holds for the rest of the request shape.+ v2().body("{\"FromEmailAddress\":\"" + FROM + "\",\"TenantName\":\"ghost-tenant\","+ + "\"DefaultContent\":{},"+ + "\"BulkEmailEntries\":[{\"Destination\":{\"ToAddresses\":"+ + "[\"[email protected]\"]}}]}")+ .when().post("/v2/email/outbound-bulk-emails").then().statusCode(400);+ v2().body("{\"FromEmailAddress\":\"" + FROM + "\",\"TenantName\":\"ghost-tenant\","+ + "\"DefaultContent\":{\"Template\":{\"TemplateName\":\"" + TEMPLATE + "\","+ + "\"TemplateData\":\"{}\"}},\"BulkEmailEntries\":[]}")+ .when().post("/v2/email/outbound-bulk-emails").then().statusCode(400);+ // An all-blank inline template is a shape error too — 400 before the ghost tenant's 404.+ v2().body("{\"FromEmailAddress\":\"" + FROM + "\",\"TenantName\":\"ghost-tenant\","+ + "\"DefaultContent\":{\"Template\":{\"TemplateContent\":{},"+ + "\"TemplateData\":\"{}\"}},"+ + "\"BulkEmailEntries\":[{\"Destination\":{\"ToAddresses\":"+ + "[\"[email protected]\"]}}]}")+ .when().post("/v2/email/outbound-bulk-emails").then().statusCode(400);++ v2().body("{\"FromEmailAddress\":\"" + FROM + "\",\"TenantName\":\"ghost-tenant\","+ + "\"DefaultContent\":{\"Template\":{\"TemplateName\":\"" + TEMPLATE + "\","+ + "\"TemplateData\":\"{}\"}},"+ + "\"BulkEmailEntries\":[{\"Destination\":{\"ToAddresses\":"+ + "[\"[email protected]\"]}}]}")+ .when().post("/v2/email/outbound-bulk-emails").then().statusCode(404)+ .body("message", equalTo(+ "Tenant ghost-tenant for AwsAccountId 000000000000 not found."));+ }++ @Test+ @Order(11)+ void bulkSend_withAssociatedResources_succeeds() {+ v2().body("{\"FromEmailAddress\":\"" + FROM + "\",\"TenantName\":\"" + TENANT + "\","+ + "\"DefaultContent\":{\"Template\":{\"TemplateName\":\"" + TEMPLATE + "\","+ + "\"TemplateData\":\"{}\"}},"+ + "\"BulkEmailEntries\":[{\"Destination\":{\"ToAddresses\":"+ + "[\"[email protected]\"]}}]}")+ .when().post("/v2/email/outbound-bulk-emails").then().statusCode(200)+ .body("BulkEmailEntryResults[0].Status", equalTo("SUCCESS"));+ }++ @Test+ @Order(12)+ void cleanup_cascadeAndResources() {+ v2().body("{\"TenantName\":\"" + TENANT + "\"}")+ .when().post("/v2/email/tenants/delete").then().statusCode(200);+ v2().when().delete("/v2/email/templates/" + TEMPLATE).then().statusCode(200);+ v2().when().delete("/v2/email/configuration-sets/" + CONFIG_SET).then().statusCode(200);+ v2().when().delete("/v2/email/configuration-sets/floci-send-default-cs").then().statusCode(200);+ v2().when().delete("/v2/email/identities/" + FROM).then().statusCode(200);+ v2().when().delete("/v2/email/identities/" + DOMAIN).then().statusCode(200);+ v2().when().delete("/v2/email/identities/floci-raw.example.com").then().statusCode(200);+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/ses/SesTenantServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/ses/SesTenantServiceTest.javaindex 928c3d5d46..f05348b6d9 100644--- a/src/test/java/io/github/hectorvent/floci/services/ses/SesTenantServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/ses/SesTenantServiceTest.java@@ -436,6 +436,45 @@ class SesTenantServiceTest {assertTrue(service.find("acme", REGION).isEmpty());}+ // ──────────────────────── Tenant-scoped sending (Phase 4) ────────────────────────++ @Test+ void tenantForSending_hasSendFlavoredNotFoundWording() {+ AwsException e = assertThrows(AwsException.class,+ () -> service.tenantForSending("ghost", REGION, ACCOUNT));+ assertEquals("NotFoundException", e.getErrorCode());+ // No angle brackets, and the account id is included — unlike the management operations.+ assertEquals("Tenant ghost for AwsAccountId " + ACCOUNT + " not found.", e.getMessage());+ assertEquals("TenantName cannot be empty",+ assertThrows(AwsException.class,+ () -> service.tenantForSending(" ", REGION, ACCOUNT)).getMessage());+ assertEquals("TenantName cannot be empty",+ assertThrows(AwsException.class,+ () -> service.tenantForSending(null, REGION, ACCOUNT)).getMessage());+ }++ @Test+ void requireResourcesAssociated_collectsEveryMissingArn() {+ Tenant tenant = service.createTenant("acme", List.of(), ACCOUNT, REGION);+ SesTenantService.AssociationResource identity = identityRef("example.com");+ SesTenantService.AssociationResource cs = SesTenantService.parseResourceArn(+ "arn:aws:ses:" + REGION + ":" + ACCOUNT + ":configuration-set/cs", ACCOUNT, REGION);+ service.associate(tenant, identity, REGION, () -> {});++ service.requireResourcesAssociated(tenant, List.of(identity), REGION);+ AwsException e = assertThrows(AwsException.class,+ () -> service.requireResourcesAssociated(tenant, List.of(identity, cs), REGION));+ assertEquals("AccessDeniedException", e.getErrorCode());+ assertEquals(403, e.getHttpStatus());+ assertEquals("Tenant not associated with resources [" + cs.arn() + "].", e.getMessage());++ service.disassociate(tenant, identity, REGION);+ AwsException both = assertThrows(AwsException.class,+ () -> service.requireResourcesAssociated(tenant, List.of(identity, cs), REGION));+ assertEquals("Tenant not associated with resources [" + identity.arn() + ", " + cs.arn() + "].",+ both.getMessage());+ }+@Testvoid validateFilterAndPaging_matchAwsMessages() {assertEquals("Invalid resource type NOPE specified.",