Improve MetricDao code coverage

server/sonar-server/src/main/java/org/sonar/server/metric/ws/DeleteAction.java

     DbSession dbSession = dbClient.openSession(false);
     try {
       List<Integer> ids = loadIds(dbSession, request);
-      dbClient.metricDao().disableByIds(dbSession, ids);
+      dbClient.metricDao().disableCustomByIds(dbSession, ids);
       dbClient.customMeasureDao().deleteByMetricIds(dbSession, ids);
       dbSession.commit();
     } finally {

server/sonar-server/src/main/java/org/sonar/server/metric/ws/DomainsAction.java

   public void handle(Request request, Response response) throws Exception {
     DbSession dbSession = dbClient.openSession(false);
     try {
-      List<String> domains = dbClient.metricDao().selectDomains(dbSession);
+      List<String> domains = dbClient.metricDao().selectEnabledDomains(dbSession);
       JsonWriter json = response.newJsonWriter();
       json.beginObject();
       writeDomains(json, domains);

server/sonar-server/src/main/java/org/sonar/server/startup/RegisterMetrics.java

     for (MetricDto nonUpdatedBase : basesByKey.values()) {
       if (!nonUpdatedBase.isUserManaged()) {
         LOG.info("Disable metric {} [{}]", nonUpdatedBase.getShortName(), nonUpdatedBase.getKey());
-        dbClient.metricDao().disableByKey(session, nonUpdatedBase.getKey());
+        dbClient.metricDao().disableCustomByKey(session, nonUpdatedBase.getKey());
       }
     }
   }

server/sonar-server/src/test/java/org/sonar/server/measure/custom/ws/CreateActionTest.java

 import org.sonar.server.exceptions.ServerException;
 import org.sonar.db.measure.custom.CustomMeasureDao;
 import org.sonar.db.metric.MetricDao;
-import org.sonar.server.metric.ws.MetricTesting;
+import org.sonar.db.metric.MetricTesting;
 import org.sonar.server.tester.UserSessionRule;
 import org.sonar.server.user.index.UserDoc;
 import org.sonar.server.user.index.UserIndex;

server/sonar-server/src/test/java/org/sonar/server/measure/custom/ws/CustomMeasureValidatorTest.java

 import static org.sonar.api.measures.Metric.ValueType.LEVEL;
 import static org.sonar.api.measures.Metric.ValueType.STRING;
 import static org.sonar.api.measures.Metric.ValueType.WORK_DUR;
-import static org.sonar.server.metric.ws.MetricTesting.newMetricDto;
+import static org.sonar.db.metric.MetricTesting.newMetricDto;
 import static org.sonar.server.util.TypeValidationsTesting.newFullTypeValidations;
 
 public class CustomMeasureValidatorTest {

server/sonar-server/src/test/java/org/sonar/server/measure/custom/ws/MetricsActionTest.java

 import static org.sonar.db.measure.custom.CustomMeasureTesting.newCustomMeasureDto;
 import static org.sonar.server.measure.custom.ws.CustomMeasuresWs.ENDPOINT;
 import static org.sonar.server.measure.custom.ws.MetricsAction.ACTION;
-import static org.sonar.server.metric.ws.MetricTesting.newMetricDto;
+import static org.sonar.db.metric.MetricTesting.newMetricDto;
 
 @Category(DbTests.class)
 public class MetricsActionTest {

server/sonar-server/src/test/java/org/sonar/server/measure/custom/ws/SearchActionTest.java

 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.sonar.db.measure.custom.CustomMeasureTesting.newCustomMeasureDto;
-import static org.sonar.server.metric.ws.MetricTesting.newMetricDto;
+import static org.sonar.db.metric.MetricTesting.newMetricDto;
 
 public class SearchActionTest {
 

server/sonar-server/src/test/java/org/sonar/server/measure/custom/ws/UpdateActionTest.java

 import org.sonar.server.exceptions.ServerException;
 import org.sonar.server.exceptions.UnauthorizedException;
 import org.sonar.db.metric.MetricDao;
-import org.sonar.server.metric.ws.MetricTesting;
+import org.sonar.db.metric.MetricTesting;
 import org.sonar.server.tester.UserSessionRule;
 import org.sonar.server.user.index.UserDoc;
 import org.sonar.server.user.index.UserIndex;

server/sonar-server/src/test/java/org/sonar/server/metric/ws/CreateActionTest.java

 import org.sonar.db.DbSession;
 import org.sonar.db.DbTester;
 import org.sonar.db.metric.MetricDto;
+import org.sonar.db.metric.MetricTesting;
 import org.sonar.server.db.DbClient;
 import org.sonar.server.exceptions.ForbiddenException;
 import org.sonar.server.exceptions.ServerException;

server/sonar-server/src/test/java/org/sonar/server/metric/ws/DeleteActionTest.java

 import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
 import static org.mockito.Mockito.mock;
-import static org.sonar.server.metric.ws.MetricTesting.newMetricDto;
+import static org.sonar.db.metric.MetricTesting.newMetricDto;
 
 @Category(DbTests.class)
 public class DeleteActionTest {

server/sonar-server/src/test/java/org/sonar/server/metric/ws/DomainsActionTest.java

 import org.sonar.test.DbTests;
 import org.sonar.test.JsonAssert;
 
-import static org.sonar.server.metric.ws.MetricTesting.newMetricDto;
+import static org.sonar.db.metric.MetricTesting.newMetricDto;
 
 @Category(DbTests.class)
 public class DomainsActionTest {

server/sonar-server/src/test/java/org/sonar/server/metric/ws/SearchActionTest.java

 import org.sonar.test.DbTests;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.sonar.server.metric.ws.MetricTesting.newMetricDto;
+import static org.sonar.db.metric.MetricTesting.newMetricDto;
 import static org.sonar.server.metric.ws.SearchAction.PARAM_IS_CUSTOM;
 
 @Category(DbTests.class)

sonar-db/src/main/java/org/sonar/db/metric/MetricDao.java

     return mapper(session).countEnabled(isCustom);
   }
 
-  public void insert(DbSession session, MetricDto dto) {
+  public MetricDto insert(DbSession session, MetricDto dto) {
     mapper(session).insert(dto);
+
+    return dto;
   }
 
   public void insert(DbSession session, Collection<MetricDto> items) {
     insert(session, Lists.asList(item, others));
   }
 
-  public List<String> selectDomains(DbSession session) {
+  public List<String> selectEnabledDomains(DbSession session) {
     return newArrayList(Collections2.filter(mapper(session).selectDomains(), new NotEmptyPredicate()));
   }
 
     return session.getMapper(MetricMapper.class);
   }
 
-  public void disableByIds(final DbSession session, List<Integer> ids) {
+  public void disableCustomByIds(final DbSession session, List<Integer> ids) {
     DatabaseUtils.executeLargeInputsWithoutOutput(ids, new Function<List<Integer>, Void>() {
       @Override
       public Void apply(@Nonnull List<Integer> input) {
     });
   }
 
-  public void disableByKey(final DbSession session, String key) {
+  public void disableCustomByKey(final DbSession session, String key) {
     mapper(session).disableByKey(key);
   }
 
     return mapper(session).selectById(id);
   }
 
-  public MetricDto selectOrFailById(DbSession session, int id) {
+  public MetricDto selectOrFailById(DbSession session, long id) {
     MetricDto metric = mapper(session).selectById(id);
     if (metric == null) {
       throw new RowNotFoundException(String.format("Metric id '%d' not found", id));

sonar-db/src/test/java/org/sonar/db/metric/MetricDaoTest.java

 
 package org.sonar.db.metric;
 
+import java.util.Arrays;
+import java.util.List;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.experimental.categories.Category;
+import org.junit.rules.ExpectedException;
 import org.sonar.api.utils.System2;
 import org.sonar.db.DbSession;
 import org.sonar.db.DbTester;
 import org.sonar.db.RowNotFoundException;
 import org.sonar.test.DbTests;
 
+import static com.google.common.collect.Sets.newHashSet;
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.sonar.db.metric.MetricTesting.newMetricDto;
 
 @Category(DbTests.class)
 public class MetricDaoTest {
 
   @Rule
   public DbTester dbTester = DbTester.create(System2.INSTANCE);
+  @Rule
+  public ExpectedException thrown = ExpectedException.none();
 
   DbSession session;
 
-  MetricDao dao;
+  MetricDao underTest;
 
   @Before
   public void createDao() {
     dbTester.truncateTables();
     session = dbTester.myBatis().openSession(false);
-    dao = new MetricDao();
+    underTest = new MetricDao();
   }
 
   @After
   }
 
   @Test
-  public void get_by_key() {
+  public void select_by_key() {
     dbTester.prepareDbUnit(getClass(), "shared.xml");
 
-    MetricDto result = dao.selectByKey(session, "coverage");
+    MetricDto result = underTest.selectByKey(session, "coverage");
     assertThat(result.getId()).isEqualTo(2);
     assertThat(result.getKey()).isEqualTo("coverage");
     assertThat(result.getShortName()).isEqualTo("Coverage");
     assertThat(result.isEnabled()).isTrue();
 
     // Disabled metrics are returned
-    result = dao.selectByKey(session, "disabled");
+    result = underTest.selectByKey(session, "disabled");
     assertThat(result.getId()).isEqualTo(3);
     assertThat(result.isEnabled()).isFalse();
   }
 
   @Test(expected = RowNotFoundException.class)
-  public void get_nullable_by_key() {
-    dao.selectOrFailByKey(session, "unknown");
+  public void select_or_fail_by_key() {
+    underTest.selectOrFailByKey(session, "unknown");
   }
 
   @Test
   public void get_manual_metric() {
     dbTester.prepareDbUnit(getClass(), "manual_metric.xml");
 
-    MetricDto result = dao.selectByKey(session, "manual");
+    MetricDto result = underTest.selectByKey(session, "manual");
     assertThat(result.getId()).isEqualTo(1);
     assertThat(result.getKey()).isEqualTo("manual");
     assertThat(result.getShortName()).isEqualTo("Manual metric");
   public void find_all_enabled() {
     dbTester.prepareDbUnit(getClass(), "shared.xml");
 
-    assertThat(dao.selectEnabled(session)).hasSize(2);
+    assertThat(underTest.selectEnabled(session)).hasSize(2);
   }
 
   @Test
   public void insert() {
-    dao.insert(session, new MetricDto()
+    underTest.insert(session, new MetricDto()
       .setKey("coverage")
       .setShortName("Coverage")
       .setDescription("Coverage by unit tests")
       .setDeleteHistoricalData(true)
       .setEnabled(true));
 
-    MetricDto result = dao.selectByKey(session, "coverage");
+    MetricDto result = underTest.selectByKey(session, "coverage");
     assertThat(result.getId()).isNotNull();
     assertThat(result.getKey()).isEqualTo("coverage");
     assertThat(result.getShortName()).isEqualTo("Coverage");
 
   @Test
   public void insert_metrics() {
-    dao.insert(session, new MetricDto()
+    underTest.insert(session, new MetricDto()
       .setKey("coverage")
       .setShortName("Coverage")
       .setDescription("Coverage by unit tests")
 
     assertThat(dbTester.countRowsOfTable("metrics")).isEqualTo(2);
   }
+
+  @Test
+  public void selectById() {
+    MetricDto metric = underTest.insert(session, newMetricDto());
+
+    MetricDto result = underTest.selectById(session, metric.getId());
+
+    assertThat(result).isNotNull();
+  }
+
+  @Test
+  public void selectOrFailById() {
+    MetricDto metric = underTest.insert(session, newMetricDto());
+
+    MetricDto result = underTest.selectOrFailById(session, metric.getId());
+
+    assertThat(result).isNotNull();
+  }
+
+  @Test
+  public void fail_when_no_id_selectOrFailById() {
+    thrown.expect(RowNotFoundException.class);
+
+    underTest.selectOrFailById(session, 42L);
+  }
+
+  @Test
+  public void selectByIds() {
+    MetricDto metric1 = underTest.insert(session, newMetricDto());
+    MetricDto metric2 = underTest.insert(session, newMetricDto());
+
+    List<MetricDto> result = underTest.selectByIds(session, newHashSet(metric1.getId(), metric2.getId()));
+
+    assertThat(result).hasSize(2);
+  }
+
+  @Test
+  public void update() {
+    MetricDto metric = underTest.insert(session, newMetricDto().setKey("first-key"));
+
+    underTest.update(session, metric.setKey("second-key"));
+
+    MetricDto result = underTest.selectByKey(session, "second-key");
+    assertThat(result).isNotNull();
+  }
+
+  @Test
+  public void countEnabled() {
+    underTest.insert(session, newMetricDto().setEnabled(true).setUserManaged(true));
+    underTest.insert(session, newMetricDto().setEnabled(true).setUserManaged(true));
+    underTest.insert(session, newMetricDto().setEnabled(false));
+
+    int result = underTest.countEnabled(session, true);
+
+    assertThat(result).isEqualTo(2);
+  }
+
+  @Test
+  public void selectDomains() {
+    underTest.insert(session, newMetricDto().setDomain("first-domain").setEnabled(true));
+    underTest.insert(session, newMetricDto().setDomain("second-domain").setEnabled(true));
+    underTest.insert(session, newMetricDto().setDomain("second-domain").setEnabled(true));
+    underTest.insert(session, newMetricDto().setDomain("third-domain").setEnabled(true));
+
+    List<String> domains = underTest.selectEnabledDomains(session);
+
+    assertThat(domains).hasSize(3).containsOnly("first-domain", "second-domain", "third-domain");
+  }
+
+  @Test
+  public void selectByKeys() {
+    underTest.insert(session, newMetricDto().setKey("first-key"));
+    underTest.insert(session, newMetricDto().setKey("second-key"));
+    underTest.insert(session, newMetricDto().setKey("third-key"));
+
+    List<MetricDto> result = underTest.selectByKeys(session, Arrays.asList("first-key", "second-key", "third-key"));
+
+    assertThat(result).hasSize(3)
+      .extracting("key").containsOnly("first-key", "second-key", "third-key");
+  }
+
+  @Test
+  public void disableByIds() {
+    MetricDto metric1 = underTest.insert(session, newMetricDto().setEnabled(true).setUserManaged(true));
+    MetricDto metric2 = underTest.insert(session, newMetricDto().setEnabled(true).setUserManaged(true));
+
+    underTest.disableCustomByIds(session, Arrays.asList(metric1.getId(), metric2.getId()));
+
+    List<MetricDto> result = underTest.selectByIds(session, newHashSet(metric1.getId(), metric2.getId()));
+    assertThat(result).hasSize(2);
+    assertThat(result).extracting("enabled").containsOnly(false);
+  }
+
+  @Test
+  public void disableByKey() {
+    underTest.insert(session, newMetricDto().setKey("metric-key").setEnabled(true).setUserManaged(true));
+
+    underTest.disableCustomByKey(session, "metric-key");
+
+    MetricDto result = underTest.selectByKey(session, "metric-key");
+    assertThat(result.isEnabled()).isFalse();
+  }
+
+  @Test
+  public void selectOrFailByKey() {
+    underTest.insert(session, newMetricDto().setKey("metric-key"));
+
+    MetricDto result = underTest.selectOrFailByKey(session, "metric-key");
+
+    assertThat(result).isNotNull();
+    assertThat(result.getKey()).isEqualTo("metric-key");
+  }
+
+  @Test
+  public void selectEnabled_with_paging_and_custom() {
+    underTest.insert(session, newMetricDto().setUserManaged(true).setEnabled(true));
+    underTest.insert(session, newMetricDto().setUserManaged(true).setEnabled(true));
+    underTest.insert(session, newMetricDto().setUserManaged(true).setEnabled(true));
+    underTest.insert(session, newMetricDto().setUserManaged(false).setEnabled(true));
+    underTest.insert(session, newMetricDto().setUserManaged(true).setEnabled(false));
+
+    List<MetricDto> result = underTest.selectEnabled(session, true, 0, 100);
+
+    assertThat(result).hasSize(3);
+  }
+
+  @Test
+  public void selectAvailableByComponentUuid() {
+    underTest.insert(session, newMetricDto().setUserManaged(true).setEnabled(true).setKey("metric-key"));
+    underTest.insert(session, newMetricDto().setUserManaged(false).setEnabled(true).setKey("another-metric-key"));
+    underTest.insert(session, newMetricDto().setUserManaged(true).setEnabled(false).setKey("third-metric-key"));
+
+    List<MetricDto> result = underTest.selectAvailableCustomMetricsByComponentUuid(session, "project-uuid");
+
+    assertThat(result).hasSize(1)
+      .extracting("key").containsOnly("metric-key");
+
+  }
 }

server/sonar-server/src/test/java/org/sonar/server/metric/ws/MetricTesting.java → sonar-db/src/test/java/org/sonar/db/metric/MetricTesting.java

  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 
-package org.sonar.server.metric.ws;
+package org.sonar.db.metric;
 
 import org.apache.commons.lang.RandomStringUtils;
 import org.apache.commons.lang.math.RandomUtils;
 import org.sonar.api.measures.Metric;
-import org.sonar.db.metric.MetricDto;
 
 public class MetricTesting {
   private MetricTesting() {