Light, fluffy, and always free - The AWS Local Emulator alternative
fix(iam): enforce inline role policy quota (#5327)
David Phillipsd22b4f107cf6
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/IamRoleInlinePolicyQuotaTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/IamRoleInlinePolicyQuotaTest.javanew file mode 100644index 0000000000..5c45596af0--- /dev/null+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/IamRoleInlinePolicyQuotaTest.java@@ -0,0 +1,116 @@+package com.floci.test;++import org.junit.jupiter.api.Test;+import software.amazon.awssdk.services.iam.IamClient;+import software.amazon.awssdk.services.iam.model.CreateRoleRequest;+import software.amazon.awssdk.services.iam.model.DeleteRolePolicyRequest;+import software.amazon.awssdk.services.iam.model.DeleteRoleRequest;+import software.amazon.awssdk.services.iam.model.GetRolePolicyRequest;+import software.amazon.awssdk.services.iam.model.LimitExceededException;+import software.amazon.awssdk.services.iam.model.ListRolePoliciesRequest;+import software.amazon.awssdk.services.iam.model.PutRolePolicyRequest;++import static org.assertj.core.api.Assertions.assertThat;+import static org.assertj.core.api.Assertions.assertThatThrownBy;++class IamRoleInlinePolicyQuotaTest {++ private static final int ROLE_INLINE_POLICY_QUOTA = 10_240;+ private static final String TRUST_POLICY = """+ {"Version":"2012-10-17","Statement":[{"Effect":"Allow","Principal":{"Service":"ec2.amazonaws.com"},"Action":"sts:AssumeRole"}]}+ """;++ @Test+ void enforcesAggregateNonWhitespaceQuotaAndPreservesAcceptedPolicies() {+ String roleName = TestFixtures.uniqueName("sdk-role-inline-quota");+ String exactLimitPolicy = policyWithNonWhitespaceLength(ROLE_INLINE_POLICY_QUOTA);+ String whitespacePaddedPolicy = exactLimitPolicy.substring(0, 1)+ + " \n\t\r ".repeat(1_000)+ + exactLimitPolicy.substring(1);++ try (IamClient iam = TestFixtures.iamClient()) {+ createRole(iam, roleName);+ try {+ putRolePolicy(iam, roleName, "exact-limit", whitespacePaddedPolicy);++ assertThatThrownBy(() -> putRolePolicy(iam, roleName, "exact-limit",+ policyWithNonWhitespaceLength(ROLE_INLINE_POLICY_QUOTA + 1)))+ .isInstanceOf(LimitExceededException.class)+ .satisfies(error -> assertThat(((LimitExceededException) error).statusCode()).isEqualTo(409));++ assertThat(iam.getRolePolicy(GetRolePolicyRequest.builder()+ .roleName(roleName)+ .policyName("exact-limit")+ .build())+ .policyDocument())+ .satisfies(readBack -> assertThat(removeCountedWhitespace(readBack)).isEqualTo(exactLimitPolicy));+ } finally {+ deleteRolePolicies(iam, roleName);+ deleteRole(iam, roleName);+ }+ }+ }++ @Test+ void rejectsAggregateQuotaOverflowAcrossPolicies() {+ String roleName = TestFixtures.uniqueName("sdk-role-inline-aggregate-quota");++ try (IamClient iam = TestFixtures.iamClient()) {+ createRole(iam, roleName);+ try {+ putRolePolicy(iam, roleName, "first", policyWithNonWhitespaceLength(6_000));+ putRolePolicy(iam, roleName, "second", policyWithNonWhitespaceLength(4_041));++ assertThatThrownBy(() -> putRolePolicy(iam, roleName, "third", policyWithNonWhitespaceLength(200)))+ .isInstanceOf(LimitExceededException.class)+ .satisfies(error -> assertThat(((LimitExceededException) error).statusCode()).isEqualTo(409));+ } finally {+ deleteRolePolicies(iam, roleName);+ deleteRole(iam, roleName);+ }+ }+ }++ private static void createRole(IamClient iam, String roleName) {+ iam.createRole(CreateRoleRequest.builder()+ .roleName(roleName)+ .assumeRolePolicyDocument(TRUST_POLICY)+ .build());+ }++ private static void putRolePolicy(IamClient iam, String roleName, String policyName, String policyDocument) {+ iam.putRolePolicy(PutRolePolicyRequest.builder()+ .roleName(roleName)+ .policyName(policyName)+ .policyDocument(policyDocument)+ .build());+ }++ private static void deleteRolePolicies(IamClient iam, String roleName) {+ for (String policyName : iam.listRolePolicies(ListRolePoliciesRequest.builder()+ .roleName(roleName)+ .build()).policyNames()) {+ iam.deleteRolePolicy(DeleteRolePolicyRequest.builder()+ .roleName(roleName)+ .policyName(policyName)+ .build());+ }+ }++ private static void deleteRole(IamClient iam, String roleName) {+ iam.deleteRole(DeleteRoleRequest.builder().roleName(roleName).build());+ }++ private static String policyWithNonWhitespaceLength(int targetLength) {+ String prefix = "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Sid\":\"";+ String suffix = "\",\"Effect\":\"Allow\",\"Action\":\"s3:GetObject\",\"Resource\":\"*\"}]}";+ return prefix + "x".repeat(targetLength - prefix.length() - suffix.length()) + suffix;+ }++ private static String removeCountedWhitespace(String policyDocument) {+ return policyDocument.replace(" ", "")+ .replace("\t", "")+ .replace("\n", "")+ .replace("\r", "");+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/IamRoleCfnProvisioner.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/IamRoleCfnProvisioner.javaindex d03f570004..f29b9d1a5e 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/IamRoleCfnProvisioner.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/IamRoleCfnProvisioner.java@@ -14,6 +14,7 @@ import java.util.Collection;import java.util.Collections;import java.util.HashMap;import java.util.HashSet;+import java.util.LinkedHashMap;import java.util.LinkedHashSet;import java.util.List;import java.util.Map;@@ -148,6 +149,7 @@ public class IamRoleCfnProvisioner implements CfnResourceProvisioner {// Inline policies run inside the same protected block: a failure here used to leave// the created role, its managed attachments and any earlier inline writes behind,// because rollback only deletes resources that reached CREATE_COMPLETE.+ Map<String, String> desiredInlinePolicies = new LinkedHashMap<>();if (props != null && props.has("Policies")) {for (JsonNode policy : props.get("Policies")) {String declaredName = ctx.resolveOptional(policy, "PolicyName");@@ -167,9 +169,7 @@ public class IamRoleCfnProvisioner implements CfnResourceProvisioner {"Inline policy '" + policyName + "' on role " + resolvedRoleName+ " has no PolicyDocument.", 400);}- iamService.putRolePolicy(resolvedRoleName, policyName,- ctx.engine().resolveJsonAttributeStrict(document));- inlineWrittenByThisAttempt.add(policyName);+ desiredInlinePolicies.put(policyName, ctx.engine().resolveJsonAttributeStrict(document));}}@@ -180,12 +180,17 @@ public class IamRoleCfnProvisioner implements CfnResourceProvisioner {// calls raise NoSuchEntity on an absent target, which would fail an update whose desired// end state, the policy not being on the role, already holds.for (String stale : previousInlineNames) {- if (!inlineWrittenByThisAttempt.contains(stale)+ if (!desiredInlinePolicies.containsKey(stale)&& originalInlinePolicies.containsKey(stale)) {iamService.deleteRolePolicy(resolvedRoleName, stale);inlineRemovedByThisAttempt.add(stale);}}+ // Free the quota held by renamed policies before writing their replacements.+ for (Map.Entry<String, String> policy : desiredInlinePolicies.entrySet()) {+ iamService.putRolePolicy(resolvedRoleName, policy.getKey(), policy.getValue());+ inlineWrittenByThisAttempt.add(policy.getKey());+ }for (String stale : previousManagedArns) {if (!managedPolicyArns.contains(stale) && originalPolicyArns.contains(stale)) {iamService.detachRolePolicy(resolvedRoleName, stale);@@ -195,19 +200,6 @@ public class IamRoleCfnProvisioner implements CfnResourceProvisioner {} catch (RuntimeException failure) {boolean cleanupSucceeded = true;- // Reconciliation runs last, so unwinding it comes first. A policy this attempt took out- // because the template stopped declaring it goes back with the document it had.- for (String policyName : inlineRemovedByThisAttempt) {- String prior = originalInlinePolicies.get(policyName);- if (prior == null) {- continue;- }- if (!CfnRollback.attemptIamCleanup(failure,- "restore inline policy " + policyName + " on role " + resolvedRoleName,- () -> iamService.putRolePolicy(resolvedRoleName, policyName, prior))) {- cleanupSucceeded = false;- }- }for (String policyArn : detachedByThisAttempt) {if (!CfnRollback.attemptIamCleanup(failure,"reattach policy " + policyArn + " to role " + resolvedRoleName,@@ -216,19 +208,24 @@ public class IamRoleCfnProvisioner implements CfnResourceProvisioner {}}+ // Remove this attempt's writes before restoring earlier documents, so temporary+ // overlap cannot exceed the role quota during rollback either.List<String> inlineRollback = new ArrayList<>(inlineWrittenByThisAttempt);Collections.reverse(inlineRollback);for (String policyName : inlineRollback) {+ if (!CfnRollback.attemptIamCleanup(failure,+ "remove inline policy " + policyName + " on role " + resolvedRoleName,+ () -> iamService.deleteRolePolicy(resolvedRoleName, policyName))) {+ cleanupSucceeded = false;+ }+ }+ Set<String> inlineToRestore = new LinkedHashSet<>(inlineRollback);+ inlineToRestore.addAll(inlineRemovedByThisAttempt);+ for (String policyName : inlineToRestore) {String prior = originalInlinePolicies.get(policyName);- String cleanupDescription = (prior == null ? "remove" : "restore")- + " inline policy " + policyName + " on role " + resolvedRoleName;- if (!CfnRollback.attemptIamCleanup(failure, cleanupDescription, () -> {- if (prior == null) {- iamService.deleteRolePolicy(resolvedRoleName, policyName);- } else {- iamService.putRolePolicy(resolvedRoleName, policyName, prior);- }- })) {+ if (prior != null && !CfnRollback.attemptIamCleanup(failure,+ "restore inline policy " + policyName + " on role " + resolvedRoleName,+ () -> iamService.putRolePolicy(resolvedRoleName, policyName, prior))) {cleanupSucceeded = false;}}diff --git a/src/main/java/io/github/hectorvent/floci/services/iam/IamService.java b/src/main/java/io/github/hectorvent/floci/services/iam/IamService.javaindex 8fb533c8ca..bd38d1078d 100644--- a/src/main/java/io/github/hectorvent/floci/services/iam/IamService.java+++ b/src/main/java/io/github/hectorvent/floci/services/iam/IamService.java@@ -99,6 +99,7 @@ import java.util.stream.Stream;@ApplicationScopedpublic class IamService implements SessionAccountLookup, ResourceProvider {+ private static final int ROLE_INLINE_POLICY_SIZE_LIMIT = 10_240;private static final Logger LOG = Logger.getLogger(IamService.class);private static final String CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";private static final String TEMPORARY_ACCESS_KEY_PREFIX = "ASIA";@@ -1806,8 +1807,30 @@ public class IamService implements SessionAccountLookup, ResourceProvider {public void putRolePolicy(String roleName, String policyName, String policyDocument) {IamRole role = getRole(roleName);requireNotServiceLinked(role, roleName);- role.getInlinePolicies().put(policyName, policyDocument);- roles.put(roleName, role);+ Map<String, String> inlinePolicies = role.getInlinePolicies();+ synchronized (inlinePolicies) {+ long aggregateSize = inlinePolicies.entrySet().stream()+ .filter(entry -> !entry.getKey().equals(policyName))+ .mapToLong(entry -> nonWhitespaceLength(entry.getValue()))+ .sum() + nonWhitespaceLength(policyDocument);+ if (aggregateSize > ROLE_INLINE_POLICY_SIZE_LIMIT) {+ throw new AwsException("LimitExceeded",+ "Maximum policy size of 10240 bytes exceeded for role " + roleName, 409);+ }+ inlinePolicies.put(policyName, policyDocument);+ roles.put(roleName, role);+ }+ }++ private static int nonWhitespaceLength(String policyDocument) {+ int size = 0;+ for (int i = 0; i < policyDocument.length(); i++) {+ char character = policyDocument.charAt(i);+ if (character != ' ' && character != '\t' && character != '\n' && character != '\r') {+ size++;+ }+ }+ return size;}public String getRolePolicy(String roleName, String policyName) {diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationIamRoleInlinePoliciesIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationIamRoleInlinePoliciesIntegrationTest.javaindex 21c5594b87..9d6f00ec05 100644--- a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationIamRoleInlinePoliciesIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationIamRoleInlinePoliciesIntegrationTest.java@@ -6,6 +6,7 @@ import org.junit.jupiter.api.Test;import static io.restassured.RestAssured.given;import static org.hamcrest.Matchers.containsString;import static org.hamcrest.Matchers.not;+import static org.junit.jupiter.api.Assertions.assertEquals;/*** End-to-end check that CloudFormation applies the inline {@code Policies} of an@@ -21,6 +22,43 @@ class CloudFormationIamRoleInlinePoliciesIntegrationTest {private static final String IAM_AUTH ="AWS4-HMAC-SHA256 Credential=test/20260205/us-east-1/iam/aws4_request";+ @Test+ void updateStackRenamesLargeInlinePolicyWithoutExceedingQuota() {+ String suffix = Long.toString(System.nanoTime(), 36);+ String stackName = "cfn-policy-quota-" + suffix;+ String roleName = "cfn-policy-quota-role-" + suffix;+ String template = """+ {"Resources":{"AppRole":{"Type":"AWS::IAM::Role","Properties":{+ "RoleName":"%s","AssumeRolePolicyDocument":{"Statement":[]},+ "Policies":[{"PolicyName":"%%s","PolicyDocument":{"Statement":[{+ "Effect":"Allow","Action":"s3:GetObject","Resource":"*","Sid":"%s"+ }]}}]}}}}+ """.formatted(roleName, "x".repeat(6_000));+ given().contentType("application/x-www-form-urlencoded").header("Authorization", CFN_AUTH)+ .formParam("Action", "CreateStack").formParam("StackName", stackName)+ .formParam("TemplateBody", template.formatted("old-policy"))+ .formParam("Capabilities.member.1", "CAPABILITY_NAMED_IAM")+ .post("/").then().statusCode(200);+ try {+ assertEquals("CREATE_COMPLETE", CfnStackWaits.awaitTerminal(stackName, CFN_AUTH).status());+ given().contentType("application/x-www-form-urlencoded").header("Authorization", CFN_AUTH)+ .formParam("Action", "UpdateStack").formParam("StackName", stackName)+ .formParam("TemplateBody", template.formatted("new-policy"))+ .formParam("Capabilities.member.1", "CAPABILITY_NAMED_IAM")+ .post("/").then().statusCode(200);+ assertEquals("UPDATE_COMPLETE", CfnStackWaits.awaitTerminal(stackName, CFN_AUTH).status());+ given().contentType("application/x-www-form-urlencoded").header("Authorization", IAM_AUTH)+ .formParam("Action", "ListRolePolicies").formParam("RoleName", roleName)+ .post("/").then().statusCode(200)+ .body(containsString("new-policy")).body(not(containsString("old-policy")));+ } finally {+ given().contentType("application/x-www-form-urlencoded").header("Authorization", CFN_AUTH)+ .formParam("Action", "DeleteStack").formParam("StackName", stackName)+ .post("/").then().statusCode(200);+ CfnStackWaits.awaitStackDeleted(stackName);+ }+ }+@Testvoid createStackProvisionsInlineRolePoliciesAndDeleteStackRemovesRole() {String suffix = Long.toString(System.nanoTime(), 36);diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/IamRoleCfnProvisionerTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/IamRoleCfnProvisionerTest.javaindex d213e4dd6d..708d711ca2 100644--- a/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/IamRoleCfnProvisionerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/IamRoleCfnProvisionerTest.java@@ -7,6 +7,7 @@ import io.github.hectorvent.floci.services.cloudformation.CloudFormationTemplateimport io.github.hectorvent.floci.services.cloudformation.model.StackResource;import io.github.hectorvent.floci.services.iam.IamService;import io.github.hectorvent.floci.services.iam.model.IamRole;+import io.github.hectorvent.floci.testutil.IamServiceTestHelper;import org.junit.jupiter.api.Test;import org.mockito.ArgumentCaptor;import org.mockito.InOrder;@@ -291,6 +292,28 @@ class IamRoleCfnProvisionerTest {verify(iam, never()).deleteRolePolicy(anyString(), anyString());}+ @Test+ void failedPolicyRenameRestoresOriginalPoliciesWithinQuota() throws Exception {+ IamService realIam = IamServiceTestHelper.iamServiceWithUserPolicy("test", "secret", "user", EMPTY_TRUST);+ IamRoleCfnProvisioner realProvisioner = new IamRoleCfnProvisioner(realIam);+ StackResource r = resource();+ String policy = "{\"Statement\":[{\"Effect\":\"Allow\",\"Action\":\"s3:GetObject\","+ + "\"Resource\":\"*\",\"Sid\":\"" + "x".repeat(6_000) + "\"}]}";+ JsonNode original = mapper.readTree("{\"RoleName\":\"app-role\",\"Policies\":["+ + "{\"PolicyName\":\"old\",\"PolicyDocument\":" + policy + "}]}");+ realProvisioner.provision(r, original, ctx());+ JsonNode replacement = mapper.readTree("{\"RoleName\":\"app-role\",\"Policies\":["+ + "{\"PolicyName\":\"new\",\"PolicyDocument\":" + policy + "},"+ + "{\"PolicyName\":\"overflow\",\"PolicyDocument\":" + policy + "}]}");++ AwsException failure = assertThrows(AwsException.class,+ () -> realProvisioner.provision(r, replacement, ctx()));++ assertEquals("LimitExceeded", failure.getErrorCode());+ assertEquals(0, failure.getSuppressed().length);+ assertEquals(Map.of("old", policy), realIam.getRole("app-role").getInlinePolicies());+ }+@Testvoid failedUpdateRestoresTheInlinePolicyItAlreadyOverwrote() {// An update that adopts an existing role must not keep the permissions a half-applied@@ -321,8 +344,8 @@ class IamRoleCfnProvisionerTest {InOrder order = inOrder(iam);order.verify(iam).putRolePolicy("app-role", "first", EMPTY_TRUST);+ order.verify(iam).deleteRolePolicy("app-role", "first");order.verify(iam).putRolePolicy("app-role", "first", priorDocument);- verify(iam, never()).deleteRolePolicy(anyString(), anyString());verify(iam, never()).deleteRole(anyString());}diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/IamServicePersistenceTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/IamServicePersistenceTest.javaindex 33ebb3cd3d..c69e9f6d41 100644--- a/src/test/java/io/github/hectorvent/floci/services/iam/IamServicePersistenceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/iam/IamServicePersistenceTest.java@@ -1,6 +1,7 @@package io.github.hectorvent.floci.services.iam;import com.fasterxml.jackson.core.type.TypeReference;+import io.github.hectorvent.floci.core.common.AwsException;import io.github.hectorvent.floci.core.common.RegionResolver;import io.github.hectorvent.floci.core.common.Totp;import io.github.hectorvent.floci.core.storage.AccountAwareStorageBackend;@@ -27,8 +28,10 @@ import java.time.Instant;import java.util.List;import java.util.Map;+import static io.github.hectorvent.floci.services.iam.InlinePolicyTestHelper.policyWithNonWhitespaceLength;import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.assertNotNull;+import static org.junit.jupiter.api.Assertions.assertThrows;import static org.junit.jupiter.api.Assertions.assertTrue;/**@@ -42,6 +45,32 @@ class IamServicePersistenceTest {"https://oidc.eks.eu-central-1.amazonaws.com/id/PERSISTED0EXAMPLE";private static final String THUMBPRINT = "9e99a48a9960b14926bb7f3b02e22da2b0ab7280";+ @Test+ void roleInlinePolicyQuotaUsesPersistedAggregateAfterRestart(@TempDir Path directory) {+ IamService first = newService(directory);+ first.createRole("R", "/", "{}", null, 0, null);+ String firstPolicy = policyWithNonWhitespaceLength(6_000);+ String secondPolicy = policyWithNonWhitespaceLength(4_000);+ first.putRolePolicy("R", "first", firstPolicy);+ first.putRolePolicy("R", "second", secondPolicy);++ IamService restarted = newService(directory);+ assertEquals(firstPolicy, restarted.getRolePolicy("R", "first"));+ assertEquals(secondPolicy, restarted.getRolePolicy("R", "second"));++ AwsException aggregateError = assertThrows(AwsException.class,+ () -> restarted.putRolePolicy("R", "third", policyWithNonWhitespaceLength(241)));+ assertEquals("LimitExceeded", aggregateError.getErrorCode());+ assertEquals(409, aggregateError.getHttpStatus());++ AwsException replacementError = assertThrows(AwsException.class,+ () -> restarted.putRolePolicy("R", "first", policyWithNonWhitespaceLength(6_241)));+ assertEquals("LimitExceeded", replacementError.getErrorCode());+ assertEquals(409, replacementError.getHttpStatus());+ assertEquals(firstPolicy, restarted.getRolePolicy("R", "first"));+ assertEquals(secondPolicy, restarted.getRolePolicy("R", "second"));+ }+@Testvoid openIdConnectProviderSurvivesRestart(@TempDir Path dir) {IamService first = newService(dir);diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/IamServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/IamServiceTest.javaindex 25aacdf231..129e71e27b 100644--- a/src/test/java/io/github/hectorvent/floci/services/iam/IamServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/iam/IamServiceTest.java@@ -34,7 +34,13 @@ import java.util.Base64;import java.util.List;import java.util.Map;import java.util.Optional;+import java.util.concurrent.CountDownLatch;+import java.util.concurrent.ExecutorService;+import java.util.concurrent.Executors;+import java.util.concurrent.TimeUnit;+import java.util.concurrent.atomic.AtomicInteger;+import static io.github.hectorvent.floci.services.iam.InlinePolicyTestHelper.policyWithNonWhitespaceLength;import static org.junit.jupiter.api.Assertions.*;class IamServiceTest {@@ -75,6 +81,66 @@ class IamServiceTest {);}+ @Test+ void roleInlinePolicyQuotaIgnoresWhitespaceAndPreservesRejectedReplacement() {+ iamService.createRole("R", "/", "{}", null, 0, null);+ String exactLimit = policyWithNonWhitespaceLength(10_240);+ String padded = exactLimit.substring(0, 1) + " \n\t\r ".repeat(1_000) + exactLimit.substring(1);+ iamService.putRolePolicy("R", "inline-exec", padded);++ AwsException error = assertThrows(AwsException.class,+ () -> iamService.putRolePolicy("R", "inline-exec", policyWithNonWhitespaceLength(10_241)));++ assertEquals("LimitExceeded", error.getErrorCode());+ assertEquals(409, error.getHttpStatus());+ assertEquals(padded, iamService.getRolePolicy("R", "inline-exec"));+ }++ @Test+ void roleInlinePolicyQuotaCountsAllPolicies() {+ iamService.createRole("R", "/", "{}", null, 0, null);+ iamService.putRolePolicy("R", "first", policyWithNonWhitespaceLength(6_000));+ iamService.putRolePolicy("R", "second", policyWithNonWhitespaceLength(4_041));++ AwsException error = assertThrows(AwsException.class,+ () -> iamService.putRolePolicy("R", "third", policyWithNonWhitespaceLength(200)));++ assertEquals("LimitExceeded", error.getErrorCode());+ assertEquals(409, error.getHttpStatus());+ assertEquals(List.of("first", "second"), iamService.listRolePolicies("R").stream().sorted().toList());+ }++ @Test+ void roleInlinePolicyQuotaIsAtomicAcrossConcurrentWrites() throws Exception {+ iamService.createRole("R", "/", "{}", null, 0, null);+ CountDownLatch start = new CountDownLatch(1);+ AtomicInteger accepted = new AtomicInteger();+ AtomicInteger rejected = new AtomicInteger();++ try (ExecutorService executor = Executors.newFixedThreadPool(2)) {+ for (String policyName : List.of("first", "second")) {+ executor.submit(() -> {+ start.await();+ try {+ iamService.putRolePolicy("R", policyName, policyWithNonWhitespaceLength(6_000));+ accepted.incrementAndGet();+ } catch (AwsException error) {+ assertEquals("LimitExceeded", error.getErrorCode());+ rejected.incrementAndGet();+ }+ return null;+ });+ }+ start.countDown();+ executor.shutdown();+ assertTrue(executor.awaitTermination(10, TimeUnit.SECONDS));+ }++ assertEquals(1, accepted.get());+ assertEquals(1, rejected.get());+ assertEquals(1, iamService.listRolePolicies("R").size());+ }+/** The STS global endpoint, and so the token version it reports, exists only in the commercial partition. */@Testvoid accountSummaryReportsTheGlobalEndpointTokenVersionOnlyWhereStsHasAGlobalHost() {diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/InlinePolicyTestHelper.java b/src/test/java/io/github/hectorvent/floci/services/iam/InlinePolicyTestHelper.javanew file mode 100644index 0000000000..1634b3ea7e--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/iam/InlinePolicyTestHelper.java@@ -0,0 +1,12 @@+package io.github.hectorvent.floci.services.iam;++final class InlinePolicyTestHelper {++ private InlinePolicyTestHelper() {}++ static String policyWithNonWhitespaceLength(int targetLength) {+ String prefix = "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Sid\":\"";+ String suffix = "\",\"Effect\":\"Allow\",\"Action\":\"s3:GetObject\",\"Resource\":\"*\"}]}";+ return prefix + "x".repeat(targetLength - prefix.length() - suffix.length()) + suffix;+ }+}