Light, fluffy, and always free - The AWS Local Emulator alternative
fix(cognito): run the PreSignUp trigger on AdminCreateUser (#5149)
jwoa9569b4d17c678f
diff --git a/docs/services/cognito.md b/docs/services/cognito.mdindex adebb5e6c9..5a4fe53743 100644--- a/docs/services/cognito.md+++ b/docs/services/cognito.md@@ -181,7 +181,7 @@ further divergences, both deliberate:| Action | Description ||--------|-------------|-| AdminCreateUser | Creates or resends setup for a user in a user pool. |+| AdminCreateUser | Creates or resends setup for a user in a user pool. Creating a user invokes the pre sign-up trigger with triggerSource `PreSignUp_AdminCreateUser`, the request's `ValidationData` and `ClientMetadata`, and `callerContext.clientId` `CLIENT_ID_NOT_APPLICABLE`. A trigger error refuses the user with `UserLambdaValidationException`, and its `autoConfirmUser`, `autoVerifyEmail` and `autoVerifyPhone` are ignored, as on AWS. || AdminGetUser | Returns a user's stored attributes and status. || AdminDeleteUser | Deletes a user from a user pool. An API Gateway Cognito authorizer rejects the user's existing tokens afterwards. || AdminSetUserPassword | Sets a user's password and permanent-password status. |diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/CognitoUserPoolUserCfnProvisioner.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/CognitoUserPoolUserCfnProvisioner.javaindex 8e65a63ba1..56ca8bec78 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/CognitoUserPoolUserCfnProvisioner.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/CognitoUserPoolUserCfnProvisioner.java@@ -76,9 +76,9 @@ public class CognitoUserPoolUserCfnProvisioner implements CfnResourceProvisionerfor (JsonNode attribute : resolved.path("UserAttributes")) {userAttributes.put(attribute.path("Name").asText(), attribute.path("Value").asText());}- // DesiredDeliveryMediums, ValidationData and ClientMetadata only reach a message transport- // or a Lambda trigger, neither of which AdminCreateUser drives here, so they only take part- // in the createOnly record.+ // DesiredDeliveryMediums only reaches a message transport, which AdminCreateUser does not+ // drive here. ValidationData and ClientMetadata are not passed to the PreSignUp trigger,+ // which sees empty maps. All three only take part in the createOnly record.String name = customNamed ? username : ctx.generatePhysicalName(r.getLogicalId(), 128, false);String messageAction = text(resolved, "MessageAction");if ("RESEND".equalsIgnoreCase(messageAction)) {diff --git a/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoAuthFlowHandler.java b/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoAuthFlowHandler.javaindex 0a53da69a7..4d632ef257 100644--- a/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoAuthFlowHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoAuthFlowHandler.java@@ -52,6 +52,8 @@ final class CognitoAuthFlowHandler {private static final Logger LOG = Logger.getLogger(CognitoAuthFlowHandler.class);private static final ObjectMapper MAPPER = new ObjectMapper();private static final String CUSTOM_MESSAGE_CODE_PARAMETER = "{####}";+ /** The {@code callerContext.clientId} AWS sends for an admin action, which names no app client. */+ private static final String CLIENT_ID_NOT_APPLICABLE = "CLIENT_ID_NOT_APPLICABLE";/** The message of a wrong password, which managed login also shows for an unknown user. */static final String INCORRECT_CREDENTIALS = "Incorrect username or password";static final int MAX_USER_AUTH_SESSIONS_PER_PARTITION = 4_096;@@ -1538,7 +1540,7 @@ final class CognitoAuthFlowHandler {event.put("userName", user == null ? null : user.getUsername());event.put("callerContext", Map.of("awsSdkVersion", "floci",- "clientId", client.getClientId()));+ "clientId", client == null ? CLIENT_ID_NOT_APPLICABLE : client.getClientId()));event.put("triggerSource", triggerSource);Map<String, Object> req = new HashMap<>(request);if (user != null) {@@ -1703,6 +1705,28 @@ final class CognitoAuthFlowHandler {Boolean.TRUE.equals(resp.get("autoVerifyPhone")));}+ /**+ * Fires PreSignUp with triggerSource {@code PreSignUp_AdminCreateUser}. AWS ignores+ * {@code autoConfirmUser}, {@code autoVerifyEmail} and {@code autoVerifyPhone} for this+ * source, so the response is discarded and only a failure changes the outcome.+ */+ void firePreSignUpForAdminCreateUser(UserPool pool, CognitoUser user,+ Map<String, String> validationData,+ Map<String, String> clientMetadata) {+ Map<String, Object> req = new HashMap<>();+ req.put("validationData", validationData == null ? Map.of() : validationData);+ req.put("clientMetadata", clientMetadata == null ? Map.of() : clientMetadata);+ TriggerResult result = invokeTrigger(pool, null, user, "PreSignUp", "PreSignUp_AdminCreateUser", req);+ if (!result.errored()) {+ return;+ }+ if (result.errorKind() == TriggerErrorKind.USER_VALIDATION) {+ throw new AwsException("UserLambdaValidationException",+ "PreSignUp failed with error " + result.errorMessage() + ".", 400);+ }+ throw triggerFailure(result, "PreSignUp");+ }+/*** Fires the CustomMessage trigger, if configured, so the function can override the* subject/body Cognito would otherwise deliver. Non-blocking: an unconfigured ordiff --git a/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoJsonHandler.java b/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoJsonHandler.javaindex 2f162518fc..b05ac041c3 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@@ -611,6 +611,10 @@ public class CognitoJsonHandler {: request.path("TemporaryPassword").asText(null);String messageAction = request.path("MessageAction").isMissingNode() ? null: request.path("MessageAction").asText(null);+ Map<String, String> validationData = new HashMap<>();+ request.path("ValidationData").forEach(a -> validationData.put(a.path("Name").asText(), a.path("Value").asText()));+ Map<String, String> clientMetadata = new HashMap<>();+ request.path("ClientMetadata").fields().forEachRemaining(e -> clientMetadata.put(e.getKey(), e.getValue().asText()));CognitoUser user = service.adminCreateUser(request.path("UserPoolId").asText(),@@ -618,7 +622,9 @@ public class CognitoJsonHandler {attrs,tempPassword,messageAction,- request.path("ForceAliasCreation").asBoolean(false)+ request.path("ForceAliasCreation").asBoolean(false),+ validationData,+ clientMetadata);ObjectNode response = objectMapper.createObjectNode();response.set("User", userToNode(user));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.javaindex 1b10d799d5..5c3696c716 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@@ -79,6 +79,7 @@ import java.util.Map;import java.util.Optional;import java.util.Set;import java.util.UUID;+import java.util.concurrent.ConcurrentHashMap;import java.util.regex.Pattern;import static io.github.hectorvent.floci.core.common.ReservedTags.rejectUnknownReservedTags;@@ -148,6 +149,10 @@ public class CognitoService implements ResourceProvider {private final CognitoMessageDispatcher messageDispatcher;private final TlsCertificateManager certificateManager;private final Object[] userLocks = newUserLockStripes();+ // The userKey of each username an AdminCreateUser is creating, from before its existence check+ // until it stores the user or fails, so an overlapping request for the same username is refused+ // instead of invoking the PreSignUp trigger again. Only the request that adds a key removes it.+ private final Set<String> adminCreatesInFlight = ConcurrentHashMap.newKeySet();// Keyed by session token; contains SRP ephemeral state (bPrivate, B, A, secretBlock)private final CognitoAuthFlowHandler authFlowHandler;@@ -2022,78 +2027,124 @@ public class CognitoService implements ResourceProvider {String temporaryPassword,String messageAction,boolean forceAliasCreation) {- // Locked on the requested username/alias (not yet resolved to a canonical id, since- // an alias pool doesn't have one until creation), so two concurrent requests for the- // same identifier can't both pass the existence/alias check and create duplicates.- synchronized (userLock(userPoolId, username)) {- return adminCreateUserUnderUserLock(userPoolId, username, attributes,- temporaryPassword, messageAction, forceAliasCreation);- }+ return adminCreateUser(userPoolId, username, attributes, temporaryPassword, messageAction,+ forceAliasCreation, Map.of(), Map.of());}- private CognitoUser adminCreateUserUnderUserLock(String userPoolId,+ /**+ * AdminCreateUser with the request's {@code ValidationData} and {@code ClientMetadata}, which+ * reach only the PreSignUp trigger and are never stored.+ */+ public CognitoUser adminCreateUser(String userPoolId,String username,Map<String, String> attributes,String temporaryPassword,String messageAction,- boolean forceAliasCreation) {+ boolean forceAliasCreation,+ Map<String, String> validationData,+ Map<String, String> clientMetadata) {+ // Locked on the requested username/alias (not yet resolved to a canonical id, since+ // an alias pool doesn't have one until creation), so two concurrent requests for the+ // same identifier can't both pass the existence/alias check and create duplicates.+ Object lock = userLock(userPoolId, username);+ if ("RESEND".equalsIgnoreCase(messageAction)) {+ synchronized (lock) {+ return resendInvitationUnderUserLock(userPoolId, username);+ }+ }++ // The PreSignUp trigger runs with no lock held: its function can call back into the pool,+ // and a call that needs the same lock stripe would wait until the invocation timed out.+ // A taken username or alias is refused before the trigger sees the request, and checked+ // again under the lock once the trigger accepts, since users can change while it runs.UserPool pool = describeUserPool(userPoolId);- boolean resend = "RESEND".equalsIgnoreCase(messageAction);- boolean aliasPool = usesAliasUsernames(pool);+ // Claimed before the username is checked, so an overlapping request for it is refused here+ // rather than passing the check while this one is in its trigger and invoking the trigger+ // again. That includes a function calling back for the username it was given.+ String inFlightKey = userKey(userPoolId, username);+ if (!adminCreatesInFlight.add(inFlightKey)) {+ throw new AwsException("UsernameExistsException", "User already exists", 400);+ }+ try {+ aliasHolderToMove(pool, username, forceAliasCreation);+ CognitoUser user = newAdminCreatedUser(pool, username, attributes, temporaryPassword);- Map<String, String> resolvedAttributes = attributes == null- ? new HashMap<>() : new HashMap<>(attributes);+ // Before anything is stored, so a trigger that refuses the user leaves the pool unchanged,+ // including the alias a ForceAliasCreation request would move.+ authFlowHandler.firePreSignUpForAdminCreateUser(pool, user, validationData, clientMetadata);++ synchronized (lock) {+ return storeAdminCreatedUserUnderUserLock(userPoolId, username, forceAliasCreation, user);+ }+ } finally {+ adminCreatesInFlight.remove(inFlightKey);+ }+ }+ private CognitoUser resendInvitationUnderUserLock(String userPoolId, String username) {+ UserPool pool = describeUserPool(userPoolId);CognitoUser existing = userStore.get(userKey(userPoolId, username)).orElse(null);+ if (usesAliasUsernames(pool) && existing == null) {+ existing = findUserByAlias(userPoolId, aliasAttributeForValue(pool, username), username);+ }+ if (existing == null) {+ throw new AwsException("UserNotFoundException", "User not found", 400);+ }+ if (!"FORCE_CHANGE_PASSWORD".equals(existing.getUserStatus())) {+ final String userStateExceptionMessage = """+ User is in %s state and cannot be resent an invitation.+ """.formatted(existing.getUserStatus());+ throw new AwsException("UnsupportedUserStateException", userStateExceptionMessage, 400);+ }+ existing.setLastModifiedDate(System.currentTimeMillis() / 1000L);+ userStore.put(userKey(userPoolId, existing.getUsername()), existing);+ LOG.infov("Resent invitation for user {0} in pool {1}", existing.getUsername(), userPoolId);+ return existing;+ }++ /**+ * The user whose verified alias an AdminCreateUser for {@code username} moves to the new user,+ * or null when no user has that username or alias. Throws when one does and the request+ * cannot take it: {@code UsernameExistsException} for a username or an unverified alias, and+ * {@code AliasExistsException} for a verified alias without ForceAliasCreation.+ */+ private CognitoUser aliasHolderToMove(UserPool pool, String username, boolean forceAliasCreation) {+ CognitoUser existing = userStore.get(userKey(pool.getId(), username)).orElse(null);String aliasAttribute = null;- if (aliasPool && existing == null) {+ if (usesAliasUsernames(pool) && existing == null) {aliasAttribute = aliasAttributeForValue(pool, username);- existing = findUserByAlias(userPoolId, aliasAttribute, username);+ existing = findUserByAlias(pool.getId(), aliasAttribute, username);}-- if (resend) {- if (existing == null) {- throw new AwsException("UserNotFoundException", "User not found", 400);- }- if (!"FORCE_CHANGE_PASSWORD".equals(existing.getUserStatus())) {- final String userStateExceptionMessage = """- User is in %s state and cannot be resent an invitation.- """.formatted(existing.getUserStatus());- throw new AwsException("UnsupportedUserStateException", userStateExceptionMessage, 400);- }- existing.setLastModifiedDate(System.currentTimeMillis() / 1000L);- userStore.put(userKey(userPoolId, existing.getUsername()), existing);- LOG.infov("Resent invitation for user {0} in pool {1}", existing.getUsername(), userPoolId);- return existing;+ if (existing == null) {+ return null;}-- if (existing != null) {- boolean existingAliasVerified = aliasAttribute != null- && "true".equalsIgnoreCase(existing.getAttributes().get(aliasAttribute + "_verified"));- if (existingAliasVerified) {- if (!forceAliasCreation) {- throw new AwsException("AliasExistsException",- "An account with the given " + aliasAttribute + " already exists.", 400);- }- existing.getAttributes().remove(aliasAttribute);- existing.getAttributes().put(aliasAttribute + "_verified", "false");- existing.setLastModifiedDate(System.currentTimeMillis() / 1000L);- userStore.put(userKey(userPoolId, existing.getUsername()), existing);- } else {- throw new AwsException("UsernameExistsException", "User already exists", 400);- }+ boolean existingAliasVerified = aliasAttribute != null+ && "true".equalsIgnoreCase(existing.getAttributes().get(aliasAttribute + "_verified"));+ if (!existingAliasVerified) {+ throw new AwsException("UsernameExistsException", "User already exists", 400);+ }+ if (!forceAliasCreation) {+ throw new AwsException("AliasExistsException",+ "An account with the given " + aliasAttribute + " already exists.", 400);}+ return existing;+ }++ private CognitoUser newAdminCreatedUser(UserPool pool, String username, Map<String, String> attributes,+ String temporaryPassword) {+ Map<String, String> resolvedAttributes = attributes == null+ ? new HashMap<>() : new HashMap<>(attributes);String canonicalUsername = username;- if (aliasPool) {- resolvedAttributes.put(aliasAttribute, username);+ if (usesAliasUsernames(pool)) {+ resolvedAttributes.put(aliasAttributeForValue(pool, username), username);canonicalUsername = UUID.randomUUID().toString();resolvedAttributes.put("sub", canonicalUsername);}CognitoUser user = new CognitoUser();user.setUsername(canonicalUsername);- user.setUserPoolId(userPoolId);+ user.setUserPoolId(pool.getId());user.getAttributes().putAll(resolvedAttributes);// Ensure sub attribute is present@@ -2106,9 +2157,27 @@ public class CognitoService implements ResourceProvider {user.setTemporaryPassword(true);user.setUserStatus("FORCE_CHANGE_PASSWORD");}+ return user;+ }++ private CognitoUser storeAdminCreatedUserUnderUserLock(String userPoolId, String username,+ boolean forceAliasCreation, CognitoUser user) {+ // Read again under the lock rather than reused from before the trigger: while it ran, the+ // pool may have been deleted, another request may have taken the username or alias, and+ // the alias holder may have been updated or deleted, which writing back an earlier read+ // would undo.+ UserPool pool = describeUserPool(userPoolId);+ CognitoUser aliasHolder = aliasHolderToMove(pool, username, forceAliasCreation);+ if (aliasHolder != null) {+ String aliasAttribute = aliasAttributeForValue(pool, username);+ aliasHolder.getAttributes().remove(aliasAttribute);+ aliasHolder.getAttributes().put(aliasAttribute + "_verified", "false");+ aliasHolder.setLastModifiedDate(System.currentTimeMillis() / 1000L);+ userStore.put(userKey(userPoolId, aliasHolder.getUsername()), aliasHolder);+ }- userStore.put(userKey(userPoolId, canonicalUsername), user);- LOG.infov("Created user {0} in pool {1}", canonicalUsername, userPoolId);+ userStore.put(userKey(userPoolId, user.getUsername()), user);+ LOG.infov("Created user {0} in pool {1}", user.getUsername(), userPoolId);return user;}diff --git a/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoLambdaTriggersTest.java b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoLambdaTriggersTest.javaindex b8e64ea0ee..782758b10f 100644--- a/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoLambdaTriggersTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoLambdaTriggersTest.java@@ -1,7 +1,9 @@package io.github.hectorvent.floci.services.cognito;import com.fasterxml.jackson.core.type.TypeReference;+import com.fasterxml.jackson.databind.JsonNode;import com.fasterxml.jackson.databind.ObjectMapper;+import com.fasterxml.jackson.databind.node.ObjectNode;import io.github.hectorvent.floci.config.TlsCertificateManager;import io.github.hectorvent.floci.core.common.AwsException;import io.github.hectorvent.floci.core.common.RegionResolver;@@ -27,7 +29,9 @@ import org.junit.jupiter.params.ParameterizedTest;import org.junit.jupiter.params.provider.NullAndEmptySource;import org.junit.jupiter.params.provider.ValueSource;import org.mockito.ArgumentCaptor;+import org.mockito.invocation.InvocationOnMock;+import java.io.IOException;import java.nio.charset.StandardCharsets;import java.time.Duration;import java.util.Base64;@@ -35,15 +39,26 @@ import java.util.HashMap;import java.util.List;import java.util.Map;import java.util.Set;+import java.util.concurrent.Callable;+import java.util.concurrent.CopyOnWriteArrayList;+import java.util.concurrent.CountDownLatch;+import java.util.concurrent.ExecutionException;+import java.util.concurrent.ExecutorService;+import java.util.concurrent.Executors;+import java.util.concurrent.Future;+import java.util.concurrent.TimeUnit;+import java.util.concurrent.atomic.AtomicReference;import javax.crypto.Mac;import javax.crypto.spec.SecretKeySpec;import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.assertFalse;+import static org.junit.jupiter.api.Assertions.assertInstanceOf;import static org.junit.jupiter.api.Assertions.assertNotEquals;import static org.junit.jupiter.api.Assertions.assertNotNull;import static org.junit.jupiter.api.Assertions.assertNull;import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.junit.jupiter.api.Assertions.assertTimeoutPreemptively;import static org.junit.jupiter.api.Assertions.assertTrue;import static org.mockito.ArgumentMatchers.any;import static org.mockito.ArgumentMatchers.anyString;@@ -485,6 +500,300 @@ class CognitoLambdaTriggersTest {.invoke(anyString(), anyString(), any(byte[].class), any());}+ @Test+ void preSignUpFiresOnAdminCreateUserWithValidationDataAndClientMetadata() throws Exception {+ UserPool pool = createPoolWithLambdaConfig(Map.of("PreSignUp", "arn:aws:lambda:::pre-signup"));+ when(lambdaService.invoke(anyString(), eq("arn:aws:lambda:::pre-signup"),+ any(byte[].class), eq(InvocationType.RequestResponse)))+ .thenReturn(ok(Map.of()));++ ObjectNode request = MAPPER.createObjectNode();+ request.put("UserPoolId", pool.getId());+ request.put("Username", "alice");+ request.put("MessageAction", "SUPPRESS");+ request.putArray("UserAttributes").addObject().put("Name", "email").put("Value", "[email protected]");+ request.putArray("ValidationData").addObject().put("Name", "inviteCode").put("Value", "abc123");+ request.putObject("ClientMetadata").put("source", "admin-console");+ new CognitoJsonHandler(service, MAPPER).handle("AdminCreateUser", request, "us-east-1");++ ArgumentCaptor<byte[]> payloadCaptor = ArgumentCaptor.forClass(byte[].class);+ verify(lambdaService).invoke(anyString(), eq("arn:aws:lambda:::pre-signup"),+ payloadCaptor.capture(), eq(InvocationType.RequestResponse));+ JsonNode event = MAPPER.readTree(payloadCaptor.getValue());+ assertEquals("PreSignUp_AdminCreateUser", event.path("triggerSource").asText());+ assertEquals("CLIENT_ID_NOT_APPLICABLE", event.path("callerContext").path("clientId").asText());+ assertEquals("alice", event.path("userName").asText());+ assertEquals("[email protected]", event.path("request").path("userAttributes").path("email").asText());+ assertEquals("abc123", event.path("request").path("validationData").path("inviteCode").asText());+ assertEquals("admin-console", event.path("request").path("clientMetadata").path("source").asText());+ assertFalse(service.adminGetUser(pool.getId(), "alice").getAttributes().containsKey("inviteCode"),+ "ValidationData must not be stored as a user attribute");+ }++ @Test+ void preSignUpLambdaErrorBlocksAdminCreateUser() {+ UserPool pool = createPoolWithLambdaConfig(Map.of("PreSignUp", "arn:aws:lambda:::pre-signup"));+ when(lambdaService.invoke(anyString(), eq("arn:aws:lambda:::pre-signup"),+ any(byte[].class), any()))+ .thenReturn(lambdaError("Unhandled", "Invitations are closed"));++ AwsException ex = assertThrows(AwsException.class, () ->+ service.adminCreateUser(pool.getId(), "alice",+ Map.of("email", "[email protected]"), null, "SUPPRESS"));+ assertEquals("UserLambdaValidationException", ex.getErrorCode());+ assertEquals("PreSignUp failed with error Invitations are closed.", ex.getMessage());++ AwsException lookup = assertThrows(AwsException.class, () ->+ service.adminGetUser(pool.getId(), "alice"));+ assertEquals("UserNotFoundException", lookup.getErrorCode());+ }++ @Test+ void preSignUpAutoConfirmAndVerifyResponseIsIgnoredOnAdminCreateUser() {+ // AWS ignores autoConfirmUser, autoVerifyEmail and autoVerifyPhone for PreSignUp_AdminCreateUser.+ UserPool pool = createPoolWithLambdaConfig(Map.of("PreSignUp", "arn:aws:lambda:::pre-signup"));+ when(lambdaService.invoke(anyString(), eq("arn:aws:lambda:::pre-signup"),+ any(byte[].class), any()))+ .thenReturn(ok(Map.of(+ "autoConfirmUser", true,+ "autoVerifyEmail", true,+ "autoVerifyPhone", true)));++ CognitoUser user = service.adminCreateUser(pool.getId(), "alice",+ Map.of("email", "[email protected]", "phone_number", "+15551234567"),+ "Temp1234!", "SUPPRESS");++ verify(lambdaService).invoke(anyString(), eq("arn:aws:lambda:::pre-signup"),+ any(byte[].class), eq(InvocationType.RequestResponse));+ assertEquals("FORCE_CHANGE_PASSWORD", user.getUserStatus());+ assertNull(user.getAttributes().get("email_verified"));+ assertNull(user.getAttributes().get("phone_number_verified"));+ }++ @Test+ void preSignUpLambdaErrorOnForcedAliasCreationKeepsTheExistingAlias() {+ Map<String, Object> poolRequest = new HashMap<>();+ poolRequest.put("PoolName", "alias-trigger-pool");+ poolRequest.put("UsernameAttributes", List.of("email"));+ poolRequest.put("LambdaConfig", Map.of("PreSignUp", "arn:aws:lambda:::pre-signup"));+ UserPool pool = service.createUserPool(poolRequest, "us-east-1");+ when(lambdaService.invoke(anyString(), eq("arn:aws:lambda:::pre-signup"),+ any(byte[].class), any()))+ .thenReturn(ok(Map.of()))+ .thenReturn(lambdaError("Unhandled", "Refused"));+ CognitoUser holder = service.adminCreateUser(pool.getId(), "[email protected]",+ Map.of("email_verified", "true"), null, "SUPPRESS");++ AwsException ex = assertThrows(AwsException.class, () ->+ service.adminCreateUser(pool.getId(), "[email protected]",+ Map.of("email_verified", "true"), null, "SUPPRESS", true));+ assertEquals("UserLambdaValidationException", ex.getErrorCode());++ CognitoUser after = service.adminGetUser(pool.getId(), holder.getUsername());+ assertEquals("[email protected]", after.getAttributes().get("email"));+ assertEquals("true", after.getAttributes().get("email_verified"));+ }++ @Test+ void preSignUpFunctionCallingBackForTheSameUsernameIsNotBlocked() {+ UserPool pool = createPoolWithLambdaConfig(Map.of("PreSignUp", "arn:aws:lambda:::pre-signup"));+ AtomicReference<Throwable> callbackFailure = new AtomicReference<>();+ when(lambdaService.invoke(anyString(), eq("arn:aws:lambda:::pre-signup"),+ any(byte[].class), eq(InvocationType.RequestResponse)))+ .thenAnswer(invocation -> {+ try {+ callFromFunction(() -> service.adminCreateUser(pool.getId(), "alice",+ Map.of("name", "created by the function"), null, "SUPPRESS"));+ } catch (ExecutionException e) {+ callbackFailure.set(e.getCause());+ }+ return ok(Map.of());+ })+ .thenReturn(ok(Map.of()));++ // The function's call is for the username the request is creating. It would wait out the+ // invocation if the request held that username's lock stripe while the function ran, and+ // it is refused rather than invoking the trigger a second time for the same username.+ assertTimeoutPreemptively(Duration.ofSeconds(10), () -> service.adminCreateUser(pool.getId(), "alice",+ Map.of("name", "created by the request"), null, "SUPPRESS"));++ assertEquals("UsernameExistsException",+ assertInstanceOf(AwsException.class, callbackFailure.get()).getErrorCode());+ assertEquals("created by the request",+ service.adminGetUser(pool.getId(), "alice").getAttributes().get("name"));+ verify(lambdaService).invoke(anyString(), eq("arn:aws:lambda:::pre-signup"),+ any(byte[].class), eq(InvocationType.RequestResponse));+ }++ @Test+ void overlappingAdminCreateUserForTheSameUsernameInvokesPreSignUpOnce() throws Exception {+ UserPool pool = createPoolWithLambdaConfig(Map.of("PreSignUp", "arn:aws:lambda:::pre-signup"));+ List<String> invokedFor = new CopyOnWriteArrayList<>();+ CountDownLatch firstInTrigger = new CountDownLatch(1);+ CountDownLatch releaseFirst = new CountDownLatch(1);+ when(lambdaService.invoke(anyString(), eq("arn:aws:lambda:::pre-signup"),+ any(byte[].class), eq(InvocationType.RequestResponse)))+ .thenAnswer(invocation -> {+ String request = nameAttributeOf(invocation);+ invokedFor.add(request);+ if ("first".equals(request)) {+ firstInTrigger.countDown();+ assertTrue(releaseFirst.await(10, TimeUnit.SECONDS));+ }+ return ok(Map.of());+ });++ ExecutorService firstRequest = Executors.newSingleThreadExecutor();+ try {+ Future<CognitoUser> first = firstRequest.submit(() -> service.adminCreateUser(pool.getId(), "alice",+ Map.of("name", "first"), null, "SUPPRESS"));+ assertTrue(firstInTrigger.await(10, TimeUnit.SECONDS));++ // The first request is still in its trigger, so no user named alice is stored yet.+ AwsException second = assertThrows(AwsException.class, () -> service.adminCreateUser(pool.getId(),+ "alice", Map.of("name", "second"), null, "SUPPRESS"));+ assertEquals("UsernameExistsException", second.getErrorCode());+ assertEquals("User already exists", second.getMessage());++ releaseFirst.countDown();+ assertEquals("alice", first.get(10, TimeUnit.SECONDS).getUsername());+ } finally {+ releaseFirst.countDown();+ firstRequest.shutdownNow();+ }++ assertEquals(List.of("first"), invokedFor);+ assertEquals("first", service.adminGetUser(pool.getId(), "alice").getAttributes().get("name"));+ }++ @Test+ void adminCreateUserOverlappingAFailingPreSignUpIsRefusedAndTheUsernameIsFreedAfterwards() throws Exception {+ UserPool pool = createPoolWithLambdaConfig(Map.of("PreSignUp", "arn:aws:lambda:::pre-signup"));+ List<String> invokedFor = new CopyOnWriteArrayList<>();+ CountDownLatch firstInTrigger = new CountDownLatch(1);+ CountDownLatch releaseFirst = new CountDownLatch(1);+ // The function refuses every user but the retried one, so a second request that reached it+ // would fail with the function's error instead of UsernameExistsException.+ when(lambdaService.invoke(anyString(), eq("arn:aws:lambda:::pre-signup"),+ any(byte[].class), eq(InvocationType.RequestResponse)))+ .thenAnswer(invocation -> {+ String request = nameAttributeOf(invocation);+ invokedFor.add(request);+ if ("first".equals(request)) {+ firstInTrigger.countDown();+ assertTrue(releaseFirst.await(10, TimeUnit.SECONDS));+ }+ return "retry".equals(request) ? ok(Map.of()) : lambdaError("Unhandled", "Refused");+ });++ ExecutorService firstRequest = Executors.newSingleThreadExecutor();+ try {+ Future<CognitoUser> first = firstRequest.submit(() -> service.adminCreateUser(pool.getId(), "alice",+ Map.of("name", "first"), null, "SUPPRESS"));+ assertTrue(firstInTrigger.await(10, TimeUnit.SECONDS));++ AwsException second = assertThrows(AwsException.class, () -> service.adminCreateUser(pool.getId(),+ "alice", Map.of("name", "second"), null, "SUPPRESS"));+ assertEquals("UsernameExistsException", second.getErrorCode());++ releaseFirst.countDown();+ ExecutionException firstFailure = assertThrows(ExecutionException.class,+ () -> first.get(10, TimeUnit.SECONDS));+ assertEquals("UserLambdaValidationException",+ assertInstanceOf(AwsException.class, firstFailure.getCause()).getErrorCode());+ } finally {+ releaseFirst.countDown();+ firstRequest.shutdownNow();+ }++ service.adminCreateUser(pool.getId(), "alice", Map.of("name", "retry"), null, "SUPPRESS");++ assertEquals(List.of("first", "retry"), invokedFor);+ assertEquals("retry", service.adminGetUser(pool.getId(), "alice").getAttributes().get("name"));+ }++ @Test+ void forcedAliasCreationDoesNotRestoreAHolderThePreSignUpFunctionDeleted() {+ UserPool pool = createEmailUsernamePoolWithPreSignUp();+ when(lambdaService.invoke(anyString(), eq("arn:aws:lambda:::pre-signup"),+ any(byte[].class), any()))+ .thenReturn(ok(Map.of()))+ .thenAnswer(invocation -> {+ callFromFunction(() -> {+ service.adminDeleteUser(pool.getId(), "[email protected]");+ return null;+ });+ return ok(Map.of());+ });+ CognitoUser holder = service.adminCreateUser(pool.getId(), "[email protected]",+ Map.of("email_verified", "true"), null, "SUPPRESS");++ CognitoUser created = service.adminCreateUser(pool.getId(), "[email protected]",+ Map.of("email_verified", "true"), null, "SUPPRESS", true);++ AwsException lookup = assertThrows(AwsException.class, () ->+ service.adminGetUser(pool.getId(), holder.getUsername()));+ assertEquals("UserNotFoundException", lookup.getErrorCode());+ assertEquals(created.getUsername(),+ service.adminGetUser(pool.getId(), "[email protected]").getUsername());+ }++ @Test+ void forcedAliasCreationKeepsTheEmailThePreSignUpFunctionGaveTheHolder() {+ UserPool pool = createEmailUsernamePoolWithPreSignUp();+ when(lambdaService.invoke(anyString(), eq("arn:aws:lambda:::pre-signup"),+ any(byte[].class), any()))+ .thenReturn(ok(Map.of()))+ .thenAnswer(invocation -> {+ callFromFunction(() -> {+ service.adminUpdateUserAttributes(pool.getId(), "[email protected]",+ Map.of("email", "[email protected]"));+ return null;+ });+ return ok(Map.of());+ });+ CognitoUser holder = service.adminCreateUser(pool.getId(), "[email protected]",+ Map.of("email_verified", "true"), null, "SUPPRESS");++ CognitoUser created = service.adminCreateUser(pool.getId(), "[email protected]",+ Map.of("email_verified", "true"), null, "SUPPRESS", true);++ assertEquals("[email protected]",+ service.adminGetUser(pool.getId(), holder.getUsername()).getAttributes().get("email"));+ assertEquals(created.getUsername(),+ service.adminGetUser(pool.getId(), "[email protected]").getUsername());+ }++ private UserPool createEmailUsernamePoolWithPreSignUp() {+ Map<String, Object> poolRequest = new HashMap<>();+ poolRequest.put("PoolName", "alias-trigger-pool");+ poolRequest.put("UsernameAttributes", List.of("email"));+ poolRequest.put("LambdaConfig", Map.of("PreSignUp", "arn:aws:lambda:::pre-signup"));+ return service.createUserPool(poolRequest, "us-east-1");+ }++ /**+ * Makes {@code call} the way a trigger function's SDK call reaches Floci: from another thread,+ * while the request that invoked the function waits for it to return.+ */+ private static <T> T callFromFunction(Callable<T> call) throws Exception {+ ExecutorService functionThread = Executors.newSingleThreadExecutor();+ try {+ return functionThread.submit(call).get(30, TimeUnit.SECONDS);+ } finally {+ functionThread.shutdownNow();+ }+ }++ /**+ * The {@code name} attribute of the user a trigger invocation is for, which tells the tests'+ * requests apart.+ */+ private static String nameAttributeOf(InvocationOnMock invocation) throws IOException {+ byte[] event = invocation.getArgument(2);+ return MAPPER.readTree(event).path("request").path("userAttributes").path("name").asText();+ }+// =========================================================================// PreTokenGeneration// =========================================================================