@Test(groups = "fast", description = "Verify Mockito setup in GuicyKillbillTestSuite") public void testSpy() { clock.setDay(new LocalDate("2012-08-01")); Assert.assertEquals(clock.getUTCToday().toString(), "2012-08-01"); Assert.assertEquals(theRealClock.getUTCToday().toString(), "2012-08-01"); clock.addMonths(1); Assert.assertEquals(clock.getUTCToday().toString(), "2012-09-01"); Assert.assertEquals(theRealClock.getUTCToday().toString(), "2012-09-01"); clock.addDays(30); Assert.assertEquals(clock.getUTCToday().toString(), "2012-10-01"); Assert.assertEquals(theRealClock.getUTCToday().toString(), "2012-10-01"); } }
@Test(groups = "slow") public void testCreateSubscriptionInTheFuture() throws SubscriptionBaseApiException { final LocalDate init = clock.getUTCToday(); final String productName = "Shotgun"; final BillingPeriod term = BillingPeriod.MONTHLY; final String planSetName = PriceListSet.DEFAULT_PRICELIST_NAME; final LocalDate futureCreationDate = init.plusDays(10); DefaultSubscriptionBase subscription = testUtil.createSubscription(bundle, productName, term, planSetName, futureCreationDate); assertListenerStatus(); assertNotNull(subscription); assertEquals(subscription.getState(), EntitlementState.PENDING); testListener.pushExpectedEvent(NextEvent.CREATE); clock.addDays(10); assertListenerStatus(); subscription = (DefaultSubscriptionBase) subscriptionInternalApi.getSubscriptionFromId(subscription.getId(), internalCallContext); assertEquals(subscription.getState(), EntitlementState.ACTIVE); }
@Test(groups = "slow") public void testWrapperNoConfig() throws Exception { final Account account; final OverdueWrapper wrapper; final OverdueState state; final InputStream is = new ByteArrayInputStream(testOverdueHelper.getConfigXml().getBytes()); final DefaultOverdueConfig config = XMLLoader.getObjectFromStreamNoValidation(is, DefaultOverdueConfig.class); state = config.getOverdueStatesAccount().findState(OverdueWrapper.CLEAR_STATE_NAME); account = testOverdueHelper.createAccount(clock.getUTCToday().minusDays(31)); wrapper = overdueWrapperFactory.createOverdueWrapperFor(account, internalCallContext); final OverdueState result = wrapper.refresh(clock.getUTCNow(), internalCallContext); Assert.assertEquals(result.getName(), state.getName()); Assert.assertEquals(result.isBlockChanges(), state.isBlockChanges()); Assert.assertEquals(result.isDisableEntitlementAndChangesBlocked(), state.isDisableEntitlementAndChangesBlocked()); } }
@Test(groups = "slow") public void testCreateWithRequestedDate() throws SubscriptionBaseApiException { final LocalDate init = clock.getUTCToday(); final LocalDate requestedDate = init.minusYears(1); final String productName = "Shotgun"; final BillingPeriod term = BillingPeriod.MONTHLY; final String planSetName = PriceListSet.DEFAULT_PRICELIST_NAME; testListener.pushExpectedEvent(NextEvent.PHASE); final DefaultSubscriptionBase subscription = testUtil.createSubscription(bundle, productName, term, planSetName, requestedDate); assertNotNull(subscription); // // In addition to Alignment phase we also test SubscriptionBaseTransition eventIds and created dates. // Keep tracks of row events to compare with ids and created dates returned by SubscriptionBaseTransition later. // final List<SubscriptionBaseEvent> events = subscription.getEvents(); Assert.assertEquals(events.size(), 2); final SubscriptionBaseEvent trialEvent = events.get(0); final SubscriptionBaseEvent phaseEvent = events.get(1); assertEquals(subscription.getBundleExternalKey(), bundle.getExternalKey()); assertEquals(subscription.getStartDate().compareTo(requestedDate.toDateTime(accountData.getReferenceTime())), 0); assertListenerStatus(); final SubscriptionBaseTransition transition = subscription.getPreviousTransition(); assertEquals(transition.getPreviousEventId(), trialEvent.getId()); assertEquals(transition.getNextEventId(), phaseEvent.getId()); assertEquals(transition.getPreviousEventCreatedDate().compareTo(trialEvent.getCreatedDate()), 0); assertEquals(transition.getNextEventCreatedDate().compareTo(phaseEvent.getCreatedDate()), 0); }
@Test(groups = "slow") public void testCreateBundlesWithSameExternalKeys() throws SubscriptionBaseApiException { final LocalDate init = clock.getUTCToday(); final LocalDate requestedDate = init.minusYears(1);
@Test(groups = "slow") public void testCancelPlanOnPendingSubscription3() throws SubscriptionBaseApiException { final String baseProduct = "Shotgun"; final BillingPeriod baseTerm = BillingPeriod.MONTHLY; final String basePriceList = PriceListSet.DEFAULT_PRICELIST_NAME; final LocalDate startDate = clock.getUTCToday().plusDays(5); final DefaultSubscriptionBase subscription = testUtil.createSubscription(bundle, baseProduct, baseTerm, basePriceList, startDate); assertEquals(subscription.getState(), Entitlement.EntitlementState.PENDING); assertEquals(subscription.getStartDate().compareTo(startDate.toDateTime(accountData.getReferenceTime())), 0); subscription.cancelWithPolicy(BillingActionPolicy.IMMEDIATE, callContext); testListener.pushExpectedEvents(NextEvent.CREATE, NextEvent.CANCEL); clock.addDays(5); assertListenerStatus(); final DefaultSubscriptionBase subscription2 = (DefaultSubscriptionBase) subscriptionInternalApi.getSubscriptionFromId(subscription.getId(), internalCallContext); assertEquals(subscription2.getStartDate().compareTo(subscription.getStartDate()), 0); assertEquals(subscription2.getState(), Entitlement.EntitlementState.CANCELLED); assertNull(subscription2.getCurrentPlan()); }
@Test(groups = "slow") public void testCancelPlanOnPendingSubscription1() throws SubscriptionBaseApiException { final String baseProduct = "Shotgun"; final BillingPeriod baseTerm = BillingPeriod.MONTHLY; final String basePriceList = PriceListSet.DEFAULT_PRICELIST_NAME; final LocalDate startDate = clock.getUTCToday().plusDays(5); final DefaultSubscriptionBase subscription = testUtil.createSubscription(bundle, baseProduct, baseTerm, basePriceList, startDate); assertEquals(subscription.getState(), Entitlement.EntitlementState.PENDING); assertEquals(subscription.getStartDate().compareTo(startDate.toDateTime(accountData.getReferenceTime())), 0); // The code will be smart to infer the cancelation date as being the future startDate subscription.cancel(callContext); testListener.pushExpectedEvents(NextEvent.CREATE, NextEvent.CANCEL); clock.addDays(5); assertListenerStatus(); final DefaultSubscriptionBase subscription2 = (DefaultSubscriptionBase) subscriptionInternalApi.getSubscriptionFromId(subscription.getId(), internalCallContext); assertEquals(subscription2.getStartDate().compareTo(subscription.getStartDate()), 0); assertEquals(subscription2.getState(), Entitlement.EntitlementState.CANCELLED); assertNull(subscription2.getCurrentPlan()); }
@Test(groups = "slow") public void testCancelPlanOnPendingSubscription2() throws SubscriptionBaseApiException { final String baseProduct = "Shotgun"; final BillingPeriod baseTerm = BillingPeriod.MONTHLY; final String basePriceList = PriceListSet.DEFAULT_PRICELIST_NAME; final LocalDate startDate = clock.getUTCToday().plusDays(5); final DefaultSubscriptionBase subscription = testUtil.createSubscription(bundle, baseProduct, baseTerm, basePriceList, startDate); assertEquals(subscription.getState(), Entitlement.EntitlementState.PENDING); assertEquals(subscription.getStartDate().compareTo(startDate.toDateTime(accountData.getReferenceTime())), 0); try { subscription.cancelWithDate(null, callContext); fail("Cancel plan should have failed : subscription PENDING"); } catch (SubscriptionBaseApiException e) { assertEquals(e.getCode(), ErrorCode.SUB_INVALID_REQUESTED_DATE.getCode()); } try { subscription.cancelWithDate(subscription.getStartDate().minusDays(1), callContext); fail("Cancel plan should have failed : subscription PENDING"); } catch (SubscriptionBaseApiException e) { assertEquals(e.getCode(), ErrorCode.SUB_INVALID_REQUESTED_DATE.getCode()); } subscription.cancelWithDate(subscription.getStartDate(), callContext); testListener.pushExpectedEvents(NextEvent.CREATE, NextEvent.CANCEL); clock.addDays(5); assertListenerStatus(); final DefaultSubscriptionBase subscription2 = (DefaultSubscriptionBase) subscriptionInternalApi.getSubscriptionFromId(subscription.getId(), internalCallContext); assertEquals(subscription2.getStartDate().compareTo(subscription.getStartDate()), 0); assertEquals(subscription2.getState(), Entitlement.EntitlementState.CANCELLED); assertNull(subscription2.getCurrentPlan()); }
@Test(groups = "slow") public void testWrapperBasic() throws Exception { final InputStream is = new ByteArrayInputStream(testOverdueHelper.getConfigXml().getBytes()); final DefaultOverdueConfig config = XMLLoader.getObjectFromStreamNoValidation(is, DefaultOverdueConfig.class); ((MockOverdueConfigCache) overdueConfigCache).loadOverwriteDefaultOverdueConfig(config); Account account; OverdueWrapper wrapper; OverdueState state; state = config.getOverdueStatesAccount().findState("OD1"); account = testOverdueHelper.createAccount(clock.getUTCToday().minusDays(31)); wrapper = overdueWrapperFactory.createOverdueWrapperFor(account, internalCallContext); wrapper.refresh(clock.getUTCNow(), internalCallContext); testOverdueHelper.checkStateApplied(state); state = config.getOverdueStatesAccount().findState("OD2"); account = testOverdueHelper.createAccount(clock.getUTCToday().minusDays(41)); wrapper = overdueWrapperFactory.createOverdueWrapperFor(account, internalCallContext); wrapper.refresh(clock.getUTCNow(), internalCallContext); testOverdueHelper.checkStateApplied(state); state = config.getOverdueStatesAccount().findState("OD3"); account = testOverdueHelper.createAccount(clock.getUTCToday().minusDays(51)); wrapper = overdueWrapperFactory.createOverdueWrapperFor(account, internalCallContext); wrapper.refresh(clock.getUTCNow(), internalCallContext); testOverdueHelper.checkStateApplied(state); }
@Test(groups = "slow") public void testCancelUncancelFutureSubscription() throws SubscriptionBaseApiException { final LocalDate init = clock.getUTCToday(); final String productName = "Shotgun"; final BillingPeriod term = BillingPeriod.MONTHLY; final String planSetName = PriceListSet.DEFAULT_PRICELIST_NAME; final LocalDate futureCreationDate = init.plusDays(10); DefaultSubscriptionBase subscription = testUtil.createSubscription(bundle, productName, term, planSetName, futureCreationDate); assertListenerStatus(); assertNotNull(subscription); assertEquals(subscription.getState(), EntitlementState.PENDING); // Cancel / Uncancel a few times to make sure this works and we end up on a stable state for (int i = 0; i < 3; i++) { subscription.cancelWithPolicy(BillingActionPolicy.IMMEDIATE, callContext); subscription = (DefaultSubscriptionBase) subscriptionInternalApi.getSubscriptionFromId(subscription.getId(), internalCallContext); assertEquals(subscription.getState(), EntitlementState.PENDING); testListener.pushExpectedEvents(NextEvent.UNCANCEL); subscription.uncancel(callContext); assertListenerStatus(); } // Now check we are on the right state (as if nothing had happened) testListener.pushExpectedEvents(NextEvent.CREATE); clock.addDays(10); assertListenerStatus(); subscription = (DefaultSubscriptionBase) subscriptionInternalApi.getSubscriptionFromId(subscription.getId(), internalCallContext); assertEquals(subscription.getState(), EntitlementState.ACTIVE); testListener.pushExpectedEvent(NextEvent.PHASE); clock.addMonths(1); assertListenerStatus(); }
final String basePriceList = PriceListSet.DEFAULT_PRICELIST_NAME; final LocalDate startDate = clock.getUTCToday().plusDays(5);
@Test(groups = "slow") public void testPostExternalChargeForBundle() throws Exception { // Post an external charge final BigDecimal externalChargeAmount = BigDecimal.TEN; final UUID bundleId = UUID.randomUUID(); final InvoiceItem externalCharge = new ExternalChargeInvoiceItem(null, accountId, bundleId, UUID.randomUUID().toString(), clock.getUTCToday(), null, externalChargeAmount, accountCurrency, null); final InvoiceItem externalChargeInvoiceItem = invoiceUserApi.insertExternalCharges(accountId, clock.getUTCToday(), ImmutableList.<InvoiceItem>of(externalCharge), true, null, callContext).get(0); Assert.assertEquals(externalChargeInvoiceItem.getBundleId(), bundleId); }
@Test(groups = "slow") public void testAddTaxItems() throws Exception { final BigDecimal taxItemAmount = BigDecimal.TEN; final UUID bundleId = UUID.randomUUID(); final InvoiceItem taxItem = new TaxInvoiceItem(null, accountId, bundleId, UUID.randomUUID().toString(), clock.getUTCToday(), taxItemAmount, accountCurrency); final List<InvoiceItem> resultTaxInvoiceItems = invoiceUserApi.insertTaxItems(accountId, clock.getUTCToday(), ImmutableList.<InvoiceItem>of(taxItem), true, null, callContext); Assert.assertEquals(resultTaxInvoiceItems.size(), 1); Assert.assertEquals(resultTaxInvoiceItems.get(0).getAmount().compareTo(taxItemAmount), 0); Assert.assertEquals(resultTaxInvoiceItems.get(0).getBundleId(), bundleId); }
@Test(groups = "fast") public void testWithNullEventSetAndNullInvoiceSet() throws InvoiceApiException { final InvoiceWithMetadata invoiceWithMetadata = generator.generateInvoice(account, null, null, null, clock.getUTCToday(), Currency.USD, internalCallContext); assertNull(invoiceWithMetadata.getInvoice()); }
private List<Invoice> getUnpaidInvoicesOrderFromRecent() { final Collection<Invoice> invoices = invoiceUserApi.getUnpaidInvoicesByAccountId(account.getId(), clock.getUTCToday(), callContext); // Sort in reverse order to first pay most recent invoice-- that way overdue state may only flip when we reach the last one. final List<Invoice> sortedInvoices = new LinkedList<Invoice>(invoices); Collections.sort(sortedInvoices, new Comparator<Invoice>() { @Override public int compare(final Invoice i1, final Invoice i2) { return i2.getInvoiceDate().compareTo(i1.getInvoiceDate()); } }); return sortedInvoices; }
@Test(groups = "slow") public void testOriginalAmountCharged() throws Exception { // Post an external charge final BigDecimal externalChargeAmount = BigDecimal.TEN; final InvoiceItem externalCharge = new ExternalChargeInvoiceItem(null, accountId, null, UUID.randomUUID().toString(), clock.getUTCToday(), null, externalChargeAmount, accountCurrency, null); final InvoiceItem externalChargeInvoiceItem = invoiceUserApi.insertExternalCharges(accountId, clock.getUTCToday(), ImmutableList.<InvoiceItem>of(externalCharge), true, null, callContext).get(0); final Invoice newInvoice = invoiceUserApi.getInvoice(externalChargeInvoiceItem.getInvoiceId(), callContext); final BigDecimal newAmountCharged = newInvoice.getChargedAmount(); Assert.assertEquals(newInvoice.getOriginalChargedAmount().compareTo(externalChargeAmount), 0); Assert.assertEquals(newAmountCharged.compareTo(externalChargeAmount), 0); }
@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); }
@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()); } }
protected void checkNoMoreInvoiceToGenerate(final Account account) { busHandler.pushExpectedEvent(NextEvent.NULL_INVOICE); try { invoiceUserApi.triggerInvoiceGeneration(account.getId(), clock.getUTCToday(), callContext); fail("Should not have generated an extra invoice"); } catch (final InvoiceApiException e) { assertListenerStatus(); assertEquals(e.getCode(), ErrorCode.INVOICE_NOTHING_TO_DO.getCode()); } }
@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); }