JACOCO-89 Allow multiple report file paths into aggregateXmlReportPaths parameter

Author: leonardo-pilastri-sonarsource

its/src/test/java/org/sonar/plugins/jacoco/its/JacocoTest.java

@@ -209,7 +209,7 @@ void aggregate_and_module_based_reports_complement_each_over_to_build_total_cove
             .setPom(rootPom.toFile())
             .addGoal("clean verify")
             .addSonarGoal()
-            .setProperty("sonar.coverage.jacoco.aggregateXmlReportPath", reportLocation.toAbsolutePath().toString());
+            .setProperty("sonar.coverage.jacoco.aggregateXmlReportPaths", reportLocation.toAbsolutePath().toString());
 
     orchestrator.executeBuild(build, true);
 

src/main/java/org/sonar/plugins/jacoco/FileLocator.java

@@ -41,7 +41,8 @@ protected FileLocator(Iterable<InputFile> inputFiles, KotlinFileLocator kotlinFi
   protected FileLocator(List<InputFile> inputFiles, @Nullable KotlinFileLocator kotlinFileLocator) {
     this.kotlinFileLocator = kotlinFileLocator;
     for (InputFile inputFile : inputFiles) {
-      String[] path = inputFile.relativePath().split(SEPARATOR_REGEX);
+      // InputFile.relativePath() always uses '/' as separator
+      String[] path = inputFile.relativePath().split("/");
       tree.index(inputFile, path);
     }
   }
@@ -50,7 +51,7 @@ protected FileLocator(List<InputFile> inputFiles, @Nullable KotlinFileLocator ko
   public InputFile getInputFile(@Nullable String groupName, String packagePath, String fileName) {
     String filePath = packagePath.isEmpty()
             ? fileName
-            : (packagePath + '/' + fileName);
+            : normalizePath(packagePath + "/" + fileName);
 
     InputFile file = lookup(groupName, filePath);
 
@@ -62,4 +63,9 @@ public InputFile getInputFile(@Nullable String groupName, String packagePath, St
 
   @CheckForNull
   protected abstract InputFile lookup(@Nullable String groupName, String filePath);
+
+  private static String normalizePath(String path) {
+    return path.replace("/", File.separator);
+  }
+
 }

src/main/java/org/sonar/plugins/jacoco/JacocoAggregateSensor.java

@@ -22,6 +22,7 @@
 import java.io.FileNotFoundException;
 import java.nio.file.Path;
 import java.nio.file.Paths;
+import java.util.Set;
 import java.util.stream.Stream;
 import java.util.stream.StreamSupport;
 import org.sonar.api.batch.fs.InputFile;
@@ -31,6 +32,8 @@
 import org.sonar.api.utils.log.Logger;
 import org.sonar.api.utils.log.Loggers;
 
+import static org.sonar.plugins.jacoco.SensorUtils.importReports;
+
 public class JacocoAggregateSensor implements ProjectSensor {
   private static final Logger LOG = Loggers.get(JacocoAggregateSensor.class);
   private final ProjectCoverageContext projectCoverageContext;
@@ -47,14 +50,8 @@ public void describe(SensorDescriptor descriptor) {
   @Override
   public void execute(SensorContext context) {
     this.projectCoverageContext.setProjectBaseDir(Paths.get(context.config().get("sonar.projectBaseDir").get()));
-    Path reportPath = null;
-    try {
-      reportPath = new ReportPathsProvider(context).getAggregateReportPath();
-    } catch (FileNotFoundException e) {
-      LOG.error(String.format("The aggregate JaCoCo sensor will stop: %s", e.getMessage()));
-      return;
-    }
-    if (reportPath == null) {
+    Set<Path> reportPaths = new ReportPathsProvider(context).getAggregateReportPaths();
+    if (reportPaths.isEmpty()) {
       LOG.debug("No aggregate XML report found. No coverage coverage information will be added at project level.");
       return;
     }
@@ -63,7 +60,6 @@ public void execute(SensorContext context) {
     FileLocator locator = new ProjectFileLocator(inputFiles, new KotlinFileLocator(kotlinInputFileStream), projectCoverageContext);
     ReportImporter importer = new ReportImporter(context);
 
-    LOG.info("Importing aggregate report {}.", reportPath);
-    SensorUtils.importReport(new XmlReportParser(reportPath), locator, importer, LOG);
+    importReports(reportPaths, locator, importer, LOG);
   }
 }

src/main/java/org/sonar/plugins/jacoco/JacocoPlugin.java

@@ -38,12 +38,13 @@ public void define(Context context) {
       .build());
 
     context.addExtension(JacocoAggregateSensor.class);
-    context.addExtension(PropertyDefinition.builder(ReportPathsProvider.AGGREGATE_REPORT_PATH_PROPERTY_KEY)
+    context.addExtension(PropertyDefinition.builder(ReportPathsProvider.AGGREGATE_REPORT_PATHS_PROPERTY_KEY)
       .onQualifiers(Qualifiers.PROJECT)
       .type(PropertyType.STRING)
       .multiValues(false)
       .category("JaCoCo")
-      .description("Single path to aggregate XML coverage report file.")
+      .description("Paths to JaCoCo XML aggregate coverage report files. Each path can be either absolute or relative" +
+              " to the project base directory. Wildcard patterns are accepted (*, ** and ?).")
       .build());
   }
 }

src/main/java/org/sonar/plugins/jacoco/JacocoSensor.java

@@ -30,6 +30,8 @@
 import org.sonar.api.utils.log.Logger;
 import org.sonar.api.utils.log.Loggers;
 
+import static org.sonar.plugins.jacoco.SensorUtils.importReports;
+
 public class JacocoSensor implements Sensor {
   private static final Logger LOG = Loggers.get(JacocoSensor.class);
 
@@ -57,20 +59,7 @@ public void execute(SensorContext context) {
     ModuleFileLocator locator = new ModuleFileLocator(inputFiles, new KotlinFileLocator(kotlinInputFileStream));
     ReportImporter importer = new ReportImporter(context);
 
-    importReports(reportPaths, locator, importer);
-  }
-
-  void importReports(Collection<Path> reportPaths, ModuleFileLocator locator, ReportImporter importer) {
-    LOG.info("Importing {} report(s). Turn your logs in debug mode in order to see the exhaustive list.", reportPaths.size());
-
-    for (Path reportPath : reportPaths) {
-      LOG.debug("Reading report '{}'", reportPath);
-      try {
-        SensorUtils.importReport(new XmlReportParser(reportPath), locator, importer, LOG);
-      } catch (Exception e) {
-        LOG.error("Coverage report '{}' could not be read/imported. Error: {}", reportPath, e);
-      }
-    }
+    importReports(reportPaths, locator, importer, LOG);
   }
 
   private void recordModuleCoverageContext(SensorContext sensorContext) {

src/main/java/org/sonar/plugins/jacoco/ReportPathsProvider.java

@@ -26,21 +26,22 @@
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.List;
-import java.util.Optional;
 import java.util.Set;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
-import javax.annotation.CheckForNull;
 import org.sonar.api.batch.sensor.SensorContext;
 import org.sonar.api.utils.log.Logger;
 import org.sonar.api.utils.log.Loggers;
 
 class ReportPathsProvider {
   private static final Logger LOG = Loggers.get(ReportPathsProvider.class);
 
-  private static final String[] DEFAULT_PATHS = {"target/site/jacoco/jacoco.xml", "target/site/jacoco-it/jacoco.xml", "build/reports/jacoco/test/jacocoTestReport.xml"};
+  private static final String[] DEFAULT_PATHS = {
+    "target/site/jacoco/jacoco.xml",
+    "target/site/jacoco-it/jacoco.xml",
+    "build/reports/jacoco/test/jacocoTestReport.xml"};
 
-  static final String AGGREGATE_REPORT_PATH_PROPERTY_KEY = "sonar.coverage.jacoco.aggregateXmlReportPath";
+  static final String AGGREGATE_REPORT_PATHS_PROPERTY_KEY = "sonar.coverage.jacoco.aggregateXmlReportPaths";
   static final String REPORT_PATHS_PROPERTY_KEY = "sonar.coverage.jacoco.xmlReportPaths";
 
   private final SensorContext context;
@@ -84,22 +85,23 @@ Collection<Path> getPaths() {
   }
 
   /**
-   * Checks if the aggregate report path property is set, finds the first path matching and returns it.
+   * Checks if the aggregate report path property is set, finds the paths matching and returns them.
    *
-   * @return Path to the existing aggregate report if the property is set. Null if none specified.
-   * @throws FileNotFoundException If a path is set but does not match with an existing file.
+   * @return A Set of Path to the existing aggregate report files if the property is set. An empty set if none specified.
    */
-  @CheckForNull
-  Path getAggregateReportPath() throws FileNotFoundException {
-    Optional<String> property = context.config().get(AGGREGATE_REPORT_PATH_PROPERTY_KEY);
-    if (!property.isPresent()) {
-      return null;
-    }
-    List<Path> scanned = WildcardPatternFileScanner.scan(context.fileSystem().baseDir().toPath(), property.get());
-    if (scanned.isEmpty()) {
-      throw new FileNotFoundException(String.format("Aggregate report %s was not found", property.get()));
+  Set<Path> getAggregateReportPaths() {
+    Set<Path> reportPaths = new HashSet<>();
+    String[] reportPathsParam = context.config().getStringArray(AGGREGATE_REPORT_PATHS_PROPERTY_KEY);
+    for (String reportPathPattern : reportPathsParam) {
+      List<Path> scanned = WildcardPatternFileScanner.scan(context.fileSystem().baseDir().toPath(), reportPathPattern);
+      if (scanned.isEmpty()) {
+        LOG.warn(String.format("No coverage report found for pattern: '%s'", reportPathPattern));
+      } else {
+        reportPaths.addAll(scanned);
+      }
     }
-    return scanned.get(0);
+
+    return reportPaths;
   }
 
 

src/main/java/org/sonar/plugins/jacoco/SensorUtils.java

@@ -19,6 +19,8 @@
  */
 package org.sonar.plugins.jacoco;
 
+import java.nio.file.Path;
+import java.util.Collection;
 import java.util.List;
 import org.sonar.api.batch.fs.InputFile;
 import org.sonar.api.utils.log.Logger;
@@ -28,6 +30,19 @@ private SensorUtils() {
     /* This class should not be instantiated */
   }
 
+  static void importReports(Collection<Path> reportPaths, FileLocator locator, ReportImporter importer, Logger logger) {
+    logger.info("Importing {} report(s). Turn your logs in debug mode in order to see the exhaustive list.", reportPaths.size());
+
+    for (Path reportPath : reportPaths) {
+      logger.debug("Reading report '{}'", reportPath);
+      try {
+        SensorUtils.importReport(new XmlReportParser(reportPath), locator, importer, logger);
+      } catch (Exception e) {
+        logger.error("Coverage report '{}' could not be read/imported. Error: {}", reportPath, e);
+      }
+    }
+  }
+
   static void importReport(XmlReportParser reportParser, FileLocator locator, ReportImporter importer, Logger logger) {
     List<XmlReportParser.SourceFile> sourceFiles = reportParser.parse();
 

src/test/java/org/sonar/plugins/jacoco/JacocoAggregateSensorTest.java

@@ -70,14 +70,15 @@ void log_missing_report_and_return_early_when_missing_analysis_parameter() {
   @Test
   void log_missing_report_and_return_early_when_analysis_parameter_points_to_report_that_does_not_exist() {
     context.settings()
-            .setProperty(ReportPathsProvider.AGGREGATE_REPORT_PATH_PROPERTY_KEY, "non-existing-report.xml");
+            .setProperty(ReportPathsProvider.AGGREGATE_REPORT_PATHS_PROPERTY_KEY, "non-existing-report.xml");
 
     var sensor = new JacocoAggregateSensor(new ProjectCoverageContext());
     sensor.execute(context);
 
-    assertThat(logTester.logs(LoggerLevel.ERROR)).
-            containsExactly("The aggregate JaCoCo sensor will stop: Aggregate report non-existing-report.xml was not found");
-    assertThat(logTester.logs(LoggerLevel.DEBUG)).isEmpty();
+    assertThat(logTester.logs(LoggerLevel.DEBUG)).
+            containsExactly("No aggregate XML report found. No coverage coverage information will be added at project level.");
+    assertThat(logTester.logs(LoggerLevel.WARN))
+            .contains("No coverage report found for pattern: 'non-existing-report.xml'");
     assertThat(logTester.logs(LoggerLevel.INFO)).isEmpty();
   }
 
@@ -86,13 +87,13 @@ void executes_as_expected() {
     Path aggregateReport = Path.of("src", "test", "resources", "jacoco-aggregate.xml");
 
     context.settings()
-            .setProperty(ReportPathsProvider.AGGREGATE_REPORT_PATH_PROPERTY_KEY, aggregateReport.toAbsolutePath().toString());
+            .setProperty(ReportPathsProvider.AGGREGATE_REPORT_PATHS_PROPERTY_KEY, aggregateReport.toAbsolutePath().toString());
 
     var sensor = new JacocoAggregateSensor(new ProjectCoverageContext());
     sensor.execute(context);
     assertThat(logTester.logs(LoggerLevel.DEBUG)).doesNotContain(NO_REPORT_TO_IMPORT_LOG_MESSAGE);
     assertThat(logTester.logs(LoggerLevel.INFO)).containsOnly(
-            String.format("Importing aggregate report %s.", aggregateReport.toAbsolutePath())
+            "Importing 1 report(s). Turn your logs in debug mode in order to see the exhaustive list."
     );
   }
 
@@ -101,15 +102,16 @@ void should_not_fail_when_processing_a_single_module_report() {
     Path singModuleReport = Path.of("src", "test", "resources", "jacoco.xml");
 
     context.settings()
-            .setProperty(ReportPathsProvider.AGGREGATE_REPORT_PATH_PROPERTY_KEY, singModuleReport.toAbsolutePath().toString());
+            .setProperty(ReportPathsProvider.AGGREGATE_REPORT_PATHS_PROPERTY_KEY, singModuleReport.toAbsolutePath().toString());
 
     var sensor = new JacocoAggregateSensor(new ProjectCoverageContext());
     sensor.execute(context);
     assertThat(logTester.logs(LoggerLevel.DEBUG)).doesNotContain(NO_REPORT_TO_IMPORT_LOG_MESSAGE);
+    assertThat(logTester.logs(LoggerLevel.DEBUG)).contains("Reading report '" + singModuleReport.toAbsolutePath() + "'");
     assertThat(logTester.logs(LoggerLevel.INFO)).containsOnly(
-            String.format("Importing aggregate report %s.", singModuleReport.toAbsolutePath())
+            "Importing 1 report(s). Turn your logs in debug mode in order to see the exhaustive list."
     );
     assertThat(logTester.logs(LoggerLevel.ERROR)).isEmpty();
   }
 
-}
+}

src/test/java/org/sonar/plugins/jacoco/JacocoPluginTest.java

@@ -51,14 +51,18 @@ void should_add_sensors_and_property_definitions() {
     assertThat(multiValueReportPaths.key()).isEqualTo("sonar.coverage.jacoco.xmlReportPaths");
     assertThat(multiValueReportPaths.multiValues()).isTrue();
     assertThat(multiValueReportPaths.category()).isEqualTo("JaCoCo");
+    assertThat(multiValueReportPaths.description()).isEqualTo("Paths to JaCoCo XML coverage report files. Each path can be either absolute or relative" +
+            " to the project base directory. Wildcard patterns are accepted (*, ** and ?).");
     assertThat(multiValueReportPaths.qualifiers()).containsOnly(Qualifiers.PROJECT);
 
     assertThat(arg.getAllValues().get(3)).isEqualTo(JacocoAggregateSensor.class);
     PropertyDefinition aggregateReportPath = (PropertyDefinition) arg.getAllValues().get(4);
-    assertThat(aggregateReportPath.key()).isEqualTo("sonar.coverage.jacoco.aggregateXmlReportPath");
+    assertThat(aggregateReportPath.key()).isEqualTo("sonar.coverage.jacoco.aggregateXmlReportPaths");
     assertThat(aggregateReportPath.type()).isEqualTo(PropertyType.STRING);
     assertThat(aggregateReportPath.multiValues()).isFalse();
     assertThat(aggregateReportPath.category()).isEqualTo("JaCoCo");
+    assertThat(aggregateReportPath.description()).isEqualTo("Paths to JaCoCo XML aggregate coverage report files. Each path can be either absolute or relative" +
+            " to the project base directory. Wildcard patterns are accepted (*, ** and ?).");
     assertThat(aggregateReportPath.qualifiers()).containsOnly(Qualifiers.PROJECT);
   }
 }

src/test/java/org/sonar/plugins/jacoco/JacocoSensorTest.java

@@ -93,41 +93,18 @@ void do_not_index_files_when_no_report_was_found() throws IOException {
 
   @Test
   void do_nothing_if_report_parse_failure() {
-    ModuleFileLocator locator = mock(ModuleFileLocator.class);
-    ReportImporter importer = mock(ReportImporter.class);
-
-    sensor.importReports(Collections.singletonList(Paths.get("invalid.xml")), locator, importer);
+    SensorContextTester tester = SensorContextTester.create(temp.getRoot());
+    MapSettings settings = new MapSettings()
+            .setProperty("sonar.moduleKey", "module")
+            .setProperty("sonar.projectBaseDir", temp.getRoot().getAbsolutePath());
+    settings.setProperty(ReportPathsProvider.REPORT_PATHS_PROPERTY_KEY, "invalid.xml");
+    tester.setSettings(settings);
+    sensor.execute(tester);
 
-    assertThat(logTester.logs(LoggerLevel.INFO)).contains("Importing 1 report(s). Turn your logs in debug mode in order to see the exhaustive list.");
+    assertThat(logTester.logs(LoggerLevel.INFO)).contains("No report imported, no coverage information will be imported by JaCoCo XML Report Importer");
 
-    assertThat(logTester.logs(LoggerLevel.ERROR)).hasSize(1);
+    assertThat(logTester.logs(LoggerLevel.WARN)).hasSize(1);
     assertThat(logTester.logs(LoggerLevel.ERROR)).allMatch(s -> s.startsWith("Coverage report 'invalid.xml' could not be read/imported"));
-
-    verifyNoInteractions(locator, importer);
-  }
-
-  @Test
-  void parse_failure_do_not_fail_analysis() {
-    ModuleFileLocator locator = mock(ModuleFileLocator.class);
-    ReportImporter importer = mock(ReportImporter.class);
-    InputFile inputFile = mock(InputFile.class);
-    Path baseDir = Paths.get("src", "test", "resources");
-    Path invalidFile = baseDir.resolve("invalid_ci_in_line.xml");
-    Path validFile = baseDir.resolve("jacoco.xml");
-
-    when(locator.getInputFile(null, "org/sonarlint/cli", "Stats.java")).thenReturn(inputFile);
-
-    sensor.importReports(Arrays.asList(invalidFile, validFile), locator, importer);
-
-    String expectedErrorMessage = String.format(
-      "Coverage report '%s' could not be read/imported. Error: java.lang.IllegalStateException: Invalid report: failed to parse integer from the attribute 'ci' for the sourcefile 'File.java' at line 6 column 61",
-      invalidFile.toString());
-
-    assertThat(logTester.logs(LoggerLevel.INFO)).contains("Importing 2 report(s). Turn your logs in debug mode in order to see the exhaustive list.");
-
-    assertThat(logTester.logs(LoggerLevel.ERROR)).contains(expectedErrorMessage);
-
-    verify(importer, times(1)).importCoverage(any(), eq(inputFile));
   }
 
   @Test