public Invoice createInvoice(final LocalDate date, final BigDecimal balance, final List<InvoiceItem> invoiceItems) { final Invoice invoice = Mockito.mock(Invoice.class); Mockito.when(invoice.getBalance()).thenReturn(balance); Mockito.when(invoice.getInvoiceDate()).thenReturn(date); Mockito.when(invoice.getInvoiceItems()).thenReturn(invoiceItems); Mockito.when(invoice.getId()).thenReturn(UUID.randomUUID()); return invoice; }
public BillingState calculateBillingState(final ImmutableAccountData account, final InternalCallContext context) throws OverdueException { final SortedSet<Invoice> unpaidInvoices = unpaidInvoicesForAccount(account.getId(), context); final int numberOfUnpaidInvoices = unpaidInvoices.size(); final BigDecimal unpaidInvoiceBalance = sumBalance(unpaidInvoices); LocalDate dateOfEarliestUnpaidInvoice = null; UUID idOfEarliestUnpaidInvoice = null; final Invoice invoice = earliest(unpaidInvoices); if (invoice != null) { dateOfEarliestUnpaidInvoice = invoice.getInvoiceDate(); idOfEarliestUnpaidInvoice = invoice.getId(); } final PaymentResponse responseForLastFailedPayment = PaymentResponse.INSUFFICIENT_FUNDS; //TODO MDW final List<Tag> accountTags = tagApi.getTags(account.getId(), ObjectType.ACCOUNT, context); final Tag[] tags = accountTags.toArray(new Tag[accountTags.size()]); return new BillingState(account.getId(), numberOfUnpaidInvoices, unpaidInvoiceBalance, dateOfEarliestUnpaidInvoice, idOfEarliestUnpaidInvoice, responseForLastFailedPayment, tags); }
public Account createAccount(final LocalDate dateOfLastUnPaidInvoice) throws SubscriptionBaseApiException, AccountApiException { final UUID accountId = UUID.randomUUID(); final Account account = Mockito.mock(Account.class); Mockito.when(account.getId()).thenReturn(accountId); Mockito.when(account.getTimeZone()).thenReturn(DateTimeZone.UTC); Mockito.when(accountInternalApi.getAccountById(Mockito.eq(account.getId()), Mockito.<InternalTenantContext>any())).thenReturn(account); final Invoice invoice = Mockito.mock(Invoice.class); Mockito.when(invoice.getInvoiceDate()).thenReturn(dateOfLastUnPaidInvoice); Mockito.when(invoice.getBalance()).thenReturn(BigDecimal.TEN); Mockito.when(invoice.getStatus()).thenReturn(InvoiceStatus.COMMITTED); Mockito.when(invoice.getId()).thenReturn(UUID.randomUUID()); final InvoiceItem item = Mockito.mock(InvoiceItem.class); final List<InvoiceItem> items = new ArrayList<InvoiceItem>(); items.add(item); Mockito.when(invoice.getInvoiceItems()).thenReturn(items); final List<Invoice> invoices = new ArrayList<Invoice>(); invoices.add(invoice); Mockito.when(invoiceInternalApi.getUnpaidInvoicesByAccountId(Mockito.<UUID>any(), Mockito.<LocalDate>any(), Mockito.<InternalTenantContext>any())).thenReturn(invoices); final Tag tag = Mockito.mock(Tag.class); Mockito.when(tag.getObjectId()).thenReturn(accountId); Mockito.when(tag.getObjectType()).thenReturn(ObjectType.ACCOUNT); Mockito.when(tag.getTagDefinitionId()).thenReturn(ControlTagType.TEST.getId()); final List<Tag> tags = new ArrayList<Tag>(); tags.add(tag); Mockito.when(tagInternalApi.getTags(Mockito.eq(account.getId()), Mockito.eq(ObjectType.ACCOUNT), Mockito.<InternalTenantContext>any())) .thenReturn(tags); return account; }
@Override public boolean apply(final Invoice input) { return input.getId().equals(targetInvoiceId); } }).orNull();
Map<Long, String> map = new HashMap<Long, String>(); for(Invoice invoice : invoces) { map.put(invoice.getId(), invoce.getName()); }
@Override public InvoicePaymentJson apply(final Payment input) { return new InvoicePaymentJson(input, invoice.getId(), null); } }));
Invoice invEntity = em.find(Invoice.class, id); InvoiceDTO invDTO = new InvoiceDTO(); invDTO.setId(invEntity.getId()); invDTO.setDate(invEntity.Date()); return invDTO;
private void canInvoiceBeVoided(final Invoice invoice) throws InvoiceApiException { final List<InvoicePayment> invoicePayments = invoice.getPayments(); final BigDecimal amountPaid = InvoiceCalculatorUtils.computeInvoiceAmountPaid(invoice.getCurrency(), invoicePayments) .add(InvoiceCalculatorUtils.computeInvoiceAmountRefunded(invoice.getCurrency(), invoicePayments)); if (amountPaid.compareTo(BigDecimal.ZERO) != 0) { throw new InvoiceApiException(ErrorCode.CAN_NOT_VOID_INVOICE_THAT_IS_PAID, invoice.getId().toString()); } } }
@Test(groups = "slow") public void testUserApiAccess() { final List<Invoice> byAccount = invoiceUserApi.getInvoicesByAccount(accountId, false, false, callContext); Assert.assertEquals(byAccount.size(), 1); Assert.assertEquals(byAccount.get(0).getId(), regularInvoiceId); final List<Invoice> byAccountAndDate = invoiceUserApi.getInvoicesByAccount(accountId, date_migrated.minusDays(1), false, callContext); Assert.assertEquals(byAccountAndDate.size(), 1); Assert.assertEquals(byAccountAndDate.get(0).getId(), regularInvoiceId); final Collection<Invoice> unpaid = invoiceUserApi.getUnpaidInvoicesByAccountId(accountId, new LocalDate(date_regular.plusDays(1)), callContext); Assert.assertEquals(unpaid.size(), 1); Assert.assertEquals(unpaid.iterator().next().getId(), regularInvoiceId); }
public Invoice checkInvoice(final UUID accountId, final int invoiceOrderingNumber, final CallContext context, final List<ExpectedInvoiceItemCheck> expected) throws InvoiceApiException { final List<Invoice> invoices = invoiceUserApi.getInvoicesByAccount(accountId, false, false, context); //Assert.assertEquals(invoices.size(), invoiceOrderingNumber); final Invoice invoice = invoices.get(invoiceOrderingNumber - 1); checkInvoice(invoice.getId(), context, expected); return invoice; }
public static Invoice buildInvoice(final Account account) { final Invoice invoice = Mockito.mock(Invoice.class); Mockito.when(invoice.getId()).thenReturn(UUID.randomUUID()); // To work-around org.mockito.exceptions.misusing.UnfinishedStubbingException final UUID accountId = account.getId(); final Currency currency = account.getCurrency(); Mockito.when(invoice.getAccountId()).thenReturn(accountId); Mockito.when(invoice.getInvoiceDate()).thenReturn(new LocalDate()); Mockito.when(invoice.getCurrency()).thenReturn(currency); Mockito.when(invoice.getInvoiceItems()).thenReturn(new LinkedList<InvoiceItem>()); return invoice; }
@Test(groups = "slow") public void testAccountBalanceWithNoInvoiceItems() throws EntityPersistenceException { final UUID accountId = account.getId(); final LocalDate targetDate1 = new LocalDate(2011, 10, 6); final Invoice invoice1 = new DefaultInvoice(accountId, clock.getUTCToday(), targetDate1, Currency.USD); invoiceUtil.createInvoice(invoice1, context); final BigDecimal payment1 = new BigDecimal("48.0"); final InvoicePayment payment = new DefaultInvoicePayment(InvoicePaymentType.ATTEMPT, UUID.randomUUID(), invoice1.getId(), new DateTime(), payment1, Currency.USD, Currency.USD, null, true); invoiceUtil.createPayment(payment, context); final BigDecimal balance = invoiceDao.getAccountBalance(accountId, context); assertEquals(balance.compareTo(BigDecimal.ZERO.subtract(payment1)), 0); }
private void printDetailInvoice(final Invoice invoice) { log.info("-------------------- START DETAIL ----------------------"); log.info("Invoice " + invoice.getId() + ": BALANCE = " + invoice.getBalance() + ", CBA = " + invoice.getCreditedAmount() + ", CHARGE_AMOUNT = " + invoice.getChargedAmount() + ", ADJ_AMOUNT = " + invoice.getCreditedAmount()); for (final InvoiceItem cur : invoice.getInvoiceItems()) { log.info(cur.toString()); } log.info("-------------------- END DETAIL ----------------------"); } }
@Test(groups = "slow") public void testRefundWithNoAdjustments() throws Exception { // Although we don't adjust the invoice, the invoicing system sends an event because invoice balance changes and overdue system-- in particular-- needs to know about it. refundPaymentAndCheckForCompletion(account, payment, NextEvent.PAYMENT, NextEvent.INVOICE_PAYMENT); refundChecker.checkRefund(payment.getId(), callContext, new ExpectedRefundCheck(payment.getId(), false, new BigDecimal("233.82"), Currency.USD, initialCreationDate.toLocalDate())); final Invoice invoiceRefreshed = invoiceUserApi.getInvoice(invoice.getId(), callContext); assertTrue(invoiceRefreshed.getBalance().compareTo(new BigDecimal("233.82")) == 0); final BigDecimal accountBalance = invoiceUserApi.getAccountBalance(account.getId(), callContext); assertTrue(accountBalance.compareTo(new BigDecimal("233.82")) == 0); }
public void checkInvoicesEqual(final InvoiceModelDao retrievedInvoice, final Invoice invoice) { Assert.assertEquals(retrievedInvoice.getId(), invoice.getId()); Assert.assertEquals(retrievedInvoice.getAccountId(), invoice.getAccountId()); Assert.assertEquals(retrievedInvoice.getCurrency(), invoice.getCurrency()); Assert.assertEquals(retrievedInvoice.getInvoiceDate(), invoice.getInvoiceDate()); Assert.assertEquals(retrievedInvoice.getTargetDate(), invoice.getTargetDate()); Assert.assertEquals(retrievedInvoice.getInvoiceItems().size(), invoice.getInvoiceItems().size()); Assert.assertEquals(retrievedInvoice.getInvoicePayments().size(), invoice.getPayments().size()); }
@Override public Void apply(@Nullable final Void input) { try { invoiceUserApi.insertInvoiceItemAdjustment(account.getId(), invoice.getId(), invoice.getInvoiceItems().get(itemNb - 1).getId(), invoice.getInvoiceDate(), null, null, null, callContext); } catch (final InvoiceApiException e) { fail(e.toString()); } return null; } }, events);
@BeforeMethod(groups = "fast") public void setUp() throws Exception { account = TestUtils.buildAccount(Currency.BTC, "US"); invoice1 = TestUtils.buildInvoice(account); invoice1TaxableItem = TestUtils.buildInvoiceItem(invoice1, InvoiceItemType.EXTERNAL_CHARGE, BigDecimal.TEN, null); invoice1TaxItem = PluginInvoiceItem.createTaxItem(invoice1TaxableItem, invoice1.getId(), invoice1TaxableItem.getStartDate(), null, BigDecimal.ONE, "TestNG tax"); invoice1.getInvoiceItems().add(invoice1TaxableItem); invoice1.getInvoiceItems().add(invoice1TaxItem); }
public InvoiceJson(final Invoice input, final String bundleKeys, final List<CreditJson> credits, final List<AuditLog> auditLogs) { this(input.getChargedAmount(), input.getCurrency(), input.getStatus(), input.getCreditedAmount(), input.getRefundedAmount(), input.getId(), input.getInvoiceDate(), input.getTargetDate(), String.valueOf(input.getInvoiceNumber()), input.getBalance(), input.getAccountId(), bundleKeys, credits, null, input.isParentInvoice(), input.getParentInvoiceId(), input.getParentAccountId(), toAuditLogJson(auditLogs)); }
private void insertInvoiceItemAdjustmentToChildInvoice(final Account childAccount, final Invoice childInvoice, BigDecimal amount) throws InvoiceApiException { busHandler.pushExpectedEvents(NextEvent.INVOICE_ADJUSTMENT, NextEvent.INVOICE_ADJUSTMENT); invoiceUserApi.insertInvoiceItemAdjustment(childAccount.getId(), childInvoice.getId(), childInvoice.getInvoiceItems().get(0).getId(), clock.getToday(childAccount.getTimeZone()), amount, childAccount.getCurrency(), "test adjustment", null, null, callContext); assertListenerStatus(); }
@Test(groups = "slow") public void testSimple() throws Exception { final UUID accountId = account.getId(); final Invoice invoice = new DefaultInvoice(accountId, clock.getUTCToday(), clock.getUTCToday(), Currency.USD); invoiceUtil.createInvoice(invoice, context); final InvoiceModelDao retrievedInvoice = invoiceDao.getById(invoice.getId(), context); invoiceUtil.checkInvoicesEqual(retrievedInvoice, invoice); invoiceUtil.checkInvoicesEqual(invoiceDao.getByNumber(retrievedInvoice.getInvoiceNumber(), context), invoice); }