Skip to content

armgit / floci

Public Imported from GitHub
0

Light, fluffy, and always free - The AWS Local Emulator alternative

feat(ses): support v2 dedicated IP (IP-level) and scaling/warmup APIs (#3420)

Kenshin Okinakae219ea409ff9
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/SesDedicatedIpPoolTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/SesDedicatedIpPoolTest.java
index 6c4f8dbf82..528fe70504 100644
--- a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/SesDedicatedIpPoolTest.java
+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/SesDedicatedIpPoolTest.java
@@ -13,10 +13,17 @@ import software.amazon.awssdk.services.sesv2.model.AlreadyExistsException;
import software.amazon.awssdk.services.sesv2.model.BadRequestException;
import software.amazon.awssdk.services.sesv2.model.CreateDedicatedIpPoolRequest;
import software.amazon.awssdk.services.sesv2.model.DeleteDedicatedIpPoolRequest;
+import software.amazon.awssdk.services.sesv2.model.GetAccountRequest;
import software.amazon.awssdk.services.sesv2.model.GetDedicatedIpPoolRequest;
import software.amazon.awssdk.services.sesv2.model.GetDedicatedIpPoolResponse;
+import software.amazon.awssdk.services.sesv2.model.GetDedicatedIpRequest;
+import software.amazon.awssdk.services.sesv2.model.GetDedicatedIpsRequest;
import software.amazon.awssdk.services.sesv2.model.ListDedicatedIpPoolsResponse;
import software.amazon.awssdk.services.sesv2.model.NotFoundException;
+import software.amazon.awssdk.services.sesv2.model.PutAccountDedicatedIpWarmupAttributesRequest;
+import software.amazon.awssdk.services.sesv2.model.PutDedicatedIpInPoolRequest;
+import software.amazon.awssdk.services.sesv2.model.PutDedicatedIpPoolScalingAttributesRequest;
+import software.amazon.awssdk.services.sesv2.model.PutDedicatedIpWarmupAttributesRequest;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
@@ -130,4 +137,98 @@ class SesDedicatedIpPoolTest {
DeleteDedicatedIpPoolRequest.builder().poolName("compat-pool-ghost").build()))
.isInstanceOf(NotFoundException.class);
}
+
+ // ─────────────── IP-level / scaling / account warmup ───────────────
+
+ private static final String TEST_IP = "192.0.2.1";
+
+ @Test
+ @Order(9)
+ void getDedicatedIps_empty() {
+ assertThat(sesV2.getDedicatedIps(GetDedicatedIpsRequest.builder().build()).dedicatedIps())
+ .isEmpty();
+ }
+
+ @Test
+ @Order(10)
+ void getDedicatedIp_throwsNotFound() {
+ assertThatThrownBy(() -> sesV2.getDedicatedIp(
+ GetDedicatedIpRequest.builder().ip(TEST_IP).build()))
+ .isInstanceOf(NotFoundException.class);
+ }
+
+ @Test
+ @Order(11)
+ void putDedicatedIpInPool_throwsNotFound() {
+ String pool = "compat-pool-scaling";
+ // Pre-clean like the class-level pools: an interrupted earlier run may have left it behind.
+ deletePoolQuietly(pool);
+ sesV2.createDedicatedIpPool(CreateDedicatedIpPoolRequest.builder().poolName(pool).build());
+ try {
+ assertThatThrownBy(() -> sesV2.putDedicatedIpInPool(PutDedicatedIpInPoolRequest.builder()
+ .ip(TEST_IP).destinationPoolName(pool).build()))
+ .isInstanceOf(NotFoundException.class);
+
+ // Switching the pool's scaling mode is the only IP-level operation that
+ // mutates state (no IPs exist to manage).
+ sesV2.putDedicatedIpPoolScalingAttributes(PutDedicatedIpPoolScalingAttributesRequest.builder()
+ .poolName(pool).scalingMode("MANAGED").build());
+ assertThat(sesV2.getDedicatedIpPool(GetDedicatedIpPoolRequest.builder().poolName(pool).build())
+ .dedicatedIpPool().scalingModeAsString()).isEqualTo("MANAGED");
+ } finally {
+ sesV2.deleteDedicatedIpPool(DeleteDedicatedIpPoolRequest.builder().poolName(pool).build());
+ }
+ }
+
+ @Test
+ @Order(12)
+ void putDedicatedIpWarmupAttributes_throwsNotFound() {
+ assertThatThrownBy(() -> sesV2.putDedicatedIpWarmupAttributes(
+ PutDedicatedIpWarmupAttributesRequest.builder().ip(TEST_IP).warmupPercentage(50).build()))
+ .isInstanceOf(NotFoundException.class);
+ }
+
+ @Test
+ @Order(13)
+ void putDedicatedIpPoolScalingAttributes_managedToStandard_throwsBadRequest() {
+ String pool = "compat-pool-downgrade";
+ deletePoolQuietly(pool);
+ sesV2.createDedicatedIpPool(CreateDedicatedIpPoolRequest.builder().poolName(pool).build());
+ try {
+ sesV2.putDedicatedIpPoolScalingAttributes(PutDedicatedIpPoolScalingAttributesRequest.builder()
+ .poolName(pool).scalingMode("MANAGED").build());
+ assertThatThrownBy(() -> sesV2.putDedicatedIpPoolScalingAttributes(
+ PutDedicatedIpPoolScalingAttributesRequest.builder()
+ .poolName(pool).scalingMode("STANDARD").build()))
+ .isInstanceOf(BadRequestException.class);
+ } finally {
+ sesV2.deleteDedicatedIpPool(DeleteDedicatedIpPoolRequest.builder().poolName(pool).build());
+ }
+ }
+
+ @Test
+ @Order(14)
+ void putDedicatedIpWarmupAttributes_outOfRange_throwsBadRequest() {
+ // Range is enforced before the IP lookup, so an out-of-range value is a BadRequestException
+ // rather than the IP NotFoundException.
+ assertThatThrownBy(() -> sesV2.putDedicatedIpWarmupAttributes(
+ PutDedicatedIpWarmupAttributesRequest.builder().ip(TEST_IP).warmupPercentage(150).build()))
+ .isInstanceOf(BadRequestException.class);
+ }
+
+ @Test
+ @Order(15)
+ void accountDedicatedIpAutoWarmup_togglable() {
+ boolean original = sesV2.getAccount(GetAccountRequest.builder().build())
+ .dedicatedIpAutoWarmupEnabled();
+ try {
+ sesV2.putAccountDedicatedIpWarmupAttributes(PutAccountDedicatedIpWarmupAttributesRequest.builder()
+ .autoWarmupEnabled(false).build());
+ assertThat(sesV2.getAccount(GetAccountRequest.builder().build()).dedicatedIpAutoWarmupEnabled())
+ .isFalse();
+ } finally {
+ sesV2.putAccountDedicatedIpWarmupAttributes(PutAccountDedicatedIpWarmupAttributesRequest.builder()
+ .autoWarmupEnabled(original).build());
+ }
+ }
}
diff --git a/docs/services/ses.md b/docs/services/ses.md
index 1e749f0a86..299b13b816 100644
--- a/docs/services/ses.md
+++ b/docs/services/ses.md
@@ -260,6 +260,12 @@ Alongside the classic Query API, Floci implements a subset of the SES v2 REST JS
| `GET` | `/v2/email/dedicated-ip-pools` | `ListDedicatedIpPools` |
| `GET` | `/v2/email/dedicated-ip-pools/{PoolName}` | `GetDedicatedIpPool` |
| `DELETE` | `/v2/email/dedicated-ip-pools/{PoolName}` | `DeleteDedicatedIpPool` |
+| `PUT` | `/v2/email/dedicated-ip-pools/{PoolName}/scaling` | `PutDedicatedIpPoolScalingAttributes` |
+| `GET` | `/v2/email/dedicated-ips` | `GetDedicatedIps` |
+| `GET` | `/v2/email/dedicated-ips/{IP}` | `GetDedicatedIp` |
+| `PUT` | `/v2/email/dedicated-ips/{IP}/pool` | `PutDedicatedIpInPool` |
+| `PUT` | `/v2/email/dedicated-ips/{IP}/warmup` | `PutDedicatedIpWarmupAttributes` |
+| `PUT` | `/v2/email/account/dedicated-ips/warmup` | `PutAccountDedicatedIpWarmupAttributes` |
| `POST` | `/v2/email/contact-lists` | `CreateContactList` |
| `GET` | `/v2/email/contact-lists` | `ListContactLists` |
| `GET` | `/v2/email/contact-lists/{ContactListName}` | `GetContactList` |
@@ -278,6 +284,8 @@ Alongside the classic Query API, Floci implements a subset of the SES v2 REST JS
| `DELETE` | `/v2/email/tags?ResourceArn=...&TagKeys=...` | `UntagResource` |
| `GET` | `/v2/email/tags?ResourceArn=...` | `ListTagsForResource` |
+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`).
+
Configuration set event destinations are stored as configuration. The target is not validated for existence; missing targets cause Floci to log a warning and skip that destination. Each event destination must specify exactly one destination type and at least one matching event type. A CloudWatch destination requires a non-empty dimension configuration list, and a Pinpoint destination requires an application ARN.
Floci publishes SES events to `SnsDestination`, `KinesisFirehoseDestination`, `EventBridgeDestination`, and `CloudWatchDestination`. `PinpointDestination` logs a warning and skips. The published payload follows the [AWS SES SNS notification format](https://docs.aws.amazon.com/ses/latest/dg/event-publishing-retrieving-sns-contents.html) with an outer `eventType` plus `mail` and event-type-specific blocks. Events fire whenever a configuration set has at least one event destination matching the event type — disable per-destination via `EventDestination.Enabled=false`, or remove the destination entirely.
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.java
index b57761c158..a4c50d32d1 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
@@ -64,6 +64,14 @@ public class SesAccountService {
LOG.infov("Updated account sending enabled for region {0}: {1}", region, enabled);
}
+ public boolean isDedicatedIpAutoWarmupEnabled(String region) {
+ return accountSettingsStore.get("dedicatedIpAutoWarmup::" + region).orElse(true);
+ }
+
+ public void setDedicatedIpAutoWarmup(String region, boolean enabled) {
+ accountSettingsStore.put("dedicatedIpAutoWarmup::" + region, enabled);
+ }
+
// VDM (Virtual Deliverability Manager) is opt-in and per region: GetAccount omits VdmAttributes
// entirely until PutAccountVdmAttributes is called for the region, so this returns empty when the
// region was never configured. The whole tuple is stored under one region key so GetAccount never
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.java
index 12fb5a0aa7..bf6befb4a7 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
@@ -1881,6 +1881,36 @@ public class SesController {
return Response.ok(result).build();
}
+ @PUT
+ @Path("/dedicated-ip-pools/{poolName}/scaling")
+ public Response putDedicatedIpPoolScalingAttributes(@Context HttpHeaders headers,
+ @PathParam("poolName") String poolName,
+ String body) {
+ String region = regionResolver.resolveRegion(headers);
+ try {
+ JsonNode request = readOptionBody(body);
+ String scalingMode = parseOptionString(request.path("ScalingMode"), "ScalingMode");
+ sesService.putDedicatedIpPoolScalingAttributes(poolName, scalingMode, region);
+ LOG.infov("SES V2 PutDedicatedIpPoolScalingAttributes on {0}", poolName);
+ return Response.ok(objectMapper.createObjectNode()).build();
+ } catch (AwsException e) {
+ throw remapV1Exception(e);
+ }
+ }
+
+ // ──────────────────────── Dedicated IPs (IP-level) ────────────────────────
+
+ @GET
+ @Path("/dedicated-ips")
+ public Response getDedicatedIps(@Context HttpHeaders headers) {
+ regionResolver.resolveRegion(headers);
+ // Floci does not model leased dedicated IPs, so the account has none.
+ ObjectNode result = objectMapper.createObjectNode();
+ result.putArray("DedicatedIps");
+ result.putNull("NextToken");
+ return Response.ok(result).build();
+ }
+
@GET
@Path("/contact-lists/{contactListName}")
public Response getContactList(@Context HttpHeaders headers,
@@ -2160,6 +2190,59 @@ public class SesController {
return result;
}
+ @GET
+ @Path("/dedicated-ips/{ip}")
+ public Response getDedicatedIp(@Context HttpHeaders headers, @PathParam("ip") String ip) {
+ String region = regionResolver.resolveRegion(headers);
+ sesService.getDedicatedIp(ip, region);
+ return Response.ok(objectMapper.createObjectNode()).build();
+ }
+
+ @PUT
+ @Path("/dedicated-ips/{ip}/pool")
+ public Response putDedicatedIpInPool(@Context HttpHeaders headers,
+ @PathParam("ip") String ip, String body) {
+ String region = regionResolver.resolveRegion(headers);
+ try {
+ JsonNode request = readOptionBody(body);
+ String destinationPoolName = parseOptionString(
+ request.path("DestinationPoolName"), "DestinationPoolName");
+ sesService.putDedicatedIpInPool(ip, destinationPoolName, region);
+ LOG.infov("SES V2 PutDedicatedIpInPool: {0}", ip);
+ return Response.ok(objectMapper.createObjectNode()).build();
+ } catch (AwsException e) {
+ throw remapV1Exception(e);
+ }
+ }
+
+ @PUT
+ @Path("/dedicated-ips/{ip}/warmup")
+ public Response putDedicatedIpWarmupAttributes(@Context HttpHeaders headers,
+ @PathParam("ip") String ip, String body) {
+ String region = regionResolver.resolveRegion(headers);
+ try {
+ JsonNode request = readOptionBody(body);
+ sesService.putDedicatedIpWarmupAttributes(ip,
+ parseWarmupPercentage(request.path("WarmupPercentage")), region);
+ LOG.infov("SES V2 PutDedicatedIpWarmupAttributes: {0}", ip);
+ return Response.ok(objectMapper.createObjectNode()).build();
+ } catch (AwsException e) {
+ throw remapV1Exception(e);
+ }
+ }
+
+ // JSON-layer concern only: a non-integer WarmupPercentage is a SerializationException,
+ // matching AWS. Required/range validation lives in the service.
+ private static Integer parseWarmupPercentage(JsonNode node) {
+ if (node.isMissingNode() || node.isNull()) {
+ return null;
+ }
+ if (!node.isInt()) {
+ throw new AwsException("SerializationException", null, 400);
+ }
+ return node.intValue();
+ }
+
// ──────────────────────────── Account ────────────────────────────
@GET
@@ -2171,7 +2254,7 @@ public class SesController {
AccountSuppressionAttributes suppression = sesService.getAccountSuppressionAttributes(region);
ObjectNode result = objectMapper.createObjectNode();
- result.put("DedicatedIpAutoWarmupEnabled", false);
+ result.put("DedicatedIpAutoWarmupEnabled", sesService.isAccountDedicatedIpAutoWarmupEnabled(region));
result.put("EnforcementStatus", "HEALTHY");
result.put("ProductionAccessEnabled", true);
result.put("SendingEnabled", sendingEnabled);
@@ -2373,6 +2456,25 @@ public class SesController {
400);
}
+ @PUT
+ @Path("/account/dedicated-ips/warmup")
+ public Response putAccountDedicatedIpWarmupAttributes(@Context HttpHeaders headers, String body) {
+ String region = regionResolver.resolveRegion(headers);
+ try {
+ JsonNode request = readOptionBody(body);
+ JsonNode enabledNode = request.path("AutoWarmupEnabled");
+ // AutoWarmupEnabled has a default of false: the SDK omits it when false, so a missing
+ // member is treated as false rather than rejected. A present value goes through the
+ // shared SES v2 boolean coercion (string→true, null/number/container→SerializationException).
+ boolean enabled = enabledNode.isMissingNode() ? false : coerceBoolean(enabledNode);
+ sesService.setAccountDedicatedIpAutoWarmup(region, enabled);
+ LOG.infov("SES V2 PutAccountDedicatedIpWarmupAttributes: {0}", enabled);
+ return Response.ok(objectMapper.createObjectNode()).build();
+ } catch (AwsException e) {
+ throw remapV1Exception(e);
+ }
+ }
+
@PUT
@Path("/account/suppression")
public Response putAccountSuppressionAttributes(@Context HttpHeaders headers, String body) {
diff --git a/src/main/java/io/github/hectorvent/floci/services/ses/SesDedicatedIpService.java b/src/main/java/io/github/hectorvent/floci/services/ses/SesDedicatedIpService.java
index 855b56033c..c374312d8b 100644
--- a/src/main/java/io/github/hectorvent/floci/services/ses/SesDedicatedIpService.java
+++ b/src/main/java/io/github/hectorvent/floci/services/ses/SesDedicatedIpService.java
@@ -30,8 +30,9 @@ public class SesDedicatedIpService {
private static final Set<String> SCALING_MODES = Set.of("STANDARD", "MANAGED");
private final StorageBackend<String, DedicatedIpPool> dedicatedIpPoolStore;
- // Serializes pool check-then-write mutations (create/delete/tag) so concurrent creates for the
- // same name can't both succeed and tagging can't resurrect a concurrently deleted pool.
+ // Serializes pool check-then-write mutations (create/delete/tag/scaling) so concurrent creates
+ // for the same name can't both succeed and tagging or scaling can't resurrect a concurrently
+ // deleted pool.
private final Object poolMutationLock = new Object();
@Inject
@@ -141,6 +142,69 @@ public class SesDedicatedIpService {
"No DedicatedIpPool present with name: " + poolName, 404);
}
+ // ──────────────────────── Dedicated IPs (IP-level) ────────────────────────
+ //
+ // SES has no API to create a dedicated IP: they are leased out-of-band
+ // (STANDARD) or auto-provisioned by AWS (MANAGED). Floci does not model that,
+ // so an account has no dedicated IPs: GetDedicatedIps is empty and any
+ // IP-targeted operation reports the IP as not found, matching real AWS for an
+ // account with no leased IPs (verified 2026-06-21).
+
+ private AwsException dedicatedIpNotFound(String ip) {
+ return new AwsException("NotFoundException",
+ "Could not find dedicated IP <" + ip + "> under this account.", 404);
+ }
+
+ public void getDedicatedIp(String ip, String region) {
+ // Unconditional, hence void: the account holds no dedicated IPs (see the section note
+ // above), so the lookup can only fail, the way real AWS answers with no leased IPs.
+ throw dedicatedIpNotFound(ip);
+ }
+
+ public void putDedicatedIpInPool(String ip, String destinationPoolName, String region) {
+ // AWS validates the required DestinationPoolName before it checks the IP.
+ if (destinationPoolName == null || destinationPoolName.isBlank()) {
+ throw new AwsException("BadRequestException", "Pool name can't be blank.", 400);
+ }
+ // AWS checks the IP before the destination pool.
+ throw dedicatedIpNotFound(ip);
+ }
+
+ // WarmupPercentage is a required integer in 0..100 (AWS returns -1 only in responses, for
+ // managed pools). AWS validates it before it looks up the IP; a non-integer value is a
+ // SerializationException raised at the controller's JSON layer before reaching here.
+ public void putDedicatedIpWarmupAttributes(String ip, Integer warmupPercentage, String region) {
+ if (warmupPercentage == null) {
+ throw new AwsException("BadRequestException", "Warmup Percentage can't be null.", 400);
+ }
+ if (warmupPercentage < 0 || warmupPercentage > 100) {
+ throw new AwsException("BadRequestException",
+ "Warmup Percentage must be between 0 and 100.", 400);
+ }
+ throw dedicatedIpNotFound(ip);
+ }
+
+ public void putDedicatedIpPoolScalingAttributes(String poolName, String scalingMode, String region) {
+ // AWS validates ScalingMode before it checks that the pool exists.
+ if (scalingMode == null || !SCALING_MODES.contains(scalingMode)) {
+ throw new AwsException("BadRequestException", "The ScalingMode parameter is invalid.", 400);
+ }
+ String key = dedicatedIpPoolKey(region, poolName);
+ synchronized (poolMutationLock) {
+ DedicatedIpPool pool = dedicatedIpPoolStore.get(key)
+ .orElseThrow(() -> new AwsException("NotFoundException",
+ "The requested pool <" + poolName + "> does not exist.", 404));
+ // AWS rejects downgrading a MANAGED pool back to STANDARD.
+ if ("MANAGED".equals(pool.getScalingMode()) && "STANDARD".equals(scalingMode)) {
+ throw new AwsException("BadRequestException", "The ScalingMode parameter is invalid.", 400);
+ }
+ pool.setScalingMode(scalingMode);
+ dedicatedIpPoolStore.put(key, pool);
+ }
+ LOG.infov("Updated ScalingMode on dedicated IP pool {0} in region {1}: {2}",
+ poolName, region, scalingMode);
+ }
+
private static String dedicatedIpPoolKey(String region, String name) {
return "dedicatedIpPool::" + region + "::" + name;
}
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.java
index 1baabe80db..bbfe862875 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
@@ -1338,6 +1338,34 @@ public class SesService {
+ // Dedicated IPs (IP-level) and pool scaling live in SesDedicatedIpService; the facade forwards.
+
+ public void getDedicatedIp(String ip, String region) {
+ dedicatedIpService.getDedicatedIp(ip, region);
+ }
+
+ public void putDedicatedIpInPool(String ip, String destinationPoolName, String region) {
+ dedicatedIpService.putDedicatedIpInPool(ip, destinationPoolName, region);
+ }
+
+ public void putDedicatedIpWarmupAttributes(String ip, Integer warmupPercentage, String region) {
+ dedicatedIpService.putDedicatedIpWarmupAttributes(ip, warmupPercentage, region);
+ }
+
+ public void putDedicatedIpPoolScalingAttributes(String poolName, String scalingMode, String region) {
+ dedicatedIpService.putDedicatedIpPoolScalingAttributes(poolName, scalingMode, region);
+ }
+
+ // Dedicated-IP auto-warmup is an account-level setting owned by SesAccountService.
+
+ public boolean isAccountDedicatedIpAutoWarmupEnabled(String region) {
+ return accountService.isDedicatedIpAutoWarmupEnabled(region);
+ }
+
+ public void setAccountDedicatedIpAutoWarmup(String region, boolean enabled) {
+ accountService.setDedicatedIpAutoWarmup(region, enabled);
+ }
+
public void createConfigurationSetEventDestination(String configSetName, String eventDestinationName,
EventDestination dest, String region) {
configSetService.createEventDestination(configSetName, eventDestinationName, dest, region);
diff --git a/src/test/java/io/github/hectorvent/floci/services/ses/SesAccountServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/ses/SesAccountServiceTest.java
index 804f7164b6..55a88b6464 100644
--- a/src/test/java/io/github/hectorvent/floci/services/ses/SesAccountServiceTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/ses/SesAccountServiceTest.java
@@ -90,4 +90,13 @@ class SesAccountServiceTest {
assertThrows(AwsException.class, () -> service.putAccountDetails(REGION, null,
null, null, null, null, false));
}
+
+ @Test
+ void dedicatedIpAutoWarmup_defaultsTrue_thenRoundTrips() {
+ assertTrue(service.isDedicatedIpAutoWarmupEnabled(REGION));
+
+ service.setDedicatedIpAutoWarmup(REGION, false);
+ assertFalse(service.isDedicatedIpAutoWarmupEnabled(REGION));
+ assertTrue(service.isDedicatedIpAutoWarmupEnabled("eu-west-1"));
+ }
}
diff --git a/src/test/java/io/github/hectorvent/floci/services/ses/SesDedicatedIpServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/ses/SesDedicatedIpServiceTest.java
index 197092f4fb..64db2dab0d 100644
--- a/src/test/java/io/github/hectorvent/floci/services/ses/SesDedicatedIpServiceTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/ses/SesDedicatedIpServiceTest.java
@@ -118,4 +118,53 @@ class SesDedicatedIpServiceTest {
void delete_missingThrows() {
assertThrows(AwsException.class, () -> service.deleteDedicatedIpPool("ghost", REGION));
}
+
+ @Test
+ void ipLevelOperations_reportIpNotFound() {
+ // Floci models no leased dedicated IPs, so every IP-targeted op reports not-found.
+ assertThrows(AwsException.class, () -> service.getDedicatedIp("1.2.3.4", REGION));
+ assertThrows(AwsException.class, () -> service.putDedicatedIpInPool("1.2.3.4", "pool-a", REGION));
+ assertThrows(AwsException.class, () -> service.putDedicatedIpWarmupAttributes("1.2.3.4", 50, REGION));
+ }
+
+ @Test
+ void putWarmupAttributes_validatesPercentageBeforeIp() {
+ // Required and range checks fire before the IP lookup, matching AWS precedence.
+ AwsException missing = assertThrows(AwsException.class,
+ () -> service.putDedicatedIpWarmupAttributes("1.2.3.4", null, REGION));
+ assertEquals("Warmup Percentage can't be null.", missing.getMessage());
+
+ AwsException outOfRange = assertThrows(AwsException.class,
+ () -> service.putDedicatedIpWarmupAttributes("1.2.3.4", 101, REGION));
+ assertEquals("Warmup Percentage must be between 0 and 100.", outOfRange.getMessage());
+ }
+
+ @Test
+ void putDedicatedIpInPool_validatesBlankDestinationBeforeIp() {
+ assertThrows(AwsException.class, () -> service.putDedicatedIpInPool("1.2.3.4", " ", REGION));
+ }
+
+ @Test
+ void putScalingAttributes_rejectsInvalidMode() {
+ service.createDedicatedIpPool("pool-a", "STANDARD", null, REGION);
+ assertThrows(AwsException.class,
+ () -> service.putDedicatedIpPoolScalingAttributes("pool-a", "TURBO", REGION));
+ }
+
+ @Test
+ void putScalingAttributes_missingPoolThrows() {
+ assertThrows(AwsException.class,
+ () -> service.putDedicatedIpPoolScalingAttributes("ghost", "MANAGED", REGION));
+ }
+
+ @Test
+ void putScalingAttributes_upgradesStandardToManaged_thenRejectsDowngrade() {
+ service.createDedicatedIpPool("pool-a", "STANDARD", null, REGION);
+
+ service.putDedicatedIpPoolScalingAttributes("pool-a", "MANAGED", REGION);
+ assertEquals("MANAGED", service.getDedicatedIpPool("pool-a", REGION).getScalingMode());
+
+ assertThrows(AwsException.class,
+ () -> service.putDedicatedIpPoolScalingAttributes("pool-a", "STANDARD", REGION));
+ }
}
diff --git a/src/test/java/io/github/hectorvent/floci/services/ses/SesDedicatedIpV2IntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/ses/SesDedicatedIpV2IntegrationTest.java
new file mode 100644
index 0000000000..330944faaa
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/ses/SesDedicatedIpV2IntegrationTest.java
@@ -0,0 +1,232 @@
+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;
+
+/**
+ * Integration tests for the SES V2 dedicated-IP (IP-level) endpoints. Floci does
+ * not model leased dedicated IPs, so an account has none: GetDedicatedIps is
+ * empty and any IP-targeted operation reports the IP as not found, matching real
+ * AWS for an account with no leased IPs.
+ */
+@QuarkusTest
+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+class SesDedicatedIpV2IntegrationTest {
+
+ private static final String AUTH_HEADER =
+ "AWS4-HMAC-SHA256 Credential=AKID/20260101/us-east-1/ses/aws4_request";
+ private static final String TEST_IP = "192.0.2.1";
+
+ @Test
+ @Order(1)
+ void getDedicatedIps_empty() {
+ given().header("Authorization", AUTH_HEADER)
+ .when().get("/v2/email/dedicated-ips")
+ .then().statusCode(200)
+ .body("DedicatedIps", hasSize(0));
+ }
+
+ @Test
+ @Order(2)
+ void getDedicatedIp_notFound() {
+ given().header("Authorization", AUTH_HEADER)
+ .when().get("/v2/email/dedicated-ips/" + TEST_IP)
+ .then().statusCode(404)
+ .body("__type", equalTo("NotFoundException"))
+ .body("message", equalTo("Could not find dedicated IP <" + TEST_IP + "> under this account."));
+ }
+
+ @Test
+ @Order(3)
+ void putDedicatedIpInPool_ipNotFound() {
+ // Even with an existing destination pool, the IP is checked first.
+ given().contentType("application/json").header("Authorization", AUTH_HEADER)
+ .body("{\"PoolName\": \"dip-scaling-pool\"}")
+ .when().post("/v2/email/dedicated-ip-pools").then().statusCode(200);
+ given().contentType("application/json").header("Authorization", AUTH_HEADER)
+ .body("{\"DestinationPoolName\": \"dip-scaling-pool\"}")
+ .when().put("/v2/email/dedicated-ips/" + TEST_IP + "/pool")
+ .then().statusCode(404)
+ .body("__type", equalTo("NotFoundException"))
+ .body("message", equalTo("Could not find dedicated IP <" + TEST_IP + "> under this account."));
+ }
+
+ @Test
+ @Order(4)
+ void putDedicatedIpWarmupAttributes_ipNotFound() {
+ given().contentType("application/json").header("Authorization", AUTH_HEADER)
+ .body("{\"WarmupPercentage\": 50}")
+ .when().put("/v2/email/dedicated-ips/" + TEST_IP + "/warmup")
+ .then().statusCode(404)
+ .body("__type", equalTo("NotFoundException"))
+ .body("message", equalTo("Could not find dedicated IP <" + TEST_IP + "> under this account."));
+ }
+
+ @Test
+ @Order(5)
+ void putDedicatedIpPoolScalingAttributes_updatesPool() {
+ // The pool from Order 3 starts STANDARD; switch it to MANAGED.
+ given().contentType("application/json").header("Authorization", AUTH_HEADER)
+ .body("{\"ScalingMode\": \"MANAGED\"}")
+ .when().put("/v2/email/dedicated-ip-pools/dip-scaling-pool/scaling")
+ .then().statusCode(200);
+ given().header("Authorization", AUTH_HEADER)
+ .when().get("/v2/email/dedicated-ip-pools/dip-scaling-pool")
+ .then().statusCode(200)
+ .body("DedicatedIpPool.ScalingMode", equalTo("MANAGED"));
+ }
+
+ @Test
+ @Order(6)
+ void putDedicatedIpPoolScalingAttributes_invalidMode_returns400() {
+ given().contentType("application/json").header("Authorization", AUTH_HEADER)
+ .body("{\"ScalingMode\": \"NONSENSE\"}")
+ .when().put("/v2/email/dedicated-ip-pools/dip-scaling-pool/scaling")
+ .then().statusCode(400)
+ .body("__type", equalTo("BadRequestException"))
+ .body("message", equalTo("The ScalingMode parameter is invalid."));
+ }
+
+ @Test
+ @Order(7)
+ void putDedicatedIpPoolScalingAttributes_unknownPool_returns404() {
+ given().contentType("application/json").header("Authorization", AUTH_HEADER)
+ .body("{\"ScalingMode\": \"STANDARD\"}")
+ .when().put("/v2/email/dedicated-ip-pools/dip-ghost-pool/scaling")
+ .then().statusCode(404)
+ .body("__type", equalTo("NotFoundException"))
+ .body("message", equalTo("The requested pool <dip-ghost-pool> does not exist."));
+ }
+
+ @Test
+ @Order(8)
+ void accountDedicatedIpAutoWarmup_defaultsTrue_andTogglable() {
+ given().header("Authorization", AUTH_HEADER)
+ .when().get("/v2/email/account")
+ .then().statusCode(200)
+ .body("DedicatedIpAutoWarmupEnabled", equalTo(true));
+
+ given().contentType("application/json").header("Authorization", AUTH_HEADER)
+ .body("{\"AutoWarmupEnabled\": false}")
+ .when().put("/v2/email/account/dedicated-ips/warmup")
+ .then().statusCode(200);
+
+ given().header("Authorization", AUTH_HEADER)
+ .when().get("/v2/email/account")
+ .then().statusCode(200)
+ .body("DedicatedIpAutoWarmupEnabled", equalTo(false));
+ }
+
+ @Test
+ @Order(9)
+ void putDedicatedIpInPool_missingDestinationPoolName_returns400() {
+ // A missing required member is validated before the IP lookup.
+ given().contentType("application/json").header("Authorization", AUTH_HEADER)
+ .body("{}")
+ .when().put("/v2/email/dedicated-ips/" + TEST_IP + "/pool")
+ .then().statusCode(400)
+ .body("__type", equalTo("BadRequestException"))
+ .body("message", equalTo("Pool name can't be blank."));
+ }
+
+ @Test
+ @Order(10)
+ void putDedicatedIpPoolScalingAttributes_missingModeUnknownPool_returns400() {
+ // ScalingMode is validated before the pool-existence check, so a missing mode on an
+ // unknown pool is a BadRequestException, not NotFoundException.
+ given().contentType("application/json").header("Authorization", AUTH_HEADER)
+ .body("{}")
+ .when().put("/v2/email/dedicated-ip-pools/dip-ghost-pool/scaling")
+ .then().statusCode(400)
+ .body("__type", equalTo("BadRequestException"))
+ .body("message", equalTo("The ScalingMode parameter is invalid."));
+ }
+
+ @Test
+ @Order(11)
+ void putDedicatedIpPoolScalingAttributes_managedToStandard_returns400() {
+ // dip-scaling-pool was switched to MANAGED in Order 5; AWS forbids downgrading to STANDARD.
+ given().contentType("application/json").header("Authorization", AUTH_HEADER)
+ .body("{\"ScalingMode\": \"STANDARD\"}")
+ .when().put("/v2/email/dedicated-ip-pools/dip-scaling-pool/scaling")
+ .then().statusCode(400)
+ .body("__type", equalTo("BadRequestException"))
+ .body("message", equalTo("The ScalingMode parameter is invalid."));
+ }
+
+ @Test
+ @Order(12)
+ void putDedicatedIpWarmupAttributes_missingPercentage_returns400() {
+ given().contentType("application/json").header("Authorization", AUTH_HEADER)
+ .body("{}")
+ .when().put("/v2/email/dedicated-ips/" + TEST_IP + "/warmup")
+ .then().statusCode(400)
+ .body("__type", equalTo("BadRequestException"))
+ .body("message", equalTo("Warmup Percentage can't be null."));
+ }
+
+ @Test
+ @Order(13)
+ void putDedicatedIpWarmupAttributes_outOfRange_returns400() {
+ given().contentType("application/json").header("Authorization", AUTH_HEADER)
+ .body("{\"WarmupPercentage\": 150}")
+ .when().put("/v2/email/dedicated-ips/" + TEST_IP + "/warmup")
+ .then().statusCode(400)
+ .body("__type", equalTo("BadRequestException"))
+ .body("message", equalTo("Warmup Percentage must be between 0 and 100."));
+ }
+
+ @Test
+ @Order(14)
+ void putDedicatedIpWarmupAttributes_nonInteger_returnsSerializationException() {
+ given().contentType("application/json").header("Authorization", AUTH_HEADER)
+ .body("{\"WarmupPercentage\": \"abc\"}")
+ .when().put("/v2/email/dedicated-ips/" + TEST_IP + "/warmup")
+ .then().statusCode(400)
+ .body("__type", equalTo("SerializationException"));
+ }
+
+ @Test
+ @Order(15)
+ void putAccountAutoWarmup_stringCoercesToTrue() {
+ // AWS's Jackson layer coerces a JSON string to true for SES v2 booleans.
+ given().contentType("application/json").header("Authorization", AUTH_HEADER)
+ .body("{\"AutoWarmupEnabled\": \"nonsense\"}")
+ .when().put("/v2/email/account/dedicated-ips/warmup")
+ .then().statusCode(200);
+
+ given().header("Authorization", AUTH_HEADER)
+ .when().get("/v2/email/account")
+ .then().statusCode(200)
+ .body("DedicatedIpAutoWarmupEnabled", equalTo(true));
+ }
+
+ @Test
+ @Order(16)
+ void putAccountAutoWarmup_explicitNull_returnsSerializationException() {
+ // Only an omitted member falls back to the @default(false); an explicit null does not.
+ given().contentType("application/json").header("Authorization", AUTH_HEADER)
+ .body("{\"AutoWarmupEnabled\": null}")
+ .when().put("/v2/email/account/dedicated-ips/warmup")
+ .then().statusCode(400)
+ .body("__type", equalTo("SerializationException"));
+ }
+
+ @Test
+ @Order(17)
+ void putAccountAutoWarmup_number_returnsSerializationException() {
+ given().contentType("application/json").header("Authorization", AUTH_HEADER)
+ .body("{\"AutoWarmupEnabled\": 1}")
+ .when().put("/v2/email/account/dedicated-ips/warmup")
+ .then().statusCode(400)
+ .body("__type", equalTo("SerializationException"))
+ .body("message", equalTo("NUMBER_VALUE can not be converted to a Boolean"));
+ }
+}