/**
* Tries to create payment against review invoice. Here, instead of using the billing process to
* generate a review invoice we are creating a review invoice with the help of saveLegacyInvoice
* call.
*/
@Test
public void testPayReviewInvoice() {
// creating new user
UserWS user = buildUser(PRANCING_PONY_ACCOUNT_TYPE);
user.setId(api.createUser(user));
ItemTypeWS itemType = buildItemType();
itemType.setId(api.createItemCategory(itemType));
ItemDTOEx item = buildItem(itemType.getId(), api.getCallerCompanyId());
item.setId(api.createItem(item));
InvoiceWS invoice = buildInvoice(user.getId(), item.getId());
invoice.setIsReview(Integer.valueOf(1));
invoice.setId(api.saveLegacyInvoice(invoice));
// check if invoice is a review invoice
System.out.println("Invoice is review : " + invoice.getIsReview());
assertEquals("Invoice is a review invoice", Integer.valueOf(1), invoice.getIsReview());
try {
// pay for a review invoice
api.payInvoice(invoice.getId());
fail("We should not be able to issue a payment against review invoice");
} catch (SessionInternalError e) {
System.out.println(e.getMessage());
}
// clean up
api.deleteInvoice(invoice.getId());
api.deleteItem(item.getId());
api.deleteItemCategory(itemType.getId());
api.deleteUser(user.getId());
}
/** Test payInvoice(invoice) API call. */
@Test
public void testPayInvoice() {
// setup
UserWS user = buildUser(PRANCING_PONY_ACCOUNT_TYPE);
user.setId(api.createUser(user));
ItemTypeWS itemType = buildItemType();
itemType.setId(api.createItemCategory(itemType));
ItemDTOEx item = buildItem(itemType.getId(), api.getCallerCompanyId());
item.setId(api.createItem(item));
// testing
System.out.println("Getting an invoice paid, and validating the payment.");
OrderWS order = buildOrder(user.getId(), Arrays.asList(item.getId()), new BigDecimal("3.45"));
Integer invoiceId =
api.createOrderAndInvoice(
order, OrderChangeBL.buildFromOrder(order, ORDER_CHANGE_STATUS_APPLY));
Integer orderId = api.getInvoiceWS(invoiceId).getOrders()[0];
PaymentAuthorizationDTOEx auth = api.payInvoice(invoiceId);
assertNotNull("auth can not be null", auth);
PaymentWS payment = api.getLatestPayment(user.getId());
assertNotNull("payment can not be null", payment);
assertNotNull("auth in payment can not be null", payment.getAuthorizationId());
// cleanup
api.deletePayment(auth.getPaymentId());
api.deleteInvoice(invoiceId);
api.deleteOrder(orderId);
api.deleteItem(item.getId());
api.deleteItemCategory(itemType.getId());
api.deleteUser(user.getId());
}
/** Removing pre-authorization when the CC number is changed. */
@Test
public void testRemoveOnCCChange() {
UserWS user = buildUser(PRANCING_PONY_ACCOUNT_TYPE);
user.setId(api.createUser(user));
ItemTypeWS itemType = buildItemType();
itemType.setId(api.createItemCategory(itemType));
ItemDTOEx item = buildItem(itemType.getId(), api.getCallerCompanyId());
item.setId(api.createItem(item));
// put a pre-auth record on this user
OrderWS order = buildOrder(user.getId(), Arrays.asList(item.getId()), new BigDecimal("3.45"));
PaymentAuthorizationDTOEx auth =
api.createOrderPreAuthorize(
order, OrderChangeBL.buildFromOrder(order, ORDER_CHANGE_STATUS_APPLY));
Integer orderId = api.getLatestOrder(user.getId()).getId();
PaymentWS preAuthPayment = api.getPayment(auth.getPaymentId());
assertThat(preAuthPayment, is(not(nullValue())));
assertThat(preAuthPayment.getIsPreauth(), is(1));
assertThat(preAuthPayment.getDeleted(), is(0)); // NOT deleted
// update the user's credit card, this should remove the old card
// and delete any associated pre-authorizations
DateTimeFormatter format = DateTimeFormat.forPattern(Constants.CC_DATE_FORMAT);
user = api.getUserWS(user.getId());
com.sapienter.jbilling.server.user.WSTest.updateMetaField(
user.getPaymentInstruments().iterator().next().getMetaFields(),
PaymentMethodHelper.CC_MF_EXPIRY_DATE,
format.print(new DateMidnight().plusYears(4).withDayOfMonth(1).toDate().getTime()));
api.updateUser(user);
System.out.println("User instruments are: " + user.getPaymentInstruments());
// validate that the pre-auth payment is no longer available
preAuthPayment = api.getPayment(auth.getPaymentId());
assertThat(preAuthPayment, is(not(nullValue())));
assertThat(preAuthPayment.getIsPreauth(), is(1));
assertThat(preAuthPayment.getDeleted(), is(1)); // is now deleted
// cleanup
api.deleteOrder(orderId);
api.deleteItem(item.getId());
api.deleteItemCategory(itemType.getId());
api.deleteUser(user.getId());
}
/**
* Test for: CreditCardFilter.For now it uses a value already in DB for the blacklisted cc number.
* In prepare-test db the cc number 5555555555554444 is blacklisted.
*/
@Test
public void testBlacklistCreditCardFilter() {
UserWS user = buildUser(PRANCING_PONY_ACCOUNT_TYPE, "5555555555554444");
user.setId(api.createUser(user));
ItemTypeWS itemType = buildItemType();
itemType.setId(api.createItemCategory(itemType));
ItemDTOEx item = buildItem(itemType.getId(), api.getCallerCompanyId());
item.setId(api.createItem(item));
InvoiceWS invoice = buildInvoice(user.getId(), item.getId());
invoice.setId(api.saveLegacyInvoice(invoice));
// get invoice id
invoice = api.getLatestInvoice(user.getId());
assertNotNull("Couldn't get last invoice", invoice);
Integer invoiceId = invoice.getId();
assertNotNull("Invoice id was null", invoiceId);
// try paying the invoice
System.out.println("Trying to pay invoice for blacklisted user ...");
PaymentAuthorizationDTOEx authInfo = api.payInvoice(invoiceId);
assertNotNull("Payment result empty", authInfo);
// check that it was failed by the test blacklist filter
assertFalse(
"Payment wasn't failed for user: "******"Processor response", "Credit card number is blacklisted.", authInfo.getResponseMessage());
// cleanup
api.deleteInvoice(invoiceId);
api.deleteItem(item.getId());
api.deleteItemCategory(itemType.getId());
api.deleteUser(user.getId());
}
/** Tests processPayment API call. */
@Test
public void testProcessPayment() {
// setup
UserWS user = buildUser(PRANCING_PONY_ACCOUNT_TYPE, "4111111111111111");
user.setId(api.createUser(user));
ItemTypeWS itemType = buildItemType();
itemType.setId(api.createItemCategory(itemType));
ItemDTOEx item = buildItem(itemType.getId(), api.getCallerCompanyId());
item.setId(api.createItem(item));
// first, create two unpaid invoices
OrderWS order = buildOrder(user.getId(), Arrays.asList(item.getId()), new BigDecimal("10.00"));
Integer invoiceId1 =
api.createOrderAndInvoice(
order, OrderChangeBL.buildFromOrder(order, ORDER_CHANGE_STATUS_APPLY));
Integer invoiceId2 =
api.createOrderAndInvoice(
order, OrderChangeBL.buildFromOrder(order, ORDER_CHANGE_STATUS_APPLY));
// create the payment
PaymentWS payment = new PaymentWS();
payment.setAmount(new BigDecimal("5.00"));
payment.setIsRefund(new Integer(0));
payment.setMethodId(Constants.PAYMENT_METHOD_VISA);
payment.setPaymentDate(Calendar.getInstance().getTime());
payment.setCurrencyId(CURRENCY_USD);
payment.setUserId(user.getId());
// try a credit card number that fails
// note that creating a payment with a NEW credit card will save it and associate
// it with the user who made the payment.
Calendar cal = Calendar.getInstance();
cal.add(Calendar.YEAR, 5);
PaymentInformationWS cc =
PaymentMethodHelper.createCreditCard(
CC_PAYMENT_TYPE, "Frodo Baggins", "4111111111111111", cal.getTime());
cc.setPaymentMethodId(Constants.PAYMENT_METHOD_VISA);
payment.getPaymentInstruments().add(cc);
System.out.println("processing payment.");
PaymentAuthorizationDTOEx authInfo = api.processPayment(payment, null);
// check payment failed
assertNotNull("Payment result not null", authInfo);
assertFalse(
"Payment Authorization result should be FAILED", authInfo.getResult().booleanValue());
// check payment has zero balance
PaymentWS lastPayment = api.getLatestPayment(user.getId());
assertNotNull("payment can not be null", lastPayment);
assertNotNull("auth in payment can not be null", lastPayment.getAuthorizationId());
assertEquals("correct payment amount", new BigDecimal("5"), lastPayment.getAmountAsDecimal());
assertEquals("correct payment balance", BigDecimal.ZERO, lastPayment.getBalanceAsDecimal());
// check invoices still have balance
InvoiceWS invoice1 = api.getInvoiceWS(invoiceId1);
assertEquals("correct invoice balance", new BigDecimal("10.0"), invoice1.getBalanceAsDecimal());
InvoiceWS invoice2 = api.getInvoiceWS(invoiceId1);
assertEquals("correct invoice balance", new BigDecimal("10.0"), invoice2.getBalanceAsDecimal());
// do it again, but using the credit card on file
// which is also 4111111111111111
payment.getPaymentInstruments().clear();
System.out.println("processing payment.");
authInfo = api.processPayment(payment, null);
// check payment has zero balance
PaymentWS lastPayment2 = api.getLatestPayment(user.getId());
assertNotNull("payment can not be null", lastPayment2);
assertNotNull("auth in payment can not be null", lastPayment2.getAuthorizationId());
assertEquals("correct payment amount", new BigDecimal("5"), lastPayment2.getAmountAsDecimal());
assertEquals("correct payment balance", BigDecimal.ZERO, lastPayment2.getBalanceAsDecimal());
assertFalse("Payment is not the same as preiouvs", lastPayment2.getId() == lastPayment.getId());
// check invoices still have balance
invoice1 = api.getInvoiceWS(invoiceId1);
assertEquals("correct invoice balance", new BigDecimal("10"), invoice1.getBalanceAsDecimal());
invoice2 = api.getInvoiceWS(invoiceId1);
assertEquals("correct invoice balance", new BigDecimal("10"), invoice2.getBalanceAsDecimal());
// do a successful payment of $5
cc =
PaymentMethodHelper.createCreditCard(
CC_PAYMENT_TYPE, "Frodo Baggins", "4111111111111152", cal.getTime());
cc.setPaymentMethodId(Constants.PAYMENT_METHOD_VISA);
payment.getPaymentInstruments().add(cc);
System.out.println("processing payment.");
authInfo = api.processPayment(payment, null);
// check payment successful
assertNotNull("Payment result not null", authInfo);
assertNotNull("Auth id not null", authInfo.getId());
assertTrue("Payment Authorization result should be OK", authInfo.getResult().booleanValue());
// check payment was made
lastPayment = api.getLatestPayment(user.getId());
assertNotNull("payment can not be null", lastPayment);
assertNotNull("auth in payment can not be null", lastPayment.getAuthorizationId());
assertEquals("payment ids match", lastPayment.getId(), authInfo.getPaymentId().intValue());
assertEquals("correct payment amount", new BigDecimal("5"), lastPayment.getAmountAsDecimal());
assertEquals("correct payment balance", BigDecimal.ZERO, lastPayment.getBalanceAsDecimal());
// check invoice 1 was partially paid (balance 5)
invoice1 = api.getInvoiceWS(invoiceId1);
assertEquals("correct invoice balance", new BigDecimal("5.0"), invoice1.getBalanceAsDecimal());
// check invoice 2 wan't paid at all
invoice2 = api.getInvoiceWS(invoiceId2);
assertEquals("correct invoice balance", new BigDecimal("10.0"), invoice2.getBalanceAsDecimal());
// another payment for $10, this time with the user's credit card
// update the credit card to the one that is good
user = api.getUserWS(user.getId());
com.sapienter.jbilling.server.user.WSTest.updateMetaField(
user.getPaymentInstruments().iterator().next().getMetaFields(),
PaymentMethodHelper.CC_MF_NUMBER,
"4111111111111152");
api.updateUser(user);
// process a payment without an attached credit card
// should try and use the user's saved credit card
payment.getPaymentInstruments().clear();
payment.setAmount(new BigDecimal("10.00"));
System.out.println("processing payment.");
authInfo = api.processPayment(payment, null);
// check payment successful
assertNotNull("Payment result not null", authInfo);
assertTrue("Payment Authorization result should be OK", authInfo.getResult().booleanValue());
// check payment was made
lastPayment = api.getLatestPayment(user.getId());
assertNotNull("payment can not be null", lastPayment);
assertNotNull("auth in payment can not be null", lastPayment.getAuthorizationId());
assertEquals("correct payment amount", new BigDecimal("10"), lastPayment.getAmountAsDecimal());
assertEquals("correct payment balance", BigDecimal.ZERO, lastPayment.getBalanceAsDecimal());
// check invoice 1 is fully paid (balance 0)
invoice1 = api.getInvoiceWS(invoiceId1);
assertEquals("correct invoice balance", BigDecimal.ZERO, invoice1.getBalanceAsDecimal());
// check invoice 2 was partially paid (balance 5)
invoice2 = api.getInvoiceWS(invoiceId2);
assertEquals("correct invoice balance", new BigDecimal("5"), invoice2.getBalanceAsDecimal());
// another payment for $10
payment.getPaymentInstruments().add(cc);
payment.setAmount(new BigDecimal("10.00"));
System.out.println("processing payment.");
authInfo = api.processPayment(payment, null);
// check payment successful
assertNotNull("Payment result not null", authInfo);
assertTrue("Payment Authorization result should be OK", authInfo.getResult().booleanValue());
// check payment was made
lastPayment = api.getLatestPayment(user.getId());
assertNotNull("payment can not be null", lastPayment);
assertNotNull("auth in payment can not be null", lastPayment.getAuthorizationId());
assertEquals("correct payment amount", new BigDecimal("10"), lastPayment.getAmountAsDecimal());
assertEquals(
"correct payment balance", new BigDecimal("5"), lastPayment.getBalanceAsDecimal());
// check invoice 1 balance is unchanged
invoice1 = api.getInvoiceWS(invoiceId1);
assertEquals("correct invoice balance", BigDecimal.ZERO, invoice1.getBalanceAsDecimal());
// check invoice 2 is fully paid (balance 0)
invoice2 = api.getInvoiceWS(invoiceId2);
assertEquals("correct invoice balance", BigDecimal.ZERO, invoice2.getBalanceAsDecimal());
// cleanup
System.out.println("Deleting invoices and orders.");
api.deleteInvoice(invoice1.getId());
api.deleteInvoice(invoice2.getId());
api.deleteOrder(invoice1.getOrders()[0]);
api.deleteOrder(invoice2.getOrders()[0]);
api.deleteItem(item.getId());
api.deleteItemCategory(itemType.getId());
api.deleteUser(user.getId());
}
/** Tests the PaymentRouterCurrencyTask. */
@Test
public void testPaymentRouterCurrencyTask() {
// prepare
UserWS userUSD = buildUser(PRANCING_PONY_ACCOUNT_TYPE);
userUSD.setCurrencyId(CURRENCY_USD);
userUSD.setId(api.createUser(userUSD));
UserWS userAUD = buildUser(PRANCING_PONY_ACCOUNT_TYPE);
userAUD.setCurrencyId(CURRENCY_AUD);
userAUD.setId(api.createUser(userAUD));
ItemTypeWS itemType = buildItemType();
itemType.setId(api.createItemCategory(itemType));
ItemDTOEx item = buildItem(itemType.getId(), api.getCallerCompanyId());
item.setId(api.createItem(item));
// testing
OrderWS order = buildOrder(userUSD.getId(), Arrays.asList(item.getId()), new BigDecimal("10"));
order.setCurrencyId(userUSD.getCurrencyId());
// create the order and invoice it
System.out.println("Creating and invoicing order ...");
Integer invoiceIdUSD =
api.createOrderAndInvoice(
order, OrderChangeBL.buildFromOrder(order, ORDER_CHANGE_STATUS_APPLY));
Integer orderIdUSD = api.getLastOrders(userUSD.getId(), 1)[0];
// try paying the invoice in USD
System.out.println("Making payment in USD...");
PaymentAuthorizationDTOEx authInfo = api.payInvoice(invoiceIdUSD);
assertTrue("USD Payment should be successful", authInfo.getResult().booleanValue());
assertEquals(
"Should be processed by 'first_fake_processor'",
authInfo.getProcessor(),
"first_fake_processor");
// create a new order in AUD and invoice it
order.setUserId(userAUD.getId());
order.setCurrencyId(userAUD.getCurrencyId());
System.out.println("Creating and invoicing order ...");
Integer invoiceIdAUD =
api.createOrderAndInvoice(
order, OrderChangeBL.buildFromOrder(order, ORDER_CHANGE_STATUS_APPLY));
Integer orderIdAUD = api.getLastOrders(userAUD.getId(), 1)[0];
// try paying the invoice in AUD
System.out.println("Making payment in AUD...");
authInfo = api.payInvoice(invoiceIdAUD);
assertTrue("AUD Payment should be successful", authInfo.getResult().booleanValue());
assertEquals(
"Should be processed by 'second_fake_processor'",
authInfo.getProcessor(),
"second_fake_processor");
// remove invoices and orders
System.out.println("Deleting invoices and orders.");
api.deleteInvoice(invoiceIdUSD);
api.deleteInvoice(invoiceIdAUD);
api.deleteOrder(orderIdUSD);
api.deleteOrder(orderIdAUD);
api.deleteUser(userUSD.getId());
api.deleteUser(userAUD.getId());
api.deleteItem(item.getId());
api.deleteItemCategory(itemType.getId());
}