}
private static boolean hasAnyVariation(MeasureDto measureDto) {
- for (int i = 1; i < 6; i++) {
- if (measureDto.getVariation(i) != null) {
- return true;
- }
- }
- return false;
+ return measureDto.getVariation() != null;
}
private static MeasureVariations createVariations(MeasureDto measureDto) {
- return new MeasureVariations(
- measureDto.getVariation(1),
- measureDto.getVariation(2),
- measureDto.getVariation(3),
- measureDto.getVariation(4),
- measureDto.getVariation(5));
+ return new MeasureVariations(measureDto.getVariation());
}
}
out.setComponentUuid(component.getUuid());
out.setAnalysisUuid(analysisMetadataHolder.getUuid());
if (measure.hasVariations()) {
- setVariations(out, measure.getVariations());
+ setVariation(out, measure.getVariations());
}
if (measure.hasQualityGateStatus()) {
setAlert(out, measure.getQualityGateStatus());
return out;
}
- private static void setVariations(MeasureDto measureDto, MeasureVariations variations) {
- measureDto.setVariation(1, variations.hasVariation1() ? variations.getVariation1() : null);
- measureDto.setVariation(2, variations.hasVariation2() ? variations.getVariation2() : null);
- measureDto.setVariation(3, variations.hasVariation3() ? variations.getVariation3() : null);
- measureDto.setVariation(4, variations.hasVariation4() ? variations.getVariation4() : null);
- measureDto.setVariation(5, variations.hasVariation5() ? variations.getVariation5() : null);
+ private static void setVariation(MeasureDto measureDto, MeasureVariations variations) {
+ measureDto.setVariation(variations.hasVariation1() ? variations.getVariation1() : null);
}
private static void setAlert(MeasureDto measureDto, QualityGateStatus qualityGateStatus) {
*/
package org.sonar.server.computation.task.projectanalysis.step;
+import java.util.List;
import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
import org.sonar.api.utils.System2;
private final PeriodsHolder periodsHolder;
public PersistAnalysisStep(System2 system2, DbClient dbClient, TreeRootHolder treeRootHolder,
- AnalysisMetadataHolder analysisMetadataHolder, PeriodsHolder periodsHolder) {
+ AnalysisMetadataHolder analysisMetadataHolder, PeriodsHolder periodsHolder) {
this.system2 = system2;
this.dbClient = dbClient;
this.treeRootHolder = treeRootHolder;
DbSession session = dbClient.openSession(false);
try {
new PathAwareCrawler<>(
- new PersistSnapshotsPathAwareVisitor(session, analysisMetadataHolder.getAnalysisDate()))
+ new PersistSnapshotsPathAwareVisitor(session, analysisMetadataHolder.getAnalysisDate()))
.visit(treeRootHolder.getRoot());
session.commit();
} finally {
}
private void updateSnapshotPeriods(SnapshotDto snapshotDto) {
- for (Period period : periodsHolder.getPeriods()) {
- int index = period.getIndex();
- snapshotDto.setPeriodMode(index, period.getMode());
- snapshotDto.setPeriodParam(index, period.getModeParameter());
- snapshotDto.setPeriodDate(index, period.getSnapshotDate());
+ List<Period> periods = periodsHolder.getPeriods();
+ if (periods.isEmpty()) {
+ return;
}
+ Period period = periods.get(0);
+ snapshotDto.setPeriodMode(period.getMode());
+ snapshotDto.setPeriodParam(period.getModeParameter());
+ snapshotDto.setPeriodDate(period.getSnapshotDate());
}
private SnapshotDto createAnalysis(String snapshotUuid, Component component, boolean setVersion) {
String componentUuid = component.getUuid();
return new SnapshotDto()
- .setUuid(snapshotUuid)
- .setVersion(setVersion ? component.getReportAttributes().getVersion() : null)
- .setComponentUuid(componentUuid)
- .setLast(false)
- .setStatus(SnapshotDto.STATUS_UNPROCESSED)
- .setCreatedAt(analysisDate)
- .setBuildDate(system2.now());
+ .setUuid(snapshotUuid)
+ .setVersion(setVersion ? component.getReportAttributes().getVersion() : null)
+ .setComponentUuid(componentUuid)
+ .setLast(false)
+ .setStatus(SnapshotDto.STATUS_UNPROCESSED)
+ .setCreatedAt(analysisDate)
+ .setBuildDate(system2.now());
}
private void persist(SnapshotDto snapshotDto, DbSession dbSession) {
@Test
@UseDataProvider("all_types_MeasureDtos")
public void toMeasure_creates_MeasureVariation_and_maps_the_right_one(MeasureDto builder, Metric metric) {
- assertThat(underTest.toMeasure(builder.setVariation(1, 1d), metric).get().getVariations().getVariation1()).isEqualTo(1);
- assertThat(underTest.toMeasure(builder.setVariation(2, 2d), metric).get().getVariations().getVariation2()).isEqualTo(2);
- assertThat(underTest.toMeasure(builder.setVariation(3, 3d), metric).get().getVariations().getVariation3()).isEqualTo(3);
- assertThat(underTest.toMeasure(builder.setVariation(4, 4d), metric).get().getVariations().getVariation4()).isEqualTo(4);
- assertThat(underTest.toMeasure(builder.setVariation(5, 5d), metric).get().getVariations().getVariation5()).isEqualTo(5);
+ assertThat(underTest.toMeasure(builder.setVariation(1d), metric).get().getVariations().getVariation1()).isEqualTo(1);
}
@Test
public void toMeasure_creates_MeasureVariation_and_maps_the_right_one() {
MeasureDto measureDto = new MeasureDto()
.setData("1")
- .setVariation(2, 2d).setVariation(3, 3d).setVariation(5, 5d);
+ .setVariation(2d);
Optional<Measure> measure = underTest.toMeasure(measureDto, SOME_STRING_METRIC);
- assertThat(measure.get().getVariations().hasVariation1()).isFalse();
- assertThat(measure.get().getVariations().getVariation2()).isEqualTo(2);
- assertThat(measure.get().getVariations().getVariation3()).isEqualTo(3);
- assertThat(measure.get().getVariations().hasVariation4()).isFalse();
- assertThat(measure.get().getVariations().getVariation5()).isEqualTo(5);
+ assertThat(measure.get().getVariations().getVariation1()).isEqualTo(2);
}
@Test
private static final int SOME_COMPONENT_ID = 951;
private static final String SOME_DATA = "some_data";
private static final String SOME_STRING = "some_string";
- private static final MeasureVariations SOME_VARIATIONS = new MeasureVariations(1d, 2d, 3d, 4d, 5d);
+ private static final MeasureVariations SOME_VARIATIONS = new MeasureVariations(1d);
private static final MetricImpl SOME_BOOLEAN_METRIC = new MetricImpl(1, "1", "1", Metric.MetricType.BOOL);
private static final MetricImpl SOME_INT_METRIC = new MetricImpl(2, "2", "2", Metric.MetricType.INT);
private static final MetricImpl SOME_LONG_METRIC = new MetricImpl(3, "3", "3", Metric.MetricType.DISTRIB);
public void toMeasureDto_returns_Dto_without_any_variation_if_Measure_has_no_MeasureVariations(Measure measure, Metric metric) {
MeasureDto measureDto = underTest.toMeasureDto(measure, metric, SOME_COMPONENT);
- assertThat(measureDto.getVariation(1)).isNull();
- assertThat(measureDto.getVariation(2)).isNull();
- assertThat(measureDto.getVariation(3)).isNull();
- assertThat(measureDto.getVariation(4)).isNull();
- assertThat(measureDto.getVariation(5)).isNull();
+ assertThat(measureDto.getVariation()).isNull();
}
@Test
public void toMeasureDto_returns_Dto_with_variation_if_Measure_has_MeasureVariations() {
MeasureDto measureDto = underTest.toMeasureDto(Measure.newMeasureBuilder().setVariations(SOME_VARIATIONS).create(SOME_STRING), SOME_STRING_METRIC, SOME_COMPONENT);
- assertThat(measureDto.getVariation(1)).isEqualTo(1d);
- assertThat(measureDto.getVariation(2)).isEqualTo(2d);
- assertThat(measureDto.getVariation(3)).isEqualTo(3d);
- assertThat(measureDto.getVariation(4)).isEqualTo(4d);
- assertThat(measureDto.getVariation(5)).isEqualTo(5d);
+ assertThat(measureDto.getVariation()).isEqualTo(1d);
}
@Test
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
newMeasureBuilder()
.setVariations(
newMeasureVariationsBuilder()
- .setVariation(createPeriod(1), 1.1d)
- .setVariation(createPeriod(2), 2.2d)
- .setVariation(createPeriod(3), 3.3d)
- .setVariation(createPeriod(4), 4.4d)
- .setVariation(createPeriod(5), 5.5d)
+ .setVariation(createPeriod(), 1.1d)
.build())
.create(10d, 1));
assertThat(dbTester.countRowsOfTable("project_measures")).isEqualTo(1);
List<Map<String, Object>> dtos = selectSnapshots();
Map<String, Object> dto = dtos.get(0);
- assertThat(dto.get("variation_value_1")).isEqualTo(1.1d);
- assertThat(dto.get("variation_value_2")).isEqualTo(2.2d);
- assertThat(dto.get("variation_value_3")).isEqualTo(3.3d);
- assertThat(dto.get("variation_value_4")).isEqualTo(4.4d);
- assertThat(dto.get("variation_value_5")).isEqualTo(5.5d);
+ assertThat(dto.get("variation_value")).isEqualTo(1.1d);
}
@Test
return componentDto;
}
- private static Period createPeriod(Integer index) {
- return new Period(index, "mode" + index, null, index, String.valueOf(index));
+ private static Period createPeriod() {
+ return new Period(1, "mode" + 1, null, 1, "1");
}
private List<Map<String, Object>> selectSnapshots() {
"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_2 as \"variation_value_2\", " +
- "variation_value_3 as \"variation_value_3\", " +
- "variation_value_4 as \"variation_value_4\", " +
- "variation_value_5 as \"variation_value_5\"" +
+ "variation_value_1 as \"variation_value\"" +
"FROM project_measures " +
"ORDER by id asc");
}
import org.sonar.db.component.SnapshotTesting;
import org.sonar.db.organization.OrganizationDto;
import org.sonar.server.computation.task.projectanalysis.analysis.AnalysisMetadataHolderRule;
-import org.sonar.server.computation.task.projectanalysis.component.TreeRootHolderRule;
import org.sonar.server.computation.task.projectanalysis.component.Component;
import org.sonar.server.computation.task.projectanalysis.component.DbIdsRepositoryImpl;
import org.sonar.server.computation.task.projectanalysis.component.ReportComponent;
+import org.sonar.server.computation.task.projectanalysis.component.TreeRootHolderRule;
import org.sonar.server.computation.task.projectanalysis.period.Period;
import org.sonar.server.computation.task.projectanalysis.period.PeriodsHolderRule;
import org.sonar.server.computation.task.step.ComputationStep;
}
@Test
- public void persist_snapshots_with_periods() {
+ public void persist_snapshots_with_leak_period() {
OrganizationDto organizationDto = dbTester.organizations().insert();
ComponentDto projectDto = ComponentTesting.newProjectDto(organizationDto, "ABCD").setKey(PROJECT_KEY).setName("Project");
dbClient.componentDao().insert(dbTester.getSession(), projectDto);
underTest.execute();
SnapshotDto projectSnapshot = getUnprocessedSnapshot(projectDto.uuid());
- assertThat(projectSnapshot.getPeriodMode(1)).isEqualTo(TIMEMACHINE_MODE_DATE);
- assertThat(projectSnapshot.getPeriodDate(1)).isEqualTo(analysisDate);
- assertThat(projectSnapshot.getPeriodModeParameter(1)).isNotNull();
+ assertThat(projectSnapshot.getPeriodMode()).isEqualTo(TIMEMACHINE_MODE_DATE);
+ assertThat(projectSnapshot.getPeriodDate()).isEqualTo(analysisDate);
+ assertThat(projectSnapshot.getPeriodModeParameter()).isNotNull();
}
@Test
- public void only_persist_snapshots_with_periods_on_project_and_module() {
+ public void only_persist_snapshots_with_leak_period_on_project_and_module() {
periodsHolder.setPeriods(new Period(1, TIMEMACHINE_MODE_PREVIOUS_ANALYSIS, null, analysisDate, "u1"));
OrganizationDto organizationDto = dbTester.organizations().insert();
underTest.execute();
SnapshotDto newProjectSnapshot = getUnprocessedSnapshot(projectDto.uuid());
- assertThat(newProjectSnapshot.getPeriodMode(1)).isEqualTo(TIMEMACHINE_MODE_PREVIOUS_ANALYSIS);
+ assertThat(newProjectSnapshot.getPeriodMode()).isEqualTo(TIMEMACHINE_MODE_PREVIOUS_ANALYSIS);
}
@Test
underTest.execute();
SnapshotDto projectSnapshot = getUnprocessedSnapshot(projectDto.uuid());
- assertThat(projectSnapshot.getPeriodMode(1)).isNull();
- assertThat(projectSnapshot.getPeriodDate(1)).isNull();
- assertThat(projectSnapshot.getPeriodModeParameter(1)).isNull();
+ assertThat(projectSnapshot.getPeriodMode()).isNull();
+ assertThat(projectSnapshot.getPeriodDate()).isNull();
+ assertThat(projectSnapshot.getPeriodModeParameter()).isNull();
}
private SnapshotDto getUnprocessedSnapshot(String componentUuid) {
import org.sonar.db.component.SnapshotQuery;
import org.sonar.db.organization.OrganizationDto;
import org.sonar.server.computation.task.projectanalysis.analysis.AnalysisMetadataHolderRule;
-import org.sonar.server.computation.task.projectanalysis.component.TreeRootHolderRule;
import org.sonar.server.computation.task.projectanalysis.component.Component;
+import org.sonar.server.computation.task.projectanalysis.component.TreeRootHolderRule;
import org.sonar.server.computation.task.projectanalysis.component.ViewsComponent;
import org.sonar.server.computation.task.projectanalysis.period.Period;
import org.sonar.server.computation.task.projectanalysis.period.PeriodsHolderRule;
}
@Test
- public void persist_snapshots_with_periods() {
+ public void persist_snapshots_with_leak_period() {
OrganizationDto organizationDto = dbTester.organizations().insert();
ComponentDto viewDto = save(newView(organizationDto, "UUID_VIEW").setKey("KEY_VIEW"));
ComponentDto subViewDto = save(newSubView(viewDto, "UUID_SUBVIEW", "KEY_SUBVIEW"));
underTest.execute();
SnapshotDto viewSnapshot = getUnprocessedSnapshot(viewDto.uuid());
- assertThat(viewSnapshot.getPeriodMode(1)).isEqualTo(TIMEMACHINE_MODE_DATE);
- assertThat(viewSnapshot.getPeriodDate(1)).isEqualTo(analysisDate);
- assertThat(viewSnapshot.getPeriodModeParameter(1)).isNotNull();
+ assertThat(viewSnapshot.getPeriodMode()).isEqualTo(TIMEMACHINE_MODE_DATE);
+ assertThat(viewSnapshot.getPeriodDate()).isEqualTo(analysisDate);
+ assertThat(viewSnapshot.getPeriodModeParameter()).isNotNull();
}
private ComponentDto save(ComponentDto componentDto) {