Light, fluffy, and always free - The AWS Local Emulator alternative
feat(cognito): include all standard attributes in DescribeUserPool Schema (#642)
Yorí1cccf43f7b81
diff --git a/compatibility-tests/sdk-test-awscli/test/cognito.bats b/compatibility-tests/sdk-test-awscli/test/cognito.batsindex 40d711fb9f..225aeae9a1 100644--- a/compatibility-tests/sdk-test-awscli/test/cognito.bats+++ b/compatibility-tests/sdk-test-awscli/test/cognito.bats@@ -229,3 +229,28 @@ teardown() {assert_failure[[ "$output" == *"ValidationException"* ]]}++@test "Cognito: describe-user-pool returns all 20 standard SchemaAttributes" {+ out=$(aws_cmd cognito-idp create-user-pool --pool-name "bats-test-pool-$(unique_name)")+ POOL_ID=$(json_get "$out" '.UserPool.Id')++ run aws_cmd cognito-idp describe-user-pool --user-pool-id "$POOL_ID"+ assert_success++ count=$(echo "$output" | jq '.UserPool.SchemaAttributes | length')+ [ "$count" -eq 20 ]++ for attr in sub name given_name family_name middle_name nickname \+ preferred_username profile picture website email email_verified \+ gender birthdate zoneinfo locale phone_number phone_number_verified \+ address updated_at; do+ found=$(echo "$output" | jq --arg n "$attr" '[.UserPool.SchemaAttributes[] | select(.Name == $n)] | length')+ [ "$found" -eq 1 ] || { echo "missing standard attribute: $attr"; return 1; }+ done++ sub_required=$(echo "$output" | jq '[.UserPool.SchemaAttributes[] | select(.Name == "sub")] | .[0].Required')+ [ "$sub_required" = "true" ]++ sub_mutable=$(echo "$output" | jq '[.UserPool.SchemaAttributes[] | select(.Name == "sub")] | .[0].Mutable')+ [ "$sub_mutable" = "false" ]+}diff --git a/compatibility-tests/sdk-test-go/internal/testutil/fixtures.go b/compatibility-tests/sdk-test-go/internal/testutil/fixtures.goindex 7d6ca75b96..c9cf8985aa 100644--- a/compatibility-tests/sdk-test-go/internal/testutil/fixtures.go+++ b/compatibility-tests/sdk-test-go/internal/testutil/fixtures.go@@ -11,6 +11,7 @@ import ("github.com/aws/aws-sdk-go-v2/config""github.com/aws/aws-sdk-go-v2/credentials""github.com/aws/aws-sdk-go-v2/service/acm"+ "github.com/aws/aws-sdk-go-v2/service/cognitoidentityprovider""github.com/aws/aws-sdk-go-v2/service/ecr""github.com/aws/aws-sdk-go-v2/service/pipes""github.com/aws/aws-sdk-go-v2/service/cloudwatch"@@ -132,6 +133,11 @@ func RDSClient() *rds.Client {return rds.NewFromConfig(Config())}+// CognitoClient returns a new Cognito Identity Provider client.+func CognitoClient() *cognitoidentityprovider.Client {+ return cognitoidentityprovider.NewFromConfig(Config())+}+// ProxyHost returns the host to use for direct TCP connections to RDS/ElastiCache proxies.func ProxyHost() string {ep := Endpoint()diff --git a/compatibility-tests/sdk-test-go/tests/cognito_test.go b/compatibility-tests/sdk-test-go/tests/cognito_test.gonew file mode 100644index 0000000000..448641eb8c--- /dev/null+++ b/compatibility-tests/sdk-test-go/tests/cognito_test.go@@ -0,0 +1,62 @@+package tests++import (+ "context"+ "testing"++ "floci-sdk-test-go/internal/testutil"++ "github.com/aws/aws-sdk-go-v2/aws"+ "github.com/aws/aws-sdk-go-v2/service/cognitoidentityprovider"+ "github.com/stretchr/testify/assert"+ "github.com/stretchr/testify/require"+)++func TestCognitoDescribeUserPoolStandardAttributes(t *testing.T) {+ ctx := context.Background()+ svc := testutil.CognitoClient()++ poolName := "go-test-cognito-standard-attrs"+ created, err := svc.CreateUserPool(ctx, &cognitoidentityprovider.CreateUserPoolInput{+ PoolName: aws.String(poolName),+ })+ require.NoError(t, err)+ poolID := created.UserPool.Id++ t.Cleanup(func() {+ svc.DeleteUserPool(ctx, &cognitoidentityprovider.DeleteUserPoolInput{+ UserPoolId: poolID,+ })+ })++ resp, err := svc.DescribeUserPool(ctx, &cognitoidentityprovider.DescribeUserPoolInput{+ UserPoolId: poolID,+ })+ require.NoError(t, err)++ schema := resp.UserPool.SchemaAttributes+ assert.Len(t, schema, 20, "DescribeUserPool must return all 20 standard Cognito attributes")++ names := make(map[string]bool, len(schema))+ for _, attr := range schema {+ names[aws.ToString(attr.Name)] = true+ }++ expected := []string{+ "sub", "name", "given_name", "family_name", "middle_name", "nickname",+ "preferred_username", "profile", "picture", "website", "email",+ "email_verified", "gender", "birthdate", "zoneinfo", "locale",+ "phone_number", "phone_number_verified", "address", "updated_at",+ }+ for _, attr := range expected {+ assert.True(t, names[attr], "missing standard attribute: %s", attr)+ }++ // spot-check sub+ for _, attr := range schema {+ if aws.ToString(attr.Name) == "sub" {+ assert.True(t, aws.ToBool(attr.Required), "sub must be Required")+ assert.False(t, aws.ToBool(attr.Mutable), "sub must not be Mutable")+ }+ }+}diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CognitoFeaturesTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CognitoFeaturesTest.javaindex f6b321e27b..cb78069353 100644--- a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CognitoFeaturesTest.java+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CognitoFeaturesTest.java@@ -382,6 +382,24 @@ class CognitoFeaturesTest {assertThat(resp.users()).isEmpty();}+ @Test+ @Order(55)+ void describeUserPoolReturnsAllTwentyStandardAttributes() {+ DescribeUserPoolResponse resp = cognito.describeUserPool(b -> b.userPoolId(poolId));+ List<SchemaAttributeType> schema = resp.userPool().schemaAttributes();+ assertThat(schema).hasSize(20);+ List<String> names = schema.stream().map(SchemaAttributeType::name).toList();+ assertThat(names).contains(+ "sub", "name", "given_name", "family_name", "middle_name", "nickname",+ "preferred_username", "profile", "picture", "website", "email",+ "email_verified", "gender", "birthdate", "zoneinfo", "locale",+ "phone_number", "phone_number_verified", "address", "updated_at");++ SchemaAttributeType sub = schema.stream().filter(a -> "sub".equals(a.name())).findFirst().orElseThrow();+ assertThat(sub.required()).isTrue();+ assertThat(sub.mutable()).isFalse();+ }+// ── Issue #234 note ───────────────────────────────────────────────────────// GetTokensFromRefreshToken is tested in sdk-test-node/tests/cognito-features.test.ts// because GetTokensFromRefreshTokenCommand is not available in Java SDK 2.31.8.diff --git a/compatibility-tests/sdk-test-node/tests/cognito-features.test.ts b/compatibility-tests/sdk-test-node/tests/cognito-features.test.tsindex 18f396b8f8..47e01e6438 100644--- a/compatibility-tests/sdk-test-node/tests/cognito-features.test.ts+++ b/compatibility-tests/sdk-test-node/tests/cognito-features.test.ts@@ -21,6 +21,7 @@ import {InitiateAuthCommand,ListUsersCommand,GetTokensFromRefreshTokenCommand,+ DescribeUserPoolCommand,DeleteUserPoolCommand,MessageActionType,ExplicitAuthFlowsType,@@ -415,6 +416,25 @@ describe('Cognito features (#218 #220 #228 #229 #233 #234 #235)', () => {).rejects.toThrow();});+ it('DescribeUserPool returns all 20 standard SchemaAttributes', async () => {+ const resp = await cognito.send(new DescribeUserPoolCommand({ UserPoolId: poolId }));+ const schema = resp.UserPool?.SchemaAttributes ?? [];+ expect(schema).toHaveLength(20);+ const names = schema.map((a) => a.Name);+ const expected = [+ 'sub', 'name', 'given_name', 'family_name', 'middle_name', 'nickname',+ 'preferred_username', 'profile', 'picture', 'website', 'email',+ 'email_verified', 'gender', 'birthdate', 'zoneinfo', 'locale',+ 'phone_number', 'phone_number_verified', 'address', 'updated_at',+ ];+ for (const attr of expected) {+ expect(names).toContain(attr);+ }+ const sub = schema.find((a) => a.Name === 'sub');+ expect(sub?.Required).toBe(true);+ expect(sub?.Mutable).toBe(false);+ });+it('#234: REFRESH_TOKEN_AUTH flow also works with structured token', async () => {const loginResp = await cognito.send(new InitiateAuthCommand({diff --git a/compatibility-tests/sdk-test-python/tests/test_cognito.py b/compatibility-tests/sdk-test-python/tests/test_cognito.pyindex 0c9b176ad5..07e452d7e5 100644--- a/compatibility-tests/sdk-test-python/tests/test_cognito.py+++ b/compatibility-tests/sdk-test-python/tests/test_cognito.py@@ -189,3 +189,33 @@ class TestCognitoAuth:UserPoolId=pool_id, ClientId=client_id)cognito_client.delete_user_pool(UserPoolId=pool_id)+++class TestCognitoDescribeUserPoolStandardAttributes:+ """DescribeUserPool must return all 20 standard OIDC attributes."""++ STANDARD_ATTRIBUTES = [+ "sub", "name", "given_name", "family_name", "middle_name", "nickname",+ "preferred_username", "profile", "picture", "website", "email",+ "email_verified", "gender", "birthdate", "zoneinfo", "locale",+ "phone_number", "phone_number_verified", "address", "updated_at",+ ]++ def test_describe_user_pool_returns_all_standard_schema_attributes(self, cognito_client, unique_name):+ response = cognito_client.create_user_pool(PoolName=f"pytest-schema-{unique_name}")+ pool_id = response["UserPool"]["Id"]++ try:+ described = cognito_client.describe_user_pool(UserPoolId=pool_id)+ schema = described["UserPool"]["SchemaAttributes"]+ names = [a["Name"] for a in schema]++ assert len(schema) == 20+ for attr in self.STANDARD_ATTRIBUTES:+ assert attr in names, f"Missing standard attribute: {attr}"++ sub = next(a for a in schema if a["Name"] == "sub")+ assert sub["Required"] is True+ assert sub["Mutable"] is False+ finally:+ cognito_client.delete_user_pool(UserPoolId=pool_id)diff --git a/compatibility-tests/sdk-test-rust/tests/cognito_test.rs b/compatibility-tests/sdk-test-rust/tests/cognito_test.rsnew file mode 100644index 0000000000..0d11ab60e5--- /dev/null+++ b/compatibility-tests/sdk-test-rust/tests/cognito_test.rs@@ -0,0 +1,63 @@+mod common;++#[tokio::test(flavor = "multi_thread")]+async fn test_cognito_describe_user_pool_returns_all_standard_attributes() {+ let cognito = common::cognito_client().await;+ let pool_name = "rust-test-cognito-standard-attrs";++ let created = cognito+ .create_user_pool()+ .pool_name(pool_name)+ .send()+ .await+ .expect("CreateUserPool failed");++ let pool_id = created+ .user_pool()+ .and_then(|p| p.id())+ .expect("pool id missing")+ .to_string();++ let _guard = common::CleanupGuard::new({+ let cognito = cognito.clone();+ let pool_id = pool_id.clone();+ async move {+ let _ = cognito+ .delete_user_pool()+ .user_pool_id(pool_id)+ .send()+ .await;+ }+ });++ let resp = cognito+ .describe_user_pool()+ .user_pool_id(&pool_id)+ .send()+ .await+ .expect("DescribeUserPool failed");++ let schema = resp+ .user_pool()+ .and_then(|p| Some(p.schema_attributes()))+ .unwrap_or_default();++ assert_eq!(schema.len(), 20, "DescribeUserPool must return all 20 standard Cognito attributes");++ let names: Vec<&str> = schema.iter().filter_map(|a| a.name()).collect();++ let expected = [+ "sub", "name", "given_name", "family_name", "middle_name", "nickname",+ "preferred_username", "profile", "picture", "website", "email",+ "email_verified", "gender", "birthdate", "zoneinfo", "locale",+ "phone_number", "phone_number_verified", "address", "updated_at",+ ];+ for attr in &expected {+ assert!(names.contains(attr), "missing standard attribute: {attr}");+ }++ // spot-check sub+ let sub = schema.iter().find(|a| a.name() == Some("sub")).expect("sub not found");+ assert_eq!(sub.required(), Some(true), "sub must be Required");+ assert_eq!(sub.mutable(), Some(false), "sub must not be Mutable");+}diff --git a/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoJsonHandler.java b/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoJsonHandler.javaindex ed7c156259..48dcea2a65 100644--- a/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoJsonHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoJsonHandler.java@@ -495,7 +495,7 @@ public class CognitoJsonHandler {node.set("Policies", objectMapper.valueToTree(p.getPolicies() != null ? p.getPolicies() : new HashMap<>()));node.put("DeletionProtection", p.getDeletionProtection() != null ? p.getDeletionProtection() : "INACTIVE");node.set("LambdaConfig", objectMapper.valueToTree(p.getLambdaConfig() != null ? p.getLambdaConfig() : new HashMap<>()));- node.set("SchemaAttributes", objectMapper.valueToTree(p.getSchemaAttributes() != null ? p.getSchemaAttributes() : new java.util.ArrayList<>()));+ node.set("SchemaAttributes", objectMapper.valueToTree(CognitoStandardAttributes.merge(p.getSchemaAttributes())));node.set("AutoVerifiedAttributes", objectMapper.valueToTree(p.getAutoVerifiedAttributes() != null ? p.getAutoVerifiedAttributes() : new java.util.ArrayList<>()));node.set("AliasAttributes", objectMapper.valueToTree(p.getAliasAttributes() != null ? p.getAliasAttributes() : new java.util.ArrayList<>()));node.set("UsernameAttributes", objectMapper.valueToTree(p.getUsernameAttributes() != null ? p.getUsernameAttributes() : new java.util.ArrayList<>()));diff --git a/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoStandardAttributes.java b/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoStandardAttributes.javanew file mode 100644index 0000000000..115a70a25a--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoStandardAttributes.java@@ -0,0 +1,105 @@+package io.github.hectorvent.floci.services.cognito;++import java.util.ArrayList;+import java.util.LinkedHashMap;+import java.util.List;+import java.util.Map;++final class CognitoStandardAttributes {++ private CognitoStandardAttributes() {}++ static final List<Map<String, Object>> DEFAULTS = buildDefaults();++ private static List<Map<String, Object>> buildDefaults() {+ List<Map<String, Object>> attrs = new ArrayList<>();++ attrs.add(stringAttr("sub", "1", "2048", false, true));+ attrs.add(stringAttr("name", "0", "2048", true, false));+ attrs.add(stringAttr("given_name", "0", "2048", true, false));+ attrs.add(stringAttr("family_name", "0", "2048", true, false));+ attrs.add(stringAttr("middle_name", "0", "2048", true, false));+ attrs.add(stringAttr("nickname", "0", "2048", true, false));+ attrs.add(stringAttr("preferred_username", "0", "2048", true, false));+ attrs.add(stringAttr("profile", "0", "2048", true, false));+ attrs.add(stringAttr("picture", "0", "2048", true, false));+ attrs.add(stringAttr("website", "0", "2048", true, false));+ attrs.add(stringAttr("email", "0", "2048", true, false));+ attrs.add(booleanAttr("email_verified"));+ attrs.add(stringAttr("gender", "0", "2048", true, false));+ attrs.add(stringAttr("birthdate", "10", "10", true, false));+ attrs.add(stringAttr("zoneinfo", "0", "2048", true, false));+ attrs.add(stringAttr("locale", "0", "2048", true, false));+ attrs.add(stringAttr("phone_number", "0", "2048", true, false));+ attrs.add(booleanAttr("phone_number_verified"));+ attrs.add(stringAttr("address", "0", "2048", true, false));+ attrs.add(numberAttr("updated_at"));++ return List.copyOf(attrs);+ }++ private static Map<String, Object> stringAttr(String name, String minLength, String maxLength,+ boolean mutable, boolean required) {+ Map<String, Object> attr = new LinkedHashMap<>();+ attr.put("Name", name);+ attr.put("AttributeDataType", "String");+ attr.put("DeveloperOnlyAttribute", false);+ attr.put("Mutable", mutable);+ attr.put("Required", required);+ attr.put("StringAttributeConstraints", Map.of("MinLength", minLength, "MaxLength", maxLength));+ return attr;+ }++ private static Map<String, Object> booleanAttr(String name) {+ Map<String, Object> attr = new LinkedHashMap<>();+ attr.put("Name", name);+ attr.put("AttributeDataType", "Boolean");+ attr.put("DeveloperOnlyAttribute", false);+ attr.put("Mutable", true);+ attr.put("Required", false);+ return attr;+ }++ private static Map<String, Object> numberAttr(String name) {+ Map<String, Object> attr = new LinkedHashMap<>();+ attr.put("Name", name);+ attr.put("AttributeDataType", "Number");+ attr.put("DeveloperOnlyAttribute", false);+ attr.put("Mutable", true);+ attr.put("Required", false);+ attr.put("NumberAttributeConstraints", Map.of("MinValue", "0"));+ return attr;+ }++ /**+ * Merges standard attributes with any pool-defined schema.+ * Custom attributes (name starts with "custom:") are appended after standard ones.+ * Standard attributes explicitly included in the schema override the defaults.+ */+ static List<Map<String, Object>> merge(List<Map<String, Object>> poolSchema) {+ if (poolSchema == null || poolSchema.isEmpty()) {+ return DEFAULTS;+ }++ Map<String, Map<String, Object>> byName = new LinkedHashMap<>();+ for (Map<String, Object> attr : DEFAULTS) {+ byName.put((String) attr.get("Name"), attr);+ }++ List<Map<String, Object>> custom = new ArrayList<>();+ for (Map<String, Object> attr : poolSchema) {+ String name = (String) attr.get("Name");+ if (name != null && name.startsWith("custom:")) {+ custom.add(attr);+ } else if (name != null && byName.containsKey(name)) {+ byName.put(name, attr);+ } else if (name != null) {+ custom.add(attr);+ }+ }++ List<Map<String, Object>> result = new ArrayList<>(byName.values());+ result.addAll(custom);+ return result;+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoIntegrationTest.javaindex 607b539c5b..1a6f2e5fb4 100644--- a/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoIntegrationTest.java@@ -24,11 +24,15 @@ import java.security.PublicKey;import java.security.Signature;import java.security.spec.RSAPublicKeySpec;import java.util.Base64;+import java.util.List;+import java.util.Spliterators;import java.util.UUID;import java.util.stream.Stream;+import java.util.stream.StreamSupport;import static io.restassured.RestAssured.given;import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertFalse;import static org.junit.jupiter.api.Assertions.assertNotNull;import static org.junit.jupiter.api.Assertions.assertTrue;@@ -176,6 +180,36 @@ class CognitoIntegrationTest {assertEquals("RS256", document.path("id_token_signing_alg_values_supported").get(0).asText());}+ @Test+ @Order(5)+ void describeUserPoolReturnsAllTwentyStandardAttributes() throws Exception {+ JsonNode body = cognitoJson("DescribeUserPool", """+ { "UserPoolId": "%s" }+ """.formatted(poolId));++ JsonNode schema = body.path("UserPool").path("SchemaAttributes");+ assertEquals(20, schema.size(), "DescribeUserPool must include all 20 Cognito standard attributes");++ java.util.Set<String> names = new java.util.HashSet<>();+ schema.forEach(attr -> names.add(attr.path("Name").asText()));++ for (String expected : List.of("sub", "name", "given_name", "family_name", "middle_name",+ "nickname", "preferred_username", "profile", "picture", "website",+ "email", "email_verified", "gender", "birthdate", "zoneinfo",+ "locale", "phone_number", "phone_number_verified", "address", "updated_at")) {+ assertTrue(names.contains(expected), "Missing standard attribute in DescribeUserPool response: " + expected);+ }++ // spot-check: sub must be required and immutable+ JsonNode sub = StreamSupport.stream(+ Spliterators.spliteratorUnknownSize(schema.elements(), 0), false)+ .filter(n -> "sub".equals(n.path("Name").asText()))+ .findFirst()+ .orElseThrow();+ assertTrue(sub.path("Required").asBoolean(), "sub must be Required");+ assertFalse(sub.path("Mutable").asBoolean(), "sub must not be Mutable");+ }+// ── Groups ────────────────────────────────────────────────────────@Testdiff --git a/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoJsonHandlerTest.java b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoJsonHandlerTest.javaindex 8d6db53e15..4f5c517c76 100644--- a/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoJsonHandlerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoJsonHandlerTest.java@@ -15,6 +15,10 @@ import org.junit.jupiter.api.Test;import java.util.List;import java.util.Map;+import java.util.Set;+import java.util.Spliterators;+import java.util.stream.Collectors;+import java.util.stream.StreamSupport;import static org.junit.jupiter.api.Assertions.*;@@ -93,8 +97,9 @@ class CognitoJsonHandlerTest {// Check mandatory blocks for TerraformassertNotNull(pool.get("SchemaAttributes"));- assertEquals(1, pool.get("SchemaAttributes").size());- assertEquals("email", pool.get("SchemaAttributes").get(0).get("Name").asText());+ assertEquals(20, pool.get("SchemaAttributes").size(),+ "DescribeUserPool must always return all 20 Cognito standard attributes");+ assertTrue(schemaNames(pool).contains("email"));assertNotNull(pool.get("Policies"));assertNotNull(pool.get("LambdaConfig"));@@ -190,6 +195,80 @@ class CognitoJsonHandlerTest {assertFalse(afterUntag.has("team"));}+ @Test+ void describeUserPoolWithNoSchemaReturnsAllTwentyStandardAttributes() {+ ObjectNode create = mapper.createObjectNode();+ create.put("PoolName", "no-schema-pool");+ JsonNode created = (JsonNode) handler.handle("CreateUserPool", create, "us-east-1").getEntity();+ String poolId = created.get("UserPool").get("Id").asText();++ ObjectNode describe = mapper.createObjectNode();+ describe.put("UserPoolId", poolId);+ JsonNode body = (JsonNode) handler.handle("DescribeUserPool", describe, "us-east-1").getEntity();+ JsonNode schema = body.get("UserPool").get("SchemaAttributes");++ assertEquals(20, schema.size());+ Set<String> names = schemaNames(body.get("UserPool"));+ List.of("sub", "name", "given_name", "family_name", "middle_name", "nickname",+ "preferred_username", "profile", "picture", "website", "email",+ "email_verified", "gender", "birthdate", "zoneinfo", "locale",+ "phone_number", "phone_number_verified", "address", "updated_at")+ .forEach(n -> assertTrue(names.contains(n), "missing standard attribute: " + n));+ }++ @Test+ void describeUserPoolMergesCustomAttributeAfterStandardOnes() {+ ObjectNode create = mapper.createObjectNode();+ create.put("PoolName", "custom-attr-pool");+ ArrayNode schema = create.putArray("Schema");+ ObjectNode custom = schema.addObject();+ custom.put("Name", "custom:tenant_id");+ custom.put("AttributeDataType", "String");++ JsonNode created = (JsonNode) handler.handle("CreateUserPool", create, "us-east-1").getEntity();+ String poolId = created.get("UserPool").get("Id").asText();++ ObjectNode describe = mapper.createObjectNode();+ describe.put("UserPoolId", poolId);+ JsonNode body = (JsonNode) handler.handle("DescribeUserPool", describe, "us-east-1").getEntity();+ JsonNode schemaNode = body.get("UserPool").get("SchemaAttributes");++ assertEquals(21, schemaNode.size(), "20 standard + 1 custom");+ Set<String> names = schemaNames(body.get("UserPool"));+ assertTrue(names.contains("custom:tenant_id"));+ assertTrue(names.contains("sub"));+ assertTrue(names.contains("email"));+ // custom attribute must be last (after all standard ones)+ assertEquals("custom:tenant_id", schemaNode.get(20).get("Name").asText());+ }++ @Test+ void describeUserPoolExplicitStandardAttributeOverridesDefault() {+ ObjectNode create = mapper.createObjectNode();+ create.put("PoolName", "override-attr-pool");+ ArrayNode schema = create.putArray("Schema");+ ObjectNode emailOverride = schema.addObject();+ emailOverride.put("Name", "email");+ emailOverride.put("AttributeDataType", "String");+ emailOverride.put("Required", true);++ JsonNode created = (JsonNode) handler.handle("CreateUserPool", create, "us-east-1").getEntity();+ String poolId = created.get("UserPool").get("Id").asText();++ ObjectNode describe = mapper.createObjectNode();+ describe.put("UserPoolId", poolId);+ JsonNode body = (JsonNode) handler.handle("DescribeUserPool", describe, "us-east-1").getEntity();+ JsonNode schemaNode = body.get("UserPool").get("SchemaAttributes");++ assertEquals(20, schemaNode.size(), "override should not add a duplicate entry");+ JsonNode emailAttr = StreamSupport.stream(Spliterators.spliteratorUnknownSize(+ schemaNode.elements(), 0), false)+ .filter(n -> "email".equals(n.get("Name").asText()))+ .findFirst()+ .orElseThrow();+ assertTrue(emailAttr.get("Required").asBoolean(), "email must be required per the override");+ }+@Testvoid tagResourceRejectsReservedKey() {ObjectNode createRequest = mapper.createObjectNode();@@ -207,4 +286,11 @@ class CognitoJsonHandlerTest {);assertEquals("ValidationException", exception.getErrorCode());}++ private Set<String> schemaNames(JsonNode pool) {+ return StreamSupport.stream(+ Spliterators.spliteratorUnknownSize(pool.get("SchemaAttributes").elements(), 0), false)+ .map(n -> n.get("Name").asText())+ .collect(Collectors.toSet());+ }}diff --git a/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoStandardAttributesTest.java b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoStandardAttributesTest.javanew file mode 100644index 0000000000..9a84da1f02--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoStandardAttributesTest.java@@ -0,0 +1,168 @@+package io.github.hectorvent.floci.services.cognito;++import org.junit.jupiter.api.Test;++import java.util.ArrayList;+import java.util.List;+import java.util.Map;+import java.util.Set;+import java.util.stream.Collectors;++import static org.junit.jupiter.api.Assertions.*;++class CognitoStandardAttributesTest {++ private static final Set<String> EXPECTED_NAMES = Set.of(+ "sub", "name", "given_name", "family_name", "middle_name", "nickname",+ "preferred_username", "profile", "picture", "website", "email",+ "email_verified", "gender", "birthdate", "zoneinfo", "locale",+ "phone_number", "phone_number_verified", "address", "updated_at");++ @Test+ void defaultsContainsAllTwentyStandardAttributes() {+ assertEquals(20, CognitoStandardAttributes.DEFAULTS.size());+ Set<String> names = names(CognitoStandardAttributes.DEFAULTS);+ assertEquals(EXPECTED_NAMES, names);+ }++ @Test+ void subIsRequiredAndImmutable() {+ Map<String, Object> sub = findByName(CognitoStandardAttributes.DEFAULTS, "sub");+ assertEquals("String", sub.get("AttributeDataType"));+ assertEquals(Boolean.TRUE, sub.get("Required"));+ assertEquals(Boolean.FALSE, sub.get("Mutable"));+ @SuppressWarnings("unchecked")+ Map<String, String> constraints = (Map<String, String>) sub.get("StringAttributeConstraints");+ assertEquals("1", constraints.get("MinLength"));+ assertEquals("2048", constraints.get("MaxLength"));+ }++ @Test+ void emailHasStringConstraints() {+ Map<String, Object> email = findByName(CognitoStandardAttributes.DEFAULTS, "email");+ assertEquals("String", email.get("AttributeDataType"));+ assertEquals(Boolean.FALSE, email.get("Required"));+ assertEquals(Boolean.TRUE, email.get("Mutable"));+ @SuppressWarnings("unchecked")+ Map<String, String> constraints = (Map<String, String>) email.get("StringAttributeConstraints");+ assertEquals("0", constraints.get("MinLength"));+ assertEquals("2048", constraints.get("MaxLength"));+ }++ @Test+ void birthdateHasTenCharacterConstraint() {+ Map<String, Object> birthdate = findByName(CognitoStandardAttributes.DEFAULTS, "birthdate");+ @SuppressWarnings("unchecked")+ Map<String, String> constraints = (Map<String, String>) birthdate.get("StringAttributeConstraints");+ assertEquals("10", constraints.get("MinLength"));+ assertEquals("10", constraints.get("MaxLength"));+ }++ @Test+ void updatedAtIsNumberType() {+ Map<String, Object> updatedAt = findByName(CognitoStandardAttributes.DEFAULTS, "updated_at");+ assertEquals("Number", updatedAt.get("AttributeDataType"));+ @SuppressWarnings("unchecked")+ Map<String, String> constraints = (Map<String, String>) updatedAt.get("NumberAttributeConstraints");+ assertNotNull(constraints);+ assertEquals("0", constraints.get("MinValue"));+ }++ @Test+ void emailVerifiedAndPhoneVerifiedAreBooleanType() {+ for (String name : List.of("email_verified", "phone_number_verified")) {+ Map<String, Object> attr = findByName(CognitoStandardAttributes.DEFAULTS, name);+ assertEquals("Boolean", attr.get("AttributeDataType"), name + " should be Boolean");+ assertFalse(attr.containsKey("StringAttributeConstraints"), name + " should have no string constraints");+ }+ }++ @Test+ void noDeveloperOnlyAttributeInStandardAttrs() {+ for (Map<String, Object> attr : CognitoStandardAttributes.DEFAULTS) {+ assertEquals(Boolean.FALSE, attr.get("DeveloperOnlyAttribute"),+ attr.get("Name") + " should not be developer-only");+ }+ }++ // ── merge() ──────────────────────────────────────────────────────────────++ @Test+ void mergeWithNullReturnsAllDefaults() {+ List<Map<String, Object>> result = CognitoStandardAttributes.merge(null);+ assertEquals(20, result.size());+ assertEquals(EXPECTED_NAMES, names(result));+ }++ @Test+ void mergeWithEmptyListReturnsAllDefaults() {+ List<Map<String, Object>> result = CognitoStandardAttributes.merge(List.of());+ assertEquals(20, result.size());+ assertEquals(EXPECTED_NAMES, names(result));+ }++ @Test+ void mergeAppendsCustomAttributeAfterStandardOnes() {+ List<Map<String, Object>> schema = List.of(+ Map.of("Name", "custom:department", "AttributeDataType", "String"));++ List<Map<String, Object>> result = CognitoStandardAttributes.merge(schema);++ assertEquals(21, result.size());+ assertTrue(names(result).contains("custom:department"));+ assertTrue(names(result).containsAll(EXPECTED_NAMES));+ assertEquals("custom:department", result.get(20).get("Name"),+ "custom attribute must come after all standard ones");+ }++ @Test+ void mergeWithMultipleCustomAttributesAppendsAllInOrder() {+ List<Map<String, Object>> schema = List.of(+ Map.of("Name", "custom:tenant_id", "AttributeDataType", "String"),+ Map.of("Name", "custom:role", "AttributeDataType", "String"));++ List<Map<String, Object>> result = CognitoStandardAttributes.merge(schema);++ assertEquals(22, result.size());+ assertEquals("custom:tenant_id", result.get(20).get("Name"));+ assertEquals("custom:role", result.get(21).get("Name"));+ }++ @Test+ void mergeWithExplicitStandardAttributeOverridesDefault() {+ Map<String, Object> override = Map.of(+ "Name", "email",+ "AttributeDataType", "String",+ "Required", Boolean.TRUE,+ "Mutable", Boolean.TRUE);++ List<Map<String, Object>> result = CognitoStandardAttributes.merge(List.of(override));++ assertEquals(20, result.size(), "override must not create a duplicate");+ Map<String, Object> emailAttr = findByName(result, "email");+ assertEquals(Boolean.TRUE, emailAttr.get("Required"),+ "email Required should reflect the override");+ }++ @Test+ void mergePreservesStandardAttributeOrder() {+ List<Map<String, Object>> result = CognitoStandardAttributes.merge(null);+ // sub must be first+ assertEquals("sub", result.get(0).get("Name"));+ // updated_at must be last among standard attrs (index 19)+ assertEquals("updated_at", result.get(19).get("Name"));+ }++ // ── helpers ──────────────────────────────────────────────────────────────++ private static Set<String> names(List<Map<String, Object>> attrs) {+ return attrs.stream().map(a -> (String) a.get("Name")).collect(Collectors.toSet());+ }++ private static Map<String, Object> findByName(List<Map<String, Object>> attrs, String name) {+ return attrs.stream()+ .filter(a -> name.equals(a.get("Name")))+ .findFirst()+ .orElseThrow(() -> new AssertionError("attribute not found: " + name));+ }+}