From 37592f662b5bf78bc0facf5ba815914b913b9293 Mon Sep 17 00:00:00 2001 From: Remi Jannel Date: Thu, 19 Jul 2018 11:13:33 -0400 Subject: [PATCH] Add support for Issuing APIs/resources --- .travis.yml | 2 +- .../model/BalanceTransactionDeserializer.java | 3 + .../stripe/model/EventDataDeserializer.java | 7 + .../stripe/model/issuing/Authorization.java | 228 ++++++++++++++++++ .../issuing/AuthorizationCollection.java | 6 + .../java/com/stripe/model/issuing/Card.java | 194 +++++++++++++++ .../stripe/model/issuing/CardCollection.java | 6 + .../com/stripe/model/issuing/CardDetails.java | 41 ++++ .../com/stripe/model/issuing/Cardholder.java | 142 +++++++++++ .../model/issuing/CardholderCollection.java | 6 + .../com/stripe/model/issuing/Dispute.java | 177 ++++++++++++++ .../model/issuing/DisputeCollection.java | 6 + .../stripe/model/issuing/MerchantData.java | 20 ++ .../com/stripe/model/issuing/Transaction.java | 213 ++++++++++++++++ .../model/issuing/TransactionCollection.java | 6 + src/main/java/com/stripe/net/APIResource.java | 8 +- src/test/java/com/stripe/BaseStripeTest.java | 2 +- .../functional/issuing/AuthorizationTest.java | 95 ++++++++ .../stripe/functional/issuing/CardTest.java | 98 ++++++++ .../functional/issuing/CardholderTest.java | 93 +++++++ .../functional/issuing/DisputeTest.java | 83 +++++++ .../functional/issuing/TransactionTest.java | 67 +++++ .../stripe/model/BalanceTransactionTest.java | 72 ++++++ .../model/issuing/AuthorizationTest.java | 43 ++++ .../stripe/model/issuing/CardDetailsTest.java | 23 ++ .../com/stripe/model/issuing/CardTest.java | 24 ++ .../stripe/model/issuing/CardholderTest.java | 22 ++ .../com/stripe/model/issuing/DisputeTest.java | 40 +++ .../stripe/model/issuing/TransactionTest.java | 60 +++++ ...tion_collection_with_source_expansion.json | 87 +++++++ .../api_fixtures/issuing/card_details.json | 63 +++++ 31 files changed, 1934 insertions(+), 3 deletions(-) create mode 100644 src/main/java/com/stripe/model/issuing/Authorization.java create mode 100644 src/main/java/com/stripe/model/issuing/AuthorizationCollection.java create mode 100644 src/main/java/com/stripe/model/issuing/Card.java create mode 100644 src/main/java/com/stripe/model/issuing/CardCollection.java create mode 100644 src/main/java/com/stripe/model/issuing/CardDetails.java create mode 100644 src/main/java/com/stripe/model/issuing/Cardholder.java create mode 100644 src/main/java/com/stripe/model/issuing/CardholderCollection.java create mode 100644 src/main/java/com/stripe/model/issuing/Dispute.java create mode 100644 src/main/java/com/stripe/model/issuing/DisputeCollection.java create mode 100644 src/main/java/com/stripe/model/issuing/MerchantData.java create mode 100644 src/main/java/com/stripe/model/issuing/Transaction.java create mode 100644 src/main/java/com/stripe/model/issuing/TransactionCollection.java create mode 100644 src/test/java/com/stripe/functional/issuing/AuthorizationTest.java create mode 100644 src/test/java/com/stripe/functional/issuing/CardTest.java create mode 100644 src/test/java/com/stripe/functional/issuing/CardholderTest.java create mode 100644 src/test/java/com/stripe/functional/issuing/DisputeTest.java create mode 100644 src/test/java/com/stripe/functional/issuing/TransactionTest.java create mode 100644 src/test/java/com/stripe/model/issuing/AuthorizationTest.java create mode 100644 src/test/java/com/stripe/model/issuing/CardDetailsTest.java create mode 100644 src/test/java/com/stripe/model/issuing/CardTest.java create mode 100644 src/test/java/com/stripe/model/issuing/CardholderTest.java create mode 100644 src/test/java/com/stripe/model/issuing/DisputeTest.java create mode 100644 src/test/java/com/stripe/model/issuing/TransactionTest.java create mode 100644 src/test/resources/api_fixtures/balance_transaction_collection_with_source_expansion.json create mode 100644 src/test/resources/api_fixtures/issuing/card_details.json diff --git a/.travis.yml b/.travis.yml index 80f4e85f78c..b69387ef819 100644 --- a/.travis.yml +++ b/.travis.yml @@ -30,7 +30,7 @@ before_install: env: global: - - STRIPE_MOCK_VERSION=0.19.0 + - STRIPE_MOCK_VERSION=0.23.0 matrix: include: diff --git a/src/main/java/com/stripe/model/BalanceTransactionDeserializer.java b/src/main/java/com/stripe/model/BalanceTransactionDeserializer.java index aa38096412c..b7620e87bee 100644 --- a/src/main/java/com/stripe/model/BalanceTransactionDeserializer.java +++ b/src/main/java/com/stripe/model/BalanceTransactionDeserializer.java @@ -24,8 +24,11 @@ public class BalanceTransactionDeserializer implements JsonDeserializer { objectMap.put("invoice", Invoice.class); objectMap.put("invoice_line_item", InvoiceLineItem.class); objectMap.put("invoiceitem", InvoiceItem.class); + objectMap.put("issuing.authorization", com.stripe.model.issuing.Authorization.class); + objectMap.put("issuing.card", com.stripe.model.issuing.Card.class); + objectMap.put("issuing.card_details", com.stripe.model.issuing.CardDetails.class); + objectMap.put("issuing.cardholder", com.stripe.model.issuing.Cardholder.class); + objectMap.put("issuing.dispute", com.stripe.model.issuing.Dispute.class); + objectMap.put("issuing.transaction", com.stripe.model.issuing.Transaction.class); objectMap.put("order", Order.class); objectMap.put("order_item", OrderItem.class); objectMap.put("order_return", OrderReturn.class); + objectMap.put("payment_intent", PaymentIntent.class); objectMap.put("payout", Payout.class); objectMap.put("plan", Plan.class); objectMap.put("product", Product.class); diff --git a/src/main/java/com/stripe/model/issuing/Authorization.java b/src/main/java/com/stripe/model/issuing/Authorization.java new file mode 100644 index 00000000000..476faece672 --- /dev/null +++ b/src/main/java/com/stripe/model/issuing/Authorization.java @@ -0,0 +1,228 @@ +package com.stripe.model.issuing; + +import com.stripe.exception.APIConnectionException; +import com.stripe.exception.APIException; +import com.stripe.exception.AuthenticationException; +import com.stripe.exception.CardException; +import com.stripe.exception.InvalidRequestException; +import com.stripe.model.BalanceTransaction; +import com.stripe.model.ExpandableField; +import com.stripe.model.HasId; +import com.stripe.model.MetadataStore; +import com.stripe.model.StripeObject; +import com.stripe.net.APIResource; +import com.stripe.net.RequestOptions; + +import java.util.List; +import java.util.Map; + +import lombok.AccessLevel; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.Setter; + +@Getter +@Setter +@EqualsAndHashCode(callSuper = false) +public class Authorization extends APIResource implements MetadataStore, HasId { + @Getter(onMethod = @__({@Override})) String id; + String object; + Boolean approved; + String authorizationMethod; + String authorizedAmount; + String authorizedCurrency; + List balanceTransactions; + @Getter(AccessLevel.NONE) @Setter(AccessLevel.NONE) + ExpandableField card; + @Getter(AccessLevel.NONE) @Setter(AccessLevel.NONE) + ExpandableField cardholder; + Long created; + Long heldAmount; + String heldCurrency; + Boolean isHeldAmountControllable; + Boolean livemode; + MerchantData merchantData; + @Getter(onMethod = @__({@Override})) Map metadata; + Long pendingAuthorizedAmount; + Long pendingHeldAmount; + List requestHistory; + String status; + List transactions; + VerificationData verificationData; + + // + public String getCard() { + return (this.card != null) ? this.card.getId() : null; + } + + public void setCard(String cardId) { + this.card = setExpandableFieldID(cardId, this.card); + } + + public Card getCardObject() { + return (this.card != null) ? this.card.getExpanded() : null; + } + + public void setCardObject(Card c) { + this.card = new ExpandableField(c.getId(), c); + } + // + + // + public String getCardholder() { + return (this.cardholder != null) ? this.cardholder.getId() : null; + } + + public void setCardholder(String cardholderId) { + this.cardholder = setExpandableFieldID(cardholderId, this.cardholder); + } + + public Cardholder getCardholderObject() { + return (this.cardholder != null) ? this.cardholder.getExpanded() : null; + } + + public void setCardholderObject(Cardholder c) { + this.cardholder = new ExpandableField(c.getId(), c); + } + // + + // + /** + * Approve an issuing authorization. + */ + public Authorization approve(Map params) throws AuthenticationException, + InvalidRequestException, APIConnectionException, CardException, + APIException { + return approve(params, null); + } + + /** + * Approve an issuing authorization. + */ + public Authorization approve(Map params, RequestOptions options) + throws AuthenticationException, InvalidRequestException, + APIConnectionException, CardException, APIException { + return request(RequestMethod.POST, String.format("%s/approve", + instanceURL(Authorization.class, this.getId())), params, Authorization.class, options); + } + // + + // + /** + * Decline an issuing authorization. + */ + public Authorization decline(Map params) throws AuthenticationException, + InvalidRequestException, APIConnectionException, CardException, + APIException { + return decline(params, null); + } + + /** + * Decline an issuing authorization. + */ + public Authorization decline(Map params, RequestOptions options) + throws AuthenticationException, InvalidRequestException, + APIConnectionException, CardException, APIException { + return request(RequestMethod.POST, String.format("%s/decline", + instanceURL(Authorization.class, this.getId())), params, Authorization.class, options); + } + // + + // + /** + * List all issuing authorizations. + */ + public static AuthorizationCollection list(Map params) + throws AuthenticationException, InvalidRequestException, + APIConnectionException, CardException, APIException { + return list(params, null); + } + + /** + * List all issuing authorizations. + */ + public static AuthorizationCollection list(Map params, RequestOptions options) + throws AuthenticationException, InvalidRequestException, APIConnectionException, + CardException, APIException { + return requestCollection(classURL(Authorization.class), params, + AuthorizationCollection.class, options); + } + // + + // + /** + * Retrieve an issuing authorization. + */ + public static Authorization retrieve(String id) throws AuthenticationException, + InvalidRequestException, APIConnectionException, CardException, + APIException { + return retrieve(id, null); + } + + /** + * Retrieve an issuing authorization. + */ + public static Authorization retrieve(String id, RequestOptions options) + throws AuthenticationException, InvalidRequestException, + APIConnectionException, CardException, APIException { + return request(RequestMethod.GET, instanceURL(Authorization.class, id), null, + Authorization.class, options); + } + + /** + * Retrieve an issuing authorization. + */ + public static Authorization retrieve(String id, Map params, + RequestOptions options) + throws AuthenticationException, InvalidRequestException, + APIConnectionException, CardException, APIException { + return request(RequestMethod.GET, instanceURL(Authorization.class, id), params, + Authorization.class, options); + } + // + + // + /** + * Update an issuing authorization. + */ + @Override + public Authorization update(Map params) + throws AuthenticationException, InvalidRequestException, + APIConnectionException, CardException, APIException { + return update(params, null); + } + + /** + * Update an issuing authorization. + */ + @Override + public Authorization update(Map params, RequestOptions options) + throws AuthenticationException, InvalidRequestException, + APIConnectionException, CardException, APIException { + return request(RequestMethod.POST, instanceURL(Authorization.class, this.id), params, + Authorization.class, options); + } + // + + @Getter + @Setter + @EqualsAndHashCode(callSuper = false) + public final class RequestHistory extends StripeObject { + Boolean approved; + Long authorizedAmount; + String authorizedCurrency; + Long created; + Long heldAmount; + String heldCurrency; + String reason; + } + + @Getter + @Setter + @EqualsAndHashCode(callSuper = false) + public final class VerificationData extends StripeObject { + String addressLine1Check; + String addressZipCheck; + String cvcCheck; + } +} diff --git a/src/main/java/com/stripe/model/issuing/AuthorizationCollection.java b/src/main/java/com/stripe/model/issuing/AuthorizationCollection.java new file mode 100644 index 00000000000..0f094d76c33 --- /dev/null +++ b/src/main/java/com/stripe/model/issuing/AuthorizationCollection.java @@ -0,0 +1,6 @@ +package com.stripe.model.issuing; + +import com.stripe.model.StripeCollection; + +public class AuthorizationCollection extends StripeCollection { +} diff --git a/src/main/java/com/stripe/model/issuing/Card.java b/src/main/java/com/stripe/model/issuing/Card.java new file mode 100644 index 00000000000..3ca01275aed --- /dev/null +++ b/src/main/java/com/stripe/model/issuing/Card.java @@ -0,0 +1,194 @@ +package com.stripe.model.issuing; + +import com.stripe.exception.APIConnectionException; +import com.stripe.exception.APIException; +import com.stripe.exception.AuthenticationException; +import com.stripe.exception.CardException; +import com.stripe.exception.InvalidRequestException; +import com.stripe.model.Address; +import com.stripe.model.HasId; +import com.stripe.model.MetadataStore; +import com.stripe.model.StripeObject; +import com.stripe.net.APIResource; +import com.stripe.net.RequestOptions; + +import java.util.List; +import java.util.Map; + +import lombok.AccessLevel; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.Setter; + +@Getter +@Setter +@EqualsAndHashCode(callSuper = false) +public class Card extends APIResource implements MetadataStore, HasId { + @Getter(onMethod = @__({@Override})) String id; + String object; + AuthorizationControls authorizationControls; + Billing billing; + String brand; + Cardholder cardholder; + Long created; + String currency; + Integer expMonth; + Integer expYear; + String last4; + Boolean livemode; + @Getter(onMethod = @__({@Override})) Map metadata; + String name; + String status; + String type; + + // + /** + * Create an issuing card. + */ + public static Card create(Map params) + throws AuthenticationException, InvalidRequestException, + APIConnectionException, CardException, APIException { + return create(params, null); + } + + /** + * Create an issuing card. + */ + public static Card create(Map params, RequestOptions options) + throws AuthenticationException, InvalidRequestException, + APIConnectionException, CardException, APIException { + return request(RequestMethod.POST, classURL(Card.class), params, + Card.class, options); + } + // + + // + /** + * Retrieve the card details associated with an issuing card. + */ + public CardDetails details(Map params) + throws AuthenticationException, InvalidRequestException, + APIConnectionException, CardException, APIException { + return details(params, null); + } + + /** + * Retrieve the card details associated with an issuing card. + */ + public CardDetails details(Map params, RequestOptions options) + throws AuthenticationException, InvalidRequestException, + APIConnectionException, CardException, APIException { + return request(RequestMethod.GET, String.format("%s/details", + instanceURL(Card.class, this.getId())), params, CardDetails.class, options); + } + // + + // + /** + * List all issuing cards. + */ + public static CardCollection list(Map params) + throws AuthenticationException, InvalidRequestException, + APIConnectionException, CardException, APIException { + return list(params, null); + } + + /** + * List all issuing cards. + */ + public static CardCollection list(Map params, RequestOptions options) + throws AuthenticationException, InvalidRequestException, APIConnectionException, + CardException, APIException { + return requestCollection(classURL(Card.class), params, + CardCollection.class, options); + } + // + + // + /** + * Retrieve an issuing card. + */ + public static Card retrieve(String id) throws AuthenticationException, + InvalidRequestException, APIConnectionException, CardException, + APIException { + return retrieve(id, null); + } + + /** + * Retrieve an issuing card. + */ + public static Card retrieve(String id, RequestOptions options) + throws AuthenticationException, InvalidRequestException, + APIConnectionException, CardException, APIException { + return request(RequestMethod.GET, instanceURL(Card.class, id), null, + Card.class, options); + } + + /** + * Retrieve an issuing card. + */ + public static Card retrieve(String id, Map params, + RequestOptions options) + throws AuthenticationException, InvalidRequestException, + APIConnectionException, CardException, APIException { + return request(RequestMethod.GET, instanceURL(Card.class, id), params, + Card.class, options); + } + // + + // + /** + * Update an issuing card. + */ + @Override + public Card update(Map params) + throws AuthenticationException, InvalidRequestException, + APIConnectionException, CardException, APIException { + return update(params, null); + } + + /** + * Update an issuing card. + */ + @Override + public Card update(Map params, RequestOptions options) + throws AuthenticationException, InvalidRequestException, + APIConnectionException, CardException, APIException { + return request(RequestMethod.POST, instanceURL(Card.class, this.id), params, + Card.class, options); + } + // + + @Getter + @Setter + @EqualsAndHashCode(callSuper = false) + public final class AuthorizationControls extends StripeObject { + List allowedCategories; + List blockedCategories; + String currency; + Long maxAmount; + Long maxApprovals; + } + + @Getter + @Setter + @EqualsAndHashCode(callSuper = false) + public final class Billing extends StripeObject { + Address address; + } + + @Getter + @Setter + @EqualsAndHashCode(callSuper = false) + public final class Shipping extends StripeObject { + Address address; + String carrier; + Long eta; + String name; + String phone; + String status; + String trackingNumber; + String trackingURL; + String type; + } +} diff --git a/src/main/java/com/stripe/model/issuing/CardCollection.java b/src/main/java/com/stripe/model/issuing/CardCollection.java new file mode 100644 index 00000000000..cfa9da499c3 --- /dev/null +++ b/src/main/java/com/stripe/model/issuing/CardCollection.java @@ -0,0 +1,6 @@ +package com.stripe.model.issuing; + +import com.stripe.model.StripeCollection; + +public class CardCollection extends StripeCollection { +} diff --git a/src/main/java/com/stripe/model/issuing/CardDetails.java b/src/main/java/com/stripe/model/issuing/CardDetails.java new file mode 100644 index 00000000000..7e2f96af687 --- /dev/null +++ b/src/main/java/com/stripe/model/issuing/CardDetails.java @@ -0,0 +1,41 @@ +package com.stripe.model.issuing; + +import com.stripe.model.ExpandableField; +import com.stripe.net.APIResource; +import com.stripe.net.RequestOptions; + +import lombok.AccessLevel; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.Setter; + +@Getter +@Setter +@EqualsAndHashCode(callSuper = false) +public class CardDetails extends APIResource { + String object; + @Getter(AccessLevel.NONE) @Setter(AccessLevel.NONE) + ExpandableField card; + String cvc; + Integer expMonth; + Integer expYear; + String number; + + // + public String getCard() { + return (this.card != null) ? this.card.getId() : null; + } + + public void setCard(String cardId) { + this.card = setExpandableFieldID(cardId, this.card); + } + + public Card getCardObject() { + return (this.card != null) ? this.card.getExpanded() : null; + } + + public void setCardObject(Card c) { + this.card = new ExpandableField(c.getId(), c); + } + // +} diff --git a/src/main/java/com/stripe/model/issuing/Cardholder.java b/src/main/java/com/stripe/model/issuing/Cardholder.java new file mode 100644 index 00000000000..6c377d1ea50 --- /dev/null +++ b/src/main/java/com/stripe/model/issuing/Cardholder.java @@ -0,0 +1,142 @@ +package com.stripe.model.issuing; + +import com.stripe.exception.APIConnectionException; +import com.stripe.exception.APIException; +import com.stripe.exception.AuthenticationException; +import com.stripe.exception.CardException; +import com.stripe.exception.InvalidRequestException; +import com.stripe.model.Address; +import com.stripe.model.HasId; +import com.stripe.model.MetadataStore; +import com.stripe.model.StripeObject; +import com.stripe.net.APIResource; +import com.stripe.net.RequestOptions; + +import java.util.Map; + +import lombok.AccessLevel; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.Setter; + +@Getter +@Setter +@EqualsAndHashCode(callSuper = false) +public class Cardholder extends APIResource implements MetadataStore, HasId { + @Getter(onMethod = @__({@Override})) String id; + String object; + Billing billing; + Long created; + String email; + Boolean livemode; + @Getter(onMethod = @__({@Override})) Map metadata; + String name; + String phoneNumber; + String status; + String type; + + // + /** + * Create an issuing cardholder. + */ + public static Cardholder create(Map params) + throws AuthenticationException, InvalidRequestException, + APIConnectionException, CardException, APIException { + return create(params, null); + } + + /** + * Create an issuing cardholder. + */ + public static Cardholder create(Map params, RequestOptions options) + throws AuthenticationException, InvalidRequestException, + APIConnectionException, CardException, APIException { + return request(RequestMethod.POST, classURL(Cardholder.class), params, + Cardholder.class, options); + } + // + + // + /** + * List all issuing cardholders. + */ + public static CardholderCollection list(Map params) + throws AuthenticationException, InvalidRequestException, + APIConnectionException, CardException, APIException { + return list(params, null); + } + + /** + * List all issuing cardholders. + */ + public static CardholderCollection list(Map params, RequestOptions options) + throws AuthenticationException, InvalidRequestException, APIConnectionException, + CardException, APIException { + return requestCollection(classURL(Cardholder.class), params, + CardholderCollection.class, options); + } + // + + // + /** + * Retrieve an issuing cardholder. + */ + public static Cardholder retrieve(String id) throws AuthenticationException, + InvalidRequestException, APIConnectionException, CardException, + APIException { + return retrieve(id, null); + } + + /** + * Retrieve an issuing cardholder. + */ + public static Cardholder retrieve(String id, RequestOptions options) + throws AuthenticationException, InvalidRequestException, + APIConnectionException, CardException, APIException { + return request(RequestMethod.GET, instanceURL(Cardholder.class, id), null, + Cardholder.class, options); + } + + /** + * Retrieve an issuing cardholder. + */ + public static Cardholder retrieve(String id, Map params, + RequestOptions options) + throws AuthenticationException, InvalidRequestException, + APIConnectionException, CardException, APIException { + return request(RequestMethod.GET, instanceURL(Cardholder.class, id), params, + Cardholder.class, options); + } + // + + // + /** + * Update an issuing cardholder. + */ + @Override + public Cardholder update(Map params) + throws AuthenticationException, InvalidRequestException, + APIConnectionException, CardException, APIException { + return update(params, null); + } + + /** + * Update an issuing cardholder. + */ + @Override + public Cardholder update(Map params, RequestOptions options) + throws AuthenticationException, InvalidRequestException, + APIConnectionException, CardException, APIException { + return request(RequestMethod.POST, instanceURL(Cardholder.class, this.id), params, + Cardholder.class, options); + } + // + + @Getter + @Setter + @EqualsAndHashCode(callSuper = false) + public final class Billing extends StripeObject { + Address address; + String name; + } +} diff --git a/src/main/java/com/stripe/model/issuing/CardholderCollection.java b/src/main/java/com/stripe/model/issuing/CardholderCollection.java new file mode 100644 index 00000000000..e80d84031de --- /dev/null +++ b/src/main/java/com/stripe/model/issuing/CardholderCollection.java @@ -0,0 +1,6 @@ +package com.stripe.model.issuing; + +import com.stripe.model.StripeCollection; + +public class CardholderCollection extends StripeCollection { +} diff --git a/src/main/java/com/stripe/model/issuing/Dispute.java b/src/main/java/com/stripe/model/issuing/Dispute.java new file mode 100644 index 00000000000..5b45e0a9afd --- /dev/null +++ b/src/main/java/com/stripe/model/issuing/Dispute.java @@ -0,0 +1,177 @@ +package com.stripe.model.issuing; + +import com.stripe.exception.APIConnectionException; +import com.stripe.exception.APIException; +import com.stripe.exception.AuthenticationException; +import com.stripe.exception.CardException; +import com.stripe.exception.InvalidRequestException; +import com.stripe.model.ExpandableField; +import com.stripe.model.HasId; +import com.stripe.model.MetadataStore; +import com.stripe.model.StripeObject; +import com.stripe.net.APIResource; +import com.stripe.net.RequestOptions; + +import java.util.List; +import java.util.Map; + +import lombok.AccessLevel; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.Setter; + +@Getter +@Setter +@EqualsAndHashCode(callSuper = false) +public class Dispute extends APIResource implements MetadataStore, HasId { + @Getter(onMethod = @__({@Override})) String id; + String object; + Long amount; + Long created; + Evidence evidence; + Boolean livemode; + @Getter(onMethod = @__({@Override})) Map metadata; + String reason; + String status; + @Getter(AccessLevel.NONE) @Setter(AccessLevel.NONE) + ExpandableField transaction; + + // + public String getTransaction() { + return (this.transaction != null) ? this.transaction.getId() : null; + } + + public void setTransaction(String transactionId) { + this.transaction = setExpandableFieldID(transactionId, this.transaction); + } + + public Transaction getTransactionObject() { + return (this.transaction != null) ? this.transaction.getExpanded() : null; + } + + public void setTransactionObject(Transaction c) { + this.transaction = new ExpandableField(c.getId(), c); + } + // + + // + /** + * Create an issuing dispute. + */ + public static Dispute create(Map params) + throws AuthenticationException, InvalidRequestException, + APIConnectionException, CardException, APIException { + return create(params, null); + } + + /** + * Create an issuing dispute. + */ + public static Dispute create(Map params, RequestOptions options) + throws AuthenticationException, InvalidRequestException, + APIConnectionException, CardException, APIException { + return request(RequestMethod.POST, classURL(Dispute.class), params, + Dispute.class, options); + } + // + + // + /** + * List all issuing disputes. + */ + public static DisputeCollection list(Map params) + throws AuthenticationException, InvalidRequestException, + APIConnectionException, CardException, APIException { + return list(params, null); + } + + /** + * List all issuing disputes. + */ + public static DisputeCollection list(Map params, RequestOptions options) + throws AuthenticationException, InvalidRequestException, APIConnectionException, + CardException, APIException { + return requestCollection(classURL(Dispute.class), params, + DisputeCollection.class, options); + } + // + + // + /** + * Retrieve an issuing dispute. + */ + public static Dispute retrieve(String id) throws AuthenticationException, + InvalidRequestException, APIConnectionException, CardException, + APIException { + return retrieve(id, null); + } + + /** + * Retrieve an issuing dispute. + */ + public static Dispute retrieve(String id, RequestOptions options) + throws AuthenticationException, InvalidRequestException, + APIConnectionException, CardException, APIException { + return request(RequestMethod.GET, instanceURL(Dispute.class, id), null, + Dispute.class, options); + } + + /** + * Retrieve an issuing dispute. + */ + public static Dispute retrieve(String id, Map params, + RequestOptions options) + throws AuthenticationException, InvalidRequestException, + APIConnectionException, CardException, APIException { + return request(RequestMethod.GET, instanceURL(Dispute.class, id), params, + Dispute.class, options); + } + // + + // + /** + * Update an issuing dispute. + */ + @Override + public Dispute update(Map params) + throws AuthenticationException, InvalidRequestException, + APIConnectionException, CardException, APIException { + return update(params, null); + } + + /** + * Update an issuing dispute. + */ + @Override + public Dispute update(Map params, RequestOptions options) + throws AuthenticationException, InvalidRequestException, + APIConnectionException, CardException, APIException { + return request(RequestMethod.POST, instanceURL(Dispute.class, this.id), params, + Dispute.class, options); + } + // + + @Getter + @Setter + @EqualsAndHashCode(callSuper = false) + public final class EvidenceFraudulent extends StripeObject { + String disputeExplanation; + String uncategorizedFile; + } + + @Getter + @Setter + @EqualsAndHashCode(callSuper = false) + public final class EvidenceOther extends StripeObject { + String disputeExplanation; + String uncategorizedFile; + } + + @Getter + @Setter + @EqualsAndHashCode(callSuper = false) + public final class Evidence extends StripeObject { + EvidenceFraudulent fraudulent; + EvidenceOther other; + } +} diff --git a/src/main/java/com/stripe/model/issuing/DisputeCollection.java b/src/main/java/com/stripe/model/issuing/DisputeCollection.java new file mode 100644 index 00000000000..16f47ad5fdb --- /dev/null +++ b/src/main/java/com/stripe/model/issuing/DisputeCollection.java @@ -0,0 +1,6 @@ +package com.stripe.model.issuing; + +import com.stripe.model.StripeCollection; + +public class DisputeCollection extends StripeCollection { +} diff --git a/src/main/java/com/stripe/model/issuing/MerchantData.java b/src/main/java/com/stripe/model/issuing/MerchantData.java new file mode 100644 index 00000000000..13aa2ff301e --- /dev/null +++ b/src/main/java/com/stripe/model/issuing/MerchantData.java @@ -0,0 +1,20 @@ +package com.stripe.model.issuing; + +import com.stripe.model.StripeObject; + +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.Setter; + +@Getter +@Setter +@EqualsAndHashCode(callSuper = false) +public final class MerchantData extends StripeObject { + String category; + String city; + String country; + String name; + String networkId; + String postalCode; + String state; +} \ No newline at end of file diff --git a/src/main/java/com/stripe/model/issuing/Transaction.java b/src/main/java/com/stripe/model/issuing/Transaction.java new file mode 100644 index 00000000000..4f5283fbe78 --- /dev/null +++ b/src/main/java/com/stripe/model/issuing/Transaction.java @@ -0,0 +1,213 @@ +package com.stripe.model.issuing; + +import com.stripe.exception.APIConnectionException; +import com.stripe.exception.APIException; +import com.stripe.exception.AuthenticationException; +import com.stripe.exception.CardException; +import com.stripe.exception.InvalidRequestException; +import com.stripe.model.BalanceTransaction; +import com.stripe.model.ExpandableField; +import com.stripe.model.HasId; +import com.stripe.model.MetadataStore; +import com.stripe.model.StripeObject; +import com.stripe.net.APIResource; +import com.stripe.net.RequestOptions; + +import java.util.List; +import java.util.Map; + +import lombok.AccessLevel; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.Setter; + +@Getter +@Setter +@EqualsAndHashCode(callSuper = false) +public class Transaction extends APIResource implements MetadataStore, HasId { + @Getter(onMethod = @__({@Override})) String id; + String object; + Long amount; + @Getter(AccessLevel.NONE) @Setter(AccessLevel.NONE) + ExpandableField authorization; + @Getter(AccessLevel.NONE) @Setter(AccessLevel.NONE) + ExpandableField balanceTransaction; + @Getter(AccessLevel.NONE) @Setter(AccessLevel.NONE) + ExpandableField card; + @Getter(AccessLevel.NONE) @Setter(AccessLevel.NONE) + ExpandableField cardholder; + Long created; + String currency; + @Getter(AccessLevel.NONE) @Setter(AccessLevel.NONE) + ExpandableField dispute; + Boolean livemode; + MerchantData merchantData; + @Getter(onMethod = @__({@Override})) Map metadata; + String type; + + // + public String getAuthorization() { + return (this.authorization != null) ? this.authorization.getId() : null; + } + + public void setAuthorization(String authorizationId) { + this.authorization = setExpandableFieldID(authorizationId, this.authorization); + } + + public Authorization getAuthorizationObject() { + return (this.authorization != null) ? this.authorization.getExpanded() : null; + } + + public void setAuthorizationObject(Authorization c) { + this.authorization = new ExpandableField(c.getId(), c); + } + // + + // + public String getBalanceTransaction() { + return (this.balanceTransaction != null) ? this.balanceTransaction.getId() : null; + } + + public void setBalanceTransaction(String balanceTransactionId) { + this.balanceTransaction = setExpandableFieldID(balanceTransactionId, this.balanceTransaction); + } + + public BalanceTransaction getBalanceTransactionObject() { + return (this.balanceTransaction != null) ? this.balanceTransaction.getExpanded() : null; + } + + public void setBalanceTransactionObject(BalanceTransaction c) { + this.balanceTransaction = new ExpandableField(c.getId(), c); + } + // + + // + public String getCard() { + return (this.card != null) ? this.card.getId() : null; + } + + public void setCard(String cardId) { + this.card = setExpandableFieldID(cardId, this.card); + } + + public Card getCardObject() { + return (this.card != null) ? this.card.getExpanded() : null; + } + + public void setCardObject(Card c) { + this.card = new ExpandableField(c.getId(), c); + } + // + + // + public String getCardholder() { + return (this.cardholder != null) ? this.cardholder.getId() : null; + } + + public void setCardholder(String cardholderId) { + this.cardholder = setExpandableFieldID(cardholderId, this.cardholder); + } + + public Cardholder getCardholderObject() { + return (this.cardholder != null) ? this.cardholder.getExpanded() : null; + } + + public void setCardholderObject(Cardholder c) { + this.cardholder = new ExpandableField(c.getId(), c); + } + // + + // + public String getDispute() { + return (this.dispute != null) ? this.dispute.getId() : null; + } + + public void setDispute(String disputeId) { + this.dispute = setExpandableFieldID(disputeId, this.dispute); + } + + public Dispute getDisputeObject() { + return (this.dispute != null) ? this.dispute.getExpanded() : null; + } + + public void setDisputeObject(Dispute c) { + this.dispute = new ExpandableField(c.getId(), c); + } + // + + // + /** + * List all issuing transactions. + */ + public static TransactionCollection list(Map params) + throws AuthenticationException, InvalidRequestException, + APIConnectionException, CardException, APIException { + return list(params, null); + } + + /** + * List all issuing transactions. + */ + public static TransactionCollection list(Map params, RequestOptions options) + throws AuthenticationException, InvalidRequestException, APIConnectionException, + CardException, APIException { + return requestCollection(classURL(Transaction.class), params, + TransactionCollection.class, options); + } + // + + // + /** + * Retrieve an issuing transaction. + */ + public static Transaction retrieve(String id) throws AuthenticationException, + InvalidRequestException, APIConnectionException, CardException, + APIException { + return retrieve(id, null); + } + + /** + * Retrieve an issuing transaction. + */ + public static Transaction retrieve(String id, RequestOptions options) + throws AuthenticationException, InvalidRequestException, + APIConnectionException, CardException, APIException { + return request(RequestMethod.GET, instanceURL(Transaction.class, id), null, + Transaction.class, options); + } + + /** + * Retrieve an issuing transaction. + */ + public static Transaction retrieve(String id, Map params, + RequestOptions options) + throws AuthenticationException, InvalidRequestException, + APIConnectionException, CardException, APIException { + return request(RequestMethod.GET, instanceURL(Transaction.class, id), params, + Transaction.class, options); + } + // + + // + /** + * Update an issuing transaction. + */ + @Override + public Transaction update(Map params) + throws AuthenticationException, InvalidRequestException, + APIConnectionException, CardException, APIException { + return update(params, null); + } + + /** + * Update an issuing transaction. + */ + @Override + public Transaction update(Map params, RequestOptions options) + throws AuthenticationException, InvalidRequestException, + APIConnectionException, CardException, APIException { + return request(RequestMethod.POST, instanceURL(Transaction.class, this.id), params, + Transaction.class, options); + } + // +} diff --git a/src/main/java/com/stripe/model/issuing/TransactionCollection.java b/src/main/java/com/stripe/model/issuing/TransactionCollection.java new file mode 100644 index 00000000000..601d2e0c14d --- /dev/null +++ b/src/main/java/com/stripe/model/issuing/TransactionCollection.java @@ -0,0 +1,6 @@ +package com.stripe.model.issuing; + +import com.stripe.model.StripeCollection; + +public class TransactionCollection extends StripeCollection { +} diff --git a/src/main/java/com/stripe/net/APIResource.java b/src/main/java/com/stripe/net/APIResource.java index 00b6c472fe3..0720d0183bb 100644 --- a/src/main/java/com/stripe/net/APIResource.java +++ b/src/main/java/com/stripe/net/APIResource.java @@ -77,11 +77,17 @@ public static void setStripeResponseGetter(StripeResponseGetter srg) { private static String className(Class clazz) { // Convert CamelCase to snake_case - final String className = clazz.getSimpleName() + String className = clazz.getSimpleName() .replaceAll("(.)([A-Z][a-z]+)", "$1_$2") .replaceAll("([a-z0-9])([A-Z])", "$1_$2") .toLowerCase(); + // Issuing resources are in their own package. Until we can support adding OBJECT_NAME + // to all classes, we use this dirty trick to properly format the API endpoints + if (clazz.getName().contains("com.stripe.model.issuing.")) { + className = "issuing/" + className; + } + // Handle special cases switch (className) { case "invoice_item": diff --git a/src/test/java/com/stripe/BaseStripeTest.java b/src/test/java/com/stripe/BaseStripeTest.java index 732a53e89c5..aca2fc09b26 100644 --- a/src/test/java/com/stripe/BaseStripeTest.java +++ b/src/test/java/com/stripe/BaseStripeTest.java @@ -35,7 +35,7 @@ public class BaseStripeTest { // If changing this number, please also change it in `.travis.yml`. - private static final String MOCK_MINIMUM_VERSION = "0.19.0"; + private static final String MOCK_MINIMUM_VERSION = "0.23.0"; private static String port; diff --git a/src/test/java/com/stripe/functional/issuing/AuthorizationTest.java b/src/test/java/com/stripe/functional/issuing/AuthorizationTest.java new file mode 100644 index 00000000000..70df74773f6 --- /dev/null +++ b/src/test/java/com/stripe/functional/issuing/AuthorizationTest.java @@ -0,0 +1,95 @@ +package com.stripe.functional.issuing; + +import static org.junit.Assert.assertNotNull; + +import com.stripe.BaseStripeTest; +import com.stripe.exception.StripeException; +import com.stripe.model.issuing.Authorization; +import com.stripe.model.issuing.AuthorizationCollection; +import com.stripe.net.APIResource; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.junit.Test; + + +public class AuthorizationTest extends BaseStripeTest { + public static final String AUTHORIZATION_ID = "iauth_123"; + + @Test + public void testApprove() throws IOException, StripeException { + final Authorization authorization = Authorization.retrieve(AUTHORIZATION_ID); + + final Authorization approvedAuthorization = authorization.approve(null); + + assertNotNull(approvedAuthorization); + verifyRequest( + APIResource.RequestMethod.POST, + String.format("/v1/issuing/authorizations/%s/approve", authorization.getId()), + null + ); + } + + @Test + public void testDecline() throws IOException, StripeException { + final Authorization authorization = Authorization.retrieve(AUTHORIZATION_ID); + + final Authorization approvedAuthorization = authorization.decline(null); + + assertNotNull(approvedAuthorization); + verifyRequest( + APIResource.RequestMethod.POST, + String.format("/v1/issuing/authorizations/%s/decline", authorization.getId()), + null + ); + } + + @Test + public void testRetrieve() throws IOException, StripeException { + final Authorization authorization = Authorization.retrieve(AUTHORIZATION_ID); + + assertNotNull(authorization); + verifyRequest( + APIResource.RequestMethod.GET, + String.format("/v1/issuing/authorizations/%s", AUTHORIZATION_ID) + ); + } + + @Test + public void testUpdate() throws IOException, StripeException { + final Authorization authorization = Authorization.retrieve(AUTHORIZATION_ID); + + final Map metadata = new HashMap(); + metadata.put("key", "value"); + final Map params = new HashMap(); + params.put("metadata", metadata); + + final Authorization updatedAuthorization = authorization.update(params); + + assertNotNull(updatedAuthorization); + verifyRequest( + APIResource.RequestMethod.POST, + String.format("/v1/issuing/authorizations/%s", authorization.getId()), + params + ); + } + + @Test + public void testList() throws IOException, StripeException { + final Map params = new HashMap(); + params.put("limit", 1); + + AuthorizationCollection authorizations = Authorization.list(params); + + assertNotNull(authorizations); + verifyRequest( + APIResource.RequestMethod.GET, + String.format("/v1/issuing/authorizations"), + params + ); + } +} diff --git a/src/test/java/com/stripe/functional/issuing/CardTest.java b/src/test/java/com/stripe/functional/issuing/CardTest.java new file mode 100644 index 00000000000..c0f792b4443 --- /dev/null +++ b/src/test/java/com/stripe/functional/issuing/CardTest.java @@ -0,0 +1,98 @@ +package com.stripe.functional.issuing; + +import static org.junit.Assert.assertNotNull; + +import com.stripe.BaseStripeTest; +import com.stripe.exception.StripeException; +import com.stripe.model.issuing.Card; +import com.stripe.model.issuing.CardCollection; +import com.stripe.model.issuing.CardDetails; +import com.stripe.net.APIResource; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.junit.Test; + + +public class CardTest extends BaseStripeTest { + public static final String CARD_ID = "ic_123"; + + @Test + public void testCreate() throws IOException, StripeException { + final Map params = new HashMap(); + params.put("currency", "usd"); + params.put("type", "physical"); + + final Card card = Card.create(params); + + assertNotNull(card); + verifyRequest( + APIResource.RequestMethod.POST, + String.format("/v1/issuing/cards"), + params + ); + } + + @Test + public void testDetails() throws IOException, StripeException { + final Card card = Card.retrieve(CARD_ID); + + final CardDetails cardDetails = card.details(null); + + assertNotNull(cardDetails); + verifyRequest( + APIResource.RequestMethod.GET, + String.format("/v1/issuing/cards/%s/details", card.getId()), + null + ); + } + + @Test + public void testRetrieve() throws IOException, StripeException { + final Card card = Card.retrieve(CARD_ID); + + assertNotNull(card); + verifyRequest( + APIResource.RequestMethod.GET, + String.format("/v1/issuing/cards/%s", CARD_ID) + ); + } + + @Test + public void testUpdate() throws IOException, StripeException { + final Card card = Card.retrieve(CARD_ID); + + final Map metadata = new HashMap(); + metadata.put("key", "value"); + final Map params = new HashMap(); + params.put("metadata", metadata); + + final Card updatedCard = card.update(params); + + assertNotNull(updatedCard); + verifyRequest( + APIResource.RequestMethod.POST, + String.format("/v1/issuing/cards/%s", card.getId()), + params + ); + } + + @Test + public void testList() throws IOException, StripeException { + final Map params = new HashMap(); + params.put("limit", 1); + + CardCollection resources = Card.list(params); + + assertNotNull(resources); + verifyRequest( + APIResource.RequestMethod.GET, + String.format("/v1/issuing/cards"), + params + ); + } +} diff --git a/src/test/java/com/stripe/functional/issuing/CardholderTest.java b/src/test/java/com/stripe/functional/issuing/CardholderTest.java new file mode 100644 index 00000000000..23758fe1615 --- /dev/null +++ b/src/test/java/com/stripe/functional/issuing/CardholderTest.java @@ -0,0 +1,93 @@ +package com.stripe.functional.issuing; + +import static org.junit.Assert.assertNotNull; + +import com.stripe.BaseStripeTest; +import com.stripe.exception.StripeException; +import com.stripe.model.issuing.Cardholder; +import com.stripe.model.issuing.CardholderCollection; +import com.stripe.net.APIResource; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.junit.Test; + + +public class CardholderTest extends BaseStripeTest { + public static final String CARDHOLDER_ID = "ich_123"; + + @Test + public void testCreate() throws IOException, StripeException { + final Map address = new HashMap(); + address.put("city", "city"); + address.put("country", "US"); + address.put("line1", "line1"); + address.put("postal_code", "90210"); + + final Map billing = new HashMap(); + billing.put("address", address); + + final Map params = new HashMap(); + params.put("billing", billing); + params.put("name", "Jenny Rosen"); + params.put("type", "individual"); + + final Cardholder cardholder = Cardholder.create(params); + + assertNotNull(cardholder); + verifyRequest( + APIResource.RequestMethod.POST, + String.format("/v1/issuing/cardholders"), + params + ); + } + + @Test + public void testRetrieve() throws IOException, StripeException { + final Cardholder cardholder = Cardholder.retrieve(CARDHOLDER_ID); + + assertNotNull(cardholder); + verifyRequest( + APIResource.RequestMethod.GET, + String.format("/v1/issuing/cardholders/%s", CARDHOLDER_ID) + ); + } + + @Test + public void testUpdate() throws IOException, StripeException { + final Cardholder cardholder = Cardholder.retrieve(CARDHOLDER_ID); + + final Map metadata = new HashMap(); + metadata.put("key", "value"); + final Map params = new HashMap(); + params.put("metadata", metadata); + + final Cardholder updatedCardholder = cardholder.update(params); + + assertNotNull(updatedCardholder); + verifyRequest( + APIResource.RequestMethod.POST, + String.format("/v1/issuing/cardholders/%s", cardholder.getId()), + params + ); + } + + @Test + public void testList() throws IOException, StripeException { + final Map params = new HashMap(); + params.put("limit", 1); + + CardholderCollection cardholders = Cardholder.list(params); + + assertNotNull(cardholders); + verifyRequest( + APIResource.RequestMethod.GET, + String.format("/v1/issuing/cardholders"), + params + ); + } +} diff --git a/src/test/java/com/stripe/functional/issuing/DisputeTest.java b/src/test/java/com/stripe/functional/issuing/DisputeTest.java new file mode 100644 index 00000000000..d61c5dace32 --- /dev/null +++ b/src/test/java/com/stripe/functional/issuing/DisputeTest.java @@ -0,0 +1,83 @@ +package com.stripe.functional.issuing; + +import static org.junit.Assert.assertNotNull; + +import com.stripe.BaseStripeTest; +import com.stripe.exception.StripeException; +import com.stripe.model.issuing.Dispute; +import com.stripe.model.issuing.DisputeCollection; +import com.stripe.net.APIResource; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.junit.Test; + + +public class DisputeTest extends BaseStripeTest { + public static final String DISPUTE_ID = "idp_123"; + + @Test + public void testCreate() throws IOException, StripeException { + final Map params = new HashMap(); + params.put("reason", "fraudulent"); + params.put("transaction", "ipi_123"); + + final Dispute dispute = Dispute.create(params); + + assertNotNull(dispute); + verifyRequest( + APIResource.RequestMethod.POST, + String.format("/v1/issuing/disputes"), + params + ); + } + + @Test + public void testRetrieve() throws IOException, StripeException { + final Dispute dispute = Dispute.retrieve(DISPUTE_ID); + + assertNotNull(dispute); + verifyRequest( + APIResource.RequestMethod.GET, + String.format("/v1/issuing/disputes/%s", DISPUTE_ID) + ); + } + + @Test + public void testUpdate() throws IOException, StripeException { + final Dispute dispute = Dispute.retrieve(DISPUTE_ID); + + final Map metadata = new HashMap(); + metadata.put("key", "value"); + final Map params = new HashMap(); + params.put("metadata", metadata); + + final Dispute updatedDispute = dispute.update(params); + + assertNotNull(updatedDispute); + verifyRequest( + APIResource.RequestMethod.POST, + String.format("/v1/issuing/disputes/%s", dispute.getId()), + params + ); + } + + @Test + public void testList() throws IOException, StripeException { + final Map params = new HashMap(); + params.put("limit", 1); + + DisputeCollection disputes = Dispute.list(params); + + assertNotNull(disputes); + verifyRequest( + APIResource.RequestMethod.GET, + String.format("/v1/issuing/disputes"), + params + ); + } +} diff --git a/src/test/java/com/stripe/functional/issuing/TransactionTest.java b/src/test/java/com/stripe/functional/issuing/TransactionTest.java new file mode 100644 index 00000000000..a9d46d9af47 --- /dev/null +++ b/src/test/java/com/stripe/functional/issuing/TransactionTest.java @@ -0,0 +1,67 @@ +package com.stripe.functional.issuing; + +import static org.junit.Assert.assertNotNull; + +import com.stripe.BaseStripeTest; +import com.stripe.exception.StripeException; +import com.stripe.model.issuing.Transaction; +import com.stripe.model.issuing.TransactionCollection; +import com.stripe.net.APIResource; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.junit.Test; + + +public class TransactionTest extends BaseStripeTest { + public static final String TRANSACTION_ID = "ipi_123"; + + @Test + public void testRetrieve() throws IOException, StripeException { + final Transaction transaction = Transaction.retrieve(TRANSACTION_ID); + + assertNotNull(transaction); + verifyRequest( + APIResource.RequestMethod.GET, + String.format("/v1/issuing/transactions/%s", TRANSACTION_ID) + ); + } + + @Test + public void testUpdate() throws IOException, StripeException { + final Transaction transaction = Transaction.retrieve(TRANSACTION_ID); + + final Map metadata = new HashMap(); + metadata.put("key", "value"); + final Map params = new HashMap(); + params.put("metadata", metadata); + + final Transaction updatedTransaction = transaction.update(params); + + assertNotNull(updatedTransaction); + verifyRequest( + APIResource.RequestMethod.POST, + String.format("/v1/issuing/transactions/%s", transaction.getId()), + params + ); + } + + @Test + public void testList() throws IOException, StripeException { + final Map params = new HashMap(); + params.put("limit", 1); + + TransactionCollection transactions = Transaction.list(params); + + assertNotNull(transactions); + verifyRequest( + APIResource.RequestMethod.GET, + String.format("/v1/issuing/transactions"), + params + ); + } +} diff --git a/src/test/java/com/stripe/model/BalanceTransactionTest.java b/src/test/java/com/stripe/model/BalanceTransactionTest.java index 2c304d0be6d..9b410fc815c 100644 --- a/src/test/java/com/stripe/model/BalanceTransactionTest.java +++ b/src/test/java/com/stripe/model/BalanceTransactionTest.java @@ -1,11 +1,15 @@ package com.stripe.model; +import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; import com.stripe.BaseStripeTest; import com.stripe.model.BalanceTransaction; +import com.stripe.model.BalanceTransactionCollection; import com.stripe.net.APIResource; +import java.util.List; + import org.junit.Test; public class BalanceTransactionTest extends BaseStripeTest { @@ -27,4 +31,72 @@ public void testDeserializeExpansions() throws Exception { assertNotNull(source); assertNotNull(source.getId()); } + + @Test + public void testDeserializeCollectionWithSourceExpansions() throws Exception { + final String data = getResourceAsString( + "/api_fixtures/balance_transaction_collection_with_source_expansion.json"); + final BalanceTransactionCollection btCollection = + APIResource.GSON.fromJson(data, BalanceTransactionCollection.class); + + assertNotNull(btCollection); + final List bts = btCollection.getData(); + assertNotNull(bts); + + for (BalanceTransaction bt : bts) { + String btId = bt.getId(); + + if (btId.equals("txn_100")) { + ApplicationFee btSource = (ApplicationFee) bt.getSourceObject(); + assertNotNull(btSource); + assertEquals("application_fee", btSource.getObject()); + } else if (btId.equals("txn_101")) { + Charge btSource = (Charge) bt.getSourceObject(); + assertNotNull(btSource); + assertEquals("charge", btSource.getObject()); + } else if (btId.equals("txn_102")) { + Dispute btSource = (Dispute) bt.getSourceObject(); + assertNotNull(btSource); + assertEquals("dispute", btSource.getObject()); + } else if (btId.equals("txn_103")) { + Payout btSource = (Payout) bt.getSourceObject(); + assertNotNull(btSource); + assertEquals("payout", btSource.getObject()); + } else if (btId.equals("txn_104")) { + Refund btSource = (Refund) bt.getSourceObject(); + assertNotNull(btSource); + assertEquals("refund", btSource.getObject()); + } else if (btId.equals("txn_105")) { + Transfer btSource = (Transfer) bt.getSourceObject(); + assertNotNull(btSource); + assertEquals("transfer", btSource.getObject()); + } else if (btId.equals("txn_106")) { + Reversal btSource = (Reversal) bt.getSourceObject(); + assertNotNull(btSource); + assertEquals("transfer_reversal", btSource.getObject()); + } else if (btId.equals("txn_107")) { + Topup btSource = (Topup) bt.getSourceObject(); + assertNotNull(btSource); + assertEquals("topup", btSource.getObject()); + } else if (btId.equals("txn_108")) { + com.stripe.model.issuing.Authorization btSource = + (com.stripe.model.issuing.Authorization) bt.getSourceObject(); + assertNotNull(btSource); + assertEquals("issuing.authorization", btSource.getObject()); + } else if (btId.equals("txn_109")) { + com.stripe.model.issuing.Transaction btSource = + (com.stripe.model.issuing.Transaction ) bt.getSourceObject(); + assertNotNull(btSource); + assertEquals("issuing.transaction", btSource.getObject()); + } else if (btId.equals("txn_110")) { + ApplicationFee btSource = (ApplicationFee) bt.getSourceObject(); + assertNotNull(btSource); + assertEquals("application_fee", btSource.getObject()); + } else if (btId.equals("txn_110")) { + ApplicationFee btSource = (ApplicationFee) bt.getSourceObject(); + assertNotNull(btSource); + assertEquals("application_fee", btSource.getObject()); + } + } + } } diff --git a/src/test/java/com/stripe/model/issuing/AuthorizationTest.java b/src/test/java/com/stripe/model/issuing/AuthorizationTest.java new file mode 100644 index 00000000000..5df18467991 --- /dev/null +++ b/src/test/java/com/stripe/model/issuing/AuthorizationTest.java @@ -0,0 +1,43 @@ +package com.stripe.model.issuing; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; + +import com.stripe.BaseStripeTest; +import com.stripe.net.APIResource; + +import org.junit.Test; + +public class AuthorizationTest extends BaseStripeTest { + @Test + public void testDeserialize() throws Exception { + final String data = getFixture("/v1/issuing/authorizations/iauth_123"); + final Authorization authorization = APIResource.GSON.fromJson(data, Authorization.class); + + assertNotNull(authorization); + assertNotNull(authorization.getId()); + assertEquals("issuing.authorization", authorization.getObject()); + assertNotNull(authorization.getCardObject()); + assertEquals("issuing.card", authorization.getCardObject().getObject()); + } + + @Test + public void testDeserializeWithExpansions() throws Exception { + final String[] expansions = { + "cardholder", + }; + final String data = getFixture("/v1/issuing/authorizations/iauth_123", expansions); + final Authorization authorization = APIResource.GSON.fromJson(data, Authorization.class); + + assertNotNull(authorization); + assertNotNull(authorization.getId()); + assertEquals("issuing.authorization", authorization.getObject()); + assertEquals("issuing.card", authorization.getCardObject().getObject()); + + final Cardholder cardholder = authorization.getCardholderObject(); + assertNotNull(cardholder); + assertNotNull(cardholder.getId()); + assertEquals(authorization.getCardholder(), cardholder.getId()); + } +} diff --git a/src/test/java/com/stripe/model/issuing/CardDetailsTest.java b/src/test/java/com/stripe/model/issuing/CardDetailsTest.java new file mode 100644 index 00000000000..a576f75de49 --- /dev/null +++ b/src/test/java/com/stripe/model/issuing/CardDetailsTest.java @@ -0,0 +1,23 @@ +package com.stripe.model.issuing; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; + +import com.stripe.BaseStripeTest; +import com.stripe.net.APIResource; + +import org.junit.Test; + +public class CardDetailsTest extends BaseStripeTest { + @Test + public void testDeserialize() throws Exception { + final CardDetails cardDetails = APIResource.GSON.fromJson( + getResourceAsString("/api_fixtures/issuing/card_details.json"), CardDetails.class); + + assertNotNull(cardDetails); + assertEquals("issuing.card_details", cardDetails.getObject()); + assertNotNull(cardDetails.getCardObject()); + assertEquals("issuing.card", cardDetails.getCardObject().getObject()); + } +} \ No newline at end of file diff --git a/src/test/java/com/stripe/model/issuing/CardTest.java b/src/test/java/com/stripe/model/issuing/CardTest.java new file mode 100644 index 00000000000..83c25a715ed --- /dev/null +++ b/src/test/java/com/stripe/model/issuing/CardTest.java @@ -0,0 +1,24 @@ +package com.stripe.model.issuing; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; + +import com.stripe.BaseStripeTest; +import com.stripe.net.APIResource; + +import org.junit.Test; + +public class CardTest extends BaseStripeTest { + @Test + public void testDeserialize() throws Exception { + final String data = getFixture("/v1/issuing/cards/ic_123"); + final Card card = APIResource.GSON.fromJson(data, Card.class); + + assertNotNull(card); + assertNotNull(card.getId()); + assertEquals("issuing.card", card.getObject()); + assertNotNull(card.getCardholder()); + assertEquals("issuing.cardholder", card.getCardholder().getObject()); + } +} \ No newline at end of file diff --git a/src/test/java/com/stripe/model/issuing/CardholderTest.java b/src/test/java/com/stripe/model/issuing/CardholderTest.java new file mode 100644 index 00000000000..87f3f944396 --- /dev/null +++ b/src/test/java/com/stripe/model/issuing/CardholderTest.java @@ -0,0 +1,22 @@ +package com.stripe.model.issuing; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; + +import com.stripe.BaseStripeTest; +import com.stripe.net.APIResource; + +import org.junit.Test; + +public class CardholderTest extends BaseStripeTest { + @Test + public void testDeserialize() throws Exception { + final String data = getFixture("/v1/issuing/cardholders/ich_123"); + final Cardholder cardholder = APIResource.GSON.fromJson(data, Cardholder.class); + + assertNotNull(cardholder); + assertNotNull(cardholder.getId()); + assertEquals("issuing.cardholder", cardholder.getObject()); + } +} \ No newline at end of file diff --git a/src/test/java/com/stripe/model/issuing/DisputeTest.java b/src/test/java/com/stripe/model/issuing/DisputeTest.java new file mode 100644 index 00000000000..0bcbd7b2822 --- /dev/null +++ b/src/test/java/com/stripe/model/issuing/DisputeTest.java @@ -0,0 +1,40 @@ +package com.stripe.model.issuing; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; + +import com.stripe.BaseStripeTest; +import com.stripe.net.APIResource; + +import org.junit.Test; + +public class DisputeTest extends BaseStripeTest { + @Test + public void testDeserialize() throws Exception { + final String data = getFixture("/v1/issuing/disputes/idp_123"); + final Dispute dispute = APIResource.GSON.fromJson(data, Dispute.class); + + assertNotNull(dispute); + assertNotNull(dispute.getId()); + assertEquals("issuing.dispute", dispute.getObject()); + } + + @Test + public void testDeserializeWithExpansions() throws Exception { + final String[] expansions = { + "transaction", + }; + final String data = getFixture("/v1/issuing/disputes/idp_123", expansions); + final Dispute dispute = APIResource.GSON.fromJson(data, Dispute.class); + + assertNotNull(dispute); + assertNotNull(dispute.getId()); + assertEquals("issuing.dispute", dispute.getObject()); + + final Transaction transaction = dispute.getTransactionObject(); + assertNotNull(transaction); + assertNotNull(transaction.getId()); + assertEquals(dispute.getTransaction(), transaction.getId()); + } +} \ No newline at end of file diff --git a/src/test/java/com/stripe/model/issuing/TransactionTest.java b/src/test/java/com/stripe/model/issuing/TransactionTest.java new file mode 100644 index 00000000000..26e63deb748 --- /dev/null +++ b/src/test/java/com/stripe/model/issuing/TransactionTest.java @@ -0,0 +1,60 @@ +package com.stripe.model.issuing; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; + +import com.stripe.BaseStripeTest; +import com.stripe.model.BalanceTransaction; +import com.stripe.net.APIResource; + +import org.junit.Test; + +public class TransactionTest extends BaseStripeTest { + @Test + public void testDeserialize() throws Exception { + final String data = getFixture("/v1/issuing/transactions/ipi_123"); + final Transaction transaction = APIResource.GSON.fromJson(data, Transaction.class); + + assertNotNull(transaction); + assertNotNull(transaction.getId()); + assertEquals("issuing.transaction", transaction.getObject()); + } + + @Test + public void testDeserializeWithExpansions() throws Exception { + final String[] expansions = { + "authorization", + "balance_transaction", + "card", + "cardholder", + }; + final String data = getFixture("/v1/issuing/transactions/ipi_123", expansions); + final Transaction transaction = APIResource.GSON.fromJson(data, Transaction.class); + + assertNotNull(transaction); + assertNotNull(transaction.getId()); + assertEquals("issuing.transaction", transaction.getObject()); + assertEquals("issuing.card", transaction.getCardObject().getObject()); + + final Authorization authorization = transaction.getAuthorizationObject(); + assertNotNull(authorization); + assertNotNull(authorization.getId()); + assertEquals(transaction.getAuthorization(), authorization.getId()); + + final BalanceTransaction bt = transaction.getBalanceTransactionObject(); + assertNotNull(bt); + assertNotNull(bt.getId()); + assertEquals(transaction.getBalanceTransaction(), bt.getId()); + + final Card card = transaction.getCardObject(); + assertNotNull(card); + assertNotNull(card.getId()); + assertEquals(transaction.getCard(), card.getId()); + + final Cardholder cardholder = transaction.getCardholderObject(); + assertNotNull(cardholder); + assertNotNull(cardholder.getId()); + assertEquals(transaction.getCardholder(), cardholder.getId()); + } +} diff --git a/src/test/resources/api_fixtures/balance_transaction_collection_with_source_expansion.json b/src/test/resources/api_fixtures/balance_transaction_collection_with_source_expansion.json new file mode 100644 index 00000000000..ebcbf948b95 --- /dev/null +++ b/src/test/resources/api_fixtures/balance_transaction_collection_with_source_expansion.json @@ -0,0 +1,87 @@ +{ + "object": "list", + "url": "/v1/balance/history", + "data": [ + { + "id": "txn_100", + "object": "balance_transaction", + "source": { + "id": "fee_123", + "object": "application_fee" + } + }, + { + "id": "txn_101", + "object": "balance_transaction", + "source": { + "id": "ch_123", + "object": "charge" + } + }, + { + "id": "txn_102", + "object": "balance_transaction", + "source": { + "id": "dp_123", + "object": "dispute", + "evidence": null + } + }, + { + "id": "txn_103", + "object": "balance_transaction", + "source": { + "id": "po_123", + "object": "payout" + } + }, + { + "id": "txn_104", + "object": "balance_transaction", + "source": { + "id": "re_123", + "object": "refund" + } + }, + { + "id": "txn_105", + "object": "balance_transaction", + "source": { + "id": "tr_123", + "object": "transfer" + } + }, + { + "id": "txn_106", + "object": "balance_transaction", + "source": { + "id": "trr_123", + "object": "transfer_reversal" + } + }, + { + "id": "txn_107", + "object": "balance_transaction", + "source": { + "id": "tu_123", + "object": "topup" + } + }, + { + "id": "txn_108", + "object": "balance_transaction", + "source": { + "id": "iauth_123", + "object": "issuing.authorization" + } + }, + { + "id": "txn_109", + "object": "balance_transaction", + "source": { + "id": "ipi_123", + "object": "issuing.transaction" + } + } + ] +} diff --git a/src/test/resources/api_fixtures/issuing/card_details.json b/src/test/resources/api_fixtures/issuing/card_details.json new file mode 100644 index 00000000000..37a0352f102 --- /dev/null +++ b/src/test/resources/api_fixtures/issuing/card_details.json @@ -0,0 +1,63 @@ +{ + "object": "issuing.card_details", + "card": { + "id": "ic_123", + "object": "issuing.card", + "authorization_controls": { + "allowed_categories": null, + "blocked_categories": null, + "currency": "usd", + "max_amount": 10000, + "max_approvals": 1 + }, + "billing": { + "address": { + "city": "City", + "country": "US", + "line1": "line1", + "line2": "line2", + "postal_code": "90210", + "state": "CA" + } + }, + "brand": "Visa", + "cardholder": { + "id": "ich_123", + "object": "issuing.cardholder", + "billing": { + "address": { + "city": "City", + "country": "US", + "line1": "line1", + "line2": "line2", + "postal_code": "90210", + "state": "CA" + }, + "name": "Jenny Rosen" + }, + "created": 1528992903, + "email": "jenny@example.com", + "livemode": false, + "metadata": { + }, + "name": "Jenny Rosen", + "phone_number": "+15555555555", + "status": "active", + "type": "individual" + }, + "created": 1532016681, + "currency": "usd", + "exp_month": 2, + "exp_year": 2023, + "last4": "4242", + "livemode": false, + "metadata": { + }, + "name": "Jenny Rosen", + "shipping": null, + "status": "active", + "type": "physical" + }, + "cvc": "123", + "number": "4242424242424242" +} \ No newline at end of file