From 561a0a0fcdbc080ac2f47485409e9ee3c8c3c789 Mon Sep 17 00:00:00 2001 From: jkurra-hw Date: Sat, 14 Nov 2020 00:14:15 +0530 Subject: [PATCH 1/3] DTRUNETWO-298-Transfer Refunds methods added in v3 --- .../hyperwallet/clientsdk/Hyperwallet.java | 75 ++++- .../model/HyperwalletTransferRefund.java | 306 ++++++++++++++++++ .../clientsdk/HyperwalletTest.java | 230 ++++++++++++- 3 files changed, 606 insertions(+), 5 deletions(-) create mode 100644 src/main/java/com/hyperwallet/clientsdk/model/HyperwalletTransferRefund.java diff --git a/src/main/java/com/hyperwallet/clientsdk/Hyperwallet.java b/src/main/java/com/hyperwallet/clientsdk/Hyperwallet.java index 80ef53304..6f06468d1 100644 --- a/src/main/java/com/hyperwallet/clientsdk/Hyperwallet.java +++ b/src/main/java/com/hyperwallet/clientsdk/Hyperwallet.java @@ -2130,8 +2130,77 @@ public HyperwalletTransferMethod createTransferMethod(String jsonCacheToken, Str HashMap headers = new HashMap(); headers.put("Json-Cache-Token", jsonCacheToken); - return apiClient.post(url + "/users/" + transferMethod.getUserToken() + "/transfer-methods", transferMethod, HyperwalletTransferMethod.class, headers); + return apiClient.post(url + "/users/" + transferMethod.getUserToken() + "/transfer-methods", transferMethod, HyperwalletTransferMethod.class, + headers); } + + //-------------------------------------- + // Transfer refunds + //-------------------------------------- + + /** + * Create Transfer Refund + * + * @param transferToken Transfer token assigned + * @param transferRefund Transfer Refund object to create + * @return Created Transfer Refund + */ + public HyperwalletTransferRefund createTransferRefund(String transferToken, HyperwalletTransferRefund transferRefund) { + if (transferRefund == null) { + throw new HyperwalletException("Transfer Refund is required"); + } + if (StringUtils.isEmpty(transferToken)) { + throw new HyperwalletException("Transfer token is required"); + } + if (StringUtils.isEmpty(transferRefund.getClientRefundId())) { + throw new HyperwalletException("ClientRefundId is required"); + } + + transferRefund = copy(transferRefund); + transferRefund.clearStatus(); + transferRefund.clearCreatedOn(); + return apiClient.post(url + "/transfers/" + transferToken + "/refunds", transferRefund, HyperwalletTransferRefund.class); + } + + /** + * Get Transfer Refund + * + * @param transferToken Transfer token assigned + * @param transferRefundToken Transfer Refund token assigned + * @return Transfer Refund object + */ + public HyperwalletTransferRefund getTransferRefund(String transferToken, String transferRefundToken) { + if (StringUtils.isEmpty(transferToken)) { + throw new HyperwalletException("Transfer token is required"); + } + if (StringUtils.isEmpty(transferRefundToken)) { + throw new HyperwalletException("Transfer Refund token is required"); + } + + return apiClient.get(url + "/transfers/" + transferToken + "/refunds/" + transferRefundToken, HyperwalletTransferRefund.class); + } + + /** + * List Transfer Refund Requests + * + * @param options List filter option + * @param transferToken Transfer token assigned + * @return HyperwalletList of HyperwalletTransferRefund + */ + public HyperwalletList listTransferRefunds(String transferToken, HyperwalletTransferListOptions options) { + if (StringUtils.isEmpty(transferToken)) { + throw new HyperwalletException("Transfer token is required"); + } + + String url = paginate(this.url + "/transfers/" + transferToken + "/refunds", options); + if (options != null) { + url = addParameter(url, "clientRefundId", options.getDestinationToken()); + url = addParameter(url, "sourceToken", options.getSourceToken()); + } + return apiClient.get(url, new TypeReference>() { + }); + } + //-------------------------------------- // Internal utils //-------------------------------------- @@ -2233,4 +2302,8 @@ private HyperwalletVenmoAccount copy(HyperwalletVenmoAccount venmoAccount) { return venmoAccount; } + private HyperwalletTransferRefund copy(HyperwalletTransferRefund transferRefund) { + return HyperwalletJsonUtil.fromJson(HyperwalletJsonUtil.toJson(transferRefund), HyperwalletTransferRefund.class); + } + } diff --git a/src/main/java/com/hyperwallet/clientsdk/model/HyperwalletTransferRefund.java b/src/main/java/com/hyperwallet/clientsdk/model/HyperwalletTransferRefund.java new file mode 100644 index 000000000..ba5521744 --- /dev/null +++ b/src/main/java/com/hyperwallet/clientsdk/model/HyperwalletTransferRefund.java @@ -0,0 +1,306 @@ +package com.hyperwallet.clientsdk.model; + +import com.fasterxml.jackson.annotation.JsonFilter; +import com.hyperwallet.clientsdk.model.HyperwalletTransfer.ForeignExchange; +import com.hyperwallet.clientsdk.util.HyperwalletJsonConfiguration; + +import javax.xml.bind.annotation.XmlAccessType; +import javax.xml.bind.annotation.XmlAccessorType; +import javax.xml.bind.annotation.XmlRootElement; +import java.util.Date; +import java.util.List; + +@JsonFilter(HyperwalletJsonConfiguration.INCLUSION_FILTER) +@XmlRootElement +@XmlAccessorType(XmlAccessType.FIELD) +public class HyperwalletTransferRefund extends HyperwalletBaseMonitor { + + public static enum Status {PENDING, FAILED, COMPLETED} + + private String token; + private Status status; + private String clientRefundId; + private String sourceToken; + private Double sourceAmount; + private String sourceCurrency; + private String destinationToken; + private Double destinationAmount; + private String destinationCurrency; + private List foreignExchanges; + private Date createdOn; + private String notes; + private String memo; + + public String getToken() { + return token; + } + + public void setToken(String token) { + addField("token", token); + this.token = token; + } + + public HyperwalletTransferRefund token(String token) { + addField("token", token); + this.token = token; + return this; + } + + public HyperwalletTransferRefund clearToken() { + clearField("token"); + this.token = null; + return this; + } + + public Status getStatus() { + return status; + } + + public void setStatus(Status status) { + addField("status", status); + this.status = status; + } + + public HyperwalletTransferRefund status(Status status) { + addField("status", status); + this.status = status; + return this; + } + + public HyperwalletTransferRefund clearStatus() { + clearField("status"); + this.status = null; + return this; + } + + public String getClientRefundId() { + return clientRefundId; + } + + public void setClientRefundId(String clientRefundId) { + addField("clientRefundId", clientRefundId); + this.clientRefundId = clientRefundId; + } + + public HyperwalletTransferRefund clientRefundId(String clientRefundId) { + addField("clientRefundId", clientRefundId); + this.clientRefundId = clientRefundId; + return this; + } + + public HyperwalletTransferRefund clearClientRefundId() { + clearField("clientRefundId"); + this.clientRefundId = null; + return this; + } + + public String getSourceToken() { + return sourceToken; + } + + public void setSourceToken(String sourceToken) { + addField("sourceToken", sourceToken); + this.sourceToken = sourceToken; + } + + public HyperwalletTransferRefund sourceToken(String sourceToken) { + addField("sourceToken", sourceToken); + this.sourceToken = sourceToken; + return this; + } + + public HyperwalletTransferRefund clearSourceToken() { + clearField("sourceToken"); + this.sourceToken = null; + return this; + } + + public Double getSourceAmount() { + return sourceAmount; + } + + public void setSourceAmount(Double sourceAmount) { + addField("sourceAmount", sourceAmount); + this.sourceAmount = sourceAmount; + } + + public HyperwalletTransferRefund sourceAmount(Double sourceAmount) { + addField("sourceAmount", sourceAmount); + this.sourceAmount = sourceAmount; + return this; + } + + public HyperwalletTransferRefund clearSourceAmount() { + clearField("sourceAmount"); + this.sourceAmount = null; + return this; + } + + public String getSourceCurrency() { + return sourceCurrency; + } + + public void setSourceCurrency(String sourceCurrency) { + addField("sourceCurrency", sourceCurrency); + this.sourceCurrency = sourceCurrency; + } + + public HyperwalletTransferRefund sourceCurrency(String sourceCurrency) { + addField("sourceCurrency", sourceCurrency); + this.sourceCurrency = sourceCurrency; + return this; + } + + public HyperwalletTransferRefund clearSourceCurrency() { + clearField("sourceCurrency"); + this.sourceCurrency = null; + return this; + } + + public String getDestinationToken() { + return destinationToken; + } + + public void setDestinationToken(String destinationToken) { + addField("destinationToken", destinationToken); + this.destinationToken = destinationToken; + } + + public HyperwalletTransferRefund destinationToken(String destinationToken) { + addField("destinationToken", destinationToken); + this.destinationToken = destinationToken; + return this; + } + + public HyperwalletTransferRefund clearDestinationToken() { + clearField("destinationToken"); + this.destinationToken = null; + return this; + } + + public Double getDestinationAmount() { + return destinationAmount; + } + + public void setDestinationAmount(Double destinationAmount) { + addField("destinationAmount", destinationAmount); + this.destinationAmount = destinationAmount; + } + + public HyperwalletTransferRefund destinationAmount(Double destinationAmount) { + addField("destinationAmount", destinationAmount); + this.destinationAmount = destinationAmount; + return this; + } + + public HyperwalletTransferRefund clearDestinationAmount() { + clearField("destinationAmount"); + this.destinationAmount = null; + return this; + } + + public String getDestinationCurrency() { + return destinationCurrency; + } + + public void setDestinationCurrency(String destinationCurrency) { + addField("destinationCurrency", destinationCurrency); + this.destinationCurrency = destinationCurrency; + } + + public HyperwalletTransferRefund destinationCurrency(String destinationCurrency) { + addField("destinationCurrency", destinationCurrency); + this.destinationCurrency = destinationCurrency; + return this; + } + + public HyperwalletTransferRefund clearDestinationCurrency() { + clearField("destinationCurrency"); + this.destinationCurrency = null; + return this; + } + + public Date getCreatedOn() { + return createdOn; + } + + public void setCreatedOn(Date createdOn) { + addField("createdOn", createdOn); + this.createdOn = createdOn; + } + + public HyperwalletTransferRefund createdOn(Date createdOn) { + addField("createdOn", createdOn); + this.createdOn = createdOn; + return this; + } + + public HyperwalletTransferRefund clearCreatedOn() { + clearField("createdOn"); + this.createdOn = null; + return this; + } + + public String getNotes() { + return notes; + } + + public void setNotes(String notes) { + addField("notes", notes); + this.notes = notes; + } + + public HyperwalletTransferRefund notes(String notes) { + addField("notes", notes); + this.notes = notes; + return this; + } + + public HyperwalletTransferRefund clearNotes() { + clearField("notes"); + this.notes = null; + return this; + } + + public String getMemo() { + return memo; + } + + public void setMemo(String memo) { + addField("memo", memo); + this.memo = memo; + } + + public HyperwalletTransferRefund memo(String memo) { + addField("memo", memo); + this.memo = memo; + return this; + } + + public HyperwalletTransferRefund clearMemo() { + clearField("memo"); + this.memo = null; + return this; + } + + public List getForeignExchanges() { + return foreignExchanges; + } + + public void setForeignExchanges(List foreignExchanges) { + addField("foreignExchanges", foreignExchanges); + this.foreignExchanges = foreignExchanges; + } + + public HyperwalletTransferRefund foreignExchanges(List foreignExchanges) { + addField("foreignExchanges", foreignExchanges); + this.foreignExchanges = foreignExchanges; + return this; + } + + public HyperwalletTransferRefund clearForeignExchanges() { + clearField("foreignExchanges"); + this.foreignExchanges = null; + return this; + } +} diff --git a/src/test/java/com/hyperwallet/clientsdk/HyperwalletTest.java b/src/test/java/com/hyperwallet/clientsdk/HyperwalletTest.java index 782845a8d..621190cef 100644 --- a/src/test/java/com/hyperwallet/clientsdk/HyperwalletTest.java +++ b/src/test/java/com/hyperwallet/clientsdk/HyperwalletTest.java @@ -3,6 +3,7 @@ import com.fasterxml.jackson.core.type.TypeReference; import com.hyperwallet.clientsdk.model.*; import com.hyperwallet.clientsdk.model.HyperwalletStatusTransition.Status; +import com.hyperwallet.clientsdk.model.HyperwalletTransfer.ForeignExchange; import com.hyperwallet.clientsdk.model.HyperwalletUser.VerificationStatus; import com.hyperwallet.clientsdk.util.HyperwalletApiClient; import org.mockito.ArgumentCaptor; @@ -15,10 +16,7 @@ import java.lang.reflect.Method; import java.text.DateFormat; import java.text.SimpleDateFormat; -import java.util.Date; -import java.util.HashMap; -import java.util.Locale; -import java.util.TimeZone; +import java.util.*; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.*; @@ -7060,4 +7058,228 @@ private HyperwalletTransferMethod createPrePopulatedTransferMethod() { .country("test-country"); return transferMethod; } + //-------------------------------------- + // Transfer Refund + //-------------------------------------- + + private void checkHyperwalletException(HyperwalletException actual, HyperwalletException expected) { + assertThat(actual.getErrorCode(), is(expected.getErrorCode())); + assertThat(actual.getResponse(), is(expected.getResponse())); + assertThat(actual.getErrorMessage(), is(expected.getErrorMessage())); + assertThat(actual.getMessage(), is(expected.getMessage())); + assertThat(actual.getHyperwalletErrors(), is(expected.getHyperwalletErrors())); + assertThat(actual.getRelatedResources(), is(expected.getRelatedResources())); + } + + @Test + public void testCreateTransferRefund_noTransferRefund() { + Hyperwallet client = new Hyperwallet("test-username", "test-password"); + try { + client.createTransferRefund("transferToken", null); + fail("Expect HyperwalletException"); + } catch (HyperwalletException e) { + HyperwalletException expectedException = new HyperwalletException("Transfer Refund is required"); + checkHyperwalletException(e, expectedException); + } + } + + @Test + public void testCreateTransferRefund_noTransferToken() { + Hyperwallet client = new Hyperwallet("test-username", "test-password"); + try { + client.createTransferRefund(null, new HyperwalletTransferRefund()); + fail("Expect HyperwalletException"); + } catch (HyperwalletException e) { + HyperwalletException expectedException = new HyperwalletException("Transfer token is required"); + checkHyperwalletException(e, expectedException); + } + } + + @Test + public void testCreateTransferRefund_noClientRefundId() { + Hyperwallet client = new Hyperwallet("test-username", "test-password"); + try { + client.createTransferRefund("transferToken", new HyperwalletTransferRefund()); + fail("Expect HyperwalletException"); + } catch (HyperwalletException e) { + HyperwalletException expectedException = new HyperwalletException("ClientRefundId is required"); + checkHyperwalletException(e, expectedException); + } + } + + @Test + public void testCreateTransferRefund_successful() throws Exception { + String clientRefundId = "clientRefundId"; + double sourceAmount = 20.0; + String notes = "notes"; + String memo = "memo"; + + ForeignExchange foreignExchange = new ForeignExchange(); + foreignExchange.setSourceAmount(200.0); + foreignExchange.setSourceCurrency("USD"); + foreignExchange.setDestinationAmount(100.0); + foreignExchange.setDestinationCurrency("CAD"); + foreignExchange.setRate(2.3); + + HyperwalletTransferRefund transferRefund = new HyperwalletTransferRefund(); + transferRefund.setClientRefundId(clientRefundId); + transferRefund.setSourceAmount(sourceAmount); + transferRefund.setNotes(notes); + transferRefund.setMemo(memo); + transferRefund.setForeignExchanges(Collections.singletonList(foreignExchange)); + + HyperwalletTransferRefund transferRefundResponse = new HyperwalletTransferRefund(); + + Hyperwallet client = new Hyperwallet("test-username", "test-password"); + HyperwalletApiClient mockApiClient = createAndInjectHyperwalletApiClientMock(client); + + Mockito.when(mockApiClient.post(Mockito.anyString(), Mockito.anyObject(), Mockito.any(Class.class))).thenReturn(transferRefundResponse); + + String transferToken = "transferToken"; + HyperwalletTransferRefund resp = client.createTransferRefund(transferToken, transferRefund); + assertThat(resp, is(equalTo(transferRefundResponse))); + + ArgumentCaptor argument = ArgumentCaptor.forClass(HyperwalletTransferRefund.class); + Mockito.verify(mockApiClient).post(Mockito.eq("https://api.sandbox.hyperwallet.com/rest/v3/transfers/" + transferToken + "/refunds"), + argument.capture(), Mockito.eq(transferRefund.getClass())); + + HyperwalletTransferRefund apiTransfer = argument.getValue(); + assertThat(apiTransfer, is(notNullValue())); + assertThat(apiTransfer.getClientRefundId(), is(equalTo(clientRefundId))); + assertThat(apiTransfer.getSourceAmount(), is(equalTo(sourceAmount))); + assertThat(apiTransfer.getNotes(), is(equalTo(notes))); + assertThat(apiTransfer.getMemo(), is(equalTo(memo))); + assertThat(apiTransfer.getCreatedOn(), is(nullValue())); + assertThat(apiTransfer.getStatus(), is(nullValue())); + + ForeignExchange foreignExchangeResponse = apiTransfer.getForeignExchanges().get(0); + assertThat(foreignExchange.getSourceAmount(), is(equalTo(200.0))); + assertThat(foreignExchange.getSourceCurrency(), is(equalTo("USD"))); + assertThat(foreignExchange.getDestinationAmount(), is(equalTo(100.0))); + assertThat(foreignExchange.getDestinationCurrency(), is(equalTo("CAD"))); + assertThat(foreignExchange.getRate(), is(equalTo(2.3))); + } + + @Test + public void testGetTransferRefund_noTransferToken() { + Hyperwallet client = new Hyperwallet("test-username", "test-password"); + try { + client.getTransferRefund(null, "transferRefundToken"); + fail("Expect HyperwalletException"); + } catch (HyperwalletException e) { + HyperwalletException expectedException = new HyperwalletException("Transfer token is required"); + checkHyperwalletException(e, expectedException); + } + } + + @Test + public void testGetTransferRefund_noTransferRefundToken() { + Hyperwallet client = new Hyperwallet("test-username", "test-password"); + try { + client.getTransferRefund("transferToken", null); + fail("Expect HyperwalletException"); + } catch (HyperwalletException e) { + HyperwalletException expectedException = new HyperwalletException("Transfer Refund token is required"); + checkHyperwalletException(e, expectedException); + } + } + + @Test + public void testGetTransferRefund_successful() throws Exception { + HyperwalletTransferRefund transferRefund = new HyperwalletTransferRefund(); + + Hyperwallet client = new Hyperwallet("test-username", "test-password"); + HyperwalletApiClient mockApiClient = createAndInjectHyperwalletApiClientMock(client); + + Mockito.when(mockApiClient.get(Mockito.anyString(), Mockito.any(Class.class))).thenReturn(transferRefund); + + HyperwalletTransferRefund resp = client.getTransferRefund("transferToken", "transferRefundToken"); + assertThat(resp, is(equalTo(transferRefund))); + + Mockito.verify(mockApiClient).get("https://api.sandbox.hyperwallet.com/rest/v3/transfers/transferToken/refunds/transferRefundToken", + transferRefund.getClass()); + } + + @Test + public void testListTransferRefunds_noParameters() throws Exception { + HyperwalletList response = new HyperwalletList<>(); + + Hyperwallet client = new Hyperwallet("test-username", "test-password"); + HyperwalletApiClient mockApiClient = createAndInjectHyperwalletApiClientMock(client); + + Mockito.when(mockApiClient.get(Mockito.anyString(), Mockito.any(TypeReference.class))).thenReturn(response); + + String transferToken = "transferToken"; + HyperwalletList resp = client.listTransferRefunds(transferToken, null); + assertThat(resp, is(equalTo(response))); + + Mockito.verify(mockApiClient).get(Mockito.eq("https://api.sandbox.hyperwallet.com/rest/v3/transfers/" + transferToken + "/refunds"), + Mockito.any(TypeReference.class)); + } + + @Test + public void testListTransferRefunds_withAllParameters() throws Exception { + HyperwalletList response = new HyperwalletList<>(); + + Hyperwallet client = new Hyperwallet("test-username", "test-password"); + HyperwalletApiClient mockApiClient = createAndInjectHyperwalletApiClientMock(client); + + HyperwalletTransferListOptions options = new HyperwalletTransferListOptions(); + options + .sourceToken("sourceToken") + .destinationToken("destinationToken") + .sortBy("sortByField") + .limit(10) + .createdAfter(convertStringToDate("2016-06-29T17:58:26Z")) + .createdBefore(convertStringToDate("2016-06-29T17:58:26Z")); + + Mockito.when(mockApiClient.get(Mockito.anyString(), Mockito.any(TypeReference.class))).thenReturn(response); + + String transferToken = "transferToken"; + HyperwalletList resp = client.listTransferRefunds(transferToken, options); + assertThat(resp, is(equalTo(response))); + + Mockito.verify(mockApiClient).get(Mockito.eq("https://api.sandbox.hyperwallet.com/rest/v3/transfers/" + transferToken + + "/refunds?createdAfter=2016-06-29T17:58:26Z&createdBefore=2016-06-29T17:58:26Z&sortBy=sortByField&limit=10&clientRefundId" + + "=destinationToken&sourceToken=sourceToken"), + Mockito.any(TypeReference.class)); + System.out.println(); + } + + @Test + public void testListTransferRefunds_withSomeParameters() throws Exception { + HyperwalletList response = new HyperwalletList<>(); + + Hyperwallet client = new Hyperwallet("test-username", "test-password"); + HyperwalletApiClient mockApiClient = createAndInjectHyperwalletApiClientMock(client); + + HyperwalletTransferListOptions options = new HyperwalletTransferListOptions(); + options + .sourceToken("test-source-token") + .sortBy("test-sort-by") + .createdBefore(convertStringToDate("2016-06-29T17:58:26Z")); + + Mockito.when(mockApiClient.get(Mockito.anyString(), Mockito.any(TypeReference.class))).thenReturn(response); + + String transferToken = "transferToken"; + HyperwalletList resp = client.listTransferRefunds(transferToken, options); + assertThat(resp, is(equalTo(response))); + + Mockito.verify(mockApiClient).get(Mockito.eq("https://api.sandbox.hyperwallet.com/rest/v3/transfers/" + transferToken + "/refunds" + + "?createdBefore=2016-06-29T17:58:26Z&sortBy=test-sort-by&sourceToken=test-source-token"), + Mockito.any(TypeReference.class)); + } + + @Test + public void testListTransferRefunds_noTransferToken() { + Hyperwallet client = new Hyperwallet("test-username", "test-password"); + try { + client.listTransferRefunds(null, new HyperwalletTransferListOptions()); + fail("Expect HyperwalletException"); + } catch (HyperwalletException e) { + HyperwalletException expectedException = new HyperwalletException("Transfer token is required"); + checkHyperwalletException(e, expectedException); + } + } + } From a6b25bdd84713d991ceef18e76bff3fced9f6431 Mon Sep 17 00:00:00 2001 From: jkurra-hw Date: Tue, 17 Nov 2020 15:15:20 +0530 Subject: [PATCH 2/3] DTRUNETWO-298-Transfer Refunds methods added --- .../hyperwallet/clientsdk/HyperwalletIT.java | 126 ++++++++++++++++++ .../model/HyperwalletTransferRefundTest.java | 42 ++++++ .../createTransferRefund-request.txt | 9 ++ .../createTransferRefund-response.json | 31 +++++ .../integration/getTransferRefund-request.txt | 3 + .../getTransferRefund-response.json | 31 +++++ .../listTransferRefunds-request.txt | 3 + .../listTransferRefunds-response.json | 68 ++++++++++ 8 files changed, 313 insertions(+) create mode 100644 src/test/java/com/hyperwallet/clientsdk/model/HyperwalletTransferRefundTest.java create mode 100644 src/test/resources/integration/createTransferRefund-request.txt create mode 100644 src/test/resources/integration/createTransferRefund-response.json create mode 100644 src/test/resources/integration/getTransferRefund-request.txt create mode 100644 src/test/resources/integration/getTransferRefund-response.json create mode 100644 src/test/resources/integration/listTransferRefunds-request.txt create mode 100644 src/test/resources/integration/listTransferRefunds-response.json diff --git a/src/test/java/com/hyperwallet/clientsdk/HyperwalletIT.java b/src/test/java/com/hyperwallet/clientsdk/HyperwalletIT.java index 2652fd752..936b3ceb6 100644 --- a/src/test/java/com/hyperwallet/clientsdk/HyperwalletIT.java +++ b/src/test/java/com/hyperwallet/clientsdk/HyperwalletIT.java @@ -1,6 +1,7 @@ package com.hyperwallet.clientsdk; import com.hyperwallet.clientsdk.model.*; +import com.hyperwallet.clientsdk.model.HyperwalletTransfer.ForeignExchange; import com.hyperwallet.clientsdk.model.HyperwalletUser.*; import org.mockserver.integration.ClientAndServer; import org.mockserver.model.HttpRequest; @@ -1128,6 +1129,131 @@ public void testGetPaymentStatusTransition() throws Exception { assertThat(returnValue.getToStatus(), is(equalTo(COMPLETED))); } + // + // Transfer Refunds + // + + @Test + public void testCreateTransferRefund() throws Exception { + String functionality = "createTransferRefund"; + initMockServer(functionality); + + HyperwalletTransferRefund transferRefund = new HyperwalletTransferRefund() + .clientRefundId("clientRefundId") + .notes("Merchant Payment return to Wallet Balance") + .memo("TransferReturn123456"); + + HyperwalletTransferRefund returnValue; + try { + returnValue = client.createTransferRefund("trf-dc6a19f7-1d24-434d-87ce-f1a960f3fbce", transferRefund); + } catch (Exception e) { + mockServer.verify(parseRequest(functionality)); + throw e; + } + + HyperwalletTransferRefund expectedValue = new HyperwalletTransferRefund() + .token("trd-a159dc18-eb29-4530-8733-060c7feaad0f") + .status(HyperwalletTransferRefund.Status.COMPLETED) + .clientRefundId("clientRefundId") + .sourceToken("act-ba4e8fdd-614b-11e5-af23-0faa28ca7c0f") + .sourceAmount(20.0) + .sourceCurrency("USD") + .destinationToken("usr-3deb34a0-ffd1-487d-8860-6d69435cea6c") + .destinationAmount(20.0) + .destinationCurrency("USD") + .notes("Merchant Payment return to Wallet Balance") + .memo("TransferReturn123456") + .createdOn(dateFormat.parse("2019-11-11T19:04:43 UTC")); + + checkTransferRefund(returnValue, expectedValue); + checkForeignExchange(returnValue, expectedValue); + } + + private void checkTransferRefund(HyperwalletTransferRefund actual, HyperwalletTransferRefund expected) { + assertThat(actual.getToken(), is(expected.getToken())); + assertThat(actual.getStatus(), is(expected.getStatus())); + assertThat(actual.getClientRefundId(), is(expected.getClientRefundId())); + assertThat(actual.getSourceToken(), is(expected.getSourceToken())); + assertThat(actual.getSourceAmount(), is(expected.getSourceAmount())); + assertThat(actual.getSourceCurrency(), is(expected.getSourceCurrency())); + assertThat(actual.getDestinationToken(), is(expected.getDestinationToken())); + assertThat(actual.getDestinationAmount(), is(expected.getDestinationAmount())); + assertThat(actual.getDestinationCurrency(), is(expected.getDestinationCurrency())); + assertThat(actual.getNotes(), is(expected.getNotes())); + assertThat(actual.getMemo(), is(expected.getMemo())); + assertThat(actual.getCreatedOn(), is(expected.getCreatedOn())); + } + + private void checkForeignExchange(HyperwalletTransferRefund actual, HyperwalletTransferRefund expected) { + ForeignExchange foreignExchange = actual.getForeignExchanges().get(0); + assertThat(foreignExchange.getSourceAmount(), is(equalTo(100.00))); + assertThat(foreignExchange.getSourceCurrency(), is(equalTo("USD"))); + assertThat(foreignExchange.getDestinationAmount(), is(equalTo(63.49))); + assertThat(foreignExchange.getDestinationCurrency(), is(equalTo("CAD"))); + assertThat(foreignExchange.getRate(), is(equalTo(0.79))); + } + + @Test + public void testGetTransferRefund() throws Exception { + String functionality = "getTransferRefund"; + initMockServer(functionality); + + HyperwalletTransferRefund returnValue; + try { + returnValue = client.getTransferRefund("trf-639579d9-4fe8-4fbf-8e34-827d27697f64", "trd-19156720-01e8-4f1c-8ef3-7ced80672128"); + } catch (Exception e) { + mockServer.verify(parseRequest(functionality)); + throw e; + } + HyperwalletTransferRefund expectedValue = new HyperwalletTransferRefund() + .token("trd-19156720-01e8-4f1c-8ef3-7ced80672128") + .status(HyperwalletTransferRefund.Status.COMPLETED) + .clientRefundId("1573548663") + .sourceToken("act-ba4e8fdd-614b-11e5-af23-0faa28ca7c0f") + .sourceAmount(50.0) + .sourceCurrency("USD") + .destinationToken("usr-3deb34a0-ffd1-487d-8860-6d69435cea6c") + .destinationAmount(50.0) + .destinationCurrency("USD") + .notes("Merchant Payment return to Wallet Balance") + .memo("TransferReturn123456") + .createdOn(dateFormat.parse("2019-11-12T11:51:05 UTC")); + + checkTransferRefund(returnValue, expectedValue); + checkForeignExchange(returnValue, expectedValue); + } + + @Test + public void testListTransferRefunds() throws Exception { + String functionality = "listTransferRefunds"; + initMockServer(functionality); + + HyperwalletList returnValue; + try { + returnValue = client.listTransferRefunds("trf-fdbc1f59-ef5f-4b9f-94e5-7e15797bcefb", null); + } catch (Exception e) { + mockServer.verify(parseRequest(functionality)); + throw e; + } + + HyperwalletTransferRefund expectedValue = new HyperwalletTransferRefund() + .token("trd-e59d19d4-eccb-4160-b04c-4f11c83f99f0") + .status(HyperwalletTransferRefund.Status.COMPLETED) + .clientRefundId("1573566270") + .sourceToken("act-ba4e8fdd-614b-11e5-af23-0faa28ca7c0f") + .sourceAmount(50.0) + .sourceCurrency("USD") + .destinationToken("usr-3deb34a0-ffd1-487d-8860-6d69435cea6c") + .destinationAmount(50.0) + .destinationCurrency("USD") + .notes("Merchant Payment return to Wallet Balance") + .memo("TransferReturn123456") + .createdOn(dateFormat.parse("2019-11-12T16:44:30 UTC")); + + checkTransferRefund(returnValue.getData().get(0), expectedValue); + checkForeignExchange(returnValue.getData().get(0), expectedValue); + } + // // Response with error // diff --git a/src/test/java/com/hyperwallet/clientsdk/model/HyperwalletTransferRefundTest.java b/src/test/java/com/hyperwallet/clientsdk/model/HyperwalletTransferRefundTest.java new file mode 100644 index 000000000..a579a01f4 --- /dev/null +++ b/src/test/java/com/hyperwallet/clientsdk/model/HyperwalletTransferRefundTest.java @@ -0,0 +1,42 @@ + +package com.hyperwallet.clientsdk.model; + +import com.hyperwallet.clientsdk.model.HyperwalletTransfer.ForeignExchange; +import com.hyperwallet.clientsdk.model.HyperwalletTransferRefund.Status; + +import java.util.Collections; +import java.util.Date; + +public class HyperwalletTransferRefundTest extends BaseModelTest { + + @Override + protected HyperwalletTransferRefund createBaseModel() { + ForeignExchange foreignExchange = new ForeignExchange(); + foreignExchange.setSourceAmount(200.0); + foreignExchange.setSourceCurrency("USD"); + foreignExchange.setDestinationAmount(100.0); + foreignExchange.setDestinationCurrency("CAD"); + foreignExchange.setRate(2.3); + HyperwalletTransferRefund transferRefund = new HyperwalletTransferRefund() + .token("token") + .status(Status.COMPLETED) + .clientRefundId("clientRefundId") + .sourceToken("sourceToken") + .sourceAmount(20.00) + .sourceCurrency("USD") + .destinationToken("destinationToken") + .destinationAmount(20.00) + .destinationCurrency("USD") + .createdOn(new Date()) + .notes("notes") + .memo("memo") + .foreignExchanges(Collections.singletonList(foreignExchange)); + + return transferRefund; + } + + @Override + protected Class createModelClass() { + return HyperwalletTransferRefund.class; + } +} diff --git a/src/test/resources/integration/createTransferRefund-request.txt b/src/test/resources/integration/createTransferRefund-request.txt new file mode 100644 index 000000000..8efba87f2 --- /dev/null +++ b/src/test/resources/integration/createTransferRefund-request.txt @@ -0,0 +1,9 @@ +curl -X "POST" "https://api.sandbox.hyperwallet.com/rest/v3/transfers/trf-dc6a19f7-1d24-434d-87ce-f1a960f3fbce/refunds" \ +-u testuser@12345678:myAccPassw0rd \ +-H "Content-Type: application/json" \ +-H "Accept: application/json" \ +-d "{ + "clientRefundId": "clientRefundId", + "notes": "Merchant Payment return to Wallet Balance", + "memo": "TransferReturn123456" +}" diff --git a/src/test/resources/integration/createTransferRefund-response.json b/src/test/resources/integration/createTransferRefund-response.json new file mode 100644 index 000000000..de8b44da9 --- /dev/null +++ b/src/test/resources/integration/createTransferRefund-response.json @@ -0,0 +1,31 @@ +{ + "token": "trd-a159dc18-eb29-4530-8733-060c7feaad0f", + "status": "COMPLETED", + "clientRefundId": "clientRefundId", + "sourceToken": "act-ba4e8fdd-614b-11e5-af23-0faa28ca7c0f", + "sourceAmount": "20.00", + "sourceCurrency": "USD", + "destinationToken": "usr-3deb34a0-ffd1-487d-8860-6d69435cea6c", + "destinationAmount": "20.00", + "destinationCurrency": "USD", + "createdOn": "2019-11-11T19:04:43", + "notes": "Merchant Payment return to Wallet Balance", + "memo": "TransferReturn123456", + "foreignExchanges": [ + { + "sourceAmount": "100.00", + "sourceCurrency": "USD", + "destinationAmount": "63.49", + "destinationCurrency": "CAD", + "rate": "0.79" + } + ], + "links": [ + { + "params": { + "rel": "self" + }, + "href": "https://api.sandbox.hyperwallet.com/rest/v3/transfers/trf-dc6a19f7-1d24-434d-87ce-f1a960f3fbce/refunds/trd-a159dc18-eb29-4530-8733-060c7feaad0f" + } + ] +} diff --git a/src/test/resources/integration/getTransferRefund-request.txt b/src/test/resources/integration/getTransferRefund-request.txt new file mode 100644 index 000000000..4d8026a93 --- /dev/null +++ b/src/test/resources/integration/getTransferRefund-request.txt @@ -0,0 +1,3 @@ +curl -X "GET" "https://api.sandbox.hyperwallet.com/rest/v3/transfers/trf-639579d9-4fe8-4fbf-8e34-827d27697f64/refunds/trd-19156720-01e8-4f1c-8ef3-7ced80672128 +-u testuser@12345678:myAccPassw0rd \ +-H "Accept: application/json" diff --git a/src/test/resources/integration/getTransferRefund-response.json b/src/test/resources/integration/getTransferRefund-response.json new file mode 100644 index 000000000..72b7092eb --- /dev/null +++ b/src/test/resources/integration/getTransferRefund-response.json @@ -0,0 +1,31 @@ +{ + "token": "trd-19156720-01e8-4f1c-8ef3-7ced80672128", + "status": "COMPLETED", + "clientRefundId": "1573548663", + "sourceToken": "act-ba4e8fdd-614b-11e5-af23-0faa28ca7c0f", + "sourceAmount": "50.00", + "sourceCurrency": "USD", + "destinationToken": "usr-3deb34a0-ffd1-487d-8860-6d69435cea6c", + "destinationAmount": "50.00", + "destinationCurrency": "USD", + "createdOn": "2019-11-12T11:51:05", + "notes": "Merchant Payment return to Wallet Balance", + "memo": "TransferReturn123456", + "foreignExchanges": [ + { + "sourceAmount": "100.00", + "sourceCurrency": "USD", + "destinationAmount": "63.49", + "destinationCurrency": "CAD", + "rate": "0.79" + } + ], + "links": [ + { + "params": { + "rel": "self" + }, + "href": "https://api.sandbox.hyperwallet.com/rest/v3/transfers/trf-639579d9-4fe8-4fbf-8e34-827d27697f64/refunds/trd-19156720-01e8-4f1c-8ef3-7ced80672128" + } + ] +} diff --git a/src/test/resources/integration/listTransferRefunds-request.txt b/src/test/resources/integration/listTransferRefunds-request.txt new file mode 100644 index 000000000..2ab88a24a --- /dev/null +++ b/src/test/resources/integration/listTransferRefunds-request.txt @@ -0,0 +1,3 @@ +curl -X "GET" "https://api.sandbox.hyperwallet.com/rest/v3/transfers/trf-fdbc1f59-ef5f-4b9f-94e5-7e15797bcefb/refunds" \ +-u testuser@12345678:myAccPassw0rd \ +-H "Accept: application/json" diff --git a/src/test/resources/integration/listTransferRefunds-response.json b/src/test/resources/integration/listTransferRefunds-response.json new file mode 100644 index 000000000..0fa2a1cd9 --- /dev/null +++ b/src/test/resources/integration/listTransferRefunds-response.json @@ -0,0 +1,68 @@ +{ + "count": 2, + "offset": 0, + "limit": 10, + "data": [ + { + "token": "trd-e59d19d4-eccb-4160-b04c-4f11c83f99f0", + "status": "COMPLETED", + "clientRefundId": "1573566270", + "sourceToken": "act-ba4e8fdd-614b-11e5-af23-0faa28ca7c0f", + "sourceAmount": "50.00", + "sourceCurrency": "USD", + "destinationToken": "usr-3deb34a0-ffd1-487d-8860-6d69435cea6c", + "destinationAmount": "50.00", + "destinationCurrency": "USD", + "createdOn": "2019-11-12T16:44:30", + "notes": "Merchant Payment return to Wallet Balance", + "memo": "TransferReturn123456", + "foreignExchanges": [ + { + "sourceAmount": "100.00", + "sourceCurrency": "USD", + "destinationAmount": "63.49", + "destinationCurrency": "CAD", + "rate": "0.79" + } + ], + "links": [ + { + "params": { + "rel": "self" + }, + "href": "https://localhost:8181/rest/v4/transfers/trf-fdbc1f59-ef5f-4b9f-94e5-7e15797bcefb/refunds/trd-e59d19d4-eccb-4160-b04c-4f11c83f99f0" + } + ] + }, + { + "token": "trd-686baee1-b56c-49d8-bd57-cd47ee0085f2", + "status": "COMPLETED", + "clientRefundId": "1573566314", + "sourceToken": "act-ba4e8fdd-614b-11e5-af23-0faa28ca7c0f", + "sourceAmount": "50.00", + "sourceCurrency": "USD", + "destinationToken": "usr-3deb34a0-ffd1-487d-8860-6d69435cea6c", + "destinationAmount": "50.00", + "destinationCurrency": "USD", + "createdOn": "2019-11-12T16:45:15", + "notes": "Merchant Payment return to Wallet Balance", + "memo": "TransferReturn123456", + "links": [ + { + "params": { + "rel": "self" + }, + "href": "https://api.sandbox.hyperwallet.com/rest/v4/transfers/trf-fdbc1f59-ef5f-4b9f-94e5-7e15797bcefb/refunds/trd-686baee1-b56c-49d8-bd57-cd47ee0085f2" + } + ] + } + ], + "links": [ + { + "params": { + "rel": "self" + }, + "href": "https://api.sandbox.hyperwallet.com/rest/v4/transfers/trf-fdbc1f59-ef5f-4b9f-94e5-7e15797bcefb/refunds?offset=0&limit=10" + } + ] +} From 475545e8c3ee4fe45345799619f1061ae0f2d4f2 Mon Sep 17 00:00:00 2001 From: jkurra-hw Date: Fri, 20 Nov 2020 01:21:20 +0530 Subject: [PATCH 3/3] resloved Merge conflicts --- .../hyperwallet/clientsdk/Hyperwallet.java | 70 ++++++ .../hyperwallet/clientsdk/HyperwalletIT.java | 127 ++++++++++ .../clientsdk/HyperwalletTest.java | 216 ++++++++++++++++++ 3 files changed, 413 insertions(+) diff --git a/src/main/java/com/hyperwallet/clientsdk/Hyperwallet.java b/src/main/java/com/hyperwallet/clientsdk/Hyperwallet.java index 5fb4649bb..3bae68b14 100644 --- a/src/main/java/com/hyperwallet/clientsdk/Hyperwallet.java +++ b/src/main/java/com/hyperwallet/clientsdk/Hyperwallet.java @@ -2220,6 +2220,73 @@ public HyperwalletList listTransferMethods(String use }); } + //-------------------------------------- + // Transfer refunds + //-------------------------------------- + + /** + * Create Transfer Refund + * + * @param transferToken Transfer token assigned + * @param transferRefund Transfer Refund object to create + * @return Created Transfer Refund + */ + public HyperwalletTransferRefund createTransferRefund(String transferToken, HyperwalletTransferRefund transferRefund) { + if (transferRefund == null) { + throw new HyperwalletException("Transfer Refund is required"); + } + if (StringUtils.isEmpty(transferToken)) { + throw new HyperwalletException("Transfer token is required"); + } + if (StringUtils.isEmpty(transferRefund.getClientRefundId())) { + throw new HyperwalletException("ClientRefundId is required"); + } + + transferRefund = copy(transferRefund); + transferRefund.clearStatus(); + transferRefund.clearCreatedOn(); + return apiClient.post(url + "/transfers/" + transferToken + "/refunds", transferRefund, HyperwalletTransferRefund.class); + } + + /** + * Get Transfer Refund + * + * @param transferToken Transfer token assigned + * @param transferRefundToken Transfer Refund token assigned + * @return Transfer Refund object + */ + public HyperwalletTransferRefund getTransferRefund(String transferToken, String transferRefundToken) { + if (StringUtils.isEmpty(transferToken)) { + throw new HyperwalletException("Transfer token is required"); + } + if (StringUtils.isEmpty(transferRefundToken)) { + throw new HyperwalletException("Transfer Refund token is required"); + } + + return apiClient.get(url + "/transfers/" + transferToken + "/refunds/" + transferRefundToken, HyperwalletTransferRefund.class); + } + + /** + * List Transfer Refund Requests + * + * @param options List filter option + * @param transferToken Transfer token assigned + * @return HyperwalletList of HyperwalletTransferRefund + */ + public HyperwalletList listTransferRefunds(String transferToken, HyperwalletTransferListOptions options) { + if (StringUtils.isEmpty(transferToken)) { + throw new HyperwalletException("Transfer token is required"); + } + + String url = paginate(this.url + "/transfers/" + transferToken + "/refunds", options); + if (options != null) { + url = addParameter(url, "clientRefundId", options.getDestinationToken()); + url = addParameter(url, "sourceToken", options.getSourceToken()); + } + return apiClient.get(url, new TypeReference>() { + }); + } + //-------------------------------------- // Internal utils //-------------------------------------- @@ -2320,5 +2387,8 @@ private HyperwalletVenmoAccount copy(HyperwalletVenmoAccount venmoAccount) { venmoAccount = HyperwalletJsonUtil.fromJson(HyperwalletJsonUtil.toJson(venmoAccount), HyperwalletVenmoAccount.class); return venmoAccount; } + private HyperwalletTransferRefund copy(HyperwalletTransferRefund transferRefund) { + return HyperwalletJsonUtil.fromJson(HyperwalletJsonUtil.toJson(transferRefund), HyperwalletTransferRefund.class); + } } diff --git a/src/test/java/com/hyperwallet/clientsdk/HyperwalletIT.java b/src/test/java/com/hyperwallet/clientsdk/HyperwalletIT.java index f7b5bfe7c..c2f72facf 100644 --- a/src/test/java/com/hyperwallet/clientsdk/HyperwalletIT.java +++ b/src/test/java/com/hyperwallet/clientsdk/HyperwalletIT.java @@ -2,6 +2,7 @@ import com.hyperwallet.clientsdk.model.*; import com.hyperwallet.clientsdk.model.HyperwalletPrepaidCard.Brand; +import com.hyperwallet.clientsdk.model.HyperwalletTransfer.ForeignExchange; import com.hyperwallet.clientsdk.model.HyperwalletTransferMethod.CardType; import com.hyperwallet.clientsdk.model.HyperwalletUser.*; import org.mockserver.integration.ClientAndServer; @@ -1229,6 +1230,132 @@ public void testListTransferMethods() throws Exception { } + // + // Transfer Refunds + // + + @Test + public void testCreateTransferRefund() throws Exception { + String functionality = "createTransferRefund"; + initMockServer(functionality); + + HyperwalletTransferRefund transferRefund = new HyperwalletTransferRefund() + .clientRefundId("clientRefundId") + .notes("Merchant Payment return to Wallet Balance") + .memo("TransferReturn123456"); + + HyperwalletTransferRefund returnValue; + try { + returnValue = client.createTransferRefund("trf-dc6a19f7-1d24-434d-87ce-f1a960f3fbce", transferRefund); + } catch (Exception e) { + mockServer.verify(parseRequest(functionality)); + throw e; + } + + HyperwalletTransferRefund expectedValue = new HyperwalletTransferRefund() + .token("trd-a159dc18-eb29-4530-8733-060c7feaad0f") + .status(HyperwalletTransferRefund.Status.COMPLETED) + .clientRefundId("clientRefundId") + .sourceToken("act-ba4e8fdd-614b-11e5-af23-0faa28ca7c0f") + .sourceAmount(20.0) + .sourceCurrency("USD") + .destinationToken("usr-3deb34a0-ffd1-487d-8860-6d69435cea6c") + .destinationAmount(20.0) + .destinationCurrency("USD") + .notes("Merchant Payment return to Wallet Balance") + .memo("TransferReturn123456") + .createdOn(dateFormat.parse("2019-11-11T19:04:43 UTC")); + + checkTransferRefund(returnValue, expectedValue); + checkForeignExchange(returnValue, expectedValue); + } + + private void checkTransferRefund(HyperwalletTransferRefund actual, HyperwalletTransferRefund expected) { + assertThat(actual.getToken(), is(expected.getToken())); + assertThat(actual.getStatus(), is(expected.getStatus())); + assertThat(actual.getClientRefundId(), is(expected.getClientRefundId())); + assertThat(actual.getSourceToken(), is(expected.getSourceToken())); + assertThat(actual.getSourceAmount(), is(expected.getSourceAmount())); + assertThat(actual.getSourceCurrency(), is(expected.getSourceCurrency())); + assertThat(actual.getDestinationToken(), is(expected.getDestinationToken())); + assertThat(actual.getDestinationAmount(), is(expected.getDestinationAmount())); + assertThat(actual.getDestinationCurrency(), is(expected.getDestinationCurrency())); + assertThat(actual.getNotes(), is(expected.getNotes())); + assertThat(actual.getMemo(), is(expected.getMemo())); + assertThat(actual.getCreatedOn(), is(expected.getCreatedOn())); + } + + private void checkForeignExchange(HyperwalletTransferRefund actual, HyperwalletTransferRefund expected) { + ForeignExchange foreignExchange = actual.getForeignExchanges().get(0); + assertThat(foreignExchange.getSourceAmount(), is(equalTo(100.00))); + assertThat(foreignExchange.getSourceCurrency(), is(equalTo("USD"))); + assertThat(foreignExchange.getDestinationAmount(), is(equalTo(63.49))); + assertThat(foreignExchange.getDestinationCurrency(), is(equalTo("CAD"))); + assertThat(foreignExchange.getRate(), is(equalTo(0.79))); + } + + @Test + public void testGetTransferRefund() throws Exception { + String functionality = "getTransferRefund"; + initMockServer(functionality); + + HyperwalletTransferRefund returnValue; + try { + returnValue = client.getTransferRefund("trf-639579d9-4fe8-4fbf-8e34-827d27697f64", "trd-19156720-01e8-4f1c-8ef3-7ced80672128"); + } catch (Exception e) { + mockServer.verify(parseRequest(functionality)); + throw e; + } + HyperwalletTransferRefund expectedValue = new HyperwalletTransferRefund() + .token("trd-19156720-01e8-4f1c-8ef3-7ced80672128") + .status(HyperwalletTransferRefund.Status.COMPLETED) + .clientRefundId("1573548663") + .sourceToken("act-ba4e8fdd-614b-11e5-af23-0faa28ca7c0f") + .sourceAmount(50.0) + .sourceCurrency("USD") + .destinationToken("usr-3deb34a0-ffd1-487d-8860-6d69435cea6c") + .destinationAmount(50.0) + .destinationCurrency("USD") + .notes("Merchant Payment return to Wallet Balance") + .memo("TransferReturn123456") + .createdOn(dateFormat.parse("2019-11-12T11:51:05 UTC")); + + checkTransferRefund(returnValue, expectedValue); + checkForeignExchange(returnValue, expectedValue); + } + + @Test + public void testListTransferRefunds() throws Exception { + String functionality = "listTransferRefunds"; + initMockServer(functionality); + + HyperwalletList returnValue; + try { + returnValue = client.listTransferRefunds("trf-fdbc1f59-ef5f-4b9f-94e5-7e15797bcefb", null); + } catch (Exception e) { + mockServer.verify(parseRequest(functionality)); + throw e; + } + + HyperwalletTransferRefund expectedValue = new HyperwalletTransferRefund() + .token("trd-e59d19d4-eccb-4160-b04c-4f11c83f99f0") + .status(HyperwalletTransferRefund.Status.COMPLETED) + .clientRefundId("1573566270") + .sourceToken("act-ba4e8fdd-614b-11e5-af23-0faa28ca7c0f") + .sourceAmount(50.0) + .sourceCurrency("USD") + .destinationToken("usr-3deb34a0-ffd1-487d-8860-6d69435cea6c") + .destinationAmount(50.0) + .destinationCurrency("USD") + .notes("Merchant Payment return to Wallet Balance") + .memo("TransferReturn123456") + .createdOn(dateFormat.parse("2019-11-12T16:44:30 UTC")); + + checkTransferRefund(returnValue.getData().get(0), expectedValue); + checkForeignExchange(returnValue.getData().get(0), expectedValue); + } + + // // Response with error // diff --git a/src/test/java/com/hyperwallet/clientsdk/HyperwalletTest.java b/src/test/java/com/hyperwallet/clientsdk/HyperwalletTest.java index ca97f3f78..293f2b322 100644 --- a/src/test/java/com/hyperwallet/clientsdk/HyperwalletTest.java +++ b/src/test/java/com/hyperwallet/clientsdk/HyperwalletTest.java @@ -3,6 +3,7 @@ import com.fasterxml.jackson.core.type.TypeReference; import com.hyperwallet.clientsdk.model.*; import com.hyperwallet.clientsdk.model.HyperwalletStatusTransition.Status; +import com.hyperwallet.clientsdk.model.HyperwalletTransfer.ForeignExchange; import com.hyperwallet.clientsdk.model.HyperwalletTransferMethod.Type; import com.hyperwallet.clientsdk.model.HyperwalletUser.VerificationStatus; import com.hyperwallet.clientsdk.util.HyperwalletApiClient; @@ -7284,4 +7285,219 @@ public void testListTransferMethods() throws Exception { assertThat(response2.getType(), is(equalTo(Type.PREPAID_CARD))); } + //-------------------------------------- + // Transfer Refund + //-------------------------------------- + + private void checkHyperwalletException(HyperwalletException actual, HyperwalletException expected) { + assertThat(actual.getErrorCode(), is(expected.getErrorCode())); + assertThat(actual.getResponse(), is(expected.getResponse())); + assertThat(actual.getErrorMessage(), is(expected.getErrorMessage())); + assertThat(actual.getMessage(), is(expected.getMessage())); + assertThat(actual.getHyperwalletErrors(), is(expected.getHyperwalletErrors())); + assertThat(actual.getRelatedResources(), is(expected.getRelatedResources())); + } + + @Test + public void testCreateTransferRefund_noTransferRefund() { + Hyperwallet client = new Hyperwallet("test-username", "test-password"); + try { + client.createTransferRefund("transferToken", null); + fail("Expect HyperwalletException"); + } catch (HyperwalletException e) { + HyperwalletException expectedException = new HyperwalletException("Transfer Refund is required"); + checkHyperwalletException(e, expectedException); + } + } + + @Test + public void testCreateTransferRefund_noTransferToken() { + Hyperwallet client = new Hyperwallet("test-username", "test-password"); + try { + client.createTransferRefund(null, new HyperwalletTransferRefund()); + fail("Expect HyperwalletException"); + } catch (HyperwalletException e) { + HyperwalletException expectedException = new HyperwalletException("Transfer token is required"); + checkHyperwalletException(e, expectedException); + } + } + + @Test + public void testCreateTransferRefund_noClientRefundId() { + Hyperwallet client = new Hyperwallet("test-username", "test-password"); + try { + client.createTransferRefund("transferToken", new HyperwalletTransferRefund()); + fail("Expect HyperwalletException"); + } catch (HyperwalletException e) { + HyperwalletException expectedException = new HyperwalletException("ClientRefundId is required"); + checkHyperwalletException(e, expectedException); + } + } + + @Test + public void testCreateTransferRefund_successful() throws Exception { + String clientRefundId = "clientRefundId"; + double sourceAmount = 20.0; + String notes = "notes"; + String memo = "memo"; + + ForeignExchange foreignExchange = new ForeignExchange(); + foreignExchange.setSourceAmount(200.0); + foreignExchange.setSourceCurrency("USD"); + foreignExchange.setDestinationAmount(100.0); + foreignExchange.setDestinationCurrency("CAD"); + foreignExchange.setRate(2.3); + + HyperwalletTransferRefund transferRefund = new HyperwalletTransferRefund(); + transferRefund.setClientRefundId(clientRefundId); + transferRefund.setSourceAmount(sourceAmount); + transferRefund.setNotes(notes); + transferRefund.setMemo(memo); + transferRefund.setForeignExchanges(Collections.singletonList(foreignExchange)); + + HyperwalletTransferRefund transferRefundResponse = new HyperwalletTransferRefund(); + + Hyperwallet client = new Hyperwallet("test-username", "test-password"); + HyperwalletApiClient mockApiClient = createAndInjectHyperwalletApiClientMock(client); + + Mockito.when(mockApiClient.post(Mockito.anyString(), Mockito.anyObject(), Mockito.any(Class.class))).thenReturn(transferRefundResponse); + + String transferToken = "transferToken"; + HyperwalletTransferRefund resp = client.createTransferRefund(transferToken, transferRefund); + assertThat(resp, is(equalTo(transferRefundResponse))); + + ArgumentCaptor argument = ArgumentCaptor.forClass(HyperwalletTransferRefund.class); + Mockito.verify(mockApiClient).post(Mockito.eq("https://api.sandbox.hyperwallet.com/rest/v3/transfers/" + transferToken + "/refunds"), argument.capture(), Mockito.eq(transferRefund.getClass())); + + HyperwalletTransferRefund apiTransfer = argument.getValue(); + assertThat(apiTransfer, is(notNullValue())); + assertThat(apiTransfer.getClientRefundId(), is(equalTo(clientRefundId))); + assertThat(apiTransfer.getSourceAmount(), is(equalTo(sourceAmount))); + assertThat(apiTransfer.getNotes(), is(equalTo(notes))); + assertThat(apiTransfer.getMemo(), is(equalTo(memo))); + assertThat(apiTransfer.getCreatedOn(), is(nullValue())); + assertThat(apiTransfer.getStatus(), is(nullValue())); + + ForeignExchange foreignExchangeResponse = apiTransfer.getForeignExchanges().get(0); + assertThat(foreignExchange.getSourceAmount(), is(equalTo(200.0))); + assertThat(foreignExchange.getSourceCurrency(), is(equalTo("USD"))); + assertThat(foreignExchange.getDestinationAmount(), is(equalTo(100.0))); + assertThat(foreignExchange.getDestinationCurrency(), is(equalTo("CAD"))); + assertThat(foreignExchange.getRate(), is(equalTo(2.3))); + } + + @Test + public void testGetTransferRefund_noTransferToken() { + Hyperwallet client = new Hyperwallet("test-username", "test-password"); + try { + client.getTransferRefund(null, "transferRefundToken"); + fail("Expect HyperwalletException"); + } catch (HyperwalletException e) { + HyperwalletException expectedException = new HyperwalletException("Transfer token is required"); + checkHyperwalletException(e, expectedException); + } + } + + @Test + public void testGetTransferRefund_noTransferRefundToken() { + Hyperwallet client = new Hyperwallet("test-username", "test-password"); + try { + client.getTransferRefund("transferToken", null); + fail("Expect HyperwalletException"); + } catch (HyperwalletException e) { + HyperwalletException expectedException = new HyperwalletException("Transfer Refund token is required"); + checkHyperwalletException(e, expectedException); + } + } + + @Test + public void testGetTransferRefund_successful() throws Exception { + HyperwalletTransferRefund transferRefund = new HyperwalletTransferRefund(); + + Hyperwallet client = new Hyperwallet("test-username", "test-password"); + HyperwalletApiClient mockApiClient = createAndInjectHyperwalletApiClientMock(client); + + Mockito.when(mockApiClient.get(Mockito.anyString(), Mockito.any(Class.class))).thenReturn(transferRefund); + + HyperwalletTransferRefund resp = client.getTransferRefund("transferToken", "transferRefundToken"); + assertThat(resp, is(equalTo(transferRefund))); + + Mockito.verify(mockApiClient).get("https://api.sandbox.hyperwallet.com/rest/v3/transfers/transferToken/refunds/transferRefundToken", transferRefund.getClass()); + } + + @Test + public void testListTransferRefunds_noParameters() throws Exception { + HyperwalletList response = new HyperwalletList<>(); + + Hyperwallet client = new Hyperwallet("test-username", "test-password"); + HyperwalletApiClient mockApiClient = createAndInjectHyperwalletApiClientMock(client); + + Mockito.when(mockApiClient.get(Mockito.anyString(), Mockito.any(TypeReference.class))).thenReturn(response); + + String transferToken = "transferToken"; + HyperwalletList resp = client.listTransferRefunds(transferToken, null); + assertThat(resp, is(equalTo(response))); + + Mockito.verify(mockApiClient).get(Mockito.eq("https://api.sandbox.hyperwallet.com/rest/v3/transfers/" + transferToken + "/refunds"), Mockito.any(TypeReference.class)); + } + + @Test + public void testListTransferRefunds_withAllParameters() throws Exception { + HyperwalletList response = new HyperwalletList<>(); + + Hyperwallet client = new Hyperwallet("test-username", "test-password"); + HyperwalletApiClient mockApiClient = createAndInjectHyperwalletApiClientMock(client); + + HyperwalletTransferListOptions options = new HyperwalletTransferListOptions(); + options + .sourceToken("sourceToken") + .destinationToken("destinationToken") + .sortBy("sortByField") + .limit(10) + .createdAfter(convertStringToDate("2016-06-29T17:58:26Z")) + .createdBefore(convertStringToDate("2016-06-29T17:58:26Z")); + + Mockito.when(mockApiClient.get(Mockito.anyString(), Mockito.any(TypeReference.class))).thenReturn(response); + + String transferToken = "transferToken"; + HyperwalletList resp = client.listTransferRefunds(transferToken, options); + assertThat(resp, is(equalTo(response))); + + Mockito.verify(mockApiClient).get(Mockito.eq("https://api.sandbox.hyperwallet.com/rest/v3/transfers/" + transferToken + "/refunds?createdAfter=2016-06-29T17:58:26Z&createdBefore=2016-06-29T17:58:26Z&sortBy=sortByField&limit=10&clientRefundId" + "=destinationToken&sourceToken=sourceToken"), Mockito.any(TypeReference.class)); + System.out.println(); + } + + @Test + public void testListTransferRefunds_withSomeParameters() throws Exception { + HyperwalletList response = new HyperwalletList<>(); + + Hyperwallet client = new Hyperwallet("test-username", "test-password"); + HyperwalletApiClient mockApiClient = createAndInjectHyperwalletApiClientMock(client); + + HyperwalletTransferListOptions options = new HyperwalletTransferListOptions(); + options + .sourceToken("test-source-token") + .sortBy("test-sort-by") + .createdBefore(convertStringToDate("2016-06-29T17:58:26Z")); + + Mockito.when(mockApiClient.get(Mockito.anyString(), Mockito.any(TypeReference.class))).thenReturn(response); + + String transferToken = "transferToken"; + HyperwalletList resp = client.listTransferRefunds(transferToken, options); + assertThat(resp, is(equalTo(response))); + + Mockito.verify(mockApiClient).get(Mockito.eq("https://api.sandbox.hyperwallet.com/rest/v3/transfers/" + transferToken + "/refunds" + "?createdBefore=2016-06-29T17:58:26Z&sortBy=test-sort-by&sourceToken=test-source-token"), Mockito.any(TypeReference.class)); + } + + @Test + public void testListTransferRefunds_noTransferToken() { + Hyperwallet client = new Hyperwallet("test-username", "test-password"); + try { + client.listTransferRefunds(null, new HyperwalletTransferListOptions()); + fail("Expect HyperwalletException"); + } catch (HyperwalletException e) { + HyperwalletException expectedException = new HyperwalletException("Transfer token is required"); + checkHyperwalletException(e, expectedException); + } + } }