Skip to content

armgit / floci

Public Imported from GitHub
0

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

feat(cognito): implement identity provider configuration CRUD (#2858)

Brian Taylor0a3bc030f651
diff --git a/compatibility-tests/sdk-test-node/tests/cognito-identity-provider.test.ts b/compatibility-tests/sdk-test-node/tests/cognito-identity-provider.test.ts
new file mode 100644
index 0000000000..d80950f846
--- /dev/null
+++ b/compatibility-tests/sdk-test-node/tests/cognito-identity-provider.test.ts
@@ -0,0 +1,185 @@
+/**
+ * Cognito identity provider configuration compatibility tests.
+ *
+ * The response shapes asserted here were measured against the live Cognito API:
+ * `IdpIdentifiers` is echoed by CreateIdentityProvider and UpdateIdentityProvider
+ * only when the request supplied the member, whatever the stored value, while
+ * DescribeIdentityProvider always returns it. Members a request omits are
+ * preserved rather than cleared.
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import {
+ CognitoIdentityProviderClient,
+ CreateUserPoolCommand,
+ DeleteUserPoolCommand,
+ CreateIdentityProviderCommand,
+ DescribeIdentityProviderCommand,
+ ListIdentityProvidersCommand,
+ UpdateIdentityProviderCommand,
+ DeleteIdentityProviderCommand,
+ IdentityProviderTypeType,
+} from '@aws-sdk/client-cognito-identity-provider';
+import { makeClient, uniqueName } from './setup';
+
+const OIDC_DETAILS = {
+ client_id: 'node-compat-client',
+ client_secret: 'node-compat-secret',
+ attributes_request_method: 'GET',
+ oidc_issuer: 'https://issuer.example.com',
+ authorize_scopes: 'openid',
+};
+
+describe('Cognito identity providers', () => {
+ let cognito: CognitoIdentityProviderClient;
+ let poolId: string;
+
+ beforeAll(async () => {
+ cognito = makeClient(CognitoIdentityProviderClient);
+ const pool = await cognito.send(
+ new CreateUserPoolCommand({ PoolName: uniqueName('idp-pool') })
+ );
+ poolId = pool.UserPool!.Id!;
+ });
+
+ afterAll(async () => {
+ if (poolId) {
+ await cognito.send(new DeleteUserPoolCommand({ UserPoolId: poolId }));
+ }
+ });
+
+ it('defaults AttributeMapping and omits IdpIdentifiers on create', async () => {
+ const created = await cognito.send(
+ new CreateIdentityProviderCommand({
+ UserPoolId: poolId,
+ ProviderName: 'NodeOidc',
+ ProviderType: IdentityProviderTypeType.OIDC,
+ ProviderDetails: { ...OIDC_DETAILS },
+ })
+ );
+
+ expect(created.IdentityProvider!.AttributeMapping).toEqual({ username: 'sub' });
+ expect(created.IdentityProvider!.IdpIdentifiers).toBeUndefined();
+
+ const described = await cognito.send(
+ new DescribeIdentityProviderCommand({ UserPoolId: poolId, ProviderName: 'NodeOidc' })
+ );
+ expect(described.IdentityProvider!.IdpIdentifiers).toEqual([]);
+ expect(described.IdentityProvider!.ProviderDetails!.client_id).toBe('node-compat-client');
+
+ await cognito.send(
+ new DeleteIdentityProviderCommand({ UserPoolId: poolId, ProviderName: 'NodeOidc' })
+ );
+ });
+
+ it('preserves members the update request omits', async () => {
+ await cognito.send(
+ new CreateIdentityProviderCommand({
+ UserPoolId: poolId,
+ ProviderName: 'NodeOidcAliased',
+ ProviderType: IdentityProviderTypeType.OIDC,
+ ProviderDetails: { ...OIDC_DETAILS },
+ AttributeMapping: { email: 'email', username: 'sub' },
+ IdpIdentifiers: ['node-alias'],
+ })
+ );
+
+ const updated = await cognito.send(
+ new UpdateIdentityProviderCommand({
+ UserPoolId: poolId,
+ ProviderName: 'NodeOidcAliased',
+ ProviderDetails: { ...OIDC_DETAILS },
+ })
+ );
+ expect(updated.IdentityProvider!.IdpIdentifiers).toBeUndefined();
+
+ const described = await cognito.send(
+ new DescribeIdentityProviderCommand({
+ UserPoolId: poolId,
+ ProviderName: 'NodeOidcAliased',
+ })
+ );
+ expect(described.IdentityProvider!.IdpIdentifiers).toEqual(['node-alias']);
+ expect(described.IdentityProvider!.AttributeMapping).toEqual({
+ email: 'email',
+ username: 'sub',
+ });
+
+ await cognito.send(
+ new DeleteIdentityProviderCommand({
+ UserPoolId: poolId,
+ ProviderName: 'NodeOidcAliased',
+ })
+ );
+ });
+
+ it('lists providers as summaries without provider details', async () => {
+ await cognito.send(
+ new CreateIdentityProviderCommand({
+ UserPoolId: poolId,
+ ProviderName: 'NodeOidcListed',
+ ProviderType: IdentityProviderTypeType.OIDC,
+ ProviderDetails: { ...OIDC_DETAILS },
+ })
+ );
+
+ const listed = await cognito.send(new ListIdentityProvidersCommand({ UserPoolId: poolId }));
+
+ expect(listed.Providers).toHaveLength(1);
+ expect(listed.Providers![0].ProviderName).toBe('NodeOidcListed');
+ expect(listed.Providers![0].ProviderType).toBe('OIDC');
+ expect(listed.Providers![0].CreationDate).toBeInstanceOf(Date);
+ expect(listed.Providers![0]).not.toHaveProperty('ProviderDetails');
+
+ await cognito.send(
+ new DeleteIdentityProviderCommand({ UserPoolId: poolId, ProviderName: 'NodeOidcListed' })
+ );
+ const empty = await cognito.send(new ListIdentityProvidersCommand({ UserPoolId: poolId }));
+ expect(empty.Providers).toEqual([]);
+ });
+
+ it('rejects a duplicate provider name and an unknown provider type', async () => {
+ await cognito.send(
+ new CreateIdentityProviderCommand({
+ UserPoolId: poolId,
+ ProviderName: 'NodeOidcDuplicate',
+ ProviderType: IdentityProviderTypeType.OIDC,
+ ProviderDetails: { ...OIDC_DETAILS },
+ })
+ );
+
+ // The SDK maps the wire `__type` onto `error.name` and puts the AWS text in
+ // `message`, so the exception has to be matched on the name.
+ await expect(
+ cognito.send(
+ new CreateIdentityProviderCommand({
+ UserPoolId: poolId,
+ ProviderName: 'NodeOidcDuplicate',
+ ProviderType: IdentityProviderTypeType.OIDC,
+ ProviderDetails: { ...OIDC_DETAILS },
+ })
+ )
+ ).rejects.toMatchObject({ name: 'DuplicateProviderException' });
+
+ await expect(
+ cognito.send(
+ new CreateIdentityProviderCommand({
+ UserPoolId: poolId,
+ ProviderName: 'NodeBogus',
+ ProviderType: 'NotARealType' as IdentityProviderTypeType,
+ ProviderDetails: { client_id: 'x' },
+ })
+ )
+ ).rejects.toMatchObject({
+ name: 'InvalidParameterException',
+ message: expect.stringContaining('Member must satisfy enum value set'),
+ });
+
+ await cognito.send(
+ new DeleteIdentityProviderCommand({
+ UserPoolId: poolId,
+ ProviderName: 'NodeOidcDuplicate',
+ })
+ );
+ });
+});
diff --git a/compatibility-tests/sdk-test-python/tests/test_cognito.py b/compatibility-tests/sdk-test-python/tests/test_cognito.py
index 238c7d0385..d1b9164896 100644
--- a/compatibility-tests/sdk-test-python/tests/test_cognito.py
+++ b/compatibility-tests/sdk-test-python/tests/test_cognito.py
@@ -360,3 +360,132 @@ class TestCognitoDescribeUserPoolStandardAttributes:
assert sub["Mutable"] is False
finally:
cognito_client.delete_user_pool(UserPoolId=pool_id)
+
+
+class TestCognitoIdentityProvider:
+ """Test Cognito identity provider configuration operations.
+
+ The response shapes asserted here were measured against the live Cognito API.
+ ``IdpIdentifiers`` is echoed by CreateIdentityProvider only when the request
+ supplied it, while DescribeIdentityProvider always returns it.
+ """
+
+ OIDC_DETAILS = {
+ "client_id": "pytest-client",
+ "client_secret": "pytest-secret",
+ "attributes_request_method": "GET",
+ "oidc_issuer": "https://issuer.example.com",
+ "authorize_scopes": "openid",
+ }
+
+ @pytest.fixture
+ def pool_id(self, cognito_client, unique_name):
+ response = cognito_client.create_user_pool(PoolName=f"pytest-idp-pool-{unique_name}")
+ pool_id = response["UserPool"]["Id"]
+ yield pool_id
+ cognito_client.delete_user_pool(UserPoolId=pool_id)
+
+ def test_create_defaults_attribute_mapping_and_omits_idp_identifiers(
+ self, cognito_client, pool_id
+ ):
+ """Create defaults AttributeMapping and omits IdpIdentifiers when not supplied."""
+ provider = cognito_client.create_identity_provider(
+ UserPoolId=pool_id,
+ ProviderName="PytestOidc",
+ ProviderType="OIDC",
+ ProviderDetails=dict(self.OIDC_DETAILS),
+ )["IdentityProvider"]
+
+ assert provider["ProviderType"] == "OIDC"
+ assert provider["AttributeMapping"] == {"username": "sub"}
+ assert "IdpIdentifiers" not in provider
+
+ def test_describe_always_returns_idp_identifiers(self, cognito_client, pool_id):
+ """Describe returns IdpIdentifiers even when the stored list is empty."""
+ cognito_client.create_identity_provider(
+ UserPoolId=pool_id,
+ ProviderName="PytestOidc",
+ ProviderType="OIDC",
+ ProviderDetails=dict(self.OIDC_DETAILS),
+ )
+
+ provider = cognito_client.describe_identity_provider(
+ UserPoolId=pool_id, ProviderName="PytestOidc"
+ )["IdentityProvider"]
+
+ assert provider["IdpIdentifiers"] == []
+ assert provider["ProviderDetails"]["client_id"] == "pytest-client"
+
+ def test_update_preserves_members_the_request_omits(self, cognito_client, pool_id):
+ """Omitting AttributeMapping/IdpIdentifiers on update leaves them unchanged."""
+ cognito_client.create_identity_provider(
+ UserPoolId=pool_id,
+ ProviderName="PytestOidc",
+ ProviderType="OIDC",
+ ProviderDetails=dict(self.OIDC_DETAILS),
+ AttributeMapping={"email": "email", "username": "sub"},
+ IdpIdentifiers=["pytest-alias"],
+ )
+
+ cognito_client.update_identity_provider(
+ UserPoolId=pool_id,
+ ProviderName="PytestOidc",
+ ProviderDetails=dict(self.OIDC_DETAILS),
+ )
+
+ provider = cognito_client.describe_identity_provider(
+ UserPoolId=pool_id, ProviderName="PytestOidc"
+ )["IdentityProvider"]
+
+ assert provider["IdpIdentifiers"] == ["pytest-alias"]
+ assert provider["AttributeMapping"] == {"email": "email", "username": "sub"}
+
+ def test_list_returns_summaries_without_provider_details(self, cognito_client, pool_id):
+ """ListIdentityProviders returns summaries, never provider credentials."""
+ cognito_client.create_identity_provider(
+ UserPoolId=pool_id,
+ ProviderName="PytestOidc",
+ ProviderType="OIDC",
+ ProviderDetails=dict(self.OIDC_DETAILS),
+ )
+
+ providers = cognito_client.list_identity_providers(UserPoolId=pool_id)["Providers"]
+
+ assert len(providers) == 1
+ assert providers[0]["ProviderName"] == "PytestOidc"
+ assert providers[0]["ProviderType"] == "OIDC"
+ assert "ProviderDetails" not in providers[0]
+
+ def test_create_rejects_duplicate_provider_name(self, cognito_client, pool_id):
+ """A second provider with the same name raises DuplicateProviderException."""
+ cognito_client.create_identity_provider(
+ UserPoolId=pool_id,
+ ProviderName="PytestOidc",
+ ProviderType="OIDC",
+ ProviderDetails=dict(self.OIDC_DETAILS),
+ )
+
+ with pytest.raises(cognito_client.exceptions.DuplicateProviderException):
+ cognito_client.create_identity_provider(
+ UserPoolId=pool_id,
+ ProviderName="PytestOidc",
+ ProviderType="OIDC",
+ ProviderDetails=dict(self.OIDC_DETAILS),
+ )
+
+ def test_delete_removes_the_provider(self, cognito_client, pool_id):
+ """Delete removes the provider and a second delete raises."""
+ cognito_client.create_identity_provider(
+ UserPoolId=pool_id,
+ ProviderName="PytestOidc",
+ ProviderType="OIDC",
+ ProviderDetails=dict(self.OIDC_DETAILS),
+ )
+
+ cognito_client.delete_identity_provider(UserPoolId=pool_id, ProviderName="PytestOidc")
+
+ assert cognito_client.list_identity_providers(UserPoolId=pool_id)["Providers"] == []
+ with pytest.raises(cognito_client.exceptions.ResourceNotFoundException):
+ cognito_client.delete_identity_provider(
+ UserPoolId=pool_id, ProviderName="PytestOidc"
+ )
diff --git a/docs/services/cognito.md b/docs/services/cognito.md
index 772e1afd51..5c10479a16 100644
--- a/docs/services/cognito.md
+++ b/docs/services/cognito.md
@@ -56,6 +56,38 @@ Standalone `TagResource` rejects reserved `floci:*` keys. `ListTagsForResource`
| UpdateResourceServer | Updates a resource server's name and scopes. |
| DeleteResourceServer | Deletes a resource server from a user pool. |
+### Identity Providers
+
+| Action | Description |
+|--------|-------------|
+| CreateIdentityProvider | Registers a federated identity provider on a user pool. |
+| DescribeIdentityProvider | Returns a registered identity provider. |
+| ListIdentityProviders | Lists a user pool's providers as name/type/date summaries. |
+| UpdateIdentityProvider | Updates a provider's details, attribute mapping or identifiers. |
+| DeleteIdentityProvider | Deletes an identity provider from a user pool. |
+
+Providers are stored configuration only. Floci does not perform the federated sign-in
+flow: there is no `/oauth2/authorize` or `/oauth2/idpresponse` endpoint, so a registered
+provider cannot be used to authenticate. This covers infrastructure tooling that creates
+and reads provider configuration, not federated login.
+
+Two deliberate divergences from AWS, both consequences of not calling out to a third
+party:
+
+- **No create-time validation of `ProviderDetails`.** AWS resolves an OIDC provider's
+ `oidc_issuer` discovery document while handling `CreateIdentityProvider`, and rejects
+ the call when it is unreachable. Floci stores `ProviderDetails` opaquely and makes no
+ outbound request, so it also does not enforce the per-provider-type required keys.
+- **No injected provider defaults.** AWS adds keys such as
+ `attributes_url_add_attributes` to an OIDC provider's stored details; Floci returns
+ only what was supplied.
+
+`AttributeMapping` and `IdpIdentifiers` follow AWS's update semantics: a member the
+request omits is left unchanged, and an explicitly empty map or list is what clears it.
+`IdpIdentifiers` is echoed by `CreateIdentityProvider` and `UpdateIdentityProvider` only
+when the request supplied it, whatever the stored value, while `DescribeIdentityProvider`
+always returns it.
+
### User Pool Domains
| Action | Description |
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.java
index bdca6f26bb..e4bc12d140 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
@@ -9,6 +9,7 @@ import io.github.hectorvent.floci.core.common.AwsErrorResponse;
import io.github.hectorvent.floci.core.common.AwsException;
import io.github.hectorvent.floci.services.cognito.model.CognitoGroup;
import io.github.hectorvent.floci.services.cognito.model.CognitoUser;
+import io.github.hectorvent.floci.services.cognito.model.IdentityProvider;
import io.github.hectorvent.floci.services.cognito.model.ResourceServer;
import io.github.hectorvent.floci.services.cognito.model.ResourceServerScope;
import io.github.hectorvent.floci.services.cognito.model.UserPool;
@@ -61,6 +62,11 @@ public class CognitoJsonHandler {
case "ListResourceServers" -> handleListResourceServers(request);
case "UpdateResourceServer" -> handleUpdateResourceServer(request);
case "DeleteResourceServer" -> handleDeleteResourceServer(request);
+ case "CreateIdentityProvider" -> handleCreateIdentityProvider(request);
+ case "DescribeIdentityProvider" -> handleDescribeIdentityProvider(request);
+ case "ListIdentityProviders" -> handleListIdentityProviders(request);
+ case "UpdateIdentityProvider" -> handleUpdateIdentityProvider(request);
+ case "DeleteIdentityProvider" -> handleDeleteIdentityProvider(request);
case "CreateUserPoolDomain" -> handleCreateUserPoolDomain(request);
case "DescribeUserPoolDomain" -> handleDescribeUserPoolDomain(request);
case "DeleteUserPoolDomain" -> handleDeleteUserPoolDomain(request);
@@ -355,6 +361,59 @@ public class CognitoJsonHandler {
return Response.ok(objectMapper.createObjectNode()).build();
}
+ private Response handleCreateIdentityProvider(JsonNode request) {
+ IdentityProvider provider = service.createIdentityProvider(
+ request.path("UserPoolId").asText(),
+ request.path("ProviderName").asText(),
+ request.path("ProviderType").asText(null),
+ readStringMap(request, "ProviderDetails"),
+ readStringMap(request, "AttributeMapping"),
+ readStringList(request, "IdpIdentifiers")
+ );
+ ObjectNode response = objectMapper.createObjectNode();
+ response.set("IdentityProvider", identityProviderToNode(provider, request.has("IdpIdentifiers")));
+ return Response.ok(response).build();
+ }
+
+ private Response handleDescribeIdentityProvider(JsonNode request) {
+ IdentityProvider provider = service.describeIdentityProvider(
+ request.path("UserPoolId").asText(),
+ request.path("ProviderName").asText()
+ );
+ ObjectNode response = objectMapper.createObjectNode();
+ response.set("IdentityProvider", identityProviderToNode(provider, true));
+ return Response.ok(response).build();
+ }
+
+ private Response handleListIdentityProviders(JsonNode request) {
+ List<IdentityProvider> providers = service.listIdentityProviders(request.path("UserPoolId").asText());
+ ObjectNode response = objectMapper.createObjectNode();
+ ArrayNode items = response.putArray("Providers");
+ providers.forEach(provider -> items.add(providerDescriptionToNode(provider)));
+ return Response.ok(response).build();
+ }
+
+ private Response handleUpdateIdentityProvider(JsonNode request) {
+ IdentityProvider provider = service.updateIdentityProvider(
+ request.path("UserPoolId").asText(),
+ request.path("ProviderName").asText(),
+ readStringMap(request, "ProviderDetails"),
+ readStringMap(request, "AttributeMapping"),
+ readStringList(request, "IdpIdentifiers")
+ );
+ ObjectNode response = objectMapper.createObjectNode();
+ response.set("IdentityProvider", identityProviderToNode(provider, request.has("IdpIdentifiers")));
+ return Response.ok(response).build();
+ }
+
+ private Response handleDeleteIdentityProvider(JsonNode request) {
+ service.deleteIdentityProvider(
+ request.path("UserPoolId").asText(),
+ request.path("ProviderName").asText()
+ );
+ return Response.ok(objectMapper.createObjectNode()).build();
+ }
+
private Response handleCreateUserPoolDomain(JsonNode request) {
JsonNode customDomainConfigNode = request.path("CustomDomainConfig");
Map<String, Object> customDomainConfig = customDomainConfigNode.isObject()
@@ -1074,6 +1133,58 @@ public class CognitoJsonHandler {
return node;
}
+ /**
+ * {@code IdpIdentifiers} is echoed only when the caller supplied the member: AWS omits it
+ * from CreateIdentityProvider and UpdateIdentityProvider responses otherwise, whatever the
+ * stored value, while DescribeIdentityProvider always returns it.
+ */
+ private ObjectNode identityProviderToNode(IdentityProvider provider, boolean includeIdpIdentifiers) {
+ ObjectNode node = objectMapper.createObjectNode();
+ node.put("UserPoolId", provider.getUserPoolId());
+ node.put("ProviderName", provider.getProviderName());
+ node.put("ProviderType", provider.getProviderType());
+ ObjectNode details = node.putObject("ProviderDetails");
+ provider.getProviderDetails().forEach(details::put);
+ ObjectNode mapping = node.putObject("AttributeMapping");
+ provider.getAttributeMapping().forEach(mapping::put);
+ if (includeIdpIdentifiers) {
+ ArrayNode identifiers = node.putArray("IdpIdentifiers");
+ provider.getIdpIdentifiers().forEach(identifiers::add);
+ }
+ node.put("CreationDate", provider.getCreationDate());
+ node.put("LastModifiedDate", provider.getLastModifiedDate());
+ return node;
+ }
+
+ private ObjectNode providerDescriptionToNode(IdentityProvider provider) {
+ ObjectNode node = objectMapper.createObjectNode();
+ node.put("ProviderName", provider.getProviderName());
+ node.put("ProviderType", provider.getProviderType());
+ node.put("LastModifiedDate", provider.getLastModifiedDate());
+ node.put("CreationDate", provider.getCreationDate());
+ return node;
+ }
+
+ private Map<String, String> readStringMap(JsonNode request, String member) {
+ JsonNode node = request.get(member);
+ if (node == null || !node.isObject()) {
+ return null;
+ }
+ Map<String, String> values = new LinkedHashMap<>();
+ node.fields().forEachRemaining(entry -> values.put(entry.getKey(), entry.getValue().asText()));
+ return values;
+ }
+
+ private List<String> readStringList(JsonNode request, String member) {
+ JsonNode node = request.get(member);
+ if (node == null || !node.isArray()) {
+ return null;
+ }
+ List<String> values = new ArrayList<>();
+ node.forEach(item -> values.add(item.asText()));
+ return values;
+ }
+
private List<ResourceServerScope> parseScopes(JsonNode scopesNode) {
if (scopesNode == null || !scopesNode.isArray()) {
return List.of();
diff --git a/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoService.java b/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoService.java
index 4fd8f9d272..6a5b2169e2 100644
--- a/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoService.java
+++ b/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoService.java
@@ -18,6 +18,7 @@ import io.github.hectorvent.floci.core.storage.StorageBackend;
import io.github.hectorvent.floci.core.storage.StorageFactory;
import io.github.hectorvent.floci.services.cognito.model.CognitoGroup;
import io.github.hectorvent.floci.services.cognito.model.CognitoUser;
+import io.github.hectorvent.floci.services.cognito.model.IdentityProvider;
import io.github.hectorvent.floci.services.cognito.model.ResourceServer;
import io.github.hectorvent.floci.services.cognito.model.ResourceServerScope;
import io.github.hectorvent.floci.services.cognito.model.RevokedTokenInfo;
@@ -112,6 +113,7 @@ public class CognitoService implements ResourceProvider {
private final StorageBackend<String, UserPoolClient> clientStore;
private final StorageBackend<String, ResourceServer> resourceServerStore;
private final StorageBackend<String, UserPoolDomain> domainStore;
+ private final StorageBackend<String, IdentityProvider> identityProviderStore;
private final StorageBackend<String, CognitoUser> userStore;
private final StorageBackend<String, CognitoGroup> groupStore;
private final StorageBackend<String, RevokedTokenInfo> revokedTokenStore;
@@ -137,6 +139,8 @@ public class CognitoService implements ResourceProvider {
new TypeReference<Map<String, ResourceServer>>() {}),
storageFactory.create("cognito", "cognito-domains.json",
new TypeReference<Map<String, UserPoolDomain>>() {}),
+ storageFactory.create("cognito", "cognito-identity-providers.json",
+ new TypeReference<Map<String, IdentityProvider>>() {}),
storageFactory.create("cognito", "cognito-users.json",
new TypeReference<Map<String, CognitoUser>>() {}),
storageFactory.create("cognito", "cognito-groups.json",
@@ -161,7 +165,7 @@ public class CognitoService implements ResourceProvider {
RegionResolver regionResolver,
LambdaService lambdaService) {
this(poolStore, clientStore, resourceServerStore, new InMemoryStorage<>(),
- userStore, groupStore, revokedTokenStore, baseUrl,
+ new InMemoryStorage<>(), userStore, groupStore, revokedTokenStore, baseUrl,
regionResolver, lambdaService, null, null);
}
@@ -169,6 +173,7 @@ public class CognitoService implements ResourceProvider {
StorageBackend<String, UserPoolClient> clientStore,
StorageBackend<String, ResourceServer> resourceServerStore,
StorageBackend<String, UserPoolDomain> domainStore,
+ StorageBackend<String, IdentityProvider> identityProviderStore,
StorageBackend<String, CognitoUser> userStore,
StorageBackend<String, CognitoGroup> groupStore,
StorageBackend<String, RevokedTokenInfo> revokedTokenStore,
@@ -180,6 +185,7 @@ public class CognitoService implements ResourceProvider {
this.clientStore = clientStore;
this.resourceServerStore = resourceServerStore;
this.domainStore = domainStore;
+ this.identityProviderStore = identityProviderStore;
this.userStore = userStore;
this.groupStore = groupStore;
this.revokedTokenStore = revokedTokenStore;
@@ -460,7 +466,13 @@ public class CognitoService implements ResourceProvider {
String prefix = id + "::";
groupStore.scan(k -> k.startsWith(prefix))
.forEach(g -> groupStore.delete(groupKey(id, g.getGroupName())));
- poolStore.delete(id);
+ // Same lock as the provider mutations: a create or update that interleaves with
+ // this cascade would otherwise reinstate a provider for a pool that is going away.
+ synchronized (identityProviderLock) {
+ identityProviderStore.scan(k -> k.startsWith(prefix))
+ .forEach(p -> identityProviderStore.delete(identityProviderKey(id, p.getProviderName())));
+ poolStore.delete(id);
+ }
}
// ──────────────────────────── User Pool Clients ────────────────────────────
@@ -877,6 +889,129 @@ public class CognitoService implements ResourceProvider {
resourceServerStore.delete(resourceServerKey(userPoolId, identifier));
}
+ // ──────────────────────────── Identity Providers ────────────────────────────
+
+ private static final Set<String> PROVIDER_TYPES =
+ Set.of("Facebook", "SAML", "SignInWithApple", "LoginWithAmazon", "OIDC", "Google");
+
+ public IdentityProvider createIdentityProvider(String userPoolId, String providerName, String providerType,
+ Map<String, String> providerDetails,
+ Map<String, String> attributeMapping,
+ List<String> idpIdentifiers) {
+ describeUserPool(userPoolId);
+ if (providerName == null || providerName.isBlank()) {
+ throw new AwsException("InvalidParameterException", "ProviderName is required", 400);
+ }
+ validateProviderType(providerType);
+
+ String key = identityProviderKey(userPoolId, providerName);
+ synchronized (identityProviderLock) {
+ // The pool was checked before the lock, so a DeleteUserPool that ran its
+ // cascade in between would leave this create writing a provider for a pool
+ // that no longer exists. Update needs no equivalent recheck: the cascade
+ // removes the provider, so its own lookup throws.
+ describeUserPool(userPoolId);
+ if (identityProviderStore.get(key).isPresent()) {
+ throw new AwsException("DuplicateProviderException",
+ providerName + " already exists for tenant " + userPoolId + ".", 400);
+ }
+
+ IdentityProvider provider = new IdentityProvider();
+ provider.setUserPoolId(userPoolId);
+ provider.setProviderName(providerName);
+ provider.setProviderType(providerType);
+ provider.setProviderDetails(copyOrEmpty(providerDetails));
+ // AWS supplies a default mapping only when the member is absent; an explicitly
+ // empty map is stored as given.
+ provider.setAttributeMapping(attributeMapping == null
+ ? new LinkedHashMap<>(Map.of("username", "sub"))
+ : new LinkedHashMap<>(attributeMapping));
+ provider.setIdpIdentifiers(idpIdentifiers == null
+ ? new ArrayList<>() : new ArrayList<>(idpIdentifiers));
+ identityProviderStore.put(key, provider);
+ return provider;
+ }
+ }
+
+ public IdentityProvider describeIdentityProvider(String userPoolId, String providerName) {
+ describeUserPool(userPoolId);
+ return identityProviderStore.get(identityProviderKey(userPoolId, providerName))
+ .orElseThrow(() -> new AwsException("ResourceNotFoundException",
+ "Identity provider " + providerName + " for tenantId " + userPoolId
+ + " does not exist.", 400));
+ }
+
+ public List<IdentityProvider> listIdentityProviders(String userPoolId) {
+ describeUserPool(userPoolId);
+ String prefix = userPoolId + "::";
+ return identityProviderStore.scan(k -> k.startsWith(prefix));
+ }
+
+ /**
+ * Members the request omits are left as they were: AWS preserves the stored
+ * {@code AttributeMapping} and {@code IdpIdentifiers} rather than clearing them, and an
+ * explicitly empty map or list is what clears them.
+ */
+ public IdentityProvider updateIdentityProvider(String userPoolId, String providerName,
+ Map<String, String> providerDetails,
+ Map<String, String> attributeMapping,
+ List<String> idpIdentifiers) {
+ describeUserPool(userPoolId);
+ String key = identityProviderKey(userPoolId, providerName);
+ synchronized (identityProviderLock) {
+ IdentityProvider provider = copyOf(identityProviderStore.get(key)
+ .orElseThrow(() -> new AwsException("ResourceNotFoundException",
+ "Identity provider " + providerName + " in User Pool " + userPoolId
+ + " does not exist.", 400)));
+
+ if (providerDetails != null) {
+ provider.setProviderDetails(new LinkedHashMap<>(providerDetails));
+ }
+ if (attributeMapping != null) {
+ provider.setAttributeMapping(new LinkedHashMap<>(attributeMapping));
+ }
+ if (idpIdentifiers != null) {
+ provider.setIdpIdentifiers(new ArrayList<>(idpIdentifiers));
+ }
+ provider.setLastModifiedDate(System.currentTimeMillis() / 1000L);
+ identityProviderStore.put(key, provider);
+ return provider;
+ }
+ }
+
+ public void deleteIdentityProvider(String userPoolId, String providerName) {
+ synchronized (identityProviderLock) {
+ describeIdentityProvider(userPoolId, providerName);
+ identityProviderStore.delete(identityProviderKey(userPoolId, providerName));
+ }
+ }
+
+ private void validateProviderType(String providerType) {
+ if (providerType == null || !PROVIDER_TYPES.contains(providerType)) {
+ throw new AwsException("InvalidParameterException",
+ "1 validation error detected: Value '" + providerType + "' at 'providerType' failed to "
+ + "satisfy constraint: Member must satisfy enum value set: "
+ + "[Facebook, SAML, SignInWithApple, LoginWithAmazon, OIDC, Google]", 400);
+ }
+ }
+
+ private Map<String, String> copyOrEmpty(Map<String, String> source) {
+ return source == null ? new LinkedHashMap<>() : new LinkedHashMap<>(source);
+ }
+
+ private IdentityProvider copyOf(IdentityProvider source) {
+ IdentityProvider copy = new IdentityProvider();
+ copy.setUserPoolId(source.getUserPoolId());
+ copy.setProviderName(source.getProviderName());
+ copy.setProviderType(source.getProviderType());
+ copy.setProviderDetails(new LinkedHashMap<>(source.getProviderDetails()));
+ copy.setAttributeMapping(new LinkedHashMap<>(source.getAttributeMapping()));
+ copy.setIdpIdentifiers(new ArrayList<>(source.getIdpIdentifiers()));
+ copy.setCreationDate(source.getCreationDate());
+ copy.setLastModifiedDate(source.getLastModifiedDate());
+ return copy;
+ }
+
// ──────────────────────────── User Pool Domains ────────────────────────────
/**
@@ -1388,6 +1523,12 @@ public class CognitoService implements ResourceProvider {
// Serializes adminLinkProviderForUser's check-then-write.
private final Object identityLinkLock = new Object();
+ // Identity provider mutations are read-modify-write (update) and check-then-act
+ // (create, delete). AWS applies each of those atomically, so two overlapping
+ // updates that touch different optional members both survive there. Guarding
+ // every mutating path with one lock reproduces that.
+ private final Object identityProviderLock = new Object();
+
public void adminLinkProviderForUser(String userPoolId, String destinationUsername,
String sourceProviderName, String sourceUserId) {
if (destinationUsername == null || destinationUsername.isEmpty()) {
@@ -3210,6 +3351,10 @@ public class CognitoService implements ResourceProvider {
return userPoolId + "::" + identifier;
}
+ private String identityProviderKey(String userPoolId, String providerName) {
+ return userPoolId + "::" + providerName;
+ }
+
private String escapeJson(String value) {
return value
.replace("\\", "\\\\")
diff --git a/src/main/java/io/github/hectorvent/floci/services/cognito/model/IdentityProvider.java b/src/main/java/io/github/hectorvent/floci/services/cognito/model/IdentityProvider.java
new file mode 100644
index 0000000000..bba409ab24
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/cognito/model/IdentityProvider.java
@@ -0,0 +1,52 @@
+package io.github.hectorvent.floci.services.cognito.model;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import io.quarkus.runtime.annotations.RegisterForReflection;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+@RegisterForReflection
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class IdentityProvider {
+ private String userPoolId;
+ private String providerName;
+ private String providerType;
+ private Map<String, String> providerDetails = new LinkedHashMap<>();
+ private Map<String, String> attributeMapping = new LinkedHashMap<>();
+ private List<String> idpIdentifiers = new ArrayList<>();
+ private long creationDate;
+ private long lastModifiedDate;
+
+ public IdentityProvider() {
+ long now = System.currentTimeMillis() / 1000L;
+ this.creationDate = now;
+ this.lastModifiedDate = now;
+ }
+
+ public String getUserPoolId() { return userPoolId; }
+ public void setUserPoolId(String userPoolId) { this.userPoolId = userPoolId; }
+
+ public String getProviderName() { return providerName; }
+ public void setProviderName(String providerName) { this.providerName = providerName; }
+
+ public String getProviderType() { return providerType; }
+ public void setProviderType(String providerType) { this.providerType = providerType; }
+
+ public Map<String, String> getProviderDetails() { return providerDetails; }
+ public void setProviderDetails(Map<String, String> providerDetails) { this.providerDetails = providerDetails; }
+
+ public Map<String, String> getAttributeMapping() { return attributeMapping; }
+ public void setAttributeMapping(Map<String, String> attributeMapping) { this.attributeMapping = attributeMapping; }
+
+ public List<String> getIdpIdentifiers() { return idpIdentifiers; }
+ public void setIdpIdentifiers(List<String> idpIdentifiers) { this.idpIdentifiers = idpIdentifiers; }
+
+ public long getCreationDate() { return creationDate; }
+ public void setCreationDate(long creationDate) { this.creationDate = creationDate; }
+
+ public long getLastModifiedDate() { return lastModifiedDate; }
+ public void setLastModifiedDate(long lastModifiedDate) { this.lastModifiedDate = lastModifiedDate; }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoIdentityProviderIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoIdentityProviderIntegrationTest.java
new file mode 100644
index 0000000000..27b88799e3
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoIdentityProviderIntegrationTest.java
@@ -0,0 +1,462 @@
+package io.github.hectorvent.floci.services.cognito;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;
+import io.quarkus.test.junit.QuarkusTest;
+import java.util.concurrent.CyclicBarrier;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+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 static io.github.hectorvent.floci.services.cognito.CognitoRestAssuredUtils.cognitoAction;
+import static io.github.hectorvent.floci.services.cognito.CognitoRestAssuredUtils.cognitoJson;
+import static org.hamcrest.Matchers.equalTo;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * Covers CreateIdentityProvider/DescribeIdentityProvider/ListIdentityProviders/
+ * UpdateIdentityProvider/DeleteIdentityProvider.
+ *
+ * <p>The response and update semantics asserted here were measured against the live
+ * Cognito API; they are not derivable from the API reference. In particular
+ * {@code IdpIdentifiers} is echoed by create and update only when the request supplied
+ * the member, and members a request omits are preserved rather than cleared.
+ */
+@QuarkusTest
+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+class CognitoIdentityProviderIntegrationTest {
+
+ private static String poolId;
+
+ private static final String OIDC_DETAILS = """
+ {
+ "client_id": "idp-test-client",
+ "client_secret": "idp-test-secret",
+ "attributes_request_method": "GET",
+ "oidc_issuer": "https://issuer.example.com",
+ "authorize_scopes": "openid"
+ }
+ """;
+
+ @BeforeAll
+ static void configureRestAssured() {
+ RestAssuredJsonUtils.configureAwsContentTypes();
+ }
+
+ @Test
+ @Order(1)
+ void createPool() throws Exception {
+ JsonNode response = cognitoJson("CreateUserPool", """
+ {
+ "PoolName": "IdentityProviderTestPool"
+ }
+ """);
+ poolId = response.path("UserPool").path("Id").asText();
+ }
+
+ @Test
+ @Order(2)
+ void createRejectsUnknownProviderType() {
+ cognitoAction("CreateIdentityProvider", """
+ {
+ "UserPoolId": "%s",
+ "ProviderName": "Bogus",
+ "ProviderType": "NotARealType",
+ "ProviderDetails": {"client_id": "x"}
+ }
+ """.formatted(poolId))
+ .then()
+ .statusCode(400)
+ .body("__type", equalTo("InvalidParameterException"))
+ .body("message", equalTo(
+ "1 validation error detected: Value 'NotARealType' at 'providerType' failed to "
+ + "satisfy constraint: Member must satisfy enum value set: "
+ + "[Facebook, SAML, SignInWithApple, LoginWithAmazon, OIDC, Google]"));
+ }
+
+ @Test
+ @Order(3)
+ void createDefaultsAttributeMappingAndOmitsIdpIdentifiers() throws Exception {
+ JsonNode provider = cognitoJson("CreateIdentityProvider", """
+ {
+ "UserPoolId": "%s",
+ "ProviderName": "TestOidc",
+ "ProviderType": "OIDC",
+ "ProviderDetails": %s
+ }
+ """.formatted(poolId, OIDC_DETAILS)).path("IdentityProvider");
+
+ assertEquals("TestOidc", provider.path("ProviderName").asText());
+ assertEquals("OIDC", provider.path("ProviderType").asText());
+ assertEquals("idp-test-client", provider.path("ProviderDetails").path("client_id").asText());
+ assertEquals("sub", provider.path("AttributeMapping").path("username").asText());
+ assertEquals(1, provider.path("AttributeMapping").size());
+ assertTrue(provider.path("IdpIdentifiers").isMissingNode(),
+ "AWS omits IdpIdentifiers from a create response that did not supply it");
+ }
+
+ @Test
+ @Order(4)
+ void describeAlwaysReturnsIdpIdentifiers() throws Exception {
+ JsonNode provider = cognitoJson("DescribeIdentityProvider", """
+ {
+ "UserPoolId": "%s",
+ "ProviderName": "TestOidc"
+ }
+ """.formatted(poolId)).path("IdentityProvider");
+
+ assertTrue(provider.path("IdpIdentifiers").isArray(),
+ "Describe returns IdpIdentifiers even when it is empty");
+ assertEquals(0, provider.path("IdpIdentifiers").size());
+ assertEquals(poolId, provider.path("UserPoolId").asText());
+ }
+
+ @Test
+ @Order(5)
+ void createRejectsDuplicateProviderName() {
+ cognitoAction("CreateIdentityProvider", """
+ {
+ "UserPoolId": "%s",
+ "ProviderName": "TestOidc",
+ "ProviderType": "OIDC",
+ "ProviderDetails": %s
+ }
+ """.formatted(poolId, OIDC_DETAILS))
+ .then()
+ .statusCode(400)
+ .body("__type", equalTo("DuplicateProviderException"))
+ .body("message", equalTo("TestOidc already exists for tenant " + poolId + "."));
+ }
+
+ @Test
+ @Order(6)
+ void createEchoesIdpIdentifiersWhenSupplied() throws Exception {
+ JsonNode provider = cognitoJson("CreateIdentityProvider", """
+ {
+ "UserPoolId": "%s",
+ "ProviderName": "TestOidcAliased",
+ "ProviderType": "OIDC",
+ "ProviderDetails": %s,
+ "AttributeMapping": {"email": "email", "username": "sub"},
+ "IdpIdentifiers": ["alias-keep"]
+ }
+ """.formatted(poolId, OIDC_DETAILS)).path("IdentityProvider");
+
+ assertEquals(1, provider.path("IdpIdentifiers").size());
+ assertEquals("alias-keep", provider.path("IdpIdentifiers").get(0).asText());
+ assertEquals("email", provider.path("AttributeMapping").path("email").asText());
+ }
+
+ @Test
+ @Order(7)
+ void updateOmittingMembersPreservesThem() throws Exception {
+ JsonNode updated = cognitoJson("UpdateIdentityProvider", """
+ {
+ "UserPoolId": "%s",
+ "ProviderName": "TestOidcAliased",
+ "ProviderDetails": %s
+ }
+ """.formatted(poolId, OIDC_DETAILS)).path("IdentityProvider");
+
+ assertTrue(updated.path("IdpIdentifiers").isMissingNode(),
+ "the update response omits IdpIdentifiers regardless of the stored value");
+
+ JsonNode described = cognitoJson("DescribeIdentityProvider", """
+ {
+ "UserPoolId": "%s",
+ "ProviderName": "TestOidcAliased"
+ }
+ """.formatted(poolId)).path("IdentityProvider");
+
+ assertEquals(1, described.path("IdpIdentifiers").size(),
+ "omitting IdpIdentifiers preserves the stored value");
+ assertEquals("alias-keep", described.path("IdpIdentifiers").get(0).asText());
+ assertEquals("email", described.path("AttributeMapping").path("email").asText());
+ }
+
+ @Test
+ @Order(8)
+ void updateWithEmptyCollectionsClearsThem() throws Exception {
+ JsonNode updated = cognitoJson("UpdateIdentityProvider", """
+ {
+ "UserPoolId": "%s",
+ "ProviderName": "TestOidcAliased",
+ "ProviderDetails": %s,
+ "AttributeMapping": {},
+ "IdpIdentifiers": []
+ }
+ """.formatted(poolId, OIDC_DETAILS)).path("IdentityProvider");
+
+ assertTrue(updated.path("IdpIdentifiers").isArray(),
+ "a supplied IdpIdentifiers member is echoed even when empty");
+ assertEquals(0, updated.path("IdpIdentifiers").size());
+ assertEquals(0, updated.path("AttributeMapping").size());
+
+ JsonNode described = cognitoJson("DescribeIdentityProvider", """
+ {
+ "UserPoolId": "%s",
+ "ProviderName": "TestOidcAliased"
+ }
+ """.formatted(poolId)).path("IdentityProvider");
+
+ assertEquals(0, described.path("AttributeMapping").size());
+ assertEquals(0, described.path("IdpIdentifiers").size());
+ }
+
+ @Test
+ @Order(9)
+ void listReturnsSummariesWithoutProviderDetails() throws Exception {
+ JsonNode providers = cognitoJson("ListIdentityProviders", """
+ {
+ "UserPoolId": "%s"
+ }
+ """.formatted(poolId)).path("Providers");
+
+ assertEquals(2, providers.size());
+ for (JsonNode provider : providers) {
+ assertTrue(provider.hasNonNull("ProviderName"));
+ assertTrue(provider.hasNonNull("ProviderType"));
+ assertTrue(provider.hasNonNull("CreationDate"));
+ assertTrue(provider.hasNonNull("LastModifiedDate"));
+ assertFalse(provider.has("ProviderDetails"),
+ "ListIdentityProviders returns summaries only, never provider credentials");
+ assertFalse(provider.has("AttributeMapping"));
+ }
+ }
+
+ @Test
+ @Order(10)
+ void describeAndUpdateReportMissingProvidersDifferently() {
+ cognitoAction("DescribeIdentityProvider", """
+ {
+ "UserPoolId": "%s",
+ "ProviderName": "NoSuchProvider"
+ }
+ """.formatted(poolId))
+ .then()
+ .statusCode(400)
+ .body("__type", equalTo("ResourceNotFoundException"))
+ .body("message", equalTo(
+ "Identity provider NoSuchProvider for tenantId " + poolId + " does not exist."));
+
+ cognitoAction("UpdateIdentityProvider", """
+ {
+ "UserPoolId": "%s",
+ "ProviderName": "NoSuchProvider",
+ "ProviderDetails": %s
+ }
+ """.formatted(poolId, OIDC_DETAILS))
+ .then()
+ .statusCode(400)
+ .body("__type", equalTo("ResourceNotFoundException"))
+ .body("message", equalTo(
+ "Identity provider NoSuchProvider in User Pool " + poolId + " does not exist."));
+ }
+
+ @Test
+ @Order(11)
+ void deleteRemovesProviderAndIsNotIdempotent() throws Exception {
+ cognitoAction("DeleteIdentityProvider", """
+ {
+ "UserPoolId": "%s",
+ "ProviderName": "TestOidcAliased"
+ }
+ """.formatted(poolId))
+ .then()
+ .statusCode(200);
+
+ cognitoAction("DeleteIdentityProvider", """
+ {
+ "UserPoolId": "%s",
+ "ProviderName": "TestOidcAliased"
+ }
+ """.formatted(poolId))
+ .then()
+ .statusCode(400)
+ .body("__type", equalTo("ResourceNotFoundException"));
+
+ cognitoAction("DeleteIdentityProvider", """
+ {
+ "UserPoolId": "%s",
+ "ProviderName": "TestOidc"
+ }
+ """.formatted(poolId))
+ .then()
+ .statusCode(200);
+
+ assertEquals(0, cognitoJson("ListIdentityProviders", """
+ {
+ "UserPoolId": "%s"
+ }
+ """.formatted(poolId)).path("Providers").size());
+ }
+
+ /**
+ * A pool recreated on a pinned id must not inherit the dead pool's providers: their
+ * ProviderDetails carry the client_secret.
+ */
+ @Test
+ @Order(12)
+ void deletingAPoolRemovesItsIdentityProviders() throws Exception {
+ String pinnedId = "us-east-1_idporph1";
+ cognitoAction("CreateUserPool", """
+ {
+ "PoolName": "IdpOrphanPool",
+ "UserPoolTags": {"floci:override-id": "%s"}
+ }
+ """.formatted(pinnedId))
+ .then()
+ .statusCode(200);
+
+ cognitoAction("CreateIdentityProvider", """
+ {
+ "UserPoolId": "%s",
+ "ProviderName": "OrphanOidc",
+ "ProviderType": "OIDC",
+ "ProviderDetails": %s
+ }
+ """.formatted(pinnedId, OIDC_DETAILS))
+ .then()
+ .statusCode(200);
+
+ cognitoAction("DeleteUserPool", """
+ {
+ "UserPoolId": "%s"
+ }
+ """.formatted(pinnedId))
+ .then()
+ .statusCode(200);
+
+ cognitoAction("CreateUserPool", """
+ {
+ "PoolName": "IdpOrphanPoolAgain",
+ "UserPoolTags": {"floci:override-id": "%s"}
+ }
+ """.formatted(pinnedId))
+ .then()
+ .statusCode(200);
+
+ assertEquals(0, cognitoJson("ListIdentityProviders", """
+ {
+ "UserPoolId": "%s"
+ }
+ """.formatted(pinnedId)).path("Providers").size(),
+ "a recreated pool must not inherit the deleted pool's providers");
+
+ cognitoAction("DeleteUserPool", """
+ {
+ "UserPoolId": "%s"
+ }
+ """.formatted(pinnedId))
+ .then()
+ .statusCode(200);
+ }
+
+ /**
+ * Two overlapping updates that touch different optional members must both survive.
+ *
+ * <p>Update is a read-modify-write: it copies the stored provider, applies only the
+ * members the request supplied and writes the whole record back. Without a lock both
+ * callers copy the same base, so the later write restores the other's omitted members
+ * to their stale values and silently drops an update.
+ *
+ * <p>Measured against live Cognito in ap-southeast-1: an update that omits
+ * {@code AttributeMapping} and {@code IdpIdentifiers} leaves both intact, so the
+ * service merges, and it does so atomically. Reverting the lock in
+ * {@code CognitoService.updateIdentityProvider} makes this test fail.
+ */
+ @Test
+ @Order(13)
+ void concurrentUpdatesOfDifferentMembersBothSurvive() throws Exception {
+ String racePool = cognitoJson("CreateUserPool", """
+ {
+ "PoolName": "idp-concurrency-pool"
+ }
+ """).path("UserPool").path("Id").asText();
+
+ cognitoAction("CreateIdentityProvider", """
+ {
+ "UserPoolId": "%s",
+ "ProviderName": "RaceOidc",
+ "ProviderType": "OIDC",
+ "ProviderDetails": %s,
+ "AttributeMapping": {"username": "sub"}
+ }
+ """.formatted(racePool, OIDC_DETAILS))
+ .then()
+ .statusCode(200);
+
+ ExecutorService threads = Executors.newFixedThreadPool(2);
+ try {
+ for (int round = 0; round < 25; round++) {
+ String attribute = "email" + round;
+ String identifier = "ident" + round;
+ CyclicBarrier start = new CyclicBarrier(2);
+
+ Future<?> mappingWriter = threads.submit(() -> {
+ start.await();
+ return cognitoAction("UpdateIdentityProvider", """
+ {
+ "UserPoolId": "%s",
+ "ProviderName": "RaceOidc",
+ "AttributeMapping": {"username": "sub", "%s": "%s"}
+ }
+ """.formatted(racePool, attribute, attribute));
+ });
+ Future<?> identifierWriter = threads.submit(() -> {
+ start.await();
+ return cognitoAction("UpdateIdentityProvider", """
+ {
+ "UserPoolId": "%s",
+ "ProviderName": "RaceOidc",
+ "IdpIdentifiers": ["%s"]
+ }
+ """.formatted(racePool, identifier));
+ });
+ mappingWriter.get(30, TimeUnit.SECONDS);
+ identifierWriter.get(30, TimeUnit.SECONDS);
+
+ JsonNode described = cognitoJson("DescribeIdentityProvider", """
+ {
+ "UserPoolId": "%s",
+ "ProviderName": "RaceOidc"
+ }
+ """.formatted(racePool)).path("IdentityProvider");
+
+ assertTrue(described.path("AttributeMapping").has(attribute),
+ "round " + round + ": the concurrent IdpIdentifiers update discarded "
+ + "the AttributeMapping write");
+ assertEquals(identifier, described.path("IdpIdentifiers").path(0).asText(),
+ "round " + round + ": the concurrent AttributeMapping update discarded "
+ + "the IdpIdentifiers write");
+ }
+ } finally {
+ threads.shutdownNow();
+ cognitoAction("DeleteUserPool", """
+ {
+ "UserPoolId": "%s"
+ }
+ """.formatted(racePool));
+ }
+ }
+
+ @Test
+ @Order(14)
+ void deletePool() {
+ cognitoAction("DeleteUserPool", """
+ {
+ "UserPoolId": "%s"
+ }
+ """.formatted(poolId))
+ .then()
+ .statusCode(200);
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoServiceTest.java
index 47e428031c..7725526421 100644
--- a/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoServiceTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoServiceTest.java
@@ -9,6 +9,7 @@ import io.github.hectorvent.floci.core.common.ReservedTags;
import io.github.hectorvent.floci.core.storage.InMemoryStorage;
import io.github.hectorvent.floci.services.cognito.model.CognitoGroup;
import io.github.hectorvent.floci.services.cognito.model.CognitoUser;
+import io.github.hectorvent.floci.services.cognito.model.IdentityProvider;
import io.github.hectorvent.floci.services.cognito.model.UserPool;
import io.github.hectorvent.floci.services.cognito.model.UserPoolClient;
import io.github.hectorvent.floci.services.cognito.verification.CognitoMessageDispatcher;
@@ -1385,6 +1386,7 @@ class CognitoServiceTest {
new InMemoryStorage<>(),
new InMemoryStorage<>(),
new InMemoryStorage<>(),
+ new InMemoryStorage<>(),
"http://localhost:4566",
regionResolver,
null,
@@ -1423,6 +1425,7 @@ class CognitoServiceTest {
new InMemoryStorage<>(),
new InMemoryStorage<>(),
new InMemoryStorage<>(),
+ new InMemoryStorage<>(),
"http://localhost:4566",
regionResolver,
null,
@@ -2602,6 +2605,29 @@ class CognitoServiceTest {
}
+ @Test
+ void updateIdentityProviderDoesNotMutateAlreadyReturnedInstances() {
+ UserPool pool = service.createUserPool(Map.of("PoolName", "IdpCopyPool"), "us-east-1");
+ Map<String, String> details = Map.of(
+ "client_id", "before",
+ "client_secret", "secret",
+ "attributes_request_method", "GET",
+ "oidc_issuer", "https://issuer.example.com",
+ "authorize_scopes", "openid");
+ service.createIdentityProvider(pool.getId(), "CopyOidc", "OIDC", details, null, null);
+
+ IdentityProvider held = service.describeIdentityProvider(pool.getId(), "CopyOidc");
+
+ Map<String, String> updated = new java.util.LinkedHashMap<>(details);
+ updated.put("client_id", "after");
+ service.updateIdentityProvider(pool.getId(), "CopyOidc", updated, null, null);
+
+ assertEquals("before", held.getProviderDetails().get("client_id"),
+ "update must write a copy, not mutate the instance the store already handed out");
+ assertEquals("after",
+ service.describeIdentityProvider(pool.getId(), "CopyOidc").getProviderDetails().get("client_id"));
+ }
+
// Issue #1654: ConfirmSignUp updates verified attribute
@Nested
class ConfirmSignUpVerifiedAttributes {
@@ -2815,6 +2841,7 @@ class CognitoServiceTest {
new InMemoryStorage<>(),
new InMemoryStorage<>(),
new InMemoryStorage<>(),
+ new InMemoryStorage<>(),
"http://localhost:4566",
regionResolver,
null,