killbill-aplcache

diff --git a/catalog/src/main/java/org/killbill/billing/catalog/dao/CatalogOverridePhaseUsageModelDao.java b/catalog/src/main/java/org/killbill/billing/catalog/dao/CatalogOverridePhaseUsageModelDao.java
index b4e8f7f..5cf6d95 100644
--- a/catalog/src/main/java/org/killbill/billing/catalog/dao/CatalogOverridePhaseUsageModelDao.java
+++ b/catalog/src/main/java/org/killbill/billing/catalog/dao/CatalogOverridePhaseUsageModelDao.java
@@ -21,8 +21,8 @@ import org.joda.time.DateTime;
 
 public class CatalogOverridePhaseUsageModelDao {
 
-    private Short usageNumber;
     private Long recordId;
+    private Short usageNumber;
     private Long usageDefRecordId;
     private Long targetPhaseDefRecordId;
     private DateTime createdDate;

diff --git a/catalog/src/main/java/org/killbill/billing/catalog/dao/CatalogOverrideTierBlockModelDao.java b/catalog/src/main/java/org/killbill/billing/catalog/dao/CatalogOverrideTierBlockModelDao.java
index 8235a08..5bcfdc6 100644
--- a/catalog/src/main/java/org/killbill/billing/catalog/dao/CatalogOverrideTierBlockModelDao.java
+++ b/catalog/src/main/java/org/killbill/billing/catalog/dao/CatalogOverrideTierBlockModelDao.java
@@ -23,7 +23,7 @@ public class CatalogOverrideTierBlockModelDao {
     private Short blockNumber;
     private Long recordId;
     private Long blockDefRecordId;
-    private Long targetTierRecordId;
+    private Long targetTierDefRecordId;
     private DateTime createdDate;
     private String createdBy;
     private Long tenantRecordId;
@@ -31,10 +31,10 @@ public class CatalogOverrideTierBlockModelDao {
     public CatalogOverrideTierBlockModelDao() {
     }
 
-    public CatalogOverrideTierBlockModelDao(Short blockNumber, Long blockDefRecordId, Long targetTierRecordId) {
+    public CatalogOverrideTierBlockModelDao(Short blockNumber, Long blockDefRecordId, Long targetTierDefRecordId) {
         this.blockNumber = blockNumber;
         this.blockDefRecordId = blockDefRecordId;
-        this.targetTierRecordId = targetTierRecordId;
+        this.targetTierDefRecordId = targetTierDefRecordId;
     }
 
     public Short getBlockNumber() {
@@ -49,8 +49,8 @@ public class CatalogOverrideTierBlockModelDao {
         return blockDefRecordId;
     }
 
-    public Long getTargetTierRecordId() {
-        return targetTierRecordId;
+    public Long getTargetTierDefRecordId() {
+        return targetTierDefRecordId;
     }
 
     public String getCreatedBy() {
@@ -77,8 +77,8 @@ public class CatalogOverrideTierBlockModelDao {
         this.blockDefRecordId = blockDefRecordId;
     }
 
-    public void setTargetTierRecordId(Long targetTierRecordId) {
-        this.targetTierRecordId = targetTierRecordId;
+    public void setTargetTierDefRecordId(Long targetTierDefRecordId) {
+        this.targetTierDefRecordId = targetTierDefRecordId;
     }
 
     public void setCreatedDate(DateTime createdDate) {

diff --git a/catalog/src/main/java/org/killbill/billing/catalog/dao/CatalogOverrideUsageDefinitionModelDao.java b/catalog/src/main/java/org/killbill/billing/catalog/dao/CatalogOverrideUsageDefinitionModelDao.java
index df9c010..62eafbe 100644
--- a/catalog/src/main/java/org/killbill/billing/catalog/dao/CatalogOverrideUsageDefinitionModelDao.java
+++ b/catalog/src/main/java/org/killbill/billing/catalog/dao/CatalogOverrideUsageDefinitionModelDao.java
@@ -17,15 +17,15 @@
 
 package org.killbill.billing.catalog.dao;
 
-import org.joda.time.DateTime;
-
 import java.math.BigDecimal;
 
+import org.joda.time.DateTime;
+
 public class CatalogOverrideUsageDefinitionModelDao {
 
     private Long recordId;
     private String parentUsageName;
-    private String parentUsageType;
+    private String type;
     private String currency;
     private BigDecimal fixedPrice;
     private BigDecimal recurringPrice;
@@ -37,10 +37,10 @@ public class CatalogOverrideUsageDefinitionModelDao {
     public CatalogOverrideUsageDefinitionModelDao() {
     }
 
-    public CatalogOverrideUsageDefinitionModelDao(String parentUsageName, String parentUsageType, String currency, BigDecimal fixedPrice, BigDecimal recurringPrice, DateTime effectiveDate) {
+    public CatalogOverrideUsageDefinitionModelDao(String parentUsageName, String type, String currency, BigDecimal fixedPrice, BigDecimal recurringPrice, DateTime effectiveDate) {
 
         this.parentUsageName = parentUsageName;
-        this.parentUsageType = parentUsageType;
+        this.type = type;
         this.currency = currency;
         this.fixedPrice = fixedPrice;
         this.recurringPrice = recurringPrice;
@@ -59,8 +59,8 @@ public class CatalogOverrideUsageDefinitionModelDao {
         this.parentUsageName = parentUsageName;
     }
 
-    public void setParentUsageType(String parentUsageType) {
-        this.parentUsageType = parentUsageType;
+    public void setType(String type) {
+        this.type = type;
     }
 
     public void setCurrency(String currency) {
@@ -95,8 +95,8 @@ public class CatalogOverrideUsageDefinitionModelDao {
         return parentUsageName;
     }
 
-    public String getParentUsageType() {
-        return parentUsageType;
+    public String getType() {
+        return type;
     }
 
     public String getCurrency() {

diff --git a/catalog/src/main/java/org/killbill/billing/catalog/dao/CatalogOverrideUsageDefinitionSqlDao.java b/catalog/src/main/java/org/killbill/billing/catalog/dao/CatalogOverrideUsageDefinitionSqlDao.java
index a54e776..24ad294 100644
--- a/catalog/src/main/java/org/killbill/billing/catalog/dao/CatalogOverrideUsageDefinitionSqlDao.java
+++ b/catalog/src/main/java/org/killbill/billing/catalog/dao/CatalogOverrideUsageDefinitionSqlDao.java
@@ -45,7 +45,7 @@ public interface CatalogOverrideUsageDefinitionSqlDao extends Transactional<Cata
                                                                                 @SmartBindBean final InternalTenantContext context);
 
     @SqlQuery
-    public List<CatalogOverrideUsageDefinitionModelDao> getByAttributes(@Bind("parentUsageName") String parentPhaseName,
+    public List<CatalogOverrideUsageDefinitionModelDao> getByAttributes(@Bind("parentUsageName") String parentUsageName,
                                                                         @SmartBindBean final InternalTenantContext context);
 
     @SqlQuery

diff --git a/catalog/src/main/resources/org/killbill/billing/catalog/dao/CatalogOverrideTierBlockSqlDao.sql.stg b/catalog/src/main/resources/org/killbill/billing/catalog/dao/CatalogOverrideTierBlockSqlDao.sql.stg
index 34e52da..6fd7732 100644
--- a/catalog/src/main/resources/org/killbill/billing/catalog/dao/CatalogOverrideTierBlockSqlDao.sql.stg
+++ b/catalog/src/main/resources/org/killbill/billing/catalog/dao/CatalogOverrideTierBlockSqlDao.sql.stg
@@ -19,7 +19,7 @@ allTableFields(prefix) ::= <<
 tableValues() ::= <<
   :blockNumber
 , :blockDefRecordId
-, :targetTierRecordId
+, :targetTierDefRecordId
 , :createdDate
 , :createdBy
 , :tenantRecordId

diff --git a/catalog/src/main/resources/org/killbill/billing/catalog/dao/CatalogOverrideUsageDefinitionSqlDao.sql.stg b/catalog/src/main/resources/org/killbill/billing/catalog/dao/CatalogOverrideUsageDefinitionSqlDao.sql.stg
index 9455c49..359d435 100644
--- a/catalog/src/main/resources/org/killbill/billing/catalog/dao/CatalogOverrideUsageDefinitionSqlDao.sql.stg
+++ b/catalog/src/main/resources/org/killbill/billing/catalog/dao/CatalogOverrideUsageDefinitionSqlDao.sql.stg
@@ -22,7 +22,7 @@ allTableFields(prefix) ::= <<
 
 tableValues() ::= <<
   :parentUsageName
-, :parentUsageType
+, :type
 , :fixedPrice
 , :recurringPrice
 , :effectiveDate

diff --git a/catalog/src/test/java/org/killbill/billing/catalog/dao/TestCatalogOverrideBlockDefinitionSqlDao.java b/catalog/src/test/java/org/killbill/billing/catalog/dao/TestCatalogOverrideBlockDefinitionSqlDao.java
index 591a6ef..f4f6fc0 100644
--- a/catalog/src/test/java/org/killbill/billing/catalog/dao/TestCatalogOverrideBlockDefinitionSqlDao.java
+++ b/catalog/src/test/java/org/killbill/billing/catalog/dao/TestCatalogOverrideBlockDefinitionSqlDao.java
@@ -29,7 +29,6 @@ import org.testng.annotations.BeforeClass;
 import org.testng.annotations.Test;
 
 import static org.testng.Assert.assertEquals;
-import static org.testng.Assert.assertNull;
 
 public class TestCatalogOverrideBlockDefinitionSqlDao extends CatalogTestSuiteWithEmbeddedDB {
 
@@ -42,8 +41,7 @@ public class TestCatalogOverrideBlockDefinitionSqlDao extends CatalogTestSuiteWi
     @Test(groups = "slow")
     public void testBasic() throws Exception {
 
-        final CatalogOverrideBlockDefinitionModelDao obj1 = new CatalogOverrideBlockDefinitionModelDao("p1","USD" ,BigDecimal.ONE ,1 ,1 , clock.getUTCNow());
-
+        final CatalogOverrideBlockDefinitionModelDao obj1 = new CatalogOverrideBlockDefinitionModelDao("p1", "USD", BigDecimal.ONE, 1 , 1, clock.getUTCNow());
         performTestInTransaction(new WithCatalogOverrideBlockDefinitionSqlDaoTransaction<Void>() {
             @Override
             public Void doTransaction(final CatalogOverrideBlockDefinitionSqlDao sqlDao) {
@@ -52,7 +50,7 @@ public class TestCatalogOverrideBlockDefinitionSqlDao extends CatalogTestSuiteWi
 
                 final CatalogOverrideBlockDefinitionModelDao rehydrated = sqlDao.getByRecordId(lastInserted, internalCallContext);
                 assertEquals(rehydrated.getParentUnitName(), obj1.getParentUnitName());
-                assertEquals(rehydrated.getCurrency().compareTo(obj1.getCurrency()), 0);
+                assertEquals(rehydrated.getCurrency(), obj1.getCurrency());
                 assertEquals(rehydrated.getPrice().compareTo(obj1.getPrice()), 0);
                 assertEquals(rehydrated.getSize(), obj1.getSize());
                 assertEquals(rehydrated.getMax(), obj1.getMax());
@@ -64,36 +62,33 @@ public class TestCatalogOverrideBlockDefinitionSqlDao extends CatalogTestSuiteWi
     @Test(groups = "slow")
     public void testGetByAttributes() throws Exception {
 
-        final CatalogOverrideBlockDefinitionModelDao objWithNoNullPrice = new CatalogOverrideBlockDefinitionModelDao("p2", "USD", BigDecimal.ONE, 1, 5, clock.getUTCNow());
+        final CatalogOverrideBlockDefinitionModelDao objWithNoNullPrice = new CatalogOverrideBlockDefinitionModelDao("p2", "USD", BigDecimal.ONE, new Double("1"), new Double("5"), clock.getUTCNow());
 
         performTestInTransaction(new WithCatalogOverrideBlockDefinitionSqlDaoTransaction<Void>() {
             @Override
             public Void doTransaction(final CatalogOverrideBlockDefinitionSqlDao sqlDao) {
                 sqlDao.create(objWithNoNullPrice, internalCallContext);
-                final Long lastInserted = sqlDao.getLastInsertId();
                 checkRehydrated(objWithNoNullPrice, sqlDao);
 
                 return null;
             }
 
             private void checkRehydrated(final CatalogOverrideBlockDefinitionModelDao obj, final CatalogOverrideBlockDefinitionSqlDao sqlDao) {
-                final CatalogOverrideBlockDefinitionModelDao rehydrated = sqlDao.getByAttributes(obj.getParentUnitName(), obj.getCurrency(), obj.getPrice(), obj.getSize(),obj.getMax(), internalCallContext);
-               /* assertEquals(rehydrated.getParentUnitName(), obj.getParentUnitName());
+                final CatalogOverrideBlockDefinitionModelDao rehydrated = sqlDao.getByAttributes(obj.getParentUnitName(), obj.getCurrency(), obj.getPrice(),obj.getMax(),obj.getSize(), internalCallContext);
+                assertEquals(rehydrated.getParentUnitName(), obj.getParentUnitName());
                 assertEquals(rehydrated.getCurrency(), obj.getCurrency());
-                assertEquals(rehydrated.getPrice(), obj.getPrice());
+                assertEquals(rehydrated.getPrice().compareTo(obj.getPrice()), 0);
                 assertEquals(rehydrated.getSize(), obj.getSize());
-                assertEquals(rehydrated.getMax(), obj.getMax()); */
+                assertEquals(rehydrated.getMax(), obj.getMax());
             }
         });
     }
 
-  private interface WithCatalogOverrideBlockDefinitionSqlDaoTransaction<T> {
+    private interface WithCatalogOverrideBlockDefinitionSqlDaoTransaction<T> {
 
         public <T> T doTransaction(final CatalogOverrideBlockDefinitionSqlDao sqlDao);
     }
 
-
-
     private <T> T performTestInTransaction(final WithCatalogOverrideBlockDefinitionSqlDaoTransaction<T> callback) {
         return dbi.inTransaction(new TransactionCallback<T>() {
             @Override
@@ -103,5 +98,4 @@ public class TestCatalogOverrideBlockDefinitionSqlDao extends CatalogTestSuiteWi
             }
         });
     }
-
 }

diff --git a/catalog/src/test/java/org/killbill/billing/catalog/dao/TestCatalogOverrideDao.java b/catalog/src/test/java/org/killbill/billing/catalog/dao/TestCatalogOverrideDao.java
index 39d6c3f..89a160f 100644
--- a/catalog/src/test/java/org/killbill/billing/catalog/dao/TestCatalogOverrideDao.java
+++ b/catalog/src/test/java/org/killbill/billing/catalog/dao/TestCatalogOverrideDao.java
@@ -18,15 +18,23 @@
 package org.killbill.billing.catalog.dao;
 
 import java.math.BigDecimal;
+import java.util.ArrayList;
 import java.util.List;
 
 import org.joda.time.DateTime;
 import org.killbill.billing.catalog.CatalogTestSuiteWithEmbeddedDB;
 import org.killbill.billing.catalog.DefaultPlanPhasePriceOverride;
+import org.killbill.billing.catalog.DefaultTierPriceOverride;
+import org.killbill.billing.catalog.DefaultTieredBlockPriceOverride;
+import org.killbill.billing.catalog.DefaultUsagePriceOverride;
 import org.killbill.billing.catalog.StandaloneCatalog;
 import org.killbill.billing.catalog.api.Currency;
 import org.killbill.billing.catalog.api.Plan;
 import org.killbill.billing.catalog.api.PlanPhasePriceOverride;
+import org.killbill.billing.catalog.api.TierPriceOverride;
+import org.killbill.billing.catalog.api.TieredBlockPriceOverride;
+import org.killbill.billing.catalog.api.UsagePriceOverride;
+import org.killbill.billing.catalog.api.UsageType;
 import org.killbill.xmlloader.XMLLoader;
 import org.testng.annotations.Test;
 
@@ -94,5 +102,56 @@ public class TestCatalogOverrideDao extends CatalogTestSuiteWithEmbeddedDB {
         }
     }
 
+    @Test(groups = "slow")
+    public void testGetOverriddenPlanPhasesWithUsageOverrides() throws Exception {
+
+        final StandaloneCatalog catalog = XMLLoader.getObjectFromString(Resources.getResource("SpyCarAdvanced.xml").toExternalForm(), StandaloneCatalog.class);
+        final Plan plan = catalog.findCurrentPlan("gas-monthly");
+
+        final PlanPhasePriceOverride[] resolvedOverrides = new PlanPhasePriceOverride[plan.getAllPhases().length];
+
+        List<TieredBlockPriceOverride> tieredBlockPriceOverrides = new ArrayList<TieredBlockPriceOverride>();
+        DefaultTieredBlockPriceOverride tieredBlockPriceOverride = new DefaultTieredBlockPriceOverride("gallons",new Double("1"), new BigDecimal(4), new Double("100"));
+        tieredBlockPriceOverrides.add(tieredBlockPriceOverride);
+
+        List<TierPriceOverride> tierPriceOverrides = new ArrayList<TierPriceOverride>();
+        DefaultTierPriceOverride tierPriceOverride = new DefaultTierPriceOverride(tieredBlockPriceOverrides);
+        tierPriceOverrides.add(tierPriceOverride);
+
+        List<UsagePriceOverride> usagePriceOverrides = new ArrayList<UsagePriceOverride>();
+        DefaultUsagePriceOverride usagePriceOverride = new DefaultUsagePriceOverride("gas-monthly-in-arrear", UsageType.CONSUMABLE, tierPriceOverrides);
+        usagePriceOverrides.add(usagePriceOverride);
+
+        resolvedOverrides[0]  = new DefaultPlanPhasePriceOverride(plan.getFinalPhase().getName(), Currency.USD, BigDecimal.ZERO, new BigDecimal("348.64"), usagePriceOverrides);
+
+        final CatalogOverridePlanDefinitionModelDao newPlan = catalogOverrideDao.getOrCreateOverridePlanDefinition(plan, new DateTime(catalog.getEffectiveDate()), resolvedOverrides, internalCallContext);
+
+        final List<CatalogOverridePhaseDefinitionModelDao> phases = catalogOverrideDao.getOverriddenPlanPhases(newPlan.getRecordId(), internalCallContext);
+        assertEquals(phases.size(), 1);
+        final CatalogOverridePhaseDefinitionModelDao curPhase = phases.get(0);
+
+        assertEquals(curPhase.getCurrency(), resolvedOverrides[0].getCurrency().name());
+        assertEquals(curPhase.getFixedPrice().compareTo(resolvedOverrides[0].getFixedPrice()), 0);
+        assertEquals(curPhase.getRecurringPrice().compareTo(resolvedOverrides[0].getRecurringPrice()), 0);
+        assertEquals(curPhase.getParentPhaseName(), resolvedOverrides[0].getPhaseName());
+
+        final List<CatalogOverrideUsageDefinitionModelDao> usages = catalogOverrideDao.getOverriddenPhaseUsages(curPhase.getRecordId(), internalCallContext);
+        assertEquals(usages.size(), 1);
+        final CatalogOverrideUsageDefinitionModelDao curUsage = usages.get(0);
+        assertEquals(curUsage.getParentUsageName(), usagePriceOverride.getName());
+        assertEquals(curUsage.getType(), usagePriceOverride.getUsageType().toString());
+
+        final List<CatalogOverrideTierDefinitionModelDao> tiers = catalogOverrideDao.getOverriddenUsageTiers(curUsage.getRecordId(), internalCallContext);
+        assertEquals(tiers.size(), 1);
+        final CatalogOverrideTierDefinitionModelDao curTier = tiers.get(0);
+
+        final List<CatalogOverrideBlockDefinitionModelDao> tierBlocks =  catalogOverrideDao.getOverriddenTierBlocks(curTier.getRecordId(), internalCallContext);
+        assertEquals(tierBlocks.size(), 1);
+        final CatalogOverrideBlockDefinitionModelDao curTieredBlock =  tierBlocks.get(0);
+        assertEquals(curTieredBlock.getParentUnitName(),tieredBlockPriceOverride.getUnitName());
+        assertEquals(curTieredBlock.getPrice().compareTo(tieredBlockPriceOverride.getPrice()), 0);
+        assertEquals(curTieredBlock.getSize(),tieredBlockPriceOverride.getSize());
+        assertEquals(curTieredBlock.getMax(),tieredBlockPriceOverride.getMax());
+    }
 }
 

diff --git a/catalog/src/test/java/org/killbill/billing/catalog/dao/TestCatalogOverridePhaseUsageSqlDao.java b/catalog/src/test/java/org/killbill/billing/catalog/dao/TestCatalogOverridePhaseUsageSqlDao.java
new file mode 100644
index 0000000..f32c850
--- /dev/null
+++ b/catalog/src/test/java/org/killbill/billing/catalog/dao/TestCatalogOverridePhaseUsageSqlDao.java
@@ -0,0 +1,128 @@
+package org.killbill.billing.catalog.dao;
+/*
+ * Copyright 2014-2015 Groupon, Inc
+ * Copyright 2014-2015 The Billing Project, LLC
+ *
+ * The Billing Project licenses this file to you under the Apache License, version 2.0
+ * (the "License"); you may not use this file except in compliance with the
+ * License.  You may obtain a copy of the License at:
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ */
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.killbill.billing.catalog.CatalogTestSuiteWithEmbeddedDB;
+import org.killbill.commons.jdbi.mapper.LowerToCamelBeanMapperFactory;
+import org.skife.jdbi.v2.DBI;
+import org.skife.jdbi.v2.Handle;
+import org.skife.jdbi.v2.TransactionCallback;
+import org.skife.jdbi.v2.TransactionStatus;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import static org.testng.Assert.assertEquals;
+
+public class TestCatalogOverridePhaseUsageSqlDao extends CatalogTestSuiteWithEmbeddedDB {
+
+
+    @BeforeClass(groups = "slow")
+    public void beforeClass() throws Exception {
+        super.beforeClass();
+        ((DBI) dbi).registerMapper(new LowerToCamelBeanMapperFactory(CatalogOverridePhaseUsageModelDao.class));
+    }
+
+    @Test(groups = "slow")
+    public void testBasic() throws Exception {
+
+        final CatalogOverridePhaseUsageModelDao obj1 = new CatalogOverridePhaseUsageModelDao((short) 1, 2L, 3L);
+
+        performTestInTransaction(new WithCatalogOverridePhaseUsageSqlDaoTransaction<Void>() {
+            @Override
+            public Void doTransaction(final CatalogOverridePhaseUsageSqlDao sqlDao) {
+                sqlDao.create(obj1, internalCallContext);
+                final Long lastInserted = sqlDao.getLastInsertId();
+
+                final CatalogOverridePhaseUsageModelDao rehydrated = sqlDao.getByRecordId(lastInserted, internalCallContext);
+                assertEquals(rehydrated.getUsageNumber(), obj1.getUsageNumber());
+                assertEquals(rehydrated.getUsageDefRecordId(), obj1.getUsageDefRecordId());
+                assertEquals(rehydrated.getTargetPhaseDefRecordId(), obj1.getTargetPhaseDefRecordId());
+                return null;
+            }
+        });
+    }
+
+    @Test(groups = "slow")
+    public void testGetTargetPhaseDefinition() throws Exception {
+
+        final CatalogOverridePhaseUsageModelDao obj1 = new CatalogOverridePhaseUsageModelDao((short) 1, 2L, 3L);
+        final CatalogOverridePhaseUsageModelDao obj2 = new CatalogOverridePhaseUsageModelDao((short) 2, 5L, 3L);
+        final CatalogOverridePhaseUsageModelDao obj3 = new CatalogOverridePhaseUsageModelDao((short) 4, 7L, 3L);
+        final CatalogOverridePhaseUsageModelDao nobj1 = new CatalogOverridePhaseUsageModelDao((short) 4, 7L, 4L);
+
+        performTestInTransaction(new WithCatalogOverridePhaseUsageSqlDaoTransaction<Void>() {
+            @Override
+            public Void doTransaction(final CatalogOverridePhaseUsageSqlDao sqlDao) {
+                sqlDao.create(obj1, internalCallContext);
+                sqlDao.create(obj2, internalCallContext);
+                sqlDao.create(obj3, internalCallContext);
+                sqlDao.create(nobj1, internalCallContext);
+
+                final List<String> keys = new ArrayList<String>();
+                keys.add("1,2");
+                keys.add("2,5");
+                keys.add("4,7");
+                final List<Long> targetPhases = sqlDao.getTargetPhaseDefinition(keys, keys.size(), internalCallContext);
+                assertEquals(targetPhases.size(), 1);
+                assertEquals(targetPhases.get(0), new Long(3));
+                return null;
+            }
+        });
+    }
+
+    @Test(groups = "slow")
+    public void testGetTargetPhaseDefWithSameUsageOverrideAndDifferentRecurringPriceOverride() throws Exception {
+
+        final CatalogOverridePhaseUsageModelDao obj1 = new CatalogOverridePhaseUsageModelDao((short) 1, 2L, 3L);
+        final CatalogOverridePhaseUsageModelDao obj2 = new CatalogOverridePhaseUsageModelDao((short) 1, 2L, 4L);
+
+        performTestInTransaction(new WithCatalogOverridePhaseUsageSqlDaoTransaction<Void>() {
+            @Override
+            public Void doTransaction(final CatalogOverridePhaseUsageSqlDao sqlDao) {
+                sqlDao.create(obj1, internalCallContext);
+                sqlDao.create(obj2, internalCallContext);
+
+                final List<String> keys = new ArrayList<String>();
+                keys.add("1,2");
+                final List<Long> targetPhases = sqlDao.getTargetPhaseDefinition(keys, keys.size(), internalCallContext);
+                assertEquals(targetPhases.size(), 2);
+                assertEquals(targetPhases.get(0), new Long(3));
+                assertEquals(targetPhases.get(1), new Long(4));
+                return null;
+            }
+        });
+    }
+
+    private interface WithCatalogOverridePhaseUsageSqlDaoTransaction<T> {
+
+        public <T> T doTransaction(final CatalogOverridePhaseUsageSqlDao sqlDao);
+    }
+
+    private <T> T performTestInTransaction(final WithCatalogOverridePhaseUsageSqlDaoTransaction<T> callback) {
+        return dbi.inTransaction(new TransactionCallback<T>() {
+            @Override
+            public T inTransaction(final Handle handle, final TransactionStatus status) throws Exception {
+                final CatalogOverridePhaseUsageSqlDao sqlDao = handle.attach(CatalogOverridePhaseUsageSqlDao.class);
+                return callback.doTransaction(sqlDao);
+            }
+        });
+    }
+
+}

diff --git a/catalog/src/test/java/org/killbill/billing/catalog/dao/TestCatalogOverridePlanPhaseSqlDao.java b/catalog/src/test/java/org/killbill/billing/catalog/dao/TestCatalogOverridePlanPhaseSqlDao.java
index 2aed21b..996b186 100644
--- a/catalog/src/test/java/org/killbill/billing/catalog/dao/TestCatalogOverridePlanPhaseSqlDao.java
+++ b/catalog/src/test/java/org/killbill/billing/catalog/dao/TestCatalogOverridePlanPhaseSqlDao.java
@@ -17,7 +17,6 @@
 
 package org.killbill.billing.catalog.dao;
 
-import java.math.BigDecimal;
 import java.util.ArrayList;
 import java.util.List;
 
@@ -61,7 +60,6 @@ public class TestCatalogOverridePlanPhaseSqlDao extends CatalogTestSuiteWithEmbe
         });
     }
 
-
     @Test(groups = "slow")
     public void testGetTargetPlanDefinition() throws Exception {
 

diff --git a/catalog/src/test/java/org/killbill/billing/catalog/dao/TestCatalogOverrideTierBlockSqlDao.java b/catalog/src/test/java/org/killbill/billing/catalog/dao/TestCatalogOverrideTierBlockSqlDao.java
new file mode 100644
index 0000000..1f05919
--- /dev/null
+++ b/catalog/src/test/java/org/killbill/billing/catalog/dao/TestCatalogOverrideTierBlockSqlDao.java
@@ -0,0 +1,104 @@
+package org.killbill.billing.catalog.dao;
+/*
+ * Copyright 2014-2015 Groupon, Inc
+ * Copyright 2014-2015 The Billing Project, LLC
+ *
+ * The Billing Project licenses this file to you under the Apache License, version 2.0
+ * (the "License"); you may not use this file except in compliance with the
+ * License.  You may obtain a copy of the License at:
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ */
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.killbill.billing.catalog.CatalogTestSuiteWithEmbeddedDB;
+import org.killbill.commons.jdbi.mapper.LowerToCamelBeanMapperFactory;
+import org.skife.jdbi.v2.DBI;
+import org.skife.jdbi.v2.Handle;
+import org.skife.jdbi.v2.TransactionCallback;
+import org.skife.jdbi.v2.TransactionStatus;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import static org.testng.Assert.assertEquals;
+
+public class TestCatalogOverrideTierBlockSqlDao extends CatalogTestSuiteWithEmbeddedDB {
+
+
+    @BeforeClass(groups = "slow")
+    public void beforeClass() throws Exception {
+        super.beforeClass();
+        ((DBI) dbi).registerMapper(new LowerToCamelBeanMapperFactory(CatalogOverrideTierBlockModelDao.class));
+    }
+
+    @Test(groups = "slow")
+    public void testBasic() throws Exception {
+
+        final CatalogOverrideTierBlockModelDao obj1 = new CatalogOverrideTierBlockModelDao((short) 1, 2L, 3L);
+
+        performTestInTransaction(new WithCatalogOverrideTierBlockSqlDaoTransaction<Void>() {
+            @Override
+            public Void doTransaction(final CatalogOverrideTierBlockSqlDao sqlDao) {
+                sqlDao.create(obj1, internalCallContext);
+                final Long lastInserted = sqlDao.getLastInsertId();
+
+                final CatalogOverrideTierBlockModelDao rehydrated = sqlDao.getByRecordId(lastInserted, internalCallContext);
+                assertEquals(rehydrated.getBlockNumber(), obj1.getBlockNumber());
+                assertEquals(rehydrated.getBlockDefRecordId(), obj1.getBlockDefRecordId());
+                assertEquals(rehydrated.getTargetTierDefRecordId(), obj1.getTargetTierDefRecordId());
+                return null;
+            }
+        });
+    }
+
+    @Test(groups = "slow")
+    public void testGetTargetTierDefinition() throws Exception {
+
+        final CatalogOverrideTierBlockModelDao obj1 = new CatalogOverrideTierBlockModelDao((short) 1, 2L, 3L);
+        final CatalogOverrideTierBlockModelDao obj2 = new CatalogOverrideTierBlockModelDao((short) 2, 5L, 3L);
+        final CatalogOverrideTierBlockModelDao obj3 = new CatalogOverrideTierBlockModelDao((short) 4, 7L, 3L);
+        final CatalogOverrideTierBlockModelDao nobj1 = new CatalogOverrideTierBlockModelDao((short) 4, 7L, 4L);
+
+        performTestInTransaction(new WithCatalogOverrideTierBlockSqlDaoTransaction<Void>() {
+            @Override
+            public Void doTransaction(final CatalogOverrideTierBlockSqlDao sqlDao) {
+                sqlDao.create(obj1, internalCallContext);
+                sqlDao.create(obj2, internalCallContext);
+                sqlDao.create(obj3, internalCallContext);
+                sqlDao.create(nobj1, internalCallContext);
+
+                final List<String> keys = new ArrayList<String>();
+                keys.add("1,2");
+                keys.add("2,5");
+                keys.add("4,7");
+                final Long targetTier = sqlDao.getTargetTierDefinition(keys, keys.size(), internalCallContext);
+                assertEquals(targetTier, new Long(3));
+                return null;
+            }
+        });
+    }
+
+    private interface WithCatalogOverrideTierBlockSqlDaoTransaction<T> {
+
+        public <T> T doTransaction(final CatalogOverrideTierBlockSqlDao sqlDao);
+    }
+
+    private <T> T performTestInTransaction(final WithCatalogOverrideTierBlockSqlDaoTransaction<T> callback) {
+        return dbi.inTransaction(new TransactionCallback<T>() {
+            @Override
+            public T inTransaction(final Handle handle, final TransactionStatus status) throws Exception {
+                final CatalogOverrideTierBlockSqlDao sqlDao = handle.attach(CatalogOverrideTierBlockSqlDao.class);
+                return callback.doTransaction(sqlDao);
+            }
+        });
+    }
+
+}

diff --git a/catalog/src/test/java/org/killbill/billing/catalog/dao/TestCatalogOverrideTierDefinitionSqlDao.java b/catalog/src/test/java/org/killbill/billing/catalog/dao/TestCatalogOverrideTierDefinitionSqlDao.java
new file mode 100644
index 0000000..997d547
--- /dev/null
+++ b/catalog/src/test/java/org/killbill/billing/catalog/dao/TestCatalogOverrideTierDefinitionSqlDao.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright 2014-2015 Groupon, Inc
+ * Copyright 2014-2015 The Billing Project, LLC
+ *
+ * The Billing Project licenses this file to you under the Apache License, version 2.0
+ * (the "License"); you may not use this file except in compliance with the
+ * License.  You may obtain a copy of the License at:
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.killbill.billing.catalog.dao;
+
+import java.math.BigDecimal;
+
+import org.killbill.billing.catalog.CatalogTestSuiteWithEmbeddedDB;
+import org.killbill.commons.jdbi.mapper.LowerToCamelBeanMapperFactory;
+import org.skife.jdbi.v2.DBI;
+import org.skife.jdbi.v2.Handle;
+import org.skife.jdbi.v2.TransactionCallback;
+import org.skife.jdbi.v2.TransactionStatus;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import static org.testng.Assert.assertEquals;
+
+public class TestCatalogOverrideTierDefinitionSqlDao extends CatalogTestSuiteWithEmbeddedDB {
+    @BeforeClass(groups = "slow")
+    public void beforeClass() throws Exception {
+        super.beforeClass();
+        ((DBI) dbi).registerMapper(new LowerToCamelBeanMapperFactory(CatalogOverrideTierDefinitionModelDao.class));
+    }
+
+    @Test(groups = "slow")
+    public void testBasic() throws Exception {
+
+        final CatalogOverrideTierDefinitionModelDao obj1 = new CatalogOverrideTierDefinitionModelDao("USD", BigDecimal.ONE,null, clock.getUTCNow());
+        performTestInTransaction(new WithCatalogOverrideTierDefinitionSqlDaoTransaction<Void>() {
+            @Override
+            public Void doTransaction(final CatalogOverrideTierDefinitionSqlDao sqlDao) {
+                sqlDao.create(obj1, internalCallContext);
+                final Long lastInserted = sqlDao.getLastInsertId();
+
+                final CatalogOverrideTierDefinitionModelDao rehydrated = sqlDao.getByRecordId(lastInserted, internalCallContext);
+                assertEquals(rehydrated.getFixedPrice().compareTo(obj1.getFixedPrice()), 0);
+                assertEquals(rehydrated.getCurrency(), obj1.getCurrency());
+                return null;
+            }
+        });
+    }
+
+    private interface WithCatalogOverrideTierDefinitionSqlDaoTransaction<T> {
+
+        public <T> T doTransaction(final CatalogOverrideTierDefinitionSqlDao sqlDao);
+    }
+
+    private <T> T performTestInTransaction(final WithCatalogOverrideTierDefinitionSqlDaoTransaction<T> callback) {
+        return dbi.inTransaction(new TransactionCallback<T>() {
+            @Override
+            public T inTransaction(final Handle handle, final TransactionStatus status) throws Exception {
+                final CatalogOverrideTierDefinitionSqlDao sqlDao = handle.attach(CatalogOverrideTierDefinitionSqlDao.class);
+                return callback.doTransaction(sqlDao);
+            }
+        });
+    }
+}

diff --git a/catalog/src/test/java/org/killbill/billing/catalog/dao/TestCatalogOverrideUsageDefinitionSqlDao.java b/catalog/src/test/java/org/killbill/billing/catalog/dao/TestCatalogOverrideUsageDefinitionSqlDao.java
new file mode 100644
index 0000000..222c929
--- /dev/null
+++ b/catalog/src/test/java/org/killbill/billing/catalog/dao/TestCatalogOverrideUsageDefinitionSqlDao.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright 2014-2015 Groupon, Inc
+ * Copyright 2014-2015 The Billing Project, LLC
+ *
+ * The Billing Project licenses this file to you under the Apache License, version 2.0
+ * (the "License"); you may not use this file except in compliance with the
+ * License.  You may obtain a copy of the License at:
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.killbill.billing.catalog.dao;
+
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.killbill.billing.catalog.CatalogTestSuiteWithEmbeddedDB;
+import org.killbill.commons.jdbi.mapper.LowerToCamelBeanMapperFactory;
+import org.skife.jdbi.v2.DBI;
+import org.skife.jdbi.v2.Handle;
+import org.skife.jdbi.v2.TransactionCallback;
+import org.skife.jdbi.v2.TransactionStatus;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import static org.testng.Assert.assertEquals;
+
+public class TestCatalogOverrideUsageDefinitionSqlDao extends CatalogTestSuiteWithEmbeddedDB {
+
+    @BeforeClass(groups = "slow")
+    public void beforeClass() throws Exception {
+        super.beforeClass();
+        ((DBI) dbi).registerMapper(new LowerToCamelBeanMapperFactory(CatalogOverrideUsageDefinitionModelDao.class));
+    }
+
+    @Test(groups = "slow")
+    public void testBasic() throws Exception {
+
+        final CatalogOverrideUsageDefinitionModelDao obj1 = new CatalogOverrideUsageDefinitionModelDao("u1", "CONSUMABLE", "USD",BigDecimal.ONE,null, clock.getUTCNow());
+        performTestInTransaction(new WithCatalogOverrideUsageDefinitionSqlDaoTransaction<Void>() {
+            @Override
+            public Void doTransaction(final CatalogOverrideUsageDefinitionSqlDao sqlDao) {
+                sqlDao.create(obj1, internalCallContext);
+                final Long lastInserted = sqlDao.getLastInsertId();
+
+                final CatalogOverrideUsageDefinitionModelDao rehydrated = sqlDao.getByRecordId(lastInserted, internalCallContext);
+                assertEquals(rehydrated.getParentUsageName(), obj1.getParentUsageName());
+                assertEquals(rehydrated.getType(), obj1.getType());
+                assertEquals(rehydrated.getCurrency(), obj1.getCurrency());
+                assertEquals(rehydrated.getFixedPrice().compareTo(obj1.getFixedPrice()), 0);
+                return null;
+            }
+        });
+    }
+
+    @Test(groups = "slow")
+    public void testGetByAttributes() throws Exception {
+
+        final CatalogOverrideUsageDefinitionModelDao sameUsageWithDiffBlockPrice1 = new CatalogOverrideUsageDefinitionModelDao("u1", "CONSUMABLE", "USD", null, null, clock.getUTCNow());
+        final CatalogOverrideUsageDefinitionModelDao sameUsageWithDiffBlockPrice2 = new CatalogOverrideUsageDefinitionModelDao("u1", "CONSUMABLE", "USD", null, null, clock.getUTCNow());
+        final CatalogOverrideUsageDefinitionModelDao sameUsageWithDiffBlockPrice3 = new CatalogOverrideUsageDefinitionModelDao("u2", "CONSUMABLE", "USD", null, null, clock.getUTCNow());
+        performTestInTransaction(new WithCatalogOverrideUsageDefinitionSqlDaoTransaction<Void>() {
+            @Override
+            public Void doTransaction(final CatalogOverrideUsageDefinitionSqlDao sqlDao) {
+                sqlDao.create(sameUsageWithDiffBlockPrice1, internalCallContext);
+                sqlDao.create(sameUsageWithDiffBlockPrice2, internalCallContext);
+                sqlDao.create(sameUsageWithDiffBlockPrice3, internalCallContext);
+                List<CatalogOverrideUsageDefinitionModelDao> objList = new ArrayList<CatalogOverrideUsageDefinitionModelDao>();
+                objList.add(sameUsageWithDiffBlockPrice1);
+                objList.add(sameUsageWithDiffBlockPrice2);
+                checkRehydrated(objList, sqlDao);
+
+                return null;
+            }
+
+            private void checkRehydrated(final List<CatalogOverrideUsageDefinitionModelDao> objList, final CatalogOverrideUsageDefinitionSqlDao sqlDao) {
+                final List<CatalogOverrideUsageDefinitionModelDao> rehydrated = sqlDao.getByAttributes("u1", internalCallContext);
+                assertEquals(rehydrated.size(), 2);
+                assertEquals(rehydrated.get(0).getParentUsageName(), objList.get(0).getParentUsageName());
+                assertEquals(rehydrated.get(0).getType(), objList.get(0).getType());
+                assertEquals(rehydrated.get(0).getCurrency(), objList.get(0).getCurrency());
+                assertEquals(rehydrated.get(1).getParentUsageName(), objList.get(1).getParentUsageName());
+                assertEquals(rehydrated.get(1).getType(), objList.get(1).getType());
+                assertEquals(rehydrated.get(1).getCurrency(), objList.get(1).getCurrency());
+
+            }
+        });
+    }
+
+    private interface WithCatalogOverrideUsageDefinitionSqlDaoTransaction<T> {
+
+        public <T> T doTransaction(final CatalogOverrideUsageDefinitionSqlDao sqlDao);
+    }
+
+    private <T> T performTestInTransaction(final WithCatalogOverrideUsageDefinitionSqlDaoTransaction<T> callback) {
+        return dbi.inTransaction(new TransactionCallback<T>() {
+            @Override
+            public T inTransaction(final Handle handle, final TransactionStatus status) throws Exception {
+                final CatalogOverrideUsageDefinitionSqlDao sqlDao = handle.attach(CatalogOverrideUsageDefinitionSqlDao.class);
+                return callback.doTransaction(sqlDao);
+            }
+        });
+    }
+}

diff --git a/catalog/src/test/java/org/killbill/billing/catalog/dao/TestCatalogOverrideUsageTierSqlDao.java b/catalog/src/test/java/org/killbill/billing/catalog/dao/TestCatalogOverrideUsageTierSqlDao.java
new file mode 100644
index 0000000..4d3e128
--- /dev/null
+++ b/catalog/src/test/java/org/killbill/billing/catalog/dao/TestCatalogOverrideUsageTierSqlDao.java
@@ -0,0 +1,130 @@
+package org.killbill.billing.catalog.dao;
+/*
+ * Copyright 2014-2015 Groupon, Inc
+ * Copyright 2014-2015 The Billing Project, LLC
+ *
+ * The Billing Project licenses this file to you under the Apache License, version 2.0
+ * (the "License"); you may not use this file except in compliance with the
+ * License.  You may obtain a copy of the License at:
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ */
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.killbill.billing.catalog.CatalogTestSuiteWithEmbeddedDB;
+import org.killbill.commons.jdbi.mapper.LowerToCamelBeanMapperFactory;
+import org.skife.jdbi.v2.DBI;
+import org.skife.jdbi.v2.Handle;
+import org.skife.jdbi.v2.TransactionCallback;
+import org.skife.jdbi.v2.TransactionStatus;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+
+
+import static org.testng.Assert.assertEquals;
+
+public class TestCatalogOverrideUsageTierSqlDao extends CatalogTestSuiteWithEmbeddedDB {
+
+
+    @BeforeClass(groups = "slow")
+    public void beforeClass() throws Exception {
+        super.beforeClass();
+        ((DBI) dbi).registerMapper(new LowerToCamelBeanMapperFactory(CatalogOverrideUsageTierModelDao.class));
+    }
+
+    @Test(groups = "slow")
+    public void testBasic() throws Exception {
+
+        final CatalogOverrideUsageTierModelDao obj1 = new CatalogOverrideUsageTierModelDao((short) 1, 2L, 3L);
+
+        performTestInTransaction(new WithCatalogOverrideUsageTierSqlDaoTransaction<Void>() {
+            @Override
+            public Void doTransaction(final CatalogOverrideUsageTierSqlDao sqlDao) {
+                sqlDao.create(obj1, internalCallContext);
+                final Long lastInserted = sqlDao.getLastInsertId();
+
+                final CatalogOverrideUsageTierModelDao rehydrated = sqlDao.getByRecordId(lastInserted, internalCallContext);
+                assertEquals(rehydrated.getTierNumber(), obj1.getTierNumber());
+                assertEquals(rehydrated.getTierDefRecordId(), obj1.getTierDefRecordId());
+                assertEquals(rehydrated.getTargetUsageDefRecordId(), obj1.getTargetUsageDefRecordId());
+                return null;
+            }
+        });
+    }
+
+    @Test(groups = "slow")
+    public void testGetTargetUsageDefinition() throws Exception {
+
+        final CatalogOverrideUsageTierModelDao obj1 = new CatalogOverrideUsageTierModelDao((short) 1, 2L, 3L);
+        final CatalogOverrideUsageTierModelDao obj2 = new CatalogOverrideUsageTierModelDao((short) 2, 5L, 3L);
+        final CatalogOverrideUsageTierModelDao obj3 = new CatalogOverrideUsageTierModelDao((short) 4, 7L, 3L);
+        final CatalogOverrideUsageTierModelDao nobj1 = new CatalogOverrideUsageTierModelDao((short) 4, 7L, 4L);
+
+        performTestInTransaction(new WithCatalogOverrideUsageTierSqlDaoTransaction<Void>() {
+            @Override
+            public Void doTransaction(final CatalogOverrideUsageTierSqlDao sqlDao) {
+                sqlDao.create(obj1, internalCallContext);
+                sqlDao.create(obj2, internalCallContext);
+                sqlDao.create(obj3, internalCallContext);
+                sqlDao.create(nobj1, internalCallContext);
+
+                final List<String> keys = new ArrayList<String>();
+                keys.add("1,2");
+                keys.add("2,5");
+                keys.add("4,7");
+                final List<Long> targetUsages = sqlDao.getTargetUsageDefinition(keys, keys.size(), internalCallContext);
+                assertEquals(targetUsages.size(), 1);
+                assertEquals(targetUsages.get(0), new Long(3));
+                return null;
+            }
+        });
+    }
+
+    @Test(groups = "slow")
+    public void testGetTargetUsageDefWithSameTierOverrideAndDifferentUsagePriceOverride() throws Exception {
+
+        final CatalogOverrideUsageTierModelDao obj1 = new CatalogOverrideUsageTierModelDao((short) 1, 2L, 3L);
+        final CatalogOverrideUsageTierModelDao obj2 = new CatalogOverrideUsageTierModelDao((short) 1, 2L, 4L);
+
+        performTestInTransaction(new WithCatalogOverrideUsageTierSqlDaoTransaction<Void>() {
+            @Override
+            public Void doTransaction(final CatalogOverrideUsageTierSqlDao sqlDao) {
+                sqlDao.create(obj1, internalCallContext);
+                sqlDao.create(obj2, internalCallContext);
+
+                final List<String> keys = new ArrayList<String>();
+                keys.add("1,2");
+                final List<Long> targetUsages = sqlDao.getTargetUsageDefinition(keys, keys.size(), internalCallContext);
+                assertEquals(targetUsages.size(), 2);
+                assertEquals(targetUsages.get(0), new Long(3));
+                assertEquals(targetUsages.get(1), new Long(4));
+                return null;
+            }
+        });
+    }
+
+    private interface WithCatalogOverrideUsageTierSqlDaoTransaction<T> {
+
+        public <T> T doTransaction(final CatalogOverrideUsageTierSqlDao sqlDao);
+    }
+
+    private <T> T performTestInTransaction(final WithCatalogOverrideUsageTierSqlDaoTransaction<T> callback) {
+        return dbi.inTransaction(new TransactionCallback<T>() {
+            @Override
+            public T inTransaction(final Handle handle, final TransactionStatus status) throws Exception {
+                final CatalogOverrideUsageTierSqlDao sqlDao = handle.attach(CatalogOverrideUsageTierSqlDao.class);
+                return callback.doTransaction(sqlDao);
+            }
+        });
+    }
+
+}