Light, fluffy, and always free - The AWS Local Emulator alternative
test(partition): finish the cross-partition smoke coverage for every minting service (#5464)
Hector Ventura48d60e792909
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 ea0339c6dd..9aeb745fbe 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@@ -5,6 +5,7 @@ import io.github.hectorvent.floci.testing.PartitionMatrix;import io.github.hectorvent.floci.testing.PartitionMatrix.PartitionCase;import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;import io.quarkus.test.junit.QuarkusTest;+import io.restassured.path.json.config.JsonPathConfig;import io.restassured.response.Response;import io.restassured.specification.RequestSpecification;import org.junit.jupiter.api.BeforeAll;@@ -39,12 +40,15 @@ class PartitionCrossServiceSmokeIntegrationTest {static final Set<String> COVERED_PACKAGES = Set.of("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");+ "aps", "autoscaling", "backup", "batch", "bcmdataexports", "bedrock", "bedrockagentcorecontrol", "ce",+ "cloudfront", "cloudmap", "cloudwatch", "codebuild", "codedeploy", "codepipeline", "cognito",+ "configservice", "connect", "controlcatalog", "controltower", "datasync", "dlm", "dms", "dynamodb", "ec2",+ "ecr", "ecs", "efs", "eks", "elasticache", "elasticbeanstalk", "elbv2", "emr", "emrserverless",+ "eventbridge", "firehose", "fis", "glue", "guardduty", "iot", "kinesis", "kinesisanalytics",+ "lambdamicrovms", "memorydb", "msk", "mwaa", "networkfirewall", "oam", "opensearch", "organizations",+ "pipes", "ram", "rds", "redshift", "redshiftserverless", "resourceexplorer2", "route53resolver",+ "s3tables", "s3vectors", "sagemaker", "scheduler", "secretsmanager", "servicequotas", "ses", "sns", "sqs",+ "timestreaminfluxdb", "transfer", "verifiedpermissions", "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";@@ -1082,6 +1086,317 @@ class PartitionCrossServiceSmokeIntegrationTest {PartitionMatrix.assertArnIn(partitionCase, created.jsonPath().getString("arn"));}+ @ParameterizedTest+ @MethodSource("nonCommercialCases")+ void bcmDataExportsExportArn(PartitionCase partitionCase) {+ String region = offered(partitionCase, "bcm-data-exports");+ String target = "AWSBillingAndCostManagementDataExports.";+ String body = "{\"Export\":{\"Name\":\"" + unique("smoke-export", partitionCase) + "\","+ + "\"DataQuery\":{\"QueryStatement\":\"SELECT * FROM COST_AND_USAGE_REPORT\"},"+ + "\"DestinationConfigurations\":{\"S3Destination\":{\"S3Bucket\":\"smoke-bucket\","+ + "\"S3Prefix\":\"out/\",\"S3Region\":\"" + region + "\",\"S3OutputConfigurations\":{"+ + "\"Format\":\"PARQUET\",\"Compression\":\"PARQUET\",\"OutputType\":\"CUSTOM\","+ + "\"Overwrite\":\"OVERWRITE_REPORT\"}}},\"RefreshCadence\":{\"Frequency\":\"SYNCHRONOUS\"}}}";+ String arn = json11(region, "bcm-data-exports", target + "CreateExport", body)+ .when().post("/").then().statusCode(200)+ .extract().jsonPath().getString("ExportArn");+ cleanup.register(() -> json11(region, "bcm-data-exports", target + "DeleteExport",+ "{\"ExportArn\":\"" + arn + "\"}").when().post("/"));+ PartitionMatrix.assertArnIn(partitionCase, arn);+ }++ @ParameterizedTest+ @MethodSource("nonCommercialCases")+ void fisExperimentTemplateArn(PartitionCase partitionCase) {+ String region = offered(partitionCase, "fis");+ Response created = signed(region, "fis")+ .contentType(JSON)+ .body("{\"clientToken\":\"" + unique("smoke-token", partitionCase) + "\",\"description\":\"smoke\","+ + "\"roleArn\":\"arn:" + partitionCase.partition() + ":iam::000000000000:role/fis-role\","+ + "\"stopConditions\":[{\"source\":\"none\"}],\"targets\":{},"+ + "\"actions\":{\"wait\":{\"actionId\":\"aws:fis:wait\",\"parameters\":{\"duration\":\"PT1M\"}}}}")+ .when().post("/experimentTemplates").then().statusCode(200).extract().response();+ String templateId = created.jsonPath().getString("experimentTemplate.id");+ cleanup.register(() -> signed(region, "fis").when().delete("/experimentTemplates/" + templateId));+ PartitionMatrix.assertArnIn(partitionCase, created.jsonPath().getString("experimentTemplate.arn"));+ }++ @ParameterizedTest+ @MethodSource("nonCommercialCases")+ void pipesPipeArn(PartitionCase partitionCase) {+ String region = offered(partitionCase, "pipes");+ String name = unique("smoke-pipe", partitionCase);+ String queuePrefix = "arn:" + partitionCase.partition() + ":sqs:" + region + ":000000000000:";+ String arn = signed(region, "pipes")+ .contentType(JSON)+ .body("{\"Source\":\"" + queuePrefix + "smoke-source\",\"Target\":\"" + queuePrefix + "smoke-target\","+ + "\"RoleArn\":\"arn:" + partitionCase.partition() + ":iam::000000000000:role/pipe-role\","+ + "\"DesiredState\":\"STOPPED\"}")+ .when().post("/v1/pipes/" + name).then().statusCode(200)+ .extract().jsonPath().getString("Arn");+ cleanup.register(() -> signed(region, "pipes").when().delete("/v1/pipes/" + name));+ PartitionMatrix.assertArnIn(partitionCase, arn);+ }++ @ParameterizedTest+ @MethodSource("nonCommercialCases")+ void s3VectorsVectorBucketArn(PartitionCase partitionCase) {+ String region = offered(partitionCase, "s3vectors");+ String body = "{\"vectorBucketName\":\"" + unique("smoke-vectors", partitionCase) + "\"}";+ String arn = signed(region, "s3vectors")+ .contentType(JSON)+ .body(body)+ .when().post("/CreateVectorBucket").then().statusCode(200)+ .extract().jsonPath().getString("vectorBucketArn");+ cleanup.register(() -> signed(region, "s3vectors").contentType(JSON).body(body)+ .when().post("/DeleteVectorBucket"));+ PartitionMatrix.assertArnIn(partitionCase, arn);+ }++ @ParameterizedTest+ @MethodSource("nonCommercialCases")+ void serviceQuotasQuotaArn(PartitionCase partitionCase) {+ String region = offered(partitionCase, "servicequotas");+ String arn = json11(region, "servicequotas", "ServiceQuotasV20190624.ListServiceQuotas",+ "{\"ServiceCode\":\"codebuild\"}")+ .when().post("/").then().statusCode(200)+ .extract().jsonPath().getString("Quotas[0].QuotaArn");+ PartitionMatrix.assertArnIn(partitionCase, arn);+ }++ @ParameterizedTest+ @MethodSource("nonCommercialCases")+ void transferServerArn(PartitionCase partitionCase) {+ String region = offered(partitionCase, "transfer");+ String serverId = json11(region, "transfer", "TransferService.CreateServer", "{}")+ .when().post("/").then().statusCode(200)+ .extract().jsonPath().getString("ServerId");+ String byId = "{\"ServerId\":\"" + serverId + "\"}";+ cleanup.register(() -> json11(region, "transfer", "TransferService.DeleteServer", byId).when().post("/"));+ String arn = json11(region, "transfer", "TransferService.DescribeServer", byId)+ .when().post("/").then().statusCode(200)+ .extract().jsonPath().getString("Server.Arn");+ PartitionMatrix.assertArnIn(partitionCase, arn);+ }++ @ParameterizedTest+ @MethodSource("nonCommercialCases")+ void verifiedPermissionsPolicyStoreArn(PartitionCase partitionCase) {+ String region = offered(partitionCase, "verifiedpermissions");+ Response created = json10(region, "verifiedpermissions", "VerifiedPermissions.CreatePolicyStore",+ "{\"validationSettings\":{\"mode\":\"OFF\"}}")+ .when().post("/").then().statusCode(200).extract().response();+ String policyStoreId = created.jsonPath().getString("policyStoreId");+ cleanup.register(() -> json10(region, "verifiedpermissions", "VerifiedPermissions.DeletePolicyStore",+ "{\"policyStoreId\":\"" + policyStoreId + "\"}").when().post("/"));+ PartitionMatrix.assertArnIn(partitionCase, created.jsonPath().getString("arn"));+ }++ @ParameterizedTest+ @MethodSource("nonCommercialCases")+ void codePipelineWebhookArn(PartitionCase partitionCase) {+ String region = offered(partitionCase, "codepipeline");+ String name = unique("smoke-webhook", partitionCase);+ String arn = json11(region, "codepipeline", "CodePipeline_20150709.PutWebhook",+ "{\"webhook\":{\"name\":\"" + name + "\"}}")+ .when().post("/").then().statusCode(200)+ .extract().jsonPath().getString("webhook.arn");+ cleanup.register(() -> json11(region, "codepipeline", "CodePipeline_20150709.DeleteWebhook",+ "{\"name\":\"" + name + "\"}").when().post("/"));+ PartitionMatrix.assertArnIn(partitionCase, arn);+ }++ @ParameterizedTest+ @MethodSource("nonCommercialCases")+ void dmsEndpointArn(PartitionCase partitionCase) {+ String region = offered(partitionCase, "dms");+ String arn = json11(region, "dms", "AmazonDMSv20160101.CreateEndpoint",+ "{\"EndpointIdentifier\":\"" + unique("smoke-dms", partitionCase)+ + "\",\"EndpointType\":\"source\",\"EngineName\":\"mysql\"}")+ .when().post("/").then().statusCode(200)+ .extract().jsonPath().getString("Endpoint.EndpointArn");+ cleanup.register(() -> json11(region, "dms", "AmazonDMSv20160101.DeleteEndpoint",+ "{\"EndpointArn\":\"" + arn + "\"}").when().post("/"));+ PartitionMatrix.assertArnIn(partitionCase, arn);+ }++ @ParameterizedTest+ @MethodSource("nonCommercialCases")+ void ecrRepositoryArn(PartitionCase partitionCase) {+ String region = offered(partitionCase, "ecr");+ String name = unique("smoke-repo", partitionCase);+ String target = "AmazonEC2ContainerRegistry_V20150921.";+ String arn = json11(region, "ecr", target + "CreateRepository", "{\"repositoryName\":\"" + name + "\"}")+ .when().post("/").then().statusCode(200)+ .extract().jsonPath().getString("repository.repositoryArn");+ cleanup.register(() -> json11(region, "ecr", target + "DeleteRepository",+ "{\"repositoryName\":\"" + name + "\",\"force\":true}").when().post("/"));+ PartitionMatrix.assertArnIn(partitionCase, arn);+ }++ @ParameterizedTest+ @MethodSource("nonCommercialCases")+ void elasticBeanstalkApplicationArn(PartitionCase partitionCase) {+ String region = offered(partitionCase, "elasticbeanstalk");+ String name = unique("smoke-app", partitionCase);+ String arn = signed(region, "elasticbeanstalk")+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "CreateApplication")+ .formParam("ApplicationName", name)+ .when().post("/").then().statusCode(200)+ .extract().xmlPath()+ .getString("CreateApplicationResponse.CreateApplicationResult.Application.ApplicationArn");+ cleanup.register(() -> signed(region, "elasticbeanstalk")+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "DeleteApplication")+ .formParam("ApplicationName", name)+ .when().post("/"));+ PartitionMatrix.assertArnIn(partitionCase, arn);+ }++ @ParameterizedTest+ @MethodSource("nonCommercialCases")+ void kinesisAnalyticsApplicationArn(PartitionCase partitionCase) {+ String region = offered(partitionCase, "kinesisanalytics");+ String name = unique("smoke-flink", partitionCase);+ String target = "KinesisAnalytics_20180523.";+ Response created = json11(region, "kinesisanalytics", target + "CreateApplication",+ "{\"ApplicationName\":\"" + name + "\",\"RuntimeEnvironment\":\"FLINK-1_18\","+ + "\"ServiceExecutionRole\":\"arn:" + partitionCase.partition()+ + ":iam::000000000000:role/flink-role\"}")+ .when().post("/").then().statusCode(200).extract().response();+ // DeleteApplication matches CreateTimestamp to the second, and the default float extraction rounds it.+ String createTimestamp = created.jsonPath(new JsonPathConfig(JsonPathConfig.NumberReturnType.BIG_DECIMAL))+ .getString("ApplicationDetail.CreateTimestamp");+ cleanup.register(() -> json11(region, "kinesisanalytics", target + "DeleteApplication",+ "{\"ApplicationName\":\"" + name + "\",\"CreateTimestamp\":" + createTimestamp + "}")+ .when().post("/"));+ PartitionMatrix.assertArnIn(partitionCase, created.jsonPath().getString("ApplicationDetail.ApplicationARN"));+ }++ @ParameterizedTest+ @MethodSource("nonCommercialCases")+ void redshiftServerlessNamespaceArn(PartitionCase partitionCase) {+ String region = offered(partitionCase, "redshift-serverless");+ String body = "{\"namespaceName\":\"" + unique("smoke-namespace", partitionCase) + "\"}";+ String arn = json11(region, "redshift-serverless", "RedshiftServerless.CreateNamespace", body)+ .when().post("/").then().statusCode(200)+ .extract().jsonPath().getString("namespace.namespaceArn");+ cleanup.register(() -> json11(region, "redshift-serverless", "RedshiftServerless.DeleteNamespace", body)+ .when().post("/"));+ PartitionMatrix.assertArnIn(partitionCase, arn);+ }++ @ParameterizedTest+ @MethodSource("nonCommercialCases")+ void resourceExplorerViewArn(PartitionCase partitionCase) {+ String region = offered(partitionCase, "resource-explorer-2");+ String arn = signed(region, "resource-explorer-2")+ .contentType(JSON)+ .body("{\"ViewName\":\"" + unique("smoke-view", partitionCase) + "\"}")+ .when().post("/CreateView").then().statusCode(200)+ .extract().jsonPath().getString("View.ViewArn");+ cleanup.register(() -> signed(region, "resource-explorer-2").contentType(JSON)+ .body("{\"ViewArn\":\"" + arn + "\"}").when().post("/DeleteView"));+ PartitionMatrix.assertArnIn(partitionCase, arn);+ }++ @ParameterizedTest+ @MethodSource("nonCommercialCases")+ void sageMakerModelArn(PartitionCase partitionCase) {+ String region = offered(partitionCase, "sagemaker");+ String name = unique("smoke-model", partitionCase);+ String arn = json11(region, "sagemaker", "SageMaker.CreateModel",+ "{\"ModelName\":\"" + name + "\",\"PrimaryContainer\":{\"Image\":\"busybox:stable\"}}")+ .when().post("/").then().statusCode(200)+ .extract().jsonPath().getString("ModelArn");+ cleanup.register(() -> json11(region, "sagemaker", "SageMaker.DeleteModel",+ "{\"ModelName\":\"" + name + "\"}").when().post("/"));+ PartitionMatrix.assertArnIn(partitionCase, arn);+ }++ @ParameterizedTest+ @MethodSource("nonCommercialCases")+ void timestreamInfluxDbInstanceArn(PartitionCase partitionCase) {+ String region = offered(partitionCase, "timestream-influxdb");+ String target = "AmazonTimestreamInfluxDB.";+ Response created = json10(region, "timestream-influxdb", target + "CreateDbInstance",+ "{\"name\":\"" + unique("smoke-tsi", partitionCase) + "\",\"password\":\"password123\","+ + "\"dbInstanceType\":\"db.influx.medium\",\"allocatedStorage\":20,"+ + "\"vpcSubnetIds\":[\"subnet-abc123\"],\"vpcSecurityGroupIds\":[\"sg-abc123\"]}")+ .when().post("/").then().statusCode(200).extract().response();+ String id = created.jsonPath().getString("id");+ cleanup.register(() -> json10(region, "timestream-influxdb", target + "DeleteDbInstance",+ "{\"identifier\":\"" + id + "\"}").when().post("/"));+ // DeleteDbInstance leaves the auth secret an instance may have created behind.+ cleanup.register(() -> json11(region, "secretsmanager", "secretsmanager.DeleteSecret",+ "{\"SecretId\":\"READONLY-InfluxDB-auth-parameters-" + id+ + "\",\"ForceDeleteWithoutRecovery\":true}").when().post("/"));+ PartitionMatrix.assertArnIn(partitionCase, created.jsonPath().getString("arn"));+ }++ @ParameterizedTest+ @MethodSource("nonCommercialCases")+ void mwaaEnvironmentArn(PartitionCase partitionCase) {+ String region = offered(partitionCase, "airflow");+ String name = unique("smoke-airflow", partitionCase);+ String partition = partitionCase.partition();+ String arn = signed(region, "airflow")+ .contentType(JSON)+ .body("{\"ExecutionRoleArn\":\"arn:" + partition + ":iam::000000000000:role/airflow-role\","+ + "\"SourceBucketArn\":\"arn:" + partition + ":s3:::smoke-dags\",\"DagS3Path\":\"dags\","+ + "\"NetworkConfiguration\":{\"SubnetIds\":[\"subnet-1\",\"subnet-2\"],"+ + "\"SecurityGroupIds\":[\"sg-1\"]}}")+ .when().put("/environments/" + name).then().statusCode(200)+ .extract().jsonPath().getString("Arn");+ cleanup.register(() -> signed(region, "airflow").when().delete("/environments/" + name));+ PartitionMatrix.assertArnIn(partitionCase, arn);+ }++ @ParameterizedTest+ @MethodSource("nonCommercialCases")+ void organizationArn(PartitionCase partitionCase) {+ String region = offered(partitionCase, "organizations");+ // An account holds one organization, so this case uses an account no other test class signs with.+ String auth = "AWS4-HMAC-SHA256 Credential=000000004272/20260215/" + region+ + "/organizations/aws4_request, SignedHeaders=host;x-amz-date, Signature=abc";+ String target = "AWSOrganizationsV20161128.";+ Response created = given().header("Authorization", auth)+ .header("X-Amz-Target", target + "CreateOrganization")+ .contentType(JSON_1_1)+ .body("{\"FeatureSet\":\"ALL\"}")+ .when().post("/").then().statusCode(200).extract().response();+ cleanup.register(() -> given().header("Authorization", auth)+ .header("X-Amz-Target", target + "DeleteOrganization")+ .contentType(JSON_1_1)+ .body("{}")+ .when().post("/"));+ PartitionMatrix.assertGlobalArnIn(partitionCase, created.jsonPath().getString("Organization.Arn"));+ PartitionMatrix.assertGlobalArnIn(partitionCase, created.jsonPath().getString("Organization.MasterAccountArn"));+ }++ @ParameterizedTest+ @MethodSource("nonCommercialCases")+ void redshiftSnapshotCopyGrantKeyArn(PartitionCase partitionCase) {+ String region = offered(partitionCase, "redshift");+ String name = unique("smoke-grant", partitionCase);+ String arn = signed(region, "redshift")+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "CreateSnapshotCopyGrant")+ .formParam("Version", "2012-12-01")+ .formParam("SnapshotCopyGrantName", name)+ .when().post("/").then().statusCode(200)+ .extract().xmlPath()+ .getString("CreateSnapshotCopyGrantResponse.CreateSnapshotCopyGrantResult.SnapshotCopyGrant.KmsKeyId");+ cleanup.register(() -> signed(region, "redshift")+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "DeleteSnapshotCopyGrant")+ .formParam("Version", "2012-12-01")+ .formParam("SnapshotCopyGrantName", name)+ .when().post("/"));+ PartitionMatrix.assertArnIn(partitionCase, 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,diff --git a/src/test/resources/partition/smoke-exemptions.tsv b/src/test/resources/partition/smoke-exemptions.tsvindex 4cd9246050..93f83a7f68 100644--- a/src/test/resources/partition/smoke-exemptions.tsv+++ b/src/test/resources/partition/smoke-exemptions.tsv@@ -2,50 +2,31 @@# 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.-appintegrations not yet covered (BL-249 follow-up)-bcmdataexports not yet covered (BL-249 follow-up)+appintegrations no non-commercial partition publishes the service, so a case would be skipped in every partitioncloudformation covered by PartitionArnMintingIntegrationTest (aws-cn only)-cloudhsmv2 not yet covered (BL-249 follow-up)+cloudhsmv2 the only ARN on the wire is the automatic backup's, and a backup is never removed (DeleteBackup only marks it), so a case would leak state into the shared emulatorcloudtrail covered by CloudTrailSelfDeliveryTest (one partition)-codeartifact not yet covered (BL-249 follow-up)-codegurureviewer not yet covered (BL-249 follow-up)-codepipeline not yet covered (BL-249 follow-up)+codeartifact no non-commercial partition publishes the service, so a case would be skipped in every partition+codegurureviewer no non-commercial partition publishes the service, so a case would be skipped in every partitioncognitoidentity identity pool ARN is never returned and ARN lookup ignores the partition, nothing to assertdetective 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)-ecr not yet covered (BL-249 follow-up)-elasticbeanstalk not yet covered (BL-249 follow-up)-fis not yet covered (BL-249 follow-up)-globalaccelerator not yet covered (BL-249 follow-up)+docdb CreateDBCluster starts a container under the test config and the package has no lighter resource; its parameter and subnet groups are RDS's, covered there+globalaccelerator no non-commercial partition publishes the service, so a case would be skipped in every partitioniam 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)-lightsail not yet covered (BL-249 follow-up)-macie2 not yet covered (BL-249 follow-up)-marketplace not yet covered (BL-249 follow-up)-mwaa not yet covered (BL-249 follow-up)-neptune not yet covered (BL-249 follow-up)-organizations not yet covered (BL-249 follow-up)-pipes 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)-rum not yet covered (BL-249 follow-up)+lightsail no non-commercial partition publishes the service, so a case would be skipped in every partition+macie2 no non-commercial partition publishes the service, so a case would be skipped in every partition+marketplace the ARN-minting calls are pinned to us-east-1 except ResolveCustomer, whose record nothing removes, so a case would leak state into the shared emulator+neptune CreateDBCluster starts a graph container whenever Docker is reachable, and the package has no container-free resource+redshiftdata the only ARN it mints is internal and never returned, and every action needs a running cluster container+rum no RUM response carries the app monitor ARN: it is minted only for Resource Explorer listingss3 covered by S3PartitionIntegrationTest (aws-cn only)-s3vectors not yet covered (BL-249 follow-up)-sagemaker 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)-signin not yet covered (BL-249 follow-up)+signin the only ARN is the sub claim of an id token issued by the OAuth flow, and the session that flow registers cannot be removedssm 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)+ssoportal no portal response carries the reserved role ARN, and a portal session cannot be built over HTTP under the test configstepfunctions covered by StatesIntegrationTest and StepFunctionsPartitionIntegrationTest-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)+swf a registered domain can only be deprecated, never removed, so a case would leak state into the shared emulator