protected SortedSet<BillingEvent> createNewEvents(final List<DisabledDuration> disabledDuration, final SortedSet<BillingEvent> billingEvents, final Account account, final SubscriptionBase subscription) { final SortedSet<BillingEvent> result = new TreeSet<BillingEvent>(); for (final DisabledDuration duration : disabledDuration) { // The first one before the blocked duration final BillingEvent precedingInitialEvent = precedingBillingEventForSubscription(duration.getStart(), billingEvents, subscription); // The last one during of before the duration final BillingEvent precedingFinalEvent = precedingBillingEventForSubscription(duration.getEnd(), billingEvents, subscription); if (precedingInitialEvent != null) { // there is a preceding billing event result.add(createNewDisableEvent(duration.getStart(), precedingInitialEvent)); if (duration.getEnd() != null) { // no second event in the pair means they are still disabled (no re-enable) result.add(createNewReenableEvent(duration.getEnd(), precedingFinalEvent)); } } else if (precedingFinalEvent != null) { // can happen - e.g. phase event result.add(createNewReenableEvent(duration.getEnd(), precedingFinalEvent)); } // N.B. if there's no precedingInitial and no precedingFinal then there's nothing to do } return result; }
protected BillingEvent createRealEvent(final DateTime effectiveDate, final SubscriptionBase subscription) { return createRealEvent(effectiveDate, subscription, SubscriptionBaseTransitionType.CHANGE); }
private BillingEvent createEvent(final SubscriptionBase sub, final DateTime effectiveDate, final SubscriptionBaseTransitionType type) { return createEvent(sub, effectiveDate, type, 1L); }
@Test(groups = "fast") public void testEventsToRemoveOpenFollow() { final DateTime now = clock.getUTCNow(); final List<DisabledDuration> disabledDuration = new ArrayList<BlockingCalculator.DisabledDuration>(); final SortedSet<BillingEvent> billingEvents = new TreeSet<BillingEvent>(); disabledDuration.add(new DisabledDuration(now, null)); final BillingEvent e1 = createRealEvent(now.plusDays(1), subscription1); billingEvents.add(e1); final SortedSet<BillingEvent> results = blockingCalculator.eventsToRemove(disabledDuration, billingEvents, subscription1); assertEquals(results.size(), 1); assertEquals(results.first(), e1); }
@Test(groups = "fast") public void testCreateNewEventsOpenFollow() { final DateTime now = clock.getUTCNow(); final List<DisabledDuration> disabledDuration = new ArrayList<BlockingCalculator.DisabledDuration>(); final SortedSet<BillingEvent> billingEvents = new TreeSet<BillingEvent>(); disabledDuration.add(new DisabledDuration(now, null)); billingEvents.add(createRealEvent(now.plusDays(1), subscription1)); final SortedSet<BillingEvent> results = blockingCalculator.createNewEvents(disabledDuration, billingEvents, account, subscription1); assertEquals(results.size(), 0); }
protected SortedSet<BillingEvent> eventsToRemove(final List<DisabledDuration> disabledDuration, final SortedSet<BillingEvent> billingEvents, final SubscriptionBase subscription) { final SortedSet<BillingEvent> result = new TreeSet<BillingEvent>(); final SortedSet<BillingEvent> filteredBillingEvents = filter(billingEvents, subscription); for (final DisabledDuration duration : disabledDuration) { for (final BillingEvent event : filteredBillingEvents) { if (duration.getEnd() == null || event.getEffectiveDate().isBefore(duration.getEnd())) { if (event.getEffectiveDate().isAfter(duration.getStart())) { //between the pair result.add(event); } } else { //after the last event of the pair no need to keep checking break; } } } return result; }
@Test(groups = "fast") public void testCreateBundleSubscriptionMap() { final SortedSet<BillingEvent> events = new TreeSet<BillingEvent>(); events.add(createBillingEvent(subscription1)); events.add(createBillingEvent(subscription2)); events.add(createBillingEvent(subscription3)); events.add(createBillingEvent(subscription4)); final Hashtable<UUID, List<SubscriptionBase>> map = blockingCalculator.createBundleSubscriptionMap(events); assertNotNull(map); assertEquals(map.keySet().size(), 2); assertEquals(map.get(bundleId1).size(), 3); assertEquals(map.get(bundleId2).size(), 1); }
private BillingEvent createEvent(final SubscriptionBase sub, final DateTime effectiveDate, final SubscriptionBaseTransitionType type, final long totalOrdering) { final int billCycleDay = 1; final Plan shotgun = new MockPlan(); final PlanPhase shotgunMonthly = createMockMonthlyPlanPhase(null, BigDecimal.ZERO, PhaseType.TRIAL); final Account account = new MockAccountBuilder().build(); return new DefaultBillingEvent(account, sub, effectiveDate, shotgun, shotgunMonthly, BigDecimal.ZERO, null, Currency.USD, BillingPeriod.NO_BILLING_PERIOD, billCycleDay, BillingModeType.IN_ADVANCE, "Test Event 1", totalOrdering, type, DateTimeZone.UTC); }
@Test(groups = "fast") public void testCalculateBCDWithTimeZoneUTC() throws Exception { final DateTimeZone accountTimeZone = DateTimeZone.UTC; final DateTime startDateUTC = new DateTime("2012-07-16T21:17:03.000Z", DateTimeZone.UTC); final int bcdLocal = 16; verifyBCDCalculation(accountTimeZone, startDateUTC, bcdLocal); }
@Test(groups = "fast") public void testEventsToRemoveOpenPrev() { final DateTime now = clock.getUTCNow(); final List<DisabledDuration> disabledDuration = new ArrayList<BlockingCalculator.DisabledDuration>(); final SortedSet<BillingEvent> billingEvents = new TreeSet<BillingEvent>(); disabledDuration.add(new DisabledDuration(now, null)); billingEvents.add(createRealEvent(now.minusDays(1), subscription1)); final SortedSet<BillingEvent> results = blockingCalculator.eventsToRemove(disabledDuration, billingEvents, subscription1); assertEquals(results.size(), 0); }
@Test(groups = "fast") public void testCreateNewEventsClosedFollow() { final DateTime now = clock.getUTCNow(); final List<DisabledDuration> disabledDuration = new ArrayList<BlockingCalculator.DisabledDuration>(); final SortedSet<BillingEvent> billingEvents = new TreeSet<BillingEvent>(); disabledDuration.add(new DisabledDuration(now, now.plusDays(2))); billingEvents.add(createRealEvent(now.plusDays(3), subscription1)); final SortedSet<BillingEvent> results = blockingCalculator.createNewEvents(disabledDuration, billingEvents, account, subscription1); assertEquals(results.size(), 0); }
@Test(groups = "fast") public void testCalculateBCDWithTimeZoneHST() throws Exception { final DateTimeZone accountTimeZone = DateTimeZone.forID("HST"); final DateTime startDateUTC = new DateTime("2012-07-16T21:17:03.000Z", DateTimeZone.UTC); final int bcdLocal = 16; verifyBCDCalculation(accountTimeZone, startDateUTC, bcdLocal); }
@Test(groups = "fast") public void testEventsToRemoveClosedPrev() { final DateTime now = clock.getUTCNow(); final List<DisabledDuration> disabledDuration = new ArrayList<BlockingCalculator.DisabledDuration>(); final SortedSet<BillingEvent> billingEvents = new TreeSet<BillingEvent>(); disabledDuration.add(new DisabledDuration(now, now.plusDays(2))); final BillingEvent e1 = createRealEvent(now.minusDays(1), subscription1); billingEvents.add(e1); final SortedSet<BillingEvent> results = blockingCalculator.eventsToRemove(disabledDuration, billingEvents, subscription1); assertEquals(results.size(), 0); }
@Test(groups = "fast") public void testCreateNewEventsClosedBetweenFollow() { final DateTime now = clock.getUTCNow(); final List<DisabledDuration> disabledDuration = new ArrayList<BlockingCalculator.DisabledDuration>(); final SortedSet<BillingEvent> billingEvents = new TreeSet<BillingEvent>(); disabledDuration.add(new DisabledDuration(now, now.plusDays(2))); billingEvents.add(createRealEvent(now.plusDays(1), subscription1)); final SortedSet<BillingEvent> results = blockingCalculator.createNewEvents(disabledDuration, billingEvents, account, subscription1); assertEquals(results.size(), 1); assertEquals(results.last().getEffectiveDate(), now.plusDays(2)); assertEquals(results.last().getRecurringPrice(), billingEvents.first().getRecurringPrice()); assertEquals(results.last().getTransitionType(), SubscriptionBaseTransitionType.END_BILLING_DISABLED); }
@Test(groups = "fast") public void testCalculateBCDWithSubscriptionDateNotInUTC() throws Exception { // Test to verify the computations don't rely implicitly on UTC final DateTimeZone accountTimeZone = DateTimeZone.forID("Asia/Tokyo"); final DateTime startDate = new DateTime("2012-07-16T21:17:03.000Z", DateTimeZone.forID("HST")); final int bcdLocal = 17; verifyBCDCalculation(accountTimeZone, startDate, bcdLocal); }
@Test(groups = "fast") public void testEventsToRemoveClosedFollow() { final DateTime now = clock.getUTCNow(); final List<DisabledDuration> disabledDuration = new ArrayList<BlockingCalculator.DisabledDuration>(); final SortedSet<BillingEvent> billingEvents = new TreeSet<BillingEvent>(); disabledDuration.add(new DisabledDuration(now, now.plusDays(2))); final BillingEvent e3 = createRealEvent(now.plusDays(3), subscription1); billingEvents.add(e3); final SortedSet<BillingEvent> results = blockingCalculator.eventsToRemove(disabledDuration, billingEvents, subscription1); assertEquals(results.size(), 0); }
@Test(groups = "fast") public void testEventsToRemoveOpenPrevFollow() { final DateTime now = clock.getUTCNow(); final List<DisabledDuration> disabledDuration = new ArrayList<BlockingCalculator.DisabledDuration>(); final SortedSet<BillingEvent> billingEvents = new TreeSet<BillingEvent>(); disabledDuration.add(new DisabledDuration(now, null)); final BillingEvent e1 = createRealEvent(now.minusDays(1), subscription1); final BillingEvent e2 = createRealEvent(now.plusDays(1), subscription1); billingEvents.add(e1); billingEvents.add(e2); final SortedSet<BillingEvent> results = blockingCalculator.eventsToRemove(disabledDuration, billingEvents, subscription1); assertEquals(results.size(), 1); assertEquals(results.first(), e2); }
@Test(groups = "fast") public void testEventsToRemoveClosedBetwn() { final DateTime now = clock.getUTCNow(); final List<DisabledDuration> disabledDuration = new ArrayList<BlockingCalculator.DisabledDuration>(); final SortedSet<BillingEvent> billingEvents = new TreeSet<BillingEvent>(); disabledDuration.add(new DisabledDuration(now, now.plusDays(2))); final BillingEvent e2 = createRealEvent(now.plusDays(1), subscription1); billingEvents.add(e2); final SortedSet<BillingEvent> results = blockingCalculator.eventsToRemove(disabledDuration, billingEvents, subscription1); assertEquals(results.size(), 1); assertEquals(results.first(), e2); }
@Test(groups = "fast") public void testEventsToRemoveClosedPrevBetw() { final DateTime now = clock.getUTCNow(); final List<DisabledDuration> disabledDuration = new ArrayList<BlockingCalculator.DisabledDuration>(); final SortedSet<BillingEvent> billingEvents = new TreeSet<BillingEvent>(); disabledDuration.add(new DisabledDuration(now, now.plusDays(2))); final BillingEvent e1 = createRealEvent(now.minusDays(1), subscription1); final BillingEvent e2 = createRealEvent(now.plusDays(1), subscription1); billingEvents.add(e1); billingEvents.add(e2); final SortedSet<BillingEvent> results = blockingCalculator.eventsToRemove(disabledDuration, billingEvents, subscription1); assertEquals(results.size(), 1); assertEquals(results.first(), e2); }
@Test(groups = "fast") public void testEventsToRemoveClosedBetweenFollow() { final DateTime now = clock.getUTCNow(); final List<DisabledDuration> disabledDuration = new ArrayList<BlockingCalculator.DisabledDuration>(); final SortedSet<BillingEvent> billingEvents = new TreeSet<BillingEvent>(); disabledDuration.add(new DisabledDuration(now, now.plusDays(2))); final BillingEvent e2 = createRealEvent(now.plusDays(1), subscription1); final BillingEvent e3 = createRealEvent(now.plusDays(3), subscription1); billingEvents.add(e2); billingEvents.add(e3); final SortedSet<BillingEvent> results = blockingCalculator.eventsToRemove(disabledDuration, billingEvents, subscription1); assertEquals(results.size(), 1); assertEquals(results.first(), e2); }