From 9dc1ddb0c91b6eb60bf9e38b292ec3a0ef6d276d Mon Sep 17 00:00:00 2001 From: david ruiz Date: Thu, 18 Jun 2026 12:53:39 +0200 Subject: [PATCH 1/3] GetFaceAuthenticationAttemptAssets + PaymentPlan updates + unit and integration tests --- .../flow/requests/PaymentSessionInfo.java | 16 +++ .../entities/AttemptAssetLinks.java | 27 +++++ .../entities/AttemptAssetsQueryFilter.java | 31 +++++ .../FaceAuthenticationClient.java | 22 ++++ .../FaceAuthenticationClientImpl.java | 39 +++++- .../FaceAuthenticationAttemptAsset.java | 32 +++++ .../FaceAuthenticationAttemptAssetType.java | 15 +++ ...ceAuthenticationAttemptAssetsResponse.java | 45 +++++++ .../IdentityVerificationClient.java | 22 ++++ .../IdentityVerificationClientImpl.java | 35 ++++++ .../IdentityVerificationAttemptAsset.java | 32 +++++ .../IdentityVerificationAttemptAssetType.java | 35 ++++++ ...tityVerificationAttemptAssetsResponse.java | 45 +++++++ .../checkout/payments/ProcessingSettings.java | 6 + .../payments/hosted/HostedPaymentRequest.java | 16 +++ .../payments/links/PaymentLinkRequest.java | 16 +++ .../flow/PaymentSessionSerializationTest.java | 48 ++++++++ ...ttemptAssetsResponseSerializationTest.java | 113 ++++++++++++++++++ .../FaceAuthenticationClientImplTest.java | 42 ++++++- .../FaceAuthenticationTestIT.java | 23 ++++ ...ttemptAssetsResponseSerializationTest.java | 113 ++++++++++++++++++ .../IdentityVerificationClientImplTest.java | 38 ++++++ .../IdentityVerificationTestIT.java | 20 ++++ .../ProcessingSettingsSerializationTest.java | 21 ++++ ...HostedPaymentRequestSerializationTest.java | 62 ++++++++++ .../PaymentLinkRequestSerializationTest.java | 65 ++++++++++ 26 files changed, 975 insertions(+), 4 deletions(-) create mode 100644 src/main/java/com/checkout/identities/entities/AttemptAssetLinks.java create mode 100644 src/main/java/com/checkout/identities/entities/AttemptAssetsQueryFilter.java create mode 100644 src/main/java/com/checkout/identities/faceauthentications/responses/FaceAuthenticationAttemptAsset.java create mode 100644 src/main/java/com/checkout/identities/faceauthentications/responses/FaceAuthenticationAttemptAssetType.java create mode 100644 src/main/java/com/checkout/identities/faceauthentications/responses/FaceAuthenticationAttemptAssetsResponse.java create mode 100644 src/main/java/com/checkout/identities/identityverification/responses/IdentityVerificationAttemptAsset.java create mode 100644 src/main/java/com/checkout/identities/identityverification/responses/IdentityVerificationAttemptAssetType.java create mode 100644 src/main/java/com/checkout/identities/identityverification/responses/IdentityVerificationAttemptAssetsResponse.java create mode 100644 src/test/java/com/checkout/identities/faceauthentications/FaceAuthenticationAttemptAssetsResponseSerializationTest.java create mode 100644 src/test/java/com/checkout/identities/identityverification/IdentityVerificationAttemptAssetsResponseSerializationTest.java diff --git a/src/main/java/com/checkout/handlepaymentsandpayouts/flow/requests/PaymentSessionInfo.java b/src/main/java/com/checkout/handlepaymentsandpayouts/flow/requests/PaymentSessionInfo.java index fa5eac5d..6bc51c75 100644 --- a/src/main/java/com/checkout/handlepaymentsandpayouts/flow/requests/PaymentSessionInfo.java +++ b/src/main/java/com/checkout/handlepaymentsandpayouts/flow/requests/PaymentSessionInfo.java @@ -2,9 +2,11 @@ import com.checkout.common.Currency; import com.checkout.handlepaymentsandpayouts.flow.entities.Customer; +import com.checkout.payments.AuthorizationType; import com.checkout.payments.BillingInformation; import com.checkout.payments.ShippingDetails; import com.checkout.payments.BillingDescriptor; +import com.checkout.payments.PaymentPlan; import com.checkout.payments.PaymentRecipient; import com.checkout.payments.ProcessingSettings; import com.checkout.payments.PaymentInstruction; @@ -154,4 +156,18 @@ public abstract class PaymentSessionInfo extends PaymentSessionBase { * Format: date-time (ISO 8601) */ private Instant captureOn; + + /** + * The authorization type. + * [Optional] + * Enum: "Final" "Estimated" + * Default: "Final" + */ + private AuthorizationType authorizationType; + + /** + * The information to process a recurring payment request. To be used when the payment_type is Recurring. + * [Optional] + */ + private PaymentPlan paymentPlan; } diff --git a/src/main/java/com/checkout/identities/entities/AttemptAssetLinks.java b/src/main/java/com/checkout/identities/entities/AttemptAssetLinks.java new file mode 100644 index 00000000..842330c3 --- /dev/null +++ b/src/main/java/com/checkout/identities/entities/AttemptAssetLinks.java @@ -0,0 +1,27 @@ +package com.checkout.identities.entities; + +import com.checkout.common.Link; +import com.google.gson.annotations.SerializedName; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +/** + * The links related to an attempt asset. + */ +@Data +@Builder +@NoArgsConstructor +@AllArgsConstructor +public final class AttemptAssetLinks { + + /** + * The URL to download the asset. + * [Required] + * Format: uri + */ + @SerializedName("asset_url") + private Link assetUrl; + +} diff --git a/src/main/java/com/checkout/identities/entities/AttemptAssetsQueryFilter.java b/src/main/java/com/checkout/identities/entities/AttemptAssetsQueryFilter.java new file mode 100644 index 00000000..97b1e92d --- /dev/null +++ b/src/main/java/com/checkout/identities/entities/AttemptAssetsQueryFilter.java @@ -0,0 +1,31 @@ +package com.checkout.identities.entities; + +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +/** + * Query parameters for retrieving the assets captured during an attempt. + */ +@Data +@Builder +@AllArgsConstructor +@NoArgsConstructor +public final class AttemptAssetsQueryFilter { + + /** + * The number of assets to skip. + * [Optional] + * Default: 0 + */ + private Integer skip; + + /** + * The maximum number of assets to return. + * [Optional] + * Default: 10 + */ + private Integer limit; + +} diff --git a/src/main/java/com/checkout/identities/faceauthentications/FaceAuthenticationClient.java b/src/main/java/com/checkout/identities/faceauthentications/FaceAuthenticationClient.java index a5ee32a1..fa0a0b4d 100644 --- a/src/main/java/com/checkout/identities/faceauthentications/FaceAuthenticationClient.java +++ b/src/main/java/com/checkout/identities/faceauthentications/FaceAuthenticationClient.java @@ -1,7 +1,9 @@ package com.checkout.identities.faceauthentications; +import com.checkout.identities.entities.AttemptAssetsQueryFilter; import com.checkout.identities.faceauthentications.requests.FaceAuthenticationAttemptRequest; import com.checkout.identities.faceauthentications.requests.FaceAuthenticationRequest; +import com.checkout.identities.faceauthentications.responses.FaceAuthenticationAttemptAssetsResponse; import com.checkout.identities.faceauthentications.responses.FaceAuthenticationAttemptResponse; import com.checkout.identities.faceauthentications.responses.FaceAuthenticationAttemptsResponse; import com.checkout.identities.faceauthentications.responses.FaceAuthenticationResponse; @@ -63,6 +65,16 @@ public interface FaceAuthenticationClient { */ CompletableFuture getFaceAuthenticationAttempt(String faceAuthenticationId, String attemptId); + /** + * Retrieves the assets (face images and videos) captured during a face authentication attempt. + * + * @param faceAuthenticationId The face authentication ID + * @param attemptId The attempt ID + * @param queryFilter The pagination query parameters (skip and limit) + * @return CompletableFuture containing the face authentication attempt assets response + */ + CompletableFuture getFaceAuthenticationAttemptAssets(String faceAuthenticationId, String attemptId, AttemptAssetsQueryFilter queryFilter); + // Synchronous methods /** @@ -114,4 +126,14 @@ public interface FaceAuthenticationClient { * @return The face authentication attempt response */ FaceAuthenticationAttemptResponse getFaceAuthenticationAttemptSync(String faceAuthenticationId, String attemptId); + + /** + * Retrieves the assets (face images and videos) captured during a face authentication attempt. + * + * @param faceAuthenticationId The face authentication ID + * @param attemptId The attempt ID + * @param queryFilter The pagination query parameters (skip and limit) + * @return The face authentication attempt assets response + */ + FaceAuthenticationAttemptAssetsResponse getFaceAuthenticationAttemptAssetsSync(String faceAuthenticationId, String attemptId, AttemptAssetsQueryFilter queryFilter); } \ No newline at end of file diff --git a/src/main/java/com/checkout/identities/faceauthentications/FaceAuthenticationClientImpl.java b/src/main/java/com/checkout/identities/faceauthentications/FaceAuthenticationClientImpl.java index 6df11584..33144a92 100644 --- a/src/main/java/com/checkout/identities/faceauthentications/FaceAuthenticationClientImpl.java +++ b/src/main/java/com/checkout/identities/faceauthentications/FaceAuthenticationClientImpl.java @@ -4,8 +4,10 @@ import com.checkout.ApiClient; import com.checkout.CheckoutConfiguration; import com.checkout.SdkAuthorizationType; +import com.checkout.identities.entities.AttemptAssetsQueryFilter; import com.checkout.identities.faceauthentications.requests.FaceAuthenticationAttemptRequest; import com.checkout.identities.faceauthentications.requests.FaceAuthenticationRequest; +import com.checkout.identities.faceauthentications.responses.FaceAuthenticationAttemptAssetsResponse; import com.checkout.identities.faceauthentications.responses.FaceAuthenticationAttemptResponse; import com.checkout.identities.faceauthentications.responses.FaceAuthenticationAttemptsResponse; import com.checkout.identities.faceauthentications.responses.FaceAuthenticationResponse; @@ -22,6 +24,7 @@ public class FaceAuthenticationClientImpl extends AbstractClient implements Face private static final String FACE_AUTHENTICATIONS_PATH = "face-authentications"; private static final String ANONYMIZE_PATH = "anonymize"; private static final String ATTEMPTS_PATH = "attempts"; + private static final String ASSETS_PATH = "assets"; public FaceAuthenticationClientImpl(final ApiClient apiClient, final CheckoutConfiguration configuration) { super(apiClient, configuration, SdkAuthorizationType.SECRET_KEY_OR_OAUTH); @@ -107,10 +110,26 @@ public CompletableFuture getFaceAuthenticati public CompletableFuture getFaceAuthenticationAttempt( final String faceAuthenticationId, final String attemptId) { validateParams("faceAuthenticationId", faceAuthenticationId, "attemptId", attemptId); - return apiClient.getAsync(buildPath(FACE_AUTHENTICATIONS_PATH, faceAuthenticationId, ATTEMPTS_PATH, attemptId), + return apiClient.getAsync(buildPath(FACE_AUTHENTICATIONS_PATH, faceAuthenticationId, ATTEMPTS_PATH, attemptId), sdkAuthorization(), FaceAuthenticationAttemptResponse.class); } + /** + * Retrieves the assets (face images and videos) captured during a face authentication attempt. + * + * @param faceAuthenticationId The face authentication ID + * @param attemptId The attempt ID + * @param queryFilter The pagination query parameters (skip and limit) + * @return CompletableFuture containing the face authentication attempt assets response + */ + @Override + public CompletableFuture getFaceAuthenticationAttemptAssets( + final String faceAuthenticationId, final String attemptId, final AttemptAssetsQueryFilter queryFilter) { + validateParams("faceAuthenticationId", faceAuthenticationId, "attemptId", attemptId); + return apiClient.queryAsync(buildPath(FACE_AUTHENTICATIONS_PATH, faceAuthenticationId, ATTEMPTS_PATH, attemptId, ASSETS_PATH), + sdkAuthorization(), queryFilter, FaceAuthenticationAttemptAssetsResponse.class); + } + // Synchronous methods /** @@ -192,7 +211,23 @@ public FaceAuthenticationAttemptsResponse getFaceAuthenticationAttemptsSync(fina public FaceAuthenticationAttemptResponse getFaceAuthenticationAttemptSync( final String faceAuthenticationId, final String attemptId) { validateParams("faceAuthenticationId", faceAuthenticationId, "attemptId", attemptId); - return apiClient.get(buildPath(FACE_AUTHENTICATIONS_PATH, faceAuthenticationId, ATTEMPTS_PATH, attemptId), + return apiClient.get(buildPath(FACE_AUTHENTICATIONS_PATH, faceAuthenticationId, ATTEMPTS_PATH, attemptId), sdkAuthorization(), FaceAuthenticationAttemptResponse.class); } + + /** + * Retrieves the assets (face images and videos) captured during a face authentication attempt. + * + * @param faceAuthenticationId The face authentication ID + * @param attemptId The attempt ID + * @param queryFilter The pagination query parameters (skip and limit) + * @return The face authentication attempt assets response + */ + @Override + public FaceAuthenticationAttemptAssetsResponse getFaceAuthenticationAttemptAssetsSync( + final String faceAuthenticationId, final String attemptId, final AttemptAssetsQueryFilter queryFilter) { + validateParams("faceAuthenticationId", faceAuthenticationId, "attemptId", attemptId); + return apiClient.query(buildPath(FACE_AUTHENTICATIONS_PATH, faceAuthenticationId, ATTEMPTS_PATH, attemptId, ASSETS_PATH), + sdkAuthorization(), queryFilter, FaceAuthenticationAttemptAssetsResponse.class); + } } \ No newline at end of file diff --git a/src/main/java/com/checkout/identities/faceauthentications/responses/FaceAuthenticationAttemptAsset.java b/src/main/java/com/checkout/identities/faceauthentications/responses/FaceAuthenticationAttemptAsset.java new file mode 100644 index 00000000..0b5b487e --- /dev/null +++ b/src/main/java/com/checkout/identities/faceauthentications/responses/FaceAuthenticationAttemptAsset.java @@ -0,0 +1,32 @@ +package com.checkout.identities.faceauthentications.responses; + +import com.checkout.identities.entities.AttemptAssetLinks; +import com.google.gson.annotations.SerializedName; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +/** + * An asset (face image or video) captured during a face authentication attempt. + */ +@Data +@Builder +@NoArgsConstructor +@AllArgsConstructor +public final class FaceAuthenticationAttemptAsset { + + /** + * The type of asset. + * [Required] + */ + private FaceAuthenticationAttemptAssetType type; + + /** + * The links related to the asset. + * [Required] + */ + @SerializedName("_links") + private AttemptAssetLinks links; + +} diff --git a/src/main/java/com/checkout/identities/faceauthentications/responses/FaceAuthenticationAttemptAssetType.java b/src/main/java/com/checkout/identities/faceauthentications/responses/FaceAuthenticationAttemptAssetType.java new file mode 100644 index 00000000..9aa890a6 --- /dev/null +++ b/src/main/java/com/checkout/identities/faceauthentications/responses/FaceAuthenticationAttemptAssetType.java @@ -0,0 +1,15 @@ +package com.checkout.identities.faceauthentications.responses; + +import com.google.gson.annotations.SerializedName; + +/** + * The type of asset captured during a face authentication attempt. + */ +public enum FaceAuthenticationAttemptAssetType { + + @SerializedName("face_image") + FACE_IMAGE, + @SerializedName("face_video") + FACE_VIDEO + +} diff --git a/src/main/java/com/checkout/identities/faceauthentications/responses/FaceAuthenticationAttemptAssetsResponse.java b/src/main/java/com/checkout/identities/faceauthentications/responses/FaceAuthenticationAttemptAssetsResponse.java new file mode 100644 index 00000000..91e1fc7f --- /dev/null +++ b/src/main/java/com/checkout/identities/faceauthentications/responses/FaceAuthenticationAttemptAssetsResponse.java @@ -0,0 +1,45 @@ +package com.checkout.identities.faceauthentications.responses; + +import com.checkout.common.Resource; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.EqualsAndHashCode; +import lombok.NoArgsConstructor; + +import java.util.List; + +/** + * The paginated assets captured during a face authentication attempt. + */ +@Data +@EqualsAndHashCode(callSuper = false) +@Builder +@NoArgsConstructor +@AllArgsConstructor +public final class FaceAuthenticationAttemptAssetsResponse extends Resource { + + /** + * The total number of assets. + * [Required] + */ + private Integer totalCount; + + /** + * The number of assets skipped. + * [Required] + */ + private Integer skip; + + /** + * The maximum number of assets returned. + * [Required] + */ + private Integer limit; + + /** + * The list of assets for the current page. + * [Required] + */ + private List data; +} diff --git a/src/main/java/com/checkout/identities/identityverification/IdentityVerificationClient.java b/src/main/java/com/checkout/identities/identityverification/IdentityVerificationClient.java index 43de0ed2..ee6c714f 100644 --- a/src/main/java/com/checkout/identities/identityverification/IdentityVerificationClient.java +++ b/src/main/java/com/checkout/identities/identityverification/IdentityVerificationClient.java @@ -1,8 +1,10 @@ package com.checkout.identities.identityverification; +import com.checkout.identities.entities.AttemptAssetsQueryFilter; import com.checkout.identities.identityverification.requests.CreateAndOpenIdentityVerificationRequest; import com.checkout.identities.identityverification.requests.IdentityVerificationRequest; import com.checkout.identities.identityverification.requests.IdentityVerificationAttemptRequest; +import com.checkout.identities.identityverification.responses.IdentityVerificationAttemptAssetsResponse; import com.checkout.identities.identityverification.responses.IdentityVerificationAttemptResponse; import com.checkout.identities.identityverification.responses.IdentityVerificationAttemptsResponse; import com.checkout.identities.identityverification.responses.IdentityVerificationReportResponse; @@ -75,6 +77,16 @@ public interface IdentityVerificationClient { */ CompletableFuture getIdentityVerificationAttemptAsync(String identityVerificationId, String attemptId); + /** + * Retrieves the assets (face images, videos, and document images) captured during an identity verification attempt. + * + * @param identityVerificationId the identity verification ID + * @param attemptId the attempt ID + * @param queryFilter the pagination query parameters (skip and limit) + * @return a {@link CompletableFuture} containing the {@link IdentityVerificationAttemptAssetsResponse} + */ + CompletableFuture getIdentityVerificationAttemptAssetsAsync(String identityVerificationId, String attemptId, AttemptAssetsQueryFilter queryFilter); + /** * Generate and download a PDF report * @@ -143,6 +155,16 @@ public interface IdentityVerificationClient { */ IdentityVerificationAttemptResponse getIdentityVerificationAttempt(String identityVerificationId, String attemptId); + /** + * Retrieves the assets (face images, videos, and document images) captured during an identity verification attempt. + * + * @param identityVerificationId the identity verification ID + * @param attemptId the attempt ID + * @param queryFilter the pagination query parameters (skip and limit) + * @return the {@link IdentityVerificationAttemptAssetsResponse} + */ + IdentityVerificationAttemptAssetsResponse getIdentityVerificationAttemptAssets(String identityVerificationId, String attemptId, AttemptAssetsQueryFilter queryFilter); + /** * Generate and download a PDF report * diff --git a/src/main/java/com/checkout/identities/identityverification/IdentityVerificationClientImpl.java b/src/main/java/com/checkout/identities/identityverification/IdentityVerificationClientImpl.java index d3e9ec41..dd5d5ddc 100644 --- a/src/main/java/com/checkout/identities/identityverification/IdentityVerificationClientImpl.java +++ b/src/main/java/com/checkout/identities/identityverification/IdentityVerificationClientImpl.java @@ -4,9 +4,11 @@ import com.checkout.ApiClient; import com.checkout.CheckoutConfiguration; import com.checkout.SdkAuthorizationType; +import com.checkout.identities.entities.AttemptAssetsQueryFilter; import com.checkout.identities.identityverification.requests.CreateAndOpenIdentityVerificationRequest; import com.checkout.identities.identityverification.requests.IdentityVerificationRequest; import com.checkout.identities.identityverification.requests.IdentityVerificationAttemptRequest; +import com.checkout.identities.identityverification.responses.IdentityVerificationAttemptAssetsResponse; import com.checkout.identities.identityverification.responses.IdentityVerificationAttemptResponse; import com.checkout.identities.identityverification.responses.IdentityVerificationAttemptsResponse; import com.checkout.identities.identityverification.responses.IdentityVerificationReportResponse; @@ -26,6 +28,7 @@ public class IdentityVerificationClientImpl extends AbstractClient implements Id private static final String ANONYMIZE_PATH = "anonymize"; private static final String ATTEMPTS_PATH = "attempts"; private static final String PDF_REPORT_PATH = "pdf-report"; + private static final String ASSETS_PATH = "assets"; public IdentityVerificationClientImpl(final ApiClient apiClient, final CheckoutConfiguration configuration) { super(apiClient, configuration, SdkAuthorizationType.SECRET_KEY_OR_OAUTH); @@ -136,6 +139,22 @@ public CompletableFuture getIdentityVerific sdkAuthorization(), IdentityVerificationAttemptResponse.class); } + /** + * Retrieve the assets captured during an identity verification attempt + * + * @param identityVerificationId the identity verification ID + * @param attemptId the attempt ID + * @param queryFilter the pagination query parameters (skip and limit) + * @return a {@link CompletableFuture} containing the {@link IdentityVerificationAttemptAssetsResponse} + */ + @Override + public CompletableFuture getIdentityVerificationAttemptAssetsAsync( + final String identityVerificationId, final String attemptId, final AttemptAssetsQueryFilter queryFilter) { + validateParams("identityVerificationId", identityVerificationId, "attemptId", attemptId); + return apiClient.queryAsync(buildPath(IDENTITY_VERIFICATIONS_PATH, identityVerificationId, ATTEMPTS_PATH, attemptId, ASSETS_PATH), + sdkAuthorization(), queryFilter, IdentityVerificationAttemptAssetsResponse.class); + } + /** * Generate and download a PDF report * @@ -252,6 +271,22 @@ public IdentityVerificationAttemptResponse getIdentityVerificationAttempt( sdkAuthorization(), IdentityVerificationAttemptResponse.class); } + /** + * Retrieve the assets captured during an identity verification attempt + * + * @param identityVerificationId the identity verification ID + * @param attemptId the attempt ID + * @param queryFilter the pagination query parameters (skip and limit) + * @return the {@link IdentityVerificationAttemptAssetsResponse} + */ + @Override + public IdentityVerificationAttemptAssetsResponse getIdentityVerificationAttemptAssets( + final String identityVerificationId, final String attemptId, final AttemptAssetsQueryFilter queryFilter) { + validateParams("identityVerificationId", identityVerificationId, "attemptId", attemptId); + return apiClient.query(buildPath(IDENTITY_VERIFICATIONS_PATH, identityVerificationId, ATTEMPTS_PATH, attemptId, ASSETS_PATH), + sdkAuthorization(), queryFilter, IdentityVerificationAttemptAssetsResponse.class); + } + /** * Generate and download a PDF report * diff --git a/src/main/java/com/checkout/identities/identityverification/responses/IdentityVerificationAttemptAsset.java b/src/main/java/com/checkout/identities/identityverification/responses/IdentityVerificationAttemptAsset.java new file mode 100644 index 00000000..5944401e --- /dev/null +++ b/src/main/java/com/checkout/identities/identityverification/responses/IdentityVerificationAttemptAsset.java @@ -0,0 +1,32 @@ +package com.checkout.identities.identityverification.responses; + +import com.checkout.identities.entities.AttemptAssetLinks; +import com.google.gson.annotations.SerializedName; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +/** + * An asset (face image, video, or document image) captured during an identity verification attempt. + */ +@Data +@Builder +@NoArgsConstructor +@AllArgsConstructor +public final class IdentityVerificationAttemptAsset { + + /** + * The type of asset. + * [Required] + */ + private IdentityVerificationAttemptAssetType type; + + /** + * The links related to the asset. + * [Required] + */ + @SerializedName("_links") + private AttemptAssetLinks links; + +} diff --git a/src/main/java/com/checkout/identities/identityverification/responses/IdentityVerificationAttemptAssetType.java b/src/main/java/com/checkout/identities/identityverification/responses/IdentityVerificationAttemptAssetType.java new file mode 100644 index 00000000..5adc1082 --- /dev/null +++ b/src/main/java/com/checkout/identities/identityverification/responses/IdentityVerificationAttemptAssetType.java @@ -0,0 +1,35 @@ +package com.checkout.identities.identityverification.responses; + +import com.google.gson.annotations.SerializedName; + +/** + * The type of asset captured during an identity verification attempt. + */ +public enum IdentityVerificationAttemptAssetType { + + @SerializedName("face_image") + FACE_IMAGE, + @SerializedName("face_video") + FACE_VIDEO, + @SerializedName("document_front_image") + DOCUMENT_FRONT_IMAGE, + @SerializedName("document_back_image") + DOCUMENT_BACK_IMAGE, + @SerializedName("document_front_video") + DOCUMENT_FRONT_VIDEO, + @SerializedName("document_back_video") + DOCUMENT_BACK_VIDEO, + @SerializedName("document_signature_image") + DOCUMENT_SIGNATURE_IMAGE, + @SerializedName("secondary_document_front_image") + SECONDARY_DOCUMENT_FRONT_IMAGE, + @SerializedName("secondary_document_back_image") + SECONDARY_DOCUMENT_BACK_IMAGE, + @SerializedName("secondary_document_front_video") + SECONDARY_DOCUMENT_FRONT_VIDEO, + @SerializedName("secondary_document_back_video") + SECONDARY_DOCUMENT_BACK_VIDEO, + @SerializedName("secondary_document_signature_image") + SECONDARY_DOCUMENT_SIGNATURE_IMAGE + +} diff --git a/src/main/java/com/checkout/identities/identityverification/responses/IdentityVerificationAttemptAssetsResponse.java b/src/main/java/com/checkout/identities/identityverification/responses/IdentityVerificationAttemptAssetsResponse.java new file mode 100644 index 00000000..5880a456 --- /dev/null +++ b/src/main/java/com/checkout/identities/identityverification/responses/IdentityVerificationAttemptAssetsResponse.java @@ -0,0 +1,45 @@ +package com.checkout.identities.identityverification.responses; + +import com.checkout.common.Resource; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.EqualsAndHashCode; +import lombok.NoArgsConstructor; + +import java.util.List; + +/** + * The paginated assets captured during an identity verification attempt. + */ +@Data +@EqualsAndHashCode(callSuper = false) +@Builder +@NoArgsConstructor +@AllArgsConstructor +public final class IdentityVerificationAttemptAssetsResponse extends Resource { + + /** + * The total number of assets. + * [Required] + */ + private Integer totalCount; + + /** + * The number of assets skipped. + * [Required] + */ + private Integer skip; + + /** + * The maximum number of assets returned. + * [Required] + */ + private Integer limit; + + /** + * The list of assets for the current page. + * [Required] + */ + private List data; +} diff --git a/src/main/java/com/checkout/payments/ProcessingSettings.java b/src/main/java/com/checkout/payments/ProcessingSettings.java index f44fa997..27512718 100644 --- a/src/main/java/com/checkout/payments/ProcessingSettings.java +++ b/src/main/java/com/checkout/payments/ProcessingSettings.java @@ -310,4 +310,10 @@ public final class ProcessingSettings { */ private String partnerCode; + /** + * The scheme transaction link identifier. + * [Optional] + */ + private String schemeTransactionLinkId; + } diff --git a/src/main/java/com/checkout/payments/hosted/HostedPaymentRequest.java b/src/main/java/com/checkout/payments/hosted/HostedPaymentRequest.java index 801428ac..0cbb4d44 100644 --- a/src/main/java/com/checkout/payments/hosted/HostedPaymentRequest.java +++ b/src/main/java/com/checkout/payments/hosted/HostedPaymentRequest.java @@ -5,10 +5,12 @@ import com.checkout.common.CustomerRequest; import com.checkout.common.PaymentSourceType; import com.checkout.common.Product; +import com.checkout.payments.AuthorizationType; import com.checkout.payments.BillingDescriptor; import com.checkout.payments.BillingInformation; import com.checkout.payments.PaymentInstruction; import com.checkout.payments.LocaleType; +import com.checkout.payments.PaymentPlan; import com.checkout.payments.PaymentRecipient; import com.checkout.payments.PaymentType; import com.checkout.payments.ProcessingSettings; @@ -229,4 +231,18 @@ public final class HostedPaymentRequest { * [Optional] */ private PaymentMethodConfiguration paymentMethodConfiguration; + + /** + * The information to process a recurring payment request. To be used when the payment_type is Recurring. + * [Optional] + */ + private PaymentPlan paymentPlan; + + /** + * The authorization type. + * [Optional] + * Enum: "Final" "Estimated" + * Default: "Final" + */ + private AuthorizationType authorizationType; } diff --git a/src/main/java/com/checkout/payments/links/PaymentLinkRequest.java b/src/main/java/com/checkout/payments/links/PaymentLinkRequest.java index b612e4e4..37ea5680 100644 --- a/src/main/java/com/checkout/payments/links/PaymentLinkRequest.java +++ b/src/main/java/com/checkout/payments/links/PaymentLinkRequest.java @@ -5,10 +5,12 @@ import com.checkout.common.CustomerRequest; import com.checkout.common.PaymentSourceType; import com.checkout.common.Product; +import com.checkout.payments.AuthorizationType; import com.checkout.payments.BillingDescriptor; import com.checkout.payments.BillingInformation; import com.checkout.payments.LocaleType; import com.checkout.payments.PaymentMethodConfiguration; +import com.checkout.payments.PaymentPlan; import com.checkout.payments.PaymentRecipient; import com.checkout.payments.PaymentType; import com.checkout.payments.ProcessingSettings; @@ -216,4 +218,18 @@ public final class PaymentLinkRequest { * [Optional] */ private PaymentMethodConfiguration paymentMethodConfiguration; + + /** + * The information to process a recurring payment request. To be used when the payment_type is Recurring. + * [Optional] + */ + private PaymentPlan paymentPlan; + + /** + * The authorization type. + * [Optional] + * Enum: "Final" "Estimated" + * Default: "Final" + */ + private AuthorizationType authorizationType; } diff --git a/src/test/java/com/checkout/handlepaymentsandpayouts/flow/PaymentSessionSerializationTest.java b/src/test/java/com/checkout/handlepaymentsandpayouts/flow/PaymentSessionSerializationTest.java index d85a20a8..61359c20 100644 --- a/src/test/java/com/checkout/handlepaymentsandpayouts/flow/PaymentSessionSerializationTest.java +++ b/src/test/java/com/checkout/handlepaymentsandpayouts/flow/PaymentSessionSerializationTest.java @@ -5,7 +5,10 @@ import com.checkout.common.PaymentMethodType; import com.checkout.handlepaymentsandpayouts.flow.entities.Customer; import com.checkout.handlepaymentsandpayouts.flow.requests.PaymentSessionCreateRequest; +import com.checkout.payments.AmountVariabilityType; +import com.checkout.payments.AuthorizationType; import com.checkout.payments.LocaleType; +import com.checkout.payments.PaymentPlan; import com.checkout.payments.PaymentType; import org.junit.jupiter.api.Test; @@ -297,4 +300,49 @@ void shouldHandleLocalDateInCompactFormat() { assertEquals(LocalDate.of(2023, 1, 15), request.getCustomer().getSummary().getRegistrationDate()); }, "Should deserialize compact date format (yyyyMMdd)"); } + + @Test + void shouldSerializePaymentSessionWithAuthorizationTypeAndPaymentPlan() { + PaymentSessionCreateRequest request = PaymentSessionCreateRequest.builder() + .amount(1234L) + .currency(Currency.USD) + .reference("plan-ref") + .authorizationType(AuthorizationType.ESTIMATED) + .paymentPlan(PaymentPlan.builder() + .amountVariabilityType(AmountVariabilityType.VARIABLE) + .amount(1234L) + .totalNumberOfPayments(5) + .name("Subscription 1234") + .build()) + .build(); + + final String json = serializer.toJson(request); + + assertTrue(json.contains("\"authorization_type\":\"Estimated\"")); + assertTrue(json.contains("\"payment_plan\"")); + assertTrue(json.contains("\"amount_variability\":\"Variable\"")); + } + + @Test + void shouldDeserializePaymentSessionWithAuthorizationTypeAndPaymentPlan() { + String json = "{" + + "\"amount\":500," + + "\"currency\":\"USD\"," + + "\"authorization_type\":\"Final\"," + + "\"payment_plan\":{" + + " \"amount_variability\":\"Fixed\"," + + " \"amount\":500," + + " \"total_number_of_payments\":6" + + "}" + + "}"; + + PaymentSessionCreateRequest request = serializer.fromJson(json, PaymentSessionCreateRequest.class); + + assertNotNull(request); + assertEquals(AuthorizationType.FINAL, request.getAuthorizationType()); + assertNotNull(request.getPaymentPlan()); + assertEquals(AmountVariabilityType.FIXED, request.getPaymentPlan().getAmountVariabilityType()); + assertEquals(500L, request.getPaymentPlan().getAmount()); + assertEquals(6, request.getPaymentPlan().getTotalNumberOfPayments()); + } } diff --git a/src/test/java/com/checkout/identities/faceauthentications/FaceAuthenticationAttemptAssetsResponseSerializationTest.java b/src/test/java/com/checkout/identities/faceauthentications/FaceAuthenticationAttemptAssetsResponseSerializationTest.java new file mode 100644 index 00000000..b73f9290 --- /dev/null +++ b/src/test/java/com/checkout/identities/faceauthentications/FaceAuthenticationAttemptAssetsResponseSerializationTest.java @@ -0,0 +1,113 @@ +package com.checkout.identities.faceauthentications; + +import com.checkout.GsonSerializer; +import com.checkout.common.Link; +import com.checkout.identities.entities.AttemptAssetLinks; +import com.checkout.identities.faceauthentications.responses.FaceAuthenticationAttemptAsset; +import com.checkout.identities.faceauthentications.responses.FaceAuthenticationAttemptAssetType; +import com.checkout.identities.faceauthentications.responses.FaceAuthenticationAttemptAssetsResponse; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.EnumSource; + +import java.util.Collections; + +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class FaceAuthenticationAttemptAssetsResponseSerializationTest { + + private final GsonSerializer serializer = new GsonSerializer(); + + @Test + void shouldSerializeWithAllProperties() { + final FaceAuthenticationAttemptAssetsResponse response = FaceAuthenticationAttemptAssetsResponse.builder() + .totalCount(1) + .skip(0) + .limit(10) + .data(Collections.singletonList(FaceAuthenticationAttemptAsset.builder() + .type(FaceAuthenticationAttemptAssetType.FACE_IMAGE) + .links(AttemptAssetLinks.builder() + .assetUrl(new Link("https://example.com/face-image.jpg", null, null)) + .build()) + .build())) + .build(); + + assertDoesNotThrow(() -> serializer.toJson(response)); + } + + @Test + void shouldDeserializeFromSwaggerExample() { + final String json = "{" + + "\"total_count\":2," + + "\"skip\":0," + + "\"limit\":10," + + "\"data\":[" + + " {\"type\":\"face_image\",\"_links\":{\"asset_url\":{\"href\":\"https://example.com/face-image.jpg\"}}}," + + " {\"type\":\"face_video\",\"_links\":{\"asset_url\":{\"href\":\"https://example.com/face-video.mp4\"}}}" + + "]," + + "\"_links\":{" + + " \"self\":{\"href\":\"https://example.com/assets\"}," + + " \"next\":{\"href\":\"https://example.com/assets?skip=10\"}" + + "}" + + "}"; + + final FaceAuthenticationAttemptAssetsResponse response = + serializer.fromJson(json, FaceAuthenticationAttemptAssetsResponse.class); + + assertNotNull(response); + assertEquals(2, response.getTotalCount()); + assertEquals(0, response.getSkip()); + assertEquals(10, response.getLimit()); + assertNotNull(response.getData()); + assertEquals(2, response.getData().size()); + assertEquals(FaceAuthenticationAttemptAssetType.FACE_IMAGE, response.getData().get(0).getType()); + assertNotNull(response.getData().get(0).getLinks()); + assertNotNull(response.getData().get(0).getLinks().getAssetUrl()); + assertEquals("https://example.com/face-image.jpg", response.getData().get(0).getLinks().getAssetUrl().getHref()); + assertEquals(FaceAuthenticationAttemptAssetType.FACE_VIDEO, response.getData().get(1).getType()); + assertNotNull(response.getSelfLink()); + } + + @Test + void shouldRoundTripSerialize() { + final FaceAuthenticationAttemptAssetsResponse original = FaceAuthenticationAttemptAssetsResponse.builder() + .totalCount(1) + .skip(5) + .limit(20) + .data(Collections.singletonList(FaceAuthenticationAttemptAsset.builder() + .type(FaceAuthenticationAttemptAssetType.FACE_VIDEO) + .links(AttemptAssetLinks.builder() + .assetUrl(new Link("https://example.com/face-video.mp4", null, null)) + .build()) + .build())) + .build(); + + final String json = serializer.toJson(original); + final FaceAuthenticationAttemptAssetsResponse deserialized = + serializer.fromJson(json, FaceAuthenticationAttemptAssetsResponse.class); + + assertTrue(json.contains("\"total_count\":1")); + assertTrue(json.contains("\"asset_url\"")); + assertEquals(1, deserialized.getTotalCount()); + assertEquals(5, deserialized.getSkip()); + assertEquals(20, deserialized.getLimit()); + assertEquals(1, deserialized.getData().size()); + assertEquals(FaceAuthenticationAttemptAssetType.FACE_VIDEO, deserialized.getData().get(0).getType()); + assertEquals("https://example.com/face-video.mp4", deserialized.getData().get(0).getLinks().getAssetUrl().getHref()); + } + + @ParameterizedTest + @EnumSource(FaceAuthenticationAttemptAssetType.class) + void shouldSerializeEachAssetTypeToSwaggerValue(final FaceAuthenticationAttemptAssetType type) { + final FaceAuthenticationAttemptAsset asset = FaceAuthenticationAttemptAsset.builder() + .type(type) + .build(); + + final String json = serializer.toJson(asset); + + assertTrue(json.contains("\"type\":\"" + type.name().toLowerCase() + "\"")); + } +} diff --git a/src/test/java/com/checkout/identities/faceauthentications/FaceAuthenticationClientImplTest.java b/src/test/java/com/checkout/identities/faceauthentications/FaceAuthenticationClientImplTest.java index 2a62558b..0caef866 100644 --- a/src/test/java/com/checkout/identities/faceauthentications/FaceAuthenticationClientImplTest.java +++ b/src/test/java/com/checkout/identities/faceauthentications/FaceAuthenticationClientImplTest.java @@ -5,8 +5,10 @@ import com.checkout.SdkAuthorization; import com.checkout.SdkAuthorizationType; import com.checkout.SdkCredentials; +import com.checkout.identities.entities.AttemptAssetsQueryFilter; import com.checkout.identities.faceauthentications.requests.FaceAuthenticationAttemptRequest; import com.checkout.identities.faceauthentications.requests.FaceAuthenticationRequest; +import com.checkout.identities.faceauthentications.responses.FaceAuthenticationAttemptAssetsResponse; import com.checkout.identities.faceauthentications.responses.FaceAuthenticationAttemptResponse; import com.checkout.identities.faceauthentications.responses.FaceAuthenticationAttemptsResponse; import com.checkout.identities.faceauthentications.responses.FaceAuthenticationResponse; @@ -135,13 +137,31 @@ void shouldGetFaceAuthenticationAttempt() throws ExecutionException, Interrupted authorization, FaceAuthenticationAttemptResponse.class)) .thenReturn(CompletableFuture.completedFuture(response)); - final CompletableFuture future = + final CompletableFuture future = client.getFaceAuthenticationAttempt(faceAuthenticationId, attemptId); assertNotNull(future.get()); assertEquals(response, future.get()); } + @Test + void shouldGetFaceAuthenticationAttemptAssets() throws ExecutionException, InterruptedException { + final String faceAuthenticationId = "fav_test_123456789"; + final String attemptId = "fatp_test_987654321"; + final AttemptAssetsQueryFilter queryFilter = AttemptAssetsQueryFilter.builder().skip(0).limit(10).build(); + final FaceAuthenticationAttemptAssetsResponse response = mock(FaceAuthenticationAttemptAssetsResponse.class); + + when(apiClient.queryAsync("face-authentications/" + faceAuthenticationId + "/attempts/" + attemptId + "/assets", + authorization, queryFilter, FaceAuthenticationAttemptAssetsResponse.class)) + .thenReturn(CompletableFuture.completedFuture(response)); + + final CompletableFuture future = + client.getFaceAuthenticationAttemptAssets(faceAuthenticationId, attemptId, queryFilter); + + assertNotNull(future.get()); + assertEquals(response, future.get()); + } + // Synchronous methods tests @Test @@ -231,10 +251,28 @@ void shouldGetFaceAuthenticationAttemptSync() { authorization, FaceAuthenticationAttemptResponse.class)) .thenReturn(response); - final FaceAuthenticationAttemptResponse result = + final FaceAuthenticationAttemptResponse result = client.getFaceAuthenticationAttemptSync(faceAuthenticationId, attemptId); assertNotNull(result); assertEquals(response, result); } + + @Test + void shouldGetFaceAuthenticationAttemptAssetsSync() { + final String faceAuthenticationId = "fav_test_123456789"; + final String attemptId = "fatp_test_987654321"; + final AttemptAssetsQueryFilter queryFilter = AttemptAssetsQueryFilter.builder().skip(0).limit(10).build(); + final FaceAuthenticationAttemptAssetsResponse response = mock(FaceAuthenticationAttemptAssetsResponse.class); + + when(apiClient.query("face-authentications/" + faceAuthenticationId + "/attempts/" + attemptId + "/assets", + authorization, queryFilter, FaceAuthenticationAttemptAssetsResponse.class)) + .thenReturn(response); + + final FaceAuthenticationAttemptAssetsResponse result = + client.getFaceAuthenticationAttemptAssetsSync(faceAuthenticationId, attemptId, queryFilter); + + assertNotNull(result); + assertEquals(response, result); + } } \ No newline at end of file diff --git a/src/test/java/com/checkout/identities/faceauthentications/FaceAuthenticationTestIT.java b/src/test/java/com/checkout/identities/faceauthentications/FaceAuthenticationTestIT.java index b04268db..f94135f9 100644 --- a/src/test/java/com/checkout/identities/faceauthentications/FaceAuthenticationTestIT.java +++ b/src/test/java/com/checkout/identities/faceauthentications/FaceAuthenticationTestIT.java @@ -2,9 +2,11 @@ import com.checkout.PlatformType; import com.checkout.SandboxTestFixture; +import com.checkout.identities.entities.AttemptAssetsQueryFilter; import com.checkout.identities.entities.ClientInformation; import com.checkout.identities.faceauthentications.requests.FaceAuthenticationAttemptRequest; import com.checkout.identities.faceauthentications.requests.FaceAuthenticationRequest; +import com.checkout.identities.faceauthentications.responses.FaceAuthenticationAttemptAssetsResponse; import com.checkout.identities.faceauthentications.responses.FaceAuthenticationAttemptResponse; import com.checkout.identities.faceauthentications.responses.FaceAuthenticationAttemptsResponse; import com.checkout.identities.faceauthentications.responses.FaceAuthenticationResponse; @@ -125,6 +127,27 @@ void shouldGetFaceAuthenticationAttempt() { validateRetrievedFaceAuthenticationAttempt(retrievedAttempt, createdAttempt); } + @Test + @Disabled("Integration test - requires valid face authentication and attempt IDs") + void shouldGetFaceAuthenticationAttemptAssets() { + // Arrange + final FaceAuthenticationRequest request = createFaceAuthenticationRequest(); + final FaceAuthenticationResponse created = blocking(() -> + checkoutApi.faceAuthenticationClient().createFaceAuthentication(request)); + final FaceAuthenticationAttemptRequest attemptRequest = createFaceAuthenticationAttemptRequest(); + final FaceAuthenticationAttemptResponse createdAttempt = blocking(() -> + checkoutApi.faceAuthenticationClient().createFaceAuthenticationAttempt(created.getId(), attemptRequest)); + final AttemptAssetsQueryFilter queryFilter = AttemptAssetsQueryFilter.builder().skip(0).limit(10).build(); + + // Act + final FaceAuthenticationAttemptAssetsResponse assets = blocking(() -> + checkoutApi.faceAuthenticationClient().getFaceAuthenticationAttemptAssets(created.getId(), createdAttempt.getId(), queryFilter)); + + // Assert + assertNotNull(assets); + assertNotNull(assets.getData()); + } + @Test @Disabled("Integration test - comprehensive workflow test") void shouldPerformFaceAuthenticationWorkflow() { diff --git a/src/test/java/com/checkout/identities/identityverification/IdentityVerificationAttemptAssetsResponseSerializationTest.java b/src/test/java/com/checkout/identities/identityverification/IdentityVerificationAttemptAssetsResponseSerializationTest.java new file mode 100644 index 00000000..cebeb4e8 --- /dev/null +++ b/src/test/java/com/checkout/identities/identityverification/IdentityVerificationAttemptAssetsResponseSerializationTest.java @@ -0,0 +1,113 @@ +package com.checkout.identities.identityverification; + +import com.checkout.GsonSerializer; +import com.checkout.common.Link; +import com.checkout.identities.entities.AttemptAssetLinks; +import com.checkout.identities.identityverification.responses.IdentityVerificationAttemptAsset; +import com.checkout.identities.identityverification.responses.IdentityVerificationAttemptAssetType; +import com.checkout.identities.identityverification.responses.IdentityVerificationAttemptAssetsResponse; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.EnumSource; + +import java.util.Collections; + +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class IdentityVerificationAttemptAssetsResponseSerializationTest { + + private final GsonSerializer serializer = new GsonSerializer(); + + @Test + void shouldSerializeWithAllProperties() { + final IdentityVerificationAttemptAssetsResponse response = IdentityVerificationAttemptAssetsResponse.builder() + .totalCount(1) + .skip(0) + .limit(10) + .data(Collections.singletonList(IdentityVerificationAttemptAsset.builder() + .type(IdentityVerificationAttemptAssetType.DOCUMENT_FRONT_IMAGE) + .links(AttemptAssetLinks.builder() + .assetUrl(new Link("https://example.com/document-front.jpg", null, null)) + .build()) + .build())) + .build(); + + assertDoesNotThrow(() -> serializer.toJson(response)); + } + + @Test + void shouldDeserializeFromSwaggerExample() { + final String json = "{" + + "\"total_count\":2," + + "\"skip\":0," + + "\"limit\":10," + + "\"data\":[" + + " {\"type\":\"document_front_image\",\"_links\":{\"asset_url\":{\"href\":\"https://example.com/document-front.jpg\"}}}," + + " {\"type\":\"face_image\",\"_links\":{\"asset_url\":{\"href\":\"https://example.com/face-image.jpg\"}}}" + + "]," + + "\"_links\":{" + + " \"self\":{\"href\":\"https://example.com/assets\"}," + + " \"previous\":{\"href\":\"https://example.com/assets?skip=0\"}" + + "}" + + "}"; + + final IdentityVerificationAttemptAssetsResponse response = + serializer.fromJson(json, IdentityVerificationAttemptAssetsResponse.class); + + assertNotNull(response); + assertEquals(2, response.getTotalCount()); + assertEquals(0, response.getSkip()); + assertEquals(10, response.getLimit()); + assertNotNull(response.getData()); + assertEquals(2, response.getData().size()); + assertEquals(IdentityVerificationAttemptAssetType.DOCUMENT_FRONT_IMAGE, response.getData().get(0).getType()); + assertNotNull(response.getData().get(0).getLinks()); + assertNotNull(response.getData().get(0).getLinks().getAssetUrl()); + assertEquals("https://example.com/document-front.jpg", response.getData().get(0).getLinks().getAssetUrl().getHref()); + assertEquals(IdentityVerificationAttemptAssetType.FACE_IMAGE, response.getData().get(1).getType()); + assertNotNull(response.getSelfLink()); + } + + @Test + void shouldRoundTripSerialize() { + final IdentityVerificationAttemptAssetsResponse original = IdentityVerificationAttemptAssetsResponse.builder() + .totalCount(1) + .skip(5) + .limit(20) + .data(Collections.singletonList(IdentityVerificationAttemptAsset.builder() + .type(IdentityVerificationAttemptAssetType.SECONDARY_DOCUMENT_SIGNATURE_IMAGE) + .links(AttemptAssetLinks.builder() + .assetUrl(new Link("https://example.com/signature.jpg", null, null)) + .build()) + .build())) + .build(); + + final String json = serializer.toJson(original); + final IdentityVerificationAttemptAssetsResponse deserialized = + serializer.fromJson(json, IdentityVerificationAttemptAssetsResponse.class); + + assertTrue(json.contains("\"total_count\":1")); + assertTrue(json.contains("\"asset_url\"")); + assertEquals(1, deserialized.getTotalCount()); + assertEquals(5, deserialized.getSkip()); + assertEquals(20, deserialized.getLimit()); + assertEquals(1, deserialized.getData().size()); + assertEquals(IdentityVerificationAttemptAssetType.SECONDARY_DOCUMENT_SIGNATURE_IMAGE, deserialized.getData().get(0).getType()); + assertEquals("https://example.com/signature.jpg", deserialized.getData().get(0).getLinks().getAssetUrl().getHref()); + } + + @ParameterizedTest + @EnumSource(IdentityVerificationAttemptAssetType.class) + void shouldSerializeEachAssetTypeToSwaggerValue(final IdentityVerificationAttemptAssetType type) { + final IdentityVerificationAttemptAsset asset = IdentityVerificationAttemptAsset.builder() + .type(type) + .build(); + + final String json = serializer.toJson(asset); + + assertTrue(json.contains("\"type\":\"" + type.name().toLowerCase() + "\"")); + } +} diff --git a/src/test/java/com/checkout/identities/identityverification/IdentityVerificationClientImplTest.java b/src/test/java/com/checkout/identities/identityverification/IdentityVerificationClientImplTest.java index a3ce1790..d844921e 100644 --- a/src/test/java/com/checkout/identities/identityverification/IdentityVerificationClientImplTest.java +++ b/src/test/java/com/checkout/identities/identityverification/IdentityVerificationClientImplTest.java @@ -5,9 +5,11 @@ import com.checkout.SdkAuthorization; import com.checkout.SdkAuthorizationType; import com.checkout.SdkCredentials; +import com.checkout.identities.entities.AttemptAssetsQueryFilter; import com.checkout.identities.identityverification.requests.CreateAndOpenIdentityVerificationRequest; import com.checkout.identities.identityverification.requests.IdentityVerificationRequest; import com.checkout.identities.identityverification.requests.IdentityVerificationAttemptRequest; +import com.checkout.identities.identityverification.responses.IdentityVerificationAttemptAssetsResponse; import com.checkout.identities.identityverification.responses.IdentityVerificationAttemptResponse; import com.checkout.identities.identityverification.responses.IdentityVerificationAttemptsResponse; import com.checkout.identities.identityverification.responses.IdentityVerificationReportResponse; @@ -159,6 +161,24 @@ void shouldGetIdentityVerificationAttemptAsync() throws ExecutionException, Inte assertEquals(response, future.get()); } + @Test + void shouldGetIdentityVerificationAttemptAssetsAsync() throws ExecutionException, InterruptedException { + final String identityVerificationId = "idv_test_123456789"; + final String attemptId = "idva_test_987654321"; + final AttemptAssetsQueryFilter queryFilter = AttemptAssetsQueryFilter.builder().skip(0).limit(10).build(); + final IdentityVerificationAttemptAssetsResponse response = mock(IdentityVerificationAttemptAssetsResponse.class); + + when(apiClient.queryAsync("identity-verifications/" + identityVerificationId + "/attempts/" + attemptId + "/assets", + authorization, queryFilter, IdentityVerificationAttemptAssetsResponse.class)) + .thenReturn(CompletableFuture.completedFuture(response)); + + final CompletableFuture future = + client.getIdentityVerificationAttemptAssetsAsync(identityVerificationId, attemptId, queryFilter); + + assertNotNull(future.get()); + assertEquals(response, future.get()); + } + @Test void shouldGenerateIdentityVerificationReportAsync() throws ExecutionException, InterruptedException { final String identityVerificationId = "idv_test_123456789"; @@ -283,6 +303,24 @@ void shouldGetIdentityVerificationAttempt() { assertEquals(response, result); } + @Test + void shouldGetIdentityVerificationAttemptAssets() { + final String identityVerificationId = "idv_test_123456789"; + final String attemptId = "idva_test_987654321"; + final AttemptAssetsQueryFilter queryFilter = AttemptAssetsQueryFilter.builder().skip(0).limit(10).build(); + final IdentityVerificationAttemptAssetsResponse response = mock(IdentityVerificationAttemptAssetsResponse.class); + + when(apiClient.query("identity-verifications/" + identityVerificationId + "/attempts/" + attemptId + "/assets", + authorization, queryFilter, IdentityVerificationAttemptAssetsResponse.class)) + .thenReturn(response); + + final IdentityVerificationAttemptAssetsResponse result = + client.getIdentityVerificationAttemptAssets(identityVerificationId, attemptId, queryFilter); + + assertNotNull(result); + assertEquals(response, result); + } + @Test void shouldGenerateIdentityVerificationReport() { final String identityVerificationId = "idv_test_123456789"; diff --git a/src/test/java/com/checkout/identities/identityverification/IdentityVerificationTestIT.java b/src/test/java/com/checkout/identities/identityverification/IdentityVerificationTestIT.java index 259f3e10..62624c5a 100644 --- a/src/test/java/com/checkout/identities/identityverification/IdentityVerificationTestIT.java +++ b/src/test/java/com/checkout/identities/identityverification/IdentityVerificationTestIT.java @@ -2,11 +2,13 @@ import com.checkout.PlatformType; import com.checkout.SandboxTestFixture; +import com.checkout.identities.entities.AttemptAssetsQueryFilter; import com.checkout.identities.entities.ClientInformation; import com.checkout.identities.entities.DeclaredData; import com.checkout.identities.identityverification.requests.CreateAndOpenIdentityVerificationRequest; import com.checkout.identities.identityverification.requests.IdentityVerificationRequest; import com.checkout.identities.identityverification.requests.IdentityVerificationAttemptRequest; +import com.checkout.identities.identityverification.responses.IdentityVerificationAttemptAssetsResponse; import com.checkout.identities.identityverification.responses.IdentityVerificationAttemptResponse; import com.checkout.identities.identityverification.responses.IdentityVerificationAttemptsResponse; import com.checkout.identities.identityverification.responses.IdentityVerificationReportResponse; @@ -262,6 +264,24 @@ void shouldGetIdentityVerificationAttempt() { validateRetrievedIdentityVerificationAttempt(retrievedAttempt, createdAttempt); } + @Test + @Disabled("Integration test - requires valid identity verification and attempt IDs") + void shouldGetIdentityVerificationAttemptAssets() { + // Arrange + final IdentityVerificationRequest request = createIdentityVerificationRequest(); + final IdentityVerificationResponse created = checkoutApi.identityVerificationClient().createIdentityVerification(request); + final IdentityVerificationAttemptRequest attemptRequest = createIdentityVerificationAttemptRequest(); + final IdentityVerificationAttemptResponse createdAttempt = checkoutApi.identityVerificationClient().createIdentityVerificationAttempt(created.getId(), attemptRequest); + final AttemptAssetsQueryFilter queryFilter = AttemptAssetsQueryFilter.builder().skip(0).limit(10).build(); + + // Act + final IdentityVerificationAttemptAssetsResponse assets = checkoutApi.identityVerificationClient().getIdentityVerificationAttemptAssets(created.getId(), createdAttempt.getId(), queryFilter); + + // Assert + assertNotNull(assets); + assertNotNull(assets.getData()); + } + @Test @Disabled("Integration test - requires valid identity verification ID") void shouldGenerateIdentityVerificationReport() { diff --git a/src/test/java/com/checkout/payments/ProcessingSettingsSerializationTest.java b/src/test/java/com/checkout/payments/ProcessingSettingsSerializationTest.java index c890349b..ab97bad5 100644 --- a/src/test/java/com/checkout/payments/ProcessingSettingsSerializationTest.java +++ b/src/test/java/com/checkout/payments/ProcessingSettingsSerializationTest.java @@ -202,4 +202,25 @@ void shouldHandleAbsentOptionalFields() { assertNull(settings.getAffiliateId()); assertNull(settings.getCardType()); } + + @Test + void shouldSerializeSchemeTransactionLinkId() { + final ProcessingSettings settings = ProcessingSettings.builder() + .schemeTransactionLinkId("MTL-001") + .build(); + + final String json = serializer.toJson(settings); + + assertTrue(json.contains("\"scheme_transaction_link_id\":\"MTL-001\"")); + } + + @Test + void shouldDeserializeSchemeTransactionLinkId() { + final String json = "{\"scheme_transaction_link_id\":\"MTL-001\"}"; + + final ProcessingSettings settings = serializer.fromJson(json, ProcessingSettings.class); + + assertNotNull(settings); + assertEquals("MTL-001", settings.getSchemeTransactionLinkId()); + } } diff --git a/src/test/java/com/checkout/payments/hosted/HostedPaymentRequestSerializationTest.java b/src/test/java/com/checkout/payments/hosted/HostedPaymentRequestSerializationTest.java index 5378dca0..99ecd10c 100644 --- a/src/test/java/com/checkout/payments/hosted/HostedPaymentRequestSerializationTest.java +++ b/src/test/java/com/checkout/payments/hosted/HostedPaymentRequestSerializationTest.java @@ -4,7 +4,10 @@ import com.checkout.common.Address; import com.checkout.common.CountryCode; import com.checkout.common.Currency; +import com.checkout.payments.AmountVariabilityType; +import com.checkout.payments.AuthorizationType; import com.checkout.payments.BillingInformation; +import com.checkout.payments.PaymentPlan; import com.checkout.payments.PaymentType; import org.junit.jupiter.api.Test; @@ -219,4 +222,63 @@ void shouldHandleAbsentOptionalFields() { assertNull(request.getCancelUrl()); assertNull(request.getFailureUrl()); } + + @Test + void shouldSerializeAuthorizationType() { + final HostedPaymentRequest request = HostedPaymentRequest.builder() + .currency(Currency.USD) + .authorizationType(AuthorizationType.ESTIMATED) + .build(); + + final String json = serializer.toJson(request); + + assertTrue(json.contains("\"authorization_type\":\"Estimated\"")); + } + + @Test + void shouldSerializePaymentPlan() { + final HostedPaymentRequest request = HostedPaymentRequest.builder() + .currency(Currency.USD) + .paymentPlan(PaymentPlan.builder() + .amountVariabilityType(AmountVariabilityType.VARIABLE) + .amount(1234L) + .daysBetweenPayments(28) + .totalNumberOfPayments(5) + .currentPaymentNumber(3) + .expiry("20251031") + .name("Subscription 1234") + .startDate("20260507") + .build()) + .build(); + + final String json = serializer.toJson(request); + + assertTrue(json.contains("\"payment_plan\"")); + assertTrue(json.contains("\"amount_variability\":\"Variable\"")); + } + + @Test + void shouldDeserializePaymentPlanAndAuthorizationType() { + final String json = "{" + + "\"currency\":\"USD\"," + + "\"authorization_type\":\"Estimated\"," + + "\"payment_plan\":{" + + "\"amount_variability\":\"Fixed\"," + + "\"amount\":999," + + "\"days_between_payments\":30," + + "\"total_number_of_payments\":12," + + "\"name\":\"Plan A\"" + + "}}"; + + final HostedPaymentRequest request = serializer.fromJson(json, HostedPaymentRequest.class); + + assertNotNull(request); + assertEquals(AuthorizationType.ESTIMATED, request.getAuthorizationType()); + assertNotNull(request.getPaymentPlan()); + assertEquals(AmountVariabilityType.FIXED, request.getPaymentPlan().getAmountVariabilityType()); + assertEquals(999L, request.getPaymentPlan().getAmount()); + assertEquals(30, request.getPaymentPlan().getDaysBetweenPayments()); + assertEquals(12, request.getPaymentPlan().getTotalNumberOfPayments()); + assertEquals("Plan A", request.getPaymentPlan().getName()); + } } diff --git a/src/test/java/com/checkout/payments/links/PaymentLinkRequestSerializationTest.java b/src/test/java/com/checkout/payments/links/PaymentLinkRequestSerializationTest.java index edf89097..38d24a77 100644 --- a/src/test/java/com/checkout/payments/links/PaymentLinkRequestSerializationTest.java +++ b/src/test/java/com/checkout/payments/links/PaymentLinkRequestSerializationTest.java @@ -4,7 +4,10 @@ import com.checkout.common.Address; import com.checkout.common.CountryCode; import com.checkout.common.Currency; +import com.checkout.payments.AmountVariabilityType; +import com.checkout.payments.AuthorizationType; import com.checkout.payments.BillingInformation; +import com.checkout.payments.PaymentPlan; import com.checkout.payments.PaymentType; import org.junit.jupiter.api.Test; @@ -213,4 +216,66 @@ void shouldHandleAbsentOptionalFields() { assertNull(request.getReturnUrl()); assertNull(request.getDescription()); } + + @Test + void shouldSerializeAuthorizationType() { + final PaymentLinkRequest request = PaymentLinkRequest.builder() + .amount(1000L) + .currency(Currency.USD) + .authorizationType(AuthorizationType.ESTIMATED) + .build(); + + final String json = serializer.toJson(request); + + assertTrue(json.contains("\"authorization_type\":\"Estimated\"")); + } + + @Test + void shouldSerializePaymentPlan() { + final PaymentLinkRequest request = PaymentLinkRequest.builder() + .amount(1000L) + .currency(Currency.USD) + .paymentPlan(PaymentPlan.builder() + .amountVariabilityType(AmountVariabilityType.VARIABLE) + .amount(1234L) + .daysBetweenPayments(28) + .totalNumberOfPayments(5) + .currentPaymentNumber(3) + .expiry("20251031") + .name("Subscription 1234") + .startDate("20260507") + .build()) + .build(); + + final String json = serializer.toJson(request); + + assertTrue(json.contains("\"payment_plan\"")); + assertTrue(json.contains("\"amount_variability\":\"Variable\"")); + } + + @Test + void shouldDeserializePaymentPlanAndAuthorizationType() { + final String json = "{" + + "\"amount\":500," + + "\"currency\":\"USD\"," + + "\"authorization_type\":\"Estimated\"," + + "\"payment_plan\":{" + + "\"amount_variability\":\"Fixed\"," + + "\"amount\":999," + + "\"days_between_payments\":30," + + "\"total_number_of_payments\":12," + + "\"name\":\"Plan A\"" + + "}}"; + + final PaymentLinkRequest request = serializer.fromJson(json, PaymentLinkRequest.class); + + assertNotNull(request); + assertEquals(AuthorizationType.ESTIMATED, request.getAuthorizationType()); + assertNotNull(request.getPaymentPlan()); + assertEquals(AmountVariabilityType.FIXED, request.getPaymentPlan().getAmountVariabilityType()); + assertEquals(999L, request.getPaymentPlan().getAmount()); + assertEquals(30, request.getPaymentPlan().getDaysBetweenPayments()); + assertEquals(12, request.getPaymentPlan().getTotalNumberOfPayments()); + assertEquals("Plan A", request.getPaymentPlan().getName()); + } } From 48192f0ae7e588f4f16a6413cd753e58c5c884db Mon Sep 17 00:00:00 2001 From: david ruiz Date: Thu, 18 Jun 2026 15:34:16 +0200 Subject: [PATCH 2/3] Reconcilate naming async/sync styandard - breaking change --- .../amlscreening/AmlScreeningClient.java | 8 +- .../amlscreening/AmlScreeningClientImpl.java | 8 +- .../IdDocumentVerificationClient.java | 28 ++--- .../IdDocumentVerificationClientImpl.java | 28 ++--- .../IdentityVerificationClient.java | 36 +++--- .../IdentityVerificationClientImpl.java | 36 +++--- .../previous/ReconciliationClient.java | 2 +- .../previous/ReconciliationClientImpl.java | 2 +- .../AmlScreeningClientImplTest.java | 8 +- .../amlscreening/AmlScreeningTestIT.java | 12 +- .../IdDocumentVerificationClientImplTest.java | 56 +++++----- .../IdDocumentVerificationTestIT.java | 60 +++++----- .../IdentityVerificationClientImplTest.java | 72 ++++++------ .../IdentityVerificationTestIT.java | 104 +++++++++--------- .../ReconciliationClientImplTest.java | 4 +- .../previous/ReconciliationTestIT.java | 2 +- 16 files changed, 233 insertions(+), 233 deletions(-) diff --git a/src/main/java/com/checkout/identities/amlscreening/AmlScreeningClient.java b/src/main/java/com/checkout/identities/amlscreening/AmlScreeningClient.java index 898bc084..edfa6fbd 100644 --- a/src/main/java/com/checkout/identities/amlscreening/AmlScreeningClient.java +++ b/src/main/java/com/checkout/identities/amlscreening/AmlScreeningClient.java @@ -18,7 +18,7 @@ public interface AmlScreeningClient { * @param amlScreeningRequest the {@link AmlScreeningRequest} * @return a {@link CompletableFuture} of {@link AmlScreeningResponse} */ - CompletableFuture createAmlScreeningAsync(AmlScreeningRequest amlScreeningRequest); + CompletableFuture createAmlScreening(AmlScreeningRequest amlScreeningRequest); /** * Get an AML screening @@ -26,7 +26,7 @@ public interface AmlScreeningClient { * @param amlScreeningId the AML screening's unique identifier * @return a {@link CompletableFuture} of {@link AmlScreeningResponse} */ - CompletableFuture getAmlScreeningAsync(String amlScreeningId); + CompletableFuture getAmlScreening(String amlScreeningId); // Sync methods @@ -36,7 +36,7 @@ public interface AmlScreeningClient { * @param amlScreeningRequest the {@link AmlScreeningRequest} * @return a {@link AmlScreeningResponse} */ - AmlScreeningResponse createAmlScreening(AmlScreeningRequest amlScreeningRequest); + AmlScreeningResponse createAmlScreeningSync(AmlScreeningRequest amlScreeningRequest); /** * Get an AML screening @@ -44,6 +44,6 @@ public interface AmlScreeningClient { * @param amlScreeningId the AML screening's unique identifier * @return a {@link AmlScreeningResponse} */ - AmlScreeningResponse getAmlScreening(String amlScreeningId); + AmlScreeningResponse getAmlScreeningSync(String amlScreeningId); } \ No newline at end of file diff --git a/src/main/java/com/checkout/identities/amlscreening/AmlScreeningClientImpl.java b/src/main/java/com/checkout/identities/amlscreening/AmlScreeningClientImpl.java index 53e3698c..2afee6b9 100644 --- a/src/main/java/com/checkout/identities/amlscreening/AmlScreeningClientImpl.java +++ b/src/main/java/com/checkout/identities/amlscreening/AmlScreeningClientImpl.java @@ -31,7 +31,7 @@ public AmlScreeningClientImpl(final ApiClient apiClient, final CheckoutConfigura * @return a {@link CompletableFuture} containing the {@link AmlScreeningResponse} */ @Override - public CompletableFuture createAmlScreeningAsync( + public CompletableFuture createAmlScreening( final AmlScreeningRequest amlScreeningRequest) { validateParams("amlScreeningRequest", amlScreeningRequest); return apiClient.postAsync(AML_VERIFICATIONS_PATH, sdkAuthorization(), AmlScreeningResponse.class, @@ -45,7 +45,7 @@ public CompletableFuture createAmlScreeningAsync( * @return a {@link CompletableFuture} containing the {@link AmlScreeningResponse} */ @Override - public CompletableFuture getAmlScreeningAsync( + public CompletableFuture getAmlScreening( final String amlVerificationId) { validateParams("amlVerificationId", amlVerificationId); return apiClient.getAsync(buildPath(AML_VERIFICATIONS_PATH, amlVerificationId), sdkAuthorization(), @@ -61,7 +61,7 @@ public CompletableFuture getAmlScreeningAsync( * @return a {@link AmlScreeningResponse} */ @Override - public AmlScreeningResponse createAmlScreening(final AmlScreeningRequest amlScreeningRequest) { + public AmlScreeningResponse createAmlScreeningSync(final AmlScreeningRequest amlScreeningRequest) { validateParams("amlScreeningRequest", amlScreeningRequest); return apiClient.post(AML_VERIFICATIONS_PATH, sdkAuthorization(), AmlScreeningResponse.class, amlScreeningRequest, null); @@ -74,7 +74,7 @@ public AmlScreeningResponse createAmlScreening(final AmlScreeningRequest amlScre * @return a {@link AmlScreeningResponse} */ @Override - public AmlScreeningResponse getAmlScreening(final String amlVerificationId) { + public AmlScreeningResponse getAmlScreeningSync(final String amlVerificationId) { validateParams("amlVerificationId", amlVerificationId); return apiClient.get(buildPath(AML_VERIFICATIONS_PATH, amlVerificationId), sdkAuthorization(), AmlScreeningResponse.class); diff --git a/src/main/java/com/checkout/identities/iddocumentverification/IdDocumentVerificationClient.java b/src/main/java/com/checkout/identities/iddocumentverification/IdDocumentVerificationClient.java index 72de6e5e..a4631c3f 100644 --- a/src/main/java/com/checkout/identities/iddocumentverification/IdDocumentVerificationClient.java +++ b/src/main/java/com/checkout/identities/iddocumentverification/IdDocumentVerificationClient.java @@ -20,7 +20,7 @@ public interface IdDocumentVerificationClient { * @param idDocumentVerificationRequest the ID document verification request * @return a {@link CompletableFuture} containing the {@link IdDocumentVerificationResponse} */ - CompletableFuture createIdDocumentVerificationAsync(IdDocumentVerificationRequest idDocumentVerificationRequest); + CompletableFuture createIdDocumentVerification(IdDocumentVerificationRequest idDocumentVerificationRequest); /** * Retrieve an ID document verification @@ -28,7 +28,7 @@ public interface IdDocumentVerificationClient { * @param idDocumentVerificationId the ID document verification ID * @return a {@link CompletableFuture} containing the {@link IdDocumentVerificationResponse} */ - CompletableFuture getIdDocumentVerificationAsync(String idDocumentVerificationId); + CompletableFuture getIdDocumentVerification(String idDocumentVerificationId); /** * Anonymize an ID document verification @@ -36,7 +36,7 @@ public interface IdDocumentVerificationClient { * @param idDocumentVerificationId the ID document verification ID * @return a {@link CompletableFuture} containing the {@link IdDocumentVerificationResponse} */ - CompletableFuture anonymizeIdDocumentVerificationAsync(String idDocumentVerificationId); + CompletableFuture anonymizeIdDocumentVerification(String idDocumentVerificationId); /** * Create an ID document verification attempt @@ -45,7 +45,7 @@ public interface IdDocumentVerificationClient { * @param idDocumentVerificationAttemptRequest the attempt request * @return a {@link CompletableFuture} containing the {@link IdDocumentVerificationAttemptResponse} */ - CompletableFuture createIdDocumentVerificationAttemptAsync(String idDocumentVerificationId, IdDocumentVerificationAttemptRequest idDocumentVerificationAttemptRequest); + CompletableFuture createIdDocumentVerificationAttempt(String idDocumentVerificationId, IdDocumentVerificationAttemptRequest idDocumentVerificationAttemptRequest); /** * Retrieve all ID document verification attempts @@ -53,7 +53,7 @@ public interface IdDocumentVerificationClient { * @param idDocumentVerificationId the ID document verification ID * @return a {@link CompletableFuture} containing the {@link IdDocumentVerificationAttemptsResponse} */ - CompletableFuture getIdDocumentVerificationAttemptsAsync(String idDocumentVerificationId); + CompletableFuture getIdDocumentVerificationAttempts(String idDocumentVerificationId); /** * Retrieve a specific ID document verification attempt @@ -62,7 +62,7 @@ public interface IdDocumentVerificationClient { * @param attemptId the attempt ID * @return a {@link CompletableFuture} containing the {@link IdDocumentVerificationAttemptResponse} */ - CompletableFuture getIdDocumentVerificationAttemptAsync(String idDocumentVerificationId, String attemptId); + CompletableFuture getIdDocumentVerificationAttempt(String idDocumentVerificationId, String attemptId); /** * Generate and download a PDF report @@ -70,7 +70,7 @@ public interface IdDocumentVerificationClient { * @param idDocumentVerificationId the ID document verification ID * @return a {@link CompletableFuture} containing the {@link IdDocumentVerificationReportResponse} */ - CompletableFuture getIdDocumentVerificationReportAsync(String idDocumentVerificationId); + CompletableFuture getIdDocumentVerificationReport(String idDocumentVerificationId); // Synchronous methods @@ -80,7 +80,7 @@ public interface IdDocumentVerificationClient { * @param idDocumentVerificationRequest the ID document verification request * @return the {@link IdDocumentVerificationResponse} */ - IdDocumentVerificationResponse createIdDocumentVerification(IdDocumentVerificationRequest idDocumentVerificationRequest); + IdDocumentVerificationResponse createIdDocumentVerificationSync(IdDocumentVerificationRequest idDocumentVerificationRequest); /** * Retrieve an ID document verification @@ -88,7 +88,7 @@ public interface IdDocumentVerificationClient { * @param idDocumentVerificationId the ID document verification ID * @return the {@link IdDocumentVerificationResponse} */ - IdDocumentVerificationResponse getIdDocumentVerification(String idDocumentVerificationId); + IdDocumentVerificationResponse getIdDocumentVerificationSync(String idDocumentVerificationId); /** * Anonymize an ID document verification @@ -96,7 +96,7 @@ public interface IdDocumentVerificationClient { * @param idDocumentVerificationId the ID document verification ID * @return the {@link IdDocumentVerificationResponse} */ - IdDocumentVerificationResponse anonymizeIdDocumentVerification(String idDocumentVerificationId); + IdDocumentVerificationResponse anonymizeIdDocumentVerificationSync(String idDocumentVerificationId); /** * Create an ID document verification attempt @@ -105,7 +105,7 @@ public interface IdDocumentVerificationClient { * @param idDocumentVerificationAttemptRequest the attempt request * @return the {@link IdDocumentVerificationAttemptResponse} */ - IdDocumentVerificationAttemptResponse createIdDocumentVerificationAttempt(String idDocumentVerificationId, IdDocumentVerificationAttemptRequest idDocumentVerificationAttemptRequest); + IdDocumentVerificationAttemptResponse createIdDocumentVerificationAttemptSync(String idDocumentVerificationId, IdDocumentVerificationAttemptRequest idDocumentVerificationAttemptRequest); /** * Retrieve all ID document verification attempts @@ -113,7 +113,7 @@ public interface IdDocumentVerificationClient { * @param idDocumentVerificationId the ID document verification ID * @return the {@link IdDocumentVerificationAttemptsResponse} */ - IdDocumentVerificationAttemptsResponse getIdDocumentVerificationAttempts(String idDocumentVerificationId); + IdDocumentVerificationAttemptsResponse getIdDocumentVerificationAttemptsSync(String idDocumentVerificationId); /** * Retrieve a specific ID document verification attempt @@ -122,7 +122,7 @@ public interface IdDocumentVerificationClient { * @param attemptId the attempt ID * @return the {@link IdDocumentVerificationAttemptResponse} */ - IdDocumentVerificationAttemptResponse getIdDocumentVerificationAttempt(String idDocumentVerificationId, String attemptId); + IdDocumentVerificationAttemptResponse getIdDocumentVerificationAttemptSync(String idDocumentVerificationId, String attemptId); /** * Generate and download a PDF report @@ -130,5 +130,5 @@ public interface IdDocumentVerificationClient { * @param idDocumentVerificationId the ID document verification ID * @return the {@link IdDocumentVerificationReportResponse} */ - IdDocumentVerificationReportResponse getIdDocumentVerificationReport(String idDocumentVerificationId); + IdDocumentVerificationReportResponse getIdDocumentVerificationReportSync(String idDocumentVerificationId); } \ No newline at end of file diff --git a/src/main/java/com/checkout/identities/iddocumentverification/IdDocumentVerificationClientImpl.java b/src/main/java/com/checkout/identities/iddocumentverification/IdDocumentVerificationClientImpl.java index 21d38e69..b410c0dd 100644 --- a/src/main/java/com/checkout/identities/iddocumentverification/IdDocumentVerificationClientImpl.java +++ b/src/main/java/com/checkout/identities/iddocumentverification/IdDocumentVerificationClientImpl.java @@ -36,7 +36,7 @@ public IdDocumentVerificationClientImpl(final ApiClient apiClient, final Checkou * @return a {@link CompletableFuture} containing the {@link IdDocumentVerificationResponse} */ @Override - public CompletableFuture createIdDocumentVerificationAsync( + public CompletableFuture createIdDocumentVerification( final IdDocumentVerificationRequest idDocumentVerificationRequest) { validateParams("idDocumentVerificationRequest", idDocumentVerificationRequest); return apiClient.postAsync(ID_DOCUMENT_VERIFICATIONS_PATH, sdkAuthorization(), IdDocumentVerificationResponse.class, @@ -50,7 +50,7 @@ public CompletableFuture createIdDocumentVerific * @return a {@link CompletableFuture} containing the {@link IdDocumentVerificationResponse} */ @Override - public CompletableFuture getIdDocumentVerificationAsync( + public CompletableFuture getIdDocumentVerification( final String idDocumentVerificationId) { validateParams("idDocumentVerificationId", idDocumentVerificationId); return apiClient.getAsync(buildPath(ID_DOCUMENT_VERIFICATIONS_PATH, idDocumentVerificationId), sdkAuthorization(), @@ -64,7 +64,7 @@ public CompletableFuture getIdDocumentVerificati * @return a {@link CompletableFuture} containing the {@link IdDocumentVerificationResponse} */ @Override - public CompletableFuture anonymizeIdDocumentVerificationAsync( + public CompletableFuture anonymizeIdDocumentVerification( final String idDocumentVerificationId) { validateParams("idDocumentVerificationId", idDocumentVerificationId); return apiClient.postAsync(buildPath(ID_DOCUMENT_VERIFICATIONS_PATH, idDocumentVerificationId, ANONYMIZE_PATH), @@ -79,7 +79,7 @@ public CompletableFuture anonymizeIdDocumentVeri * @return a {@link CompletableFuture} containing the {@link IdDocumentVerificationAttemptResponse} */ @Override - public CompletableFuture createIdDocumentVerificationAttemptAsync( + public CompletableFuture createIdDocumentVerificationAttempt( final String idDocumentVerificationId, final IdDocumentVerificationAttemptRequest idDocumentVerificationAttemptRequest) { validateParams("idDocumentVerificationId", idDocumentVerificationId, @@ -96,7 +96,7 @@ public CompletableFuture createIdDocument * @return a {@link CompletableFuture} containing the {@link IdDocumentVerificationAttemptsResponse} */ @Override - public CompletableFuture getIdDocumentVerificationAttemptsAsync( + public CompletableFuture getIdDocumentVerificationAttempts( final String idDocumentVerificationId) { validateParams("idDocumentVerificationId", idDocumentVerificationId); return apiClient.getAsync(buildPath(ID_DOCUMENT_VERIFICATIONS_PATH, idDocumentVerificationId, ATTEMPTS_PATH), @@ -111,7 +111,7 @@ public CompletableFuture getIdDocumentVe * @return a {@link CompletableFuture} containing the {@link IdDocumentVerificationAttemptResponse} */ @Override - public CompletableFuture getIdDocumentVerificationAttemptAsync( + public CompletableFuture getIdDocumentVerificationAttempt( final String idDocumentVerificationId, final String attemptId) { validateParams("idDocumentVerificationId", idDocumentVerificationId, "attemptId", attemptId); return apiClient.getAsync(buildPath(ID_DOCUMENT_VERIFICATIONS_PATH, idDocumentVerificationId, ATTEMPTS_PATH, attemptId), @@ -125,7 +125,7 @@ public CompletableFuture getIdDocumentVer * @return a {@link CompletableFuture} containing the {@link IdDocumentVerificationReportResponse} */ @Override - public CompletableFuture getIdDocumentVerificationReportAsync( + public CompletableFuture getIdDocumentVerificationReport( final String idDocumentVerificationId) { validateParams("idDocumentVerificationId", idDocumentVerificationId); return apiClient.getAsync(buildPath(ID_DOCUMENT_VERIFICATIONS_PATH, idDocumentVerificationId, PDF_REPORT_PATH), @@ -141,7 +141,7 @@ public CompletableFuture getIdDocumentVeri * @return the {@link IdDocumentVerificationResponse} */ @Override - public IdDocumentVerificationResponse createIdDocumentVerification( + public IdDocumentVerificationResponse createIdDocumentVerificationSync( final IdDocumentVerificationRequest idDocumentVerificationRequest) { validateParams("idDocumentVerificationRequest", idDocumentVerificationRequest); return apiClient.post(ID_DOCUMENT_VERIFICATIONS_PATH, sdkAuthorization(), IdDocumentVerificationResponse.class, @@ -155,7 +155,7 @@ public IdDocumentVerificationResponse createIdDocumentVerification( * @return the {@link IdDocumentVerificationResponse} */ @Override - public IdDocumentVerificationResponse getIdDocumentVerification(final String idDocumentVerificationId) { + public IdDocumentVerificationResponse getIdDocumentVerificationSync(final String idDocumentVerificationId) { validateParams("idDocumentVerificationId", idDocumentVerificationId); return apiClient.get(buildPath(ID_DOCUMENT_VERIFICATIONS_PATH, idDocumentVerificationId), sdkAuthorization(), IdDocumentVerificationResponse.class); @@ -168,7 +168,7 @@ public IdDocumentVerificationResponse getIdDocumentVerification(final String idD * @return the {@link IdDocumentVerificationResponse} */ @Override - public IdDocumentVerificationResponse anonymizeIdDocumentVerification(final String idDocumentVerificationId) { + public IdDocumentVerificationResponse anonymizeIdDocumentVerificationSync(final String idDocumentVerificationId) { validateParams("idDocumentVerificationId", idDocumentVerificationId); return apiClient.post(buildPath(ID_DOCUMENT_VERIFICATIONS_PATH, idDocumentVerificationId, ANONYMIZE_PATH), sdkAuthorization(), IdDocumentVerificationResponse.class, null, null); @@ -182,7 +182,7 @@ public IdDocumentVerificationResponse anonymizeIdDocumentVerification(final Stri * @return the {@link IdDocumentVerificationAttemptResponse} */ @Override - public IdDocumentVerificationAttemptResponse createIdDocumentVerificationAttempt( + public IdDocumentVerificationAttemptResponse createIdDocumentVerificationAttemptSync( final String idDocumentVerificationId, final IdDocumentVerificationAttemptRequest idDocumentVerificationAttemptRequest) { validateParams("idDocumentVerificationId", idDocumentVerificationId, @@ -199,7 +199,7 @@ public IdDocumentVerificationAttemptResponse createIdDocumentVerificationAttempt * @return the {@link IdDocumentVerificationAttemptsResponse} */ @Override - public IdDocumentVerificationAttemptsResponse getIdDocumentVerificationAttempts(final String idDocumentVerificationId) { + public IdDocumentVerificationAttemptsResponse getIdDocumentVerificationAttemptsSync(final String idDocumentVerificationId) { validateParams("idDocumentVerificationId", idDocumentVerificationId); return apiClient.get(buildPath(ID_DOCUMENT_VERIFICATIONS_PATH, idDocumentVerificationId, ATTEMPTS_PATH), sdkAuthorization(), IdDocumentVerificationAttemptsResponse.class); @@ -213,7 +213,7 @@ public IdDocumentVerificationAttemptsResponse getIdDocumentVerificationAttempts( * @return the {@link IdDocumentVerificationAttemptResponse} */ @Override - public IdDocumentVerificationAttemptResponse getIdDocumentVerificationAttempt( + public IdDocumentVerificationAttemptResponse getIdDocumentVerificationAttemptSync( final String idDocumentVerificationId, final String attemptId) { validateParams("idDocumentVerificationId", idDocumentVerificationId, "attemptId", attemptId); return apiClient.get(buildPath(ID_DOCUMENT_VERIFICATIONS_PATH, idDocumentVerificationId, ATTEMPTS_PATH, attemptId), @@ -227,7 +227,7 @@ public IdDocumentVerificationAttemptResponse getIdDocumentVerificationAttempt( * @return the {@link IdDocumentVerificationReportResponse} */ @Override - public IdDocumentVerificationReportResponse getIdDocumentVerificationReport(final String idDocumentVerificationId) { + public IdDocumentVerificationReportResponse getIdDocumentVerificationReportSync(final String idDocumentVerificationId) { validateParams("idDocumentVerificationId", idDocumentVerificationId); return apiClient.get(buildPath(ID_DOCUMENT_VERIFICATIONS_PATH, idDocumentVerificationId, PDF_REPORT_PATH), sdkAuthorization(), IdDocumentVerificationReportResponse.class); diff --git a/src/main/java/com/checkout/identities/identityverification/IdentityVerificationClient.java b/src/main/java/com/checkout/identities/identityverification/IdentityVerificationClient.java index ee6c714f..8cbcd482 100644 --- a/src/main/java/com/checkout/identities/identityverification/IdentityVerificationClient.java +++ b/src/main/java/com/checkout/identities/identityverification/IdentityVerificationClient.java @@ -25,7 +25,7 @@ public interface IdentityVerificationClient { * @param identityVerificationRequest the identity verification request * @return a {@link CompletableFuture} containing the {@link IdentityVerificationResponse} */ - CompletableFuture createAndOpenIdentityVerificationAsync(CreateAndOpenIdentityVerificationRequest identityVerificationRequest); + CompletableFuture createAndOpenIdentityVerification(CreateAndOpenIdentityVerificationRequest identityVerificationRequest); /** * Create an identity verification session @@ -33,7 +33,7 @@ public interface IdentityVerificationClient { * @param identityVerificationRequest the identity verification request * @return a {@link CompletableFuture} containing the {@link IdentityVerificationResponse} */ - CompletableFuture createIdentityVerificationAsync(IdentityVerificationRequest identityVerificationRequest); + CompletableFuture createIdentityVerification(IdentityVerificationRequest identityVerificationRequest); /** * Retrieve an identity verification session @@ -41,7 +41,7 @@ public interface IdentityVerificationClient { * @param identityVerificationId the identity verification ID * @return a {@link CompletableFuture} containing the {@link IdentityVerificationResponse} */ - CompletableFuture getIdentityVerificationAsync(String identityVerificationId); + CompletableFuture getIdentityVerification(String identityVerificationId); /** * Anonymize an identity verification @@ -49,7 +49,7 @@ public interface IdentityVerificationClient { * @param identityVerificationId the identity verification ID * @return a {@link CompletableFuture} containing the {@link IdentityVerificationResponse} */ - CompletableFuture anonymizeIdentityVerificationAsync(String identityVerificationId); + CompletableFuture anonymizeIdentityVerification(String identityVerificationId); /** * Retrieve all identity verification attempts @@ -57,7 +57,7 @@ public interface IdentityVerificationClient { * @param identityVerificationId the identity verification ID * @return a {@link CompletableFuture} containing the {@link IdentityVerificationAttemptsResponse} */ - CompletableFuture getIdentityVerificationAttemptsAsync(String identityVerificationId); + CompletableFuture getIdentityVerificationAttempts(String identityVerificationId); /** * Create an identity verification attempt @@ -66,7 +66,7 @@ public interface IdentityVerificationClient { * @param identityVerificationAttemptRequest the attempt request * @return a {@link CompletableFuture} containing the {@link IdentityVerificationAttemptResponse} */ - CompletableFuture createIdentityVerificationAttemptAsync(String identityVerificationId, IdentityVerificationAttemptRequest identityVerificationAttemptRequest); + CompletableFuture createIdentityVerificationAttempt(String identityVerificationId, IdentityVerificationAttemptRequest identityVerificationAttemptRequest); /** * Retrieve a specific identity verification attempt @@ -75,7 +75,7 @@ public interface IdentityVerificationClient { * @param attemptId the attempt ID * @return a {@link CompletableFuture} containing the {@link IdentityVerificationAttemptResponse} */ - CompletableFuture getIdentityVerificationAttemptAsync(String identityVerificationId, String attemptId); + CompletableFuture getIdentityVerificationAttempt(String identityVerificationId, String attemptId); /** * Retrieves the assets (face images, videos, and document images) captured during an identity verification attempt. @@ -85,7 +85,7 @@ public interface IdentityVerificationClient { * @param queryFilter the pagination query parameters (skip and limit) * @return a {@link CompletableFuture} containing the {@link IdentityVerificationAttemptAssetsResponse} */ - CompletableFuture getIdentityVerificationAttemptAssetsAsync(String identityVerificationId, String attemptId, AttemptAssetsQueryFilter queryFilter); + CompletableFuture getIdentityVerificationAttemptAssets(String identityVerificationId, String attemptId, AttemptAssetsQueryFilter queryFilter); /** * Generate and download a PDF report @@ -93,7 +93,7 @@ public interface IdentityVerificationClient { * @param identityVerificationId the identity verification ID * @return a {@link CompletableFuture} containing the {@link IdentityVerificationReportResponse} */ - CompletableFuture generateIdentityVerificationReportAsync(String identityVerificationId); + CompletableFuture generateIdentityVerificationReport(String identityVerificationId); // Sync methods @@ -103,7 +103,7 @@ public interface IdentityVerificationClient { * @param identityVerificationRequest the identity verification request * @return the {@link IdentityVerificationResponse} */ - IdentityVerificationResponse createAndOpenIdentityVerification(CreateAndOpenIdentityVerificationRequest identityVerificationRequest); + IdentityVerificationResponse createAndOpenIdentityVerificationSync(CreateAndOpenIdentityVerificationRequest identityVerificationRequest); /** * Create an identity verification session @@ -111,7 +111,7 @@ public interface IdentityVerificationClient { * @param identityVerificationRequest the identity verification request * @return the {@link IdentityVerificationResponse} */ - IdentityVerificationResponse createIdentityVerification(IdentityVerificationRequest identityVerificationRequest); + IdentityVerificationResponse createIdentityVerificationSync(IdentityVerificationRequest identityVerificationRequest); /** * Retrieve an identity verification session @@ -119,7 +119,7 @@ public interface IdentityVerificationClient { * @param identityVerificationId the identity verification ID * @return the {@link IdentityVerificationResponse} */ - IdentityVerificationResponse getIdentityVerification(String identityVerificationId); + IdentityVerificationResponse getIdentityVerificationSync(String identityVerificationId); /** * Anonymize an identity verification @@ -127,7 +127,7 @@ public interface IdentityVerificationClient { * @param identityVerificationId the identity verification ID * @return the {@link IdentityVerificationResponse} */ - IdentityVerificationResponse anonymizeIdentityVerification(String identityVerificationId); + IdentityVerificationResponse anonymizeIdentityVerificationSync(String identityVerificationId); /** * Retrieve all identity verification attempts @@ -135,7 +135,7 @@ public interface IdentityVerificationClient { * @param identityVerificationId the identity verification ID * @return the {@link IdentityVerificationAttemptsResponse} */ - IdentityVerificationAttemptsResponse getIdentityVerificationAttempts(String identityVerificationId); + IdentityVerificationAttemptsResponse getIdentityVerificationAttemptsSync(String identityVerificationId); /** * Create an identity verification attempt @@ -144,7 +144,7 @@ public interface IdentityVerificationClient { * @param identityVerificationAttemptRequest the attempt request * @return the {@link IdentityVerificationAttemptResponse} */ - IdentityVerificationAttemptResponse createIdentityVerificationAttempt(String identityVerificationId, IdentityVerificationAttemptRequest identityVerificationAttemptRequest); + IdentityVerificationAttemptResponse createIdentityVerificationAttemptSync(String identityVerificationId, IdentityVerificationAttemptRequest identityVerificationAttemptRequest); /** * Retrieve a specific identity verification attempt @@ -153,7 +153,7 @@ public interface IdentityVerificationClient { * @param attemptId the attempt ID * @return the {@link IdentityVerificationAttemptResponse} */ - IdentityVerificationAttemptResponse getIdentityVerificationAttempt(String identityVerificationId, String attemptId); + IdentityVerificationAttemptResponse getIdentityVerificationAttemptSync(String identityVerificationId, String attemptId); /** * Retrieves the assets (face images, videos, and document images) captured during an identity verification attempt. @@ -163,7 +163,7 @@ public interface IdentityVerificationClient { * @param queryFilter the pagination query parameters (skip and limit) * @return the {@link IdentityVerificationAttemptAssetsResponse} */ - IdentityVerificationAttemptAssetsResponse getIdentityVerificationAttemptAssets(String identityVerificationId, String attemptId, AttemptAssetsQueryFilter queryFilter); + IdentityVerificationAttemptAssetsResponse getIdentityVerificationAttemptAssetsSync(String identityVerificationId, String attemptId, AttemptAssetsQueryFilter queryFilter); /** * Generate and download a PDF report @@ -171,5 +171,5 @@ public interface IdentityVerificationClient { * @param identityVerificationId the identity verification ID * @return the {@link IdentityVerificationReportResponse} */ - IdentityVerificationReportResponse generateIdentityVerificationReport(String identityVerificationId); + IdentityVerificationReportResponse generateIdentityVerificationReportSync(String identityVerificationId); } \ No newline at end of file diff --git a/src/main/java/com/checkout/identities/identityverification/IdentityVerificationClientImpl.java b/src/main/java/com/checkout/identities/identityverification/IdentityVerificationClientImpl.java index dd5d5ddc..42a9145f 100644 --- a/src/main/java/com/checkout/identities/identityverification/IdentityVerificationClientImpl.java +++ b/src/main/java/com/checkout/identities/identityverification/IdentityVerificationClientImpl.java @@ -43,7 +43,7 @@ public IdentityVerificationClientImpl(final ApiClient apiClient, final CheckoutC * @return a {@link CompletableFuture} containing the {@link IdentityVerificationResponse} */ @Override - public CompletableFuture createAndOpenIdentityVerificationAsync( + public CompletableFuture createAndOpenIdentityVerification( final CreateAndOpenIdentityVerificationRequest identityVerificationRequest) { validateParams("identityVerificationRequest", identityVerificationRequest); return apiClient.postAsync(CREATE_AND_OPEN_PATH, sdkAuthorization(), IdentityVerificationResponse.class, @@ -57,7 +57,7 @@ public CompletableFuture createAndOpenIdentityVeri * @return a {@link CompletableFuture} containing the {@link IdentityVerificationResponse} */ @Override - public CompletableFuture createIdentityVerificationAsync( + public CompletableFuture createIdentityVerification( final IdentityVerificationRequest identityVerificationRequest) { validateParams("identityVerificationRequest", identityVerificationRequest); return apiClient.postAsync(IDENTITY_VERIFICATIONS_PATH, sdkAuthorization(), IdentityVerificationResponse.class, @@ -71,7 +71,7 @@ public CompletableFuture createIdentityVerificatio * @return a {@link CompletableFuture} containing the {@link IdentityVerificationResponse} */ @Override - public CompletableFuture getIdentityVerificationAsync( + public CompletableFuture getIdentityVerification( final String identityVerificationId) { validateParams("identityVerificationId", identityVerificationId); return apiClient.getAsync(buildPath(IDENTITY_VERIFICATIONS_PATH, identityVerificationId), sdkAuthorization(), @@ -85,7 +85,7 @@ public CompletableFuture getIdentityVerificationAs * @return a {@link CompletableFuture} containing the {@link IdentityVerificationResponse} */ @Override - public CompletableFuture anonymizeIdentityVerificationAsync( + public CompletableFuture anonymizeIdentityVerification( final String identityVerificationId) { validateParams("identityVerificationId", identityVerificationId); return apiClient.postAsync(buildPath(IDENTITY_VERIFICATIONS_PATH, identityVerificationId, ANONYMIZE_PATH), @@ -100,7 +100,7 @@ public CompletableFuture anonymizeIdentityVerifica * @return a {@link CompletableFuture} containing the {@link IdentityVerificationAttemptResponse} */ @Override - public CompletableFuture createIdentityVerificationAttemptAsync( + public CompletableFuture createIdentityVerificationAttempt( final String identityVerificationId, final IdentityVerificationAttemptRequest identityVerificationAttemptRequest) { validateParams("identityVerificationId", identityVerificationId, "identityVerificationAttemptRequest", @@ -117,7 +117,7 @@ public CompletableFuture createIdentityVeri * @return a {@link CompletableFuture} containing the {@link IdentityVerificationAttemptsResponse} */ @Override - public CompletableFuture getIdentityVerificationAttemptsAsync( + public CompletableFuture getIdentityVerificationAttempts( final String identityVerificationId) { validateParams("identityVerificationId", identityVerificationId); return apiClient.getAsync(buildPath(IDENTITY_VERIFICATIONS_PATH, identityVerificationId, ATTEMPTS_PATH), @@ -132,7 +132,7 @@ public CompletableFuture getIdentityVerifi * @return a {@link CompletableFuture} containing the {@link IdentityVerificationAttemptResponse} */ @Override - public CompletableFuture getIdentityVerificationAttemptAsync( + public CompletableFuture getIdentityVerificationAttempt( final String identityVerificationId, final String attemptId) { validateParams("identityVerificationId", identityVerificationId, "attemptId", attemptId); return apiClient.getAsync(buildPath(IDENTITY_VERIFICATIONS_PATH, identityVerificationId, ATTEMPTS_PATH, attemptId), @@ -148,7 +148,7 @@ public CompletableFuture getIdentityVerific * @return a {@link CompletableFuture} containing the {@link IdentityVerificationAttemptAssetsResponse} */ @Override - public CompletableFuture getIdentityVerificationAttemptAssetsAsync( + public CompletableFuture getIdentityVerificationAttemptAssets( final String identityVerificationId, final String attemptId, final AttemptAssetsQueryFilter queryFilter) { validateParams("identityVerificationId", identityVerificationId, "attemptId", attemptId); return apiClient.queryAsync(buildPath(IDENTITY_VERIFICATIONS_PATH, identityVerificationId, ATTEMPTS_PATH, attemptId, ASSETS_PATH), @@ -162,7 +162,7 @@ public CompletableFuture getIdentityV * @return a {@link CompletableFuture} containing the {@link IdentityVerificationReportResponse} */ @Override - public CompletableFuture generateIdentityVerificationReportAsync( + public CompletableFuture generateIdentityVerificationReport( final String identityVerificationId) { validateParams("identityVerificationId", identityVerificationId); return apiClient.getAsync(buildPath(IDENTITY_VERIFICATIONS_PATH, identityVerificationId, PDF_REPORT_PATH), @@ -178,7 +178,7 @@ public CompletableFuture generateIdentityVer * @return the {@link IdentityVerificationResponse} */ @Override - public IdentityVerificationResponse createAndOpenIdentityVerification( + public IdentityVerificationResponse createAndOpenIdentityVerificationSync( final CreateAndOpenIdentityVerificationRequest identityVerificationRequest) { validateParams("identityVerificationRequest", identityVerificationRequest); return apiClient.post(CREATE_AND_OPEN_PATH, sdkAuthorization(), IdentityVerificationResponse.class, @@ -192,7 +192,7 @@ public IdentityVerificationResponse createAndOpenIdentityVerification( * @return the {@link IdentityVerificationResponse} */ @Override - public IdentityVerificationResponse createIdentityVerification( + public IdentityVerificationResponse createIdentityVerificationSync( final IdentityVerificationRequest identityVerificationRequest) { validateParams("identityVerificationRequest", identityVerificationRequest); return apiClient.post(IDENTITY_VERIFICATIONS_PATH, sdkAuthorization(), IdentityVerificationResponse.class, @@ -206,7 +206,7 @@ public IdentityVerificationResponse createIdentityVerification( * @return the {@link IdentityVerificationResponse} */ @Override - public IdentityVerificationResponse getIdentityVerification(final String identityVerificationId) { + public IdentityVerificationResponse getIdentityVerificationSync(final String identityVerificationId) { validateParams("identityVerificationId", identityVerificationId); return apiClient.get(buildPath(IDENTITY_VERIFICATIONS_PATH, identityVerificationId), sdkAuthorization(), IdentityVerificationResponse.class); @@ -219,7 +219,7 @@ public IdentityVerificationResponse getIdentityVerification(final String identit * @return the {@link IdentityVerificationResponse} */ @Override - public IdentityVerificationResponse anonymizeIdentityVerification(final String identityVerificationId) { + public IdentityVerificationResponse anonymizeIdentityVerificationSync(final String identityVerificationId) { validateParams("identityVerificationId", identityVerificationId); return apiClient.post(buildPath(IDENTITY_VERIFICATIONS_PATH, identityVerificationId, ANONYMIZE_PATH), sdkAuthorization(), IdentityVerificationResponse.class, null, null); @@ -232,7 +232,7 @@ public IdentityVerificationResponse anonymizeIdentityVerification(final String i * @return the {@link IdentityVerificationAttemptsResponse} */ @Override - public IdentityVerificationAttemptsResponse getIdentityVerificationAttempts(final String identityVerificationId) { + public IdentityVerificationAttemptsResponse getIdentityVerificationAttemptsSync(final String identityVerificationId) { validateParams("identityVerificationId", identityVerificationId); return apiClient.get(buildPath(IDENTITY_VERIFICATIONS_PATH, identityVerificationId, ATTEMPTS_PATH), sdkAuthorization(), IdentityVerificationAttemptsResponse.class); @@ -246,7 +246,7 @@ public IdentityVerificationAttemptsResponse getIdentityVerificationAttempts(fina * @return the {@link IdentityVerificationAttemptResponse} */ @Override - public IdentityVerificationAttemptResponse createIdentityVerificationAttempt( + public IdentityVerificationAttemptResponse createIdentityVerificationAttemptSync( final String identityVerificationId, final IdentityVerificationAttemptRequest identityVerificationAttemptRequest) { validateParams("identityVerificationId", identityVerificationId, "identityVerificationAttemptRequest", @@ -264,7 +264,7 @@ public IdentityVerificationAttemptResponse createIdentityVerificationAttempt( * @return the {@link IdentityVerificationAttemptResponse} */ @Override - public IdentityVerificationAttemptResponse getIdentityVerificationAttempt( + public IdentityVerificationAttemptResponse getIdentityVerificationAttemptSync( final String identityVerificationId, final String attemptId) { validateParams("identityVerificationId", identityVerificationId, "attemptId", attemptId); return apiClient.get(buildPath(IDENTITY_VERIFICATIONS_PATH, identityVerificationId, ATTEMPTS_PATH, attemptId), @@ -280,7 +280,7 @@ public IdentityVerificationAttemptResponse getIdentityVerificationAttempt( * @return the {@link IdentityVerificationAttemptAssetsResponse} */ @Override - public IdentityVerificationAttemptAssetsResponse getIdentityVerificationAttemptAssets( + public IdentityVerificationAttemptAssetsResponse getIdentityVerificationAttemptAssetsSync( final String identityVerificationId, final String attemptId, final AttemptAssetsQueryFilter queryFilter) { validateParams("identityVerificationId", identityVerificationId, "attemptId", attemptId); return apiClient.query(buildPath(IDENTITY_VERIFICATIONS_PATH, identityVerificationId, ATTEMPTS_PATH, attemptId, ASSETS_PATH), @@ -294,7 +294,7 @@ public IdentityVerificationAttemptAssetsResponse getIdentityVerificationAttemptA * @return the {@link IdentityVerificationReportResponse} */ @Override - public IdentityVerificationReportResponse generateIdentityVerificationReport(final String identityVerificationId) { + public IdentityVerificationReportResponse generateIdentityVerificationReportSync(final String identityVerificationId) { validateParams("identityVerificationId", identityVerificationId); return apiClient.get(buildPath(IDENTITY_VERIFICATIONS_PATH, identityVerificationId, PDF_REPORT_PATH), sdkAuthorization(), IdentityVerificationReportResponse.class); diff --git a/src/main/java/com/checkout/reconciliation/previous/ReconciliationClient.java b/src/main/java/com/checkout/reconciliation/previous/ReconciliationClient.java index 4dd6853a..25624775 100644 --- a/src/main/java/com/checkout/reconciliation/previous/ReconciliationClient.java +++ b/src/main/java/com/checkout/reconciliation/previous/ReconciliationClient.java @@ -9,7 +9,7 @@ public interface ReconciliationClient { CompletableFuture queryPaymentsReport(ReconciliationQueryPaymentsFilter filter); - CompletableFuture singlePaymentReportAsync(String paymentId); + CompletableFuture singlePaymentReport(String paymentId); CompletableFuture queryStatementsReport(StatementsQueryFilter filter); diff --git a/src/main/java/com/checkout/reconciliation/previous/ReconciliationClientImpl.java b/src/main/java/com/checkout/reconciliation/previous/ReconciliationClientImpl.java index ee9fe99d..3bd95ec1 100644 --- a/src/main/java/com/checkout/reconciliation/previous/ReconciliationClientImpl.java +++ b/src/main/java/com/checkout/reconciliation/previous/ReconciliationClientImpl.java @@ -34,7 +34,7 @@ public CompletableFuture queryPaymentsRepor } @Override - public CompletableFuture singlePaymentReportAsync(final String paymentId) { + public CompletableFuture singlePaymentReport(final String paymentId) { validateParams("paymentId", paymentId); return apiClient.getAsync( buildPath(REPORTING_PATH, PAYMENTS_PATH, paymentId), diff --git a/src/test/java/com/checkout/identities/amlscreening/AmlScreeningClientImplTest.java b/src/test/java/com/checkout/identities/amlscreening/AmlScreeningClientImplTest.java index 46207a15..5d4d9b63 100644 --- a/src/test/java/com/checkout/identities/amlscreening/AmlScreeningClientImplTest.java +++ b/src/test/java/com/checkout/identities/amlscreening/AmlScreeningClientImplTest.java @@ -58,7 +58,7 @@ void shouldCreateAmlScreening() throws ExecutionException, InterruptedException eq(request), isNull())) .thenReturn(CompletableFuture.completedFuture(response)); - final CompletableFuture future = client.createAmlScreeningAsync(request); + final CompletableFuture future = client.createAmlScreening(request); assertNotNull(future.get()); assertEquals(response, future.get()); @@ -73,7 +73,7 @@ void shouldGetAmlScreening() throws ExecutionException, InterruptedException { AmlScreeningResponse.class)) .thenReturn(CompletableFuture.completedFuture(response)); - final CompletableFuture future = client.getAmlScreeningAsync(amlScreeningId); + final CompletableFuture future = client.getAmlScreening(amlScreeningId); assertNotNull(future.get()); assertEquals(response, future.get()); @@ -89,7 +89,7 @@ void shouldCreateAmlScreeningSync() { eq(request), isNull())) .thenReturn(response); - final AmlScreeningResponse result = client.createAmlScreening(request); + final AmlScreeningResponse result = client.createAmlScreeningSync(request); assertNotNull(result); assertEquals(response, result); @@ -104,7 +104,7 @@ void shouldGetAmlScreeningSync() { AmlScreeningResponse.class)) .thenReturn(response); - final AmlScreeningResponse result = client.getAmlScreening(amlScreeningId); + final AmlScreeningResponse result = client.getAmlScreeningSync(amlScreeningId); assertNotNull(result); assertEquals(response, result); diff --git a/src/test/java/com/checkout/identities/amlscreening/AmlScreeningTestIT.java b/src/test/java/com/checkout/identities/amlscreening/AmlScreeningTestIT.java index 07c1c84f..2c6f2e6f 100644 --- a/src/test/java/com/checkout/identities/amlscreening/AmlScreeningTestIT.java +++ b/src/test/java/com/checkout/identities/amlscreening/AmlScreeningTestIT.java @@ -31,7 +31,7 @@ void shouldCreateAmlScreening() { // Act final AmlScreeningResponse response = blocking(() -> - checkoutApi.amlScreeningClient().createAmlScreeningAsync(request)); + checkoutApi.amlScreeningClient().createAmlScreening(request)); // Assert validateCreatedAmlScreening(response, request); @@ -43,11 +43,11 @@ void shouldGetAmlScreening() { // Arrange final AmlScreeningRequest request = createAmlScreeningRequest(); final AmlScreeningResponse created = blocking(() -> - checkoutApi.amlScreeningClient().createAmlScreeningAsync(request)); + checkoutApi.amlScreeningClient().createAmlScreening(request)); // Act final AmlScreeningResponse retrieved = blocking(() -> - checkoutApi.amlScreeningClient().getAmlScreeningAsync(created.getId())); + checkoutApi.amlScreeningClient().getAmlScreening(created.getId())); // Assert validateRetrievedAmlScreening(retrieved, created); @@ -61,7 +61,7 @@ void shouldCreateAmlScreeningSync() { final AmlScreeningRequest request = createAmlScreeningRequest(); // Act - final AmlScreeningResponse response = checkoutApi.amlScreeningClient().createAmlScreening(request); + final AmlScreeningResponse response = checkoutApi.amlScreeningClient().createAmlScreeningSync(request); // Assert validateCreatedAmlScreening(response, request); @@ -72,10 +72,10 @@ void shouldCreateAmlScreeningSync() { void shouldGetAmlScreeningSync() { // Arrange final AmlScreeningRequest request = createAmlScreeningRequest(); - final AmlScreeningResponse created = checkoutApi.amlScreeningClient().createAmlScreening(request); + final AmlScreeningResponse created = checkoutApi.amlScreeningClient().createAmlScreeningSync(request); // Act - final AmlScreeningResponse retrieved = checkoutApi.amlScreeningClient().getAmlScreening(created.getId()); + final AmlScreeningResponse retrieved = checkoutApi.amlScreeningClient().getAmlScreeningSync(created.getId()); // Assert validateRetrievedAmlScreening(retrieved, created); diff --git a/src/test/java/com/checkout/identities/iddocumentverification/IdDocumentVerificationClientImplTest.java b/src/test/java/com/checkout/identities/iddocumentverification/IdDocumentVerificationClientImplTest.java index cfcd2b56..54d31e74 100644 --- a/src/test/java/com/checkout/identities/iddocumentverification/IdDocumentVerificationClientImplTest.java +++ b/src/test/java/com/checkout/identities/iddocumentverification/IdDocumentVerificationClientImplTest.java @@ -50,7 +50,7 @@ void setUp() { } @Test - void shouldCreateIdDocumentVerificationAsync() throws ExecutionException, InterruptedException { + void shouldCreateIdDocumentVerification() throws ExecutionException, InterruptedException { final IdDocumentVerificationRequest request = createIdDocumentVerificationRequest(); final IdDocumentVerificationResponse response = createIdDocumentVerificationResponse(); @@ -58,14 +58,14 @@ void shouldCreateIdDocumentVerificationAsync() throws ExecutionException, Interr request, null)) .thenReturn(CompletableFuture.completedFuture(response)); - final CompletableFuture future = client.createIdDocumentVerificationAsync(request); + final CompletableFuture future = client.createIdDocumentVerification(request); assertNotNull(future.get()); assertEquals(response, future.get()); } @Test - void shouldGetIdDocumentVerificationAsync() throws ExecutionException, InterruptedException { + void shouldGetIdDocumentVerification() throws ExecutionException, InterruptedException { final String idDocumentVerificationId = "iddv_test_123456789"; final IdDocumentVerificationResponse response = createIdDocumentVerificationResponse(); @@ -73,14 +73,14 @@ void shouldGetIdDocumentVerificationAsync() throws ExecutionException, Interrupt IdDocumentVerificationResponse.class)) .thenReturn(CompletableFuture.completedFuture(response)); - final CompletableFuture future = client.getIdDocumentVerificationAsync(idDocumentVerificationId); + final CompletableFuture future = client.getIdDocumentVerification(idDocumentVerificationId); assertNotNull(future.get()); assertEquals(response, future.get()); } @Test - void shouldAnonymizeIdDocumentVerificationAsync() throws ExecutionException, InterruptedException { + void shouldAnonymizeIdDocumentVerification() throws ExecutionException, InterruptedException { final String idDocumentVerificationId = "iddv_test_123456789"; final IdDocumentVerificationResponse response = createIdDocumentVerificationResponse(); @@ -88,14 +88,14 @@ void shouldAnonymizeIdDocumentVerificationAsync() throws ExecutionException, Int IdDocumentVerificationResponse.class, null, null)) .thenReturn(CompletableFuture.completedFuture(response)); - final CompletableFuture future = client.anonymizeIdDocumentVerificationAsync(idDocumentVerificationId); + final CompletableFuture future = client.anonymizeIdDocumentVerification(idDocumentVerificationId); assertNotNull(future.get()); assertEquals(response, future.get()); } @Test - void shouldCreateIdDocumentVerificationAttemptAsync() throws ExecutionException, InterruptedException { + void shouldCreateIdDocumentVerificationAttempt() throws ExecutionException, InterruptedException { final String idDocumentVerificationId = "iddv_test_123456789"; final IdDocumentVerificationAttemptRequest request = createIdDocumentVerificationAttemptRequest(); final IdDocumentVerificationAttemptResponse response = createIdDocumentVerificationAttemptResponse(); @@ -104,14 +104,14 @@ void shouldCreateIdDocumentVerificationAttemptAsync() throws ExecutionException, IdDocumentVerificationAttemptResponse.class, request, null)) .thenReturn(CompletableFuture.completedFuture(response)); - final CompletableFuture future = client.createIdDocumentVerificationAttemptAsync(idDocumentVerificationId, request); + final CompletableFuture future = client.createIdDocumentVerificationAttempt(idDocumentVerificationId, request); assertNotNull(future.get()); assertEquals(response, future.get()); } @Test - void shouldGetIdDocumentVerificationAttemptsAsync() throws ExecutionException, InterruptedException { + void shouldGetIdDocumentVerificationAttempts() throws ExecutionException, InterruptedException { final String idDocumentVerificationId = "iddv_test_123456789"; final IdDocumentVerificationAttemptsResponse response = createIdDocumentVerificationAttemptsResponse(); @@ -119,14 +119,14 @@ void shouldGetIdDocumentVerificationAttemptsAsync() throws ExecutionException, I IdDocumentVerificationAttemptsResponse.class)) .thenReturn(CompletableFuture.completedFuture(response)); - final CompletableFuture future = client.getIdDocumentVerificationAttemptsAsync(idDocumentVerificationId); + final CompletableFuture future = client.getIdDocumentVerificationAttempts(idDocumentVerificationId); assertNotNull(future.get()); assertEquals(response, future.get()); } @Test - void shouldGetIdDocumentVerificationAttemptAsync() throws ExecutionException, InterruptedException { + void shouldGetIdDocumentVerificationAttempt() throws ExecutionException, InterruptedException { final String idDocumentVerificationId = "iddv_test_123456789"; final String attemptId = "datp_test_123456789"; final IdDocumentVerificationAttemptResponse response = createIdDocumentVerificationAttemptResponse(); @@ -135,14 +135,14 @@ void shouldGetIdDocumentVerificationAttemptAsync() throws ExecutionException, In IdDocumentVerificationAttemptResponse.class)) .thenReturn(CompletableFuture.completedFuture(response)); - final CompletableFuture future = client.getIdDocumentVerificationAttemptAsync(idDocumentVerificationId, attemptId); + final CompletableFuture future = client.getIdDocumentVerificationAttempt(idDocumentVerificationId, attemptId); assertNotNull(future.get()); assertEquals(response, future.get()); } @Test - void shouldGetIdDocumentVerificationReportAsync() throws ExecutionException, InterruptedException { + void shouldGetIdDocumentVerificationReport() throws ExecutionException, InterruptedException { final String idDocumentVerificationId = "iddv_test_123456789"; final IdDocumentVerificationReportResponse response = createIdDocumentVerificationReportResponse(); @@ -150,7 +150,7 @@ void shouldGetIdDocumentVerificationReportAsync() throws ExecutionException, Int IdDocumentVerificationReportResponse.class)) .thenReturn(CompletableFuture.completedFuture(response)); - final CompletableFuture future = client.getIdDocumentVerificationReportAsync(idDocumentVerificationId); + final CompletableFuture future = client.getIdDocumentVerificationReport(idDocumentVerificationId); assertNotNull(future.get()); assertEquals(response, future.get()); @@ -158,7 +158,7 @@ void shouldGetIdDocumentVerificationReportAsync() throws ExecutionException, Int // Synchronous methods tests @Test - void shouldCreateIdDocumentVerification() { + void shouldCreateIdDocumentVerificationSync() { final IdDocumentVerificationRequest request = createIdDocumentVerificationRequest(); final IdDocumentVerificationResponse response = createIdDocumentVerificationResponse(); @@ -166,14 +166,14 @@ void shouldCreateIdDocumentVerification() { request, null)) .thenReturn(response); - final IdDocumentVerificationResponse result = client.createIdDocumentVerification(request); + final IdDocumentVerificationResponse result = client.createIdDocumentVerificationSync(request); assertNotNull(result); assertEquals(response, result); } @Test - void shouldGetIdDocumentVerification() { + void shouldGetIdDocumentVerificationSync() { final String idDocumentVerificationId = "iddv_test_123456789"; final IdDocumentVerificationResponse response = createIdDocumentVerificationResponse(); @@ -181,14 +181,14 @@ void shouldGetIdDocumentVerification() { IdDocumentVerificationResponse.class)) .thenReturn(response); - final IdDocumentVerificationResponse result = client.getIdDocumentVerification(idDocumentVerificationId); + final IdDocumentVerificationResponse result = client.getIdDocumentVerificationSync(idDocumentVerificationId); assertNotNull(result); assertEquals(response, result); } @Test - void shouldAnonymizeIdDocumentVerification() { + void shouldAnonymizeIdDocumentVerificationSync() { final String idDocumentVerificationId = "iddv_test_123456789"; final IdDocumentVerificationResponse response = createIdDocumentVerificationResponse(); @@ -196,14 +196,14 @@ void shouldAnonymizeIdDocumentVerification() { IdDocumentVerificationResponse.class, null, null)) .thenReturn(response); - final IdDocumentVerificationResponse result = client.anonymizeIdDocumentVerification(idDocumentVerificationId); + final IdDocumentVerificationResponse result = client.anonymizeIdDocumentVerificationSync(idDocumentVerificationId); assertNotNull(result); assertEquals(response, result); } @Test - void shouldCreateIdDocumentVerificationAttempt() { + void shouldCreateIdDocumentVerificationAttemptSync() { final String idDocumentVerificationId = "iddv_test_123456789"; final IdDocumentVerificationAttemptRequest request = createIdDocumentVerificationAttemptRequest(); final IdDocumentVerificationAttemptResponse response = createIdDocumentVerificationAttemptResponse(); @@ -212,14 +212,14 @@ void shouldCreateIdDocumentVerificationAttempt() { IdDocumentVerificationAttemptResponse.class, request, null)) .thenReturn(response); - final IdDocumentVerificationAttemptResponse result = client.createIdDocumentVerificationAttempt(idDocumentVerificationId, request); + final IdDocumentVerificationAttemptResponse result = client.createIdDocumentVerificationAttemptSync(idDocumentVerificationId, request); assertNotNull(result); assertEquals(response, result); } @Test - void shouldGetIdDocumentVerificationAttempts() { + void shouldGetIdDocumentVerificationAttemptsSync() { final String idDocumentVerificationId = "iddv_test_123456789"; final IdDocumentVerificationAttemptsResponse response = createIdDocumentVerificationAttemptsResponse(); @@ -227,14 +227,14 @@ void shouldGetIdDocumentVerificationAttempts() { IdDocumentVerificationAttemptsResponse.class)) .thenReturn(response); - final IdDocumentVerificationAttemptsResponse result = client.getIdDocumentVerificationAttempts(idDocumentVerificationId); + final IdDocumentVerificationAttemptsResponse result = client.getIdDocumentVerificationAttemptsSync(idDocumentVerificationId); assertNotNull(result); assertEquals(response, result); } @Test - void shouldGetIdDocumentVerificationAttempt() { + void shouldGetIdDocumentVerificationAttemptSync() { final String idDocumentVerificationId = "iddv_test_123456789"; final String attemptId = "datp_test_123456789"; final IdDocumentVerificationAttemptResponse response = createIdDocumentVerificationAttemptResponse(); @@ -243,14 +243,14 @@ void shouldGetIdDocumentVerificationAttempt() { IdDocumentVerificationAttemptResponse.class)) .thenReturn(response); - final IdDocumentVerificationAttemptResponse result = client.getIdDocumentVerificationAttempt(idDocumentVerificationId, attemptId); + final IdDocumentVerificationAttemptResponse result = client.getIdDocumentVerificationAttemptSync(idDocumentVerificationId, attemptId); assertNotNull(result); assertEquals(response, result); } @Test - void shouldGetIdDocumentVerificationReport() { + void shouldGetIdDocumentVerificationReportSync() { final String idDocumentVerificationId = "iddv_test_123456789"; final IdDocumentVerificationReportResponse response = createIdDocumentVerificationReportResponse(); @@ -258,7 +258,7 @@ void shouldGetIdDocumentVerificationReport() { IdDocumentVerificationReportResponse.class)) .thenReturn(response); - final IdDocumentVerificationReportResponse result = client.getIdDocumentVerificationReport(idDocumentVerificationId); + final IdDocumentVerificationReportResponse result = client.getIdDocumentVerificationReportSync(idDocumentVerificationId); assertNotNull(result); assertEquals(response, result); diff --git a/src/test/java/com/checkout/identities/iddocumentverification/IdDocumentVerificationTestIT.java b/src/test/java/com/checkout/identities/iddocumentverification/IdDocumentVerificationTestIT.java index 4e5f4342..a837d69f 100644 --- a/src/test/java/com/checkout/identities/iddocumentverification/IdDocumentVerificationTestIT.java +++ b/src/test/java/com/checkout/identities/iddocumentverification/IdDocumentVerificationTestIT.java @@ -32,7 +32,7 @@ void shouldCreateIdDocumentVerification() { // Act final IdDocumentVerificationResponse response = blocking(() -> - checkoutApi.idDocumentVerificationClient().createIdDocumentVerificationAsync(request)); + checkoutApi.idDocumentVerificationClient().createIdDocumentVerification(request)); // Assert validateCreatedIdDocumentVerification(response); @@ -44,11 +44,11 @@ void shouldGetIdDocumentVerification() { // Arrange final IdDocumentVerificationRequest request = createIdDocumentVerificationRequest(); final IdDocumentVerificationResponse created = blocking(() -> - checkoutApi.idDocumentVerificationClient().createIdDocumentVerificationAsync(request)); + checkoutApi.idDocumentVerificationClient().createIdDocumentVerification(request)); // Act final IdDocumentVerificationResponse retrieved = blocking(() -> - checkoutApi.idDocumentVerificationClient().getIdDocumentVerificationAsync(created.getId())); + checkoutApi.idDocumentVerificationClient().getIdDocumentVerification(created.getId())); // Assert validateRetrievedIdDocumentVerification(retrieved, created); @@ -60,11 +60,11 @@ void shouldAnonymizeIdDocumentVerification() { // Arrange final IdDocumentVerificationRequest request = createIdDocumentVerificationRequest(); final IdDocumentVerificationResponse created = blocking(() -> - checkoutApi.idDocumentVerificationClient().createIdDocumentVerificationAsync(request)); + checkoutApi.idDocumentVerificationClient().createIdDocumentVerification(request)); // Act final IdDocumentVerificationResponse anonymized = blocking(() -> - checkoutApi.idDocumentVerificationClient().anonymizeIdDocumentVerificationAsync(created.getId())); + checkoutApi.idDocumentVerificationClient().anonymizeIdDocumentVerification(created.getId())); // Assert validateAnonymizedIdDocumentVerification(anonymized); @@ -76,12 +76,12 @@ void shouldCreateIdDocumentVerificationAttempt() { // Arrange final IdDocumentVerificationRequest request = createIdDocumentVerificationRequest(); final IdDocumentVerificationResponse created = blocking(() -> - checkoutApi.idDocumentVerificationClient().createIdDocumentVerificationAsync(request)); + checkoutApi.idDocumentVerificationClient().createIdDocumentVerification(request)); final IdDocumentVerificationAttemptRequest attemptRequest = createIdDocumentVerificationAttemptRequest(); // Act final IdDocumentVerificationAttemptResponse attempt = blocking(() -> - checkoutApi.idDocumentVerificationClient().createIdDocumentVerificationAttemptAsync(created.getId(), attemptRequest)); + checkoutApi.idDocumentVerificationClient().createIdDocumentVerificationAttempt(created.getId(), attemptRequest)); // Assert validateCreatedIdDocumentVerificationAttempt(attempt); @@ -93,14 +93,14 @@ void shouldGetIdDocumentVerificationAttempts() { // Arrange final IdDocumentVerificationRequest request = createIdDocumentVerificationRequest(); final IdDocumentVerificationResponse created = blocking(() -> - checkoutApi.idDocumentVerificationClient().createIdDocumentVerificationAsync(request)); + checkoutApi.idDocumentVerificationClient().createIdDocumentVerification(request)); final IdDocumentVerificationAttemptRequest attemptRequest = createIdDocumentVerificationAttemptRequest(); final IdDocumentVerificationAttemptResponse createdAttempt = blocking(() -> - checkoutApi.idDocumentVerificationClient().createIdDocumentVerificationAttemptAsync(created.getId(), attemptRequest)); + checkoutApi.idDocumentVerificationClient().createIdDocumentVerificationAttempt(created.getId(), attemptRequest)); // Act final IdDocumentVerificationAttemptsResponse attempts = blocking(() -> - checkoutApi.idDocumentVerificationClient().getIdDocumentVerificationAttemptsAsync(created.getId())); + checkoutApi.idDocumentVerificationClient().getIdDocumentVerificationAttempts(created.getId())); // Assert validateRetrievedIdDocumentVerificationAttempts(attempts, createdAttempt); @@ -112,14 +112,14 @@ void shouldGetIdDocumentVerificationAttempt() { // Arrange final IdDocumentVerificationRequest request = createIdDocumentVerificationRequest(); final IdDocumentVerificationResponse created = blocking(() -> - checkoutApi.idDocumentVerificationClient().createIdDocumentVerificationAsync(request)); + checkoutApi.idDocumentVerificationClient().createIdDocumentVerification(request)); final IdDocumentVerificationAttemptRequest attemptRequest = createIdDocumentVerificationAttemptRequest(); final IdDocumentVerificationAttemptResponse createdAttempt = blocking(() -> - checkoutApi.idDocumentVerificationClient().createIdDocumentVerificationAttemptAsync(created.getId(), attemptRequest)); + checkoutApi.idDocumentVerificationClient().createIdDocumentVerificationAttempt(created.getId(), attemptRequest)); // Act final IdDocumentVerificationAttemptResponse retrievedAttempt = blocking(() -> - checkoutApi.idDocumentVerificationClient().getIdDocumentVerificationAttemptAsync(created.getId(), createdAttempt.getId())); + checkoutApi.idDocumentVerificationClient().getIdDocumentVerificationAttempt(created.getId(), createdAttempt.getId())); // Assert validateRetrievedIdDocumentVerificationAttempt(retrievedAttempt, createdAttempt); @@ -131,11 +131,11 @@ void shouldGetIdDocumentVerificationReport() { // Arrange final IdDocumentVerificationRequest request = createIdDocumentVerificationRequest(); final IdDocumentVerificationResponse created = blocking(() -> - checkoutApi.idDocumentVerificationClient().createIdDocumentVerificationAsync(request)); + checkoutApi.idDocumentVerificationClient().createIdDocumentVerification(request)); // Act final IdDocumentVerificationReportResponse report = blocking(() -> - checkoutApi.idDocumentVerificationClient().getIdDocumentVerificationReportAsync(created.getId())); + checkoutApi.idDocumentVerificationClient().getIdDocumentVerificationReport(created.getId())); // Assert validateGeneratedIdDocumentVerificationReport(report); @@ -149,7 +149,7 @@ void shouldCreateIdDocumentVerificationSync() { final IdDocumentVerificationRequest request = createIdDocumentVerificationRequest(); // Act - final IdDocumentVerificationResponse response = checkoutApi.idDocumentVerificationClient().createIdDocumentVerification(request); + final IdDocumentVerificationResponse response = checkoutApi.idDocumentVerificationClient().createIdDocumentVerificationSync(request); // Assert validateCreatedIdDocumentVerification(response); @@ -160,10 +160,10 @@ void shouldCreateIdDocumentVerificationSync() { void shouldGetIdDocumentVerificationSync() { // Arrange final IdDocumentVerificationRequest request = createIdDocumentVerificationRequest(); - final IdDocumentVerificationResponse created = checkoutApi.idDocumentVerificationClient().createIdDocumentVerification(request); + final IdDocumentVerificationResponse created = checkoutApi.idDocumentVerificationClient().createIdDocumentVerificationSync(request); // Act - final IdDocumentVerificationResponse retrieved = checkoutApi.idDocumentVerificationClient().getIdDocumentVerification(created.getId()); + final IdDocumentVerificationResponse retrieved = checkoutApi.idDocumentVerificationClient().getIdDocumentVerificationSync(created.getId()); // Assert validateRetrievedIdDocumentVerification(retrieved, created); @@ -174,10 +174,10 @@ void shouldGetIdDocumentVerificationSync() { void shouldAnonymizeIdDocumentVerificationSync() { // Arrange final IdDocumentVerificationRequest request = createIdDocumentVerificationRequest(); - final IdDocumentVerificationResponse created = checkoutApi.idDocumentVerificationClient().createIdDocumentVerification(request); + final IdDocumentVerificationResponse created = checkoutApi.idDocumentVerificationClient().createIdDocumentVerificationSync(request); // Act - final IdDocumentVerificationResponse anonymized = checkoutApi.idDocumentVerificationClient().anonymizeIdDocumentVerification(created.getId()); + final IdDocumentVerificationResponse anonymized = checkoutApi.idDocumentVerificationClient().anonymizeIdDocumentVerificationSync(created.getId()); // Assert validateAnonymizedIdDocumentVerification(anonymized); @@ -188,11 +188,11 @@ void shouldAnonymizeIdDocumentVerificationSync() { void shouldCreateIdDocumentVerificationAttemptSync() { // Arrange final IdDocumentVerificationRequest request = createIdDocumentVerificationRequest(); - final IdDocumentVerificationResponse created = checkoutApi.idDocumentVerificationClient().createIdDocumentVerification(request); + final IdDocumentVerificationResponse created = checkoutApi.idDocumentVerificationClient().createIdDocumentVerificationSync(request); final IdDocumentVerificationAttemptRequest attemptRequest = createIdDocumentVerificationAttemptRequest(); // Act - final IdDocumentVerificationAttemptResponse attempt = checkoutApi.idDocumentVerificationClient().createIdDocumentVerificationAttempt(created.getId(), attemptRequest); + final IdDocumentVerificationAttemptResponse attempt = checkoutApi.idDocumentVerificationClient().createIdDocumentVerificationAttemptSync(created.getId(), attemptRequest); // Assert validateCreatedIdDocumentVerificationAttempt(attempt); @@ -203,12 +203,12 @@ void shouldCreateIdDocumentVerificationAttemptSync() { void shouldGetIdDocumentVerificationAttemptsSync() { // Arrange final IdDocumentVerificationRequest request = createIdDocumentVerificationRequest(); - final IdDocumentVerificationResponse created = checkoutApi.idDocumentVerificationClient().createIdDocumentVerification(request); + final IdDocumentVerificationResponse created = checkoutApi.idDocumentVerificationClient().createIdDocumentVerificationSync(request); final IdDocumentVerificationAttemptRequest attemptRequest = createIdDocumentVerificationAttemptRequest(); - final IdDocumentVerificationAttemptResponse createdAttempt = checkoutApi.idDocumentVerificationClient().createIdDocumentVerificationAttempt(created.getId(), attemptRequest); + final IdDocumentVerificationAttemptResponse createdAttempt = checkoutApi.idDocumentVerificationClient().createIdDocumentVerificationAttemptSync(created.getId(), attemptRequest); // Act - final IdDocumentVerificationAttemptsResponse attempts = checkoutApi.idDocumentVerificationClient().getIdDocumentVerificationAttempts(created.getId()); + final IdDocumentVerificationAttemptsResponse attempts = checkoutApi.idDocumentVerificationClient().getIdDocumentVerificationAttemptsSync(created.getId()); // Assert validateRetrievedIdDocumentVerificationAttempts(attempts, createdAttempt); @@ -219,12 +219,12 @@ void shouldGetIdDocumentVerificationAttemptsSync() { void shouldGetIdDocumentVerificationAttemptSync() { // Arrange final IdDocumentVerificationRequest request = createIdDocumentVerificationRequest(); - final IdDocumentVerificationResponse created = checkoutApi.idDocumentVerificationClient().createIdDocumentVerification(request); + final IdDocumentVerificationResponse created = checkoutApi.idDocumentVerificationClient().createIdDocumentVerificationSync(request); final IdDocumentVerificationAttemptRequest attemptRequest = createIdDocumentVerificationAttemptRequest(); - final IdDocumentVerificationAttemptResponse createdAttempt = checkoutApi.idDocumentVerificationClient().createIdDocumentVerificationAttempt(created.getId(), attemptRequest); + final IdDocumentVerificationAttemptResponse createdAttempt = checkoutApi.idDocumentVerificationClient().createIdDocumentVerificationAttemptSync(created.getId(), attemptRequest); // Act - final IdDocumentVerificationAttemptResponse retrievedAttempt = checkoutApi.idDocumentVerificationClient().getIdDocumentVerificationAttempt(created.getId(), createdAttempt.getId()); + final IdDocumentVerificationAttemptResponse retrievedAttempt = checkoutApi.idDocumentVerificationClient().getIdDocumentVerificationAttemptSync(created.getId(), createdAttempt.getId()); // Assert validateRetrievedIdDocumentVerificationAttempt(retrievedAttempt, createdAttempt); @@ -235,10 +235,10 @@ void shouldGetIdDocumentVerificationAttemptSync() { void shouldGetIdDocumentVerificationReportSync() { // Arrange final IdDocumentVerificationRequest request = createIdDocumentVerificationRequest(); - final IdDocumentVerificationResponse created = checkoutApi.idDocumentVerificationClient().createIdDocumentVerification(request); + final IdDocumentVerificationResponse created = checkoutApi.idDocumentVerificationClient().createIdDocumentVerificationSync(request); // Act - final IdDocumentVerificationReportResponse report = checkoutApi.idDocumentVerificationClient().getIdDocumentVerificationReport(created.getId()); + final IdDocumentVerificationReportResponse report = checkoutApi.idDocumentVerificationClient().getIdDocumentVerificationReportSync(created.getId()); // Assert validateGeneratedIdDocumentVerificationReport(report); diff --git a/src/test/java/com/checkout/identities/identityverification/IdentityVerificationClientImplTest.java b/src/test/java/com/checkout/identities/identityverification/IdentityVerificationClientImplTest.java index d844921e..10096cf7 100644 --- a/src/test/java/com/checkout/identities/identityverification/IdentityVerificationClientImplTest.java +++ b/src/test/java/com/checkout/identities/identityverification/IdentityVerificationClientImplTest.java @@ -55,7 +55,7 @@ void setUp() { // Async methods @Test - void shouldCreateAndOpenIdentityVerificationAsync() throws ExecutionException, InterruptedException { + void shouldCreateAndOpenIdentityVerification() throws ExecutionException, InterruptedException { final CreateAndOpenIdentityVerificationRequest request = createCreateAndOpenIdentityVerificationRequest(); final IdentityVerificationResponse response = createIdentityVerificationResponse(); @@ -63,14 +63,14 @@ void shouldCreateAndOpenIdentityVerificationAsync() throws ExecutionException, I request, null)) .thenReturn(CompletableFuture.completedFuture(response)); - final CompletableFuture future = client.createAndOpenIdentityVerificationAsync(request); + final CompletableFuture future = client.createAndOpenIdentityVerification(request); assertNotNull(future.get()); assertEquals(response, future.get()); } @Test - void shouldCreateIdentityVerificationAsync() throws ExecutionException, InterruptedException { + void shouldCreateIdentityVerification() throws ExecutionException, InterruptedException { final IdentityVerificationRequest request = createIdentityVerificationRequest(); final IdentityVerificationResponse response = createIdentityVerificationResponse(); @@ -78,14 +78,14 @@ void shouldCreateIdentityVerificationAsync() throws ExecutionException, Interrup request, null)) .thenReturn(CompletableFuture.completedFuture(response)); - final CompletableFuture future = client.createIdentityVerificationAsync(request); + final CompletableFuture future = client.createIdentityVerification(request); assertNotNull(future.get()); assertEquals(response, future.get()); } @Test - void shouldGetIdentityVerificationAsync() throws ExecutionException, InterruptedException { + void shouldGetIdentityVerification() throws ExecutionException, InterruptedException { final String identityVerificationId = "idv_test_123456789"; final IdentityVerificationResponse response = createIdentityVerificationResponse(); @@ -93,14 +93,14 @@ void shouldGetIdentityVerificationAsync() throws ExecutionException, Interrupted IdentityVerificationResponse.class)) .thenReturn(CompletableFuture.completedFuture(response)); - final CompletableFuture future = client.getIdentityVerificationAsync(identityVerificationId); + final CompletableFuture future = client.getIdentityVerification(identityVerificationId); assertNotNull(future.get()); assertEquals(response, future.get()); } @Test - void shouldAnonymizeIdentityVerificationAsync() throws ExecutionException, InterruptedException { + void shouldAnonymizeIdentityVerification() throws ExecutionException, InterruptedException { final String identityVerificationId = "idv_test_123456789"; final IdentityVerificationResponse response = createIdentityVerificationResponse(); @@ -108,14 +108,14 @@ void shouldAnonymizeIdentityVerificationAsync() throws ExecutionException, Inter IdentityVerificationResponse.class, null, null)) .thenReturn(CompletableFuture.completedFuture(response)); - final CompletableFuture future = client.anonymizeIdentityVerificationAsync(identityVerificationId); + final CompletableFuture future = client.anonymizeIdentityVerification(identityVerificationId); assertNotNull(future.get()); assertEquals(response, future.get()); } @Test - void shouldGetIdentityVerificationAttemptsAsync() throws ExecutionException, InterruptedException { + void shouldGetIdentityVerificationAttempts() throws ExecutionException, InterruptedException { final String identityVerificationId = "idv_test_123456789"; final IdentityVerificationAttemptsResponse response = createIdentityVerificationAttemptsResponse(); @@ -123,14 +123,14 @@ void shouldGetIdentityVerificationAttemptsAsync() throws ExecutionException, Int IdentityVerificationAttemptsResponse.class)) .thenReturn(CompletableFuture.completedFuture(response)); - final CompletableFuture future = client.getIdentityVerificationAttemptsAsync(identityVerificationId); + final CompletableFuture future = client.getIdentityVerificationAttempts(identityVerificationId); assertNotNull(future.get()); assertEquals(response, future.get()); } @Test - void shouldCreateIdentityVerificationAttemptAsync() throws ExecutionException, InterruptedException { + void shouldCreateIdentityVerificationAttempt() throws ExecutionException, InterruptedException { final String identityVerificationId = "idv_test_123456789"; final IdentityVerificationAttemptRequest request = createIdentityVerificationAttemptRequest(); final IdentityVerificationAttemptResponse response = createIdentityVerificationAttemptResponse(); @@ -139,14 +139,14 @@ void shouldCreateIdentityVerificationAttemptAsync() throws ExecutionException, I IdentityVerificationAttemptResponse.class, request, null)) .thenReturn(CompletableFuture.completedFuture(response)); - final CompletableFuture future = client.createIdentityVerificationAttemptAsync(identityVerificationId, request); + final CompletableFuture future = client.createIdentityVerificationAttempt(identityVerificationId, request); assertNotNull(future.get()); assertEquals(response, future.get()); } @Test - void shouldGetIdentityVerificationAttemptAsync() throws ExecutionException, InterruptedException { + void shouldGetIdentityVerificationAttempt() throws ExecutionException, InterruptedException { final String identityVerificationId = "idv_test_123456789"; final String attemptId = "idva_test_987654321"; final IdentityVerificationAttemptResponse response = createIdentityVerificationAttemptResponse(); @@ -155,14 +155,14 @@ void shouldGetIdentityVerificationAttemptAsync() throws ExecutionException, Inte authorization, IdentityVerificationAttemptResponse.class)) .thenReturn(CompletableFuture.completedFuture(response)); - final CompletableFuture future = client.getIdentityVerificationAttemptAsync(identityVerificationId, attemptId); + final CompletableFuture future = client.getIdentityVerificationAttempt(identityVerificationId, attemptId); assertNotNull(future.get()); assertEquals(response, future.get()); } @Test - void shouldGetIdentityVerificationAttemptAssetsAsync() throws ExecutionException, InterruptedException { + void shouldGetIdentityVerificationAttemptAssets() throws ExecutionException, InterruptedException { final String identityVerificationId = "idv_test_123456789"; final String attemptId = "idva_test_987654321"; final AttemptAssetsQueryFilter queryFilter = AttemptAssetsQueryFilter.builder().skip(0).limit(10).build(); @@ -173,14 +173,14 @@ void shouldGetIdentityVerificationAttemptAssetsAsync() throws ExecutionException .thenReturn(CompletableFuture.completedFuture(response)); final CompletableFuture future = - client.getIdentityVerificationAttemptAssetsAsync(identityVerificationId, attemptId, queryFilter); + client.getIdentityVerificationAttemptAssets(identityVerificationId, attemptId, queryFilter); assertNotNull(future.get()); assertEquals(response, future.get()); } @Test - void shouldGenerateIdentityVerificationReportAsync() throws ExecutionException, InterruptedException { + void shouldGenerateIdentityVerificationReport() throws ExecutionException, InterruptedException { final String identityVerificationId = "idv_test_123456789"; final IdentityVerificationReportResponse response = createIdentityVerificationReportResponse(); @@ -188,7 +188,7 @@ void shouldGenerateIdentityVerificationReportAsync() throws ExecutionException, IdentityVerificationReportResponse.class)) .thenReturn(CompletableFuture.completedFuture(response)); - final CompletableFuture future = client.generateIdentityVerificationReportAsync(identityVerificationId); + final CompletableFuture future = client.generateIdentityVerificationReport(identityVerificationId); assertNotNull(future.get()); assertEquals(response, future.get()); @@ -197,7 +197,7 @@ void shouldGenerateIdentityVerificationReportAsync() throws ExecutionException, // Synchronous methods tests @Test - void shouldCreateAndOpenIdentityVerification() { + void shouldCreateAndOpenIdentityVerificationSync() { final CreateAndOpenIdentityVerificationRequest request = createCreateAndOpenIdentityVerificationRequest(); final IdentityVerificationResponse response = createIdentityVerificationResponse(); @@ -205,14 +205,14 @@ void shouldCreateAndOpenIdentityVerification() { request, null)) .thenReturn(response); - final IdentityVerificationResponse result = client.createAndOpenIdentityVerification(request); + final IdentityVerificationResponse result = client.createAndOpenIdentityVerificationSync(request); assertNotNull(result); assertEquals(response, result); } @Test - void shouldCreateIdentityVerification() { + void shouldCreateIdentityVerificationSync() { final IdentityVerificationRequest request = createIdentityVerificationRequest(); final IdentityVerificationResponse response = createIdentityVerificationResponse(); @@ -220,14 +220,14 @@ void shouldCreateIdentityVerification() { request, null)) .thenReturn(response); - final IdentityVerificationResponse result = client.createIdentityVerification(request); + final IdentityVerificationResponse result = client.createIdentityVerificationSync(request); assertNotNull(result); assertEquals(response, result); } @Test - void shouldGetIdentityVerification() { + void shouldGetIdentityVerificationSync() { final String identityVerificationId = "idv_test_123456789"; final IdentityVerificationResponse response = createIdentityVerificationResponse(); @@ -235,14 +235,14 @@ void shouldGetIdentityVerification() { IdentityVerificationResponse.class)) .thenReturn(response); - final IdentityVerificationResponse result = client.getIdentityVerification(identityVerificationId); + final IdentityVerificationResponse result = client.getIdentityVerificationSync(identityVerificationId); assertNotNull(result); assertEquals(response, result); } @Test - void shouldAnonymizeIdentityVerification() { + void shouldAnonymizeIdentityVerificationSync() { final String identityVerificationId = "idv_test_123456789"; final IdentityVerificationResponse response = createIdentityVerificationResponse(); @@ -250,14 +250,14 @@ void shouldAnonymizeIdentityVerification() { IdentityVerificationResponse.class, null, null)) .thenReturn(response); - final IdentityVerificationResponse result = client.anonymizeIdentityVerification(identityVerificationId); + final IdentityVerificationResponse result = client.anonymizeIdentityVerificationSync(identityVerificationId); assertNotNull(result); assertEquals(response, result); } @Test - void shouldGetIdentityVerificationAttempts() { + void shouldGetIdentityVerificationAttemptsSync() { final String identityVerificationId = "idv_test_123456789"; final IdentityVerificationAttemptsResponse response = createIdentityVerificationAttemptsResponse(); @@ -265,14 +265,14 @@ void shouldGetIdentityVerificationAttempts() { IdentityVerificationAttemptsResponse.class)) .thenReturn(response); - final IdentityVerificationAttemptsResponse result = client.getIdentityVerificationAttempts(identityVerificationId); + final IdentityVerificationAttemptsResponse result = client.getIdentityVerificationAttemptsSync(identityVerificationId); assertNotNull(result); assertEquals(response, result); } @Test - void shouldCreateIdentityVerificationAttempt() { + void shouldCreateIdentityVerificationAttemptSync() { final String identityVerificationId = "idv_test_123456789"; final IdentityVerificationAttemptRequest request = createIdentityVerificationAttemptRequest(); final IdentityVerificationAttemptResponse response = createIdentityVerificationAttemptResponse(); @@ -281,14 +281,14 @@ void shouldCreateIdentityVerificationAttempt() { IdentityVerificationAttemptResponse.class, request, null)) .thenReturn(response); - final IdentityVerificationAttemptResponse result = client.createIdentityVerificationAttempt(identityVerificationId, request); + final IdentityVerificationAttemptResponse result = client.createIdentityVerificationAttemptSync(identityVerificationId, request); assertNotNull(result); assertEquals(response, result); } @Test - void shouldGetIdentityVerificationAttempt() { + void shouldGetIdentityVerificationAttemptSync() { final String identityVerificationId = "idv_test_123456789"; final String attemptId = "idva_test_987654321"; final IdentityVerificationAttemptResponse response = createIdentityVerificationAttemptResponse(); @@ -297,14 +297,14 @@ void shouldGetIdentityVerificationAttempt() { authorization, IdentityVerificationAttemptResponse.class)) .thenReturn(response); - final IdentityVerificationAttemptResponse result = client.getIdentityVerificationAttempt(identityVerificationId, attemptId); + final IdentityVerificationAttemptResponse result = client.getIdentityVerificationAttemptSync(identityVerificationId, attemptId); assertNotNull(result); assertEquals(response, result); } @Test - void shouldGetIdentityVerificationAttemptAssets() { + void shouldGetIdentityVerificationAttemptAssetsSync() { final String identityVerificationId = "idv_test_123456789"; final String attemptId = "idva_test_987654321"; final AttemptAssetsQueryFilter queryFilter = AttemptAssetsQueryFilter.builder().skip(0).limit(10).build(); @@ -315,14 +315,14 @@ void shouldGetIdentityVerificationAttemptAssets() { .thenReturn(response); final IdentityVerificationAttemptAssetsResponse result = - client.getIdentityVerificationAttemptAssets(identityVerificationId, attemptId, queryFilter); + client.getIdentityVerificationAttemptAssetsSync(identityVerificationId, attemptId, queryFilter); assertNotNull(result); assertEquals(response, result); } @Test - void shouldGenerateIdentityVerificationReport() { + void shouldGenerateIdentityVerificationReportSync() { final String identityVerificationId = "idv_test_123456789"; final IdentityVerificationReportResponse response = createIdentityVerificationReportResponse(); @@ -330,7 +330,7 @@ void shouldGenerateIdentityVerificationReport() { IdentityVerificationReportResponse.class)) .thenReturn(response); - final IdentityVerificationReportResponse result = client.generateIdentityVerificationReport(identityVerificationId); + final IdentityVerificationReportResponse result = client.generateIdentityVerificationReportSync(identityVerificationId); assertNotNull(result); assertEquals(response, result); diff --git a/src/test/java/com/checkout/identities/identityverification/IdentityVerificationTestIT.java b/src/test/java/com/checkout/identities/identityverification/IdentityVerificationTestIT.java index 62624c5a..05a43ffc 100644 --- a/src/test/java/com/checkout/identities/identityverification/IdentityVerificationTestIT.java +++ b/src/test/java/com/checkout/identities/identityverification/IdentityVerificationTestIT.java @@ -32,13 +32,13 @@ class IdentityVerificationTestIT extends SandboxTestFixture { @Test @Disabled("Integration test - requires valid applicant and user journey") - void shouldCreateAndOpenIdentityVerificationAsync() { + void shouldCreateAndOpenIdentityVerification() { // Arrange final CreateAndOpenIdentityVerificationRequest request = createCreateAndOpenIdentityVerificationRequest(); // Act final IdentityVerificationResponse response = blocking(() -> - checkoutApi.identityVerificationClient().createAndOpenIdentityVerificationAsync(request)); + checkoutApi.identityVerificationClient().createAndOpenIdentityVerification(request)); // Assert validateCreatedAndOpenedIdentityVerification(response, request); @@ -46,13 +46,13 @@ void shouldCreateAndOpenIdentityVerificationAsync() { @Test @Disabled("Integration test - requires valid applicant and user journey") - void shouldCreateIdentityVerificationAsync() { + void shouldCreateIdentityVerification() { // Arrange final IdentityVerificationRequest request = createIdentityVerificationRequest(); // Act final IdentityVerificationResponse response = blocking(() -> - checkoutApi.identityVerificationClient().createIdentityVerificationAsync(request)); + checkoutApi.identityVerificationClient().createIdentityVerification(request)); // Assert validateCreatedIdentityVerification(response, request); @@ -60,15 +60,15 @@ void shouldCreateIdentityVerificationAsync() { @Test @Disabled("Integration test - requires valid identity verification ID") - void shouldGetIdentityVerificationAsync() { + void shouldGetIdentityVerification() { // Arrange final IdentityVerificationRequest request = createIdentityVerificationRequest(); final IdentityVerificationResponse created = blocking(() -> - checkoutApi.identityVerificationClient().createIdentityVerificationAsync(request)); + checkoutApi.identityVerificationClient().createIdentityVerification(request)); // Act final IdentityVerificationResponse retrieved = blocking(() -> - checkoutApi.identityVerificationClient().getIdentityVerificationAsync(created.getId())); + checkoutApi.identityVerificationClient().getIdentityVerification(created.getId())); // Assert validateRetrievedIdentityVerification(retrieved, created); @@ -76,15 +76,15 @@ void shouldGetIdentityVerificationAsync() { @Test @Disabled("Integration test - requires valid identity verification ID") - void shouldAnonymizeIdentityVerificationAsync() { + void shouldAnonymizeIdentityVerification() { // Arrange final IdentityVerificationRequest request = createIdentityVerificationRequest(); final IdentityVerificationResponse created = blocking(() -> - checkoutApi.identityVerificationClient().createIdentityVerificationAsync(request)); + checkoutApi.identityVerificationClient().createIdentityVerification(request)); // Act final IdentityVerificationResponse anonymized = blocking(() -> - checkoutApi.identityVerificationClient().anonymizeIdentityVerificationAsync(created.getId())); + checkoutApi.identityVerificationClient().anonymizeIdentityVerification(created.getId())); // Assert validateAnonymizedIdentityVerification(anonymized); @@ -92,18 +92,18 @@ void shouldAnonymizeIdentityVerificationAsync() { @Test @Disabled("Integration test - requires valid identity verification ID") - void shouldGetIdentityVerificationAttemptsAsync() { + void shouldGetIdentityVerificationAttempts() { // Arrange final IdentityVerificationRequest request = createIdentityVerificationRequest(); final IdentityVerificationResponse created = blocking(() -> - checkoutApi.identityVerificationClient().createIdentityVerificationAsync(request)); + checkoutApi.identityVerificationClient().createIdentityVerification(request)); final IdentityVerificationAttemptRequest attemptRequest = createIdentityVerificationAttemptRequest(); final IdentityVerificationAttemptResponse createdAttempt = blocking(() -> - checkoutApi.identityVerificationClient().createIdentityVerificationAttemptAsync(created.getId(), attemptRequest)); + checkoutApi.identityVerificationClient().createIdentityVerificationAttempt(created.getId(), attemptRequest)); // Act final IdentityVerificationAttemptsResponse attempts = blocking(() -> - checkoutApi.identityVerificationClient().getIdentityVerificationAttemptsAsync(created.getId())); + checkoutApi.identityVerificationClient().getIdentityVerificationAttempts(created.getId())); // Assert validateRetrievedIdentityVerificationAttempts(attempts, createdAttempt); @@ -111,16 +111,16 @@ void shouldGetIdentityVerificationAttemptsAsync() { @Test @Disabled("Integration test - requires valid identity verification ID") - void shouldCreateIdentityVerificationAttemptAsync() { + void shouldCreateIdentityVerificationAttempt() { // Arrange final IdentityVerificationRequest request = createIdentityVerificationRequest(); final IdentityVerificationResponse created = blocking(() -> - checkoutApi.identityVerificationClient().createIdentityVerificationAsync(request)); + checkoutApi.identityVerificationClient().createIdentityVerification(request)); final IdentityVerificationAttemptRequest attemptRequest = createIdentityVerificationAttemptRequest(); // Act final IdentityVerificationAttemptResponse attempt = blocking(() -> - checkoutApi.identityVerificationClient().createIdentityVerificationAttemptAsync(created.getId(), attemptRequest)); + checkoutApi.identityVerificationClient().createIdentityVerificationAttempt(created.getId(), attemptRequest)); // Assert validateCreatedIdentityVerificationAttempt(attempt); @@ -128,18 +128,18 @@ void shouldCreateIdentityVerificationAttemptAsync() { @Test @Disabled("Integration test - requires valid identity verification and attempt IDs") - void shouldGetIdentityVerificationAttemptAsync() { + void shouldGetIdentityVerificationAttempt() { // Arrange final IdentityVerificationRequest request = createIdentityVerificationRequest(); final IdentityVerificationResponse created = blocking(() -> - checkoutApi.identityVerificationClient().createIdentityVerificationAsync(request)); + checkoutApi.identityVerificationClient().createIdentityVerification(request)); final IdentityVerificationAttemptRequest attemptRequest = createIdentityVerificationAttemptRequest(); final IdentityVerificationAttemptResponse createdAttempt = blocking(() -> - checkoutApi.identityVerificationClient().createIdentityVerificationAttemptAsync(created.getId(), attemptRequest)); + checkoutApi.identityVerificationClient().createIdentityVerificationAttempt(created.getId(), attemptRequest)); // Act final IdentityVerificationAttemptResponse retrievedAttempt = blocking(() -> - checkoutApi.identityVerificationClient().getIdentityVerificationAttemptAsync(created.getId(), createdAttempt.getId())); + checkoutApi.identityVerificationClient().getIdentityVerificationAttempt(created.getId(), createdAttempt.getId())); // Assert validateRetrievedIdentityVerificationAttempt(retrievedAttempt, createdAttempt); @@ -147,15 +147,15 @@ void shouldGetIdentityVerificationAttemptAsync() { @Test @Disabled("Integration test - requires valid identity verification ID") - void shouldGenerateIdentityVerificationReportAsync() { + void shouldGenerateIdentityVerificationReport() { // Arrange final IdentityVerificationRequest request = createIdentityVerificationRequest(); final IdentityVerificationResponse created = blocking(() -> - checkoutApi.identityVerificationClient().createIdentityVerificationAsync(request)); + checkoutApi.identityVerificationClient().createIdentityVerification(request)); // Act final IdentityVerificationReportResponse report = blocking(() -> - checkoutApi.identityVerificationClient().generateIdentityVerificationReportAsync(created.getId())); + checkoutApi.identityVerificationClient().generateIdentityVerificationReport(created.getId())); // Assert validateGeneratedIdentityVerificationReport(report); @@ -165,12 +165,12 @@ void shouldGenerateIdentityVerificationReportAsync() { @Test @Disabled("Integration test - requires valid applicant and user journey") - void shouldCreateAndOpenIdentityVerification() { + void shouldCreateAndOpenIdentityVerificationSync() { // Arrange final CreateAndOpenIdentityVerificationRequest request = createCreateAndOpenIdentityVerificationRequest(); // Act - final IdentityVerificationResponse response = checkoutApi.identityVerificationClient().createAndOpenIdentityVerification(request); + final IdentityVerificationResponse response = checkoutApi.identityVerificationClient().createAndOpenIdentityVerificationSync(request); // Assert validateCreatedAndOpenedIdentityVerification(response, request); @@ -178,12 +178,12 @@ void shouldCreateAndOpenIdentityVerification() { @Test @Disabled("Integration test - requires valid applicant and user journey") - void shouldCreateIdentityVerification() { + void shouldCreateIdentityVerificationSync() { // Arrange final IdentityVerificationRequest request = createIdentityVerificationRequest(); // Act - final IdentityVerificationResponse response = checkoutApi.identityVerificationClient().createIdentityVerification(request); + final IdentityVerificationResponse response = checkoutApi.identityVerificationClient().createIdentityVerificationSync(request); // Assert validateCreatedIdentityVerification(response, request); @@ -191,13 +191,13 @@ void shouldCreateIdentityVerification() { @Test @Disabled("Integration test - requires valid identity verification ID") - void shouldGetIdentityVerification() { + void shouldGetIdentityVerificationSync() { // Arrange final IdentityVerificationRequest request = createIdentityVerificationRequest(); - final IdentityVerificationResponse created = checkoutApi.identityVerificationClient().createIdentityVerification(request); + final IdentityVerificationResponse created = checkoutApi.identityVerificationClient().createIdentityVerificationSync(request); // Act - final IdentityVerificationResponse retrieved = checkoutApi.identityVerificationClient().getIdentityVerification(created.getId()); + final IdentityVerificationResponse retrieved = checkoutApi.identityVerificationClient().getIdentityVerificationSync(created.getId()); // Assert validateRetrievedIdentityVerification(retrieved, created); @@ -205,13 +205,13 @@ void shouldGetIdentityVerification() { @Test @Disabled("Integration test - requires valid identity verification ID") - void shouldAnonymizeIdentityVerification() { + void shouldAnonymizeIdentityVerificationSync() { // Arrange final IdentityVerificationRequest request = createIdentityVerificationRequest(); - final IdentityVerificationResponse created = checkoutApi.identityVerificationClient().createIdentityVerification(request); + final IdentityVerificationResponse created = checkoutApi.identityVerificationClient().createIdentityVerificationSync(request); // Act - final IdentityVerificationResponse anonymized = checkoutApi.identityVerificationClient().anonymizeIdentityVerification(created.getId()); + final IdentityVerificationResponse anonymized = checkoutApi.identityVerificationClient().anonymizeIdentityVerificationSync(created.getId()); // Assert validateAnonymizedIdentityVerification(anonymized); @@ -219,15 +219,15 @@ void shouldAnonymizeIdentityVerification() { @Test @Disabled("Integration test - requires valid identity verification ID") - void shouldGetIdentityVerificationAttempts() { + void shouldGetIdentityVerificationAttemptsSync() { // Arrange final IdentityVerificationRequest request = createIdentityVerificationRequest(); - final IdentityVerificationResponse created = checkoutApi.identityVerificationClient().createIdentityVerification(request); + final IdentityVerificationResponse created = checkoutApi.identityVerificationClient().createIdentityVerificationSync(request); final IdentityVerificationAttemptRequest attemptRequest = createIdentityVerificationAttemptRequest(); - final IdentityVerificationAttemptResponse createdAttempt = checkoutApi.identityVerificationClient().createIdentityVerificationAttempt(created.getId(), attemptRequest); + final IdentityVerificationAttemptResponse createdAttempt = checkoutApi.identityVerificationClient().createIdentityVerificationAttemptSync(created.getId(), attemptRequest); // Act - final IdentityVerificationAttemptsResponse attempts = checkoutApi.identityVerificationClient().getIdentityVerificationAttempts(created.getId()); + final IdentityVerificationAttemptsResponse attempts = checkoutApi.identityVerificationClient().getIdentityVerificationAttemptsSync(created.getId()); // Assert validateRetrievedIdentityVerificationAttempts(attempts, createdAttempt); @@ -235,14 +235,14 @@ void shouldGetIdentityVerificationAttempts() { @Test @Disabled("Integration test - requires valid identity verification ID") - void shouldCreateIdentityVerificationAttempt() { + void shouldCreateIdentityVerificationAttemptSync() { // Arrange final IdentityVerificationRequest request = createIdentityVerificationRequest(); - final IdentityVerificationResponse created = checkoutApi.identityVerificationClient().createIdentityVerification(request); + final IdentityVerificationResponse created = checkoutApi.identityVerificationClient().createIdentityVerificationSync(request); final IdentityVerificationAttemptRequest attemptRequest = createIdentityVerificationAttemptRequest(); // Act - final IdentityVerificationAttemptResponse attempt = checkoutApi.identityVerificationClient().createIdentityVerificationAttempt(created.getId(), attemptRequest); + final IdentityVerificationAttemptResponse attempt = checkoutApi.identityVerificationClient().createIdentityVerificationAttemptSync(created.getId(), attemptRequest); // Assert validateCreatedIdentityVerificationAttempt(attempt); @@ -250,15 +250,15 @@ void shouldCreateIdentityVerificationAttempt() { @Test @Disabled("Integration test - requires valid identity verification and attempt IDs") - void shouldGetIdentityVerificationAttempt() { + void shouldGetIdentityVerificationAttemptSync() { // Arrange final IdentityVerificationRequest request = createIdentityVerificationRequest(); - final IdentityVerificationResponse created = checkoutApi.identityVerificationClient().createIdentityVerification(request); + final IdentityVerificationResponse created = checkoutApi.identityVerificationClient().createIdentityVerificationSync(request); final IdentityVerificationAttemptRequest attemptRequest = createIdentityVerificationAttemptRequest(); - final IdentityVerificationAttemptResponse createdAttempt = checkoutApi.identityVerificationClient().createIdentityVerificationAttempt(created.getId(), attemptRequest); + final IdentityVerificationAttemptResponse createdAttempt = checkoutApi.identityVerificationClient().createIdentityVerificationAttemptSync(created.getId(), attemptRequest); // Act - final IdentityVerificationAttemptResponse retrievedAttempt = checkoutApi.identityVerificationClient().getIdentityVerificationAttempt(created.getId(), createdAttempt.getId()); + final IdentityVerificationAttemptResponse retrievedAttempt = checkoutApi.identityVerificationClient().getIdentityVerificationAttemptSync(created.getId(), createdAttempt.getId()); // Assert validateRetrievedIdentityVerificationAttempt(retrievedAttempt, createdAttempt); @@ -266,16 +266,16 @@ void shouldGetIdentityVerificationAttempt() { @Test @Disabled("Integration test - requires valid identity verification and attempt IDs") - void shouldGetIdentityVerificationAttemptAssets() { + void shouldGetIdentityVerificationAttemptAssetsSync() { // Arrange final IdentityVerificationRequest request = createIdentityVerificationRequest(); - final IdentityVerificationResponse created = checkoutApi.identityVerificationClient().createIdentityVerification(request); + final IdentityVerificationResponse created = checkoutApi.identityVerificationClient().createIdentityVerificationSync(request); final IdentityVerificationAttemptRequest attemptRequest = createIdentityVerificationAttemptRequest(); - final IdentityVerificationAttemptResponse createdAttempt = checkoutApi.identityVerificationClient().createIdentityVerificationAttempt(created.getId(), attemptRequest); + final IdentityVerificationAttemptResponse createdAttempt = checkoutApi.identityVerificationClient().createIdentityVerificationAttemptSync(created.getId(), attemptRequest); final AttemptAssetsQueryFilter queryFilter = AttemptAssetsQueryFilter.builder().skip(0).limit(10).build(); // Act - final IdentityVerificationAttemptAssetsResponse assets = checkoutApi.identityVerificationClient().getIdentityVerificationAttemptAssets(created.getId(), createdAttempt.getId(), queryFilter); + final IdentityVerificationAttemptAssetsResponse assets = checkoutApi.identityVerificationClient().getIdentityVerificationAttemptAssetsSync(created.getId(), createdAttempt.getId(), queryFilter); // Assert assertNotNull(assets); @@ -284,13 +284,13 @@ void shouldGetIdentityVerificationAttemptAssets() { @Test @Disabled("Integration test - requires valid identity verification ID") - void shouldGenerateIdentityVerificationReport() { + void shouldGenerateIdentityVerificationReportSync() { // Arrange final IdentityVerificationRequest request = createIdentityVerificationRequest(); - final IdentityVerificationResponse created = checkoutApi.identityVerificationClient().createIdentityVerification(request); + final IdentityVerificationResponse created = checkoutApi.identityVerificationClient().createIdentityVerificationSync(request); // Act - final IdentityVerificationReportResponse report = checkoutApi.identityVerificationClient().generateIdentityVerificationReport(created.getId()); + final IdentityVerificationReportResponse report = checkoutApi.identityVerificationClient().generateIdentityVerificationReportSync(created.getId()); // Assert validateGeneratedIdentityVerificationReport(report); diff --git a/src/test/java/com/checkout/reconciliation/previous/ReconciliationClientImplTest.java b/src/test/java/com/checkout/reconciliation/previous/ReconciliationClientImplTest.java index acf750ce..249aa5c9 100644 --- a/src/test/java/com/checkout/reconciliation/previous/ReconciliationClientImplTest.java +++ b/src/test/java/com/checkout/reconciliation/previous/ReconciliationClientImplTest.java @@ -64,13 +64,13 @@ void shouldQueryPaymentsReport() throws ExecutionException, InterruptedException } @Test - void shouldSinglePaymentReportAsync() throws ExecutionException, InterruptedException { + void shouldSinglePaymentReport() throws ExecutionException, InterruptedException { final ReconciliationPaymentReportResponse response = mock(ReconciliationPaymentReportResponse.class); when(apiClient.getAsync(eq("reporting/payments/payment_id"), any(SdkAuthorization.class), eq(ReconciliationPaymentReportResponse.class))) .thenReturn(CompletableFuture.completedFuture(response)); - final CompletableFuture future = client.singlePaymentReportAsync("payment_id"); + final CompletableFuture future = client.singlePaymentReport("payment_id"); assertNotNull(future.get()); assertEquals(response, future.get()); diff --git a/src/test/java/com/checkout/reconciliation/previous/ReconciliationTestIT.java b/src/test/java/com/checkout/reconciliation/previous/ReconciliationTestIT.java index 23eefd1b..102bf826 100644 --- a/src/test/java/com/checkout/reconciliation/previous/ReconciliationTestIT.java +++ b/src/test/java/com/checkout/reconciliation/previous/ReconciliationTestIT.java @@ -73,7 +73,7 @@ void shouldQueryPaymentsReport() throws ExecutionException, InterruptedException @Disabled("Only works in production") void shouldGetSinglePaymentReport() throws ExecutionException, InterruptedException { - final ReconciliationPaymentReportResponse response = getProductionCheckoutApi().reconciliationClient().singlePaymentReportAsync("id").get(); + final ReconciliationPaymentReportResponse response = getProductionCheckoutApi().reconciliationClient().singlePaymentReport("id").get(); assertNotNull(response); assertNotNull(response.getLinks()); From d2d3da960ef8117faf627a67cab9e89aadd1d8c1 Mon Sep 17 00:00:00 2001 From: david ruiz Date: Thu, 18 Jun 2026 16:53:27 +0200 Subject: [PATCH 3/3] Skip tests: card product account range is full (422 invalid_request: card_product_account_range_full) --- .../java/com/checkout/issuing/IssuingTransactionsTestIT.java | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/test/java/com/checkout/issuing/IssuingTransactionsTestIT.java b/src/test/java/com/checkout/issuing/IssuingTransactionsTestIT.java index 7977427d..2ce67e95 100644 --- a/src/test/java/com/checkout/issuing/IssuingTransactionsTestIT.java +++ b/src/test/java/com/checkout/issuing/IssuingTransactionsTestIT.java @@ -6,15 +6,14 @@ import com.checkout.issuing.transactions.responses.TransactionsListResponse; import com.checkout.issuing.transactions.responses.TransactionsSingleResponse; import org.junit.jupiter.api.BeforeAll; -//import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.TestInstance; import static org.junit.jupiter.api.Assertions.assertNotNull; -//@Disabled("Sandbox card product account range is full (card_product_account_range_full); " + -// "requires a card product with available account range") +@Disabled("Sandbox card product account range is full (422 invalid_request: card_product_account_range_full) - card creation prerequisite cannot be satisfied") @TestInstance(TestInstance.Lifecycle.PER_CLASS) class IssuingTransactionsTestIT extends BaseIssuingTestIT {