@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); }
protected BillingEvent createRealEvent(final DateTime effectiveDate, final SubscriptionBase subscription) { return createRealEvent(effectiveDate, subscription, SubscriptionBaseTransitionType.CHANGE); }
final DateTime now = clock.getUTCNow(); final BillingEvent A = createRealEvent(now.minusDays(1).minusHours(1), subscription1); final BillingEvent B = createRealEvent(now.minusDays(1), subscription2); final BillingEvent C = createRealEvent(now.plusDays(1), subscription2); final BillingEvent D = createRealEvent(now.plusDays(3), subscription3); final SortedSet<BillingEvent> billingEvents = new TreeSet<BillingEvent>(); billingEvents.add(A); blockingStates.add(new DefaultBlockingState(bundleId1, BlockingStateType.SUBSCRIPTION_BUNDLE, CLEAR_BUNDLE, "test", false, false, false, now.plusDays(2))); setBlockingStates(blockingStates);
@Test(groups = "fast") public void testSimpleWithClearBlockingDuration() throws Exception { final UUID ovdId = UUID.randomUUID(); final BillingEvent trial = createRealEvent(new LocalDate(2012, 5, 1).toDateTimeAtStartOfDay(DateTimeZone.UTC), subscription1, SubscriptionBaseTransitionType.CREATE); final BillingEvent phase = createRealEvent(new LocalDate(2012, 5, 31).toDateTimeAtStartOfDay(DateTimeZone.UTC), subscription1, SubscriptionBaseTransitionType.PHASE); final BillingEvent upgrade = createRealEvent(new LocalDate(2012, 7, 25).toDateTimeAtStartOfDay(DateTimeZone.UTC), subscription1, SubscriptionBaseTransitionType.CHANGE); final SortedSet<BillingEvent> billingEvents = new TreeSet<BillingEvent>(); billingEvents.add(trial); billingEvents.add(phase); billingEvents.add(upgrade); final List<BlockingState> blockingEvents = new ArrayList<BlockingState>(); blockingEvents.add(new DefaultBlockingState(ovdId, BlockingStateType.SUBSCRIPTION_BUNDLE, DISABLED_BUNDLE, "test", true, false, false, new LocalDate(2012, 7, 5).toDateTimeAtStartOfDay(DateTimeZone.UTC))); blockingEvents.add(new DefaultBlockingState(ovdId, BlockingStateType.SUBSCRIPTION_BUNDLE, DISABLED_BUNDLE, "test", true, true, true, new LocalDate(2012, 7, 15).toDateTimeAtStartOfDay(DateTimeZone.UTC))); blockingEvents.add(new DefaultBlockingState(ovdId, BlockingStateType.SUBSCRIPTION_BUNDLE, DISABLED_BUNDLE, "test", true, true, true, new LocalDate(2012, 7, 25).toDateTimeAtStartOfDay(DateTimeZone.UTC))); blockingEvents.add(new DefaultBlockingState(ovdId, BlockingStateType.SUBSCRIPTION_BUNDLE, CLEAR_BUNDLE, "test", false, false, false, new LocalDate(2012, 7, 25).toDateTimeAtStartOfDay(DateTimeZone.UTC))); setBlockingStates(blockingEvents); blockingCalculator.insertBlockingEvents(billingEvents, internalCallContext); assertEquals(billingEvents.size(), 5); final List<BillingEvent> events = new ArrayList<BillingEvent>(billingEvents); assertEquals(events.get(0).getEffectiveDate(), new LocalDate(2012, 5, 1).toDateTimeAtStartOfDay(DateTimeZone.UTC)); assertEquals(events.get(0).getTransitionType(), SubscriptionBaseTransitionType.CREATE); assertEquals(events.get(1).getEffectiveDate(), new LocalDate(2012, 5, 31).toDateTimeAtStartOfDay(DateTimeZone.UTC)); assertEquals(events.get(1).getTransitionType(), SubscriptionBaseTransitionType.PHASE); assertEquals(events.get(2).getEffectiveDate(), new LocalDate(2012, 7, 15).toDateTimeAtStartOfDay(DateTimeZone.UTC)); assertEquals(events.get(2).getTransitionType(), SubscriptionBaseTransitionType.START_BILLING_DISABLED); assertEquals(events.get(3).getEffectiveDate(), new LocalDate(2012, 7, 25).toDateTimeAtStartOfDay(DateTimeZone.UTC)); assertEquals(events.get(3).getTransitionType(), SubscriptionBaseTransitionType.END_BILLING_DISABLED); assertEquals(events.get(4).getEffectiveDate(), new LocalDate(2012, 7, 25).toDateTimeAtStartOfDay(DateTimeZone.UTC)); assertEquals(events.get(4).getTransitionType(), SubscriptionBaseTransitionType.CHANGE); }
@Test(groups = "fast") public void testPrecedingBillingEventForSubscription() { final DateTime now = new DateTime(); final SortedSet<BillingEvent> events = new TreeSet<BillingEvent>(); events.add(createRealEvent(now.minusDays(10), subscription1)); events.add(createRealEvent(now.minusDays(6), subscription1)); events.add(createRealEvent(now.minusDays(5), subscription1)); events.add(createRealEvent(now.minusDays(1), subscription1)); final BillingEvent minus11 = blockingCalculator.precedingBillingEventForSubscription(now.minusDays(11), events, subscription1); assertNull(minus11); final BillingEvent minus5andAHalf = blockingCalculator.precedingBillingEventForSubscription(now.minusDays(5).minusHours(12), events, subscription1); assertNotNull(minus5andAHalf); assertEquals(minus5andAHalf.getEffectiveDate(), now.minusDays(6)); }
@Test(groups = "fast") public void testFilter() { final SortedSet<BillingEvent> events = new TreeSet<BillingEvent>(); events.add(createBillingEvent(subscription1)); events.add(createBillingEvent(subscription1)); events.add(createBillingEvent(subscription1)); events.add(createBillingEvent(subscription2)); final SortedSet<BillingEvent> result1 = blockingCalculator.filter(events, subscription1); final SortedSet<BillingEvent> result2 = blockingCalculator.filter(events, subscription2); final SortedSet<BillingEvent> result3 = blockingCalculator.filter(events, subscription3); assertEquals(result1.size(), 3); assertEquals(result1.first().getSubscription(), subscription1); assertEquals(result1.last().getSubscription(), subscription1); assertEquals(result2.size(), 1); assertEquals(result2.first().getSubscription(), subscription2); assertEquals(result3.size(), 0); }
@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); }
@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 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 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 testEventsToRemoveClosedPrevBetwNext() { 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); final BillingEvent e3 = createRealEvent(now.plusDays(3), subscription1); billingEvents.add(e1); billingEvents.add(e2); billingEvents.add(e3); final SortedSet<BillingEvent> results = blockingCalculator.eventsToRemove(disabledDuration, billingEvents, subscription1); assertEquals(results.size(), 1); assertEquals(results.first(), e2); }
@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 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 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); }
@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 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 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 testCreateNewEventsOpenPrevFollow() { 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)); billingEvents.add(createRealEvent(now.plusDays(1), subscription1)); final SortedSet<BillingEvent> results = blockingCalculator.createNewEvents(disabledDuration, billingEvents, account, subscription1); assertEquals(results.size(), 1); assertEquals(results.first().getEffectiveDate(), now); assertNull(results.first().getFixedPrice()); assertNull(results.first().getRecurringPrice()); assertEquals(results.first().getBillingPeriod(), BillingPeriod.NO_BILLING_PERIOD); assertEquals(results.first().getTransitionType(), SubscriptionBaseTransitionType.START_BILLING_DISABLED); }
@Test(groups = "fast") public void testCreateNewEventsClosedBetwn() { 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); }