Light, fluffy, and always free - The AWS Local Emulator alternative
feat(cognitoidentity): identity pool management plane (CRUD, roles, principal-tag maps, tags) (#2977)
lex00dd9cdc12073e
diff --git a/docs/services/cognitoidentity.md b/docs/services/cognitoidentity.mdnew file mode 100644index 0000000000..65a51ead1d--- /dev/null+++ b/docs/services/cognitoidentity.md@@ -0,0 +1,82 @@+# Amazon Cognito Identity++**Protocol:** JSON 1.1 (`X-Amz-Target: AWSCognitoIdentityService.<Action>`)+**Endpoint:** `http://localhost:4566/` (SigV4 service `cognito-identity`)++Cognito Identity is the federated identity pool API, distinct from the Cognito user pool+API (`cognito-idp`, documented in [Cognito](cognito.md)). Floci emulates the identity pool+management plane; the identity and credential-vending data plane is not emulated.++## Supported Actions++<!-- floci:actions:start -->+| Action | Description |+| --- | --- |+| `CreateIdentityPool` | Create a pool; returns the whole pool including tags |+| `DescribeIdentityPool` | Read a pool by id |+| `UpdateIdentityPool` | Replace a pool's configuration wholesale |+| `DeleteIdentityPool` | Delete a pool |+| `ListIdentityPools` | Page through pools, ordered by pool id |+| `SetIdentityPoolRoles` | Set the authenticated/unauthenticated roles and role mappings |+| `GetIdentityPoolRoles` | Read the roles and role mappings |+| `TagResource` | Add tags to a pool by ARN |+| `UntagResource` | Remove tags from a pool by ARN |+| `ListTagsForResource` | List a pool's tags |+| `SetPrincipalTagAttributeMap` | Map principal tags to user attributes for one provider |+| `GetPrincipalTagAttributeMap` | Read a provider's principal tag attribute map |+<!-- floci:actions:end -->++Pool ids use the AWS `<region>:<uuid>` format (`us-east-1:0f4a...`), and pool ARNs the+documented `arn:aws:cognito-identity:<region>:<account>:identitypool/<poolId>` form, so+callers that parse either get the same structure they would from AWS.++`UpdateIdentityPool` takes the full `IdentityPool` shape and replaces the stored pool with+it: a member the caller omits is reset to its default rather than carried over, matching+the AWS behaviour ("if you don't provide a value for a parameter, Amazon Cognito sets it to+its default value"). Roles, role mappings and principal tag attribute maps are set by their+own operations, are not part of the `IdentityPool` shape, and survive the replace.++`TagResource` writes into the same store as `IdentityPoolTags`, so a tag added by ARN is+visible on the next `DescribeIdentityPool` and vice versa.++`GetIdentityPoolRoles` returns `Roles` and `RoleMappings` as empty maps before+`SetIdentityPoolRoles` has run, never as null, so a provider read that dereferences them+does not crash.++## Not implemented++The identity and credential-vending operations are absent and return+`UnknownOperationException`:++`GetId`, `GetCredentialsForIdentity`, `GetOpenIdToken`, `GetOpenIdTokenForDeveloperIdentity`,+`DescribeIdentity`, `ListIdentities`, `DeleteIdentities`, `UnlinkIdentity`,+`UnlinkDeveloperIdentity`, `LookupDeveloperIdentity`, `MergeDeveloperIdentities`.++These mint real STS session credentials and signed OIDC tokens against a pool's configured+providers. An identity id handed out by `GetId` is only usable as input to+`GetCredentialsForIdentity` or `GetOpenIdToken`, so serving it alone would move the failure+one call later instead of removing it.++## Configuration++| Variable | Default | Description |+|---|---|---|+| `FLOCI_SERVICES_COGNITOIDENTITY_ENABLED` | `true` | Enable or disable the service |++## Examples++```bash+export AWS_ENDPOINT_URL=http://localhost:4566++aws cognito-identity create-identity-pool \+ --identity-pool-name my-pool \+ --allow-unauthenticated-identities++aws cognito-identity set-identity-pool-roles \+ --identity-pool-id us-east-1:... \+ --roles authenticated=arn:aws:iam::000000000000:role/authenticated++aws cognito-identity describe-identity-pool --identity-pool-id us-east-1:...++aws cognito-identity delete-identity-pool --identity-pool-id us-east-1:...+```diff --git a/docs/services/index.md b/docs/services/index.mdindex cc60092b45..82e6c7d22d 100644--- a/docs/services/index.md+++ b/docs/services/index.md@@ -27,6 +27,7 @@ Operation counts are exact. For dispatch-table services (Query and JSON 1.1) eac| [AWS Sign-In](iam.md#aws-sign-in-login-credentials) | `/v1/authorize`, `/v1/token` | REST JSON | 2 || [Organizations](organizations.md) | `POST /` + `X-Amz-Target: AWSOrganizationsV20161128.*` | JSON 1.1 | 55 || [Cognito](cognito.md) | `POST /` + `X-Amz-Target: AWSCognitoIdentityProviderService.*` | JSON 1.1 | 43 |+| [Cognito Identity](cognitoidentity.md) | `POST /` + `X-Amz-Target: AWSCognitoIdentityService.*` | JSON 1.1 | 13 || [KMS](kms.md) | `POST /` + `X-Amz-Target: TrentService.*` | JSON 1.1 | 34 || [CloudHSM v2](cloudhsmv2.md) | `POST /` + `X-Amz-Target: BaldrApiService.*` | JSON 1.1 | 18 || [Kinesis](kinesis.md) | `POST /` + `X-Amz-Target: Kinesis_20131202.*` | JSON 1.1 | 24 |diff --git a/mkdocs.yml b/mkdocs.ymlindex 31d5e30c49..12a113a8b9 100644--- a/mkdocs.yml+++ b/mkdocs.yml@@ -106,6 +106,7 @@ nav:- Lambda MicroVMs: services/lambda-microvms.md- API Gateway: services/api-gateway.md- Cognito: services/cognito.md+ - Cognito Identity: services/cognitoidentity.md- KMS: services/kms.md- CloudHSM v2: services/cloudhsmv2.md- Kinesis: services/kinesis.mddiff --git a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.javaindex e23c9cb5fe..252e4b0695 100644--- a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java+++ b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java@@ -714,6 +714,7 @@ public interface EmulatorConfig {RamServiceConfig ram();ControlTowerServiceConfig controltower();ConnectServiceConfig connect();+ CognitoIdentityServiceConfig cognitoidentity();ApsServiceConfig aps();@@ -727,6 +728,11 @@ public interface EmulatorConfig {boolean enabled();}+ interface CognitoIdentityServiceConfig {+ @WithDefault("true")+ boolean enabled();+ }+interface SsoAdminServiceConfig {@WithDefault("true")boolean enabled();diff --git a/src/main/java/io/github/hectorvent/floci/core/common/AwsJson11Controller.java b/src/main/java/io/github/hectorvent/floci/core/common/AwsJson11Controller.javaindex 1426717082..1e065d3b49 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/AwsJson11Controller.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/AwsJson11Controller.java@@ -45,6 +45,7 @@ import io.github.hectorvent.floci.services.kinesisanalytics.KinesisAnalyticsV2Jsimport io.github.hectorvent.floci.services.kms.KmsJsonHandler;import io.github.hectorvent.floci.services.secretsmanager.SecretsManagerJsonHandler;import io.github.hectorvent.floci.services.organizations.OrganizationsJsonHandler;+import io.github.hectorvent.floci.services.cognitoidentity.CognitoIdentityJsonHandler;import io.github.hectorvent.floci.services.route53resolver.Route53ResolverJsonHandler;import io.github.hectorvent.floci.services.networkfirewall.NetworkFirewallJsonHandler;import io.github.hectorvent.floci.services.servicecatalog.ServiceCatalogJsonHandler;@@ -115,6 +116,7 @@ public class AwsJson11Controller {private final CloudTrailJsonHandler cloudTrailJsonHandler;private final LightsailJsonHandler lightsailJsonHandler;private final Route53ResolverJsonHandler route53ResolverJsonHandler;+ private final CognitoIdentityJsonHandler cognitoIdentityJsonHandler;private final NetworkFirewallJsonHandler networkFirewallJsonHandler;private final ServiceCatalogJsonHandler serviceCatalogJsonHandler;private final CloudControlJsonHandler cloudControlJsonHandler;@@ -161,6 +163,7 @@ public class AwsJson11Controller {CloudTrailJsonHandler cloudTrailJsonHandler,LightsailJsonHandler lightsailJsonHandler,Route53ResolverJsonHandler route53ResolverJsonHandler,+ CognitoIdentityJsonHandler cognitoIdentityJsonHandler,NetworkFirewallJsonHandler networkFirewallJsonHandler,ServiceCatalogJsonHandler serviceCatalogJsonHandler,CloudControlJsonHandler cloudControlJsonHandler,@@ -211,6 +214,7 @@ public class AwsJson11Controller {this.cloudTrailJsonHandler = cloudTrailJsonHandler;this.lightsailJsonHandler = lightsailJsonHandler;this.route53ResolverJsonHandler = route53ResolverJsonHandler;+ this.cognitoIdentityJsonHandler = cognitoIdentityJsonHandler;this.networkFirewallJsonHandler = networkFirewallJsonHandler;this.serviceCatalogJsonHandler = serviceCatalogJsonHandler;this.cloudControlJsonHandler = cloudControlJsonHandler;@@ -293,6 +297,7 @@ public class AwsJson11Controller {case "application-autoscaling" -> applicationAutoScalingJsonHandler.handle(action, request, region);case "lightsail" -> lightsailJsonHandler.handle(action, request, region);case "route53resolver" -> route53ResolverJsonHandler.handle(action, request, region, regionResolver.getAccountId());+ case "cognito-identity" -> cognitoIdentityJsonHandler.handle(action, request, region);case "network-firewall" -> networkFirewallJsonHandler.handle(action, request, region, regionResolver.getAccountId());case "servicecatalog" -> serviceCatalogJsonHandler.handle(diff --git a/src/main/java/io/github/hectorvent/floci/core/common/ResolvedServiceCatalog.java b/src/main/java/io/github/hectorvent/floci/core/common/ResolvedServiceCatalog.javaindex 63f195d580..153bb3374b 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/ResolvedServiceCatalog.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/ResolvedServiceCatalog.java@@ -555,6 +555,11 @@ public class ResolvedServiceCatalog {protocols(ServiceProtocol.REST_JSON),Set.of(), Set.of("connect"), Set.of(),Set.of(io.github.hectorvent.floci.services.connect.ConnectController.class)),+ descriptor("cognito-identity", "cognitoidentity",+ config.services().cognitoidentity().enabled(), true,+ "cognitoidentity", config.storage().mode(), 5000L, null, ServiceProtocol.JSON,+ protocols(ServiceProtocol.JSON),+ Set.of("AWSCognitoIdentityService."), Set.of("cognito-identity"), Set.of(), Set.of()),descriptor("network-firewall", "networkfirewall", config.services().networkfirewall().enabled(), true,"networkfirewall", config.storage().mode(), 5000L, null, ServiceProtocol.JSON,protocols(ServiceProtocol.JSON),diff --git a/src/main/java/io/github/hectorvent/floci/services/cognitoidentity/CognitoIdentityJsonHandler.java b/src/main/java/io/github/hectorvent/floci/services/cognitoidentity/CognitoIdentityJsonHandler.javanew file mode 100644index 0000000000..ba3026332b--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/cognitoidentity/CognitoIdentityJsonHandler.java@@ -0,0 +1,244 @@+package io.github.hectorvent.floci.services.cognitoidentity;++import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import com.fasterxml.jackson.databind.node.ArrayNode;+import com.fasterxml.jackson.databind.node.ObjectNode;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.services.cognitoidentity.model.CognitoIdentityProvider;+import io.github.hectorvent.floci.services.cognitoidentity.model.IdentityPool;+import io.github.hectorvent.floci.services.cognitoidentity.model.PrincipalTagAttributeMap;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.inject.Inject;+import jakarta.ws.rs.core.Response;++import java.util.ArrayList;+import java.util.LinkedHashMap;+import java.util.List;+import java.util.Map;++/**+ * Amazon Cognito Identity (federated identity pools) management plane.+ *+ * <p>Operations that are not implemented fall through to a clean+ * {@code UnknownOperationException} rather than a stub success, so callers fail fast+ * instead of stranding a waiter. The identity and credential-vending operations+ * ({@code GetId}, {@code GetCredentialsForIdentity}, {@code GetOpenIdToken} and peers) are+ * deliberately absent: they mint STS session credentials and signed OIDC tokens, which this+ * management plane has no way to produce.+ */+@ApplicationScoped+public class CognitoIdentityJsonHandler {++ private final CognitoIdentityService cognitoIdentityService;+ private final ObjectMapper objectMapper;++ @Inject+ public CognitoIdentityJsonHandler(CognitoIdentityService cognitoIdentityService, ObjectMapper objectMapper) {+ this.cognitoIdentityService = cognitoIdentityService;+ this.objectMapper = objectMapper;+ }++ public Response handle(String action, JsonNode request, String region) throws Exception {+ return switch (action) {+ case "CreateIdentityPool" -> Response.ok(+ identityPoolNode(cognitoIdentityService.createIdentityPool(parsePool(request), region))).build();++ case "DescribeIdentityPool" -> Response.ok(identityPoolNode(+ cognitoIdentityService.describeIdentityPool(text(request, "IdentityPoolId"), region))).build();++ case "UpdateIdentityPool" -> Response.ok(+ identityPoolNode(cognitoIdentityService.updateIdentityPool(parsePool(request), region))).build();++ case "DeleteIdentityPool" -> {+ cognitoIdentityService.deleteIdentityPool(text(request, "IdentityPoolId"), region);+ yield Response.ok(objectMapper.createObjectNode()).build();+ }++ case "ListIdentityPools" -> {+ CognitoIdentityService.Page page = cognitoIdentityService.listIdentityPools(+ integer(request, "MaxResults"), text(request, "NextToken"), region);+ ObjectNode response = objectMapper.createObjectNode();+ ArrayNode identityPools = response.putArray("IdentityPools");+ for (IdentityPool pool : page.identityPools()) {+ ObjectNode summary = identityPools.addObject();+ summary.put("IdentityPoolId", pool.getIdentityPoolId());+ summary.put("IdentityPoolName", pool.getIdentityPoolName());+ }+ if (page.nextToken() != null) {+ response.put("NextToken", page.nextToken());+ }+ yield Response.ok(response).build();+ }++ case "SetIdentityPoolRoles" -> {+ cognitoIdentityService.setIdentityPoolRoles(text(request, "IdentityPoolId"),+ stringMap(request.get("Roles")), request.get("RoleMappings"), region);+ yield Response.ok(objectMapper.createObjectNode()).build();+ }++ case "GetIdentityPoolRoles" -> {+ IdentityPool pool = cognitoIdentityService.getIdentityPoolRoles(+ text(request, "IdentityPoolId"), region);+ ObjectNode response = objectMapper.createObjectNode();+ response.put("IdentityPoolId", pool.getIdentityPoolId());+ response.set("Roles", objectMapper.valueToTree(pool.getRoles()));+ response.set("RoleMappings", pool.getRoleMappings() != null+ ? pool.getRoleMappings()+ : objectMapper.createObjectNode());+ yield Response.ok(response).build();+ }++ case "TagResource" -> {+ cognitoIdentityService.tagResource(text(request, "ResourceArn"),+ stringMap(request.get("Tags")), region);+ yield Response.ok(objectMapper.createObjectNode()).build();+ }++ case "UntagResource" -> {+ cognitoIdentityService.untagResource(text(request, "ResourceArn"),+ stringList(request.get("TagKeys")), region);+ yield Response.ok(objectMapper.createObjectNode()).build();+ }++ case "ListTagsForResource" -> {+ Map<String, String> tags = cognitoIdentityService.listTagsForResource(+ text(request, "ResourceArn"), region);+ ObjectNode response = objectMapper.createObjectNode();+ response.set("Tags", objectMapper.valueToTree(tags));+ yield Response.ok(response).build();+ }++ case "SetPrincipalTagAttributeMap" -> {+ String identityPoolId = text(request, "IdentityPoolId");+ PrincipalTagAttributeMap attributeMap = cognitoIdentityService.setPrincipalTagAttributeMap(+ identityPoolId, text(request, "IdentityProviderName"),+ bool(request, "UseDefaults"), stringMap(request.get("PrincipalTags")), region);+ yield Response.ok(principalTagAttributeMapNode(identityPoolId, attributeMap)).build();+ }++ case "GetPrincipalTagAttributeMap" -> {+ String identityPoolId = text(request, "IdentityPoolId");+ PrincipalTagAttributeMap attributeMap = cognitoIdentityService.getPrincipalTagAttributeMap(+ identityPoolId, text(request, "IdentityProviderName"), region);+ yield Response.ok(principalTagAttributeMapNode(identityPoolId, attributeMap)).build();+ }++ default -> throw new AwsException("UnknownOperationException",+ "Operation " + action + " is not supported by floci", 400);+ };+ }++ private IdentityPool parsePool(JsonNode request) {+ IdentityPool pool = new IdentityPool();+ pool.setIdentityPoolId(text(request, "IdentityPoolId"));+ pool.setIdentityPoolName(text(request, "IdentityPoolName"));+ pool.setAllowUnauthenticatedIdentities(requiredBool(request, "AllowUnauthenticatedIdentities"));+ pool.setAllowClassicFlow(request.path("AllowClassicFlow").asBoolean(false));+ pool.setSupportedLoginProviders(stringMap(request.get("SupportedLoginProviders")));+ pool.setDeveloperProviderName(text(request, "DeveloperProviderName"));+ pool.setOpenIdConnectProviderArns(stringList(request.get("OpenIdConnectProviderARNs")));+ pool.setSamlProviderArns(stringList(request.get("SamlProviderARNs")));+ pool.setIdentityPoolTags(stringMap(request.get("IdentityPoolTags")));++ List<CognitoIdentityProvider> providers = new ArrayList<>();+ JsonNode providersNode = request.get("CognitoIdentityProviders");+ if (providersNode != null && providersNode.isArray()) {+ for (JsonNode node : providersNode) {+ CognitoIdentityProvider provider = new CognitoIdentityProvider();+ provider.setProviderName(text(node, "ProviderName"));+ provider.setClientId(text(node, "ClientId"));+ provider.setServerSideTokenCheck(node.path("ServerSideTokenCheck").asBoolean(false));+ providers.add(provider);+ }+ }+ pool.setCognitoIdentityProviders(providers);+ return pool;+ }++ private ObjectNode identityPoolNode(IdentityPool pool) {+ ObjectNode node = objectMapper.createObjectNode();+ node.put("IdentityPoolId", pool.getIdentityPoolId());+ node.put("IdentityPoolName", pool.getIdentityPoolName());+ node.put("AllowUnauthenticatedIdentities", pool.isAllowUnauthenticatedIdentities());+ node.put("AllowClassicFlow", pool.isAllowClassicFlow());+ node.set("SupportedLoginProviders", objectMapper.valueToTree(pool.getSupportedLoginProviders()));+ if (pool.getDeveloperProviderName() != null) {+ node.put("DeveloperProviderName", pool.getDeveloperProviderName());+ }+ node.set("OpenIdConnectProviderARNs", objectMapper.valueToTree(pool.getOpenIdConnectProviderArns()));+ node.set("SamlProviderARNs", objectMapper.valueToTree(pool.getSamlProviderArns()));+ node.set("IdentityPoolTags", objectMapper.valueToTree(pool.getIdentityPoolTags()));++ ArrayNode providers = node.putArray("CognitoIdentityProviders");+ for (CognitoIdentityProvider provider : pool.getCognitoIdentityProviders()) {+ ObjectNode providerNode = providers.addObject();+ providerNode.put("ProviderName", provider.getProviderName());+ providerNode.put("ClientId", provider.getClientId());+ providerNode.put("ServerSideTokenCheck", provider.isServerSideTokenCheck());+ }+ return node;+ }++ private ObjectNode principalTagAttributeMapNode(String identityPoolId, PrincipalTagAttributeMap attributeMap) {+ ObjectNode node = objectMapper.createObjectNode();+ node.put("IdentityPoolId", identityPoolId);+ node.put("IdentityProviderName", attributeMap.getIdentityProviderName());+ node.put("UseDefaults", attributeMap.isUseDefaults());+ node.set("PrincipalTags", objectMapper.valueToTree(attributeMap.getPrincipalTags()));+ return node;+ }++ private String text(JsonNode node, String field) {+ JsonNode value = node.get(field);+ if (value == null || value.isNull()) {+ return null;+ }+ return value.asText();+ }++ private Integer integer(JsonNode node, String field) {+ JsonNode value = node.get(field);+ if (value == null || !value.isNumber()) {+ return null;+ }+ return value.asInt();+ }++ private Boolean bool(JsonNode node, String field) {+ JsonNode value = node.get(field);+ if (value == null || value.isNull()) {+ return null;+ }+ if (!value.isBoolean()) {+ throw new AwsException("SerializationException", field + " must be a boolean.", 400);+ }+ return value.asBoolean();+ }++ private boolean requiredBool(JsonNode node, String field) {+ Boolean value = bool(node, field);+ if (value == null) {+ throw new AwsException("ValidationException", "1 validation error detected: Value null at '"+ + Character.toLowerCase(field.charAt(0)) + field.substring(1)+ + "' failed to satisfy constraint: Member must not be null", 400);+ }+ return value;+ }++ private Map<String, String> stringMap(JsonNode node) {+ Map<String, String> values = new LinkedHashMap<>();+ if (node != null && node.isObject()) {+ node.fields().forEachRemaining(entry -> values.put(entry.getKey(), entry.getValue().asText()));+ }+ return values;+ }++ private List<String> stringList(JsonNode node) {+ List<String> values = new ArrayList<>();+ if (node != null && node.isArray()) {+ node.forEach(element -> values.add(element.asText()));+ }+ return values;+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/cognitoidentity/CognitoIdentityService.java b/src/main/java/io/github/hectorvent/floci/services/cognitoidentity/CognitoIdentityService.javanew file mode 100644index 0000000000..7c734096a7--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/cognitoidentity/CognitoIdentityService.java@@ -0,0 +1,309 @@+package io.github.hectorvent.floci.services.cognitoidentity;++import com.fasterxml.jackson.core.type.TypeReference;+import com.fasterxml.jackson.databind.JsonNode;+import io.github.hectorvent.floci.core.common.AwsArnUtils;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.core.storage.StorageBackend;+import io.github.hectorvent.floci.core.storage.StorageFactory;+import io.github.hectorvent.floci.services.cognitoidentity.model.IdentityPool;+import io.github.hectorvent.floci.services.cognitoidentity.model.PrincipalTagAttributeMap;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.inject.Inject;+import org.jboss.logging.Logger;++import java.time.Instant;+import java.util.Comparator;+import java.util.LinkedHashMap;+import java.util.List;+import java.util.Map;+import java.util.Set;+import java.util.UUID;+import java.util.regex.Pattern;++/**+ * Amazon Cognito Identity (federated identity pools) management plane.+ *+ * <p>Pool ids follow the AWS format {@code <region>:<uuid>} and pool ARNs the documented+ * {@code arn:aws:cognito-identity:<region>:<account>:identitypool/<poolId>} form, so a caller+ * that parses either gets the same structure it would from AWS.+ */+@ApplicationScoped+public class CognitoIdentityService {++ private static final Logger LOG = Logger.getLogger(CognitoIdentityService.class);++ private static final Pattern IDENTITY_POOL_NAME = Pattern.compile("[\\w\\s+=,.@-]+");+ private static final Pattern DEVELOPER_PROVIDER_NAME = Pattern.compile("[\\w._-]+");+ private static final Set<String> ROLE_TYPES = Set.of("authenticated", "unauthenticated");+ private static final Set<String> ROLE_MAPPING_TYPES = Set.of("Token", "Rules");+ private static final String ARN_RESOURCE_PREFIX = "identitypool/";+ private static final int MAX_LIST_RESULTS = 60;++ private final StorageBackend<String, IdentityPool> pools;+ private final RegionResolver regionResolver;++ @Inject+ public CognitoIdentityService(StorageFactory storageFactory, RegionResolver regionResolver) {+ this.pools = storageFactory.create("cognitoidentity", "cognitoidentity-pools.json",+ new TypeReference<Map<String, IdentityPool>>() {});+ this.regionResolver = regionResolver;+ }++ // ──────────────────────────── Identity pools ────────────────────────────++ public IdentityPool createIdentityPool(IdentityPool spec, String region) {+ validatePoolConfiguration(spec);++ String identityPoolId = region + ":" + UUID.randomUUID();+ spec.setIdentityPoolId(identityPoolId);+ spec.setArn(regionResolver.buildArn("cognito-identity", region, ARN_RESOURCE_PREFIX + identityPoolId));+ spec.setAccountId(regionResolver.getAccountId());+ spec.setCreatedAt(Instant.now());++ pools.put(storageKey(region, identityPoolId), spec);+ LOG.infov("Created Cognito identity pool: {0}", identityPoolId);+ return spec;+ }++ public IdentityPool describeIdentityPool(String identityPoolId, String region) {+ requireIdentityPoolId(identityPoolId);+ return pools.get(storageKey(region, identityPoolId))+ .orElseThrow(() -> new AwsException("ResourceNotFoundException",+ "IdentityPool '" + identityPoolId + "' not found.", 404));+ }++ /**+ * {@code UpdateIdentityPool} takes the whole {@code IdentityPool} shape and replaces the+ * stored pool with it: a member the caller omits is reset to its default rather than+ * carried over. The roles, role mappings and principal-tag maps are set by their own+ * operations and are not part of the shape, so they survive the replace.+ */+ public IdentityPool updateIdentityPool(IdentityPool spec, String region) {+ IdentityPool existing = describeIdentityPool(spec.getIdentityPoolId(), region);+ validatePoolConfiguration(spec);++ spec.setArn(existing.getArn());+ spec.setAccountId(existing.getAccountId());+ spec.setCreatedAt(existing.getCreatedAt());+ spec.setRoles(existing.getRoles());+ spec.setRoleMappings(existing.getRoleMappings());+ spec.setPrincipalTagAttributeMaps(existing.getPrincipalTagAttributeMaps());++ pools.put(storageKey(region, spec.getIdentityPoolId()), spec);+ LOG.infov("Updated Cognito identity pool: {0}", spec.getIdentityPoolId());+ return spec;+ }++ public void deleteIdentityPool(String identityPoolId, String region) {+ describeIdentityPool(identityPoolId, region);+ pools.delete(storageKey(region, identityPoolId));+ LOG.infov("Deleted Cognito identity pool: {0}", identityPoolId);+ }++ /**+ * Returns one page of pools ordered by pool id. The pagination token is the index of the+ * first pool of the next page, which keeps the token stable for the common case of a pool+ * set that only grows.+ */+ public Page listIdentityPools(Integer maxResults, String nextToken, String region) {+ int limit = maxResults == null ? MAX_LIST_RESULTS : maxResults;+ if (limit < 1 || limit > MAX_LIST_RESULTS) {+ throw new AwsException("InvalidParameterException",+ "MaxResults must be between 1 and " + MAX_LIST_RESULTS + ".", 400);+ }+ int offset = parseToken(nextToken);++ String regionPrefix = region + "::";+ List<IdentityPool> ordered = pools.scan(key -> key.startsWith(regionPrefix)).stream()+ .sorted(Comparator.comparing(IdentityPool::getIdentityPoolId))+ .toList();+ if (offset >= ordered.size()) {+ return new Page(List.of(), null);+ }+ int end = Math.min(offset + limit, ordered.size());+ return new Page(ordered.subList(offset, end), end < ordered.size() ? String.valueOf(end) : null);+ }++ // ──────────────────────────── Pool roles ────────────────────────────++ public IdentityPool setIdentityPoolRoles(String identityPoolId, Map<String, String> roles,+ JsonNode roleMappings, String region) {+ IdentityPool pool = describeIdentityPool(identityPoolId, region);+ if (roles == null || roles.isEmpty()) {+ throw new AwsException("InvalidParameterException", "Roles is required.", 400);+ }+ for (Map.Entry<String, String> entry : roles.entrySet()) {+ if (!ROLE_TYPES.contains(entry.getKey())) {+ throw new AwsException("InvalidParameterException",+ "Role key '" + entry.getKey() + "' must be one of authenticated, unauthenticated.", 400);+ }+ if (entry.getValue() == null || entry.getValue().isBlank()) {+ throw new AwsException("InvalidParameterException",+ "Role ARN for '" + entry.getKey() + "' must not be empty.", 400);+ }+ }+ validateRoleMappings(roleMappings);++ pool.setRoles(new LinkedHashMap<>(roles));+ pool.setRoleMappings(roleMappings != null && roleMappings.isObject() ? roleMappings : null);+ pools.put(storageKey(region, identityPoolId), pool);+ return pool;+ }++ public IdentityPool getIdentityPoolRoles(String identityPoolId, String region) {+ return describeIdentityPool(identityPoolId, region);+ }++ // ──────────────────────── Principal tag attribute maps ────────────────────────++ public PrincipalTagAttributeMap setPrincipalTagAttributeMap(String identityPoolId, String identityProviderName,+ Boolean useDefaults, Map<String, String> principalTags,+ String region) {+ IdentityPool pool = describeIdentityPool(identityPoolId, region);+ if (identityProviderName == null || identityProviderName.isBlank()) {+ throw new AwsException("InvalidParameterException", "IdentityProviderName is required.", 400);+ }++ PrincipalTagAttributeMap attributeMap = new PrincipalTagAttributeMap();+ attributeMap.setIdentityProviderName(identityProviderName);+ attributeMap.setUseDefaults(useDefaults != null && useDefaults);+ attributeMap.setPrincipalTags(principalTags != null ? new LinkedHashMap<>(principalTags) : new LinkedHashMap<>());++ pool.getPrincipalTagAttributeMaps().put(identityProviderName, attributeMap);+ pools.put(storageKey(region, identityPoolId), pool);+ return attributeMap;+ }++ /**+ * A provider with no attribute map is not an error in AWS. The read returns the provider+ * with an empty map, so an unset provider yields defaults rather than a not-found.+ */+ public PrincipalTagAttributeMap getPrincipalTagAttributeMap(String identityPoolId, String identityProviderName,+ String region) {+ IdentityPool pool = describeIdentityPool(identityPoolId, region);+ if (identityProviderName == null || identityProviderName.isBlank()) {+ throw new AwsException("InvalidParameterException", "IdentityProviderName is required.", 400);+ }+ PrincipalTagAttributeMap attributeMap = pool.getPrincipalTagAttributeMaps().get(identityProviderName);+ if (attributeMap != null) {+ return attributeMap;+ }+ PrincipalTagAttributeMap empty = new PrincipalTagAttributeMap();+ empty.setIdentityProviderName(identityProviderName);+ return empty;+ }++ // ──────────────────────────── Tags ────────────────────────────++ public Map<String, String> listTagsForResource(String resourceArn, String region) {+ return findByArn(resourceArn, region).getIdentityPoolTags();+ }++ public void tagResource(String resourceArn, Map<String, String> tags, String region) {+ if (tags == null || tags.isEmpty()) {+ throw new AwsException("InvalidParameterException", "Tags is required.", 400);+ }+ IdentityPool pool = findByArn(resourceArn, region);+ pool.getIdentityPoolTags().putAll(tags);+ pools.put(storageKey(pool), pool);+ }++ public void untagResource(String resourceArn, List<String> tagKeys, String region) {+ if (tagKeys == null || tagKeys.isEmpty()) {+ throw new AwsException("InvalidParameterException", "TagKeys is required.", 400);+ }+ IdentityPool pool = findByArn(resourceArn, region);+ tagKeys.forEach(pool.getIdentityPoolTags()::remove);+ pools.put(storageKey(pool), pool);+ }++ // ──────────────────────────── Helpers ────────────────────────────++ /** One page of {@code ListIdentityPools} results plus the token for the page after it. */+ public record Page(List<IdentityPool> identityPools, String nextToken) {}++ private void validatePoolConfiguration(IdentityPool spec) {+ String name = spec.getIdentityPoolName();+ if (name == null || name.isBlank() || name.length() > 128 || !IDENTITY_POOL_NAME.matcher(name).matches()) {+ throw new AwsException("InvalidParameterException",+ "IdentityPoolName must be 1-128 characters matching [\\w\\s+=,.@-]+.", 400);+ }+ String developerProviderName = spec.getDeveloperProviderName();+ if (developerProviderName != null+ && (developerProviderName.length() > 128+ || !DEVELOPER_PROVIDER_NAME.matcher(developerProviderName).matches())) {+ throw new AwsException("InvalidParameterException",+ "DeveloperProviderName must be 1-128 characters matching [\\w._-]+.", 400);+ }+ }++ private void validateRoleMappings(JsonNode roleMappings) {+ if (roleMappings == null || !roleMappings.isObject()) {+ return;+ }+ roleMappings.fields().forEachRemaining(entry -> {+ JsonNode mapping = entry.getValue();+ String type = mapping.path("Type").asText(null);+ if (type == null || !ROLE_MAPPING_TYPES.contains(type)) {+ throw new AwsException("InvalidParameterException",+ "RoleMapping Type for '" + entry.getKey() + "' must be one of Token, Rules.", 400);+ }+ if ("Rules".equals(type)) {+ JsonNode rules = mapping.path("RulesConfiguration").path("Rules");+ if (!rules.isArray() || rules.isEmpty()) {+ throw new AwsException("InvalidParameterException",+ "RoleMapping '" + entry.getKey() + "' of type Rules requires RulesConfiguration.Rules.",+ 400);+ }+ }+ });+ }++ private void requireIdentityPoolId(String identityPoolId) {+ if (identityPoolId == null || identityPoolId.isBlank()) {+ throw new AwsException("InvalidParameterException", "IdentityPoolId is required.", 400);+ }+ }++ private IdentityPool findByArn(String resourceArn, String region) {+ AwsArnUtils.Arn arn;+ try {+ arn = AwsArnUtils.parse(resourceArn);+ } catch (IllegalArgumentException e) {+ throw new AwsException("InvalidParameterException", "Invalid ResourceArn: " + resourceArn, 400);+ }+ if (!"cognito-identity".equals(arn.service()) || !arn.resource().startsWith(ARN_RESOURCE_PREFIX)) {+ throw new AwsException("InvalidParameterException", "Invalid ResourceArn: " + resourceArn, 400);+ }+ String identityPoolId = arn.resource().substring(ARN_RESOURCE_PREFIX.length());+ String arnRegion = arn.region().isEmpty() ? region : arn.region();+ return pools.get(storageKey(arnRegion, identityPoolId))+ .orElseThrow(() -> new AwsException("ResourceNotFoundException",+ "IdentityPool '" + identityPoolId + "' not found.", 404));+ }++ private int parseToken(String nextToken) {+ if (nextToken == null || nextToken.isBlank()) {+ return 0;+ }+ try {+ int offset = Integer.parseInt(nextToken);+ if (offset < 0) {+ throw new NumberFormatException(nextToken);+ }+ return offset;+ } catch (NumberFormatException e) {+ throw new AwsException("InvalidParameterException", "Invalid NextToken: " + nextToken, 400);+ }+ }++ private String storageKey(String region, String identityPoolId) {+ return region + "::" + identityPoolId;+ }++ private String storageKey(IdentityPool pool) {+ return storageKey(AwsArnUtils.parse(pool.getArn()).region(), pool.getIdentityPoolId());+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/cognitoidentity/model/CognitoIdentityProvider.java b/src/main/java/io/github/hectorvent/floci/services/cognitoidentity/model/CognitoIdentityProvider.javanew file mode 100644index 0000000000..3c737c08d2--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/cognitoidentity/model/CognitoIdentityProvider.java@@ -0,0 +1,39 @@+package io.github.hectorvent.floci.services.cognitoidentity.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++/**+ * A Cognito user pool attached to an identity pool+ * ({@code IdentityPool.CognitoIdentityProviders} member).+ */+@RegisterForReflection+public class CognitoIdentityProvider {++ private String providerName;+ private String clientId;+ private boolean serverSideTokenCheck;++ public String getProviderName() {+ return providerName;+ }++ public void setProviderName(String providerName) {+ this.providerName = providerName;+ }++ public String getClientId() {+ return clientId;+ }++ public void setClientId(String clientId) {+ this.clientId = clientId;+ }++ public boolean isServerSideTokenCheck() {+ return serverSideTokenCheck;+ }++ public void setServerSideTokenCheck(boolean serverSideTokenCheck) {+ this.serverSideTokenCheck = serverSideTokenCheck;+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/cognitoidentity/model/IdentityPool.java b/src/main/java/io/github/hectorvent/floci/services/cognitoidentity/model/IdentityPool.javanew file mode 100644index 0000000000..4309178fb9--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/cognitoidentity/model/IdentityPool.java@@ -0,0 +1,169 @@+package io.github.hectorvent.floci.services.cognitoidentity.model;++import com.fasterxml.jackson.databind.JsonNode;++import io.quarkus.runtime.annotations.RegisterForReflection;+import java.time.Instant;+import java.util.ArrayList;+import java.util.LinkedHashMap;+import java.util.List;+import java.util.Map;++/**+ * A Cognito federated identity pool.+ *+ * <p>The pool's own configuration is the {@code IdentityPool} shape of the AWS model. The+ * roles, role mappings and principal-tag attribute maps are separate AWS operations+ * ({@code SetIdentityPoolRoles}, {@code SetPrincipalTagAttributeMap}) but belong to the same+ * pool, so they are persisted alongside it and survive an {@code UpdateIdentityPool} replace.+ */+@RegisterForReflection+public class IdentityPool {++ private String identityPoolId;+ private String identityPoolName;+ private boolean allowUnauthenticatedIdentities;+ private boolean allowClassicFlow;+ private Map<String, String> supportedLoginProviders = new LinkedHashMap<>();+ private String developerProviderName;+ private List<String> openIdConnectProviderArns = new ArrayList<>();+ private List<CognitoIdentityProvider> cognitoIdentityProviders = new ArrayList<>();+ private List<String> samlProviderArns = new ArrayList<>();+ private Map<String, String> identityPoolTags = new LinkedHashMap<>();++ private String arn;+ private String accountId;+ private Instant createdAt;++ private Map<String, String> roles = new LinkedHashMap<>();+ private JsonNode roleMappings;+ private Map<String, PrincipalTagAttributeMap> principalTagAttributeMaps = new LinkedHashMap<>();++ public String getIdentityPoolId() {+ return identityPoolId;+ }++ public void setIdentityPoolId(String identityPoolId) {+ this.identityPoolId = identityPoolId;+ }++ public String getIdentityPoolName() {+ return identityPoolName;+ }++ public void setIdentityPoolName(String identityPoolName) {+ this.identityPoolName = identityPoolName;+ }++ public boolean isAllowUnauthenticatedIdentities() {+ return allowUnauthenticatedIdentities;+ }++ public void setAllowUnauthenticatedIdentities(boolean allowUnauthenticatedIdentities) {+ this.allowUnauthenticatedIdentities = allowUnauthenticatedIdentities;+ }++ public boolean isAllowClassicFlow() {+ return allowClassicFlow;+ }++ public void setAllowClassicFlow(boolean allowClassicFlow) {+ this.allowClassicFlow = allowClassicFlow;+ }++ public Map<String, String> getSupportedLoginProviders() {+ return supportedLoginProviders;+ }++ public void setSupportedLoginProviders(Map<String, String> supportedLoginProviders) {+ this.supportedLoginProviders = supportedLoginProviders;+ }++ public String getDeveloperProviderName() {+ return developerProviderName;+ }++ public void setDeveloperProviderName(String developerProviderName) {+ this.developerProviderName = developerProviderName;+ }++ public List<String> getOpenIdConnectProviderArns() {+ return openIdConnectProviderArns;+ }++ public void setOpenIdConnectProviderArns(List<String> openIdConnectProviderArns) {+ this.openIdConnectProviderArns = openIdConnectProviderArns;+ }++ public List<CognitoIdentityProvider> getCognitoIdentityProviders() {+ return cognitoIdentityProviders;+ }++ public void setCognitoIdentityProviders(List<CognitoIdentityProvider> cognitoIdentityProviders) {+ this.cognitoIdentityProviders = cognitoIdentityProviders;+ }++ public List<String> getSamlProviderArns() {+ return samlProviderArns;+ }++ public void setSamlProviderArns(List<String> samlProviderArns) {+ this.samlProviderArns = samlProviderArns;+ }++ public Map<String, String> getIdentityPoolTags() {+ return identityPoolTags;+ }++ public void setIdentityPoolTags(Map<String, String> identityPoolTags) {+ this.identityPoolTags = identityPoolTags;+ }++ public String getArn() {+ return arn;+ }++ public void setArn(String arn) {+ this.arn = arn;+ }++ public String getAccountId() {+ return accountId;+ }++ public void setAccountId(String accountId) {+ this.accountId = accountId;+ }++ public Instant getCreatedAt() {+ return createdAt;+ }++ public void setCreatedAt(Instant createdAt) {+ this.createdAt = createdAt;+ }++ public Map<String, String> getRoles() {+ return roles;+ }++ public void setRoles(Map<String, String> roles) {+ this.roles = roles;+ }++ public JsonNode getRoleMappings() {+ return roleMappings;+ }++ public void setRoleMappings(JsonNode roleMappings) {+ this.roleMappings = roleMappings;+ }++ public Map<String, PrincipalTagAttributeMap> getPrincipalTagAttributeMaps() {+ return principalTagAttributeMaps;+ }++ public void setPrincipalTagAttributeMaps(Map<String, PrincipalTagAttributeMap> principalTagAttributeMaps) {+ this.principalTagAttributeMaps = principalTagAttributeMaps;+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/cognitoidentity/model/PrincipalTagAttributeMap.java b/src/main/java/io/github/hectorvent/floci/services/cognitoidentity/model/PrincipalTagAttributeMap.javanew file mode 100644index 0000000000..a611492fdf--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/cognitoidentity/model/PrincipalTagAttributeMap.java@@ -0,0 +1,41 @@+package io.github.hectorvent.floci.services.cognitoidentity.model;++import io.quarkus.runtime.annotations.RegisterForReflection;+import java.util.LinkedHashMap;+import java.util.Map;++/**+ * Mapping between principal tags and user attributes for one identity provider attached to+ * an identity pool ({@code SetPrincipalTagAttributeMap} / {@code GetPrincipalTagAttributeMap}).+ */+@RegisterForReflection+public class PrincipalTagAttributeMap {++ private String identityProviderName;+ private boolean useDefaults;+ private Map<String, String> principalTags = new LinkedHashMap<>();++ public String getIdentityProviderName() {+ return identityProviderName;+ }++ public void setIdentityProviderName(String identityProviderName) {+ this.identityProviderName = identityProviderName;+ }++ public boolean isUseDefaults() {+ return useDefaults;+ }++ public void setUseDefaults(boolean useDefaults) {+ this.useDefaults = useDefaults;+ }++ public Map<String, String> getPrincipalTags() {+ return principalTags;+ }++ public void setPrincipalTags(Map<String, String> principalTags) {+ this.principalTags = principalTags;+ }+}diff --git a/src/main/resources/application.yml b/src/main/resources/application.ymlindex 87e4a9e062..320f5cebae 100644--- a/src/main/resources/application.yml+++ b/src/main/resources/application.yml@@ -610,6 +610,8 @@ floci:enabled: trueconnect:enabled: true+ cognitoidentity:+ enabled: trueaps:enabled: truelakeformation:diff --git a/src/test/java/io/github/hectorvent/floci/services/cognitoidentity/CognitoIdentityIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/cognitoidentity/CognitoIdentityIntegrationTest.javanew file mode 100644index 0000000000..7672945b50--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/cognitoidentity/CognitoIdentityIntegrationTest.java@@ -0,0 +1,467 @@+package io.github.hectorvent.floci.services.cognitoidentity;++import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;+import io.quarkus.test.junit.QuarkusTest;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.MethodOrderer;+import org.junit.jupiter.api.Order;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.TestMethodOrder;++import java.util.Map;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.emptyIterable;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.hasItem;+import static org.hamcrest.Matchers.hasKey;+import static org.hamcrest.Matchers.matchesPattern;+import static org.hamcrest.Matchers.not;+import static org.hamcrest.Matchers.nullValue;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertNotNull;++@QuarkusTest+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)+class CognitoIdentityIntegrationTest {++ private static final String CONTENT_TYPE = "application/x-amz-json-1.1";+ private static final String TARGET = "AWSCognitoIdentityService";+ private static final String USER_POOL_PROVIDER = "cognito-idp.us-east-1.amazonaws.com/us-east-1_abc123";+ private static final String EU_WEST_1_AUTHORIZATION =+ "AWS4-HMAC-SHA256 Credential=test/20260101/eu-west-1/cognito-identity/aws4_request";++ private static String identityPoolId;+ private static String identityPoolArn;++ @BeforeAll+ static void configureRestAssured() {+ RestAssuredJsonUtils.configureAwsContentTypes();+ }++ private static io.restassured.specification.RequestSpecification action(String name) {+ return given()+ .header("X-Amz-Target", TARGET + "." + name)+ .contentType(CONTENT_TYPE);+ }++ @Test+ @Order(1)+ void createIdentityPool() {+ identityPoolId = action("CreateIdentityPool")+ .body("""+ {+ "IdentityPoolName": "floci integration pool",+ "AllowUnauthenticatedIdentities": true,+ "AllowClassicFlow": true,+ "DeveloperProviderName": "login.floci.test",+ "SupportedLoginProviders": {"graph.facebook.com": "1234567890"},+ "OpenIdConnectProviderARNs": ["arn:aws:iam::000000000000:oidc-provider/example.com"],+ "SamlProviderARNs": ["arn:aws:iam::000000000000:saml-provider/example"],+ "CognitoIdentityProviders": [+ {"ProviderName": "%s", "ClientId": "client-abc", "ServerSideTokenCheck": true}+ ],+ "IdentityPoolTags": {"team": "identity"}+ }+ """.formatted(USER_POOL_PROVIDER))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("IdentityPoolId", matchesPattern("us-east-1:[0-9a-f-]{36}"))+ .body("IdentityPoolName", equalTo("floci integration pool"))+ .body("AllowUnauthenticatedIdentities", equalTo(true))+ .body("AllowClassicFlow", equalTo(true))+ .body("DeveloperProviderName", equalTo("login.floci.test"))+ .body("SupportedLoginProviders.'graph.facebook.com'", equalTo("1234567890"))+ .body("OpenIdConnectProviderARNs[0]", equalTo("arn:aws:iam::000000000000:oidc-provider/example.com"))+ .body("SamlProviderARNs[0]", equalTo("arn:aws:iam::000000000000:saml-provider/example"))+ .body("CognitoIdentityProviders[0].ProviderName", equalTo(USER_POOL_PROVIDER))+ .body("CognitoIdentityProviders[0].ClientId", equalTo("client-abc"))+ .body("CognitoIdentityProviders[0].ServerSideTokenCheck", equalTo(true))+ .body("IdentityPoolTags.team", equalTo("identity"))+ .extract().path("IdentityPoolId");++ identityPoolArn = "arn:aws:cognito-identity:us-east-1:000000000000:identitypool/" + identityPoolId;+ }++ @Test+ @Order(2)+ void describeIdentityPool() {+ action("DescribeIdentityPool")+ .body("{\"IdentityPoolId\": \"" + identityPoolId + "\"}")+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("IdentityPoolId", equalTo(identityPoolId))+ .body("IdentityPoolName", equalTo("floci integration pool"))+ .body("AllowUnauthenticatedIdentities", equalTo(true))+ .body("CognitoIdentityProviders[0].ClientId", equalTo("client-abc"))+ .body("IdentityPoolTags.team", equalTo("identity"));+ }++ @Test+ @Order(3)+ void describeMissingIdentityPoolReturnsResourceNotFound() {+ action("DescribeIdentityPool")+ .body("{\"IdentityPoolId\": \"us-east-1:00000000-0000-0000-0000-000000000000\"}")+ .when()+ .post("/")+ .then()+ .statusCode(404)+ .body("__type", equalTo("ResourceNotFoundException"));+ }++ @Test+ @Order(4)+ void createIdentityPoolRejectsInvalidName() {+ action("CreateIdentityPool")+ .body("{\"IdentityPoolName\": \"bad/name\", \"AllowUnauthenticatedIdentities\": false}")+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("__type", equalTo("InvalidParameterException"));+ }++ @Test+ @Order(5)+ void listIdentityPools() {+ action("ListIdentityPools")+ .body("{\"MaxResults\": 60}")+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("IdentityPools.IdentityPoolId", hasItem(identityPoolId))+ .body("IdentityPools.IdentityPoolName", hasItem("floci integration pool"));+ }++ @Test+ @Order(6)+ void listIdentityPoolsRejectsOutOfRangeMaxResults() {+ action("ListIdentityPools")+ .body("{\"MaxResults\": 500}")+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("__type", equalTo("InvalidParameterException"));+ }++ @Test+ @Order(7)+ void getIdentityPoolRolesBeforeSetReturnsEmptyMaps() {+ action("GetIdentityPoolRoles")+ .body("{\"IdentityPoolId\": \"" + identityPoolId + "\"}")+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("IdentityPoolId", equalTo(identityPoolId))+ .body("Roles", not(nullValue()))+ .body("Roles.keySet()", emptyIterable())+ .body("RoleMappings", not(nullValue()));+ }++ @Test+ @Order(8)+ void setAndGetIdentityPoolRoles() {+ action("SetIdentityPoolRoles")+ .body("""+ {+ "IdentityPoolId": "%s",+ "Roles": {+ "authenticated": "arn:aws:iam::000000000000:role/authenticated",+ "unauthenticated": "arn:aws:iam::000000000000:role/unauthenticated"+ },+ "RoleMappings": {+ "%s:client-abc": {+ "Type": "Rules",+ "AmbiguousRoleResolution": "Deny",+ "RulesConfiguration": {+ "Rules": [+ {"Claim": "isAdmin", "MatchType": "Equals", "Value": "true",+ "RoleARN": "arn:aws:iam::000000000000:role/admin"}+ ]+ }+ }+ }+ }+ """.formatted(identityPoolId, USER_POOL_PROVIDER))+ .when()+ .post("/")+ .then()+ .statusCode(200);++ Map<String, ?> roleMappings = action("GetIdentityPoolRoles")+ .body("{\"IdentityPoolId\": \"" + identityPoolId + "\"}")+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("IdentityPoolId", equalTo(identityPoolId))+ .body("Roles.authenticated", equalTo("arn:aws:iam::000000000000:role/authenticated"))+ .body("Roles.unauthenticated", equalTo("arn:aws:iam::000000000000:role/unauthenticated"))+ .extract().path("RoleMappings");++ @SuppressWarnings("unchecked")+ Map<String, Object> mapping = (Map<String, Object>) roleMappings.get(USER_POOL_PROVIDER + ":client-abc");+ assertNotNull(mapping, "RoleMappings must round-trip the provider key sent on SetIdentityPoolRoles");+ assertEquals("Rules", mapping.get("Type"));+ assertEquals("Deny", mapping.get("AmbiguousRoleResolution"));+ }++ @Test+ @Order(9)+ void setIdentityPoolRolesRejectsUnknownRoleKey() {+ action("SetIdentityPoolRoles")+ .body("""+ {"IdentityPoolId": "%s", "Roles": {"admin": "arn:aws:iam::000000000000:role/admin"}}+ """.formatted(identityPoolId))+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("__type", equalTo("InvalidParameterException"));+ }++ @Test+ @Order(10)+ void tagRoundTrip() {+ action("TagResource")+ .body("""+ {"ResourceArn": "%s", "Tags": {"env": "test"}}+ """.formatted(identityPoolArn))+ .when()+ .post("/")+ .then()+ .statusCode(200);++ action("ListTagsForResource")+ .body("{\"ResourceArn\": \"" + identityPoolArn + "\"}")+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("Tags.team", equalTo("identity"))+ .body("Tags.env", equalTo("test"));++ action("DescribeIdentityPool")+ .body("{\"IdentityPoolId\": \"" + identityPoolId + "\"}")+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("IdentityPoolTags.env", equalTo("test"));++ action("UntagResource")+ .body("""+ {"ResourceArn": "%s", "TagKeys": ["env"]}+ """.formatted(identityPoolArn))+ .when()+ .post("/")+ .then()+ .statusCode(200);++ action("ListTagsForResource")+ .body("{\"ResourceArn\": \"" + identityPoolArn + "\"}")+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("Tags", hasKey("team"))+ .body("Tags", not(hasKey("env")));+ }++ @Test+ @Order(11)+ void listTagsForUnknownPoolReturnsResourceNotFound() {+ action("ListTagsForResource")+ .body("""+ {"ResourceArn": "arn:aws:cognito-identity:us-east-1:000000000000:identitypool/us-east-1:00000000-0000-0000-0000-000000000000"}+ """)+ .when()+ .post("/")+ .then()+ .statusCode(404)+ .body("__type", equalTo("ResourceNotFoundException"));+ }++ @Test+ @Order(12)+ void principalTagAttributeMapRoundTrip() {+ action("SetPrincipalTagAttributeMap")+ .body("""+ {"IdentityPoolId": "%s", "IdentityProviderName": "%s",+ "UseDefaults": false, "PrincipalTags": {"department": "custom:department"}}+ """.formatted(identityPoolId, USER_POOL_PROVIDER))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("IdentityPoolId", equalTo(identityPoolId))+ .body("IdentityProviderName", equalTo(USER_POOL_PROVIDER))+ .body("UseDefaults", equalTo(false))+ .body("PrincipalTags.department", equalTo("custom:department"));++ action("GetPrincipalTagAttributeMap")+ .body("""+ {"IdentityPoolId": "%s", "IdentityProviderName": "%s"}+ """.formatted(identityPoolId, USER_POOL_PROVIDER))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("UseDefaults", equalTo(false))+ .body("PrincipalTags.department", equalTo("custom:department"));+ }++ @Test+ @Order(13)+ void updateIdentityPoolReplacesTheWholePool() {+ action("UpdateIdentityPool")+ .body("""+ {+ "IdentityPoolId": "%s",+ "IdentityPoolName": "floci integration pool renamed",+ "AllowUnauthenticatedIdentities": false+ }+ """.formatted(identityPoolId))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("IdentityPoolId", equalTo(identityPoolId))+ .body("IdentityPoolName", equalTo("floci integration pool renamed"))+ .body("AllowUnauthenticatedIdentities", equalTo(false))+ .body("AllowClassicFlow", equalTo(false))+ .body("CognitoIdentityProviders", emptyIterable())+ .body("SupportedLoginProviders.keySet()", emptyIterable())+ .body("IdentityPoolTags.keySet()", emptyIterable());++ action("GetIdentityPoolRoles")+ .body("{\"IdentityPoolId\": \"" + identityPoolId + "\"}")+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("Roles.authenticated", equalTo("arn:aws:iam::000000000000:role/authenticated"));+ }++ @Test+ @Order(14)+ void unimplementedOperationReturnsUnknownOperation() {+ action("GetCredentialsForIdentity")+ .body("{\"IdentityId\": \"us-east-1:00000000-0000-0000-0000-000000000000\"}")+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("__type", equalTo("UnknownOperationException"));+ }++ @Test+ @Order(15)+ void deleteIdentityPool() {+ action("DeleteIdentityPool")+ .body("{\"IdentityPoolId\": \"" + identityPoolId + "\"}")+ .when()+ .post("/")+ .then()+ .statusCode(200);++ action("DescribeIdentityPool")+ .body("{\"IdentityPoolId\": \"" + identityPoolId + "\"}")+ .when()+ .post("/")+ .then()+ .statusCode(404)+ .body("__type", equalTo("ResourceNotFoundException"));+ }++ @Test+ @Order(16)+ void createIdentityPoolRequiresAllowUnauthenticatedIdentities() {+ action("CreateIdentityPool")+ .body("{\"IdentityPoolName\": \"missing member\"}")+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("__type", equalTo("ValidationException"))+ .body("message", equalTo("1 validation error detected: Value null at 'allowUnauthenticatedIdentities'"+ + " failed to satisfy constraint: Member must not be null"));+ }++ @Test+ @Order(17)+ void tagResourceWithCrossRegionArnWritesBackToThePoolRegion() {+ String euPoolId = action("CreateIdentityPool")+ .header("Authorization", EU_WEST_1_AUTHORIZATION)+ .body("{\"IdentityPoolName\": \"eu pool\", \"AllowUnauthenticatedIdentities\": false}")+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("IdentityPoolId", matchesPattern("eu-west-1:[0-9a-f-]{36}"))+ .extract().path("IdentityPoolId");+ String euPoolArn = "arn:aws:cognito-identity:eu-west-1:000000000000:identitypool/" + euPoolId;++ action("TagResource")+ .body("""+ {"ResourceArn": "%s", "Tags": {"env": "eu"}}+ """.formatted(euPoolArn))+ .when()+ .post("/")+ .then()+ .statusCode(200);++ action("DescribeIdentityPool")+ .header("Authorization", EU_WEST_1_AUTHORIZATION)+ .body("{\"IdentityPoolId\": \"" + euPoolId + "\"}")+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("IdentityPoolTags.env", equalTo("eu"));++ action("DescribeIdentityPool")+ .body("{\"IdentityPoolId\": \"" + euPoolId + "\"}")+ .when()+ .post("/")+ .then()+ .statusCode(404)+ .body("__type", equalTo("ResourceNotFoundException"));++ action("ListIdentityPools")+ .body("{\"MaxResults\": 60}")+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("IdentityPools.IdentityPoolId", not(hasItem(euPoolId)));++ action("DeleteIdentityPool")+ .header("Authorization", EU_WEST_1_AUTHORIZATION)+ .body("{\"IdentityPoolId\": \"" + euPoolId + "\"}")+ .when()+ .post("/")+ .then()+ .statusCode(200);+ }++ @Test+ @Order(18)+ void createIdentityPoolRejectsNonBooleanAllowUnauthenticatedIdentities() {+ action("CreateIdentityPool")+ .body("{\"IdentityPoolName\": \"wrong type\", \"AllowUnauthenticatedIdentities\": \"true\"}")+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("__type", equalTo("SerializationException"))+ .body("message", equalTo("AllowUnauthenticatedIdentities must be a boolean."));+ }+}diff --git a/src/test/resources/application.yml b/src/test/resources/application.ymlindex 4c471c6423..f3daf8d7a4 100644--- a/src/test/resources/application.yml+++ b/src/test/resources/application.yml@@ -375,6 +375,8 @@ floci:enabled: trueconnect:enabled: true+ cognitoidentity:+ enabled: trueaps:enabled: truelakeformation:diff --git a/tools/docs/service_matrix.yaml b/tools/docs/service_matrix.yamlindex 0e8b847d08..0b1bdfcc12 100644--- a/tools/docs/service_matrix.yaml+++ b/tools/docs/service_matrix.yaml@@ -33,6 +33,7 @@ aliases:monitoring: cloudwatch # CloudWatch Metrics facet, at cloudwatch.md#metricssecretsmanager: secrets-managercodeguru-reviewer: codegurureviewer # SigV4 signing name is hyphenated; the doc slug is not+ cognito-identity: cognitoidentity # SigV4 signing name is hyphenated; the doc slug is notservicecatalog: service-catalogcognito-idp: cognito # Cognito's SigV4 signing namestates: step-functions # Step Functions' SigV4 signing namediff --git a/tools/docs/services.yaml b/tools/docs/services.yamlindex a6bdb971f7..e20a0e6102 100644--- a/tools/docs/services.yaml+++ b/tools/docs/services.yaml@@ -166,6 +166,10 @@ services:# SubnetIds / VpcSecurityGroupIds / TagKeys are labels of an inner member-name# switch (memberKeyRegex), not actions — same shape as the rds exclusions above.exclude_actions: [SubnetIds, VpcSecurityGroupIds, TagKeys]+ - service: cognitoidentity+ doc: docs/services/cognitoidentity.md+ sources:+ - { path: src/main/java/io/github/hectorvent/floci/services/cognitoidentity/CognitoIdentityJsonHandler.java, mode: switch }- service: route53doc: docs/services/route53.mdsources: