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.javaindex 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.tsvindex 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 emulatordms 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 regionservicecatalog 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)