Details
diff --git a/junction/src/test/java/com/ning/billing/junction/api/blocking/TestBlockingApi.java b/junction/src/test/java/com/ning/billing/junction/api/blocking/TestBlockingApi.java
index b8f4343..9174f80 100644
--- a/junction/src/test/java/com/ning/billing/junction/api/blocking/TestBlockingApi.java
+++ b/junction/src/test/java/com/ning/billing/junction/api/blocking/TestBlockingApi.java
@@ -20,6 +20,7 @@ import java.io.IOException;
import java.util.SortedSet;
import java.util.UUID;
+import org.mockito.Mockito;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.testng.Assert;
@@ -38,8 +39,6 @@ import com.ning.billing.junction.api.BlockingApi;
import com.ning.billing.junction.api.BlockingState;
import com.ning.billing.junction.api.DefaultBlockingState;
import com.ning.billing.junction.dao.TestBlockingDao;
-import com.ning.billing.mock.BrainDeadProxyFactory;
-import com.ning.billing.mock.BrainDeadProxyFactory.ZombieControl;
import com.ning.billing.mock.glue.MockEntitlementModule;
import com.ning.billing.util.clock.ClockMock;
import com.ning.billing.util.io.IOUtils;
@@ -57,7 +56,7 @@ public class TestBlockingApi {
@Inject
private ClockMock clock;
- @BeforeClass(groups = {"slow"})
+ @BeforeClass(groups = "slow")
public void setup() throws IOException {
log.info("Starting set up TestBlockingApi");
@@ -67,7 +66,7 @@ public class TestBlockingApi {
helper.initDb(utilDdl);
}
- @BeforeMethod(groups = {"slow"})
+ @BeforeMethod(groups = "slow")
public void clean() {
helper.cleanupTable("blocking_states");
clock.resetDeltaFromReality();
@@ -78,9 +77,8 @@ public class TestBlockingApi {
helper.stopMysql();
}
- @Test(groups = {"slow"}, enabled = true)
+ @Test(groups = "slow")
public void testApi() {
-
final UUID uuid = UUID.randomUUID();
final String overdueStateName = "WayPassedItMan";
final String service = "TEST";
@@ -97,15 +95,14 @@ public class TestBlockingApi {
final BlockingState state2 = new DefaultBlockingState(uuid, overdueStateName2, Blockable.Type.SUBSCRIPTION_BUNDLE, service, blockChange, blockEntitlement, blockBilling);
api.setBlockingState(state2);
- final SubscriptionBundle bundle = BrainDeadProxyFactory.createBrainDeadProxyFor(SubscriptionBundle.class);
- ((ZombieControl) bundle).addResult("getId", uuid);
+ final SubscriptionBundle bundle = Mockito.mock(SubscriptionBundle.class);
+ Mockito.when(bundle.getId()).thenReturn(uuid);
Assert.assertEquals(api.getBlockingStateFor(bundle).getStateName(), overdueStateName2);
Assert.assertEquals(api.getBlockingStateFor(bundle.getId()).getStateName(), overdueStateName2);
-
}
- @Test(groups = {"slow"}, enabled = true)
+ @Test(groups = "slow")
public void testApiHistory() throws Exception {
final UUID uuid = UUID.randomUUID();
final String overdueStateName = "WayPassedItMan";
@@ -124,9 +121,8 @@ public class TestBlockingApi {
final BlockingState state2 = new DefaultBlockingState(uuid, overdueStateName2, Blockable.Type.SUBSCRIPTION_BUNDLE, service, blockChange, blockEntitlement, blockBilling);
api.setBlockingState(state2);
- final SubscriptionBundle bundle = BrainDeadProxyFactory.createBrainDeadProxyFor(SubscriptionBundle.class);
- ((ZombieControl) bundle).addResult("getId", uuid);
-
+ final SubscriptionBundle bundle = Mockito.mock(SubscriptionBundle.class);
+ Mockito.when(bundle.getId()).thenReturn(uuid);
final SortedSet<BlockingState> history1 = api.getBlockingHistory(bundle);
final SortedSet<BlockingState> history2 = api.getBlockingHistory(bundle.getId());
@@ -138,7 +134,5 @@ public class TestBlockingApi {
Assert.assertEquals(history2.size(), 2);
Assert.assertEquals(history2.first().getStateName(), overdueStateName);
Assert.assertEquals(history2.last().getStateName(), overdueStateName2);
-
}
-
}
diff --git a/junction/src/test/java/com/ning/billing/junction/blocking/TestBlockingChecker.java b/junction/src/test/java/com/ning/billing/junction/blocking/TestBlockingChecker.java
index 43a2e79..f2248d4 100644
--- a/junction/src/test/java/com/ning/billing/junction/blocking/TestBlockingChecker.java
+++ b/junction/src/test/java/com/ning/billing/junction/blocking/TestBlockingChecker.java
@@ -19,6 +19,7 @@ package com.ning.billing.junction.blocking;
import java.util.SortedSet;
import java.util.UUID;
+import org.mockito.Mockito;
import org.testng.Assert;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
@@ -28,6 +29,7 @@ import com.google.inject.Guice;
import com.google.inject.Injector;
import com.ning.billing.account.api.Account;
import com.ning.billing.entitlement.api.user.EntitlementUserApi;
+import com.ning.billing.entitlement.api.user.EntitlementUserApiException;
import com.ning.billing.entitlement.api.user.Subscription;
import com.ning.billing.entitlement.api.user.SubscriptionBundle;
import com.ning.billing.junction.api.Blockable;
@@ -37,18 +39,14 @@ import com.ning.billing.junction.api.DefaultBlockingState;
import com.ning.billing.junction.block.BlockingChecker;
import com.ning.billing.junction.block.DefaultBlockingChecker;
import com.ning.billing.junction.dao.BlockingStateDao;
-import com.ning.billing.mock.BrainDeadProxyFactory;
-import com.ning.billing.mock.BrainDeadProxyFactory.ZombieControl;
import com.ning.billing.util.clock.Clock;
public class TestBlockingChecker {
-
private BlockingState bundleState;
private BlockingState subscriptionState;
private BlockingState accountState;
private final BlockingStateDao dao = new BlockingStateDao() {
-
@Override
public BlockingState getBlockingStateFor(final Blockable blockable) {
if (blockable.getId() == account.getId()) {
@@ -92,43 +90,44 @@ public class TestBlockingChecker {
private Account account;
private SubscriptionBundle bundle;
- @BeforeClass(groups = {"fast"})
+ @BeforeClass(groups = "fast")
public void setup() {
- account = BrainDeadProxyFactory.createBrainDeadProxyFor(Account.class);
- ((ZombieControl) account).addResult("getId", UUID.randomUUID());
-
- bundle = BrainDeadProxyFactory.createBrainDeadProxyFor(SubscriptionBundle.class);
- ((ZombieControl) bundle).addResult("getAccountId", account.getId());
- ((ZombieControl) bundle).addResult("getId", UUID.randomUUID());
- ((ZombieControl) bundle).addResult("getKey", "key");
+ final UUID accountId = UUID.randomUUID();
+ account = Mockito.mock(Account.class);
+ Mockito.when(account.getId()).thenReturn(accountId);
- subscription = BrainDeadProxyFactory.createBrainDeadProxyFor(Subscription.class);
- ((ZombieControl) subscription).addResult("getId", UUID.randomUUID());
- ((ZombieControl) subscription).addResult("getBundleId", bundle.getId());
+ bundle = Mockito.mock(SubscriptionBundle.class);
+ Mockito.when(bundle.getAccountId()).thenReturn(accountId);
+ final UUID bundleId = UUID.randomUUID();
+ Mockito.when(bundle.getId()).thenReturn(bundleId);
+ Mockito.when(bundle.getKey()).thenReturn("key");
+ subscription = Mockito.mock(Subscription.class);
+ Mockito.when(subscription.getId()).thenReturn(UUID.randomUUID());
+ Mockito.when(subscription.getBundleId()).thenReturn(bundleId);
final Injector i = Guice.createInjector(new AbstractModule() {
-
@Override
protected void configure() {
bind(BlockingChecker.class).to(DefaultBlockingChecker.class).asEagerSingleton();
bind(BlockingStateDao.class).toInstance(dao);
- final EntitlementUserApi entitlementUserApi = BrainDeadProxyFactory.createBrainDeadProxyFor(EntitlementUserApi.class);
+ final EntitlementUserApi entitlementUserApi = Mockito.mock(EntitlementUserApi.class);
bind(EntitlementUserApi.class).toInstance(entitlementUserApi);
- ((ZombieControl) entitlementUserApi).addResult("getBundleFromId", bundle);
-
+ try {
+ Mockito.when(entitlementUserApi.getBundleFromId(Mockito.<UUID>any())).thenReturn(bundle);
+ } catch (EntitlementUserApiException e) {
+ Assert.fail(e.toString());
+ }
}
-
});
checker = i.getInstance(BlockingChecker.class);
}
-
private void setStateBundle(final boolean bC, final boolean bE, final boolean bB) {
bundleState = new DefaultBlockingState(UUID.randomUUID(), "state", Blockable.Type.SUBSCRIPTION_BUNDLE, "test-service", bC, bE, bB);
- ((ZombieControl) bundle).addResult("getBlockingState", bundleState);
+ Mockito.when(bundle.getBlockingState()).thenReturn(bundleState);
}
private void setStateAccount(final boolean bC, final boolean bE, final boolean bB) {
@@ -137,10 +136,10 @@ public class TestBlockingChecker {
private void setStateSubscription(final boolean bC, final boolean bE, final boolean bB) {
subscriptionState = new DefaultBlockingState(UUID.randomUUID(), "state", Blockable.Type.SUBSCRIPTION_BUNDLE, "test-service", bC, bE, bB);
- ((ZombieControl) subscription).addResult("getBlockingState", subscriptionState);
+ Mockito.when(subscription.getBlockingState()).thenReturn(subscriptionState);
}
- @Test(groups = {"fast"}, enabled = true)
+ @Test(groups = "fast")
public void testSubscriptionChecker() throws Exception {
setStateAccount(false, false, false);
setStateBundle(false, false, false);
@@ -212,7 +211,6 @@ public class TestBlockingChecker {
//Expected behavior
}
-
//BLOCKED ACCOUNT
setStateSubscription(false, false, false);
setStateBundle(false, false, false);
@@ -245,11 +243,9 @@ public class TestBlockingChecker {
} catch (BlockingApiException e) {
//Expected behavior
}
-
-
}
- @Test(groups = {"fast"}, enabled = true)
+ @Test(groups = "fast")
public void testBundleChecker() throws Exception {
setStateAccount(false, false, false);
setStateBundle(false, false, false);
@@ -290,7 +286,6 @@ public class TestBlockingChecker {
//Expected behavior
}
-
//BLOCKED ACCOUNT
setStateSubscription(false, false, false);
setStateBundle(false, false, false);
@@ -323,11 +318,9 @@ public class TestBlockingChecker {
} catch (BlockingApiException e) {
//Expected behavior
}
-
-
}
- @Test(groups = {"fast"}, enabled = true)
+ @Test(groups = "fast")
public void testAccountChecker() throws Exception {
setStateAccount(false, false, false);
setStateBundle(false, false, false);
@@ -368,9 +361,5 @@ public class TestBlockingChecker {
} catch (BlockingApiException e) {
//Expected behavior
}
-
-
}
-
-
}
diff --git a/junction/src/test/java/com/ning/billing/junction/dao/TestBlockingDao.java b/junction/src/test/java/com/ning/billing/junction/dao/TestBlockingDao.java
index 4659778..6a29ad0 100644
--- a/junction/src/test/java/com/ning/billing/junction/dao/TestBlockingDao.java
+++ b/junction/src/test/java/com/ning/billing/junction/dao/TestBlockingDao.java
@@ -20,6 +20,7 @@ import java.io.IOException;
import java.util.SortedSet;
import java.util.UUID;
+import org.mockito.Mockito;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.testng.Assert;
@@ -35,8 +36,6 @@ import com.ning.billing.junction.MockModule;
import com.ning.billing.junction.api.Blockable;
import com.ning.billing.junction.api.BlockingState;
import com.ning.billing.junction.api.DefaultBlockingState;
-import com.ning.billing.mock.BrainDeadProxyFactory;
-import com.ning.billing.mock.BrainDeadProxyFactory.ZombieControl;
import com.ning.billing.mock.glue.MockEntitlementModule;
import com.ning.billing.util.clock.ClockMock;
import com.ning.billing.util.io.IOUtils;
@@ -51,7 +50,7 @@ public class TestBlockingDao {
@Inject
private BlockingStateDao dao;
- @BeforeClass(groups = {"slow"})
+ @BeforeClass(groups = "slow")
public void setup() throws IOException {
log.info("Starting set up TestBlockingDao");
@@ -68,7 +67,7 @@ public class TestBlockingDao {
}
}
- @Test(groups = {"slow"}, enabled = true)
+ @Test(groups = "slow")
public void testDao() {
final ClockMock clock = new ClockMock();
final UUID uuid = UUID.randomUUID();
@@ -87,15 +86,14 @@ public class TestBlockingDao {
final BlockingState state2 = new DefaultBlockingState(uuid, overdueStateName2, Blockable.Type.SUBSCRIPTION_BUNDLE, service, blockChange, blockEntitlement, blockBilling);
dao.setBlockingState(state2, clock);
- final SubscriptionBundle bundle = BrainDeadProxyFactory.createBrainDeadProxyFor(SubscriptionBundle.class);
- ((ZombieControl) bundle).addResult("getId", uuid);
+ final SubscriptionBundle bundle = Mockito.mock(SubscriptionBundle.class);
+ Mockito.when(bundle.getId()).thenReturn(uuid);
Assert.assertEquals(dao.getBlockingStateFor(bundle).getStateName(), state2.getStateName());
Assert.assertEquals(dao.getBlockingStateFor(bundle.getId()).getStateName(), overdueStateName2);
-
}
- @Test(groups = {"slow"}, enabled = true)
+ @Test(groups = "slow")
public void testDaoHistory() throws Exception {
final ClockMock clock = new ClockMock();
final UUID uuid = UUID.randomUUID();
@@ -114,9 +112,8 @@ public class TestBlockingDao {
final BlockingState state2 = new DefaultBlockingState(uuid, overdueStateName2, Blockable.Type.SUBSCRIPTION_BUNDLE, service, blockChange, blockEntitlement, blockBilling);
dao.setBlockingState(state2, clock);
- final SubscriptionBundle bundle = BrainDeadProxyFactory.createBrainDeadProxyFor(SubscriptionBundle.class);
- ((ZombieControl) bundle).addResult("getId", uuid);
-
+ final SubscriptionBundle bundle = Mockito.mock(SubscriptionBundle.class);
+ Mockito.when(bundle.getId()).thenReturn(uuid);
final SortedSet<BlockingState> history1 = dao.getBlockingHistoryFor(bundle);
final SortedSet<BlockingState> history2 = dao.getBlockingHistoryFor(bundle.getId());
@@ -128,7 +125,5 @@ public class TestBlockingDao {
Assert.assertEquals(history2.size(), 2);
Assert.assertEquals(history2.first().getStateName(), overdueStateName);
Assert.assertEquals(history2.last().getStateName(), overdueStateName2);
-
}
-
}
diff --git a/junction/src/test/java/com/ning/billing/junction/MockBlockingModule.java b/junction/src/test/java/com/ning/billing/junction/MockBlockingModule.java
index 2b7a0a9..3158d68 100644
--- a/junction/src/test/java/com/ning/billing/junction/MockBlockingModule.java
+++ b/junction/src/test/java/com/ning/billing/junction/MockBlockingModule.java
@@ -16,20 +16,18 @@
package com.ning.billing.junction;
+import org.mockito.Mockito;
+
import com.google.inject.AbstractModule;
import com.ning.billing.junction.api.BlockingApi;
import com.ning.billing.junction.dao.BlockingStateDao;
-import com.ning.billing.mock.BrainDeadProxyFactory;
-import com.ning.billing.mock.BrainDeadProxyFactory.ZombieControl;
public class MockBlockingModule extends AbstractModule {
- public static final String CLEAR_STATE = "Clear";
-
@Override
protected void configure() {
- final BlockingApi BlockingApi = BrainDeadProxyFactory.createBrainDeadProxyFor(BlockingApi.class);
- ((ZombieControl) BlockingApi).addResult("getOverdueStateNameFor", MockBlockingModule.CLEAR_STATE);
- bind(BlockingStateDao.class).toInstance(BrainDeadProxyFactory.createBrainDeadProxyFor(BlockingStateDao.class));
- bind(BlockingApi.class).toInstance(BlockingApi);
+ bind(BlockingStateDao.class).toInstance(Mockito.mock(BlockingStateDao.class));
+
+ final BlockingApi blockingApi = Mockito.mock(BlockingApi.class);
+ bind(BlockingApi.class).toInstance(blockingApi);
}
}
diff --git a/junction/src/test/java/com/ning/billing/junction/plumbing/billing/TestBillingApi.java b/junction/src/test/java/com/ning/billing/junction/plumbing/billing/TestBillingApi.java
index 2a31a6e..bc77e17 100644
--- a/junction/src/test/java/com/ning/billing/junction/plumbing/billing/TestBillingApi.java
+++ b/junction/src/test/java/com/ning/billing/junction/plumbing/billing/TestBillingApi.java
@@ -29,12 +29,14 @@ import java.util.UUID;
import org.joda.time.DateTime;
import org.joda.time.DateTimeZone;
+import org.mockito.Mockito;
import org.testng.Assert;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.BeforeSuite;
import org.testng.annotations.Test;
import com.ning.billing.account.api.Account;
+import com.ning.billing.account.api.AccountApiException;
import com.ning.billing.account.api.AccountUserApi;
import com.ning.billing.catalog.MockCatalog;
import com.ning.billing.catalog.MockCatalogService;
@@ -54,6 +56,7 @@ import com.ning.billing.entitlement.api.billing.BillingEvent;
import com.ning.billing.entitlement.api.billing.BillingModeType;
import com.ning.billing.entitlement.api.user.EffectiveSubscriptionEvent;
import com.ning.billing.entitlement.api.user.EntitlementUserApi;
+import com.ning.billing.entitlement.api.user.EntitlementUserApiException;
import com.ning.billing.entitlement.api.user.Subscription;
import com.ning.billing.entitlement.api.user.Subscription.SubscriptionState;
import com.ning.billing.entitlement.api.user.SubscriptionBundle;
@@ -64,8 +67,6 @@ import com.ning.billing.junction.api.BlockingApi;
import com.ning.billing.junction.api.BlockingState;
import com.ning.billing.junction.api.DefaultBlockingState;
import com.ning.billing.lifecycle.KillbillService.ServiceException;
-import com.ning.billing.mock.BrainDeadProxyFactory;
-import com.ning.billing.mock.BrainDeadProxyFactory.ZombieControl;
import com.ning.billing.mock.MockEffectiveSubscriptionEvent;
import com.ning.billing.mock.MockSubscription;
import com.ning.billing.util.api.TagUserApi;
@@ -84,7 +85,6 @@ import static org.testng.Assert.assertNull;
import static org.testng.Assert.assertTrue;
public class TestBillingApi {
-
class MockPrice implements InternationalPrice {
private final BigDecimal price;
@@ -101,7 +101,6 @@ public class TestBillingApi {
public Price[] getPrices() {
return new Price[]{
new Price() {
-
@Override
public Currency getCurrency() {
return Currency.USD;
@@ -155,10 +154,10 @@ public class TestBillingApi {
}
@BeforeMethod(groups = {"fast", "slow"})
- public void setupEveryTime() {
+ public void setupEveryTime() throws EntitlementUserApiException {
final List<SubscriptionBundle> bundles = new ArrayList<SubscriptionBundle>();
- final SubscriptionBundle bundle = BrainDeadProxyFactory.createBrainDeadProxyFor(SubscriptionBundle.class);
- ((ZombieControl) bundle).addResult("getId", bunId);
+ final SubscriptionBundle bundle = Mockito.mock(SubscriptionBundle.class);
+ Mockito.when(bundle.getId()).thenReturn(bunId);
//new SubscriptionBundleData( eventId,"TestKey", subId, clock.getUTCNow().minusDays(4), null);
bundles.add(bundle);
@@ -171,26 +170,27 @@ public class TestBillingApi {
subscriptions.add(subscription);
- entitlementApi = BrainDeadProxyFactory.createBrainDeadProxyFor(EntitlementUserApi.class);
- ((ZombieControl) entitlementApi).addResult("getBundlesForAccount", bundles);
- ((ZombieControl) entitlementApi).addResult("getSubscriptionsForBundle", subscriptions);
- ((ZombieControl) entitlementApi).addResult("getSubscriptionFromId", subscription);
- ((ZombieControl) entitlementApi).addResult("getBundleFromId", bundle);
- ((ZombieControl) entitlementApi).addResult("getBaseSubscription", subscription);
+ entitlementApi = Mockito.mock(EntitlementUserApi.class);
+ Mockito.when(entitlementApi.getBundlesForAccount(Mockito.<UUID>any())).thenReturn(bundles);
+ Mockito.when(entitlementApi.getSubscriptionsForBundle(Mockito.<UUID>any())).thenReturn(subscriptions);
+ Mockito.when(entitlementApi.getSubscriptionFromId(Mockito.<UUID>any())).thenReturn(subscription);
+ Mockito.when(entitlementApi.getBundleFromId(Mockito.<UUID>any())).thenReturn(bundle);
+ Mockito.when(entitlementApi.getBaseSubscription(Mockito.<UUID>any())).thenReturn(subscription);
tagApi = mock(TagUserApi.class);
assertTrue(true);
}
- @Test(enabled = true, groups = "fast")
- public void testBillingEventsEmpty() {
+ @Test(groups = "fast")
+ public void testBillingEventsEmpty() throws AccountApiException {
final UUID accountId = UUID.randomUUID();
- final Account account = BrainDeadProxyFactory.createBrainDeadProxyFor(Account.class);
- ((ZombieControl) account).addResult("getId", accountId).addResult("getCurrency", Currency.USD);
+ final Account account = Mockito.mock(Account.class);
+ Mockito.when(account.getId()).thenReturn(accountId);
+ Mockito.when(account.getCurrency()).thenReturn(Currency.USD);
- final AccountUserApi accountApi = BrainDeadProxyFactory.createBrainDeadProxyFor(AccountUserApi.class);
- ((ZombieControl) accountApi).addResult("getAccountById", account);
+ final AccountUserApi accountApi = Mockito.mock(AccountUserApi.class);
+ Mockito.when(accountApi.getAccountById(Mockito.<UUID>any())).thenReturn(account);
final BillCycleDayCalculator bcdCalculator = new BillCycleDayCalculator(catalogService, entitlementApi);
final CallContextFactory factory = new DefaultCallContextFactory(clock);
@@ -201,8 +201,8 @@ public class TestBillingApi {
Assert.assertEquals(events.size(), 0);
}
- @Test(enabled = true, groups = "fast")
- public void testBillingEventsNoBillingPeriod() throws CatalogApiException {
+ @Test(groups = "fast")
+ public void testBillingEventsNoBillingPeriod() throws CatalogApiException, AccountApiException {
final DateTime now = clock.getUTCNow();
final DateTime then = now.minusDays(1);
final Plan nextPlan = catalogService.getFullCatalog().findPlan("PickupTrialEvergreen10USD", now);
@@ -217,13 +217,13 @@ public class TestBillingApi {
effectiveSubscriptionTransitions.add(t);
- final AccountUserApi accountApi = BrainDeadProxyFactory.createBrainDeadProxyFor(AccountUserApi.class);
- final Account account = BrainDeadProxyFactory.createBrainDeadProxyFor(Account.class);
- ((ZombieControl) account).addResult("getBillCycleDay", 32);
- ((ZombieControl) account).addResult("getCurrency", Currency.USD);
- ((ZombieControl) account).addResult("getId", UUID.randomUUID());
- ((ZombieControl) account).addResult("getTimeZone", DateTimeZone.UTC);
- ((ZombieControl) accountApi).addResult("getAccountById", account);
+ final AccountUserApi accountApi = Mockito.mock(AccountUserApi.class);
+ final Account account = Mockito.mock(Account.class);
+ Mockito.when(account.getBillCycleDay()).thenReturn(32);
+ Mockito.when(account.getCurrency()).thenReturn(Currency.USD);
+ Mockito.when(account.getId()).thenReturn(UUID.randomUUID());
+ Mockito.when(account.getTimeZone()).thenReturn(DateTimeZone.UTC);
+ Mockito.when(accountApi.getAccountById(Mockito.<UUID>any())).thenReturn(account);
final BillCycleDayCalculator bcdCalculator = new BillCycleDayCalculator(catalogService, entitlementApi);
final CallContextFactory factory = new DefaultCallContextFactory(clock);
@@ -234,7 +234,7 @@ public class TestBillingApi {
}
@Test(enabled = false, groups = "fast")
- public void testBillingEventsAnnual() throws CatalogApiException {
+ public void testBillingEventsAnnual() throws CatalogApiException, AccountApiException {
final DateTime now = clock.getUTCNow();
final DateTime then = now.minusDays(1);
final Plan nextPlan = catalogService.getFullCatalog().findPlan("PickupTrialEvergreen10USD", now);
@@ -248,14 +248,15 @@ public class TestBillingApi {
effectiveSubscriptionTransitions.add(t);
- final Account account = BrainDeadProxyFactory.createBrainDeadProxyFor(Account.class);
- ((ZombieControl) account).addResult("getBillCycleDay", 1).addResult("getTimeZone", DateTimeZone.UTC)
- .addResult("getCurrency", Currency.USD);
+ final Account account = Mockito.mock(Account.class);
+ Mockito.when(account.getBillCycleDay()).thenReturn(1);
+ Mockito.when(account.getTimeZone()).thenReturn(DateTimeZone.UTC);
+ Mockito.when(account.getCurrency()).thenReturn(Currency.USD);
((MockCatalog) catalogService.getFullCatalog()).setBillingAlignment(BillingAlignment.SUBSCRIPTION);
- final AccountUserApi accountApi = BrainDeadProxyFactory.createBrainDeadProxyFor(AccountUserApi.class);
- ((ZombieControl) accountApi).addResult("getAccountById", account);
+ final AccountUserApi accountApi = Mockito.mock(AccountUserApi.class);
+ Mockito.when(accountApi.getAccountById(Mockito.<UUID>any())).thenReturn(account);
final BillCycleDayCalculator bcdCalculator = new BillCycleDayCalculator(catalogService, entitlementApi);
final CallContextFactory factory = new DefaultCallContextFactory(clock);
@@ -266,8 +267,8 @@ public class TestBillingApi {
checkFirstEvent(events, nextPlan, subscription.getStartDate().plusDays(30).getDayOfMonth(), subId, now, nextPhase, SubscriptionTransitionType.CREATE.toString());
}
- @Test(enabled = true, groups = "fast")
- public void testBillingEventsMonthly() throws CatalogApiException {
+ @Test(groups = "fast")
+ public void testBillingEventsMonthly() throws CatalogApiException, AccountApiException {
final DateTime now = clock.getUTCNow();
final DateTime then = now.minusDays(1);
final Plan nextPlan = catalogService.getFullCatalog().findPlan("PickupTrialEvergreen10USD", now);
@@ -282,13 +283,13 @@ public class TestBillingApi {
effectiveSubscriptionTransitions.add(t);
- final AccountUserApi accountApi = BrainDeadProxyFactory.createBrainDeadProxyFor(AccountUserApi.class);
- final Account account = BrainDeadProxyFactory.createBrainDeadProxyFor(Account.class);
- ((ZombieControl) account).addResult("getBillCycleDay", 32);
- ((ZombieControl) account).addResult("getCurrency", Currency.USD);
- ((ZombieControl) account).addResult("getId", UUID.randomUUID());
- ((ZombieControl) account).addResult("getTimeZone", DateTimeZone.UTC);
- ((ZombieControl) accountApi).addResult("getAccountById", account);
+ final AccountUserApi accountApi = Mockito.mock(AccountUserApi.class);
+ final Account account = Mockito.mock(Account.class);
+ Mockito.when(account.getBillCycleDay()).thenReturn(32);
+ Mockito.when(account.getCurrency()).thenReturn(Currency.USD);
+ Mockito.when(account.getId()).thenReturn(UUID.randomUUID());
+ Mockito.when(account.getTimeZone()).thenReturn(DateTimeZone.UTC);
+ Mockito.when(accountApi.getAccountById(Mockito.<UUID>any())).thenReturn(account);
((MockCatalog) catalogService.getFullCatalog()).setBillingAlignment(BillingAlignment.ACCOUNT);
@@ -302,7 +303,7 @@ public class TestBillingApi {
}
@Test(enabled = false, groups = "fast")
- public void testBillingEventsAddOn() throws CatalogApiException {
+ public void testBillingEventsAddOn() throws CatalogApiException, AccountApiException {
final DateTime now = clock.getUTCNow();
final DateTime then = now.minusDays(1);
final Plan nextPlan = catalogService.getFullCatalog().findPlan("Horn1USD", now);
@@ -317,14 +318,15 @@ public class TestBillingApi {
effectiveSubscriptionTransitions.add(t);
- final Account account = BrainDeadProxyFactory.createBrainDeadProxyFor(Account.class);
- ((ZombieControl) account).addResult("getBillCycleDay", 1).addResult("getTimeZone", DateTimeZone.UTC);
- ((ZombieControl) account).addResult("getCurrency", Currency.USD);
- ((ZombieControl) account).addResult("getId", UUID.randomUUID());
- ((ZombieControl) account).addResult("getTimeZone", DateTimeZone.UTC);
+ final Account account = Mockito.mock(Account.class);
+ Mockito.when(account.getBillCycleDay()).thenReturn(1);
+ Mockito.when(account.getTimeZone()).thenReturn(DateTimeZone.UTC);
+ Mockito.when(account.getCurrency()).thenReturn(Currency.USD);
+ Mockito.when(account.getId()).thenReturn(UUID.randomUUID());
+ Mockito.when(account.getTimeZone()).thenReturn(DateTimeZone.UTC);
- final AccountUserApi accountApi = BrainDeadProxyFactory.createBrainDeadProxyFor(AccountUserApi.class);
- ((ZombieControl) accountApi).addResult("getAccountById", account);
+ final AccountUserApi accountApi = Mockito.mock(AccountUserApi.class);
+ Mockito.when(accountApi.getAccountById(Mockito.<UUID>any())).thenReturn(account);
((MockCatalog) catalogService.getFullCatalog()).setBillingAlignment(BillingAlignment.BUNDLE);
@@ -339,8 +341,8 @@ public class TestBillingApi {
checkFirstEvent(events, nextPlan, subscription.getStartDate().plusDays(30).getDayOfMonth(), subId, now, nextPhase, SubscriptionTransitionType.CREATE.toString());
}
- @Test(enabled = true, groups = "fast")
- public void testBillingEventsWithBlock() throws CatalogApiException {
+ @Test(groups = "fast")
+ public void testBillingEventsWithBlock() throws CatalogApiException, AccountApiException {
final DateTime now = clock.getUTCNow();
final DateTime then = now.minusDays(1);
final Plan nextPlan = catalogService.getFullCatalog().findPlan("PickupTrialEvergreen10USD", now);
@@ -355,13 +357,13 @@ public class TestBillingApi {
effectiveSubscriptionTransitions.add(t);
- final AccountUserApi accountApi = BrainDeadProxyFactory.createBrainDeadProxyFor(AccountUserApi.class);
- final Account account = BrainDeadProxyFactory.createBrainDeadProxyFor(Account.class);
- ((ZombieControl) account).addResult("getBillCycleDay", 32);
- ((ZombieControl) account).addResult("getCurrency", Currency.USD);
- ((ZombieControl) account).addResult("getTimeZone", DateTimeZone.UTC);
- ((ZombieControl) accountApi).addResult("getAccountById", account);
- ((ZombieControl) account).addResult("getId", UUID.randomUUID());
+ final AccountUserApi accountApi = Mockito.mock(AccountUserApi.class);
+ final Account account = Mockito.mock(Account.class);
+ Mockito.when(account.getBillCycleDay()).thenReturn(32);
+ Mockito.when(account.getCurrency()).thenReturn(Currency.USD);
+ Mockito.when(account.getTimeZone()).thenReturn(DateTimeZone.UTC);
+ Mockito.when(accountApi.getAccountById(Mockito.<UUID>any())).thenReturn(account);
+ Mockito.when(account.getId()).thenReturn(UUID.randomUUID());
((MockCatalog) catalogService.getFullCatalog()).setBillingAlignment(BillingAlignment.ACCOUNT);
@@ -370,7 +372,6 @@ public class TestBillingApi {
blockingStates.add(new DefaultBlockingState(bunId, CLEAR_BUNDLE, Blockable.Type.SUBSCRIPTION_BUNDLE, "test", false, false, false, now.plusDays(2)));
final BlockingCalculator blockingCal = new BlockingCalculator(new BlockingApi() {
-
@Override
public <T extends Blockable> void setBlockingState(final BlockingState state) {
}
@@ -410,11 +411,10 @@ public class TestBillingApi {
checkEvent(it.next(), nextPlan, 32, subId, now, nextPhase, SubscriptionTransitionType.CREATE.toString(), nextPhase.getFixedPrice(), nextPhase.getRecurringPrice());
checkEvent(it.next(), nextPlan, 32, subId, now.plusDays(1), nextPhase, SubscriptionTransitionType.CANCEL.toString(), new MockPrice("0"), new MockPrice("0"));
checkEvent(it.next(), nextPlan, 32, subId, now.plusDays(2), nextPhase, SubscriptionTransitionType.RE_CREATE.toString(), nextPhase.getFixedPrice(), nextPhase.getRecurringPrice());
-
}
- @Test(enabled = true, groups = "fast")
- public void testBillingEventsAutoInvoicingOffAccount() throws CatalogApiException {
+ @Test(groups = "fast")
+ public void testBillingEventsAutoInvoicingOffAccount() throws CatalogApiException, AccountApiException {
final DateTime now = clock.getUTCNow();
final DateTime then = now.minusDays(1);
final Plan nextPlan = catalogService.getFullCatalog().findPlan("PickupTrialEvergreen10USD", now);
@@ -429,12 +429,12 @@ public class TestBillingApi {
effectiveSubscriptionTransitions.add(t);
- final AccountUserApi accountApi = BrainDeadProxyFactory.createBrainDeadProxyFor(AccountUserApi.class);
- final Account account = BrainDeadProxyFactory.createBrainDeadProxyFor(Account.class);
- ((ZombieControl) account).addResult("getBillCycleDay", 32);
- ((ZombieControl) account).addResult("getCurrency", Currency.USD);
- ((ZombieControl) account).addResult("getId", UUID.randomUUID());
- ((ZombieControl) accountApi).addResult("getAccountById", account);
+ final AccountUserApi accountApi = Mockito.mock(AccountUserApi.class);
+ final Account account = Mockito.mock(Account.class);
+ Mockito.when(account.getBillCycleDay()).thenReturn(32);
+ Mockito.when(account.getCurrency()).thenReturn(Currency.USD);
+ Mockito.when(account.getId()).thenReturn(UUID.randomUUID());
+ Mockito.when(accountApi.getAccountById(Mockito.<UUID>any())).thenReturn(account);
final Map<String, Tag> tags = new HashMap<String, Tag>();
final Tag aioTag = mock(Tag.class);
@@ -455,8 +455,8 @@ public class TestBillingApi {
assertEquals(events.size(), 0);
}
- @Test(enabled = true, groups = "fast")
- public void testBillingEventsAutoInvoicingOffBundle() throws CatalogApiException {
+ @Test(groups = "fast")
+ public void testBillingEventsAutoInvoicingOffBundle() throws CatalogApiException, AccountApiException {
final DateTime now = clock.getUTCNow();
final DateTime then = now.minusDays(1);
final Plan nextPlan = catalogService.getFullCatalog().findPlan("PickupTrialEvergreen10USD", now);
@@ -471,12 +471,12 @@ public class TestBillingApi {
effectiveSubscriptionTransitions.add(t);
- final AccountUserApi accountApi = BrainDeadProxyFactory.createBrainDeadProxyFor(AccountUserApi.class);
- final Account account = BrainDeadProxyFactory.createBrainDeadProxyFor(Account.class);
- ((ZombieControl) account).addResult("getBillCycleDay", 32);
- ((ZombieControl) account).addResult("getCurrency", Currency.USD);
- ((ZombieControl) account).addResult("getId", UUID.randomUUID());
- ((ZombieControl) accountApi).addResult("getAccountById", account);
+ final AccountUserApi accountApi = Mockito.mock(AccountUserApi.class);
+ final Account account = Mockito.mock(Account.class);
+ Mockito.when(account.getBillCycleDay()).thenReturn(32);
+ Mockito.when(account.getCurrency()).thenReturn(Currency.USD);
+ Mockito.when(account.getId()).thenReturn(UUID.randomUUID());
+ Mockito.when(accountApi.getAccountById(Mockito.<UUID>any())).thenReturn(account);
final Map<String, Tag> tags = new HashMap<String, Tag>();
final Tag aioTag = mock(Tag.class);
diff --git a/junction/src/test/java/com/ning/billing/junction/plumbing/billing/TestBlockingCalculator.java b/junction/src/test/java/com/ning/billing/junction/plumbing/billing/TestBlockingCalculator.java
index ce0b6dc..4eb6773 100644
--- a/junction/src/test/java/com/ning/billing/junction/plumbing/billing/TestBlockingCalculator.java
+++ b/junction/src/test/java/com/ning/billing/junction/plumbing/billing/TestBlockingCalculator.java
@@ -27,6 +27,7 @@ import java.util.UUID;
import org.joda.time.DateTime;
import org.joda.time.DateTimeZone;
+import org.mockito.Mockito;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
@@ -51,8 +52,6 @@ import com.ning.billing.junction.api.BlockingState;
import com.ning.billing.junction.api.DefaultBlockingState;
import com.ning.billing.junction.dao.BlockingStateDao;
import com.ning.billing.junction.plumbing.billing.BlockingCalculator.DisabledDuration;
-import com.ning.billing.mock.BrainDeadProxyFactory;
-import com.ning.billing.mock.BrainDeadProxyFactory.ZombieControl;
import com.ning.billing.util.clock.Clock;
import com.ning.billing.util.clock.ClockMock;
@@ -60,9 +59,7 @@ import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertNotNull;
import static org.testng.Assert.assertNull;
-
public class TestBlockingCalculator {
-
private static final String DISABLED_BUNDLE = "disabled-bundle";
private static final String CLEAR_BUNDLE = "clear-bundle";
@@ -79,37 +76,29 @@ public class TestBlockingCalculator {
@BeforeClass
public void setUpBeforeClass() throws Exception {
-
clock = new ClockMock();
final Injector i = Guice.createInjector(new AbstractModule() {
-
@Override
protected void configure() {
- blockingApi = BrainDeadProxyFactory.createBrainDeadProxyFor(BlockingApi.class);
- account = BrainDeadProxyFactory.createBrainDeadProxyFor(Account.class);
- subscription1 = BrainDeadProxyFactory.createBrainDeadProxyFor(Subscription.class, Comparable.class);
- subscription2 = BrainDeadProxyFactory.createBrainDeadProxyFor(Subscription.class, Comparable.class);
- subscription3 = BrainDeadProxyFactory.createBrainDeadProxyFor(Subscription.class, Comparable.class);
- subscription4 = BrainDeadProxyFactory.createBrainDeadProxyFor(Subscription.class, Comparable.class);
- ((ZombieControl) account).addResult("getId", UUID.randomUUID());
- ((ZombieControl) subscription1).addResult("getBundleId", bundleId1);
- ((ZombieControl) subscription2).addResult("getBundleId", bundleId1);
- ((ZombieControl) subscription3).addResult("getBundleId", bundleId1);
- ((ZombieControl) subscription4).addResult("getBundleId", bundleId2);
- ((ZombieControl) subscription1).addResult("compareTo", 1);
- ((ZombieControl) subscription2).addResult("compareTo", 1);
- ((ZombieControl) subscription3).addResult("compareTo", 1);
- ((ZombieControl) subscription4).addResult("compareTo", 1);
- ((ZombieControl) subscription1).addResult("getId", UUID.randomUUID());
- ((ZombieControl) subscription2).addResult("getId", UUID.randomUUID());
- ((ZombieControl) subscription3).addResult("getId", UUID.randomUUID());
- ((ZombieControl) subscription4).addResult("getId", UUID.randomUUID());
-
-
- bind(BlockingStateDao.class).toInstance(BrainDeadProxyFactory.createBrainDeadProxyFor(BlockingStateDao.class));
+ blockingApi = Mockito.mock(BlockingApi.class);
+ account = Mockito.mock(Account.class);
+ subscription1 = Mockito.mock(Subscription.class);
+ subscription2 = Mockito.mock(Subscription.class);
+ subscription3 = Mockito.mock(Subscription.class);
+ subscription4 = Mockito.mock(Subscription.class);
+ Mockito.when(account.getId()).thenReturn(UUID.randomUUID());
+ Mockito.when(subscription1.getBundleId()).thenReturn(bundleId1);
+ Mockito.when(subscription2.getBundleId()).thenReturn(bundleId1);
+ Mockito.when(subscription3.getBundleId()).thenReturn(bundleId1);
+ Mockito.when(subscription4.getBundleId()).thenReturn(bundleId2);
+ Mockito.when(subscription1.getId()).thenReturn(UUID.randomUUID());
+ Mockito.when(subscription2.getId()).thenReturn(UUID.randomUUID());
+ Mockito.when(subscription3.getId()).thenReturn(UUID.randomUUID());
+ Mockito.when(subscription4.getId()).thenReturn(UUID.randomUUID());
+
+ bind(BlockingStateDao.class).toInstance(Mockito.mock(BlockingStateDao.class));
bind(BlockingApi.class).toInstance(blockingApi);
-
}
});
@@ -117,19 +106,17 @@ public class TestBlockingCalculator {
}
- @Test
// S1-S2-S3 subscriptions in B1
// B1 -----[--------]
// S1 --A-------------------------------------
// S2 --B------C------------------------------
// S3 ------------------D---------------------
-
//Result
// S1 --A--[-------]--------------------------
// S2 --B--[-------]--------------------------
// S3 ------------------D---------------------
-
+ @Test
public void testInsertBlockingEvents() {
final DateTime now = clock.getUTCNow();
final List<DisabledDuration> disabledDuration = new ArrayList<BlockingCalculator.DisabledDuration>();
@@ -149,8 +136,7 @@ public class TestBlockingCalculator {
blockingStates.add(new DefaultBlockingState(bundleId1, DISABLED_BUNDLE, Blockable.Type.SUBSCRIPTION_BUNDLE, "test", true, true, true, now));
blockingStates.add(new DefaultBlockingState(bundleId1, CLEAR_BUNDLE, Blockable.Type.SUBSCRIPTION_BUNDLE, "test", false, false, false, now.plusDays(2)));
- ((ZombieControl) blockingApi).addResult("getBlockingHistory", blockingStates);
-
+ Mockito.when(blockingApi.getBlockingHistory(Mockito.<Blockable>anyObject())).thenReturn(blockingStates);
odc.insertBlockingEvents(billingEvents);
@@ -258,7 +244,6 @@ public class TestBlockingCalculator {
billingEvents.add(e1);
billingEvents.add(e2);
-
final SortedSet<BillingEvent> results = odc.eventsToRemove(disabledDuration, billingEvents, subscription1);
assertEquals(results.size(), 1);
@@ -299,7 +284,6 @@ public class TestBlockingCalculator {
final BillingEvent e2 = createRealEvent(now.plusDays(1), subscription1);
billingEvents.add(e2);
-
final SortedSet<BillingEvent> results = odc.eventsToRemove(disabledDuration, billingEvents, subscription1);
assertEquals(results.size(), 1);
@@ -566,7 +550,6 @@ public class TestBlockingCalculator {
description, totalOrdering, type, tz);
}
-
@Test
public void testFilter() {
final SortedSet<BillingEvent> events = new TreeSet<BillingEvent>();
@@ -653,9 +636,9 @@ public class TestBlockingCalculator {
}
private BillingEvent createBillingEvent(final Subscription subscription) {
- final BillingEvent result = BrainDeadProxyFactory.createBrainDeadProxyFor(BillingEvent.class, Comparable.class);
- ((ZombieControl) result).addResult("getSubscription", subscription);
- ((ZombieControl) result).addResult("compareTo", 1);
+ final BillingEvent result = Mockito.mock(BillingEvent.class);
+ Mockito.when(result.getSubscription()).thenReturn(subscription);
+ Mockito.when(result.compareTo(Mockito.<BillingEvent>any())).thenReturn(1);
return result;
}
@@ -702,7 +685,6 @@ public class TestBlockingCalculator {
assertNotNull(pairs.get(0).getEnd());
assertEquals(pairs.get(0).getEnd(), now.plusDays(2));
-
//two or more disableds in a row
blockingEvents = new TreeSet<BlockingState>();
blockingEvents.add(new DefaultBlockingState(ovdId, CLEAR_BUNDLE, Type.SUBSCRIPTION_BUNDLE, "test", false, false, false, now));
@@ -717,7 +699,6 @@ public class TestBlockingCalculator {
assertNotNull(pairs.get(0).getEnd());
assertEquals(pairs.get(0).getEnd(), now.plusDays(3));
-
blockingEvents = new TreeSet<BlockingState>();
blockingEvents.add(new DefaultBlockingState(ovdId, CLEAR_BUNDLE, Type.SUBSCRIPTION_BUNDLE, "test", false, false, false, now));
blockingEvents.add(new DefaultBlockingState(ovdId, DISABLED_BUNDLE, Type.SUBSCRIPTION_BUNDLE, "test", true, true, true, now.plusDays(1)));
@@ -731,6 +712,5 @@ public class TestBlockingCalculator {
assertEquals(pairs.get(0).getStart(), now.plusDays(1));
assertNotNull(pairs.get(0).getEnd());
assertEquals(pairs.get(0).getEnd(), now.plusDays(4));
-
}
}
diff --git a/junction/src/test/java/com/ning/billing/junction/plumbing/billing/TestDefaultBillingEvent.java b/junction/src/test/java/com/ning/billing/junction/plumbing/billing/TestDefaultBillingEvent.java
index 6a6abfb..c52d033 100644
--- a/junction/src/test/java/com/ning/billing/junction/plumbing/billing/TestDefaultBillingEvent.java
+++ b/junction/src/test/java/com/ning/billing/junction/plumbing/billing/TestDefaultBillingEvent.java
@@ -25,6 +25,7 @@ import java.util.UUID;
import org.joda.time.DateTime;
import org.joda.time.DateTimeZone;
+import org.mockito.Mockito;
import org.testng.Assert;
import org.testng.annotations.Test;
@@ -41,15 +42,13 @@ import com.ning.billing.entitlement.api.SubscriptionTransitionType;
import com.ning.billing.entitlement.api.billing.BillingEvent;
import com.ning.billing.entitlement.api.billing.BillingModeType;
import com.ning.billing.entitlement.api.user.Subscription;
-import com.ning.billing.mock.BrainDeadProxyFactory;
-import com.ning.billing.mock.BrainDeadProxyFactory.ZombieControl;
public class TestDefaultBillingEvent {
public static final UUID ID_ZERO = new UUID(0L, 0L);
public static final UUID ID_ONE = new UUID(0L, 1L);
public static final UUID ID_TWO = new UUID(0L, 2L);
- @Test(groups = {"fast"})
+ @Test(groups = "fast")
public void testEventOrderingSubscription() {
final BillingEvent event0 = createEvent(subscription(ID_ZERO), new DateTime("2012-01-31T00:02:04.000Z"), SubscriptionTransitionType.CREATE);
@@ -68,9 +67,8 @@ public class TestDefaultBillingEvent {
Assert.assertEquals(event2, it.next());
}
- @Test(groups = {"fast"})
+ @Test(groups = "fast")
public void testEventOrderingDate() {
-
final BillingEvent event0 = createEvent(subscription(ID_ZERO), new DateTime("2012-01-01T00:02:04.000Z"), SubscriptionTransitionType.CREATE);
final BillingEvent event1 = createEvent(subscription(ID_ZERO), new DateTime("2012-02-01T00:02:04.000Z"), SubscriptionTransitionType.CREATE);
final BillingEvent event2 = createEvent(subscription(ID_ZERO), new DateTime("2012-03-01T00:02:04.000Z"), SubscriptionTransitionType.CREATE);
@@ -87,9 +85,8 @@ public class TestDefaultBillingEvent {
Assert.assertEquals(event2, it.next());
}
- @Test(groups = {"fast"})
+ @Test(groups = "fast")
public void testEventTotalOrdering() {
-
final BillingEvent event0 = createEvent(subscription(ID_ZERO), new DateTime("2012-01-01T00:02:04.000Z"), SubscriptionTransitionType.CREATE, 1L);
final BillingEvent event1 = createEvent(subscription(ID_ZERO), new DateTime("2012-01-01T00:02:04.000Z"), SubscriptionTransitionType.CANCEL, 2L);
final BillingEvent event2 = createEvent(subscription(ID_ZERO), new DateTime("2012-01-01T00:02:04.000Z"), SubscriptionTransitionType.RE_CREATE, 3L);
@@ -106,9 +103,8 @@ public class TestDefaultBillingEvent {
Assert.assertEquals(event2, it.next());
}
- @Test(groups = {"fast"})
+ @Test(groups = "fast")
public void testEventOrderingMix() {
-
final BillingEvent event0 = createEvent(subscription(ID_ZERO), new DateTime("2012-01-01T00:02:04.000Z"), SubscriptionTransitionType.CREATE);
final BillingEvent event1 = createEvent(subscription(ID_ZERO), new DateTime("2012-01-02T00:02:04.000Z"), SubscriptionTransitionType.CHANGE);
final BillingEvent event2 = createEvent(subscription(ID_ONE), new DateTime("2012-01-01T00:02:04.000Z"), SubscriptionTransitionType.CANCEL);
@@ -149,9 +145,8 @@ public class TestDefaultBillingEvent {
}
private Subscription subscription(final UUID id) {
- final Subscription subscription = BrainDeadProxyFactory.createBrainDeadProxyFor(Subscription.class);
- ((ZombieControl) subscription).addResult("getId", id);
+ final Subscription subscription = Mockito.mock(Subscription.class);
+ Mockito.when(subscription.getId()).thenReturn(id);
return subscription;
}
-
}
