Skip to content

armgit / floci

Public Imported from GitHub
0

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

feat(ses): implement email template CRUD with stored, inline, and ARN variants (#573)

Kenshin Okinaka763ea379d7f8
diff --git a/README.md b/README.md
index b9b4d290b1..0f7a98f9c7 100644
--- a/README.md
+++ b/README.md
@@ -203,8 +203,8 @@ All default images are configurable via environment variables, useful for pinnin
| **EC2** | In-process | VPCs, subnets, security groups, instances, AMIs, key pairs, internet gateways, route tables, Elastic IPs, tags |
| **ACM** | In-process | Certificate issuance, validation lifecycle |
| **ECR** | In-process + **real OCI registry** | Repositories, image push / pull via stock `docker`, image-backed Lambda functions |
-| **SES** | In-process | Send email / raw email, identity verification, DKIM attributes |
-| **SES v2 (HTTP)** | In-process | REST JSON API, identities, DKIM, feedback attributes, account sending |
+| **SES** | In-process | Send email / raw email, identity verification, DKIM attributes, email templates with `{{var}}` substitution |
+| **SES v2 (HTTP)** | In-process | REST JSON API, identities, DKIM, feedback attributes, account sending, email templates with `{{var}}` substitution |
| **OpenSearch** | **Real Docker containers** | Domain CRUD, tags, versions, instance types, upgrade stubs |
| **AppConfig** | In-process | Applications, environments, profiles, hosted configuration versions, deployments |
| **AppConfigData** | In-process | Configuration sessions, dynamic configuration retrieval |
diff --git a/compatibility-tests/sdk-test-awscli/test/ses.bats b/compatibility-tests/sdk-test-awscli/test/ses.bats
index eca95ce032..a8a16b66c5 100644
--- a/compatibility-tests/sdk-test-awscli/test/ses.bats
+++ b/compatibility-tests/sdk-test-awscli/test/ses.bats
@@ -140,3 +140,97 @@ teardown_file() {
refute_output --partial "$TEST_EMAIL"
refute_output --partial "$TEST_DOMAIN"
}
+
+# ──────────────── Template CRUD ────────────────
+
+@test "SES: create template" {
+ local tpl_json
+ tpl_json=$(cat <<TMPL
+{"TemplateName":"cli-tpl-${BATS_ROOT_PID}","SubjectPart":"Hello {{name}}","TextPart":"Hi {{name}} from {{team}}","HtmlPart":"<p>Hi {{name}}</p>"}
+TMPL
+ )
+ run aws_cmd ses create-template --template "$tpl_json"
+ assert_success
+}
+
+@test "SES: create template - duplicate rejected" {
+ local tpl_json
+ tpl_json=$(cat <<TMPL
+{"TemplateName":"cli-tpl-${BATS_ROOT_PID}","SubjectPart":"Dup","TextPart":"Dup"}
+TMPL
+ )
+ run aws_cmd ses create-template --template "$tpl_json"
+ assert_failure
+ assert_output --partial "AlreadyExists"
+}
+
+@test "SES: get template" {
+ run aws_cmd ses get-template --template-name "cli-tpl-${BATS_ROOT_PID}"
+ assert_success
+ name=$(json_get "$output" '.Template.TemplateName')
+ subject=$(json_get "$output" '.Template.SubjectPart')
+ [ "$name" = "cli-tpl-${BATS_ROOT_PID}" ]
+ [ "$subject" = "Hello {{name}}" ]
+}
+
+@test "SES: get template - not found" {
+ run aws_cmd ses get-template --template-name "nonexistent-tpl"
+ assert_failure
+ assert_output --partial "TemplateDoesNotExist"
+}
+
+@test "SES: update template" {
+ local tpl_json
+ tpl_json=$(cat <<TMPL
+{"TemplateName":"cli-tpl-${BATS_ROOT_PID}","SubjectPart":"Updated {{name}}","TextPart":"Updated {{name}} {{team}}","HtmlPart":"<p>Updated {{name}}</p>"}
+TMPL
+ )
+ run aws_cmd ses update-template --template "$tpl_json"
+ assert_success
+
+ run aws_cmd ses get-template --template-name "cli-tpl-${BATS_ROOT_PID}"
+ assert_success
+ subject=$(json_get "$output" '.Template.SubjectPart')
+ [ "$subject" = "Updated {{name}}" ]
+}
+
+@test "SES: list templates includes created" {
+ run aws_cmd ses list-templates
+ assert_success
+ assert_output --partial "cli-tpl-${BATS_ROOT_PID}"
+}
+
+@test "SES: send templated email" {
+ # Ensure an identity exists for sending
+ aws_cmd ses verify-email-identity --email-address "[email protected]" >/dev/null 2>&1 || true
+
+ run aws_cmd ses send-templated-email \
+ --source "[email protected]" \
+ --destination "[email protected]" \
+ --template "cli-tpl-${BATS_ROOT_PID}" \
+ --template-data '{"name":"Alice","team":"floci"}'
+ assert_success
+ message_id=$(json_get "$output" '.MessageId')
+ [ -n "$message_id" ]
+}
+
+@test "SES: send templated email - unknown template" {
+ run aws_cmd ses send-templated-email \
+ --source "[email protected]" \
+ --destination "[email protected]" \
+ --template "nonexistent-tpl" \
+ --template-data '{}'
+ assert_failure
+ assert_output --partial "TemplateDoesNotExist"
+}
+
+@test "SES: delete template" {
+ run aws_cmd ses delete-template --template-name "cli-tpl-${BATS_ROOT_PID}"
+ assert_success
+}
+
+@test "SES: delete template - not found" {
+ run aws_cmd ses delete-template --template-name "nonexistent-tpl"
+ assert_failure
+ assert_output --partial "TemplateDoesNotExist"
+}
diff --git a/compatibility-tests/sdk-test-java/pom.xml b/compatibility-tests/sdk-test-java/pom.xml
index d62c677061..8ee55a5f03 100644
--- a/compatibility-tests/sdk-test-java/pom.xml
+++ b/compatibility-tests/sdk-test-java/pom.xml
@@ -174,6 +174,11 @@
<groupId>software.amazon.awssdk</groupId>
<artifactId>ses</artifactId>
</dependency>
+ <!-- SES V2 client -->
+ <dependency>
+ <groupId>software.amazon.awssdk</groupId>
+ <artifactId>sesv2</artifactId>
+ </dependency>
<!-- OpenSearch Service management client -->
<dependency>
<groupId>software.amazon.awssdk</groupId>
diff --git a/compatibility-tests/sdk-test-java/src/main/java/com/floci/test/TestFixtures.java b/compatibility-tests/sdk-test-java/src/main/java/com/floci/test/TestFixtures.java
index 1087f1fa25..b474e27097 100644
--- a/compatibility-tests/sdk-test-java/src/main/java/com/floci/test/TestFixtures.java
+++ b/compatibility-tests/sdk-test-java/src/main/java/com/floci/test/TestFixtures.java
@@ -21,6 +21,7 @@ import software.amazon.awssdk.services.s3control.S3ControlClient;
import software.amazon.awssdk.services.s3control.endpoints.S3ControlEndpointProvider;
import software.amazon.awssdk.services.secretsmanager.SecretsManagerClient;
import software.amazon.awssdk.services.ses.SesClient;
+import software.amazon.awssdk.services.sesv2.SesV2Client;
import software.amazon.awssdk.services.sfn.SfnClient;
import software.amazon.awssdk.services.sns.SnsClient;
import software.amazon.awssdk.services.sqs.SqsClient;
@@ -392,6 +393,14 @@ public final class TestFixtures {
.build();
}
+ public static SesV2Client sesV2Client() {
+ return SesV2Client.builder()
+ .endpointOverride(ENDPOINT)
+ .region(REGION)
+ .credentialsProvider(CREDENTIALS)
+ .build();
+ }
+
public static RdsClient rdsClient() {
return RdsClient.builder()
.endpointOverride(ENDPOINT)
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/SesTemplateTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/SesTemplateTest.java
new file mode 100644
index 0000000000..7b92166eff
--- /dev/null
+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/SesTemplateTest.java
@@ -0,0 +1,457 @@
+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.MethodOrderer;
+import org.junit.jupiter.api.Order;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
+
+import software.amazon.awssdk.awscore.exception.AwsServiceException;
+import software.amazon.awssdk.services.ses.SesClient;
+import software.amazon.awssdk.services.ses.model.CreateTemplateRequest;
+import software.amazon.awssdk.services.ses.model.DeleteIdentityRequest;
+import software.amazon.awssdk.services.ses.model.DeleteTemplateRequest;
+import software.amazon.awssdk.services.ses.model.GetTemplateRequest;
+import software.amazon.awssdk.services.ses.model.GetTemplateResponse;
+import software.amazon.awssdk.services.ses.model.ListTemplatesRequest;
+import software.amazon.awssdk.services.ses.model.ListTemplatesResponse;
+import software.amazon.awssdk.services.ses.model.SendTemplatedEmailRequest;
+import software.amazon.awssdk.services.ses.model.SendTemplatedEmailResponse;
+import software.amazon.awssdk.services.ses.model.UpdateTemplateRequest;
+import software.amazon.awssdk.services.ses.model.VerifyEmailIdentityRequest;
+
+import software.amazon.awssdk.services.sesv2.SesV2Client;
+import software.amazon.awssdk.services.sesv2.model.CreateEmailIdentityRequest;
+import software.amazon.awssdk.services.sesv2.model.CreateEmailTemplateRequest;
+import software.amazon.awssdk.services.sesv2.model.DeleteEmailIdentityRequest;
+import software.amazon.awssdk.services.sesv2.model.DeleteEmailTemplateRequest;
+import software.amazon.awssdk.services.sesv2.model.Destination;
+import software.amazon.awssdk.services.sesv2.model.EmailContent;
+import software.amazon.awssdk.services.sesv2.model.EmailTemplateContent;
+import software.amazon.awssdk.services.sesv2.model.GetEmailTemplateRequest;
+import software.amazon.awssdk.services.sesv2.model.GetEmailTemplateResponse;
+import software.amazon.awssdk.services.sesv2.model.ListEmailTemplatesRequest;
+import software.amazon.awssdk.services.sesv2.model.ListEmailTemplatesResponse;
+import software.amazon.awssdk.services.sesv2.model.SendEmailRequest;
+import software.amazon.awssdk.services.sesv2.model.SendEmailResponse;
+import software.amazon.awssdk.services.sesv2.model.Template;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+/**
+ * SES email template compatibility tests against both the V1 (query) SES API
+ * and the V2 (REST JSON) SESv2 API.
+ */
+@DisplayName("SES Email Templates")
+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+class SesTemplateTest {
+
+ private static SesClient sesV1;
+ private static SesV2Client sesV2;
+ private static String v1Template;
+ private static String v2Template;
+ private static String v1Sender;
+ private static String v2Sender;
+
+ @BeforeAll
+ static void setup() {
+ sesV1 = TestFixtures.sesClient();
+ sesV2 = TestFixtures.sesV2Client();
+ String suffix = TestFixtures.uniqueName();
+ v1Template = "sdk-v1-" + suffix;
+ v2Template = "sdk-v2-" + suffix;
+ v1Sender = suffix + "[email protected]";
+ v2Sender = suffix + "[email protected]";
+ }
+
+ @AfterAll
+ static void cleanup() {
+ if (sesV1 != null) {
+ safelyDeleteV1Template(v1Template);
+ try {
+ sesV1.deleteIdentity(DeleteIdentityRequest.builder()
+ .identity(v1Sender).build());
+ } catch (Exception ignored) {}
+ sesV1.close();
+ }
+ if (sesV2 != null) {
+ safelyDeleteV2Template(v2Template);
+ try {
+ sesV2.deleteEmailIdentity(DeleteEmailIdentityRequest.builder()
+ .emailIdentity(v2Sender).build());
+ } catch (Exception ignored) {}
+ sesV2.close();
+ }
+ }
+
+ // ────────────────────────────── V2 (SESv2) ──────────────────────────────
+
+ @Test
+ @Order(1)
+ void v2CreateAndGetTemplate() {
+ sesV2.createEmailTemplate(CreateEmailTemplateRequest.builder()
+ .templateName(v2Template)
+ .templateContent(EmailTemplateContent.builder()
+ .subject("Hello {{name}}")
+ .text("Hi {{name}}!")
+ .html("<p>Hi <b>{{name}}</b>!</p>")
+ .build())
+ .build());
+
+ GetEmailTemplateResponse response = sesV2.getEmailTemplate(
+ GetEmailTemplateRequest.builder().templateName(v2Template).build());
+ assertThat(response.templateName()).isEqualTo(v2Template);
+ assertThat(response.templateContent().subject()).isEqualTo("Hello {{name}}");
+ assertThat(response.templateContent().text()).isEqualTo("Hi {{name}}!");
+ assertThat(response.templateContent().html()).contains("{{name}}");
+ }
+
+ @Test
+ @Order(2)
+ void v2CreateDuplicateRejectedWith400() {
+ assertThatThrownBy(() -> sesV2.createEmailTemplate(CreateEmailTemplateRequest.builder()
+ .templateName(v2Template)
+ .templateContent(EmailTemplateContent.builder()
+ .subject("dup")
+ .text("dup")
+ .build())
+ .build()))
+ .isInstanceOf(AwsServiceException.class)
+ .extracting(e -> ((AwsServiceException) e).statusCode())
+ .isEqualTo(400);
+ }
+
+ @Test
+ @Order(3)
+ void v2GetNonExistentReturns404() {
+ assertThatThrownBy(() -> sesV2.getEmailTemplate(GetEmailTemplateRequest.builder()
+ .templateName("sdk-v2-missing-" + System.currentTimeMillis())
+ .build()))
+ .isInstanceOf(AwsServiceException.class)
+ .extracting(e -> ((AwsServiceException) e).statusCode())
+ .isEqualTo(404);
+ }
+
+ @Test
+ @Order(4)
+ void v2UpdateTemplate() {
+ sesV2.updateEmailTemplate(builder -> builder
+ .templateName(v2Template)
+ .templateContent(EmailTemplateContent.builder()
+ .subject("Welcome {{name}}!")
+ .text("Hello {{name}}, from {{team}}")
+ .html("<p>Welcome {{name}}</p>")
+ .build()));
+
+ GetEmailTemplateResponse response = sesV2.getEmailTemplate(
+ GetEmailTemplateRequest.builder().templateName(v2Template).build());
+ assertThat(response.templateContent().subject()).isEqualTo("Welcome {{name}}!");
+ assertThat(response.templateContent().text()).contains("{{team}}");
+ }
+
+ @Test
+ @Order(5)
+ void v2ListTemplatesIncludesCreated() {
+ ListEmailTemplatesResponse response = sesV2.listEmailTemplates(
+ ListEmailTemplatesRequest.builder().build());
+ assertThat(response.templatesMetadata())
+ .anyMatch(meta -> v2Template.equals(meta.templateName()));
+ }
+
+ @Test
+ @Order(6)
+ void v2SendEmailWithTemplateSubstitutesVariables() {
+ sesV2.createEmailIdentity(CreateEmailIdentityRequest.builder()
+ .emailIdentity(v2Sender).build());
+
+ SendEmailResponse response = sesV2.sendEmail(SendEmailRequest.builder()
+ .fromEmailAddress(v2Sender)
+ .destination(Destination.builder()
+ .toAddresses("[email protected]")
+ .build())
+ .content(EmailContent.builder()
+ .template(Template.builder()
+ .templateName(v2Template)
+ .templateData("{\"name\":\"Alice\",\"team\":\"floci\"}")
+ .build())
+ .build())
+ .build());
+ assertThat(response.messageId()).isNotBlank();
+ }
+
+ @Test
+ @Order(20)
+ void v2SendEmailWithInlineTemplateSubstitutesVariables() {
+ SendEmailResponse response = sesV2.sendEmail(SendEmailRequest.builder()
+ .fromEmailAddress(v2Sender)
+ .destination(Destination.builder()
+ .toAddresses("[email protected]")
+ .build())
+ .content(EmailContent.builder()
+ .template(Template.builder()
+ .templateContent(EmailTemplateContent.builder()
+ .subject("Inline {{name}}")
+ .text("Hello inline {{name}}")
+ .html("<p>Hello inline <b>{{name}}</b></p>")
+ .build())
+ .templateData("{\"name\":\"Alice\"}")
+ .build())
+ .build())
+ .build());
+ assertThat(response.messageId()).isNotBlank();
+ }
+
+ @Test
+ @Order(22)
+ void v2SendEmailWithTemplateArnResolvesStoredTemplate() {
+ String name = "sdk-v2-arn-" + TestFixtures.uniqueName();
+ try {
+ sesV2.createEmailTemplate(CreateEmailTemplateRequest.builder()
+ .templateName(name)
+ .templateContent(EmailTemplateContent.builder()
+ .subject("Hi {{name}}")
+ .text("Hello {{name}}")
+ .build())
+ .build());
+
+ SendEmailResponse response = sesV2.sendEmail(SendEmailRequest.builder()
+ .fromEmailAddress(v2Sender)
+ .destination(Destination.builder()
+ .toAddresses("[email protected]")
+ .build())
+ .content(EmailContent.builder()
+ .template(Template.builder()
+ .templateArn("arn:aws:ses:us-east-1:000000000000:template/" + name)
+ .templateData("{\"name\":\"Alice\"}")
+ .build())
+ .build())
+ .build());
+ assertThat(response.messageId()).isNotBlank();
+ } finally {
+ safelyDeleteV2Template(name);
+ }
+ }
+
+ @Test
+ @Order(21)
+ void v2SendEmailWithBothNameAndInlineReturns400() {
+ assertThatThrownBy(() -> sesV2.sendEmail(SendEmailRequest.builder()
+ .fromEmailAddress(v2Sender)
+ .destination(Destination.builder()
+ .toAddresses("[email protected]")
+ .build())
+ .content(EmailContent.builder()
+ .template(Template.builder()
+ .templateName(v2Template)
+ .templateContent(EmailTemplateContent.builder()
+ .subject("s")
+ .text("t")
+ .build())
+ .templateData("{}")
+ .build())
+ .build())
+ .build()))
+ .isInstanceOf(AwsServiceException.class)
+ .extracting(e -> ((AwsServiceException) e).statusCode())
+ .isEqualTo(400);
+ }
+
+ @Test
+ @Order(7)
+ void v2SendEmailWithUnknownTemplateReturns404() {
+ assertThatThrownBy(() -> sesV2.sendEmail(SendEmailRequest.builder()
+ .fromEmailAddress(v2Sender)
+ .destination(Destination.builder()
+ .toAddresses("[email protected]")
+ .build())
+ .content(EmailContent.builder()
+ .template(Template.builder()
+ .templateName("sdk-v2-missing-" + System.currentTimeMillis())
+ .templateData("{}")
+ .build())
+ .build())
+ .build()))
+ .isInstanceOf(AwsServiceException.class)
+ .extracting(e -> ((AwsServiceException) e).statusCode())
+ .isEqualTo(404);
+ }
+
+ @Test
+ @Order(8)
+ void v2DeleteTemplate() {
+ sesV2.deleteEmailTemplate(DeleteEmailTemplateRequest.builder()
+ .templateName(v2Template).build());
+
+ assertThatThrownBy(() -> sesV2.getEmailTemplate(GetEmailTemplateRequest.builder()
+ .templateName(v2Template).build()))
+ .isInstanceOf(AwsServiceException.class)
+ .extracting(e -> ((AwsServiceException) e).statusCode())
+ .isEqualTo(404);
+ }
+
+ // ────────────────────────────── V1 (SES) ──────────────────────────────
+
+ @Test
+ @Order(10)
+ void v1CreateAndGetTemplate() {
+ sesV1.createTemplate(CreateTemplateRequest.builder()
+ .template(software.amazon.awssdk.services.ses.model.Template.builder()
+ .templateName(v1Template)
+ .subjectPart("Hello {{name}}")
+ .textPart("Hi {{name}}!")
+ .htmlPart("<p>Hi <b>{{name}}</b>!</p>")
+ .build())
+ .build());
+
+ GetTemplateResponse response = sesV1.getTemplate(GetTemplateRequest.builder()
+ .templateName(v1Template).build());
+ software.amazon.awssdk.services.ses.model.Template template = response.template();
+ assertThat(template.templateName()).isEqualTo(v1Template);
+ assertThat(template.subjectPart()).isEqualTo("Hello {{name}}");
+ assertThat(template.textPart()).isEqualTo("Hi {{name}}!");
+ assertThat(template.htmlPart()).contains("{{name}}");
+ }
+
+ @Test
+ @Order(11)
+ void v1CreateDuplicateRejected() {
+ assertThatThrownBy(() -> sesV1.createTemplate(CreateTemplateRequest.builder()
+ .template(software.amazon.awssdk.services.ses.model.Template.builder()
+ .templateName(v1Template)
+ .subjectPart("dup")
+ .textPart("dup")
+ .build())
+ .build()))
+ .isInstanceOf(AwsServiceException.class)
+ .extracting(e -> ((AwsServiceException) e).statusCode())
+ .isEqualTo(400);
+ }
+
+ @Test
+ @Order(12)
+ void v1GetNonExistentRaises() {
+ assertThatThrownBy(() -> sesV1.getTemplate(GetTemplateRequest.builder()
+ .templateName("sdk-v1-missing-" + System.currentTimeMillis())
+ .build()))
+ .isInstanceOf(AwsServiceException.class)
+ .extracting(e -> ((AwsServiceException) e).statusCode())
+ .isEqualTo(400);
+ }
+
+ @Test
+ @Order(13)
+ void v1UpdateTemplate() {
+ sesV1.updateTemplate(UpdateTemplateRequest.builder()
+ .template(software.amazon.awssdk.services.ses.model.Template.builder()
+ .templateName(v1Template)
+ .subjectPart("Welcome {{name}}!")
+ .textPart("Hello {{name}}, from {{team}}")
+ .build())
+ .build());
+
+ GetTemplateResponse response = sesV1.getTemplate(GetTemplateRequest.builder()
+ .templateName(v1Template).build());
+ assertThat(response.template().subjectPart()).isEqualTo("Welcome {{name}}!");
+ assertThat(response.template().textPart()).contains("{{team}}");
+ }
+
+ @Test
+ @Order(14)
+ void v1ListTemplatesIncludesCreated() {
+ ListTemplatesResponse response = sesV1.listTemplates(ListTemplatesRequest.builder().build());
+ assertThat(response.templatesMetadata())
+ .anyMatch(meta -> v1Template.equals(meta.name()));
+ }
+
+ @Test
+ @Order(15)
+ void v1SendTemplatedEmail() {
+ sesV1.verifyEmailIdentity(VerifyEmailIdentityRequest.builder()
+ .emailAddress(v1Sender).build());
+
+ SendTemplatedEmailResponse response = sesV1.sendTemplatedEmail(
+ SendTemplatedEmailRequest.builder()
+ .source(v1Sender)
+ .destination(d -> d.toAddresses("[email protected]"))
+ .template(v1Template)
+ .templateData("{\"name\":\"Alice\",\"team\":\"floci\"}")
+ .build());
+ assertThat(response.messageId()).isNotBlank();
+ }
+
+ @Test
+ @Order(16)
+ void v1SendTemplatedEmailUnknownTemplateRaises() {
+ assertThatThrownBy(() -> sesV1.sendTemplatedEmail(SendTemplatedEmailRequest.builder()
+ .source(v1Sender)
+ .destination(d -> d.toAddresses("[email protected]"))
+ .template("sdk-v1-missing-" + System.currentTimeMillis())
+ .templateData("{}")
+ .build()))
+ .isInstanceOf(AwsServiceException.class)
+ .extracting(e -> ((AwsServiceException) e).statusCode())
+ .isEqualTo(400);
+ }
+
+ @Test
+ @Order(17)
+ void v1DeleteTemplate() {
+ sesV1.deleteTemplate(DeleteTemplateRequest.builder()
+ .templateName(v1Template).build());
+
+ assertThatThrownBy(() -> sesV1.getTemplate(GetTemplateRequest.builder()
+ .templateName(v1Template).build()))
+ .isInstanceOf(AwsServiceException.class)
+ .extracting(e -> ((AwsServiceException) e).statusCode())
+ .isEqualTo(400);
+ }
+
+ @Test
+ @Order(30)
+ void v1SendTemplatedEmailWithTemplateArnAndName() {
+ // boto3 and AWS Java SDK v2 both require the V1 Template (name) field on
+ // SendTemplatedEmail — TemplateArn is supplementary for cross-account
+ // addressing on real AWS. Floci accepts both and resolves via the name.
+ String name = "sdk-v1-arn-" + TestFixtures.uniqueName();
+ try {
+ sesV1.createTemplate(CreateTemplateRequest.builder()
+ .template(software.amazon.awssdk.services.ses.model.Template.builder()
+ .templateName(name)
+ .subjectPart("Hi {{name}}")
+ .textPart("Hello {{name}}")
+ .build())
+ .build());
+
+ SendTemplatedEmailResponse response = sesV1.sendTemplatedEmail(
+ SendTemplatedEmailRequest.builder()
+ .source(v1Sender)
+ .destination(d -> d.toAddresses("[email protected]"))
+ .template(name)
+ .templateArn("arn:aws:ses:us-east-1:000000000000:template/" + name)
+ .templateData("{\"name\":\"Alice\"}")
+ .build());
+ assertThat(response.messageId()).isNotBlank();
+ } finally {
+ safelyDeleteV1Template(name);
+ }
+ }
+
+ // ─────────────────────────────── Helpers ───────────────────────────────
+
+ private static void safelyDeleteV1Template(String name) {
+ try {
+ sesV1.deleteTemplate(DeleteTemplateRequest.builder()
+ .templateName(name).build());
+ } catch (Exception ignored) {}
+ }
+
+ private static void safelyDeleteV2Template(String name) {
+ try {
+ sesV2.deleteEmailTemplate(DeleteEmailTemplateRequest.builder()
+ .templateName(name).build());
+ } catch (Exception ignored) {}
+ }
+}
diff --git a/compatibility-tests/sdk-test-python/conftest.py b/compatibility-tests/sdk-test-python/conftest.py
index ed224e19c8..d06a5dc33f 100644
--- a/compatibility-tests/sdk-test-python/conftest.py
+++ b/compatibility-tests/sdk-test-python/conftest.py
@@ -151,6 +151,18 @@ def pipes_client(aws_config, client_config):
return boto3.client("pipes", config=client_config, **aws_config)
+def ses_client(aws_config, client_config):
+ """Create SES (v1) client."""
+ return boto3.client("ses", config=client_config, **aws_config)
+
+
+def sesv2_client(aws_config, client_config):
+ """Create SES v2 client."""
+ return boto3.client("sesv2", config=client_config, **aws_config)
+
+
# ============================================
# Utility Fixtures
# ============================================
diff --git a/compatibility-tests/sdk-test-python/tests/test_ses_templates.py b/compatibility-tests/sdk-test-python/tests/test_ses_templates.py
new file mode 100644
index 0000000000..7ef813826c
--- /dev/null
+++ b/compatibility-tests/sdk-test-python/tests/test_ses_templates.py
@@ -0,0 +1,481 @@
+"""SES email template SDK compatibility tests.
+
+Exercises both the V1 SES client (Query protocol) and the V2 SESv2 client
+(REST JSON protocol) via boto3, covering CRUD and templated send with
+Mustache-style variable substitution.
+"""
+
+import json
+
+import pytest
+from botocore.exceptions import ClientError
+
+
+# ============================================
+# SES V2 (sesv2) - REST JSON
+# ============================================
+
+
+class TestSesV2EmailTemplateCrud:
+ """Template CRUD via the SESv2 REST JSON API."""
+
+ def test_create_and_get_email_template(self, sesv2_client, unique_name):
+ name = f"pytest-tpl-{unique_name}"
+ try:
+ sesv2_client.create_email_template(
+ TemplateName=name,
+ TemplateContent={
+ "Subject": "Hello {{name}}",
+ "Text": "Hi {{name}}!",
+ "Html": "<p>Hi <b>{{name}}</b>!</p>",
+ },
+ )
+ response = sesv2_client.get_email_template(TemplateName=name)
+ assert response["TemplateName"] == name
+ assert response["TemplateContent"]["Subject"] == "Hello {{name}}"
+ assert response["TemplateContent"]["Text"] == "Hi {{name}}!"
+ assert "{{name}}" in response["TemplateContent"]["Html"]
+ finally:
+ _safe_delete_v2(sesv2_client, name)
+
+ def test_list_email_templates_includes_created(self, sesv2_client, unique_name):
+ name = f"pytest-tpl-{unique_name}"
+ try:
+ sesv2_client.create_email_template(
+ TemplateName=name,
+ TemplateContent={"Subject": "s", "Text": "t"},
+ )
+ response = sesv2_client.list_email_templates()
+ names = [t["TemplateName"] for t in response.get("TemplatesMetadata", [])]
+ assert name in names
+ finally:
+ _safe_delete_v2(sesv2_client, name)
+
+ def test_update_email_template(self, sesv2_client, unique_name):
+ name = f"pytest-tpl-{unique_name}"
+ try:
+ sesv2_client.create_email_template(
+ TemplateName=name,
+ TemplateContent={"Subject": "original", "Text": "original body"},
+ )
+ sesv2_client.update_email_template(
+ TemplateName=name,
+ TemplateContent={
+ "Subject": "updated {{who}}",
+ "Text": "updated body for {{who}}",
+ },
+ )
+ response = sesv2_client.get_email_template(TemplateName=name)
+ assert response["TemplateContent"]["Subject"] == "updated {{who}}"
+ assert "{{who}}" in response["TemplateContent"]["Text"]
+ finally:
+ _safe_delete_v2(sesv2_client, name)
+
+ def test_delete_email_template(self, sesv2_client, unique_name):
+ name = f"pytest-tpl-{unique_name}"
+ sesv2_client.create_email_template(
+ TemplateName=name,
+ TemplateContent={"Subject": "s", "Text": "t"},
+ )
+ sesv2_client.delete_email_template(TemplateName=name)
+ with pytest.raises(ClientError) as exc_info:
+ sesv2_client.get_email_template(TemplateName=name)
+ assert (
+ exc_info.value.response["ResponseMetadata"]["HTTPStatusCode"] == 404
+ )
+
+
+class TestSesV2EmailTemplateErrors:
+ """Error paths for V2 template operations."""
+
+ def test_create_duplicate_rejected(self, sesv2_client, unique_name):
+ name = f"pytest-tpl-{unique_name}"
+ try:
+ sesv2_client.create_email_template(
+ TemplateName=name,
+ TemplateContent={"Subject": "s", "Text": "t"},
+ )
+ with pytest.raises(ClientError) as exc_info:
+ sesv2_client.create_email_template(
+ TemplateName=name,
+ TemplateContent={"Subject": "dup", "Text": "dup"},
+ )
+ assert (
+ exc_info.value.response["ResponseMetadata"]["HTTPStatusCode"] == 400
+ )
+ finally:
+ _safe_delete_v2(sesv2_client, name)
+
+ def test_get_nonexistent(self, sesv2_client, unique_name):
+ with pytest.raises(ClientError) as exc_info:
+ sesv2_client.get_email_template(
+ TemplateName=f"pytest-missing-{unique_name}"
+ )
+ assert (
+ exc_info.value.response["ResponseMetadata"]["HTTPStatusCode"] == 404
+ )
+
+
+class TestSesV2SendTemplatedEmail:
+ """Content.Template substitution via SESv2 SendEmail."""
+
+ def test_send_email_substitutes_template_variables(
+ self, sesv2_client, unique_name
+ ):
+ template_name = f"pytest-tpl-{unique_name}"
+ sender = f"pytest-sender-{unique_name}@example.com"
+ recipient = f"pytest-recipient-{unique_name}@example.com"
+
+ try:
+ sesv2_client.create_email_identity(EmailIdentity=sender)
+ sesv2_client.create_email_template(
+ TemplateName=template_name,
+ TemplateContent={
+ "Subject": "Welcome {{name}}",
+ "Text": "Hello {{name}}, from {{team}}",
+ "Html": "<p>Welcome <b>{{name}}</b> ({{team}})</p>",
+ },
+ )
+
+ response = sesv2_client.send_email(
+ FromEmailAddress=sender,
+ Destination={"ToAddresses": [recipient]},
+ Content={
+ "Template": {
+ "TemplateName": template_name,
+ "TemplateData": json.dumps(
+ {"name": "Alice", "team": "floci"}
+ ),
+ }
+ },
+ )
+ assert response["MessageId"]
+ finally:
+ _safe_delete_v2(sesv2_client, template_name)
+ _safe_delete_identity_v2(sesv2_client, sender)
+
+ def test_send_email_with_inline_template_substitutes_variables(
+ self, sesv2_client, unique_name
+ ):
+ sender = f"pytest-inline-sender-{unique_name}@example.com"
+ try:
+ sesv2_client.create_email_identity(EmailIdentity=sender)
+ response = sesv2_client.send_email(
+ FromEmailAddress=sender,
+ Destination={"ToAddresses": ["[email protected]"]},
+ Content={
+ "Template": {
+ "TemplateContent": {
+ "Subject": "Inline {{name}}",
+ "Text": "Hello inline {{name}}",
+ "Html": "<p>Hello inline <b>{{name}}</b></p>",
+ },
+ "TemplateData": json.dumps({"name": "Alice"}),
+ }
+ },
+ )
+ assert response["MessageId"]
+ finally:
+ _safe_delete_identity_v2(sesv2_client, sender)
+
+ def test_send_email_with_both_name_and_inline_raises(
+ self, sesv2_client, unique_name
+ ):
+ sender = f"pytest-both-sender-{unique_name}@example.com"
+ try:
+ sesv2_client.create_email_identity(EmailIdentity=sender)
+ with pytest.raises(ClientError) as exc_info:
+ sesv2_client.send_email(
+ FromEmailAddress=sender,
+ Destination={"ToAddresses": ["[email protected]"]},
+ Content={
+ "Template": {
+ "TemplateName": "whatever",
+ "TemplateContent": {"Subject": "s", "Text": "t"},
+ "TemplateData": "{}",
+ }
+ },
+ )
+ assert (
+ exc_info.value.response["ResponseMetadata"]["HTTPStatusCode"] == 400
+ )
+ finally:
+ _safe_delete_identity_v2(sesv2_client, sender)
+
+ def test_send_email_with_template_arn_resolves_stored_template(
+ self, sesv2_client, unique_name
+ ):
+ template_name = f"pytest-arn-tpl-{unique_name}"
+ sender = f"pytest-arn-sender-{unique_name}@example.com"
+ arn = f"arn:aws:ses:us-east-1:000000000000:template/{template_name}"
+ try:
+ sesv2_client.create_email_identity(EmailIdentity=sender)
+ sesv2_client.create_email_template(
+ TemplateName=template_name,
+ TemplateContent={"Subject": "Hi {{name}}", "Text": "Hello {{name}}"},
+ )
+ response = sesv2_client.send_email(
+ FromEmailAddress=sender,
+ Destination={"ToAddresses": ["[email protected]"]},
+ Content={
+ "Template": {
+ "TemplateArn": arn,
+ "TemplateData": json.dumps({"name": "Alice"}),
+ }
+ },
+ )
+ assert response["MessageId"]
+ finally:
+ _safe_delete_v2(sesv2_client, template_name)
+ _safe_delete_identity_v2(sesv2_client, sender)
+
+ def test_send_email_with_unknown_template_raises(
+ self, sesv2_client, unique_name
+ ):
+ sender = f"pytest-sender-{unique_name}@example.com"
+ try:
+ sesv2_client.create_email_identity(EmailIdentity=sender)
+ with pytest.raises(ClientError) as exc_info:
+ sesv2_client.send_email(
+ FromEmailAddress=sender,
+ Destination={"ToAddresses": ["[email protected]"]},
+ Content={
+ "Template": {
+ "TemplateName": f"pytest-missing-{unique_name}",
+ "TemplateData": "{}",
+ }
+ },
+ )
+ assert (
+ exc_info.value.response["ResponseMetadata"]["HTTPStatusCode"] == 404
+ )
+ finally:
+ _safe_delete_identity_v2(sesv2_client, sender)
+
+
+# ============================================
+# SES V1 (ses) - Query / XML
+# ============================================
+
+
+class TestSesV1TemplateCrud:
+ """Template CRUD via the V1 SES Query API."""
+
+ def test_create_and_get_template(self, ses_client, unique_name):
+ name = f"pytest-v1-tpl-{unique_name}"
+ try:
+ ses_client.create_template(
+ Template={
+ "TemplateName": name,
+ "SubjectPart": "Hello {{name}}",
+ "TextPart": "Hi {{name}}!",
+ "HtmlPart": "<p>Hi <b>{{name}}</b>!</p>",
+ }
+ )
+ response = ses_client.get_template(TemplateName=name)
+ template = response["Template"]
+ assert template["TemplateName"] == name
+ assert template["SubjectPart"] == "Hello {{name}}"
+ assert template["TextPart"] == "Hi {{name}}!"
+ assert "{{name}}" in template["HtmlPart"]
+ finally:
+ _safe_delete_v1(ses_client, name)
+
+ def test_list_templates_includes_created(self, ses_client, unique_name):
+ name = f"pytest-v1-tpl-{unique_name}"
+ try:
+ ses_client.create_template(
+ Template={
+ "TemplateName": name,
+ "SubjectPart": "s",
+ "TextPart": "t",
+ }
+ )
+ response = ses_client.list_templates()
+ names = [
+ t["Name"] for t in response.get("TemplatesMetadata", [])
+ ]
+ assert name in names
+ finally:
+ _safe_delete_v1(ses_client, name)
+
+ def test_update_template(self, ses_client, unique_name):
+ name = f"pytest-v1-tpl-{unique_name}"
+ try:
+ ses_client.create_template(
+ Template={
+ "TemplateName": name,
+ "SubjectPart": "original",
+ "TextPart": "original",
+ }
+ )
+ ses_client.update_template(
+ Template={
+ "TemplateName": name,
+ "SubjectPart": "updated {{who}}",
+ "TextPart": "updated body {{who}}",
+ }
+ )
+ response = ses_client.get_template(TemplateName=name)
+ assert response["Template"]["SubjectPart"] == "updated {{who}}"
+ finally:
+ _safe_delete_v1(ses_client, name)
+
+ def test_delete_template(self, ses_client, unique_name):
+ name = f"pytest-v1-tpl-{unique_name}"
+ ses_client.create_template(
+ Template={"TemplateName": name, "SubjectPart": "s", "TextPart": "t"}
+ )
+ ses_client.delete_template(TemplateName=name)
+ with pytest.raises(ClientError) as exc_info:
+ ses_client.get_template(TemplateName=name)
+ assert (
+ exc_info.value.response["ResponseMetadata"]["HTTPStatusCode"] == 400
+ )
+
+
+class TestSesV1TemplateErrors:
+ """Error paths for V1 template operations."""
+
+ def test_create_duplicate_rejected(self, ses_client, unique_name):
+ name = f"pytest-v1-tpl-{unique_name}"
+ try:
+ ses_client.create_template(
+ Template={
+ "TemplateName": name,
+ "SubjectPart": "s",
+ "TextPart": "t",
+ }
+ )
+ with pytest.raises(ClientError) as exc_info:
+ ses_client.create_template(
+ Template={
+ "TemplateName": name,
+ "SubjectPart": "dup",
+ "TextPart": "dup",
+ }
+ )
+ assert (
+ exc_info.value.response["ResponseMetadata"]["HTTPStatusCode"] == 400
+ )
+ finally:
+ _safe_delete_v1(ses_client, name)
+
+ def test_get_nonexistent(self, ses_client, unique_name):
+ with pytest.raises(ClientError) as exc_info:
+ ses_client.get_template(TemplateName=f"pytest-missing-{unique_name}")
+ assert (
+ exc_info.value.response["ResponseMetadata"]["HTTPStatusCode"] == 400
+ )
+
+
+class TestSesV1SendTemplatedEmail:
+ """SendTemplatedEmail resolves stored templates via the V1 Query API."""
+
+ def test_send_templated_email(self, ses_client, unique_name):
+ template_name = f"pytest-v1-tpl-{unique_name}"
+ sender = f"pytest-v1-sender-{unique_name}@example.com"
+ recipient = f"pytest-v1-recipient-{unique_name}@example.com"
+
+ try:
+ ses_client.verify_email_identity(EmailAddress=sender)
+ ses_client.create_template(
+ Template={
+ "TemplateName": template_name,
+ "SubjectPart": "Welcome {{name}}",
+ "TextPart": "Hello {{name}}, from {{team}}",
+ }
+ )
+
+ response = ses_client.send_templated_email(
+ Source=sender,
+ Destination={"ToAddresses": [recipient]},
+ Template=template_name,
+ TemplateData=json.dumps({"name": "Alice", "team": "floci"}),
+ )
+ assert response["MessageId"]
+ finally:
+ _safe_delete_v1(ses_client, template_name)
+ _safe_delete_identity_v1(ses_client, sender)
+
+ def test_send_templated_email_with_template_arn_and_name(
+ self, ses_client, unique_name
+ ):
+ """boto3 requires Template (name) on SendTemplatedEmail; TemplateArn is
+ supplied alongside for cross-account addressing on real AWS. Floci
+ accepts both and resolves via the name."""
+ template_name = f"pytest-v1-arn-tpl-{unique_name}"
+ sender = f"pytest-v1-arn-sender-{unique_name}@example.com"
+ arn = f"arn:aws:ses:us-east-1:000000000000:template/{template_name}"
+ try:
+ ses_client.verify_email_identity(EmailAddress=sender)
+ ses_client.create_template(
+ Template={
+ "TemplateName": template_name,
+ "SubjectPart": "Hi {{name}}",
+ "TextPart": "Hello {{name}}",
+ }
+ )
+ response = ses_client.send_templated_email(
+ Source=sender,
+ Destination={"ToAddresses": ["[email protected]"]},
+ Template=template_name,
+ TemplateArn=arn,
+ TemplateData=json.dumps({"name": "Alice"}),
+ )
+ assert response["MessageId"]
+ finally:
+ _safe_delete_v1(ses_client, template_name)
+ _safe_delete_identity_v1(ses_client, sender)
+
+ def test_send_templated_email_with_unknown_template_raises(
+ self, ses_client, unique_name
+ ):
+ sender = f"pytest-v1-sender-{unique_name}@example.com"
+ try:
+ ses_client.verify_email_identity(EmailAddress=sender)
+ with pytest.raises(ClientError) as exc_info:
+ ses_client.send_templated_email(
+ Source=sender,
+ Destination={"ToAddresses": ["[email protected]"]},
+ Template=f"pytest-missing-{unique_name}",
+ TemplateData="{}",
+ )
+ assert (
+ exc_info.value.response["ResponseMetadata"]["HTTPStatusCode"] == 400
+ )
+ finally:
+ _safe_delete_identity_v1(ses_client, sender)
+
+
+# ============================================
+# Cleanup helpers
+# ============================================
+
+
+def _safe_delete_v2(client, template_name):
+ try:
+ client.delete_email_template(TemplateName=template_name)
+ except ClientError:
+ pass
+
+
+def _safe_delete_v1(client, template_name):
+ try:
+ client.delete_template(TemplateName=template_name)
+ except ClientError:
+ pass
+
+
+def _safe_delete_identity_v2(client, email):
+ try:
+ client.delete_email_identity(EmailIdentity=email)
+ except ClientError:
+ pass
+
+
+def _safe_delete_identity_v1(client, email):
+ try:
+ client.delete_identity(Identity=email)
+ except ClientError:
+ pass
diff --git a/docs/services/ses.md b/docs/services/ses.md
index d904836ee2..0d8df06973 100644
--- a/docs/services/ses.md
+++ b/docs/services/ses.md
@@ -17,6 +17,12 @@ Floci exposes the classic Amazon SES Query API used by `aws ses ...` commands an
| `GetIdentityVerificationAttributes` | Get verification status for one or more identities |
| `SendEmail` | Send a structured email with text or HTML body |
| `SendRawEmail` | Send a raw MIME payload |
+| `SendTemplatedEmail` | Send an email by resolving a stored template |
+| `CreateTemplate` | Create an email template with subject / text / html parts |
+| `GetTemplate` | Read a stored template |
+| `UpdateTemplate` | Replace the content of a stored template |
+| `DeleteTemplate` | Remove a stored template |
+| `ListTemplates` | List stored templates |
| `GetSendQuota` | Return local send quota counters |
| `GetSendStatistics` | Return aggregate delivery stats for sent messages |
| `GetAccountSendingEnabled` | Report whether sending is enabled |
@@ -167,5 +173,10 @@ Alongside the classic Query API, Floci implements a subset of the SES v2 REST JS
| `POST` | `/v2/email/outbound-emails` | `SendEmail` (simple / raw / templated) |
| `GET` | `/v2/email/account` | `GetAccount` |
| `PUT` | `/v2/email/account/sending` | `PutAccountSendingAttributes` |
+| `POST` | `/v2/email/templates` | `CreateEmailTemplate` |
+| `GET` | `/v2/email/templates` | `ListEmailTemplates` |
+| `GET` | `/v2/email/templates/{templateName}` | `GetEmailTemplate` |
+| `PUT` | `/v2/email/templates/{templateName}` | `UpdateEmailTemplate` |
+| `DELETE` | `/v2/email/templates/{templateName}` | `DeleteEmailTemplate` |
-Identity and sent-message state is shared with the v1 Query API, so messages sent through v2 appear in the same `GET /_aws/ses` inspection mailbox.
+Identity, template, and sent-message state is shared between the v1 Query API and the v2 REST JSON API, so a template created with `CreateTemplate` resolves through `SendEmail` on v2 (and vice versa), and every send appears in the same `GET /_aws/ses` inspection mailbox.
diff --git a/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.java b/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.java
index 9547f1aa54..16d69c912b 100644
--- a/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.java
+++ b/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.java
@@ -257,7 +257,9 @@ public class AwsQueryController {
"SendEmail", "SendRawEmail", "GetSendQuota", "GetSendStatistics",
"GetAccountSendingEnabled", "ListVerifiedEmailAddresses", "DeleteVerifiedEmailAddress",
"SetIdentityNotificationTopic", "GetIdentityNotificationAttributes",
- "GetIdentityDkimAttributes"
+ "GetIdentityDkimAttributes",
+ "CreateTemplate", "UpdateTemplate", "GetTemplate", "DeleteTemplate",
+ "ListTemplates", "SendTemplatedEmail"
);
private static final Set<String> COGNITO_ACTIONS = Set.of(
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 8b264e42cb..f76faad5bc 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
@@ -2,6 +2,7 @@ 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.services.ses.model.EmailTemplate;
import io.github.hectorvent.floci.services.ses.model.Identity;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
@@ -226,10 +227,38 @@ public class SesController {
messageId = sesService.sendEmail(fromEmailAddress, toAddresses, ccAddresses,
bccAddresses, replyToAddresses, subject, bodyText, bodyHtml, region);
} else if (content.has("Template")) {
- String subject = content.path("Template").path("TemplateName").asText("(template)");
- String templateData = content.path("Template").path("TemplateData").asText("");
- messageId = sesService.sendEmail(fromEmailAddress, toAddresses, ccAddresses,
- bccAddresses, replyToAddresses, subject, templateData, null, region);
+ JsonNode template = content.path("Template");
+ String templateName = template.path("TemplateName").asText(null);
+ String templateArn = template.path("TemplateArn").asText(null);
+ boolean hasName = templateName != null && !templateName.isBlank();
+ boolean hasArn = templateArn != null && !templateArn.isBlank();
+ boolean hasInline = template.has("TemplateContent");
+ int selectorCount = (hasName ? 1 : 0) + (hasArn ? 1 : 0) + (hasInline ? 1 : 0);
+ if (selectorCount > 1) {
+ throw new AwsException("BadRequestException",
+ "Content.Template must specify exactly one of TemplateName, TemplateArn, or TemplateContent.",
+ 400);
+ }
+ if (selectorCount == 0) {
+ throw new AwsException("BadRequestException",
+ "Content.Template requires TemplateName, TemplateArn, or TemplateContent.", 400);
+ }
+ JsonNode templateData = parseTemplateData(template.path("TemplateData").asText(""));
+ if (hasName || hasArn) {
+ String resolvedName = hasName
+ ? templateName
+ : SesService.templateNameFromArn(templateArn);
+ messageId = sesService.sendTemplatedEmail(fromEmailAddress, toAddresses, ccAddresses,
+ bccAddresses, replyToAddresses, resolvedName, templateData, region);
+ } else {
+ JsonNode inline = template.path("TemplateContent");
+ String subject = inline.path("Subject").asText(null);
+ String text = inline.path("Text").asText(null);
+ String html = inline.path("Html").asText(null);
+ messageId = sesService.sendInlineTemplatedEmail(fromEmailAddress, toAddresses,
+ ccAddresses, bccAddresses, replyToAddresses,
+ subject, text, html, templateData, region);
+ }
} else {
throw new AwsException("BadRequestException",
"Content must contain Raw, Simple, or Template.", 400);
@@ -248,6 +277,93 @@ public class SesController {
}
}
+ // ──────────────────────────── Templates ────────────────────────────
+
+ @POST
+ @Path("/templates")
+ public Response createEmailTemplate(@Context HttpHeaders headers, String body) {
+ String region = regionResolver.resolveRegion(headers);
+ try {
+ JsonNode request = objectMapper.readTree(body);
+ String templateName = request.path("TemplateName").asText(null);
+ if (templateName == null || templateName.isBlank()) {
+ throw new AwsException("BadRequestException", "TemplateName is required.", 400);
+ }
+ EmailTemplate template = parseTemplateContent(templateName, request.path("TemplateContent"));
+ sesService.createTemplate(template, region);
+ LOG.infov("SES V2 CreateEmailTemplate: {0}", templateName);
+ return Response.ok(objectMapper.createObjectNode()).build();
+ } catch (AwsException e) {
+ throw remapV1Exception(e);
+ } catch (com.fasterxml.jackson.core.JsonProcessingException e) {
+ throw new AwsException("BadRequestException", e.getMessage(), 400);
+ }
+ }
+
+ @GET
+ @Path("/templates")
+ public Response listEmailTemplates(@Context HttpHeaders headers) {
+ String region = regionResolver.resolveRegion(headers);
+ List<EmailTemplate> templates = sesService.listTemplates(region);
+ ObjectNode result = objectMapper.createObjectNode();
+ ArrayNode items = result.putArray("TemplatesMetadata");
+ for (EmailTemplate t : templates) {
+ ObjectNode item = objectMapper.createObjectNode();
+ item.put("TemplateName", t.getTemplateName());
+ if (t.getCreatedTimestamp() != null) {
+ item.put("CreatedTimestamp", t.getCreatedTimestamp().getEpochSecond());
+ }
+ items.add(item);
+ }
+ return Response.ok(result).build();
+ }
+
+ @GET
+ @Path("/templates/{templateName}")
+ public Response getEmailTemplate(@Context HttpHeaders headers,
+ @PathParam("templateName") String templateName) {
+ String region = regionResolver.resolveRegion(headers);
+ try {
+ EmailTemplate template = sesService.getTemplate(templateName, region);
+ return Response.ok(buildTemplateResponse(template)).build();
+ } catch (AwsException e) {
+ throw remapV1Exception(e);
+ }
+ }
+
+ @PUT
+ @Path("/templates/{templateName}")
+ public Response updateEmailTemplate(@Context HttpHeaders headers,
+ @PathParam("templateName") String templateName,
+ String body) {
+ String region = regionResolver.resolveRegion(headers);
+ try {
+ JsonNode request = objectMapper.readTree(body);
+ EmailTemplate template = parseTemplateContent(templateName, request.path("TemplateContent"));
+ sesService.updateTemplate(template, region);
+ LOG.infov("SES V2 UpdateEmailTemplate: {0}", templateName);
+ return Response.ok(objectMapper.createObjectNode()).build();
+ } catch (AwsException e) {
+ throw remapV1Exception(e);
+ } catch (com.fasterxml.jackson.core.JsonProcessingException e) {
+ throw new AwsException("BadRequestException", e.getMessage(), 400);
+ }
+ }
+
+ @DELETE
+ @Path("/templates/{templateName}")
+ public Response deleteEmailTemplate(@Context HttpHeaders headers,
+ @PathParam("templateName") String templateName) {
+ String region = regionResolver.resolveRegion(headers);
+ try {
+ sesService.deleteTemplate(templateName, region);
+ LOG.infov("SES V2 DeleteEmailTemplate: {0}", templateName);
+ return Response.ok(objectMapper.createObjectNode()).build();
+ } catch (AwsException e) {
+ throw remapV1Exception(e);
+ }
+ }
+
// ──────────────────────────── Account ────────────────────────────
@GET
@@ -354,10 +470,50 @@ public class SesController {
return all;
}
- private static AwsException remapV1Exception(AwsException e) {
- if ("InvalidParameterValue".equals(e.getErrorCode())) {
- return new AwsException("BadRequestException", e.getMessage(), 400);
+ private EmailTemplate parseTemplateContent(String templateName, JsonNode content) {
+ String subject = content.path("Subject").asText(null);
+ String text = content.path("Text").asText(null);
+ String html = content.path("Html").asText(null);
+ return new EmailTemplate(templateName, subject, text, html);
+ }
+
+ private ObjectNode buildTemplateResponse(EmailTemplate template) {
+ ObjectNode result = objectMapper.createObjectNode();
+ result.put("TemplateName", template.getTemplateName());
+ ObjectNode content = result.putObject("TemplateContent");
+ if (template.getSubject() != null) {
+ content.put("Subject", template.getSubject());
+ }
+ if (template.getTextPart() != null) {
+ content.put("Text", template.getTextPart());
+ }
+ if (template.getHtmlPart() != null) {
+ content.put("Html", template.getHtmlPart());
+ }
+ return result;
+ }
+
+ private JsonNode parseTemplateData(String raw) {
+ if (raw == null || raw.isBlank()) {
+ return objectMapper.createObjectNode();
+ }
+ try {
+ return objectMapper.readTree(raw);
+ } catch (Exception e) {
+ throw new AwsException("BadRequestException",
+ "Invalid TemplateData JSON: " + e.getMessage(), 400);
}
- return e;
+ }
+
+ private static AwsException remapV1Exception(AwsException e) {
+ return switch (e.getErrorCode()) {
+ case "InvalidParameterValue", "InvalidTemplate" ->
+ new AwsException("BadRequestException", e.getMessage(), 400);
+ case "TemplateDoesNotExist" ->
+ new AwsException("NotFoundException", e.getMessage(), 404);
+ case "AlreadyExists" ->
+ new AwsException("AlreadyExistsException", e.getMessage(), 400);
+ default -> e;
+ };
}
}
diff --git a/src/main/java/io/github/hectorvent/floci/services/ses/SesQueryHandler.java b/src/main/java/io/github/hectorvent/floci/services/ses/SesQueryHandler.java
index c181fa2ccc..084c277bb0 100644
--- a/src/main/java/io/github/hectorvent/floci/services/ses/SesQueryHandler.java
+++ b/src/main/java/io/github/hectorvent/floci/services/ses/SesQueryHandler.java
@@ -4,7 +4,10 @@ import io.github.hectorvent.floci.core.common.AwsException;
import io.github.hectorvent.floci.core.common.AwsNamespaces;
import io.github.hectorvent.floci.core.common.AwsQueryResponse;
import io.github.hectorvent.floci.core.common.XmlBuilder;
+import io.github.hectorvent.floci.services.ses.model.EmailTemplate;
import io.github.hectorvent.floci.services.ses.model.Identity;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import jakarta.ws.rs.core.MultivaluedMap;
@@ -24,10 +27,12 @@ public class SesQueryHandler {
private static final Logger LOG = Logger.getLogger(SesQueryHandler.class);
private final SesService sesService;
+ private final ObjectMapper objectMapper;
@Inject
- public SesQueryHandler(SesService sesService) {
+ public SesQueryHandler(SesService sesService, ObjectMapper objectMapper) {
this.sesService = sesService;
+ this.objectMapper = objectMapper;
}
public Response handle(String action, MultivaluedMap<String, String> params, String region) {
@@ -51,6 +56,12 @@ public class SesQueryHandler {
case "SetIdentityNotificationTopic" -> handleSetIdentityNotificationTopic(params, region);
case "GetIdentityNotificationAttributes" -> handleGetIdentityNotificationAttributes(params, region);
case "GetIdentityDkimAttributes" -> handleGetIdentityDkimAttributes(params, region);
+ case "CreateTemplate" -> handleCreateTemplate(params, region);
+ case "UpdateTemplate" -> handleUpdateTemplate(params, region);
+ case "GetTemplate" -> handleGetTemplate(params, region);
+ case "DeleteTemplate" -> handleDeleteTemplate(params, region);
+ case "ListTemplates" -> handleListTemplates(region);
+ case "SendTemplatedEmail" -> handleSendTemplatedEmail(params, region);
default -> AwsQueryResponse.error("UnsupportedOperation",
"Operation " + action + " is not supported by SES.", AwsNamespaces.SES, 400);
};
@@ -246,6 +257,105 @@ public class SesQueryHandler {
return Response.ok(AwsQueryResponse.envelope("GetIdentityDkimAttributes", AwsNamespaces.SES, xml.build())).build();
}
+ // --- Templates ---
+
+ private Response handleCreateTemplate(MultivaluedMap<String, String> params, String region) {
+ EmailTemplate template = readTemplateParams(params);
+ sesService.createTemplate(template, region);
+ return Response.ok(AwsQueryResponse.envelopeEmptyResult("CreateTemplate", AwsNamespaces.SES)).build();
+ }
+
+ private Response handleUpdateTemplate(MultivaluedMap<String, String> params, String region) {
+ EmailTemplate template = readTemplateParams(params);
+ sesService.updateTemplate(template, region);
+ return Response.ok(AwsQueryResponse.envelopeEmptyResult("UpdateTemplate", AwsNamespaces.SES)).build();
+ }
+
+ private Response handleGetTemplate(MultivaluedMap<String, String> params, String region) {
+ String templateName = getParam(params, "TemplateName");
+ EmailTemplate template = sesService.getTemplate(templateName, region);
+ var xml = new XmlBuilder().start("Template")
+ .elem("TemplateName", template.getTemplateName());
+ if (template.getSubject() != null) {
+ xml.elem("SubjectPart", template.getSubject());
+ }
+ if (template.getTextPart() != null) {
+ xml.elem("TextPart", template.getTextPart());
+ }
+ if (template.getHtmlPart() != null) {
+ xml.elem("HtmlPart", template.getHtmlPart());
+ }
+ xml.end("Template");
+ return Response.ok(AwsQueryResponse.envelope("GetTemplate", AwsNamespaces.SES, xml.build())).build();
+ }
+
+ private Response handleDeleteTemplate(MultivaluedMap<String, String> params, String region) {
+ String templateName = getParam(params, "TemplateName");
+ sesService.deleteTemplate(templateName, region);
+ return Response.ok(AwsQueryResponse.envelopeEmptyResult("DeleteTemplate", AwsNamespaces.SES)).build();
+ }
+
+ private Response handleListTemplates(String region) {
+ List<EmailTemplate> templates = sesService.listTemplates(region);
+ var xml = new XmlBuilder().start("TemplatesMetadata");
+ for (EmailTemplate t : templates) {
+ xml.start("member")
+ .elem("Name", t.getTemplateName());
+ if (t.getCreatedTimestamp() != null) {
+ xml.elem("CreatedTimestamp", t.getCreatedTimestamp().toString());
+ }
+ xml.end("member");
+ }
+ xml.end("TemplatesMetadata");
+ return Response.ok(AwsQueryResponse.envelope("ListTemplates", AwsNamespaces.SES, xml.build())).build();
+ }
+
+ private Response handleSendTemplatedEmail(MultivaluedMap<String, String> params, String region) {
+ String source = getParam(params, "Source");
+ List<String> toAddresses = extractMembers(params, "Destination.ToAddresses");
+ List<String> ccAddresses = extractMembers(params, "Destination.CcAddresses");
+ List<String> bccAddresses = extractMembers(params, "Destination.BccAddresses");
+ List<String> replyToAddresses = extractMembers(params, "ReplyToAddresses");
+ String templateName = getParam(params, "Template");
+ String templateArn = getParam(params, "TemplateArn");
+ String templateDataRaw = getParam(params, "TemplateData");
+
+ boolean hasName = templateName != null && !templateName.isBlank();
+ boolean hasArn = templateArn != null && !templateArn.isBlank();
+ if (!hasName && !hasArn) {
+ throw new AwsException("InvalidParameterValue",
+ "Template or TemplateArn is required.", 400);
+ }
+ String resolvedName = hasName ? templateName : SesService.templateNameFromArn(templateArn);
+
+ JsonNode templateData = parseTemplateData(templateDataRaw);
+ String messageId = sesService.sendTemplatedEmail(source, toAddresses, ccAddresses,
+ bccAddresses, replyToAddresses, resolvedName, templateData, region);
+
+ String result = new XmlBuilder().elem("MessageId", messageId).build();
+ return Response.ok(AwsQueryResponse.envelope("SendTemplatedEmail", AwsNamespaces.SES, result)).build();
+ }
+
+ private EmailTemplate readTemplateParams(MultivaluedMap<String, String> params) {
+ String name = getParam(params, "Template.TemplateName");
+ String subject = getParam(params, "Template.SubjectPart");
+ String text = getParam(params, "Template.TextPart");
+ String html = getParam(params, "Template.HtmlPart");
+ return new EmailTemplate(name, subject, text, html);
+ }
+
+ private JsonNode parseTemplateData(String raw) {
+ if (raw == null || raw.isBlank()) {
+ return objectMapper.createObjectNode();
+ }
+ try {
+ return objectMapper.readTree(raw);
+ } catch (com.fasterxml.jackson.core.JsonProcessingException e) {
+ throw new AwsException("InvalidTemplate",
+ "Invalid TemplateData JSON: " + e.getMessage(), 400);
+ }
+ }
+
// --- Helpers ---
private List<String> extractMembers(MultivaluedMap<String, String> params, String prefix) {
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 b649df3b03..69683143f6 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
@@ -3,27 +3,36 @@ package io.github.hectorvent.floci.services.ses;
import io.github.hectorvent.floci.core.common.AwsException;
import io.github.hectorvent.floci.core.storage.StorageBackend;
import io.github.hectorvent.floci.core.storage.StorageFactory;
+import io.github.hectorvent.floci.services.ses.model.EmailTemplate;
import io.github.hectorvent.floci.services.ses.model.Identity;
import io.github.hectorvent.floci.services.ses.model.SentEmail;
import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.JsonNode;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import org.jboss.logging.Logger;
+import java.time.Instant;
import java.util.ArrayList;
import java.util.Collections;
+import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.UUID;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
@ApplicationScoped
public class SesService {
private static final Logger LOG = Logger.getLogger(SesService.class);
+ private static final Pattern TEMPLATE_VARIABLE = Pattern.compile("\\{\\{\\s*([\\w-]+)\\s*\\}\\}");
+
private final StorageBackend<String, Identity> identityStore;
private final StorageBackend<String, SentEmail> emailStore;
private final StorageBackend<String, Boolean> accountSettingsStore;
+ private final StorageBackend<String, EmailTemplate> templateStore;
private final SmtpRelay smtpRelay;
@Inject
@@ -34,16 +43,20 @@ public class SesService {
new TypeReference<Map<String, SentEmail>>() {});
this.accountSettingsStore = storageFactory.create("ses", "ses-account-settings.json",
new TypeReference<Map<String, Boolean>>() {});
+ this.templateStore = storageFactory.create("ses", "ses-templates.json",
+ new TypeReference<Map<String, EmailTemplate>>() {});
this.smtpRelay = smtpRelay;
}
SesService(StorageBackend<String, Identity> identityStore,
StorageBackend<String, SentEmail> emailStore,
StorageBackend<String, Boolean> accountSettingsStore,
+ StorageBackend<String, EmailTemplate> templateStore,
SmtpRelay smtpRelay) {
this.identityStore = identityStore;
this.emailStore = emailStore;
this.accountSettingsStore = accountSettingsStore;
+ this.templateStore = templateStore;
this.smtpRelay = smtpRelay;
}
@@ -239,6 +252,161 @@ public class SesService {
LOG.infov("Updated account sending enabled for region {0}: {1}", region, enabled);
}
+ // ──────────────────────────── Templates ────────────────────────────
+
+ public EmailTemplate createTemplate(EmailTemplate template, String region) {
+ validateTemplate(template);
+ String key = templateKey(region, template.getTemplateName());
+ if (templateStore.get(key).isPresent()) {
+ throw new AwsException("AlreadyExists",
+ "Template " + template.getTemplateName() + " already exists.", 400);
+ }
+ Instant now = Instant.now();
+ template.setCreatedTimestamp(now);
+ template.setLastUpdatedTimestamp(now);
+ templateStore.put(key, template);
+ LOG.infov("Created SES template: {0} in region {1}", template.getTemplateName(), region);
+ return template;
+ }
+
+ public EmailTemplate getTemplate(String templateName, String region) {
+ return templateStore.get(templateKey(region, templateName))
+ .orElseThrow(() -> new AwsException("TemplateDoesNotExist",
+ "Template " + templateName + " does not exist.", 400));
+ }
+
+ public EmailTemplate updateTemplate(EmailTemplate template, String region) {
+ validateTemplate(template);
+ String key = templateKey(region, template.getTemplateName());
+ EmailTemplate existing = templateStore.get(key)
+ .orElseThrow(() -> new AwsException("TemplateDoesNotExist",
+ "Template " + template.getTemplateName() + " does not exist.", 400));
+ template.setCreatedTimestamp(existing.getCreatedTimestamp());
+ template.setLastUpdatedTimestamp(Instant.now());
+ templateStore.put(key, template);
+ LOG.infov("Updated SES template: {0} in region {1}", template.getTemplateName(), region);
+ return template;
+ }
+
+ public void deleteTemplate(String templateName, String region) {
+ String key = templateKey(region, templateName);
+ if (templateStore.get(key).isEmpty()) {
+ throw new AwsException("TemplateDoesNotExist",
+ "Template " + templateName + " does not exist.", 400);
+ }
+ templateStore.delete(key);
+ LOG.infov("Deleted SES template: {0} in region {1}", templateName, region);
+ }
+
+ public List<EmailTemplate> listTemplates(String region) {
+ String prefix = "template::" + region + "::";
+ List<EmailTemplate> all = new ArrayList<>(templateStore.scan(k -> k.startsWith(prefix)));
+ all.sort(Comparator.comparing(EmailTemplate::getCreatedTimestamp,
+ Comparator.nullsLast(Comparator.naturalOrder()))
+ .thenComparing(EmailTemplate::getTemplateName,
+ Comparator.nullsLast(Comparator.naturalOrder())));
+ return all;
+ }
+
+ public String sendTemplatedEmail(String source, List<String> toAddresses, List<String> ccAddresses,
+ List<String> bccAddresses, List<String> replyToAddresses,
+ String templateName, JsonNode templateData, String region) {
+ EmailTemplate template = getTemplate(templateName, region);
+ return sendInlineTemplatedEmail(source, toAddresses, ccAddresses, bccAddresses,
+ replyToAddresses, template.getSubject(), template.getTextPart(),
+ template.getHtmlPart(), templateData, region);
+ }
+
+ public String sendInlineTemplatedEmail(String source, List<String> toAddresses, List<String> ccAddresses,
+ List<String> bccAddresses, List<String> replyToAddresses,
+ String subject, String textPart, String htmlPart,
+ JsonNode templateData, String region) {
+ boolean hasSubject = subject != null && !subject.isBlank();
+ boolean hasText = textPart != null && !textPart.isBlank();
+ boolean hasHtml = htmlPart != null && !htmlPart.isBlank();
+ if (!hasSubject && !hasText && !hasHtml) {
+ throw new AwsException("InvalidTemplate",
+ "Template must have at least a subject, text, or html part.", 400);
+ }
+ return sendEmail(source, toAddresses, ccAddresses, bccAddresses, replyToAddresses,
+ applyTemplateData(subject, templateData),
+ applyTemplateData(textPart, templateData),
+ applyTemplateData(htmlPart, templateData),
+ region);
+ }
+
+ static String applyTemplateData(String text, JsonNode data) {
+ if (text == null || text.isEmpty()) {
+ return text;
+ }
+ Matcher matcher = TEMPLATE_VARIABLE.matcher(text);
+ StringBuilder out = new StringBuilder();
+ while (matcher.find()) {
+ String key = matcher.group(1);
+ String replacement = "";
+ if (data != null && data.hasNonNull(key)) {
+ JsonNode value = data.get(key);
+ replacement = value.isValueNode() ? value.asText() : value.toString();
+ }
+ matcher.appendReplacement(out, Matcher.quoteReplacement(replacement));
+ }
+ matcher.appendTail(out);
+ return out.toString();
+ }
+
+ private static void validateTemplate(EmailTemplate template) {
+ if (template == null) {
+ throw new AwsException("InvalidTemplate", "Template is required.", 400);
+ }
+ validateTemplateName(template.getTemplateName());
+ boolean hasSubject = template.getSubject() != null && !template.getSubject().isBlank();
+ boolean hasText = template.getTextPart() != null && !template.getTextPart().isBlank();
+ boolean hasHtml = template.getHtmlPart() != null && !template.getHtmlPart().isBlank();
+ if (!hasSubject && !hasText && !hasHtml) {
+ throw new AwsException("InvalidTemplate",
+ "Template must have at least a subject, text, or html part.", 400);
+ }
+ }
+
+ private static void validateTemplateName(String templateName) {
+ if (templateName == null || templateName.isBlank()) {
+ throw new AwsException("InvalidTemplate", "TemplateName is required.", 400);
+ }
+ if (Character.isWhitespace(templateName.charAt(0))
+ || Character.isWhitespace(templateName.charAt(templateName.length() - 1))) {
+ throw new AwsException("InvalidTemplate",
+ "TemplateName must not contain leading or trailing whitespace.", 400);
+ }
+ }
+
+ private static String templateKey(String region, String templateName) {
+ validateTemplateName(templateName);
+ return "template::" + region + "::" + templateName;
+ }
+
+ /**
+ * Extracts the template name from an SES template ARN of the form
+ * {@code arn:aws:ses:<region>:<account>:template/<name>}. Region and
+ * account segments are not validated; only the {@code template/<name>}
+ * suffix is required.
+ */
+ public static String templateNameFromArn(String arn) {
+ if (arn == null || arn.isBlank()) {
+ throw new AwsException("InvalidParameterValue", "TemplateArn is required.", 400);
+ }
+ int marker = arn.indexOf(":template/");
+ if (!arn.startsWith("arn:") || marker < 0) {
+ throw new AwsException("InvalidParameterValue",
+ "TemplateArn is not a valid SES template ARN: " + arn, 400);
+ }
+ String name = arn.substring(marker + ":template/".length());
+ if (name.isEmpty()) {
+ throw new AwsException("InvalidParameterValue",
+ "TemplateArn is missing a template name: " + arn, 400);
+ }
+ return name;
+ }
+
private static String identityKey(String region, String identity) {
validateIdentityWhitespace(identity, "Identity");
return "identity::" + region + "::" + identity;
diff --git a/src/main/java/io/github/hectorvent/floci/services/ses/model/EmailTemplate.java b/src/main/java/io/github/hectorvent/floci/services/ses/model/EmailTemplate.java
new file mode 100644
index 0000000000..2eacd2988d
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/ses/model/EmailTemplate.java
@@ -0,0 +1,57 @@
+package io.github.hectorvent.floci.services.ses.model;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import io.quarkus.runtime.annotations.RegisterForReflection;
+
+import java.time.Instant;
+
+@RegisterForReflection
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class EmailTemplate {
+
+ @JsonProperty("TemplateName")
+ private String templateName;
+
+ @JsonProperty("Subject")
+ private String subject;
+
+ @JsonProperty("TextPart")
+ private String textPart;
+
+ @JsonProperty("HtmlPart")
+ private String htmlPart;
+
+ @JsonProperty("CreatedTimestamp")
+ private Instant createdTimestamp;
+
+ @JsonProperty("LastUpdatedTimestamp")
+ private Instant lastUpdatedTimestamp;
+
+ public EmailTemplate() {}
+
+ public EmailTemplate(String templateName, String subject, String textPart, String htmlPart) {
+ this.templateName = templateName;
+ this.subject = subject;
+ this.textPart = textPart;
+ this.htmlPart = htmlPart;
+ }
+
+ public String getTemplateName() { return templateName; }
+ public void setTemplateName(String templateName) { this.templateName = templateName; }
+
+ public String getSubject() { return subject; }
+ public void setSubject(String subject) { this.subject = subject; }
+
+ public String getTextPart() { return textPart; }
+ public void setTextPart(String textPart) { this.textPart = textPart; }
+
+ public String getHtmlPart() { return htmlPart; }
+ public void setHtmlPart(String htmlPart) { this.htmlPart = htmlPart; }
+
+ public Instant getCreatedTimestamp() { return createdTimestamp; }
+ public void setCreatedTimestamp(Instant createdTimestamp) { this.createdTimestamp = createdTimestamp; }
+
+ public Instant getLastUpdatedTimestamp() { return lastUpdatedTimestamp; }
+ public void setLastUpdatedTimestamp(Instant lastUpdatedTimestamp) { this.lastUpdatedTimestamp = lastUpdatedTimestamp; }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceSmtpTest.java b/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceSmtpTest.java
index a4c7c170cf..3eb9595741 100644
--- a/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceSmtpTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceSmtpTest.java
@@ -1,6 +1,7 @@
package io.github.hectorvent.floci.services.ses;
import io.github.hectorvent.floci.core.storage.InMemoryStorage;
+import io.github.hectorvent.floci.services.ses.model.EmailTemplate;
import io.github.hectorvent.floci.services.ses.model.Identity;
import io.github.hectorvent.floci.services.ses.model.SentEmail;
import org.junit.jupiter.api.BeforeEach;
@@ -29,6 +30,7 @@ class SesServiceSmtpTest {
new InMemoryStorage<String, Identity>(),
emailStore,
new InMemoryStorage<String, Boolean>(),
+ new InMemoryStorage<String, EmailTemplate>(),
smtpRelay);
}
diff --git a/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceTemplateTest.java b/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceTemplateTest.java
new file mode 100644
index 0000000000..3cf1706b01
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/ses/SesServiceTemplateTest.java
@@ -0,0 +1,114 @@
+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.ObjectNode;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+/**
+ * Unit tests for {@link SesService#applyTemplateData} covering
+ * template variable substitution edge cases.
+ */
+class SesServiceTemplateTest {
+
+ private static final ObjectMapper MAPPER = new ObjectMapper();
+
+ @Test
+ void undefinedVariable_replacedWithEmptyString() {
+ JsonNode data = MAPPER.createObjectNode().put("name", "Alice");
+ String result = SesService.applyTemplateData("Hello {{name}}, team {{team}}", data);
+ assertEquals("Hello Alice, team ", result);
+ }
+
+ @Test
+ void spacedVariable_matchesCorrectly() {
+ JsonNode data = MAPPER.createObjectNode().put("name", "Alice");
+ String result = SesService.applyTemplateData("Hello {{ name }}", data);
+ assertEquals("Hello Alice", result);
+ }
+
+ @Test
+ void hyphenatedVariableName() {
+ JsonNode data = MAPPER.createObjectNode().put("first-name", "Alice");
+ String result = SesService.applyTemplateData("Hello {{first-name}}", data);
+ assertEquals("Hello Alice", result);
+ }
+
+ @Test
+ void unclosedBraces_leftAsIs() {
+ JsonNode data = MAPPER.createObjectNode().put("name", "Alice");
+ String result = SesService.applyTemplateData("Hello {{name}} and {{foo", data);
+ assertEquals("Hello Alice and {{foo", result);
+ }
+
+ @Test
+ void nonStringJsonValues() throws Exception {
+ ObjectNode data = MAPPER.createObjectNode();
+ data.put("count", 42);
+ data.put("active", true);
+ data.set("nested", MAPPER.readTree("{\"key\":\"val\"}"));
+
+ assertEquals("Items: 42", SesService.applyTemplateData("Items: {{count}}", data));
+ assertEquals("Active: true", SesService.applyTemplateData("Active: {{active}}", data));
+ assertEquals("Data: {\"key\":\"val\"}", SesService.applyTemplateData("Data: {{nested}}", data));
+ }
+
+ @Test
+ void emptyTemplateData_allVariablesCleared() {
+ JsonNode data = MAPPER.createObjectNode();
+ String result = SesService.applyTemplateData("Hello {{name}}, {{team}}", data);
+ assertEquals("Hello , ", result);
+ }
+
+ @Test
+ void nullTemplateData_allVariablesCleared() {
+ String result = SesService.applyTemplateData("Hello {{name}}", null);
+ assertEquals("Hello ", result);
+ }
+
+ @Test
+ void nullText_returnsNull() {
+ assertNull(SesService.applyTemplateData(null, MAPPER.createObjectNode()));
+ }
+
+ @Test
+ void emptyText_returnsEmpty() {
+ assertEquals("", SesService.applyTemplateData("", MAPPER.createObjectNode()));
+ }
+
+ @Test
+ void noVariables_textUnchanged() {
+ JsonNode data = MAPPER.createObjectNode().put("name", "Alice");
+ assertEquals("Hello world", SesService.applyTemplateData("Hello world", data));
+ }
+
+ @Test
+ void duplicateVariables_allReplaced() {
+ JsonNode data = MAPPER.createObjectNode().put("name", "Alice");
+ String result = SesService.applyTemplateData("{{name}} and {{name}}", data);
+ assertEquals("Alice and Alice", result);
+ }
+
+ @Test
+ void replacementWithRegexMetacharacters() {
+ JsonNode data = MAPPER.createObjectNode().put("val", "price is $100 (50% off)");
+ String result = SesService.applyTemplateData("The {{val}}", data);
+ assertEquals("The price is $100 (50% off)", result);
+ }
+
+ @Test
+ void variableNameCaseSensitive() {
+ JsonNode data = MAPPER.createObjectNode().put("Name", "Alice");
+ String result = SesService.applyTemplateData("Hello {{name}} and {{Name}}", data);
+ assertEquals("Hello and Alice", result);
+ }
+
+ @Test
+ void emptyStringValue() {
+ JsonNode data = MAPPER.createObjectNode().put("name", "");
+ assertEquals("Hello ", SesService.applyTemplateData("Hello {{name}}", data));
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/ses/SesTemplateV1IntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/ses/SesTemplateV1IntegrationTest.java
new file mode 100644
index 0000000000..59c4fd85a9
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/ses/SesTemplateV1IntegrationTest.java
@@ -0,0 +1,326 @@
+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.containsString;
+import static org.hamcrest.Matchers.equalTo;
+
+/**
+ * Integration tests for SES V1 Query-protocol template actions.
+ */
+@QuarkusTest
+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+class SesTemplateV1IntegrationTest {
+
+ private static final String AUTH =
+ "AWS4-HMAC-SHA256 Credential=AKID/20260101/us-east-1/email/aws4_request";
+
+ @Test
+ @Order(1)
+ void createTemplate() {
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", AUTH)
+ .formParam("Action", "CreateTemplate")
+ .formParam("Template.TemplateName", "v1-welcome")
+ .formParam("Template.SubjectPart", "Hello {{name}}")
+ .formParam("Template.TextPart", "Hi {{name}}!")
+ .formParam("Template.HtmlPart", "<p>Hi <b>{{name}}</b>!</p>")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body(containsString("CreateTemplateResponse"));
+ }
+
+ @Test
+ @Order(2)
+ void createTemplate_duplicateRejected() {
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", AUTH)
+ .formParam("Action", "CreateTemplate")
+ .formParam("Template.TemplateName", "v1-welcome")
+ .formParam("Template.SubjectPart", "dup")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(400)
+ .body(containsString("<Code>AlreadyExists</Code>"));
+ }
+
+ @Test
+ @Order(3)
+ void getTemplate() {
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", AUTH)
+ .formParam("Action", "GetTemplate")
+ .formParam("TemplateName", "v1-welcome")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body(containsString("<TemplateName>v1-welcome</TemplateName>"))
+ .body(containsString("<SubjectPart>Hello {{name}}</SubjectPart>"))
+ .body(containsString("<TextPart>Hi {{name}}!</TextPart>"));
+ }
+
+ @Test
+ @Order(4)
+ void getTemplate_notFound() {
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", AUTH)
+ .formParam("Action", "GetTemplate")
+ .formParam("TemplateName", "missing-template")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(400)
+ .body(containsString("<Code>TemplateDoesNotExist</Code>"));
+ }
+
+ @Test
+ @Order(5)
+ void updateTemplate() {
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", AUTH)
+ .formParam("Action", "UpdateTemplate")
+ .formParam("Template.TemplateName", "v1-welcome")
+ .formParam("Template.SubjectPart", "Welcome {{name}}!")
+ .formParam("Template.TextPart", "Hello {{name}}, from {{team}}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body(containsString("UpdateTemplateResponse"));
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", AUTH)
+ .formParam("Action", "GetTemplate")
+ .formParam("TemplateName", "v1-welcome")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body(containsString("<SubjectPart>Welcome {{name}}!</SubjectPart>"))
+ .body(containsString("{{team}}"));
+ }
+
+ @Test
+ @Order(6)
+ void listTemplates_includesCreated() {
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", AUTH)
+ .formParam("Action", "ListTemplates")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body(containsString("<TemplatesMetadata>"))
+ .body(containsString("<Name>v1-welcome</Name>"));
+ }
+
+ @Test
+ @Order(7)
+ void sendTemplatedEmail_substitutesVariables() {
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", AUTH)
+ .formParam("Action", "VerifyEmailIdentity")
+ .formParam("EmailAddress", "[email protected]")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ String body = given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", AUTH)
+ .formParam("Action", "SendTemplatedEmail")
+ .formParam("Source", "[email protected]")
+ .formParam("Destination.ToAddresses.member.1", "[email protected]")
+ .formParam("Template", "v1-welcome")
+ .formParam("TemplateData", "{\"name\":\"Alice\",\"team\":\"floci\"}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body(containsString("SendTemplatedEmailResponse"))
+ .body(containsString("<MessageId>"))
+ .extract().body().asString();
+
+ String messageId = body.replaceAll("(?s).*<MessageId>([^<]+)</MessageId>.*", "$1");
+
+ given()
+ .queryParam("id", messageId)
+ .when()
+ .get("/_aws/ses")
+ .then()
+ .statusCode(200)
+ .body("messages[0].Subject", equalTo("Welcome Alice!"))
+ .body("messages[0].Body.text_part", equalTo("Hello Alice, from floci"));
+ }
+
+ @Test
+ @Order(8)
+ void sendTemplatedEmail_unknownTemplate() {
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", AUTH)
+ .formParam("Action", "SendTemplatedEmail")
+ .formParam("Source", "[email protected]")
+ .formParam("Destination.ToAddresses.member.1", "[email protected]")
+ .formParam("Template", "ghost")
+ .formParam("TemplateData", "{}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(400)
+ .body(containsString("<Code>TemplateDoesNotExist</Code>"));
+ }
+
+ @Test
+ @Order(9)
+ void deleteTemplate() {
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", AUTH)
+ .formParam("Action", "DeleteTemplate")
+ .formParam("TemplateName", "v1-welcome")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body(containsString("DeleteTemplateResponse"));
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", AUTH)
+ .formParam("Action", "GetTemplate")
+ .formParam("TemplateName", "v1-welcome")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(400)
+ .body(containsString("<Code>TemplateDoesNotExist</Code>"));
+ }
+
+ @Test
+ @Order(10)
+ void deleteTemplate_notFound() {
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", AUTH)
+ .formParam("Action", "DeleteTemplate")
+ .formParam("TemplateName", "already-gone")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(400)
+ .body(containsString("<Code>TemplateDoesNotExist</Code>"));
+ }
+
+ @Test
+ @Order(11)
+ void createTemplate_rejectsLeadingTrailingWhitespace() {
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", AUTH)
+ .formParam("Action", "CreateTemplate")
+ .formParam("Template.TemplateName", " padded ")
+ .formParam("Template.SubjectPart", "s")
+ .formParam("Template.TextPart", "t")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(400)
+ .body(containsString("<Code>InvalidTemplate</Code>"));
+ }
+
+ @Test
+ @Order(12)
+ void sendTemplatedEmail_withTemplateArn_resolvesStoredTemplate() {
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", AUTH)
+ .formParam("Action", "CreateTemplate")
+ .formParam("Template.TemplateName", "v1-arn-welcome")
+ .formParam("Template.SubjectPart", "Hi {{name}}")
+ .formParam("Template.TextPart", "Hello {{name}}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", AUTH)
+ .formParam("Action", "VerifyEmailIdentity")
+ .formParam("EmailAddress", "[email protected]")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", AUTH)
+ .formParam("Action", "SendTemplatedEmail")
+ .formParam("Source", "[email protected]")
+ .formParam("Destination.ToAddresses.member.1", "[email protected]")
+ .formParam("TemplateArn", "arn:aws:ses:us-east-1:000000000000:template/v1-arn-welcome")
+ .formParam("TemplateData", "{\"name\":\"Alice\"}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body(containsString("<MessageId>"));
+ }
+
+ @Test
+ @Order(13)
+ void sendTemplatedEmail_withNameAndArn_accepted() {
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", AUTH)
+ .formParam("Action", "SendTemplatedEmail")
+ .formParam("Source", "[email protected]")
+ .formParam("Destination.ToAddresses.member.1", "[email protected]")
+ .formParam("Template", "v1-arn-welcome")
+ .formParam("TemplateArn", "arn:aws:ses:us-east-1:000000000000:template/v1-arn-welcome")
+ .formParam("TemplateData", "{\"name\":\"Alice\"}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body(containsString("<MessageId>"));
+ }
+
+ @Test
+ @Order(14)
+ void sendTemplatedEmail_withMalformedArn_returns400() {
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", AUTH)
+ .formParam("Action", "SendTemplatedEmail")
+ .formParam("Source", "[email protected]")
+ .formParam("Destination.ToAddresses.member.1", "[email protected]")
+ .formParam("TemplateArn", "not-an-arn")
+ .formParam("TemplateData", "{}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(400)
+ .body(containsString("<Code>InvalidParameterValue</Code>"));
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/ses/SesTemplateV2IntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/ses/SesTemplateV2IntegrationTest.java
new file mode 100644
index 0000000000..4639779b32
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/ses/SesTemplateV2IntegrationTest.java
@@ -0,0 +1,549 @@
+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.containsString;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.hasItem;
+import static org.hamcrest.Matchers.notNullValue;
+
+/**
+ * Integration tests for SES V2 email template CRUD and templated send
+ * via the REST JSON protocol at /v2/email/templates.
+ */
+@QuarkusTest
+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+class SesTemplateV2IntegrationTest {
+
+ private static final String AUTH_HEADER =
+ "AWS4-HMAC-SHA256 Credential=AKID/20260101/us-east-1/ses/aws4_request";
+
+ @Test
+ @Order(1)
+ void createTemplate() {
+ given()
+ .contentType("application/json")
+ .header("Authorization", AUTH_HEADER)
+ .body("""
+ {
+ "TemplateName": "v2-welcome",
+ "TemplateContent": {
+ "Subject": "Hello {{name}}",
+ "Text": "Hi {{name}}!",
+ "Html": "<p>Hi <b>{{name}}</b>!</p>"
+ }
+ }
+ """)
+ .when()
+ .post("/v2/email/templates")
+ .then()
+ .statusCode(200);
+ }
+
+ @Test
+ @Order(2)
+ void createTemplate_duplicateRejected() {
+ given()
+ .contentType("application/json")
+ .header("Authorization", AUTH_HEADER)
+ .body("""
+ {
+ "TemplateName": "v2-welcome",
+ "TemplateContent": {"Subject": "dup", "Text": "dup"}
+ }
+ """)
+ .when()
+ .post("/v2/email/templates")
+ .then()
+ .statusCode(400)
+ .body("__type", equalTo("AlreadyExistsException"));
+ }
+
+ @Test
+ @Order(3)
+ void createTemplate_missingName() {
+ given()
+ .contentType("application/json")
+ .header("Authorization", AUTH_HEADER)
+ .body("""
+ {"TemplateContent": {"Subject": "x"}}
+ """)
+ .when()
+ .post("/v2/email/templates")
+ .then()
+ .statusCode(400)
+ .body("__type", equalTo("BadRequestException"));
+ }
+
+ @Test
+ @Order(4)
+ void getTemplate() {
+ given()
+ .contentType("application/json")
+ .header("Authorization", AUTH_HEADER)
+ .when()
+ .get("/v2/email/templates/v2-welcome")
+ .then()
+ .statusCode(200)
+ .body("TemplateName", equalTo("v2-welcome"))
+ .body("TemplateContent.Subject", equalTo("Hello {{name}}"))
+ .body("TemplateContent.Text", equalTo("Hi {{name}}!"))
+ .body("TemplateContent.Html", containsString("{{name}}"));
+ }
+
+ @Test
+ @Order(5)
+ void getTemplate_notFound() {
+ given()
+ .contentType("application/json")
+ .header("Authorization", AUTH_HEADER)
+ .when()
+ .get("/v2/email/templates/does-not-exist")
+ .then()
+ .statusCode(404)
+ .body("__type", equalTo("NotFoundException"));
+ }
+
+ @Test
+ @Order(6)
+ void updateTemplate() {
+ given()
+ .contentType("application/json")
+ .header("Authorization", AUTH_HEADER)
+ .body("""
+ {
+ "TemplateContent": {
+ "Subject": "Welcome {{name}}!",
+ "Text": "Hello {{name}}, from {{team}}",
+ "Html": "<p>Welcome {{name}}</p>"
+ }
+ }
+ """)
+ .when()
+ .put("/v2/email/templates/v2-welcome")
+ .then()
+ .statusCode(200);
+
+ given()
+ .contentType("application/json")
+ .header("Authorization", AUTH_HEADER)
+ .when()
+ .get("/v2/email/templates/v2-welcome")
+ .then()
+ .statusCode(200)
+ .body("TemplateContent.Subject", equalTo("Welcome {{name}}!"))
+ .body("TemplateContent.Text", containsString("{{team}}"));
+ }
+
+ @Test
+ @Order(7)
+ void updateTemplate_notFound() {
+ given()
+ .contentType("application/json")
+ .header("Authorization", AUTH_HEADER)
+ .body("""
+ {"TemplateContent": {"Subject": "x"}}
+ """)
+ .when()
+ .put("/v2/email/templates/ghost")
+ .then()
+ .statusCode(404)
+ .body("__type", equalTo("NotFoundException"));
+ }
+
+ @Test
+ @Order(8)
+ void listTemplates_includesCreated() {
+ given()
+ .contentType("application/json")
+ .header("Authorization", AUTH_HEADER)
+ .when()
+ .get("/v2/email/templates")
+ .then()
+ .statusCode(200)
+ .body("TemplatesMetadata", notNullValue())
+ .body("TemplatesMetadata.TemplateName", hasItem("v2-welcome"));
+ }
+
+ @Test
+ @Order(9)
+ void sendEmail_withTemplate_substitutesVariables() {
+ given()
+ .contentType("application/json")
+ .header("Authorization", AUTH_HEADER)
+ .body("""
+ {"EmailIdentity": "[email protected]"}
+ """)
+ .when()
+ .post("/v2/email/identities")
+ .then()
+ .statusCode(200);
+
+ String messageId = given()
+ .contentType("application/json")
+ .header("Authorization", AUTH_HEADER)
+ .body("""
+ {
+ "FromEmailAddress": "[email protected]",
+ "Destination": {"ToAddresses": ["[email protected]"]},
+ "Content": {
+ "Template": {
+ "TemplateName": "v2-welcome",
+ "TemplateData": "{\\"name\\":\\"Alice\\",\\"team\\":\\"floci\\"}"
+ }
+ }
+ }
+ """)
+ .when()
+ .post("/v2/email/outbound-emails")
+ .then()
+ .statusCode(200)
+ .body("MessageId", notNullValue())
+ .extract().path("MessageId");
+
+ given()
+ .queryParam("id", messageId)
+ .when()
+ .get("/_aws/ses")
+ .then()
+ .statusCode(200)
+ .body("messages[0].Subject", equalTo("Welcome Alice!"))
+ .body("messages[0].Body.text_part", equalTo("Hello Alice, from floci"))
+ .body("messages[0].Body.html_part", equalTo("<p>Welcome Alice</p>"));
+ }
+
+ @Test
+ @Order(10)
+ void sendEmail_withUnknownTemplate_returns404() {
+ given()
+ .contentType("application/json")
+ .header("Authorization", AUTH_HEADER)
+ .body("""
+ {
+ "FromEmailAddress": "[email protected]",
+ "Destination": {"ToAddresses": ["[email protected]"]},
+ "Content": {
+ "Template": {
+ "TemplateName": "ghost",
+ "TemplateData": "{}"
+ }
+ }
+ }
+ """)
+ .when()
+ .post("/v2/email/outbound-emails")
+ .then()
+ .statusCode(404)
+ .body("__type", equalTo("NotFoundException"));
+ }
+
+ @Test
+ @Order(11)
+ void sendEmail_withTemplate_missingName_returns400() {
+ given()
+ .contentType("application/json")
+ .header("Authorization", AUTH_HEADER)
+ .body("""
+ {
+ "FromEmailAddress": "[email protected]",
+ "Destination": {"ToAddresses": ["[email protected]"]},
+ "Content": {"Template": {"TemplateData": "{}"}}
+ }
+ """)
+ .when()
+ .post("/v2/email/outbound-emails")
+ .then()
+ .statusCode(400)
+ .body("__type", equalTo("BadRequestException"));
+ }
+
+ @Test
+ @Order(12)
+ void deleteTemplate() {
+ given()
+ .contentType("application/json")
+ .header("Authorization", AUTH_HEADER)
+ .when()
+ .delete("/v2/email/templates/v2-welcome")
+ .then()
+ .statusCode(200);
+
+ given()
+ .contentType("application/json")
+ .header("Authorization", AUTH_HEADER)
+ .when()
+ .get("/v2/email/templates/v2-welcome")
+ .then()
+ .statusCode(404);
+ }
+
+ @Test
+ @Order(13)
+ void deleteTemplate_notFound() {
+ given()
+ .contentType("application/json")
+ .header("Authorization", AUTH_HEADER)
+ .when()
+ .delete("/v2/email/templates/already-gone")
+ .then()
+ .statusCode(404)
+ .body("__type", equalTo("NotFoundException"));
+ }
+
+ @Test
+ @Order(14)
+ void createTemplate_rejectsLeadingTrailingWhitespace() {
+ given()
+ .contentType("application/json")
+ .header("Authorization", AUTH_HEADER)
+ .body("""
+ {
+ "TemplateName": " padded ",
+ "TemplateContent": {"Subject": "s", "Text": "t"}
+ }
+ """)
+ .when()
+ .post("/v2/email/templates")
+ .then()
+ .statusCode(400)
+ .body("__type", equalTo("BadRequestException"));
+ }
+
+ @Test
+ @Order(15)
+ void sendEmail_withInlineTemplate_substitutesVariables() {
+ given()
+ .contentType("application/json")
+ .header("Authorization", AUTH_HEADER)
+ .body("""
+ {"EmailIdentity": "[email protected]"}
+ """)
+ .when()
+ .post("/v2/email/identities")
+ .then()
+ .statusCode(200);
+
+ String messageId = given()
+ .contentType("application/json")
+ .header("Authorization", AUTH_HEADER)
+ .body("""
+ {
+ "FromEmailAddress": "[email protected]",
+ "Destination": {"ToAddresses": ["[email protected]"]},
+ "Content": {
+ "Template": {
+ "TemplateContent": {
+ "Subject": "Inline {{name}}",
+ "Text": "Hello inline {{name}} on {{team}}",
+ "Html": "<p>Hello inline <b>{{name}}</b></p>"
+ },
+ "TemplateData": "{\\"name\\":\\"Alice\\",\\"team\\":\\"floci\\"}"
+ }
+ }
+ }
+ """)
+ .when()
+ .post("/v2/email/outbound-emails")
+ .then()
+ .statusCode(200)
+ .body("MessageId", notNullValue())
+ .extract().path("MessageId");
+
+ given()
+ .queryParam("id", messageId)
+ .when()
+ .get("/_aws/ses")
+ .then()
+ .statusCode(200)
+ .body("messages[0].Subject", equalTo("Inline Alice"))
+ .body("messages[0].Body.text_part", equalTo("Hello inline Alice on floci"))
+ .body("messages[0].Body.html_part", equalTo("<p>Hello inline <b>Alice</b></p>"));
+ }
+
+ @Test
+ @Order(16)
+ void sendEmail_templateWithBothNameAndContent_returns400() {
+ given()
+ .contentType("application/json")
+ .header("Authorization", AUTH_HEADER)
+ .body("""
+ {
+ "FromEmailAddress": "[email protected]",
+ "Destination": {"ToAddresses": ["[email protected]"]},
+ "Content": {
+ "Template": {
+ "TemplateName": "anything",
+ "TemplateContent": {"Subject": "s", "Text": "t"},
+ "TemplateData": "{}"
+ }
+ }
+ }
+ """)
+ .when()
+ .post("/v2/email/outbound-emails")
+ .then()
+ .statusCode(400)
+ .body("__type", equalTo("BadRequestException"));
+ }
+
+ @Test
+ @Order(17)
+ void sendEmail_withTemplateArn_resolvesStoredTemplate() {
+ given()
+ .contentType("application/json")
+ .header("Authorization", AUTH_HEADER)
+ .body("""
+ {
+ "TemplateName": "arn-welcome",
+ "TemplateContent": {
+ "Subject": "Hi {{name}}",
+ "Text": "Hello {{name}}"
+ }
+ }
+ """)
+ .when()
+ .post("/v2/email/templates")
+ .then()
+ .statusCode(200);
+
+ String messageId = given()
+ .contentType("application/json")
+ .header("Authorization", AUTH_HEADER)
+ .body("""
+ {
+ "FromEmailAddress": "[email protected]",
+ "Destination": {"ToAddresses": ["[email protected]"]},
+ "Content": {
+ "Template": {
+ "TemplateArn": "arn:aws:ses:us-east-1:000000000000:template/arn-welcome",
+ "TemplateData": "{\\"name\\":\\"Alice\\"}"
+ }
+ }
+ }
+ """)
+ .when()
+ .post("/v2/email/outbound-emails")
+ .then()
+ .statusCode(200)
+ .body("MessageId", notNullValue())
+ .extract().path("MessageId");
+
+ given()
+ .queryParam("id", messageId)
+ .when()
+ .get("/_aws/ses")
+ .then()
+ .statusCode(200)
+ .body("messages[0].Subject", equalTo("Hi Alice"))
+ .body("messages[0].Body.text_part", equalTo("Hello Alice"));
+ }
+
+ @Test
+ @Order(18)
+ void sendEmail_templateWithMalformedArn_returns400() {
+ given()
+ .contentType("application/json")
+ .header("Authorization", AUTH_HEADER)
+ .body("""
+ {
+ "FromEmailAddress": "[email protected]",
+ "Destination": {"ToAddresses": ["[email protected]"]},
+ "Content": {
+ "Template": {
+ "TemplateArn": "not-an-arn",
+ "TemplateData": "{}"
+ }
+ }
+ }
+ """)
+ .when()
+ .post("/v2/email/outbound-emails")
+ .then()
+ .statusCode(400)
+ .body("__type", equalTo("BadRequestException"));
+ }
+
+ @Test
+ @Order(19)
+ void sendEmail_templateWithNameAndArn_returns400() {
+ given()
+ .contentType("application/json")
+ .header("Authorization", AUTH_HEADER)
+ .body("""
+ {
+ "FromEmailAddress": "[email protected]",
+ "Destination": {"ToAddresses": ["[email protected]"]},
+ "Content": {
+ "Template": {
+ "TemplateName": "arn-welcome",
+ "TemplateArn": "arn:aws:ses:us-east-1:000000000000:template/arn-welcome",
+ "TemplateData": "{}"
+ }
+ }
+ }
+ """)
+ .when()
+ .post("/v2/email/outbound-emails")
+ .then()
+ .statusCode(400)
+ .body("__type", equalTo("BadRequestException"));
+ }
+
+ // ──────────────── Cross-region isolation ────────────────
+
+ private static final String AUTH_EU_WEST_1 =
+ "AWS4-HMAC-SHA256 Credential=AKID/20260101/eu-west-1/ses/aws4_request";
+
+ @Test
+ @Order(20)
+ void crossRegionIsolation_templateNotVisibleInOtherRegion() {
+ // Create template in eu-west-1
+ given()
+ .contentType("application/json")
+ .header("Authorization", AUTH_EU_WEST_1)
+ .body("""
+ {
+ "TemplateName": "region-test",
+ "TemplateContent": {
+ "Subject": "Regional",
+ "Text": "Hello from eu-west-1"
+ }
+ }
+ """)
+ .when()
+ .post("/v2/email/templates")
+ .then()
+ .statusCode(200);
+
+ // Verify it exists in eu-west-1
+ given()
+ .header("Authorization", AUTH_EU_WEST_1)
+ .when()
+ .get("/v2/email/templates/region-test")
+ .then()
+ .statusCode(200)
+ .body("TemplateName", equalTo("region-test"));
+
+ // Verify it does NOT exist in us-east-1
+ given()
+ .header("Authorization", AUTH_HEADER)
+ .when()
+ .get("/v2/email/templates/region-test")
+ .then()
+ .statusCode(404);
+
+ // Clean up
+ given()
+ .header("Authorization", AUTH_EU_WEST_1)
+ .when()
+ .delete("/v2/email/templates/region-test")
+ .then()
+ .statusCode(200);
+ }
+
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/ses/SesV2IntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/ses/SesV2IntegrationTest.java
index a140a6d68b..928a6ca3c1 100644
--- a/src/test/java/io/github/hectorvent/floci/services/ses/SesV2IntegrationTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/ses/SesV2IntegrationTest.java
@@ -260,7 +260,6 @@ class SesV2IntegrationTest {
@Test
@Order(13)
void sendEmail_template() {
- // Re-create an identity for template test
given()
.contentType("application/json")
.header("Authorization", AUTH_HEADER)
@@ -272,6 +271,23 @@ class SesV2IntegrationTest {
.then()
.statusCode(200);
+ given()
+ .contentType("application/json")
+ .header("Authorization", AUTH_HEADER)
+ .body("""
+ {
+ "TemplateName": "MyTemplate",
+ "TemplateContent": {
+ "Subject": "Hello {{name}}",
+ "Text": "Hi {{name}}!"
+ }
+ }
+ """)
+ .when()
+ .post("/v2/email/templates")
+ .then()
+ .statusCode(200);
+
given()
.contentType("application/json")
.header("Authorization", AUTH_HEADER)