SONAR-11245 Record a warning when blame information is missing on some files during analysis

sonar-scanner-engine/src/main/java/org/sonar/scanner/scan/filesystem/CharsetDetector.java

 
 public class CharsetDetector {
   private static final int BYTES_TO_DECODE = 4192;
-  private Path filePath;
+  private final Path filePath;
   private BufferedInputStream stream;
   private Charset detectedCharset;
   private Charset userEncoding;

sonar-scanner-engine/src/main/java/org/sonar/scanner/scm/DefaultBlameOutput.java

 import org.sonar.api.batch.fs.internal.DefaultInputFile;
 import org.sonar.api.batch.scm.BlameCommand.BlameOutput;
 import org.sonar.api.batch.scm.BlameLine;
+import org.sonar.api.notifications.AnalysisWarnings;
 import org.sonar.api.utils.log.Logger;
 import org.sonar.api.utils.log.Loggers;
 import org.sonar.scanner.protocol.output.ScannerReport;
   private static final Logger LOG = Loggers.get(DefaultBlameOutput.class);
 
   private final ScannerReportWriter writer;
+  private AnalysisWarnings analysisWarnings;
   private final Set<InputFile> allFilesToBlame = new LinkedHashSet<>();
   private ProgressReport progressReport;
   private int count;
   private int total;
 
-  DefaultBlameOutput(ScannerReportWriter writer, List<InputFile> filesToBlame) {
+  DefaultBlameOutput(ScannerReportWriter writer, AnalysisWarnings analysisWarnings, List<InputFile> filesToBlame) {
     this.writer = writer;
+    this.analysisWarnings = analysisWarnings;
     this.allFilesToBlame.addAll(filesToBlame);
     count = 0;
     total = filesToBlame.size();
         LOG.warn("  * " + f);
       }
       LOG.warn("This may lead to missing/broken features in SonarQube");
+      analysisWarnings.addUnique(String.format("Missing blame information for %d %s. This may lead to some features not working correctly. Please check the analysis logs.",
+        allFilesToBlame.size(),
+        allFilesToBlame.size() > 1 ? "files" : "file"));
     }
   }
 

sonar-scanner-engine/src/main/java/org/sonar/scanner/scm/ScmPublisher.java

 import org.sonar.api.batch.fs.InputFile.Status;
 import org.sonar.api.batch.fs.internal.DefaultInputFile;
 import org.sonar.api.batch.scm.ScmProvider;
+import org.sonar.api.notifications.AnalysisWarnings;
 import org.sonar.api.utils.log.Logger;
 import org.sonar.api.utils.log.Loggers;
 import org.sonar.scanner.protocol.output.ScannerReport;
   private final InputComponentStore componentStore;
   private final FileSystem fs;
   private final ScannerReportWriter writer;
+  private AnalysisWarnings analysisWarnings;
   private final BranchConfiguration branchConfiguration;
 
   public ScmPublisher(ScmConfiguration configuration, ProjectRepositoriesSupplier projectRepositoriesSupplier,
-    InputComponentStore componentStore, FileSystem fs, ReportPublisher reportPublisher, BranchConfiguration branchConfiguration) {
+    InputComponentStore componentStore, FileSystem fs, ReportPublisher reportPublisher, BranchConfiguration branchConfiguration, AnalysisWarnings analysisWarnings) {
     this.configuration = configuration;
     this.projectRepositoriesSupplier = projectRepositoriesSupplier;
     this.componentStore = componentStore;
     this.fs = fs;
     this.branchConfiguration = branchConfiguration;
     this.writer = reportPublisher.getWriter();
+    this.analysisWarnings = analysisWarnings;
   }
 
   public void publish() {
     if (!filesToBlame.isEmpty()) {
       String key = provider.key();
       LOG.info("SCM Publisher SCM provider for this project is: " + key);
-      DefaultBlameOutput output = new DefaultBlameOutput(writer, filesToBlame);
+      DefaultBlameOutput output = new DefaultBlameOutput(writer, analysisWarnings, filesToBlame);
       try {
         provider.blameCommand().blame(new DefaultBlameInput(fs, filesToBlame), output);
       } catch (Exception e) {

sonar-scanner-engine/src/test/java/org/sonar/scanner/scm/DefaultBlameOutputTest.java

 package org.sonar.scanner.scm;
 
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.Date;
 import org.junit.Rule;
 import org.junit.Test;
 import org.sonar.api.batch.fs.InputFile;
 import org.sonar.api.batch.fs.internal.TestInputFileBuilder;
 import org.sonar.api.batch.scm.BlameLine;
+import org.sonar.api.utils.System2;
+import org.sonar.scanner.notifications.DefaultAnalysisWarnings;
+
+import static java.util.Collections.emptyList;
+import static java.util.Collections.singletonList;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
 
 public class DefaultBlameOutputTest {
 
   @Rule
   public ExpectedException thrown = ExpectedException.none();
+  private System2 system2 = mock(System2.class);
+  private DefaultAnalysisWarnings analysisWarnings = new DefaultAnalysisWarnings(system2);
 
   @Test
   public void shouldNotFailIfNotSameNumberOfLines() {
     InputFile file = new TestInputFileBuilder("foo", "src/main/java/Foo.java").setLines(10).build();
 
-    new DefaultBlameOutput(null, Arrays.asList(file)).blameResult(file, Arrays.asList(new BlameLine().revision("1").author("guy")));
+    new DefaultBlameOutput(null, analysisWarnings, singletonList(file)).blameResult(file, singletonList(new BlameLine().revision("1").author("guy")));
+  }
+
+  @Test
+  public void addWarningIfFilesMissing() {
+    InputFile file = new TestInputFileBuilder("foo", "src/main/java/Foo.java").setLines(10).build();
+
+    new DefaultBlameOutput(null, analysisWarnings, singletonList(file)).finish(true);
+    assertThat(analysisWarnings.warnings()).extracting(DefaultAnalysisWarnings.Message::getText)
+      .containsOnly("Missing blame information for 1 file. This may lead to some features not working correctly. Please check the analysis logs.");
   }
 
   @Test
     thrown.expect(IllegalArgumentException.class);
     thrown.expectMessage("It was not expected to blame file " + file);
 
-    new DefaultBlameOutput(null, Arrays.<InputFile>asList(new TestInputFileBuilder("foo", "src/main/java/Foo2.java").build()))
-      .blameResult(file, Arrays.asList(new BlameLine().revision("1").author("guy")));
+    new DefaultBlameOutput(null, analysisWarnings, singletonList(new TestInputFileBuilder("foo", "src/main/java/Foo2.java").build()))
+      .blameResult(file, singletonList(new BlameLine().revision("1").author("guy")));
   }
 
   @Test
     thrown.expect(IllegalArgumentException.class);
     thrown.expectMessage("Blame date is null for file " + file + " at line 1");
 
-    new DefaultBlameOutput(null, Arrays.<InputFile>asList(file))
-      .blameResult(file, Arrays.asList(new BlameLine().revision("1").author("guy")));
+    new DefaultBlameOutput(null, analysisWarnings, singletonList(file))
+      .blameResult(file, singletonList(new BlameLine().revision("1").author("guy")));
   }
 
   @Test
     thrown.expect(IllegalArgumentException.class);
     thrown.expectMessage("Blame revision is blank for file " + file + " at line 1");
 
-    new DefaultBlameOutput(null, Arrays.<InputFile>asList(file))
-      .blameResult(file, Arrays.asList(new BlameLine().date(new Date()).author("guy")));
+    new DefaultBlameOutput(null, analysisWarnings, singletonList(file))
+      .blameResult(file, singletonList(new BlameLine().date(new Date()).author("guy")));
   }
 
 }