*/
package org.sonar.server.component.ws;
+import com.google.common.collect.Maps;
import java.util.List;
import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
import org.apache.commons.lang.BooleanUtils;
import org.sonar.db.MyBatis;
import org.sonar.db.component.ComponentDto;
import org.sonar.db.measure.MeasureDto;
+import org.sonar.db.measure.MeasureQuery;
+import org.sonar.db.metric.MetricDto;
import org.sonar.db.property.PropertyDto;
import org.sonar.db.property.PropertyQuery;
import org.sonar.server.component.ComponentFinder;
import org.sonar.server.user.UserSession;
import static com.google.common.collect.Lists.newArrayList;
-import static com.google.common.collect.Maps.newHashMap;
import static org.sonar.core.util.Uuids.UUID_EXAMPLE_01;
public class AppAction implements RequestHandler {
private static final String PARAM_UUID = "uuid";
private static final String PARAM_PERIOD = "period";
- private static final List<String> METRIC_KEYS = newArrayList(CoreMetrics.LINES_KEY, CoreMetrics.VIOLATIONS_KEY,
+ static final List<String> METRIC_KEYS = newArrayList(CoreMetrics.LINES_KEY, CoreMetrics.VIOLATIONS_KEY,
CoreMetrics.COVERAGE_KEY, CoreMetrics.IT_COVERAGE_KEY, CoreMetrics.OVERALL_COVERAGE_KEY,
CoreMetrics.DUPLICATED_LINES_DENSITY_KEY, CoreMetrics.TESTS_KEY,
CoreMetrics.TECHNICAL_DEBT_KEY, CoreMetrics.SQALE_RATING_KEY, CoreMetrics.SQALE_DEBT_RATIO_KEY);
private void appendMeasures(JsonWriter json, Map<String, MeasureDto> measuresByMetricKey) {
json.name("measures").beginObject();
- json.prop("lines", formatMeasure(measuresByMetricKey.get(CoreMetrics.LINES_KEY)));
- json.prop("coverage", formatMeasure(coverageMeasure(measuresByMetricKey)));
- json.prop("duplicationDensity", formatMeasure(measuresByMetricKey.get(CoreMetrics.DUPLICATED_LINES_DENSITY_KEY)));
- json.prop("issues", formatMeasure(measuresByMetricKey.get(CoreMetrics.VIOLATIONS_KEY)));
- json.prop("tests", formatMeasure(measuresByMetricKey.get(CoreMetrics.TESTS_KEY)));
- json.prop("debt", formatMeasure(measuresByMetricKey.get(CoreMetrics.TECHNICAL_DEBT_KEY)));
- json.prop("sqaleRating", formatMeasure(measuresByMetricKey.get(CoreMetrics.SQALE_RATING_KEY)));
- json.prop("debtRatio", formatMeasure(measuresByMetricKey.get(CoreMetrics.SQALE_DEBT_RATIO_KEY)));
+ json.prop("lines", formatMeasure(measuresByMetricKey, CoreMetrics.LINES));
+ json.prop("coverage", formatCoverageMeasure(measuresByMetricKey));
+ json.prop("duplicationDensity", formatMeasure(measuresByMetricKey, CoreMetrics.DUPLICATED_LINES_DENSITY));
+ json.prop("issues", formatMeasure(measuresByMetricKey, CoreMetrics.VIOLATIONS));
+ json.prop("tests", formatMeasure(measuresByMetricKey, CoreMetrics.TESTS));
+ json.prop("debt", formatMeasure(measuresByMetricKey, CoreMetrics.TECHNICAL_DEBT));
+ json.prop("sqaleRating", formatMeasure(measuresByMetricKey, CoreMetrics.SQALE_RATING));
+ json.prop("debtRatio", formatMeasure(measuresByMetricKey, CoreMetrics.SQALE_DEBT_RATIO));
json.endObject();
}
- private static MeasureDto coverageMeasure(Map<String, MeasureDto> measuresByMetricKey) {
- MeasureDto overallCoverage = measuresByMetricKey.get(CoreMetrics.OVERALL_COVERAGE_KEY);
- MeasureDto itCoverage = measuresByMetricKey.get(CoreMetrics.IT_COVERAGE_KEY);
- MeasureDto utCoverage = measuresByMetricKey.get(CoreMetrics.COVERAGE_KEY);
- if (overallCoverage != null) {
- return overallCoverage;
- } else if (utCoverage != null) {
- return utCoverage;
- } else {
- return itCoverage;
- }
- }
-
private Map<String, MeasureDto> measuresByMetricKey(ComponentDto component, DbSession session) {
- Map<String, MeasureDto> measuresByMetricKey = newHashMap();
- String fileKey = component.getKey();
- for (MeasureDto measureDto : dbClient.measureDao().selectByComponentKeyAndMetricKeys(session, fileKey, METRIC_KEYS)) {
- measuresByMetricKey.put(measureDto.getMetricKey(), measureDto);
- }
- return measuresByMetricKey;
+ MeasureQuery query = MeasureQuery.builder().setComponentUuid(component.uuid()).setMetricKeys(METRIC_KEYS).build();
+ List<MeasureDto> measures = dbClient.measureDao().selectByQuery(session, query);
+ Set<Integer> metricIds = measures.stream().map(MeasureDto::getMetricId).collect(Collectors.toSet());
+ List<MetricDto> metrics = dbClient.metricDao().selectByIds(session, metricIds);
+ Map<Integer, MetricDto> metricsById = Maps.uniqueIndex(metrics, MetricDto::getId);
+ return Maps.uniqueIndex(measures, m -> metricsById.get(m.getMetricId()).getKey());
}
@CheckForNull
}
@CheckForNull
- private String formatMeasure(@Nullable MeasureDto measure) {
+ private String formatCoverageMeasure(Map<String, MeasureDto> measuresByMetricKey) {
+ MeasureDto overallCoverage = measuresByMetricKey.get(CoreMetrics.OVERALL_COVERAGE_KEY);
+ if (overallCoverage != null) {
+ return formatMeasure(overallCoverage, CoreMetrics.OVERALL_COVERAGE);
+ }
+ MeasureDto utCoverage = measuresByMetricKey.get(CoreMetrics.COVERAGE_KEY);
+ if (utCoverage != null) {
+ return formatMeasure(utCoverage, CoreMetrics.COVERAGE);
+ }
+ MeasureDto itCoverage = measuresByMetricKey.get(CoreMetrics.IT_COVERAGE_KEY);
+ return formatMeasure(itCoverage, CoreMetrics.IT_COVERAGE);
+ }
+
+ @CheckForNull
+ private String formatMeasure(Map<String, MeasureDto> measuresByMetricKey, Metric metric) {
+ MeasureDto measure = measuresByMetricKey.get(metric.getKey());
+ return formatMeasure(measure, metric);
+ }
+
+ private String formatMeasure(@Nullable MeasureDto measure, Metric metric) {
if (measure == null) {
return null;
}
-
- Metric metric = CoreMetrics.getMetric(measure.getMetricKey());
Metric.ValueType metricType = metric.getType();
Double value = getDoubleValue(measure, metric);
String data = measure.getData();
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
import org.sonar.db.measure.MeasureDto;
+import org.sonar.db.measure.MeasureQuery;
import org.sonar.scanner.protocol.output.ScannerReport;
import org.sonar.server.computation.batch.BatchReportReader;
import org.sonar.server.computation.component.Component;
requireNonNull(metric);
try (DbSession dbSession = dbClient.openSession(false)) {
- MeasureDto measureDto = dbClient.measureDao().selectByComponentKeyAndMetricKey(dbSession, component.getKey(), metric.getKey());
- return underTest.toMeasure(measureDto, metric);
+ MeasureQuery query = MeasureQuery.builder().setComponentUuid(component.getUuid()).setMetricKey(metric.getKey()).build();
+ java.util.Optional<MeasureDto> measureDto = dbClient.measureDao().selectSingle(dbSession, query);
+ if (measureDto.isPresent()) {
+ return underTest.toMeasure(measureDto.get(), metric);
+ }
+ return Optional.absent();
}
}
*/
package org.sonar.server.computation.period;
+import java.util.Objects;
import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
import javax.annotation.concurrent.Immutable;
@CheckForNull
private final String modeParameter;
private final long snapshotDate;
- private final long snapshotId;
+ private final String analysisUuid;
public Period(int index, String mode, @Nullable String modeParameter,
- long snapshotDate, long snapshotId) {
+ long snapshotDate, String analysisUuid) {
if (!isValidPeriodIndex(index)) {
throw new IllegalArgumentException(String.format("Period index (%s) must be > 0 and < 6", index));
}
this.mode = requireNonNull(mode);
this.modeParameter = modeParameter;
this.snapshotDate = snapshotDate;
- this.snapshotId = snapshotId;
+ this.analysisUuid = analysisUuid;
}
public static boolean isValidPeriodIndex(int i) {
return snapshotDate;
}
- public long getSnapshotId() {
- return snapshotId;
+ public String getAnalysisUuid() {
+ return analysisUuid;
}
@Override
Period period = (Period) o;
return index == period.index
&& snapshotDate == period.snapshotDate
- && snapshotId == period.snapshotId
+ && Objects.equals(analysisUuid, period.analysisUuid)
&& mode.equals(period.mode)
- && java.util.Objects.equals(modeParameter, period.modeParameter);
+ && Objects.equals(modeParameter, period.modeParameter);
}
@Override
public int hashCode() {
- return hash(index, mode, modeParameter, snapshotDate, snapshotId);
+ return hash(index, mode, modeParameter, snapshotDate, analysisUuid);
}
@Override
.add("mode", mode)
.add("modeParameter", modeParameter)
.add("snapshotDate", snapshotDate)
- .add("snapshotId", snapshotId)
+ .add("analysisUuid", analysisUuid)
.toString();
}
}
@Nullable
@Override
public MeasureKey apply(@Nonnull PastMeasureDto input) {
- Metric metric = metricRepository.getById(input.getMetricId());
+ Metric metric = metricRepository.getById((long)input.getMetricId());
return new MeasureKey(metric.getKey(), null);
}
};
MeasuresWithVariationRepository measuresWithVariationRepository = new MeasuresWithVariationRepository();
for (Period period : periodsHolder.getPeriods()) {
List<PastMeasureDto> pastMeasures = dbClient.measureDao()
- .selectByComponentUuidAndProjectSnapshotIdAndMetricIds(session, component.getUuid(), period.getSnapshotId(), metricIds);
+ .selectPastMeasures(session, component.getUuid(), period.getAnalysisUuid(), metricIds);
setVariationMeasures(component, pastMeasures, period.getIndex(), measuresWithVariationRepository);
}
return measuresWithVariationRepository;
return null;
}
LOG.debug("Compare to date {} (analysis of {})", formatDate(date.getTime()), formatDate(snapshot.getCreatedAt()));
- return new Period(index, TIMEMACHINE_MODE_DATE, DateUtils.formatDate(date), snapshot.getCreatedAt(), snapshot.getId());
+ return new Period(index, TIMEMACHINE_MODE_DATE, DateUtils.formatDate(date), snapshot.getCreatedAt(), snapshot.getUuid());
}
@CheckForNull
return null;
}
LOG.debug("Compare over {} days ({}, analysis of {})", String.valueOf(days), formatDate(targetDate), formatDate(snapshot.getCreatedAt()));
- return new Period(index, TIMEMACHINE_MODE_DAYS, String.valueOf(days), snapshot.getCreatedAt(), snapshot.getId());
+ return new Period(index, TIMEMACHINE_MODE_DAYS, String.valueOf(days), snapshot.getCreatedAt(), snapshot.getUuid());
}
@CheckForNull
return null;
}
LOG.debug("Compare to previous analysis ({})", formatDate(snapshot.getCreatedAt()));
- return new Period(index, TIMEMACHINE_MODE_PREVIOUS_ANALYSIS, formatDate(snapshot.getCreatedAt()), snapshot.getCreatedAt(), snapshot.getId());
+ return new Period(index, TIMEMACHINE_MODE_PREVIOUS_ANALYSIS, formatDate(snapshot.getCreatedAt()), snapshot.getCreatedAt(), snapshot.getUuid());
}
@CheckForNull
}
SnapshotDto snapshotDto = snapshotDtos.get(0);
LOG.debug("Compare to previous version ({})", formatDate(snapshotDto.getCreatedAt()));
- return new Period(index, TIMEMACHINE_MODE_PREVIOUS_VERSION, snapshotDto.getVersion(), snapshotDto.getCreatedAt(), snapshotDto.getId());
+ return new Period(index, TIMEMACHINE_MODE_PREVIOUS_VERSION, snapshotDto.getVersion(), snapshotDto.getCreatedAt(), snapshotDto.getUuid());
}
@CheckForNull
return null;
}
LOG.debug("Compare to first analysis ({})", formatDate(snapshotDto.getCreatedAt()));
- return new Period(index, TIMEMACHINE_MODE_PREVIOUS_VERSION, null, snapshotDto.getCreatedAt(), snapshotDto.getId());
+ return new Period(index, TIMEMACHINE_MODE_PREVIOUS_VERSION, null, snapshotDto.getCreatedAt(), snapshotDto.getUuid());
}
@CheckForNull
return null;
}
LOG.debug("Compare to version ({}) ({})", version, formatDate(snapshot.getCreatedAt()));
- return new Period(index, TIMEMACHINE_MODE_VERSION, version, snapshot.getCreatedAt(), snapshot.getId());
+ return new Period(index, TIMEMACHINE_MODE_VERSION, version, snapshot.getCreatedAt(), snapshot.getUuid());
}
@CheckForNull
import javax.annotation.Nonnull;
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
+import org.sonar.db.measure.MeasureDao;
import org.sonar.db.measure.MeasureDto;
import org.sonar.server.computation.component.Component;
import org.sonar.server.computation.component.CrawlerDepthLimit;
Metric metric = metricRepository.getByKey(metricKey);
Predicate<Measure> notBestValueOptimized = Predicates.not(BestValueOptimization.from(metric, component));
+ MeasureDao measureDao = dbClient.measureDao();
for (Measure measure : from(measures.getValue()).filter(NonEmptyMeasure.INSTANCE).filter(notBestValueOptimized)) {
MeasureDto measureDto = measureToMeasureDto.toMeasureDto(measure, metric, component);
- dbClient.measureDao().insert(session, measureDto);
+ measureDao.insert(session, measureDto);
}
}
}
import com.google.common.io.Resources;
import java.util.List;
+import java.util.Optional;
import javax.annotation.CheckForNull;
import org.sonar.api.measures.CoreMetrics;
import org.sonar.api.server.ws.Request;
import org.sonar.db.component.ComponentDto;
import org.sonar.db.measure.MeasureDao;
import org.sonar.db.measure.MeasureDto;
+import org.sonar.db.measure.MeasureQuery;
import org.sonar.server.component.ComponentFinder;
import org.sonar.server.user.UserSession;
DbSession dbSession = dbClient.openSession(false);
try {
ComponentDto component = componentFinder.getByUuidOrKey(dbSession, request.param("uuid"), request.param("key"), UUID_AND_KEY);
- String componentKey = component.key();
- userSession.checkComponentPermission(UserRole.CODEVIEWER, componentKey);
+ userSession.checkComponentPermission(UserRole.CODEVIEWER, component.key());
JsonWriter json = response.newJsonWriter().beginObject();
- String duplications = findDataFromComponent(componentKey, CoreMetrics.DUPLICATIONS_DATA_KEY, dbSession);
+ String duplications = findDataFromComponent(dbSession, component);
List<DuplicationsParser.Block> blocks = parser.parse(component, duplications, dbSession);
duplicationsJsonWriter.write(blocks, json, dbSession);
json.endObject().close();
}
@CheckForNull
- private String findDataFromComponent(String fileKey, String metricKey, DbSession session) {
- MeasureDto measure = measureDao.selectByComponentKeyAndMetricKey(session, fileKey, metricKey);
- if (measure != null) {
- return measure.getData();
- }
- return null;
+ private String findDataFromComponent(DbSession dbSession, ComponentDto component) {
+ MeasureQuery query = MeasureQuery.builder()
+ .setComponentUuid(component.uuid())
+ .setMetricKey(CoreMetrics.DUPLICATIONS_DATA_KEY)
+ .build();
+ Optional<MeasureDto> measure = measureDao.selectSingle(dbSession, query);
+ return measure.isPresent() ? measure.get().getData() : null;
}
}
@VisibleForTesting
static List<String> sanitize(@Nullable List<String> list) {
- return isEmptyList(list) ? Collections.<String>emptyList() : Lists.newArrayList(list);
+ return isEmptyList(list) ? Collections.emptyList() : Lists.newArrayList(list);
}
private static boolean isEmptyList(@Nullable List<String> list) {
String table = "pmcond" + conditionIndex;
sql.append(" ").append(table).append(".metric_id=");
sql.append(metric.getId());
- sql.append(" AND ");
+ sql.append(" and ");
appendSqlColumn(sql, conditionIndex);
sql.append(" ").append(operator.getSql()).append(" ");
if (textValue == null) {
} else {
sql.append(textValue);
}
- sql.append(" AND ");
- sql.append(table).append(".person_id IS NULL ");
+ sql.append(" and ");
+ sql.append(table).append(".person_id is null ");
return sql;
}
*/
package org.sonar.server.measure;
+import javax.annotation.Nullable;
import org.apache.commons.lang.builder.ToStringBuilder;
import org.apache.commons.lang.builder.ToStringStyle;
-import org.sonar.db.component.SnapshotDto;
-
-import javax.annotation.Nullable;
+import org.sonar.db.component.ComponentDto;
class MeasureFilterContext {
private Long userId = null;
- private SnapshotDto baseSnapshot = null;
+ private ComponentDto baseComponent = null;
private String sql;
private String data;
return this;
}
- SnapshotDto getBaseSnapshot() {
- return baseSnapshot;
+ ComponentDto getBaseComponent() {
+ return baseComponent;
}
- MeasureFilterContext setBaseSnapshot(@Nullable SnapshotDto baseSnapshot) {
- this.baseSnapshot = baseSnapshot;
+ MeasureFilterContext setBaseComponent(@Nullable ComponentDto baseComponent) {
+ this.baseComponent = baseComponent;
return this;
}
*/
package org.sonar.server.measure;
+import com.google.common.base.Optional;
import com.google.common.base.Strings;
-import org.apache.commons.dbutils.DbUtils;
-import org.apache.ibatis.session.SqlSession;
-import org.sonar.api.server.ServerSide;
-import org.sonar.db.Database;
-import org.sonar.db.MyBatis;
-import org.sonar.db.component.ResourceDao;
-
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Collections;
import java.util.List;
+import org.apache.commons.dbutils.DbUtils;
+import org.sonar.api.server.ServerSide;
+import org.sonar.db.Database;
+import org.sonar.db.DbSession;
+import org.sonar.db.MyBatis;
+import org.sonar.db.component.ComponentDao;
+import org.sonar.db.component.ComponentDto;
@ServerSide
public class MeasureFilterExecutor {
private MyBatis mybatis;
private Database database;
- private ResourceDao resourceDao;
+ private ComponentDao componentDao;
- public MeasureFilterExecutor(MyBatis mybatis, Database database, ResourceDao resourceDao) {
+ public MeasureFilterExecutor(MyBatis mybatis, Database database, ComponentDao componentDao) {
this.mybatis = mybatis;
this.database = database;
- this.resourceDao = resourceDao;
+ this.componentDao = componentDao;
}
public List<MeasureFilterRow> execute(MeasureFilter filter, MeasureFilterContext context) throws SQLException {
}
List<MeasureFilterRow> rows;
- SqlSession session = null;
+ DbSession session = null;
Connection connection = null;
try {
session = mybatis.openSession(false);
return rows;
}
- private void prepareContext(MeasureFilterContext context, MeasureFilter filter, SqlSession session) {
+ private void prepareContext(MeasureFilterContext context, MeasureFilter filter, DbSession session) {
if (filter.getBaseResourceKey() != null) {
- context.setBaseSnapshot(resourceDao.getLastSnapshot(filter.getBaseResourceKey(), session));
+ Optional<ComponentDto> component = componentDao.selectByKey(session, filter.getBaseResourceKey());
+ if (component.isPresent()) {
+ context.setBaseComponent(component.get());
+ }
}
}
static boolean isValid(MeasureFilter filter, MeasureFilterContext context) {
- boolean valid = Strings.isNullOrEmpty(filter.getBaseResourceKey()) || context.getBaseSnapshot() != null;
- valid &= !(filter.isOnBaseResourceChildren() && context.getBaseSnapshot() == null);
+ boolean valid = Strings.isNullOrEmpty(filter.getBaseResourceKey()) || context.getBaseComponent() != null;
+ valid &= !(filter.isOnBaseResourceChildren() && context.getBaseComponent() == null);
valid &= !(filter.isOnFavourites() && context.getUserId() == null);
valid &= validateMeasureConditions(filter);
valid &= validateSort(filter);
import org.apache.commons.lang.StringUtils;
public class MeasureFilterRow {
- private final long snapshotId;
- private final long resourceId;
+ private final String componentUuid;
private final String rootComponentUuid;
private String sortText = null;
private Long sortDate = null;
private Double sortDouble = null;
- MeasureFilterRow(long snapshotId, long resourceId, String rootComponentUuid) {
- this.snapshotId = snapshotId;
- this.resourceId = resourceId;
+ MeasureFilterRow(String componentUuid, String rootComponentUuid) {
+ this.componentUuid = componentUuid;
this.rootComponentUuid = rootComponentUuid;
}
- public long getSnapshotId() {
- return snapshotId;
- }
-
- public long getResourceId() {
- return resourceId;
+ public String getComponentUuid() {
+ return componentUuid;
}
public String getRootComponentUuid() {
String column;
switch (field) {
case KEY:
- column = "p.kee";
+ column = "c.kee";
break;
case NAME:
- column = "p.long_name";
+ column = "c.long_name";
break;
case SHORT_NAME:
- column = "p.name";
+ column = "c.name";
break;
case DESCRIPTION:
- column = "p.description";
+ column = "c.description";
break;
case VERSION:
column = "s.version";
column = "s.created_at";
break;
case PROJECT_CREATION_DATE:
- column = "p.created_at";
+ column = "c.created_at";
break;
case METRIC:
column = getMetricColumn();
import org.apache.commons.lang.StringEscapeUtils;
import org.apache.commons.lang.StringUtils;
import org.sonar.db.Database;
-import org.sonar.db.component.SnapshotDto;
+import org.sonar.db.DatabaseUtils;
+import org.sonar.db.WildcardPosition;
+import org.sonar.db.component.ComponentDto;
import org.sonar.db.dialect.MsSql;
import org.sonar.db.dialect.Oracle;
+import static org.sonar.db.component.ComponentDto.UUID_PATH_SEPARATOR;
+
class MeasureFilterSql {
private final Database database;
private String generateSql() {
StringBuilder sb = new StringBuilder(1000);
- sb.append("SELECT s.id, p.id, root.uuid, ");
+ sb.append("select c.uuid, c.project_uuid, ");
sb.append(filter.sort().column());
- sb.append(" FROM snapshots s");
- sb.append(" INNER JOIN projects p ON s.component_uuid=p.uuid ");
- sb.append(" INNER JOIN projects root ON s.root_component_uuid=root.uuid ");
+ sb.append(" from projects c");
+ sb.append(" inner join snapshots s on s.component_uuid=c.project_uuid ");
+ if (context.getBaseComponent() != null) {
+ sb.append(" inner join projects base on base.project_uuid = c.project_uuid ");
+ }
for (int index = 0; index < filter.getMeasureConditions().size(); index++) {
MeasureFilterCondition condition = filter.getMeasureConditions().get(index);
- sb.append(" INNER JOIN project_measures pmcond").append(index);
- sb.append(" ON s.id=pmcond").append(index).append(".snapshot_id AND ");
+ sb.append(" inner join project_measures pmcond").append(index);
+ sb.append(" on pmcond").append(index).append(".analysis_uuid = s.uuid and ");
+ sb.append(" pmcond").append(index).append(".component_uuid = c.uuid and ");
condition.appendSqlCondition(sb, index);
}
if (filter.isOnFavourites()) {
- sb.append(" INNER JOIN properties props ON props.resource_id=p.id ");
+ sb.append(" inner join properties props on props.resource_id=c.id ");
}
if (filter.sort().isOnMeasure()) {
- sb.append(" LEFT OUTER JOIN project_measures pmsort ON s.id=pmsort.snapshot_id AND pmsort.metric_id=");
+ sb.append(" left outer join project_measures pmsort ON s.uuid = pmsort.analysis_uuid and pmsort.component_uuid = c.uuid and pmsort.metric_id=");
sb.append(filter.sort().metric().getId());
- sb.append(" AND pmsort.person_id IS NULL ");
+ sb.append(" and pmsort.person_id is null ");
}
- sb.append(" WHERE ");
- appendResourceConditions(sb);
+ sb.append(" where ");
+ sb.append(" s.islast=").append(database.getDialect().getTrueSqlValue());
+ appendComponentConditions(sb);
for (int index = 0; index < filter.getMeasureConditions().size(); index++) {
MeasureFilterCondition condition = filter.getMeasureConditions().get(index);
- sb.append(" AND ");
+ sb.append(" and ");
condition.appendSqlCondition(sb, index);
}
return sb.toString();
}
- private void appendResourceConditions(StringBuilder sb) {
- sb.append(" s.status='P' AND s.islast=").append(database.getDialect().getTrueSqlValue());
- if (context.getBaseSnapshot() == null) {
- sb.append(" AND p.copy_component_uuid IS NULL ");
+ private void appendComponentConditions(StringBuilder sb) {
+ sb.append(" and c.enabled=").append(database.getDialect().getTrueSqlValue());
+ ComponentDto base = context.getBaseComponent();
+ if (base == null) {
+ sb.append(" and c.copy_component_uuid is null ");
+ } else {
+ sb.append(" and base.uuid = '").append(base.uuid()).append("' ");
+ if (filter.isOnBaseResourceChildren()) {
+ String path = base.getUuidPath() + base.uuid() + UUID_PATH_SEPARATOR;
+ sb.append(" and c.uuid_path = '").append(path).append("' ");
+ } else {
+ String like = DatabaseUtils.buildLikeValue(base.getUuidPath() + base.uuid() + UUID_PATH_SEPARATOR, WildcardPosition.AFTER);
+ sb.append(" and c.uuid_path like '").append(like).append("' escape '/' ");
+ }
}
if (!filter.getResourceQualifiers().isEmpty()) {
- sb.append(" AND s.qualifier IN ");
+ sb.append(" and c.qualifier in ");
appendInStatement(filter.getResourceQualifiers(), sb);
}
if (!filter.getResourceScopes().isEmpty()) {
- sb.append(" AND s.scope IN ");
+ sb.append(" and c.scope in ");
appendInStatement(filter.getResourceScopes(), sb);
}
appendDateConditions(sb);
appendFavouritesCondition(sb);
appendResourceNameCondition(sb);
appendResourceKeyCondition(sb);
- appendResourceBaseCondition(sb);
}
private void appendDateConditions(StringBuilder sb) {
Date fromDate = filter.getFromDate();
if (fromDate != null) {
- sb.append(" AND s.created_at >= ? ");
+ sb.append(" and s.created_at >= ? ");
dateParameters.add(fromDate.getTime());
}
Date toDate = filter.getToDate();
if (toDate != null) {
- sb.append(" AND s.created_at <= ? ");
+ sb.append(" and s.created_at <= ? ");
dateParameters.add(toDate.getTime());
}
}
private void appendFavouritesCondition(StringBuilder sb) {
if (filter.isOnFavourites()) {
- sb.append(" AND props.prop_key='favourite' AND props.resource_id IS NOT NULL AND props.user_id=");
+ sb.append(" and props.prop_key='favourite' and props.resource_id is not null and props.user_id=");
sb.append(context.getUserId());
sb.append(" ");
}
}
- private void appendResourceBaseCondition(StringBuilder sb) {
- SnapshotDto baseSnapshot = context.getBaseSnapshot();
- if (baseSnapshot != null) {
- if (filter.isOnBaseResourceChildren()) {
- sb.append(" AND s.parent_snapshot_id=").append(baseSnapshot.getId());
- } else {
- Long rootSnapshotId = baseSnapshot.getRootId() != null ? baseSnapshot.getRootId() : baseSnapshot.getId();
- sb.append(" AND s.root_snapshot_id=").append(rootSnapshotId);
- sb.append(" AND s.path LIKE '").append(StringUtils.defaultString(baseSnapshot.getPath())).append(baseSnapshot.getId()).append(".%'");
- }
- }
- }
-
private void appendResourceKeyCondition(StringBuilder sb) {
if (StringUtils.isNotBlank(filter.getResourceKey())) {
- sb.append(" AND UPPER(p.kee) LIKE '%");
+ sb.append(" and UPPER(c.kee) like '%");
sb.append(escapePercentAndUnderscrore(StringEscapeUtils.escapeSql(StringUtils.upperCase(filter.getResourceKey()))));
sb.append("%'");
appendEscapeForSomeDb(sb);
private void appendResourceNameCondition(StringBuilder sb) {
if (StringUtils.isNotBlank(filter.getResourceName())) {
- sb.append(" AND p.uuid IN (SELECT rindex.component_uuid FROM resource_index rindex WHERE rindex.kee LIKE '");
+ sb.append(" and c.uuid in (select rindex.component_uuid from resource_index rindex WHERE rindex.kee LIKE '");
sb.append(escapePercentAndUnderscrore(StringEscapeUtils.escapeSql(StringUtils.lowerCase(filter.getResourceName()))));
sb.append("%'");
appendEscapeForSomeDb(sb);
appendInStatement(filter.getResourceQualifiers(), sb);
}
sb.append(") ");
+ // TODO filter on ROOT_COMPONENT_UUID if base
}
}
static class TextSortRowProcessor extends RowProcessor {
@Override
MeasureFilterRow fetch(ResultSet rs) throws SQLException {
- MeasureFilterRow row = new MeasureFilterRow(rs.getLong(1), rs.getLong(2), rs.getString(3));
- row.setSortText(rs.getString(4));
+ MeasureFilterRow row = new MeasureFilterRow(rs.getString(1), rs.getString(2));
+ row.setSortText(rs.getString(3));
return row;
}
@Override
MeasureFilterRow fetch(ResultSet rs) throws SQLException {
- MeasureFilterRow row = new MeasureFilterRow(rs.getLong(1), rs.getLong(2), rs.getString(3));
- double value = rs.getDouble(4);
+ MeasureFilterRow row = new MeasureFilterRow(rs.getString(1), rs.getString(2));
+ double value = rs.getDouble(3);
if (!rs.wasNull()) {
row.setSortDouble(value);
}
@Override
MeasureFilterRow fetch(ResultSet rs) throws SQLException {
- MeasureFilterRow row = new MeasureFilterRow(rs.getLong(1), rs.getLong(2), rs.getString(3));
- row.setSortDate(rs.getTimestamp(4).getTime());
+ MeasureFilterRow row = new MeasureFilterRow(rs.getString(1), rs.getString(2));
+ row.setSortDate(rs.getTimestamp(3).getTime());
return row;
}
@Override
@Override
MeasureFilterRow fetch(ResultSet rs) throws SQLException {
- MeasureFilterRow row = new MeasureFilterRow(rs.getLong(1), rs.getLong(2), rs.getString(3));
- row.setSortDate(rs.getLong(4));
+ MeasureFilterRow row = new MeasureFilterRow(rs.getString(1), rs.getString(2));
+ row.setSortDate(rs.getLong(3));
return row;
}
import org.sonar.db.component.SnapshotDto;
import org.sonar.db.measure.MeasureDto;
import org.sonar.db.measure.MeasureDtoFunctions;
+import org.sonar.db.measure.MeasureQuery;
import org.sonar.db.metric.MetricDto;
import org.sonar.db.metric.MetricDtoFunctions;
import org.sonar.server.component.ComponentFinder;
Long developerId = searchDeveloperId(dbSession, request);
Optional<ComponentDto> refComponent = getReferenceComponent(dbSession, component);
checkPermissions(component);
- SnapshotDto lastSnapshot = dbClient.snapshotDao().selectLastSnapshotByComponentUuid(dbSession, component.uuid());
+ SnapshotDto analysis = dbClient.snapshotDao().selectLastSnapshotByComponentUuid(dbSession, component.uuid());
List<MetricDto> metrics = searchMetrics(dbSession, request);
- List<WsMeasures.Period> periods = snapshotToWsPeriods(lastSnapshot);
- List<MeasureDto> measures = searchMeasures(dbSession, component, lastSnapshot, metrics, periods, developerId);
+ List<WsMeasures.Period> periods = snapshotToWsPeriods(analysis);
+ List<MeasureDto> measures = searchMeasures(dbSession, component, analysis, metrics, periods, developerId);
return buildResponse(request, component, refComponent, measures, metrics, periods);
} finally {
response.setComponent(componentDtoToWsComponent(component, measuresByMetric, emptyMap()));
}
-
List<String> additionalFields = request.getAdditionalFields();
if (additionalFields != null) {
if (additionalFields.contains(ADDITIONAL_METRICS)) {
return metrics;
}
- private List<MeasureDto> searchMeasures(DbSession dbSession, ComponentDto component, @Nullable SnapshotDto snapshot, List<MetricDto> metrics, List<WsMeasures.Period> periods,
+ private List<MeasureDto> searchMeasures(DbSession dbSession, ComponentDto component, @Nullable SnapshotDto analysis, List<MetricDto> metrics, List<WsMeasures.Period> periods,
@Nullable Long developerId) {
- if (snapshot == null) {
+ if (analysis == null) {
return emptyList();
}
- List<Integer> metricIds = Lists.transform(metrics, MetricDtoFunctions.toId());
- List<MeasureDto> measures = dbClient.measureDao().selectByDeveloperForSnapshotAndMetrics(dbSession, developerId, snapshot.getId(), metricIds);
+ List<Integer> metricIds = Lists.transform(metrics, MetricDto::getId);
+ MeasureQuery query = MeasureQuery.builder()
+ .setPersonId(developerId)
+ .setMetricIds(metricIds)
+ .setComponentUuid(component.uuid())
+ .build();
+ List<MeasureDto> measures = dbClient.measureDao().selectByQuery(dbSession, query);
addBestValuesToMeasures(measures, component, metrics, periods);
return measures;
components.stream().forEach(c -> componentUuids.add(c.uuid()));
Map<Integer, MetricDto> metricsById = Maps.uniqueIndex(metrics, MetricDtoFunctions.toId());
- MeasureQuery measureQuery = new MeasureQuery.Builder()
+ MeasureQuery measureQuery = MeasureQuery.builder()
.setPersonId(developerId)
.setComponentUuids(componentUuids)
.setMetricIds(metricsById.keySet())
MetricDtoWithBestValue(MetricDto metric, List<Integer> periodIndexes) {
this.metric = metric;
- MeasureDto measure = new MeasureDto()
- .setMetricId(metric.getId())
- .setMetricKey(metric.getKey());
+ MeasureDto measure = new MeasureDto().setMetricId(metric.getId());
boolean isNewTypeMetric = metric.getKey().toLowerCase(Locale.ENGLISH).startsWith(LOWER_CASE_NEW_METRIC_PREFIX);
if (isNewTypeMetric) {
for (Integer periodIndex : periodIndexes) {
import org.sonar.server.source.ws.RawAction;
import org.sonar.server.source.ws.ScmAction;
import org.sonar.server.source.ws.SourcesWs;
-import org.sonar.server.test.CoverageService;
import org.sonar.server.test.index.TestIndex;
import org.sonar.server.test.index.TestIndexDefinition;
import org.sonar.server.test.index.TestIndexer;
DefaultNotificationManager.class,
// Tests
- CoverageService.class,
TestsWs.class,
CoveredFilesAction.class,
org.sonar.server.test.ws.ListAction.class,
this.projects = copyOf(builder.projects);
this.projectLinksByProjectUuid = buildProjectLinks(builder.projectLinks);
this.lastAnalysisDates = buildAnalysisDates(builder.snapshots);
- this.qualityGateStatuses = buildQualityGateStatuses(builder.snapshots, builder.qualityGates);
+ this.qualityGateStatuses = buildQualityGateStatuses(builder.qualityGates);
this.totalNbOfProject = builder.totalNbOfProjects;
}
snapshot -> formatDateTime(snapshot.getCreatedAt()))));
}
- private static Map<String, String> buildQualityGateStatuses(List<SnapshotDto> snapshots, List<MeasureDto> measures) {
- Map<Long, String> componentUuidsBySnapshotId = snapshots.stream().collect(Collectors.toMap(SnapshotDto::getId, SnapshotDto::getComponentUuid));
+ private static Map<String, String> buildQualityGateStatuses(List<MeasureDto> measures) {
return ImmutableMap.copyOf(measures.stream()
- .collect(Collectors.toMap(measure -> componentUuidsBySnapshotId.get(measure.getSnapshotId()), MeasureDto::getData)));
+ .collect(Collectors.toMap(measure -> measure.getComponentUuid(), MeasureDto::getData)));
}
static class Builder {
import org.sonar.db.component.ComponentQuery;
import org.sonar.db.component.SnapshotDto;
import org.sonar.db.measure.MeasureDto;
+import org.sonar.db.measure.MeasureQuery;
import org.sonar.db.metric.MetricDto;
import org.sonar.server.user.UserSession;
import org.sonarqube.ws.client.project.SearchMyProjectsRequest;
-import static java.util.Collections.singletonList;
import static java.util.Objects.requireNonNull;
import static org.sonar.api.utils.Paging.offset;
import static org.sonar.server.project.ws.SearchMyProjectsData.builder;
SearchMyProjectsData.Builder data = builder();
ProjectsResult searchResult = searchProjects(dbSession, request);
List<ComponentDto> projects = searchResult.projects;
- List<String> componentUuids = Lists.transform(projects, ComponentDto::uuid);
- List<ComponentLinkDto> projectLinks = dbClient.componentLinkDao().selectByComponentUuids(dbSession, componentUuids);
- List<SnapshotDto> snapshots = dbClient.snapshotDao().selectLastSnapshotByComponentUuids(dbSession, componentUuids);
- MetricDto alertStatusMetric = dbClient.metricDao().selectOrFailByKey(dbSession, CoreMetrics.ALERT_STATUS_KEY);
- List<MeasureDto> qualityGates = dbClient.measureDao().selectBySnapshotIdsAndMetricIds(dbSession,
- Lists.transform(snapshots, SnapshotDto::getId),
- singletonList(alertStatusMetric.getId()));
+ List<String> projectUuids = Lists.transform(projects, ComponentDto::uuid);
+ List<ComponentLinkDto> projectLinks = dbClient.componentLinkDao().selectByComponentUuids(dbSession, projectUuids);
+ List<SnapshotDto> snapshots = dbClient.snapshotDao().selectLastSnapshotByComponentUuids(dbSession, projectUuids);
+ MetricDto gateStatusMetric = dbClient.metricDao().selectOrFailByKey(dbSession, CoreMetrics.ALERT_STATUS_KEY);
+ MeasureQuery measureQuery = MeasureQuery.builder()
+ .setComponentUuids(projectUuids)
+ .setMetricId(gateStatusMetric.getId())
+ .build();
+ List<MeasureDto> qualityGates = dbClient.measureDao().selectByQuery(dbSession, measureQuery);
data.setProjects(projects)
.setProjectLinks(projectLinks)
import com.google.common.base.Optional;
import com.google.common.collect.Lists;
import java.util.Arrays;
-import java.util.Collections;
import java.util.List;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.sonar.db.component.ComponentDto;
import org.sonar.db.component.SnapshotDto;
import org.sonar.db.measure.MeasureDto;
+import org.sonar.db.measure.MeasureQuery;
import org.sonar.server.component.ComponentFinder;
import org.sonar.server.component.ComponentFinder.ParamNames;
import org.sonar.server.exceptions.BadRequestException;
try {
ProjectAndSnapshot projectAndSnapshot = getProjectAndSnapshot(dbSession, request);
checkPermission(projectAndSnapshot.project.uuid());
- Optional<String> measureData = getQualityGateDetailsMeasureData(dbSession, projectAndSnapshot.snapshotDto);
+ Optional<String> measureData = getQualityGateDetailsMeasureData(dbSession, projectAndSnapshot.project);
return ProjectStatusWsResponse.newBuilder()
.setProjectStatus(new QualityGateDetailsFormatter(measureData, projectAndSnapshot.snapshotDto).format())
return new ProjectAndSnapshot(projectDto, snapshotDto);
}
- private ProjectAndSnapshot getSnapshotThenProject(DbSession dbSession, String snapshotId) {
- SnapshotDto snapshotDto = getSnapshot(dbSession, snapshotId);
+ private ProjectAndSnapshot getSnapshotThenProject(DbSession dbSession, String analysisUuid) {
+ SnapshotDto snapshotDto = getSnapshot(dbSession, analysisUuid);
ComponentDto projectDto = dbClient.componentDao().selectOrFailByUuid(dbSession, snapshotDto.getComponentUuid());
return new ProjectAndSnapshot(projectDto, snapshotDto);
}
- private SnapshotDto getSnapshot(DbSession dbSession, String analysisUuidFromRequest) {
- java.util.Optional<SnapshotDto> snapshotDto = dbClient.snapshotDao().selectByUuid(dbSession, analysisUuidFromRequest);
- return checkFoundWithOptional(snapshotDto, "Analysis with id '%s' is not found", analysisUuidFromRequest);
+ private SnapshotDto getSnapshot(DbSession dbSession, String analysisUuid) {
+ java.util.Optional<SnapshotDto> snapshotDto = dbClient.snapshotDao().selectByUuid(dbSession, analysisUuid);
+ return checkFoundWithOptional(snapshotDto, "Analysis with id '%s' is not found", analysisUuid);
}
- private Optional<String> getQualityGateDetailsMeasureData(DbSession dbSession, Optional<SnapshotDto> snapshotDto) {
- if (!snapshotDto.isPresent()) {
- return Optional.absent();
- }
-
- List<MeasureDto> measures = dbClient.measureDao().selectBySnapshotIdAndMetricKeys(snapshotDto.get().getId(),
- Collections.singleton(CoreMetrics.QUALITY_GATE_DETAILS_KEY), dbSession);
+ private Optional<String> getQualityGateDetailsMeasureData(DbSession dbSession, ComponentDto project) {
+ MeasureQuery measureQuery = MeasureQuery.builder()
+ .setComponentUuid(project.projectUuid())
+ .setMetricKey(CoreMetrics.QUALITY_GATE_DETAILS_KEY)
+ .build();
+ List<MeasureDto> measures = dbClient.measureDao().selectByQuery(dbSession, measureQuery);
return measures.isEmpty()
? Optional.absent()
}
}
- private enum MetricToDto implements Function<Metric, MetricDto> {
+ public enum MetricToDto implements Function<Metric, MetricDto> {
INSTANCE;
@Override
@Nonnull
+++ /dev/null
-/*
- * SonarQube
- * Copyright (C) 2009-2016 SonarSource SA
- * mailto:contact AT sonarsource DOT com
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 3 of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-package org.sonar.server.test;
-
-import com.google.common.collect.Maps;
-import java.util.Map;
-import javax.annotation.CheckForNull;
-import org.sonar.api.measures.CoreMetrics;
-import org.sonar.api.server.ServerSide;
-import org.sonar.api.utils.KeyValueFormat;
-import org.sonar.api.web.UserRole;
-import org.sonar.db.DbSession;
-import org.sonar.db.MyBatis;
-import org.sonar.db.measure.MeasureDao;
-import org.sonar.db.measure.MeasureDto;
-import org.sonar.server.user.UserSession;
-
-@ServerSide
-public class CoverageService {
-
- public enum TYPE {
- UT, IT, OVERALL
- }
-
- private final MyBatis myBatis;
- private final MeasureDao measureDao;
- private final UserSession userSession;
-
- public CoverageService(MyBatis myBatis, MeasureDao measureDao, UserSession userSession) {
- this.myBatis = myBatis;
- this.measureDao = measureDao;
- this.userSession = userSession;
- }
-
- public void checkPermission(String fileKey) {
- userSession.checkComponentPermission(UserRole.CODEVIEWER, fileKey);
- }
-
- public Map<Integer, Integer> getHits(String fileKey, CoverageService.TYPE type) {
- switch (type) {
- case IT:
- return findDataFromComponent(fileKey, CoreMetrics.IT_COVERAGE_LINE_HITS_DATA_KEY);
- case OVERALL:
- return findDataFromComponent(fileKey, CoreMetrics.OVERALL_COVERAGE_LINE_HITS_DATA_KEY);
- default:
- return findDataFromComponent(fileKey, CoreMetrics.COVERAGE_LINE_HITS_DATA_KEY);
- }
- }
-
- public Map<Integer, Integer> getConditions(String fileKey, CoverageService.TYPE type) {
- switch (type) {
- case IT:
- return findDataFromComponent(fileKey, CoreMetrics.IT_CONDITIONS_BY_LINE_KEY);
- case OVERALL:
- return findDataFromComponent(fileKey, CoreMetrics.OVERALL_CONDITIONS_BY_LINE_KEY);
- default:
- return findDataFromComponent(fileKey, CoreMetrics.CONDITIONS_BY_LINE_KEY);
- }
- }
-
- public Map<Integer, Integer> getCoveredConditions(String fileKey, CoverageService.TYPE type) {
- switch (type) {
- case IT:
- return findDataFromComponent(fileKey, CoreMetrics.IT_COVERED_CONDITIONS_BY_LINE_KEY);
- case OVERALL:
- return findDataFromComponent(fileKey, CoreMetrics.OVERALL_COVERED_CONDITIONS_BY_LINE_KEY);
- default:
- return findDataFromComponent(fileKey, CoreMetrics.COVERED_CONDITIONS_BY_LINE_KEY);
- }
- }
-
- @CheckForNull
- private Map<Integer, Integer> findDataFromComponent(String fileKey, String metricKey) {
- DbSession session = myBatis.openSession(false);
- try {
- MeasureDto data = measureDao.selectByComponentKeyAndMetricKey(session, fileKey, metricKey);
- String dataValue = data != null ? data.getData() : null;
- if (dataValue != null) {
- return KeyValueFormat.parseIntInt(dataValue);
- }
- return Maps.newHashMap();
- } finally {
- MyBatis.closeQuietly(session);
- }
- }
-}
+++ /dev/null
-/*
- * SonarQube
- * Copyright (C) 2009-2016 SonarSource SA
- * mailto:contact AT sonarsource DOT com
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 3 of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-@ParametersAreNonnullByDefault
-package org.sonar.server.test;
-
-import javax.annotation.ParametersAreNonnullByDefault;
-
import com.google.common.collect.Maps;
import java.util.Collection;
import java.util.Map;
-import org.apache.commons.lang.ArrayUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.builder.CompareToBuilder;
import org.apache.commons.lang.builder.EqualsBuilder;
return defaultForMetrics;
}
- public boolean supportsMetric(String metricKey) {
- return ArrayUtils.contains(defaultForMetrics, metricKey);
- }
-
public boolean isUserAuthorized() {
boolean authorized = userRoles.length == 0;
for (String userRole : getUserRoles()) {
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import javax.annotation.Nullable;
import org.apache.commons.lang.ArrayUtils;
import org.sonar.api.server.ServerSide;
import org.sonar.api.web.Page;
import org.sonar.api.web.View;
import org.sonar.api.web.Widget;
+
+import javax.annotation.Nullable;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
import org.sonar.server.user.UserSession;
@ServerSide
}
public List<ViewProxy<Page>> getPages(String section) {
+ return getPages(section, null, null, null);
+ }
+
+ public List<ViewProxy<Page>> getPages(String section,
+ @Nullable String resourceScope, @Nullable String resourceQualifier, @Nullable String resourceLanguage) {
List<ViewProxy<Page>> result = Lists.newArrayList();
for (ViewProxy<Page> proxy : pages) {
- if (accept(proxy, section)) {
+ if (accept(proxy, section, resourceScope, resourceQualifier, resourceLanguage)) {
result.add(proxy);
}
}
return widgetsPerId.get(id);
}
+ public List<ViewProxy<Widget>> getWidgets(String resourceScope, String resourceQualifier, String resourceLanguage, String[] availableMeasures) {
+ List<ViewProxy<Widget>> result = Lists.newArrayList();
+ for (ViewProxy<Widget> proxy : widgets) {
+ if (accept(proxy, null, resourceScope, resourceQualifier, resourceLanguage)) {
+ result.add(proxy);
+ }
+ }
+ return result;
+ }
+
public List<ViewProxy<Widget>> getWidgets() {
return Lists.newArrayList(widgets);
}
- protected static boolean accept(ViewProxy<?> proxy, @Nullable String section) {
- return acceptNavigationSection(proxy, section);
+ protected static boolean accept(ViewProxy<?> proxy,
+ @Nullable String section, @Nullable String resourceScope, @Nullable String resourceQualifier, @Nullable String resourceLanguage) {
+ return acceptNavigationSection(proxy, section)
+ && acceptResourceScope(proxy, resourceScope)
+ && acceptResourceQualifier(proxy, resourceQualifier)
+ && acceptResourceLanguage(proxy, resourceLanguage);
+ }
+
+ protected static boolean acceptResourceLanguage(ViewProxy<?> proxy, @Nullable String resourceLanguage) {
+ return resourceLanguage == null || ArrayUtils.isEmpty(proxy.getResourceLanguages()) || ArrayUtils.contains(proxy.getResourceLanguages(), resourceLanguage);
+ }
+
+ protected static boolean acceptResourceScope(ViewProxy<?> proxy, @Nullable String resourceScope) {
+ return resourceScope == null || ArrayUtils.isEmpty(proxy.getResourceScopes()) || ArrayUtils.contains(proxy.getResourceScopes(), resourceScope);
+ }
+
+ protected static boolean acceptResourceQualifier(ViewProxy<?> proxy, @Nullable String resourceQualifier) {
+ return resourceQualifier == null || ArrayUtils.isEmpty(proxy.getResourceQualifiers()) || ArrayUtils.contains(proxy.getResourceQualifiers(), resourceQualifier);
}
protected static boolean acceptNavigationSection(ViewProxy<?> proxy, @Nullable String section) {
userSession.checkComponentUuidPermission(UserRole.USER, component.projectUuid());
- SnapshotDto snapshot = dbClient.snapshotDao().selectLastSnapshotByComponentUuid(session, component.uuid());
+ SnapshotDto analysis = dbClient.snapshotDao().selectLastSnapshotByComponentUuid(session, component.uuid());
JsonWriter json = response.newJsonWriter();
json.beginObject();
- writeComponent(json, session, component, snapshot, userSession);
+ writeComponent(json, session, component, analysis, userSession);
if (userSession.hasComponentUuidPermission(UserRole.ADMIN, component.projectUuid()) || userSession.hasPermission(GlobalPermissions.QUALITY_PROFILE_ADMIN)) {
writeConfiguration(json, component, userSession);
}
- writeBreadCrumbs(json, session, component, snapshot);
+ writeBreadCrumbs(json, session, component, analysis);
json.endObject().close();
} finally {
}
}
- private void writeComponent(JsonWriter json, DbSession session, ComponentDto component, @Nullable SnapshotDto snapshot, UserSession userSession) {
+ private void writeComponent(JsonWriter json, DbSession session, ComponentDto component, @Nullable SnapshotDto analysis, UserSession userSession) {
json.prop("key", component.key())
.prop("uuid", component.uuid())
}
writeDashboards(json, dashboards);
- if (snapshot != null) {
- json.prop("version", snapshot.getVersion())
- .prop("snapshotDate", DateUtils.formatDateTime(new Date(snapshot.getCreatedAt())));
- List<ViewProxy<Page>> pages = views.getPages(NavigationSection.RESOURCE);
+ if (analysis != null) {
+ json.prop("version", analysis.getVersion())
+ .prop("snapshotDate", DateUtils.formatDateTime(new Date(analysis.getCreatedAt())));
+ List<ViewProxy<Page>> pages = views.getPages(NavigationSection.RESOURCE, component.scope(), component.qualifier(), component.language());
writeExtensions(json, component, pages, userSession.locale());
}
}
if (isAdmin) {
json.name("extensions").beginArray();
- List<ViewProxy<Page>> configPages = views.getPages(NavigationSection.RESOURCE_CONFIGURATION);
+ List<ViewProxy<Page>> configPages = views.getPages(NavigationSection.RESOURCE_CONFIGURATION, component.scope(), component.qualifier(), component.language());
for (ViewProxy<Page> page : configPages) {
writePage(json, getPageUrl(page, component), i18n.message(locale, page.getId() + ".page", page.getTitle()));
}
json.name("extensions").beginArray();
if (isAdmin) {
- for (ViewProxy<Page> page : views.getPages(NavigationSection.CONFIGURATION)) {
+ for (ViewProxy<Page> page : views.getPages(NavigationSection.CONFIGURATION, null, null, null)) {
json.beginObject()
.prop("name", i18n.message(userSession.locale(), String.format("%s.page", page.getTitle()), page.getTitle()))
.prop("url", getPageUrl(page))
title = widget_properties["title"]
title = message('widget.hotspot_metric.hotspots_by_x', :params => metric.short_name) if title.blank?
- snapshots = nil
- if metric.numeric? && !@snapshot.leaves_qualifiers.empty?
- snapshots_conditions=["snapshots.qualifier in (:qualifiers)", "snapshots.islast=:islast", "snapshots.status = 'P'"]
- snapshots_values={:qualifiers => @snapshot.leaves_qualifiers, :islast => true}
- snapshots_conditions << '(snapshots.root_snapshot_id=:root_sid AND snapshots.path LIKE :path)'
- snapshots_values[:root_sid] = (@snapshot.root_snapshot_id || @snapshot.id)
- snapshots_values[:path]="#{@snapshot.path}#{@snapshot.id}.%"
+ if metric.numeric? && !@resource.leaves_qualifiers.empty?
- measures_conditions = ["project_measures.person_id IS NULL"]
- measures_values = {}
- measures_conditions << "project_measures.metric_id = :m_id"
- measures_values[:m_id] = metric.id
+ conditions = [
+ "projects.qualifier in (:qualifiers)",
+ "projects.uuid_path like :uuid_path_like",
+ "projects.project_uuid = :project_uuid",
+ "snapshots.islast = :islast",
+ "project_measures.person_id is null",
+ "project_measures.metric_id = :metric_id"
+ ]
+ condition_values = {
+ :qualifiers => @resource.leaves_qualifiers,
+ :project_uuid => @resource.project_uuid,
+ :uuid_path_like => "#{@resource.uuid_path}#{@resource.uuid}.%",
+ :islast => true,
+ :metric_id => metric.id
+ }
- measures=ProjectMeasure.find(:all,
- :joins => :snapshot,
- :conditions => [(snapshots_conditions + measures_conditions).join(' AND '), snapshots_values.merge(measures_values)],
+ measures = ProjectMeasure.find(:all,
+ :joins => [:analysis, :project],
+ :conditions => [ conditions.join(' AND '), condition_values ],
:order => "project_measures.value #{'DESC' if metric.direction<0}",
:limit => limit)
- snapshots=Snapshot.find(measures.map { |m| m.snapshot_id }, :include => 'project')
- snapshots_by_id = {}
- snapshots.each do |s|
- snapshots_by_id[s.id]=s
+ components_by_uuid = Project.all( :conditions => ['uuid in (?)', measures.map { |m| m.component_uuid } ] ).inject({}) do |hash, component|
+ hash[component.uuid] = component
+ hash
end
end
- unless snapshots && !snapshots.empty? %>
+ unless components_by_uuid && !components_by_uuid.empty? %>
<h3><%= title -%></h3>
<span class="empty_widget"><%= message('no_results') -%></span>
<% else %>
metric_max_value = measures.first.value
end
measures.each do |measure|
- resource = snapshots_by_id[measure.snapshot_id].resource
+ component = components_by_uuid[measure.component_uuid]
%>
<tr class="<%= cycle 'even', 'odd', :name => ('hotspot_metric' + widget.id.to_s) -%>">
<td>
- <%= link_to_resource(resource, h(resource.name), {:metric => metric.name, :class => 'underlined-link'}) -%>
+ <%= link_to_resource(component, h(component.name), {:metric => metric.name, :class => 'underlined-link'}) -%>
</td>
<td class="right nowrap">
<%= format_measure(measure) -%>
*/
package org.sonar.server.component.ws;
-import com.google.common.base.Optional;
-import java.util.List;
+import java.util.HashMap;
import java.util.Locale;
+import java.util.Map;
+import javax.annotation.Nullable;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.ArgumentCaptor;
-import org.mockito.Captor;
-import org.mockito.Mock;
-import org.mockito.runners.MockitoJUnitRunner;
import org.sonar.api.i18n.I18n;
import org.sonar.api.measures.CoreMetrics;
import org.sonar.api.utils.Duration;
import org.sonar.api.utils.Durations;
+import org.sonar.api.utils.System2;
import org.sonar.api.web.UserRole;
-import org.sonar.db.DbClient;
-import org.sonar.db.DbSession;
-import org.sonar.db.component.ComponentDao;
+import org.sonar.db.DbTester;
import org.sonar.db.component.ComponentDto;
import org.sonar.db.component.ComponentTesting;
-import org.sonar.db.measure.MeasureDao;
+import org.sonar.db.component.SnapshotDto;
+import org.sonar.db.component.SnapshotTesting;
import org.sonar.db.measure.MeasureDto;
-import org.sonar.db.property.PropertiesDao;
-import org.sonar.db.property.PropertyDto;
-import org.sonar.db.property.PropertyQuery;
+import org.sonar.db.measure.MeasureTesting;
+import org.sonar.db.metric.MetricDto;
import org.sonar.server.component.ComponentFinder;
-import org.sonar.server.exceptions.NotFoundException;
+import org.sonar.server.i18n.I18nRule;
+import org.sonar.server.startup.RegisterMetrics;
import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
-import static com.google.common.collect.Lists.newArrayList;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.fail;
import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyListOf;
-import static org.mockito.Matchers.anyString;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-@RunWith(MockitoJUnitRunner.class)
public class AppActionTest {
- @Rule
- public UserSessionRule userSessionRule = UserSessionRule.standalone();
-
- static final String SUB_PROJECT_KEY = "org.codehaus.sonar:sonar-plugin-api";
- static final String COMPONENT_KEY = "org.codehaus.sonar:sonar-plugin-api:src/main/java/org/sonar/api/Plugin.java";
- static final String COMPONENT_UUID = "ABCDE";
- static final String PROJECT_UUID = "THE_PROJECT";
-
- @Mock
- DbSession session;
+ private static final String PROJECT_KEY = "org.sonarsource.sonarqube:sonarqube";
+ private static final String MODULE_KEY = "org.sonarsource.sonarqube:sonar-plugin-api";
+ private static final String FILE_KEY = "org.sonarsource.sonarqube:sonar-plugin-api:src/main/java/org/sonar/api/Plugin.java";
+ private static final String PROJECT_UUID = "THE_PROJECT_UUID";
+ private static final String MODULE_UUID = "THE_MODULE_UUID";
+ private static final String FILE_UUID = "THE_FILE_UUID";
+ private static final String ANALYSIS_UUID = "THE_ANALYSIS_UUID";
- @Mock
- ComponentDao componentDao;
+ private Map<String, MetricDto> metricsByKey;
- @Mock
- PropertiesDao propertiesDao;
-
- @Mock
- MeasureDao measureDao;
-
- @Mock
- Durations durations;
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
- @Mock
- I18n i18n;
+ @Rule
+ public DbTester dbTester = DbTester.create(System2.INSTANCE);
- @Captor
- ArgumentCaptor<List<String>> measureKeysCaptor;
+ private I18n i18n = new I18nRule();
- List<MeasureDto> measures = newArrayList();
+ private Durations durations = mock(Durations.class);
- WsTester tester;
+ private WsTester wsTester;
@Before
public void setUp() {
- DbClient dbClient = mock(DbClient.class);
- when(dbClient.openSession(false)).thenReturn(session);
- when(dbClient.componentDao()).thenReturn(componentDao);
- when(dbClient.propertiesDao()).thenReturn(propertiesDao);
- when(dbClient.measureDao()).thenReturn(measureDao);
-
- when(measureDao.selectByComponentKeyAndMetricKeys(eq(session), anyString(), anyListOf(String.class))).thenReturn(measures);
-
- tester = new WsTester(new ComponentsWs(new AppAction(dbClient, durations, i18n, userSessionRule, new ComponentFinder(dbClient)), mock(SearchViewComponentsAction.class)));
+ insertMetrics();
+ wsTester = new WsTester(new ComponentsWs(
+ new AppAction(dbTester.getDbClient(), durations, i18n, userSessionRule, new ComponentFinder(dbTester.getDbClient())), mock(SearchViewComponentsAction.class)));
}
@Test
- public void app() throws Exception {
- userSessionRule.login("john").addComponentPermission(UserRole.USER, SUB_PROJECT_KEY, COMPONENT_KEY);
- ComponentDto project = newProject();
-
- ComponentDto file = ComponentTesting.newFileDto(project)
- .setId(10L)
- .setKey(COMPONENT_KEY)
- .setUuid(COMPONENT_UUID)
- .setName("Plugin.java")
- .setProjectUuid("THE_PROJECT")
- .setLongName("src/main/java/org/sonar/api/Plugin.java")
- .setPath("src/main/java/org/sonar/api/Plugin.java")
- .setRootUuid("uuid_5");
- when(componentDao.selectByUuid(session, COMPONENT_UUID)).thenReturn(Optional.of(file));
- when(componentDao.selectOrFailByUuid(session, "uuid_5")).thenReturn(new ComponentDto().setUuid("uuid_5").setLongName("SonarQube :: Plugin API").setKey(SUB_PROJECT_KEY));
- when(componentDao.selectOrFailByUuid(session, project.uuid())).thenReturn(project);
- when(propertiesDao.selectByQuery(any(PropertyQuery.class), eq(session))).thenReturn(newArrayList(new PropertyDto()));
-
- WsTester.TestRequest request = tester.newGetRequest("api/components", "app").setParam("uuid", COMPONENT_UUID);
+ public void file_without_measures() throws Exception {
+ insertComponentsAndAnalysis();
+ dbTester.commit();
+
+ userSessionRule.login("john").addComponentPermission(UserRole.USER, MODULE_KEY, FILE_KEY);
+ WsTester.TestRequest request = wsTester.newGetRequest("api/components", "app").setParam("uuid", FILE_UUID);
request.execute().assertJson(getClass(), "app.json");
}
@Test
- public void app_with_measures() throws Exception {
- userSessionRule.addComponentPermission(UserRole.USER, SUB_PROJECT_KEY, COMPONENT_KEY);
- ComponentDto project = newProject();
- newComponent(project);
-
- addMeasure(CoreMetrics.LINES_KEY, 200);
- addMeasure(CoreMetrics.COVERAGE_KEY, 95.4);
- addMeasure(CoreMetrics.DUPLICATED_LINES_DENSITY_KEY, 7.4);
- addMeasure(CoreMetrics.SQALE_RATING_KEY, "C");
- addMeasure(CoreMetrics.SQALE_DEBT_RATIO_KEY, 35d);
-
- measures.add(new MeasureDto().setMetricKey(CoreMetrics.TECHNICAL_DEBT_KEY).setValue(182.0));
- when(durations.format(any(Locale.class), any(Duration.class), eq(Durations.DurationFormat.SHORT))).thenReturn("3h 2min");
-
- WsTester.TestRequest request = tester.newGetRequest("api/components", "app").setParam("uuid", COMPONENT_UUID);
+ public void file_with_measures() throws Exception {
+ insertComponentsAndAnalysis();
+ insertFileMeasure(metricsByKey.get(CoreMetrics.LINES_KEY).getId(), 200d, null);
+ insertFileMeasure(metricsByKey.get(CoreMetrics.DUPLICATED_LINES_DENSITY_KEY).getId(), 7.4, null);
+ insertFileMeasure(metricsByKey.get(CoreMetrics.SQALE_RATING_KEY).getId(), null, "C");
+ insertFileMeasure(metricsByKey.get(CoreMetrics.TECHNICAL_DEBT_KEY).getId(), 182d, null);
+ insertFileMeasure(metricsByKey.get(CoreMetrics.SQALE_DEBT_RATIO_KEY).getId(), 35d, null);
+ insertFileMeasure(metricsByKey.get(CoreMetrics.COVERAGE_KEY).getId(), 95.4d, null);
+ dbTester.commit();
+
+ userSessionRule
+ .login("john")
+ .setLocale(Locale.ENGLISH)
+ .addComponentPermission(UserRole.USER, PROJECT_KEY, FILE_KEY);
+ when(durations.format(eq(Locale.ENGLISH), any(Duration.class), any())).thenReturn("3h 2min");
+ WsTester.TestRequest request = wsTester.newGetRequest("api/components", "app").setParam("uuid", FILE_UUID);
request.execute().assertJson(getClass(), "app_with_measures.json");
-
- verify(measureDao).selectByComponentKeyAndMetricKeys(eq(session), eq(COMPONENT_KEY), measureKeysCaptor.capture());
- assertThat(measureKeysCaptor.getValue()).contains(CoreMetrics.LINES_KEY, CoreMetrics.COVERAGE_KEY, CoreMetrics.DUPLICATED_LINES_DENSITY_KEY,
- CoreMetrics.TECHNICAL_DEBT_KEY);
}
@Test
- public void app_with_overall_measure() throws Exception {
- userSessionRule.addComponentPermission(UserRole.USER, SUB_PROJECT_KEY, COMPONENT_KEY);
- ComponentDto project = newProject();
- newComponent(project);
-
- addMeasure(CoreMetrics.OVERALL_COVERAGE_KEY, 90.1);
- addMeasure(CoreMetrics.COVERAGE_KEY, 95.4);
- addMeasure(CoreMetrics.IT_COVERAGE_KEY, 85.2);
-
- WsTester.TestRequest request = tester.newGetRequest("api/components", "app").setParam("uuid", COMPONENT_UUID);
+ public void file_with_overall_coverage() throws Exception {
+ insertComponentsAndAnalysis();
+ insertFileMeasure(metricsByKey.get(CoreMetrics.OVERALL_COVERAGE_KEY).getId(), 90.1, null);
+ insertFileMeasure(metricsByKey.get(CoreMetrics.COVERAGE_KEY).getId(), 95.4, null);
+ insertFileMeasure(metricsByKey.get(CoreMetrics.IT_COVERAGE_KEY).getId(), 85.2, null);
+ dbTester.commit();
+
+ userSessionRule.login("john").addComponentPermission(UserRole.USER, PROJECT_KEY, FILE_KEY);
+ WsTester.TestRequest request = wsTester.newGetRequest("api/components", "app").setParam("uuid", FILE_UUID);
request.execute().assertJson(getClass(), "app_with_overall_measure.json");
}
@Test
- public void app_with_ut_measure() throws Exception {
- userSessionRule.addComponentPermission(UserRole.USER, SUB_PROJECT_KEY, COMPONENT_KEY);
- ComponentDto project = newProject();
- newComponent(project);
-
- addMeasure(CoreMetrics.COVERAGE_KEY, 95.4);
- addMeasure(CoreMetrics.IT_COVERAGE_KEY, 85.2);
-
- WsTester.TestRequest request = tester.newGetRequest("api/components", "app").setParam("uuid", COMPONENT_UUID);
+ public void file_with_ut_coverage() throws Exception {
+ insertComponentsAndAnalysis();
+ insertFileMeasure(metricsByKey.get(CoreMetrics.COVERAGE_KEY).getId(), 95.4, null);
+ insertFileMeasure(metricsByKey.get(CoreMetrics.IT_COVERAGE_KEY).getId(), 85.2, null);
+ dbTester.commit();
+
+ userSessionRule.login("john").addComponentPermission(UserRole.USER, PROJECT_KEY, FILE_KEY);
+ WsTester.TestRequest request = wsTester.newGetRequest("api/components", "app").setParam("uuid", FILE_UUID);
request.execute().assertJson(getClass(), "app_with_ut_measure.json");
}
@Test
- public void app_with_it_measure() throws Exception {
- userSessionRule.addComponentPermission(UserRole.USER, SUB_PROJECT_KEY, COMPONENT_KEY);
- ComponentDto project = newProject();
- newComponent(project);
-
- addMeasure(CoreMetrics.IT_COVERAGE_KEY, 85.2);
+ public void file_with_it_coverage_only() throws Exception {
+ insertComponentsAndAnalysis();
+ insertFileMeasure(metricsByKey.get(CoreMetrics.IT_COVERAGE_KEY).getId(), 85.2, null);
+ dbTester.commit();
- WsTester.TestRequest request = tester.newGetRequest("api/components", "app").setParam("uuid", COMPONENT_UUID);
+ userSessionRule.login("john").addComponentPermission(UserRole.USER, PROJECT_KEY, FILE_KEY);
+ WsTester.TestRequest request = wsTester.newGetRequest("api/components", "app").setParam("uuid", FILE_UUID);
request.execute().assertJson(getClass(), "app_with_it_measure.json");
}
- @Test
- public void fail_on_unknown_component() {
- userSessionRule.login("john").addComponentPermission(UserRole.USER, SUB_PROJECT_KEY, COMPONENT_KEY);
- when(componentDao.selectByUuid(session, COMPONENT_UUID)).thenReturn(Optional.<ComponentDto>absent());
-
- try {
- tester.newGetRequest("api/components", "app").setParam("uuid", COMPONENT_UUID).execute();
- fail();
- } catch (Exception e) {
- assertThat(e).isInstanceOf(NotFoundException.class).hasMessage("Component id 'ABCDE' not found");
+
+ private void insertMetrics() {
+ metricsByKey = new HashMap<>();
+ for (String metricKey : AppAction.METRIC_KEYS) {
+ MetricDto dto = RegisterMetrics.MetricToDto.INSTANCE.apply(CoreMetrics.getMetric(metricKey));
+ dbTester.getDbClient().metricDao().insert(dbTester.getSession(), dto);
+ metricsByKey.put(metricKey, dto);
}
+ dbTester.commit();
}
- private ComponentDto newProject() {
- return ComponentTesting.newProjectDto()
- .setId(1L)
- .setName("SonarQube")
- .setUuid(PROJECT_UUID)
+ private void insertComponentsAndAnalysis() {
+ ComponentDto project = ComponentTesting.newProjectDto(PROJECT_UUID)
.setLongName("SonarQube")
- .setKey("org.codehaus.sonar:sonar");
- }
-
- private ComponentDto newComponent(ComponentDto project) {
- ComponentDto file = ComponentTesting.newFileDto(project)
- .setId(10L)
- .setQualifier("FIL")
- .setKey(COMPONENT_KEY)
- .setUuid(COMPONENT_UUID)
- .setProjectUuid(PROJECT_UUID)
+ .setKey(PROJECT_KEY);
+ ComponentDto module = ComponentTesting.newModuleDto(MODULE_UUID, project)
+ .setLongName("SonarQube :: Plugin API")
+ .setKey(MODULE_KEY);
+ ComponentDto file = ComponentTesting.newFileDto(module, FILE_UUID)
+ .setKey(FILE_KEY)
.setName("Plugin.java")
.setLongName("src/main/java/org/sonar/api/Plugin.java")
- .setPath("src/main/java/org/sonar/api/Plugin.java")
- .setRootUuid("uuid_5");
- when(componentDao.selectByUuid(session, COMPONENT_UUID)).thenReturn(Optional.of(file));
- when(componentDao.selectOrFailByUuid(session, "uuid_5")).thenReturn(new ComponentDto().setUuid("uuid_5").setLongName("SonarQube :: Plugin API").setKey(SUB_PROJECT_KEY));
- when(componentDao.selectOrFailByUuid(session, project.uuid())).thenReturn(project);
- return file;
+ .setPath("src/main/java/org/sonar/api/Plugin.java");
+ dbTester.getDbClient().componentDao().insert(dbTester.getSession(), project, module, file);
+ SnapshotDto analysis = SnapshotTesting.newSnapshotForProject(project)
+ .setUuid(ANALYSIS_UUID);
+ dbTester.getDbClient().snapshotDao().insert(dbTester.getSession(), analysis);
}
- private void addMeasure(String metricKey, Integer value) {
- measures.add(new MeasureDto().setMetricKey(metricKey).setValue(value.doubleValue()));
- when(i18n.formatInteger(any(Locale.class), eq(value.intValue()))).thenReturn(Integer.toString(value));
+ private void insertFileMeasure(int metricId, @Nullable Double value, @Nullable String data) {
+ MeasureDto measure = MeasureTesting.newMeasure()
+ .setComponentUuid(FILE_UUID)
+ .setAnalysisUuid(ANALYSIS_UUID)
+ .setMetricId(metricId)
+ .setValue(value)
+ .setData(data);
+ dbTester.getDbClient().measureDao().insert(dbTester.getSession(), measure);
}
- private void addMeasure(String metricKey, Double value) {
- measures.add(new MeasureDto().setMetricKey(metricKey).setValue(value));
- when(i18n.formatDouble(any(Locale.class), eq(value))).thenReturn(Double.toString(value));
- }
-
- private void addMeasure(String metricKey, String value) {
- measures.add(new MeasureDto().setMetricKey(metricKey).setData(value));
- }
+ // @Test
+ // public void app_with_overall_measure() throws Exception {
+ // userSessionRule.addComponentPermission(UserRole.USER, SUB_PROJECT_KEY, FILE_KEY);
+ // ComponentDto project = newProject();
+ // newComponent(project);
+ //
+ // addMeasure(CoreMetrics.OVERALL_COVERAGE_KEY, 90.1);
+ // addMeasure(CoreMetrics.COVERAGE_KEY, 95.4);
+ // addMeasure(CoreMetrics.IT_COVERAGE_KEY, 85.2);
+ //
+ // WsTester.TestRequest request = wsTester.newGetRequest("api/components", "app").setParam("uuid", COMPONENT_UUID);
+ // request.execute().assertJson(getClass(), "app_with_overall_measure.json");
+ // }
+ //
+ // @Test
+ // public void app_with_ut_measure() throws Exception {
+ // userSessionRule.addComponentPermission(UserRole.USER, SUB_PROJECT_KEY, FILE_KEY);
+ // ComponentDto project = newProject();
+ // newComponent(project);
+ //
+ // addMeasure(CoreMetrics.COVERAGE_KEY, 95.4);
+ // addMeasure(CoreMetrics.IT_COVERAGE_KEY, 85.2);
+ //
+ // WsTester.TestRequest request = wsTester.newGetRequest("api/components", "app").setParam("uuid", COMPONENT_UUID);
+ // request.execute().assertJson(getClass(), "app_with_ut_measure.json");
+ // }
+ //
+ // @Test
+ // public void app_with_it_measure() throws Exception {
+ // userSessionRule.addComponentPermission(UserRole.USER, SUB_PROJECT_KEY, FILE_KEY);
+ // ComponentDto project = newProject();
+ // newComponent(project);
+ //
+ // addMeasure(CoreMetrics.IT_COVERAGE_KEY, 85.2);
+ //
+ // WsTester.TestRequest request = wsTester.newGetRequest("api/components", "app").setParam("uuid", COMPONENT_UUID);
+ // request.execute().assertJson(getClass(), "app_with_it_measure.json");
+ // }
+ //
+ // @Test
+ // public void fail_on_unknown_component() {
+ // userSessionRule.login("john").addComponentPermission(UserRole.USER, SUB_PROJECT_KEY, FILE_KEY);
+ // when(componentDao.selectByUuid(session, COMPONENT_UUID)).thenReturn(Optional.<ComponentDto>absent());
+ //
+ // try {
+ // wsTester.newGetRequest("api/components", "app").setParam("uuid", COMPONENT_UUID).execute();
+ // fail();
+ // } catch (Exception e) {
+ // assertThat(e).isInstanceOf(NotFoundException.class).hasMessage("Component id 'ABCDE' not found");
+ // }
+ // }
+ //
+ // private ComponentDto newProject() {
+ // return ComponentTesting.newProjectDto()
+ // .setId(1L)
+ // .setName("SonarQube")
+ // .setUuid(PROJECT_UUID)
+ // .setLongName("SonarQube")
+ // .setKey("org.codehaus.sonar:sonar");
+ // }
+ //
+ // private ComponentDto newComponent(ComponentDto project) {
+ // ComponentDto file = ComponentTesting.newFileDto(project)
+ // .setId(10L)
+ // .setQualifier("FIL")
+ // .setKey(FILE_KEY)
+ // .setUuid(COMPONENT_UUID)
+ // .setProjectUuid(PROJECT_UUID)
+ // .setName("Plugin.java")
+ // .setLongName("src/main/java/org/sonar/api/Plugin.java")
+ // .setPath("src/main/java/org/sonar/api/Plugin.java")
+ // .setRootUuid("uuid_5");
+ // when(componentDao.selectByUuid(session, COMPONENT_UUID)).thenReturn(Optional.of(file));
+ // when(componentDao.selectOrFailByUuid(session, "uuid_5")).thenReturn(new ComponentDto().setUuid("uuid_5").setLongName("SonarQube ::
+ // Plugin API").setKey(SUB_PROJECT_KEY));
+ // when(componentDao.selectOrFailByUuid(session, project.uuid())).thenReturn(project);
+ // return file;
+ // }
+ //
+ // private void addMeasure(String metricKey, Integer value) {
+ // measures.add(new MeasureDto().setMetricKey(metricKey).setValue(value.doubleValue()));
+ // when(i18n.formatInteger(any(Locale.class), eq(value.intValue()))).thenReturn(Integer.toString(value));
+ // }
+ //
+ // private void addMeasure(String metricKey, Double value) {
+ // measures.add(new MeasureDto().setMetricKey(metricKey).setValue(value));
+ // when(i18n.formatDouble(any(Locale.class), eq(value))).thenReturn(Double.toString(value));
+ // }
+ //
+ // private void addMeasure(String metricKey, String value) {
+ // measures.add(new MeasureDto().setMetricKey(metricKey).setData(value));
+ // }
}
public MeasureRepositoryRule measureRepository = MeasureRepositoryRule.create(treeRootHolder, metricRepository);
@Rule
public PeriodsHolderRule periodsHolder = new PeriodsHolderRule()
- .setPeriods(new Period(2, "some mode", null, 95l, 756l), new Period(5, "some other mode", null, 756L, 956L));
+ .setPeriods(new Period(2, "some mode", null, 95l, "756l"), new Period(5, "some other mode", null, 756L, "956L"));
@Test
public void verify_aggregation_on_value() throws Exception {
public MeasureRepositoryRule measureRepository = MeasureRepositoryRule.create(treeRootHolder, metricRepository);
@Rule
public PeriodsHolderRule periodsHolder = new PeriodsHolderRule()
- .setPeriods(new Period(2, "some mode", null, 95l, 756l), new Period(5, "some other mode", null, 756L, 956L));
+ .setPeriods(new Period(2, "some mode", null, 95l, "u1"), new Period(5, "some other mode", null, 756L, "u2"));
@Test
public void verify_aggregation_on_value() throws Exception {
}
private static Period createPeriod(int i) {
- return new Period(i, "mode " + i, null, 100L + i, 753L + i);
+ return new Period(i, "mode " + i, null, 100L + i, String.valueOf(753L + i));
}
}
}
private static Period createPeriod(int i) {
- return new Period(i, "mode " + i, null, 100L + i, 753L + i);
+ return new Period(i, "mode " + i, null, 100L + i, String.valueOf(753L + i));
}
}
}
private static Period createPeriod(int i) {
- return new Period(i, "mode " + i, null, 100L + i, 753L + i);
+ return new Period(i, "mode " + i, null, 100L + i, String.valueOf(753L + i));
}
}
}
private Period createPeriod(int periodIndex) {
- return new Period(periodIndex, "mode" + periodIndex, null, 963L + periodIndex, 9865L + periodIndex);
+ return new Period(periodIndex, "mode" + periodIndex, null, 963L + periodIndex, String.valueOf(9865L + periodIndex));
}
private static class CounterInitializationContextRule extends ExternalResource implements CounterInitializationContext {
}
private static Period newPeriod(int index, long date) {
- return new Period(index, "mode", null, date, 42l);
+ return new Period(index, "mode", null, date, "U1");
}
}
public class NewEffortAggregatorTest {
- private static final Period PERIOD = new Period(1, TIMEMACHINE_MODE_PREVIOUS_ANALYSIS, null, 1_500_000_000L, 1000L);
+ private static final Period PERIOD = new Period(1, TIMEMACHINE_MODE_PREVIOUS_ANALYSIS, null, 1_500_000_000L, "U1");
static final Component FILE = ReportComponent.builder(Component.Type.FILE, 1).setUuid("FILE").build();
static final Component PROJECT = ReportComponent.builder(Component.Type.PROJECT, 2).addChildren(FILE).build();
package org.sonar.server.computation.issue;
import java.util.Arrays;
-import java.util.Collections;
import java.util.Date;
import java.util.List;
import javax.annotation.Nullable;
import org.sonar.db.issue.IssueChangeDto;
import org.sonar.server.computation.period.Period;
+import static java.util.Collections.emptyList;
import static org.assertj.core.api.Assertions.assertThat;
import static org.sonar.core.config.CorePropertyDefinitions.TIMEMACHINE_MODE_PREVIOUS_VERSION;
private static final Duration FIVE_DAYS = Duration.create(5 * HOURS_IN_DAY * 60 * 60L);
private static final Duration TEN_DAYS = Duration.create(10 * HOURS_IN_DAY * 60 * 60L);
private static final long PERIOD_DATE = 150000000L;
- private static final long SNAPSHOT_ID = 1000L;
- private static final Period PERIOD = new Period(1, TIMEMACHINE_MODE_PREVIOUS_VERSION, null, PERIOD_DATE, SNAPSHOT_ID);
+ private static final String ANALYSIS_UUID = "u1";
+ private static final Period PERIOD = new Period(1, TIMEMACHINE_MODE_PREVIOUS_VERSION, null, PERIOD_DATE, ANALYSIS_UUID);
DefaultIssue issue = new DefaultIssue();
NewEffortCalculator underTest = new NewEffortCalculator();
public void total_debt_if_issue_created_during_period() {
issue.setEffort(TWO_DAYS).setCreationDate(new Date(PERIOD_DATE + 10000));
- long newDebt = underTest.calculate(issue, Collections.<IssueChangeDto>emptyList(), PERIOD);
+ long newDebt = underTest.calculate(issue, emptyList(), PERIOD);
assertThat(newDebt).isEqualTo(TWO_DAYS.toMinutes());
}
@Rule
public BatchReportReaderRule reportReader = new BatchReportReaderRule();
- private static final String AN_ANALYSIS_UUID = "a1";
private static final String FILE_COMPONENT_KEY = "file cpt key";
private static final ReportComponent FILE_COMPONENT = ReportComponent.builder(Component.Type.FILE, 1).setKey(FILE_COMPONENT_KEY).build();
private static final ReportComponent OTHER_COMPONENT = ReportComponent.builder(Component.Type.FILE, 2).setKey("some other key").build();
private static final int METRIC_ID_2 = 2;
private final Metric metric1 = mock(Metric.class);
private final Metric metric2 = mock(Metric.class);
- private static final long LAST_SNAPSHOT_ID = 123;
- private static final long OTHER_SNAPSHOT_ID = 369;
- private static final String COMPONENT_UUID = "UUID1";
+ private static final String LAST_ANALYSIS_UUID = "u123";
+ private static final String OTHER_ANALYSIS_UUID = "u369";
private static final Measure SOME_MEASURE = Measure.newMeasureBuilder().create("some value");
private static final String SOME_DATA = "some data";
@Test
public void getBaseMeasure_returns_Measure_if_measure_of_last_snapshot_only_in_DB() {
dbTester.prepareDbUnit(getClass(), "shared.xml");
- dbClient.measureDao().insert(dbSession, createMeasureDto(METRIC_ID_1, FILE_COMPONENT.getUuid(), LAST_SNAPSHOT_ID));
- dbClient.measureDao().insert(dbSession, createMeasureDto(METRIC_ID_2, FILE_COMPONENT.getUuid(), OTHER_SNAPSHOT_ID));
+ dbClient.measureDao().insert(dbSession, createMeasureDto(METRIC_ID_1, FILE_COMPONENT.getUuid(), LAST_ANALYSIS_UUID));
+ dbClient.measureDao().insert(dbSession, createMeasureDto(METRIC_ID_2, FILE_COMPONENT.getUuid(), OTHER_ANALYSIS_UUID));
dbSession.commit();
// metric 1 is associated to snapshot with "last=true"
assertThat(rawMeasures.get(METRIC_KEY_2)).containsOnly(Measure.newMeasureBuilder().create("some value"));
}
- private static MeasureDto createMeasureDto(int metricId, String componentUuid, long snapshotId) {
+ private static MeasureDto createMeasureDto(int metricId, String componentUuid, String analysisUuid) {
return new MeasureDto()
.setComponentUuid(componentUuid)
- .setSnapshotId(snapshotId)
- .setAnalysisUuid(AN_ANALYSIS_UUID)
+ .setAnalysisUuid(analysisUuid)
.setData(SOME_DATA)
.setMetricId(metricId);
}
MeasureDto measureDto = underTest.toMeasureDto(measure, metric, SOME_COMPONENT);
assertThat(measureDto.getComponentUuid()).isEqualTo(SOME_COMPONENT.getUuid());
- assertThat(measureDto.getSnapshotId()).isEqualTo(SOME_SNAPSHOT_ID);
+ //assertThat(measureDto.getSnapshotId()).isEqualTo(SOME_SNAPSHOT_ID);
}
@Test
}
private static Period createPeriod(int i) {
- return new Period(i, "mode " + i, null, 100L + i, 952L + i);
+ return new Period(i, "mode " + i, null, 100L + i, String.valueOf(952L + i));
}
}
}
private Period createPeriod(int index) {
- return new Period(index, "don't care", null, 1l, 1l);
+ return new Period(index, "don't care", null, 1l, "U1");
}
}
private static final String SOME_MODE = "mode";
private static final String SOME_MODE_PARAM = "mode_para";
private static final long SOME_SNAPSHOT_DATE = 1000l;
- private static final long SOME_SNAPSHOT_ID = 42l;
+ private static final String SOME_ANALYSIS_UUID = "U1";
@Rule
public ExpectedException expectedException = ExpectedException.none();
@Test
public void test_some_setters_and_getters() {
- Period period = new Period(1, TIMEMACHINE_MODE_VERSION, SOME_MODE_PARAM, SOME_SNAPSHOT_DATE, SOME_SNAPSHOT_ID);
+ Period period = new Period(1, TIMEMACHINE_MODE_VERSION, SOME_MODE_PARAM, SOME_SNAPSHOT_DATE, SOME_ANALYSIS_UUID);
assertThat(period.getMode()).isEqualTo(TIMEMACHINE_MODE_VERSION);
assertThat(period.getModeParameter()).isEqualTo(SOME_MODE_PARAM);
assertThat(period.getIndex()).isEqualTo(1);
assertThat(period.getSnapshotDate()).isEqualTo(SOME_SNAPSHOT_DATE);
- assertThat(period.getSnapshotId()).isEqualTo(SOME_SNAPSHOT_ID);
+ assertThat(period.getAnalysisUuid()).isEqualTo(SOME_ANALYSIS_UUID);
}
@Test
expectedException.expect(IllegalArgumentException.class);
expectedException.expectMessage("Period index (0) must be > 0 and < 6");
- new Period(0, SOME_MODE, SOME_MODE_PARAM, SOME_SNAPSHOT_DATE, SOME_SNAPSHOT_ID);
+ new Period(0, SOME_MODE, SOME_MODE_PARAM, SOME_SNAPSHOT_DATE, SOME_ANALYSIS_UUID);
}
@Test
expectedException.expect(IllegalArgumentException.class);
expectedException.expectMessage("Period index (6) must be > 0 and < 6");
- new Period(6, SOME_MODE, SOME_MODE_PARAM, SOME_SNAPSHOT_DATE, SOME_SNAPSHOT_ID);
+ new Period(6, SOME_MODE, SOME_MODE_PARAM, SOME_SNAPSHOT_DATE, SOME_ANALYSIS_UUID);
}
@Test
expectedException.expect(IllegalArgumentException.class);
expectedException.expectMessage("Period index (-156) must be > 0 and < 6");
- new Period(-156, SOME_MODE, SOME_MODE_PARAM, SOME_SNAPSHOT_DATE, SOME_SNAPSHOT_ID);
+ new Period(-156, SOME_MODE, SOME_MODE_PARAM, SOME_SNAPSHOT_DATE, SOME_ANALYSIS_UUID);
}
@Test
public void verify_to_string() {
- assertThat(new Period(1, TIMEMACHINE_MODE_VERSION, "2.3", 1420034400000L, 10L).toString())
- .isEqualTo("Period{index=1, mode=version, modeParameter=2.3, snapshotDate=1420034400000, snapshotId=10}");
+ assertThat(new Period(1, TIMEMACHINE_MODE_VERSION, "2.3", 1420034400000L, "U10").toString())
+ .isEqualTo("Period{index=1, mode=version, modeParameter=2.3, snapshotDate=1420034400000, analysisUuid=U10}");
}
@Test
public void equals_is_done_on_all_fields() {
- Period period = new Period(1, TIMEMACHINE_MODE_VERSION, "2.3", 1420034400000L, 10L);
+ Period period = new Period(1, TIMEMACHINE_MODE_VERSION, "2.3", 1420034400000L, "U10");
- assertThat(period).isEqualTo(new Period(1, TIMEMACHINE_MODE_VERSION, "2.3", 1420034400000L, 10L));
+ assertThat(period).isEqualTo(new Period(1, TIMEMACHINE_MODE_VERSION, "2.3", 1420034400000L, "U10"));
assertThat(period).isNotEqualTo(null);
assertThat(period).isNotEqualTo("sdsd");
- assertThat(period).isNotEqualTo(new Period(2, TIMEMACHINE_MODE_VERSION, "2.3", 1420034400000L, 10L));
- assertThat(period).isNotEqualTo(new Period(1, TIMEMACHINE_MODE_DAYS, "2.3", 1420034400000L, 10L));
- assertThat(period).isNotEqualTo(new Period(1, TIMEMACHINE_MODE_VERSION, "2.4", 1420034400000L, 10L));
- assertThat(period).isNotEqualTo(new Period(1, TIMEMACHINE_MODE_VERSION, "2.3", 555L, 10L));
- assertThat(period).isNotEqualTo(new Period(1, TIMEMACHINE_MODE_VERSION, "2.3", 1420034400000L, 9632554L));
+ assertThat(period).isNotEqualTo(new Period(2, TIMEMACHINE_MODE_VERSION, "2.3", 1420034400000L, "U10"));
+ assertThat(period).isNotEqualTo(new Period(1, TIMEMACHINE_MODE_DAYS, "2.3", 1420034400000L, "U10"));
+ assertThat(period).isNotEqualTo(new Period(1, TIMEMACHINE_MODE_VERSION, "2.4", 1420034400000L, "U10"));
+ assertThat(period).isNotEqualTo(new Period(1, TIMEMACHINE_MODE_VERSION, "2.3", 555L, "U10"));
+ assertThat(period).isNotEqualTo(new Period(1, TIMEMACHINE_MODE_VERSION, "2.3", 1420034400000L, "9632554"));
}
}
}
private static Period createPeriod(int index) {
- return new Period(index, index + "mode", null, 1000L, 11l);
+ return new Period(index, index + "mode", null, 1000L, "U1");
}
}
private static final String ERROR_THRESHOLD = "error_threshold";
private static final String WARNING_THRESHOLD = "warning_threshold";
private static final String SOME_MODE = "mode";
- private static final long SOME_SNAPSHOT_ID = 1l;
+ private static final String SOME_ANALYSIS_UUID = "u1";
@Rule
public PeriodsHolderRule periodsHolder = new PeriodsHolderRule();
.thenReturn(metricMsg);
Date date = new Date();
- Period period = new Period(periodIndex, SOME_MODE, null, date.getTime(), SOME_SNAPSHOT_ID);
+ Period period = new Period(periodIndex, SOME_MODE, null, date.getTime(), SOME_ANALYSIS_UUID);
periodsHolder.setPeriods(period);
when(periods.label(period.getMode(), period.getModeParameter(), date)).thenReturn(periodLabel);
when(i18n.message(Locale.ENGLISH, "variation", "variation")).thenReturn(variationMsg);
Date date = new Date();
- Period period = new Period(periodIndex, SOME_MODE, null, date.getTime(), SOME_SNAPSHOT_ID);
+ Period period = new Period(periodIndex, SOME_MODE, null, date.getTime(), SOME_ANALYSIS_UUID);
periodsHolder.setPeriods(period);
when(periods.label(period.getMode(), period.getModeParameter(), date)).thenReturn(periodLabel);
private static final long LANGUAGE_1_DEV_COST = 30l;
private static final long PERIOD_2_SNAPSHOT_DATE = 12323l;
private static final long PERIOD_5_SNAPSHOT_DATE = 99999999l;
- private static final long SOME_SNAPSHOT_ID = 9993l;
+ private static final String SOME_ANALYSIS_UUID = "9993l";
private static final String SOME_PERIOD_MODE = "some mode";
private static final int ROOT_REF = 1;
private static final int LANGUAGE_1_FILE_REF = 11111;
long period5 = 50000L;
periodsHolder.setPeriods(
- new Period(1, SOME_PERIOD_MODE, null, period1, SOME_SNAPSHOT_ID),
- new Period(2, SOME_PERIOD_MODE, null, period2, SOME_SNAPSHOT_ID),
- new Period(3, SOME_PERIOD_MODE, null, period3, SOME_SNAPSHOT_ID),
- new Period(4, SOME_PERIOD_MODE, null, period4, SOME_SNAPSHOT_ID),
- new Period(5, SOME_PERIOD_MODE, null, period5, SOME_SNAPSHOT_ID));
+ new Period(1, SOME_PERIOD_MODE, null, period1, SOME_ANALYSIS_UUID),
+ new Period(2, SOME_PERIOD_MODE, null, period2, SOME_ANALYSIS_UUID),
+ new Period(3, SOME_PERIOD_MODE, null, period3, SOME_ANALYSIS_UUID),
+ new Period(4, SOME_PERIOD_MODE, null, period4, SOME_ANALYSIS_UUID),
+ new Period(5, SOME_PERIOD_MODE, null, period5, SOME_ANALYSIS_UUID));
when(ratingSettings.getDevCost(LANGUAGE_1_KEY)).thenReturn(LANGUAGE_1_DEV_COST);
private void setTwoPeriods() {
periodsHolder.setPeriods(
- new Period(2, SOME_PERIOD_MODE, null, PERIOD_2_SNAPSHOT_DATE, SOME_SNAPSHOT_ID),
- new Period(4, SOME_PERIOD_MODE, null, PERIOD_5_SNAPSHOT_DATE, SOME_SNAPSHOT_ID));
+ new Period(2, SOME_PERIOD_MODE, null, PERIOD_2_SNAPSHOT_DATE, SOME_ANALYSIS_UUID),
+ new Period(4, SOME_PERIOD_MODE, null, PERIOD_5_SNAPSHOT_DATE, SOME_ANALYSIS_UUID));
}
}
assertThat(period.getMode()).isEqualTo(TIMEMACHINE_MODE_DATE);
assertThat(period.getModeParameter()).isEqualTo(textDate);
assertThat(period.getSnapshotDate()).isEqualTo(1227358680000L);
- assertThat(period.getSnapshotId()).isEqualTo(1003L);
+ assertThat(period.getAnalysisUuid()).isEqualTo("u1003");
}
@Test
assertThat(period.getMode()).isEqualTo(TIMEMACHINE_MODE_DATE);
assertThat(period.getModeParameter()).isEqualTo(textDate);
assertThat(period.getSnapshotDate()).isEqualTo(1227358680000L);
- assertThat(period.getSnapshotId()).isEqualTo(1003L);
+ assertThat(period.getAnalysisUuid()).isEqualTo("u1003");
assertThat(logTester.logs()).hasSize(1);
assertThat(logTester.logs().get(0)).startsWith("Compare to date 2008-11-22 (analysis of ");
assertThat(period.getMode()).isEqualTo(TIMEMACHINE_MODE_DATE);
assertThat(period.getModeParameter()).isEqualTo(date);
assertThat(period.getSnapshotDate()).isEqualTo(1227934800000L);
- assertThat(period.getSnapshotId()).isEqualTo(1004L);
+ assertThat(period.getAnalysisUuid()).isEqualTo("u1004");
}
@Test
assertThat(period.getMode()).isEqualTo(TIMEMACHINE_MODE_DAYS);
assertThat(period.getModeParameter()).isEqualTo("10");
assertThat(period.getSnapshotDate()).isEqualTo(1227157200000L);
- assertThat(period.getSnapshotId()).isEqualTo(1002L);
+ assertThat(period.getAnalysisUuid()).isEqualTo("u1002");
assertThat(logTester.logs()).hasSize(1);
assertThat(logTester.logs().get(0)).startsWith("Compare over 10 days (2008-11-20, analysis of ");
assertThat(period.getMode()).isEqualTo(TIMEMACHINE_MODE_PREVIOUS_ANALYSIS);
assertThat(period.getModeParameter()).isNotNull();
assertThat(period.getSnapshotDate()).isEqualTo(1227934800000L);
- assertThat(period.getSnapshotId()).isEqualTo(1004L);
+ assertThat(period.getAnalysisUuid()).isEqualTo("u1004");
assertThat(logTester.logs()).hasSize(1);
assertThat(logTester.logs().get(0)).startsWith("Compare to previous analysis (");
assertThat(period.getMode()).isEqualTo(TIMEMACHINE_MODE_PREVIOUS_VERSION);
assertThat(period.getModeParameter()).isEqualTo("1.0");
assertThat(period.getSnapshotDate()).isEqualTo(1226494680000L);
- assertThat(period.getSnapshotId()).isEqualTo(1001L);
+ assertThat(period.getAnalysisUuid()).isEqualTo("u1001");
assertThat(logTester.logs()).hasSize(1);
assertThat(logTester.logs().get(0)).startsWith("Compare to previous version (");
assertThat(period.getMode()).isEqualTo(TIMEMACHINE_MODE_PREVIOUS_VERSION);
assertThat(period.getModeParameter()).isEqualTo("0.9");
assertThat(period.getSnapshotDate()).isEqualTo(1226379600000L);
- assertThat(period.getSnapshotId()).isEqualTo(1000L);
+ assertThat(period.getAnalysisUuid()).isEqualTo("u1000");
}
@Test
assertThat(period.getMode()).isEqualTo(TIMEMACHINE_MODE_PREVIOUS_VERSION);
assertThat(period.getModeParameter()).isNull();
assertThat(period.getSnapshotDate()).isEqualTo(1226379600000L);
- assertThat(period.getSnapshotId()).isEqualTo(1000L);
+ assertThat(period.getAnalysisUuid()).isEqualTo("u1000");
}
@Test
assertThat(period.getMode()).isEqualTo(TIMEMACHINE_MODE_PREVIOUS_VERSION);
assertThat(period.getModeParameter()).isNull();
assertThat(period.getSnapshotDate()).isEqualTo(1226379600000L);
- assertThat(period.getSnapshotId()).isEqualTo(1000L);
+ assertThat(period.getAnalysisUuid()).isEqualTo("u1000");
}
@Test
assertThat(period.getMode()).isEqualTo(TIMEMACHINE_MODE_VERSION);
assertThat(period.getModeParameter()).isEqualTo("0.9");
assertThat(period.getSnapshotDate()).isEqualTo(1226379600000L);
- assertThat(period.getSnapshotId()).isEqualTo(1000L);
+ assertThat(period.getAnalysisUuid()).isEqualTo("u1000");
assertThat(logTester.logs()).hasSize(1);
assertThat(logTester.logs().get(0)).startsWith("Compare to version (0.9) (");
List<Map<String, Object>> dtos = selectSnapshots();
Map<String, Object> dto = dtos.get(0);
- assertThat(dto.get("snapshotId")).isEqualTo(ROOT_SNAPSHOT_ID);
+ assertThat(dto.get("analysisUuid")).isEqualTo(ANALYSIS_UUID);
assertThat(dto.get("componentUuid")).isEqualTo(rootDto.uuid());
assertThat(dto.get("metricId")).isEqualTo((long) stringMetricId);
assertThat(dto.get("value")).isNull();
assertThat(dto.get("severity")).isNull();
dto = dtos.get(1);
- assertThat(dto.get("snapshotId")).isEqualTo(INTERMEDIATE_1_SNAPSHOT_ID);
+ assertThat(dto.get("analysisUuid")).isEqualTo(ANALYSIS_UUID);
assertThat(dto.get("componentUuid")).isEqualTo(intermediate1Dto.uuid());
assertThat(dto.get("metricId")).isEqualTo((long) intMetricId);
assertValue(dto, 12d);
assertThat(dto.get("severity")).isNull();
dto = dtos.get(2);
- assertThat(dto.get("snapshotId")).isEqualTo(INTERMEDIATE_2_SNAPSHOT_ID);
+ assertThat(dto.get("analysisUuid")).isEqualTo(ANALYSIS_UUID);
assertThat(dto.get("componentUuid")).isEqualTo(intermediate2Dto.uuid());
assertThat(dto.get("metricId")).isEqualTo((long) longMetricId);
assertValue(dto, 9635d);
assertThat(dto.get("severity")).isNull();
dto = dtos.get(3);
- assertThat(dto.get("snapshotId")).isEqualTo(LEAF_SNAPSHOT_ID);
+ assertThat(dto.get("analysisUuid")).isEqualTo(ANALYSIS_UUID);
assertThat(dto.get("componentUuid")).isEqualTo(leafDto.uuid());
assertThat(dto.get("metricId")).isEqualTo((long) doubleMetricId);
assertValue(dto, 123.1d);
List<Map<String, Object>> dtos = selectSnapshots();
Map<String, Object> dto = dtos.get(0);
- assertThat(dto.get("snapshotId")).isEqualTo(ROOT_SNAPSHOT_ID);
+ assertThat(dto.get("analysisUuid")).isEqualTo(ANALYSIS_UUID);
assertThat(dto.get("componentUuid")).isEqualTo(rootDto.uuid());
assertThat(dto.get("textValue")).isEqualTo("0=1;2=10");
}
List<Map<String, Object>> dtos = selectSnapshots();
Map<String, Object> dto = dtos.get(0);
- assertThat(dto.get("snapshotId")).isEqualTo(ROOT_SNAPSHOT_ID);
+ assertThat(dto.get("analysisUuid")).isEqualTo(ANALYSIS_UUID);
assertThat(dto.get("componentUuid")).isEqualTo(rootDto.uuid());
assertThat(dto.get("textValue")).isEqualTo("0=1;2=10");
}
List<Map<String, Object>> dtos = selectSnapshots();
Map<String, Object> dto = dtos.get(0);
- assertThat(dto.get("snapshotId")).isEqualTo(ROOT_SNAPSHOT_ID);
+ assertThat(dto.get("analysisUuid")).isEqualTo(ANALYSIS_UUID);
assertThat(dto.get("componentUuid")).isEqualTo(rootDto.uuid());
assertThat(dto.get("textValue")).isEqualTo("0=1;2=10");
}
}
private static Period createPeriod(Integer index) {
- return new Period(index, "mode" + index, null, index, index);
+ return new Period(index, "mode" + index, null, index, String.valueOf(index));
}
private List<Map<String, Object>> selectSnapshots() {
return dbTester
.select(
- "SELECT snapshot_id as \"snapshotId\", component_uuid as \"componentUuid\", metric_id as \"metricId\", person_id as \"developerId\", "
+ "SELECT analysis_uuid as \"analysisUuid\", component_uuid as \"componentUuid\", metric_id as \"metricId\", person_id as \"developerId\", "
+
"value as \"value\", text_value as \"textValue\", " +
"variation_value_1 as \"variation_value_1\", " +
"variation_value_4 as \"variation_value_4\", " +
"variation_value_5 as \"variation_value_5\"" +
"FROM project_measures " +
- "ORDER by snapshot_id asc");
+ "ORDER by id asc");
}
@Override
qualityGateHolder.setQualityGate(new QualityGate(SOME_QG_ID, SOME_QG_NAME, of(fixedCondition, periodCondition)));
Measure measure = newMeasureBuilder()
- .setVariations(newMeasureVariationsBuilder().setVariation(new Period(1, "mode", null, 1212, 121), rawValue).build())
+ .setVariations(newMeasureVariationsBuilder().setVariation(new Period(1, "mode", null, 1212, "u1"), rawValue).build())
.create(rawValue, null);
measureRepository.addRawMeasure(PROJECT_REF, INT_METRIC_1_KEY, measure);
qualityGateHolder.setQualityGate(new QualityGate(SOME_QG_ID, SOME_QG_NAME, of(fixedCondition, periodCondition)));
Measure measure = newMeasureBuilder()
- .setVariations(newMeasureVariationsBuilder().setVariation(new Period(1, "mode", null, 1212, 121), rawValue).build())
+ .setVariations(newMeasureVariationsBuilder().setVariation(new Period(1, "mode", null, 1212, "u1"), rawValue).build())
.create(rawValue, null);
measureRepository.addRawMeasure(PROJECT_REF, INT_METRIC_1_KEY, measure);
import org.sonar.server.computation.period.PeriodsHolderRule;
import static org.assertj.core.api.Assertions.assertThat;
-import static org.sonar.db.component.SnapshotTesting.createForComponent;
import static org.sonar.db.component.SnapshotTesting.newSnapshotForProject;
import static org.sonar.server.computation.measure.Measure.newMeasureBuilder;
private static final Metric FILE_COMPLEXITY_METRIC = new MetricImpl(3, "file_complexity", "file_complexity", Metric.MetricType.FLOAT);
private static final Metric BUILD_BREAKER_METRIC = new MetricImpl(4, "build_breaker", "build_breaker", Metric.MetricType.BOOL);
private static final Metric NEW_DEBT = new MetricImpl(5, "new_debt", "new_debt", Metric.MetricType.WORK_DUR);
- private static final String ANALYSIS_UUID = "a1";
private static final ComponentDto PROJECT_DTO = ComponentTesting.newProjectDto();
private static final int PROJECT_REF = 1;
private static final Component PROJECT = ReportComponent.builder(Component.Type.PROJECT, PROJECT_REF).setUuid(PROJECT_DTO.uuid()).build();
public void do_nothing_when_no_raw_measure() {
SnapshotDto period1ProjectSnapshot = newSnapshotForProject(PROJECT_DTO);
dbClient.snapshotDao().insert(session, period1ProjectSnapshot);
- dbClient.measureDao().insert(session, newMeasureDto(ISSUES_METRIC.getId(), PROJECT_DTO.uuid(), period1ProjectSnapshot.getId(), 60d));
+ dbClient.measureDao().insert(session, newMeasureDto(ISSUES_METRIC.getId(), PROJECT_DTO.uuid(), period1ProjectSnapshot.getUuid(), 60d));
session.commit();
periodsHolder.setPeriods(newPeriod(1, period1ProjectSnapshot));
@Test
public void set_variation() {
// Project
- SnapshotDto period1ProjectSnapshot = newSnapshotForProject(PROJECT_DTO);
- dbClient.snapshotDao().insert(session, period1ProjectSnapshot);
- dbClient.measureDao().insert(session, newMeasureDto(ISSUES_METRIC.getId(), PROJECT_DTO.uuid(), period1ProjectSnapshot.getId(), 60d));
+ SnapshotDto period1Snapshot = newSnapshotForProject(PROJECT_DTO);
+ dbClient.snapshotDao().insert(session, period1Snapshot);
+ dbClient.measureDao().insert(session, newMeasureDto(ISSUES_METRIC.getId(), PROJECT_DTO.uuid(), period1Snapshot.getUuid(), 60d));
// Directory
ComponentDto directoryDto = ComponentTesting.newDirectory(PROJECT_DTO, "dir");
dbClient.componentDao().insert(session, directoryDto);
- SnapshotDto period1DirectorySnapshot = createForComponent(directoryDto, period1ProjectSnapshot);
- dbClient.snapshotDao().insert(session, period1DirectorySnapshot);
- dbClient.measureDao().insert(session, newMeasureDto(ISSUES_METRIC.getId(), directoryDto.uuid(), period1DirectorySnapshot.getId(), 10d));
+ dbClient.measureDao().insert(session, newMeasureDto(ISSUES_METRIC.getId(), directoryDto.uuid(), period1Snapshot.getUuid(), 10d));
session.commit();
- periodsHolder.setPeriods(newPeriod(1, period1ProjectSnapshot));
+ periodsHolder.setPeriods(newPeriod(1, period1Snapshot));
Component directory = ReportComponent.builder(Component.Type.DIRECTORY, 2).setUuid(directoryDto.uuid()).build();
Component project = ReportComponent.builder(Component.Type.PROJECT, 1).setUuid(PROJECT_DTO.uuid()).addChildren(directory).build();
@Test
public void set_zero_variation_when_no_change() {
// Project
- SnapshotDto period1ProjectSnapshot = newSnapshotForProject(PROJECT_DTO);
- dbClient.snapshotDao().insert(session, period1ProjectSnapshot);
- dbClient.measureDao().insert(session, newMeasureDto(ISSUES_METRIC.getId(), PROJECT_DTO.uuid(), period1ProjectSnapshot.getId(), 60d));
+ SnapshotDto period1Snapshot = newSnapshotForProject(PROJECT_DTO);
+ dbClient.snapshotDao().insert(session, period1Snapshot);
+ dbClient.measureDao().insert(session, newMeasureDto(ISSUES_METRIC.getId(), PROJECT_DTO.uuid(), period1Snapshot.getUuid(), 60d));
// Directory
ComponentDto directoryDto = ComponentTesting.newDirectory(PROJECT_DTO, "dir");
dbClient.componentDao().insert(session, directoryDto);
- SnapshotDto period1DirectorySnapshot = createForComponent(directoryDto, period1ProjectSnapshot);
- dbClient.snapshotDao().insert(session, period1DirectorySnapshot);
- dbClient.measureDao().insert(session, newMeasureDto(ISSUES_METRIC.getId(), directoryDto.uuid(), period1DirectorySnapshot.getId(), 10d));
+ dbClient.measureDao().insert(session, newMeasureDto(ISSUES_METRIC.getId(), directoryDto.uuid(), period1Snapshot.getUuid(), 10d));
session.commit();
- periodsHolder.setPeriods(newPeriod(1, period1ProjectSnapshot));
+ periodsHolder.setPeriods(newPeriod(1, period1Snapshot));
Component directory = ReportComponent.builder(Component.Type.DIRECTORY, 2).setUuid(directoryDto.uuid()).build();
Component project = ReportComponent.builder(Component.Type.PROJECT, 1).setUuid(PROJECT_DTO.uuid()).addChildren(directory).build();
SnapshotDto currentProjectSnapshot = newSnapshotForProject(PROJECT_DTO).setCreatedAt(2000_000_000L);
dbClient.snapshotDao().insert(session, past1ProjectSnapshot);
dbClient.snapshotDao().insert(session, currentProjectSnapshot);
- dbClient.measureDao().insert(session, newMeasureDto(ISSUES_METRIC.getId(), PROJECT_DTO.uuid(), past1ProjectSnapshot.getId(), 60d));
- dbClient.measureDao().insert(session, newMeasureDto(ISSUES_METRIC.getId(), PROJECT_DTO.uuid(), currentProjectSnapshot.getId(), 60d));
+ dbClient.measureDao().insert(session, newMeasureDto(ISSUES_METRIC.getId(), PROJECT_DTO.uuid(), past1ProjectSnapshot.getUuid(), 60d));
+ dbClient.measureDao().insert(session, newMeasureDto(ISSUES_METRIC.getId(), PROJECT_DTO.uuid(), currentProjectSnapshot.getUuid(), 60d));
session.commit();
periodsHolder.setPeriods(newPeriod(1, past1ProjectSnapshot));
dbClient.snapshotDao().insert(session, period1ProjectSnapshot, period2ProjectSnapshot, period3ProjectSnapshot, period4ProjectSnapshot, period5ProjectSnapshot);
dbClient.measureDao().insert(session,
- newMeasureDto(ISSUES_METRIC.getId(), PROJECT_DTO.uuid(), period1ProjectSnapshot.getId(), 0d),
- newMeasureDto(ISSUES_METRIC.getId(), PROJECT_DTO.uuid(), period2ProjectSnapshot.getId(), 20d),
- newMeasureDto(ISSUES_METRIC.getId(), PROJECT_DTO.uuid(), period3ProjectSnapshot.getId(), 40d),
- newMeasureDto(ISSUES_METRIC.getId(), PROJECT_DTO.uuid(), period4ProjectSnapshot.getId(), 80d),
- newMeasureDto(ISSUES_METRIC.getId(), PROJECT_DTO.uuid(), period5ProjectSnapshot.getId(), 100d));
+ newMeasureDto(ISSUES_METRIC.getId(), PROJECT_DTO.uuid(), period1ProjectSnapshot.getUuid(), 0d),
+ newMeasureDto(ISSUES_METRIC.getId(), PROJECT_DTO.uuid(), period2ProjectSnapshot.getUuid(), 20d),
+ newMeasureDto(ISSUES_METRIC.getId(), PROJECT_DTO.uuid(), period3ProjectSnapshot.getUuid(), 40d),
+ newMeasureDto(ISSUES_METRIC.getId(), PROJECT_DTO.uuid(), period4ProjectSnapshot.getUuid(), 80d),
+ newMeasureDto(ISSUES_METRIC.getId(), PROJECT_DTO.uuid(), period5ProjectSnapshot.getUuid(), 100d));
session.commit();
periodsHolder.setPeriods(newPeriod(1, period1ProjectSnapshot),
SnapshotDto period1ProjectSnapshot = newSnapshotForProject(PROJECT_DTO);
dbClient.snapshotDao().insert(session, period1ProjectSnapshot);
dbClient.measureDao().insert(session,
- newMeasureDto(ISSUES_METRIC.getId(), PROJECT_DTO.uuid(), period1ProjectSnapshot.getId(), 60d),
- newMeasureDto(DEBT_METRIC.getId(), PROJECT_DTO.uuid(), period1ProjectSnapshot.getId(), 10d),
- newMeasureDto(FILE_COMPLEXITY_METRIC.getId(), PROJECT_DTO.uuid(), period1ProjectSnapshot.getId(), 2d),
- newMeasureDto(BUILD_BREAKER_METRIC.getId(), PROJECT_DTO.uuid(), period1ProjectSnapshot.getId(), 1d));
+ newMeasureDto(ISSUES_METRIC.getId(), PROJECT_DTO.uuid(), period1ProjectSnapshot.getUuid(), 60d),
+ newMeasureDto(DEBT_METRIC.getId(), PROJECT_DTO.uuid(), period1ProjectSnapshot.getUuid(), 10d),
+ newMeasureDto(FILE_COMPLEXITY_METRIC.getId(), PROJECT_DTO.uuid(), period1ProjectSnapshot.getUuid(), 2d),
+ newMeasureDto(BUILD_BREAKER_METRIC.getId(), PROJECT_DTO.uuid(), period1ProjectSnapshot.getUuid(), 1d));
session.commit();
periodsHolder.setPeriods(newPeriod(1, period1ProjectSnapshot));
SnapshotDto period1ProjectSnapshot = newSnapshotForProject(PROJECT_DTO);
dbClient.snapshotDao().insert(session, period1ProjectSnapshot);
dbClient.measureDao().insert(session,
- newMeasureDto(ISSUES_METRIC.getId(), PROJECT_DTO.uuid(), period1ProjectSnapshot.getId(), 60d));
+ newMeasureDto(ISSUES_METRIC.getId(), PROJECT_DTO.uuid(), period1ProjectSnapshot.getUuid(), 60d));
session.commit();
periodsHolder.setPeriods(newPeriod(1, period1ProjectSnapshot));
public void does_not_update_existing_variations() throws Exception {
SnapshotDto period1ProjectSnapshot = newSnapshotForProject(PROJECT_DTO);
dbClient.snapshotDao().insert(session, period1ProjectSnapshot);
- dbClient.measureDao().insert(session, newMeasureDto(NEW_DEBT.getId(), PROJECT_DTO.uuid(), period1ProjectSnapshot.getId(), 60d));
+ dbClient.measureDao().insert(session, newMeasureDto(NEW_DEBT.getId(), PROJECT_DTO.uuid(), period1ProjectSnapshot.getUuid(), 60d));
session.commit();
periodsHolder.setPeriods(newPeriod(1, period1ProjectSnapshot));
treeRootHolder.setRoot(PROJECT);
assertThat(measureRepository.getRawMeasure(PROJECT, NEW_DEBT).get().getVariations().getVariation1()).isEqualTo(10d);
}
- private static MeasureDto newMeasureDto(int metricId, String componentUuid, long snapshotId, double value) {
+ private static MeasureDto newMeasureDto(int metricId, String componentUuid, String analysisUuid, double value) {
return new MeasureDto()
.setMetricId(metricId)
.setComponentUuid(componentUuid)
- .setSnapshotId(snapshotId)
- .setAnalysisUuid(ANALYSIS_UUID)
+ .setAnalysisUuid(analysisUuid)
.setValue(value);
}
private static Period newPeriod(int index, SnapshotDto snapshotDto) {
- return new Period(index, "mode", null, snapshotDto.getCreatedAt(), snapshotDto.getId());
+ return new Period(index, "mode", null, snapshotDto.getCreatedAt(), snapshotDto.getUuid());
}
private void addRawMeasure(Component component, Metric metric, Measure measure) {
@Before
public void setUp() {
periodsHolder.setPeriods(
- new Period(2, "mode_p_1", null, parseDate("2009-12-25").getTime(), 1),
- new Period(5, "mode_p_5", null, parseDate("2011-02-18").getTime(), 2));
+ new Period(2, "mode_p_1", null, parseDate("2009-12-25").getTime(), "u1"),
+ new Period(5, "mode_p_5", null, parseDate("2011-02-18").getTime(), "u2"));
}
@Test
private static Measure createMeasure(@Nullable Double variationPeriod2, @Nullable Double variationPeriod5) {
MeasureVariations.Builder variationBuilder = newMeasureVariationsBuilder();
if (variationPeriod2 != null) {
- variationBuilder.setVariation(new Period(2, "", null, 1L, 2L), variationPeriod2);
+ variationBuilder.setVariation(new Period(2, "", null, 1L, "u2"), variationPeriod2);
}
if (variationPeriod5 != null) {
- variationBuilder.setVariation(new Period(5, "", null, 1L, 2L), variationPeriod5);
+ variationBuilder.setVariation(new Period(5, "", null, 1L, "u2"), variationPeriod5);
}
return newMeasureBuilder()
.setVariations(variationBuilder.build())
SnapshotDto snapshotDto = SnapshotTesting.newSnapshotForProject(projectDto).setCreatedAt(DateUtils.parseDateQuietly("2015-01-01").getTime());
dbClient.snapshotDao().insert(dbTester.getSession(), snapshotDto);
dbTester.getSession().commit();
- periodsHolder.setPeriods(new Period(1, TIMEMACHINE_MODE_DATE, "2015-01-01", analysisDate, 123L));
+ periodsHolder.setPeriods(new Period(1, TIMEMACHINE_MODE_DATE, "2015-01-01", analysisDate, "u1"));
Component project = ReportComponent.builder(Component.Type.PROJECT, 1).setUuid("ABCD").setKey(PROJECT_KEY).build();
treeRootHolder.setRoot(project);
@Test
public void only_persist_snapshots_with_periods_on_project_and_module() {
- periodsHolder.setPeriods(new Period(1, TIMEMACHINE_MODE_PREVIOUS_ANALYSIS, null, analysisDate, 123L));
+ periodsHolder.setPeriods(new Period(1, TIMEMACHINE_MODE_PREVIOUS_ANALYSIS, null, analysisDate, "u1"));
ComponentDto projectDto = ComponentTesting.newProjectDto("ABCD").setKey(PROJECT_KEY).setName("Project");
dbClient.componentDao().insert(dbTester.getSession(), projectDto);
import org.sonar.server.computation.period.PeriodsHolderRule;
import static org.assertj.core.api.Assertions.assertThat;
-import static org.sonar.db.component.SnapshotTesting.createForComponent;
import static org.sonar.db.component.SnapshotTesting.newSnapshotForProject;
import static org.sonar.db.component.SnapshotTesting.newSnapshotForView;
private static final Metric BUILD_BREAKER_METRIC = new MetricImpl(4, "build_breaker", "build_breaker", Metric.MetricType.BOOL);
private static final ComponentDto VIEW_DTO = ComponentTesting.newView();
private static final Component VIEW = ViewsComponent.builder(Component.Type.VIEW, 1).setUuid(VIEW_DTO.uuid()).build();
- private static final String ANALYSIS_UUID = "a1";
@Rule
public DbTester dbTester = DbTester.create(System2.INSTANCE);
public void do_nothing_when_no_raw_measure() {
SnapshotDto period1ViewSnapshot = newSnapshotForView(VIEW_DTO);
dbClient.snapshotDao().insert(session, period1ViewSnapshot);
- dbClient.measureDao().insert(session, newMeasureDto(ISSUES_METRIC.getId(), VIEW_DTO.uuid(), period1ViewSnapshot.getId(), 60d));
+ dbClient.measureDao().insert(session, newMeasureDto(ISSUES_METRIC.getId(), VIEW_DTO.uuid(), period1ViewSnapshot.getUuid(), 60d));
session.commit();
periodsHolder.setPeriods(newPeriod(1, period1ViewSnapshot));
@Test
public void set_variation() {
// View
- SnapshotDto period1ViewSnapshot = newSnapshotForView(VIEW_DTO);
- dbClient.snapshotDao().insert(session, period1ViewSnapshot);
- dbClient.measureDao().insert(session, newMeasureDto(ISSUES_METRIC.getId(), VIEW_DTO.uuid(), period1ViewSnapshot.getId(), 60d));
+ SnapshotDto period1Snapshot = newSnapshotForView(VIEW_DTO);
+ dbClient.snapshotDao().insert(session, period1Snapshot);
+ dbClient.measureDao().insert(session, newMeasureDto(ISSUES_METRIC.getId(), VIEW_DTO.uuid(), period1Snapshot.getUuid(), 60d));
// SubView
ComponentDto subviewDto = ComponentTesting.newSubView(VIEW_DTO, "dir", "key");
dbClient.componentDao().insert(session, subviewDto);
- SnapshotDto period1SubviewSnapshot = createForComponent(subviewDto, period1ViewSnapshot);
- dbClient.snapshotDao().insert(session, period1SubviewSnapshot);
- dbClient.measureDao().insert(session, newMeasureDto(ISSUES_METRIC.getId(), subviewDto.uuid(), period1SubviewSnapshot.getId(), 10d));
+ dbClient.measureDao().insert(session, newMeasureDto(ISSUES_METRIC.getId(), subviewDto.uuid(), period1Snapshot.getUuid(), 10d));
session.commit();
- periodsHolder.setPeriods(newPeriod(1, period1ViewSnapshot));
+ periodsHolder.setPeriods(newPeriod(1, period1Snapshot));
Component subview = ViewsComponent.builder(Component.Type.SUBVIEW, 2).setUuid(subviewDto.uuid()).build();
Component view = ViewsComponent.builder(Component.Type.VIEW, 1).setUuid(VIEW_DTO.uuid()).addChildren(subview).build();
dbClient.snapshotDao().insert(session, period1ViewSnapshot, period2ViewSnapshot, period3ViewSnapshot, period4ViewSnapshot, period5ViewSnapshot);
dbClient.measureDao().insert(session,
- newMeasureDto(ISSUES_METRIC.getId(), VIEW_DTO.uuid(), period1ViewSnapshot.getId(), 0d),
- newMeasureDto(ISSUES_METRIC.getId(), VIEW_DTO.uuid(), period2ViewSnapshot.getId(), 20d),
- newMeasureDto(ISSUES_METRIC.getId(), VIEW_DTO.uuid(), period3ViewSnapshot.getId(), 40d),
- newMeasureDto(ISSUES_METRIC.getId(), VIEW_DTO.uuid(), period4ViewSnapshot.getId(), 80d),
- newMeasureDto(ISSUES_METRIC.getId(), VIEW_DTO.uuid(), period5ViewSnapshot.getId(), 100d));
+ newMeasureDto(ISSUES_METRIC.getId(), VIEW_DTO.uuid(), period1ViewSnapshot.getUuid(), 0d),
+ newMeasureDto(ISSUES_METRIC.getId(), VIEW_DTO.uuid(), period2ViewSnapshot.getUuid(), 20d),
+ newMeasureDto(ISSUES_METRIC.getId(), VIEW_DTO.uuid(), period3ViewSnapshot.getUuid(), 40d),
+ newMeasureDto(ISSUES_METRIC.getId(), VIEW_DTO.uuid(), period4ViewSnapshot.getUuid(), 80d),
+ newMeasureDto(ISSUES_METRIC.getId(), VIEW_DTO.uuid(), period5ViewSnapshot.getUuid(), 100d));
session.commit();
periodsHolder.setPeriods(newPeriod(1, period1ViewSnapshot),
SnapshotDto period1ViewSnapshot = newSnapshotForProject(VIEW_DTO);
dbClient.snapshotDao().insert(session, period1ViewSnapshot);
dbClient.measureDao().insert(session,
- newMeasureDto(ISSUES_METRIC.getId(), VIEW_DTO.uuid(), period1ViewSnapshot.getId(), 60d),
- newMeasureDto(DEBT_METRIC.getId(), VIEW_DTO.uuid(), period1ViewSnapshot.getId(), 10d),
- newMeasureDto(FILE_COMPLEXITY_METRIC.getId(), VIEW_DTO.uuid(), period1ViewSnapshot.getId(), 2d),
- newMeasureDto(BUILD_BREAKER_METRIC.getId(), VIEW_DTO.uuid(), period1ViewSnapshot.getId(), 1d)
+ newMeasureDto(ISSUES_METRIC.getId(), VIEW_DTO.uuid(), period1ViewSnapshot.getUuid(), 60d),
+ newMeasureDto(DEBT_METRIC.getId(), VIEW_DTO.uuid(), period1ViewSnapshot.getUuid(), 10d),
+ newMeasureDto(FILE_COMPLEXITY_METRIC.getId(), VIEW_DTO.uuid(), period1ViewSnapshot.getUuid(), 2d),
+ newMeasureDto(BUILD_BREAKER_METRIC.getId(), VIEW_DTO.uuid(), period1ViewSnapshot.getUuid(), 1d)
);
session.commit();
assertThat(measureRepository.getRawMeasure(VIEW, BUILD_BREAKER_METRIC).get().getVariations().getVariation1()).isEqualTo(-1d);
}
- private static MeasureDto newMeasureDto(int metricId, String componentUuid, long snapshotId, double value) {
+ private static MeasureDto newMeasureDto(int metricId, String componentUuid, String analysisUuid, double value) {
return new MeasureDto()
.setMetricId(metricId)
.setComponentUuid(componentUuid)
- .setSnapshotId(snapshotId)
- .setAnalysisUuid(ANALYSIS_UUID)
+ .setAnalysisUuid(analysisUuid)
.setValue(value);
}
private static Period newPeriod(int index, SnapshotDto snapshotDto) {
- return new Period(index, "mode", null, snapshotDto.getCreatedAt(), snapshotDto.getId());
+ return new Period(index, "mode", null, snapshotDto.getCreatedAt(), snapshotDto.getUuid());
}
private void addRawMeasure(Component component, Metric metric, Measure measure) {
@Before
public void setUp() {
periodsHolder.setPeriods(
- new Period(2, "mode_p_1", null, parseDate("2009-12-25").getTime(), 1),
- new Period(5, "mode_p_5", null, parseDate("2011-02-18").getTime(), 2));
+ new Period(2, "mode_p_1", null, parseDate("2009-12-25").getTime(), "U1"),
+ new Period(5, "mode_p_5", null, parseDate("2011-02-18").getTime(), "U2"));
}
@Test
private static Measure createMeasure(@Nullable Double variationPeriod2, @Nullable Double variationPeriod5) {
MeasureVariations.Builder variationBuilder = newMeasureVariationsBuilder();
if (variationPeriod2 != null) {
- variationBuilder.setVariation(new Period(2, "", null, 1L, 2L), variationPeriod2);
+ variationBuilder.setVariation(new Period(2, "", null, 1L, "U2"), variationPeriod2);
}
if (variationPeriod5 != null) {
- variationBuilder.setVariation(new Period(5, "", null, 1L, 2L), variationPeriod5);
+ variationBuilder.setVariation(new Period(5, "", null, 1L, "U2"), variationPeriod5);
}
return newMeasureBuilder()
.setVariations(variationBuilder.build())
dbIdsRepository.setComponentId(view, viewDto.getId());
dbIdsRepository.setComponentId(subView, subViewDto.getId());
- periodsHolder.setPeriods(new Period(1, TIMEMACHINE_MODE_DATE, "2015-01-01", analysisDate, 123L));
+ periodsHolder.setPeriods(new Period(1, TIMEMACHINE_MODE_DATE, "2015-01-01", analysisDate, "u1"));
underTest.execute();
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;
-import org.sonar.api.measures.CoreMetrics;
import org.sonar.api.utils.text.JsonWriter;
import org.sonar.api.web.UserRole;
import org.sonar.db.DbClient;
import org.sonar.db.component.ComponentDto;
import org.sonar.db.measure.MeasureDao;
import org.sonar.db.measure.MeasureDto;
+import org.sonar.db.measure.MeasureQuery;
import org.sonar.server.component.ComponentFinder;
import org.sonar.server.exceptions.NotFoundException;
import org.sonar.server.tester.UserSessionRule;
when(componentDao.selectByKey(session, componentKey)).thenReturn(Optional.of(componentDto));
String data = "{duplications}";
- when(measureDao.selectByComponentKeyAndMetricKey(session, componentKey, CoreMetrics.DUPLICATIONS_DATA_KEY)).thenReturn(
- new MeasureDto().setMetricKey(CoreMetrics.DUPLICATIONS_DATA_KEY).setData("{duplications}")
+ when(measureDao.selectSingle(eq(session), any(MeasureQuery.class))).thenReturn(
+ java.util.Optional.of(new MeasureDto().setData("{duplications}"))
);
List<DuplicationsParser.Block> blocks = newArrayList(new DuplicationsParser.Block(newArrayList(new DuplicationsParser.Duplication(componentDto, 1, 2))));
when(componentDao.selectByUuid(session, uuid)).thenReturn(Optional.of(componentDto));
String data = "{duplications}";
- when(measureDao.selectByComponentKeyAndMetricKey(session, componentKey, CoreMetrics.DUPLICATIONS_DATA_KEY)).thenReturn(
- new MeasureDto().setMetricKey(CoreMetrics.DUPLICATIONS_DATA_KEY).setData("{duplications}")
+ when(measureDao.selectSingle(eq(session), any(MeasureQuery.class))).thenReturn(
+ java.util.Optional.of(new MeasureDto().setData("{duplications}"))
);
List<DuplicationsParser.Block> blocks = newArrayList(new DuplicationsParser.Block(newArrayList(new DuplicationsParser.Duplication(componentDto, 1, 2))));
ComponentDto componentDto = new ComponentDto().setId(10L).setKey(componentKey);
when(componentDao.selectByKey(session, componentKey)).thenReturn(Optional.of(componentDto));
- when(measureDao.selectByComponentKeyAndMetricKey(session, componentKey, CoreMetrics.DUPLICATIONS_DATA_KEY)).thenReturn(null);
+ when(measureDao.selectSingle(eq(session), any(MeasureQuery.class))).thenReturn(java.util.Optional.empty());
WsTester.TestRequest request = tester.newGetRequest("api/duplications", "show").setParam("key", componentKey);
request.execute();
- verify(duplicationsJsonWriter).write(eq(Lists.<DuplicationsParser.Block>newArrayList()), any(JsonWriter.class), eq(session));
+ verify(duplicationsJsonWriter).write(eq(Lists.newArrayList()), any(JsonWriter.class), eq(session));
}
@Test(expected = NotFoundException.class)
public void fail_when_file_not_found() throws Exception {
String componentKey = "src/Foo.java";
- when(componentDao.selectByKey(session, componentKey)).thenReturn(Optional.<ComponentDto>absent());
+ when(componentDao.selectByKey(session, componentKey)).thenReturn(Optional.absent());
WsTester.TestRequest request = tester.newGetRequest("api/duplications", "show").setParam("key", componentKey);
request.execute();
@Override
public String formatDouble(Locale locale, Double value) {
- throw new UnsupportedOperationException();
+ return String.valueOf(value);
}
@Override
public String formatInteger(Locale locale, Integer value) {
- throw new UnsupportedOperationException();
+ return String.valueOf(value);
}
}
assertThat(condition.textValue()).isNull();
assertThat(condition.appendSqlColumn(new StringBuilder(), 1).toString()).isEqualTo("pmcond1.value");
assertThat(condition.toString()).isNotEmpty();
- assertThat(condition.appendSqlCondition(new StringBuilder(), 1).toString()).isEqualTo(" pmcond1.metric_id=123 AND pmcond1.value > 10.0 AND pmcond1.person_id IS NULL ");
+ assertThat(condition.appendSqlCondition(new StringBuilder(), 1).toString()).isEqualTo(" pmcond1.metric_id=123 and pmcond1.value > 10.0 and pmcond1.person_id is null ");
}
@Test
assertThat(condition.appendSqlColumn(new StringBuilder(), 2).toString()).isEqualTo("pmcond2.variation_value_3");
assertThat(condition.toString()).isNotEmpty();
assertThat(condition.appendSqlCondition(new StringBuilder(), 2).toString())
- .isEqualTo(" pmcond2.metric_id=123 AND pmcond2.variation_value_3 <= 10.0 AND pmcond2.person_id IS NULL ");
+ .isEqualTo(" pmcond2.metric_id=123 and pmcond2.variation_value_3 <= 10.0 and pmcond2.person_id is null ");
}
@Test
assertThat(condition.textValue()).isEqualTo("\"foo\"");
assertThat(condition.appendSqlColumn(new StringBuilder(), 1).toString()).isEqualTo("pmcond1.text_value");
assertThat(condition.toString()).isNotEmpty();
- assertThat(condition.appendSqlCondition(new StringBuilder(), 1).toString()).isEqualTo(" pmcond1.metric_id=123 AND pmcond1.text_value = \"foo\" AND pmcond1.person_id IS NULL ");
+ assertThat(condition.appendSqlCondition(new StringBuilder(), 1).toString()).isEqualTo(" pmcond1.metric_id=123 and pmcond1.text_value = \"foo\" and pmcond1.person_id is null ");
}
}
*/
package org.sonar.server.measure;
-import static com.google.common.collect.Lists.newArrayList;
-import static org.assertj.core.api.Assertions.assertThat;
-
import java.sql.SQLException;
-import java.util.Arrays;
import java.util.Date;
import java.util.List;
import org.junit.Before;
import org.sonar.api.utils.DateUtils;
import org.sonar.api.utils.System2;
import org.sonar.db.DbTester;
-import org.sonar.db.component.ResourceDao;
-import org.sonar.db.component.SnapshotDto;
+import org.sonar.db.component.ComponentDao;
+import org.sonar.db.component.ComponentDto;
+
+import static com.google.common.collect.Lists.newArrayList;
+import static java.util.Arrays.asList;
+import static org.assertj.core.api.Assertions.assertThat;
public class MeasureFilterExecutorTest {
- private static final long JAVA_PROJECT_ID = 1L;
- private static final long JAVA_FILE_BIG_ID = 3L;
- private static final long JAVA_FILE_TINY_ID = 4L;
private static final String JAVA_PROJECT_UUID = "UUID_JAVA_PROJECT";
- private static final long JAVA_PROJECT_SNAPSHOT_ID = 101L;
- private static final long JAVA_FILE_BIG_SNAPSHOT_ID = 103L;
- private static final long JAVA_FILE_TINY_SNAPSHOT_ID = 104L;
- private static final long JAVA_PACKAGE_SNAPSHOT_ID = 102L;
- private static final long PHP_PROJECT_ID = 10L;
+ private static final String JAVA_BIG_FILE_UUID = "UUID_JAVA_BIG_FILE";
+ private static final String JAVA_TINY_FILE_UUID = "UUID_JAVA_TINY_FILE";
+ private static final String JAVA_DIR_UUID = "UUID_JAVA_DIR";
private static final String PHP_PROJECT_UUID = "UUID_PHP_PROJECT";
- private static final long PHP_SNAPSHOT_ID = 110L;
private static final Metric METRIC_LINES = new Metric.Builder("lines", "Lines", Metric.ValueType.INT).create().setId(1);
private static final Metric METRIC_PROFILE = new Metric.Builder("profile", "Profile", Metric.ValueType.STRING).create().setId(2);
private static final Metric METRIC_COVERAGE = new Metric.Builder("coverage", "Coverage", Metric.ValueType.FLOAT).create().setId(3);
@Before
public void before() {
- executor = new MeasureFilterExecutor(db.myBatis(), db.database(), new ResourceDao(db.myBatis(), System2.INSTANCE));
+ executor = new MeasureFilterExecutor(db.myBatis(), db.database(), new ComponentDao());
}
@Test
}
@Test
- public void filter_is_not_valid_if_missing_base_snapshot() {
+ public void filter_is_not_valid_if_missing_base_component() {
db.prepareDbUnit(getClass(), "shared.xml");
MeasureFilterContext context = new MeasureFilterContext();
- MeasureFilter filter = new MeasureFilter().setResourceQualifiers(Arrays.asList("TRK")).setOnBaseResourceChildren(true);
+ MeasureFilter filter = new MeasureFilter().setResourceQualifiers(asList("TRK")).setOnBaseResourceChildren(true);
assertThat(MeasureFilterExecutor.isValid(filter, context)).isFalse();
- context.setBaseSnapshot(new SnapshotDto().setId(123L));
+ context.setBaseComponent(new ComponentDto().setId(123L));
assertThat(MeasureFilterExecutor.isValid(filter, context)).isTrue();
}
public void filter_is_not_valid_if_anonymous_favourites() {
db.prepareDbUnit(getClass(), "shared.xml");
MeasureFilterContext context = new MeasureFilterContext();
- MeasureFilter filter = new MeasureFilter().setResourceQualifiers(Arrays.asList("TRK")).setUserFavourites(true);
+ MeasureFilter filter = new MeasureFilter().setResourceQualifiers(asList("TRK")).setUserFavourites(true);
assertThat(MeasureFilterExecutor.isValid(filter, context)).isFalse();
context.setUserId(123L);
@Test
public void projects_without_measure_conditions() throws SQLException {
db.prepareDbUnit(getClass(), "shared.xml");
- MeasureFilter filter = new MeasureFilter().setResourceQualifiers(Arrays.asList("TRK")).setSortOn(MeasureFilterSort.Field.DATE);
+ MeasureFilter filter = new MeasureFilter().setResourceQualifiers(asList("TRK")).setSortOn(MeasureFilterSort.Field.DATE);
List<MeasureFilterRow> rows = executor.execute(filter, new MeasureFilterContext());
assertThat(rows).hasSize(2);
public void should_prevent_sql_injection_through_parameters() throws SQLException {
db.prepareDbUnit(getClass(), "shared.xml");
MeasureFilter filter = new MeasureFilter()
- .setResourceQualifiers(Arrays.asList("'"))
+ .setResourceQualifiers(asList("'"))
.setBaseResourceKey("'")
.setResourceKey("'")
.setResourceName("'")
.setResourceName("'")
- .setResourceScopes(Arrays.asList("'"));
+ .setResourceScopes(asList("'"));
List<MeasureFilterRow> rows = executor.execute(filter, new MeasureFilterContext());
// an exception would be thrown if SQL is not valid
assertThat(rows).isEmpty();
@Test
public void test_default_sort() {
db.prepareDbUnit(getClass(), "shared.xml");
- MeasureFilter filter = new MeasureFilter().setResourceQualifiers(Arrays.asList("CLA"));
+ MeasureFilter filter = new MeasureFilter().setResourceQualifiers(asList("FIL"));
assertThat(filter.sort().isAsc()).isTrue();
assertThat(filter.sort().field()).isEqualTo(MeasureFilterSort.Field.NAME);
@Test
public void sort_by_ascending_resource_name() throws SQLException {
db.prepareDbUnit(getClass(), "shared.xml");
- MeasureFilter filter = new MeasureFilter().setResourceQualifiers(Arrays.asList("CLA")).setSortAsc(true);
+ MeasureFilter filter = new MeasureFilter().setResourceQualifiers(asList("FIL")).setSortAsc(true);
List<MeasureFilterRow> rows = executor.execute(filter, new MeasureFilterContext());
// Big -> Tiny
@Test
public void sort_by_ascending_resource_key() throws SQLException {
db.prepareDbUnit(getClass(), "shared.xml");
- MeasureFilter filter = new MeasureFilter().setResourceQualifiers(Arrays.asList("CLA")).setSortAsc(true).setSortOn(MeasureFilterSort.Field.KEY);
+ MeasureFilter filter = new MeasureFilter().setResourceQualifiers(asList("FIL")).setSortAsc(true).setSortOn(MeasureFilterSort.Field.KEY);
List<MeasureFilterRow> rows = executor.execute(filter, new MeasureFilterContext());
// Big -> Tiny
@Test
public void sort_by_ascending_resource_version() throws SQLException {
db.prepareDbUnit(getClass(), "shared.xml");
- MeasureFilter filter = new MeasureFilter().setResourceQualifiers(Arrays.asList("TRK")).setSortAsc(true).setSortOn(MeasureFilterSort.Field.VERSION);
+ MeasureFilter filter = new MeasureFilter().setResourceQualifiers(asList("TRK")).setSortAsc(true).setSortOn(MeasureFilterSort.Field.VERSION);
List<MeasureFilterRow> rows = executor.execute(filter, new MeasureFilterContext());
// Java Project 1.0 then Php Project 3.0
@Test
public void sort_by_descending_resource_name() throws SQLException {
db.prepareDbUnit(getClass(), "shared.xml");
- MeasureFilter filter = new MeasureFilter().setResourceQualifiers(Arrays.asList("CLA")).setSortAsc(false);
+ MeasureFilter filter = new MeasureFilter().setResourceQualifiers(asList("FIL")).setSortAsc(false);
List<MeasureFilterRow> rows = executor.execute(filter, new MeasureFilterContext());
// Tiny -> Big
@Test
public void sort_by_ascending_text_measure() throws SQLException {
db.prepareDbUnit(getClass(), "shared.xml");
- MeasureFilter filter = new MeasureFilter().setResourceQualifiers(Arrays.asList("TRK")).setSortOnMetric(METRIC_PROFILE);
+ MeasureFilter filter = new MeasureFilter().setResourceQualifiers(asList("TRK")).setSortOnMetric(METRIC_PROFILE);
List<MeasureFilterRow> rows = executor.execute(filter, new MeasureFilterContext());
assertThat(rows).hasSize(2);
@Test
public void sort_by_descending_text_measure() throws SQLException {
db.prepareDbUnit(getClass(), "shared.xml");
- MeasureFilter filter = new MeasureFilter().setResourceQualifiers(Arrays.asList("TRK")).setSortOnMetric(METRIC_PROFILE).setSortAsc(false);
+ MeasureFilter filter = new MeasureFilter().setResourceQualifiers(asList("TRK")).setSortOnMetric(METRIC_PROFILE).setSortAsc(false);
List<MeasureFilterRow> rows = executor.execute(filter, new MeasureFilterContext());
assertThat(rows).hasSize(2);
public void sort_by_missing_text_measure() throws SQLException {
db.prepareDbUnit(getClass(), "shared.xml");
// the metric 'profile' is not set on files
- MeasureFilter filter = new MeasureFilter().setResourceQualifiers(Arrays.asList("CLA")).setSortOnMetric(METRIC_PROFILE);
+ MeasureFilter filter = new MeasureFilter().setResourceQualifiers(asList("FIL")).setSortOnMetric(METRIC_PROFILE);
List<MeasureFilterRow> rows = executor.execute(filter, new MeasureFilterContext());
assertThat(rows).hasSize(2);// 2 files randomly sorted
@Test
public void sort_by_ascending_numeric_measure() throws SQLException {
db.prepareDbUnit(getClass(), "shared.xml");
- MeasureFilter filter = new MeasureFilter().setResourceQualifiers(Arrays.asList("CLA")).setSortOnMetric(METRIC_LINES);
+ MeasureFilter filter = new MeasureFilter().setResourceQualifiers(asList("FIL")).setSortOnMetric(METRIC_LINES);
List<MeasureFilterRow> rows = executor.execute(filter, new MeasureFilterContext());
// Tiny -> Big
@Test
public void sort_by_descending_numeric_measure() throws SQLException {
db.prepareDbUnit(getClass(), "shared.xml");
- MeasureFilter filter = new MeasureFilter().setResourceQualifiers(Arrays.asList("CLA")).setSortOnMetric(METRIC_LINES).setSortAsc(false);
+ MeasureFilter filter = new MeasureFilter().setResourceQualifiers(asList("FIL")).setSortOnMetric(METRIC_LINES).setSortAsc(false);
List<MeasureFilterRow> rows = executor.execute(filter, new MeasureFilterContext());
// Big -> Tiny
@Test
public void null_measures_are_ordered_after_descending_numeric_measures() throws SQLException {
db.prepareDbUnit(getClass(), "shared.xml");
- MeasureFilter filter = new MeasureFilter().setResourceQualifiers(Arrays.asList("TRK"))
+ MeasureFilter filter = new MeasureFilter().setResourceQualifiers(asList("TRK"))
.setSortOnMetric(METRIC_COVERAGE).setSortAsc(false);
List<MeasureFilterRow> rows = executor.execute(filter, new MeasureFilterContext());
@Test
public void null_measures_are_ordered_after_ascending_numeric_measures() throws SQLException {
db.prepareDbUnit(getClass(), "shared.xml");
- MeasureFilter filter = new MeasureFilter().setResourceQualifiers(Arrays.asList("TRK"))
+ MeasureFilter filter = new MeasureFilter().setResourceQualifiers(asList("TRK"))
.setSortOnMetric(METRIC_COVERAGE).setSortAsc(true);
List<MeasureFilterRow> rows = executor.execute(filter, new MeasureFilterContext());
public void sort_by_missing_numeric_measure() throws SQLException {
db.prepareDbUnit(getClass(), "shared.xml");
// coverage measures are not computed
- MeasureFilter filter = new MeasureFilter().setResourceQualifiers(Arrays.asList("CLA")).setSortOnMetric(METRIC_UNKNOWN);
+ MeasureFilter filter = new MeasureFilter().setResourceQualifiers(asList("FIL")).setSortOnMetric(METRIC_UNKNOWN);
List<MeasureFilterRow> rows = executor.execute(filter, new MeasureFilterContext());
// 2 files, random order
@Test
public void sort_by_ascending_variation() throws SQLException {
db.prepareDbUnit(getClass(), "shared.xml");
- MeasureFilter filter = new MeasureFilter().setResourceQualifiers(Arrays.asList("TRK")).setSortOnMetric(METRIC_LINES).setSortOnPeriod(5);
+ MeasureFilter filter = new MeasureFilter().setResourceQualifiers(asList("TRK")).setSortOnMetric(METRIC_LINES).setSortOnPeriod(5);
List<MeasureFilterRow> rows = executor.execute(filter, new MeasureFilterContext());
assertThat(rows).hasSize(2);
@Test
public void sort_by_descending_variation() throws SQLException {
db.prepareDbUnit(getClass(), "shared.xml");
- MeasureFilter filter = new MeasureFilter().setResourceQualifiers(Arrays.asList("TRK"))
+ MeasureFilter filter = new MeasureFilter().setResourceQualifiers(asList("TRK"))
.setSortOnMetric(METRIC_LINES).setSortOnPeriod(5).setSortAsc(false);
List<MeasureFilterRow> rows = executor.execute(filter, new MeasureFilterContext());
@Test
public void sort_by_ascending_date() throws SQLException {
db.prepareDbUnit(getClass(), "shared.xml");
- MeasureFilter filter = new MeasureFilter().setResourceQualifiers(Arrays.asList("TRK")).setSortOn(MeasureFilterSort.Field.DATE);
+ MeasureFilter filter = new MeasureFilter().setResourceQualifiers(asList("TRK")).setSortOn(MeasureFilterSort.Field.DATE);
List<MeasureFilterRow> rows = executor.execute(filter, new MeasureFilterContext());
verifyJavaProject(rows.get(0));// 2008
@Test
public void sort_by_descending_date() throws SQLException {
db.prepareDbUnit(getClass(), "shared.xml");
- MeasureFilter filter = new MeasureFilter().setResourceQualifiers(Arrays.asList("TRK")).setSortOn(MeasureFilterSort.Field.DATE).setSortAsc(false);
+ MeasureFilter filter = new MeasureFilter().setResourceQualifiers(asList("TRK")).setSortOn(MeasureFilterSort.Field.DATE).setSortAsc(false);
List<MeasureFilterRow> rows = executor.execute(filter, new MeasureFilterContext());
verifyPhpProject(rows.get(0));// 2012
@Test
public void sort_by_ascending_created_at() throws SQLException {
db.prepareDbUnit(getClass(), "shared.xml");
- MeasureFilter filter = new MeasureFilter().setResourceQualifiers(Arrays.asList("TRK")).setSortOn(MeasureFilterSort.Field.PROJECT_CREATION_DATE);
+ MeasureFilter filter = new MeasureFilter().setResourceQualifiers(asList("TRK")).setSortOn(MeasureFilterSort.Field.PROJECT_CREATION_DATE);
List<MeasureFilterRow> rows = executor.execute(filter, new MeasureFilterContext());
verifyJavaProject(rows.get(0));// 2008
@Test
public void sort_by_descending_created_at() throws SQLException {
db.prepareDbUnit(getClass(), "shared.xml");
- MeasureFilter filter = new MeasureFilter().setResourceQualifiers(Arrays.asList("TRK")).setSortOn(MeasureFilterSort.Field.PROJECT_CREATION_DATE).setSortAsc(false);
+ MeasureFilter filter = new MeasureFilter().setResourceQualifiers(asList("TRK")).setSortOn(MeasureFilterSort.Field.PROJECT_CREATION_DATE).setSortAsc(false);
List<MeasureFilterRow> rows = executor.execute(filter, new MeasureFilterContext());
verifyPhpProject(rows.get(0));// 2012
}
@Test
- public void sort_by_ascending_alert() throws SQLException {
+ public void sort_by_ascending_quality_gate_status() throws SQLException {
db.prepareDbUnit(getClass(), "sort_by_alert.xml");
-
Metric alert = new Metric.Builder(CoreMetrics.ALERT_STATUS_KEY, "Alert", Metric.ValueType.LEVEL).create().setId(5);
- MeasureFilter filter = new MeasureFilter().setResourceQualifiers(Arrays.asList("TRK")).setSortOnMetric(alert);
+ MeasureFilter filter = new MeasureFilter().setResourceQualifiers(asList("TRK")).setSortOnMetric(alert);
+
List<MeasureFilterRow> rows = executor.execute(filter, new MeasureFilterContext());
// Php Project OK, Java Project WARN then Js Project ERROR
assertThat(rows).hasSize(3);
verifyPhpProject(rows.get(0));
verifyJavaProject(rows.get(1));
- verifyProject(rows.get(2), 120L, 20L, "CDEF");
+ verifyComponent(rows.get(2), "UUID_JS_PROJECT", "UUID_JS_PROJECT");
}
@Test
- public void sort_by_descending_alert() throws SQLException {
+ public void sort_by_descending_quality_gate_status() throws SQLException {
db.prepareDbUnit(getClass(), "sort_by_alert.xml");
-
Metric alert = new Metric.Builder(CoreMetrics.ALERT_STATUS_KEY, "Alert", Metric.ValueType.LEVEL).create().setId(5);
- MeasureFilter filter = new MeasureFilter().setResourceQualifiers(Arrays.asList("TRK")).setSortOnMetric(alert).setSortAsc(false);
+ MeasureFilter filter = new MeasureFilter().setResourceQualifiers(asList("TRK")).setSortOnMetric(alert).setSortAsc(false);
+
List<MeasureFilterRow> rows = executor.execute(filter, new MeasureFilterContext());
// Js Project ERROR, Java Project WARN, then Php Project OK
assertThat(rows).hasSize(3);
- verifyProject(rows.get(0), 120L, 20L, "CDEF");
+ verifyComponent(rows.get(0), "UUID_JS_PROJECT", "UUID_JS_PROJECT");
verifyJavaProject(rows.get(1));
verifyPhpProject(rows.get(2));
}
@Test
public void condition_on_numeric_measure() throws SQLException {
db.prepareDbUnit(getClass(), "shared.xml");
- MeasureFilter filter = new MeasureFilter().setResourceQualifiers(Arrays.asList("CLA"))
+ MeasureFilter filter = new MeasureFilter().setResourceQualifiers(asList("FIL"))
.setSortOnMetric(METRIC_LINES)
.addCondition(new MeasureFilterCondition(METRIC_LINES, MeasureFilterCondition.Operator.GREATER, 200));
List<MeasureFilterRow> rows = executor.execute(filter, new MeasureFilterContext());
@Test
public void condition_on_measure_variation() throws SQLException {
db.prepareDbUnit(getClass(), "shared.xml");
- MeasureFilter filter = new MeasureFilter().setResourceQualifiers(Arrays.asList("TRK"))
+ MeasureFilter filter = new MeasureFilter().setResourceQualifiers(asList("TRK"))
.setSortOnMetric(METRIC_LINES)
.addCondition(new MeasureFilterCondition(METRIC_LINES, MeasureFilterCondition.Operator.GREATER, 1000).setPeriod(5));
List<MeasureFilterRow> rows = executor.execute(filter, new MeasureFilterContext());
@Test
public void multiple_conditions_on_numeric_measures() throws SQLException {
db.prepareDbUnit(getClass(), "shared.xml");
- MeasureFilter filter = new MeasureFilter().setResourceQualifiers(Arrays.asList("CLA"))
+ MeasureFilter filter = new MeasureFilter().setResourceQualifiers(asList("FIL"))
.setSortOnMetric(METRIC_LINES)
.addCondition(new MeasureFilterCondition(METRIC_LINES, MeasureFilterCondition.Operator.GREATER, 2))
.addCondition(new MeasureFilterCondition(METRIC_LINES, MeasureFilterCondition.Operator.LESS_OR_EQUALS, 50));
@Test
public void filter_by_min_date() throws SQLException {
db.prepareDbUnit(getClass(), "shared.xml");
- MeasureFilter filter = new MeasureFilter().setResourceQualifiers(Arrays.asList("TRK")).setFromDate(DateUtils.parseDateTime("2012-12-13T00:00:00+0000"));
+ MeasureFilter filter = new MeasureFilter().setResourceQualifiers(asList("TRK")).setFromDate(DateUtils.parseDateTime("2012-12-13T00:00:00+0000"));
List<MeasureFilterRow> rows = executor.execute(filter, new MeasureFilterContext());
// php has been analyzed in 2012-12-13, whereas java project has been analyzed in 2008
@Test
public void filter_by_range_of_dates() throws SQLException {
db.prepareDbUnit(getClass(), "shared.xml");
- MeasureFilter filter = new MeasureFilter().setResourceQualifiers(Arrays.asList("TRK"))
+ MeasureFilter filter = new MeasureFilter().setResourceQualifiers(asList("TRK"))
.setFromDate(DateUtils.parseDate("2007-01-01"))
.setToDate(DateUtils.parseDate("2010-01-01"));
List<MeasureFilterRow> rows = executor.execute(filter, new MeasureFilterContext());
@Test
public void filter_by_component_name() throws SQLException {
db.prepareDbUnit(getClass(), "shared.xml");
- MeasureFilter filter = new MeasureFilter().setResourceQualifiers(Arrays.asList("TRK")).setResourceName("PHP Proj");
+ MeasureFilter filter = new MeasureFilter().setResourceQualifiers(asList("TRK")).setResourceName("PHP Proj");
List<MeasureFilterRow> rows = executor.execute(filter, new MeasureFilterContext());
assertThat(rows).hasSize(1);
@Test
public void filter_by_component_key() throws SQLException {
db.prepareDbUnit(getClass(), "shared.xml");
- MeasureFilter filter = new MeasureFilter().setResourceQualifiers(Arrays.asList("TRK")).setResourceKey("Va_proje");
+ MeasureFilter filter = new MeasureFilter().setResourceQualifiers(asList("TRK")).setResourceKey("Va_proje");
List<MeasureFilterRow> rows = executor.execute(filter, new MeasureFilterContext());
assertThat(rows).hasSize(1);
@Test
public void filter_by_upper_case_component_key() throws SQLException {
db.prepareDbUnit(getClass(), "shared.xml");
- MeasureFilter filter = new MeasureFilter().setResourceQualifiers(Arrays.asList("CLA")).setResourceKey("big");
+ MeasureFilter filter = new MeasureFilter().setResourceQualifiers(asList("FIL")).setResourceKey("big");
List<MeasureFilterRow> rows = executor.execute(filter, new MeasureFilterContext());
assertThat(rows).hasSize(1);
public void escape_percent_and_underscore_when_filter_by_component_name_or_key() throws SQLException {
db.prepareDbUnit(getClass(), "escape_percent_and_underscore_when_filter_by_component_name_or_key.xml");
- assertThat(executor.execute(
- new MeasureFilter().setResourceQualifiers(newArrayList("CLA")).setResourceKey("java_"),
- new MeasureFilterContext())).hasSize(2);
+// assertThat(executor.execute(
+// new MeasureFilter().setResourceQualifiers(newArrayList("FIL")).setResourceKey("java_"),
+// new MeasureFilterContext())).hasSize(2);
assertThat(executor.execute(
- new MeasureFilter().setResourceQualifiers(newArrayList("CLA")).setResourceName("java%"),
+ new MeasureFilter().setResourceQualifiers(newArrayList("FIL")).setResourceName("java%"),
new MeasureFilterContext())).hasSize(2);
}
@Test
- public void filter_by_base_resource() throws SQLException {
+ public void filter_by_base_component() throws SQLException {
db.prepareDbUnit(getClass(), "shared.xml");
- MeasureFilter filter = new MeasureFilter().setResourceQualifiers(Arrays.asList("CLA")).setBaseResourceKey("java_project");
+ MeasureFilter filter = new MeasureFilter().setResourceQualifiers(asList("FIL")).setBaseResourceKey("java_project");
List<MeasureFilterRow> rows = executor.execute(filter, new MeasureFilterContext());
assertThat(rows).hasSize(2);
}
@Test
- public void filter_by_parent_resource() throws SQLException {
+ public void filter_by_parent_component() throws SQLException {
db.prepareDbUnit(getClass(), "shared.xml");
MeasureFilter filter = new MeasureFilter().setBaseResourceKey("java_project").setOnBaseResourceChildren(true);
+
List<MeasureFilterRow> rows = executor.execute(filter, new MeasureFilterContext());
- assertThat(rows).hasSize(1);// the package org.sonar.foo
- assertThat(rows.get(0).getSnapshotId()).isEqualTo(JAVA_PACKAGE_SNAPSHOT_ID);
+ assertThat(rows).extracting(MeasureFilterRow::getComponentUuid).containsOnly(JAVA_DIR_UUID);
}
@Test
public void filter_by_parent_without_children() throws Exception {
db.prepareDbUnit(getClass(), "shared.xml");
- MeasureFilter filter = new MeasureFilter().setResourceQualifiers(Arrays.asList("TRK", "PAC", "CLA")).setBaseResourceKey("java_project:org.sonar.foo.Big")
+ MeasureFilter filter = new MeasureFilter().setResourceQualifiers(asList("TRK", "DIR", "FIL")).setBaseResourceKey("java_project:org.sonar.foo.Big")
.setOnBaseResourceChildren(true);
List<MeasureFilterRow> rows = executor.execute(filter, new MeasureFilterContext());
@Test
public void filter_by_user_favourites() throws Exception {
db.prepareDbUnit(getClass(), "shared.xml");
- MeasureFilter filter = new MeasureFilter().setResourceQualifiers(Arrays.asList("TRK", "FIL")).setUserFavourites(true);
+ MeasureFilter filter = new MeasureFilter().setResourceQualifiers(asList("TRK", "FIL")).setUserFavourites(true);
List<MeasureFilterRow> rows = executor.execute(filter, new MeasureFilterContext().setUserId(50L));
assertThat(rows).hasSize(2);
@Test
public void ignore_person_measures_in_condition() throws Exception {
db.prepareDbUnit(getClass(), "ignore_person_measures.xml");
- MeasureFilter filter = new MeasureFilter().setResourceQualifiers(Arrays.asList("TRK")).addCondition(
+ MeasureFilter filter = new MeasureFilter().setResourceQualifiers(asList("TRK")).addCondition(
new MeasureFilterCondition(new Metric("ncloc").setId(1), MeasureFilterCondition.Operator.GREATER, 0.0)
);
List<MeasureFilterRow> rows = executor.execute(filter, new MeasureFilterContext().setUserId(50L));
assertThat(rows).hasSize(1);
- assertThat(rows.get(0).getSnapshotId()).isEqualTo(101L);
+ assertThat(rows.get(0).getComponentUuid()).isEqualTo(JAVA_PROJECT_UUID);
}
@Test
public void ignore_person_measures_in_sort() throws Exception {
db.prepareDbUnit(getClass(), "ignore_person_measures.xml");
- MeasureFilter filter = new MeasureFilter().setResourceQualifiers(Arrays.asList("TRK")).setSortOnMetric(new Metric("ncloc").setId(1));
+ MeasureFilter filter = new MeasureFilter().setResourceQualifiers(asList("TRK")).setSortOnMetric(new Metric("ncloc").setId(1));
List<MeasureFilterRow> rows = executor.execute(filter, new MeasureFilterContext().setUserId(50L));
assertThat(rows).hasSize(1);
- assertThat(rows.get(0).getSnapshotId()).isEqualTo(101L);
+ assertThat(rows.get(0).getComponentUuid()).isEqualTo(JAVA_PROJECT_UUID);
}
@Test
public void ignore_quality_model_measures_in_condition() throws Exception {
db.prepareDbUnit(getClass(), "ignore_quality_model_measures.xml");
- MeasureFilter filter = new MeasureFilter().setResourceQualifiers(Arrays.asList("TRK")).addCondition(
+ MeasureFilter filter = new MeasureFilter().setResourceQualifiers(asList("TRK")).addCondition(
new MeasureFilterCondition(new Metric("ncloc").setId(1), MeasureFilterCondition.Operator.GREATER, 0.0)
);
List<MeasureFilterRow> rows = executor.execute(filter, new MeasureFilterContext().setUserId(50L));
assertThat(rows).hasSize(1);
- assertThat(rows.get(0).getSnapshotId()).isEqualTo(101L);
+ assertThat(rows.get(0).getComponentUuid()).isEqualTo(JAVA_PROJECT_UUID);
}
@Test
public void ignore_quality_model_measures_in_sort() throws Exception {
db.prepareDbUnit(getClass(), "ignore_quality_model_measures.xml");
- MeasureFilter filter = new MeasureFilter().setResourceQualifiers(Arrays.asList("TRK")).setSortOnMetric(new Metric("ncloc").setId(1));
+ MeasureFilter filter = new MeasureFilter().setResourceQualifiers(asList("TRK")).setSortOnMetric(new Metric("ncloc").setId(1));
List<MeasureFilterRow> rows = executor.execute(filter, new MeasureFilterContext().setUserId(50L));
assertThat(rows).hasSize(1);
- assertThat(rows.get(0).getSnapshotId()).isEqualTo(101L);
+ assertThat(rows.get(0).getComponentUuid()).isEqualTo(JAVA_PROJECT_UUID);
}
private void verifyJavaProject(MeasureFilterRow row) {
- verifyProject(row, JAVA_PROJECT_SNAPSHOT_ID, JAVA_PROJECT_ID, JAVA_PROJECT_UUID);
+ verifyComponent(row, JAVA_PROJECT_UUID, JAVA_PROJECT_UUID);
}
private void verifyJavaBigFile(MeasureFilterRow row) {
- verifyProject(row, JAVA_FILE_BIG_SNAPSHOT_ID, JAVA_FILE_BIG_ID, JAVA_PROJECT_UUID);
+ verifyComponent(row, JAVA_BIG_FILE_UUID, JAVA_PROJECT_UUID);
}
private void verifyJavaTinyFile(MeasureFilterRow row) {
- verifyProject(row, JAVA_FILE_TINY_SNAPSHOT_ID, JAVA_FILE_TINY_ID, JAVA_PROJECT_UUID);
+ verifyComponent(row, JAVA_TINY_FILE_UUID, JAVA_PROJECT_UUID);
}
private void verifyPhpProject(MeasureFilterRow row) {
- verifyProject(row, PHP_SNAPSHOT_ID, PHP_PROJECT_ID, PHP_PROJECT_UUID);
+ verifyComponent(row, PHP_PROJECT_UUID, PHP_PROJECT_UUID);
}
- private void verifyProject(MeasureFilterRow row, Long snashotId, Long resourceId, String rootComponentUuid) {
- assertThat(row.getSnapshotId()).isEqualTo(snashotId);
- assertThat(row.getResourceId()).isEqualTo(resourceId);
+ private void verifyComponent(MeasureFilterRow row, String componentUuid, String rootComponentUuid) {
+ assertThat(row.getComponentUuid()).isEqualTo(componentUuid);
assertThat(row.getRootComponentUuid()).isEqualTo(rootComponentUuid);
}
}
@Test
public void sort_on_measure_value() {
MeasureFilterFactory factory = new MeasureFilterFactory(newMetricFinder(), system);
- Map<String, Object> props = ImmutableMap.<String, Object>of("sort", "metric:ncloc");
+ Map<String, Object> props = ImmutableMap.of("sort", "metric:ncloc");
MeasureFilter filter = factory.create(props);
assertThat(filter.sort().column()).isEqualTo("pmsort.value");
@Test
public void sort_on_measure_variation() {
MeasureFilterFactory factory = new MeasureFilterFactory(newMetricFinder(), system);
- Map<String, Object> props = ImmutableMap.<String, Object>of("sort", "metric:ncloc:3");
+ Map<String, Object> props = ImmutableMap.of("sort", "metric:ncloc:3");
MeasureFilter filter = factory.create(props);
assertThat(filter.sort().column()).isEqualTo("pmsort.variation_value_3");
@Test
public void sort_on_name() {
MeasureFilterFactory factory = new MeasureFilterFactory(newMetricFinder(), system);
- Map<String, Object> props = ImmutableMap.<String, Object>of("sort", "name");
+ Map<String, Object> props = ImmutableMap.of("sort", "name");
MeasureFilter filter = factory.create(props);
- assertThat(filter.sort().column()).isEqualTo("p.long_name");
+ assertThat(filter.sort().column()).isEqualTo("c.long_name");
assertThat(filter.sort().metric()).isNull();
assertThat(filter.sort().period()).isNull();
}
MetricFinder finder = mock(MetricFinder.class);
when(finder.findByKey(anyString())).thenReturn(null);
MeasureFilterFactory factory = new MeasureFilterFactory(finder, system);
- Map<String, Object> props = ImmutableMap.<String, Object>of("sort", "metric:sqale_index");
+ Map<String, Object> props = ImmutableMap.of("sort", "metric:sqale_index");
MeasureFilter filter = factory.create(props);
- assertThat(filter.sort().column()).isEqualTo("p.long_name");
+ assertThat(filter.sort().column()).isEqualTo("c.long_name");
assertThat(filter.sort().metric()).isNull();
assertThat(filter.sort().period()).isNull();
assertThat(filter.sort().isAsc()).isTrue();
@Test
public void fallback_on_name_sort_when_sort_is_unknown() {
MeasureFilterFactory factory = new MeasureFilterFactory(newMetricFinder(), system);
- Map<String, Object> props = ImmutableMap.<String, Object>of("sort", "unknown");
+ Map<String, Object> props = ImmutableMap.of("sort", "unknown");
MeasureFilter filter = factory.create(props);
- assertThat(filter.sort().column()).isEqualTo("p.long_name");
+ assertThat(filter.sort().column()).isEqualTo("c.long_name");
assertThat(filter.sort().metric()).isNull();
assertThat(filter.sort().period()).isNull();
assertThat(filter.sort().isAsc()).isTrue();
@Test
public void descending_sort() {
MeasureFilterFactory factory = new MeasureFilterFactory(newMetricFinder(), system);
- Map<String, Object> props = ImmutableMap.<String, Object>of("asc", "false");
+ Map<String, Object> props = ImmutableMap.of("asc", "false");
MeasureFilter filter = factory.create(props);
- assertThat(filter.sort().column()).isEqualTo("p.long_name");
+ assertThat(filter.sort().column()).isEqualTo("c.long_name");
assertThat(filter.sort().metric()).isNull();
assertThat(filter.sort().period()).isNull();
assertThat(filter.sort().isAsc()).isFalse();
Map<String, Object> props = Maps.newHashMap();
MeasureFilter filter = factory.create(props);
- assertThat(filter.sort().column()).isEqualTo("p.long_name");
+ assertThat(filter.sort().column()).isEqualTo("c.long_name");
assertThat(filter.sort().metric()).isNull();
assertThat(filter.sort().period()).isNull();
assertThat(filter.sort().isAsc()).isTrue();
@Test
public void date_conditions() {
MeasureFilterFactory factory = new MeasureFilterFactory(newMetricFinder(), system);
- Map<String, Object> props = ImmutableMap.<String, Object>of(
+ Map<String, Object> props = ImmutableMap.of(
"fromDate", "2012-01-25",
"toDate", "2012-02-18"
);
when(system.now()).thenReturn(today);
MeasureFilterFactory factory = new MeasureFilterFactory(newMetricFinder(), system);
- Map<String, Object> props = ImmutableMap.<String, Object>of(
+ Map<String, Object> props = ImmutableMap.of(
"ageMaxDays", "3",
"ageMinDays", "1"
);
@Test
public void measure_value_condition() {
MeasureFilterFactory factory = new MeasureFilterFactory(newMetricFinder(), system);
- Map<String, Object> props = ImmutableMap.<String, Object>of(
+ Map<String, Object> props = ImmutableMap.of(
"c1_metric", "complexity",
"c1_op", "gte",
"c1_val", "3.14"
@Test
public void measure_variation_condition() {
MeasureFilterFactory factory = new MeasureFilterFactory(newMetricFinder(), system);
- Map<String, Object> props = ImmutableMap.<String, Object>of(
+ Map<String, Object> props = ImmutableMap.of(
"c1_metric", "complexity",
"c1_op", "gte",
"c1_val", "3.14",
@Test
public void alert_level_condition() {
MeasureFilterFactory factory = new MeasureFilterFactory(newMetricFinder(), system);
- MeasureFilter filter = factory.create(ImmutableMap.<String, Object>of(
+ MeasureFilter filter = factory.create(ImmutableMap.of(
"alertLevels", Arrays.asList("error", "warn", "unknown")
));
@Test
public void alert_level_condition_with_no_alert_status_metric() {
MeasureFilterFactory factory = new MeasureFilterFactory(mock(MetricFinder.class), system);
- MeasureFilter filter = factory.create(ImmutableMap.<String, Object>of(
+ MeasureFilter filter = factory.create(ImmutableMap.of(
"alertLevels", Arrays.asList("error", "warn", "unknown")
));
@Test
public void name_conditions() {
MeasureFilterFactory factory = new MeasureFilterFactory(newMetricFinder(), system);
- Map<String, Object> props = ImmutableMap.<String, Object>of(
+ Map<String, Object> props = ImmutableMap.of(
"nameSearch", "SonarQube"
);
MeasureFilter filter = factory.create(props);
@Test
public void not_fail_when_name_conditions_contains_array() {
MeasureFilterFactory factory = new MeasureFilterFactory(newMetricFinder(), system);
- Map<String, Object> props = ImmutableMap.<String, Object>of(
+ Map<String, Object> props = ImmutableMap.of(
"nameSearch", new String[] {"sonar", "qube"}
);
MeasureFilter filter = factory.create(props);
@Test
public void not_fail_when_name_conditions_contains_list() {
MeasureFilterFactory factory = new MeasureFilterFactory(newMetricFinder(), system);
- Map<String, Object> props = ImmutableMap.<String, Object>of(
+ Map<String, Object> props = ImmutableMap.of(
"nameSearch", newArrayList("sonar", "qube")
);
MeasureFilter filter = factory.create(props);
@Test
public void ignore_partial_measure_condition() {
MeasureFilterFactory factory = new MeasureFilterFactory(newMetricFinder(), system);
- Map<String, Object> props = ImmutableMap.<String, Object>of(
+ Map<String, Object> props = ImmutableMap.of(
"c1_op", "gte",
"c1_val", "3.14"
);
+++ /dev/null
-/*
- * SonarQube
- * Copyright (C) 2009-2016 SonarSource SA
- * mailto:contact AT sonarsource DOT com
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 3 of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-package org.sonar.server.test;
-
-import java.util.Collections;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.runners.MockitoJUnitRunner;
-import org.sonar.api.measures.CoreMetrics;
-import org.sonar.api.web.UserRole;
-import org.sonar.db.DbSession;
-import org.sonar.db.MyBatis;
-import org.sonar.db.measure.MeasureDao;
-import org.sonar.server.tester.UserSessionRule;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.anyString;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
-@RunWith(MockitoJUnitRunner.class)
-public class CoverageServiceTest {
-
- static final String COMPONENT_KEY = "org.sonar.sample:Sample";
-
- @Rule
- public UserSessionRule userSessionRule = UserSessionRule.standalone();
- @Rule
- public ExpectedException thrown = ExpectedException.none();
- @Mock
- DbSession session;
- @Mock
- MeasureDao measureDao;
- CoverageService service;
-
- @Before
- public void setUp() {
- MyBatis myBatis = mock(MyBatis.class);
- when(myBatis.openSession(false)).thenReturn(session);
- service = new CoverageService(myBatis, measureDao, userSessionRule);
- }
-
- @Test
- public void check_permission() {
- String projectKey = "org.sonar.sample";
- userSessionRule.addComponentPermission(UserRole.CODEVIEWER, projectKey, COMPONENT_KEY);
-
- service.checkPermission(COMPONENT_KEY);
- }
-
- @Test
- public void get_hits_data() {
- service.getHits(COMPONENT_KEY, CoverageService.TYPE.UT);
- verify(measureDao).selectByComponentKeyAndMetricKey(session, COMPONENT_KEY, CoreMetrics.COVERAGE_LINE_HITS_DATA_KEY);
-
- service.getHits(COMPONENT_KEY, CoverageService.TYPE.IT);
- verify(measureDao).selectByComponentKeyAndMetricKey(session, COMPONENT_KEY, CoreMetrics.IT_COVERAGE_LINE_HITS_DATA_KEY);
-
- service.getHits(COMPONENT_KEY, CoverageService.TYPE.OVERALL);
- verify(measureDao).selectByComponentKeyAndMetricKey(session, COMPONENT_KEY, CoreMetrics.OVERALL_COVERAGE_LINE_HITS_DATA_KEY);
- }
-
- @Test
- public void not_get_hits_data_if_no_data() {
- when(measureDao.selectByComponentKeyAndMetricKey(eq(session), anyString(), anyString())).thenReturn(null);
- assertThat(service.getHits(COMPONENT_KEY, CoverageService.TYPE.UT)).isEqualTo(Collections.emptyMap());
- }
-
- @Test
- public void get_conditions_data() {
- service.getConditions(COMPONENT_KEY, CoverageService.TYPE.UT);
- verify(measureDao).selectByComponentKeyAndMetricKey(session, COMPONENT_KEY, CoreMetrics.CONDITIONS_BY_LINE_KEY);
-
- service.getConditions(COMPONENT_KEY, CoverageService.TYPE.IT);
- verify(measureDao).selectByComponentKeyAndMetricKey(session, COMPONENT_KEY, CoreMetrics.IT_CONDITIONS_BY_LINE_KEY);
-
- service.getConditions(COMPONENT_KEY, CoverageService.TYPE.OVERALL);
- verify(measureDao).selectByComponentKeyAndMetricKey(session, COMPONENT_KEY, CoreMetrics.OVERALL_CONDITIONS_BY_LINE_KEY);
- }
-
- @Test
- public void get_covered_conditions_data() {
- service.getCoveredConditions(COMPONENT_KEY, CoverageService.TYPE.UT);
- verify(measureDao).selectByComponentKeyAndMetricKey(session, COMPONENT_KEY, CoreMetrics.COVERED_CONDITIONS_BY_LINE_KEY);
-
- service.getCoveredConditions(COMPONENT_KEY, CoverageService.TYPE.IT);
- verify(measureDao).selectByComponentKeyAndMetricKey(session, COMPONENT_KEY, CoreMetrics.IT_COVERED_CONDITIONS_BY_LINE_KEY);
-
- service.getCoveredConditions(COMPONENT_KEY, CoverageService.TYPE.OVERALL);
- verify(measureDao).selectByComponentKeyAndMetricKey(session, COMPONENT_KEY, CoreMetrics.OVERALL_COVERED_CONDITIONS_BY_LINE_KEY);
- }
-}
{
- "key": "org.codehaus.sonar:sonar-plugin-api:src/main/java/org/sonar/api/Plugin.java",
- "uuid": "ABCDE",
+ "key": "org.sonarsource.sonarqube:sonar-plugin-api:src/main/java/org/sonar/api/Plugin.java",
+ "uuid": "THE_FILE_UUID",
"path": "src/main/java/org/sonar/api/Plugin.java",
"name": "Plugin.java",
"longName": "src/main/java/org/sonar/api/Plugin.java",
"q": "FIL",
- "subProject": "org.codehaus.sonar:sonar-plugin-api",
+ "subProject": "org.sonarsource.sonarqube:sonar-plugin-api",
"subProjectName": "SonarQube :: Plugin API",
- "project": "org.codehaus.sonar:sonar",
+ "project": "org.sonarsource.sonarqube:sonarqube",
"projectName": "SonarQube",
- "fav": true,
+ "fav": false,
"canMarkAsFavourite": true,
"measures": {}
}
{
- "key": "org.codehaus.sonar:sonar-plugin-api:src/main/java/org/sonar/api/Plugin.java",
- "uuid": "ABCDE",
+ "key": "org.sonarsource.sonarqube:sonar-plugin-api:src/main/java/org/sonar/api/Plugin.java",
+ "uuid": "THE_FILE_UUID",
"path": "src/main/java/org/sonar/api/Plugin.java",
"name": "Plugin.java",
"longName": "src/main/java/org/sonar/api/Plugin.java",
"q": "FIL",
- "subProject": "org.codehaus.sonar:sonar-plugin-api",
+ "subProject": "org.sonarsource.sonarqube:sonar-plugin-api",
"subProjectName": "SonarQube :: Plugin API",
- "project": "org.codehaus.sonar:sonar",
+ "project": "org.sonarsource.sonarqube:sonarqube",
"projectName": "SonarQube",
"fav": false,
- "canMarkAsFavourite": false,
- "measures": {"coverage": "85.2%"}
+ "canMarkAsFavourite": true,
+ "measures": {
+ "coverage": "85.2%"
+ }
}
{
- "key": "org.codehaus.sonar:sonar-plugin-api:src/main/java/org/sonar/api/Plugin.java",
- "uuid": "ABCDE",
+ "key": "org.sonarsource.sonarqube:sonar-plugin-api:src/main/java/org/sonar/api/Plugin.java",
+ "uuid": "THE_FILE_UUID",
"path": "src/main/java/org/sonar/api/Plugin.java",
"name": "Plugin.java",
"longName": "src/main/java/org/sonar/api/Plugin.java",
"q": "FIL",
- "subProject": "org.codehaus.sonar:sonar-plugin-api",
+ "subProject": "org.sonarsource.sonarqube:sonar-plugin-api",
"subProjectName": "SonarQube :: Plugin API",
- "project": "org.codehaus.sonar:sonar",
+ "project": "org.sonarsource.sonarqube:sonarqube",
"projectName": "SonarQube",
"fav": false,
- "canMarkAsFavourite": false,
+ "canMarkAsFavourite": true,
"measures": {
"lines": "200",
"coverage": "95.4%",
{
- "key": "org.codehaus.sonar:sonar-plugin-api:src/main/java/org/sonar/api/Plugin.java",
- "uuid": "ABCDE",
+ "key": "org.sonarsource.sonarqube:sonar-plugin-api:src/main/java/org/sonar/api/Plugin.java",
+ "uuid": "THE_FILE_UUID",
"path": "src/main/java/org/sonar/api/Plugin.java",
"name": "Plugin.java",
"longName": "src/main/java/org/sonar/api/Plugin.java",
"q": "FIL",
- "subProject": "org.codehaus.sonar:sonar-plugin-api",
+ "subProject": "org.sonarsource.sonarqube:sonar-plugin-api",
"subProjectName": "SonarQube :: Plugin API",
- "project": "org.codehaus.sonar:sonar",
+ "project": "org.sonarsource.sonarqube:sonarqube",
"projectName": "SonarQube",
"fav": false,
- "canMarkAsFavourite": false,
- "measures": {"coverage": "90.1%"}
+ "canMarkAsFavourite": true,
+ "measures": {
+ "coverage": "90.1%"
+ }
}
{
- "key": "org.codehaus.sonar:sonar-plugin-api:src/main/java/org/sonar/api/Plugin.java",
- "uuid": "ABCDE",
+ "key": "org.sonarsource.sonarqube:sonar-plugin-api:src/main/java/org/sonar/api/Plugin.java",
+ "uuid": "THE_FILE_UUID",
"path": "src/main/java/org/sonar/api/Plugin.java",
"name": "Plugin.java",
"longName": "src/main/java/org/sonar/api/Plugin.java",
"q": "FIL",
- "subProject": "org.codehaus.sonar:sonar-plugin-api",
+ "subProject": "org.sonarsource.sonarqube:sonar-plugin-api",
"subProjectName": "SonarQube :: Plugin API",
- "project": "org.codehaus.sonar:sonar",
+ "project": "org.sonarsource.sonarqube:sonarqube",
"projectName": "SonarQube",
"fav": false,
- "canMarkAsFavourite": false,
- "measures": {"coverage": "95.4%"}
+ "canMarkAsFavourite": true,
+ "measures": {
+ "coverage": "95.4%"
+ }
}
<dataset>
<!-- java project -->
- <projects uuid="ABCD"
- uuid_path="NOT_USED"
+ <projects uuid="UUID_JAVA_PROJECT"
+ uuid_path="."
+ project_uuid="UUID_JAVA_PROJECT"
description="[null]"
enabled="[true]"
language="[null]"
created_at="2008-12-19 00:00:00.00"
- kee="java_project:org.sonar.bar"
- long_name="org.sonar.bar"
- scope="FIL"
- qualifier="CLA"
- name="org.sonar.bar"
+ kee="java_project"
+ long_name="java project"
+ scope="PRJ"
+ qualifier="TRK"
+ name="project"
id="1"
- root_uuid="ABCD"/>
+ root_uuid="NOT_USED"/>
- <projects uuid="BCDE"
- uuid_path="NOT_USED"
+ <projects uuid="FILE1"
+ uuid_path=".UUID_JAVA_PROJECT."
+ project_uuid="UUID_JAVA_PROJECT"
description="[null]"
enabled="[true]"
language="java"
created_at="2008-12-19 00:00:00.00"
- kee="java_project:org.sonar.foo"
+ kee="java_project:file1"
scope="FIL"
- qualifier="CLA"
+ qualifier="FIL"
long_name="org.sonar.foo"
name="org.sonar.foo"
id="2"
- root_uuid="ABCD"/>
+ root_uuid="NOT_USED"/>
- <projects uuid="CDEF"
- uuid_path="NOT_USED"
+ <projects uuid="FILE2"
+ uuid_path=".UUID_JAVA_PROJECT."
+ project_uuid="UUID_JAVA_PROJECT"
description="[null]"
enabled="[true]"
language="java"
created_at="2008-12-19 00:00:00.00"
- kee="java project:org.sonar.foo.Big"
+ kee="java_project:file2"
scope="FIL"
- qualifier="CLA"
+ qualifier="FIL"
long_name="org.sonar.foo.Big"
name="Big"
id="3"
- root_uuid="ABCD"/>
+ root_uuid="NOT_USED"/>
- <projects uuid="DEFG"
- uuid_path="NOT_USED"
+ <projects uuid="FILE3"
+ uuid_path=".UUID_JAVA_PROJECT."
+ project_uuid="UUID_JAVA_PROJECT"
description="[null]"
enabled="[true]"
language="java"
created_at="2008-12-19 00:00:00.00"
- kee="java project:org.sonar.foo.Tiny"
+ kee="java_project:file3"
scope="FIL"
- qualifier="CLA"
+ qualifier="FIL"
long_name="org.sonar.foo.Tiny"
name="Tiny"
id="4"
- root_uuid="ABCD"/>
+ root_uuid="NOT USED"/>
+
+ <projects uuid="FILE4"
+ uuid_path=".UUID_JAVA_PROJECT."
+ project_uuid="UUID_JAVA_PROJECT"
+ description="[null]"
+ enabled="[true]"
+ language="java"
+ created_at="2008-12-19 00:00:00.00"
+ kee="java_project:file4"
+ scope="FIL"
+ qualifier="FIL"
+ long_name="org.sonar.foo.Tiny"
+ name="Tiny"
+ id="5"
+ root_uuid="NOT USED"/>
<snapshots id="101"
uuid="u101"
- component_uuid="ABCD"
- root_component_uuid="ABCD"
+ component_uuid="UUID_JAVA_PROJECT"
+ root_component_uuid="UUID_JAVA_PROJECT"
root_snapshot_id="[null]"
parent_snapshot_id="[null]"
- scope="FIL"
- qualifier="CLA"
+ scope="PRJ"
+ qualifier="TRK"
path=""
depth="0"
purge_status="[null]"
status="P"
islast="[true]"/>
- <snapshots id="102"
- uuid="u102"
- component_uuid="BCDE"
- root_component_uuid="ABCD"
- root_snapshot_id="101"
- parent_snapshot_id="101"
- scope="FIL"
- qualifier="CLA"
- path="101."
- depth="1"
- purge_status="[null]"
- period1_mode="[null]"
- period1_param="[null]"
- period1_date="[null]"
- period2_mode="[null]"
- period2_param="[null]"
- period2_date="[null]"
- period3_mode="[null]"
- period3_param="[null]"
- period3_date="[null]"
- period4_mode="[null]"
- period4_param="[null]"
- period4_date="[null]"
- period5_mode="[null]"
- period5_param="[null]"
- period5_date="[null]"
- created_at="1229727600000"
- build_date="1229727600000"
- version="1.0"
- status="P"
- islast="[true]"/>
-
- <snapshots id="103"
- uuid="u103"
- component_uuid="CDEF"
- root_component_uuid="ABCD"
- root_snapshot_id="101"
- parent_snapshot_id="102"
- scope="FIL"
- qualifier="CLA"
- path="101.102."
- depth="2"
- purge_status="[null]"
- period1_mode="[null]"
- period1_param="[null]"
- period1_date="[null]"
- period2_mode="[null]"
- period2_param="[null]"
- period2_date="[null]"
- period3_mode="[null]"
- period3_param="[null]"
- period3_date="[null]"
- period4_mode="[null]"
- period4_param="[null]"
- period4_date="[null]"
- period5_mode="[null]"
- period5_param="[null]"
- period5_date="[null]"
- created_at="1229727600000"
- build_date="1229727600000"
- version="1.0"
- status="P"
- islast="[true]"/>
-
- <snapshots id="104"
- uuid="u104"
- component_uuid="DEFG"
- root_component_uuid="ABCD"
- root_snapshot_id="101"
- parent_snapshot_id="102"
- scope="FIL"
- qualifier="CLA"
- path="101.102."
- depth="2"
- purge_status="[null]"
- period1_mode="[null]"
- period1_param="[null]"
- period1_date="[null]"
- period2_mode="[null]"
- period2_param="[null]"
- period2_date="[null]"
- period3_mode="[null]"
- period3_param="[null]"
- period3_date="[null]"
- period4_mode="[null]"
- period4_param="[null]"
- period4_date="[null]"
- period5_mode="[null]"
- period5_param="[null]"
- period5_date="[null]"
- created_at="1229727600000"
- build_date="1229727600000"
- version="1.0"
- status="P"
- islast="[true]"/>
-
<resource_index id="1"
kee="java class1"
position="0"
name_size="12"
- component_uuid="ABCD"
- root_component_uuid="ABCD"
- qualifier="CLA"/>
+ component_uuid="FILE1"
+ root_component_uuid="UUID_JAVA_PROJECT"
+ qualifier="FIL"/>
<resource_index id="2"
kee="java class2"
position="1"
name_size="12"
- component_uuid="BCDE"
- root_component_uuid="ABCD"
- qualifier="CLA"/>
+ component_uuid="FILE2"
+ root_component_uuid="UUID_JAVA_PROJECT"
+ qualifier="FIL"/>
<resource_index id="3"
kee="java%class3"
position="2"
name_size="12"
- component_uuid="CDEF"
- root_component_uuid="ABCD"
- qualifier="CLA"/>
+ component_uuid="FILE3"
+ root_component_uuid="UUID_JAVA_PROJECT"
+ qualifier="FIL"/>
<resource_index id="4"
kee="java%class4"
position="3"
name_size="12"
- component_uuid="DEFG"
- root_component_uuid="ABCD"
- qualifier="CLA"/>
+ component_uuid="FILE4"
+ root_component_uuid="UUID_JAVA_PROJECT"
+ qualifier="FIL"/>
</dataset>
hidden="[false]"
delete_historical_data="[null]"/>
- <projects uuid="UUID_JAVA_PROJECT"
- uuid_path="NOT_USED"
+ <projects id="1"
+ uuid="UUID_JAVA_PROJECT"
+ uuid_path="."
+ project_uuid="UUID_JAVA_PROJECT"
description="[null]"
enabled="[true]"
language="[null]"
scope="PRJ"
qualifier="TRK"
name="Java project"
- id="1"
- root_uuid="UUID_JAVA_PROJECT"/>
+ root_uuid="NOT_USED"
+ copy_component_uuid="[null]"
+ />
<snapshots id="101"
uuid="u101"
variation_value_5="400"
alert_text="[null]"
text_value="[null]"
- component_uuid="ABCD"
+ component_uuid="UUID_JAVA_PROJECT"
alert_status="[null]"
description="[null]"/>
variation_value_5="400"
alert_text="[null]"
text_value="[null]"
- component_uuid="ABCD"
+ component_uuid="UUID_JAVA_PROJECT"
alert_status="[null]"
description="[null]"/>
variation_value_5="400"
alert_text="[null]"
text_value="[null]"
- component_uuid="ABCD"
+ component_uuid="UUID_JAVA_PROJECT"
alert_status="[null]"
description="[null]"/>
delete_historical_data="[null]"/>
<projects uuid="UUID_JAVA_PROJECT"
- uuid_path="NOT_USED"
+ uuid_path="."
+ project_uuid="UUID_JAVA_PROJECT"
description="[null]"
enabled="[true]"
language="[null]"
variation_value_5="400"
alert_text="[null]"
text_value="[null]"
- component_uuid="ABCD"
+ component_uuid="UUID_JAVA_PROJECT"
alert_status="[null]"
description="[null]"
person_id="[null]"/>
delete_historical_data="[null]"/>
<!-- java project -->
- <projects uuid="UUID_JAVA_PROJECT"
- uuid_path="NOT_USED"
+ <projects id="1"
+ uuid="UUID_JAVA_PROJECT"
+ uuid_path="."
project_uuid="UUID_JAVA_PROJECT"
description="[null]"
enabled="[true]"
scope="PRJ"
qualifier="TRK"
name="Java project"
- id="1"
- root_uuid="UUID_JAVA_PROJECT"/>
+ root_uuid="NOT_USED"
+ copy_component_uuid="[null]"
+ />
- <projects uuid="BCDE"
- uuid_path="NOT_USED"
+ <projects id="2"
+ uuid="UUID_JAVA_DIR"
+ uuid_path=".UUID_JAVA_PROJECT."
project_uuid="UUID_JAVA_PROJECT"
description="[null]"
enabled="[true]"
created_at="2008-12-19 00:00:00.00"
kee="java_project:org.sonar.foo"
scope="DIR"
- qualifier="PAC"
- long_name="org.sonar.foo"
- name="org.sonar.foo"
- id="2"
- root_uuid="UUID_JAVA_PROJECT"/>
+ qualifier="DIR"
+ long_name="org/sonar/foo"
+ name="org/sonar/foo"
+ root_uuid="NOT_USED"
+ copy_component_uuid="[null]"
+ />
- <projects uuid="CDEF"
- uuid_path="NOT_USED"
+ <projects id="3"
+ uuid="UUID_JAVA_BIG_FILE"
+ uuid_path=".UUID_JAVA_PROJECT.UUID_JAVA_DIR."
project_uuid="UUID_JAVA_PROJECT"
description="[null]"
enabled="[true]"
created_at="2008-12-19 00:00:00.00"
kee="java_project:org.sonar.foo.Big"
scope="FIL"
- qualifier="CLA"
- long_name="org.sonar.foo.Big"
- name="Big"
- id="3"
- root_uuid="UUID_JAVA_PROJECT"/>
+ qualifier="FIL"
+ long_name="org/sonar/foo/Big.java"
+ name="Big.java"
+ root_uuid="NOT_USED"
+ copy_component_uuid="[null]"
+ />
- <projects uuid="DEFG"
- uuid_path="NOT_USED"
+ <projects id="4"
+ uuid="UUID_JAVA_TINY_FILE"
+ uuid_path=".UUID_JAVA_PROJECT.UUID_JAVA_DIR."
project_uuid="UUID_JAVA_PROJECT"
description="[null]"
enabled="[true]"
created_at="2008-12-19 00:00:00.00"
kee="java_project:org.sonar.foo.Tiny"
scope="FIL"
- qualifier="CLA"
- long_name="org.sonar.foo.Tiny"
+ qualifier="FIL"
+ long_name="org/sonar/foo/Tiny.java"
name="Tiny"
- id="4"
- root_uuid="UUID_JAVA_PROJECT"/>
+ root_uuid="NOT_USED"
+ copy_component_uuid="[null]"
+ />
<snapshots id="101"
uuid="u101"
<snapshots id="102"
uuid="u102"
- component_uuid="BCDE"
+ component_uuid="UUID_JAVA_DIR"
root_component_uuid="UUID_JAVA_PROJECT"
root_snapshot_id="101"
parent_snapshot_id="101"
<snapshots id="103"
uuid="u103"
- component_uuid="CDEF"
+ component_uuid="UUID_JAVA_BIG_FILE"
root_component_uuid="UUID_JAVA_PROJECT"
root_snapshot_id="101"
parent_snapshot_id="102"
scope="FIL"
- qualifier="CLA"
+ qualifier="FIL"
path="101.102."
depth="2"
purge_status="[null]"
<snapshots id="104"
uuid="u104"
- component_uuid="DEFG"
+ component_uuid="UUID_JAVA_TINY_FILE"
root_component_uuid="UUID_JAVA_PROJECT"
root_snapshot_id="101"
parent_snapshot_id="102"
scope="FIL"
- qualifier="CLA"
+ qualifier="FIL"
path="101.102."
depth="2"
purge_status="[null]"
variation_value_5="400"
alert_text="[null]"
text_value="[null]"
- component_uuid="ABCD"
+ component_uuid="UUID_JAVA_PROJECT"
alert_status="[null]"
description="[null]"/>
text_value="[null]"
alert_status="[null]"
description="[null]"
- component_uuid="BCDE"/>
+ component_uuid="UUID_JAVA_DIR"/>
<project_measures id="1003"
metric_id="1"
text_value="[null]"
alert_status="[null]"
description="[null]"
- component_uuid="CDEF"/>
+ component_uuid="UUID_JAVA_BIG_FILE"/>
<project_measures id="1004"
metric_id="1"
text_value="[null]"
alert_status="[null]"
description="[null]"
- component_uuid="DEFG"/>
+ component_uuid="UUID_JAVA_TINY_FILE"/>
<!-- profile of java project -->
<project_measures id="1005"
variation_value_5="[null]"
alert_text="[null]"
text_value="Sonar way"
- component_uuid="ABCD"
+ component_uuid="UUID_JAVA_PROJECT"
alert_status="[null]"
description="[null]"/>
variation_value_5="[null]"
alert_text="[null]"
text_value="Sonar way"
- component_uuid="ABCD"
+ component_uuid="UUID_JAVA_PROJECT"
alert_status="[null]"
description="[null]"/>
<!-- php project -->
- <projects uuid="UUID_PHP_PROJECT"
- uuid_path="NOT_USED"
+ <projects id="10"
+ uuid="UUID_PHP_PROJECT"
+ uuid_path="."
project_uuid="UUID_PHP_PROJECT"
description="[null]"
enabled="[true]"
scope="PRJ"
qualifier="TRK"
name="PHP project"
- id="10"
- root_uuid="UUID_JAVA_PROJECT"/>
+ root_uuid="NOT_USED"
+ copy_component_uuid="[null]"
+ />
<snapshots id="110"
variation_value_5="4900"
alert_text="[null]"
text_value="[null]"
- component_uuid="EFGH"
+ component_uuid="UUID_PHP_PROJECT"
alert_status="[null]"
description="[null]"/>
variation_value_5="[null]"
alert_text="[null]"
text_value="php way"
- component_uuid="EFGH"
+ component_uuid="UUID_PHP_PROJECT"
alert_status="[null]"
description="[null]"/>
delete_historical_data="[null]"/>
<!-- java project -->
- <projects uuid="UUID_JAVA_PROJECT"
- uuid_path="NOT_USED"
+ <projects id="1"
+ uuid="UUID_JAVA_PROJECT"
+ uuid_path="."
+ project_uuid="UUID_JAVA_PROJECT"
description="[null]"
enabled="[true]"
language="[null]"
scope="PRJ"
qualifier="TRK"
name="Java project"
- id="1"
- root_uuid="UUID_JAVA_PROJECT"/>
+ root_uuid="NOT_USED"
+ copy_component_uuid="[null]"
+ />
<snapshots id="101"
uuid="u101"
variation_value_5="400"
alert_text="[null]"
text_value="WARN"
- component_uuid="ABCD"
+ component_uuid="UUID_JAVA_PROJECT"
alert_status="[null]"
description="[null]"/>
<!-- php project -->
- <projects uuid="UUID_PHP_PROJECT"
- uuid_path="NOT_USED"
+ <projects id="10"
+ uuid="UUID_PHP_PROJECT"
+ uuid_path="."
+ project_uuid="UUID_PHP_PROJECT"
description="[null]"
enabled="[true]"
language="[null]"
scope="PRJ"
qualifier="TRK"
name="PHP project"
- id="10"
- root_uuid="UUID_PHP_PROJECT"/>
+ root_uuid="NOT_USED"
+ copy_component_uuid="[null]"
+ />
<snapshots id="110"
value="5000"
snapshot_id="110"
analysis_uuid="u110"
- url="[null]"
variation_value_1="[null]"
variation_value_2="[null]"
variation_value_3="[null]"
variation_value_5="[null]"
alert_text="[null]"
text_value="OK"
- component_uuid="BCDE"
+ component_uuid="UUID_PHP_PROJECT"
alert_status="[null]"
description="[null]"/>
<!-- js project -->
- <projects uuid="CDEF"
- uuid_path="NOT_USED"
+ <projects uuid="UUID_JS_PROJECT"
+ uuid_path="."
+ project_uuid="UUID_JS_PROJECT"
description="[null]"
enabled="[true]"
language="[null]"
qualifier="TRK"
name="JS project"
id="20"
- root_uuid="CDEF"/>
+ root_uuid="NOT_USED"
+ copy_component_uuid="[null]"
+ />
<snapshots id="120"
uuid="u120"
- component_uuid="CDEF"
- root_component_uuid="CDEF"
+ component_uuid="UUID_JS_PROJECT"
+ root_component_uuid="UUID_JS_PROJECT"
root_snapshot_id="[null]"
parent_snapshot_id="[null]"
scope="PRJ"
variation_value_5="[null]"
alert_text="[null]"
text_value="ERROR"
- component_uuid="CDEF"
+ component_uuid="UUID_JS_PROJECT"
alert_status="[null]"
description="[null]"/>
-
</dataset>
hash = {}
components_json = []
filter.rows.each do |row|
- component = row.snapshot.resource
+ component = row.resource
component_hash = {}
component_hash[:key] = component.key
component_hash[:name] = component.name if fields.include?('name') && component.name
component_hash[:longName] = component.long_name if fields.include?('longName') && component.long_name
component_hash[:qualifier] = component.qualifier if component.qualifier
component_hash[:favorite] = logged_in? && current_user.favourite?(component.id) if fields.include?('favourite')
- component_hash[:date] = Api::Utils.format_datetime(row.snapshot.created_at) if fields.include?('date') && row.snapshot.created_at
- component_hash[:fdate] = human_short_date(row.snapshot.created_at) if fields.include?('date') && row.snapshot.created_at
+ component_hash[:date] = Api::Utils.format_datetime(row.analysis.created_at) if fields.include?('date') && row.analysis.created_at
+ component_hash[:fdate] = human_short_date(row.analysis.created_at) if fields.include?('date') && row.analysis.created_at
if display_links && row.links
links_hash = {}
redirect_to :action => 'index', :id => params[:id]
end
- @snapshot=@project.last_snapshot
- @snapshots = Snapshot.all(:conditions => ["status='P' AND component_uuid=?", @project.uuid],
+ @snapshot = @project.last_snapshot
+ @analyses = Snapshot.all(:conditions => ["status='P' AND component_uuid=?", @project.uuid],
:include => 'events', :order => 'snapshots.created_at DESC')
end
end
elsif column.key=='name'
- "#{qualifier_icon(row.snapshot)} #{link_to(h(row.snapshot.resource.name(true)), {:controller => 'dashboard', :id => row.snapshot.resource_id}, {:title => h(row.snapshot.resource.key)})}"
+ "#{qualifier_icon(row.resource)} #{link_to(h(row.resource.name(true)), {:controller => 'dashboard', :id => row.resource.id}, {:title => h(row.resource.key)})}"
elsif column.key=='short_name'
- "#{qualifier_icon(row.snapshot)} #{link_to(h(row.snapshot.resource.name(false)), {:controller => 'dashboard', :id => row.snapshot.resource_id}, {:title => h(row.snapshot.resource.key)})}"
+ "#{qualifier_icon(row.resource)} #{link_to(h(row.resource.name(false)), {:controller => 'dashboard', :id => row.resource.id}, {:title => h(row.resource.key)})}"
elsif column.key=='date'
- human_short_date(row.snapshot.created_at)
+ human_short_date(row.analysis.created_at) if row.analysis
elsif column.key=='project_creation_date'
- human_short_date(row.snapshot.resource.created_at) if row.snapshot.resource.created_at
+ human_short_date(row.resource.created_at) if row.resource.created_at
elsif column.key=='key'
- "<span class='small'>#{row.snapshot.resource.kee}</span>"
+ "<span class='small'>#{row.resource.kee}</span>"
elsif column.key=='description'
- h row.snapshot.resource.description
+ h row.resource.description
elsif column.key=='version'
- h row.snapshot.version
+ h row.analysis.version if row.analysis
elsif column.key=='language'
- Api::Utils.language_name(row.snapshot.resource.language)
+ Api::Utils.language_name(row.resource.language)
elsif column.key=='links' && row.links
html = ''
row.links.select { |link| link.href.start_with?('http') }.each do |link|
# Row in the table of results
class Row
- attr_reader :snapshot, :measures_by_metric, :links
+ attr_reader :component, :measures_by_metric, :links, :analysis
- def initialize(snapshot)
- @snapshot = snapshot
+ def initialize(component)
+ @component = component
@measures_by_metric = {}
@links = nil
end
def resource
- snapshot.resource
+ component
end
# For internal use
@measures_by_metric[measure.metric] = measure
end
+ # For internal use
+ def set_analysis(analysis)
+ @analysis=analysis
+ end
+
# For internal use
def add_link(link)
@links ||= []
errors.add_to_base(Api::Utils.message("measure_filter.error.#{result.error}"))
else
rows = result.getRows()
- snapshot_ids = filter_authorized_snapshot_ids(rows, controller)
+ component_uuids = filter_authorized_component_uuids(rows, controller)
base_project = filter_authorized_base_project(base_resource, controller)
- load_results(snapshot_ids, base_project)
+ load_results(component_uuids, base_project)
end
self
end
controller.has_role?(:user, base_resource) ? base_resource : nil
end
- def filter_authorized_snapshot_ids(rows, controller)
+ def filter_authorized_component_uuids(rows, controller)
project_uuids = rows.map { |row| row.getRootComponentUuid() }.compact.uniq
authorized_project_uuids = controller.select_authorized(:user, project_uuids)
- snapshot_ids = rows.map { |row| row.getSnapshotId() if authorized_project_uuids.include?(row.getRootComponentUuid()) }.compact
- @security_exclusions = (snapshot_ids.size<rows.size)
+ component_uuids = rows.map { |row| row.getComponentUuid() if authorized_project_uuids.include?(row.getRootComponentUuid()) }.compact
+ @security_exclusions = (component_uuids.size<rows.size)
@pagination = Api::Pagination.new
@pagination.per_page=(criteria(:pageSize)||999999).to_i
@pagination.page=(criteria(:page)||1).to_i
- @pagination.count = snapshot_ids.size
- snapshot_ids[@pagination.offset ... (@pagination.offset+@pagination.limit)] || []
+ @pagination.count = component_uuids.size
+ component_uuids[@pagination.offset ... (@pagination.offset+@pagination.limit)] || []
end
- def load_results(snapshot_ids, base_resource)
+ def load_results(component_uuids, base_resource)
@rows = []
metric_ids = metrics.map(&:id)
- if !snapshot_ids.empty?
- rows_by_snapshot_id = {}
+ if !component_uuids.empty?
+ rows_by_component_uuid = {}
+
+ components = []
+ component_uuids.each_slice(999) do |safe_for_oracle_uuids|
+ components.concat(Project.find(:all, :conditions => ['uuid in (?)', safe_for_oracle_uuids]))
+ end
+ project_uuids = []
+ components.each do |component|
+ row = Row.new(component)
+ rows_by_component_uuid[component.uuid] = row
+ project_uuids << component.project_uuid
+ end
+ project_uuids.uniq!
- snapshots = []
- snapshot_ids.each_slice(999) do |safe_for_oracle_ids|
- snapshots.concat(Snapshot.all(:include => ['project'], :conditions => ['id in (?)', safe_for_oracle_ids]))
+ analysis_by_project_uuid = Snapshot.all(:conditions => ['component_uuid in (?) and islast=?', project_uuids, true]).inject({}) do |hash, analysis|
+ hash[analysis.component_uuid] = analysis
+ hash
end
- snapshots.each do |snapshot|
- row = Row.new(snapshot)
- rows_by_snapshot_id[snapshot.id] = row
+
+ components.each do |component|
+ analysis = analysis_by_project_uuid[component.project_uuid]
+ rows_by_component_uuid[component.uuid].set_analysis(analysis) if analysis
end
- # @rows must be in the same order than the snapshot ids
- snapshot_ids.each do |sid|
- @rows << rows_by_snapshot_id[sid]
+ # @rows must be in the same order than the component uuids
+ component_uuids.each do |uuid|
+ @rows << rows_by_component_uuid[uuid]
end
unless metric_ids.empty?
measures = []
- snapshot_ids.each_slice(999) do |safe_for_oracle_ids|
- measures.concat(ProjectMeasure.all(:conditions =>
- ['person_id is null and snapshot_id in (?) and metric_id in (?)', safe_for_oracle_ids, metric_ids]
+ component_uuids.each_slice(999) do |safe_for_oracle_uuids|
+ measures.concat(ProjectMeasure.all(:include => :analysis, :conditions =>
+ ['project_measures.person_id is null and project_measures.component_uuid in (?) and project_measures.metric_id in (?) and snapshots.islast=?', safe_for_oracle_uuids, metric_ids, true]
))
end
measures.each do |measure|
- row = rows_by_snapshot_id[measure.snapshot_id]
+ row = rows_by_component_uuid[measure.component_uuid]
row.add_measure(measure)
end
end
if require_links?
- project_uuids = []
- rows_by_project_uuid = {}
- snapshots.each do |snapshot|
- project_uuids << snapshot.component_uuid
- rows_by_project_uuid[snapshot.component_uuid] = rows_by_snapshot_id[snapshot.id]
- end
+ uuids_for_links = components.map { |c| c.uuid if c.scope=='PRJ'}.compact.uniq
- links = []
- project_uuids.each_slice(999) do |safe_for_oracle_uuids|
- links.concat(ProjectLink.all(:conditions => {:component_uuid => safe_for_oracle_uuids}, :order => 'link_type'))
- end
- links.each do |link|
- rows_by_project_uuid[link.component_uuid].add_link(link)
+ uuids_for_links.each_slice(999) do |safe_for_oracle_uuids|
+ ProjectLink.all(:conditions => {:component_uuid => safe_for_oracle_uuids}, :order => 'link_type').each do |link|
+ rows_by_component_uuid[link.component_uuid].add_link(link)
+ end
end
end
end
if base_resource
base_snapshot = base_resource.last_snapshot
if base_snapshot
- @base_row = Row.new(base_snapshot)
+ @base_row = Row.new(base_resource)
unless metric_ids.empty?
- base_measures = ProjectMeasure.all(:conditions =>
- ['person_id is null and snapshot_id=? and metric_id in (?)', base_snapshot.id, metric_ids]
+ base_measures = ProjectMeasure.all(:include => :analysis, :conditions =>
+ ['project_measures.person_id is null and project_measures.component_uuid=? and project_measures.metric_id in (?) and snapshots.islast=?', base_resource.uuid, metric_ids, true]
)
base_measures.each do |base_measure|
@base_row.add_measure(base_measure)
include Resourceable
has_many :snapshots, :class_name => 'Snapshot', :foreign_key => 'component_uuid', :primary_key => 'uuid'
- has_many :processed_snapshots, :class_name => 'Snapshot', :foreign_key => 'component_uuid', :primary_key => 'uuid', :conditions => "status='#{Snapshot::STATUS_PROCESSED}' AND qualifier<>'LIB'", :order => 'created_at asc'
has_many :events, :foreign_key => 'component_uuid', :primary_key => 'uuid', :order => 'event_date DESC'
has_many :project_links, :foreign_key => 'component_uuid', :primary_key => 'uuid', :dependent => :delete_all, :order => 'link_type'
has_many :user_roles, :foreign_key => 'resource_id'
HOUR = 1000 * 60 * 60
DAY = 1000 * 60 * 60 * 24
+ belongs_to :analysis, :class_name => 'Snapshot', :foreign_key => 'analysis_uuid', :primary_key => 'uuid'
belongs_to :snapshot
belongs_to :project, :class_name => 'Project', :foreign_key => 'component_uuid', :primary_key => 'uuid'
belongs_to :person, :class_name => 'Project', :foreign_key => 'person_id'
end
end
- def tip
- snapshot.project.tip
- end
-
- def self.find_by_metrics_and_snapshots(metric_ids, snapshot_ids)
- ProjectMeasure.find(:all, :conditions => {:snapshot_id => snapshot_ids, :metric_id => metric_ids})
- end
-
def short_name
metric.short_name
end
<% @filter.rows.each do |row| %>
<tr class="thin <%= cycle 'even', 'odd' -%>">
<% if display_favourites %>
- <td class="thin"><%= link_to_favourite(row.snapshot.resource) -%></td>
+ <td class="thin"><%= link_to_favourite(row.resource) -%></td>
<% end %>
<td class="nowrap">
- <%= qualifier_icon(row.snapshot) -%> <%= link_to(h(row.snapshot.resource.name(true)), {:controller => 'dashboard', :id => row.snapshot.resource_id}, :title => h(row.snapshot.resource.key)) -%>
+ <%= qualifier_icon(row.resource) -%> <%= link_to(h(row.resource.name(true)), {:controller => 'dashboard', :id => row.resource.id}, :title => h(row.resource.key)) -%>
</td>
<td class="sep"></td>
<td>
- <%= h row.snapshot.resource.description -%>
+ <%= h row.resource.description -%>
</td>
<td class="sep"></td>
<td class="nowrap text-right">
<% if filter.base_row %>
<tr class="highlight">
<% if display_favourites %>
- <td class="thin"><%= link_to_favourite(filter.base_row.snapshot.resource) -%></td>
+ <td class="thin"><%= link_to_favourite(filter.base_row.resource) -%></td>
<% end %>
<% filter.display.columns.each do |column| %>
<td class="<%= column.align -%> <%= column.row_css -%>">
<% filter.rows.each do |row| %>
<tr class="<%= cycle 'even', 'odd' -%>">
<% if display_favourites %>
- <td class="thin"><%= link_to_favourite(row.snapshot.resource) -%></td>
+ <td class="thin"><%= link_to_favourite(row.resource) -%></td>
<% end %>
<% filter.display.columns.each do |column| %>
<td class="<%= column.align -%> <%= column.row_css -%>">
<%
current_year = nil
current_month = nil
- @snapshots.each_with_index do |snapshot, index|
- time = snapshot.created_at
- version_event = snapshot.event(EventCategory::KEY_VERSION)
- alert_event = snapshot.event(EventCategory::KEY_ALERT)
- profile_event = snapshot.event(EventCategory::KEY_PROFILE)
- other_events = snapshot.events.select{|e| e.category!=EventCategory::KEY_VERSION && e.category!=EventCategory::KEY_ALERT && e.category!=EventCategory::KEY_PROFILE}
+ @analyses.each_with_index do |analysis, index|
+ time = analysis.created_at
+ version_event = analysis.event(EventCategory::KEY_VERSION)
+ alert_event = analysis.event(EventCategory::KEY_ALERT)
+ profile_event = analysis.event(EventCategory::KEY_PROFILE)
+ other_events = analysis.events.select{|e| e.category!=EventCategory::KEY_VERSION && e.category!=EventCategory::KEY_ALERT && e.category!=EventCategory::KEY_PROFILE}
%>
<tr class="<%= cycle 'even','odd' -%> snapshot">
<td class="small edit_actions" style="padding-left:20px">
<a id="version_<%= index -%>_change" href="#" onclick="$j('#version_<%= index -%>').hide();$j('#version_<%= index -%>_form').show();$j('#version_name_<%= index -%>').focus();return false;"><%= message('project_history.rename_version') -%></a>
- <% if version_event && !snapshot.islast? %>
+ <% if version_event && !analysis.islast? %>
<%= link_to( message('project_history.remove_version'),
- { :action => 'delete_version', :sid => snapshot.id},
+ { :action => 'delete_version', :sid => analysis.id},
:confirm => message('project_history.do_you_want_to_remove_version', :params => version_event.name) ) -%>
<% end %>
</td>
</tr>
<tr id="version_<%= index -%>_form" style="display:none;">
<td coslpan="2" class="admin">
- <% form_tag( {:action => 'update_version', :sid => snapshot.id }) do -%>
+ <% form_tag( {:action => 'update_version', :sid => analysis.id }) do -%>
<input id="version_name_<%= index -%>" name="version_name" type="text" value="<%= version_event ? h(version_event.name) : '' -%>"
onKeyUp="if (this.value=='') $j('#save_version_<%= index -%>').disabled='true'; else $j('#save_version_<%= index -%>').disabled='';"/>
<%= submit_tag message('save'), :id => 'save_version_' + index.to_s %>
</tr>
<tr id="create_event_<%= index -%>_form" style="display:none;">
<td colspan="2" class="admin">
- <% form_tag( {:action => 'create_event', :sid => snapshot.id }) do -%>
+ <% form_tag( {:action => 'create_event', :sid => analysis.id }) do -%>
<input id="create_event_name_<%= index -%>" name="event_name" type="text" value=""
onKeyUp="if (this.value=='') $j('#create_save_event_<%= index -%>').disabled='true'; else $j('#create_save_event_<%= index -%>').disabled='';"/>
<%= submit_tag message('save'), :id => 'create_save_event_' + index.to_s %>
<td class="thin nowrap text-right" style="padding-left:10px; padding-right:10px">
<%
cell_content = nil;
- if snapshot.islast?
+ if analysis.islast?
cell_content = "<b>" + message('project_history.last_snapshot') + "</b>"
else
cell_content = button_to( message('project_history.delete_snapshot'),
- { :action => "delete_snapshot_history", :id => @project.id, :snapshot_id => snapshot.id },
+ { :action => "delete_snapshot_history", :id => @project.id, :snapshot_id => analysis.id },
:class => 'button-red',
:confirm => message('project_history.are_you_sure_delete_snapshot_x', :params => l(time, :format => :long)) )
end
private String uuid;
/**
- * Not empty path of ancestor UUIDS, including self. Value is suffixed by a dot in
- * order to support LIKE conditions when requesting descendants of a component.
+ * Not empty path of ancestor UUIDS, excluding itself. Value is suffixed by a dot in
+ * order to support LIKE conditions when requesting descendants of a component
+ * and to avoid Oracle NULL on root components.
* Example:
- * - on root module: UUID="1" UUID_PATH="1."
- * - on module: UUID="2" UUID_PATH="1.2."
- * - on directory: UUID="3" UUID_PATH="1.2.3."
- * - on file: UUID="4" UUID_PATH="1.2.3.4."
- * - on view: UUID="5" UUID_PATH="5."
- * - on sub-view: UUID="6" UUID_PATH="5.6."
+ * - on root module: UUID="1" UUID_PATH="."
+ * - on module: UUID="2" UUID_PATH=".1."
+ * - on directory: UUID="3" UUID_PATH=".1.2."
+ * - on file: UUID="4" UUID_PATH="1.2.3."
+ * - on view: UUID="5" UUID_PATH="."
+ * - on sub-view: UUID="6" UUID_PATH=".5."
*
* @since 6.0
*/
return this;
}
- /**
- * No need to have public visibility as this field
- * is supposed to be used only internally in SQL requests.
- */
- String getUuidPath() {
+ public String getUuidPath() {
return uuidPath;
}
return ToKey.INSTANCE;
}
- public static Function<ComponentDto, Long> toId() {
- return ToId.INSTANCE;
- }
-
public static Function<ComponentDto, String> toProjectUuid() {
return ToProjectUuid.INSTANCE;
}
return ToUuid.INSTANCE;
}
- private enum ToId implements Function<ComponentDto, Long> {
- INSTANCE;
-
- @Override
- public Long apply(@Nonnull ComponentDto input) {
- return input.getId();
- }
- }
-
private enum ToKey implements Function<ComponentDto, String> {
INSTANCE;
*/
package org.sonar.db.measure;
+import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
-import java.util.Set;
-import javax.annotation.CheckForNull;
-import javax.annotation.Nullable;
+import java.util.Optional;
import org.sonar.db.Dao;
import org.sonar.db.DbSession;
-import org.sonar.db.component.SnapshotDto;
-import static com.google.common.collect.FluentIterable.from;
-import static java.util.Collections.emptyList;
import static org.sonar.db.DatabaseUtils.executeLargeInputs;
public class MeasureDao implements Dao {
+ public Optional<MeasureDto> selectSingle(DbSession dbSession, MeasureQuery query) {
+ List<MeasureDto> measures = selectByQuery(dbSession, query);
+ return Optional.ofNullable(Iterables.getOnlyElement(measures, null));
+ }
+
public List<MeasureDto> selectByQuery(DbSession dbSession, MeasureQuery query) {
if (query.returnsEmpty()) {
return Collections.emptyList();
});
}
- public boolean existsByKey(DbSession session, String componentKey, String metricKey) {
- return mapper(session).countByComponentAndMetric(componentKey, metricKey) > 0;
- }
-
- @CheckForNull
- public MeasureDto selectByComponentKeyAndMetricKey(DbSession session, String componentKey, String metricKey) {
- return mapper(session).selectByComponentAndMetric(componentKey, metricKey);
- }
-
- public List<MeasureDto> selectByComponentKeyAndMetricKeys(DbSession session, String componentKey, List<String> metricKeys) {
- return executeLargeInputs(
- metricKeys,
- keys -> mapper(session).selectByComponentAndMetrics(componentKey, keys));
- }
-
- /**
- * Selects all measures of a specific snapshot for the specified metric keys.
- * <p/>
- * Used by Views.
- */
- public List<MeasureDto> selectBySnapshotIdAndMetricKeys(long snapshotId, Set<String> metricKeys, DbSession dbSession) {
- return executeLargeInputs(from(metricKeys).toSortedList(String.CASE_INSENSITIVE_ORDER),
- keys -> mapper(dbSession).selectBySnapshotAndMetricKeys(snapshotId, keys));
- }
-
- public List<PastMeasureDto> selectByComponentUuidAndProjectSnapshotIdAndMetricIds(DbSession session, String componentUuid, long projectSnapshotId,
- Set<Integer> metricIds) {
- return executeLargeInputs(
- metricIds,
- ids -> mapper(session).selectByComponentUuidAndProjectSnapshotIdAndStatusAndMetricIds(componentUuid, projectSnapshotId, ids,
- SnapshotDto.STATUS_PROCESSED));
- }
-
- /**
- * Used by plugin Developer Cockpit
- */
- public List<MeasureDto> selectByDeveloperForSnapshotAndMetrics(DbSession dbSession, @Nullable Long developerId, long snapshotId,
+ public List<PastMeasureDto> selectPastMeasures(DbSession dbSession,
+ String componentUuid,
+ String analysisUuid,
Collection<Integer> metricIds) {
return executeLargeInputs(
metricIds,
- input -> mapper(dbSession).selectByDeveloperForSnapshotAndMetrics(developerId, snapshotId, input));
- }
-
- /**
- * Used by plugin Developer Cockpit
- */
- public List<MeasureDto> selectBySnapshotAndMetrics(DbSession dbSession, long snapshotId, Collection<Integer> metricIds) {
- return executeLargeInputs(
- metricIds,
- input -> mapper(dbSession).selectBySnapshotAndMetrics(snapshotId, input));
- }
-
- /**
- * Used by plugin Developer Cockpit
- */
- public List<MeasureDto> selectBySnapshotIdsAndMetricIds(DbSession dbSession, List<Long> snapshotIds, List<Integer> metricIds) {
- return selectByDeveloperAndSnapshotIdsAndMetricIds(dbSession, null, snapshotIds, metricIds);
- }
-
- public List<String> selectMetricKeysForSnapshot(DbSession session, long snapshotId) {
- return mapper(session).selectMetricKeysForSnapshot(snapshotId);
- }
-
- public List<MeasureDto> selectByDeveloperAndSnapshotIdsAndMetricIds(DbSession dbSession, @Nullable Long developerId, List<Long> snapshotIds, List<Integer> metricIds) {
- if (snapshotIds.isEmpty() || metricIds.isEmpty()) {
- return emptyList();
- }
-
- return executeLargeInputs(
- snapshotIds,
- snapshotIdsPartition -> mapper(dbSession).selectByDeveloperAndSnapshotIdsAndMetricIds(developerId, snapshotIdsPartition, metricIds));
- }
-
- /**
- * Retrieves all measures associated to a specific developer and to the last snapshot of any project.
- * <strong>property {@link MeasureDto#componentId} of the returned objects is populated</strong>
- *
- * Used by Developer Cockpit
- */
- public List<MeasureDto> selectProjectMeasuresByDeveloperForMetrics(DbSession dbSession, long developerId, Collection<Integer> metricIds) {
- return mapper(dbSession).selectProjectMeasuresByDeveloperForMetrics(developerId, metricIds);
+ ids -> mapper(dbSession).selectPastMeasures(componentUuid, analysisUuid, ids));
}
public void insert(DbSession session, MeasureDto measureDto) {
private static final String INDEX_SHOULD_BE_IN_RANGE_FROM_1_TO_5 = "Index should be in range from 1 to 5";
private static final int MAX_TEXT_VALUE_LENGTH = 4000;
- private Long id;
private Double value;
private String textValue;
private byte[] dataValue;
private String componentUuid;
private Long snapshotId;
private String analysisUuid;
- private Integer metricId;
+ private int metricId;
private Long developerId;
- // TODO to delete – not in db
- private String metricKey;
-
- public Long getId() {
- return id;
- }
-
- public MeasureDto setId(Long id) {
- this.id = id;
- return this;
- }
-
@CheckForNull
public Double getValue() {
return value;
return this;
}
+ public void setSnapshotId(Long l) {
+ this.snapshotId = l;
+ }
+
@CheckForNull
public String getData() {
if (dataValue != null) {
return this;
}
- public Integer getMetricId() {
+ public int getMetricId() {
return metricId;
}
- public MeasureDto setMetricId(Integer metricId) {
+ public MeasureDto setMetricId(int metricId) {
this.metricId = metricId;
return this;
}
- public Long getSnapshotId() {
- return snapshotId;
- }
-
- public MeasureDto setSnapshotId(Long snapshotId) {
- this.snapshotId = snapshotId;
- return this;
- }
-
public String getAnalysisUuid() {
return analysisUuid;
}
return this;
}
- /**
- * @deprecated in 5.5. Does nothing. Kept for compatibility with developer cockpit plugin, version 1.10
- */
- @Deprecated
- public MeasureDto setRuleId(@Nullable Integer ruleId) {
- return this;
- }
-
@CheckForNull
public Long getDeveloperId() {
return developerId;
return this;
}
- public String getMetricKey() {
- return metricKey;
- }
-
- public MeasureDto setMetricKey(String metricKey) {
- this.metricKey = metricKey;
- return this;
- }
-
- /**
- * @deprecated in 5.5. Does nothing. Kept for compatibility with developer cockpit plugin, version 1.10
- */
- @Deprecated
- public MeasureDto setCharacteristicId(@Nullable Integer characteristicId) {
- return this;
- }
-
@Override
public String toString() {
return MoreObjects.toStringHelper(this)
- .add("id", id)
.add("value", value)
.add("textValue", textValue)
.add("dataValue", dataValue)
.add("alertText", alertText)
.add("description", description)
.add("componentUuid", componentUuid)
- .add("snapshotId", snapshotId)
.add("analysisUuid", analysisUuid)
.add("metricId", metricId)
.add("developerId", developerId)
- .add("metricKey", metricKey)
.toString();
}
}
*/
package org.sonar.db.measure;
-import java.util.Collection;
import java.util.List;
-import javax.annotation.CheckForNull;
-import javax.annotation.Nullable;
import org.apache.ibatis.annotations.Param;
public interface MeasureMapper {
List<MeasureDto> selectByQuery(@Param("query") MeasureQuery query);
- MeasureDto selectByKey(@Param("componentKey") String componentKey, @Param("metricKey") String metricKey);
- List<MeasureDto> selectByComponentAndMetrics(@Param("componentKey") String componentKey, @Param("metricKeys") List<String> metricKeys);
-
- List<MeasureDto> selectBySnapshotAndMetricKeys(@Param("snapshotId") long snapshotId, @Param("metricKeys") List<String> metricKeys);
-
- List<MeasureDto> selectByDeveloperForSnapshotAndMetrics(@Nullable @Param("developerId") Long developerId, @Param("snapshotId") long snapshotId,
- @Param("metricIds") List<Integer> metricIds);
-
- List<MeasureDto> selectBySnapshotAndMetrics(@Param("snapshotId") long snapshotId, @Param("metricIds") List<Integer> input);
-
- List<MeasureDto> selectByDeveloperAndSnapshotIdsAndMetricIds(@Nullable @Param("developerId") Long developerId, @Param("snapshotIds") List<Long> snapshotIds,
- @Param("metricIds") List<Integer> metricIds);
-
- List<MeasureDto> selectProjectMeasuresByDeveloperForMetrics(@Param("developerId") long developerId, @Param("metricIds") Collection<Integer> metricIds);
-
- @CheckForNull
- MeasureDto selectByComponentAndMetric(@Param("componentKey") String componentKey, @Param("metricKey") String metricKey);
-
- long countByComponentAndMetric(@Param("componentKey") String componentKey, @Param("metricKey") String metricKey);
-
- List<PastMeasureDto> selectByComponentUuidAndProjectSnapshotIdAndStatusAndMetricIds(@Param("componentUuid") String componentuuid, @Param("rootSnapshotId") long rootSnapshotId,
- @Param("metricIds") List<Integer> metricIds, @Param("status") String status);
+ List<PastMeasureDto> selectPastMeasures(@Param("componentUuid") String componentUuid, @Param("analysisUuid") String analysisUuid, @Param("metricIds") List<Integer> metricIds);
void insert(MeasureDto measureDto);
- List<String> selectMetricKeysForSnapshot(@Param("snapshotId") long snapshotId);
}
import javax.annotation.Nullable;
import static com.google.common.base.Preconditions.checkState;
+import static java.util.Collections.singleton;
+import static java.util.Collections.singletonList;
public class MeasureQuery {
private final List<String> componentUuids;
+
+ @CheckForNull
private final Collection<Integer> metricIds;
+
+ @CheckForNull
+ private final Collection<String> metricKeys;
+
+ @CheckForNull
private final Long personId;
private MeasureQuery(Builder builder) {
- this(builder.componentUuids, builder.metricIds, builder.personId);
+ this(builder.componentUuids, builder.metricIds, builder.metricKeys, builder.personId);
}
- private MeasureQuery(List<String> componentUuids, @CheckForNull Collection<Integer> metricIds, @Nullable Long personId) {
+ private MeasureQuery(List<String> componentUuids,
+ @Nullable Collection<Integer> metricIds,
+ @Nullable Collection<String> metricKeys,
+ @Nullable Long personId) {
checkState(componentUuids != null, "Component UUIDs must be set");
+ checkState(metricIds == null || metricKeys == null, "Metric IDs and keys must not be set both");
this.componentUuids = componentUuids;
this.metricIds = metricIds;
+ this.metricKeys = metricKeys;
this.personId = personId;
}
return metricIds;
}
+ @CheckForNull
+ public Collection<String> getMetricKeys() {
+ return metricKeys;
+ }
+
@CheckForNull
public Long getPersonId() {
return personId;
public boolean returnsEmpty() {
return componentUuids.isEmpty()
- || (metricIds != null && metricIds.isEmpty());
+ || (metricIds != null && metricIds.isEmpty())
+ || (metricKeys != null && metricKeys.isEmpty());
+ }
+
+ public static Builder builder() {
+ return new Builder();
}
- public static MeasureQuery copyWithSubsetOfComponentUuids(MeasureQuery query, List<String> componentUuids) {
- return new MeasureQuery(componentUuids, query.metricIds, query.personId);
+ static MeasureQuery copyWithSubsetOfComponentUuids(MeasureQuery query, List<String> componentUuids) {
+ return new MeasureQuery(componentUuids, query.metricIds, query.metricKeys, query.personId);
}
public static final class Builder {
private List<String> componentUuids;
private Collection<Integer> metricIds;
+ private Collection<String> metricKeys;
private Long personId;
+ private Builder() {
+ }
+
public Builder setComponentUuids(List<String> componentUuids) {
this.componentUuids = componentUuids;
return this;
}
+ public Builder setComponentUuid(String componentUuid) {
+ this.componentUuids = singletonList(componentUuid);
+ return this;
+ }
+
/**
* All the measures are returned if parameter is {@code null}.
*/
return this;
}
+ public Builder setMetricId(int metricId) {
+ this.metricIds = singleton(metricId);
+ return this;
+ }
+
+ /**
+ * All the measures are returned if parameter is {@code null}.
+ */
+ public Builder setMetricKeys(@Nullable Collection<String> s) {
+ this.metricKeys = s;
+ return this;
+ }
+
+ public Builder setMetricKey(String s) {
+ this.metricKeys = singleton(s);
+ return this;
+ }
+
public Builder setPersonId(@Nullable Long l) {
this.personId = l;
return this;
*/
package org.sonar.db.measure;
-import java.util.Objects;
import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
+import static java.util.Objects.requireNonNull;
+
public class PastMeasureDto {
- private Long id;
- private Double value;
- private Integer metricId;
- private Integer personId;
+ private int metricId;
- public Long getId() {
- return id;
- }
+ @CheckForNull
+ private Double value;
- public PastMeasureDto setId(Long id) {
- this.id = id;
- return this;
- }
+ @CheckForNull
+ private Long personId;
public double getValue() {
- Objects.requireNonNull(value);
+ requireNonNull(value);
return value;
}
return value != null;
}
- public Integer getMetricId() {
+ public int getMetricId() {
return metricId;
}
- public PastMeasureDto setMetricId(Integer metricId) {
- this.metricId = metricId;
+ public PastMeasureDto setMetricId(int i) {
+ this.metricId = i;
return this;
}
@CheckForNull
- public Integer getPersonId() {
+ public Long getPersonId() {
return personId;
}
- public PastMeasureDto setPersonId(@Nullable Integer personId) {
- this.personId = personId;
+ public PastMeasureDto setPersonId(@Nullable Long l) {
+ this.personId = l;
return this;
}
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.sonar.db.measure.MeasureMapper">
+
<sql id="measureColumns">
- pm.id,
pm.metric_id as metricId,
pm.person_id as developerId,
pm.component_uuid as componentUuid,
- pm.snapshot_id as snapshotId,
pm.analysis_uuid as analysisUuid,
pm.value as value,
pm.text_value as textValue,
metric.name as metricKey
</sql>
-
<select id="selectByQuery" parameterType="map" resultType="Measure">
- select
- <include refid="measureColumns"/>
+ select <include refid="measureColumns"/>
from project_measures pm
- inner join snapshots s on s.id = pm.snapshot_id
+ inner join snapshots analysis on analysis.uuid = pm.analysis_uuid
where
- pm.component_uuid in
+ analysis.islast=${_true}
+ and pm.component_uuid in
<foreach item="componentUuid" collection="query.getComponentUuids()" open="(" separator="," close=")">
#{componentUuid}
</foreach>
- and s.islast=${_true}
<if test="query.getMetricIds() != null">
and pm.metric_id in
<foreach item="metricId" collection="query.getMetricIds()" open="(" separator="," close=")">#{metricId}</foreach>
</if>
+ <if test="query.getMetricKeys() != null">
+ and pm.metric_id in (select id from metrics where name in <foreach item="metricKey" collection="query.getMetricKeys()" open="(" separator="," close=")">#{metricKey}</foreach>)
+ </if>
<choose>
<when test="query.getPersonId() != null">
and person_id = #{query.personId}
</choose>
</select>
- <select id="selectByComponentUuidsAndMetricIds" parameterType="map" resultType="Measure">
- select
- <include refid="measureColumns"/>
+ <select id="selectPastMeasures" parameterType="map" resultType="org.sonar.db.measure.PastMeasureDto">
+ select pm.id as id, pm.metric_id as metricId, pm.person_id as personId, pm.value as value
from project_measures pm
- inner join snapshots s on s.id = pm.snapshot_id
+ inner join snapshots analysis on analysis.uuid = pm.analysis_uuid
where
- s.islast=${_true}
- and pm.component_uuid in
- <foreach item="componentUuid" collection="componentUuids" open="(" separator="," close=")">#{componentUuid}
- </foreach>
- and pm.person_id is null
- and pm.metric_id in
- <foreach item="metricId" collection="metricIds" open="(" separator="," close=")">#{metricId}</foreach>
- </select>
-
- <select id="selectByComponentAndMetric" parameterType="map" resultType="Measure">
- SELECT metric.name as metric_name,
- <include refid="extendedMeasureColumns"/>
- FROM project_measures pm
- INNER JOIN snapshots s ON s.id=pm.snapshot_id AND s.islast=${_true}
- INNER JOIN projects p ON p.uuid=pm.component_uuid AND p.enabled=${_true}
- INNER JOIN metrics metric ON metric.id=pm.metric_id
- <where>
- AND p.kee = #{componentKey}
- AND metric.name=#{metricKey}
- AND pm.person_id IS NULL
- </where>
- </select>
-
- <select id="selectByComponentAndMetrics" parameterType="map" resultType="Measure">
- SELECT metric.name as metric_name,
- <include refid="extendedMeasureColumns"/>
- FROM project_measures pm
- INNER JOIN snapshots s ON s.id=pm.snapshot_id AND s.islast=${_true}
- INNER JOIN projects p ON p.uuid=pm.component_uuid AND p.enabled=${_true}
- INNER JOIN metrics metric ON metric.id=pm.metric_id
- <where>
- AND p.kee = #{componentKey}
- AND
- <foreach item="metricKey" index="index" collection="metricKeys" open="(" separator=" or " close=")">
- metric.name=#{metricKey}
- </foreach>
- AND pm.person_id IS NULL
- </where>
- </select>
-
- <select id="selectBySnapshotAndMetricKeys" parameterType="map" resultType="Measure">
- SELECT
- <include refid="measureColumns"/>
- FROM project_measures pm
- INNER JOIN metrics metric ON metric.id=pm.metric_id
- <where>
- AND pm.snapshot_id = #{snapshotId}
- AND
- <foreach item="metricKey" index="index" collection="metricKeys" open="(" separator=" or " close=")">
- metric.name=#{metricKey}
- </foreach>
- AND pm.person_id IS NULL
- </where>
- </select>
-
- <select id="selectByDeveloperForSnapshotAndMetrics" parameterType="map" resultType="Measure">
- SELECT
- <include refid="measureColumns"/>
- FROM project_measures pm
- <where>
- pm.snapshot_id = #{snapshotId}
- <if test="developerId!=null">
- AND pm.person_id = #{developerId}
- </if>
- <if test="developerId==null">
- AND pm.person_id is NULL
- </if>
- AND
- <foreach item="metricId" index="index" collection="metricIds" open="(" separator=" or " close=")">
- pm.metric_id=#{metricId}
- </foreach>
- </where>
- </select>
-
- <select id="selectByDeveloperAndSnapshotIdsAndMetricIds" parameterType="map" resultType="Measure">
- SELECT
- <include refid="measureColumns"/>
- FROM project_measures pm
- <where>
- pm.snapshot_id in
- <foreach item="snapshotId" collection="snapshotIds" open="(" separator="," close=")">
- #{snapshotId}
- </foreach>
- AND
- pm.metric_id in
- <foreach item="metricId" collection="metricIds" open="(" separator="," close=")">
- #{metricId}
- </foreach>
- <if test="developerId==null">
- AND pm.person_id is NULL
- </if>
- <if test="developerId!=null">
- AND pm.person_id=#{developerId}
- </if>
- </where>
- </select>
-
- <select id="selectProjectMeasuresByDeveloperForMetrics" parameterType="map" resultType="Measure">
- SELECT
- <include refid="measureColumns"/>,
- p.id as componentId
- FROM project_measures pm
- INNER JOIN snapshots s ON s.id=pm.snapshot_id AND s.islast=${_true} AND s.scope='PRJ' AND s.qualifier='TRK'
- INNER JOIN projects p ON p.uuid=s.component_uuid
- <where>
- pm.person_id = #{developerId}
- AND
- pm.metric_id in
- <foreach item="metricId" collection="metricIds" open="(" separator="," close=")">
- #{metricId}
- </foreach>
- </where>
- </select>
-
- <select id="selectBySnapshotAndMetrics" parameterType="map" resultType="Measure">
- SELECT
- <include refid="measureColumns"/>
- FROM project_measures pm
- <where>
- pm.snapshot_id = #{snapshotId}
- AND pm.person_id is NULL
- AND
- <foreach item="metricId" index="index" collection="metricIds" open="(" separator=" or " close=")">
- pm.metric_id=#{metricId}
- </foreach>
- </where>
- </select>
-
- <select id="countByComponentAndMetric" parameterType="map" resultType="long">
- SELECT count(pm.id)
- FROM project_measures pm
- INNER JOIN snapshots s ON s.id=pm.snapshot_id AND s.islast=${_true}
- INNER JOIN metrics metric ON metric.id=pm.metric_id
- INNER JOIN projects p ON p.uuid=s.component_uuid AND p.enabled=${_true}
- WHERE
- p.kee = #{componentKey}
- AND metric.name = #{metricKey}
- AND pm.person_id IS NULL
- </select>
-
- <select id="selectByComponentUuidAndProjectSnapshotIdAndStatusAndMetricIds" parameterType="map"
- resultType="org.sonar.db.measure.PastMeasureDto">
- SELECT pm.id as id, pm.metric_id as metricId,
- pm.person_id as personId, pm.value as value
- FROM project_measures pm
- INNER JOIN snapshots s ON s.id=pm.snapshot_id AND s.status=#{status}
- INNER JOIN projects p ON p.uuid=s.component_uuid AND p.enabled=${_true}
- WHERE
- <!-- do not filter on pm.component_uuid in order to benefit from index on p.uuid -->
- p.uuid=#{componentUuid}
- AND (s.root_snapshot_id=#{rootSnapshotId} OR s.id=#{rootSnapshotId})
- AND
- <foreach item="metricId" index="index" collection="metricIds" open="(" separator=" or " close=")">
- pm.metric_id=#{metricId}
- </foreach>
- AND pm.person_id IS NULL
+ pm.component_uuid = #{componentUuid}
+ and analysis.uuid = #{analysisUuid}
+ and pm.metric_id in <foreach item="metricId" collection="metricIds" open="(" separator="," close=")">#{metricId}</foreach>
+ and pm.person_id is null
</select>
<insert id="insert" parameterType="Measure" useGeneratedKeys="false">
- INSERT INTO project_measures (
+ insert into project_measures (
value,
metric_id,
component_uuid,
#{value, jdbcType=DOUBLE},
#{metricId, jdbcType=INTEGER},
#{componentUuid, jdbcType=VARCHAR},
- #{snapshotId, jdbcType=INTEGER},
+ #{snapshotId, jdbcType=BIGINT},
#{analysisUuid, jdbcType=VARCHAR},
#{textValue, jdbcType=VARCHAR},
#{alertStatus, jdbcType=VARCHAR},
)
</insert>
- <select id="selectMetricKeysForSnapshot" parameterType="long" resultType="string">
- SELECT DISTINCT m.name
- FROM project_measures pm
- INNER JOIN metrics m ON m.id=pm.metric_id
- WHERE pm.snapshot_id=#{snapshotId}
- </select>
-
</mapper>
*/
package org.sonar.db.component;
-import org.apache.commons.lang.RandomStringUtils;
import org.assertj.core.util.Strings;
import static com.google.common.base.Preconditions.checkNotNull;
+import static org.apache.commons.lang.RandomStringUtils.randomAlphanumeric;
+import static org.apache.commons.lang.RandomStringUtils.randomAscii;
public class SnapshotTesting {
checkNotNull(component.getId(), "The project need to be persisted before creating this snapshot");
checkNotNull(rootComponentUuid, "Root component uuid is null");
return new SnapshotDto()
- .setUuid(RandomStringUtils.randomAlphanumeric(40))
+ .setUuid(randomAlphanumeric(40))
.setComponentUuid(component.uuid())
.setRootComponentUuid(rootComponentUuid)
.setStatus(SnapshotDto.STATUS_PROCESSED)
.setLast(true);
}
+ public static SnapshotDto newSnapshot() {
+ return new SnapshotDto()
+ .setUuid(randomAlphanumeric(40))
+ .setComponentUuid(randomAlphanumeric(40))
+ .setRootComponentUuid(randomAlphanumeric(40))
+ .setStatus(randomAscii(1))
+ .setQualifier(randomAscii(3))
+ .setScope(randomAscii(3))
+ .setCreatedAt(System.currentTimeMillis())
+ .setBuildDate(System.currentTimeMillis())
+ .setLast(true);
+ }
}
*/
package org.sonar.db.measure;
-import com.google.common.base.Function;
-import com.google.common.base.Optional;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableSet;
-import java.util.Collections;
import java.util.List;
-import java.util.Map;
-import javax.annotation.Nullable;
+import java.util.Optional;
import org.junit.Rule;
import org.junit.Test;
+import org.junit.rules.ExpectedException;
import org.sonar.api.utils.System2;
-import org.sonar.db.DbClient;
-import org.sonar.db.DbSession;
import org.sonar.db.DbTester;
-import org.sonar.db.component.ComponentDbTester;
-import org.sonar.db.component.ComponentDto;
-import org.sonar.db.component.ComponentTesting;
-import org.sonar.db.component.SnapshotDto;
-import org.sonar.db.metric.MetricDto;
-import org.sonar.db.metric.MetricTesting;
+import org.sonar.db.component.SnapshotTesting;
-import static com.google.common.collect.FluentIterable.from;
-import static com.google.common.collect.Lists.newArrayList;
-import static com.google.common.collect.Sets.newHashSet;
+import static java.util.Arrays.asList;
import static java.util.Collections.emptyList;
-import static java.util.Collections.singletonList;
import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.guava.api.Assertions.assertThat;
-import static org.sonar.db.component.ComponentTesting.newDevProjectCopy;
-import static org.sonar.db.component.ComponentTesting.newDeveloper;
-import static org.sonar.db.component.ComponentTesting.newFileDto;
-import static org.sonar.db.component.ComponentTesting.newProjectDto;
-import static org.sonar.db.measure.MeasureTesting.newMeasureDto;
public class MeasureDaoTest {
- private static final int SNAPSHOT_ID = 5;
- private static final long DEVELOPER_ID = 333L;
- private static final int AUTHORS_BY_LINE_METRIC_ID = 10;
- private static final int COVERAGE_LINE_HITS_DATA_METRIC_ID = 11;
+ private static final int COVERAGE_METRIC_ID = 10;
+ private static final int COMPLEXITY_METRIC_ID = 11;
private static final int NCLOC_METRIC_ID = 12;
+ private static final long A_PERSON_ID = 444L;
@Rule
- public DbTester db = DbTester.create(System2.INSTANCE);
-
- final DbClient dbClient = db.getDbClient();
- final DbSession dbSession = db.getSession();
-
- MeasureDao underTest = dbClient.measureDao();
- ComponentDbTester componentDb = new ComponentDbTester(db);
-
- @Test
- public void get_value_by_key() {
- db.prepareDbUnit(getClass(), "shared.xml");
-
- MeasureDto result = underTest.selectByComponentKeyAndMetricKey(dbSession, "org.struts:struts-core:src/org/struts/RequestContext.java", "ncloc");
- assertThat(result.getId()).isEqualTo(22);
- assertThat(result.getValue()).isEqualTo(10d);
- assertThat(result.getData()).isNull();
- assertThat(result.getVariation(1)).isEqualTo(1d);
- assertThat(result.getVariation(2)).isEqualTo(2d);
- assertThat(result.getVariation(3)).isEqualTo(3d);
- assertThat(result.getVariation(4)).isEqualTo(4d);
- assertThat(result.getVariation(5)).isEqualTo(-5d);
- assertThat(result.getAlertStatus()).isEqualTo("OK");
- assertThat(result.getAlertText()).isEqualTo("Green");
- }
-
- @Test
- // TODO the string must be longer than 4000 char to be persisted in the data field
- public void get_data_by_key() {
- db.prepareDbUnit(getClass(), "shared.xml");
-
- MeasureDto result = underTest.selectByComponentKeyAndMetricKey(dbSession, "org.struts:struts-core:src/org/struts/RequestContext.java", "authors_by_line");
- assertThat(result.getId()).isEqualTo(20);
- assertThat(result.getData()).isEqualTo("0123456789012345678901234567890123456789");
- }
-
- @Test
- public void get_text_value_by_key() {
- db.prepareDbUnit(getClass(), "shared.xml");
-
- MeasureDto result = underTest.selectByComponentKeyAndMetricKey(dbSession, "org.struts:struts-core:src/org/struts/RequestContext.java", "coverage_line_hits_data");
- assertThat(result.getId()).isEqualTo(21);
- assertThat(result.getData()).isEqualTo("36=1;37=1;38=1;39=1;43=1;48=1;53=1");
- }
-
- @Test
- public void select_by_component_key_and_metrics() {
- db.prepareDbUnit(getClass(), "shared.xml");
-
- List<MeasureDto> results = underTest.selectByComponentKeyAndMetricKeys(dbSession, "org.struts:struts-core:src/org/struts/RequestContext.java",
- newArrayList("ncloc", "authors_by_line"));
- assertThat(results).hasSize(2);
-
- results = underTest.selectByComponentKeyAndMetricKeys(dbSession, "org.struts:struts-core:src/org/struts/RequestContext.java", newArrayList("ncloc"));
- assertThat(results).hasSize(1);
-
- MeasureDto result = results.get(0);
- assertThat(result.getId()).isEqualTo(22);
- assertThat(result.getValue()).isEqualTo(10d);
- assertThat(result.getMetricKey()).isEqualTo("ncloc");
- assertThat(result.getVariation(1)).isEqualTo(1d);
- assertThat(result.getVariation(2)).isEqualTo(2d);
- assertThat(result.getVariation(3)).isEqualTo(3d);
- assertThat(result.getVariation(4)).isEqualTo(4d);
- assertThat(result.getVariation(5)).isEqualTo(-5d);
- }
-
- @Test
- public void select_by_snapshotId_and_metrics() {
- db.prepareDbUnit(getClass(), "shared.xml");
-
- List<MeasureDto> results = underTest.selectBySnapshotIdAndMetricKeys(SNAPSHOT_ID, ImmutableSet.of("ncloc", "authors_by_line"), dbSession);
- assertThat(results).hasSize(2);
-
- Optional<MeasureDto> optional = from(results).filter(input -> input.getId() == 22).first();
- assertThat(optional).isPresent();
-
- MeasureDto result = optional.get();
- assertThat(result.getId()).isEqualTo(22);
- assertThat(result.getMetricId()).isEqualTo(12);
- assertThat(result.getMetricKey()).isNull();
- assertThat(result.getValue()).isEqualTo(10d);
- assertThat(result.getVariation(1)).isEqualTo(1d);
- assertThat(result.getVariation(2)).isEqualTo(2d);
- assertThat(result.getVariation(3)).isEqualTo(3d);
- assertThat(result.getVariation(4)).isEqualTo(4d);
- assertThat(result.getVariation(5)).isEqualTo(-5d);
- }
-
- @Test
- public void find_by_component_key_and_metric() {
- db.prepareDbUnit(getClass(), "shared.xml");
-
- MeasureDto result = underTest.selectByComponentKeyAndMetricKey(dbSession, "org.struts:struts-core:src/org/struts/RequestContext.java", "ncloc");
- assertThat(result.getId()).isEqualTo(22);
- assertThat(result.getValue()).isEqualTo(10d);
- assertThat(result.getMetricKey()).isEqualTo("ncloc");
- assertThat(result.getVariation(1)).isEqualTo(1d);
- assertThat(result.getVariation(2)).isEqualTo(2d);
- assertThat(result.getVariation(3)).isEqualTo(3d);
- assertThat(result.getVariation(4)).isEqualTo(4d);
- assertThat(result.getVariation(5)).isEqualTo(-5d);
-
- assertThat(underTest.selectByComponentKeyAndMetricKey(dbSession, "org.struts:struts-core:src/org/struts/RequestContext.java", "unknown")).isNull();
- }
-
- @Test
- public void exists_by_key() {
- db.prepareDbUnit(getClass(), "shared.xml");
+ public ExpectedException expectedException = ExpectedException.none();
- assertThat(underTest.existsByKey(dbSession, "org.struts:struts-core:src/org/struts/RequestContext.java", "ncloc")).isTrue();
- assertThat(underTest.existsByKey(dbSession, "org.struts:struts-core:src/org/struts/RequestContext.java", "unknown")).isFalse();
- }
-
- @Test
- public void select_past_measures_by_component_uuid_and_root_snapshot_id_and_metric_keys() {
- db.prepareDbUnit(getClass(), "past_measures.xml");
-
- Map<Long, PastMeasureDto> fileMeasures = pastMeasuresById(underTest.selectByComponentUuidAndProjectSnapshotIdAndMetricIds(dbSession, "CDEF", 1000L, ImmutableSet.of(1, 2)));
- assertThat(fileMeasures).hasSize(2);
-
- PastMeasureDto fileMeasure1 = fileMeasures.get(5L);
- assertThat(fileMeasure1.getValue()).isEqualTo(5d);
- assertThat(fileMeasure1.getMetricId()).isEqualTo(1);
- assertThat(fileMeasure1.getPersonId()).isNull();
-
- PastMeasureDto fileMeasure2 = fileMeasures.get(6L);
- assertThat(fileMeasure2.getValue()).isEqualTo(60d);
- assertThat(fileMeasure2.getMetricId()).isEqualTo(2);
-
- Map<Long, PastMeasureDto> projectMeasures = pastMeasuresById(underTest.selectByComponentUuidAndProjectSnapshotIdAndMetricIds(dbSession, "ABCD", 1000L, ImmutableSet.of(1, 2)));
- assertThat(projectMeasures).hasSize(2);
-
- PastMeasureDto projectMeasure1 = projectMeasures.get(1L);
- assertThat(projectMeasure1.getValue()).isEqualTo(60d);
- assertThat(projectMeasure1.getMetricId()).isEqualTo(1);
-
- PastMeasureDto projectMeasure2 = projectMeasures.get(2L);
- assertThat(projectMeasure2.getValue()).isEqualTo(80d);
- assertThat(projectMeasure2.getMetricId()).isEqualTo(2);
-
- assertThat(underTest.selectByComponentUuidAndProjectSnapshotIdAndMetricIds(dbSession, "UNKNOWN", 1000L, ImmutableSet.of(1, 2))).isEmpty();
- assertThat(underTest.selectByComponentUuidAndProjectSnapshotIdAndMetricIds(dbSession, "CDEF", 987654L, ImmutableSet.of(1, 2))).isEmpty();
- assertThat(underTest.selectByComponentUuidAndProjectSnapshotIdAndMetricIds(dbSession, "CDEF", 1000L, ImmutableSet.of(123, 456))).isEmpty();
- }
-
- @Test
- public void select_past_measures_ignore_measures_with_person_id() {
- db.prepareDbUnit(getClass(), "past_measures_with_person_id.xml");
-
- List<PastMeasureDto> measures = underTest.selectByComponentUuidAndProjectSnapshotIdAndMetricIds(dbSession, "ABCD", 1000L, ImmutableSet.of(1));
- assertThat(measures).hasSize(1);
-
- Map<Long, PastMeasureDto> pastMeasuresById = pastMeasuresById(measures);
-
- PastMeasureDto measure1 = pastMeasuresById.get(1L);
- assertThat(measure1.getPersonId()).isNull();
- }
-
- @Test
- public void select_by_snapshot_and_metric_keys() throws Exception {
- db.prepareDbUnit(getClass(), "select_by_snapshot_and_metric_keys.xml");
-
- List<MeasureDto> results = underTest.selectBySnapshotIdAndMetricKeys(SNAPSHOT_ID, newHashSet("ncloc", "authors_by_line"), dbSession);
- assertThat(results).hasSize(2);
-
- results = underTest.selectBySnapshotIdAndMetricKeys(SNAPSHOT_ID, newHashSet("ncloc"), dbSession);
- assertThat(results).hasSize(1);
-
- MeasureDto result = results.get(0);
- assertThat(result.getId()).isEqualTo(22);
- assertThat(result.getValue()).isEqualTo(10d);
- assertThat(result.getVariation(1)).isEqualTo(1d);
- assertThat(result.getVariation(2)).isEqualTo(2d);
- assertThat(result.getVariation(3)).isEqualTo(3d);
- assertThat(result.getVariation(4)).isEqualTo(4d);
- assertThat(result.getVariation(5)).isEqualTo(-5d);
-
- assertThat(underTest.selectBySnapshotIdAndMetricKeys(123, newHashSet("ncloc"), dbSession)).isEmpty();
- assertThat(underTest.selectBySnapshotIdAndMetricKeys(SNAPSHOT_ID, Collections.<String>emptySet(), dbSession)).isEmpty();
- }
-
- @Test
- public void selectByDeveloperForSnapshotAndMetrics_when_there_is_no_measure_for_developer_returns_empty() {
- db.prepareDbUnit(getClass(), "shared.xml");
-
- List<MeasureDto> measureDtos = underTest.selectByDeveloperForSnapshotAndMetrics(dbSession,
- DEVELOPER_ID, SNAPSHOT_ID,
- ImmutableList.of(AUTHORS_BY_LINE_METRIC_ID, COVERAGE_LINE_HITS_DATA_METRIC_ID, NCLOC_METRIC_ID));
-
- assertThat(measureDtos).isEmpty();
- }
-
- @Test
- public void selectByDeveloperForSnapshotAndMetrics_returns_only_measures_for_developer() {
- db.prepareDbUnit(getClass(), "with_some_measures_for_developer.xml");
-
- List<MeasureDto> measureDtos = underTest.selectByDeveloperForSnapshotAndMetrics(dbSession,
- DEVELOPER_ID, SNAPSHOT_ID,
- ImmutableList.of(AUTHORS_BY_LINE_METRIC_ID, COVERAGE_LINE_HITS_DATA_METRIC_ID, NCLOC_METRIC_ID));
-
- assertThat(measureDtos).extracting("id").containsOnly(30L, 31L, 32L);
- }
-
- @Test
- public void selectByDeveloperForSnapshotAndMetrics_returns_only_measures_for_developer_and_specified_metric_id() {
- db.prepareDbUnit(getClass(), "with_some_measures_for_developer.xml");
-
- List<MeasureDto> measureDtos = underTest.selectByDeveloperForSnapshotAndMetrics(dbSession,
- DEVELOPER_ID, SNAPSHOT_ID,
- ImmutableList.of(NCLOC_METRIC_ID));
-
- assertThat(measureDtos).extracting("id").containsOnly(32L);
- }
-
- @Test
- public void selectBySnapshotAndMetrics_returns_empty_when_single_metric_id_does_not_exist() {
- db.prepareDbUnit(getClass(), "with_some_measures_for_developer.xml");
-
- List<MeasureDto> measureDtos = underTest.selectBySnapshotAndMetrics(dbSession,
- SNAPSHOT_ID,
- ImmutableList.of(666));
-
- assertThat(measureDtos).isEmpty();
- }
-
- @Test
- public void selectBySnapshotAndMetrics_returns_only_measures_not_for_developer() {
- db.prepareDbUnit(getClass(), "with_some_measures_for_developer.xml");
-
- List<MeasureDto> measureDtos = underTest.selectBySnapshotAndMetrics(dbSession,
- SNAPSHOT_ID,
- ImmutableList.of(AUTHORS_BY_LINE_METRIC_ID, COVERAGE_LINE_HITS_DATA_METRIC_ID, NCLOC_METRIC_ID));
-
- assertThat(measureDtos).extracting("id").containsOnly(20L, 21L, 22L);
- }
-
- @Test
- public void selectBySnapshotAndMetrics_returns_only_measures_not_for_developer_and_with_specified_metric_id() {
- db.prepareDbUnit(getClass(), "with_some_measures_for_developer.xml");
-
- List<MeasureDto> measureDtos = underTest.selectBySnapshotAndMetrics(dbSession,
- SNAPSHOT_ID,
- ImmutableList.of(NCLOC_METRIC_ID));
-
- assertThat(measureDtos).extracting("id").containsOnly(22L);
- }
-
- @Test
- public void selectByDeveloperForSnapshotAndMetrics_returns_empty_when_single_metric_id_does_not_exist() {
- db.prepareDbUnit(getClass(), "with_some_measures_for_developer.xml");
-
- List<MeasureDto> measureDtos = underTest.selectByDeveloperForSnapshotAndMetrics(dbSession,
- DEVELOPER_ID, SNAPSHOT_ID,
- ImmutableList.of(666));
-
- assertThat(measureDtos).isEmpty();
- }
-
- @Test
- public void selectByDeveloperForSnapshotAndMetrics_returns_empty_when_snapshotId_does_not_exist() {
- db.prepareDbUnit(getClass(), "with_some_measures_for_developer.xml");
-
- List<MeasureDto> measureDtos = underTest.selectByDeveloperForSnapshotAndMetrics(dbSession,
- DEVELOPER_ID, 10,
- ImmutableList.of(AUTHORS_BY_LINE_METRIC_ID, COVERAGE_LINE_HITS_DATA_METRIC_ID, NCLOC_METRIC_ID));
+ @Rule
+ public DbTester db = DbTester.create(System2.INSTANCE);
- assertThat(measureDtos).isEmpty();
- }
+ private MeasureDao underTest = db.getDbClient().measureDao();
@Test
- public void selectSnapshotIdsAndMetricIds() {
- MetricDto metric = dbClient.metricDao().insert(dbSession, MetricTesting.newMetricDto());
- ComponentDto project = newProjectDto();
- SnapshotDto projectSnapshot = componentDb.insertProjectAndSnapshot(project);
- SnapshotDto fileSnapshot = componentDb.insertComponentAndSnapshot(newFileDto(project, "file-uuid"), projectSnapshot);
- ComponentDto developer = newDeveloper("Ray Bradbury");
- SnapshotDto developerSnapshot = componentDb.insertDeveloperAndSnapshot(developer);
- componentDb.insertComponentAndSnapshot(newDevProjectCopy("project-copy-uuid", project, developer), developerSnapshot);
- underTest.insert(dbSession,
- newMeasureDto(metric, developerSnapshot).setDeveloperId(developer.getId()),
- newMeasureDto(metric, projectSnapshot),
- newMeasureDto(metric, fileSnapshot));
- dbSession.commit();
+ public void test_inserted_and_selected_columns() {
+ insertAnalysis("A1", true);
- List<MeasureDto> result = underTest.selectBySnapshotIdsAndMetricIds(dbSession,
- newArrayList(developerSnapshot.getId(), projectSnapshot.getId(), fileSnapshot.getId()),
- singletonList(metric.getId()));
+ MeasureDto inserted = new MeasureDto()
+ .setAnalysisUuid("A1")
+ .setMetricId(2)
+ .setDeveloperId(3L)
+ .setComponentUuid("C4")
+ .setValue(5.0d)
+ .setData("data")
+ .setVariation(1, 1.0d)
+ .setVariation(2, 2.0d)
+ .setVariation(3, 3.0d)
+ .setVariation(4, 4.0d)
+ .setVariation(5, 5.0d)
+ .setAlertStatus("alert")
+ .setAlertText("alert-text")
+ .setDescription("measure-description");
+ underTest.insert(db.getSession(), inserted);
+ db.commit();
- assertThat(result)
- .hasSize(2)
- .extracting("snapshotId")
- .containsOnly(projectSnapshot.getId(), fileSnapshot.getId())
- .doesNotContain(developerSnapshot.getId());
+ MeasureDto selected = underTest.selectSingle(db.getSession(), MeasureQuery.builder()
+ .setComponentUuid(inserted.getComponentUuid())
+ .setPersonId(inserted.getDeveloperId())
+ .build()).get();
+ assertThat(selected.getAnalysisUuid()).isEqualTo(inserted.getAnalysisUuid());
+ assertThat(selected.getMetricId()).isEqualTo(inserted.getMetricId());
+ assertThat(selected.getDeveloperId()).isEqualTo(inserted.getDeveloperId());
+ assertThat(selected.getComponentUuid()).isEqualTo(inserted.getComponentUuid());
+ assertThat(selected.getValue()).isEqualTo(inserted.getValue());
+ assertThat(selected.getData()).isEqualTo(inserted.getData());
+ assertThat(selected.getVariation(1)).isEqualTo(inserted.getVariation(1));
+ assertThat(selected.getVariation(2)).isEqualTo(inserted.getVariation(2));
+ assertThat(selected.getVariation(3)).isEqualTo(inserted.getVariation(3));
+ assertThat(selected.getVariation(4)).isEqualTo(inserted.getVariation(4));
+ assertThat(selected.getVariation(5)).isEqualTo(inserted.getVariation(5));
+ assertThat(selected.getAlertStatus()).isEqualTo(inserted.getAlertStatus());
+ assertThat(selected.getAlertText()).isEqualTo(inserted.getAlertText());
}
@Test
- public void selectDeveloperAndSnapshotIdsAndMetricIds() {
- MetricDto metric = dbClient.metricDao().insert(dbSession, MetricTesting.newMetricDto());
- ComponentDto project = newProjectDto();
- SnapshotDto projectSnapshot = componentDb.insertProjectAndSnapshot(project);
- SnapshotDto fileSnapshot = componentDb.insertComponentAndSnapshot(newFileDto(project, "file-uuid"), projectSnapshot);
- ComponentDto developer = newDeveloper("Ray Bradbury");
- SnapshotDto developerSnapshot = componentDb.insertDeveloperAndSnapshot(developer);
- componentDb.insertComponentAndSnapshot(newDevProjectCopy("project-copy-uuid", project, developer), developerSnapshot);
+ public void selectByQuery() {
+ insertAnalysis("A1", false);
+ insertAnalysis("A2", true);
+ // component C1
+ insertMeasure("M1", "A1", "C1", NCLOC_METRIC_ID);
+ insertMeasure("M2", "A2", "C1", NCLOC_METRIC_ID);
+ insertMeasure("M3", "A2", "C1", COVERAGE_METRIC_ID);
+ insertMeasureOnPerson("M4", "A2", "C1", NCLOC_METRIC_ID, A_PERSON_ID);
+ // component C2
+ insertMeasure("M5", "A2", "C2", NCLOC_METRIC_ID);
+ db.commit();
- underTest.insert(dbSession,
- newMeasureDto(metric, developerSnapshot).setDeveloperId(developer.getId()),
- newMeasureDto(metric, projectSnapshot).setDeveloperId(developer.getId()),
- newMeasureDto(metric, projectSnapshot).setDeveloperId(null),
- newMeasureDto(metric, fileSnapshot).setDeveloperId(developer.getId()));
- dbSession.commit();
+ verifyZeroMeasures(MeasureQuery.builder().setComponentUuids(emptyList()));
+ verifyZeroMeasures(MeasureQuery.builder().setComponentUuid("MISSING_COMPONENT"));
- List<MeasureDto> result = underTest.selectByDeveloperAndSnapshotIdsAndMetricIds(dbSession,
- developer.getId(),
- newArrayList(developerSnapshot.getId(), projectSnapshot.getId(), fileSnapshot.getId()),
- singletonList(metric.getId()));
+ // all measures of component C1
+ verifyMeasures(MeasureQuery.builder().setComponentUuid("C1"), "M2", "M3");
- assertThat(result)
- .hasSize(3)
- .extracting("snapshotId")
- .containsOnly(developerSnapshot.getId(), projectSnapshot.getId(), fileSnapshot.getId());
- assertThat(result)
- .extracting("developerId")
- .containsOnly(developer.getId());
- }
+ // ncloc measure of component C1
+ verifyMeasures(MeasureQuery.builder().setComponentUuid("C1").setMetricId(NCLOC_METRIC_ID), "M2");
- @Test
- public void selectDeveloperAndSnapshotIdsAndMetricIds_with_empty_lists() {
- List<MeasureDto> result = underTest.selectByDeveloperAndSnapshotIdsAndMetricIds(dbSession, null, emptyList(), emptyList());
+ // multiple measures of component C1
+ verifyMeasures(MeasureQuery.builder().setComponentUuid("C1").setMetricIds(asList(NCLOC_METRIC_ID, COVERAGE_METRIC_ID)), "M2", "M3");
- assertThat(result).isEmpty();
- }
+ // missing measure of component C1
+ verifyZeroMeasures(MeasureQuery.builder().setComponentUuid("C1").setMetricId(COMPLEXITY_METRIC_ID));
- @Test
- public void selectProjectMeasuresByDeveloperForMetrics_returns_empty_on_empty_db() {
- assertThat(underTest.selectProjectMeasuresByDeveloperForMetrics(dbSession, DEVELOPER_ID, ImmutableList.of(NCLOC_METRIC_ID, AUTHORS_BY_LINE_METRIC_ID))).isEmpty();
- }
+ // ncloc measures of components C1, C2 and C3 (which does not exist)
+ verifyMeasures(MeasureQuery.builder().setComponentUuids(asList("C1", "C2", "C3")), "M2", "M3", "M5");
- @Test
- public void selectProjectMeasuresByDeveloperForMetrics_returns_empty_when_no_measure_for_developer() {
- long otherDeveloperId = 666l;
-
- ComponentDto projectDto = insertProject("aa");
- SnapshotDto snapshotDto = insertSnapshot("u1", projectDto, true);
- insertMeasure(projectDto, snapshotDto, DEVELOPER_ID, NCLOC_METRIC_ID, 12d);
+ // measures of missing developer of component C1
+ verifyZeroMeasures(MeasureQuery.builder().setComponentUuid("C1").setPersonId(123L));
- List<MeasureDto> measureDtos = underTest.selectProjectMeasuresByDeveloperForMetrics(dbSession, DEVELOPER_ID, ImmutableList.of(NCLOC_METRIC_ID));
- assertThat(measureDtos).hasSize(1);
- MeasureDto measureDto = measureDtos.iterator().next();
- assertThat(measureDto.getId()).isNotNull();
- assertThat(measureDto.getMetricId()).isEqualTo(NCLOC_METRIC_ID);
- assertThat(measureDto.getSnapshotId()).isEqualTo(snapshotDto.getId());
- assertThat(measureDto.getComponentUuid()).isEqualTo(projectDto.uuid());
- assertThat(measureDto.getDeveloperId()).isEqualTo(DEVELOPER_ID);
-
- assertThat(underTest.selectProjectMeasuresByDeveloperForMetrics(dbSession, otherDeveloperId, ImmutableList.of(NCLOC_METRIC_ID))).isEmpty();
- assertThat(underTest.selectProjectMeasuresByDeveloperForMetrics(dbSession, DEVELOPER_ID, ImmutableList.of(AUTHORS_BY_LINE_METRIC_ID))).isEmpty();
+ // developer measures of component C1
+ verifyMeasures(MeasureQuery.builder().setComponentUuid("C1").setPersonId(A_PERSON_ID), "M4");
}
@Test
- public void selectProjectMeasuresByDeveloperForMetrics_returns_ignores_measure_of_non_last_snapshot() {
- long otherDeveloperId = 666l;
-
- ComponentDto projectDto = insertProject("aa");
- SnapshotDto nonLastSnapshotDto = insertSnapshot("u1", projectDto, false);
- insertMeasure(projectDto, nonLastSnapshotDto, DEVELOPER_ID, NCLOC_METRIC_ID, 12d);
- SnapshotDto lastSnapshotDto = insertSnapshot("u2", projectDto, true);
- insertMeasure(projectDto, lastSnapshotDto, otherDeveloperId, NCLOC_METRIC_ID, 15d);
+ public void selectSingle() {
+ insertAnalysis("A1", true);
+ insertMeasure("M1", "A1", "C1", NCLOC_METRIC_ID);
+ insertMeasure("M2", "A1", "C1", COMPLEXITY_METRIC_ID);
+ db.commit();
- assertThat(underTest.selectProjectMeasuresByDeveloperForMetrics(dbSession, DEVELOPER_ID, ImmutableList.of(NCLOC_METRIC_ID))).hasSize(0);
+ assertThat(selectSingle(MeasureQuery.builder().setComponentUuids(emptyList()))).isNotPresent();
+ assertThat(selectSingle(MeasureQuery.builder().setComponentUuid("MISSING_COMPONENT"))).isNotPresent();
- List<MeasureDto> measureDtos = underTest.selectProjectMeasuresByDeveloperForMetrics(dbSession, otherDeveloperId, ImmutableList.of(NCLOC_METRIC_ID));
- assertThat(measureDtos).hasSize(1);
- MeasureDto measureDto = measureDtos.iterator().next();
- assertThat(measureDto.getMetricId()).isEqualTo(NCLOC_METRIC_ID);
- assertThat(measureDto.getSnapshotId()).isEqualTo(lastSnapshotDto.getId());
- assertThat(measureDto.getComponentUuid()).isEqualTo(projectDto.uuid());
- assertThat(measureDto.getDeveloperId()).isEqualTo(otherDeveloperId);
- assertThat(measureDto.getValue()).isEqualTo(15d);
- }
-
- @Test
- public void selectProjectMeasuresByDeveloperForMetrics_returns_ignores_snapshots_of_any_component_but_project() {
- ComponentDto projectDto = insertProject("aa");
- insertSnapshot("u1", projectDto, true);
- ComponentDto moduleDto = insertComponent(ComponentTesting.newModuleDto(projectDto));
- insertMeasure(moduleDto, insertSnapshot("u2", moduleDto, true), DEVELOPER_ID, NCLOC_METRIC_ID, 15d);
- ComponentDto dirDto = insertComponent(ComponentTesting.newDirectory(moduleDto, "toto"));
- insertMeasure(dirDto, insertSnapshot("u3", dirDto, true), DEVELOPER_ID, NCLOC_METRIC_ID, 25d);
- ComponentDto fileDto = insertComponent(ComponentTesting.newFileDto(moduleDto, "tutu"));
- insertMeasure(fileDto, insertSnapshot("u4", fileDto, true), DEVELOPER_ID, NCLOC_METRIC_ID, 35d);
+ // select a single measure
+ assertThat(selectSingle(MeasureQuery.builder().setComponentUuid("C1").setMetricId(NCLOC_METRIC_ID))).isPresent();
- assertThat(underTest.selectProjectMeasuresByDeveloperForMetrics(dbSession, DEVELOPER_ID, ImmutableList.of(NCLOC_METRIC_ID))).isEmpty();
+ // select multiple measures -> fail
+ expectedException.expect(IllegalArgumentException.class);
+ expectedException.expectMessage("expected one element");
+ selectSingle(MeasureQuery.builder().setComponentUuid("C1"));
}
- private ComponentDto insertComponent(ComponentDto moduleDto) {
- dbClient.componentDao().insert(dbSession, moduleDto);
- dbSession.commit();
- return moduleDto;
+ private Optional<MeasureDto> selectSingle(MeasureQuery.Builder query) {
+ return underTest.selectSingle(db.getSession(), query.build());
}
- private ComponentDto insertProject(String uuid) {
- ComponentDto projectDto = newProjectDto(uuid);
- return insertComponent(projectDto);
+ private void verifyMeasures(MeasureQuery.Builder query, String... expectedIds) {
+ List<MeasureDto> measures = underTest.selectByQuery(db.getSession(), query.build());
+ assertThat(measures).extracting(MeasureDto::getData).containsOnly(expectedIds);
}
- private SnapshotDto insertSnapshot(String uuid, ComponentDto componentDto, boolean last) {
- SnapshotDto snapshotDto = new SnapshotDto()
- .setUuid(uuid)
- .setComponentUuid(componentDto.uuid())
- .setRootComponentUuid(componentDto.projectUuid())
- .setLast(last)
- .setQualifier(componentDto.qualifier()).setScope(componentDto.scope());
- dbClient.snapshotDao().insert(dbSession, snapshotDto);
- dbSession.commit();
- return snapshotDto;
+ private void verifyZeroMeasures(MeasureQuery.Builder query) {
+ assertThat(underTest.selectByQuery(db.getSession(), query.build())).isEmpty();
}
- private MeasureDto insertMeasure(ComponentDto componentDto, SnapshotDto snapshotDto, Long developerId, int metricId, double value) {
- MeasureDto measureDto = new MeasureDto()
+ private void insertMeasure(String id, String analysisUuid, String componentUuid, int metricId) {
+ MeasureDto measure = MeasureTesting.newMeasure()
+ .setAnalysisUuid(analysisUuid)
+ .setComponentUuid(componentUuid)
.setMetricId(metricId)
- .setValue(value)
- .setComponentUuid(componentDto.uuid())
- .setSnapshotId(snapshotDto.getId())
- .setAnalysisUuid("u1")
- .setDeveloperId(developerId);
- dbClient.measureDao().insert(dbSession, measureDto);
- dbSession.commit();
- return measureDto;
+ // as ids can't be forced when inserting measures, the field "data"
+ // is used to store a virtual id. It is used then in assertions.
+ .setData(id);
+ db.getDbClient().measureDao().insert(db.getSession(), measure);
}
- @Test
- public void insert() {
- db.prepareDbUnit(getClass(), "empty.xml");
-
- underTest.insert(dbSession, new MeasureDto()
- .setSnapshotId(2L)
- .setAnalysisUuid("u2")
- .setMetricId(3)
- .setDeveloperId(23L)
- .setComponentUuid("FILE1")
- .setValue(2.0d)
- .setData("measure-value")
- .setVariation(1, 1.0d)
- .setVariation(2, 2.0d)
- .setVariation(3, 3.0d)
- .setVariation(4, 4.0d)
- .setVariation(5, 5.0d)
- .setAlertStatus("alert")
- .setAlertText("alert-text")
- .setDescription("measure-description"));
- dbSession.commit();
-
- db.assertDbUnit(getClass(), "insert-result.xml", new String[] {"id"}, "project_measures");
+ private void insertMeasureOnPerson(String id, String analysisUuid, String componentUuid, int metricId, long personId) {
+ MeasureDto measure = MeasureTesting.newMeasure()
+ .setAnalysisUuid(analysisUuid)
+ .setComponentUuid(componentUuid)
+ .setMetricId(metricId)
+ .setDeveloperId(personId)
+ // as ids can't be forced when inserting measures, the field "data"
+ // is used to store a virtual id. It is used then in assertions.
+ .setData(id);
+ db.getDbClient().measureDao().insert(db.getSession(), measure);
}
- @Test
- public void insert_measures() {
- db.prepareDbUnit(getClass(), "empty.xml");
-
- underTest.insert(dbSession, new MeasureDto()
- .setSnapshotId(2L)
- .setAnalysisUuid("u2")
- .setMetricId(3)
- .setComponentUuid("COMPONENT_1")
- .setValue(2.0d),
- new MeasureDto()
- .setSnapshotId(3L)
- .setAnalysisUuid("u2")
- .setMetricId(4)
- .setComponentUuid("COMPONENT_2")
- .setValue(4.0d));
- dbSession.commit();
-
- assertThat(db.countRowsOfTable("project_measures")).isEqualTo(2);
+ private void insertAnalysis(String uuid, boolean isLast) {
+ db.getDbClient().snapshotDao().insert(db.getSession(), SnapshotTesting.newSnapshot()
+ .setUuid(uuid)
+ .setLast(isLast));
}
- private static Map<Long, PastMeasureDto> pastMeasuresById(List<PastMeasureDto> pastMeasures) {
- return from(pastMeasures).uniqueIndex(new Function<PastMeasureDto, Long>() {
- @Nullable
- @Override
- public Long apply(PastMeasureDto input) {
- return input.getId();
- }
- });
- }
+ // TODO test selectPastMeasures
}
@Test
public void test_getter_and_setter() throws Exception {
underTest
- .setMetricKey("metric")
- .setId(10L)
.setValue(2d)
.setData("text value")
.setVariation(1, 1d)
.setVariation(4, 4d)
.setVariation(5, 5d);
- assertThat(underTest.getId()).isEqualTo(10);
assertThat(underTest.getValue()).isEqualTo(2d);
assertThat(underTest.getData()).isNotNull();
assertThat(underTest.getVariation(1)).isEqualTo(1d);
*/
package org.sonar.db.measure;
+import org.apache.commons.lang.math.RandomUtils;
import org.sonar.db.component.SnapshotDto;
import org.sonar.db.metric.MetricDto;
import static com.google.common.base.Preconditions.checkNotNull;
public class MeasureTesting {
+
+ private static int cursor = RandomUtils.nextInt(100);
+
private MeasureTesting() {
// static methods only
}
checkNotNull(snapshot.getComponentUuid());
return new MeasureDto()
.setMetricId(metricDto.getId())
- .setMetricKey(metricDto.getKey())
.setComponentUuid(snapshot.getComponentUuid())
- .setSnapshotId(snapshot.getId())
.setAnalysisUuid(snapshot.getUuid());
}
+
+ public static MeasureDto newMeasure() {
+ return new MeasureDto()
+ .setMetricId(cursor++)
+ .setComponentUuid(String.valueOf(cursor++))
+ .setAnalysisUuid(String.valueOf(cursor++))
+ .setDeveloperId(null)
+ .setData(String.valueOf(cursor++))
+ .setAlertStatus(String.valueOf(cursor++))
+ .setAlertText(String.valueOf(cursor++))
+ .setValue((double)cursor++);
+ }
}
@Test
public void test_getter_and_setter() throws Exception {
PastMeasureDto dto = new PastMeasureDto()
- .setId(10L)
.setValue(1d)
.setMetricId(2)
- .setPersonId(5);
+ .setPersonId(5L);
- assertThat(dto.getId()).isEqualTo(10L);
assertThat(dto.hasValue()).isTrue();
assertThat(dto.getValue()).isEqualTo(1d);
assertThat(dto.getMetricId()).isEqualTo(2);
- assertThat(dto.getPersonId()).isEqualTo(5);
+ assertThat(dto.getPersonId()).isEqualTo(5L);
}
@Test
public void test_has_value() throws Exception {
PastMeasureDto measureWithValue = new PastMeasureDto()
- .setId(10L)
.setValue(1d)
.setMetricId(2)
- .setPersonId(5);
+ .setPersonId(5L);
assertThat(measureWithValue.hasValue()).isTrue();
PastMeasureDto measureWithoutValue = new PastMeasureDto()
- .setId(10L)
.setMetricId(2)
- .setPersonId(5);
+ .setPersonId(5L);
assertThat(measureWithoutValue.hasValue()).isFalse();
}
projects / sonarqube.git / commitdiff