Skip to content

armgit / floci

Public Imported from GitHub
0

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

test(partition): cover 46 more services in the cross-partition smoke test (#5432)

Hector Venturafe51d2996d45
diff --git a/src/test/java/io/github/hectorvent/floci/core/common/PartitionCrossServiceSmokeIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/core/common/PartitionCrossServiceSmokeIntegrationTest.java
index 7901bf4361..ea0339c6dd 100644
--- a/src/test/java/io/github/hectorvent/floci/core/common/PartitionCrossServiceSmokeIntegrationTest.java
+++ b/src/test/java/io/github/hectorvent/floci/core/common/PartitionCrossServiceSmokeIntegrationTest.java
@@ -13,11 +13,14 @@ import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;
import java.net.URI;
+import java.nio.charset.StandardCharsets;
+import java.util.Base64;
import java.util.Set;
import java.util.stream.Stream;
import static io.restassured.RestAssured.given;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assumptions.assumeTrue;
/**
@@ -35,9 +38,15 @@ import static org.junit.jupiter.api.Assumptions.assumeTrue;
class PartitionCrossServiceSmokeIntegrationTest {
static final Set<String> COVERED_PACKAGES = Set.of(
- "acm", "apigatewayv2", "batch", "codebuild", "efs", "elbv2", "firehose", "glue", "iot",
- "kinesis", "sns");
+ "accessanalyzer", "acm", "amazonmq", "apigateway", "apigatewayv2", "applicationautoscaling", "appsync",
+ "aps", "autoscaling", "backup", "batch", "bedrock", "bedrockagentcorecontrol", "ce", "cloudfront",
+ "cloudmap", "cloudwatch", "codebuild", "codedeploy", "cognito", "configservice", "connect",
+ "controlcatalog", "controltower", "datasync", "dlm", "dynamodb", "ec2", "ecs", "efs", "eks",
+ "elasticache", "elbv2", "emr", "emrserverless", "eventbridge", "firehose", "glue", "guardduty", "iot",
+ "kinesis", "lambdamicrovms", "memorydb", "msk", "networkfirewall", "oam", "opensearch", "ram", "rds",
+ "route53resolver", "s3tables", "scheduler", "secretsmanager", "ses", "sns", "sqs", "wafv2");
+ private static final String JSON_1_0 = "application/x-amz-json-1.0";
private static final String JSON_1_1 = "application/x-amz-json-1.1";
private static final String JSON = "application/json";
@@ -245,13 +254,853 @@ class PartitionCrossServiceSmokeIntegrationTest {
PartitionMatrix.assertArnIn(partitionCase, created.jsonPath().getString("FileSystemArn"));
}
- /** The case's region, or the test is skipped where the partition does not publish the service. */
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void sqsQueueArn(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "sqs");
+ String name = unique("smoke-queue", partitionCase);
+ String queueUrl = json10(region, "sqs", "AmazonSQS.CreateQueue", "{\"QueueName\":\"" + name + "\"}")
+ .when().post("/").then().statusCode(200)
+ .extract().jsonPath().getString("QueueUrl");
+ cleanup.register(() -> json10(region, "sqs", "AmazonSQS.DeleteQueue",
+ "{\"QueueUrl\":\"" + queueUrl + "\"}").when().post("/"));
+ String arn = json10(region, "sqs", "AmazonSQS.GetQueueAttributes",
+ "{\"QueueUrl\":\"" + queueUrl + "\",\"AttributeNames\":[\"QueueArn\"]}")
+ .when().post("/").then().statusCode(200)
+ .extract().jsonPath().getString("Attributes.QueueArn");
+ PartitionMatrix.assertArnIn(partitionCase, arn);
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void secretsManagerSecretArn(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "secretsmanager");
+ String name = unique("smoke-secret", partitionCase);
+ String arn = json11(region, "secretsmanager", "secretsmanager.CreateSecret",
+ "{\"Name\":\"" + name + "\",\"SecretString\":\"smoke\"}")
+ .when().post("/").then().statusCode(200)
+ .extract().jsonPath().getString("ARN");
+ cleanup.register(() -> json11(region, "secretsmanager", "secretsmanager.DeleteSecret",
+ "{\"SecretId\":\"" + arn + "\",\"ForceDeleteWithoutRecovery\":true}").when().post("/"));
+ PartitionMatrix.assertArnIn(partitionCase, arn);
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void dynamoDbTableArn(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "dynamodb");
+ String name = unique("smoke-table", partitionCase);
+ String body = """
+ {
+ "TableName": "%s",
+ "AttributeDefinitions": [{"AttributeName": "id", "AttributeType": "S"}],
+ "KeySchema": [{"AttributeName": "id", "KeyType": "HASH"}],
+ "BillingMode": "PAY_PER_REQUEST"
+ }
+ """.formatted(name);
+ String arn = json10(region, "dynamodb", "DynamoDB_20120810.CreateTable", body)
+ .when().post("/").then().statusCode(200)
+ .extract().jsonPath().getString("TableDescription.TableArn");
+ cleanup.register(() -> json10(region, "dynamodb", "DynamoDB_20120810.DeleteTable",
+ "{\"TableName\":\"" + name + "\"}").when().post("/"));
+ PartitionMatrix.assertArnIn(partitionCase, arn);
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void cloudWatchAlarmArn(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "monitoring");
+ String name = unique("smoke-alarm", partitionCase);
+ signed(region, "monitoring")
+ .formParam("Action", "PutMetricAlarm")
+ .formParam("Version", "2010-08-01")
+ .formParam("AlarmName", name)
+ .formParam("Namespace", "Smoke")
+ .formParam("MetricName", "Requests")
+ .formParam("Statistic", "Sum")
+ .formParam("Period", "60")
+ .formParam("EvaluationPeriods", "1")
+ .formParam("Threshold", "1")
+ .formParam("ComparisonOperator", "GreaterThanThreshold")
+ .when().post("/").then().statusCode(200);
+ cleanup.register(() -> signed(region, "monitoring")
+ .formParam("Action", "DeleteAlarms")
+ .formParam("Version", "2010-08-01")
+ .formParam("AlarmNames.member.1", name)
+ .when().post("/"));
+ String arn = signed(region, "monitoring")
+ .formParam("Action", "DescribeAlarms")
+ .formParam("Version", "2010-08-01")
+ .formParam("AlarmNames.member.1", name)
+ .when().post("/").then().statusCode(200)
+ .extract().xmlPath()
+ .getString("DescribeAlarmsResponse.DescribeAlarmsResult.MetricAlarms.member.AlarmArn");
+ PartitionMatrix.assertArnIn(partitionCase, arn);
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void cloudWatchDashboardArn(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "monitoring");
+ String name = unique("smoke-dashboard", partitionCase);
+ signed(region, "monitoring")
+ .formParam("Action", "PutDashboard")
+ .formParam("Version", "2010-08-01")
+ .formParam("DashboardName", name)
+ .formParam("DashboardBody", "{\"widgets\":[]}")
+ .when().post("/").then().statusCode(200);
+ cleanup.register(() -> signed(region, "monitoring")
+ .formParam("Action", "DeleteDashboards")
+ .formParam("Version", "2010-08-01")
+ .formParam("DashboardNames.member.1", name)
+ .when().post("/"));
+ String arn = signed(region, "monitoring")
+ .formParam("Action", "GetDashboard")
+ .formParam("Version", "2010-08-01")
+ .formParam("DashboardName", name)
+ .when().post("/").then().statusCode(200)
+ .extract().xmlPath().getString("GetDashboardResponse.GetDashboardResult.DashboardArn");
+ PartitionMatrix.assertGlobalArnIn(partitionCase, arn);
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void cloudWatchLogGroupArn(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "logs");
+ String name = unique("smoke-log-group", partitionCase);
+ json11(region, "logs", "Logs_20140328.CreateLogGroup", "{\"logGroupName\":\"" + name + "\"}")
+ .when().post("/").then().statusCode(200);
+ cleanup.register(() -> json11(region, "logs", "Logs_20140328.DeleteLogGroup",
+ "{\"logGroupName\":\"" + name + "\"}").when().post("/"));
+ String arn = json11(region, "logs", "Logs_20140328.DescribeLogGroups",
+ "{\"logGroupNamePrefix\":\"" + name + "\"}")
+ .when().post("/").then().statusCode(200)
+ .extract().jsonPath().getString("logGroups[0].arn");
+ PartitionMatrix.assertArnIn(partitionCase, arn);
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void eventBridgeEventBusArn(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "events");
+ String name = unique("smoke-bus", partitionCase);
+ String arn = json11(region, "events", "AWSEvents.CreateEventBus", "{\"Name\":\"" + name + "\"}")
+ .when().post("/").then().statusCode(200)
+ .extract().jsonPath().getString("EventBusArn");
+ cleanup.register(() -> json11(region, "events", "AWSEvents.DeleteEventBus",
+ "{\"Name\":\"" + name + "\"}").when().post("/"));
+ PartitionMatrix.assertArnIn(partitionCase, arn);
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void ecsClusterArn(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "ecs");
+ String name = unique("smoke-cluster", partitionCase);
+ String arn = json11(region, "ecs", "AmazonEC2ContainerServiceV20141113.CreateCluster",
+ "{\"clusterName\":\"" + name + "\"}")
+ .when().post("/").then().statusCode(200)
+ .extract().jsonPath().getString("cluster.clusterArn");
+ cleanup.register(() -> json11(region, "ecs", "AmazonEC2ContainerServiceV20141113.DeleteCluster",
+ "{\"cluster\":\"" + name + "\"}").when().post("/"));
+ PartitionMatrix.assertArnIn(partitionCase, arn);
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void rdsParameterGroupArn(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "rds");
+ String name = unique("smoke-pg", partitionCase);
+ String arn = signed(region, "rds")
+ .formParam("Action", "CreateDBParameterGroup")
+ .formParam("Version", "2014-10-31")
+ .formParam("DBParameterGroupName", name)
+ .formParam("DBParameterGroupFamily", "postgres16")
+ .formParam("Description", "smoke")
+ .when().post("/").then().statusCode(200)
+ .extract().xmlPath()
+ .getString("CreateDBParameterGroupResponse.CreateDBParameterGroupResult.DBParameterGroup.DBParameterGroupArn");
+ cleanup.register(() -> signed(region, "rds")
+ .formParam("Action", "DeleteDBParameterGroup")
+ .formParam("Version", "2014-10-31")
+ .formParam("DBParameterGroupName", name)
+ .when().post("/"));
+ PartitionMatrix.assertArnIn(partitionCase, arn);
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void ec2IpamArn(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "ec2");
+ Response created = signed(region, "ec2")
+ .formParam("Action", "CreateIpam")
+ .formParam("Version", "2016-11-15")
+ .when().post("/").then().statusCode(200).extract().response();
+ String ipamId = created.xmlPath().getString("CreateIpamResponse.ipam.ipamId");
+ cleanup.register(() -> signed(region, "ec2")
+ .formParam("Action", "DeleteIpam")
+ .formParam("Version", "2016-11-15")
+ .formParam("IpamId", ipamId)
+ .formParam("Cascade", "true")
+ .when().post("/"));
+ PartitionMatrix.assertGlobalArnIn(partitionCase, created.xmlPath().getString("CreateIpamResponse.ipam.ipamArn"));
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void apiGatewayDomainNameArn(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "apigateway");
+ String domain = unique("smoke-domain", partitionCase) + ".example.com";
+ String body = """
+ {
+ "domainName": "%s",
+ "endpointConfiguration": {"types": ["REGIONAL"]},
+ "regionalCertificateArn": "arn:%s:acm:%s:000000000000:certificate/smoke"
+ }
+ """.formatted(domain, partitionCase.partition(), region);
+ String arn = signed(region, "apigateway")
+ .contentType(JSON)
+ .body(body)
+ .when().post("/domainnames").then().statusCode(201)
+ .extract().jsonPath().getString("domainNameArn");
+ cleanup.register(() -> signed(region, "apigateway").when().delete("/domainnames/" + domain));
+ PartitionMatrix.assertArnIn(partitionCase, arn);
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void sesTenantArn(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "ses");
+ String name = unique("smoke-tenant", partitionCase);
+ String arn = signed(region, "ses")
+ .contentType(JSON)
+ .body("{\"TenantName\":\"" + name + "\"}")
+ .when().post("/v2/email/tenants").then().statusCode(200)
+ .extract().jsonPath().getString("TenantArn");
+ cleanup.register(() -> signed(region, "ses")
+ .contentType(JSON)
+ .body("{\"TenantName\":\"" + name + "\"}")
+ .when().post("/v2/email/tenants/delete"));
+ PartitionMatrix.assertArnIn(partitionCase, arn);
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void eksClusterArnAndOidcIssuerHost(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "eks");
+ String name = unique("smoke-eks", partitionCase);
+ Response created = signed(region, "eks")
+ .contentType(JSON)
+ .body("{\"name\":\"" + name + "\",\"roleArn\":\"arn:" + partitionCase.partition()
+ + ":iam::000000000000:role/eks-role\"}")
+ .when().post("/clusters").then().statusCode(200).extract().response();
+ cleanup.register(() -> signed(region, "eks").when().delete("/clusters/" + name));
+ PartitionMatrix.assertArnIn(partitionCase, created.jsonPath().getString("cluster.arn"));
+ String issuer = signed(region, "eks").when().get("/clusters/" + name).then().statusCode(200)
+ .extract().jsonPath().getString("cluster.identity.oidc.issuer");
+ assertRegionalHostIn(partitionCase, URI.create(issuer).getHost());
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void cognitoUserPoolArn(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "cognito-idp");
+ String name = unique("smoke-pool", partitionCase);
+ Response created = json11(region, "cognito-idp", "AWSCognitoIdentityProviderService.CreateUserPool",
+ "{\"PoolName\":\"" + name + "\"}")
+ .when().post("/").then().statusCode(200).extract().response();
+ String poolId = created.jsonPath().getString("UserPool.Id");
+ cleanup.register(() -> json11(region, "cognito-idp", "AWSCognitoIdentityProviderService.DeleteUserPool",
+ "{\"UserPoolId\":\"" + poolId + "\"}").when().post("/"));
+ PartitionMatrix.assertArnIn(partitionCase, created.jsonPath().getString("UserPool.Arn"));
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void appSyncGraphqlApiArn(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "appsync");
+ Response created = signed(region, "appsync")
+ .contentType(JSON)
+ .body("{\"name\":\"" + unique("smoke-api", partitionCase) + "\",\"authenticationType\":\"API_KEY\"}")
+ .when().post("/v1/apis").then().statusCode(200).extract().response();
+ String apiId = created.jsonPath().getString("graphqlApi.apiId");
+ cleanup.register(() -> signed(region, "appsync").when().delete("/v1/apis/" + apiId));
+ PartitionMatrix.assertArnIn(partitionCase, created.jsonPath().getString("graphqlApi.arn"));
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void openSearchDomainArnAndEndpointHost(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "es");
+ String name = "smoke" + Long.toString(System.nanoTime(), 36);
+ Response created = signed(region, "es")
+ .contentType(JSON)
+ .body("{\"DomainName\":\"" + name + "\"}")
+ .when().post("/2021-01-01/opensearch/domain").then().statusCode(200).extract().response();
+ cleanup.register(() -> signed(region, "es").when().delete("/2021-01-01/opensearch/domain/" + name));
+ PartitionMatrix.assertArnIn(partitionCase, created.jsonPath().getString("DomainStatus.ARN"));
+ String endpoint = signed(region, "es").when().get("/2021-01-01/opensearch/domain/" + name)
+ .then().statusCode(200).extract().jsonPath().getString("DomainStatus.Endpoint");
+ assertRegionalHostIn(partitionCase, endpoint);
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void amazonMqBrokerArn(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "mq");
+ String body = """
+ {"brokerName": "%s", "engineType": "RABBITMQ",
+ "deploymentMode": "SINGLE_INSTANCE", "hostInstanceType": "mq.t3.micro",
+ "publiclyAccessible": false,
+ "users": [{"username": "admin", "password": "AdminPass123", "consoleAccess": true}]}
+ """.formatted(unique("smoke-broker", partitionCase));
+ Response created = signed(region, "mq")
+ .contentType(JSON)
+ .body(body)
+ .when().post("/v1/brokers").then().statusCode(200).extract().response();
+ String brokerId = created.jsonPath().getString("brokerId");
+ cleanup.register(() -> signed(region, "mq").when().delete("/v1/brokers/" + brokerId));
+ PartitionMatrix.assertArnIn(partitionCase, created.jsonPath().getString("brokerArn"));
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void mskClusterArn(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "kafka");
+ String arn = signed(region, "kafka")
+ .contentType(JSON)
+ .body("{\"clusterName\":\"" + unique("smoke-msk", partitionCase) + "\",\"kafkaVersion\":\"3.6.0\"}")
+ .when().post("/v1/clusters").then().statusCode(200)
+ .extract().jsonPath().getString("clusterArn");
+ cleanup.register(() -> signed(region, "kafka").when().delete("/v1/clusters/{arn}", arn));
+ PartitionMatrix.assertArnIn(partitionCase, arn);
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void elastiCacheParameterGroupArn(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "elasticache");
+ String name = unique("smoke-cpg", partitionCase);
+ String arn = signed(region, "elasticache")
+ .formParam("Action", "CreateCacheParameterGroup")
+ .formParam("Version", "2015-02-02")
+ .formParam("CacheParameterGroupName", name)
+ .formParam("CacheParameterGroupFamily", "redis7")
+ .formParam("Description", "smoke")
+ .when().post("/").then().statusCode(200)
+ .extract().xmlPath()
+ .getString("CreateCacheParameterGroupResponse.CreateCacheParameterGroupResult.CacheParameterGroup.ARN");
+ cleanup.register(() -> signed(region, "elasticache")
+ .formParam("Action", "DeleteCacheParameterGroup")
+ .formParam("Version", "2015-02-02")
+ .formParam("CacheParameterGroupName", name)
+ .when().post("/"));
+ PartitionMatrix.assertArnIn(partitionCase, arn);
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void memoryDbAclArn(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "memorydb");
+ String name = unique("smoke-acl", partitionCase);
+ String arn = json11(region, "memorydb", "AmazonMemoryDB.CreateACL",
+ "{\"ACLName\":\"" + name + "\",\"UserNames\":[\"default\"]}")
+ .when().post("/").then().statusCode(200)
+ .extract().jsonPath().getString("ACL.ARN");
+ cleanup.register(() -> json11(region, "memorydb", "AmazonMemoryDB.DeleteACL",
+ "{\"ACLName\":\"" + name + "\"}").when().post("/"));
+ PartitionMatrix.assertArnIn(partitionCase, arn);
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void route53ResolverFirewallDomainListArn(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "route53resolver");
+ String name = unique("smoke-domains", partitionCase);
+ Response created = json11(region, "route53resolver", "Route53Resolver.CreateFirewallDomainList",
+ "{\"CreatorRequestId\":\"" + name + "\",\"Name\":\"" + name + "\"}")
+ .when().post("/").then().statusCode(200).extract().response();
+ String listId = created.jsonPath().getString("FirewallDomainList.Id");
+ cleanup.register(() -> json11(region, "route53resolver", "Route53Resolver.DeleteFirewallDomainList",
+ "{\"FirewallDomainListId\":\"" + listId + "\"}").when().post("/"));
+ PartitionMatrix.assertArnIn(partitionCase, created.jsonPath().getString("FirewallDomainList.Arn"));
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void bedrockAgentCoreGatewayArnAndUrlHost(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "bedrock-agentcore");
+ String body = """
+ {"name": "%s", "authorizerType": "AWS_IAM",
+ "roleArn": "arn:%s:iam::000000000000:role/gw"}
+ """.formatted("smoke" + Long.toString(System.nanoTime(), 36), partitionCase.partition());
+ Response created = signed(region, "bedrock-agentcore")
+ .contentType(JSON)
+ .body(body)
+ .when().post("/gateways/").then().statusCode(202).extract().response();
+ String gatewayId = created.jsonPath().getString("gatewayId");
+ cleanup.register(() -> signed(region, "bedrock-agentcore").when().delete("/gateways/" + gatewayId + "/"));
+ PartitionMatrix.assertArnIn(partitionCase, created.jsonPath().getString("gatewayArn"));
+ assertRegionalHostIn(partitionCase, URI.create(created.jsonPath().getString("gatewayUrl")).getHost());
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void cloudFrontFunctionArn(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "cloudfront");
+ String name = unique("smoke-function", partitionCase);
+ String code = Base64.getEncoder().encodeToString(
+ "function handler(event) { return event.request; }".getBytes(StandardCharsets.UTF_8));
+ String body = """
+ <CreateFunctionRequest xmlns="http://cloudfront.amazonaws.com/doc/2020-05-31/">
+ <Name>%s</Name>
+ <FunctionConfig><Comment>smoke</Comment><Runtime>cloudfront-js-2.0</Runtime></FunctionConfig>
+ <FunctionCode>%s</FunctionCode>
+ </CreateFunctionRequest>
+ """.formatted(name, code);
+ Response created = signed(region, "cloudfront")
+ .contentType("application/xml")
+ .body(body)
+ .when().post("/2020-05-31/function").then().statusCode(201).extract().response();
+ String etag = created.header("ETag");
+ cleanup.register(() -> signed(region, "cloudfront")
+ .header("If-Match", etag)
+ .when().delete("/2020-05-31/function/" + name));
+ PartitionMatrix.assertGlobalArnIn(partitionCase,
+ created.xmlPath().getString("FunctionSummary.FunctionMetadata.FunctionARN"));
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void ramResourceShareArn(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "ram");
+ String arn = signed(region, "ram")
+ .contentType(JSON)
+ .body("{\"name\":\"" + unique("smoke-share", partitionCase) + "\"}")
+ .when().post("/createresourceshare").then().statusCode(200)
+ .extract().jsonPath().getString("resourceShare.resourceShareArn");
+ cleanup.register(() -> signed(region, "ram")
+ .queryParam("resourceShareArn", arn)
+ .when().delete("/deleteresourceshare"));
+ PartitionMatrix.assertArnIn(partitionCase, arn);
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void oamSinkArn(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "oam");
+ String arn = signed(region, "oam")
+ .contentType(JSON)
+ .body("{\"Name\":\"" + unique("smoke-sink", partitionCase) + "\"}")
+ .when().post("/CreateSink").then().statusCode(200)
+ .extract().jsonPath().getString("Arn");
+ cleanup.register(() -> signed(region, "oam")
+ .contentType(JSON)
+ .body("{\"Identifier\":\"" + arn + "\"}")
+ .when().post("/DeleteSink"));
+ PartitionMatrix.assertArnIn(partitionCase, arn);
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void schedulerScheduleGroupArn(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "scheduler");
+ String name = unique("smoke-group", partitionCase);
+ String arn = signed(region, "scheduler")
+ .contentType(JSON)
+ .body("{}")
+ .when().post("/schedule-groups/" + name).then().statusCode(200)
+ .extract().jsonPath().getString("ScheduleGroupArn");
+ cleanup.register(() -> signed(region, "scheduler").when().delete("/schedule-groups/" + name));
+ PartitionMatrix.assertArnIn(partitionCase, arn);
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void backupVaultArn(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "backup");
+ String name = unique("smoke-vault", partitionCase);
+ String arn = signed(region, "backup")
+ .contentType(JSON)
+ .body("{}")
+ .when().put("/backup-vaults/" + name).then().statusCode(200)
+ .extract().jsonPath().getString("BackupVaultArn");
+ cleanup.register(() -> signed(region, "backup").when().delete("/backup-vaults/" + name));
+ PartitionMatrix.assertArnIn(partitionCase, arn);
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void wafv2RegionalIpSetArn(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "wafv2");
+ String name = unique("smoke-ipset", partitionCase);
+ Response created = json11(region, "wafv2", "AWSWAF_20190729.CreateIPSet",
+ "{\"Name\":\"" + name + "\",\"Scope\":\"REGIONAL\",\"IPAddressVersion\":\"IPV4\",\"Addresses\":[]}")
+ .when().post("/").then().statusCode(200).extract().response();
+ String id = created.jsonPath().getString("Summary.Id");
+ String lockToken = created.jsonPath().getString("Summary.LockToken");
+ cleanup.register(() -> json11(region, "wafv2", "AWSWAF_20190729.DeleteIPSet",
+ "{\"Name\":\"" + name + "\",\"Scope\":\"REGIONAL\",\"Id\":\"" + id
+ + "\",\"LockToken\":\"" + lockToken + "\"}").when().post("/"));
+ PartitionMatrix.assertArnIn(partitionCase, created.jsonPath().getString("Summary.ARN"));
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void s3TablesTableBucketArn(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "s3tables");
+ String name = "smoke-" + Long.toString(System.nanoTime(), 36);
+ String arn = signed(region, "s3tables")
+ .contentType(JSON)
+ .body("{\"name\":\"" + name + "\"}")
+ .when().put("/buckets").then().statusCode(200)
+ .extract().jsonPath().getString("arn");
+ cleanup.register(() -> signed(region, "s3tables").when().delete("/buckets/{arn}", arn));
+ PartitionMatrix.assertArnIn(partitionCase, arn);
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void guardDutyDetectorServiceRoleArn(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "guardduty");
+ String detectorId = signed(region, "guardduty")
+ .contentType(JSON)
+ .body("{\"enable\":true}")
+ .when().post("/detector").then().statusCode(200)
+ .extract().jsonPath().getString("detectorId");
+ cleanup.register(() -> signed(region, "guardduty").when().delete("/detector/" + detectorId));
+ String serviceRole = signed(region, "guardduty").when().get("/detector/" + detectorId)
+ .then().statusCode(200).extract().jsonPath().getString("serviceRole");
+ PartitionMatrix.assertGlobalArnIn(partitionCase, serviceRole);
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void costExplorerAnomalyMonitorArn(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "ce");
+ String body = """
+ {"AnomalyMonitor": {"MonitorName": "%s", "MonitorType": "DIMENSIONAL",
+ "MonitorDimension": "SERVICE"}}
+ """.formatted(unique("smoke-monitor", partitionCase));
+ String arn = json11(region, "ce", "AWSInsightsIndexService.CreateAnomalyMonitor", body)
+ .when().post("/").then().statusCode(200)
+ .extract().jsonPath().getString("MonitorArn");
+ cleanup.register(() -> json11(region, "ce", "AWSInsightsIndexService.DeleteAnomalyMonitor",
+ "{\"MonitorArn\":\"" + arn + "\"}").when().post("/"));
+ PartitionMatrix.assertGlobalArnIn(partitionCase, arn);
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void autoScalingLaunchConfigurationArn(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "autoscaling");
+ String name = unique("smoke-lc", partitionCase);
+ signed(region, "autoscaling")
+ .formParam("Action", "CreateLaunchConfiguration")
+ .formParam("Version", "2011-01-01")
+ .formParam("LaunchConfigurationName", name)
+ .formParam("ImageId", "ami-12345678")
+ .formParam("InstanceType", "t3.micro")
+ .when().post("/").then().statusCode(200);
+ cleanup.register(() -> signed(region, "autoscaling")
+ .formParam("Action", "DeleteLaunchConfiguration")
+ .formParam("Version", "2011-01-01")
+ .formParam("LaunchConfigurationName", name)
+ .when().post("/"));
+ String arn = signed(region, "autoscaling")
+ .formParam("Action", "DescribeLaunchConfigurations")
+ .formParam("Version", "2011-01-01")
+ .formParam("LaunchConfigurationNames.member.1", name)
+ .when().post("/").then().statusCode(200)
+ .extract().xmlPath().getString("DescribeLaunchConfigurationsResponse.DescribeLaunchConfigurationsResult"
+ + ".LaunchConfigurations.member.LaunchConfigurationARN");
+ PartitionMatrix.assertArnIn(partitionCase, arn);
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void applicationAutoScalingScalableTargetArn(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "application-autoscaling");
+ String resourceId = "table/" + unique("smoke-table", partitionCase);
+ String target = """
+ "ServiceNamespace": "dynamodb", "ResourceId": "%s",
+ "ScalableDimension": "dynamodb:table:ReadCapacityUnits"
+ """.formatted(resourceId);
+ String arn = json11(region, "application-autoscaling", "AnyScaleFrontendService.RegisterScalableTarget",
+ "{" + target + ", \"MinCapacity\": 1, \"MaxCapacity\": 5}")
+ .when().post("/").then().statusCode(200)
+ .extract().jsonPath().getString("ScalableTargetARN");
+ cleanup.register(() -> json11(region, "application-autoscaling",
+ "AnyScaleFrontendService.DeregisterScalableTarget", "{" + target + "}").when().post("/"));
+ PartitionMatrix.assertArnIn(partitionCase, arn);
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void codeDeployOnPremisesInstanceArn(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "codedeploy");
+ String name = unique("smoke-instance", partitionCase);
+ json11(region, "codedeploy", "CodeDeploy_20141006.RegisterOnPremisesInstance",
+ "{\"instanceName\":\"" + name + "\",\"iamUserArn\":\"arn:" + partitionCase.partition()
+ + ":iam::000000000000:user/codedeploy-agent\"}")
+ .when().post("/").then().statusCode(200);
+ cleanup.register(() -> json11(region, "codedeploy", "CodeDeploy_20141006.DeregisterOnPremisesInstance",
+ "{\"instanceName\":\"" + name + "\"}").when().post("/"));
+ String arn = json11(region, "codedeploy", "CodeDeploy_20141006.GetOnPremisesInstance",
+ "{\"instanceName\":\"" + name + "\"}")
+ .when().post("/").then().statusCode(200)
+ .extract().jsonPath().getString("instanceInfo.instanceArn");
+ PartitionMatrix.assertArnIn(partitionCase, arn);
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void configRuleArn(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "config");
+ String name = unique("smoke-rule", partitionCase);
+ String body = """
+ {"ConfigRule": {"ConfigRuleName": "%s",
+ "Source": {"Owner": "AWS", "SourceIdentifier": "S3_BUCKET_VERSIONING_ENABLED"}}}
+ """.formatted(name);
+ json11(region, "config", "StarlingDoveService.PutConfigRule", body)
+ .when().post("/").then().statusCode(200);
+ cleanup.register(() -> json11(region, "config", "StarlingDoveService.DeleteConfigRule",
+ "{\"ConfigRuleName\":\"" + name + "\"}").when().post("/"));
+ String arn = json11(region, "config", "StarlingDoveService.DescribeConfigRules",
+ "{\"ConfigRuleNames\":[\"" + name + "\"]}")
+ .when().post("/").then().statusCode(200)
+ .extract().jsonPath().getString("ConfigRules[0].ConfigRuleArn");
+ PartitionMatrix.assertArnIn(partitionCase, arn);
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void controlTowerBaselineArn(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "controltower");
+ String arn = signed(region, "controltower")
+ .contentType(JSON)
+ .body("{}")
+ .when().post("/list-baselines").then().statusCode(200)
+ .extract().jsonPath().getString("baselines[0].arn");
+ PartitionMatrix.assertArnIn(partitionCase, arn);
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void lambdaMicrovmsManagedImageArn(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "lambda");
+ String arn = signed(region, "lambda").when().get("/2025-09-09/managed-microvm-images")
+ .then().statusCode(200).extract().jsonPath().getString("items[0].imageArn");
+ PartitionMatrix.assertArnIn(partitionCase, arn);
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void dlmLifecyclePolicyArn(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "dlm");
+ String body = """
+ {"ExecutionRoleArn": "arn:%s:iam::000000000000:role/dlm",
+ "Description": "smoke", "State": "ENABLED",
+ "PolicyDetails": {"PolicyType": "EBS_SNAPSHOT_MANAGEMENT", "ResourceTypes": ["VOLUME"],
+ "TargetTags": [{"Key": "backup", "Value": "true"}],
+ "Schedules": [{"Name": "daily", "CreateRule": {"Interval": 24, "IntervalUnit": "HOURS"},
+ "RetainRule": {"Count": 7}}]}}
+ """.formatted(partitionCase.partition());
+ String policyId = signed(region, "dlm")
+ .contentType(JSON)
+ .body(body)
+ .when().post("/policies").then().statusCode(200)
+ .extract().jsonPath().getString("PolicyId");
+ cleanup.register(() -> signed(region, "dlm").when().delete("/policies/" + policyId));
+ String arn = signed(region, "dlm").when().get("/policies/" + policyId)
+ .then().statusCode(200).extract().jsonPath().getString("Policy.PolicyArn");
+ PartitionMatrix.assertArnIn(partitionCase, arn);
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void networkFirewallRuleGroupArn(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "network-firewall");
+ String name = unique("smoke-rules", partitionCase);
+ String arn = json10(region, "network-firewall", "NetworkFirewall_20201112.CreateRuleGroup",
+ "{\"RuleGroupName\":\"" + name + "\",\"Type\":\"STATEFUL\",\"Capacity\":100,"
+ + "\"RuleGroup\":{\"RulesSource\":{\"RulesString\":\"pass ip any any\"}}}")
+ .when().post("/").then().statusCode(200)
+ .extract().jsonPath().getString("RuleGroupResponse.RuleGroupArn");
+ cleanup.register(() -> json10(region, "network-firewall", "NetworkFirewall_20201112.DeleteRuleGroup",
+ "{\"RuleGroupName\":\"" + name + "\",\"Type\":\"STATEFUL\"}").when().post("/"));
+ PartitionMatrix.assertArnIn(partitionCase, arn);
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void cloudMapNamespaceArn(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "servicediscovery");
+ String target = "Route53AutoNaming_v20170314.";
+ String operationId = json11(region, "servicediscovery", target + "CreateHttpNamespace",
+ "{\"Name\":\"" + unique("smoke-ns", partitionCase) + "\"}")
+ .when().post("/").then().statusCode(200)
+ .extract().jsonPath().getString("OperationId");
+ String getOperation = "{\"OperationId\":\"" + operationId + "\"}";
+ cleanup.register(() -> json11(region, "servicediscovery", target + "DeleteNamespace",
+ "{\"Id\":\"" + json11(region, "servicediscovery", target + "GetOperation", getOperation)
+ .when().post("/").jsonPath().getString("Operation.Targets.NAMESPACE") + "\"}")
+ .when().post("/"));
+ String namespaceId = json11(region, "servicediscovery", target + "GetOperation", getOperation)
+ .when().post("/").then().statusCode(200)
+ .extract().jsonPath().getString("Operation.Targets.NAMESPACE");
+ String arn = json11(region, "servicediscovery", target + "GetNamespace", "{\"Id\":\"" + namespaceId + "\"}")
+ .when().post("/").then().statusCode(200)
+ .extract().jsonPath().getString("Namespace.Arn");
+ PartitionMatrix.assertArnIn(partitionCase, arn);
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void accessAnalyzerArn(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "access-analyzer");
+ String name = unique("smoke-analyzer", partitionCase);
+ String arn = signed(region, "access-analyzer")
+ .contentType(JSON)
+ .body("{\"analyzerName\":\"" + name + "\",\"type\":\"ACCOUNT\"}")
+ .when().put("/analyzer").then().statusCode(200)
+ .extract().jsonPath().getString("arn");
+ cleanup.register(() -> signed(region, "access-analyzer").when().delete("/analyzer/" + name));
+ PartitionMatrix.assertArnIn(partitionCase, arn);
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void prometheusWorkspaceArnAndEndpointHost(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "aps");
+ Response created = signed(region, "aps")
+ .contentType(JSON)
+ .body("{\"alias\":\"" + unique("smoke-workspace", partitionCase) + "\"}")
+ .when().post("/workspaces").then().statusCode(202).extract().response();
+ String workspaceId = created.jsonPath().getString("workspaceId");
+ cleanup.register(() -> signed(region, "aps").when().delete("/workspaces/" + workspaceId));
+ PartitionMatrix.assertArnIn(partitionCase, created.jsonPath().getString("arn"));
+ String endpoint = signed(region, "aps").when().get("/workspaces/" + workspaceId)
+ .then().statusCode(200).extract().jsonPath().getString("workspace.prometheusEndpoint");
+ assertRegionalHostIn(partitionCase, URI.create(endpoint).getHost());
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void bedrockGuardrailArn(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "bedrock");
+ String body = """
+ {"name": "%s", "blockedInputMessaging": "blocked", "blockedOutputsMessaging": "blocked",
+ "contentPolicyConfig": {"filtersConfig": [
+ {"type": "HATE", "inputStrength": "HIGH", "outputStrength": "HIGH"}]}}
+ """.formatted(unique("smoke-guardrail", partitionCase));
+ Response created = signed(region, "bedrock")
+ .contentType(JSON)
+ .body(body)
+ .when().post("/guardrails").then().statusCode(202).extract().response();
+ String guardrailId = created.jsonPath().getString("guardrailId");
+ cleanup.register(() -> signed(region, "bedrock").when().delete("/guardrails/" + guardrailId));
+ PartitionMatrix.assertArnIn(partitionCase, created.jsonPath().getString("guardrailArn"));
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void connectInstanceArnAndServiceRole(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "connect");
+ String body = """
+ {"IdentityManagementType": "CONNECT_MANAGED", "InstanceAlias": "%s",
+ "InboundCallsEnabled": true, "OutboundCallsEnabled": false}
+ """.formatted(unique("smoke-connect", partitionCase));
+ Response created = signed(region, "connect")
+ .contentType(JSON)
+ .body(body)
+ .when().put("/instance").then().statusCode(200).extract().response();
+ String instanceId = created.jsonPath().getString("Id");
+ cleanup.register(() -> signed(region, "connect").when().delete("/instance/" + instanceId));
+ PartitionMatrix.assertArnIn(partitionCase, created.jsonPath().getString("Arn"));
+ String serviceRole = signed(region, "connect").when().get("/instance/" + instanceId)
+ .then().statusCode(200).extract().jsonPath().getString("Instance.ServiceRole");
+ PartitionMatrix.assertGlobalArnIn(partitionCase, serviceRole);
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void controlCatalogControlArn(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "controlcatalog");
+ String arn = signed(region, "controlcatalog")
+ .contentType(JSON)
+ .body("{}")
+ .when().post("/list-controls").then().statusCode(200)
+ .extract().jsonPath().getString("Controls[0].Arn");
+ PartitionMatrix.assertGlobalArnIn(partitionCase, arn);
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void dataSyncAgentArn(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "datasync");
+ String arn = json11(region, "datasync", "FmrsService.CreateAgent",
+ "{\"ActivationKey\":\"AAAAA-1AAAA-BB1CC-DDDDD-EEEEE\",\"AgentName\":\""
+ + unique("smoke-agent", partitionCase) + "\"}")
+ .when().post("/").then().statusCode(200)
+ .extract().jsonPath().getString("AgentArn");
+ cleanup.register(() -> json11(region, "datasync", "FmrsService.DeleteAgent",
+ "{\"AgentArn\":\"" + arn + "\"}").when().post("/"));
+ PartitionMatrix.assertArnIn(partitionCase, arn);
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void emrClusterArn(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "elasticmapreduce");
+ String body = """
+ {"Name": "%s", "ReleaseLabel": "emr-7.5.0",
+ "Instances": {"KeepJobFlowAliveWhenNoSteps": true, "InstanceGroups": [
+ {"Name": "master", "InstanceRole": "MASTER", "InstanceType": "m5.xlarge", "InstanceCount": 1}]}}
+ """.formatted(unique("smoke-emr", partitionCase));
+ Response created = json11(region, "elasticmapreduce", "ElasticMapReduce.RunJobFlow", body)
+ .when().post("/").then().statusCode(200).extract().response();
+ String clusterId = created.jsonPath().getString("JobFlowId");
+ cleanup.register(() -> json11(region, "elasticmapreduce", "ElasticMapReduce.TerminateJobFlows",
+ "{\"JobFlowIds\":[\"" + clusterId + "\"]}").when().post("/"));
+ PartitionMatrix.assertArnIn(partitionCase, created.jsonPath().getString("ClusterArn"));
+ }
+
+ @ParameterizedTest
+ @MethodSource("nonCommercialCases")
+ void emrServerlessApplicationArn(PartitionCase partitionCase) {
+ String region = offered(partitionCase, "emr-serverless");
+ String body = """
+ {"name": "%s", "releaseLabel": "emr-7.0.0", "type": "SPARK", "clientToken": "%s"}
+ """.formatted(unique("smoke-app", partitionCase), unique("token", partitionCase));
+ Response created = signed(region, "emr-serverless")
+ .contentType(JSON)
+ .body(body)
+ .when().post("/applications").then().statusCode(200).extract().response();
+ String applicationId = created.jsonPath().getString("applicationId");
+ cleanup.register(() -> signed(region, "emr-serverless").when().delete("/applications/" + applicationId));
+ PartitionMatrix.assertArnIn(partitionCase, created.jsonPath().getString("arn"));
+ }
+
+ /**
+ * The case's region, or the test is skipped where the partition does not publish the service.
+ * A service no partition lists (the newer ones {@code endpoints.json} omits) runs everywhere,
+ * the same reading strict partition mode applies: silence there is not absence.
+ */
private static String offered(PartitionCase partitionCase, String signingName) {
- assumeTrue(AwsPartitions.byId(partitionCase.partition()).offersSigningName(signingName),
+ assumeTrue(!AwsPartitions.publishesSomewhere(signingName)
+ || AwsPartitions.byId(partitionCase.partition()).offersSigningName(signingName),
partitionCase.partition() + " does not offer " + signingName);
return partitionCase.region();
}
+ /** The host is in the case's partition and names the case's region, not another one of that partition. */
+ private static void assertRegionalHostIn(PartitionCase partitionCase, String host) {
+ PartitionMatrix.assertHostIn(partitionCase, host);
+ assertTrue(host.contains("." + partitionCase.region() + "."),
+ host + " should name the region " + partitionCase.region());
+ }
+
private static String unique(String prefix, PartitionCase partitionCase) {
return prefix + "-" + partitionCase.partition() + "-" + Long.toString(System.nanoTime(), 36);
}
@@ -260,6 +1109,13 @@ class PartitionCrossServiceSmokeIntegrationTest {
return given().header("Authorization", PartitionMatrix.sigV4Auth(region, signingName));
}
+ private static RequestSpecification json10(String region, String signingName, String target, String body) {
+ return signed(region, signingName)
+ .header("X-Amz-Target", target)
+ .contentType(JSON_1_0)
+ .body(body);
+ }
+
private static RequestSpecification json11(String region, String signingName, String target, String body) {
return signed(region, signingName)
.header("X-Amz-Target", target)
diff --git a/src/test/resources/partition/smoke-exemptions.tsv b/src/test/resources/partition/smoke-exemptions.tsv
index f7b98adf2d..4cd9246050 100644
--- a/src/test/resources/partition/smoke-exemptions.tsv
+++ b/src/test/resources/partition/smoke-exemptions.tsv
@@ -2,90 +2,45 @@
# package<TAB>reason. PartitionSmokeInventoryTest fails on a minting package missing from both,
# and on a row whose package no longer mints or is now covered. Shrink this file, never grow it
# without a reason.
-accessanalyzer not yet covered (BL-249 follow-up)
-amazonmq not yet covered (BL-249 follow-up)
-apigateway not yet covered (BL-249 follow-up)
appintegrations not yet covered (BL-249 follow-up)
-applicationautoscaling not yet covered (BL-249 follow-up)
-appsync not yet covered (BL-249 follow-up)
-aps not yet covered (BL-249 follow-up)
-autoscaling not yet covered (BL-249 follow-up)
-backup not yet covered (BL-249 follow-up)
bcmdataexports not yet covered (BL-249 follow-up)
-bedrock not yet covered (BL-249 follow-up)
-bedrockagentcorecontrol not yet covered (BL-249 follow-up)
-ce not yet covered (BL-249 follow-up)
cloudformation covered by PartitionArnMintingIntegrationTest (aws-cn only)
-cloudfront not yet covered (BL-249 follow-up)
cloudhsmv2 not yet covered (BL-249 follow-up)
-cloudmap not yet covered (BL-249 follow-up)
cloudtrail covered by CloudTrailSelfDeliveryTest (one partition)
-cloudwatch not yet covered (BL-249 follow-up)
codeartifact not yet covered (BL-249 follow-up)
-codedeploy not yet covered (BL-249 follow-up)
codegurureviewer not yet covered (BL-249 follow-up)
codepipeline not yet covered (BL-249 follow-up)
-cognito not yet covered (BL-249 follow-up)
cognitoidentity identity pool ARN is never returned and ARN lookup ignores the partition, nothing to assert
-configservice not yet covered (BL-249 follow-up)
-connect not yet covered (BL-249 follow-up)
-controlcatalog not yet covered (BL-249 follow-up)
-controltower not yet covered (BL-249 follow-up)
-datasync not yet covered (BL-249 follow-up)
-detective not yet covered (BL-249 follow-up)
-dlm not yet covered (BL-249 follow-up)
+detective the graph exists only once an organization admin is designated, and nothing removes it, so a case would leak state into the shared emulator
dms not yet covered (BL-249 follow-up)
docdb not yet covered (BL-249 follow-up)
-dynamodb not yet covered (BL-249 follow-up)
-ec2 not yet covered (BL-249 follow-up)
ecr not yet covered (BL-249 follow-up)
-ecs not yet covered (BL-249 follow-up)
-eks not yet covered (BL-249 follow-up)
-elasticache not yet covered (BL-249 follow-up)
elasticbeanstalk not yet covered (BL-249 follow-up)
-emr not yet covered (BL-249 follow-up)
-emrserverless not yet covered (BL-249 follow-up)
-eventbridge not yet covered (BL-249 follow-up)
fis not yet covered (BL-249 follow-up)
globalaccelerator not yet covered (BL-249 follow-up)
-guardduty not yet covered (BL-249 follow-up)
iam covered by IamPartitionArnIntegrationTest (all partitions)
kinesisanalytics not yet covered (BL-249 follow-up)
kms covered by PartitionArnMintingIntegrationTest (aws-cn only)
lambda covered by LambdaLayerChinaIntegrationTest (aws-cn layers only)
-lambdamicrovms not yet covered (BL-249 follow-up)
lightsail not yet covered (BL-249 follow-up)
macie2 not yet covered (BL-249 follow-up)
marketplace not yet covered (BL-249 follow-up)
-memorydb not yet covered (BL-249 follow-up)
-msk not yet covered (BL-249 follow-up)
mwaa not yet covered (BL-249 follow-up)
neptune not yet covered (BL-249 follow-up)
-networkfirewall not yet covered (BL-249 follow-up)
-oam not yet covered (BL-249 follow-up)
-opensearch not yet covered (BL-249 follow-up)
organizations not yet covered (BL-249 follow-up)
pipes not yet covered (BL-249 follow-up)
-ram not yet covered (BL-249 follow-up)
-rds not yet covered (BL-249 follow-up)
redshift not yet covered (BL-249 follow-up)
redshiftdata not yet covered (BL-249 follow-up)
redshiftserverless not yet covered (BL-249 follow-up)
resourceexplorer2 not yet covered (BL-249 follow-up)
-route53resolver not yet covered (BL-249 follow-up)
rum not yet covered (BL-249 follow-up)
s3 covered by S3PartitionIntegrationTest (aws-cn only)
-s3tables not yet covered (BL-249 follow-up)
s3vectors not yet covered (BL-249 follow-up)
sagemaker not yet covered (BL-249 follow-up)
-scheduler not yet covered (BL-249 follow-up)
-secretsmanager not yet covered (BL-249 follow-up)
-securityhub not yet covered (BL-249 follow-up)
+securityhub every ARN needs the hub enabled and DisableSecurityHub is not served, so a case would leave the hub enabled in each partition's region
servicecatalog covered by PartitionArnMintingIntegrationTest (aws-cn only)
servicequotas not yet covered (BL-249 follow-up)
-ses not yet covered (BL-249 follow-up)
signin not yet covered (BL-249 follow-up)
-sqs not yet covered (BL-249 follow-up)
ssm covered by PartitionArnMintingIntegrationTest (aws-cn only)
ssoadmin one instance per account, minted in its primary region's partition, so a request signed in another partition sees that ARN (BL-243)
ssoportal not yet covered (BL-249 follow-up)
@@ -94,4 +49,3 @@ swf not yet covered (BL-249 follow-up)
timestreaminfluxdb not yet covered (BL-249 follow-up)
transfer not yet covered (BL-249 follow-up)
verifiedpermissions not yet covered (BL-249 follow-up)
-wafv2 not yet covered (BL-249 follow-up)