Light, fluffy, and always free - The AWS Local Emulator alternative
feat(ses): add SES v2 ListRecommendations (#6817)
Kenshin Okinaka4dbe3731a9e5
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/SesRecommendationTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/SesRecommendationTest.javanew file mode 100644index 0000000000..f5b1636195--- /dev/null+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/SesRecommendationTest.java@@ -0,0 +1,119 @@+package com.floci.test;++import org.junit.jupiter.api.AfterAll;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.DisplayName;+import org.junit.jupiter.api.Test;+import software.amazon.awssdk.services.sesv2.SesV2Client;+import software.amazon.awssdk.services.sesv2.model.BadRequestException;+import software.amazon.awssdk.services.sesv2.model.ListRecommendationsFilterKey;+import software.amazon.awssdk.services.sesv2.model.ListRecommendationsResponse;+import software.amazon.awssdk.services.sesv2.model.NotFoundException;+import software.amazon.awssdk.services.sesv2.model.PutAccountVdmAttributesRequest;+import software.amazon.awssdk.services.sesv2.model.Recommendation;+import software.amazon.awssdk.services.sesv2.model.RecommendationImpact;+import software.amazon.awssdk.services.sesv2.model.RecommendationStatus;+import software.amazon.awssdk.services.sesv2.model.RecommendationType;+import software.amazon.awssdk.services.sesv2.model.VdmAttributes;++import java.util.List;+import java.util.Map;++import static org.assertj.core.api.Assertions.assertThat;+import static org.assertj.core.api.Assertions.assertThatThrownBy;++/**+ * SDK compatibility test for SES v2 ListRecommendations. With Virtual Deliverability Manager enabled, a+ * verified domain without DMARC or BIMI records gets a recommendation for each, described by SES's code+ * rather than a sentence.+ */+@DisplayName("SES v2 Recommendations")+class SesRecommendationTest {++ private static final String DOMAIN = TestFixtures.uniqueName("compat-advisor") + ".example.com";++ private static SesV2Client sesV2;+ private static VdmAttributes originalVdm;++ @BeforeAll+ static void setup() {+ sesV2 = TestFixtures.sesV2Client();+ originalVdm = sesV2.getAccount(b -> { }).vdmAttributes();+ setVdmEnabled(true);+ TestFixtures.verifySesDomainIdentityViaRoute53(sesV2, DOMAIN);+ }++ @AfterAll+ static void cleanup() {+ if (sesV2 == null) {+ return;+ }+ try {+ sesV2.deleteEmailIdentity(b -> b.emailIdentity(DOMAIN));+ } catch (NotFoundException expected) {+ // Setup failed before the identity existed; anything else (auth, connectivity) must surface.+ } finally {+ restoreVdm();+ }+ }++ private static void setVdmEnabled(boolean enabled) {+ sesV2.putAccountVdmAttributes(PutAccountVdmAttributesRequest.builder()+ .vdmAttributes(VdmAttributes.builder()+ .vdmEnabled(enabled ? "ENABLED" : "DISABLED")+ .build())+ .build());+ }++ private static void restoreVdm() {+ if (originalVdm == null || originalVdm.vdmEnabled() == null) {+ setVdmEnabled(false);+ return;+ }+ sesV2.putAccountVdmAttributes(PutAccountVdmAttributesRequest.builder()+ .vdmAttributes(originalVdm)+ .build());+ }++ private static List<Recommendation> forDomain(ListRecommendationsResponse response) {+ return response.recommendations().stream()+ .filter(r -> r.resourceArn().endsWith(":identity/" + DOMAIN))+ .toList();+ }++ @Test+ @DisplayName("A domain without DMARC and BIMI records gets both recommendations")+ void listsDmarcAndBimi() {+ List<Recommendation> recommendations = forDomain(sesV2.listRecommendations(r -> r.pageSize(1000)));++ assertThat(recommendations).extracting(Recommendation::type)+ .containsExactly(RecommendationType.BIMI, RecommendationType.DMARC);+ assertThat(recommendations).extracting(Recommendation::description).containsExactly("BIMI1", "DMARC1");+ assertThat(recommendations).extracting(Recommendation::impact)+ .containsExactly(RecommendationImpact.LOW, RecommendationImpact.HIGH);+ assertThat(recommendations).extracting(Recommendation::status).containsOnly(RecommendationStatus.OPEN);+ assertThat(recommendations).allSatisfy(r -> {+ assertThat(r.createdTimestamp()).isNotNull();+ assertThat(r.lastUpdatedTimestamp()).isNotNull();+ });+ }++ @Test+ @DisplayName("A TYPE filter narrows the list")+ void filtersByType() {+ List<Recommendation> recommendations = forDomain(sesV2.listRecommendations(r -> r+ .filter(Map.of(ListRecommendationsFilterKey.TYPE, "DMARC"))+ .pageSize(1000)));++ assertThat(recommendations).extracting(Recommendation::description).containsExactly("DMARC1");+ }++ @Test+ @DisplayName("An unknown TYPE value is refused")+ void refusesUnknownType() {+ assertThatThrownBy(() -> sesV2.listRecommendations(r -> r+ .filter(Map.of(ListRecommendationsFilterKey.TYPE, "NOPE"))))+ .isInstanceOf(BadRequestException.class)+ .hasMessageContaining("Invalid recommendation TYPE specified");+ }+}diff --git a/docs/services/ses.md b/docs/services/ses.mdindex 8cd5e73cdd..7ed77760ac 100644--- a/docs/services/ses.md+++ b/docs/services/ses.md@@ -426,6 +426,7 @@ Alongside the classic Query API, Floci implements a subset of the SES v2 REST JS| `PUT` | `/v2/email/reputation/entities/{ReputationEntityType}/{ReputationEntityReference}/policy` | `UpdateReputationEntityPolicy` || `PUT` | `/v2/email/reputation/entities/{ReputationEntityType}/{ReputationEntityReference}/customer-managed-status` | `UpdateReputationEntityCustomerManagedStatus` || `POST` | `/v2/email/email-address-insights/` | `GetEmailAddressInsights` |+| `POST` | `/v2/email/vdm/recommendations` | `ListRecommendations` |Floci models no leased dedicated IPs: `GetDedicatedIps` is empty and IP-targeted operations return `NotFoundException`, as real AWS does for an account with no leased IPs, with required request members validated first (`BadRequestException`). `PutDedicatedIpPoolScalingAttributes` rejects downgrading a `MANAGED` pool to `STANDARD`, and `PutAccountDedicatedIpWarmupAttributes` stores the flag behind `GetAccount.DedicatedIpAutoWarmupEnabled` (default `true`).@@ -523,9 +524,13 @@ S/MIME certificate associations are stored per region and never used: Floci doesDeviations from AWS: `IsValid` is `HIGH` whenever it is not `LOW` and never `MEDIUM`, although AWS documents a `MEDIUM` overall verdict too (no probed address returned one), every domain that is not reserved is taken to have valid DNS records, Floci keeps no disposable-domain list and detects no random input, and an address with a non-ASCII character in its domain (an internationalized domain name included) or in an unquoted local part is rated `LOW` everywhere, as a send would reject it, while a quoted local part, which a send does not inspect, is rated like any other; AWS's verdicts for such addresses were not probed.+[`ListRecommendations`](https://docs.aws.amazon.com/ses/latest/dg/vdm-advisor.html) is derived on every call from the region's verified domain identities, with the TXT records in Route53 hosted zones standing in for public DNS, as for DKIM detection. As on AWS, a region without Virtual Deliverability Manager enabled answers an empty list rather than an error, and a `TYPE` filter makes an `IMPACT` filter sent with it ignored. Floci raises `DKIM1` when DKIM signing is disabled, `DKIM3` when Easy DKIM signs with a 1024-bit key, `DMARC1` without a TXT record at `_dmarc.<domain>`, and `BIMI1` without one at `default._bimi.<domain>`.++Deviations from AWS: Floci keeps no recommendation history, so every recommendation is `OPEN`, one whose condition clears disappears instead of turning `FIXED`, `CreatedTimestamp` is the identity's creation time and `LastUpdatedTimestamp` the time of the request, and a change shows at once where AWS takes up to six hours. Floci never raises `DKIM2` (DKIM verification failed), as its DKIM status never reaches `FAILED`, nor the codes no probe could tie to a condition (`DMARC5` among them), nor `SPF`, `COMPLAINT`, `BOUNCE`, `FEEDBACK_3P`, `IP_LISTING` or AWS's `ENGAGEMENT` announcements. Which other filter combinations AWS accepts was not probed: Floci applies them all, and validates the request before checking Virtual Deliverability Manager. Also unprobed, and Floci's choice: any TXT record at `_dmarc.<domain>` or `default._bimi.<domain>` clears its finding whatever it holds, a `RESOURCE_ARN` filter matches the identity's ARN exactly, the domain's case included, an SES ARN with no account is not taken for another account's and simply matches nothing, and a `NextToken` is refused (`Failed to deserialize token.`) once the filter differs from the one it came from, as in Floci's other filtered SES v2 lists.+### Request member types-The operations whose body nests a structure in a structure, or holds a list of structures, check the request body against the SES v2 service model before anything else is validated, as AWS's restJson1 deserializer does: the send operations (`SendEmail`, `SendBulkEmail`, `SendCustomVerificationEmail`), `CreateConfigurationSet`, `UpdateConfigurationSet`, `PutConfigurationSetSuppressionOptions`, `PutConfigurationSetVdmOptions`, `CreateConfigurationSetEventDestination`, `UpdateConfigurationSetEventDestination`, `CreateContactList`, `UpdateContactList`, `CreateContact`, `UpdateContact`, `ListContacts`, `PutAccountSuppressionAttributes`, `PutAccountVdmAttributes`, `BatchGetMetricData`, `CreateImportJob` and `CreateExportJob`. `ListReputationEntities`, `UpdateReputationEntityPolicy`, `UpdateReputationEntityCustomerManagedStatus` and `GetEmailAddressInsights` run the same check although their bodies are flat. In those operations, the first body member of the wrong JSON type, in body order, is a `SerializationException` with AWS's deserializer message:+The operations whose body nests a structure in a structure, or holds a list of structures, check the request body against the SES v2 service model before anything else is validated, as AWS's restJson1 deserializer does: the send operations (`SendEmail`, `SendBulkEmail`, `SendCustomVerificationEmail`), `CreateConfigurationSet`, `UpdateConfigurationSet`, `PutConfigurationSetSuppressionOptions`, `PutConfigurationSetVdmOptions`, `CreateConfigurationSetEventDestination`, `UpdateConfigurationSetEventDestination`, `CreateContactList`, `UpdateContactList`, `CreateContact`, `UpdateContact`, `ListContacts`, `PutAccountSuppressionAttributes`, `PutAccountVdmAttributes`, `BatchGetMetricData`, `CreateImportJob` and `CreateExportJob`. `ListReputationEntities`, `UpdateReputationEntityPolicy`, `UpdateReputationEntityCustomerManagedStatus`, `GetEmailAddressInsights` and `ListRecommendations` run the same check although their bodies are flat. In those operations, the first body member of the wrong JSON type, in body order, is a `SerializationException` with AWS's deserializer message:| Member type | Value sent | Message ||---|---|---|diff --git a/src/main/java/io/github/hectorvent/floci/core/common/ResolvedServiceCatalog.java b/src/main/java/io/github/hectorvent/floci/core/common/ResolvedServiceCatalog.javaindex cf48cfce21..6bde43c81f 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/ResolvedServiceCatalog.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/ResolvedServiceCatalog.java@@ -88,6 +88,7 @@ import io.github.hectorvent.floci.services.ses.SesIdentityController;import io.github.hectorvent.floci.services.ses.SesImportJobController;import io.github.hectorvent.floci.services.ses.SesInsightsController;import io.github.hectorvent.floci.services.ses.SesMetricsController;+import io.github.hectorvent.floci.services.ses.SesRecommendationController;import io.github.hectorvent.floci.services.ses.SesReputationEntityController;import io.github.hectorvent.floci.services.ses.SesSendController;import io.github.hectorvent.floci.services.ses.SesSuppressionController;@@ -351,7 +352,8 @@ public class ResolvedServiceCatalog {SesDedicatedIpController.class, SesExportJobController.class,SesIdentityController.class,SesInsightsController.class, SesMetricsController.class,- SesReputationEntityController.class, SesSendController.class,+ SesRecommendationController.class, SesReputationEntityController.class,+ SesSendController.class,SesSuppressionController.class, SesTagController.class,SesTemplateController.class, SesImportJobController.class,SesTenantController.class)),diff --git a/src/main/java/io/github/hectorvent/floci/services/ses/SesAccountService.java b/src/main/java/io/github/hectorvent/floci/services/ses/SesAccountService.javaindex 298818725a..4010c05072 100644--- a/src/main/java/io/github/hectorvent/floci/services/ses/SesAccountService.java+++ b/src/main/java/io/github/hectorvent/floci/services/ses/SesAccountService.java@@ -86,6 +86,10 @@ public class SesAccountService {LOG.infov("Updated account VDM attributes for region {0}: enabled={1}", region, vdm.vdmEnabled());}+ public boolean isVdmEnabled(String region) {+ return findAccountVdmAttributes(region).map(AccountVdmAttributes::vdmEnabled).orElse(false);+ }+/** The probe-confirmed gate the VDM-only operations check before reading the request. */public void requireVdmEnabled(String region) {requireVdmEnabled(region, "NotFoundException", 404);@@ -97,8 +101,7 @@ public class SesAccountService {* the identical sentence, all probe-confirmed.*/public void requireVdmEnabled(String region, String errorCode, int status) {- Optional<AccountVdmAttributes> vdm = findAccountVdmAttributes(region);- if (vdm.isEmpty() || !vdm.get().vdmEnabled()) {+ if (!isVdmEnabled(region)) {throw new AwsException(errorCode,"To use this feature you must enable Virtual Deliverability Manager", status);}diff --git a/src/main/java/io/github/hectorvent/floci/services/ses/SesIdentityService.java b/src/main/java/io/github/hectorvent/floci/services/ses/SesIdentityService.javaindex 00fb7df524..40f0a23f84 100644--- a/src/main/java/io/github/hectorvent/floci/services/ses/SesIdentityService.java+++ b/src/main/java/io/github/hectorvent/floci/services/ses/SesIdentityService.java@@ -30,6 +30,8 @@ import java.util.Optional;import java.util.Set;import java.util.UUID;import java.util.concurrent.ConcurrentHashMap;+import java.util.stream.Collectors;+import java.util.stream.Stream;/*** Email and domain identities, extracted from {@link SesService} as the last store of the@@ -258,7 +260,7 @@ public class SesIdentityService implements SesTaggable {}/** Only a domain that is not yet verified can still change status, through its DKIM records. */- private Identity withCurrentStatus(Identity identity, String region) {+ Identity withCurrentStatus(Identity identity, String region) {if ("Domain".equals(identity.getIdentityType()) && !"Success".equals(identity.getVerificationStatus())) {Identity refreshed = refreshIdentityState(identity, region);return refreshed == null ? identity : refreshed;@@ -774,30 +776,47 @@ public class SesIdentityService implements SesTaggable {private boolean hasExpectedDkimRecord(String domain, String token) {String expectedName = normalizeDnsName(token + "._domainkey." + domain);String expectedValue = normalizeDnsName(token + "." + DKIM_SIGNING_HOSTED_ZONE);- for (HostedZone zone : route53Service.listHostedZones(null, Integer.MAX_VALUE)) {- for (ResourceRecordSet recordSet : route53Service.listResourceRecordSets(zone.getId(), null, null,- Integer.MAX_VALUE)) {- if (!"CNAME".equalsIgnoreCase(recordSet.getType())) {- continue;- }- if (!expectedName.equals(normalizeDnsName(recordSet.getName()))) {- continue;- }- List<ResourceRecord> records = recordSet.getRecords();- if (records == null) {- continue;- }- for (ResourceRecord record : records) {- if (record != null && expectedValue.equals(normalizeDnsName(record.getValue()))) {- return true;- }- }+ return recordSets("CNAME")+ .filter(recordSet -> expectedName.equals(normalizeDnsName(recordSet.getName())))+ .anyMatch(recordSet -> recordSet.getRecords() != null && recordSet.getRecords().stream()+ .anyMatch(record -> record != null+ && expectedValue.equals(normalizeDnsName(record.getValue()))));+ }++ /**+ * The names of the TXT record sets in every Route53 hosted zone, normalized as by+ * {@link #normalizeDnsName}: the stand-in for the public DNS lookups SES makes. Empty while DNS+ * lookup is disabled.+ */+ Set<String> txtRecordNames() {+ if (route53Service == null) {+ return Set.of();+ }+ return recordSets("TXT").map(recordSet -> normalizeDnsName(recordSet.getName()))+ .collect(Collectors.toSet());+ }++ /** Zone by zone, so a lookup that finds its record reads no further zones. */+ private Stream<ResourceRecordSet> recordSets(String type) {+ return route53Service.listHostedZones(null, Integer.MAX_VALUE).stream()+ .flatMap(zone -> zoneRecordSets(zone.getId()).stream())+ .filter(recordSet -> type.equalsIgnoreCase(recordSet.getType()));+ }++ /** A zone deleted after the zones were listed holds no records rather than failing the SES call. */+ private List<ResourceRecordSet> zoneRecordSets(String zoneId) {+ try {+ return route53Service.listResourceRecordSets(zoneId, null, null, Integer.MAX_VALUE);+ } catch (AwsException e) {+ if (!"NoSuchHostedZone".equals(e.getErrorCode())) {+ throw e;}+ LOG.debugv("Hosted zone {0} was deleted during an SES DNS lookup; skipping it", zoneId);+ return List.of();}- return false;}- private String normalizeDnsName(String value) {+ static String normalizeDnsName(String value) {if (value == null) {return "";}@@ -818,7 +837,7 @@ public class SesIdentityService implements SesTaggable {private String dkimLookupCacheKey(String region, Identity identity) {List<String> normalizedTokens = identity.getDkimTokens().stream()- .map(this::normalizeDnsName)+ .map(SesIdentityService::normalizeDnsName).sorted().toList();return region + "::" + normalizeDnsName(identity.getIdentity()) + "::" + String.join(",", normalizedTokens);diff --git a/src/main/java/io/github/hectorvent/floci/services/ses/SesListPaging.java b/src/main/java/io/github/hectorvent/floci/services/ses/SesListPaging.javaindex dc14ffa624..d26011f234 100644--- a/src/main/java/io/github/hectorvent/floci/services/ses/SesListPaging.java+++ b/src/main/java/io/github/hectorvent/floci/services/ses/SesListPaging.java@@ -147,6 +147,12 @@ public enum SesListPaging {token -> badRequest("Failed to deserialize token. "),true),+ /** Probed 2026-10-27: 68 recommendations came back as 50 and a token without a PageSize. */+ V2_LIST_RECOMMENDATIONS(Namespace.RECOMMENDATION, 50, 1000,+ size -> badRequest("The PageSize should be between 1 and 1000"),+ token -> badRequest("Failed to deserialize token."),+ true),+/*** The request has no size member; the model documents "up to 100 receipt rule sets at a time".* SES allows 40 rule sets per region, so a second page could not be observed.@@ -173,6 +179,7 @@ public enum SesListPaging {static final String SUPPRESSED_DESTINATION = "suppressed-destination";static final String RECEIPT_RULE_SET = "receipt-rule-set";static final String REPUTATION_ENTITY = "reputation-entity";+ static final String RECOMMENDATION = "recommendation";}/** What the tenant lists share, and ListImportJobs borrows: the bound and Smithy's messages. */diff --git a/src/main/java/io/github/hectorvent/floci/services/ses/SesRecommendationController.java b/src/main/java/io/github/hectorvent/floci/services/ses/SesRecommendationController.javanew file mode 100644index 0000000000..5b597f0b87--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ses/SesRecommendationController.java@@ -0,0 +1,85 @@+package io.github.hectorvent.floci.services.ses;++import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import com.fasterxml.jackson.databind.node.ArrayNode;+import com.fasterxml.jackson.databind.node.ObjectNode;+import io.github.hectorvent.floci.core.common.PaginatedResult;+import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.core.common.SmithyValidationErrors;+import io.github.hectorvent.floci.services.ses.SesRecommendationService.Recommendation;+import jakarta.inject.Inject;+import jakarta.ws.rs.Consumes;+import jakarta.ws.rs.POST;+import jakarta.ws.rs.Path;+import jakarta.ws.rs.Produces;+import jakarta.ws.rs.core.Context;+import jakarta.ws.rs.core.HttpHeaders;+import jakarta.ws.rs.core.MediaType;+import jakarta.ws.rs.core.Response;++import java.util.List;+import java.util.Map;++import static io.github.hectorvent.floci.services.ses.SesV2Json.filterValues;+import static io.github.hectorvent.floci.services.ses.SesV2Json.intMemberOrAbsent;+import static io.github.hectorvent.floci.services.ses.SesV2Json.putTimestamp;+import static io.github.hectorvent.floci.services.ses.SesV2Json.readOptionBody;+import static io.github.hectorvent.floci.services.ses.SesV2Json.stringMapMemberOrAbsent;+import static io.github.hectorvent.floci.services.ses.SesV2Json.stringMemberOrAbsent;++/** SES V2 Virtual Deliverability Manager advisor recommendations ({@code /v2/email/vdm/recommendations}). */+@Path("/v2/email/vdm/recommendations")+@Produces(MediaType.APPLICATION_JSON)+@Consumes(MediaType.APPLICATION_JSON)+public class SesRecommendationController {++ /** In the model's order. */+ private static final List<String> FILTER_KEYS = List.of("TYPE", "IMPACT", "STATUS", "RESOURCE_ARN");+ private static final int FILTER_MAX_KEYS = 2;+ private static final int FILTER_VALUE_MAX = 512;++ private final SesRecommendationService recommendationService;+ private final RegionResolver regionResolver;+ private final ObjectMapper objectMapper;++ @Inject+ public SesRecommendationController(SesRecommendationService recommendationService,+ RegionResolver regionResolver, ObjectMapper objectMapper) {+ this.recommendationService = recommendationService;+ this.regionResolver = regionResolver;+ this.objectMapper = objectMapper;+ }++ @POST+ public Response listRecommendations(@Context HttpHeaders headers, String body) {+ String region = regionResolver.resolveRegion(headers);+ JsonNode request = readOptionBody(objectMapper, body);+ SesV2RequestShapes.check("ListRecommendations", request);+ Map<String, String> requested = stringMapMemberOrAbsent(request, "Filter");+ if (requested != null) {+ String violation = SmithyValidationErrors.sizeOutOfRange("filter", requested.size(), 1, FILTER_MAX_KEYS);+ if (violation != null) {+ throw SmithyValidationErrors.badRequest(violation);+ }+ }+ Map<String, String> filter = filterValues(requested, FILTER_KEYS, FILTER_VALUE_MAX);+ Integer pageSize = intMemberOrAbsent(request, "PageSize");+ String nextToken = stringMemberOrAbsent(request, "NextToken");+ PaginatedResult<Recommendation> page = recommendationService.list(filter, pageSize, nextToken, region);+ ObjectNode result = objectMapper.createObjectNode();+ result.put("NextToken", page.nextToken());+ ArrayNode recommendations = result.putArray("Recommendations");+ for (Recommendation recommendation : page.items()) {+ ObjectNode node = recommendations.addObject();+ node.put("ResourceArn", recommendation.resourceArn());+ node.put("Type", recommendation.type());+ node.put("Description", recommendation.description());+ node.put("Status", recommendation.status());+ putTimestamp(node, "CreatedTimestamp", recommendation.createdTimestamp());+ putTimestamp(node, "LastUpdatedTimestamp", recommendation.lastUpdatedTimestamp());+ node.put("Impact", recommendation.impact());+ }+ return Response.ok(result).build();+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/ses/SesRecommendationService.java b/src/main/java/io/github/hectorvent/floci/services/ses/SesRecommendationService.javanew file mode 100644index 0000000000..6d4415095c--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ses/SesRecommendationService.java@@ -0,0 +1,156 @@+package io.github.hectorvent.floci.services.ses;++import io.github.hectorvent.floci.core.common.AwsArnUtils;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.common.PaginatedResult;+import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.services.ses.SesRecommendations.Finding;+import io.github.hectorvent.floci.services.ses.model.Identity;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.inject.Inject;++import java.time.Clock;+import java.time.Instant;+import java.util.ArrayList;+import java.util.List;+import java.util.Map;+import java.util.Objects;+import java.util.Set;+import java.util.function.Predicate;++/**+ * SES v2 ListRecommendations, derived on every call from the region's verified domains (see+ * {@link SesRecommendations}). Probe-confirmed against real SES: a region without Virtual Deliverability+ * Manager answers an empty list rather than an error, verified domains notwithstanding (2026-10-29);+ * recommendations come newest first; and a TYPE filter makes SES ignore an IMPACT filter sent with it+ * (2026-10-27).+ *+ * <p>Nothing is stored, so every recommendation is OPEN: a finding that clears disappears rather than+ * turning FIXED. A recommendation is dated from its identity's creation and reports the time of the+ * request as its last update, as SES re-evaluates every recommendation daily.+ */+@ApplicationScoped+public class SesRecommendationService {++ private static final List<String> TYPES =+ List.of("DKIM", "DMARC", "SPF", "BIMI", "COMPLAINT", "BOUNCE", "FEEDBACK_3P", "IP_LISTING");+ private static final List<String> IMPACTS = List.of("LOW", "HIGH");+ private static final List<String> STATUSES = List.of("OPEN", "FIXED");+ private static final String OPEN = "OPEN";++ private final SesIdentityService identityService;+ private final SesAccountService accountService;+ private final RegionResolver regionResolver;+ private final Clock clock;++ public record Recommendation(String resourceArn, String type, String description, String status,+ Instant createdTimestamp, Instant lastUpdatedTimestamp, String impact) {}++ @Inject+ public SesRecommendationService(SesIdentityService identityService, SesAccountService accountService,+ RegionResolver regionResolver, Clock clock) {+ this.identityService = identityService;+ this.accountService = accountService;+ this.regionResolver = regionResolver;+ this.clock = clock;+ }++ /**+ * The controller has already checked the filter's size and keys. The page size and an empty token+ * come next, then the filter values in key order, and last the token. Without VDM the request is+ * still validated, the order of the gate against the validation being unprobed.+ */+ public PaginatedResult<Recommendation> list(Map<String, String> filter, Integer pageSize, String nextToken,+ String region) {+ SesListPaging paging = SesListPaging.V2_LIST_RECOMMENDATIONS;+ paging.checkRequest(pageSize, nextToken);+ Predicate<Recommendation> matches = filterPredicate(filter);+ List<Recommendation> recommendations = accountService.isVdmEnabled(region)+ ? derive(region).stream().filter(matches).toList()+ : List.of();+ return paging.page(region, scope(filter), recommendations,+ r -> SesListPaging.newestFirst(r.createdTimestamp(), r.resourceArn() + "#" + r.description()),+ pageSize, nextToken);+ }++ /** The ARN goes last: the other values never hold the separator, so no ARN can pass for another filter. */+ private static String scope(Map<String, String> filter) {+ if (filter.isEmpty()) {+ return "";+ }+ return Objects.toString(filter.get("TYPE"), "") + "/" + Objects.toString(filter.get("IMPACT"), "")+ + "/" + Objects.toString(filter.get("STATUS"), "") + "/"+ + Objects.toString(filter.get("RESOURCE_ARN"), "");+ }++ private List<Recommendation> derive(String region) {+ Instant now = Instant.now(clock);+ String accountId = regionResolver.getAccountId();+ List<Identity> advised = identityService.listIdentities("Domain", region).stream()+ .map(identity -> identityService.withCurrentStatus(identity, region))+ .filter(SesRecommendations::isAdvised)+ .toList();+ if (advised.isEmpty()) {+ return List.of();+ }+ Set<String> txtRecordNames = identityService.txtRecordNames();+ List<Recommendation> recommendations = new ArrayList<>();+ for (Identity identity : advised) {+ String domain = identity.getIdentity();+ String arn = AwsArnUtils.Arn.of("ses", region, accountId, "identity/" + domain).toString();+ List<Finding> findings = SesRecommendations.findings(identity,+ txtRecordNames.contains(+ SesIdentityService.normalizeDnsName(SesRecommendations.dmarcRecordName(domain))),+ txtRecordNames.contains(+ SesIdentityService.normalizeDnsName(SesRecommendations.bimiRecordName(domain))));+ for (Finding finding : findings) {+ recommendations.add(new Recommendation(arn, finding.type(), finding.description(), OPEN,+ identity.getCreatedAt(), now, finding.impact()));+ }+ }+ return recommendations;+ }++ private Predicate<Recommendation> filterPredicate(Map<String, String> filter) {+ Predicate<Recommendation> matches = r -> true;+ String type = filter.get("TYPE");+ if (type != null) {+ requireFilterValue("TYPE", TYPES.contains(type));+ matches = matches.and(r -> type.equals(r.type()));+ }+ String impact = filter.get("IMPACT");+ if (impact != null) {+ requireFilterValue("IMPACT", IMPACTS.contains(impact));+ if (type == null) {+ matches = matches.and(r -> impact.equals(r.impact()));+ }+ }+ String status = filter.get("STATUS");+ if (status != null) {+ requireFilterValue("STATUS", STATUSES.contains(status));+ matches = matches.and(r -> status.equals(r.status()));+ }+ String resourceArn = filter.get("RESOURCE_ARN");+ if (resourceArn != null) {+ requireOwnArn(resourceArn);+ matches = matches.and(r -> resourceArn.equals(r.resourceArn()));+ }+ return matches;+ }++ private static void requireFilterValue(String key, boolean valid) {+ if (!valid) {+ throw new AwsException("BadRequestException", "Invalid recommendation " + key + " specified", 400);+ }+ }++ private void requireOwnArn(String resourceArn) {+ if (!AwsArnUtils.isArnFor(resourceArn, "ses")) {+ throw new AwsException("BadRequestException", "Filter resource is invalid", 400);+ }+ if (AwsArnUtils.isForeignAccount(AwsArnUtils.parse(resourceArn), regionResolver.getAccountId())) {+ throw new AwsException("BadRequestException",+ "Provided resource ARN does not match the caller account", 400);+ }+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/ses/SesRecommendations.java b/src/main/java/io/github/hectorvent/floci/services/ses/SesRecommendations.javanew file mode 100644index 0000000000..c31b675cc0--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ses/SesRecommendations.java@@ -0,0 +1,70 @@+package io.github.hectorvent.floci.services.ses;++import io.github.hectorvent.floci.services.ses.model.Identity;++import java.util.ArrayList;+import java.util.List;++/**+ * The Virtual Deliverability Manager advisor findings SES raises for a sending domain, derived from+ * the identity and from whether its DMARC and BIMI TXT records exist. SES describes each finding by a+ * code rather than a sentence. The codes, their impact and the condition behind each were+ * probe-confirmed against real SES (2026-10-27, us-east-1) by comparing the recommendations of+ * verified domains with their identity attributes and public DNS:+ *+ * <ul>+ * <li>{@code DKIM1}, HIGH: DKIM signing is disabled.</li>+ * <li>{@code DKIM3}, LOW: Easy DKIM signs with a 1024-bit key; a domain that does not sign gets+ * none, whatever its next key length.</li>+ * <li>{@code DMARC1}, HIGH: no {@code _dmarc} TXT record.</li>+ * <li>{@code BIMI1}, LOW: no {@code default._bimi} TXT record.</li>+ * </ul>+ *+ * <p>{@code DKIM2} (DKIM verification failed) needs a FAILED DKIM status, which Floci never reaches,+ * and {@code DMARC5} appeared on a domain whose DNS matched one without it, so neither is raised.+ */+final class SesRecommendations {++ record Finding(String type, String description, String impact) {}++ static final Finding DKIM_NOT_ENABLED = new Finding("DKIM", "DKIM1", "HIGH");+ static final Finding DKIM_SHORT_KEY = new Finding("DKIM", "DKIM3", "LOW");+ static final Finding DMARC_NOT_FOUND = new Finding("DMARC", "DMARC1", "HIGH");+ static final Finding BIMI_NOT_FOUND = new Finding("BIMI", "BIMI1", "LOW");++ private SesRecommendations() {+ }++ /** Every finding the probe observed was on a verified domain. */+ static boolean isAdvised(Identity identity) {+ return "Domain".equals(identity.getIdentityType()) && "Success".equals(identity.getVerificationStatus());+ }++ static List<Finding> findings(Identity identity, boolean hasDmarcRecord, boolean hasBimiRecord) {+ if (!isAdvised(identity)) {+ return List.of();+ }+ List<Finding> findings = new ArrayList<>();+ if (!identity.isDkimEnabled()) {+ findings.add(DKIM_NOT_ENABLED);+ } else if ("AWS_SES".equals(identity.getDkimSigningAttributesOrigin())+ && "RSA_1024_BIT".equals(identity.getDkimCurrentSigningKeyLength())) {+ findings.add(DKIM_SHORT_KEY);+ }+ if (!hasDmarcRecord) {+ findings.add(DMARC_NOT_FOUND);+ }+ if (!hasBimiRecord) {+ findings.add(BIMI_NOT_FOUND);+ }+ return findings;+ }++ static String dmarcRecordName(String domain) {+ return "_dmarc." + domain;+ }++ static String bimiRecordName(String domain) {+ return "default._bimi." + domain;+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/ses/SesDomainIdentityTestHelper.java b/src/test/java/io/github/hectorvent/floci/services/ses/SesDomainIdentityTestHelper.javaindex ee3d856cd5..7ad317cca5 100644--- a/src/test/java/io/github/hectorvent/floci/services/ses/SesDomainIdentityTestHelper.java+++ b/src/test/java/io/github/hectorvent/floci/services/ses/SesDomainIdentityTestHelper.java@@ -9,14 +9,15 @@ import static io.restassured.RestAssured.given;* Creates a domain identity that is verified for sending. A domain identity stays Pending until* its DKIM CNAME records exist in a Route 53 hosted zone, so this publishes them in a zone of its* own. A test that checks the Pending state first creates the identity itself and then calls- * {@link #publishDkimRecords}.+ * {@link #publishDkimRecords}. Both return the hosted zone id, for a test that adds records of+ * its own.*/final class SesDomainIdentityTestHelper {private SesDomainIdentityTestHelper() {}- static void createVerified(String domain, String sesAuthorization) {+ static String createVerified(String domain, String sesAuthorization) {List<String> tokens = given().contentType("application/json").header("Authorization", sesAuthorization)@@ -28,10 +29,10 @@ final class SesDomainIdentityTestHelper {.extract().jsonPath().getList("DkimAttributes.Tokens", String.class);- publishDkimRecords(domain, tokens);+ return publishDkimRecords(domain, tokens);}- static void publishDkimRecords(String domain, List<String> tokens) {+ static String publishDkimRecords(String domain, List<String> tokens) {String location = given().contentType("application/xml").body("""@@ -64,6 +65,7 @@ final class SesDomainIdentityTestHelper {</Change>""".formatted(token, domain, token));}+ String zoneId = location.substring(location.lastIndexOf('/') + 1);given().contentType("application/xml").body("""@@ -76,8 +78,9 @@ final class SesDomainIdentityTestHelper {</ChangeResourceRecordSetsRequest>""".formatted(changes)).when()- .post("/2013-04-01/hostedzone/" + location.substring(location.lastIndexOf('/') + 1) + "/rrset")+ .post("/2013-04-01/hostedzone/" + zoneId + "/rrset").then().statusCode(200);+ return zoneId;}}diff --git a/src/test/java/io/github/hectorvent/floci/services/ses/SesIdentityRoute53ScanTest.java b/src/test/java/io/github/hectorvent/floci/services/ses/SesIdentityRoute53ScanTest.javanew file mode 100644index 0000000000..7c3c8bdc91--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/ses/SesIdentityRoute53ScanTest.java@@ -0,0 +1,101 @@+package io.github.hectorvent.floci.services.ses;++import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.core.storage.InMemoryStorage;+import io.github.hectorvent.floci.services.route53.Route53Service;+import io.github.hectorvent.floci.services.route53.model.HostedZone;+import io.github.hectorvent.floci.services.route53.model.ResourceRecord;+import io.github.hectorvent.floci.services.route53.model.ResourceRecordSet;+import io.github.hectorvent.floci.services.ses.model.AccountVdmAttributes;+import io.github.hectorvent.floci.services.ses.model.Identity;+import io.github.hectorvent.floci.testing.MutableClock;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;++import java.util.List;+import java.util.Map;+import java.util.Set;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.never;+import static org.mockito.Mockito.verify;+import static org.mockito.Mockito.when;++/** How SES reads Route53 in place of public DNS: zone by zone, and past a zone deleted mid-scan. */+class SesIdentityRoute53ScanTest {++ private static final String REGION = "us-east-1";+ private static final String DOMAIN = "example.com";++ private Route53Service route53Service;+ private SesIdentityService identities;++ @BeforeEach+ void setUp() {+ route53Service = mock(Route53Service.class);+ identities = new SesIdentityService(new InMemoryStorage<>(), route53Service, new MutableClock());+ when(route53Service.listHostedZones(null, Integer.MAX_VALUE))+ .thenReturn(List.of(zone("zone-1"), zone("zone-2")));+ }++ @Test+ void dkimLookupStopsAtTheZoneHoldingTheRecord() {+ Identity identity = new Identity(DOMAIN, "Domain");+ identity.setVerificationStatus("Pending");+ identity.setDkimTokens(List.of("token-a"));+ identities.save(identity, REGION);+ when(route53Service.listResourceRecordSets("zone-1", null, null, Integer.MAX_VALUE))+ .thenReturn(List.of(recordSet("token-a._domainkey." + DOMAIN + ".", "CNAME",+ "token-a.dkim.amazonses.com.")));++ assertEquals("Success", identities.getIdentityVerificationAttributes(DOMAIN, REGION).getVerificationStatus());+ verify(route53Service, never()).listResourceRecordSets("zone-2", null, null, Integer.MAX_VALUE);+ }++ @Test+ void txtRecordNamesSkipAZoneDeletedMidScan() {+ when(route53Service.listResourceRecordSets("zone-1", null, null, Integer.MAX_VALUE))+ .thenThrow(new AwsException("NoSuchHostedZone", "No hosted zone found with ID: zone-1", 404));+ when(route53Service.listResourceRecordSets("zone-2", null, null, Integer.MAX_VALUE))+ .thenReturn(List.of(recordSet("_dmarc." + DOMAIN + ".", "TXT", "\"v=DMARC1; p=none\"")));++ assertEquals(Set.of("_dmarc." + DOMAIN), identities.txtRecordNames());+ }++ @Test+ void txtRecordNamesPropagateOtherRoute53Errors() {+ when(route53Service.listResourceRecordSets("zone-1", null, null, Integer.MAX_VALUE))+ .thenThrow(new AwsException("Throttling", "Rate exceeded", 400));++ AwsException e = assertThrows(AwsException.class, () -> identities.txtRecordNames());+ assertEquals("Throttling", e.getErrorCode());+ }++ @Test+ void recommendationsReadNoZonesWithoutAVerifiedDomain() {+ identities.save(new Identity("[email protected]", "EmailAddress"), REGION);+ SesAccountService accounts =+ new SesAccountService(new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>());+ accounts.putAccountVdmAttributes(REGION, new AccountVdmAttributes(true, false, false));+ SesRecommendationService recommendations = new SesRecommendationService(identities, accounts,+ new RegionResolver(REGION, "000000000000"), new MutableClock());++ assertEquals(List.of(), recommendations.list(Map.of(), null, null, REGION).items());+ verify(route53Service, never()).listHostedZones(null, Integer.MAX_VALUE);+ }++ private static HostedZone zone(String id) {+ return new HostedZone(id, DOMAIN + ".", "ref-" + id, null, false);+ }++ private static ResourceRecordSet recordSet(String name, String type, String value) {+ ResourceRecordSet recordSet = new ResourceRecordSet();+ recordSet.setName(name);+ recordSet.setType(type);+ recordSet.setRecords(List.of(new ResourceRecord(value)));+ return recordSet;+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/ses/SesRecommendationServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/ses/SesRecommendationServiceTest.javanew file mode 100644index 0000000000..ebf0fcc6d8--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/ses/SesRecommendationServiceTest.java@@ -0,0 +1,212 @@+package io.github.hectorvent.floci.services.ses;++import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.common.PaginatedResult;+import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.core.storage.InMemoryStorage;+import io.github.hectorvent.floci.services.ses.SesRecommendationService.Recommendation;+import io.github.hectorvent.floci.services.ses.model.AccountVdmAttributes;+import io.github.hectorvent.floci.services.ses.model.Identity;+import io.github.hectorvent.floci.testing.MutableClock;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;++import java.time.Duration;+import java.time.Instant;+import java.util.List;+import java.util.Map;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertNotNull;+import static org.junit.jupiter.api.Assertions.assertNull;+import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.junit.jupiter.api.Assertions.assertTrue;++class SesRecommendationServiceTest {++ private static final String REGION = "us-east-1";+ private static final String ACCOUNT = "000000000000";++ private MutableClock clock;+ private SesIdentityService identities;+ private SesAccountService accounts;+ private SesRecommendationService service;++ @BeforeEach+ void setUp() {+ clock = new MutableClock();+ // No Route53, so no domain has DMARC or BIMI records.+ identities = new SesIdentityService(new InMemoryStorage<>(), null, clock);+ accounts = new SesAccountService(new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>());+ accounts.putAccountVdmAttributes(REGION, new AccountVdmAttributes(true, false, false));+ service = new SesRecommendationService(identities, accounts, new RegionResolver(REGION, ACCOUNT), clock);+ }++ private Identity saveDomain(String domain, boolean signing, Instant created) {+ Identity identity = new Identity(domain, "Domain");+ identity.setDkimEnabled(signing);+ identity.setDkimTokens(List.of("token"));+ identity.setCreatedAt(created);+ identities.save(identity, REGION);+ return identity;+ }++ private static String arn(String domain) {+ return "arn:aws:ses:" + REGION + ":" + ACCOUNT + ":identity/" + domain;+ }++ private List<Recommendation> list(Map<String, String> filter) {+ return service.list(filter, null, null, REGION).items();+ }++ private static List<String> codes(List<Recommendation> recommendations) {+ return recommendations.stream().map(r -> r.resourceArn().substring(r.resourceArn().indexOf('/') + 1)+ + ":" + r.description()).toList();+ }++ @Test+ void listsNewestIdentityFirstWithCodesOrderedWithin() {+ saveDomain("old.example", true, Instant.parse("2024-01-01T00:00:00Z"));+ saveDomain("new.example", false, Instant.parse("2025-01-01T00:00:00Z"));+ assertEquals(List.of("new.example:BIMI1", "new.example:DKIM1", "new.example:DMARC1",+ "old.example:BIMI1", "old.example:DMARC1"),+ codes(list(Map.of())));+ }++ @Test+ void everyRecommendationIsOpenDatedFromItsIdentityAndUpdatedNow() {+ Instant created = Instant.parse("2024-01-01T00:00:00Z");+ saveDomain("example.com", true, created);+ Instant before = clock.instant();+ Recommendation recommendation = list(Map.of("TYPE", "DMARC")).getFirst();+ assertEquals(arn("example.com"), recommendation.resourceArn());+ assertEquals("OPEN", recommendation.status());+ assertEquals("HIGH", recommendation.impact());+ assertEquals(created, recommendation.createdTimestamp());+ // MutableClock ticks a millisecond per read, so the list's own read comes after this one.+ assertTrue(recommendation.lastUpdatedTimestamp().isAfter(before));+ }++ @Test+ void emptyWithoutVdm() {+ saveDomain("example.com", false, clock.instant());+ accounts.putAccountVdmAttributes(REGION, new AccountVdmAttributes(false, false, false));+ assertEquals(List.of(), list(Map.of()));+ assertEquals(List.of(), service.list(Map.of(), null, null, "eu-west-3").items());+ }++ @Test+ void filterIsValidatedWithoutVdm() {+ accounts.putAccountVdmAttributes(REGION, new AccountVdmAttributes(false, false, false));+ assertMessage("Invalid recommendation TYPE specified", Map.of("TYPE", "ENGAGEMENT"));+ }++ @Test+ void unverifiedDomainsAndEmailAddressesAreNotAdvised() {+ Identity pending = saveDomain("pending.example", true, clock.instant());+ pending.setVerificationStatus("Pending");+ identities.save(pending, REGION);+ identities.save(new Identity("[email protected]", "EmailAddress"), REGION);+ assertEquals(List.of(), list(Map.of()));+ }++ @Test+ void typeFilterIgnoresImpact() {+ saveDomain("example.com", false, clock.instant());+ assertEquals(List.of("example.com:DKIM1"), codes(list(Map.of("TYPE", "DKIM", "IMPACT", "LOW"))));+ }++ @Test+ void impactFilterAppliesWithoutType() {+ saveDomain("example.com", false, clock.instant());+ assertEquals(List.of("example.com:BIMI1"), codes(list(Map.of("IMPACT", "LOW"))));+ }++ @Test+ void statusFilterFixedIsEmpty() {+ saveDomain("example.com", false, clock.instant());+ assertEquals(List.of(), list(Map.of("STATUS", "FIXED")));+ assertEquals(3, list(Map.of("STATUS", "OPEN")).size());+ }++ @Test+ void resourceArnFilterMatchesTheIdentityArn() {+ saveDomain("a.example", true, clock.instant());+ saveDomain("b.example", true, clock.instant());+ assertEquals(List.of("b.example:BIMI1", "b.example:DMARC1"),+ codes(list(Map.of("RESOURCE_ARN", arn("b.example")))));+ assertEquals(List.of(), list(Map.of("RESOURCE_ARN", arn("missing.example"))));+ }++ @Test+ void invalidFilterValuesNameTheirKey() {+ assertMessage("Invalid recommendation TYPE specified", Map.of("TYPE", "ENGAGEMENT"));+ assertMessage("Invalid recommendation IMPACT specified", Map.of("IMPACT", "MEDIUM"));+ assertMessage("Invalid recommendation STATUS specified", Map.of("STATUS", "open"));+ }++ @Test+ void impactIsValidatedEvenWhenTypeMakesItIgnored() {+ assertMessage("Invalid recommendation IMPACT specified", Map.of("TYPE", "DKIM", "IMPACT", "high"));+ }++ @Test+ void resourceArnMustBeAnSesArnOfTheCallerAccount() {+ assertMessage("Filter resource is invalid", Map.of("RESOURCE_ARN", "not-an-arn"));+ assertMessage("Filter resource is invalid",+ Map.of("RESOURCE_ARN", "arn:aws:sns:us-east-1:000000000000:identity/example.com"));+ assertMessage("Provided resource ARN does not match the caller account",+ Map.of("RESOURCE_ARN", "arn:aws:ses:us-east-1:111111111111:identity/example.com"));+ }++ @Test+ void pagesOfTheDefaultFifty() {+ for (int i = 0; i < 26; i++) {+ saveDomain("d" + i + ".example", true, clock.instant().plus(Duration.ofSeconds(i)));+ }+ PaginatedResult<Recommendation> first = service.list(Map.of(), null, null, REGION);+ assertEquals(50, first.items().size());+ assertNotNull(first.nextToken());+ PaginatedResult<Recommendation> second = service.list(Map.of(), null, first.nextToken(), REGION);+ assertEquals(2, second.items().size());+ assertNull(second.nextToken());+ }++ @Test+ void tokenIsBoundToItsFilter() {+ saveDomain("a.example", true, clock.instant());+ saveDomain("b.example", true, clock.instant().plusSeconds(1));+ String token = service.list(Map.of("STATUS", "OPEN"), 1, null, REGION).nextToken();+ assertNotNull(token);+ assertEquals(1, service.list(Map.of("STATUS", "OPEN"), 1, token, REGION).items().size());+ assertPagingMessage("Failed to deserialize token.", null, token);+ AwsException e = assertThrows(AwsException.class,+ () -> service.list(Map.of("TYPE", "BIMI"), 1, token, REGION));+ assertEquals("Failed to deserialize token.", e.getMessage());+ }++ @Test+ void pageSizeOutsideItsBounds() {+ assertPagingMessage("The PageSize should be between 1 and 1000", 0, null);+ assertPagingMessage("The PageSize should be between 1 and 1000", 1001, null);+ }++ @Test+ void unreadableOrEmptyToken() {+ assertPagingMessage("Failed to deserialize token.", null, "garbage");+ assertPagingMessage("Failed to deserialize token.", null, "");+ }++ private void assertMessage(String message, Map<String, String> filter) {+ AwsException e = assertThrows(AwsException.class, () -> service.list(filter, null, null, REGION));+ assertEquals("BadRequestException", e.getErrorCode());+ assertEquals(message, e.getMessage());+ }++ private void assertPagingMessage(String message, Integer pageSize, String nextToken) {+ AwsException e = assertThrows(AwsException.class,+ () -> service.list(Map.of(), pageSize, nextToken, REGION));+ assertEquals("BadRequestException", e.getErrorCode());+ assertEquals(message, e.getMessage());+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/ses/SesRecommendationV2IntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/ses/SesRecommendationV2IntegrationTest.javanew file mode 100644index 0000000000..6f85e76456--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/ses/SesRecommendationV2IntegrationTest.java@@ -0,0 +1,177 @@+package io.github.hectorvent.floci.services.ses;++import io.quarkus.test.junit.QuarkusTest;+import io.restassured.specification.RequestSpecification;+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.contains;+import static org.hamcrest.Matchers.empty;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.everyItem;+import static org.hamcrest.Matchers.hasKey;+import static org.hamcrest.Matchers.instanceOf;+import static org.hamcrest.Matchers.notNullValue;+import static org.hamcrest.Matchers.nullValue;++/**+ * Integration tests for SES v2 ListRecommendations, derived from the verified domains of the region+ * and the TXT records their Route53 zones hold. The region is one no other test uses, so Virtual+ * Deliverability Manager is off in it until a test enables it.+ */+@QuarkusTest+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)+class SesRecommendationV2IntegrationTest {++ private static final String REGION = "eu-south-2";+ private static final String AUTH =+ "AWS4-HMAC-SHA256 Credential=AKID/20260101/" + REGION + "/ses/aws4_request";+ private static final String DOMAIN = "recommend-it.floci.test";+ private static final String ARN = "arn:aws:ses:" + REGION + ":000000000000:identity/" + DOMAIN;+ private static final String PATH = "/v2/email/vdm/recommendations";++ private static String zoneId;++ private static RequestSpecification v2() {+ return given().contentType("application/json").header("Authorization", AUTH);+ }++ private static void addTxtRecord(String name, String value) {+ given()+ .contentType("application/xml")+ .body("""+ <?xml version="1.0" encoding="UTF-8"?>+ <ChangeResourceRecordSetsRequest xmlns="https://route53.amazonaws.com/doc/2013-04-01/">+ <ChangeBatch>+ <Changes>+ <Change>+ <Action>CREATE</Action>+ <ResourceRecordSet>+ <Name>%s</Name>+ <Type>TXT</Type>+ <TTL>300</TTL>+ <ResourceRecords>+ <ResourceRecord><Value>"%s"</Value></ResourceRecord>+ </ResourceRecords>+ </ResourceRecordSet>+ </Change>+ </Changes>+ </ChangeBatch>+ </ChangeResourceRecordSetsRequest>+ """.formatted(name, value))+ .when()+ .post("/2013-04-01/hostedzone/" + zoneId + "/rrset")+ .then()+ .statusCode(200);+ }++ @Test+ @Order(1)+ void emptyWithoutIdentities() {+ v2().body("{}")+ .when().post(PATH).then().statusCode(200)+ .body("Recommendations", empty())+ .body("$", hasKey("NextToken"))+ .body("NextToken", nullValue());+ }++ @Test+ @Order(2)+ void pendingDomainIsNotAdvised() {+ v2().body("{\"EmailIdentity\":\"pending-" + DOMAIN + "\"}")+ .when().post("/v2/email/identities").then().statusCode(200);+ v2().body("{}").when().post(PATH).then().statusCode(200).body("Recommendations", empty());+ }++ @Test+ @Order(3)+ void verifiedDomainWithoutRecordsGetsBimiAndDmarcOnceVdmIsEnabled() {+ zoneId = SesDomainIdentityTestHelper.createVerified(DOMAIN, AUTH);+ v2().body("{}").when().post(PATH).then().statusCode(200).body("Recommendations", empty());+ v2().body("{\"VdmAttributes\":{\"VdmEnabled\":\"ENABLED\"}}")+ .when().put("/v2/email/account/vdm").then().statusCode(200);+ v2().body("{}")+ .when().post(PATH).then().statusCode(200)+ .body("Recommendations.Description", contains("BIMI1", "DMARC1"))+ .body("Recommendations.Type", contains("BIMI", "DMARC"))+ .body("Recommendations.Impact", contains("LOW", "HIGH"))+ .body("Recommendations.Status", everyItem(equalTo("OPEN")))+ .body("Recommendations.ResourceArn", everyItem(equalTo(ARN)))+ .body("Recommendations[0].CreatedTimestamp", instanceOf(Number.class))+ .body("Recommendations[0].LastUpdatedTimestamp", notNullValue());+ }++ @Test+ @Order(4)+ void publishedTxtRecordsClearTheirFindings() {+ addTxtRecord("_dmarc." + DOMAIN, "v=DMARC1; p=none");+ v2().body("{\"Filter\":{\"RESOURCE_ARN\":\"" + ARN + "\"}}")+ .when().post(PATH).then().statusCode(200)+ .body("Recommendations.Description", contains("BIMI1"));+ addTxtRecord("default._bimi." + DOMAIN, "v=BIMI1; l=https://example.com/logo.svg");+ v2().body("{}").when().post(PATH).then().statusCode(200).body("Recommendations", empty());+ }++ @Test+ @Order(5)+ void disabledSigningIsDkim1() {+ v2().body("{\"SigningEnabled\":false}")+ .when().put("/v2/email/identities/" + DOMAIN + "/dkim").then().statusCode(200);+ v2().body("{}")+ .when().post(PATH).then().statusCode(200)+ .body("Recommendations.Description", contains("DKIM1"))+ .body("Recommendations[0].Impact", equalTo("HIGH"));+ }++ @Test+ @Order(6)+ void shortEasyDkimKeyIsDkim3() {+ v2().body("{\"SigningEnabled\":true}")+ .when().put("/v2/email/identities/" + DOMAIN + "/dkim").then().statusCode(200);+ v2().body("{\"SigningAttributesOrigin\":\"AWS_SES\","+ + "\"SigningAttributes\":{\"NextSigningKeyLength\":\"RSA_1024_BIT\"}}")+ .when().put("/v2/email/identities/" + DOMAIN + "/dkim/signing").then().statusCode(200);+ v2().body("{\"Filter\":{\"TYPE\":\"DKIM\",\"IMPACT\":\"HIGH\"}}")+ .when().post(PATH).then().statusCode(200)+ .body("Recommendations.Description", contains("DKIM3"))+ .body("Recommendations[0].Impact", equalTo("LOW"));+ }++ @Test+ @Order(7)+ void filterSizeIsBoundedByTheModel() {+ v2().body("{\"Filter\":{}}")+ .when().post(PATH).then().statusCode(400)+ .body("message", equalTo("1 validation error detected: Value at 'filter' failed to satisfy "+ + "constraint: Member must have length greater than or equal to 1"));+ v2().body("{\"Filter\":{\"TYPE\":\"DKIM\",\"IMPACT\":\"LOW\",\"STATUS\":\"OPEN\"}}")+ .when().post(PATH).then().statusCode(400)+ .body("message", equalTo("1 validation error detected: Value at 'filter' failed to satisfy "+ + "constraint: Member must have length less than or equal to 2"));+ }++ @Test+ @Order(8)+ void invalidFilterValuesAndPaging() {+ assertBadRequest("{\"Filter\":{\"TYPE\":\"NOPE\"}}", "Invalid recommendation TYPE specified");+ assertBadRequest("{\"Filter\":{\"RESOURCE_ARN\":\"not-an-arn\"}}", "Filter resource is invalid");+ assertBadRequest("{\"Filter\":{\"RESOURCE_ARN\":\"arn:aws:ses:" + REGION + ":111111111111:identity/x.test\"}}",+ "Provided resource ARN does not match the caller account");+ assertBadRequest("{\"Filter\":{\"RESOURCE_ARN\":\"" + "a".repeat(513) + "\"}}",+ "1 validation error detected: Value at 'filter' failed to satisfy constraint: Map value must "+ + "satisfy constraint: [Member must have length less than or equal to 512, "+ + "Member must have length greater than or equal to 1]");+ assertBadRequest("{\"PageSize\":0}", "The PageSize should be between 1 and 1000");+ assertBadRequest("{\"NextToken\":\"garbage\"}", "Failed to deserialize token.");+ }++ private static void assertBadRequest(String body, String message) {+ v2().body(body)+ .when().post(PATH).then().statusCode(400)+ .body("__type", equalTo("BadRequestException"))+ .body("message", equalTo(message));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/ses/SesRecommendationsTest.java b/src/test/java/io/github/hectorvent/floci/services/ses/SesRecommendationsTest.javanew file mode 100644index 0000000000..45797aee10--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/ses/SesRecommendationsTest.java@@ -0,0 +1,87 @@+package io.github.hectorvent.floci.services.ses;++import io.github.hectorvent.floci.services.ses.SesRecommendations.Finding;+import io.github.hectorvent.floci.services.ses.model.Identity;+import org.junit.jupiter.api.Test;++import java.util.List;++import static io.github.hectorvent.floci.services.ses.SesRecommendations.BIMI_NOT_FOUND;+import static io.github.hectorvent.floci.services.ses.SesRecommendations.DKIM_NOT_ENABLED;+import static io.github.hectorvent.floci.services.ses.SesRecommendations.DKIM_SHORT_KEY;+import static io.github.hectorvent.floci.services.ses.SesRecommendations.DMARC_NOT_FOUND;+import static org.junit.jupiter.api.Assertions.assertEquals;++class SesRecommendationsTest {++ private static Identity signingDomain(String keyLength) {+ Identity identity = new Identity("example.com", "Domain");+ identity.setDkimEnabled(true);+ identity.setDkimCurrentSigningKeyLength(keyLength);+ return identity;+ }++ @Test+ void domainWithoutDnsRecordsGetsDmarcAndBimi() {+ assertEquals(List.of(DMARC_NOT_FOUND, BIMI_NOT_FOUND),+ SesRecommendations.findings(signingDomain("RSA_2048_BIT"), false, false));+ }++ @Test+ void domainWithBothRecordsAndStrongKeyGetsNothing() {+ assertEquals(List.of(), SesRecommendations.findings(signingDomain("RSA_2048_BIT"), true, true));+ }++ @Test+ void disabledSigningIsDkim1() {+ Identity identity = new Identity("example.com", "Domain");+ identity.setDkimEnabled(false);+ assertEquals(List.of(DKIM_NOT_ENABLED), SesRecommendations.findings(identity, true, true));+ }++ @Test+ void disabledSigningWithShortKeyIsDkim1Only() {+ Identity identity = signingDomain("RSA_1024_BIT");+ identity.setDkimEnabled(false);+ assertEquals(List.of(DKIM_NOT_ENABLED), SesRecommendations.findings(identity, true, true));+ }++ @Test+ void easyDkimWithShortKeyIsDkim3() {+ assertEquals(List.of(DKIM_SHORT_KEY), SesRecommendations.findings(signingDomain("RSA_1024_BIT"), true, true));+ }++ @Test+ void byoDkimKeyLengthIsNotJudged() {+ Identity identity = signingDomain("RSA_1024_BIT");+ identity.setDkimSigningAttributesOrigin("EXTERNAL");+ assertEquals(List.of(), SesRecommendations.findings(identity, true, true));+ }++ @Test+ void unverifiedDomainGetsNothing() {+ Identity identity = signingDomain("RSA_1024_BIT");+ identity.setVerificationStatus("Pending");+ assertEquals(List.of(), SesRecommendations.findings(identity, false, false));+ }++ @Test+ void emailAddressGetsNothing() {+ Identity identity = new Identity("[email protected]", "EmailAddress");+ assertEquals(List.of(), SesRecommendations.findings(identity, false, false));+ }++ @Test+ void codesAndImpactsFollowTheProbe() {+ assertEquals(new Finding("DKIM", "DKIM1", "HIGH"), DKIM_NOT_ENABLED);+ assertEquals(new Finding("DKIM", "DKIM3", "LOW"), DKIM_SHORT_KEY);+ assertEquals(new Finding("DMARC", "DMARC1", "HIGH"), DMARC_NOT_FOUND);+ assertEquals(new Finding("BIMI", "BIMI1", "LOW"), BIMI_NOT_FOUND);+ }++ @Test+ void recordNamesAreTheDmarcAndDefaultBimiSelectors() {+ assertEquals("_dmarc.example.com", SesRecommendations.dmarcRecordName("example.com"));+ assertEquals("default._bimi.example.com", SesRecommendations.bimiRecordName("example.com"));+ }+}