--- /dev/null
+/*
+ * SonarQube
+ * Copyright (C) 2009-2024 SonarSource SA
+ * mailto:info 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.ce.task.projectanalysis.step;
+
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Optional;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+import org.sonar.api.measures.Metric;
+import org.sonar.api.utils.System2;
+import org.sonar.ce.task.projectanalysis.analysis.Analysis;
+import org.sonar.ce.task.projectanalysis.analysis.MutableAnalysisMetadataHolderRule;
+import org.sonar.ce.task.projectanalysis.component.Component;
+import org.sonar.ce.task.projectanalysis.component.ReportComponent;
+import org.sonar.ce.task.projectanalysis.component.TreeRootHolderRule;
+import org.sonar.ce.task.projectanalysis.component.ViewsComponent;
+import org.sonar.ce.task.projectanalysis.duplication.ComputeDuplicationDataMeasure;
+import org.sonar.ce.task.projectanalysis.measure.MeasureRepositoryRule;
+import org.sonar.ce.task.projectanalysis.metric.MetricRepositoryRule;
+import org.sonar.ce.task.step.TestComputationStepContext;
+import org.sonar.db.DbClient;
+import org.sonar.db.DbTester;
+import org.sonar.db.component.ComponentDto;
+import org.sonar.db.measure.MeasureDto;
+import org.sonar.db.metric.MetricDto;
+import org.sonar.server.project.Project;
+
+import static java.util.Collections.emptyList;
+import static java.util.Map.entry;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.sonar.api.measures.CoreMetrics.FILE_COMPLEXITY_DISTRIBUTION_KEY;
+import static org.sonar.api.measures.CoreMetrics.FUNCTION_COMPLEXITY_DISTRIBUTION_KEY;
+import static org.sonar.ce.task.projectanalysis.component.Component.Type.DIRECTORY;
+import static org.sonar.ce.task.projectanalysis.component.Component.Type.FILE;
+import static org.sonar.ce.task.projectanalysis.component.Component.Type.PROJECT;
+import static org.sonar.ce.task.projectanalysis.component.Component.Type.PROJECT_VIEW;
+import static org.sonar.ce.task.projectanalysis.component.Component.Type.SUBVIEW;
+import static org.sonar.ce.task.projectanalysis.component.Component.Type.VIEW;
+import static org.sonar.ce.task.projectanalysis.measure.Measure.newMeasureBuilder;
+
+class PersistMeasuresStepTest {
+
+ private static final Metric<?> STRING_METRIC = new Metric.Builder("string-metric", "String metric", Metric.ValueType.STRING).create();
+ private static final Metric<?> INT_METRIC = new Metric.Builder("int-metric", "int metric", Metric.ValueType.INT).create();
+ private static final Metric<?> METRIC_WITH_BEST_VALUE = new Metric.Builder("best-value-metric", "best value metric", Metric.ValueType.INT)
+ .setBestValue(0.0)
+ .setOptimizedBestValue(true)
+ .create();
+
+ private static final int REF_1 = 1;
+ private static final int REF_2 = 2;
+ private static final int REF_3 = 3;
+ private static final int REF_4 = 4;
+
+ @RegisterExtension
+ public DbTester db = DbTester.create(System2.INSTANCE);
+ @RegisterExtension
+ public TreeRootHolderRule treeRootHolder = new TreeRootHolderRule();
+ @RegisterExtension
+ public MetricRepositoryRule metricRepository = new MetricRepositoryRule();
+ @RegisterExtension
+ public MeasureRepositoryRule measureRepository = MeasureRepositoryRule.create(treeRootHolder, metricRepository);
+ @RegisterExtension
+ public MutableAnalysisMetadataHolderRule analysisMetadataHolder = new MutableAnalysisMetadataHolderRule();
+ private final ComputeDuplicationDataMeasure computeDuplicationDataMeasure = mock(ComputeDuplicationDataMeasure.class);
+ private final TestComputationStepContext context = new TestComputationStepContext();
+
+ private final DbClient dbClient = db.getDbClient();
+
+ @BeforeEach
+ public void setUp() {
+ MetricDto stringMetricDto =
+ db.measures().insertMetric(m -> m.setKey(STRING_METRIC.getKey()).setValueType(Metric.ValueType.STRING.name()));
+ MetricDto intMetricDto = db.measures().insertMetric(m -> m.setKey(INT_METRIC.getKey()).setValueType(Metric.ValueType.INT.name()));
+ MetricDto bestValueMetricDto = db.measures()
+ .insertMetric(m -> m.setKey(METRIC_WITH_BEST_VALUE.getKey()).setValueType(Metric.ValueType.INT.name()).setOptimizedBestValue(true).setBestValue(0.0));
+ metricRepository.add(stringMetricDto.getUuid(), STRING_METRIC);
+ metricRepository.add(intMetricDto.getUuid(), INT_METRIC);
+ metricRepository.add(bestValueMetricDto.getUuid(), METRIC_WITH_BEST_VALUE);
+ }
+
+ @Test
+ void description() {
+ assertThat(step().getDescription()).isEqualTo("Persist measures");
+ }
+
+ @Test
+ void persist_measures_of_project_analysis() {
+ prepareProject();
+
+ // the computed measures
+ measureRepository.addRawMeasure(REF_1, STRING_METRIC.getKey(), newMeasureBuilder().create("project-value"));
+ measureRepository.addRawMeasure(REF_3, STRING_METRIC.getKey(), newMeasureBuilder().create("dir-value"));
+ measureRepository.addRawMeasure(REF_4, STRING_METRIC.getKey(), newMeasureBuilder().create("file-value"));
+
+ step().execute(context);
+
+ // all measures are persisted, from project to file
+ assertThat(db.countRowsOfTable("measures")).isEqualTo(3);
+ assertThat(selectMeasure("project-uuid"))
+ .hasValueSatisfying(measure -> assertThat(measure.getMetricValues()).containsEntry(STRING_METRIC.getKey(), "project-value"));
+ assertThat(selectMeasure("dir-uuid"))
+ .hasValueSatisfying(measure -> assertThat(measure.getMetricValues()).containsEntry(STRING_METRIC.getKey(), "dir-value"));
+ assertThat(selectMeasure("file-uuid"))
+ .hasValueSatisfying(measure -> assertThat(measure.getMetricValues()).containsEntry(STRING_METRIC.getKey(), "file-value"));
+ verifyInsertsOrUpdates(3);
+ }
+
+ @Test
+ void persist_measures_of_portfolio_analysis() {
+ preparePortfolio();
+
+ // the computed measures
+ measureRepository.addRawMeasure(REF_1, STRING_METRIC.getKey(), newMeasureBuilder().create("view-value"));
+ measureRepository.addRawMeasure(REF_2, STRING_METRIC.getKey(), newMeasureBuilder().create("subview-value"));
+ measureRepository.addRawMeasure(REF_3, STRING_METRIC.getKey(), newMeasureBuilder().create("project-value"));
+
+ step().execute(context);
+
+ assertThat(db.countRowsOfTable("measures")).isEqualTo(3);
+ assertThat(selectMeasure("view-uuid"))
+ .hasValueSatisfying(measure -> assertThat(measure.getMetricValues()).containsEntry(STRING_METRIC.getKey(), "view-value"));
+ assertThat(selectMeasure("subview-uuid"))
+ .hasValueSatisfying(measure -> assertThat(measure.getMetricValues()).containsEntry(STRING_METRIC.getKey(), "subview-value"));
+ assertThat(selectMeasure("project-uuid"))
+ .hasValueSatisfying(measure -> assertThat(measure.getMetricValues()).containsEntry(STRING_METRIC.getKey(), "project-value"));
+ verifyInsertsOrUpdates(3);
+ }
+
+ @Test
+ void persists_large_number_of_measures() {
+ int num = 11;
+ List<ReportComponent> files = new LinkedList<>();
+ String valuePrefix = "value".repeat(10);
+
+ for (int i = 0; i < num; i++) {
+ files.add(ReportComponent.builder(FILE, i).setUuid("file-uuid" + i).build());
+ }
+ Component project = ReportComponent.builder(Component.Type.PROJECT, -1).setUuid("project-uuid")
+ .addChildren(files.toArray(Component[]::new))
+ .build();
+ treeRootHolder.setRoot(project);
+ analysisMetadataHolder.setBaseAnalysis(new Analysis.Builder().setUuid("uuid").setCreatedAt(1L).build());
+ insertMeasure("file-uuid0", "project-uuid", STRING_METRIC, valuePrefix + "0");
+
+ for (int i = 0; i < num; i++) {
+ measureRepository.addRawMeasure(i, STRING_METRIC.getKey(), newMeasureBuilder().create(valuePrefix + i));
+ }
+ db.getSession().commit();
+
+ PersistMeasuresStep step = new PersistMeasuresStep(dbClient, metricRepository, treeRootHolder, measureRepository,
+ computeDuplicationDataMeasure, 100);
+ step.execute(context);
+
+ // all measures are persisted, for project and all files
+ assertThat(db.countRowsOfTable("measures")).isEqualTo(num + 1);
+ verifyInsertsOrUpdates(num - 1);
+ verifyUnchanged(1);
+ verify(computeDuplicationDataMeasure, times(num)).compute(any(Component.class));
+ }
+
+ @Test
+ void do_not_persist_excluded_file_metrics() {
+ MetricDto fileComplexityMetric =
+ db.measures().insertMetric(m -> m.setKey(FILE_COMPLEXITY_DISTRIBUTION_KEY).setValueType(Metric.ValueType.STRING.name()));
+ MetricDto functionComplexityMetric =
+ db.measures().insertMetric(m -> m.setKey(FUNCTION_COMPLEXITY_DISTRIBUTION_KEY).setValueType(Metric.ValueType.INT.name()));
+ metricRepository.add(fileComplexityMetric.getUuid(), new Metric.Builder(FILE_COMPLEXITY_DISTRIBUTION_KEY, "File Distribution / " +
+ "Complexity",
+ Metric.ValueType.DISTRIB).create());
+ metricRepository.add(functionComplexityMetric.getUuid(), new Metric.Builder(FUNCTION_COMPLEXITY_DISTRIBUTION_KEY, "Function " +
+ "Distribution / Complexity",
+ Metric.ValueType.DISTRIB).create());
+
+ prepareProject();
+
+ // the computed measures
+ measureRepository.addRawMeasure(REF_1, FILE_COMPLEXITY_DISTRIBUTION_KEY, newMeasureBuilder().create("project-value"));
+ measureRepository.addRawMeasure(REF_3, FILE_COMPLEXITY_DISTRIBUTION_KEY, newMeasureBuilder().create("dir-value"));
+ measureRepository.addRawMeasure(REF_4, FILE_COMPLEXITY_DISTRIBUTION_KEY, newMeasureBuilder().create("file-value"));
+
+ measureRepository.addRawMeasure(REF_1, FUNCTION_COMPLEXITY_DISTRIBUTION_KEY, newMeasureBuilder().create("project-value"));
+ measureRepository.addRawMeasure(REF_3, FUNCTION_COMPLEXITY_DISTRIBUTION_KEY, newMeasureBuilder().create("dir-value"));
+ measureRepository.addRawMeasure(REF_4, FUNCTION_COMPLEXITY_DISTRIBUTION_KEY, newMeasureBuilder().create("file-value"));
+
+ step().execute(context);
+
+ // all measures are persisted, from project to file
+ assertThat(db.countRowsOfTable("measures")).isEqualTo(3);
+
+ assertThat(selectMeasure("project-uuid"))
+ .hasValueSatisfying(measure -> assertThat(measure.getMetricValues()).contains(
+ entry(FILE_COMPLEXITY_DISTRIBUTION_KEY, "project-value"),
+ entry(FUNCTION_COMPLEXITY_DISTRIBUTION_KEY, "project-value")));
+ assertThat(selectMeasure("dir-uuid"))
+ .hasValueSatisfying(measure -> assertThat(measure.getMetricValues()).contains(
+ entry(FILE_COMPLEXITY_DISTRIBUTION_KEY, "dir-value"),
+ entry(FUNCTION_COMPLEXITY_DISTRIBUTION_KEY, "dir-value")));
+ assertThat(selectMeasure("file-uuid"))
+ .hasValueSatisfying(measure -> assertThat(measure.getMetricValues())
+ .doesNotContainKeys(FILE_COMPLEXITY_DISTRIBUTION_KEY, FUNCTION_COMPLEXITY_DISTRIBUTION_KEY));
+
+ verifyInsertsOrUpdates(4);
+ }
+
+ @Test
+ void measures_without_value_are_not_persisted() {
+ prepareProject();
+ measureRepository.addRawMeasure(REF_1, STRING_METRIC.getKey(), newMeasureBuilder().createNoValue());
+ measureRepository.addRawMeasure(REF_1, INT_METRIC.getKey(), newMeasureBuilder().createNoValue());
+
+ step().execute(context);
+
+ assertThat(selectMeasure("project-uuid")).hasValueSatisfying(measureDto -> assertThat(measureDto.getMetricValues()).isEmpty());
+ verifyInsertsOrUpdates(0);
+ }
+
+ @Test
+ void measures_on_leak_period_are_persisted() {
+ prepareProject();
+ measureRepository.addRawMeasure(REF_1, INT_METRIC.getKey(), newMeasureBuilder().create(42.0));
+
+ step().execute(context);
+
+ assertThat(selectMeasure("project-uuid"))
+ .hasValueSatisfying(persistedMeasure -> assertThat(persistedMeasure.getMetricValues()).containsEntry(INT_METRIC.getKey(), 42.0));
+ verifyInsertsOrUpdates(1);
+ }
+
+ @Test
+ void do_not_persist_file_measures_with_best_value() {
+ prepareProject();
+ // measure to be deleted because new value matches the metric best value
+ insertMeasure("file-uuid", "project-uuid", METRIC_WITH_BEST_VALUE, 123.0);
+ db.commit();
+
+ // project measure with metric best value -> persist with value 0
+ measureRepository.addRawMeasure(REF_1, METRIC_WITH_BEST_VALUE.getKey(), newMeasureBuilder().create(0));
+ // file measure with metric best value -> do not persist
+ measureRepository.addRawMeasure(REF_4, METRIC_WITH_BEST_VALUE.getKey(), newMeasureBuilder().create(0));
+
+ step().execute(context);
+
+ assertThatMeasureDoesNotExist("file-uuid", METRIC_WITH_BEST_VALUE.getKey());
+
+ Optional<MeasureDto> persisted = dbClient.measureDao().selectMeasure(db.getSession(), "project-uuid");
+ assertThat(persisted).isPresent();
+ assertThat(persisted.get().getMetricValues()).containsEntry(METRIC_WITH_BEST_VALUE.getKey(), (double) 0);
+
+ verifyInsertsOrUpdates(1);
+ }
+
+ @Test
+ void do_not_persist_if_value_hash_unchanged() {
+ prepareProject();
+ insertMeasure("file-uuid", "project-uuid", INT_METRIC, 123.0);
+ db.commit();
+
+ measureRepository.addRawMeasure(REF_4, INT_METRIC.getKey(), newMeasureBuilder().create(123L));
+
+ step().execute(context);
+
+ verifyInsertsOrUpdates(0);
+ verifyUnchanged(1);
+ }
+
+ @Test
+ void persist_if_value_hash_changed() {
+ prepareProject();
+ insertMeasure("file-uuid", "project-uuid", INT_METRIC, 123.0);
+ db.commit();
+
+ measureRepository.addRawMeasure(REF_4, INT_METRIC.getKey(), newMeasureBuilder().create(124L));
+
+ step().execute(context);
+
+ verifyInsertsOrUpdates(1);
+ verifyUnchanged(0);
+ }
+
+ private void insertMeasure(String componentUuid, String projectUuid, Metric<?> metric, Object obj) {
+ MeasureDto measure = new MeasureDto()
+ .setComponentUuid(componentUuid)
+ .setBranchUuid(projectUuid)
+ .addValue(metric.getKey(), obj);
+ measure.computeJsonValueHash();
+ dbClient.measureDao().insert(db.getSession(), measure);
+ }
+
+ private void assertThatMeasureDoesNotExist(String componentUuid, String metricKey) {
+ assertThat(dbClient.measureDao().selectMeasure(db.getSession(), componentUuid))
+ .hasValueSatisfying(measureDto -> assertThat(measureDto.getMetricValues()).doesNotContainKey(metricKey));
+ }
+
+ private void prepareProject() {
+ // tree of components as defined by scanner report
+ Component project = ReportComponent.builder(PROJECT, REF_1).setUuid("project-uuid")
+ .addChildren(
+ ReportComponent.builder(DIRECTORY, REF_3).setUuid("dir-uuid")
+ .addChildren(
+ ReportComponent.builder(FILE, REF_4).setUuid("file-uuid")
+ .build())
+ .build())
+ .build();
+ treeRootHolder.setRoot(project);
+ analysisMetadataHolder.setProject(new Project(project.getUuid(), project.getKey(), project.getName(), project.getDescription(),
+ emptyList()));
+
+ // components as persisted in db
+ insertComponent("project-key", "project-uuid");
+ insertComponent("dir-key", "dir-uuid");
+ insertComponent("file-key", "file-uuid");
+ }
+
+ private void preparePortfolio() {
+ // tree of components
+ Component portfolio = ViewsComponent.builder(VIEW, REF_1).setUuid("view-uuid")
+ .addChildren(
+ ViewsComponent.builder(SUBVIEW, REF_2).setUuid("subview-uuid")
+ .addChildren(
+ ViewsComponent.builder(PROJECT_VIEW, REF_3).setUuid("project-uuid")
+ .build())
+ .build())
+ .build();
+ treeRootHolder.setRoot(portfolio);
+
+ // components as persisted in db
+ ComponentDto portfolioDto = insertComponent("view-key", "view-uuid");
+ insertComponent("subview-key", "subview-uuid");
+ insertComponent("project-key", "project-uuid");
+ analysisMetadataHolder.setProject(Project.from(portfolioDto));
+ }
+
+ private Optional<MeasureDto> selectMeasure(String componentUuid) {
+ return dbClient.measureDao().selectMeasure(db.getSession(), componentUuid);
+ }
+
+ private ComponentDto insertComponent(String key, String uuid) {
+ ComponentDto componentDto = new ComponentDto()
+ .setKey(key)
+ .setUuid(uuid)
+ .setUuidPath(uuid + ".")
+ .setBranchUuid(uuid);
+ db.components().insertComponent(componentDto);
+ return componentDto;
+ }
+
+ private PersistMeasuresStep step() {
+ return new PersistMeasuresStep(dbClient, metricRepository, treeRootHolder, measureRepository, computeDuplicationDataMeasure);
+ }
+
+ private void verifyInsertsOrUpdates(int expectedInsertsOrUpdates) {
+ context.getStatistics().assertValue("insertsOrUpdates", expectedInsertsOrUpdates);
+ }
+
+ private void verifyUnchanged(int expectedUnchanged) {
+ context.getStatistics().assertValue("unchanged", expectedUnchanged);
+ }
+}
import org.sonar.ce.task.projectanalysis.component.ReferenceBranchComponentUuids;
import org.sonar.ce.task.projectanalysis.component.SiblingComponentsWithOpenIssues;
import org.sonar.ce.task.projectanalysis.component.TreeRootHolderImpl;
+import org.sonar.ce.task.projectanalysis.duplication.ComputeDuplicationDataMeasure;
import org.sonar.ce.task.projectanalysis.duplication.CrossProjectDuplicationStatusHolderImpl;
import org.sonar.ce.task.projectanalysis.duplication.DuplicationMeasures;
import org.sonar.ce.task.projectanalysis.duplication.DuplicationRepositoryImpl;
// duplication
IntegrateCrossProjectDuplications.class,
DuplicationMeasures.class,
+ ComputeDuplicationDataMeasure.class,
// views
ViewIndex.class,
--- /dev/null
+/*
+ * SonarQube
+ * Copyright (C) 2009-2024 SonarSource SA
+ * mailto:info 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.ce.task.projectanalysis.duplication;
+
+import java.util.Optional;
+import org.apache.commons.text.StringEscapeUtils;
+import org.sonar.ce.task.projectanalysis.component.Component;
+
+import static com.google.common.collect.Iterables.isEmpty;
+
+/**
+ * Compute duplication data measures on files, based on the {@link DuplicationRepository}
+ */
+public class ComputeDuplicationDataMeasure {
+ private final DuplicationRepository duplicationRepository;
+
+ public ComputeDuplicationDataMeasure(DuplicationRepository duplicationRepository) {
+ this.duplicationRepository = duplicationRepository;
+ }
+
+ public Optional<String> compute(Component file) {
+ Iterable<Duplication> duplications = duplicationRepository.getDuplications(file);
+ if (isEmpty(duplications)) {
+ return Optional.empty();
+ }
+ return Optional.of(generateMeasure(file.getKey(), duplications));
+ }
+
+ private static String generateMeasure(String componentDbKey, Iterable<Duplication> duplications) {
+ StringBuilder xml = new StringBuilder();
+ xml.append("<duplications>");
+ for (Duplication duplication : duplications) {
+ xml.append("<g>");
+ appendDuplication(xml, componentDbKey, duplication.getOriginal(), false);
+ for (Duplicate duplicate : duplication.getDuplicates()) {
+ processDuplicationBlock(xml, duplicate, componentDbKey);
+ }
+ xml.append("</g>");
+ }
+ xml.append("</duplications>");
+ return xml.toString();
+ }
+
+ private static void processDuplicationBlock(StringBuilder xml, Duplicate duplicate, String componentDbKey) {
+ if (duplicate instanceof InnerDuplicate) {
+ // Duplication is on the same file
+ appendDuplication(xml, componentDbKey, duplicate);
+ } else if (duplicate instanceof InExtendedProjectDuplicate inExtendedProjectDuplicate) {
+ // Duplication is on a different file that is not saved in the DB
+ appendDuplication(xml, inExtendedProjectDuplicate.getFile().getKey(), duplicate.getTextBlock(), true);
+ } else if (duplicate instanceof InProjectDuplicate inProjectDuplicate) {
+ // Duplication is on a different file
+ appendDuplication(xml, inProjectDuplicate.getFile().getKey(), duplicate);
+ } else if (duplicate instanceof CrossProjectDuplicate crossProjectDuplicate) {
+ // Only componentKey is set for cross project duplications
+ String crossProjectComponentKey = crossProjectDuplicate.getFileKey();
+ appendDuplication(xml, crossProjectComponentKey, duplicate);
+ } else {
+ throw new IllegalArgumentException("Unsupported type of Duplicate " + duplicate.getClass().getName());
+ }
+ }
+
+ private static void appendDuplication(StringBuilder xml, String componentDbKey, Duplicate duplicate) {
+ appendDuplication(xml, componentDbKey, duplicate.getTextBlock(), false);
+ }
+
+ private static void appendDuplication(StringBuilder xml, String componentDbKey, TextBlock textBlock, boolean disableLink) {
+ int length = textBlock.getEnd() - textBlock.getStart() + 1;
+ xml.append("<b s=\"").append(textBlock.getStart())
+ .append("\" l=\"").append(length)
+ .append("\" t=\"").append(disableLink)
+ .append("\" r=\"").append(StringEscapeUtils.escapeXml10(componentDbKey))
+ .append("\"/>");
+ }
+}
package org.sonar.ce.task.projectanalysis.measure;
import javax.annotation.CheckForNull;
+import org.sonar.ce.task.projectanalysis.analysis.AnalysisMetadataHolder;
import org.sonar.ce.task.projectanalysis.component.Component;
+import org.sonar.ce.task.projectanalysis.component.TreeRootHolder;
import org.sonar.ce.task.projectanalysis.metric.Metric;
import org.sonar.db.measure.LiveMeasureDto;
import org.sonar.db.measure.ProjectMeasureDto;
-import org.sonar.ce.task.projectanalysis.analysis.AnalysisMetadataHolder;
-import org.sonar.ce.task.projectanalysis.component.TreeRootHolder;
public class MeasureToMeasureDto {
return out;
}
+ public static Object getMeasureValue(Measure measure) {
+ Double doubleValue = valueAsDouble(measure);
+ if (doubleValue != null) {
+ return doubleValue;
+ }
+ return data(measure);
+ }
+
private static void setAlert(ProjectMeasureDto projectMeasureDto, QualityGateStatus qualityGateStatus) {
projectMeasureDto.setAlertStatus(qualityGateStatus.getStatus().name());
projectMeasureDto.setAlertText(qualityGateStatus.getText());
--- /dev/null
+/*
+ * SonarQube
+ * Copyright (C) 2009-2024 SonarSource SA
+ * mailto:info 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.ce.task.projectanalysis.step;
+
+import java.util.Collection;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import javax.annotation.Nullable;
+import org.sonar.ce.task.projectanalysis.component.Component;
+import org.sonar.ce.task.projectanalysis.component.CrawlerDepthLimit;
+import org.sonar.ce.task.projectanalysis.component.DepthTraversalTypeAwareCrawler;
+import org.sonar.ce.task.projectanalysis.component.TreeRootHolder;
+import org.sonar.ce.task.projectanalysis.component.TypeAwareVisitorAdapter;
+import org.sonar.ce.task.projectanalysis.duplication.ComputeDuplicationDataMeasure;
+import org.sonar.ce.task.projectanalysis.measure.BestValueOptimization;
+import org.sonar.ce.task.projectanalysis.measure.Measure;
+import org.sonar.ce.task.projectanalysis.measure.MeasureRepository;
+import org.sonar.ce.task.projectanalysis.measure.MeasureToMeasureDto;
+import org.sonar.ce.task.projectanalysis.metric.Metric;
+import org.sonar.ce.task.projectanalysis.metric.MetricRepository;
+import org.sonar.ce.task.step.ComputationStep;
+import org.sonar.db.DbClient;
+import org.sonar.db.DbSession;
+import org.sonar.db.measure.MeasureDto;
+import org.sonar.db.measure.MeasureHash;
+import org.springframework.beans.factory.annotation.Autowired;
+
+import static org.sonar.api.measures.CoreMetrics.DUPLICATIONS_DATA_KEY;
+import static org.sonar.api.measures.CoreMetrics.FILE_COMPLEXITY_DISTRIBUTION_KEY;
+import static org.sonar.api.measures.CoreMetrics.FUNCTION_COMPLEXITY_DISTRIBUTION_KEY;
+import static org.sonar.ce.task.projectanalysis.component.ComponentVisitor.Order.PRE_ORDER;
+
+public class PersistMeasuresStep implements ComputationStep {
+
+ /**
+ * List of metrics that should not be persisted on file measure.
+ */
+ private static final Set<String> NOT_TO_PERSIST_ON_FILE_METRIC_KEYS = Set.of(
+ FILE_COMPLEXITY_DISTRIBUTION_KEY,
+ FUNCTION_COMPLEXITY_DISTRIBUTION_KEY);
+
+ // 50 mb
+ private static final int MAX_TRANSACTION_SIZE = 50_000_000;
+ private static final Predicate<Measure> NON_EMPTY_MEASURE = measure ->
+ measure.getValueType() != Measure.ValueType.NO_VALUE || measure.getData() != null;
+
+ private final DbClient dbClient;
+ private final MetricRepository metricRepository;
+ private final TreeRootHolder treeRootHolder;
+ private final MeasureRepository measureRepository;
+ private final ComputeDuplicationDataMeasure computeDuplicationDataMeasure;
+ private final int maxTransactionSize;
+
+ @Autowired
+ public PersistMeasuresStep(DbClient dbClient, MetricRepository metricRepository, TreeRootHolder treeRootHolder,
+ MeasureRepository measureRepository, @Nullable ComputeDuplicationDataMeasure computeDuplicationDataMeasure) {
+ this(dbClient, metricRepository, treeRootHolder, measureRepository, computeDuplicationDataMeasure, MAX_TRANSACTION_SIZE);
+ }
+
+ PersistMeasuresStep(DbClient dbClient, MetricRepository metricRepository, TreeRootHolder treeRootHolder,
+ MeasureRepository measureRepository, @Nullable ComputeDuplicationDataMeasure computeDuplicationDataMeasure, int maxTransactionSize) {
+ this.dbClient = dbClient;
+ this.metricRepository = metricRepository;
+ this.treeRootHolder = treeRootHolder;
+ this.measureRepository = measureRepository;
+ this.computeDuplicationDataMeasure = computeDuplicationDataMeasure;
+ this.maxTransactionSize = maxTransactionSize;
+ }
+
+ @Override
+ public String getDescription() {
+ return "Persist measures";
+ }
+
+ @Override
+ public void execute(ComputationStep.Context context) {
+ Component root = treeRootHolder.getRoot();
+ CollectComponentsVisitor visitor = new CollectComponentsVisitor();
+ new DepthTraversalTypeAwareCrawler(visitor).visit(root);
+
+ Set<MeasureHash> dbMeasureHashes = getDBMeasureHashes();
+ Set<String> dbComponents = dbMeasureHashes.stream().map(MeasureHash::componentUuid).collect(Collectors.toSet());
+
+ List<MeasureDto> inserts = new LinkedList<>();
+ List<MeasureDto> updates = new LinkedList<>();
+ int insertsOrUpdates = 0;
+ int unchanged = 0;
+ int size = 0;
+
+ for (Component component : visitor.components) {
+ MeasureDto measure = createMeasure(component);
+
+ if (dbMeasureHashes.contains(new MeasureHash(measure.getComponentUuid(), measure.computeJsonValueHash()))) {
+ unchanged += measure.getMetricValues().size();
+ } else {
+ if (dbComponents.contains(measure.getComponentUuid())) {
+ updates.add(measure);
+ } else {
+ inserts.add(measure);
+ }
+ size += measure.getJsonValue().length();
+ insertsOrUpdates += measure.getMetricValues().size();
+ }
+
+ if (size > maxTransactionSize) {
+ persist(inserts, updates);
+ inserts.clear();
+ updates.clear();
+ size = 0;
+ }
+ }
+ persist(inserts, updates);
+
+ context.getStatistics()
+ .add("insertsOrUpdates", insertsOrUpdates)
+ .add("unchanged", unchanged);
+ }
+
+ private Set<MeasureHash> getDBMeasureHashes() {
+ try (DbSession dbSession = dbClient.openSession(false)) {
+ return dbClient.measureDao().selectBranchMeasureHashes(dbSession, treeRootHolder.getRoot().getUuid());
+ }
+ }
+
+ private MeasureDto createMeasure(Component component) {
+ MeasureDto measureDto = new MeasureDto();
+ measureDto.setComponentUuid(component.getUuid());
+ measureDto.setBranchUuid(treeRootHolder.getRoot().getUuid());
+
+ Map<String, Measure> measures = measureRepository.getRawMeasures(component);
+ for (Map.Entry<String, Measure> measuresByMetricKey : measures.entrySet()) {
+ String metricKey = measuresByMetricKey.getKey();
+ if (NOT_TO_PERSIST_ON_FILE_METRIC_KEYS.contains(metricKey) && component.getType() == Component.Type.FILE) {
+ continue;
+ }
+ Metric metric = metricRepository.getByKey(metricKey);
+ Predicate<Measure> notBestValueOptimized = BestValueOptimization.from(metric, component).negate();
+ Measure measure = measuresByMetricKey.getValue();
+ Stream.of(measure)
+ .filter(NON_EMPTY_MEASURE)
+ .filter(notBestValueOptimized)
+ .map(MeasureToMeasureDto::getMeasureValue)
+ .filter(Objects::nonNull)
+ .forEach(value -> measureDto.addValue(metric.getKey(), value));
+
+ if (component.getType() == Component.Type.FILE) {
+ if (computeDuplicationDataMeasure == null) {
+ throw new IllegalStateException("ComputeDuplicationDataMeasure not initialized in container");
+ }
+ computeDuplicationDataMeasure.compute(component)
+ .ifPresent(duplicationData -> measureDto.addValue(DUPLICATIONS_DATA_KEY, duplicationData));
+ }
+ }
+
+ return measureDto;
+ }
+
+ private void persist(Collection<MeasureDto> inserts, Collection<MeasureDto> updates) {
+ if (inserts.isEmpty() && updates.isEmpty()) {
+ return;
+ }
+ try (DbSession dbSession = dbClient.openSession(true)) {
+ for (MeasureDto m : inserts) {
+ dbClient.measureDao().insert(dbSession, m);
+ }
+ for (MeasureDto m : updates) {
+ dbClient.measureDao().update(dbSession, m);
+ }
+ dbSession.commit();
+ }
+ }
+
+ private static class CollectComponentsVisitor extends TypeAwareVisitorAdapter {
+ private final List<Component> components = new LinkedList<>();
+
+ private CollectComponentsVisitor() {
+ super(CrawlerDepthLimit.LEAVES, PRE_ORDER);
+ }
+
+ @Override
+ public void visitAny(Component component) {
+ components.add(component);
+ }
+ }
+}
PersistAnalysisPropertiesStep.class,
PersistProjectMeasuresStep.class,
PersistLiveMeasuresStep.class,
+ PersistMeasuresStep.class,
PersistDuplicationDataStep.class,
PersistAdHocRulesStep.class,
PersistCveStep.class,
--- /dev/null
+/*
+ * SonarQube
+ * Copyright (C) 2009-2024 SonarSource SA
+ * mailto:info 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.ce.task.projectanalysis.duplication;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+import org.sonar.api.utils.System2;
+import org.sonar.ce.task.projectanalysis.component.Component;
+import org.sonar.ce.task.projectanalysis.component.TreeRootHolderRule;
+import org.sonar.db.DbTester;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.sonar.ce.task.projectanalysis.component.Component.Type.FILE;
+import static org.sonar.ce.task.projectanalysis.component.Component.Type.PROJECT;
+import static org.sonar.ce.task.projectanalysis.component.ReportComponent.builder;
+
+class ComputeDuplicationDataMeasureTest {
+
+ private static final int ROOT_REF = 1;
+ private static final String PROJECT_KEY = "PROJECT_KEY";
+ private static final String PROJECT_UUID = "u1";
+
+ private static final int FILE_1_REF = 2;
+ private static final String FILE_1_KEY = "FILE_1_KEY";
+ private static final String FILE_1_UUID = "u2";
+
+ private static final int FILE_2_REF = 3;
+ private static final String FILE_2_KEY = "FILE_2_KEY";
+ private static final String FILE_2_UUID = "u3";
+
+ @RegisterExtension
+ public DbTester db = DbTester.create(System2.INSTANCE);
+
+ private final Component file1 = builder(FILE, FILE_1_REF).setKey(FILE_1_KEY).setUuid(FILE_1_UUID).build();
+ private final Component file2 = builder(FILE, FILE_2_REF).setKey(FILE_2_KEY).setUuid(FILE_2_UUID).build();
+
+ @RegisterExtension
+ public TreeRootHolderRule treeRootHolder = new TreeRootHolderRule()
+ .setRoot(
+ builder(PROJECT, ROOT_REF).setKey(PROJECT_KEY).setUuid(PROJECT_UUID)
+ .addChildren(file1, file2)
+ .build());
+
+ @RegisterExtension
+ public DuplicationRepositoryRule duplicationRepository = DuplicationRepositoryRule.create(treeRootHolder);
+
+ @Test
+ void nothing_to_persist_when_no_duplication() {
+ assertThat(underTest().compute(file1)).isEmpty();
+ }
+
+ @Test
+ void compute_duplications_on_same_file() {
+ duplicationRepository.addDuplication(FILE_1_REF, new TextBlock(1, 5), new TextBlock(6, 10));
+
+ assertThat(underTest().compute(file1))
+ .contains("<duplications><g><b s=\"1\" l=\"5\" t=\"false\" r=\"" + FILE_1_KEY + "\"/><b s=\"6\" l=\"5\" t=\"false\" r=\""
+ + FILE_1_KEY + "\"/></g></duplications>");
+ }
+
+ @Test
+ void compute_duplications_on_different_files() {
+ duplicationRepository.addDuplication(FILE_1_REF, new TextBlock(1, 5), FILE_2_REF, new TextBlock(6, 10));
+
+ assertThat(underTest().compute(file1))
+ .contains("<duplications><g><b s=\"1\" l=\"5\" t=\"false\" r=\"" + FILE_1_KEY + "\"/><b s=\"6\" l=\"5\" t=\"false\" r=\""
+ + FILE_2_KEY + "\"/></g></duplications>");
+ assertThat(underTest().compute(file2)).isEmpty();
+ }
+
+ @Test
+ void compute_duplications_on_unchanged_file() {
+ duplicationRepository.addExtendedProjectDuplication(FILE_1_REF, new TextBlock(1, 5), FILE_2_REF, new TextBlock(6, 10));
+
+ assertThat(underTest().compute(file1))
+ .contains("<duplications><g><b s=\"1\" l=\"5\" t=\"false\" r=\"" + FILE_1_KEY + "\"/><b s=\"6\" l=\"5\" t=\"true\" r=\""
+ + FILE_2_KEY + "\"/></g></duplications>");
+ assertThat(underTest().compute(file2)).isEmpty();
+ }
+
+ @Test
+ void compute_duplications_on_different_projects() {
+ String fileKeyFromOtherProject = "PROJECT2_KEY:file2";
+ duplicationRepository.addCrossProjectDuplication(FILE_1_REF, new TextBlock(1, 5), fileKeyFromOtherProject, new TextBlock(6, 10));
+
+ assertThat(underTest().compute(file1))
+ .contains("<duplications><g><b s=\"1\" l=\"5\" t=\"false\" r=\"" + FILE_1_KEY + "\"/><b s=\"6\" l=\"5\" t=\"false\" r=\""
+ + fileKeyFromOtherProject + "\"/></g></duplications>");
+ assertThat(underTest().compute(file2)).isEmpty();
+ }
+
+ private ComputeDuplicationDataMeasure underTest() {
+ return new ComputeDuplicationDataMeasure(duplicationRepository);
+ }
+}
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.sonar.ce.task.projectanalysis.measure.MeasureToMeasureDto.getMeasureValue;
@RunWith(DataProviderRunner.class)
public class MeasureToMeasureDtoTest {
assertThat(liveMeasureDto.getTextValue()).isEqualTo(Measure.Level.OK.name());
}
+
+ @Test
+ public void getMeasureValue_returns_null_if_measure_is_empty() {
+ assertThat(getMeasureValue(Measure.newMeasureBuilder().createNoValue())).isNull();
+ }
+
+ @Test
+ public void getMeasureValue_maps_value_to_1_or_0_and_data_from_data_field_for_BOOLEAN_metric() {
+ assertThat(getMeasureValue(Measure.newMeasureBuilder().create(true, SOME_DATA))).isEqualTo(1d);
+ assertThat(getMeasureValue(Measure.newMeasureBuilder().create(false, SOME_DATA))).isEqualTo(0d);
+ }
+
+ @Test
+ public void getMeasureValue_maps_value_and_data_from_data_field_for_INT_metric() {
+ assertThat(getMeasureValue(Measure.newMeasureBuilder().create(123, SOME_DATA))).isEqualTo(123.0);
+ }
+
+ @Test
+ public void getMeasureValue_maps_value_and_data_from_data_field_for_LONG_metric() {
+ assertThat(getMeasureValue(Measure.newMeasureBuilder().create((long) 456, SOME_DATA))).isEqualTo(456.0);
+ }
+
+ @Test
+ public void getMeasureValue_maps_value_and_data_from_data_field_for_DOUBLE_metric() {
+ assertThat(getMeasureValue(Measure.newMeasureBuilder().create(789, 1, SOME_DATA))).isEqualTo(789.0);
+ }
+
+ @Test
+ public void getMeasureValue_maps_to_only_data_for_STRING_metric() {
+ assertThat(getMeasureValue(
+ Measure.newMeasureBuilder().create(SOME_STRING))).isEqualTo(SOME_STRING);
+ }
+
+ @Test
+ public void getMeasureValue_maps_name_of_Level_to_data_and_has_no_value_for_LEVEL_metric() {
+ assertThat(getMeasureValue(
+ Measure.newMeasureBuilder().create(Measure.Level.OK))).isEqualTo(Measure.Level.OK.name());
+ }
}
"issues_impacts",
"issue_changes",
"live_measures",
+ "measures",
"metrics",
"new_code_periods",
"new_code_reference_issues",
import org.sonar.db.issue.IssueDao;
import org.sonar.db.issue.IssueFixedDao;
import org.sonar.db.measure.LiveMeasureDao;
+import org.sonar.db.measure.MeasureDao;
import org.sonar.db.measure.ProjectMeasureDao;
import org.sonar.db.metric.MetricDao;
import org.sonar.db.newcodeperiod.NewCodePeriodDao;
IssueDao.class,
IssueFixedDao.class,
IssuesDependencyDao.class,
+ MeasureDao.class,
LiveMeasureDao.class,
ProjectMeasureDao.class,
MetricDao.class,
import org.sonar.db.issue.IssueDao;
import org.sonar.db.issue.IssueFixedDao;
import org.sonar.db.measure.LiveMeasureDao;
+import org.sonar.db.measure.MeasureDao;
import org.sonar.db.measure.ProjectMeasureDao;
import org.sonar.db.metric.MetricDao;
import org.sonar.db.newcodeperiod.NewCodePeriodDao;
private final SnapshotDao snapshotDao;
private final ComponentDao componentDao;
private final ComponentKeyUpdaterDao componentKeyUpdaterDao;
+ private final MeasureDao measureDao;
private final ProjectMeasureDao projectMeasureDao;
private final UserDao userDao;
private final UserGroupDao userGroupDao;
snapshotDao = getDao(map, SnapshotDao.class);
componentDao = getDao(map, ComponentDao.class);
componentKeyUpdaterDao = getDao(map, ComponentKeyUpdaterDao.class);
+ measureDao = getDao(map, MeasureDao.class);
projectMeasureDao = getDao(map, ProjectMeasureDao.class);
userDao = getDao(map, UserDao.class);
userGroupDao = getDao(map, UserGroupDao.class);
return componentKeyUpdaterDao;
}
+ public MeasureDao measureDao() {
+ return measureDao;
+ }
+
public ProjectMeasureDao projectMeasureDao() {
return projectMeasureDao;
}
import org.sonar.db.issue.PrIssueDto;
import org.sonar.db.measure.LargestBranchNclocDto;
import org.sonar.db.measure.LiveMeasureMapper;
+import org.sonar.db.measure.MeasureMapper;
import org.sonar.db.measure.ProjectLocDistributionDto;
import org.sonar.db.measure.ProjectMeasureDto;
import org.sonar.db.measure.ProjectMeasureMapper;
IssueMapper.class,
IssueFixedMapper.class,
IssuesDependencyMapper.class,
+ MeasureMapper.class,
ProjectMeasureMapper.class,
MetricMapper.class,
NewCodePeriodMapper.class,
--- /dev/null
+/*
+ * SonarQube
+ * Copyright (C) 2009-2024 SonarSource SA
+ * mailto:info 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.db.measure;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+import org.sonar.api.utils.System2;
+import org.sonar.db.Dao;
+import org.sonar.db.DbSession;
+
+public class MeasureDao implements Dao {
+
+ private final System2 system2;
+
+ public MeasureDao(System2 system2) {
+ this.system2 = system2;
+ }
+
+ public int insert(DbSession dbSession, MeasureDto dto) {
+ return mapper(dbSession).insert(dto, system2.now());
+ }
+
+ public int update(DbSession dbSession, MeasureDto dto) {
+ return mapper(dbSession).update(dto, system2.now());
+ }
+
+ public Optional<MeasureDto> selectMeasure(DbSession dbSession, String componentUuid) {
+ List<MeasureDto> measures = mapper(dbSession).selectByComponentUuids(List.of(componentUuid));
+ if (!measures.isEmpty()) {
+ // component_uuid column is unique. List can't have more than 1 item.
+ return Optional.of(measures.get(0));
+ }
+ return Optional.empty();
+ }
+
+ public Set<MeasureHash> selectBranchMeasureHashes(DbSession dbSession, String branchUuid) {
+ return mapper(dbSession).selectBranchMeasureHashes(branchUuid);
+ }
+
+ private static MeasureMapper mapper(DbSession dbSession) {
+ return dbSession.getMapper(MeasureMapper.class);
+ }
+}
--- /dev/null
+/*
+ * SonarQube
+ * Copyright (C) 2009-2024 SonarSource SA
+ * mailto:info 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.db.measure;
+
+import com.google.gson.Gson;
+import com.google.gson.reflect.TypeToken;
+import java.util.Map;
+import java.util.TreeMap;
+import org.apache.commons.codec.digest.MurmurHash3;
+
+import static java.nio.charset.StandardCharsets.UTF_8;
+
+public class MeasureDto {
+
+ private static final Gson GSON = new Gson();
+
+ private String componentUuid;
+ private String branchUuid;
+ // measures are kept sorted by metric key so that the value hash is consistent
+ private Map<String, Object> metricValues = new TreeMap<>();
+ private Long jsonValueHash;
+
+ public MeasureDto() {
+ // empty constructor
+ }
+
+ public String getComponentUuid() {
+ return componentUuid;
+ }
+
+ public MeasureDto setComponentUuid(String s) {
+ this.componentUuid = s;
+ return this;
+ }
+
+ public String getBranchUuid() {
+ return branchUuid;
+ }
+
+ public MeasureDto setBranchUuid(String s) {
+ this.branchUuid = s;
+ return this;
+ }
+
+ public Map<String, Object> getMetricValues() {
+ return metricValues;
+ }
+
+ public MeasureDto addValue(String metricKey, Object value) {
+ metricValues.put(metricKey, value);
+ return this;
+ }
+
+ // used by MyBatis mapper
+ public String getJsonValue() {
+ return GSON.toJson(metricValues);
+ }
+
+ // used by MyBatis mapper
+ public MeasureDto setJsonValue(String jsonValue) {
+ metricValues = GSON.fromJson(jsonValue, new TypeToken<TreeMap<String, Object>>() {
+ }.getType());
+ return this;
+ }
+
+ public Long getJsonValueHash() {
+ return jsonValueHash;
+ }
+
+ public long computeJsonValueHash() {
+ jsonValueHash = MurmurHash3.hash128(getJsonValue().getBytes(UTF_8))[0];
+ return jsonValueHash;
+ }
+
+ @Override
+ public String toString() {
+ return "MeasureDto{" +
+ "componentUuid='" + componentUuid + '\'' +
+ ", branchUuid='" + branchUuid + '\'' +
+ ", metricValues=" + metricValues +
+ ", jsonValueHash=" + jsonValueHash +
+ '}';
+ }
+}
--- /dev/null
+/*
+ * SonarQube
+ * Copyright (C) 2009-2024 SonarSource SA
+ * mailto:info 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.db.measure;
+
+import java.util.Comparator;
+
+public record MeasureHash(String componentUuid, Long jsonValueHash) implements Comparable<MeasureHash> {
+
+ @Override
+ public int compareTo(MeasureHash o) {
+ return Comparator.comparing(MeasureHash::componentUuid)
+ .thenComparing(MeasureHash::jsonValueHash)
+ .compare(this, o);
+ }
+}
--- /dev/null
+/*
+ * SonarQube
+ * Copyright (C) 2009-2024 SonarSource SA
+ * mailto:info 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.db.measure;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+import org.apache.ibatis.annotations.Param;
+
+public interface MeasureMapper {
+
+ int insert(
+ @Param("dto") MeasureDto dto,
+ @Param("now") long now);
+
+ int update(
+ @Param("dto") MeasureDto dto,
+ @Param("now") long now);
+
+ List<MeasureDto> selectByComponentUuids(@Param("componentUuids") Collection<String> componentUuids);
+
+ Set<MeasureHash> selectBranchMeasureHashes(@Param("branchUuid") String branchUuid);
+}
--- /dev/null
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "mybatis-3-mapper.dtd">
+
+<mapper namespace="org.sonar.db.measure.MeasureMapper">
+
+ <insert id="insert" parameterType="map" useGeneratedKeys="false">
+ insert into measures (
+ component_uuid,
+ branch_uuid,
+ json_value,
+ json_value_hash,
+ created_at,
+ updated_at
+ ) values (
+ #{dto.componentUuid, jdbcType=VARCHAR},
+ #{dto.branchUuid, jdbcType=VARCHAR},
+ #{dto.jsonValue, jdbcType=VARCHAR},
+ #{dto.jsonValueHash, jdbcType=BIGINT},
+ #{now, jdbcType=BIGINT},
+ #{now, jdbcType=BIGINT}
+ )
+ </insert>
+
+ <update id="update" parameterType="map" useGeneratedKeys="false">
+ update measures set
+ json_value = #{dto.jsonValue, jdbcType=VARCHAR},
+ json_value_hash = #{dto.jsonValueHash, jdbcType=BIGINT},
+ updated_at = #{now, jdbcType=BIGINT}
+ where component_uuid = #{dto.componentUuid, jdbcType=VARCHAR}
+ </update>
+
+ <sql id="columns">
+ m.component_uuid as componentUuid,
+ m.branch_uuid as branchUuid,
+ m.json_value as jsonValue,
+ m.json_value_hash as jsonValueHash
+ </sql>
+
+ <select id="selectByComponentUuids" parameterType="map" resultType="org.sonar.db.measure.MeasureDto">
+ select
+ <include refid="columns"/>
+ from measures m
+ where
+ m.component_uuid in
+ <foreach item="componentUuid" collection="componentUuids" open="(" separator="," close=")">
+ #{componentUuid, jdbcType=VARCHAR}
+ </foreach>
+ </select>
+
+ <select id="selectBranchMeasureHashes" resultType="org.sonar.db.measure.MeasureHash">
+ select component_uuid, json_value_hash
+ from measures
+ where branch_uuid = #{branchUuid, jdbcType=VARCHAR}
+ </select>
+
+</mapper>
--- /dev/null
+/*
+ * SonarQube
+ * Copyright (C) 2009-2024 SonarSource SA
+ * mailto:info 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.db.measure;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+import org.sonar.api.utils.System2;
+import org.sonar.db.DbTester;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.sonar.db.measure.MeasureTesting.newMeasure;
+
+class MeasureDaoTest {
+
+ @RegisterExtension
+ public final DbTester db = DbTester.create(System2.INSTANCE);
+
+ private final MeasureDao underTest = db.getDbClient().measureDao();
+
+ @Test
+ void insert_measure() {
+ MeasureDto dto = newMeasure();
+ int count = underTest.insert(db.getSession(), dto);
+ assertThat(count).isEqualTo(1);
+ verifyTableSize(1);
+ verifyPersisted(dto);
+ }
+
+ @Test
+ void update_measure() {
+ MeasureDto dto = newMeasure();
+ underTest.insert(db.getSession(), dto);
+
+ dto.addValue("metric1", "value1");
+ dto.computeJsonValueHash();
+ int count = underTest.update(db.getSession(), dto);
+
+ assertThat(count).isEqualTo(1);
+ verifyTableSize(1);
+ verifyPersisted(dto);
+ }
+
+ @Test
+ void select_measure() {
+ MeasureDto measure1 = newMeasure();
+ MeasureDto measure2 = newMeasure();
+ underTest.insert(db.getSession(), measure1);
+ underTest.insert(db.getSession(), measure2);
+
+ assertThat(underTest.selectMeasure(db.getSession(), measure1.getComponentUuid()))
+ .hasValueSatisfying(selected -> assertThat(selected).usingRecursiveComparison().isEqualTo(measure1));
+ assertThat(underTest.selectMeasure(db.getSession(), "unknown-component")).isEmpty();
+ }
+
+ @Test
+ void select_branch_measure_hashes() {
+ MeasureDto measure1 = new MeasureDto()
+ .setComponentUuid("c1")
+ .setBranchUuid("b1")
+ .addValue("metric1", "value1");
+ MeasureDto measure2 = new MeasureDto()
+ .setComponentUuid("c2")
+ .setBranchUuid("b1")
+ .addValue("metric2", "value2");
+ MeasureDto measure3 = new MeasureDto()
+ .setComponentUuid("c3")
+ .setBranchUuid("b3")
+ .addValue("metric3", "value3");
+ long hash1 = measure1.computeJsonValueHash();
+ long hash2 = measure2.computeJsonValueHash();
+ measure3.computeJsonValueHash();
+
+ underTest.insert(db.getSession(), measure1);
+ underTest.insert(db.getSession(), measure2);
+ underTest.insert(db.getSession(), measure3);
+
+ assertThat(underTest.selectBranchMeasureHashes(db.getSession(), "b1"))
+ .containsOnly(new MeasureHash("c1", hash1), new MeasureHash("c2", hash2));
+ }
+
+ private void verifyTableSize(int expectedSize) {
+ assertThat(db.countRowsOfTable(db.getSession(), "measures")).isEqualTo(expectedSize);
+ }
+
+ private void verifyPersisted(MeasureDto dto) {
+ assertThat(underTest.selectMeasure(db.getSession(), dto.getComponentUuid())).hasValueSatisfying(selected -> {
+ assertThat(selected).usingRecursiveComparison().isEqualTo(dto);
+ });
+ }
+}
--- /dev/null
+/*
+ * SonarQube
+ * Copyright (C) 2009-2024 SonarSource SA
+ * mailto:info 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.db.measure;
+
+import java.util.Map;
+import java.util.TreeMap;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class MeasureDtoTest {
+
+ @Test
+ void compute_json_value_hash() {
+ MeasureDto measureDto = new MeasureDto();
+ measureDto.setJsonValue("{\"key\":\"value\"}");
+ assertThat(measureDto.getJsonValueHash()).isNull();
+ assertThat(measureDto.computeJsonValueHash()).isEqualTo(2887272982314571750L);
+ assertThat(measureDto.getJsonValueHash()).isEqualTo(2887272982314571750L);
+ }
+
+ @Test
+ void getMetricValues_returns_all_values_ordered() {
+ MeasureDto measureDto = new MeasureDto()
+ .addValue("string-metric", "value")
+ .addValue("int-metric", 1)
+ .addValue("long-metric", 2L);
+ assertThat(measureDto.getMetricValues()).containsExactlyEntriesOf(new TreeMap<>(Map.of(
+ "int-metric", 1,
+ "long-metric", 2L,
+ "string-metric", "value"
+ )));
+ }
+
+ @Test
+ void toString_prints_all_fields() {
+ MeasureDto measureDto = new MeasureDto()
+ .setBranchUuid("branch-uuid")
+ .setComponentUuid("component-uuid")
+ .addValue("int-metric", 12)
+ .addValue("double-metric", 34.5)
+ .addValue("boolean-metric", true)
+ .addValue("string-metric", "value");
+ measureDto.computeJsonValueHash();
+
+ assertThat(measureDto).hasToString("MeasureDto{componentUuid='component-uuid'" +
+ ", branchUuid='branch-uuid'" +
+ ", metricValues={boolean-metric=true, double-metric=34.5, int-metric=12, string-metric=value}" +
+ ", jsonValueHash=-1071134275520515337}");
+ }
+}
--- /dev/null
+/*
+ * SonarQube
+ * Copyright (C) 2009-2024 SonarSource SA
+ * mailto:info 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.db.measure;
+
+import java.util.List;
+import java.util.TreeSet;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class MeasureHashTest {
+
+ @Test
+ void hashCode_depends_on_both_fields() {
+ MeasureHash measureHash1 = new MeasureHash("component1", 123L);
+ MeasureHash measureHash2 = new MeasureHash("component", 123L);
+ MeasureHash measureHash3 = new MeasureHash("component", 124L);
+
+ assertThat(measureHash1)
+ .doesNotHaveSameHashCodeAs(measureHash2)
+ .doesNotHaveSameHashCodeAs(measureHash3)
+ .isNotEqualTo(measureHash2)
+ .isNotEqualTo(measureHash3);
+ }
+
+ @Test
+ void sort_by_component_and_hash() {
+ MeasureHash measureHash1 = new MeasureHash("A", 1L);
+ MeasureHash measureHash2 = new MeasureHash("A", 2L);
+ MeasureHash measureHash3 = new MeasureHash("B", 1L);
+ MeasureHash measureHash4 = new MeasureHash("B", 2L);
+
+ TreeSet<MeasureHash> set = new TreeSet<>(List.of(measureHash1, measureHash2, measureHash3, measureHash4));
+
+ assertThat(set).containsExactly(measureHash1, measureHash2, measureHash3, measureHash4);
+ }
+}
.setData(String.valueOf(cursor++))
.setValue((double) cursor++);
}
+
+ public static MeasureDto newMeasure() {
+ MeasureDto measureDto = new MeasureDto()
+ .setComponentUuid(String.valueOf(cursor++))
+ .setBranchUuid(String.valueOf(cursor++))
+ .addValue("metric" + cursor++, (double) cursor++);
+ measureDto.computeJsonValueHash();
+ return measureDto;
+ }
+
+ public static MeasureDto newMeasure(ComponentDto component, MetricDto metric, Object value) {
+ MeasureDto measureDto = new MeasureDto()
+ .setComponentUuid(component.uuid())
+ .setBranchUuid(component.branchUuid())
+ .addValue(metric.getKey(), value);
+ measureDto.computeJsonValueHash();
+ return measureDto;
+ }
}
projects / sonarqube.git / commitdiff