From f76c9afdc80f817a4f59ceccae0914a11eeed186 Mon Sep 17 00:00:00 2001 From: Yosi Haran Date: Fri, 20 Nov 2026 12:36:57 +0200 Subject: [PATCH 1/2] feat(auth): add enchanted link provider, template, SSO app and recovery options --- README.md | 46 ++ .../model/auth/AuthenticationInfo.java | 20 + .../com/descope/model/auth/IDPResponse.java | 12 + .../model/jwt/response/JWTResponse.java | 20 + .../magiclink/request/SignInRequest.java | 8 + .../magiclink/request/SignUpRequest.java | 8 + .../magiclink/request/UpdateEmailRequest.java | 10 + .../magiclink/request/UpdatePhoneRequest.java | 10 + .../magiclink/request/VerifyRequest.java | 6 + .../model/user/response/UserFamily.java | 19 + .../model/user/response/UserResponse.java | 51 +++ .../sdk/auth/EnchantedLinkService.java | 143 ++++++ .../sdk/auth/impl/AuthenticationsBase.java | 15 +- .../auth/impl/EnchantedLinkServiceImpl.java | 98 ++++- .../impl/EnchantedLinkServiceImplTest.java | 408 ++++++++++++++++++ 15 files changed, 860 insertions(+), 14 deletions(-) create mode 100644 src/main/java/com/descope/model/user/response/UserFamily.java diff --git a/README.md b/README.md index b12d8837..ba698d23 100644 --- a/README.md +++ b/README.md @@ -236,6 +236,25 @@ try { ``` +Sign-in and sign-up-or-in optionally take the provider to deliver the link with, the SSO application +to sign in to, and whether to send the link to the user's recovery address. Sign-up optionally takes +the provider and the message template to use. + +```java +try { + res = els.signIn(loginId, uri, null, loginOptions, "providerId", "ssoAppId", true); + res = els.signUpOrIn(loginId, uri, "providerId", "ssoAppId", false); + res = els.signUp(loginId, uri, user, signUpOptions, "providerId", "templateId"); + PhoneEnchantedLinkResponse phoneRes = + els.signInWithPhone(phoneNumber, uri, null, loginOptions, "providerId", "ssoAppId", true); + phoneRes = els.signUpOrInWithPhone(phoneNumber, uri, "providerId", "ssoAppId", false); + phoneRes = els.signUpWithPhone(phoneNumber, uri, user, signUpOptions, "providerId", "templateId"); +} catch (DescopeException de) { + // Handle the error +} + +``` + After sending the link, you must poll to receive a valid session using the `PendingRef` from the previous step. A valid session will be returned only after the user clicks the right link. @@ -271,6 +290,33 @@ try { ``` +When the link was requested with a PKCE challenge, pass the matching verifier: + +```java +try { + els.verify(token, pkceVerifier); +} catch (DescopeException de) { + // Token is invalid, handle the error +} + +``` + +To update a user's email or phone, verified by an enchanted link, pass the user's refresh token. +The provider, message template, locale and whether to fail instead of merging with another user +that already has the address are optional. + +```java +try { + EnchantedLinkResponse emailRes = els.updateUserEmail(loginId, "new@example.com", uri, refreshToken, + new UpdateOptions(true, false), null, "providerId", "templateId", "en", true); + PhoneEnchantedLinkResponse phoneRes = els.updateUserPhone(loginId, "+15555555555", uri, refreshToken, + null, null, "providerId", "templateId", "en", true); +} catch (DescopeException de) { + // Handle the error +} + +``` + The session and refresh JWTs should be returned to the caller, and passed with every request in the session. Read more on [session validation](#session-validation) ### OAuth diff --git a/src/main/java/com/descope/model/auth/AuthenticationInfo.java b/src/main/java/com/descope/model/auth/AuthenticationInfo.java index b4a5666d..fcc0daa2 100644 --- a/src/main/java/com/descope/model/auth/AuthenticationInfo.java +++ b/src/main/java/com/descope/model/auth/AuthenticationInfo.java @@ -13,8 +13,28 @@ public class AuthenticationInfo { private UserResponse user; private Boolean firstSeen; private IDPResponse idpResponse; + private Integer sessionExpiration; + private String externalToken; + private String tenantSSOID; + private String trustedDeviceJwt; + private Integer nextRefreshSeconds; + private String cookieName; + private String sessionCookieName; + private String sessionCookieDomain; + private Boolean unsavedSSO; + private String knownDeviceJwt; + /** Set only when the login went through an SSO configuration classified as authentication only. */ + private Boolean ssoAuthenticationOnly; + private Boolean userCreationDeferred; public AuthenticationInfo(Token token, Token refreshToken, UserResponse user, Boolean firstSeen) { this(token, refreshToken, user, firstSeen, null); } + + // Keeps the pre-sessionExpiration all-args constructor available to callers that use it positionally. + public AuthenticationInfo(Token token, Token refreshToken, UserResponse user, Boolean firstSeen, + IDPResponse idpResponse) { + this(token, refreshToken, user, firstSeen, idpResponse, null, null, null, null, null, null, null, null, null, + null, null, null); + } } diff --git a/src/main/java/com/descope/model/auth/IDPResponse.java b/src/main/java/com/descope/model/auth/IDPResponse.java index 60bf41e8..8a7e0fe6 100644 --- a/src/main/java/com/descope/model/auth/IDPResponse.java +++ b/src/main/java/com/descope/model/auth/IDPResponse.java @@ -13,4 +13,16 @@ public class IDPResponse { private List idpGroups; private Map idpSAMLAttributes; private Map idpOIDCClaims; + private String samlResponse; + private String samlGeneratedUser; + private String samlGeneratedRoles; + private String oidcResponse; + private String oidcGeneratedUser; + private String oidcGeneratedRoles; + + // Keeps the pre-samlResponse all-args constructor available to callers that use it positionally. + public IDPResponse(List idpGroups, Map idpSAMLAttributes, + Map idpOIDCClaims) { + this(idpGroups, idpSAMLAttributes, idpOIDCClaims, null, null, null, null, null, null); + } } diff --git a/src/main/java/com/descope/model/jwt/response/JWTResponse.java b/src/main/java/com/descope/model/jwt/response/JWTResponse.java index 763fa8c0..2408a371 100644 --- a/src/main/java/com/descope/model/jwt/response/JWTResponse.java +++ b/src/main/java/com/descope/model/jwt/response/JWTResponse.java @@ -19,6 +19,26 @@ public class JWTResponse { private UserResponse user; private Boolean firstSeen; private IDPResponse idpResponse; + private Integer sessionExpiration; + private String externalToken; + private String tenantSSOID; + private String trustedDeviceJwt; + private Integer nextRefreshSeconds; + private String cookieName; + private String sessionCookieName; + private String sessionCookieDomain; + private Boolean unsavedSSO; + private String knownDeviceJwt; + /** Set only when the login went through an SSO configuration classified as authentication only. */ + private Boolean ssoAuthenticationOnly; + private Boolean userCreationDeferred; + + // Keeps the pre-sessionExpiration all-args constructor available to callers that use it positionally. + public JWTResponse(String sessionJwt, String refreshJwt, String cookieDomain, String cookiePath, + Integer cookieMaxAge, Integer cookieExpiration, UserResponse user, Boolean firstSeen, IDPResponse idpResponse) { + this(sessionJwt, refreshJwt, cookieDomain, cookiePath, cookieMaxAge, cookieExpiration, user, firstSeen, + idpResponse, null, null, null, null, null, null, null, null, null, null, null, null); + } public JWTResponse(String sessionJwt, String refreshJwt, String cookieDomain, String cookiePath, Integer cookieMaxAge, Integer cookieExpiration, UserResponse user, Boolean firstSeen) { diff --git a/src/main/java/com/descope/model/magiclink/request/SignInRequest.java b/src/main/java/com/descope/model/magiclink/request/SignInRequest.java index 0d2caf8d..795ca024 100644 --- a/src/main/java/com/descope/model/magiclink/request/SignInRequest.java +++ b/src/main/java/com/descope/model/magiclink/request/SignInRequest.java @@ -18,4 +18,12 @@ public class SignInRequest { private String loginId; private LoginOptions loginOptions; + private String providerId; + private String ssoAppId; + private Boolean useRecovery; + + // Keeps the pre-providerId all-args constructor available to callers that use it positionally. + public SignInRequest(String uri, String loginId, LoginOptions loginOptions) { + this(uri, loginId, loginOptions, null, null, null); + } } diff --git a/src/main/java/com/descope/model/magiclink/request/SignUpRequest.java b/src/main/java/com/descope/model/magiclink/request/SignUpRequest.java index 7f72a6d1..361810aa 100644 --- a/src/main/java/com/descope/model/magiclink/request/SignUpRequest.java +++ b/src/main/java/com/descope/model/magiclink/request/SignUpRequest.java @@ -21,9 +21,17 @@ public class SignUpRequest { private String uri; private SignUpOptions loginOptions; private String phone; + private String providerId; + private String templateId; public SignUpRequest(String email, String loginId, User user, String uri, SignUpOptions loginOptions) { this(email, loginId, user, uri, loginOptions, null); } + + // Keeps the pre-providerId all-args constructor available to callers that use it positionally. + public SignUpRequest(String email, String loginId, User user, String uri, + SignUpOptions loginOptions, String phone) { + this(email, loginId, user, uri, loginOptions, phone, null, null); + } } diff --git a/src/main/java/com/descope/model/magiclink/request/UpdateEmailRequest.java b/src/main/java/com/descope/model/magiclink/request/UpdateEmailRequest.java index 2f85217c..dbd8b2fc 100644 --- a/src/main/java/com/descope/model/magiclink/request/UpdateEmailRequest.java +++ b/src/main/java/com/descope/model/magiclink/request/UpdateEmailRequest.java @@ -21,4 +21,14 @@ public class UpdateEmailRequest { private boolean addToLoginIds; private boolean onMergeUseExisting; private Map templateOptions; + private String providerId; + private String templateId; + private String locale; + private Boolean failOnConflict; + + // Keeps the pre-providerId all-args constructor available to callers that use it positionally. + public UpdateEmailRequest(String email, String loginId, String uri, boolean crossDevice, boolean addToLoginIds, + boolean onMergeUseExisting, Map templateOptions) { + this(email, loginId, uri, crossDevice, addToLoginIds, onMergeUseExisting, templateOptions, null, null, null, null); + } } diff --git a/src/main/java/com/descope/model/magiclink/request/UpdatePhoneRequest.java b/src/main/java/com/descope/model/magiclink/request/UpdatePhoneRequest.java index 1e838b1f..84f23e4f 100644 --- a/src/main/java/com/descope/model/magiclink/request/UpdatePhoneRequest.java +++ b/src/main/java/com/descope/model/magiclink/request/UpdatePhoneRequest.java @@ -21,4 +21,14 @@ public class UpdatePhoneRequest { private boolean addToLoginIds; private boolean onMergeUseExisting; private Map templateOptions; + private String providerId; + private String templateId; + private String locale; + private Boolean failOnConflict; + + // Keeps the pre-providerId all-args constructor available to callers that use it positionally. + public UpdatePhoneRequest(String phone, String loginId, String uri, boolean crossDevice, boolean addToLoginIds, + boolean onMergeUseExisting, Map templateOptions) { + this(phone, loginId, uri, crossDevice, addToLoginIds, onMergeUseExisting, templateOptions, null, null, null, null); + } } diff --git a/src/main/java/com/descope/model/magiclink/request/VerifyRequest.java b/src/main/java/com/descope/model/magiclink/request/VerifyRequest.java index 190ed4f2..aef58794 100644 --- a/src/main/java/com/descope/model/magiclink/request/VerifyRequest.java +++ b/src/main/java/com/descope/model/magiclink/request/VerifyRequest.java @@ -9,4 +9,10 @@ @AllArgsConstructor public class VerifyRequest { private String token; + private byte[] pkceVerifier; + + // Keeps the pre-pkceVerifier all-args constructor available to callers that use it positionally. + public VerifyRequest(String token) { + this(token, null); + } } diff --git a/src/main/java/com/descope/model/user/response/UserFamily.java b/src/main/java/com/descope/model/user/response/UserFamily.java new file mode 100644 index 00000000..da0815c3 --- /dev/null +++ b/src/main/java/com/descope/model/user/response/UserFamily.java @@ -0,0 +1,19 @@ +package com.descope.model.user.response; + +import java.util.List; +import java.util.Map; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +@Data +@Builder +@NoArgsConstructor +@AllArgsConstructor +public class UserFamily { + private String familyId; + private List roleNames; + private List permissions; + private Map familyScopedAttributes; +} diff --git a/src/main/java/com/descope/model/user/response/UserResponse.java b/src/main/java/com/descope/model/user/response/UserResponse.java index 1f933492..79ac35c2 100644 --- a/src/main/java/com/descope/model/user/response/UserResponse.java +++ b/src/main/java/com/descope/model/user/response/UserResponse.java @@ -1,6 +1,8 @@ package com.descope.model.user.response; import com.descope.model.auth.AssociatedTenant; +import com.fasterxml.jackson.annotation.JsonAlias; +import com.fasterxml.jackson.annotation.JsonProperty; import java.util.List; import java.util.Map; import lombok.AllArgsConstructor; @@ -40,4 +42,53 @@ public class UserResponse { * this is greater than now. */ Long tempLockExpiration; + List externalIds; + Boolean webauthn; + Boolean password; + Boolean editable; + @JsonProperty("SCIM") + Boolean scim; + Boolean push; + List permissions; + @JsonProperty("OIDC") + Boolean oidc; + Long consentExpiration; + String recoveryEmail; + Boolean verifiedRecoveryEmail; + String recoveryPhone; + Boolean verifiedRecoveryPhone; + Long modifiedTime; + /** IDs of the user's roles, in no particular order relative to roleNames. */ + List roleIds; + /** Whether the user has set up recovery codes. */ + Boolean recoveryCodes; + Boolean dependent; + List userFamilies; + /** Tenant whose SCIM connection provisioned the user, empty when none or ambiguous. */ + String scimTenantId; + /** Tenant whose SAML SSO created the user or merged its login into it, empty when none or ambiguous. */ + String samlTenantId; + /** Tenant whose OIDC SSO created the user or merged its login into it, empty when none or ambiguous. */ + String oidcTenantId; + String consentTenantId; + /** Last time the user authenticated, in unix seconds (0 when never). */ + Long lastLoginTime; + + // Keeps the pre-externalIds all-args constructor available to callers that use it positionally. + public UserResponse(String userId, List loginIds, String email, Boolean verifiedEmail, String phone, + Boolean verifiedPhone, String name, String givenName, String middleName, String familyName, + List roleNames, List userTenants, String status, String picture, Boolean test, + Long createdTime, Map customAttributes, Boolean totp, Boolean saml, + Map oauth, List ssoAppIds, String lockReason, Long tempLockExpiration) { + this(userId, loginIds, email, verifiedEmail, phone, verifiedPhone, name, givenName, middleName, familyName, + roleNames, userTenants, status, picture, test, createdTime, customAttributes, totp, saml, oauth, ssoAppIds, + lockReason, tempLockExpiration, null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null); + } + + // The server sends "OAuth"; "oauth" is still accepted. + @JsonAlias("OAuth") + public void setOAuth(Map oauth) { + this.oAuth = oauth; + } } diff --git a/src/main/java/com/descope/sdk/auth/EnchantedLinkService.java b/src/main/java/com/descope/sdk/auth/EnchantedLinkService.java index b5d9e092..3fbfd7f6 100644 --- a/src/main/java/com/descope/sdk/auth/EnchantedLinkService.java +++ b/src/main/java/com/descope/sdk/auth/EnchantedLinkService.java @@ -28,6 +28,22 @@ EnchantedLinkResponse signIn( LoginOptions loginOptions) throws DescopeException; + /** + * Use to login a user based on an enchanted link that will be sent by email. + * + * @param loginId - User login ID + * @param uri - Base URI + * @param token - when doing step-up or mfa then we need current session token + * @param loginOptions - {@link LoginOptions LoginOptions} + * @param providerId - optional ID of the provider to deliver the link with + * @param ssoAppId - optional ID of the SSO application to sign in to + * @param useRecovery - optional, send the link to the user's recovery address + * @return pendingRef, linkId and masked email + * @throws DescopeException - error upon failure + */ + EnchantedLinkResponse signIn(String loginId, String uri, String token, LoginOptions loginOptions, + String providerId, String ssoAppId, Boolean useRecovery) throws DescopeException; + /** * Use to login a user based on an enchanted link that will be sent by SMS. * @@ -45,6 +61,22 @@ PhoneEnchantedLinkResponse signInWithPhone( LoginOptions loginOptions) throws DescopeException; + /** + * Use to login a user based on an enchanted link that will be sent by SMS. + * + * @param loginId - User login ID + * @param uri - Base URI + * @param token - when doing step-up or mfa then we need current session token + * @param loginOptions - {@link LoginOptions LoginOptions} + * @param providerId - optional ID of the provider to deliver the link with + * @param ssoAppId - optional ID of the SSO application to sign in to + * @param useRecovery - optional, send the link to the user's recovery address + * @return pendingRef, linkId and masked phone + * @throws DescopeException - error upon failure + */ + PhoneEnchantedLinkResponse signInWithPhone(String loginId, String uri, String token, LoginOptions loginOptions, + String providerId, String ssoAppId, Boolean useRecovery) throws DescopeException; + /** * Use to create a new user based on the given loginID either email or a phone. * @@ -70,6 +102,21 @@ EnchantedLinkResponse signUp(String loginId, String uri, User user) EnchantedLinkResponse signUp(String loginId, String uri, User user, SignUpOptions signupOptions) throws DescopeException; + /** + * Use to create a new user based on the given loginID either email or a phone. + * + * @param loginId - User login ID + * @param uri - Base URI + * @param user - {@link User User} + * @param signupOptions - optional claims and template strings + * @param providerId - optional ID of the provider to deliver the link with + * @param templateId - optional ID of the message template to use + * @return pendingRef, linkId and masked email + * @throws DescopeException - error upon failure + */ + EnchantedLinkResponse signUp(String loginId, String uri, User user, SignUpOptions signupOptions, + String providerId, String templateId) throws DescopeException; + /** * Use to create a new user with a phone number as the loginID, verified by an enchanted link * sent by SMS. @@ -97,6 +144,22 @@ PhoneEnchantedLinkResponse signUpWithPhone(String loginId, String uri, User user PhoneEnchantedLinkResponse signUpWithPhone(String loginId, String uri, User user, SignUpOptions signupOptions) throws DescopeException; + /** + * Use to create a new user with a phone number as the loginID, verified by an enchanted link + * sent by SMS. + * + * @param loginId - User login ID, a phone number + * @param uri - Base URI + * @param user - {@link User User} + * @param signupOptions - optional claims and template strings + * @param providerId - optional ID of the provider to deliver the link with + * @param templateId - optional ID of the message template to use + * @return pendingRef, linkId and masked phone + * @throws DescopeException - error upon failure + */ + PhoneEnchantedLinkResponse signUpWithPhone(String loginId, String uri, User user, + SignUpOptions signupOptions, String providerId, String templateId) throws DescopeException; + /** * Use to login in using loginID, if user does not exist, a new user will be created. * @@ -108,6 +171,20 @@ PhoneEnchantedLinkResponse signUpWithPhone(String loginId, String uri, User user EnchantedLinkResponse signUpOrIn(String loginId, String uri) throws DescopeException; + /** + * Use to login in using loginID, if user does not exist, a new user will be created. + * + * @param loginId - User login ID + * @param uri - Base URI + * @param providerId - optional ID of the provider to deliver the link with + * @param ssoAppId - optional ID of the SSO application to sign in to + * @param useRecovery - optional, send the link to the user's recovery address + * @return pendingRef, linkId and masked email + * @throws DescopeException - error upon failure + */ + EnchantedLinkResponse signUpOrIn(String loginId, String uri, String providerId, String ssoAppId, + Boolean useRecovery) throws DescopeException; + /** * Use to login in using a phone number as the loginID, if user does not exist, a new user will * be created. The enchanted link is sent by SMS. @@ -120,6 +197,21 @@ EnchantedLinkResponse signUpOrIn(String loginId, String uri) PhoneEnchantedLinkResponse signUpOrInWithPhone(String loginId, String uri) throws DescopeException; + /** + * Use to login in using a phone number as the loginID, if user does not exist, a new user will + * be created. The enchanted link is sent by SMS. + * + * @param loginId - User login ID, a phone number + * @param uri - Base URI + * @param providerId - optional ID of the provider to deliver the link with + * @param ssoAppId - optional ID of the SSO application to sign in to + * @param useRecovery - optional, send the link to the user's recovery address + * @return pendingRef, linkId and masked phone + * @throws DescopeException - error upon failure + */ + PhoneEnchantedLinkResponse signUpOrInWithPhone(String loginId, String uri, String providerId, String ssoAppId, + Boolean useRecovery) throws DescopeException; + /** * Use to get a session that was generated by SignIn/SignUp request. * @@ -137,6 +229,15 @@ PhoneEnchantedLinkResponse signUpOrInWithPhone(String loginId, String uri) */ void verify(String token) throws DescopeException; + /** + * Use to verify a SignIn/SignUp request, based on the enchanted link token generated. + * + * @param token - token to be validate + * @param pkceVerifier - optional PKCE verifier matching the challenge sent when the link was requested + * @throws DescopeException - error upon failure + */ + void verify(String token, byte[] pkceVerifier) throws DescopeException; + /** * Use to update email and validate via enchanted link. * @@ -168,6 +269,27 @@ EnchantedLinkResponse updateUserEmail(String loginId, String email, String uri, EnchantedLinkResponse updateUserEmail(String loginId, String email, String uri, String refreshToken, UpdateOptions updateOptions, Map templateOptions) throws DescopeException; + /** + * Use to update email and validate via enchanted link. + * + * @param loginId - User login ID + * @param email - User email + * @param uri - Base URI + * @param refreshToken - refresh token to perform the update + * @param updateOptions - update options for the update + * @param templateOptions - optional parameters for template + * @param providerId - optional ID of the provider to deliver the link with + * @param templateId - optional ID of the message template to use + * @param locale - optional locale of the message + * @param failOnConflict - optional, fail instead of merging when another user already has this email + * @return {@link EnchantedLinkResponse} including masked address where the link was sent (email), + * link to chose and link to retrieve new session from + * @throws DescopeException - error upon failure + */ + EnchantedLinkResponse updateUserEmail(String loginId, String email, String uri, String refreshToken, + UpdateOptions updateOptions, Map templateOptions, String providerId, String templateId, + String locale, Boolean failOnConflict) throws DescopeException; + /** * Use to update phone and validate via enchanted link sent by SMS. * @@ -198,4 +320,25 @@ PhoneEnchantedLinkResponse updateUserPhone(String loginId, String phone, String */ PhoneEnchantedLinkResponse updateUserPhone(String loginId, String phone, String uri, String refreshToken, UpdateOptions updateOptions, Map templateOptions) throws DescopeException; + + /** + * Use to update phone and validate via enchanted link sent by SMS. + * + * @param loginId - User login ID + * @param phone - User phone number + * @param uri - Base URI + * @param refreshToken - refresh token to perform the update + * @param updateOptions - update options for the update + * @param templateOptions - optional parameters for template + * @param providerId - optional ID of the provider to deliver the link with + * @param templateId - optional ID of the message template to use + * @param locale - optional locale of the message + * @param failOnConflict - optional, fail instead of merging when another user already has this phone + * @return {@link PhoneEnchantedLinkResponse} including masked address where the link was sent + * (phone), link to chose and link to retrieve new session from + * @throws DescopeException - error upon failure + */ + PhoneEnchantedLinkResponse updateUserPhone(String loginId, String phone, String uri, String refreshToken, + UpdateOptions updateOptions, Map templateOptions, String providerId, String templateId, + String locale, Boolean failOnConflict) throws DescopeException; } diff --git a/src/main/java/com/descope/sdk/auth/impl/AuthenticationsBase.java b/src/main/java/com/descope/sdk/auth/impl/AuthenticationsBase.java index e01b2b71..4db4678c 100644 --- a/src/main/java/com/descope/sdk/auth/impl/AuthenticationsBase.java +++ b/src/main/java/com/descope/sdk/auth/impl/AuthenticationsBase.java @@ -130,9 +130,22 @@ AuthenticationInfo getAuthenticationInfo(JWTResponse jwtResponse) { if (StringUtils.isNotBlank(jwtResponse.getRefreshJwt())) { refreshToken = validateAndCreateToken(jwtResponse.getRefreshJwt()); } - return new AuthenticationInfo( + AuthenticationInfo authenticationInfo = new AuthenticationInfo( sessionToken, refreshToken, jwtResponse.getUser(), jwtResponse.getFirstSeen(), jwtResponse.getIdpResponse()); + authenticationInfo.setSessionExpiration(jwtResponse.getSessionExpiration()); + authenticationInfo.setExternalToken(jwtResponse.getExternalToken()); + authenticationInfo.setTenantSSOID(jwtResponse.getTenantSSOID()); + authenticationInfo.setTrustedDeviceJwt(jwtResponse.getTrustedDeviceJwt()); + authenticationInfo.setNextRefreshSeconds(jwtResponse.getNextRefreshSeconds()); + authenticationInfo.setCookieName(jwtResponse.getCookieName()); + authenticationInfo.setSessionCookieName(jwtResponse.getSessionCookieName()); + authenticationInfo.setSessionCookieDomain(jwtResponse.getSessionCookieDomain()); + authenticationInfo.setUnsavedSSO(jwtResponse.getUnsavedSSO()); + authenticationInfo.setKnownDeviceJwt(jwtResponse.getKnownDeviceJwt()); + authenticationInfo.setSsoAuthenticationOnly(jwtResponse.getSsoAuthenticationOnly()); + authenticationInfo.setUserCreationDeferred(jwtResponse.getUserCreationDeferred()); + return authenticationInfo; } @SuppressWarnings("unchecked") diff --git a/src/main/java/com/descope/sdk/auth/impl/EnchantedLinkServiceImpl.java b/src/main/java/com/descope/sdk/auth/impl/EnchantedLinkServiceImpl.java index b649af4f..aefdc6c1 100644 --- a/src/main/java/com/descope/sdk/auth/impl/EnchantedLinkServiceImpl.java +++ b/src/main/java/com/descope/sdk/auth/impl/EnchantedLinkServiceImpl.java @@ -47,22 +47,38 @@ class EnchantedLinkServiceImpl extends AuthenticationServiceImpl implements Ench @Override public EnchantedLinkResponse signIn(String loginId, String uri, String token, LoginOptions loginOptions) throws DescopeException { - return signInByDeliveryMethod(EMAIL, loginId, uri, token, loginOptions, EnchantedLinkResponse.class); + return signIn(loginId, uri, token, loginOptions, null, null, null); + } + + @Override + public EnchantedLinkResponse signIn(String loginId, String uri, String token, LoginOptions loginOptions, + String providerId, String ssoAppId, Boolean useRecovery) throws DescopeException { + return signInByDeliveryMethod(EMAIL, loginId, uri, token, loginOptions, providerId, ssoAppId, useRecovery, + EnchantedLinkResponse.class); } @Override public PhoneEnchantedLinkResponse signInWithPhone(String loginId, String uri, String token, LoginOptions loginOptions) throws DescopeException { - return signInByDeliveryMethod(SMS, loginId, uri, token, loginOptions, PhoneEnchantedLinkResponse.class); + return signInWithPhone(loginId, uri, token, loginOptions, null, null, null); + } + + @Override + public PhoneEnchantedLinkResponse signInWithPhone(String loginId, String uri, String token, + LoginOptions loginOptions, String providerId, String ssoAppId, Boolean useRecovery) throws DescopeException { + return signInByDeliveryMethod(SMS, loginId, uri, token, loginOptions, providerId, ssoAppId, useRecovery, + PhoneEnchantedLinkResponse.class); } private R signInByDeliveryMethod(DeliveryMethod deliveryMethod, String loginId, String uri, String token, - LoginOptions loginOptions, Class responseClass) throws DescopeException { + LoginOptions loginOptions, String providerId, String ssoAppId, Boolean useRecovery, Class responseClass) + throws DescopeException { if (StringUtils.isBlank(loginId)) { throw ServerCommonException.invalidArgument("Login ID"); } URI enchantedLink = composeEnchantedLinkSignInURL(deliveryMethod); - SignInRequest signInRequest = new SignInRequest(uri, loginId, loginOptions); + SignInRequest signInRequest = + new SignInRequest(uri, loginId, loginOptions, providerId, ssoAppId, useRecovery); ApiProxy apiProxy; if (JwtUtils.isJWTRequired(loginOptions)) { if (StringUtils.isBlank(token)) { @@ -84,7 +100,14 @@ public EnchantedLinkResponse signUp(String loginId, String uri, User user) @Override public EnchantedLinkResponse signUp(String loginId, String uri, User user, SignUpOptions signupOptions) throws DescopeException { - return signUpByDeliveryMethod(EMAIL, loginId, uri, user, signupOptions, EnchantedLinkResponse.class); + return signUp(loginId, uri, user, signupOptions, null, null); + } + + @Override + public EnchantedLinkResponse signUp(String loginId, String uri, User user, SignUpOptions signupOptions, + String providerId, String templateId) throws DescopeException { + return signUpByDeliveryMethod(EMAIL, loginId, uri, user, signupOptions, providerId, templateId, + EnchantedLinkResponse.class); } @Override @@ -96,17 +119,25 @@ public PhoneEnchantedLinkResponse signUpWithPhone(String loginId, String uri, Us @Override public PhoneEnchantedLinkResponse signUpWithPhone(String loginId, String uri, User user, SignUpOptions signupOptions) throws DescopeException { - return signUpByDeliveryMethod(SMS, loginId, uri, user, signupOptions, PhoneEnchantedLinkResponse.class); + return signUpWithPhone(loginId, uri, user, signupOptions, null, null); + } + + @Override + public PhoneEnchantedLinkResponse signUpWithPhone(String loginId, String uri, User user, + SignUpOptions signupOptions, String providerId, String templateId) throws DescopeException { + return signUpByDeliveryMethod(SMS, loginId, uri, user, signupOptions, providerId, templateId, + PhoneEnchantedLinkResponse.class); } private R signUpByDeliveryMethod(DeliveryMethod deliveryMethod, String loginId, String uri, User user, - SignUpOptions signupOptions, Class responseClass) throws DescopeException { + SignUpOptions signupOptions, String providerId, String templateId, Class responseClass) + throws DescopeException { if (user == null) { user = new User(); } URI enchantedLinkSignUpURL = composeEnchantedLinkSignUpURL(deliveryMethod); SignUpRequest.SignUpRequestBuilder signUpRequestBuilder = - SignUpRequest.builder().loginId(loginId).uri(uri); + SignUpRequest.builder().loginId(loginId).uri(uri).providerId(providerId).templateId(templateId); if (deliveryMethod == SMS) { signUpRequestBuilder.phone(loginId); if (StringUtils.isBlank(user.getPhone())) { @@ -128,21 +159,35 @@ private R signUpByDeliveryMethod(DeliveryMethod deliveryMethod, String login @Override public EnchantedLinkResponse signUpOrIn(String loginId, String uri) throws DescopeException { - return signUpOrInByDeliveryMethod(EMAIL, loginId, uri, EnchantedLinkResponse.class); + return signUpOrIn(loginId, uri, null, null, null); + } + + @Override + public EnchantedLinkResponse signUpOrIn(String loginId, String uri, String providerId, String ssoAppId, + Boolean useRecovery) throws DescopeException { + return signUpOrInByDeliveryMethod(EMAIL, loginId, uri, providerId, ssoAppId, useRecovery, + EnchantedLinkResponse.class); } @Override public PhoneEnchantedLinkResponse signUpOrInWithPhone(String loginId, String uri) throws DescopeException { - return signUpOrInByDeliveryMethod(SMS, loginId, uri, PhoneEnchantedLinkResponse.class); + return signUpOrInWithPhone(loginId, uri, null, null, null); + } + + @Override + public PhoneEnchantedLinkResponse signUpOrInWithPhone(String loginId, String uri, String providerId, + String ssoAppId, Boolean useRecovery) throws DescopeException { + return signUpOrInByDeliveryMethod(SMS, loginId, uri, providerId, ssoAppId, useRecovery, + PhoneEnchantedLinkResponse.class); } private R signUpOrInByDeliveryMethod(DeliveryMethod deliveryMethod, String loginId, String uri, - Class responseClass) throws DescopeException { + String providerId, String ssoAppId, Boolean useRecovery, Class responseClass) throws DescopeException { if (StringUtils.isBlank(loginId)) { throw ServerCommonException.invalidArgument("Login ID"); } URI enchantedLinkSignUpOrInURL = composeEnchantedLinkSignUpOrInURL(deliveryMethod); - SignInRequest signInRequest = new SignInRequest(uri, loginId, null); + SignInRequest signInRequest = new SignInRequest(uri, loginId, null, providerId, ssoAppId, useRecovery); ApiProxy apiProxy = getApiProxy(); return apiProxy.post(enchantedLinkSignUpOrInURL, signInRequest, responseClass); } @@ -161,8 +206,13 @@ public AuthenticationInfo getSession(String pendingRef) throws DescopeException @Override public void verify(String token) throws DescopeException { + verify(token, null); + } + + @Override + public void verify(String token, byte[] pkceVerifier) throws DescopeException { URI verifyEnchantedLinkURL = composeVerifyEnchantedLinkURL(); - VerifyRequest verifyRequest = new VerifyRequest(token); + VerifyRequest verifyRequest = new VerifyRequest(token, pkceVerifier); ApiProxy apiProxy = getApiProxy(); apiProxy.post(verifyEnchantedLinkURL, verifyRequest, EmptyResponse.class); } @@ -176,6 +226,13 @@ public EnchantedLinkResponse updateUserEmail(String loginId, String email, Strin @Override public EnchantedLinkResponse updateUserEmail(String loginId, String email, String uri, String refreshToken, UpdateOptions updateOptions, Map templateOptions) throws DescopeException { + return updateUserEmail(loginId, email, uri, refreshToken, updateOptions, templateOptions, null, null, null, null); + } + + @Override + public EnchantedLinkResponse updateUserEmail(String loginId, String email, String uri, String refreshToken, + UpdateOptions updateOptions, Map templateOptions, String providerId, String templateId, + String locale, Boolean failOnConflict) throws DescopeException { if (StringUtils.isBlank(loginId)) { throw ServerCommonException.invalidArgument("Login ID"); } @@ -198,6 +255,10 @@ public EnchantedLinkResponse updateUserEmail(String loginId, String email, Strin .addToLoginIds(updateOptions.isAddToLoginIds()) .onMergeUseExisting(updateOptions.isOnMergeUseExisting()) .templateOptions(templateOptions) + .providerId(providerId) + .templateId(templateId) + .locale(locale) + .failOnConflict(failOnConflict) .build(); ApiProxy apiProxy = getApiProxy(refreshToken); @@ -213,6 +274,13 @@ public PhoneEnchantedLinkResponse updateUserPhone(String loginId, String phone, @Override public PhoneEnchantedLinkResponse updateUserPhone(String loginId, String phone, String uri, String refreshToken, UpdateOptions updateOptions, Map templateOptions) throws DescopeException { + return updateUserPhone(loginId, phone, uri, refreshToken, updateOptions, templateOptions, null, null, null, null); + } + + @Override + public PhoneEnchantedLinkResponse updateUserPhone(String loginId, String phone, String uri, String refreshToken, + UpdateOptions updateOptions, Map templateOptions, String providerId, String templateId, + String locale, Boolean failOnConflict) throws DescopeException { if (StringUtils.isBlank(loginId)) { throw ServerCommonException.invalidArgument("Login ID"); } @@ -235,6 +303,10 @@ public PhoneEnchantedLinkResponse updateUserPhone(String loginId, String phone, .addToLoginIds(updateOptions.isAddToLoginIds()) .onMergeUseExisting(updateOptions.isOnMergeUseExisting()) .templateOptions(templateOptions) + .providerId(providerId) + .templateId(templateId) + .locale(locale) + .failOnConflict(failOnConflict) .build(); ApiProxy apiProxy = getApiProxy(refreshToken); diff --git a/src/test/java/com/descope/sdk/auth/impl/EnchantedLinkServiceImplTest.java b/src/test/java/com/descope/sdk/auth/impl/EnchantedLinkServiceImplTest.java index 9aa879ff..f341d006 100644 --- a/src/test/java/com/descope/sdk/auth/impl/EnchantedLinkServiceImplTest.java +++ b/src/test/java/com/descope/sdk/auth/impl/EnchantedLinkServiceImplTest.java @@ -11,6 +11,7 @@ import static com.descope.sdk.TestUtils.MOCK_TOKEN; import static com.descope.sdk.TestUtils.MOCK_URL; import static com.descope.sdk.TestUtils.PROJECT_ID; +import static com.descope.sdk.TestUtils.UPDATE_MOCK_EMAIL; import static org.assertj.core.api.Assertions.assertThat; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; @@ -27,11 +28,14 @@ import com.descope.exception.RateLimitExceededException; import com.descope.exception.ServerCommonException; import com.descope.model.auth.AuthenticationInfo; +import com.descope.model.auth.IDPResponse; +import com.descope.model.auth.UpdateOptions; import com.descope.model.client.Client; import com.descope.model.enchantedlink.EmptyResponse; import com.descope.model.enchantedlink.EnchantedLinkResponse; import com.descope.model.enchantedlink.PhoneEnchantedLinkResponse; import com.descope.model.jwt.Token; +import com.descope.model.jwt.response.JWTResponse; import com.descope.model.jwt.response.SigningKeysResponse; import com.descope.model.magiclink.request.SignInRequest; import com.descope.model.magiclink.request.SignUpRequest; @@ -39,6 +43,7 @@ import com.descope.model.user.User; import com.descope.model.user.request.UserRequest; import com.descope.model.user.response.EnchantedLinkTestUserResponse; +import com.descope.model.user.response.UserFamily; import com.descope.model.user.response.UserResponse; import com.descope.proxy.ApiProxy; import com.descope.proxy.impl.ApiProxyBuilder; @@ -48,10 +53,20 @@ import com.descope.sdk.mgmt.impl.ManagementServiceBuilder; import com.descope.utils.JwtUtils; import com.descope.utils.UriUtils; +import com.fasterxml.jackson.annotation.JsonInclude.Include; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.core.type.TypeReference; +import com.fasterxml.jackson.databind.DeserializationFeature; +import com.fasterxml.jackson.databind.ObjectMapper; import java.net.URI; +import java.nio.charset.StandardCharsets; import java.util.Arrays; +import java.util.Base64; +import java.util.HashMap; import java.util.List; import java.util.Map; +import java.util.concurrent.atomic.AtomicReference; +import java.util.function.Supplier; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junitpioneer.jupiter.RetryingTest; @@ -348,6 +363,399 @@ void testVerify() { } } + @Test + void signInSendsProviderSsoAppAndRecovery() throws Exception { + ApiProxy apiProxy = mock(ApiProxy.class); + doReturn(new EnchantedLinkResponse(MOCK_URL, MOCK_URL, MOCK_MASKED_EMAIL)) + .when(apiProxy).post(any(), any(), any()); + AtomicReference header = new AtomicReference<>(); + EnchantedLinkResponse response = withProxy(apiProxy, header, + () -> enchantedLinkService.signIn(MOCK_EMAIL, MOCK_DOMAIN, null, null, "p1", "app1", true)); + + ArgumentCaptor uriCaptor = ArgumentCaptor.forClass(URI.class); + ArgumentCaptor bodyCaptor = ArgumentCaptor.forClass(Object.class); + verify(apiProxy, times(1)).post(uriCaptor.capture(), bodyCaptor.capture(), eq(EnchantedLinkResponse.class)); + assertThat(uriCaptor.getValue().getPath()).isEqualTo("/v1/auth/enchantedlink/signin/email"); + assertThat(header.get()).isEqualTo("Bearer " + PROJECT_ID); + assertThat(toJson(bodyCaptor.getValue())).isEqualTo(jsonOf("URI", MOCK_DOMAIN, "loginId", MOCK_EMAIL, + "providerId", "p1", "ssoAppId", "app1", "useRecovery", true)); + assertThat(response.getPendingRef()).isEqualTo(MOCK_URL); + assertThat(response.getLinkId()).isEqualTo(MOCK_URL); + assertThat(response.getMaskedEmail()).isEqualTo(MOCK_MASKED_EMAIL); + } + + @Test + void signInWithPhoneSendsProviderSsoAppAndRecovery() throws Exception { + ApiProxy apiProxy = mock(ApiProxy.class); + doReturn(new PhoneEnchantedLinkResponse(MOCK_URL, MOCK_URL, MOCK_MASKED_PHONE)) + .when(apiProxy).post(any(), any(), any()); + AtomicReference header = new AtomicReference<>(); + PhoneEnchantedLinkResponse response = withProxy(apiProxy, header, + () -> enchantedLinkService.signInWithPhone(MOCK_PHONE, MOCK_DOMAIN, null, null, "p1", "app1", false)); + + ArgumentCaptor uriCaptor = ArgumentCaptor.forClass(URI.class); + ArgumentCaptor bodyCaptor = ArgumentCaptor.forClass(Object.class); + verify(apiProxy, times(1)).post(uriCaptor.capture(), bodyCaptor.capture(), + eq(PhoneEnchantedLinkResponse.class)); + assertThat(uriCaptor.getValue().getPath()).isEqualTo("/v1/auth/enchantedlink/signin/sms"); + assertThat(header.get()).isEqualTo("Bearer " + PROJECT_ID); + assertThat(toJson(bodyCaptor.getValue())).isEqualTo(jsonOf("URI", MOCK_DOMAIN, "loginId", MOCK_PHONE, + "providerId", "p1", "ssoAppId", "app1", "useRecovery", false)); + assertThat(response.getMaskedPhone()).isEqualTo(MOCK_MASKED_PHONE); + } + + @Test + void signInWithoutNewFieldsOmitsThem() throws Exception { + ApiProxy apiProxy = mock(ApiProxy.class); + AtomicReference header = new AtomicReference<>(); + withProxy(apiProxy, header, () -> enchantedLinkService.signIn(MOCK_EMAIL, MOCK_DOMAIN, null, null)); + + ArgumentCaptor bodyCaptor = ArgumentCaptor.forClass(Object.class); + verify(apiProxy, times(1)).post(any(), bodyCaptor.capture(), eq(EnchantedLinkResponse.class)); + assertThat(toJson(bodyCaptor.getValue())).isEqualTo(jsonOf("URI", MOCK_DOMAIN, "loginId", MOCK_EMAIL)); + } + + @Test + void signInWithNewFieldsRejectsEmptyLoginId() { + assertEquals("The Login ID argument is invalid", assertThrows(ServerCommonException.class, + () -> enchantedLinkService.signIn("", MOCK_DOMAIN, null, null, "p1", "app1", true)).getMessage()); + assertEquals("The Login ID argument is invalid", assertThrows(ServerCommonException.class, + () -> enchantedLinkService.signInWithPhone("", MOCK_DOMAIN, null, null, "p1", "app1", true)).getMessage()); + } + + @Test + void signUpOrInSendsProviderSsoAppAndRecovery() throws Exception { + ApiProxy apiProxy = mock(ApiProxy.class); + doReturn(new EnchantedLinkResponse(MOCK_URL, MOCK_URL, MOCK_MASKED_EMAIL)) + .when(apiProxy).post(any(), any(), any()); + AtomicReference header = new AtomicReference<>(); + EnchantedLinkResponse response = withProxy(apiProxy, header, + () -> enchantedLinkService.signUpOrIn(MOCK_EMAIL, MOCK_DOMAIN, "p1", "app1", true)); + + ArgumentCaptor uriCaptor = ArgumentCaptor.forClass(URI.class); + ArgumentCaptor bodyCaptor = ArgumentCaptor.forClass(Object.class); + verify(apiProxy, times(1)).post(uriCaptor.capture(), bodyCaptor.capture(), eq(EnchantedLinkResponse.class)); + assertThat(uriCaptor.getValue().getPath()).isEqualTo("/v1/auth/enchantedlink/signup-in/email"); + assertThat(header.get()).isEqualTo("Bearer " + PROJECT_ID); + assertThat(toJson(bodyCaptor.getValue())).isEqualTo(jsonOf("URI", MOCK_DOMAIN, "loginId", MOCK_EMAIL, + "providerId", "p1", "ssoAppId", "app1", "useRecovery", true)); + assertThat(response.getMaskedEmail()).isEqualTo(MOCK_MASKED_EMAIL); + } + + @Test + void signUpOrInWithPhoneSendsProviderSsoAppAndRecovery() throws Exception { + ApiProxy apiProxy = mock(ApiProxy.class); + doReturn(new PhoneEnchantedLinkResponse(MOCK_URL, MOCK_URL, MOCK_MASKED_PHONE)) + .when(apiProxy).post(any(), any(), any()); + AtomicReference header = new AtomicReference<>(); + PhoneEnchantedLinkResponse response = withProxy(apiProxy, header, + () -> enchantedLinkService.signUpOrInWithPhone(MOCK_PHONE, MOCK_DOMAIN, "p1", "app1", true)); + + ArgumentCaptor uriCaptor = ArgumentCaptor.forClass(URI.class); + ArgumentCaptor bodyCaptor = ArgumentCaptor.forClass(Object.class); + verify(apiProxy, times(1)).post(uriCaptor.capture(), bodyCaptor.capture(), + eq(PhoneEnchantedLinkResponse.class)); + assertThat(uriCaptor.getValue().getPath()).isEqualTo("/v1/auth/enchantedlink/signup-in/sms"); + assertThat(header.get()).isEqualTo("Bearer " + PROJECT_ID); + assertThat(toJson(bodyCaptor.getValue())).isEqualTo(jsonOf("URI", MOCK_DOMAIN, "loginId", MOCK_PHONE, + "providerId", "p1", "ssoAppId", "app1", "useRecovery", true)); + assertThat(response.getMaskedPhone()).isEqualTo(MOCK_MASKED_PHONE); + } + + @Test + void signUpOrInWithNewFieldsRejectsEmptyLoginId() { + assertEquals("The Login ID argument is invalid", assertThrows(ServerCommonException.class, + () -> enchantedLinkService.signUpOrIn("", MOCK_DOMAIN, "p1", "app1", true)).getMessage()); + assertEquals("The Login ID argument is invalid", assertThrows(ServerCommonException.class, + () -> enchantedLinkService.signUpOrInWithPhone("", MOCK_DOMAIN, "p1", "app1", true)).getMessage()); + } + + @Test + void signUpSendsProviderAndTemplate() throws Exception { + ApiProxy apiProxy = mock(ApiProxy.class); + doReturn(new EnchantedLinkResponse(MOCK_URL, MOCK_URL, MOCK_MASKED_EMAIL)) + .when(apiProxy).post(any(), any(), any()); + AtomicReference header = new AtomicReference<>(); + EnchantedLinkResponse response = withProxy(apiProxy, header, + () -> enchantedLinkService.signUp(MOCK_EMAIL, MOCK_DOMAIN, null, null, "p1", "t1")); + + ArgumentCaptor uriCaptor = ArgumentCaptor.forClass(URI.class); + ArgumentCaptor bodyCaptor = ArgumentCaptor.forClass(Object.class); + verify(apiProxy, times(1)).post(uriCaptor.capture(), bodyCaptor.capture(), eq(EnchantedLinkResponse.class)); + assertThat(uriCaptor.getValue().getPath()).isEqualTo("/v1/auth/enchantedlink/signup/email"); + assertThat(header.get()).isEqualTo("Bearer " + PROJECT_ID); + Map body = toJson(bodyCaptor.getValue()); + assertThat(body).containsEntry("providerId", "p1").containsEntry("templateId", "t1") + .containsEntry("email", MOCK_EMAIL).containsEntry("loginId", MOCK_EMAIL).containsEntry("URI", MOCK_DOMAIN); + assertThat(response.getMaskedEmail()).isEqualTo(MOCK_MASKED_EMAIL); + } + + @Test + void signUpWithPhoneSendsProviderAndTemplate() throws Exception { + ApiProxy apiProxy = mock(ApiProxy.class); + doReturn(new PhoneEnchantedLinkResponse(MOCK_URL, MOCK_URL, MOCK_MASKED_PHONE)) + .when(apiProxy).post(any(), any(), any()); + AtomicReference header = new AtomicReference<>(); + PhoneEnchantedLinkResponse response = withProxy(apiProxy, header, + () -> enchantedLinkService.signUpWithPhone(MOCK_PHONE, MOCK_DOMAIN, null, null, "p1", "t1")); + + ArgumentCaptor uriCaptor = ArgumentCaptor.forClass(URI.class); + ArgumentCaptor bodyCaptor = ArgumentCaptor.forClass(Object.class); + verify(apiProxy, times(1)).post(uriCaptor.capture(), bodyCaptor.capture(), + eq(PhoneEnchantedLinkResponse.class)); + assertThat(uriCaptor.getValue().getPath()).isEqualTo("/v1/auth/enchantedlink/signup/sms"); + assertThat(header.get()).isEqualTo("Bearer " + PROJECT_ID); + Map body = toJson(bodyCaptor.getValue()); + assertThat(body).containsEntry("providerId", "p1").containsEntry("templateId", "t1") + .containsEntry("phone", MOCK_PHONE).containsEntry("loginId", MOCK_PHONE).containsEntry("URI", MOCK_DOMAIN); + assertThat(response.getMaskedPhone()).isEqualTo(MOCK_MASKED_PHONE); + } + + @Test + void signUpWithoutNewFieldsOmitsThem() throws Exception { + ApiProxy apiProxy = mock(ApiProxy.class); + AtomicReference header = new AtomicReference<>(); + withProxy(apiProxy, header, () -> enchantedLinkService.signUp(MOCK_EMAIL, MOCK_DOMAIN, null)); + + ArgumentCaptor bodyCaptor = ArgumentCaptor.forClass(Object.class); + verify(apiProxy, times(1)).post(any(), bodyCaptor.capture(), eq(EnchantedLinkResponse.class)); + assertThat(toJson(bodyCaptor.getValue())).doesNotContainKeys("providerId", "templateId"); + } + + @Test + void updateUserEmailSendsNewFields() throws Exception { + ApiProxy apiProxy = mock(ApiProxy.class); + doReturn(new EnchantedLinkResponse(MOCK_URL, MOCK_URL, MOCK_MASKED_EMAIL)) + .when(apiProxy).post(any(), any(), any()); + AtomicReference header = new AtomicReference<>(); + EnchantedLinkResponse response = withProxy(apiProxy, header, + () -> enchantedLinkService.updateUserEmail(MOCK_EMAIL, UPDATE_MOCK_EMAIL, MOCK_DOMAIN, MOCK_REFRESH_TOKEN, + new UpdateOptions(true, false), null, "p1", "t1", "en", true)); + + ArgumentCaptor uriCaptor = ArgumentCaptor.forClass(URI.class); + ArgumentCaptor bodyCaptor = ArgumentCaptor.forClass(Object.class); + verify(apiProxy, times(1)).post(uriCaptor.capture(), bodyCaptor.capture(), eq(EnchantedLinkResponse.class)); + assertThat(uriCaptor.getValue().getPath()).isEqualTo("/v1/auth/enchantedlink/update/email"); + assertThat(header.get()).isEqualTo("Bearer " + PROJECT_ID + ":" + MOCK_REFRESH_TOKEN); + assertThat(toJson(bodyCaptor.getValue())).isEqualTo(jsonOf("email", UPDATE_MOCK_EMAIL, "loginId", MOCK_EMAIL, + "URI", MOCK_DOMAIN, "crossDevice", false, "addToLoginIDs", true, "onMergeUseExisting", false, + "providerId", "p1", "templateId", "t1", "locale", "en", "failOnConflict", true)); + assertThat(response.getMaskedEmail()).isEqualTo(MOCK_MASKED_EMAIL); + } + + @Test + void updateUserPhoneSendsNewFields() throws Exception { + ApiProxy apiProxy = mock(ApiProxy.class); + doReturn(new PhoneEnchantedLinkResponse(MOCK_URL, MOCK_URL, MOCK_MASKED_PHONE)) + .when(apiProxy).post(any(), any(), any()); + AtomicReference header = new AtomicReference<>(); + PhoneEnchantedLinkResponse response = withProxy(apiProxy, header, + () -> enchantedLinkService.updateUserPhone(MOCK_EMAIL, MOCK_PHONE, MOCK_DOMAIN, MOCK_REFRESH_TOKEN, + new UpdateOptions(true, false), null, "p1", "t1", "en", false)); + + ArgumentCaptor uriCaptor = ArgumentCaptor.forClass(URI.class); + ArgumentCaptor bodyCaptor = ArgumentCaptor.forClass(Object.class); + verify(apiProxy, times(1)).post(uriCaptor.capture(), bodyCaptor.capture(), + eq(PhoneEnchantedLinkResponse.class)); + assertThat(uriCaptor.getValue().getPath()).isEqualTo("/v1/auth/enchantedlink/update/phone/sms"); + assertThat(header.get()).isEqualTo("Bearer " + PROJECT_ID + ":" + MOCK_REFRESH_TOKEN); + assertThat(toJson(bodyCaptor.getValue())).isEqualTo(jsonOf("phone", MOCK_PHONE, "loginId", MOCK_EMAIL, + "URI", MOCK_DOMAIN, "crossDevice", false, "addToLoginIDs", true, "onMergeUseExisting", false, + "providerId", "p1", "templateId", "t1", "locale", "en", "failOnConflict", false)); + assertThat(response.getMaskedPhone()).isEqualTo(MOCK_MASKED_PHONE); + } + + @Test + void updateUserWithoutNewFieldsOmitsThem() throws Exception { + ApiProxy apiProxy = mock(ApiProxy.class); + AtomicReference header = new AtomicReference<>(); + withProxy(apiProxy, header, () -> enchantedLinkService.updateUserEmail( + MOCK_EMAIL, UPDATE_MOCK_EMAIL, MOCK_DOMAIN, MOCK_REFRESH_TOKEN, null)); + + ArgumentCaptor bodyCaptor = ArgumentCaptor.forClass(Object.class); + verify(apiProxy, times(1)).post(any(), bodyCaptor.capture(), eq(EnchantedLinkResponse.class)); + assertThat(toJson(bodyCaptor.getValue())).isEqualTo(jsonOf("email", UPDATE_MOCK_EMAIL, "loginId", MOCK_EMAIL, + "URI", MOCK_DOMAIN, "crossDevice", false, "addToLoginIDs", false, "onMergeUseExisting", false)); + } + + @Test + void updateUserWithNewFieldsRejectsInvalidArguments() { + assertEquals("The Login ID argument is invalid", assertThrows(ServerCommonException.class, + () -> enchantedLinkService.updateUserEmail("", UPDATE_MOCK_EMAIL, MOCK_DOMAIN, MOCK_REFRESH_TOKEN, null, + null, "p1", "t1", "en", true)).getMessage()); + assertEquals("The Email argument is invalid", assertThrows(ServerCommonException.class, + () -> enchantedLinkService.updateUserEmail(MOCK_EMAIL, "", MOCK_DOMAIN, MOCK_REFRESH_TOKEN, null, + null, "p1", "t1", "en", true)).getMessage()); + assertEquals("The Refresh Token argument is invalid", assertThrows(ServerCommonException.class, + () -> enchantedLinkService.updateUserEmail(MOCK_EMAIL, UPDATE_MOCK_EMAIL, MOCK_DOMAIN, "", null, + null, "p1", "t1", "en", true)).getMessage()); + assertEquals("The Login ID argument is invalid", assertThrows(ServerCommonException.class, + () -> enchantedLinkService.updateUserPhone("", MOCK_PHONE, MOCK_DOMAIN, MOCK_REFRESH_TOKEN, null, + null, "p1", "t1", "en", true)).getMessage()); + assertEquals("The Phone argument is invalid", assertThrows(ServerCommonException.class, + () -> enchantedLinkService.updateUserPhone(MOCK_EMAIL, "", MOCK_DOMAIN, MOCK_REFRESH_TOKEN, null, + null, "p1", "t1", "en", true)).getMessage()); + assertEquals("The Refresh Token argument is invalid", assertThrows(ServerCommonException.class, + () -> enchantedLinkService.updateUserPhone(MOCK_EMAIL, MOCK_PHONE, MOCK_DOMAIN, "", null, + null, "p1", "t1", "en", true)).getMessage()); + } + + @Test + void verifySendsPkceVerifier() throws Exception { + ApiProxy apiProxy = mock(ApiProxy.class); + AtomicReference header = new AtomicReference<>(); + withProxy(apiProxy, header, () -> { + enchantedLinkService.verify("token", "verifier".getBytes(StandardCharsets.UTF_8)); + return null; + }); + + ArgumentCaptor uriCaptor = ArgumentCaptor.forClass(URI.class); + ArgumentCaptor bodyCaptor = ArgumentCaptor.forClass(Object.class); + verify(apiProxy, times(1)).post(uriCaptor.capture(), bodyCaptor.capture(), eq(EmptyResponse.class)); + assertThat(uriCaptor.getValue().getPath()).isEqualTo("/v1/auth/enchantedlink/verify"); + assertThat(header.get()).isEqualTo("Bearer " + PROJECT_ID); + assertThat(toJson(bodyCaptor.getValue())).isEqualTo(jsonOf("token", "token", "pkceVerifier", + Base64.getEncoder().encodeToString("verifier".getBytes(StandardCharsets.UTF_8)))); + } + + @Test + void verifyWithoutPkceVerifierOmitsIt() throws Exception { + ApiProxy apiProxy = mock(ApiProxy.class); + AtomicReference header = new AtomicReference<>(); + withProxy(apiProxy, header, () -> { + enchantedLinkService.verify("token"); + return null; + }); + + ArgumentCaptor bodyCaptor = ArgumentCaptor.forClass(Object.class); + verify(apiProxy, times(1)).post(any(), bodyCaptor.capture(), eq(EmptyResponse.class)); + assertThat(toJson(bodyCaptor.getValue())).isEqualTo(jsonOf("token", "token")); + } + + @Test + void getSessionReadsFullResponse() throws Exception { + String json = "{\"sessionJwt\":\"s\",\"refreshJwt\":\"r\",\"firstSeen\":true," + + "\"sessionExpiration\":11,\"externalToken\":\"et\",\"tenantSSOID\":\"ts\"," + + "\"trustedDeviceJwt\":\"td\",\"nextRefreshSeconds\":12,\"cookieName\":\"cn\"," + + "\"sessionCookieName\":\"scn\",\"sessionCookieDomain\":\"scd\",\"unsavedSSO\":true," + + "\"knownDeviceJwt\":\"kd\",\"ssoAuthenticationOnly\":true,\"userCreationDeferred\":true," + + "\"idpResponse\":{\"samlResponse\":\"sr\",\"samlGeneratedUser\":\"sgu\"," + + "\"samlGeneratedRoles\":\"sgr\",\"oidcResponse\":\"or\",\"oidcGeneratedUser\":\"ogu\"," + + "\"oidcGeneratedRoles\":\"ogr\",\"idpGroups\":[\"g\"]}," + + "\"user\":{\"userId\":\"u1\",\"externalIds\":[\"e1\"],\"OAuth\":{\"google\":true}," + + "\"webauthn\":true,\"password\":true,\"editable\":true,\"SCIM\":true,\"push\":true," + + "\"permissions\":[\"perm\"],\"OIDC\":true,\"consentExpiration\":21," + + "\"recoveryEmail\":\"re@x.com\",\"verifiedRecoveryEmail\":true,\"recoveryPhone\":\"+1\"," + + "\"verifiedRecoveryPhone\":true,\"modifiedTime\":22,\"roleIds\":[\"rid\"]," + + "\"recoveryCodes\":true,\"dependent\":true,\"userFamilies\":[{\"familyId\":\"f1\"," + + "\"roleNames\":[\"fr\"],\"permissions\":[\"fp\"],\"familyScopedAttributes\":{\"a\":\"b\"}}]," + + "\"scimTenantId\":\"st\",\"samlTenantId\":\"sat\",\"oidcTenantId\":\"ot\"," + + "\"consentTenantId\":\"ct\",\"lastLoginTime\":23,\"unknownField\":1}}"; + JWTResponse jwtResponse = new ObjectMapper() + .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false).readValue(json, JWTResponse.class); + ApiProxy apiProxy = mock(ApiProxy.class); + doReturn(jwtResponse).when(apiProxy).post(any(), any(), any()); + AtomicReference header = new AtomicReference<>(); + AuthenticationInfo info; + try (MockedStatic mockedJwtUtils = mockStatic(JwtUtils.class)) { + mockedJwtUtils.when(() -> JwtUtils.getToken(anyString(), any())).thenReturn(MOCK_TOKEN); + info = withProxy(apiProxy, header, () -> enchantedLinkService.getSession("testRef")); + } + + ArgumentCaptor uriCaptor = ArgumentCaptor.forClass(URI.class); + ArgumentCaptor bodyCaptor = ArgumentCaptor.forClass(Object.class); + verify(apiProxy, times(1)).post(uriCaptor.capture(), bodyCaptor.capture(), eq(JWTResponse.class)); + assertThat(uriCaptor.getValue().getPath()).isEqualTo("/v1/auth/enchantedlink/pending-session"); + assertThat(header.get()).isEqualTo("Bearer " + PROJECT_ID); + assertThat(toJson(bodyCaptor.getValue())).isEqualTo(jsonOf("pendingRef", "testRef")); + + assertThat(info.getSessionExpiration()).isEqualTo(11); + assertThat(info.getExternalToken()).isEqualTo("et"); + assertThat(info.getTenantSSOID()).isEqualTo("ts"); + assertThat(info.getTrustedDeviceJwt()).isEqualTo("td"); + assertThat(info.getNextRefreshSeconds()).isEqualTo(12); + assertThat(info.getCookieName()).isEqualTo("cn"); + assertThat(info.getSessionCookieName()).isEqualTo("scn"); + assertThat(info.getSessionCookieDomain()).isEqualTo("scd"); + assertThat(info.getUnsavedSSO()).isTrue(); + assertThat(info.getKnownDeviceJwt()).isEqualTo("kd"); + assertThat(info.getSsoAuthenticationOnly()).isTrue(); + assertThat(info.getUserCreationDeferred()).isTrue(); + + IDPResponse idp = info.getIdpResponse(); + assertThat(idp.getSamlResponse()).isEqualTo("sr"); + assertThat(idp.getSamlGeneratedUser()).isEqualTo("sgu"); + assertThat(idp.getSamlGeneratedRoles()).isEqualTo("sgr"); + assertThat(idp.getOidcResponse()).isEqualTo("or"); + assertThat(idp.getOidcGeneratedUser()).isEqualTo("ogu"); + assertThat(idp.getOidcGeneratedRoles()).isEqualTo("ogr"); + assertThat(idp.getIdpGroups()).containsExactly("g"); + + UserResponse user = info.getUser(); + assertThat(user.getUserId()).isEqualTo("u1"); + assertThat(user.getExternalIds()).containsExactly("e1"); + assertThat(user.getOAuth()).containsEntry("google", true); + assertThat(user.getWebauthn()).isTrue(); + assertThat(user.getPassword()).isTrue(); + assertThat(user.getEditable()).isTrue(); + assertThat(user.getScim()).isTrue(); + assertThat(user.getPush()).isTrue(); + assertThat(user.getPermissions()).containsExactly("perm"); + assertThat(user.getOidc()).isTrue(); + assertThat(user.getConsentExpiration()).isEqualTo(21L); + assertThat(user.getRecoveryEmail()).isEqualTo("re@x.com"); + assertThat(user.getVerifiedRecoveryEmail()).isTrue(); + assertThat(user.getRecoveryPhone()).isEqualTo("+1"); + assertThat(user.getVerifiedRecoveryPhone()).isTrue(); + assertThat(user.getModifiedTime()).isEqualTo(22L); + assertThat(user.getRoleIds()).containsExactly("rid"); + assertThat(user.getRecoveryCodes()).isTrue(); + assertThat(user.getDependent()).isTrue(); + assertThat(user.getUserFamilies()).hasSize(1); + UserFamily family = user.getUserFamilies().get(0); + assertThat(family.getFamilyId()).isEqualTo("f1"); + assertThat(family.getRoleNames()).containsExactly("fr"); + assertThat(family.getPermissions()).containsExactly("fp"); + assertThat(family.getFamilyScopedAttributes()).containsEntry("a", "b"); + assertThat(user.getScimTenantId()).isEqualTo("st"); + assertThat(user.getSamlTenantId()).isEqualTo("sat"); + assertThat(user.getOidcTenantId()).isEqualTo("ot"); + assertThat(user.getConsentTenantId()).isEqualTo("ct"); + assertThat(user.getLastLoginTime()).isEqualTo(23L); + } + + @Test + void userResponseStillReadsLowercaseOauth() throws Exception { + UserResponse user = new ObjectMapper().readValue("{\"oauth\":{\"google\":true}}", UserResponse.class); + assertThat(user.getOAuth()).containsEntry("google", true); + } + + /** Runs the call with the given proxy and captures the Authorization header it was built with. */ + @SuppressWarnings("unchecked") + private static T withProxy(ApiProxy apiProxy, AtomicReference header, Supplier call) { + try (MockedStatic mockedApiProxyBuilder = mockStatic(ApiProxyBuilder.class)) { + mockedApiProxyBuilder.when(() -> ApiProxyBuilder.buildProxy(any(), any())).thenAnswer(inv -> { + header.set(((Supplier) inv.getArgument(0)).get()); + return apiProxy; + }); + return call.get(); + } + } + + private static Map jsonOf(Object... keysAndValues) { + Map m = new HashMap<>(); + for (int i = 0; i < keysAndValues.length; i += 2) { + m.put((String) keysAndValues[i], keysAndValues[i + 1]); + } + return m; + } + + /** Serializes a request body the way the API proxy does. */ + private static Map toJson(Object body) throws JsonProcessingException { + ObjectMapper objectMapper = new ObjectMapper().setSerializationInclusion(Include.NON_NULL); + return objectMapper.readValue(objectMapper.writeValueAsString(body), new TypeReference>() {}); + } + @RetryingTest(value = 3, suspendForMs = 30000, onExceptions = RateLimitExceededException.class) void testFunctionalFullCycle() { String loginId = TestUtils.getRandomName("u-"); From 2f3ee743d11a4903b83d9ac7fb142224452cb6ec Mon Sep 17 00:00:00 2001 From: Yosi Haran Date: Fri, 20 Nov 2026 12:51:34 +0200 Subject: [PATCH 2/2] fix: address review comments --- .../model/auth/AuthenticationInfo.java | 20 ++++++++ .../sdk/auth/impl/AuthenticationsBase.java | 17 +------ .../descope/sdk/mgmt/impl/JwtServiceImpl.java | 3 +- .../model/auth/AuthenticationInfoTest.java | 50 +++++++++++++++++++ 4 files changed, 72 insertions(+), 18 deletions(-) create mode 100644 src/test/java/com/descope/model/auth/AuthenticationInfoTest.java diff --git a/src/main/java/com/descope/model/auth/AuthenticationInfo.java b/src/main/java/com/descope/model/auth/AuthenticationInfo.java index fcc0daa2..fc5ec766 100644 --- a/src/main/java/com/descope/model/auth/AuthenticationInfo.java +++ b/src/main/java/com/descope/model/auth/AuthenticationInfo.java @@ -1,6 +1,7 @@ package com.descope.model.auth; import com.descope.model.jwt.Token; +import com.descope.model.jwt.response.JWTResponse; import com.descope.model.user.response.UserResponse; import lombok.AllArgsConstructor; import lombok.Data; @@ -37,4 +38,23 @@ public AuthenticationInfo(Token token, Token refreshToken, UserResponse user, Bo this(token, refreshToken, user, firstSeen, idpResponse, null, null, null, null, null, null, null, null, null, null, null, null); } + + /** Builds the info from a JWT response, copying every response field. */ + public static AuthenticationInfo fromJwtResponse(Token token, Token refreshToken, JWTResponse jwtResponse) { + AuthenticationInfo info = new AuthenticationInfo(token, refreshToken, jwtResponse.getUser(), + jwtResponse.getFirstSeen(), jwtResponse.getIdpResponse()); + info.setSessionExpiration(jwtResponse.getSessionExpiration()); + info.setExternalToken(jwtResponse.getExternalToken()); + info.setTenantSSOID(jwtResponse.getTenantSSOID()); + info.setTrustedDeviceJwt(jwtResponse.getTrustedDeviceJwt()); + info.setNextRefreshSeconds(jwtResponse.getNextRefreshSeconds()); + info.setCookieName(jwtResponse.getCookieName()); + info.setSessionCookieName(jwtResponse.getSessionCookieName()); + info.setSessionCookieDomain(jwtResponse.getSessionCookieDomain()); + info.setUnsavedSSO(jwtResponse.getUnsavedSSO()); + info.setKnownDeviceJwt(jwtResponse.getKnownDeviceJwt()); + info.setSsoAuthenticationOnly(jwtResponse.getSsoAuthenticationOnly()); + info.setUserCreationDeferred(jwtResponse.getUserCreationDeferred()); + return info; + } } diff --git a/src/main/java/com/descope/sdk/auth/impl/AuthenticationsBase.java b/src/main/java/com/descope/sdk/auth/impl/AuthenticationsBase.java index 4db4678c..ddc8c60e 100644 --- a/src/main/java/com/descope/sdk/auth/impl/AuthenticationsBase.java +++ b/src/main/java/com/descope/sdk/auth/impl/AuthenticationsBase.java @@ -130,22 +130,7 @@ AuthenticationInfo getAuthenticationInfo(JWTResponse jwtResponse) { if (StringUtils.isNotBlank(jwtResponse.getRefreshJwt())) { refreshToken = validateAndCreateToken(jwtResponse.getRefreshJwt()); } - AuthenticationInfo authenticationInfo = new AuthenticationInfo( - sessionToken, refreshToken, jwtResponse.getUser(), jwtResponse.getFirstSeen(), - jwtResponse.getIdpResponse()); - authenticationInfo.setSessionExpiration(jwtResponse.getSessionExpiration()); - authenticationInfo.setExternalToken(jwtResponse.getExternalToken()); - authenticationInfo.setTenantSSOID(jwtResponse.getTenantSSOID()); - authenticationInfo.setTrustedDeviceJwt(jwtResponse.getTrustedDeviceJwt()); - authenticationInfo.setNextRefreshSeconds(jwtResponse.getNextRefreshSeconds()); - authenticationInfo.setCookieName(jwtResponse.getCookieName()); - authenticationInfo.setSessionCookieName(jwtResponse.getSessionCookieName()); - authenticationInfo.setSessionCookieDomain(jwtResponse.getSessionCookieDomain()); - authenticationInfo.setUnsavedSSO(jwtResponse.getUnsavedSSO()); - authenticationInfo.setKnownDeviceJwt(jwtResponse.getKnownDeviceJwt()); - authenticationInfo.setSsoAuthenticationOnly(jwtResponse.getSsoAuthenticationOnly()); - authenticationInfo.setUserCreationDeferred(jwtResponse.getUserCreationDeferred()); - return authenticationInfo; + return AuthenticationInfo.fromJwtResponse(sessionToken, refreshToken, jwtResponse); } @SuppressWarnings("unchecked") diff --git a/src/main/java/com/descope/sdk/mgmt/impl/JwtServiceImpl.java b/src/main/java/com/descope/sdk/mgmt/impl/JwtServiceImpl.java index f3665e8b..ccf01738 100644 --- a/src/main/java/com/descope/sdk/mgmt/impl/JwtServiceImpl.java +++ b/src/main/java/com/descope/sdk/mgmt/impl/JwtServiceImpl.java @@ -142,8 +142,7 @@ private AuthenticationInfo validateAndCreateAuthInfo(JWTResponse jwtResponse) th } Token sessionToken = validateAndCreateToken(jwtResponse.getSessionJwt()); Token refreshToken = validateAndCreateToken(jwtResponse.getRefreshJwt()); - return new AuthenticationInfo(sessionToken, refreshToken, jwtResponse.getUser(), jwtResponse.getFirstSeen(), - jwtResponse.getIdpResponse()); + return AuthenticationInfo.fromJwtResponse(sessionToken, refreshToken, jwtResponse); } private URI composeUpdateJwtUri() { diff --git a/src/test/java/com/descope/model/auth/AuthenticationInfoTest.java b/src/test/java/com/descope/model/auth/AuthenticationInfoTest.java new file mode 100644 index 00000000..e6678460 --- /dev/null +++ b/src/test/java/com/descope/model/auth/AuthenticationInfoTest.java @@ -0,0 +1,50 @@ +package com.descope.model.auth; + +import static org.assertj.core.api.Assertions.assertThat; + +import com.descope.model.jwt.Token; +import com.descope.model.jwt.response.JWTResponse; +import org.junit.jupiter.api.Test; + +class AuthenticationInfoTest { + + @Test + void testFromJwtResponseCopiesAllFields() { + JWTResponse jwtResponse = new JWTResponse(); + jwtResponse.setFirstSeen(true); + jwtResponse.setIdpResponse(new IDPResponse()); + jwtResponse.setSessionExpiration(11); + jwtResponse.setExternalToken("et"); + jwtResponse.setTenantSSOID("ts"); + jwtResponse.setTrustedDeviceJwt("td"); + jwtResponse.setNextRefreshSeconds(12); + jwtResponse.setCookieName("cn"); + jwtResponse.setSessionCookieName("scn"); + jwtResponse.setSessionCookieDomain("scd"); + jwtResponse.setUnsavedSSO(true); + jwtResponse.setKnownDeviceJwt("kd"); + jwtResponse.setSsoAuthenticationOnly(true); + jwtResponse.setUserCreationDeferred(true); + Token token = Token.builder().jwt("s").build(); + Token refresh = Token.builder().jwt("r").build(); + + AuthenticationInfo info = AuthenticationInfo.fromJwtResponse(token, refresh, jwtResponse); + + assertThat(info.getToken()).isSameAs(token); + assertThat(info.getRefreshToken()).isSameAs(refresh); + assertThat(info.getFirstSeen()).isTrue(); + assertThat(info.getIdpResponse()).isSameAs(jwtResponse.getIdpResponse()); + assertThat(info.getSessionExpiration()).isEqualTo(11); + assertThat(info.getExternalToken()).isEqualTo("et"); + assertThat(info.getTenantSSOID()).isEqualTo("ts"); + assertThat(info.getTrustedDeviceJwt()).isEqualTo("td"); + assertThat(info.getNextRefreshSeconds()).isEqualTo(12); + assertThat(info.getCookieName()).isEqualTo("cn"); + assertThat(info.getSessionCookieName()).isEqualTo("scn"); + assertThat(info.getSessionCookieDomain()).isEqualTo("scd"); + assertThat(info.getUnsavedSSO()).isTrue(); + assertThat(info.getKnownDeviceJwt()).isEqualTo("kd"); + assertThat(info.getSsoAuthenticationOnly()).isTrue(); + assertThat(info.getUserCreationDeferred()).isTrue(); + } +}