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 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 Iterable<InvoiceItem> apply(final Invoice input) { return Iterables.filter(input.getInvoiceItems(), new Predicate<InvoiceItem>() { @Override public boolean apply(final InvoiceItem input) { if (input.getInvoiceItemType() == InvoiceItemType.USAGE) { final Usage usage = knownUsage.get(input.getUsageName()); return usage != null && usage.getBillingMode() == BillingMode.IN_ARREAR; } return false; } }); } }));
private Set<UUID> getUniqueInvoiceIds(final Invoice invoice) { final Set<UUID> uniqueInvoiceIds = new TreeSet<UUID>(); uniqueInvoiceIds.addAll(Collections2.transform(invoice.getInvoiceItems(), new Function<InvoiceItem, UUID>() { @Nullable @Override public UUID apply(@Nullable final InvoiceItem input) { return input.getInvoiceId(); } })); return uniqueInvoiceIds; }
private void logInvoiceWithItems(final ImmutableAccountData account, final Invoice invoice, final LocalDate targetDate, final Set<UUID> adjustedUniqueOtherInvoiceId, final boolean isRealInvoiceWithItems) { final StringBuilder tmp = new StringBuilder(); if (isRealInvoiceWithItems) { tmp.append(String.format("Generated invoiceId='%s', numberOfItems='%d', accountId='%s', targetDate='%s':", invoice.getId(), invoice.getNumberOfItems(), account.getId(), targetDate)); } else { final String adjustedInvoices = JOINER_COMMA.join(adjustedUniqueOtherInvoiceId.toArray(new UUID[adjustedUniqueOtherInvoiceId.size()])); tmp.append(String.format("Adjusting existing invoiceId='%s', numberOfItems='%d', accountId='%s', targetDate='%s':\n", adjustedInvoices, invoice.getNumberOfItems(), account.getId(), targetDate)); } for (final InvoiceItem item : invoice.getInvoiceItems()) { tmp.append(String.format("\n\t item = %s", item)); } log.info(tmp.toString()); }
@Test(groups = "slow") public void testFullRefundWithBothInvoiceItemAdjustments() throws Exception { // Create an invoice with two items (30 \u20ac and 10 \u20ac) final Invoice invoice = createAndPersistInvoice(invoiceUtil, invoiceDao, clock, ImmutableList.<BigDecimal>of(THIRTY, BigDecimal.TEN), CURRENCY, internalCallContext); // Fully adjust both items final Map<UUID, BigDecimal> adjustments = new HashMap<UUID, BigDecimal>(); adjustments.put(invoice.getInvoiceItems().get(0).getId(), null); adjustments.put(invoice.getInvoiceItems().get(1).getId(), null); verifyRefund(invoice, new BigDecimal("40"), new BigDecimal("40"), BigDecimal.ZERO, true, adjustments); }
@Test(groups = "slow") public void testPartialRefundWithTwoInvoiceItemAdjustment() throws Exception { // Create an invoice with two items (30 \u20ac and 10 \u20ac) final Invoice invoice = createAndPersistInvoice(invoiceUtil, invoiceDao, clock, ImmutableList.<BigDecimal>of(THIRTY, BigDecimal.TEN), CURRENCY, internalCallContext); // Adjust partially both items: the invoice posted was 40 \u20ac, but we should really just have charged you 2 \u20ac final ImmutableMap<UUID, BigDecimal> adjustments = ImmutableMap.<UUID, BigDecimal>of(invoice.getInvoiceItems().get(0).getId(), new BigDecimal("29"), invoice.getInvoiceItems().get(1).getId(), new BigDecimal("9")); verifyRefund(invoice, new BigDecimal("40"), new BigDecimal("38"), BigDecimal.ZERO, true, adjustments); }
@Test(groups = "slow") public void testPartialRefundWithSingleInvoiceItemAdjustment() throws Exception { // Create an invoice with two items (30 \u20ac and 10 \u20ac) final Invoice invoice = createAndPersistInvoice(invoiceUtil, invoiceDao, clock, ImmutableList.<BigDecimal>of(THIRTY, BigDecimal.TEN), CURRENCY, internalCallContext); // Fully adjust both items final Map<UUID, BigDecimal> adjustments = new HashMap<UUID, BigDecimal>(); adjustments.put(invoice.getInvoiceItems().get(0).getId(), null); verifyRefund(invoice, new BigDecimal("40"), new BigDecimal("30"), BigDecimal.ZERO, true, adjustments); }
private void checkInvoiceDescriptions(final Invoice invoice) { for (final InvoiceItem invoiceItem : invoice.getInvoiceItems()) { assertEquals(invoiceItem.getDescription(), String.format("[plugin] %s", invoiceItem.getId())); } }
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; }
@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); }
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 = "fast") public void testZeroDollarEvents() throws InvoiceApiException, CatalogApiException { final Plan plan = new MockPlan(); final PlanPhase planPhase = createMockMonthlyPlanPhase(ZERO); final BillingEventSet events = new MockBillingEventSet(); final LocalDate targetDate = invoiceUtil.buildDate(2011, 1, 1); events.add(createBillingEvent(UUID.randomUUID(), UUID.randomUUID(), targetDate, plan, planPhase, 1)); final InvoiceWithMetadata invoiceWithMetadata = generator.generateInvoice(account, events, null, null, targetDate, Currency.USD, internalCallContext); final Invoice invoice = invoiceWithMetadata.getInvoice(); assertNotNull(invoice); assertEquals(invoice.getInvoiceItems().size(), 1); assertEquals(invoice.getInvoiceItems().get(0).getAmount().compareTo(BigDecimal.ZERO), 0); }
@Test(groups = "slow") public void testRefundWithInvoiceItemAdjustemts() throws Exception { final Map<UUID, BigDecimal> iias = new HashMap<UUID, BigDecimal>(); iias.put(invoice.getInvoiceItems().get(0).getId(), null); refundPaymentWithInvoiceItemAdjAndCheckForCompletion(account, payment, iias, NextEvent.PAYMENT, NextEvent.INVOICE_PAYMENT, NextEvent.INVOICE_ADJUSTMENT); refundChecker.checkRefund(payment.getId(), callContext, new ExpectedRefundCheck(payment.getId(), true, new BigDecimal("233.82"), Currency.USD, initialCreationDate.toLocalDate())); invoice = invoiceChecker.checkInvoice(account.getId(), invoiceItemCount++, callContext, new ExpectedInvoiceItemCheck(new LocalDate(2012, 3, 2), new LocalDate(2012, 3, 31), InvoiceItemType.RECURRING, new BigDecimal("233.82")), new ExpectedInvoiceItemCheck(InvoiceItemType.ITEM_ADJ, new BigDecimal("-233.82")) ); }
@Test(groups = "slow") public void testCantAdjustInvoiceItemWithNegativeAmount() throws Exception { final InvoiceItem invoiceItem = invoiceUserApi.getInvoice(invoiceId, callContext).getInvoiceItems().get(0); try { invoiceUserApi.insertInvoiceItemAdjustment(accountId, invoiceId, invoiceItem.getId(), clock.getUTCToday(), BigDecimal.TEN.negate(), accountCurrency, null, null, null, callContext); Assert.fail("Should not have been able to adjust an item with a negative amount"); } catch (InvoiceApiException e) { Assert.assertEquals(e.getCode(), ErrorCode.INVOICE_ITEM_ADJUSTMENT_AMOUNT_SHOULD_BE_POSITIVE.getCode()); } }
/** * ******************************************** INVOICE ******************************************************* */ public void checkInvoiceCreated(final Invoice invoice, final CallContext context) { final List<AuditLog> invoiceLogs = getAuditLogForInvoice(invoice, context); //Assert.assertEquals(invoiceLogs.size(), 1); checkAuditLog(ChangeType.INSERT, context, invoiceLogs.get(0), invoice.getId(), InvoiceSqlDao.class, false, false); for (InvoiceItem cur : invoice.getInvoiceItems()) { final List<AuditLog> auditLogs = getAuditLogForInvoiceItem(cur, context); Assert.assertTrue(auditLogs.size() >= 1); checkAuditLog(ChangeType.INSERT, context, auditLogs.get(0), cur.getId(), InvoiceItemSqlDao.class, false, false); } }
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);
@Override public Object clone() { InvoiceModelDao parentInvoiceModelDao = (parentInvoice != null) ? new InvoiceModelDao(parentInvoice) : null; final Invoice clonedInvoice = new DefaultInvoice(getId(), getCreatedDate(), getAccountId(), getInvoiceNumber(), getInvoiceDate(), getTargetDate(), getCurrency(), getProcessedCurrency(), isMigrationInvoice(), isWrittenOff(), getStatus(), isParentInvoice(), parentInvoiceModelDao); clonedInvoice.getInvoiceItems().addAll(getInvoiceItems()); clonedInvoice.getPayments().addAll(getPayments()); return clonedInvoice; }
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(); }