SONARPY-2120: Ensure coverage report sensor fails gracefully when reports can't be read (#2054)

Author: Seppli11

sonar-python-plugin/src/main/java/org/sonar/plugins/python/coverage/PythonCoverageSensor.java

@@ -29,20 +29,19 @@
 import java.util.Set;
 import java.util.stream.Collectors;
 import javax.xml.stream.XMLStreamException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.sonar.api.batch.fs.InputFile;
 import org.sonar.api.batch.sensor.Sensor;
 import org.sonar.api.batch.sensor.SensorContext;
 import org.sonar.api.batch.sensor.SensorDescriptor;
 import org.sonar.api.batch.sensor.coverage.NewCoverage;
 import org.sonar.api.config.Configuration;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 import org.sonar.plugins.python.EmptyReportException;
 import org.sonar.plugins.python.Python;
+import org.sonar.plugins.python.PythonReportSensor;
 import org.sonar.plugins.python.warnings.AnalysisWarningsWrapper;
 
-import static org.sonar.plugins.python.PythonReportSensor.getReports;
-
 public class PythonCoverageSensor implements Sensor {
 
   private static final Logger LOG = LoggerFactory.getLogger(PythonCoverageSensor.class);
@@ -73,24 +72,38 @@ public void execute(SensorContext context) {
 
     warnDeprecatedPropertyUsage(config);
 
-    HashSet<InputFile> filesCovered = new HashSet<>();
-    List<File> reports = getCoverageReports(baseDir, config);
-    if (!reports.isEmpty()) {
-      LOG.info("Python test coverage");
-      for (File report : uniqueAbsolutePaths(reports)) {
-        Map<InputFile, NewCoverage> coverageMeasures = parseReport(report, context);
-        saveMeasures(coverageMeasures, filesCovered);
+    try {
+      HashSet<InputFile> filesCovered = new HashSet<>();
+      List<File> reports = getCoverageReports(baseDir, config);
+      if (!reports.isEmpty()) {
+        LOG.info("Python test coverage");
+        for (File report : uniqueAbsolutePaths(reports)) {
+          importReport(context, report, filesCovered);
+        }
       }
+    } catch (Exception e) {
+      LOG.warn("Cannot read coverage report, the following exception occurred: '{}'", e.getMessage());
+      analysisWarnings.addUnique("An error occurred while trying to import coverage report(s)");
+    }
+  }
+
+  private void importReport(SensorContext context, File report, HashSet<InputFile> filesCovered) {
+    try {
+      Map<InputFile, NewCoverage> coverageMeasures = parseReport(report, context);
+      saveMeasures(coverageMeasures, filesCovered);
+    } catch (Exception e) {
+      LOG.warn("Cannot read coverage report '{}', the following exception occurred: '{}'", report, e.getMessage());
+      analysisWarnings.addUnique(String.format("An error occurred while trying to import the coverage report: '%s'", report));
     }
   }
 
   private List<File> getCoverageReports(String baseDir, Configuration config) {
     if (!config.hasKey(REPORT_PATHS_KEY)) {
-      return getReports(config, baseDir, REPORT_PATHS_KEY, DEFAULT_REPORT_PATH, analysisWarnings);
+      return PythonReportSensor.getReports(config, baseDir, REPORT_PATHS_KEY, DEFAULT_REPORT_PATH, analysisWarnings);
     }
 
     return Arrays.stream(config.getStringArray(REPORT_PATHS_KEY))
-      .flatMap(path -> getReports(config, baseDir, REPORT_PATHS_KEY, path, analysisWarnings).stream())
+      .flatMap(path -> PythonReportSensor.getReports(config, baseDir, REPORT_PATHS_KEY, path, analysisWarnings).stream())
       .toList();
   }
 
@@ -115,7 +128,8 @@ private Map<InputFile, NewCoverage> parseReport(File report, SensorContext conte
       parser.parseReport(report, context, coverageMeasures);
       if (!parser.errors().isEmpty()) {
         String parseErrors = String.format(String.join("%n", parser.errors()));
-        analysisWarnings.addUnique(String.format("The following error(s) occurred while trying to import coverage report:%n%s", parseErrors));
+        analysisWarnings.addUnique(String.format("The following error(s) occurred while trying to import coverage report:%n%s",
+          parseErrors));
       }
     } catch (EmptyReportException e) {
       analysisWarnings.addUnique(String.format("The coverage report '%s' has been ignored because it seems to be empty.", report));

sonar-python-plugin/src/test/java/org/sonar/plugins/python/coverage/PythonCoverageSensorTest.java

@@ -25,12 +25,13 @@
 import java.nio.file.Path;
 import java.util.Arrays;
 import java.util.List;
-import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
 import org.junit.jupiter.api.io.TempDir;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
 import org.slf4j.event.Level;
 import org.sonar.api.batch.fs.InputFile;
 import org.sonar.api.batch.fs.InputFile.Type;
@@ -40,12 +41,14 @@
 import org.sonar.api.batch.sensor.internal.SensorContextTester;
 import org.sonar.api.config.internal.MapSettings;
 import org.sonar.api.testfixtures.log.LogTesterJUnit5;
+import org.sonar.plugins.python.PythonReportSensor;
 import org.sonar.plugins.python.TestUtils;
 import org.sonar.plugins.python.warnings.AnalysisWarningsWrapper;
 
 import static java.nio.charset.StandardCharsets.UTF_8;
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.contains;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.times;
@@ -284,13 +287,17 @@ void test_comma_separated_paths_with_deprecated_property() {
   @Test
   void should_fail_on_invalid_report() {
     settings.setProperty(PythonCoverageSensor.REPORT_PATHS_KEY, "invalid-coverage-result.xml");
-    assertThatThrownBy(() -> coverageSensor.execute(context)).isInstanceOf(IllegalStateException.class);
+    coverageSensor.execute(context);
+    verify(analysisWarnings).addUnique(contains("An error occurred while trying to import the coverage report: '"));
+    verify(analysisWarnings).addUnique(contains("invalid-coverage-result.xml"));
   }
 
   @Test
   void should_fail_on_unexpected_eof() {
     settings.setProperty(PythonCoverageSensor.REPORT_PATHS_KEY, "coverage_with_eof_error.xml");
-    assertThatThrownBy(() -> coverageSensor.execute(context)).isInstanceOf(IllegalStateException.class);
+    coverageSensor.execute(context);
+    verify(analysisWarnings).addUnique(contains("An error occurred while trying to import the coverage report: '"));
+    verify(analysisWarnings).addUnique(contains("coverage_with_eof_error.xml"));
   }
 
   @Test
@@ -301,6 +308,18 @@ void should_do_nothing_on_empty_report() {
     assertThat(context.lineHits(FILE1_KEY, 1)).isNull();
   }
 
+  @Test
+  void should_warn_on_invalid_basedir() {
+    try(MockedStatic<PythonReportSensor> pythonReportSensorMock = Mockito.mockStatic(PythonReportSensor.class)) {
+      pythonReportSensorMock
+        .when(() -> PythonReportSensor.getReports(any(), any(), any(), any(), any()))
+        .thenThrow(RuntimeException.class);
+      coverageSensor.execute(context);
+
+      verify(analysisWarnings).addUnique(contains("An error occurred while trying to import coverage report(s)"));
+    }
+  }
+
   @Test
   void should_warn_if_source_is_not_directory() {
     settings.setProperty(PythonCoverageSensor.REPORT_PATHS_KEY, "coverage_source_invalid_directory.xml");