Light, fluffy, and always free - The AWS Local Emulator alternative
feat(ses): support v2 tenant resource associations (#2710)
Kenshin Okinaka67f75c7e1d9f
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 d913a037c6..73c6e87d9a 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@@ -11,49 +11,75 @@ import org.junit.jupiter.api.TestMethodOrder;import software.amazon.awssdk.services.sesv2.SesV2Client;import software.amazon.awssdk.services.sesv2.model.AlreadyExistsException;import software.amazon.awssdk.services.sesv2.model.BadRequestException;+import software.amazon.awssdk.services.sesv2.model.CreateConfigurationSetRequest;+import software.amazon.awssdk.services.sesv2.model.CreateEmailIdentityRequest;import software.amazon.awssdk.services.sesv2.model.CreateTenantRequest;import software.amazon.awssdk.services.sesv2.model.CreateTenantResponse;+import software.amazon.awssdk.services.sesv2.model.DeleteConfigurationSetRequest;+import software.amazon.awssdk.services.sesv2.model.DeleteEmailIdentityRequest;import software.amazon.awssdk.services.sesv2.model.DeleteTenantRequest;+import software.amazon.awssdk.services.sesv2.model.DeleteTenantResourceAssociationRequest;import software.amazon.awssdk.services.sesv2.model.GetTenantRequest;import software.amazon.awssdk.services.sesv2.model.GetTenantResponse;+import software.amazon.awssdk.services.sesv2.model.ListResourceTenantsRequest;+import software.amazon.awssdk.services.sesv2.model.ListResourceTenantsResponse;+import software.amazon.awssdk.services.sesv2.model.ListTenantResourcesFilterKey;+import software.amazon.awssdk.services.sesv2.model.ListTenantResourcesRequest;+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.Tag;+import java.util.Map;+import static org.assertj.core.api.Assertions.assertThat;import static org.assertj.core.api.Assertions.assertThatThrownBy;/**- * SDK compatibility test for the SES v2 tenant APIs. Verifies the AWS Java SDK v2 marshalling of- * CreateTenant / GetTenant / ListTenants / DeleteTenant — the RPC-style POST routes, the generated- * TenantId (tn-) and TenantArn, the ENABLED sending status, and the- * AlreadyExistsException / NotFoundException / BadRequestException errors — against a live Floci- * instance. Tenants are reversible (create + delete), so cleanup restores the account.+ * SDK compatibility test for the SES v2 tenant APIs: the CRUD (CreateTenant / GetTenant /+ * ListTenants / DeleteTenant) and the resource associations (CreateTenantResourceAssociation /+ * DeleteTenantResourceAssociation / ListTenantResources / ListResourceTenants), one ordered flow+ * against a live Floci instance. One AWS quirk drives the association assertions: the service's wire+ * values for ResourceType — in responses and as the RESOURCE_TYPE filter value — are the ARN+ * segments (identity / configuration-set / template), not the SDK's EMAIL_IDENTITY-style enum+ * constants. Real AWS rejects the enum spelling as a filter and returns values the SDK maps to+ * UNKNOWN_TO_SDK_VERSION, so the test asserts resourceTypeAsString. Tenants are reversible+ * (create + delete), so cleanup restores the account.*/@DisplayName("SES v2 Tenants")@TestMethodOrder(MethodOrderer.OrderAnnotation.class)class SesTenantTest {private static final String TENANT = "compat-tenant-alpha";+ private static final String IDENTITY = "compat-assoc.example.com";+ private static final String CONFIG_SET = "compat-assoc-cs";private static SesV2Client sesV2;+ private static String identityArn;+ private static String configSetArn;@BeforeAllstatic void setup() {sesV2 = TestFixtures.sesV2Client();+ sesV2.createEmailIdentity(CreateEmailIdentityRequest.builder().emailIdentity(IDENTITY).build());+ sesV2.createConfigurationSet(CreateConfigurationSetRequest.builder()+ .configurationSetName(CONFIG_SET).build());}@AfterAllstatic void cleanup() {if (sesV2 != null) {try {+ // DeleteTenant cascades any remaining associations, freeing the backing resources.sesV2.deleteTenant(DeleteTenantRequest.builder().tenantName(TENANT).build());} catch (NotFoundException expected) {// Already removed by the delete test; anything else (auth, connectivity) must surface.- } finally {- sesV2.close();}+ sesV2.deleteConfigurationSet(DeleteConfigurationSetRequest.builder()+ .configurationSetName(CONFIG_SET).build());+ sesV2.deleteEmailIdentity(DeleteEmailIdentityRequest.builder().emailIdentity(IDENTITY).build());+ sesV2.close();}}@@ -70,6 +96,10 @@ class SesTenantTest {assertThat(resp.sendingStatusAsString()).isEqualTo("ENABLED");assertThat(resp.createdTimestamp()).isNotNull();assertThat(resp.tags()).extracting(Tag::key).contains("team");++ String arnPrefix = resp.tenantArn().substring(0, resp.tenantArn().indexOf(":tenant/") + 1);+ identityArn = arnPrefix + "identity/" + IDENTITY;+ configSetArn = arnPrefix + "configuration-set/" + CONFIG_SET;}@Test@@ -107,14 +137,118 @@ class SesTenantTest {@Test@Order(6)- void deleteTenant_removesIt_thenGetIsNotFound() {+ void createAssociations_succeed() {+ sesV2.createTenantResourceAssociation(r -> r.tenantName(TENANT).resourceArn(identityArn));+ sesV2.createTenantResourceAssociation(r -> r.tenantName(TENANT).resourceArn(configSetArn));+ }++ @Test+ @Order(7)+ void createAssociation_duplicate_throwsAlreadyExists() {+ assertThatThrownBy(() -> sesV2.createTenantResourceAssociation(+ r -> r.tenantName(TENANT).resourceArn(identityArn)))+ .isInstanceOf(AlreadyExistsException.class)+ .hasMessageContaining("has already been associated with tenant " + TENANT);+ }++ @Test+ @Order(8)+ void createAssociation_missingTenantOrResource_throwsNotFound() {+ assertThatThrownBy(() -> sesV2.createTenantResourceAssociation(+ r -> r.tenantName("compat-assoc-ghost").resourceArn(identityArn)))+ .isInstanceOf(NotFoundException.class);+ assertThatThrownBy(() -> sesV2.createTenantResourceAssociation(+ r -> r.tenantName(TENANT).resourceArn(configSetArn.replace(CONFIG_SET, "ghost-cs"))))+ .isInstanceOf(NotFoundException.class)+ .hasMessageContaining("Configuration set <ghost-cs> does not exist:");+ }++ @Test+ @Order(9)+ void createAssociation_invalidArn_throwsBadRequest() {+ assertThatThrownBy(() -> sesV2.createTenantResourceAssociation(+ r -> r.tenantName(TENANT).resourceArn("not-an-arn")))+ .isInstanceOf(BadRequestException.class)+ .hasMessageContaining("Provided resource identifier is not an SES resource");+ }++ @Test+ @Order(10)+ void listTenantResources_returnsArnSegmentTypeValues() {+ ListTenantResourcesResponse resp = sesV2.listTenantResources(+ ListTenantResourcesRequest.builder().tenantName(TENANT).build());+ assertThat(resp.tenantResources()).hasSize(2);+ // Sorted by ARN; the wire type values do not map onto the SDK enum.+ assertThat(resp.tenantResources().get(0).resourceTypeAsString()).isEqualTo("configuration-set");+ assertThat(resp.tenantResources().get(1).resourceTypeAsString()).isEqualTo("identity");+ assertThat(resp.tenantResources().get(1).resourceArn()).isEqualTo(identityArn);+ }++ @Test+ @Order(11)+ void listTenantResources_filterTakesWireValues_rejectsEnumSpelling() {+ ListTenantResourcesResponse filtered = sesV2.listTenantResources(+ ListTenantResourcesRequest.builder().tenantName(TENANT)+ .filter(Map.of(ListTenantResourcesFilterKey.RESOURCE_TYPE, "identity"))+ .build());+ assertThat(filtered.tenantResources()).hasSize(1);+ assertThat(filtered.tenantResources().get(0).resourceArn()).isEqualTo(identityArn);++ assertThatThrownBy(() -> sesV2.listTenantResources(+ ListTenantResourcesRequest.builder().tenantName(TENANT)+ .filter(Map.of(ListTenantResourcesFilterKey.RESOURCE_TYPE, "EMAIL_IDENTITY"))+ .build()))+ .isInstanceOf(BadRequestException.class)+ .hasMessageContaining("Invalid resource type EMAIL_IDENTITY specified.");+ }++ @Test+ @Order(12)+ void listResourceTenants_returnsAssociationMetadata() {+ ListResourceTenantsResponse resp = sesV2.listResourceTenants(+ ListResourceTenantsRequest.builder().resourceArn(identityArn).build());+ assertThat(resp.resourceTenants()).hasSize(1);+ assertThat(resp.resourceTenants().get(0).tenantName()).isEqualTo(TENANT);+ assertThat(resp.resourceTenants().get(0).tenantId()).startsWith("tn-");+ assertThat(resp.resourceTenants().get(0).resourceArn()).isEqualTo(identityArn);+ assertThat(resp.resourceTenants().get(0).associatedTimestamp()).isNotNull();+ }++ @Test+ @Order(13)+ void deleteBackingResource_whileAssociated_isBlocked() {+ assertThatThrownBy(() -> sesV2.deleteConfigurationSet(DeleteConfigurationSetRequest.builder()+ .configurationSetName(CONFIG_SET).build()))+ .isInstanceOf(BadRequestException.class)+ .hasMessageContaining("because it has tenant associations");+ }++ @Test+ @Order(14)+ void deleteAssociation_removesIt_andIsIdempotent() {+ sesV2.deleteTenantResourceAssociation(DeleteTenantResourceAssociationRequest.builder()+ .tenantName(TENANT).resourceArn(configSetArn).build());+ // Removing an association that no longer exists is a silent success on AWS.+ sesV2.deleteTenantResourceAssociation(DeleteTenantResourceAssociationRequest.builder()+ .tenantName(TENANT).resourceArn(configSetArn).build());+ ListTenantResourcesResponse resp = sesV2.listTenantResources(+ ListTenantResourcesRequest.builder().tenantName(TENANT).build());+ assertThat(resp.tenantResources()).hasSize(1);+ }++ @Test+ @Order(15)+ void deleteTenant_cascadesRemainingAssociations_thenGetIsNotFound() {sesV2.deleteTenant(DeleteTenantRequest.builder().tenantName(TENANT).build());+ ListResourceTenantsResponse resp = sesV2.listResourceTenants(+ ListResourceTenantsRequest.builder().resourceArn(identityArn).build());+ assertThat(resp.resourceTenants()).isEmpty();assertThatThrownBy(() -> sesV2.getTenant(GetTenantRequest.builder().tenantName(TENANT).build())).isInstanceOf(NotFoundException.class);}@Test- @Order(7)+ @Order(16)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 42e6afa00b..6c205c74b3 100644--- a/docs/services/ses.md+++ b/docs/services/ses.md@@ -214,6 +214,10 @@ Alongside the classic Query API, Floci implements a subset of the SES v2 REST JS| `POST` | `/v2/email/tenants/get` | `GetTenant` || `POST` | `/v2/email/tenants/list` | `ListTenants` || `POST` | `/v2/email/tenants/delete` | `DeleteTenant` |+| `POST` | `/v2/email/tenants/resources` | `CreateTenantResourceAssociation` |+| `POST` | `/v2/email/tenants/resources/delete` | `DeleteTenantResourceAssociation` |+| `POST` | `/v2/email/tenants/resources/list` | `ListTenantResources` |+| `POST` | `/v2/email/resources/tenants/list` | `ListResourceTenants` || `POST` | `/v2/email/templates` | `CreateEmailTemplate` || `GET` | `/v2/email/templates` | `ListEmailTemplates` || `GET` | `/v2/email/templates/{templateName}` | `GetEmailTemplate` |@@ -284,7 +288,9 @@ Account-level VDM (Virtual Deliverability Manager) attributes are stored per regAccount provisioning details are stored per region. `PutAccountDetails` sets `MailType` (required, ∈ {`MARKETING`, `TRANSACTIONAL`}) and `WebsiteURL` (required, 1–1000 chars) plus the optional `ContactLanguage` (∈ {`EN`, `JA`}), `UseCaseDescription` (≤5000 chars), `AdditionalContactEmailAddresses` (1–4 entries, each 6–254 chars matching `^(.+)@(.+)$`), and `ProductionAccessEnabled`. Floci stores `ProductionAccessEnabled` as given but stays production-enabled regardless (it has no sandbox), so the flag has no functional effect. Like `VdmAttributes`, `GetAccount` omits `Details` until it has been configured for the region, then echoes the stored fields under `Details` with a `ReviewDetails` block. Matching AWS, all modeled-constraint violations (null / enum / length / list) are aggregated into a single `BadRequestException` reporting every failure; a malformed (but in-range) `WebsiteURL` is reported separately as `Url contains invalid format`. Floci has no sandbox and does not run a production-access review, so `ReviewDetails.Status` is always `GRANTED`.-Tenants (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`. Resource associations, tenant suppression, and tenant-scoped sending are not yet implemented.+Tenants (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 suppression and tenant-scoped sending are not yet implemented.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).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 a774b4a5de..461c42069c 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@@ -27,6 +27,7 @@ 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 io.github.hectorvent.floci.services.ses.model.Tenant;+import io.github.hectorvent.floci.services.ses.model.TenantResourceAssociation;import io.github.hectorvent.floci.services.ses.model.TrackingOptions;import io.github.hectorvent.floci.services.ses.model.VdmOptions;import com.fasterxml.jackson.databind.JsonNode;@@ -945,6 +946,126 @@ public class SesController {}}+ // Phase 2: tenant→resource associations. AWS's wire format for ResourceType — in responses and as+ // the RESOURCE_TYPE filter value — is the ARN segment (identity / configuration-set / template),+ // not the SDK's EMAIL_IDENTITY-style enum spelling; real AWS rejects the enum spelling.++ @POST+ @Path("/tenants/resources")+ public Response createTenantResourceAssociation(@Context HttpHeaders headers, String body) {+ String region = regionResolver.resolveRegion(headers);+ try {+ JsonNode request = (body == null || body.isBlank())+ ? objectMapper.createObjectNode()+ : objectMapper.readTree(body);+ requireJsonObject(request);+ String tenantName = stringMemberOrAbsent(request, "TenantName");+ String resourceArn = stringMemberOrAbsent(request, "ResourceArn");+ sesService.createTenantResourceAssociation(tenantName, resourceArn,+ regionResolver.getAccountId(), region);+ return Response.ok(objectMapper.createObjectNode()).build();+ } catch (AwsException e) {+ throw remapV1Exception(e);+ } catch (com.fasterxml.jackson.core.JsonProcessingException e) {+ throw new AwsException("SerializationException", null, 400);+ }+ }++ @POST+ @Path("/tenants/resources/delete")+ public Response deleteTenantResourceAssociation(@Context HttpHeaders headers, String body) {+ String region = regionResolver.resolveRegion(headers);+ try {+ JsonNode request = (body == null || body.isBlank())+ ? objectMapper.createObjectNode()+ : objectMapper.readTree(body);+ requireJsonObject(request);+ String tenantName = stringMemberOrAbsent(request, "TenantName");+ String resourceArn = stringMemberOrAbsent(request, "ResourceArn");+ sesService.deleteTenantResourceAssociation(tenantName, resourceArn,+ regionResolver.getAccountId(), region);+ return Response.ok(objectMapper.createObjectNode()).build();+ } catch (AwsException e) {+ throw remapV1Exception(e);+ } catch (com.fasterxml.jackson.core.JsonProcessingException e) {+ throw new AwsException("SerializationException", null, 400);+ }+ }++ @POST+ @Path("/tenants/resources/list")+ public Response listTenantResources(@Context HttpHeaders headers, String body) {+ String region = regionResolver.resolveRegion(headers);+ try {+ JsonNode request = (body == null || body.isBlank())+ ? objectMapper.createObjectNode()+ : objectMapper.readTree(body);+ requireJsonObject(request);+ String tenantName = stringMemberOrAbsent(request, "TenantName");+ String resourceTypeFilter = null;+ JsonNode filter = request.path("Filter");+ if (!filter.isMissingNode() && !filter.isNull()) {+ if (!filter.isObject()) {+ throw new AwsException("SerializationException", null, 400);+ }+ resourceTypeFilter = stringMemberOrAbsent(filter, "RESOURCE_TYPE");+ }+ Integer pageSize = intMemberOrAbsent(request, "PageSize");+ String nextToken = stringMemberOrAbsent(request, "NextToken");+ List<TenantResourceAssociation> associations = sesService.listTenantResources(+ tenantName, resourceTypeFilter, pageSize, nextToken, region);+ ObjectNode result = objectMapper.createObjectNode();+ // AWS renders NextToken as an explicit null on the last (here: only) page.+ result.putNull("NextToken");+ ArrayNode resources = result.putArray("TenantResources");+ for (TenantResourceAssociation a : associations) {+ ObjectNode item = resources.addObject();+ item.put("ResourceArn", a.resourceArn());+ item.put("ResourceType", a.resourceType());+ }+ return Response.ok(result).build();+ } catch (AwsException e) {+ throw remapV1Exception(e);+ } catch (com.fasterxml.jackson.core.JsonProcessingException e) {+ throw new AwsException("SerializationException", null, 400);+ }+ }++ @POST+ @Path("/resources/tenants/list")+ public Response listResourceTenants(@Context HttpHeaders headers, String body) {+ String region = regionResolver.resolveRegion(headers);+ try {+ JsonNode request = (body == null || body.isBlank())+ ? objectMapper.createObjectNode()+ : objectMapper.readTree(body);+ requireJsonObject(request);+ String resourceArn = stringMemberOrAbsent(request, "ResourceArn");+ Integer pageSize = intMemberOrAbsent(request, "PageSize");+ String nextToken = stringMemberOrAbsent(request, "NextToken");+ List<TenantResourceAssociation> associations = sesService.listResourceTenants(+ resourceArn, pageSize, nextToken, regionResolver.getAccountId(), region);+ ObjectNode result = objectMapper.createObjectNode();+ result.putNull("NextToken");+ ArrayNode tenants = result.putArray("ResourceTenants");+ for (TenantResourceAssociation a : associations) {+ // ResourceTenantMetadata has no TenantArn (probe-confirmed).+ ObjectNode item = tenants.addObject();+ item.put("TenantName", a.tenantName());+ item.put("TenantId", a.tenantId());+ item.put("ResourceArn", a.resourceArn());+ if (a.associatedTimestamp() != null) {+ item.put("AssociatedTimestamp", a.associatedTimestamp().toEpochMilli() / 1000.0);+ }+ }+ return Response.ok(result).build();+ } catch (AwsException e) {+ throw remapV1Exception(e);+ } catch (com.fasterxml.jackson.core.JsonProcessingException e) {+ throw new AwsException("SerializationException", null, 400);+ }+ }+// Read a typed string member: absent/null returns null, but a present value of the wrong JSON type// is rejected rather than coerced (asText would turn 123 into "123"), matching AWS.private static String stringMemberOrAbsent(JsonNode parent, String field) {@@ -2141,6 +2262,20 @@ public class SesController {return n.textValue();}+ // Integer variant of stringMemberOrAbsent: absent/null returns null, non-integral JSON is+ // rejected rather than coerced, and so is an integral value outside the int range (intValue+ // would silently truncate it).+ private static Integer intMemberOrAbsent(JsonNode parent, String field) {+ JsonNode n = parent.path(field);+ if (n.isMissingNode() || n.isNull()) {+ return null;+ }+ if (!n.isIntegralNumber() || !n.canConvertToInt()) {+ throw new AwsException("SerializationException", null, 400);+ }+ return n.intValue();+ }+// Parse an AWS FeatureStatus (ENABLED/DISABLED) field. A required member that is absent, or any// value outside the enum, is a Smithy BadRequestException the way AWS returns it; an absent// optional member defaults to DISABLED (false).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 78e513b068..79097e72f1 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@@ -36,6 +36,7 @@ import io.github.hectorvent.floci.services.ses.model.TrackingOptions;import io.github.hectorvent.floci.services.ses.model.VdmOptions;import io.github.hectorvent.floci.services.ses.model.SentEmail;import io.github.hectorvent.floci.services.ses.model.Tenant;+import io.github.hectorvent.floci.services.ses.model.TenantResourceAssociation;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;@@ -260,6 +261,11 @@ public class SesService {if (identityValue == null || identityValue.isBlank()) {return;}+ tenantService.deleteBackingResource(SesTenantService.RESOURCE_TYPE_IDENTITY, identityValue,+ region, () -> doDeleteIdentity(identityValue, region));+ }++ private void doDeleteIdentity(String identityValue, String region) {String key = identityKey(region, identityValue);identityStore.delete(key);invalidateDkimLookupCache(region, identityValue);@@ -1185,7 +1191,8 @@ public class SesService {}public void deleteTemplate(String templateName, String region) {- templateService.deleteTemplate(templateName, region);+ tenantService.deleteBackingResource(SesTenantService.RESOURCE_TYPE_TEMPLATE, templateName,+ region, () -> templateService.deleteTemplate(templateName, region));}public List<EmailTemplate> listTemplates(String region) {@@ -1634,8 +1641,11 @@ public class SesService {throw new AwsException("ConfigurationSetDoesNotExist","Configuration set <" + name + "> does not exist.", 400);}- configSetStore.delete(key);- LOG.infov("Deleted SES configuration set: {0} in region {1}", name, region);+ tenantService.deleteBackingResource(SesTenantService.RESOURCE_TYPE_CONFIGURATION_SET, name,+ region, () -> {+ configSetStore.delete(key);+ LOG.infov("Deleted SES configuration set: {0} in region {1}", name, region);+ });}private static final Pattern CONFIG_SET_NAME = Pattern.compile("^[A-Za-z0-9_-]{1,64}$");@@ -1664,6 +1674,77 @@ public class SesService {tenantService.deleteTenant(tenantName, region);}+ // The association operations validate resource existence here in the facade — the tenant domain+ // owns the association store, but only this class can reach the identity/configuration-set/template+ // stores without a service→service dependency.++ public void createTenantResourceAssociation(String tenantName, String resourceArn,+ String accountId, String region) {+ SesTenantService.AssociationResource ref =+ SesTenantService.parseResourceArn(resourceArn, accountId, region);+ Tenant tenant = tenantService.tenantForAssociation(tenantName, region);+ // The existence check runs inside the association lock so it stays atomic with the+ // backing-resource delete guards.+ tenantService.associate(tenant, ref, region, () -> requireTenantResourceExists(ref, region));+ }++ public void deleteTenantResourceAssociation(String tenantName, String resourceArn,+ String accountId, String region) {+ SesTenantService.AssociationResource ref =+ SesTenantService.parseResourceArn(resourceArn, accountId, region);+ Tenant tenant = tenantService.tenantForAssociation(tenantName, region);+ // AWS still 404s on a missing resource even though removing a missing association succeeds.+ requireTenantResourceExists(ref, region);+ tenantService.disassociate(tenant, ref, region);+ }++ public List<TenantResourceAssociation> listTenantResources(String tenantName,+ String resourceTypeFilter,+ Integer pageSize, String nextToken,+ String region) {+ SesTenantService.validateListPaging(pageSize, nextToken);+ SesTenantService.validateResourceTypeFilter(resourceTypeFilter);+ Tenant tenant = tenantService.tenantForAssociation(tenantName, region);+ return tenantService.listTenantResources(tenant, resourceTypeFilter, region);+ }++ public List<TenantResourceAssociation> listResourceTenants(String resourceArn, Integer pageSize,+ String nextToken, String accountId,+ String region) {+ SesTenantService.validateListPaging(pageSize, nextToken);+ SesTenantService.AssociationResource ref =+ SesTenantService.parseResourceArn(resourceArn, accountId, region);+ requireTenantResourceExists(ref, region);+ return tenantService.listResourceTenants(ref, region);+ }++ // 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) {+ boolean exists = switch (ref.type()) {+ case SesTenantService.RESOURCE_TYPE_IDENTITY ->+ identityStore.get(identityKey(region, ref.name())).isPresent();+ case SesTenantService.RESOURCE_TYPE_CONFIGURATION_SET ->+ CONFIG_SET_NAME.matcher(ref.name()).matches()+ && configSetStore.get(configSetKey(region, ref.name())).isPresent();+ case SesTenantService.RESOURCE_TYPE_TEMPLATE ->+ templateService.find(ref.name(), region).isPresent();+ default -> false;+ };+ if (exists) {+ return;+ }+ String message = switch (ref.type()) {+ case SesTenantService.RESOURCE_TYPE_IDENTITY ->+ "Identity <" + ref.name() + "> does not exist";+ case SesTenantService.RESOURCE_TYPE_CONFIGURATION_SET ->+ "Configuration set <" + ref.name() + "> does not exist:";+ default -> "Email template <" + ref.name() + "> does not exist";+ };+ throw new AwsException("NotFoundException", message, 404);+ }++// ──────────────────────── Receipt rule sets (inbound) ────────────────────────//// Receipt rule sets live in SesReceiptRuleService; this facadediff --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 fcd8a0f745..2f81c04aa6 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@@ -6,6 +6,7 @@ import io.github.hectorvent.floci.core.storage.StorageBackend;import io.github.hectorvent.floci.core.storage.StorageFactory;import io.github.hectorvent.floci.services.ses.model.Tag;import io.github.hectorvent.floci.services.ses.model.Tenant;+import io.github.hectorvent.floci.services.ses.model.TenantResourceAssociation;import jakarta.enterprise.context.ApplicationScoped;import jakarta.inject.Inject;import org.jboss.logging.Logger;@@ -28,8 +29,9 @@ import java.util.regex.Pattern;* built here carry only region and tenant name. The caller's account is used for the ARN (and the* AlreadyExists message), not the key.*- * <p>This is Phase 1 (tenant CRUD); resource associations, tenant suppression, and tenant-scoped- * sending are separate follow-ups.+ * <p>Phase 2 adds tenant→resource associations, owned here as well ({@code associationStore}); the+ * facade validates that the referenced resource exists before delegating. Tenant suppression and+ * tenant-scoped sending are separate follow-ups.*/@ApplicationScopedpublic class SesTenantService {@@ -40,7 +42,26 @@ public class SesTenantService {private static final Pattern TENANT_NAME_CHARS = Pattern.compile("[A-Za-z0-9_-]+");private static final char[] HEX = "0123456789abcdef".toCharArray();+ // The wire values for ResourceType — the ARN segment, not the SDK enum spelling. Real AWS both+ // returns these and requires them as Filter values; the SDK's EMAIL_IDENTITY-style enum constants+ // are rejected by the service (probe-confirmed 2026-08-28).+ static final String RESOURCE_TYPE_IDENTITY = "identity";+ static final String RESOURCE_TYPE_CONFIGURATION_SET = "configuration-set";+ static final String RESOURCE_TYPE_TEMPLATE = "template";+ private static final List<String> SUPPORTED_RESOURCE_TYPES =+ List.of(RESOURCE_TYPE_IDENTITY, RESOURCE_TYPE_CONFIGURATION_SET, RESOURCE_TYPE_TEMPLATE);++ /**+ * A parsed, format-validated SES resource ARN for the association operations; {@code type} is one+ * of the wire resource types. Deliberately separate from the tag dispatch's {@code parseSesArn}+ * in {@code SesService}: the association APIs have their own probe-confirmed error messages and+ * validation precedence (type before region before account), so the parsers must not be merged.+ */+ record AssociationResource(String type, String name, String arn) {+ }+private final StorageBackend<String, Tenant> tenantStore;+ private final StorageBackend<String, TenantResourceAssociation> associationStore;private final Clock clock;private final SecureRandom random;// Serializes the per-name check-then-put so concurrent creates for the same tenant can't both@@ -50,11 +71,17 @@ public class SesTenantService {@Injectpublic SesTenantService(StorageFactory storageFactory, Clock clock) {this(storageFactory.create("ses", "ses-tenants.json",- new TypeReference<Map<String, Tenant>>() {}), clock, new SecureRandom());+ new TypeReference<Map<String, Tenant>>() {}),+ storageFactory.create("ses", "ses-tenant-associations.json",+ new TypeReference<Map<String, TenantResourceAssociation>>() {}),+ clock, new SecureRandom());}- SesTenantService(StorageBackend<String, Tenant> tenantStore, Clock clock, SecureRandom random) {+ SesTenantService(StorageBackend<String, Tenant> tenantStore,+ StorageBackend<String, TenantResourceAssociation> associationStore,+ Clock clock, SecureRandom random) {this.tenantStore = tenantStore;+ this.associationStore = associationStore;this.clock = clock;this.random = random;}@@ -101,8 +128,16 @@ public class SesTenantService {validateTenantName(tenantName);String key = tenantKey(region, tenantName);synchronized (tenantMutationLock) {- if (tenantStore.get(key).isEmpty()) {- throw tenantNotFound(tenantName);+ Tenant tenant = tenantStore.get(key).orElseThrow(() -> tenantNotFound(tenantName));+ // AWS cascades: deleting a tenant silently removes its resource associations+ // (probe-confirmed 2026-08-28). Keys carry the TenantId, so a recreated same-name tenant+ // never sees the old associations. The associations go first — persistent/wal backends+ // apply each deletion durably, so a crash mid-cascade must leave the tenant record (a+ // retryable DeleteTenant) rather than orphan associations no API call can remove.+ String assocPrefix = associationKeyPrefix(region, tenant.tenantId());+ for (String assocKey : associationStore.keys().stream()+ .filter(k -> k.startsWith(assocPrefix)).toList()) {+ associationStore.delete(assocKey);}tenantStore.delete(key);}@@ -115,6 +150,200 @@ public class SesTenantService {return tenantStore.get(tenantKey(region, tenantName));}+ // ──────────────────────── Resource associations (Phase 2) ────────────────────────+ // Behavior and messages probe-confirmed against real AWS us-east-1, 2026-08-28.++ /**+ * Resolves the tenant for the association operations. Unlike the CRUD operations, the association+ * request shapes carry no Smithy min-length on TenantName, so an empty value gets the+ * service-level message instead of the Smithy one.+ */+ public Tenant tenantForAssociation(String tenantName, String region) {+ if (tenantName == null) {+ throw new AwsException("BadRequestException",+ "1 validation error detected: Value at 'tenantName' failed to satisfy constraint: "+ + "Member must not be null", 400);+ }+ if (tenantName.isBlank()) {+ throw new AwsException("BadRequestException", "TenantName cannot be empty", 400);+ }+ return tenantStore.get(tenantKey(region, tenantName))+ .orElseThrow(() -> tenantNotFound(tenantName));+ }++ /**+ * 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 SES+ * resource type, then region and account mismatches. Existence is the facade's job.+ */+ public static AssociationResource parseResourceArn(String resourceArn, String accountId, String region) {+ if (resourceArn == null) {+ throw new AwsException("BadRequestException",+ "1 validation error detected: Value at 'resourceArn' failed to satisfy constraint: "+ + "Member must not be null", 400);+ }+ String[] parts = resourceArn.split(":", 6);+ if (parts.length < 6 || !"arn".equals(parts[0])) {+ throw new AwsException("BadRequestException",+ "Provided resource identifier is not an SES resource", 400);+ }+ if (!"ses".equals(parts[2])) {+ throw new AwsException("BadRequestException",+ "Provided ARN is not in SES resource ARN format", 400);+ }+ String resource = parts[5];+ int slash = resource.indexOf('/');+ String type = slash < 0 ? resource : resource.substring(0, slash);+ if (!SUPPORTED_RESOURCE_TYPES.contains(type)) {+ throw new AwsException("BadRequestException", "Unsupported resource type: " + type, 400);+ }+ if (slash < 0 || slash == resource.length() - 1) {+ // A supported type with no name segment can never reference a resource; reject it as+ // malformed rather than letting it 404 with an empty name.+ throw new AwsException("BadRequestException",+ "Provided resource identifier is not an SES resource", 400);+ }+ if (!region.equals(parts[3])) {+ throw new AwsException("BadRequestException",+ "Resource <" + resourceArn + "> must be in the same region", 400);+ }+ if (!accountId.equals(parts[4])) {+ throw new AwsException("BadRequestException",+ "Resource <" + resourceArn + "> must be in the same account", 400);+ }+ return new AssociationResource(type, resource.substring(slash + 1), resourceArn);+ }++ /**+ * Creates the association under the shared lock. The tenant is revalidated (a concurrent+ * {@code DeleteTenant} may have cascaded since the caller resolved it) and+ * {@code resourceExistenceCheck} — the facade's throwing existence check — runs inside the lock+ * too, so a backing resource cannot slip through {@link #deleteBackingResource} concurrently and+ * leave an association pointing at a deleted resource.+ */+ public void associate(Tenant tenant, AssociationResource ref, String region,+ Runnable resourceExistenceCheck) {+ String key = associationKey(region, tenant.tenantId(), ref);+ synchronized (tenantMutationLock) {+ Tenant current = tenantStore.get(tenantKey(region, tenant.tenantName())).orElse(null);+ if (current == null || !tenant.tenantId().equals(current.tenantId())) {+ throw tenantNotFound(tenant.tenantName());+ }+ resourceExistenceCheck.run();+ if (associationStore.get(key).isPresent()) {+ // "Resources" is AWS's own grammar for this message.+ throw new AwsException("AlreadyExistsException",+ "Resources " + ref.arn() + " has already been associated with tenant "+ + tenant.tenantName(), 400);+ }+ associationStore.put(key, new TenantResourceAssociation(tenant.tenantName(),+ tenant.tenantId(), ref.arn(), ref.type(), Instant.now(clock)));+ }+ LOG.infov("Associated SES resource {0} with tenant {1} in region {2}",+ ref.arn(), tenant.tenantName(), region);+ }++ /**+ * Runs a backing-resource deletion under the same lock as association creation: AWS refuses to+ * delete an identity, configuration set, or template that still has tenant associations, and the+ * shared lock keeps that guard atomic with {@link #associate}'s existence check.+ */+ public void deleteBackingResource(String resourceType, String resourceName, String region,+ Runnable deleteAction) {+ synchronized (tenantMutationLock) {+ findAssociationForResource(resourceType, resourceName, region).ifPresent(a -> {+ throw new AwsException("BadRequestException",+ "Cannot delete <" + a.resourceArn() + "> because it has tenant associations. "+ + "Remove all tenant associations and try again.", 400);+ });+ deleteAction.run();+ }+ }++ /** Removing an association that does not exist is a silent success on AWS. */+ public void disassociate(Tenant tenant, AssociationResource ref, String region) {+ associationStore.delete(associationKey(region, tenant.tenantId(), ref));+ LOG.infov("Disassociated SES resource {0} from tenant {1} in region {2}",+ ref.arn(), tenant.tenantName(), region);+ }++ /** AWS returns the tenant's resources ordered by ARN. */+ public List<TenantResourceAssociation> listTenantResources(Tenant tenant, String typeFilter,+ String region) {+ String prefix = associationKeyPrefix(region, tenant.tenantId());+ return associationStore.scan(k -> k.startsWith(prefix)).stream()+ .filter(a -> typeFilter == null || typeFilter.equals(a.resourceType()))+ .sorted(Comparator.comparing(TenantResourceAssociation::resourceArn,+ Comparator.nullsLast(Comparator.naturalOrder())))+ .toList();+ }++ // The resource lookups match on the stored record, not on a key suffix: a resource name may+ // itself contain the "::" delimiter (Floci barely restricts identity and template names), so a+ // suffix match on the key could alias one resource's associations to another's.++ /** AWS returns a resource's tenants ordered by association time. */+ public List<TenantResourceAssociation> listResourceTenants(AssociationResource ref, String region) {+ String regionPrefix = "tenantAssoc::" + region + "::";+ return associationStore.scan(k -> k.startsWith(regionPrefix)).stream()+ .filter(a -> ref.arn().equals(a.resourceArn()))+ .sorted(Comparator.comparing(TenantResourceAssociation::associatedTimestamp,+ Comparator.nullsLast(Comparator.naturalOrder()))+ .thenComparing(TenantResourceAssociation::tenantName,+ Comparator.nullsLast(Comparator.naturalOrder())))+ .toList();+ }++ /**+ * Finds any association for the given resource, for the facade's delete guards: AWS refuses to+ * delete an identity, configuration set, or template that still has tenant associations.+ */+ public Optional<TenantResourceAssociation> findAssociationForResource(String resourceType,+ String resourceName,+ String region) {+ String regionPrefix = "tenantAssoc::" + region + "::";+ return associationStore.scan(k -> k.startsWith(regionPrefix)).stream()+ .filter(a -> resourceType.equals(a.resourceType())+ && resourceName.equals(resourceNameFromArn(a.resourceArn())))+ .findFirst();+ }++ // Stored ARNs were validated by parseResourceArn, so the resource part always has a name segment.+ private static String resourceNameFromArn(String arn) {+ String resource = arn.split(":", 6)[5];+ return resource.substring(resource.indexOf('/') + 1);+ }++ public static void validateResourceTypeFilter(String value) {+ if (value != null && !SUPPORTED_RESOURCE_TYPES.contains(value)) {+ throw new AwsException("BadRequestException",+ "Invalid resource type " + value + " specified.", 400);+ }+ }++ /**+ * The list operations return everything in one page, so any client-supplied NextToken is invalid —+ * which is also what AWS answers for a token it cannot decrypt. PageSize is still range-checked.+ */+ public static void validateListPaging(Integer pageSize, String nextToken) {+ if (pageSize != null && pageSize < 1) {+ throw new AwsException("BadRequestException",+ "1 validation error detected: Value '" + pageSize + "' at 'pageSize' failed to "+ + "satisfy constraint: Member must have value greater than or equal to 1", 400);+ }+ if (nextToken != null) {+ throw new AwsException("BadRequestException", "Invalid Next Token", 400);+ }+ }++ private static String associationKey(String region, String tenantId, AssociationResource ref) {+ return associationKeyPrefix(region, tenantId) + ref.type() + "::" + ref.name();+ }++ private static String associationKeyPrefix(String region, String tenantId) {+ return "tenantAssoc::" + region + "::" + tenantId + "::";+ }+// Validation order and messages verified against real AWS (2026-08-22): an empty string is the// Smithy min-length violation, a whitespace-only value is "cannot be empty", then length, then the// character-set rule.diff --git a/src/main/java/io/github/hectorvent/floci/services/ses/model/TenantResourceAssociation.java b/src/main/java/io/github/hectorvent/floci/services/ses/model/TenantResourceAssociation.javanew file mode 100644index 0000000000..6c5f375d60--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ses/model/TenantResourceAssociation.java@@ -0,0 +1,18 @@+package io.github.hectorvent.floci.services.ses.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++import java.time.Instant;++/**+ * A SES v2 tenant→resource association, created by {@code CreateTenantResourceAssociation}.+ * {@code resourceType} is the wire value AWS uses for these APIs — the ARN segment+ * ({@code identity} / {@code configuration-set} / {@code template}), not the SDK enum spelling.+ */+@RegisterForReflection+public record TenantResourceAssociation(String tenantName,+ String tenantId,+ String resourceArn,+ String resourceType,+ Instant associatedTimestamp) {+}diff --git a/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceTestBuilder.java b/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceTestBuilder.javaindex b5955e4dac..b757237a01 100644--- a/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceTestBuilder.java+++ b/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceTestBuilder.java@@ -16,6 +16,7 @@ import io.github.hectorvent.floci.services.ses.model.ReceiptRuleSet;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.Tenant;+import io.github.hectorvent.floci.services.ses.model.TenantResourceAssociation;import io.github.hectorvent.floci.services.route53.Route53Service;import java.security.SecureRandom;@@ -48,6 +49,8 @@ final class SesServiceTestBuilder {private final InMemoryStorage<String, ReceiptRuleSet> receiptRuleStore = new InMemoryStorage<>();private final InMemoryStorage<String, CustomVerificationEmailTemplate> cvetStore = new InMemoryStorage<>();private final InMemoryStorage<String, Tenant> tenantStore = new InMemoryStorage<>();+ private final InMemoryStorage<String, TenantResourceAssociation> tenantAssociationStore =+ new InMemoryStorage<>();private SmtpRelay smtpRelay = mock(SmtpRelay.class);// Default null, matching the production null-Route53 case: SesService treats a null Route53Service@@ -124,7 +127,7 @@ final class SesServiceTestBuilder {new SesPolicyService(policyStore, objectMapper),new SesReceiptRuleService(receiptRuleStore, clock),new SesCvetService(cvetStore),- new SesTenantService(tenantStore, clock, new SecureRandom()),+ new SesTenantService(tenantStore, tenantAssociationStore, clock, new SecureRandom()),smtpRelay,objectMapper,route53Service,diff --git a/src/test/java/io/github/hectorvent/floci/services/ses/SesTenantAssociationV2IntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/ses/SesTenantAssociationV2IntegrationTest.javanew file mode 100644index 0000000000..26de515f4a--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/ses/SesTenantAssociationV2IntegrationTest.java@@ -0,0 +1,279 @@+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.hasSize;+import static org.hamcrest.Matchers.notNullValue;+import static org.hamcrest.Matchers.nullValue;+import static org.hamcrest.Matchers.startsWith;++/**+ * Integration tests for the SES v2 tenant resource associations (Phase 2): the RPC-style+ * {@code /tenants/resources}, {@code /tenants/resources/delete}, {@code /tenants/resources/list} and+ * {@code /resources/tenants/list}. The wire quirks are probe-confirmed against real AWS: ResourceType+ * values are the ARN segments (identity / configuration-set / template) — not the SDK enum spelling —+ * delete is idempotent, backing-resource deletion is blocked while associated, and DeleteTenant+ * cascades.+ */+@QuarkusTest+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)+class SesTenantAssociationV2IntegrationTest {++ private static final String AUTH =+ "AWS4-HMAC-SHA256 Credential=AKID/20260101/us-east-1/ses/aws4_request";+ private static final String TENANT = "floci-assoc-tenant";+ private static final String TENANT_B = "floci-assoc-tenant-b";+ private static final String IDENTITY = "floci-assoc.example.com";+ private static final String CONFIG_SET = "floci-assoc-cs";+ private static final String TEMPLATE = "floci-assoc-tpl";+ private static final String ARN_PREFIX = "arn:aws:ses:us-east-1:000000000000:";+ private static final String IDENTITY_ARN = ARN_PREFIX + "identity/" + IDENTITY;+ private static final String CONFIG_SET_ARN = ARN_PREFIX + "configuration-set/" + CONFIG_SET;+ private static final String TEMPLATE_ARN = ARN_PREFIX + "template/" + TEMPLATE;++ private static io.restassured.specification.RequestSpecification v2() {+ return given().contentType("application/json").header("Authorization", AUTH);+ }++ private static void associate(String tenant, String arn) {+ v2().body("{\"TenantName\":\"" + tenant + "\",\"ResourceArn\":\"" + arn + "\"}")+ .when().post("/v2/email/tenants/resources").then().statusCode(200);+ }++ @Test+ @Order(1)+ void setup_createTenantsAndResources() {+ v2().body("{\"TenantName\":\"" + TENANT + "\"}")+ .when().post("/v2/email/tenants").then().statusCode(200);+ v2().body("{\"TenantName\":\"" + TENANT_B + "\"}")+ .when().post("/v2/email/tenants").then().statusCode(200);+ v2().body("{\"EmailIdentity\":\"" + IDENTITY + "\"}")+ .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 createAssociation_returnsEmptyObject() {+ v2().body("{\"TenantName\":\"" + TENANT + "\",\"ResourceArn\":\"" + IDENTITY_ARN + "\"}")+ .when().post("/v2/email/tenants/resources").then().statusCode(200)+ .body("isEmpty()", equalTo(true));+ associate(TENANT, CONFIG_SET_ARN);+ associate(TENANT, TEMPLATE_ARN);+ associate(TENANT_B, IDENTITY_ARN);+ }++ @Test+ @Order(3)+ void createAssociation_duplicate_returnsAlreadyExists() {+ v2().body("{\"TenantName\":\"" + TENANT + "\",\"ResourceArn\":\"" + IDENTITY_ARN + "\"}")+ .when().post("/v2/email/tenants/resources").then().statusCode(400)+ .body("__type", equalTo("AlreadyExistsException"))+ // "Resources" is AWS's own grammar.+ .body("message", equalTo("Resources " + IDENTITY_ARN+ + " has already been associated with tenant " + TENANT));+ }++ @Test+ @Order(4)+ void createAssociation_errorMatrix() {+ v2().body("{\"TenantName\":\"ghost-tenant\",\"ResourceArn\":\"" + IDENTITY_ARN + "\"}")+ .when().post("/v2/email/tenants/resources").then().statusCode(404)+ .body("__type", equalTo("NotFoundException"))+ .body("message", equalTo("The requested tenant <ghost-tenant> does not exist."));++ // Missing resources 404 with a per-type message; the configuration-set trailing colon is AWS's.+ v2().body("{\"TenantName\":\"" + TENANT + "\",\"ResourceArn\":\"" + ARN_PREFIX+ + "configuration-set/ghost-cs\"}")+ .when().post("/v2/email/tenants/resources").then().statusCode(404)+ .body("message", equalTo("Configuration set <ghost-cs> does not exist:"));+ v2().body("{\"TenantName\":\"" + TENANT + "\",\"ResourceArn\":\"" + ARN_PREFIX+ + "identity/ghost.example.com\"}")+ .when().post("/v2/email/tenants/resources").then().statusCode(404)+ .body("message", equalTo("Identity <ghost.example.com> does not exist"));+ v2().body("{\"TenantName\":\"" + TENANT + "\",\"ResourceArn\":\"" + ARN_PREFIX+ + "template/ghost-tpl\"}")+ .when().post("/v2/email/tenants/resources").then().statusCode(404)+ .body("message", equalTo("Email template <ghost-tpl> does not exist"));++ v2().body("{\"TenantName\":\"" + TENANT + "\",\"ResourceArn\":\"not-an-arn\"}")+ .when().post("/v2/email/tenants/resources").then().statusCode(400)+ .body("message", equalTo("Provided resource identifier is not an SES resource"));+ v2().body("{\"TenantName\":\"" + TENANT+ + "\",\"ResourceArn\":\"arn:aws:sqs:us-east-1:000000000000:q\"}")+ .when().post("/v2/email/tenants/resources").then().statusCode(400)+ .body("message", equalTo("Provided ARN is not in SES resource ARN format"));+ v2().body("{\"TenantName\":\"" + TENANT+ + "\",\"ResourceArn\":\"arn:aws:ses:us-east-1:000000000000:contact-list/x\"}")+ .when().post("/v2/email/tenants/resources").then().statusCode(400)+ .body("message", equalTo("Unsupported resource type: contact-list"));+ v2().body("{\"TenantName\":\"" + TENANT+ + "\",\"ResourceArn\":\"arn:aws:ses:eu-west-1:000000000000:identity/" + IDENTITY + "\"}")+ .when().post("/v2/email/tenants/resources").then().statusCode(400)+ .body("message", equalTo("Resource <arn:aws:ses:eu-west-1:000000000000:identity/"+ + IDENTITY + "> must be in the same region"));+ v2().body("{\"TenantName\":\"" + TENANT+ + "\",\"ResourceArn\":\"arn:aws:ses:us-east-1:111111111111:identity/" + IDENTITY + "\"}")+ .when().post("/v2/email/tenants/resources").then().statusCode(400)+ .body("message", equalTo("Resource <arn:aws:ses:us-east-1:111111111111:identity/"+ + IDENTITY + "> must be in the same account"));++ v2().body("{\"TenantName\":\"\",\"ResourceArn\":\"" + IDENTITY_ARN + "\"}")+ .when().post("/v2/email/tenants/resources").then().statusCode(400)+ .body("message", equalTo("TenantName cannot be empty"));+ v2().body("{\"TenantName\":\"" + TENANT + "\"}")+ .when().post("/v2/email/tenants/resources").then().statusCode(400)+ .body("message", equalTo("1 validation error detected: Value at 'resourceArn' failed "+ + "to satisfy constraint: Member must not be null"));+ }++ @Test+ @Order(5)+ void listTenantResources_sortedByArn_lowercaseTypes_nullNextToken() {+ v2().body("{\"TenantName\":\"" + TENANT + "\"}")+ .when().post("/v2/email/tenants/resources/list").then().statusCode(200)+ .body("NextToken", nullValue())+ .body("TenantResources", hasSize(3))+ .body("TenantResources[0].ResourceType", equalTo("configuration-set"))+ .body("TenantResources[0].ResourceArn", equalTo(CONFIG_SET_ARN))+ .body("TenantResources[1].ResourceType", equalTo("identity"))+ .body("TenantResources[2].ResourceType", equalTo("template"));+ }++ @Test+ @Order(6)+ void listTenantResources_filterUsesWireValues() {+ v2().body("{\"TenantName\":\"" + TENANT + "\",\"Filter\":{\"RESOURCE_TYPE\":\"identity\"}}")+ .when().post("/v2/email/tenants/resources/list").then().statusCode(200)+ .body("TenantResources", hasSize(1))+ .body("TenantResources[0].ResourceArn", equalTo(IDENTITY_ARN));++ // Real AWS rejects the SDK's enum spelling — only the ARN-segment values are valid.+ v2().body("{\"TenantName\":\"" + TENANT + "\",\"Filter\":{\"RESOURCE_TYPE\":\"EMAIL_IDENTITY\"}}")+ .when().post("/v2/email/tenants/resources/list").then().statusCode(400)+ .body("__type", equalTo("BadRequestException"))+ .body("message", equalTo("Invalid resource type EMAIL_IDENTITY specified."));+ }++ @Test+ @Order(7)+ void listTenantResources_pagingValidation() {+ v2().body("{\"TenantName\":\"" + TENANT + "\",\"PageSize\":0}")+ .when().post("/v2/email/tenants/resources/list").then().statusCode(400)+ .body("message", equalTo("1 validation error detected: Value '0' at 'pageSize' failed "+ + "to satisfy constraint: Member must have value greater than or equal to 1"));+ v2().body("{\"TenantName\":\"" + TENANT + "\",\"NextToken\":\"garbage-token\"}")+ .when().post("/v2/email/tenants/resources/list").then().statusCode(400)+ .body("message", equalTo("Invalid Next Token"));+ // An integral value outside the int range must be rejected, not silently truncated+ // (4294967296 would truncate to 0 and produce the wrong Smithy message).+ v2().body("{\"TenantName\":\"" + TENANT + "\",\"PageSize\":4294967296}")+ .when().post("/v2/email/tenants/resources/list").then().statusCode(400)+ .body("__type", equalTo("SerializationException"));+ v2().body("{\"TenantName\":\"ghost-tenant\"}")+ .when().post("/v2/email/tenants/resources/list").then().statusCode(404)+ .body("__type", equalTo("NotFoundException"));+ }++ @Test+ @Order(8)+ void listResourceTenants_returnsMetadataWithoutTenantArn() {+ v2().body("{\"ResourceArn\":\"" + IDENTITY_ARN + "\"}")+ .when().post("/v2/email/resources/tenants/list").then().statusCode(200)+ .body("NextToken", nullValue())+ .body("ResourceTenants", hasSize(2))+ .body("ResourceTenants[0].TenantName", equalTo(TENANT))+ .body("ResourceTenants[0].TenantId", startsWith("tn-"))+ .body("ResourceTenants[0].ResourceArn", equalTo(IDENTITY_ARN))+ .body("ResourceTenants[0].AssociatedTimestamp", notNullValue())+ .body("ResourceTenants[0].TenantArn", nullValue())+ .body("ResourceTenants[1].TenantName", equalTo(TENANT_B));++ v2().body("{\"ResourceArn\":\"" + ARN_PREFIX + "configuration-set/ghost-cs\"}")+ .when().post("/v2/email/resources/tenants/list").then().statusCode(404)+ .body("message", equalTo("Configuration set <ghost-cs> does not exist:"));+ v2().body("{\"ResourceArn\":\"nope\"}")+ .when().post("/v2/email/resources/tenants/list").then().statusCode(400)+ .body("message", equalTo("Provided resource identifier is not an SES resource"));+ }++ @Test+ @Order(9)+ void deleteBackingResource_whileAssociated_isBlocked() {+ v2().when().delete("/v2/email/identities/" + IDENTITY).then().statusCode(400)+ .body("__type", equalTo("BadRequestException"))+ .body("message", equalTo("Cannot delete <" + IDENTITY_ARN + "> because it has tenant "+ + "associations. Remove all tenant associations and try again."));+ v2().when().delete("/v2/email/configuration-sets/" + CONFIG_SET).then().statusCode(400)+ .body("message", equalTo("Cannot delete <" + CONFIG_SET_ARN + "> because it has tenant "+ + "associations. Remove all tenant associations and try again."));+ v2().when().delete("/v2/email/templates/" + TEMPLATE).then().statusCode(400)+ .body("message", equalTo("Cannot delete <" + TEMPLATE_ARN + "> because it has tenant "+ + "associations. Remove all tenant associations and try again."));+ }++ @Test+ @Order(10)+ void deleteAssociation_isIdempotent_butValidatesTenantAndResource() {+ v2().body("{\"TenantName\":\"" + TENANT + "\",\"ResourceArn\":\"" + TEMPLATE_ARN + "\"}")+ .when().post("/v2/email/tenants/resources/delete").then().statusCode(200)+ .body("isEmpty()", equalTo(true));+ // Removing an association that no longer exists is a silent success on AWS.+ v2().body("{\"TenantName\":\"" + TENANT + "\",\"ResourceArn\":\"" + TEMPLATE_ARN + "\"}")+ .when().post("/v2/email/tenants/resources/delete").then().statusCode(200);++ v2().body("{\"TenantName\":\"ghost-tenant\",\"ResourceArn\":\"" + IDENTITY_ARN + "\"}")+ .when().post("/v2/email/tenants/resources/delete").then().statusCode(404)+ .body("__type", equalTo("NotFoundException"));+ v2().body("{\"TenantName\":\"" + TENANT + "\",\"ResourceArn\":\"" + ARN_PREFIX+ + "configuration-set/ghost-cs\"}")+ .when().post("/v2/email/tenants/resources/delete").then().statusCode(404)+ .body("message", equalTo("Configuration set <ghost-cs> does not exist:"));+ }++ @Test+ @Order(11)+ void deleteTenant_cascadesAssociations_andRecreationStartsClean() {+ v2().body("{\"TenantName\":\"" + TENANT + "\"}")+ .when().post("/v2/email/tenants/delete").then().statusCode(200);++ // Only TENANT_B's association survives the cascade.+ v2().body("{\"ResourceArn\":\"" + IDENTITY_ARN + "\"}")+ .when().post("/v2/email/resources/tenants/list").then().statusCode(200)+ .body("ResourceTenants", hasSize(1))+ .body("ResourceTenants[0].TenantName", equalTo(TENANT_B));+ v2().body("{\"ResourceArn\":\"" + CONFIG_SET_ARN + "\"}")+ .when().post("/v2/email/resources/tenants/list").then().statusCode(200)+ .body("ResourceTenants", hasSize(0));++ // A recreated same-name tenant has a new TenantId and sees none of the old associations.+ v2().body("{\"TenantName\":\"" + TENANT + "\"}")+ .when().post("/v2/email/tenants").then().statusCode(200);+ v2().body("{\"TenantName\":\"" + TENANT + "\"}")+ .when().post("/v2/email/tenants/resources/list").then().statusCode(200)+ .body("TenantResources", hasSize(0));+ v2().body("{\"TenantName\":\"" + TENANT + "\"}")+ .when().post("/v2/email/tenants/delete").then().statusCode(200);+ }++ @Test+ @Order(12)+ void cleanup_afterDisassociation_backingResourcesDeletable() {+ v2().body("{\"TenantName\":\"" + TENANT_B + "\",\"ResourceArn\":\"" + IDENTITY_ARN + "\"}")+ .when().post("/v2/email/tenants/resources/delete").then().statusCode(200);+ v2().body("{\"TenantName\":\"" + TENANT_B + "\"}")+ .when().post("/v2/email/tenants/delete").then().statusCode(200);+ v2().when().delete("/v2/email/identities/" + IDENTITY).then().statusCode(200);+ v2().when().delete("/v2/email/configuration-sets/" + CONFIG_SET).then().statusCode(200);+ v2().when().delete("/v2/email/templates/" + TEMPLATE).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 03887786a1..ef13216645 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@@ -16,8 +16,10 @@ import static org.junit.jupiter.api.Assertions.assertThrows;import static org.junit.jupiter.api.Assertions.assertTrue;/**- * Unit test for the tenant domain (Phase 1 CRUD): create/get/list/delete, id/ARN generation, and the- * probe-confirmed name validation and duplicate/not-found errors. Constructed with just its own store.+ * Unit test for the tenant domain: the Phase 1 CRUD (create/get/list/delete, id/ARN generation, name+ * validation) and the Phase 2 resource associations (ARN parsing, duplicate/idempotency semantics,+ * sorting, cascade on tenant delete). Constructed with just its own stores; resource existence is the+ * facade's concern and is covered by the integration tests.*/class SesTenantServiceTest {@@ -27,7 +29,8 @@ class SesTenantServiceTest {@BeforeEachvoid setUp() {- service = new SesTenantService(new InMemoryStorage<>(), Clock.systemUTC(), new SecureRandom());+ service = new SesTenantService(new InMemoryStorage<>(), new InMemoryStorage<>(),+ Clock.systemUTC(), new SecureRandom());}@Test@@ -130,4 +133,199 @@ class SesTenantServiceTest {AwsException d = assertThrows(AwsException.class, () -> service.deleteTenant(" ", REGION));assertEquals("BadRequestException", d.getErrorCode());}++ // ──────────────────────── Resource associations (Phase 2) ────────────────────────++ private static SesTenantService.AssociationResource identityRef(String name) {+ return SesTenantService.parseResourceArn(+ "arn:aws:ses:" + REGION + ":" + ACCOUNT + ":identity/" + name, ACCOUNT, REGION);+ }++ @Test+ void parseResourceArn_acceptsThreeTypes_andExtractsName() {+ SesTenantService.AssociationResource ref = SesTenantService.parseResourceArn(+ "arn:aws:ses:" + REGION + ":" + ACCOUNT + ":configuration-set/my-cs", ACCOUNT, REGION);+ assertEquals("configuration-set", ref.type());+ assertEquals("my-cs", ref.name());+ }++ @Test+ void parseResourceArn_errorChainMatchesAws() {+ assertEquals("Provided resource identifier is not an SES resource",+ assertThrows(AwsException.class,+ () -> SesTenantService.parseResourceArn("not-an-arn", ACCOUNT, REGION)).getMessage());+ assertEquals("Provided ARN is not in SES resource ARN format",+ assertThrows(AwsException.class, () -> SesTenantService.parseResourceArn(+ "arn:aws:sqs:" + REGION + ":" + ACCOUNT + ":q", ACCOUNT, REGION)).getMessage());+ assertEquals("Unsupported resource type: contact-list",+ assertThrows(AwsException.class, () -> SesTenantService.parseResourceArn(+ "arn:aws:ses:" + REGION + ":" + ACCOUNT + ":contact-list/x", ACCOUNT, REGION)).getMessage());+ assertTrue(assertThrows(AwsException.class, () -> SesTenantService.parseResourceArn(+ "arn:aws:ses:eu-west-1:" + ACCOUNT + ":identity/a", ACCOUNT, REGION))+ .getMessage().endsWith("must be in the same region"));+ assertTrue(assertThrows(AwsException.class, () -> SesTenantService.parseResourceArn(+ "arn:aws:ses:" + REGION + ":111111111111:identity/a", ACCOUNT, REGION))+ .getMessage().endsWith("must be in the same account"));+ assertTrue(assertThrows(AwsException.class,+ () -> SesTenantService.parseResourceArn(null, ACCOUNT, REGION))+ .getMessage().contains("'resourceArn'"));+ }++ @Test+ void parseResourceArn_rejectsMissingOrEmptyName() {+ // A supported type without a name segment must be rejected as malformed, not resolved to an+ // empty-name resource that would 404 with a misleading message.+ assertEquals("Provided resource identifier is not an SES resource",+ assertThrows(AwsException.class, () -> SesTenantService.parseResourceArn(+ "arn:aws:ses:" + REGION + ":" + ACCOUNT + ":identity", ACCOUNT, REGION)).getMessage());+ assertEquals("Provided resource identifier is not an SES resource",+ assertThrows(AwsException.class, () -> SesTenantService.parseResourceArn(+ "arn:aws:ses:" + REGION + ":" + ACCOUNT + ":identity/", ACCOUNT, REGION)).getMessage());+ }++ @Test+ void resourceLookups_dontAliasNamesContainingDelimiter() {+ // Floci barely restricts resource names, so "x" and "template::x" can both exist; the+ // lookups must not let a key-suffix match blur them together.+ Tenant tenant = service.createTenant("acme", List.of(), ACCOUNT, REGION);+ SesTenantService.AssociationResource plain = SesTenantService.parseResourceArn(+ "arn:aws:ses:" + REGION + ":" + ACCOUNT + ":template/x", ACCOUNT, REGION);+ SesTenantService.AssociationResource tricky = SesTenantService.parseResourceArn(+ "arn:aws:ses:" + REGION + ":" + ACCOUNT + ":template/template::x", ACCOUNT, REGION);+ service.associate(tenant, tricky, REGION, () -> {});++ assertEquals(0, service.listResourceTenants(plain, REGION).size());+ assertTrue(service.findAssociationForResource("template", "x", REGION).isEmpty());+ assertEquals(1, service.listResourceTenants(tricky, REGION).size());+ assertTrue(service.findAssociationForResource("template", "template::x", REGION).isPresent());+ }++ @Test+ void associate_duplicateThrows_awsGrammarPreserved() {+ Tenant tenant = service.createTenant("acme", List.of(), ACCOUNT, REGION);+ SesTenantService.AssociationResource ref = identityRef("example.com");+ service.associate(tenant, ref, REGION, () -> {});+ AwsException e = assertThrows(AwsException.class,+ () -> service.associate(tenant, ref, REGION, () -> {}));+ assertEquals("AlreadyExistsException", e.getErrorCode());+ assertEquals("Resources " + ref.arn() + " has already been associated with tenant acme",+ e.getMessage());+ }++ @Test+ void disassociate_isIdempotent() {+ Tenant tenant = service.createTenant("acme", List.of(), ACCOUNT, REGION);+ service.disassociate(tenant, identityRef("example.com"), REGION);+ service.associate(tenant, identityRef("example.com"), REGION, () -> {});+ service.disassociate(tenant, identityRef("example.com"), REGION);+ assertEquals(0, service.listTenantResources(tenant, null, REGION).size());+ }++ @Test+ void listTenantResources_sortedByArn_andFilterable() {+ Tenant tenant = service.createTenant("acme", List.of(), ACCOUNT, REGION);+ service.associate(tenant, identityRef("example.com"), REGION, () -> {});+ service.associate(tenant, SesTenantService.parseResourceArn(+ "arn:aws:ses:" + REGION + ":" + ACCOUNT + ":template/tpl", ACCOUNT, REGION),+ REGION, () -> {});+ service.associate(tenant, SesTenantService.parseResourceArn(+ "arn:aws:ses:" + REGION + ":" + ACCOUNT + ":configuration-set/cs", ACCOUNT, REGION),+ REGION, () -> {});+ var all = service.listTenantResources(tenant, null, REGION);+ assertEquals(List.of("configuration-set", "identity", "template"),+ all.stream().map(a -> a.resourceType()).toList());+ var filtered = service.listTenantResources(tenant, "identity", REGION);+ assertEquals(1, filtered.size());+ assertEquals("identity", filtered.get(0).resourceType());+ }++ @Test+ void listResourceTenants_findsAllTenants_ofOneResource() {+ Tenant a = service.createTenant("acme", List.of(), ACCOUNT, REGION);+ Tenant b = service.createTenant("beta", List.of(), ACCOUNT, REGION);+ service.associate(a, identityRef("example.com"), REGION, () -> {});+ service.associate(b, identityRef("example.com"), REGION, () -> {});+ var tenants = service.listResourceTenants(identityRef("example.com"), REGION);+ assertEquals(2, tenants.size());+ assertEquals("acme", tenants.get(0).tenantName());+ assertEquals(a.tenantId(), tenants.get(0).tenantId());+ }++ @Test+ void deleteTenant_cascadesAssociations_recreatedTenantSeesNone() {+ Tenant tenant = service.createTenant("acme", List.of(), ACCOUNT, REGION);+ service.associate(tenant, identityRef("example.com"), REGION, () -> {});+ service.deleteTenant("acme", REGION);+ assertEquals(0, service.listResourceTenants(identityRef("example.com"), REGION).size());+ Tenant recreated = service.createTenant("acme", List.of(), ACCOUNT, REGION);+ assertEquals(0, service.listTenantResources(recreated, null, REGION).size());+ }++ @Test+ void associate_staleTenant_throwsNotFound() {+ // A tenant resolved before a concurrent DeleteTenant (same or recreated name) must not be+ // able to insert an orphan association: associate revalidates the TenantId under the lock.+ Tenant stale = service.createTenant("acme", List.of(), ACCOUNT, REGION);+ service.deleteTenant("acme", REGION);+ AwsException gone = assertThrows(AwsException.class,+ () -> service.associate(stale, identityRef("example.com"), REGION, () -> {}));+ assertEquals("NotFoundException", gone.getErrorCode());++ service.createTenant("acme", List.of(), ACCOUNT, REGION);+ AwsException recreated = assertThrows(AwsException.class,+ () -> service.associate(stale, identityRef("example.com"), REGION, () -> {}));+ assertEquals("NotFoundException", recreated.getErrorCode());+ }++ @Test+ void deleteBackingResource_blocksWhileAssociated_runsActionOtherwise() {+ Tenant tenant = service.createTenant("acme", List.of(), ACCOUNT, REGION);+ service.associate(tenant, identityRef("example.com"), REGION, () -> {});+ AwsException blocked = assertThrows(AwsException.class, () -> service.deleteBackingResource(+ "identity", "example.com", REGION, () -> {}));+ assertEquals("Cannot delete <" + identityRef("example.com").arn() + "> because it has tenant "+ + "associations. Remove all tenant associations and try again.", blocked.getMessage());++ boolean[] ran = {false};+ service.deleteBackingResource("identity", "other.com", REGION, () -> ran[0] = true);+ assertTrue(ran[0]);+ }++ @Test+ void findAssociationForResource_backsDeleteGuards() {+ Tenant tenant = service.createTenant("acme", List.of(), ACCOUNT, REGION);+ service.associate(tenant, identityRef("example.com"), REGION, () -> {});+ assertTrue(service.findAssociationForResource("identity", "example.com", REGION).isPresent());+ assertTrue(service.findAssociationForResource("identity", "other.com", REGION).isEmpty());+ assertTrue(service.findAssociationForResource("identity", "example.com", "eu-west-1").isEmpty());+ }++ @Test+ void tenantForAssociation_hasServiceLevelEmptyMessage() {+ AwsException empty = assertThrows(AwsException.class,+ () -> service.tenantForAssociation("", REGION));+ assertEquals("TenantName cannot be empty", empty.getMessage());+ AwsException absent = assertThrows(AwsException.class,+ () -> service.tenantForAssociation(null, REGION));+ assertTrue(absent.getMessage().contains("'tenantName'"));+ AwsException missing = assertThrows(AwsException.class,+ () -> service.tenantForAssociation("ghost", REGION));+ assertEquals("NotFoundException", missing.getErrorCode());+ }++ @Test+ void validateFilterAndPaging_matchAwsMessages() {+ assertEquals("Invalid resource type NOPE specified.",+ assertThrows(AwsException.class,+ () -> SesTenantService.validateResourceTypeFilter("NOPE")).getMessage());+ assertEquals("Invalid resource type EMAIL_IDENTITY specified.",+ assertThrows(AwsException.class,+ () -> SesTenantService.validateResourceTypeFilter("EMAIL_IDENTITY")).getMessage());+ assertTrue(assertThrows(AwsException.class,+ () -> SesTenantService.validateListPaging(0, null))+ .getMessage().contains("greater than or equal to 1"));+ assertEquals("Invalid Next Token",+ assertThrows(AwsException.class,+ () -> SesTenantService.validateListPaging(null, "garbage")).getMessage());+ }}