diff options
Diffstat (limited to 'sonar-batch')
10 files changed, 373 insertions, 94 deletions
diff --git a/sonar-batch/src/main/java/org/sonar/batch/DefaultProjectTree.java b/sonar-batch/src/main/java/org/sonar/batch/DefaultProjectTree.java index b520c1bcf17..674a5db2182 100644 --- a/sonar-batch/src/main/java/org/sonar/batch/DefaultProjectTree.java +++ b/sonar-batch/src/main/java/org/sonar/batch/DefaultProjectTree.java @@ -33,7 +33,7 @@ import org.sonar.batch.scan.ImmutableProjectReactor; public class DefaultProjectTree implements Startable { private final ProjectConfigurator configurator; - private ImmutableProjectReactor projectReactor; + private final ImmutableProjectReactor projectReactor; private List<Project> projects; private Map<ProjectDefinition, Project> projectsByDef; diff --git a/sonar-batch/src/main/java/org/sonar/batch/analysis/DefaultAnalysisMode.java b/sonar-batch/src/main/java/org/sonar/batch/analysis/DefaultAnalysisMode.java index b4d2e3f322e..2e0d79cf9d1 100644 --- a/sonar-batch/src/main/java/org/sonar/batch/analysis/DefaultAnalysisMode.java +++ b/sonar-batch/src/main/java/org/sonar/batch/analysis/DefaultAnalysisMode.java @@ -36,9 +36,11 @@ import java.util.Map; public class DefaultAnalysisMode extends AbstractAnalysisMode implements AnalysisMode { private static final Logger LOG = LoggerFactory.getLogger(DefaultAnalysisMode.class); + private static final String KEY_ONLY_ANALYZE_CHANGED = "sonar.scanChangedFilesOnly"; private boolean mediumTestMode; private boolean notAssociated; + private boolean onlyChanged; public DefaultAnalysisMode(GlobalProperties globalProps, AnalysisProperties props) { init(globalProps.properties(), props.properties()); @@ -52,6 +54,10 @@ public class DefaultAnalysisMode extends AbstractAnalysisMode implements Analysi return notAssociated; } + public boolean onlyAnalyzeChanged() { + return onlyChanged; + } + private void init(Map<String, String> globalProps, Map<String, String> analysisProps) { // make sure analysis is consistent with global properties boolean globalPreview = isIssues(globalProps); @@ -70,6 +76,8 @@ public class DefaultAnalysisMode extends AbstractAnalysisMode implements Analysi issues = CoreProperties.ANALYSIS_MODE_ISSUES.equals(mode) || CoreProperties.ANALYSIS_MODE_PREVIEW.equals(mode); mediumTestMode = "true".equals(getPropertyWithFallback(analysisProps, globalProps, FakePluginInstaller.MEDIUM_TEST_ENABLED)); notAssociated = issues && rootProjectKeyMissing(analysisProps); + String onlyChangedStr = getPropertyWithFallback(analysisProps, globalProps, KEY_ONLY_ANALYZE_CHANGED); + onlyChanged = issues && "true".equals(onlyChangedStr); } public void printMode() { @@ -86,6 +94,9 @@ public class DefaultAnalysisMode extends AbstractAnalysisMode implements Analysi if (notAssociated) { LOG.info("Local analysis"); } + if (onlyChanged) { + LOG.info("Scanning only changed files"); + } } private static String getPropertyWithFallback(Map<String, String> props1, Map<String, String> props2, String key) { diff --git a/sonar-batch/src/main/java/org/sonar/batch/issue/tracking/LocalIssueTracking.java b/sonar-batch/src/main/java/org/sonar/batch/issue/tracking/LocalIssueTracking.java index 5273748a7f4..eaaf466228e 100644 --- a/sonar-batch/src/main/java/org/sonar/batch/issue/tracking/LocalIssueTracking.java +++ b/sonar-batch/src/main/java/org/sonar/batch/issue/tracking/LocalIssueTracking.java @@ -19,14 +19,20 @@ */ package org.sonar.batch.issue.tracking; +import org.sonar.api.batch.fs.InputFile.Status; + +import org.sonar.batch.analysis.DefaultAnalysisMode; import com.google.common.annotations.VisibleForTesting; import com.google.common.collect.Lists; + import java.util.ArrayList; import java.util.Collection; import java.util.Date; import java.util.List; import java.util.Set; + import javax.annotation.CheckForNull; + import org.sonar.api.batch.BatchSide; import org.sonar.api.batch.fs.internal.DefaultInputFile; import org.sonar.api.batch.rule.ActiveRule; @@ -54,15 +60,18 @@ public class LocalIssueTracking { private final ActiveRules activeRules; private final ServerIssueRepository serverIssueRepository; private final Date analysisDate; + private final DefaultAnalysisMode mode; private boolean hasServerAnalysis; public LocalIssueTracking(BatchComponentCache resourceCache, IssueTracking tracking, ServerLineHashesLoader lastLineHashes, IssueUpdater updater, - ActiveRules activeRules, ServerIssueRepository serverIssueRepository, ProjectRepositories projectRepositories, ReportPublisher reportPublisher) { + ActiveRules activeRules, ServerIssueRepository serverIssueRepository, ProjectRepositories projectRepositories, ReportPublisher reportPublisher, + DefaultAnalysisMode mode) { this.tracking = tracking; this.lastLineHashes = lastLineHashes; this.updater = updater; this.serverIssueRepository = serverIssueRepository; + this.mode = mode; this.analysisDate = ((Project) resourceCache.getRoot().resource()).getAnalysisDate(); this.changeContext = IssueChangeContext.createScan(analysisDate); this.activeRules = activeRules; @@ -78,18 +87,23 @@ public class LocalIssueTracking { public List<DefaultIssue> trackIssues(BatchComponent component, Set<BatchReport.Issue> rawIssues) { List<DefaultIssue> trackedIssues = Lists.newArrayList(); if (hasServerAnalysis) { - // all the issues that are not closed in db before starting this module scan, including manual issues Collection<ServerIssue> serverIssues = loadServerIssues(component); - SourceHashHolder sourceHashHolder = loadSourceHashes(component); + if (shouldCopyServerIssues(component)) { + // raw issues should be empty, we just need to deal with server issues (SONAR-6931) + copyServerIssues(serverIssues, trackedIssues); + } else { - IssueTrackingResult trackingResult = tracking.track(sourceHashHolder, serverIssues, rawIssues); + SourceHashHolder sourceHashHolder = loadSourceHashes(component); - // unmatched from server = issues that have been resolved + issues on disabled/removed rules + manual issues - addUnmatchedFromServer(trackingResult.unmatched(), sourceHashHolder, trackedIssues); + IssueTrackingResult trackingResult = tracking.track(sourceHashHolder, serverIssues, rawIssues); - mergeMatched(component, trackingResult, trackedIssues, rawIssues); + // unmatched from server = issues that have been resolved + issues on disabled/removed rules + manual issues + addUnmatchedFromServer(trackingResult.unmatched(), sourceHashHolder, trackedIssues); + + mergeMatched(component, trackingResult, trackedIssues, rawIssues); + } } if (hasServerAnalysis && ResourceUtils.isRootProject(component.resource())) { @@ -100,8 +114,33 @@ public class LocalIssueTracking { return trackedIssues; } + private boolean shouldCopyServerIssues(BatchComponent component) { + if (mode.onlyAnalyzeChanged() && component.isFile()) { + DefaultInputFile inputFile = (DefaultInputFile) component.inputComponent(); + if (inputFile.status() == Status.SAME) { + return true; + } + } + return false; + } + + private void copyServerIssues(Collection<ServerIssue> serverIssues, List<DefaultIssue> trackedIssues) { + for (ServerIssue serverIssue : serverIssues) { + org.sonar.batch.protocol.input.BatchInput.ServerIssue unmatchedPreviousIssue = ((ServerIssueFromWs) serverIssue).getDto(); + DefaultIssue unmatched = toUnmatchedIssue(unmatchedPreviousIssue); + + ActiveRule activeRule = activeRules.find(unmatched.ruleKey()); + unmatched.setNew(false); + + boolean isRemovedRule = activeRule == null; + unmatched.setBeingClosed(isRemovedRule); + unmatched.setOnDisabledRule(isRemovedRule); + trackedIssues.add(unmatched); + } + } + private DefaultIssue toTracked(BatchComponent component, BatchReport.Issue rawIssue) { - DefaultIssue trackedIssue = new org.sonar.core.issue.DefaultIssueBuilder() + return new org.sonar.core.issue.DefaultIssueBuilder() .componentKey(component.key()) .projectKey("unused") .ruleKey(RuleKey.of(rawIssue.getRuleRepository(), rawIssue.getRuleKey())) @@ -110,7 +149,6 @@ public class LocalIssueTracking { .message(rawIssue.hasMsg() ? rawIssue.getMsg() : null) .severity(rawIssue.getSeverity().name()) .build(); - return trackedIssue; } @CheckForNull diff --git a/sonar-batch/src/main/java/org/sonar/batch/scan/filesystem/ComponentIndexer.java b/sonar-batch/src/main/java/org/sonar/batch/scan/filesystem/ComponentIndexer.java index e4e5a1602ee..29488db579d 100644 --- a/sonar-batch/src/main/java/org/sonar/batch/scan/filesystem/ComponentIndexer.java +++ b/sonar-batch/src/main/java/org/sonar/batch/scan/filesystem/ComponentIndexer.java @@ -53,7 +53,7 @@ public class ComponentIndexer { public void execute(DefaultModuleFileSystem fs) { module.setBaseDir(fs.baseDir()); - for (InputFile inputFile : fs.inputFiles(fs.predicates().all())) { + for (InputFile inputFile : fs.inputFiles()) { String languageKey = inputFile.language(); boolean unitTest = InputFile.Type.TEST == inputFile.type(); Resource sonarFile = File.create(inputFile.relativePath(), languages.get(languageKey), unitTest); diff --git a/sonar-batch/src/main/java/org/sonar/batch/scan/filesystem/DefaultModuleFileSystem.java b/sonar-batch/src/main/java/org/sonar/batch/scan/filesystem/DefaultModuleFileSystem.java index 24e26f5eb94..17d6f8d4271 100644 --- a/sonar-batch/src/main/java/org/sonar/batch/scan/filesystem/DefaultModuleFileSystem.java +++ b/sonar-batch/src/main/java/org/sonar/batch/scan/filesystem/DefaultModuleFileSystem.java @@ -19,19 +19,25 @@ */ package org.sonar.batch.scan.filesystem; +import org.sonar.api.batch.fs.InputFile.Status; + +import org.sonar.batch.analysis.DefaultAnalysisMode; import com.google.common.annotations.VisibleForTesting; import com.google.common.base.Function; import com.google.common.collect.Collections2; import com.google.common.collect.ImmutableList; import com.google.common.collect.Lists; + import java.io.File; import java.nio.charset.Charset; import java.util.ArrayList; import java.util.Collection; import java.util.List; import java.util.Map; + import javax.annotation.CheckForNull; import javax.annotation.Nullable; + import org.apache.commons.lang.StringUtils; import org.sonar.api.CoreProperties; import org.sonar.api.batch.fs.FilePredicate; @@ -59,7 +65,7 @@ public class DefaultModuleFileSystem extends DefaultFileSystem implements Module private boolean initialized; public DefaultModuleFileSystem(ModuleInputFileCache moduleInputFileCache, Project project, - Settings settings, FileIndexer indexer, ModuleFileSystemInitializer initializer, ComponentIndexer componentIndexer) { + Settings settings, FileIndexer indexer, ModuleFileSystemInitializer initializer, ComponentIndexer componentIndexer, DefaultAnalysisMode mode) { super(initializer.baseDir(), moduleInputFileCache); this.componentIndexer = componentIndexer; this.moduleKey = project.getKey(); @@ -70,11 +76,16 @@ public class DefaultModuleFileSystem extends DefaultFileSystem implements Module this.sourceDirsOrFiles = initializer.sources(); this.testDirsOrFiles = initializer.tests(); this.binaryDirs = initializer.binaryDirs(); + + // filter the files that sensors have access to (SONAR-6931) + if (mode.onlyAnalyzeChanged()) { + setDefaultPredicate(predicates.not(predicates.hasStatus(Status.SAME))); + } } @VisibleForTesting public DefaultModuleFileSystem(Project project, - Settings settings, FileIndexer indexer, ModuleFileSystemInitializer initializer, ComponentIndexer componentIndexer) { + Settings settings, FileIndexer indexer, ModuleFileSystemInitializer initializer, ComponentIndexer componentIndexer, DefaultAnalysisMode mode) { super(initializer.baseDir().toPath()); this.componentIndexer = componentIndexer; this.moduleKey = project.getKey(); @@ -85,6 +96,11 @@ public class DefaultModuleFileSystem extends DefaultFileSystem implements Module this.sourceDirsOrFiles = initializer.sources(); this.testDirsOrFiles = initializer.tests(); this.binaryDirs = initializer.binaryDirs(); + + // filter the files sensors have access to + if (mode.onlyAnalyzeChanged()) { + setDefaultPredicate(predicates.not(predicates.hasStatus(Status.SAME))); + } } public boolean isInitialized() { diff --git a/sonar-batch/src/main/java/org/sonar/batch/scan/filesystem/InputPathCache.java b/sonar-batch/src/main/java/org/sonar/batch/scan/filesystem/InputPathCache.java index 3164a69d10a..195f1441bb4 100644 --- a/sonar-batch/src/main/java/org/sonar/batch/scan/filesystem/InputPathCache.java +++ b/sonar-batch/src/main/java/org/sonar/batch/scan/filesystem/InputPathCache.java @@ -19,19 +19,14 @@ */ package org.sonar.batch.scan.filesystem; -import com.google.common.base.Function; -import com.google.common.collect.Iterables; -import java.util.Collection; -import java.util.Collections; -import java.util.LinkedHashMap; -import java.util.Map; -import java.util.SortedMap; -import java.util.TreeMap; -import javax.annotation.CheckForNull; +import com.google.common.collect.Table; +import com.google.common.collect.TreeBasedTable; import org.sonar.api.batch.BatchSide; import org.sonar.api.batch.fs.InputDir; import org.sonar.api.batch.fs.InputFile; +import javax.annotation.CheckForNull; + /** * Cache of all files and dirs. This cache is shared amongst all project modules. Inclusion and * exclusion patterns are already applied. @@ -39,91 +34,59 @@ import org.sonar.api.batch.fs.InputFile; @BatchSide public class InputPathCache { - private final Map<String, SortedMap<String, InputFile>> inputFileCache = new LinkedHashMap<>(); - private final Map<String, SortedMap<String, InputDir>> inputDirCache = new LinkedHashMap<>(); + private final Table<String, String, InputFile> inputFileCache = TreeBasedTable.create(); + private final Table<String, String, InputDir> inputDirCache = TreeBasedTable.create(); public Iterable<InputFile> allFiles() { - return Iterables.concat(Iterables.transform(inputFileCache.values(), new Function<Map<String, InputFile>, Collection<InputFile>>() { - @Override - public Collection<InputFile> apply(Map<String, InputFile> input) { - return input.values(); - } - })); + return inputFileCache.values(); } public Iterable<InputDir> allDirs() { - return Iterables.concat(Iterables.transform(inputDirCache.values(), new Function<Map<String, InputDir>, Collection<InputDir>>() { - @Override - public Collection<InputDir> apply(Map<String, InputDir> input) { - return input.values(); - } - })); + return inputDirCache.values(); } public Iterable<InputFile> filesByModule(String moduleKey) { - if (inputFileCache.containsKey(moduleKey)) { - return inputFileCache.get(moduleKey).values(); - } - return Collections.emptyList(); + return inputFileCache.row(moduleKey).values(); } public Iterable<InputDir> dirsByModule(String moduleKey) { - if (inputDirCache.containsKey(moduleKey)) { - return inputDirCache.get(moduleKey).values(); - } - return Collections.emptyList(); + return inputDirCache.row(moduleKey).values(); } public InputPathCache removeModule(String moduleKey) { - inputFileCache.remove(moduleKey); - inputDirCache.remove(moduleKey); + inputFileCache.row(moduleKey).clear(); + inputDirCache.row(moduleKey).clear(); return this; } public InputPathCache remove(String moduleKey, InputFile inputFile) { - if (inputFileCache.containsKey(moduleKey)) { - inputFileCache.get(moduleKey).remove(inputFile.relativePath()); - } + inputFileCache.remove(moduleKey, inputFile.relativePath()); return this; } public InputPathCache remove(String moduleKey, InputDir inputDir) { - if (inputDirCache.containsKey(moduleKey)) { - inputDirCache.get(moduleKey).remove(inputDir.relativePath()); - } + inputDirCache.remove(moduleKey, inputDir.relativePath()); return this; } public InputPathCache put(String moduleKey, InputFile inputFile) { - if (!inputFileCache.containsKey(moduleKey)) { - inputFileCache.put(moduleKey, new TreeMap<String, InputFile>()); - } - inputFileCache.get(moduleKey).put(inputFile.relativePath(), inputFile); + inputFileCache.put(moduleKey, inputFile.relativePath(), inputFile); return this; } public InputPathCache put(String moduleKey, InputDir inputDir) { - if (!inputDirCache.containsKey(moduleKey)) { - inputDirCache.put(moduleKey, new TreeMap<String, InputDir>()); - } - inputDirCache.get(moduleKey).put(inputDir.relativePath(), inputDir); + inputDirCache.put(moduleKey, inputDir.relativePath(), inputDir); return this; } @CheckForNull public InputFile getFile(String moduleKey, String relativePath) { - if (inputFileCache.containsKey(moduleKey)) { - return inputFileCache.get(moduleKey).get(relativePath); - } - return null; + return inputFileCache.get(moduleKey, relativePath); } @CheckForNull public InputDir getDir(String moduleKey, String relativePath) { - if (inputDirCache.containsKey(moduleKey)) { - return inputDirCache.get(moduleKey).get(relativePath); - } - return null; + return inputDirCache.get(moduleKey, relativePath); } } diff --git a/sonar-batch/src/test/java/org/sonar/batch/analysis/DefaultAnalysisModeTest.java b/sonar-batch/src/test/java/org/sonar/batch/analysis/DefaultAnalysisModeTest.java index 7ea7a4088d0..9c9b294cbaf 100644 --- a/sonar-batch/src/test/java/org/sonar/batch/analysis/DefaultAnalysisModeTest.java +++ b/sonar-batch/src/test/java/org/sonar/batch/analysis/DefaultAnalysisModeTest.java @@ -20,7 +20,6 @@ package org.sonar.batch.analysis; import org.junit.Rule; - import org.junit.rules.ExpectedException; import org.sonar.batch.analysis.DefaultAnalysisMode; import org.sonar.batch.analysis.AnalysisProperties; @@ -85,9 +84,29 @@ public class DefaultAnalysisModeTest { } @Test + public void only_scan_changed() { + Map<String, String> props = new HashMap<>(); + props.put(CoreProperties.ANALYSIS_MODE, CoreProperties.ANALYSIS_MODE_ISSUES); + GlobalProperties globalProps = new GlobalProperties(props); + + props.put("sonar.scanChangedFilesOnly", "true"); + AnalysisProperties analysisProps = new AnalysisProperties(props); + + DefaultAnalysisMode mode = new DefaultAnalysisMode(globalProps, analysisProps); + assertThat(mode.onlyAnalyzeChanged()).isTrue(); + + props.put(CoreProperties.ANALYSIS_MODE, CoreProperties.ANALYSIS_MODE_PUBLISH); + analysisProps = new AnalysisProperties(props); + + mode = new DefaultAnalysisMode(globalProps, analysisProps); + assertThat(mode.onlyAnalyzeChanged()).isFalse(); + } + + @Test public void default_publish_mode() { DefaultAnalysisMode mode = createMode(null); assertThat(mode.isPublish()).isTrue(); + assertThat(mode.onlyAnalyzeChanged()).isFalse(); } @Test @@ -95,6 +114,7 @@ public class DefaultAnalysisModeTest { DefaultAnalysisMode mode = createMode(CoreProperties.ANALYSIS_MODE_ISSUES); assertThat(mode.isIssues()).isTrue(); + assertThat(mode.onlyAnalyzeChanged()).isFalse(); } private static DefaultAnalysisMode createMode(@Nullable String mode) { diff --git a/sonar-batch/src/test/java/org/sonar/batch/mediumtest/issuesmode/ScanOnlyChangedTest.java b/sonar-batch/src/test/java/org/sonar/batch/mediumtest/issuesmode/ScanOnlyChangedTest.java new file mode 100644 index 00000000000..05e68afb164 --- /dev/null +++ b/sonar-batch/src/test/java/org/sonar/batch/mediumtest/issuesmode/ScanOnlyChangedTest.java @@ -0,0 +1,186 @@ +/* + * SonarQube, open source software quality management tool. + * Copyright (C) 2008-2014 SonarSource + * mailto:contact AT sonarsource DOT com + * + * SonarQube 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. + * + * SonarQube 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.batch.mediumtest.issuesmode; + +import org.assertj.core.api.Condition; + +import com.google.common.io.Resources; +import org.sonar.batch.repository.FileData; +import com.google.common.collect.ImmutableMap; +import org.apache.commons.codec.digest.DigestUtils; +import org.apache.commons.io.FileUtils; +import org.apache.commons.io.filefilter.FileFilterUtils; +import org.junit.After; +import org.junit.Before; +import org.sonar.api.CoreProperties; +import org.sonar.batch.mediumtest.BatchMediumTester; +import org.sonar.batch.protocol.Constants.Severity; +import org.sonar.batch.protocol.input.BatchInput.ServerIssue; +import org.sonar.xoo.XooPlugin; +import org.sonar.xoo.rule.XooRulesDefinition; +import org.junit.rules.TemporaryFolder; +import org.sonar.api.utils.log.LogTester; +import org.junit.Test; +import org.sonar.api.issue.Issue; +import org.sonar.batch.mediumtest.TaskResult; + +import java.io.File; +import java.io.IOException; +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.util.Date; + +import static org.assertj.core.api.Assertions.assertThat; + +public class ScanOnlyChangedTest { + @org.junit.Rule + public TemporaryFolder temp = new TemporaryFolder(); + + @org.junit.Rule + public LogTester logTester = new LogTester(); + + private static SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy"); + + private BatchMediumTester tester; + + private static Long date(String date) { + try { + return sdf.parse(date).getTime(); + } catch (ParseException e) { + throw new IllegalStateException(e); + } + } + + @Before + public void prepare() throws IOException { + String filePath = "xources/hello/HelloJava.xoo"; + String md5sum = DigestUtils.md5Hex(FileUtils.readFileToString(new File( + Resources.getResource("mediumtest/xoo/sample/" + filePath).getPath()))); + + tester = BatchMediumTester.builder() + .bootstrapProperties(ImmutableMap.of(CoreProperties.ANALYSIS_MODE, CoreProperties.ANALYSIS_MODE_ISSUES)) + .registerPlugin("xoo", new XooPlugin()) + .addDefaultQProfile("xoo", "Sonar Way") + .addRules(new XooRulesDefinition()) + .addRule("manual:MyManualIssue", "manual", "MyManualIssue", "My manual issue") + .addRule("manual:MyManualIssueDup", "manual", "MyManualIssue", "My manual issue") + .addActiveRule("xoo", "OneIssuePerLine", null, "One issue per line", "MAJOR", null, "xoo") + .addActiveRule("xoo", "OneIssueOnDirPerFile", null, "OneIssueOnDirPerFile", "MAJOR", null, "xoo") + .addActiveRule("xoo", "OneIssuePerModule", null, "OneIssuePerModule", "MAJOR", null, "xoo") + .addActiveRule("manual", "MyManualIssue", null, "My manual issue", "MAJOR", null, null) + // this will cause the file to have status==SAME + .addFileData("sample", filePath, new FileData(md5sum, null)) + .setPreviousAnalysisDate(new Date()) + // Existing issue that is copied + .mockServerIssue(ServerIssue.newBuilder().setKey("xyz") + .setModuleKey("sample") + .setMsg("One issue per Line copied") + .setPath("xources/hello/HelloJava.xoo") + .setRuleRepository("xoo") + .setRuleKey("OneIssuePerLine") + .setLine(1) + .setSeverity(Severity.MAJOR) + .setCreationDate(date("14/03/2004")) + .setChecksum(DigestUtils.md5Hex("packagehello;")) + .setStatus("OPEN") + .build()) + // Existing issue on project that is still detected + .mockServerIssue(ServerIssue.newBuilder().setKey("resolved-on-project") + .setModuleKey("sample") + .setRuleRepository("xoo") + .setRuleKey("OneIssuePerModule") + .setSeverity(Severity.CRITICAL) + .setCreationDate(date("14/03/2004")) + .setStatus("OPEN") + .build()) + // Manual issue + .mockServerIssue(ServerIssue.newBuilder().setKey("manual") + .setModuleKey("sample") + .setPath("xources/hello/HelloJava.xoo") + .setRuleRepository("manual") + .setRuleKey("MyManualIssue") + .setLine(1) + .setSeverity(Severity.MAJOR) + .setCreationDate(date("14/03/2004")) + .setChecksum(DigestUtils.md5Hex("packagehello;")) + .setStatus("OPEN") + .build()) + .build(); + tester.start(); + } + + @After + public void stop() { + tester.stop(); + } + + private File copyProject(String path) throws Exception { + File projectDir = temp.newFolder(); + File originalProjectDir = new File(IssueModeAndReportsMediumTest.class.getResource(path).toURI()); + FileUtils.copyDirectory(originalProjectDir, projectDir, FileFilterUtils.notFileFilter(FileFilterUtils.nameFileFilter(".sonar"))); + return projectDir; + } + + @Test + public void testIssueTrackingChangedFiles() throws Exception { + File projectDir = copyProject("/mediumtest/xoo/sample"); + + TaskResult result = tester + .newScanTask(new File(projectDir, "sonar-project.properties")) + .property("sonar.scanChangedFilesOnly", "true") + .start(); + + int newIssues = 0; + int openIssues = 0; + int resolvedIssue = 0; + for (Issue issue : result.trackedIssues()) { + System.out + .println(issue.message() + " " + issue.key() + " " + issue.ruleKey() + " " + issue.isNew() + " " + issue.resolution() + " " + issue.componentKey() + " " + issue.line()); + if (issue.isNew()) { + newIssues++; + } else if (issue.resolution() != null) { + resolvedIssue++; + } else { + openIssues++; + } + } + /* + * We have: + * 6 new issues per line (open) in helloscala.xoo + * 2 new issues per file in helloscala.xoo / ClassOneTest.xoo + * 1 server issue (open, not new) copied from server in HelloJava.xoo (this file is unchanged) + * 1 manual issue (open, not new) in HelloJava.xoo + * 1 existing issue on the project (open, not new) + */ + System.out.println("new: " + newIssues + " open: " + openIssues + " resolved " + resolvedIssue); + assertThat(newIssues).isEqualTo(8); + assertThat(openIssues).isEqualTo(3); + assertThat(resolvedIssue).isEqualTo(0); + + // should only have server issues (HelloJava.xoo should not have been analyzed) + assertThat(result.trackedIssues()).haveExactly(2, new Condition<Issue>() { + @Override + public boolean matches(Issue value) { + return value.componentKey().endsWith("HelloJava.xoo"); + } + }); + } + +} diff --git a/sonar-batch/src/test/java/org/sonar/batch/scan/filesystem/ComponentIndexerTest.java b/sonar-batch/src/test/java/org/sonar/batch/scan/filesystem/ComponentIndexerTest.java index 016dc1c3c46..dceefcaaaac 100644 --- a/sonar-batch/src/test/java/org/sonar/batch/scan/filesystem/ComponentIndexerTest.java +++ b/sonar-batch/src/test/java/org/sonar/batch/scan/filesystem/ComponentIndexerTest.java @@ -19,8 +19,13 @@ */ package org.sonar.batch.scan.filesystem; +import org.sonar.api.batch.fs.InputFile.Status; + +import org.sonar.batch.analysis.DefaultAnalysisMode; + import java.io.File; import java.io.IOException; + import org.apache.commons.io.FileUtils; import org.junit.Before; import org.junit.Rule; @@ -40,7 +45,6 @@ import org.sonar.api.resources.Qualifiers; import org.sonar.api.resources.Resource; import org.sonar.batch.index.BatchComponent; import org.sonar.batch.index.BatchComponentCache; - import static org.mockito.Matchers.any; import static org.mockito.Matchers.argThat; import static org.mockito.Mockito.mock; @@ -57,6 +61,7 @@ public class ComponentIndexerTest { private AbstractLanguage cobolLanguage; private Project project; private ModuleFileSystemInitializer initializer; + private DefaultAnalysisMode mode; @Before public void prepare() throws IOException { @@ -65,6 +70,7 @@ public class ComponentIndexerTest { sonarIndex = mock(SonarIndex.class); project = new Project("myProject"); initializer = mock(ModuleFileSystemInitializer.class); + mode = mock(DefaultAnalysisMode.class); when(initializer.baseDir()).thenReturn(baseDir); when(initializer.workingDir()).thenReturn(temp.newFolder()); cobolLanguage = new AbstractLanguage("cobol") { @@ -79,10 +85,11 @@ public class ComponentIndexerTest { public void should_index_java_files() throws IOException { Languages languages = new Languages(Java.INSTANCE); ComponentIndexer indexer = createIndexer(languages); - DefaultModuleFileSystem fs = new DefaultModuleFileSystem(project, null, mock(FileIndexer.class), initializer, indexer); - fs.add(newInputFile("src/main/java/foo/bar/Foo.java", "", "foo/bar/Foo.java", "java", false)); - fs.add(newInputFile("src/main/java2/foo/bar/Foo.java", "", "foo/bar/Foo.java", "java", false)); - fs.add(newInputFile("src/test/java/foo/bar/FooTest.java", "", "foo/bar/FooTest.java", "java", true)); + DefaultModuleFileSystem fs = new DefaultModuleFileSystem(project, null, mock(FileIndexer.class), initializer, indexer, mode); + fs.add(newInputFile("src/main/java/foo/bar/Foo.java", "", "foo/bar/Foo.java", "java", false, Status.ADDED)); + fs.add(newInputFile("src/main/java2/foo/bar/Foo.java", "", "foo/bar/Foo.java", "java", false, Status.ADDED)); + // should index even if filter is applied + fs.add(newInputFile("src/test/java/foo/bar/FooTest.java", "", "foo/bar/FooTest.java", "java", true, Status.SAME)); fs.index(); @@ -110,10 +117,10 @@ public class ComponentIndexerTest { public void should_index_cobol_files() throws IOException { Languages languages = new Languages(cobolLanguage); ComponentIndexer indexer = createIndexer(languages); - DefaultModuleFileSystem fs = new DefaultModuleFileSystem(project, null, mock(FileIndexer.class), initializer, indexer); - fs.add(newInputFile("src/foo/bar/Foo.cbl", "", "foo/bar/Foo.cbl", "cobol", false)); - fs.add(newInputFile("src2/foo/bar/Foo.cbl", "", "foo/bar/Foo.cbl", "cobol", false)); - fs.add(newInputFile("src/test/foo/bar/FooTest.cbl", "", "foo/bar/FooTest.cbl", "cobol", true)); + DefaultModuleFileSystem fs = new DefaultModuleFileSystem(project, null, mock(FileIndexer.class), initializer, indexer, mode); + fs.add(newInputFile("src/foo/bar/Foo.cbl", "", "foo/bar/Foo.cbl", "cobol", false, Status.ADDED)); + fs.add(newInputFile("src2/foo/bar/Foo.cbl", "", "foo/bar/Foo.cbl", "cobol", false, Status.ADDED)); + fs.add(newInputFile("src/test/foo/bar/FooTest.cbl", "", "foo/bar/FooTest.cbl", "cobol", true, Status.ADDED)); fs.index(); @@ -122,12 +129,13 @@ public class ComponentIndexerTest { verify(sonarIndex).index(org.sonar.api.resources.File.create("/src/test/foo/bar/FooTest.cbl", cobolLanguage, true)); } - private DefaultInputFile newInputFile(String path, String content, String sourceRelativePath, String languageKey, boolean unitTest) throws IOException { + private DefaultInputFile newInputFile(String path, String content, String sourceRelativePath, String languageKey, boolean unitTest, InputFile.Status status) throws IOException { File file = new File(baseDir, path); FileUtils.write(file, content); return new DefaultInputFile("foo", path) .setLanguage(languageKey) - .setType(unitTest ? InputFile.Type.TEST : InputFile.Type.MAIN); + .setType(unitTest ? InputFile.Type.TEST : InputFile.Type.MAIN) + .setStatus(status); } } diff --git a/sonar-batch/src/test/java/org/sonar/batch/scan/filesystem/DefaultModuleFileSystemTest.java b/sonar-batch/src/test/java/org/sonar/batch/scan/filesystem/DefaultModuleFileSystemTest.java index 4a5e04b4a8e..ea087c8ebcb 100644 --- a/sonar-batch/src/test/java/org/sonar/batch/scan/filesystem/DefaultModuleFileSystemTest.java +++ b/sonar-batch/src/test/java/org/sonar/batch/scan/filesystem/DefaultModuleFileSystemTest.java @@ -19,6 +19,10 @@ */ package org.sonar.batch.scan.filesystem; +import org.sonar.api.batch.fs.InputFile.Status; + +import org.junit.Before; +import org.sonar.batch.analysis.DefaultAnalysisMode; import com.google.common.collect.Lists; import org.junit.Rule; import org.junit.Test; @@ -50,22 +54,33 @@ public class DefaultModuleFileSystemTest { @Rule public ExpectedException thrown = ExpectedException.none(); - Settings settings = new Settings(); - FileIndexer fileIndexer = mock(FileIndexer.class); - ModuleFileSystemInitializer initializer = mock(ModuleFileSystemInitializer.class, Mockito.RETURNS_DEEP_STUBS); - ComponentIndexer componentIndexer = mock(ComponentIndexer.class); - ModuleInputFileCache moduleInputFileCache = mock(ModuleInputFileCache.class); + private Settings settings; + private FileIndexer fileIndexer; + private ModuleFileSystemInitializer initializer; + private ComponentIndexer componentIndexer; + private ModuleInputFileCache moduleInputFileCache; + private DefaultAnalysisMode mode; + + @Before + public void setUp() { + settings = new Settings(); + fileIndexer = mock(FileIndexer.class); + initializer = mock(ModuleFileSystemInitializer.class, Mockito.RETURNS_DEEP_STUBS); + componentIndexer = mock(ComponentIndexer.class); + moduleInputFileCache = mock(ModuleInputFileCache.class); + mode = mock(DefaultAnalysisMode.class); + } @Test public void test_equals_and_hashCode() throws Exception { DefaultModuleFileSystem foo1 = new DefaultModuleFileSystem(moduleInputFileCache, - new Project("foo"), settings, fileIndexer, initializer, componentIndexer); + new Project("foo"), settings, fileIndexer, initializer, componentIndexer, mode); DefaultModuleFileSystem foo2 = new DefaultModuleFileSystem(moduleInputFileCache, - new Project("foo"), settings, fileIndexer, initializer, componentIndexer); + new Project("foo"), settings, fileIndexer, initializer, componentIndexer, mode); DefaultModuleFileSystem bar = new DefaultModuleFileSystem(moduleInputFileCache, - new Project("bar"), settings, fileIndexer, initializer, componentIndexer); + new Project("bar"), settings, fileIndexer, initializer, componentIndexer, mode); DefaultModuleFileSystem branch = new DefaultModuleFileSystem(moduleInputFileCache, - new Project("bar", "branch", "My project"), settings, fileIndexer, initializer, componentIndexer); + new Project("bar", "branch", "My project"), settings, fileIndexer, initializer, componentIndexer, mode); assertThat(foo1.moduleKey()).isEqualTo("foo"); assertThat(branch.moduleKey()).isEqualTo("bar:branch"); @@ -80,7 +95,7 @@ public class DefaultModuleFileSystemTest { @Test public void default_source_encoding() { DefaultModuleFileSystem fs = new DefaultModuleFileSystem(moduleInputFileCache, - new Project("foo"), settings, fileIndexer, initializer, componentIndexer); + new Project("foo"), settings, fileIndexer, initializer, componentIndexer, mode); assertThat(fs.sourceCharset()).isEqualTo(Charset.defaultCharset()); assertThat(fs.isDefaultJvmEncoding()).isTrue(); @@ -90,7 +105,7 @@ public class DefaultModuleFileSystemTest { public void source_encoding_is_set() { settings.setProperty(CoreProperties.ENCODING_PROPERTY, "Cp1124"); DefaultModuleFileSystem fs = new DefaultModuleFileSystem(moduleInputFileCache, - new Project("foo"), settings, fileIndexer, initializer, componentIndexer); + new Project("foo"), settings, fileIndexer, initializer, componentIndexer, mode); assertThat(fs.encoding()).isEqualTo(Charset.forName("Cp1124")); assertThat(fs.sourceCharset()).isEqualTo(Charset.forName("Cp1124")); @@ -100,6 +115,28 @@ public class DefaultModuleFileSystemTest { } @Test + public void default_predicate_scan_only_changed() throws IOException { + when(mode.onlyAnalyzeChanged()).thenReturn(true); + + DefaultModuleFileSystem fs = new DefaultModuleFileSystem(moduleInputFileCache, + new Project("foo"), settings, fileIndexer, initializer, componentIndexer, mode); + + File baseDir = temp.newFile(); + InputFile mainInput = new DefaultInputFile("foo", "Main.java").setModuleBaseDir(baseDir.toPath()).setType(InputFile.Type.MAIN); + InputFile testInput = new DefaultInputFile("foo", "Test.java").setModuleBaseDir(baseDir.toPath()).setType(InputFile.Type.TEST); + InputFile mainSameInput = new DefaultInputFile("foo", "MainSame.java").setModuleBaseDir(baseDir.toPath()) + .setType(InputFile.Type.TEST).setStatus(Status.SAME); + when(moduleInputFileCache.inputFiles()).thenReturn(Lists.newArrayList(mainInput, testInput, mainSameInput)); + + fs.index(); + Iterable<InputFile> inputFiles = fs.inputFiles(fs.predicates().all()); + assertThat(inputFiles).containsOnly(mainInput, testInput); + + Iterable<InputFile> allInputFiles = fs.inputFiles(); + assertThat(allInputFiles).containsOnly(mainInput, mainSameInput, testInput); + } + + @Test public void test_dirs() throws IOException { File basedir = temp.newFolder("base"); File buildDir = temp.newFolder("build"); @@ -120,7 +157,7 @@ public class DefaultModuleFileSystemTest { when(initializer.tests()).thenReturn(Arrays.asList(javaTest, additionalTest)); DefaultModuleFileSystem fs = new DefaultModuleFileSystem(moduleInputFileCache, - new Project("foo"), settings, fileIndexer, initializer, componentIndexer); + new Project("foo"), settings, fileIndexer, initializer, componentIndexer, mode); assertThat(fs.baseDir().getCanonicalPath()).isEqualTo(basedir.getCanonicalPath()); assertThat(fs.workDir().getCanonicalPath()).isEqualTo(workingDir.getCanonicalPath()); @@ -133,7 +170,7 @@ public class DefaultModuleFileSystemTest { @Test public void should_search_input_files() throws Exception { DefaultModuleFileSystem fs = new DefaultModuleFileSystem(moduleInputFileCache, - new Project("foo"), settings, fileIndexer, initializer, componentIndexer); + new Project("foo"), settings, fileIndexer, initializer, componentIndexer, mode); File baseDir = temp.newFile(); InputFile mainInput = new DefaultInputFile("foo", "Main.java").setModuleBaseDir(baseDir.toPath()).setType(InputFile.Type.MAIN); @@ -151,7 +188,7 @@ public class DefaultModuleFileSystemTest { @Test public void should_index() { DefaultModuleFileSystem fs = new DefaultModuleFileSystem(moduleInputFileCache, - new Project("foo"), settings, fileIndexer, initializer, componentIndexer); + new Project("foo"), settings, fileIndexer, initializer, componentIndexer, mode); verifyZeroInteractions(fileIndexer); |