killbill-uncached

diff --git a/.idea/dictionaries/pierre.xml b/.idea/dictionaries/pierre.xml
index 987b7a2..91e0d88 100644
--- a/.idea/dictionaries/pierre.xml
+++ b/.idea/dictionaries/pierre.xml
@@ -8,6 +8,7 @@
       <w>infos</w>
       <w>jdbc</w>
       <w>killbill</w>
+      <w>overdueable</w>
       <w>shiro</w>
       <w>stephane</w>
     </words>

diff --git a/api/src/main/java/com/ning/billing/junction/BlockingInternalApi.java b/api/src/main/java/com/ning/billing/junction/BlockingInternalApi.java
index bce4909..0d30cf4 100644
--- a/api/src/main/java/com/ning/billing/junction/BlockingInternalApi.java
+++ b/api/src/main/java/com/ning/billing/junction/BlockingInternalApi.java
@@ -21,23 +21,14 @@ import java.util.UUID;
 
 import com.ning.billing.callcontext.InternalCallContext;
 import com.ning.billing.callcontext.InternalTenantContext;
-import com.ning.billing.entitlement.api.Blockable;
 import com.ning.billing.entitlement.api.BlockingState;
+import com.ning.billing.entitlement.api.BlockingStateType;
 
 public interface BlockingInternalApi {
 
-    public BlockingState getBlockingStateForService(Blockable blockable, String serviceName, InternalTenantContext context);
+    public BlockingState getBlockingStateForService(UUID blockableId, BlockingStateType blockingStateType, String serviceName, InternalTenantContext context);
 
-    public BlockingState getBlockingStateForService(UUID blockableId, String serviceName, InternalTenantContext context);
-
-    public List<BlockingState> getBlockingHistoryForService(Blockable blockable, String serviceName, InternalTenantContext context);
-
-    public List<BlockingState> getBlockingHistoryForService(UUID blockableId, String serviceName, InternalTenantContext context);
-
-    public List<BlockingState> getBlockingAll(Blockable blockable, InternalTenantContext context);
-
-    public List<BlockingState> getBlockingAll(UUID blockableId, InternalTenantContext context);
+    public List<BlockingState> getBlockingAll(UUID blockableId, BlockingStateType blockingStateType, InternalTenantContext context);
 
     public void setBlockingState(BlockingState state, InternalCallContext context);
-
 }

diff --git a/beatrix/src/test/java/com/ning/billing/beatrix/integration/overdue/TestOverdueBase.java b/beatrix/src/test/java/com/ning/billing/beatrix/integration/overdue/TestOverdueBase.java
index 6cbfc54..4907c15 100644
--- a/beatrix/src/test/java/com/ning/billing/beatrix/integration/overdue/TestOverdueBase.java
+++ b/beatrix/src/test/java/com/ning/billing/beatrix/integration/overdue/TestOverdueBase.java
@@ -27,6 +27,7 @@ import com.ning.billing.account.api.Account;
 import com.ning.billing.beatrix.integration.BeatrixIntegrationModule;
 import com.ning.billing.beatrix.integration.TestIntegrationBase;
 import com.ning.billing.catalog.api.BillingPeriod;
+import com.ning.billing.entitlement.api.BlockingStateType;
 import com.ning.billing.entitlement.api.SubscriptionBundle;
 import com.ning.billing.overdue.OverdueService;
 import com.ning.billing.overdue.config.OverdueConfig;
@@ -77,11 +78,11 @@ public abstract class TestOverdueBase extends TestIntegrationBase {
             await().atMost(10, SECONDS).until(new Callable<Boolean>() {
                 @Override
                 public Boolean call() throws Exception {
-                    return expected.equals(blockingApi.getBlockingStateForService(account, OverdueService.OVERDUE_SERVICE_NAME, internalCallContext).getStateName());
+                    return expected.equals(blockingApi.getBlockingStateForService(account.getId(), BlockingStateType.ACCOUNT, OverdueService.OVERDUE_SERVICE_NAME, internalCallContext).getStateName());
                 }
             });
         } catch (Exception e) {
-            Assert.assertEquals(blockingApi.getBlockingStateForService(account, OverdueService.OVERDUE_SERVICE_NAME, internalCallContext).getStateName(), expected, "Got exception: " + e.toString());
+            Assert.assertEquals(blockingApi.getBlockingStateForService(account.getId(), BlockingStateType.ACCOUNT, OverdueService.OVERDUE_SERVICE_NAME, internalCallContext).getStateName(), expected, "Got exception: " + e.toString());
         }
     }
 }

diff --git a/entitlement/src/main/java/com/ning/billing/entitlement/api/DefaultEntitlementApi.java b/entitlement/src/main/java/com/ning/billing/entitlement/api/DefaultEntitlementApi.java
index 35919a5..96e7ed0 100644
--- a/entitlement/src/main/java/com/ning/billing/entitlement/api/DefaultEntitlementApi.java
+++ b/entitlement/src/main/java/com/ning/billing/entitlement/api/DefaultEntitlementApi.java
@@ -224,7 +224,7 @@ public class DefaultEntitlementApi implements EntitlementApi {
     public void pause(final UUID bundleId, final LocalDate localEffectiveDate, final CallContext context) throws EntitlementApiException {
         try {
             final InternalCallContext contextWithValidAccountRecordId = internalCallContextFactory.createInternalCallContext(bundleId, ObjectType.BUNDLE, context);
-            final BlockingState currentState = blockingStateDao.getBlockingStateForService(bundleId, EntitlementService.ENTITLEMENT_SERVICE_NAME, contextWithValidAccountRecordId);
+            final BlockingState currentState = blockingStateDao.getBlockingStateForService(bundleId, BlockingStateType.SUBSCRIPTION_BUNDLE, EntitlementService.ENTITLEMENT_SERVICE_NAME, contextWithValidAccountRecordId);
             if (currentState != null && currentState.getStateName().equals(ENT_STATE_BLOCKED)) {
                 throw new EntitlementApiException(ErrorCode.ENT_ALREADY_BLOCKED, bundleId);
             }
@@ -266,7 +266,7 @@ public class DefaultEntitlementApi implements EntitlementApi {
     public void resume(final UUID bundleId, final LocalDate localEffectiveDate, final CallContext context) throws EntitlementApiException {
         try {
             final InternalCallContext contextWithValidAccountRecordId = internalCallContextFactory.createInternalCallContext(bundleId, ObjectType.BUNDLE, context);
-            final BlockingState currentState = blockingStateDao.getBlockingStateForService(bundleId, EntitlementService.ENTITLEMENT_SERVICE_NAME, contextWithValidAccountRecordId);
+            final BlockingState currentState = blockingStateDao.getBlockingStateForService(bundleId, BlockingStateType.SUBSCRIPTION_BUNDLE, EntitlementService.ENTITLEMENT_SERVICE_NAME, contextWithValidAccountRecordId);
             if (currentState == null || currentState.getStateName().equals(ENT_STATE_CLEAR)) {
                 // Nothing to do.
                 return;

diff --git a/entitlement/src/main/java/com/ning/billing/entitlement/api/DefaultSubscriptionApi.java b/entitlement/src/main/java/com/ning/billing/entitlement/api/DefaultSubscriptionApi.java
index a73f676..850317f 100644
--- a/entitlement/src/main/java/com/ning/billing/entitlement/api/DefaultSubscriptionApi.java
+++ b/entitlement/src/main/java/com/ning/billing/entitlement/api/DefaultSubscriptionApi.java
@@ -199,7 +199,7 @@ public class DefaultSubscriptionApi implements SubscriptionApi {
 
     private Subscription fromEntitlement(final Entitlement entitlement, final InternalTenantContext internalTenantContext) {
 
-        final List<BlockingState> states = blockingStateDao.getBlockingState(entitlement.getId(), internalTenantContext);
+        final List<BlockingState> states = blockingStateDao.getBlockingState(entitlement.getId(), BlockingStateType.SUBSCRIPTION, internalTenantContext);
         final Subscription result = new DefaultSubscription((DefaultEntitlement) entitlement, states);
         return result;
     }

diff --git a/entitlement/src/main/java/com/ning/billing/entitlement/api/svcs/DefaultInternalBlockingApi.java b/entitlement/src/main/java/com/ning/billing/entitlement/api/svcs/DefaultInternalBlockingApi.java
index ea858dd..22f7434 100644
--- a/entitlement/src/main/java/com/ning/billing/entitlement/api/svcs/DefaultInternalBlockingApi.java
+++ b/entitlement/src/main/java/com/ning/billing/entitlement/api/svcs/DefaultInternalBlockingApi.java
@@ -19,11 +19,9 @@ package com.ning.billing.entitlement.api.svcs;
 import java.util.List;
 import java.util.UUID;
 
-import com.ning.billing.account.api.Account;
 import com.ning.billing.callcontext.InternalCallContext;
 import com.ning.billing.callcontext.InternalTenantContext;
 import com.ning.billing.clock.Clock;
-import com.ning.billing.entitlement.api.Blockable;
 import com.ning.billing.entitlement.api.BlockingState;
 import com.ning.billing.entitlement.api.BlockingStateType;
 import com.ning.billing.entitlement.dao.BlockingStateDao;
@@ -47,50 +45,22 @@ public class DefaultInternalBlockingApi implements BlockingInternalApi {
     }
 
     @Override
-    public BlockingState getBlockingStateForService(final Blockable overdueable, final String serviceName, final InternalTenantContext context) {
-        BlockingState state = dao.getBlockingStateForService(overdueable.getId(), serviceName, context);
-        if (state == null) {
-            state = DefaultBlockingState.getClearState(getBlockingStateType(overdueable), serviceName, clock);
+    public BlockingState getBlockingStateForService(final UUID overdueableId, final BlockingStateType blockingStateType, final String serviceName, final InternalTenantContext context) {
+        final BlockingState blockingStateForService = dao.getBlockingStateForService(overdueableId, blockingStateType, serviceName, context);
+        if (blockingStateForService == null) {
+            return DefaultBlockingState.getClearState(blockingStateType, serviceName, clock);
+        } else {
+            return blockingStateForService;
         }
-        return state;
     }
 
     @Override
-    public BlockingState getBlockingStateForService(final UUID overdueableId, final String serviceName, final InternalTenantContext context) {
-        return dao.getBlockingStateForService(overdueableId, serviceName, context);
-    }
-
-    @Override
-    public List<BlockingState> getBlockingHistoryForService(final Blockable overdueable, final String serviceName, final InternalTenantContext context) {
-        return dao.getBlockingHistoryForService(overdueable.getId(), serviceName, context);
-    }
-
-    @Override
-    public List<BlockingState> getBlockingHistoryForService(final UUID overdueableId, final String serviceName, final InternalTenantContext context) {
-        return dao.getBlockingHistoryForService(overdueableId, serviceName, context);
-    }
-
-    @Override
-    public List<BlockingState> getBlockingAll(final Blockable overdueable, final InternalTenantContext context) {
-        return dao.getBlockingAll(overdueable.getId(), context);
-    }
-
-    @Override
-    public List<BlockingState> getBlockingAll(final UUID overdueableId, final InternalTenantContext context) {
-        return dao.getBlockingAll(overdueableId, context);
+    public List<BlockingState> getBlockingAll(final UUID overdueableId, final BlockingStateType blockingStateType, final InternalTenantContext context) {
+        return dao.getBlockingAll(overdueableId, blockingStateType, context);
     }
 
     @Override
     public void setBlockingState(final BlockingState state, final InternalCallContext context) {
         entitlementUtils.setBlockingStateAndPostBlockingTransitionEvent(state, context);
     }
-
-    BlockingStateType getBlockingStateType(final Blockable overdueable) {
-        if (overdueable instanceof Account) {
-            return BlockingStateType.ACCOUNT;
-        }
-        // STEPH this is here to verify there are no service trying to block on something different than ACCOUNT level
-        // All the other entities
-        throw new RuntimeException("Unexpected blockable type");
-    }
 }

diff --git a/entitlement/src/main/java/com/ning/billing/entitlement/block/DefaultBlockingChecker.java b/entitlement/src/main/java/com/ning/billing/entitlement/block/DefaultBlockingChecker.java
index a2000a2..0cfe5ea 100644
--- a/entitlement/src/main/java/com/ning/billing/entitlement/block/DefaultBlockingChecker.java
+++ b/entitlement/src/main/java/com/ning/billing/entitlement/block/DefaultBlockingChecker.java
@@ -98,7 +98,7 @@ public class DefaultBlockingChecker implements BlockingChecker {
     private DefaultBlockingAggregator getBlockedStateSubscription(final SubscriptionBase subscription, final InternalTenantContext context) throws BlockingApiException {
         final DefaultBlockingAggregator result = new DefaultBlockingAggregator();
         if (subscription != null) {
-            final DefaultBlockingAggregator subscriptionState = getBlockedStateForId(subscription.getId(), context);
+            final DefaultBlockingAggregator subscriptionState = getBlockedStateForId(subscription.getId(), BlockingStateType.SUBSCRIPTION, context);
             if (subscriptionState != null) {
                 result.or(subscriptionState);
             }
@@ -125,7 +125,7 @@ public class DefaultBlockingChecker implements BlockingChecker {
 
     private DefaultBlockingAggregator getBlockedStateBundle(final SubscriptionBaseBundle bundle, final InternalTenantContext context) {
         final DefaultBlockingAggregator result = getBlockedStateAccountId(bundle.getAccountId(), context);
-        final DefaultBlockingAggregator bundleState = getBlockedStateForId(bundle.getId(), context);
+        final DefaultBlockingAggregator bundleState = getBlockedStateForId(bundle.getId(), BlockingStateType.SUBSCRIPTION_BUNDLE, context);
         if (bundleState != null) {
             result.or(bundleState);
         }
@@ -134,20 +134,20 @@ public class DefaultBlockingChecker implements BlockingChecker {
 
     private DefaultBlockingAggregator getBlockedStateAccount(final Account account, final InternalTenantContext context) {
         if (account != null) {
-            return getBlockedStateForId(account.getId(), context);
+            return getBlockedStateForId(account.getId(), BlockingStateType.ACCOUNT, context);
         }
         return new DefaultBlockingAggregator();
     }
 
     private DefaultBlockingAggregator getBlockedStateAccountId(final UUID accountId, final InternalTenantContext context) {
-        return getBlockedStateForId(accountId, context);
+        return getBlockedStateForId(accountId, BlockingStateType.ACCOUNT, context);
     }
 
-    private DefaultBlockingAggregator getBlockedStateForId(final UUID blockableId, final InternalTenantContext context) {
+    private DefaultBlockingAggregator getBlockedStateForId(final UUID blockableId, final BlockingStateType blockingStateType, final InternalTenantContext context) {
         final DefaultBlockingAggregator result = new DefaultBlockingAggregator();
         if (blockableId != null) {
             // Last states across services
-            final List<BlockingState> blockableState = dao.getBlockingState(blockableId, context);
+            final List<BlockingState> blockableState = dao.getBlockingState(blockableId, blockingStateType, context);
             for (BlockingState cur : blockableState) {
                 result.or(cur);
             }

diff --git a/entitlement/src/main/java/com/ning/billing/entitlement/dao/BlockingStateDao.java b/entitlement/src/main/java/com/ning/billing/entitlement/dao/BlockingStateDao.java
index 060b729..aaa286b 100644
--- a/entitlement/src/main/java/com/ning/billing/entitlement/dao/BlockingStateDao.java
+++ b/entitlement/src/main/java/com/ning/billing/entitlement/dao/BlockingStateDao.java
@@ -23,6 +23,7 @@ import com.ning.billing.callcontext.InternalCallContext;
 import com.ning.billing.callcontext.InternalTenantContext;
 import com.ning.billing.clock.Clock;
 import com.ning.billing.entitlement.api.BlockingState;
+import com.ning.billing.entitlement.api.BlockingStateType;
 import com.ning.billing.entitlement.api.EntitlementApiException;
 import com.ning.billing.util.entity.dao.EntityDao;
 
@@ -31,64 +32,67 @@ public interface BlockingStateDao extends EntityDao<BlockingStateModelDao, Block
     /**
      * Returns the current state for that specific service
      *
-     * @param blockableId
-     * @param serviceName
-     * @param context
-     * @return
+     * @param blockableId       id of the blockable object
+     * @param blockingStateType blockable object type
+     * @param serviceName       name of the service
+     * @param context           call context
+     * @return current blocking state for that blockable object and service
      */
-    public BlockingState getBlockingStateForService(UUID blockableId, String serviceName, InternalTenantContext context);
+    public BlockingState getBlockingStateForService(UUID blockableId, BlockingStateType blockingStateType, String serviceName, InternalTenantContext context);
 
     /**
      * Returns the current state across all the services
      *
-     * @param blockableId
-     * @param context
-     * @return
+     * @param blockableId       id of the blockable object
+     * @param blockingStateType blockable object type
+     * @param context           call context
+     * @return list of current blocking states for that blockable object
      */
-    public List<BlockingState> getBlockingState(UUID blockableId, InternalTenantContext context);
+    public List<BlockingState> getBlockingState(UUID blockableId, BlockingStateType blockingStateType, InternalTenantContext context);
 
     /**
-     * Returns the state history  for that specific service
+     * Returns the state history for that specific service
      *
-     * @param blockableId
-     * @param serviceName
-     * @param context
-     * @return
+     * @param blockableId       id of the blockable object
+     * @param blockingStateType blockable object type
+     * @param serviceName       name of the service
+     * @param context           call context
+     * @return list of blocking states for that blockable object and service
      */
-    public List<BlockingState> getBlockingHistoryForService(UUID blockableId, String serviceName, InternalTenantContext context);
+    public List<BlockingState> getBlockingHistoryForService(UUID blockableId, BlockingStateType blockingStateType, String serviceName, InternalTenantContext context);
 
     /**
      * Return all the events (past and future) across all services
      *
-     * @param blockableId
-     * @param context
-     * @return
+     * @param blockableId       id of the blockable object
+     * @param blockingStateType blockable object type
+     * @param context           call context
+     * @return list of blocking states for that blockable object
      */
-    public List<BlockingState> getBlockingAll(UUID blockableId, InternalTenantContext context);
-
+    public List<BlockingState> getBlockingAll(UUID blockableId, BlockingStateType blockingStateType, InternalTenantContext context);
 
     /**
      * Return all events (past and future) across all services) for a given callcontext (account_record_id)
      *
-     * @param context
-     * @return
+     * @param context call context
+     * @return list of all blocking states for that account
      */
     public List<BlockingState> getBlockingAllForAccountRecordId(InternalTenantContext context);
 
     /**
      * Sets a new state for a specific service.
      *
-     * @param state
-     * @param clock
-     * @param context
+     * @param state   blocking state to set
+     * @param clock   system clock
+     * @param context call context
      */
     public void setBlockingState(BlockingState state, Clock clock, InternalCallContext context);
 
     /**
      * Unactive the blocking state
      *
-     * @param blockableId
-     * @param context
+     * @param blockableId blockable id to unactivate
+     * @param context     call context
      */
     public void unactiveBlockingState(UUID blockableId, final InternalCallContext context);
 

diff --git a/entitlement/src/main/java/com/ning/billing/entitlement/dao/DefaultBlockingStateDao.java b/entitlement/src/main/java/com/ning/billing/entitlement/dao/DefaultBlockingStateDao.java
index 466e704..1292cbf 100644
--- a/entitlement/src/main/java/com/ning/billing/entitlement/dao/DefaultBlockingStateDao.java
+++ b/entitlement/src/main/java/com/ning/billing/entitlement/dao/DefaultBlockingStateDao.java
@@ -33,6 +33,7 @@ import com.ning.billing.callcontext.InternalCallContext;
 import com.ning.billing.callcontext.InternalTenantContext;
 import com.ning.billing.clock.Clock;
 import com.ning.billing.entitlement.api.BlockingState;
+import com.ning.billing.entitlement.api.BlockingStateType;
 import com.ning.billing.entitlement.api.EntitlementApiException;
 import com.ning.billing.util.cache.CacheControllerDispatcher;
 import com.ning.billing.util.dao.NonEntityDao;
@@ -43,6 +44,7 @@ import com.ning.billing.util.entity.dao.EntitySqlDaoTransactionalJdbiWrapper;
 import com.ning.billing.util.entity.dao.EntitySqlDaoWrapperFactory;
 
 import com.google.common.base.Function;
+import com.google.common.base.Predicate;
 import com.google.common.collect.Collections2;
 import com.google.common.collect.Ordering;
 
@@ -77,28 +79,28 @@ public class DefaultBlockingStateDao extends EntityDaoBase<BlockingStateModelDao
     }
 
     @Override
-    public BlockingState getBlockingStateForService(final UUID blockableId, final String serviceName, final InternalTenantContext context) {
+    public BlockingState getBlockingStateForService(final UUID blockableId, final BlockingStateType blockingStateType, final String serviceName, final InternalTenantContext context) {
         return transactionalSqlDao.execute(new EntitySqlDaoTransactionWrapper<BlockingState>() {
             @Override
             public BlockingState inTransaction(final EntitySqlDaoWrapperFactory<EntitySqlDao> entitySqlDaoWrapperFactory) throws Exception {
                 // Upper bound time limit is now
                 final Date upTo = clock.getUTCNow().toDate();
                 final BlockingStateModelDao model = entitySqlDaoWrapperFactory.become(BlockingStateSqlDao.class).getBlockingStateForService(blockableId, serviceName, upTo, context);
-                return BlockingStateModelDao.toBlockingState(model);
-
+                return (model != null && model.getType().equals(blockingStateType)) ? BlockingStateModelDao.toBlockingState(model) : null;
             }
         });
     }
 
     @Override
-    public List<BlockingState> getBlockingState(final UUID blockableId, final InternalTenantContext context) {
+    public List<BlockingState> getBlockingState(final UUID blockableId, final BlockingStateType blockingStateType, final InternalTenantContext context) {
         return transactionalSqlDao.execute(new EntitySqlDaoTransactionWrapper<List<BlockingState>>() {
             @Override
             public List<BlockingState> inTransaction(final EntitySqlDaoWrapperFactory<EntitySqlDao> entitySqlDaoWrapperFactory) throws Exception {
                 // Upper bound time limit is now
                 final Date upTo = clock.getUTCNow().toDate();
                 final List<BlockingStateModelDao> models = entitySqlDaoWrapperFactory.become(BlockingStateSqlDao.class).getBlockingState(blockableId, upTo, context);
-                return new ArrayList<BlockingState>(Collections2.transform(models, new Function<BlockingStateModelDao, BlockingState>() {
+                final Collection<BlockingStateModelDao> modelsFiltered = filterBlockingStates(models, blockingStateType);
+                return new ArrayList<BlockingState>(Collections2.transform(modelsFiltered, new Function<BlockingStateModelDao, BlockingState>() {
                     @Override
                     public BlockingState apply(@Nullable final BlockingStateModelDao src) {
                         return BlockingStateModelDao.toBlockingState(src);
@@ -109,12 +111,14 @@ public class DefaultBlockingStateDao extends EntityDaoBase<BlockingStateModelDao
     }
 
     @Override
-    public List<BlockingState> getBlockingHistoryForService(final UUID blockableId, final String serviceName, final InternalTenantContext context) {
+    public List<BlockingState> getBlockingHistoryForService(final UUID blockableId, final BlockingStateType blockingStateType, final String serviceName, final InternalTenantContext context) {
         return transactionalSqlDao.execute(new EntitySqlDaoTransactionWrapper<List<BlockingState>>() {
             @Override
             public List<BlockingState> inTransaction(final EntitySqlDaoWrapperFactory<EntitySqlDao> entitySqlDaoWrapperFactory) throws Exception {
                 final BlockingStateSqlDao sqlDao = entitySqlDaoWrapperFactory.become(BlockingStateSqlDao.class);
-                return new ArrayList<BlockingState>(Collections2.transform(sqlDao.getBlockingHistoryForService(blockableId, serviceName, context),
+                final List<BlockingStateModelDao> models = sqlDao.getBlockingHistoryForService(blockableId, serviceName, context);
+                final Collection<BlockingStateModelDao> modelsFiltered = filterBlockingStates(models, blockingStateType);
+                return new ArrayList<BlockingState>(Collections2.transform(modelsFiltered,
                                                                            new Function<BlockingStateModelDao, BlockingState>() {
                                                                                @Override
                                                                                public BlockingState apply(@Nullable final BlockingStateModelDao src) {
@@ -126,12 +130,14 @@ public class DefaultBlockingStateDao extends EntityDaoBase<BlockingStateModelDao
     }
 
     @Override
-    public List<BlockingState> getBlockingAll(final UUID blockableId, final InternalTenantContext context) {
+    public List<BlockingState> getBlockingAll(final UUID blockableId, final BlockingStateType blockingStateType, final InternalTenantContext context) {
         return transactionalSqlDao.execute(new EntitySqlDaoTransactionWrapper<List<BlockingState>>() {
             @Override
             public List<BlockingState> inTransaction(final EntitySqlDaoWrapperFactory<EntitySqlDao> entitySqlDaoWrapperFactory) throws Exception {
                 final BlockingStateSqlDao sqlDao = entitySqlDaoWrapperFactory.become(BlockingStateSqlDao.class);
-                return new ArrayList<BlockingState>(Collections2.transform(sqlDao.getBlockingAll(blockableId, context),
+                final List<BlockingStateModelDao> models = sqlDao.getBlockingAll(blockableId, context);
+                final Collection<BlockingStateModelDao> modelsFiltered = filterBlockingStates(models, blockingStateType);
+                return new ArrayList<BlockingState>(Collections2.transform(modelsFiltered,
                                                                            new Function<BlockingStateModelDao, BlockingState>() {
                                                                                @Override
                                                                                public BlockingState apply(@Nullable final BlockingStateModelDao src) {
@@ -220,4 +226,14 @@ public class DefaultBlockingStateDao extends EntityDaoBase<BlockingStateModelDao
             }
         });
     }
+
+    private Collection<BlockingStateModelDao> filterBlockingStates(final Collection<BlockingStateModelDao> models, final BlockingStateType blockingStateType) {
+        return Collections2.<BlockingStateModelDao>filter(models,
+                                                          new Predicate<BlockingStateModelDao>() {
+                                                              @Override
+                                                              public boolean apply(final BlockingStateModelDao input) {
+                                                                  return input.getType().equals(blockingStateType);
+                                                              }
+                                                          });
+    }
 }

diff --git a/entitlement/src/main/java/com/ning/billing/entitlement/dao/ProxyBlockingStateDao.java b/entitlement/src/main/java/com/ning/billing/entitlement/dao/ProxyBlockingStateDao.java
index 5c2967b..e0f3b60 100644
--- a/entitlement/src/main/java/com/ning/billing/entitlement/dao/ProxyBlockingStateDao.java
+++ b/entitlement/src/main/java/com/ning/billing/entitlement/dao/ProxyBlockingStateDao.java
@@ -36,6 +36,7 @@ import com.ning.billing.callcontext.InternalTenantContext;
 import com.ning.billing.catalog.api.ProductCategory;
 import com.ning.billing.clock.Clock;
 import com.ning.billing.entitlement.api.BlockingState;
+import com.ning.billing.entitlement.api.BlockingStateType;
 import com.ning.billing.entitlement.api.Entitlement.EntitlementState;
 import com.ning.billing.entitlement.api.EntitlementApiException;
 import com.ning.billing.entitlement.engine.core.EventsStream;
@@ -132,31 +133,31 @@ public class ProxyBlockingStateDao implements BlockingStateDao {
     }
 
     @Override
-    public BlockingState getBlockingStateForService(final UUID blockableId, final String serviceName, final InternalTenantContext context) {
-        return delegate.getBlockingStateForService(blockableId, serviceName, context);
+    public BlockingState getBlockingStateForService(final UUID blockableId, final BlockingStateType blockingStateType, final String serviceName, final InternalTenantContext context) {
+        return delegate.getBlockingStateForService(blockableId, blockingStateType, serviceName, context);
     }
 
     @Override
-    public List<BlockingState> getBlockingState(final UUID blockableId, final InternalTenantContext context) {
-        return delegate.getBlockingState(blockableId, context);
+    public List<BlockingState> getBlockingState(final UUID blockableId, final BlockingStateType blockingStateType, final InternalTenantContext context) {
+        return delegate.getBlockingState(blockableId, blockingStateType, context);
     }
 
     @Override
-    public List<BlockingState> getBlockingHistoryForService(final UUID blockableId, final String serviceName, final InternalTenantContext context) {
-        final List<BlockingState> statesOnDisk = delegate.getBlockingHistoryForService(blockableId, serviceName, context);
-        return addBlockingStatesNotOnDisk(blockableId, statesOnDisk, context);
+    public List<BlockingState> getBlockingHistoryForService(final UUID blockableId, final BlockingStateType blockingStateType, final String serviceName, final InternalTenantContext context) {
+        final List<BlockingState> statesOnDisk = delegate.getBlockingHistoryForService(blockableId, blockingStateType, serviceName, context);
+        return addBlockingStatesNotOnDisk(blockableId, blockingStateType, statesOnDisk, context);
     }
 
     @Override
-    public List<BlockingState> getBlockingAll(final UUID blockableId, final InternalTenantContext context) {
-        final List<BlockingState> statesOnDisk = delegate.getBlockingAll(blockableId, context);
-        return addBlockingStatesNotOnDisk(blockableId, statesOnDisk, context);
+    public List<BlockingState> getBlockingAll(final UUID blockableId, final BlockingStateType blockingStateType, final InternalTenantContext context) {
+        final List<BlockingState> statesOnDisk = delegate.getBlockingAll(blockableId, blockingStateType, context);
+        return addBlockingStatesNotOnDisk(blockableId, blockingStateType, statesOnDisk, context);
     }
 
     @Override
     public List<BlockingState> getBlockingAllForAccountRecordId(final InternalTenantContext context) {
         final List<BlockingState> statesOnDisk = delegate.getBlockingAllForAccountRecordId(context);
-        return addBlockingStatesNotOnDisk(null, statesOnDisk, context);
+        return addBlockingStatesNotOnDisk(null, null, statesOnDisk, context);
     }
 
     @Override
@@ -172,6 +173,7 @@ public class ProxyBlockingStateDao implements BlockingStateDao {
     // Add blocking states for add-ons, which would be impacted by a future cancellation or change of their base plan
     // See DefaultEntitlement#blockAddOnsIfRequired
     private List<BlockingState> addBlockingStatesNotOnDisk(@Nullable final UUID blockableId,
+                                                           @Nullable final BlockingStateType blockingStateType,
                                                            final List<BlockingState> blockingStatesOnDisk,
                                                            final InternalTenantContext context) {
         final Collection<BlockingState> blockingStatesOnDiskCopy = new LinkedList<BlockingState>(blockingStatesOnDisk);
@@ -179,7 +181,7 @@ public class ProxyBlockingStateDao implements BlockingStateDao {
         // Find all base entitlements that we care about (for which we want to find future cancelled add-ons)
         final Iterable<SubscriptionBase> baseSubscriptionsToConsider;
         try {
-            if (blockableId == null) {
+            if (blockingStateType == null) {
                 // We're coming from getBlockingAllForAccountRecordId
                 final Iterable<SubscriptionBase> subscriptions = Iterables.<SubscriptionBase>concat(subscriptionInternalApi.getSubscriptionsForAccount(context).values());
                 baseSubscriptionsToConsider = Iterables.<SubscriptionBase>filter(subscriptions,
@@ -190,24 +192,21 @@ public class ProxyBlockingStateDao implements BlockingStateDao {
                                                                                                 !EntitlementState.CANCELLED.equals(input.getState());
                                                                                      }
                                                                                  });
-            } else {
-                // We're coming from getBlockingHistoryForService / getBlockingAll, but we don't know the blocking type
-                final SubscriptionBase addOnSubscription;
-                try {
-                    addOnSubscription = subscriptionInternalApi.getSubscriptionFromId(blockableId, context);
-                } catch (SubscriptionBaseApiException ignored) {
-                    // blockable id points to an account or bundle, in which case there are no extra blocking states to add
-                    return blockingStatesOnDisk;
-                }
+            } else if (BlockingStateType.SUBSCRIPTION.equals(blockingStateType)) {
+                // We're coming from getBlockingHistoryForService / getBlockingAll
+                final SubscriptionBase subscription = subscriptionInternalApi.getSubscriptionFromId(blockableId, context);
 
                 // blockable id points to a subscription, but make sure it's an add-on
-                if (ProductCategory.ADD_ON.equals(addOnSubscription.getCategory())) {
-                    final SubscriptionBase baseSubscription = subscriptionInternalApi.getBaseSubscription(addOnSubscription.getBundleId(), context);
+                if (ProductCategory.ADD_ON.equals(subscription.getCategory())) {
+                    final SubscriptionBase baseSubscription = subscriptionInternalApi.getBaseSubscription(subscription.getBundleId(), context);
                     baseSubscriptionsToConsider = ImmutableList.<SubscriptionBase>of(baseSubscription);
                 } else {
                     // blockable id points to a base or standalone subscription, there is nothing to do
                     return blockingStatesOnDisk;
                 }
+            } else {
+                // blockable id points to an account or bundle, in which case there are no extra blocking states to add
+                return blockingStatesOnDisk;
             }
         } catch (SubscriptionBaseApiException e) {
             log.error("Error retrieving subscriptions for account record id " + context.getAccountRecordId(), e);

diff --git a/entitlement/src/main/java/com/ning/billing/entitlement/engine/core/EventsStreamBuilder.java b/entitlement/src/main/java/com/ning/billing/entitlement/engine/core/EventsStreamBuilder.java
index a9d8578..0c6e8eb 100644
--- a/entitlement/src/main/java/com/ning/billing/entitlement/engine/core/EventsStreamBuilder.java
+++ b/entitlement/src/main/java/com/ning/billing/entitlement/engine/core/EventsStreamBuilder.java
@@ -32,6 +32,7 @@ import com.ning.billing.clock.Clock;
 import com.ning.billing.entitlement.EntitlementService;
 import com.ning.billing.entitlement.api.BlockingApiException;
 import com.ning.billing.entitlement.api.BlockingState;
+import com.ning.billing.entitlement.api.BlockingStateType;
 import com.ning.billing.entitlement.api.EntitlementApiException;
 import com.ning.billing.entitlement.block.BlockingChecker;
 import com.ning.billing.entitlement.block.BlockingChecker.BlockingAggregator;
@@ -124,9 +125,9 @@ public class EventsStreamBuilder {
             throw new EntitlementApiException(e);
         }
 
-        final List<BlockingState> subscriptionEntitlementStates = blockingStateDao.getBlockingHistoryForService(subscription.getId(), EntitlementService.ENTITLEMENT_SERVICE_NAME, internalTenantContext);
-        final List<BlockingState> bundleEntitlementStates = blockingStateDao.getBlockingHistoryForService(bundle.getId(), EntitlementService.ENTITLEMENT_SERVICE_NAME, internalTenantContext);
-        final List<BlockingState> accountEntitlementStates = blockingStateDao.getBlockingHistoryForService(account.getId(), EntitlementService.ENTITLEMENT_SERVICE_NAME, internalTenantContext);
+        final List<BlockingState> subscriptionEntitlementStates = blockingStateDao.getBlockingHistoryForService(subscription.getId(), BlockingStateType.SUBSCRIPTION, EntitlementService.ENTITLEMENT_SERVICE_NAME, internalTenantContext);
+        final List<BlockingState> bundleEntitlementStates = blockingStateDao.getBlockingHistoryForService(bundle.getId(), BlockingStateType.SUBSCRIPTION_BUNDLE, EntitlementService.ENTITLEMENT_SERVICE_NAME, internalTenantContext);
+        final List<BlockingState> accountEntitlementStates = blockingStateDao.getBlockingHistoryForService(account.getId(), BlockingStateType.ACCOUNT, EntitlementService.ENTITLEMENT_SERVICE_NAME, internalTenantContext);
 
         final BlockingAggregator blockingAggregator;
         try {

diff --git a/entitlement/src/test/java/com/ning/billing/entitlement/block/TestBlockingApi.java b/entitlement/src/test/java/com/ning/billing/entitlement/block/TestBlockingApi.java
index edd57ed..e227e1d 100644
--- a/entitlement/src/test/java/com/ning/billing/entitlement/block/TestBlockingApi.java
+++ b/entitlement/src/test/java/com/ning/billing/entitlement/block/TestBlockingApi.java
@@ -19,7 +19,6 @@ package com.ning.billing.entitlement.block;
 import java.util.List;
 import java.util.UUID;
 
-import org.mockito.Mockito;
 import org.testng.Assert;
 import org.testng.annotations.BeforeMethod;
 import org.testng.annotations.Test;
@@ -29,7 +28,10 @@ import com.ning.billing.entitlement.EntitlementTestSuiteWithEmbeddedDB;
 import com.ning.billing.entitlement.api.BlockingState;
 import com.ning.billing.entitlement.api.BlockingStateType;
 import com.ning.billing.junction.DefaultBlockingState;
-import com.ning.billing.subscription.api.user.SubscriptionBaseBundle;
+
+import com.google.common.base.Predicate;
+import com.google.common.collect.Collections2;
+import com.google.common.collect.ImmutableList;
 
 public class TestBlockingApi extends EntitlementTestSuiteWithEmbeddedDB {
 
@@ -62,11 +64,7 @@ public class TestBlockingApi extends EntitlementTestSuiteWithEmbeddedDB {
         blockingInternalApi.setBlockingState(state2, internalCallContext);
         assertListenerStatus();
 
-        final SubscriptionBaseBundle bundle = Mockito.mock(SubscriptionBaseBundle.class);
-        Mockito.when(bundle.getId()).thenReturn(uuid);
-
-        Assert.assertEquals(blockingInternalApi.getBlockingStateForService(bundle, service, internalCallContext).getStateName(), overdueStateName2);
-        Assert.assertEquals(blockingInternalApi.getBlockingStateForService(bundle.getId(), service, internalCallContext).getStateName(), overdueStateName2);
+        Assert.assertEquals(blockingInternalApi.getBlockingStateForService(uuid, BlockingStateType.ACCOUNT, service, internalCallContext).getStateName(), overdueStateName2);
     }
 
     @Test(groups = "slow")
@@ -92,18 +90,17 @@ public class TestBlockingApi extends EntitlementTestSuiteWithEmbeddedDB {
         blockingInternalApi.setBlockingState(state2, internalCallContext);
         assertListenerStatus();
 
-        final SubscriptionBaseBundle bundle = Mockito.mock(SubscriptionBaseBundle.class);
-        Mockito.when(bundle.getId()).thenReturn(uuid);
-
-        final List<BlockingState> history1 = blockingInternalApi.getBlockingHistoryForService(bundle, service, internalCallContext);
-        final List<BlockingState> history2 = blockingInternalApi.getBlockingHistoryForService(bundle.getId(), service, internalCallContext);
-
-        Assert.assertEquals(history1.size(), 2);
-        Assert.assertEquals(history1.get(0).getStateName(), overdueStateName);
-        Assert.assertEquals(history1.get(1).getStateName(), overdueStateName2);
-
-        Assert.assertEquals(history2.size(), 2);
-        Assert.assertEquals(history2.get(0).getStateName(), overdueStateName);
-        Assert.assertEquals(history2.get(1).getStateName(), overdueStateName2);
+        final List<BlockingState> blockingAll = blockingInternalApi.getBlockingAll(uuid, BlockingStateType.ACCOUNT, internalCallContext);
+        final List<BlockingState> history = ImmutableList.<BlockingState>copyOf(Collections2.<BlockingState>filter(blockingAll,
+                                                                                                                   new Predicate<BlockingState>() {
+                                                                                                                       @Override
+                                                                                                                       public boolean apply(final BlockingState input) {
+                                                                                                                           return input.getService().equals(service);
+                                                                                                                       }
+                                                                                                                   }));
+
+        Assert.assertEquals(history.size(), 2);
+        Assert.assertEquals(history.get(0).getStateName(), overdueStateName);
+        Assert.assertEquals(history.get(1).getStateName(), overdueStateName2);
     }
 }

diff --git a/entitlement/src/test/java/com/ning/billing/entitlement/dao/MockBlockingStateDao.java b/entitlement/src/test/java/com/ning/billing/entitlement/dao/MockBlockingStateDao.java
index fa343d8..f2bff3d 100644
--- a/entitlement/src/test/java/com/ning/billing/entitlement/dao/MockBlockingStateDao.java
+++ b/entitlement/src/test/java/com/ning/billing/entitlement/dao/MockBlockingStateDao.java
@@ -28,6 +28,7 @@ import com.ning.billing.callcontext.InternalCallContext;
 import com.ning.billing.callcontext.InternalTenantContext;
 import com.ning.billing.clock.Clock;
 import com.ning.billing.entitlement.api.BlockingState;
+import com.ning.billing.entitlement.api.BlockingStateType;
 import com.ning.billing.entitlement.api.EntitlementApiException;
 import com.ning.billing.util.entity.dao.MockEntityDaoBase;
 
@@ -42,8 +43,8 @@ public class MockBlockingStateDao extends MockEntityDaoBase<BlockingStateModelDa
     // TODO This mock class should also check that events are past or present except for getBlockingAll
 
     @Override
-    public BlockingState getBlockingStateForService(final UUID blockableId, final String serviceName, final InternalTenantContext context) {
-        final List<BlockingState> states = getBlockingAll(blockableId, context);
+    public BlockingState getBlockingStateForService(final UUID blockableId, final BlockingStateType blockingStateType, final String serviceName, final InternalTenantContext context) {
+        final List<BlockingState> states = getBlockingAll(blockableId, blockingStateType, context);
         if (states == null) {
             return null;
         }
@@ -57,7 +58,7 @@ public class MockBlockingStateDao extends MockEntityDaoBase<BlockingStateModelDa
     }
 
     @Override
-    public List<BlockingState> getBlockingState(final UUID blockableId, final InternalTenantContext context) {
+    public List<BlockingState> getBlockingState(final UUID blockableId, final BlockingStateType blockingStateType, final InternalTenantContext context) {
         final List<BlockingState> blockingStatesForId = blockingStates.get(blockableId);
         if (blockingStatesForId == null) {
             return new ArrayList<BlockingState>();
@@ -74,7 +75,7 @@ public class MockBlockingStateDao extends MockEntityDaoBase<BlockingStateModelDa
     }
 
     @Override
-    public List<BlockingState> getBlockingHistoryForService(final UUID overdueableId, final String serviceName, final InternalTenantContext context) {
+    public List<BlockingState> getBlockingHistoryForService(final UUID overdueableId, final BlockingStateType blockingStateType, final String serviceName, final InternalTenantContext context) {
         final List<BlockingState> states = blockingStates.get(overdueableId);
         if (states == null) {
             return new ArrayList<BlockingState>();
@@ -91,7 +92,7 @@ public class MockBlockingStateDao extends MockEntityDaoBase<BlockingStateModelDa
     }
 
     @Override
-    public List<BlockingState> getBlockingAll(final UUID blockableId, final InternalTenantContext context) {
+    public List<BlockingState> getBlockingAll(final UUID blockableId, final BlockingStateType blockingStateType, final InternalTenantContext context) {
         final List<BlockingState> states = blockingStates.get(blockableId);
         // Note! The returned list cannot be immutable!
         return states == null ? new ArrayList<BlockingState>() : states;

diff --git a/entitlement/src/test/java/com/ning/billing/entitlement/dao/TestBlockingDao.java b/entitlement/src/test/java/com/ning/billing/entitlement/dao/TestBlockingDao.java
index 7850378..db37ccd 100644
--- a/entitlement/src/test/java/com/ning/billing/entitlement/dao/TestBlockingDao.java
+++ b/entitlement/src/test/java/com/ning/billing/entitlement/dao/TestBlockingDao.java
@@ -20,7 +20,6 @@ import java.util.List;
 import java.util.UUID;
 
 import org.joda.time.LocalDate;
-import org.mockito.Mockito;
 import org.testng.Assert;
 import org.testng.annotations.Test;
 
@@ -28,14 +27,12 @@ import com.ning.billing.entitlement.EntitlementTestSuiteWithEmbeddedDB;
 import com.ning.billing.entitlement.api.BlockingState;
 import com.ning.billing.entitlement.api.BlockingStateType;
 import com.ning.billing.junction.DefaultBlockingState;
-import com.ning.billing.subscription.api.user.SubscriptionBaseBundle;
 
 public class TestBlockingDao extends EntitlementTestSuiteWithEmbeddedDB {
 
     @Test(groups = "slow")
     public void testDao() {
 
-
         final UUID uuid = UUID.randomUUID();
         final String overdueStateName = "WayPassedItMan";
         final String service = "TEST";
@@ -55,19 +52,15 @@ public class TestBlockingDao extends EntitlementTestSuiteWithEmbeddedDB {
         final BlockingState state2 = new DefaultBlockingState(uuid, BlockingStateType.ACCOUNT, overdueStateName2, service, blockChange, blockEntitlement, blockBilling, clock.getUTCNow());
         blockingStateDao.setBlockingState(state2, clock, internalCallContext);
 
-        final SubscriptionBaseBundle bundle = Mockito.mock(SubscriptionBaseBundle.class);
-        Mockito.when(bundle.getId()).thenReturn(uuid);
-
-        Assert.assertEquals(blockingStateDao.getBlockingStateForService(uuid, service, internalCallContext).getStateName(), state2.getStateName());
+        Assert.assertEquals(blockingStateDao.getBlockingStateForService(uuid, BlockingStateType.ACCOUNT, service, internalCallContext).getStateName(), state2.getStateName());
 
-        final List<BlockingState> states = blockingStateDao.getBlockingHistoryForService(uuid, service, internalCallContext);
+        final List<BlockingState> states = blockingStateDao.getBlockingHistoryForService(uuid, BlockingStateType.ACCOUNT, service, internalCallContext);
         Assert.assertEquals(states.size(), 2);
 
         Assert.assertEquals(states.get(0).getStateName(), overdueStateName);
         Assert.assertEquals(states.get(1).getStateName(), overdueStateName2);
     }
 
-
     @Test(groups = "slow")
     public void testDaoHistory() throws Exception {
         final UUID uuid = UUID.randomUUID();
@@ -88,10 +81,7 @@ public class TestBlockingDao extends EntitlementTestSuiteWithEmbeddedDB {
         final BlockingState state2 = new DefaultBlockingState(uuid, BlockingStateType.ACCOUNT, overdueStateName2, service2, blockChange, blockEntitlement, blockBilling, clock.getUTCNow());
         blockingStateDao.setBlockingState(state2, clock, internalCallContext);
 
-        final SubscriptionBaseBundle bundle = Mockito.mock(SubscriptionBaseBundle.class);
-        Mockito.when(bundle.getId()).thenReturn(uuid);
-
-        final List<BlockingState> history2 = blockingStateDao.getBlockingAll(bundle.getId(), internalCallContext);
+        final List<BlockingState> history2 = blockingStateDao.getBlockingAll(uuid, BlockingStateType.ACCOUNT, internalCallContext);
         Assert.assertEquals(history2.size(), 2);
         Assert.assertEquals(history2.get(0).getStateName(), overdueStateName);
         Assert.assertEquals(history2.get(1).getStateName(), overdueStateName2);

diff --git a/entitlement/src/test/java/com/ning/billing/entitlement/dao/TestDefaultBlockingStateDao.java b/entitlement/src/test/java/com/ning/billing/entitlement/dao/TestDefaultBlockingStateDao.java
index ecca804..ed26f65 100644
--- a/entitlement/src/test/java/com/ning/billing/entitlement/dao/TestDefaultBlockingStateDao.java
+++ b/entitlement/src/test/java/com/ning/billing/entitlement/dao/TestDefaultBlockingStateDao.java
@@ -24,9 +24,16 @@ import org.joda.time.DateTimeZone;
 import org.testng.Assert;
 import org.testng.annotations.Test;
 
+import com.ning.billing.account.api.Account;
+import com.ning.billing.api.TestApiListener.NextEvent;
+import com.ning.billing.catalog.api.BillingPeriod;
+import com.ning.billing.catalog.api.PlanPhaseSpecifier;
+import com.ning.billing.catalog.api.PriceListSet;
+import com.ning.billing.catalog.api.ProductCategory;
 import com.ning.billing.entitlement.EntitlementTestSuiteWithEmbeddedDB;
 import com.ning.billing.entitlement.api.BlockingState;
 import com.ning.billing.entitlement.api.BlockingStateType;
+import com.ning.billing.entitlement.api.Entitlement;
 import com.ning.billing.junction.DefaultBlockingState;
 
 public class TestDefaultBlockingStateDao extends EntitlementTestSuiteWithEmbeddedDB {
@@ -36,20 +43,25 @@ public class TestDefaultBlockingStateDao extends EntitlementTestSuiteWithEmbedde
         // This is a simple smoke test at the dao level only to make sure we do sane
         // things in case there are no future add-on cancellation events to add in the stream.
         // See TestEntitlementUtils for a more comprehensive test
-        final UUID blockableId = UUID.randomUUID();
+        final Account account = accountApi.createAccount(getAccountData(7), callContext);
+        final PlanPhaseSpecifier spec = new PlanPhaseSpecifier("Shotgun", ProductCategory.BASE, BillingPeriod.MONTHLY, PriceListSet.DEFAULT_PRICELIST_NAME, null);
+        testListener.pushExpectedEvent(NextEvent.CREATE);
+        final Entitlement entitlement = entitlementApi.createBaseEntitlement(account.getId(), spec, account.getExternalKey(), clock.getUTCToday(), callContext);
+        assertListenerStatus();
+
         final BlockingStateType type = BlockingStateType.SUBSCRIPTION;
         final String state = "state";
         final String service = "service";
 
         // Verify initial state
-        Assert.assertEquals(blockingStateDao.getBlockingAll(blockableId, internalCallContext).size(), 0);
+        Assert.assertEquals(blockingStateDao.getBlockingAll(entitlement.getId(), type, internalCallContext).size(), 0);
 
         // Set a state
         final DateTime stateDateTime = new DateTime(2013, 5, 6, 10, 11, 12, DateTimeZone.UTC);
-        final BlockingState blockingState = new DefaultBlockingState(blockableId, type, state, service, false, false, false, stateDateTime);
+        final BlockingState blockingState = new DefaultBlockingState(entitlement.getId(), type, state, service, false, false, false, stateDateTime);
         blockingStateDao.setBlockingState(blockingState, clock, internalCallContext);
 
-        Assert.assertEquals(blockingStateDao.getBlockingAll(blockableId, internalCallContext).size(), 1);
+        Assert.assertEquals(blockingStateDao.getBlockingAll(entitlement.getId(), type, internalCallContext).size(), 1);
     }
 
     // See https://github.com/killbill/killbill/issues/111
@@ -63,7 +75,7 @@ public class TestDefaultBlockingStateDao extends EntitlementTestSuiteWithEmbedde
         final String serviceB = "service-B";
 
         // Verify initial state
-        Assert.assertEquals(blockingStateDao.getBlockingAll(blockableId, internalCallContext).size(), 0);
+        Assert.assertEquals(blockingStateDao.getBlockingAll(blockableId, type, internalCallContext).size(), 0);
 
         // Note: the checkers below rely on record_id ordering, not effective date
 
@@ -71,7 +83,7 @@ public class TestDefaultBlockingStateDao extends EntitlementTestSuiteWithEmbedde
         final DateTime stateDateTime = new DateTime(2013, 5, 6, 10, 11, 12, DateTimeZone.UTC);
         final BlockingState blockingState1 = new DefaultBlockingState(blockableId, type, state, serviceA, false, false, false, stateDateTime);
         blockingStateDao.setBlockingState(blockingState1, clock, internalCallContext);
-        final List<BlockingState> blockingStates1 = blockingStateDao.getBlockingAll(blockableId, internalCallContext);
+        final List<BlockingState> blockingStates1 = blockingStateDao.getBlockingAll(blockableId, type, internalCallContext);
         Assert.assertEquals(blockingStates1.size(), 1);
         Assert.assertEquals(blockingStates1.get(0).getBlockedId(), blockableId);
         Assert.assertEquals(blockingStates1.get(0).getStateName(), state);
@@ -80,7 +92,7 @@ public class TestDefaultBlockingStateDao extends EntitlementTestSuiteWithEmbedde
 
         // Set the same state again - no change
         blockingStateDao.setBlockingState(blockingState1, clock, internalCallContext);
-        final List<BlockingState> blockingStates2 = blockingStateDao.getBlockingAll(blockableId, internalCallContext);
+        final List<BlockingState> blockingStates2 = blockingStateDao.getBlockingAll(blockableId, type, internalCallContext);
         Assert.assertEquals(blockingStates2.size(), 1);
         Assert.assertEquals(blockingStates2.get(0).getBlockedId(), blockableId);
         Assert.assertEquals(blockingStates2.get(0).getStateName(), state);
@@ -90,7 +102,7 @@ public class TestDefaultBlockingStateDao extends EntitlementTestSuiteWithEmbedde
         // Set the state for service B
         final BlockingState blockingState2 = new DefaultBlockingState(blockableId, type, state, serviceB, false, false, false, stateDateTime);
         blockingStateDao.setBlockingState(blockingState2, clock, internalCallContext);
-        final List<BlockingState> blockingStates3 = blockingStateDao.getBlockingAll(blockableId, internalCallContext);
+        final List<BlockingState> blockingStates3 = blockingStateDao.getBlockingAll(blockableId, type, internalCallContext);
         Assert.assertEquals(blockingStates3.size(), 2);
         Assert.assertEquals(blockingStates3.get(0).getBlockedId(), blockableId);
         Assert.assertEquals(blockingStates3.get(0).getStateName(), state);
@@ -105,7 +117,7 @@ public class TestDefaultBlockingStateDao extends EntitlementTestSuiteWithEmbedde
         final DateTime stateDateTime2 = new DateTime(2013, 6, 6, 10, 11, 12, DateTimeZone.UTC);
         final BlockingState blockingState3 = new DefaultBlockingState(blockableId, type, state, serviceA, false, false, false, stateDateTime2);
         blockingStateDao.setBlockingState(blockingState3, clock, internalCallContext);
-        final List<BlockingState> blockingStates4 = blockingStateDao.getBlockingAll(blockableId, internalCallContext);
+        final List<BlockingState> blockingStates4 = blockingStateDao.getBlockingAll(blockableId, type, internalCallContext);
         Assert.assertEquals(blockingStates4.size(), 2);
         Assert.assertEquals(blockingStates4.get(0).getBlockedId(), blockableId);
         Assert.assertEquals(blockingStates4.get(0).getStateName(), state);
@@ -120,7 +132,7 @@ public class TestDefaultBlockingStateDao extends EntitlementTestSuiteWithEmbedde
         final DateTime stateDateTime3 = new DateTime(2013, 2, 6, 10, 11, 12, DateTimeZone.UTC);
         final BlockingState blockingState4 = new DefaultBlockingState(blockableId, type, state, serviceA, false, false, false, stateDateTime3);
         blockingStateDao.setBlockingState(blockingState4, clock, internalCallContext);
-        final List<BlockingState> blockingStates5 = blockingStateDao.getBlockingAll(blockableId, internalCallContext);
+        final List<BlockingState> blockingStates5 = blockingStateDao.getBlockingAll(blockableId, type, internalCallContext);
         Assert.assertEquals(blockingStates5.size(), 2);
         Assert.assertEquals(blockingStates5.get(0).getBlockedId(), blockableId);
         Assert.assertEquals(blockingStates5.get(0).getStateName(), state);
@@ -135,7 +147,7 @@ public class TestDefaultBlockingStateDao extends EntitlementTestSuiteWithEmbedde
         final DateTime state2DateTime = new DateTime(2013, 12, 6, 10, 11, 12, DateTimeZone.UTC);
         final BlockingState blockingState5 = new DefaultBlockingState(blockableId, type, state2, serviceA, false, false, false, state2DateTime);
         blockingStateDao.setBlockingState(blockingState5, clock, internalCallContext);
-        final List<BlockingState> blockingStates6 = blockingStateDao.getBlockingAll(blockableId, internalCallContext);
+        final List<BlockingState> blockingStates6 = blockingStateDao.getBlockingAll(blockableId, type, internalCallContext);
         Assert.assertEquals(blockingStates6.size(), 3);
         Assert.assertEquals(blockingStates6.get(0).getBlockedId(), blockableId);
         Assert.assertEquals(blockingStates6.get(0).getStateName(), state);

diff --git a/entitlement/src/test/java/com/ning/billing/entitlement/engine/core/TestEntitlementUtils.java b/entitlement/src/test/java/com/ning/billing/entitlement/engine/core/TestEntitlementUtils.java
index 498448f..bb5f2d9 100644
--- a/entitlement/src/test/java/com/ning/billing/entitlement/engine/core/TestEntitlementUtils.java
+++ b/entitlement/src/test/java/com/ning/billing/entitlement/engine/core/TestEntitlementUtils.java
@@ -300,7 +300,7 @@ public class TestEntitlementUtils extends EntitlementTestSuiteWithEmbeddedDB {
 
     // Test the DAO
     private void checkBlockingStatesDAO(final Entitlement baseEntitlement, final Entitlement addOnEntitlement, final LocalDate effectiveCancellationDate, final boolean isBaseCancelled) {
-        final List<BlockingState> blockingStatesForBaseEntitlement = blockingStateDao.getBlockingAll(baseEntitlement.getId(), internalCallContext);
+        final List<BlockingState> blockingStatesForBaseEntitlement = blockingStateDao.getBlockingAll(baseEntitlement.getId(), BlockingStateType.SUBSCRIPTION, internalCallContext);
         Assert.assertEquals(blockingStatesForBaseEntitlement.size(), isBaseCancelled ? 1 : 0);
         if (isBaseCancelled) {
             Assert.assertEquals(blockingStatesForBaseEntitlement.get(0).getBlockedId(), baseEntitlement.getId());
@@ -310,7 +310,7 @@ public class TestEntitlementUtils extends EntitlementTestSuiteWithEmbeddedDB {
             Assert.assertEquals(blockingStatesForBaseEntitlement.get(0).getStateName(), DefaultEntitlementApi.ENT_STATE_CANCELLED);
         }
 
-        final List<BlockingState> blockingStatesForAddOn = blockingStateDao.getBlockingAll(addOnEntitlement.getId(), internalCallContext);
+        final List<BlockingState> blockingStatesForAddOn = blockingStateDao.getBlockingAll(addOnEntitlement.getId(), BlockingStateType.SUBSCRIPTION, internalCallContext);
         Assert.assertEquals(blockingStatesForAddOn.size(), 1);
         Assert.assertEquals(blockingStatesForAddOn.get(0).getBlockedId(), addOnEntitlement.getId());
         Assert.assertEquals(blockingStatesForAddOn.get(0).getEffectiveDate().toLocalDate(), effectiveCancellationDate);

diff --git a/junction/src/main/java/com/ning/billing/junction/plumbing/billing/BlockingCalculator.java b/junction/src/main/java/com/ning/billing/junction/plumbing/billing/BlockingCalculator.java
index 37a3831..e2cca24 100644
--- a/junction/src/main/java/com/ning/billing/junction/plumbing/billing/BlockingCalculator.java
+++ b/junction/src/main/java/com/ning/billing/junction/plumbing/billing/BlockingCalculator.java
@@ -33,6 +33,7 @@ import com.ning.billing.catalog.api.BillingPeriod;
 import com.ning.billing.catalog.api.Currency;
 import com.ning.billing.catalog.api.Plan;
 import com.ning.billing.catalog.api.PlanPhase;
+import com.ning.billing.entitlement.api.BlockingStateType;
 import com.ning.billing.subscription.api.SubscriptionBaseTransitionType;
 import com.ning.billing.subscription.api.SubscriptionBase;
 import com.ning.billing.entitlement.api.BlockingState;
@@ -92,8 +93,8 @@ public class BlockingCalculator {
         final SortedSet<BillingEvent> billingEventsToRemove = new TreeSet<BillingEvent>();
 
         for (final UUID bundleId : bundleMap.keySet()) {
-            final List<BlockingState> blockingEvents = blockingApi.getBlockingAll(bundleId, context);
-            blockingEvents.addAll(blockingApi.getBlockingAll(account.getId(),context));
+            final List<BlockingState> blockingEvents = blockingApi.getBlockingAll(bundleId, BlockingStateType.SUBSCRIPTION_BUNDLE, context);
+            blockingEvents.addAll(blockingApi.getBlockingAll(account.getId(), BlockingStateType.ACCOUNT, context));
             final List<DisabledDuration> blockingDurations = createBlockingDurations(blockingEvents);
 
             for (final SubscriptionBase subscription : bundleMap.get(bundleId)) {

diff --git a/overdue/src/main/java/com/ning/billing/overdue/api/DefaultOverdueUserApi.java b/overdue/src/main/java/com/ning/billing/overdue/api/DefaultOverdueUserApi.java
index 5d16dd7..20e4bf2 100644
--- a/overdue/src/main/java/com/ning/billing/overdue/api/DefaultOverdueUserApi.java
+++ b/overdue/src/main/java/com/ning/billing/overdue/api/DefaultOverdueUserApi.java
@@ -22,6 +22,9 @@ import org.slf4j.LoggerFactory;
 import com.ning.billing.ErrorCode;
 import com.ning.billing.ObjectType;
 import com.ning.billing.account.api.Account;
+import com.ning.billing.callcontext.InternalCallContext;
+import com.ning.billing.entitlement.api.BlockingStateType;
+import com.ning.billing.junction.BlockingInternalApi;
 import com.ning.billing.overdue.OverdueApiException;
 import com.ning.billing.overdue.OverdueService;
 import com.ning.billing.overdue.OverdueState;
@@ -33,10 +36,8 @@ import com.ning.billing.overdue.config.api.OverdueStateSet;
 import com.ning.billing.overdue.wrapper.OverdueWrapper;
 import com.ning.billing.overdue.wrapper.OverdueWrapperFactory;
 import com.ning.billing.util.callcontext.CallContext;
-import com.ning.billing.callcontext.InternalCallContext;
 import com.ning.billing.util.callcontext.InternalCallContextFactory;
 import com.ning.billing.util.callcontext.TenantContext;
-import com.ning.billing.junction.BlockingInternalApi;
 
 import com.google.inject.Inject;
 
@@ -61,7 +62,7 @@ public class DefaultOverdueUserApi implements OverdueUserApi {
     @Override
     public OverdueState getOverdueStateFor(final Account overdueable, final TenantContext context) throws OverdueException {
         try {
-            final String stateName = accessApi.getBlockingStateForService(overdueable, OverdueService.OVERDUE_SERVICE_NAME, internalCallContextFactory.createInternalTenantContext(context)).getStateName();
+            final String stateName = accessApi.getBlockingStateForService(overdueable.getId(), BlockingStateType.ACCOUNT, OverdueService.OVERDUE_SERVICE_NAME, internalCallContextFactory.createInternalTenantContext(context)).getStateName();
             final OverdueStateSet states = overdueConfig.getStateSet();
             return states.findState(stateName);
         } catch (OverdueApiException e) {

diff --git a/overdue/src/main/java/com/ning/billing/overdue/wrapper/OverdueWrapper.java b/overdue/src/main/java/com/ning/billing/overdue/wrapper/OverdueWrapper.java
index 2959b65..74e8641 100644
--- a/overdue/src/main/java/com/ning/billing/overdue/wrapper/OverdueWrapper.java
+++ b/overdue/src/main/java/com/ning/billing/overdue/wrapper/OverdueWrapper.java
@@ -17,6 +17,11 @@
 package com.ning.billing.overdue.wrapper;
 
 import com.ning.billing.account.api.Account;
+import com.ning.billing.callcontext.InternalCallContext;
+import com.ning.billing.callcontext.InternalTenantContext;
+import com.ning.billing.clock.Clock;
+import com.ning.billing.entitlement.api.BlockingStateType;
+import com.ning.billing.junction.BlockingInternalApi;
 import com.ning.billing.overdue.OverdueApiException;
 import com.ning.billing.overdue.OverdueService;
 import com.ning.billing.overdue.OverdueState;
@@ -25,12 +30,9 @@ import com.ning.billing.overdue.calculator.BillingStateCalculator;
 import com.ning.billing.overdue.config.api.BillingState;
 import com.ning.billing.overdue.config.api.OverdueException;
 import com.ning.billing.overdue.config.api.OverdueStateSet;
-import com.ning.billing.callcontext.InternalCallContext;
-import com.ning.billing.callcontext.InternalTenantContext;
-import com.ning.billing.clock.Clock;
-import com.ning.billing.junction.BlockingInternalApi;
 
 public class OverdueWrapper {
+
     private final Account overdueable;
     private final BlockingInternalApi api;
     private final Clock clock;
@@ -57,7 +59,7 @@ public class OverdueWrapper {
         }
 
         final BillingState billingState = billingState(context);
-        final String previousOverdueStateName = api.getBlockingStateForService(overdueable, OverdueService.OVERDUE_SERVICE_NAME, context).getStateName();
+        final String previousOverdueStateName = api.getBlockingStateForService(overdueable.getId(), BlockingStateType.ACCOUNT, OverdueService.OVERDUE_SERVICE_NAME, context).getStateName();
 
         final OverdueState currentOverdueState = overdueStateSet.findState(previousOverdueStateName);
         final OverdueState nextOverdueState = overdueStateSet.calculateOverdueState(billingState, clock.getToday(billingState.getAccountTimeZone()));
@@ -68,7 +70,7 @@ public class OverdueWrapper {
     }
 
     public void clear(final InternalCallContext context) throws OverdueException, OverdueApiException {
-        final String previousOverdueStateName = api.getBlockingStateForService(overdueable, OverdueService.OVERDUE_SERVICE_NAME, context).getStateName();
+        final String previousOverdueStateName = api.getBlockingStateForService(overdueable.getId(), BlockingStateType.ACCOUNT, OverdueService.OVERDUE_SERVICE_NAME, context).getStateName();
         final OverdueState previousOverdueState = overdueStateSet.findState(previousOverdueStateName);
         overdueStateApplicator.clear(overdueable, previousOverdueState, overdueStateSet.getClearState(), context);
     }

diff --git a/overdue/src/test/java/com/ning/billing/overdue/glue/ApplicatorMockJunctionModule.java b/overdue/src/test/java/com/ning/billing/overdue/glue/ApplicatorMockJunctionModule.java
index d239661..12625ab 100644
--- a/overdue/src/test/java/com/ning/billing/overdue/glue/ApplicatorMockJunctionModule.java
+++ b/overdue/src/test/java/com/ning/billing/overdue/glue/ApplicatorMockJunctionModule.java
@@ -19,13 +19,11 @@ package com.ning.billing.overdue.glue;
 import java.util.List;
 import java.util.UUID;
 
-import org.joda.time.DateTime;
-
-import com.ning.billing.entitlement.api.Blockable;
-import com.ning.billing.entitlement.api.BlockingState;
-import com.ning.billing.entitlement.api.BlockingStateType;
 import com.ning.billing.callcontext.InternalCallContext;
 import com.ning.billing.callcontext.InternalTenantContext;
+import com.ning.billing.clock.ClockMock;
+import com.ning.billing.entitlement.api.BlockingState;
+import com.ning.billing.entitlement.api.BlockingStateType;
 import com.ning.billing.junction.BlockingInternalApi;
 import com.ning.billing.junction.DefaultBlockingState;
 
@@ -47,107 +45,23 @@ public class ApplicatorMockJunctionModule extends AbstractModule {
         }
 
         @Override
-        public BlockingState getBlockingStateForService(final Blockable blockable, final String serviceName, final InternalTenantContext context) {
-            return new BlockingState() {
-
-                @Override
-                public UUID getBlockedId() {
-                    return blockable.getId();
-                }
-
-                @Override
-                public String getStateName() {
-                    return DefaultBlockingState.CLEAR_STATE_NAME;
-                }
-
-                @Override
-                public BlockingStateType getType() {
-                    return BlockingStateType.ACCOUNT;
-                }
-
-                @Override
-                public DateTime getEffectiveDate() {
-                    return null;
-                }
-
-                @Override
-                public boolean isBlockChange() {
-                    return false;
-                }
-
-                @Override
-                public boolean isBlockEntitlement() {
-                    return false;
-                }
-
-                @Override
-                public boolean isBlockBilling() {
-                    return false;
-                }
-
-                @Override
-                public int compareTo(final BlockingState arg0) {
-                    return 0;
-                }
-
-                @Override
-                public String getDescription() {
-                    return null;
-                }
-
-                @Override
-                public String getService() {
-                    return "whatever";
-                }
-
-                @Override
-                public UUID getId() {
-                    return UUID.randomUUID();
-                }
-
-                @Override
-                public DateTime getCreatedDate() {
-                    return null;
-                }
-
-                @Override
-                public DateTime getUpdatedDate() {
-                    return null;
-                }
-            };
-        }
-
-        @Override
-        public BlockingState getBlockingStateForService(final UUID blockableId, final String serviceName, final InternalTenantContext context) {
-            throw new UnsupportedOperationException();
-        }
-
-        @Override
-        public List<BlockingState> getBlockingHistoryForService(final Blockable blockable, final String serviceName, final InternalTenantContext context) {
-            throw new UnsupportedOperationException();
-        }
-
-        @Override
-        public List<BlockingState> getBlockingHistoryForService(final UUID blockableId, final String serviceName, final InternalTenantContext context) {
-            throw new UnsupportedOperationException();
+        public BlockingState getBlockingStateForService(final UUID blockableId, final BlockingStateType blockingStateType, final String serviceName, final InternalTenantContext context) {
+            if (blockingState != null && blockingState.getBlockedId().equals(blockableId)) {
+                return blockingState;
+            } else {
+                return DefaultBlockingState.getClearState(blockingStateType, serviceName, new ClockMock());
+            }
         }
 
         @Override
-        public List<BlockingState> getBlockingAll(final Blockable blockable, final InternalTenantContext context) {
+        public List<BlockingState> getBlockingAll(final UUID blockableId, final BlockingStateType blockingStateType, final InternalTenantContext context) {
             throw new UnsupportedOperationException();
         }
 
         @Override
-        public List<BlockingState> getBlockingAll(final UUID blockableId, final InternalTenantContext context) {
-            throw new UnsupportedOperationException();
-        }
-
-
-        @Override
         public void setBlockingState(final BlockingState state, final InternalCallContext context) {
             blockingState = state;
         }
-
     }
 
     public void installBlockingApi() {