Skip to content

armgit / floci

Public Imported from GitHub
0

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

feat(iam): read the managed-policy family's constraints from the model (#6580)

Priamo Germosenbb48983b9c72
diff --git a/Makefile b/Makefile
index 0c50e76591..8fac930ec3 100644
--- a/Makefile
+++ b/Makefile
@@ -25,6 +25,8 @@
# by tools/aws/regen_ecs_shapes.py.
# src/main/resources/aws/ecr-request-shapes.json, the ECR request constraints, is generated
# from botocore's ECR model by tools/aws/regen_ecr_shapes.py.
+# src/main/resources/aws/iam-request-shapes.json, the IAM request constraints of the operations
+# read from the model, is generated from botocore's IAM model by tools/aws/regen_iam_shapes.py.
# src/main/resources/aws/emr-serverless-shapes.json, the shapes the Step Functions emr-serverless
# integrations recase against, is generated from botocore's EMR Serverless model by
# tools/aws/regen_emr_serverless_shapes.py.
@@ -230,6 +232,7 @@ aws-data-sync: ## Regenerate src/main/resources/aws/*.json and the IAM managed-p
$(PYTHON) tools/aws/regen_redshift_serverless_shapes.py
$(PYTHON) tools/aws/regen_resource_groups_shapes.py
$(PYTHON) tools/aws/regen_ecr_shapes.py
+ $(PYTHON) tools/aws/regen_iam_shapes.py
$(PYTHON) tools/aws/regen_apigateway_types.py
$(PYTHON) tools/aws/regen_sesv2_shapes.py
$(PYTHON) tools/aws/regen_apigateway_shapes.py
@@ -258,6 +261,12 @@ aws-data-check: ## CI gate: the vendored AWS data must match a fresh generation
echo " Run 'make aws-data-sync' and commit the result."; \
exit 1; \
}
+ @$(PYTHON) tools/aws/regen_iam_shapes.py --check || { \
+ echo ""; \
+ echo "error: src/main/resources/aws/iam-request-shapes.json is out of date."; \
+ echo " Run 'make aws-data-sync' and commit the result."; \
+ exit 1; \
+ }
@$(PYTHON) tools/aws/regen_redshift_serverless_shapes.py --check || { \
echo ""; \
echo "error: src/main/resources/aws/redshift-serverless-request-shapes.json is out of date."; \
diff --git a/docs/services/iam.md b/docs/services/iam.md
index d4b5805c66..5f394be0a5 100644
--- a/docs/services/iam.md
+++ b/docs/services/iam.md
@@ -154,6 +154,23 @@ outside 1 to 1000. `PathPrefix` and `Scope` filter before paging, and roles and
policies are listed in name order so a `Marker` resumes where the previous page stopped.
`ListPolicies` does not yet apply `OnlyAttached` or `PolicyUsageFilter`.
+The declared constraints on the managed-policy family are read from the model rather than from a
+hand-written check, `tools/aws/regen_iam_shapes.py` vendoring them for `GetPolicy`, `DeletePolicy`,
+`CreatePolicyVersion`, `GetPolicyVersion`, `DeletePolicyVersion`, `SetDefaultPolicyVersion` and the
+six attach and detach operations. A `PolicyArn` is held to `arnType`'s 20 to 2048 characters, a
+`VersionId` to `policyVersionIdType`'s pattern, a `PolicyDocument` to its 1 to 131072 characters and
+its pattern, and each principal name to its own bound, which for a role is the 1 to 64 characters of
+`[\w+=,.@-]` this service already answered. The check runs ahead of the operation, so a value that
+breaks a constraint is a 400 `ValidationError` where it used to reach the store and answer
+`NoSuchEntity` 404, the ordering the rest of this package already follows. A member sent empty is a
+member the request carries, so it breaks its own constraints rather than reading as absent, and a
+member breaking two of them is reported twice, as a `ServiceSpecificCredentialId` breaking both of
+its own already is. That is the one place the wording moves rather than only the status: a name sent
+empty breaks its minimum and its pattern at once, so these operations report both, where the
+hand-written check the rest of the service still uses stops at the first and reports the minimum
+alone. A boolean member publishes no constraint to hold it to, so a `SetAsDefault` that is neither
+`true` nor `false` reaches the operation, which reads anything but `true` as false.
+
### Permission Boundaries
| Action | Description |
diff --git a/src/main/java/io/github/hectorvent/floci/core/common/QueryConstraintCheck.java b/src/main/java/io/github/hectorvent/floci/core/common/QueryConstraintCheck.java
new file mode 100644
index 0000000000..d9837dac17
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/core/common/QueryConstraintCheck.java
@@ -0,0 +1,182 @@
+package io.github.hectorvent.floci.core.common;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import jakarta.ws.rs.core.MultivaluedMap;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.regex.Pattern;
+
+/**
+ * Checks an AWS Query request against the constraints a {@code tools/aws/regen_*_shapes.py}
+ * generator vendors from botocore through {@code request_shapes.build_constraints}: the members a
+ * structure requires, a string's length, pattern and enum, and a number's range. It reads the same
+ * vendored shape {@link RequestConstraintCheck} reads for the JSON protocols, and walks it
+ * differently because the requests differ: a JSON body arrives as a tree, where a Query request
+ * arrives as flat form parameters named after the members that carry them.
+ *
+ * <p>Every violation is collected rather than the first one thrown, which is what AWS's validation
+ * layer answers: "N validation errors detected" with the violations in the order the model lists
+ * the members, and a member that breaks two constraints reported twice. That is the reading #6402
+ * merged for a `ServiceSpecificCredentialId` breaking both its length and its pattern, and
+ * `docs/services/iam.md` carries it.
+ *
+ * <p>The offending value is quoted, which is what {@link SmithyValidationErrors#lengthOutOfRange}
+ * and this package's `validateRoleName` already answer. Whether current IAM quotes it at all is
+ * what DRIFT-13 asks, and the point of reading the constraints here is that one capture would
+ * change one helper rather than every message in the package.
+ *
+ * <p>A member the request leaves out is absent, and only a required member is reported for one. A
+ * member present and empty is a value: the protocol carries it, so it breaks its minimum length
+ * rather than reading as absent.
+ *
+ * <p>Scalars only for now. An operation whose input shape carries a list or a map is refused when
+ * the file loads rather than passed over quietly, since reading one means reading
+ * {@code Name.member.N} and {@code Name.entry.N.key} and naming each index as the request spelled
+ * it.
+ */
+public final class QueryConstraintCheck {
+
+ private static final ObjectMapper MAPPER = new ObjectMapper();
+
+ /** The shape types a Query parameter can carry on its own, without an index or an entry. */
+ private static final Set<String> SCALAR_TYPES = Set.of("string", "integer", "long", "boolean");
+
+ private final JsonNode operations;
+ private final JsonNode shapes;
+ private final Map<String, Pattern> patterns = new HashMap<>();
+
+ private QueryConstraintCheck(JsonNode model) {
+ this.operations = model.path("operations");
+ this.shapes = model.path("shapes");
+ for (Map.Entry<String, JsonNode> shape : shapes.properties()) {
+ if (shape.getValue().has("pattern")) {
+ patterns.put(shape.getKey(), Pattern.compile(shape.getValue().get("pattern").asText()));
+ }
+ }
+ for (Map.Entry<String, JsonNode> operation : operations.properties()) {
+ requireScalarMembers(operation.getKey(), operation.getValue().asText());
+ }
+ }
+
+ /** The vendored resource {@code name}; {@code description} names it in a failure. */
+ public static QueryConstraintCheck load(String name, String description) {
+ return VendoredResources.read(name, description,
+ input -> new QueryConstraintCheck(MAPPER.readTree(input)));
+ }
+
+ public static QueryConstraintCheck of(JsonNode model) {
+ return new QueryConstraintCheck(model);
+ }
+
+ private void requireScalarMembers(String operation, String inputShape) {
+ for (Map.Entry<String, JsonNode> member : shapes.path(inputShape).path("members").properties()) {
+ String type = shapes.path(member.getValue().asText()).path("type").asText();
+ if (!SCALAR_TYPES.contains(type)) {
+ throw new IllegalStateException(operation + "'s " + member.getKey() + " is a " + type
+ + ", which this check does not read yet");
+ }
+ }
+ }
+
+ /**
+ * Throws the Query protocol's {@code ValidationError} when {@code params} breaks a constraint
+ * the model declares for {@code operation}. An operation the vendored file does not carry
+ * passes, which is how the file grows one wave at a time.
+ */
+ public void check(String operation, MultivaluedMap<String, String> params) {
+ List<String> violations = violations(operation, params);
+ if (!violations.isEmpty()) {
+ throw SmithyValidationErrors.validationError(violations);
+ }
+ }
+
+ /** The violations {@code params} carries for {@code operation}, in the model's member order. */
+ public List<String> violations(String operation, MultivaluedMap<String, String> params) {
+ JsonNode shape = shapes.path(operations.path(operation).asText());
+ if (!shape.hasNonNull("members")) {
+ return List.of();
+ }
+ Set<String> required = new LinkedHashSet<>();
+ shape.path("required").forEach(name -> required.add(name.asText()));
+ List<String> violations = new ArrayList<>();
+ for (Map.Entry<String, JsonNode> member : shape.path("members").properties()) {
+ String name = member.getKey();
+ String value = params == null ? null : params.getFirst(name);
+ String path = memberPath(name);
+ if (value == null) {
+ if (required.contains(name)) {
+ violations.add(SmithyValidationErrors.notNull(path));
+ }
+ continue;
+ }
+ violations.addAll(violations(member.getValue().asText(), value, path));
+ }
+ return violations;
+ }
+
+ /** The member's name as a validation message spells it, which is the request's with a lower
+ * first letter. */
+ private static String memberPath(String name) {
+ return Character.toLowerCase(name.charAt(0)) + name.substring(1);
+ }
+
+ /** Every constraint {@code value} breaks, in the order a shape declares them. */
+ private List<String> violations(String shapeName, String value, String path) {
+ JsonNode shape = shapes.path(shapeName);
+ String type = shape.path("type").asText();
+ if ("integer".equals(type) || "long".equals(type)) {
+ return single(numberViolation(shape, value, path));
+ }
+ if (!"string".equals(type)) {
+ return List.of();
+ }
+ List<String> violations = new ArrayList<>();
+ String length = SmithyValidationErrors.lengthOutOfRange(path, value,
+ shape.path("min").asInt(0), shape.path("max").asInt(Integer.MAX_VALUE));
+ if (length != null) {
+ violations.add(length);
+ }
+ Pattern pattern = patterns.get(shapeName);
+ if (pattern != null && !pattern.matcher(value).matches()) {
+ violations.add(SmithyValidationErrors.pattern(path, value, pattern.pattern()));
+ }
+ violations.addAll(single(enumViolation(shape, value, path)));
+ return violations;
+ }
+
+ private static List<String> single(String violation) {
+ return violation == null ? List.of() : List.of(violation);
+ }
+
+ /**
+ * A value that is no number is left to the operation: this package answers one with
+ * {@code InvalidParameterValue} rather than with a constraint violation, and which member
+ * reports it that way is the operation's own reading.
+ */
+ private static String numberViolation(JsonNode shape, String value, String path) {
+ long number;
+ try {
+ number = Long.parseLong(value.trim());
+ } catch (NumberFormatException expected) {
+ // Not a number at all, so no range of the model's is what it breaks.
+ return null;
+ }
+ return SmithyValidationErrors.outOfRange(path, number,
+ shape.path("min").asLong(Long.MIN_VALUE), shape.path("max").asLong(Long.MAX_VALUE));
+ }
+
+ private static String enumViolation(JsonNode shape, String value, String path) {
+ if (!shape.has("enum")) {
+ return null;
+ }
+ List<String> allowed = new ArrayList<>();
+ shape.path("enum").forEach(choice -> allowed.add(choice.asText()));
+ return allowed.contains(value) ? null : SmithyValidationErrors.notInEnum(value, path, allowed);
+ }
+}
diff --git a/src/main/java/io/github/hectorvent/floci/core/common/SmithyValidationErrors.java b/src/main/java/io/github/hectorvent/floci/core/common/SmithyValidationErrors.java
index 1426744bc1..c9fbdb9a65 100644
--- a/src/main/java/io/github/hectorvent/floci/core/common/SmithyValidationErrors.java
+++ b/src/main/java/io/github/hectorvent/floci/core/common/SmithyValidationErrors.java
@@ -104,6 +104,12 @@ public final class SmithyValidationErrors {
+ "Member must have length greater than or equal to " + min;
}
+ /** The violation for a string that does not match the pattern its shape declares. */
+ public static String pattern(String path, String value, String pattern) {
+ return "Value '" + value + "' at '" + path + "' failed to satisfy constraint: "
+ + "Member must satisfy regular expression pattern: " + pattern;
+ }
+
/** The violation for a value outside its enum, listing the allowed values in the model's order. */
public static String notInEnum(String value, String path, List<String> allowed) {
return "Value '" + value + "' at '" + path + "' failed to satisfy constraint: "
diff --git a/src/main/java/io/github/hectorvent/floci/services/iam/IamQueryHandler.java b/src/main/java/io/github/hectorvent/floci/services/iam/IamQueryHandler.java
index 73d2dda296..0a609781f9 100644
--- a/src/main/java/io/github/hectorvent/floci/services/iam/IamQueryHandler.java
+++ b/src/main/java/io/github/hectorvent/floci/services/iam/IamQueryHandler.java
@@ -144,6 +144,7 @@ public class IamQueryHandler {
LOG.debugv("IAM action: {0}", action);
try {
+ IamRequestShapes.check(action, params);
return switch (action) {
// Users
case "CreateUser" -> handleCreateUser(params);
diff --git a/src/main/java/io/github/hectorvent/floci/services/iam/IamRequestShapes.java b/src/main/java/io/github/hectorvent/floci/services/iam/IamRequestShapes.java
new file mode 100644
index 0000000000..5a80c17ff5
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/iam/IamRequestShapes.java
@@ -0,0 +1,32 @@
+package io.github.hectorvent.floci.services.iam;
+
+import io.github.hectorvent.floci.core.common.QueryConstraintCheck;
+import jakarta.ws.rs.core.MultivaluedMap;
+
+/**
+ * The declared constraints IAM reads from its model rather than from a hand-written check, as
+ * {@code tools/aws/regen_iam_shapes.py} vendors them into
+ * {@code aws/iam-request-shapes.json}. The check runs ahead of the operation, which is where AWS's
+ * validation layer runs: a request that breaks a declared constraint is a 400 {@code
+ * ValidationError} whether or not the thing it names exists, the ordering #6402 settled for this
+ * package.
+ *
+ * <p>The vendored file carries one wave of operations rather than all 180, and grows a wave at a
+ * time: the managed-policy family first, where no operation checks a declared constraint by hand,
+ * so the model adds the refusals AWS answers without rewording an answer already given.
+ * {@code AttachRolePolicy} and {@code DetachRolePolicy} are the exception and the parity case,
+ * {@code IamService.validateRoleName} already answering {@code roleName} in the same form.
+ */
+final class IamRequestShapes {
+
+ private static final QueryConstraintCheck CHECK =
+ QueryConstraintCheck.load("aws/iam-request-shapes.json", "IAM request shapes");
+
+ private IamRequestShapes() {
+ }
+
+ /** Throws {@code ValidationError} when the request breaks a constraint the model declares. */
+ static void check(String action, MultivaluedMap<String, String> params) {
+ CHECK.check(action, params);
+ }
+}
diff --git a/src/main/resources/aws/iam-request-shapes.json b/src/main/resources/aws/iam-request-shapes.json
new file mode 100644
index 0000000000..9bccce9f5f
--- /dev/null
+++ b/src/main/resources/aws/iam-request-shapes.json
@@ -0,0 +1,187 @@
+{
+ "_source": {
+ "generator": "tools/aws/regen_iam_shapes.py",
+ "botocore": "botocore 1.43.113 (installed package)"
+ },
+ "operations": {
+ "AttachGroupPolicy": "AttachGroupPolicyRequest",
+ "AttachRolePolicy": "AttachRolePolicyRequest",
+ "AttachUserPolicy": "AttachUserPolicyRequest",
+ "DetachGroupPolicy": "DetachGroupPolicyRequest",
+ "DetachRolePolicy": "DetachRolePolicyRequest",
+ "DetachUserPolicy": "DetachUserPolicyRequest",
+ "GetPolicy": "GetPolicyRequest",
+ "DeletePolicy": "DeletePolicyRequest",
+ "CreatePolicyVersion": "CreatePolicyVersionRequest",
+ "GetPolicyVersion": "GetPolicyVersionRequest",
+ "DeletePolicyVersion": "DeletePolicyVersionRequest",
+ "SetDefaultPolicyVersion": "SetDefaultPolicyVersionRequest"
+ },
+ "shapes": {
+ "AttachGroupPolicyRequest": {
+ "type": "structure",
+ "required": [
+ "GroupName",
+ "PolicyArn"
+ ],
+ "members": {
+ "GroupName": "groupNameType",
+ "PolicyArn": "arnType"
+ }
+ },
+ "AttachRolePolicyRequest": {
+ "type": "structure",
+ "required": [
+ "RoleName",
+ "PolicyArn"
+ ],
+ "members": {
+ "RoleName": "roleNameType",
+ "PolicyArn": "arnType"
+ }
+ },
+ "AttachUserPolicyRequest": {
+ "type": "structure",
+ "required": [
+ "UserName",
+ "PolicyArn"
+ ],
+ "members": {
+ "UserName": "userNameType",
+ "PolicyArn": "arnType"
+ }
+ },
+ "CreatePolicyVersionRequest": {
+ "type": "structure",
+ "required": [
+ "PolicyArn",
+ "PolicyDocument"
+ ],
+ "members": {
+ "PolicyArn": "arnType",
+ "PolicyDocument": "policyDocumentType",
+ "SetAsDefault": "booleanType"
+ }
+ },
+ "DeletePolicyRequest": {
+ "type": "structure",
+ "required": [
+ "PolicyArn"
+ ],
+ "members": {
+ "PolicyArn": "arnType"
+ }
+ },
+ "DeletePolicyVersionRequest": {
+ "type": "structure",
+ "required": [
+ "PolicyArn",
+ "VersionId"
+ ],
+ "members": {
+ "PolicyArn": "arnType",
+ "VersionId": "policyVersionIdType"
+ }
+ },
+ "DetachGroupPolicyRequest": {
+ "type": "structure",
+ "required": [
+ "GroupName",
+ "PolicyArn"
+ ],
+ "members": {
+ "GroupName": "groupNameType",
+ "PolicyArn": "arnType"
+ }
+ },
+ "DetachRolePolicyRequest": {
+ "type": "structure",
+ "required": [
+ "RoleName",
+ "PolicyArn"
+ ],
+ "members": {
+ "RoleName": "roleNameType",
+ "PolicyArn": "arnType"
+ }
+ },
+ "DetachUserPolicyRequest": {
+ "type": "structure",
+ "required": [
+ "UserName",
+ "PolicyArn"
+ ],
+ "members": {
+ "UserName": "userNameType",
+ "PolicyArn": "arnType"
+ }
+ },
+ "GetPolicyRequest": {
+ "type": "structure",
+ "required": [
+ "PolicyArn"
+ ],
+ "members": {
+ "PolicyArn": "arnType"
+ }
+ },
+ "GetPolicyVersionRequest": {
+ "type": "structure",
+ "required": [
+ "PolicyArn",
+ "VersionId"
+ ],
+ "members": {
+ "PolicyArn": "arnType",
+ "VersionId": "policyVersionIdType"
+ }
+ },
+ "SetDefaultPolicyVersionRequest": {
+ "type": "structure",
+ "required": [
+ "PolicyArn",
+ "VersionId"
+ ],
+ "members": {
+ "PolicyArn": "arnType",
+ "VersionId": "policyVersionIdType"
+ }
+ },
+ "arnType": {
+ "type": "string",
+ "min": 20,
+ "max": 2048
+ },
+ "booleanType": {
+ "type": "boolean"
+ },
+ "groupNameType": {
+ "type": "string",
+ "min": 1,
+ "max": 128,
+ "pattern": "[\\w+=,.@-]+"
+ },
+ "policyDocumentType": {
+ "type": "string",
+ "min": 1,
+ "max": 131072,
+ "pattern": "[\\u0009\\u000A\\u000D\\u0020-\\u00FF]+"
+ },
+ "policyVersionIdType": {
+ "type": "string",
+ "pattern": "v[1-9][0-9]*(\\.[A-Za-z0-9-]*)?"
+ },
+ "roleNameType": {
+ "type": "string",
+ "min": 1,
+ "max": 64,
+ "pattern": "[\\w+=,.@-]+"
+ },
+ "userNameType": {
+ "type": "string",
+ "min": 1,
+ "max": 64,
+ "pattern": "[\\w+=,.@-]+"
+ }
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/core/common/QueryConstraintCheckTest.java b/src/test/java/io/github/hectorvent/floci/core/common/QueryConstraintCheckTest.java
new file mode 100644
index 0000000000..3ede31bd64
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/core/common/QueryConstraintCheckTest.java
@@ -0,0 +1,196 @@
+package io.github.hectorvent.floci.core.common;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import jakarta.ws.rs.core.MultivaluedHashMap;
+import jakarta.ws.rs.core.MultivaluedMap;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class QueryConstraintCheckTest {
+
+ private static final ObjectMapper MAPPER = new ObjectMapper();
+
+ private static final String MODEL = """
+ {
+ "operations": {"Put": "PutRequest", "Take": "TakeRequest"},
+ "shapes": {
+ "PutRequest": {"type": "structure", "required": ["Name", "Arn"], "members": {
+ "Name": "nameType", "Arn": "arnType", "Status": "statusType",
+ "Age": "ageType", "Default": "booleanType"}},
+ "TakeRequest": {"type": "structure", "members": {"Name": "nameType"}},
+ "nameType": {"type": "string", "min": 1, "max": 8, "pattern": "[\\\\w+=,.@-]+"},
+ "arnType": {"type": "string", "min": 20, "max": 2048},
+ "statusType": {"type": "string", "enum": ["Active", "Inactive"]},
+ "ageType": {"type": "integer", "min": 1, "max": 30},
+ "booleanType": {"type": "boolean"}
+ }
+ }
+ """;
+
+ private static QueryConstraintCheck check() throws Exception {
+ return QueryConstraintCheck.of(MAPPER.readTree(MODEL));
+ }
+
+ private static MultivaluedMap<String, String> params(String... pairs) {
+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();
+ for (int pair = 0; pair < pairs.length; pair += 2) {
+ params.putSingle(pairs[pair], pairs[pair + 1]);
+ }
+ return params;
+ }
+
+ /** Every required member the request leaves out, in the order the model lists the members. */
+ @Test
+ void theRequiredMembersAreReportedTogetherInTheModelsOrder() throws Exception {
+ List<String> violations = check().violations("Put", params());
+
+ assertEquals(List.of(
+ "Value null at 'name' failed to satisfy constraint: Member must not be null",
+ "Value null at 'arn' failed to satisfy constraint: Member must not be null"),
+ violations);
+ }
+
+ /**
+ * A member sent empty is a member the request carries, so what it breaks are its own
+ * constraints, where one that never arrived is the member reported as null. An empty value
+ * breaks both the minimum length and a pattern that asks for a character, and both are
+ * reported, as #6402 settled for an id breaking two constraints.
+ */
+ @Test
+ void aMemberSentEmptyBreaksItsConstraintsRatherThanReadingAsAbsent() throws Exception {
+ List<String> violations = check().violations("Take", params("Name", ""));
+
+ assertEquals(List.of(
+ "Value '' at 'name' failed to satisfy constraint: "
+ + "Member must have length greater than or equal to 1",
+ "Value '' at 'name' failed to satisfy constraint: "
+ + "Member must satisfy regular expression pattern: [\\w+=,.@-]+"),
+ violations);
+ assertEquals(List.of(), check().violations("Take", params()), "Name is optional here");
+ }
+
+ /** Length, pattern and enum, each reported by the member that breaks it. */
+ @Test
+ void aStringIsHeldToItsLengthItsPatternAndItsEnum() throws Exception {
+ assertEquals(List.of("Value 'abcdefghi' at 'name' failed to satisfy constraint: "
+ + "Member must have length less than or equal to 8"),
+ check().violations("Take", params("Name", "abcdefghi")),
+ "nine word characters break the length and nothing else");
+
+ assertEquals(List.of("Value 'two w' at 'name' failed to satisfy constraint: "
+ + "Member must satisfy regular expression pattern: [\\w+=,.@-]+"),
+ check().violations("Take", params("Name", "two w")),
+ "a space inside the length breaks the pattern and nothing else");
+
+ assertEquals(List.of(
+ "Value 'two words' at 'name' failed to satisfy constraint: "
+ + "Member must have length less than or equal to 8",
+ "Value 'two words' at 'name' failed to satisfy constraint: "
+ + "Member must satisfy regular expression pattern: [\\w+=,.@-]+"),
+ check().violations("Take", params("Name", "two words")),
+ "a value breaking both is reported twice");
+
+ assertEquals(List.of("Value 'Pending' at 'status' failed to satisfy constraint: "
+ + "Member must satisfy enum value set: [Active, Inactive]"),
+ check().violations("Put", params("Name", "ok", "Arn", "a".repeat(20),
+ "Status", "Pending")));
+ }
+
+ /** A number is held to its range, and one that is no number at all is left to the operation. */
+ @Test
+ void aNumberIsHeldToItsRangeAndANonNumberIsLeftToTheOperation() throws Exception {
+ MultivaluedMap<String, String> tooOld = params("Name", "ok", "Arn", "a".repeat(20), "Age", "31");
+ assertEquals(List.of("Value '31' at 'age' failed to satisfy constraint: "
+ + "Member must have value less than or equal to 30"),
+ check().violations("Put", tooOld));
+
+ MultivaluedMap<String, String> words = params("Name", "ok", "Arn", "a".repeat(20), "Age", "soon");
+ assertEquals(List.of(), check().violations("Put", words));
+ }
+
+ /** A boolean declares nothing a request can break, so nothing is checked for one. */
+ @Test
+ void aBooleanIsNotChecked() throws Exception {
+ assertEquals(List.of(), check().violations("Put",
+ params("Name", "ok", "Arn", "a".repeat(20), "Default", "yes")));
+ }
+
+ /** The file carries one wave of operations, so an operation outside it passes untouched. */
+ @Test
+ void anOperationTheFileDoesNotCarryPasses() throws Exception {
+ assertEquals(List.of(), check().violations("Delete", params("Name", "two words")));
+ }
+
+ /** The protocol's code and the Smithy count, from the same violations. */
+ @Test
+ void checkThrowsTheQueryProtocolsValidationError() throws Exception {
+ AwsException thrown = assertThrows(AwsException.class,
+ () -> check().check("Put", params("Name", "two w")));
+
+ assertEquals("ValidationError", thrown.getErrorCode());
+ assertEquals(400, thrown.getHttpStatus());
+ assertEquals("2 validation errors detected: Value 'two w' at 'name' failed to satisfy"
+ + " constraint: Member must satisfy regular expression pattern: [\\w+=,.@-]+;"
+ + " Value null at 'arn' failed to satisfy constraint: Member must not be null",
+ thrown.getMessage());
+ }
+
+ /**
+ * A list or a map is read from numbered parameters rather than from one, so an operation
+ * carrying either is refused when the file loads rather than passed over without its
+ * constraints.
+ */
+ @Test
+ void anOperationCarryingAListIsRefusedWhenTheFileLoads() throws Exception {
+ JsonNode model = MAPPER.readTree("""
+ {
+ "operations": {"Tag": "TagRequest"},
+ "shapes": {
+ "TagRequest": {"type": "structure", "members": {"Tags": "tagList"}},
+ "tagList": {"type": "list", "member": "nameType", "max": 50},
+ "nameType": {"type": "string", "min": 1}
+ }
+ }
+ """);
+
+ IllegalStateException thrown =
+ assertThrows(IllegalStateException.class, () -> QueryConstraintCheck.of(model));
+
+ assertTrue(thrown.getMessage().contains("Tag's Tags is a list"), thrown.getMessage());
+ }
+
+ /**
+ * The vendored IAM file itself, read the way the handler reads it. Loading it is the check on
+ * it: every operation's members have to be scalars and every pattern has to be one Java's
+ * engine compiles, and a wave that breaks either would otherwise surface as a failure on the
+ * first IAM request rather than here. Naming the twelve operations keeps the wave's own
+ * contract, so an operation renamed or dropped in the model is a failure with a name on it.
+ */
+ @Test
+ void theVendoredIamFileLoadsAndCarriesTheOperationsThisWaveClaims() {
+ QueryConstraintCheck iam =
+ QueryConstraintCheck.load("aws/iam-request-shapes.json", "IAM request shapes");
+
+ List<String> wave = List.of("AttachGroupPolicy", "AttachRolePolicy", "AttachUserPolicy",
+ "DetachGroupPolicy", "DetachRolePolicy", "DetachUserPolicy", "GetPolicy",
+ "DeletePolicy", "CreatePolicyVersion", "GetPolicyVersion", "DeletePolicyVersion",
+ "SetDefaultPolicyVersion");
+ for (String operation : wave) {
+ assertTrue(iam.violations(operation, params()).stream()
+ .allMatch(violation -> violation.contains("must not be null")),
+ operation + " reported something other than its absent required members");
+ assertTrue(iam.violations(operation, params()).size() >= 1,
+ operation + " resolved to no required members, so its shape did not resolve");
+ }
+
+ assertEquals(List.of("Value 'v1' at 'policyArn' failed to satisfy constraint: Member must"
+ + " have length greater than or equal to 20"),
+ iam.violations("GetPolicy", params("PolicyArn", "v1")));
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/IamRequestConstraintsIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/IamRequestConstraintsIntegrationTest.java
new file mode 100644
index 0000000000..fd69ad82bd
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/iam/IamRequestConstraintsIntegrationTest.java
@@ -0,0 +1,233 @@
+package io.github.hectorvent.floci.services.iam;
+
+import io.quarkus.test.junit.QuarkusTest;
+import io.restassured.specification.RequestSpecification;
+import org.junit.jupiter.api.Test;
+
+import static io.restassured.RestAssured.given;
+import static org.hamcrest.Matchers.containsString;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.not;
+
+/**
+ * The declared constraints the managed-policy family is now read against, from the model rather
+ * than from a hand-written check. What they change is the status: a value that breaks a declared
+ * constraint used to reach the store and answer {@code NoSuchEntity}, where AWS's validation layer
+ * runs ahead of the operation and answers {@code ValidationError}, which is the ordering #6402
+ * settled for this package.
+ *
+ * <p>{@code AttachRolePolicy}'s {@code RoleName} is the parity case rather than a change:
+ * {@code IamService.validateRoleName} already answered it in this form, from the same bounds and
+ * the same pattern, and the message is unchanged by the model taking it over.
+ */
+@QuarkusTest
+class IamRequestConstraintsIntegrationTest {
+
+ private static final String IAM_AUTH =
+ "AWS4-HMAC-SHA256 Credential=test/20261025/us-east-1/iam/aws4_request";
+
+ /** 20 characters, the shortest value `arnType` accepts, and no policy that exists. */
+ private static final String SHORTEST_ARN = "arn:aws:iam::1:p/abc";
+
+ private static final String TRUST_POLICY =
+ "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\","
+ + "\"Principal\":{\"Service\":\"lambda.amazonaws.com\"},\"Action\":\"sts:AssumeRole\"}]}";
+
+ private static final String CODE = "ErrorResponse.Error.Code";
+ private static final String MESSAGE = "ErrorResponse.Error.Message";
+
+ private static RequestSpecification iam(String action) {
+ return given().header("Authorization", IAM_AUTH).formParam("Action", action);
+ }
+
+ /** `arnType` is 20 to 2048, so a shorter ARN is the 400 rather than the lookup's 404. */
+ @Test
+ void anArnUnderItsMinimumIsRefusedAheadOfTheLookup() {
+ iam("GetPolicy")
+ .formParam("PolicyArn", "arn:aws:iam::1:p/ab")
+ .when().post("/").then().statusCode(400)
+ .body(CODE, equalTo("ValidationError"))
+ .body(MESSAGE, equalTo("1 validation error detected: Value 'arn:aws:iam::1:p/ab' at"
+ + " 'policyArn' failed to satisfy constraint: Member must have length greater"
+ + " than or equal to 20"))
+ .body(not(containsString("NoSuchEntity")));
+
+ // The same ARN one character longer clears the constraint and reaches the lookup.
+ iam("GetPolicy")
+ .formParam("PolicyArn", SHORTEST_ARN)
+ .when().post("/").then().statusCode(404)
+ .body(CODE, equalTo("NoSuchEntity"));
+ }
+
+ /** A required member the request leaves out is the validation layer's answer, not the store's. */
+ @Test
+ void aRequiredMemberLeftOutIsReportedAsNull() {
+ iam("DeletePolicy").when().post("/").then().statusCode(400)
+ .body(CODE, equalTo("ValidationError"))
+ .body(MESSAGE, equalTo("1 validation error detected: Value null at 'policyArn' failed"
+ + " to satisfy constraint: Member must not be null"));
+ }
+
+ /** `policyVersionIdType` publishes a pattern and no length, so a bare number breaks it. */
+ @Test
+ void aVersionIdOutsideItsPatternIsRefused() {
+ iam("GetPolicyVersion")
+ .formParam("PolicyArn", SHORTEST_ARN)
+ .formParam("VersionId", "1")
+ .when().post("/").then().statusCode(400)
+ .body(MESSAGE, equalTo("1 validation error detected: Value '1' at 'versionId' failed to"
+ + " satisfy constraint: Member must satisfy regular expression pattern:"
+ + " v[1-9][0-9]*(\\.[A-Za-z0-9-]*)?"));
+
+ iam("DeletePolicyVersion")
+ .formParam("PolicyArn", SHORTEST_ARN)
+ .formParam("VersionId", "v1")
+ .when().post("/").then().statusCode(404)
+ .body(CODE, equalTo("NoSuchEntity"));
+ }
+
+ /**
+ * A document sent empty is a member that is present, so what it breaks are its own
+ * constraints: the minimum length of 1 and a pattern that asks for a character, reported as
+ * two violations the way #6402 reports an id that breaks both of its.
+ */
+ @Test
+ void anEmptyPolicyDocumentBreaksItsLengthAndItsPattern() {
+ iam("CreatePolicyVersion")
+ .formParam("PolicyArn", SHORTEST_ARN)
+ .formParam("PolicyDocument", "")
+ .when().post("/").then().statusCode(400)
+ .body(MESSAGE, containsString("2 validation errors detected: Value '' at"
+ + " 'policyDocument' failed to satisfy constraint: Member must have length"
+ + " greater than or equal to 1"))
+ .body(MESSAGE, containsString("Value '' at 'policyDocument' failed to satisfy"
+ + " constraint: Member must satisfy regular expression pattern:"));
+ }
+
+ /**
+ * Both broken members are reported in one message, in the order the model lists them rather
+ * than the order the request sent them. The second half is what makes that an assertion: the
+ * request puts `PolicyArn` first and the answer still leads with `userName`, which the model
+ * lists first. Whether AWS orders them that way is GEN-2's capture to confirm; what is pinned
+ * here is that the order comes from the model and not from the wire.
+ */
+ @Test
+ void twoBrokenMembersAreReportedTogetherInTheModelsOrder() {
+ String expected = "2 validation errors detected: Value '" + "a".repeat(65) + "' at"
+ + " 'userName' failed to satisfy constraint: Member must have length less than"
+ + " or equal to 64; Value 'short' at 'policyArn' failed to satisfy constraint:"
+ + " Member must have length greater than or equal to 20";
+
+ iam("AttachUserPolicy")
+ .formParam("UserName", "a".repeat(65))
+ .formParam("PolicyArn", "short")
+ .when().post("/").then().statusCode(400)
+ .body(MESSAGE, equalTo(expected));
+
+ iam("AttachUserPolicy")
+ .formParam("PolicyArn", "short")
+ .formParam("UserName", "a".repeat(65))
+ .when().post("/").then().statusCode(400)
+ .body(MESSAGE, equalTo(expected));
+ }
+
+ /**
+ * The parity case: the message for a role name outside its pattern is the one
+ * {@code validateRoleName} already answered, from the same bounds, so what changed is where it
+ * is read rather than what it says.
+ */
+ @Test
+ void aRoleNameOutsideItsPatternKeepsTheMessageTheServiceAlreadyAnswered() {
+ iam("AttachRolePolicy")
+ .formParam("RoleName", "two words")
+ .formParam("PolicyArn", SHORTEST_ARN)
+ .when().post("/").then().statusCode(400)
+ .body(CODE, equalTo("ValidationError"))
+ .body(MESSAGE, equalTo("1 validation error detected: Value 'two words' at 'roleName'"
+ + " failed to satisfy constraint: Member must satisfy regular expression"
+ + " pattern: [\\w+=,.@-]+"));
+ }
+
+ /**
+ * An empty name is the one input where reading the model changes what this service answers
+ * rather than only when it answers. {@code validateRoleName} stops at the first constraint an
+ * empty value breaks, so it reports the minimum length alone; the model reports the pattern it
+ * also breaks, which is how #6402 reports an id breaking two of its own, and how
+ * {@code GetMFADevice} already answers an empty {@code UserName}. The operations still on the
+ * hand-written check keep the single violation until a later wave takes them over, and
+ * {@code CreateRole} below is what holds that boundary still.
+ *
+ * <p>The order of the two is this package's, matching {@code GetMFADevice}, rather than a
+ * claim about AWS: the captured messages in the Identity Center guide show length before
+ * pattern in one and pattern before length in another, so an exact order is stricter than any
+ * source states.
+ */
+ @Test
+ void anEmptyRoleNameBreaksTwoConstraintsWhereTheHandWrittenCheckStopsAtOne() {
+ iam("AttachRolePolicy")
+ .formParam("RoleName", "")
+ .formParam("PolicyArn", SHORTEST_ARN)
+ .when().post("/").then().statusCode(400)
+ .body(CODE, equalTo("ValidationError"))
+ .body(MESSAGE, equalTo("2 validation errors detected: Value '' at 'roleName' failed to"
+ + " satisfy constraint: Member must have length greater than or equal to 1;"
+ + " Value '' at 'roleName' failed to satisfy constraint: Member must satisfy"
+ + " regular expression pattern: [\\w+=,.@-]+"));
+
+ // The same empty name on an operation this wave leaves alone, reported the older way.
+ iam("CreateRole")
+ .formParam("RoleName", "")
+ .formParam("AssumeRolePolicyDocument", TRUST_POLICY)
+ .when().post("/").then().statusCode(400)
+ .body(MESSAGE, equalTo("1 validation error detected: Value '' at 'roleName' failed to"
+ + " satisfy constraint: Member must have length greater than or equal to 1"));
+ }
+
+ /**
+ * A name of one space is a character long, so it clears the minimum and breaks only the
+ * pattern. It is worth pinning because this package elsewhere reads a blank required member as
+ * absent, and the model does not: the request carries it, so it is a value.
+ */
+ @Test
+ void aBlankRoleNameBreaksOnlyItsPatternRatherThanReadingAsAbsent() {
+ iam("DetachRolePolicy")
+ .formParam("RoleName", " ")
+ .formParam("PolicyArn", SHORTEST_ARN)
+ .when().post("/").then().statusCode(400)
+ .body(MESSAGE, equalTo("1 validation error detected: Value ' ' at 'roleName' failed to"
+ + " satisfy constraint: Member must satisfy regular expression pattern:"
+ + " [\\w+=,.@-]+"));
+ }
+
+ /** The other end of `arnType`: 2048 characters are accepted and 2049 are not. */
+ @Test
+ void anArnAtItsMaximumIsAcceptedAndOneCharacterLongerIsNot() {
+ iam("GetPolicy")
+ .formParam("PolicyArn", "arn:aws:iam::1:p/" + "a".repeat(2031))
+ .when().post("/").then().statusCode(404)
+ .body(CODE, equalTo("NoSuchEntity"));
+
+ iam("GetPolicy")
+ .formParam("PolicyArn", "arn:aws:iam::1:p/" + "a".repeat(2032))
+ .when().post("/").then().statusCode(400)
+ .body(CODE, equalTo("ValidationError"))
+ .body(MESSAGE, containsString("at 'policyArn' failed to satisfy constraint: Member must"
+ + " have length less than or equal to 2048"))
+ .body(not(containsString("NoSuchEntity")));
+ }
+
+ /**
+ * A boolean is declared and not checked: the model names no constraint for one, so a value
+ * that is neither true nor false reaches the operation, which reads anything but "true" as
+ * false. Pinned rather than fixed, since what AWS answers for one is unrecorded here.
+ */
+ @Test
+ void aBooleanOutsideTrueAndFalseIsLeftToTheOperation() {
+ iam("CreatePolicyVersion")
+ .formParam("PolicyArn", SHORTEST_ARN)
+ .formParam("PolicyDocument", "{}")
+ .formParam("SetAsDefault", "maybe")
+ .when().post("/").then().statusCode(404)
+ .body(CODE, equalTo("NoSuchEntity"));
+ }
+}
diff --git a/tools/aws/regen_iam_shapes.py b/tools/aws/regen_iam_shapes.py
new file mode 100644
index 0000000000..3908057f50
--- /dev/null
+++ b/tools/aws/regen_iam_shapes.py
@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+"""Vendor IAM request constraints from botocore's Apache-2.0 service model.
+
+`IamRequestShapes` checks the operations listed here against the vendored file through the shared
+`QueryConstraintCheck`: required members, lengths, patterns and enum values, as the model states
+them. The list grows an operation at a time, each one taken off the hand-written checks in the
+same change, so a wave is always reviewable against the messages it replaces.
+
+Run from anywhere in the repo:
+ python3 tools/aws/regen_iam_shapes.py # rewrite the vendored file in place
+ python3 tools/aws/regen_iam_shapes.py --check # exit 1 when the vendored file is stale
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from regen_partitions import resolve_botocore_data, strip_source
+from request_shapes import REPO_ROOT, build_constraints, load_model
+
+OUTPUT = REPO_ROOT / "src/main/resources/aws/iam-request-shapes.json"
+MODEL = Path("iam/2010-05-08")
+GENERATOR = "tools/aws/regen_iam_shapes.py"
+
+# The managed-policy family: every member a scalar, and no operation here checks a declared
+# constraint by hand today, so the vendored shapes add the refusals AWS answers without rewording
+# anything already answered. `AttachRolePolicy` and `DetachRolePolicy` are the exception and the
+# parity case: `IamService.validateRoleName` already answers `roleName` in Smithy's form.
+OPERATIONS = (
+ "AttachGroupPolicy", "AttachRolePolicy", "AttachUserPolicy",
+ "DetachGroupPolicy", "DetachRolePolicy", "DetachUserPolicy",
+ "GetPolicy", "DeletePolicy",
+ "CreatePolicyVersion", "GetPolicyVersion", "DeletePolicyVersion", "SetDefaultPolicyVersion",
+)
+
+
+def build(model: dict, provenance: str) -> dict:
+ return build_constraints(model, OPERATIONS, provenance, GENERATOR)
+
+
+def render(doc: dict) -> str:
+ return json.dumps(doc, indent=2) + "\n"
+
+
+def main(argv: list[str] | None = None) -> int:
+ parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+ parser.add_argument("--check", action="store_true", help="exit 1 when the vendored file differs from a fresh generation")
+ parser.add_argument("--botocore-data", type=Path, help="botocore data directory")
+ parser.add_argument("--output", type=Path, default=OUTPUT, help=argparse.SUPPRESS)
+ args = parser.parse_args(argv)
+ data, provenance = resolve_botocore_data(args.botocore_data)
+ fresh = render(build(load_model(data, MODEL), provenance))
+ if args.check:
+ current = args.output.read_text(encoding="utf-8") if args.output.exists() else ""
+ if strip_source(current) != strip_source(fresh):
+ print(f"{args.output} is stale (generated from {provenance}).", file=sys.stderr)
+ return 1
+ return 0
+ args.output.write_text(fresh, encoding="utf-8")
+ shown = args.output.relative_to(REPO_ROOT) if args.output.is_relative_to(REPO_ROOT) else args.output
+ print(f"wrote {shown} from {provenance}")
+ return 0
+
+
+if __name__ == "__main__":
+ sys.exit(main())
diff --git a/tools/aws/test_regen_iam_shapes.py b/tools/aws/test_regen_iam_shapes.py
new file mode 100644
index 0000000000..79fe9d406a
--- /dev/null
+++ b/tools/aws/test_regen_iam_shapes.py
@@ -0,0 +1,88 @@
+"""Tests for regen_iam_shapes.
+
+Run with: pytest tools/aws -q (or: make aws-data-test)
+"""
+from __future__ import annotations
+
+import json
+
+import pytest
+
+import regen_iam_shapes as r
+
+
+MODEL = {
+ "operations": {
+ "GetPolicy": {"input": {"shape": "GetPolicyRequest"}, "output": {"shape": "GetPolicyResponse"}},
+ "ListPolicies": {"input": {"shape": "ListPoliciesRequest"}},
+ },
+ "shapes": {
+ "GetPolicyRequest": {"type": "structure", "required": ["PolicyArn"], "members": {
+ "PolicyArn": {"shape": "arnType"},
+ }},
+ "GetPolicyResponse": {"type": "structure", "members": {"Policy": {"shape": "arnType"}}},
+ "ListPoliciesRequest": {"type": "structure", "members": {"MaxItems": {"shape": "maxItemsType"}}},
+ "arnType": {"type": "string", "min": 20, "max": 2048},
+ "maxItemsType": {"type": "integer", "min": 1, "max": 1000},
+ },
+}
+
+
+def test_keeps_only_the_listed_operations_with_their_constraints(monkeypatch):
+ monkeypatch.setattr(r, "OPERATIONS", ("GetPolicy",))
+
+ doc = r.build(MODEL, "botocore test")
+
+ assert doc["_source"] == {"generator": "tools/aws/regen_iam_shapes.py", "botocore": "botocore test"}
+ assert doc["operations"] == {"GetPolicy": "GetPolicyRequest"}
+ assert "GetPolicyResponse" not in doc["shapes"]
+ assert "maxItemsType" not in doc["shapes"]
+ assert doc["shapes"]["GetPolicyRequest"] == {
+ "type": "structure", "required": ["PolicyArn"], "members": {"PolicyArn": "arnType"}}
+ assert doc["shapes"]["arnType"] == {"type": "string", "min": 20, "max": 2048}
+
+
+def test_a_misspelled_operation_is_refused_rather_than_skipped(monkeypatch):
+ monkeypatch.setattr(r, "OPERATIONS", ("GetPolciy",))
+
+ with pytest.raises(KeyError):
+ r.build(MODEL, "botocore test")
+
+
+def test_the_vendored_file_carries_every_listed_operation():
+ doc = json.loads(r.OUTPUT.read_text(encoding="utf-8"))
+
+ assert sorted(doc["operations"]) == sorted(r.OPERATIONS)
+ for operation, shape in doc["operations"].items():
+ assert shape in doc["shapes"], operation
+
+
+def test_check_ignores_provenance(tmp_path, monkeypatch):
+ monkeypatch.setattr(r, "OPERATIONS", ("GetPolicy",))
+ output = tmp_path / "shapes.json"
+ output.write_text(r.render(r.build(MODEL, "botocore 0.0.1 (local/aws/botocore)")), encoding="utf-8")
+ monkeypatch.setattr(r, "resolve_botocore_data", lambda explicit: (tmp_path, "--botocore-data /elsewhere"))
+ monkeypatch.setattr(r, "load_model", lambda data, model: MODEL)
+
+ assert r.main(["--check", "--output", str(output)]) == 0
+
+
+def test_check_reports_a_changed_constraint(tmp_path, monkeypatch):
+ monkeypatch.setattr(r, "OPERATIONS", ("GetPolicy",))
+ output = tmp_path / "shapes.json"
+ changed = {**MODEL, "shapes": {**MODEL["shapes"], "arnType": {"type": "string", "min": 1, "max": 2048}}}
+ output.write_text(r.render(r.build(changed, "botocore test")), encoding="utf-8")
+ monkeypatch.setattr(r, "resolve_botocore_data", lambda explicit: (tmp_path, "botocore test"))
+ monkeypatch.setattr(r, "load_model", lambda data, model: MODEL)
+
+ assert r.main(["--check", "--output", str(output)]) == 1
+
+
+def test_output_is_stable(monkeypatch):
+ monkeypatch.setattr(r, "OPERATIONS", ("GetPolicy", "ListPolicies"))
+
+ first = r.render(r.build(MODEL, "botocore test"))
+ second = r.render(r.build(MODEL, "botocore test"))
+
+ assert first == second
+ assert first.endswith("\n")