killbill-uncached

diff --git a/overdue/pom.xml b/overdue/pom.xml
index 9e1e589..97eda9c 100644
--- a/overdue/pom.xml
+++ b/overdue/pom.xml
@@ -99,6 +99,11 @@
             <artifactId>awaitility</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-all</artifactId>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
     <build>
         <plugins>

diff --git a/overdue/src/test/java/com/ning/billing/overdue/applicator/TestOverdueStateApplicator.java b/overdue/src/test/java/com/ning/billing/overdue/applicator/TestOverdueStateApplicator.java
index a58ac39..a31c78f 100644
--- a/overdue/src/test/java/com/ning/billing/overdue/applicator/TestOverdueStateApplicator.java
+++ b/overdue/src/test/java/com/ning/billing/overdue/applicator/TestOverdueStateApplicator.java
@@ -16,31 +16,28 @@
 
 package com.ning.billing.overdue.applicator;
 
-
-import static com.jayway.awaitility.Awaitility.await;
-import static java.util.concurrent.TimeUnit.SECONDS;
-
 import java.io.ByteArrayInputStream;
 import java.io.InputStream;
 import java.util.List;
 import java.util.UUID;
 import java.util.concurrent.Callable;
 
-import junit.framework.Assert;
-
+import org.mockito.Mockito;
 import org.testng.annotations.Test;
 
 import com.google.inject.Inject;
 import com.ning.billing.entitlement.api.user.SubscriptionBundle;
 import com.ning.billing.junction.api.BlockingApi;
-import com.ning.billing.mock.BrainDeadProxyFactory;
-import com.ning.billing.mock.BrainDeadProxyFactory.ZombieControl;
 import com.ning.billing.overdue.OverdueChangeEvent;
 import com.ning.billing.overdue.OverdueState;
 import com.ning.billing.overdue.OverdueTestBase;
 import com.ning.billing.overdue.config.OverdueConfig;
 import com.ning.billing.util.bus.Bus;
 import com.ning.billing.util.config.XMLLoader;
+import junit.framework.Assert;
+
+import static com.jayway.awaitility.Awaitility.await;
+import static java.util.concurrent.TimeUnit.SECONDS;
 
 public class TestOverdueStateApplicator extends OverdueTestBase {
     @Inject
@@ -48,10 +45,9 @@ public class TestOverdueStateApplicator extends OverdueTestBase {
 
     @Inject
     OverdueBusListenerTester listener;
-    
-    @Inject 
+
+    @Inject
     Bus bus;
-    
 
     @Test(groups = {"slow"}, enabled = true)
     public void testApplicator() throws Exception {
@@ -61,8 +57,8 @@ public class TestOverdueStateApplicator extends OverdueTestBase {
         config = XMLLoader.getObjectFromStreamNoValidation(is, OverdueConfig.class);
         overdueWrapperFactory.setOverdueConfig(config);
 
-        final SubscriptionBundle bundle = BrainDeadProxyFactory.createBrainDeadProxyFor(SubscriptionBundle.class);
-        ((ZombieControl) bundle).addResult("getId", UUID.randomUUID());
+        final SubscriptionBundle bundle = Mockito.mock(SubscriptionBundle.class);
+        Mockito.when(bundle.getId()).thenReturn(UUID.randomUUID());
 
         OverdueState<SubscriptionBundle> state;
 
@@ -70,24 +66,19 @@ public class TestOverdueStateApplicator extends OverdueTestBase {
         applicator.apply(bundle, BlockingApi.CLEAR_STATE_NAME, state);
         checkStateApplied(state);
         checkBussEvent("OD1");
-        
-
 
         state = config.getBundleStateSet().findState("OD2");
         applicator.apply(bundle, BlockingApi.CLEAR_STATE_NAME, state);
         checkStateApplied(state);
         checkBussEvent("OD2");
-        
 
         state = config.getBundleStateSet().findState("OD3");
         applicator.apply(bundle, BlockingApi.CLEAR_STATE_NAME, state);
         checkStateApplied(state);
         checkBussEvent("OD3");
         bus.stop();
-
     }
 
-
     private void checkBussEvent(final String state) throws Exception {
         await().atMost(10, SECONDS).until(new Callable<Boolean>() {
             @Override

diff --git a/overdue/src/test/java/com/ning/billing/overdue/calculator/TestBillingStateCalculator.java b/overdue/src/test/java/com/ning/billing/overdue/calculator/TestBillingStateCalculator.java
index 8f38f08..3ec4785 100644
--- a/overdue/src/test/java/com/ning/billing/overdue/calculator/TestBillingStateCalculator.java
+++ b/overdue/src/test/java/com/ning/billing/overdue/calculator/TestBillingStateCalculator.java
@@ -24,6 +24,7 @@ import java.util.SortedSet;
 import java.util.UUID;
 
 import org.joda.time.DateTime;
+import org.mockito.Mockito;
 import org.testng.Assert;
 import org.testng.annotations.Test;
 
@@ -31,16 +32,13 @@ import com.ning.billing.entitlement.api.user.SubscriptionBundle;
 import com.ning.billing.invoice.api.Invoice;
 import com.ning.billing.invoice.api.InvoiceItem;
 import com.ning.billing.invoice.api.InvoiceUserApi;
-import com.ning.billing.mock.BrainDeadProxyFactory;
-import com.ning.billing.mock.BrainDeadProxyFactory.ZombieControl;
 import com.ning.billing.overdue.config.api.BillingState;
 import com.ning.billing.util.clock.Clock;
 import com.ning.billing.util.clock.ClockMock;
 
 public class TestBillingStateCalculator {
     Clock clock = new ClockMock();
-    InvoiceUserApi invoiceApi = BrainDeadProxyFactory.createBrainDeadProxyFor(InvoiceUserApi.class);
-    private int hash = 0;
+    InvoiceUserApi invoiceApi = Mockito.mock(InvoiceUserApi.class);
     DateTime now;
 
     public BillingStateCalculator<SubscriptionBundle> createBSCalc() {
@@ -50,7 +48,7 @@ public class TestBillingStateCalculator {
         invoices.add(createInvoice(now.plusDays(1), BigDecimal.TEN, null));
         invoices.add(createInvoice(now.plusDays(2), new BigDecimal("100.0"), null));
 
-        ((ZombieControl) invoiceApi).addResult("getUnpaidInvoicesByAccountId", invoices);
+        Mockito.when(invoiceApi.getUnpaidInvoicesByAccountId(Mockito.<UUID>any(), Mockito.<DateTime>any())).thenReturn(invoices);
 
         return new BillingStateCalculator<SubscriptionBundle>(invoiceApi, clock) {
             @Override
@@ -62,12 +60,11 @@ public class TestBillingStateCalculator {
     }
 
     public Invoice createInvoice(final DateTime date, final BigDecimal balance, final List<InvoiceItem> invoiceItems) {
-        final Invoice invoice = BrainDeadProxyFactory.createBrainDeadProxyFor(Invoice.class);
-        ((ZombieControl) invoice).addResult("getBalance", balance);
-        ((ZombieControl) invoice).addResult("getInvoiceDate", date);
-        ((ZombieControl) invoice).addResult("hashCode", hash++);
-        ((ZombieControl) invoice).addResult("getInvoiceItems", invoiceItems);
-        ((ZombieControl) invoice).addResult("getId", UUID.randomUUID());
+        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;
     }
@@ -97,6 +94,4 @@ public class TestBillingStateCalculator {
         final SortedSet<Invoice> invoices = calc.unpaidInvoicesForAccount(new UUID(0L, 0L));
         Assert.assertEquals(calc.earliest(invoices).getInvoiceDate(), now);
     }
-
-
 }

diff --git a/overdue/src/test/java/com/ning/billing/overdue/calculator/TestBillingStateCalculatorBundle.java b/overdue/src/test/java/com/ning/billing/overdue/calculator/TestBillingStateCalculatorBundle.java
index dc5b6a4..2d7eebb 100644
--- a/overdue/src/test/java/com/ning/billing/overdue/calculator/TestBillingStateCalculatorBundle.java
+++ b/overdue/src/test/java/com/ning/billing/overdue/calculator/TestBillingStateCalculatorBundle.java
@@ -16,6 +16,7 @@
 
 package com.ning.billing.overdue.calculator;
 
+import javax.annotation.Nullable;
 import java.math.BigDecimal;
 import java.util.ArrayList;
 import java.util.List;
@@ -23,9 +24,12 @@ import java.util.SortedSet;
 import java.util.UUID;
 
 import org.joda.time.DateTime;
+import org.mockito.Mockito;
 import org.testng.Assert;
 import org.testng.annotations.Test;
 
+import com.google.common.base.Predicate;
+import com.google.common.collect.Collections2;
 import com.ning.billing.catalog.MockPlan;
 import com.ning.billing.catalog.MockPriceList;
 import com.ning.billing.catalog.api.Plan;
@@ -36,8 +40,6 @@ import com.ning.billing.entitlement.api.user.SubscriptionBundle;
 import com.ning.billing.invoice.api.Invoice;
 import com.ning.billing.invoice.api.InvoiceItem;
 import com.ning.billing.invoice.api.InvoiceUserApi;
-import com.ning.billing.mock.BrainDeadProxyFactory;
-import com.ning.billing.mock.BrainDeadProxyFactory.ZombieControl;
 import com.ning.billing.overdue.config.api.BillingStateBundle;
 import com.ning.billing.overdue.config.api.PaymentResponse;
 import com.ning.billing.util.clock.Clock;
@@ -45,12 +47,11 @@ import com.ning.billing.util.clock.ClockMock;
 
 public class TestBillingStateCalculatorBundle extends TestBillingStateCalculator {
 
-
     private List<InvoiceItem> createInvoiceItems(final UUID[] bundleIds) {
         final List<InvoiceItem> result = new ArrayList<InvoiceItem>();
         for (final UUID id : bundleIds) {
-            final InvoiceItem ii = BrainDeadProxyFactory.createBrainDeadProxyFor(InvoiceItem.class);
-            ((ZombieControl) ii).addResult("getBundleId", id);
+            final InvoiceItem ii = Mockito.mock(InvoiceItem.class);
+            Mockito.when(ii.getBundleId()).thenReturn(id);
             result.add(ii);
         }
         return result;
@@ -64,30 +65,32 @@ public class TestBillingStateCalculatorBundle extends TestBillingStateCalculator
         now = new DateTime();
         final List<Invoice> invoices = new ArrayList<Invoice>(5);
         invoices.add(createInvoice(now, BigDecimal.ZERO, createInvoiceItems(new UUID[]{thisBundleId, thatBundleId})));
-        invoices.add(createInvoice(now, BigDecimal.TEN, createInvoiceItems(new UUID[]{thatBundleId})));
-        invoices.add(createInvoice(now, new BigDecimal("100.00"), createInvoiceItems(new UUID[]{thatBundleId, thisBundleId, thatBundleId})));
-        invoices.add(createInvoice(now, new BigDecimal("1000.00"), createInvoiceItems(new UUID[]{thisBundleId})));
-        invoices.add(createInvoice(now, new BigDecimal("10000.00"), createInvoiceItems(new UUID[]{thatBundleId, thisBundleId})));
-
+        // Will not be seen below
+        invoices.add(createInvoice(now.plusDays(1), BigDecimal.TEN, createInvoiceItems(new UUID[]{thatBundleId})));
+        invoices.add(createInvoice(now.plusDays(2), new BigDecimal("100.00"), createInvoiceItems(new UUID[]{thatBundleId, thisBundleId, thatBundleId})));
+        invoices.add(createInvoice(now.plusDays(3), new BigDecimal("1000.00"), createInvoiceItems(new UUID[]{thisBundleId})));
+        invoices.add(createInvoice(now.plusDays(4), new BigDecimal("10000.00"), createInvoiceItems(new UUID[]{thatBundleId, thisBundleId})));
 
         final Clock clock = new ClockMock();
-        final InvoiceUserApi invoiceApi = BrainDeadProxyFactory.createBrainDeadProxyFor(InvoiceUserApi.class);
-        final EntitlementUserApi entitlementApi = BrainDeadProxyFactory.createBrainDeadProxyFor(EntitlementUserApi.class);
-        ((ZombieControl) invoiceApi).addResult("getUnpaidInvoicesByAccountId", invoices);
-
+        final InvoiceUserApi invoiceApi = Mockito.mock(InvoiceUserApi.class);
+        final EntitlementUserApi entitlementApi = Mockito.mock(EntitlementUserApi.class);
+        Mockito.when(invoiceApi.getUnpaidInvoicesByAccountId(Mockito.<UUID>any(), Mockito.<DateTime>any())).thenReturn(Collections2.filter(invoices, new Predicate<Invoice>() {
+            @Override
+            public boolean apply(@Nullable final Invoice invoice) {
+                return invoice != null && BigDecimal.ZERO.compareTo(invoice.getBalance()) < 0;
+            }
+        }));
 
         final BillingStateCalculatorBundle calc = new BillingStateCalculatorBundle(entitlementApi, invoiceApi, clock);
         final SortedSet<Invoice> resultinvoices = calc.unpaidInvoicesForBundle(thisBundleId, new UUID(0L, 0L));
 
-        Assert.assertEquals(resultinvoices.size(), 4);
-        Assert.assertEquals(BigDecimal.ZERO.compareTo(resultinvoices.first().getBalance()), 0);
+        Assert.assertEquals(resultinvoices.size(), 3);
+        Assert.assertEquals(new BigDecimal("100.0").compareTo(resultinvoices.first().getBalance()), 0);
         Assert.assertEquals(new BigDecimal("10000.0").compareTo(resultinvoices.last().getBalance()), 0);
-
     }
 
     @Test(groups = {"fast"}, enabled = true)
     public void testcalculateBillingStateForBundle() throws Exception {
-
         final UUID thisBundleId = new UUID(0L, 0L);
         final UUID thatBundleId = new UUID(0L, 1L);
 
@@ -99,24 +102,23 @@ public class TestBillingStateCalculatorBundle extends TestBillingStateCalculator
         invoices.add(createInvoice(now.minusDays(2), new BigDecimal("1000.00"), createInvoiceItems(new UUID[]{thisBundleId})));
         invoices.add(createInvoice(now.minusDays(1), new BigDecimal("10000.00"), createInvoiceItems(new UUID[]{thatBundleId, thisBundleId})));
 
-
         final Clock clock = new ClockMock();
-        final InvoiceUserApi invoiceApi = BrainDeadProxyFactory.createBrainDeadProxyFor(InvoiceUserApi.class);
-        ((ZombieControl) invoiceApi).addResult("getUnpaidInvoicesByAccountId", invoices);
+        final InvoiceUserApi invoiceApi = Mockito.mock(InvoiceUserApi.class);
+        Mockito.when(invoiceApi.getUnpaidInvoicesByAccountId(Mockito.<UUID>any(), Mockito.<DateTime>any())).thenReturn(invoices);
 
-        final SubscriptionBundle bundle = BrainDeadProxyFactory.createBrainDeadProxyFor(SubscriptionBundle.class);
-        ((ZombieControl) bundle).addResult("getId", thisBundleId);
-        ((ZombieControl) bundle).addResult("getAccountId", UUID.randomUUID());
+        final SubscriptionBundle bundle = Mockito.mock(SubscriptionBundle.class);
+        Mockito.when(bundle.getId()).thenReturn(thisBundleId);
+        Mockito.when(bundle.getAccountId()).thenReturn(UUID.randomUUID());
 
-        final EntitlementUserApi entitlementApi = BrainDeadProxyFactory.createBrainDeadProxyFor(EntitlementUserApi.class);
-        final Subscription subscription = BrainDeadProxyFactory.createBrainDeadProxyFor(Subscription.class);
-        ((ZombieControl) entitlementApi).addResult("getBaseSubscription", subscription);
+        final EntitlementUserApi entitlementApi = Mockito.mock(EntitlementUserApi.class);
+        final Subscription subscription = Mockito.mock(Subscription.class);
+        Mockito.when(entitlementApi.getBaseSubscription(Mockito.<UUID>any())).thenReturn(subscription);
 
         final Plan plan = MockPlan.createBicycleNoTrialEvergreen1USD();
         final PriceList pricelist = new MockPriceList();
-        ((ZombieControl) subscription).addResult("getCurrentPlan", plan);
-        ((ZombieControl) subscription).addResult("getCurrentPriceList", pricelist);
-        ((ZombieControl) subscription).addResult("getCurrentPhase", plan.getFinalPhase());
+        Mockito.when(subscription.getCurrentPlan()).thenReturn(plan);
+        Mockito.when(subscription.getCurrentPriceList()).thenReturn(pricelist);
+        Mockito.when(subscription.getCurrentPhase()).thenReturn(plan.getFinalPhase());
 
         final BillingStateCalculatorBundle calc = new BillingStateCalculatorBundle(entitlementApi, invoiceApi, clock);
 
@@ -134,33 +136,30 @@ public class TestBillingStateCalculatorBundle extends TestBillingStateCalculator
 
     }
 
-
     @Test(groups = {"fast"}, enabled = true)
     public void testcalculateBillingStateForBundleNoOverdueInvoices() throws Exception {
-
         final UUID thisBundleId = new UUID(0L, 0L);
-        final UUID thatBundleId = new UUID(0L, 1L);
 
         now = new DateTime();
         final List<Invoice> invoices = new ArrayList<Invoice>(5);
 
         final Clock clock = new ClockMock();
-        final InvoiceUserApi invoiceApi = BrainDeadProxyFactory.createBrainDeadProxyFor(InvoiceUserApi.class);
-        ((ZombieControl) invoiceApi).addResult("getUnpaidInvoicesByAccountId", invoices);
+        final InvoiceUserApi invoiceApi = Mockito.mock(InvoiceUserApi.class);
+        Mockito.when(invoiceApi.getUnpaidInvoicesByAccountId(Mockito.<UUID>any(), Mockito.<DateTime>any())).thenReturn(invoices);
 
-        final SubscriptionBundle bundle = BrainDeadProxyFactory.createBrainDeadProxyFor(SubscriptionBundle.class);
-        ((ZombieControl) bundle).addResult("getId", thisBundleId);
-        ((ZombieControl) bundle).addResult("getAccountId", UUID.randomUUID());
+        final SubscriptionBundle bundle = Mockito.mock(SubscriptionBundle.class);
+        Mockito.when(bundle.getId()).thenReturn(thisBundleId);
+        Mockito.when(bundle.getAccountId()).thenReturn(UUID.randomUUID());
 
-        final EntitlementUserApi entitlementApi = BrainDeadProxyFactory.createBrainDeadProxyFor(EntitlementUserApi.class);
-        final Subscription subscription = BrainDeadProxyFactory.createBrainDeadProxyFor(Subscription.class);
-        ((ZombieControl) entitlementApi).addResult("getBaseSubscription", subscription);
+        final EntitlementUserApi entitlementApi = Mockito.mock(EntitlementUserApi.class);
+        final Subscription subscription = Mockito.mock(Subscription.class);
+        Mockito.when(entitlementApi.getBaseSubscription(Mockito.<UUID>any())).thenReturn(subscription);
 
         final Plan plan = MockPlan.createBicycleNoTrialEvergreen1USD();
         final PriceList pricelist = new MockPriceList();
-        ((ZombieControl) subscription).addResult("getCurrentPlan", plan);
-        ((ZombieControl) subscription).addResult("getCurrentPriceList", pricelist);
-        ((ZombieControl) subscription).addResult("getCurrentPhase", plan.getFinalPhase());
+        Mockito.when(subscription.getCurrentPlan()).thenReturn(plan);
+        Mockito.when(subscription.getCurrentPriceList()).thenReturn(pricelist);
+        Mockito.when(subscription.getCurrentPhase()).thenReturn(plan.getFinalPhase());
 
         final BillingStateCalculatorBundle calc = new BillingStateCalculatorBundle(entitlementApi, invoiceApi, clock);
 
@@ -181,6 +180,4 @@ public class TestBillingStateCalculatorBundle extends TestBillingStateCalculator
     public void testCorrectBehaviorForNoOverdueConfig() {
         //TODO with no overdue config the system should be fine - take no action but see no NPEs
     }
-
-
 }

diff --git a/overdue/src/test/java/com/ning/billing/overdue/notification/TestOverdueCheckNotifier.java b/overdue/src/test/java/com/ning/billing/overdue/notification/TestOverdueCheckNotifier.java
index a098a25..53b28bc 100644
--- a/overdue/src/test/java/com/ning/billing/overdue/notification/TestOverdueCheckNotifier.java
+++ b/overdue/src/test/java/com/ning/billing/overdue/notification/TestOverdueCheckNotifier.java
@@ -22,6 +22,7 @@ import java.util.UUID;
 import java.util.concurrent.Callable;
 
 import org.joda.time.DateTime;
+import org.mockito.Mockito;
 import org.skife.config.ConfigurationObjectFactory;
 import org.skife.jdbi.v2.IDBI;
 import org.testng.Assert;
@@ -39,11 +40,10 @@ import com.ning.billing.config.InvoiceConfig;
 import com.ning.billing.dbi.MysqlTestingHelper;
 import com.ning.billing.entitlement.api.billing.ChargeThruApi;
 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.junction.api.Blockable;
 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.glue.MockInvoiceModule;
 import com.ning.billing.mock.glue.MockJunctionModule;
 import com.ning.billing.mock.glue.MockPaymentModule;
@@ -106,9 +106,8 @@ public class TestOverdueCheckNotifier {
 
     }
 
-
     @BeforeClass(groups = {"slow"})
-    public void setup() throws ServiceException, IOException, ClassNotFoundException, SQLException {
+    public void setup() throws ServiceException, IOException, ClassNotFoundException, SQLException, EntitlementUserApiException {
         //TestApiBase.loadSystemPropertiesFromClasspath("/entitlement.properties");
         final Injector g = Guice.createInjector(Stage.PRODUCTION, new MockInvoiceModule(), new MockPaymentModule(), new BusModule(), new DefaultOverdueModule() {
 
@@ -129,13 +128,12 @@ public class TestOverdueCheckNotifier {
                 bind(TagDao.class).to(AuditedTagDao.class).asEagerSingleton();
                 bind(CustomFieldDao.class).to(AuditedCustomFieldDao.class).asEagerSingleton();
                 bind(GlobalLocker.class).to(MySqlGlobalLocker.class).asEagerSingleton();
-                bind(ChargeThruApi.class).toInstance(BrainDeadProxyFactory.createBrainDeadProxyFor(ChargeThruApi.class));
+                bind(ChargeThruApi.class).toInstance(Mockito.mock(ChargeThruApi.class));
                 install(new MockJunctionModule());
             }
         });
 
         clock = g.getInstance(Clock.class);
-        final IDBI dbi = g.getInstance(IDBI.class);
 
         eventBus = g.getInstance(Bus.class);
         helper = g.getInstance(MysqlTestingHelper.class);
@@ -143,11 +141,10 @@ public class TestOverdueCheckNotifier {
 
         final OverdueProperties properties = g.getInstance(OverdueProperties.class);
 
-        final Subscription subscription = BrainDeadProxyFactory.createBrainDeadProxyFor(Subscription.class);
-        final EntitlementUserApi entitlementUserApi = BrainDeadProxyFactory.createBrainDeadProxyFor(EntitlementUserApi.class);
-        ((ZombieControl) entitlementUserApi).addResult("getSubscriptionFromId", subscription);
+        final Subscription subscription = Mockito.mock(Subscription.class);
+        final EntitlementUserApi entitlementUserApi = Mockito.mock(EntitlementUserApi.class);
+        Mockito.when(entitlementUserApi.getSubscriptionFromId(Mockito.<UUID>any())).thenReturn(subscription);
 
-//        CallContextFactory factory = new DefaultCallContextFactory(clock);
         listener = new OverdueListenerMock();
         notifier = new DefaultOverdueCheckNotifier(notificationQueueService,
                                                    properties, listener);
@@ -170,20 +167,17 @@ public class TestOverdueCheckNotifier {
     @Test(enabled = true, groups = "slow")
     public void test() throws Exception {
         final UUID subscriptionId = new UUID(0L, 1L);
-        final Blockable blockable = BrainDeadProxyFactory.createBrainDeadProxyFor(Subscription.class);
-        ((ZombieControl) blockable).addResult("getId", subscriptionId);
+        final Blockable blockable = Mockito.mock(Subscription.class);
+        Mockito.when(blockable.getId()).thenReturn(subscriptionId);
         final DateTime now = new DateTime();
         final DateTime readyTime = now.plusMillis(2000);
         final OverdueCheckPoster poster = new DefaultOverdueCheckPoster(notificationQueueService);
 
-
         poster.insertOverdueCheckNotification(blockable, readyTime);
 
-
         // Move time in the future after the notification effectiveDate
         ((ClockMock) clock).setDeltaFromReality(3000);
 
-
         await().atMost(1, MINUTES).until(new Callable<Boolean>() {
             @Override
             public Boolean call() throws Exception {
@@ -193,7 +187,6 @@ public class TestOverdueCheckNotifier {
 
         Assert.assertEquals(listener.getEventCount(), 1);
         Assert.assertEquals(listener.getLatestSubscriptionId(), subscriptionId);
-
     }
 
     @AfterClass(groups = "slow")
@@ -202,5 +195,4 @@ public class TestOverdueCheckNotifier {
         notifier.stop();
         helper.stopMysql();
     }
-
 }

diff --git a/overdue/src/test/java/com/ning/billing/overdue/OverdueTestBase.java b/overdue/src/test/java/com/ning/billing/overdue/OverdueTestBase.java
index afc93e5..39e1286 100644
--- a/overdue/src/test/java/com/ning/billing/overdue/OverdueTestBase.java
+++ b/overdue/src/test/java/com/ning/billing/overdue/OverdueTestBase.java
@@ -23,6 +23,7 @@ import java.util.List;
 import java.util.UUID;
 
 import org.joda.time.DateTime;
+import org.mockito.Mockito;
 import org.testng.Assert;
 import org.testng.annotations.AfterClass;
 import org.testng.annotations.BeforeClass;
@@ -37,6 +38,7 @@ import com.ning.billing.catalog.api.BillingPeriod;
 import com.ning.billing.catalog.glue.CatalogModule;
 import com.ning.billing.dbi.MysqlTestingHelper;
 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.invoice.api.Invoice;
@@ -44,8 +46,6 @@ import com.ning.billing.invoice.api.InvoiceItem;
 import com.ning.billing.invoice.api.InvoiceUserApi;
 import com.ning.billing.junction.api.BlockingApi;
 import com.ning.billing.junction.api.BlockingState;
-import com.ning.billing.mock.BrainDeadProxyFactory;
-import com.ning.billing.mock.BrainDeadProxyFactory.ZombieControl;
 import com.ning.billing.mock.glue.MockClockModule;
 import com.ning.billing.mock.glue.MockInvoiceModule;
 import com.ning.billing.mock.glue.MockPaymentModule;
@@ -60,12 +60,11 @@ import com.ning.billing.overdue.service.DefaultOverdueService;
 import com.ning.billing.overdue.wrapper.OverdueWrapperFactory;
 import com.ning.billing.util.bus.BusService;
 import com.ning.billing.util.clock.ClockMock;
-import com.ning.billing.util.glue.BusModule;
 import com.ning.billing.util.glue.NotificationQueueModule;
 import com.ning.billing.util.io.IOUtils;
 import com.ning.billing.util.notificationq.NotificationQueueService.NotificationQueueAlreadyExists;
 
-@Guice(modules = {DefaultOverdueModule.class,OverdueListenerTesterModule.class, MockClockModule.class, ApplicatorMockJunctionModule.class, CatalogModule.class, MockInvoiceModule.class, MockPaymentModule.class, NotificationQueueModule.class, TestDbiModule.class})
+@Guice(modules = {DefaultOverdueModule.class, OverdueListenerTesterModule.class, MockClockModule.class, ApplicatorMockJunctionModule.class, CatalogModule.class, MockInvoiceModule.class, MockPaymentModule.class, NotificationQueueModule.class, TestDbiModule.class})
 public class OverdueTestBase {
     protected final String configXml =
             "<overdueConfig>" +
@@ -125,7 +124,6 @@ public class OverdueTestBase {
     @Inject
     protected OverdueUserApi overdueApi;
 
-
     @Inject
     protected InvoiceUserApi invoiceApi;
 
@@ -172,17 +170,13 @@ public class OverdueTestBase {
         service.stop();
     }
 
-
     @BeforeMethod(groups = "slow")
     public void setupTest() throws Exception {
-
         // Pre test cleanup
         helper.cleanupAllTables();
         clock.resetDeltaFromReality();
-
     }
 
-
     protected void checkStateApplied(final OverdueState<SubscriptionBundle> state) {
         final BlockingState result = ((ApplicatorBlockingApi) blockingApi).getBlockingState();
         checkStateApplied(result, state);
@@ -195,36 +189,33 @@ public class OverdueTestBase {
         Assert.assertEquals(result.isBlockBilling(), state.disableEntitlementAndChangesBlocked());
     }
 
-
-    protected SubscriptionBundle createBundle(final DateTime dateOfLastUnPaidInvoice) {
-        final SubscriptionBundle bundle = BrainDeadProxyFactory.createBrainDeadProxyFor(SubscriptionBundle.class);
+    protected SubscriptionBundle createBundle(final DateTime dateOfLastUnPaidInvoice) throws EntitlementUserApiException {
+        final SubscriptionBundle bundle = Mockito.mock(SubscriptionBundle.class);
         final UUID bundleId = UUID.randomUUID();
-        ((ZombieControl) bundle).addResult("getId", bundleId);
-        ((ZombieControl) bundle).addResult("getAccountId", UUID.randomUUID());
+        Mockito.when(bundle.getId()).thenReturn(bundleId);
+        Mockito.when(bundle.getAccountId()).thenReturn(UUID.randomUUID());
 
-        final Invoice invoice = BrainDeadProxyFactory.createBrainDeadProxyFor(Invoice.class);
-        ((ZombieControl) invoice).addResult("getInvoiceDate", dateOfLastUnPaidInvoice);
-        ((ZombieControl) invoice).addResult("getBalance", BigDecimal.TEN);
-        ((ZombieControl) invoice).addResult("getId", UUID.randomUUID());
-        ((ZombieControl) invoice).addResult("hashCode", UUID.randomUUID().hashCode());
+        final Invoice invoice = Mockito.mock(Invoice.class);
+        Mockito.when(invoice.getInvoiceDate()).thenReturn(dateOfLastUnPaidInvoice);
+        Mockito.when(invoice.getBalance()).thenReturn(BigDecimal.TEN);
+        Mockito.when(invoice.getId()).thenReturn(UUID.randomUUID());
 
-        final InvoiceItem item = BrainDeadProxyFactory.createBrainDeadProxyFor(InvoiceItem.class);
-        ((ZombieControl) item).addResult("getBundleId", bundleId);
+        final InvoiceItem item = Mockito.mock(InvoiceItem.class);
+        Mockito.when(item.getBundleId()).thenReturn(bundleId);
         final List<InvoiceItem> items = new ArrayList<InvoiceItem>();
         items.add(item);
 
-        ((ZombieControl) invoice).addResult("getInvoiceItems", items);
+        Mockito.when(invoice.getInvoiceItems()).thenReturn(items);
 
         final List<Invoice> invoices = new ArrayList<Invoice>();
         invoices.add(invoice);
-        ((ZombieControl) invoiceApi).addResult("getUnpaidInvoicesByAccountId", invoices);
-
+        Mockito.when(invoiceApi.getUnpaidInvoicesByAccountId(Mockito.<UUID>any(), Mockito.<DateTime>any())).thenReturn(invoices);
 
-        final Subscription base = BrainDeadProxyFactory.createBrainDeadProxyFor(Subscription.class);
-        ((ZombieControl) base).addResult("getCurrentPlan", MockPlan.createBicycleNoTrialEvergreen1USD());
-        ((ZombieControl) base).addResult("getCurrentPriceList", new MockPriceList());
-        ((ZombieControl) base).addResult("getCurrentPhase", MockPlan.createBicycleNoTrialEvergreen1USD().getFinalPhase());
-        ((ZombieControl) entitlementApi).addResult("getBaseSubscription", base);
+        final Subscription base = Mockito.mock(Subscription.class);
+        Mockito.when(base.getCurrentPlan()).thenReturn(MockPlan.createBicycleNoTrialEvergreen1USD());
+        Mockito.when(base.getCurrentPriceList()).thenReturn(new MockPriceList());
+        Mockito.when(base.getCurrentPhase()).thenReturn(MockPlan.createBicycleNoTrialEvergreen1USD().getFinalPhase());
+        Mockito.when(entitlementApi.getBaseSubscription(Mockito.<UUID>any())).thenReturn(base);
 
         return bundle;
     }