*/
package org.sonar.xoo.lang;
+import java.io.File;
+import java.io.IOException;
import org.apache.commons.io.FileUtils;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.sonar.api.batch.fs.InputFile;
-import org.sonar.api.batch.fs.internal.DefaultFileSystem;
import org.sonar.api.batch.fs.internal.TestInputFileBuilder;
-import org.sonar.api.batch.sensor.SensorContext;
import org.sonar.api.batch.sensor.internal.DefaultSensorDescriptor;
+import org.sonar.api.batch.sensor.internal.SensorContextTester;
import org.sonar.api.component.ResourcePerspectives;
import org.sonar.api.source.Symbol;
import org.sonar.api.source.Symbolizable;
-import java.io.File;
-import java.io.IOException;
-
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
public class SymbolReferencesSensorTest {
private SymbolReferencesSensor sensor;
- private SensorContext context = mock(SensorContext.class);
- private DefaultFileSystem fileSystem;
+ private SensorContextTester context;
@Rule
public TemporaryFolder temp = new TemporaryFolder();
baseDir = temp.newFolder();
perspectives = mock(ResourcePerspectives.class);
sensor = new SymbolReferencesSensor(perspectives);
- fileSystem = new DefaultFileSystem(baseDir.toPath());
- when(context.fileSystem()).thenReturn(fileSystem);
+ context = SensorContextTester.create(baseDir);
}
@Test
@Test
public void testNoExecutionIfNoSymbolFile() {
InputFile inputFile = new TestInputFileBuilder("foo", "src/foo.xoo").setLanguage("xoo").setModuleBaseDir(baseDir.toPath()).build();
- fileSystem.add(inputFile);
+ context.fileSystem().add(inputFile);
sensor.execute(context);
}
File symbol = new File(baseDir, "src/foo.xoo.symbol");
FileUtils.write(symbol, "1:4,7\n12:15,23:33\n\n#comment");
InputFile inputFile = new TestInputFileBuilder("foo", "src/foo.xoo").setLanguage("xoo").setModuleBaseDir(baseDir.toPath()).build();
- fileSystem.add(inputFile);
+ context.fileSystem().add(inputFile);
Symbolizable symbolizable = mock(Symbolizable.class);
when(perspectives.as(Symbolizable.class, inputFile)).thenReturn(symbolizable);
Symbolizable.SymbolTableBuilder symbolTableBuilder = mock(Symbolizable.SymbolTableBuilder.class);
*/
public static void deleteDirectory(File directory) throws IOException {
requireNonNull(directory, DIRECTORY_CAN_NOT_BE_NULL);
-
deleteDirectoryImpl(directory.toPath());
}
+ /**
+ * Deletes a directory recursively.
+ *
+ * @param directory directory to delete
+ * @throws IOException in case deletion is unsuccessful
+ */
+ public static void deleteDirectory(Path directory) throws IOException {
+ requireNonNull(directory, DIRECTORY_CAN_NOT_BE_NULL);
+ deleteDirectoryImpl(directory);
+ }
+
/**
* Cleans a directory recursively.
*
if (file == null) {
return false;
}
+ return deleteQuietly(file.toPath());
+ }
+
+ /**
+ * Deletes a file, never throwing an exception. If file is a directory, delete it and all sub-directories.
+ * <p>
+ * The difference between File.delete() and this method are:
+ * <ul>
+ * <li>A directory to be deleted does not have to be empty.</li>
+ * <li>No exceptions are thrown when a file or directory cannot be deleted.</li>
+ * </ul>
+ *
+ * @param file file or directory to delete, can be {@code null}
+ * @return {@code true} if the file or directory was deleted, otherwise {@code false}
+ */
+ public static boolean deleteQuietly(@Nullable Path path) {
+ if (path == null) {
+ return false;
+ }
try {
- if (file.isDirectory()) {
- deleteDirectory(file);
+ if (Files.isDirectory(path)) {
+ deleteDirectory(path);
} else {
- Files.delete(file.toPath());
+ Files.delete(path);
}
return true;
} catch (IOException | SecurityException ignored) {
@Test
public void deleteQuietly_does_not_fail_if_argument_is_null() {
- FileUtils.deleteQuietly(null);
+ FileUtils.deleteQuietly((File) null);
+ FileUtils.deleteQuietly((Path) null);
}
@Test
public void deleteDirectory_throws_NPE_if_argument_is_null() throws IOException {
expectDirectoryCanNotBeNullNPE();
- FileUtils.deleteDirectory(null);
+ FileUtils.deleteDirectory((File) null);
}
@Test
import java.io.File;
import java.io.IOException;
import java.nio.charset.Charset;
-import java.nio.file.LinkOption;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.HashMap;
* Only for testing
*/
public DefaultFileSystem(Path baseDir) {
- this(baseDir.toFile(), new MapCache());
+ this(baseDir, new MapCache());
}
/**
* Only for testing
*/
public DefaultFileSystem(File baseDir) {
- this(baseDir, new MapCache());
+ this(baseDir.toPath(), new MapCache());
}
- protected DefaultFileSystem(@Nullable File baseDir, Cache cache) {
- // Basedir can be null with views
- try {
- this.baseDir = baseDir != null ? baseDir.toPath().toRealPath(LinkOption.NOFOLLOW_LINKS) : new File(".").toPath().toAbsolutePath().normalize();
- } catch (IOException e) {
- throw new IllegalStateException(e);
- }
+ protected DefaultFileSystem(Path baseDir, Cache cache) {
+ this.baseDir = baseDir;
this.cache = cache;
this.predicates = new DefaultFilePredicates(this.baseDir);
}
return baseDir.toFile();
}
- public DefaultFileSystem setEncoding(@Nullable Charset e) {
+ public DefaultFileSystem setEncoding(Charset e) {
this.encoding = e;
return this;
}
@Override
public Charset encoding() {
- return encoding == null ? Charset.defaultCharset() : encoding;
- }
-
- public boolean isDefaultJvmEncoding() {
- return encoding == null;
+ return encoding;
}
- public DefaultFileSystem setWorkDir(File d) {
- this.workDir = d.getAbsoluteFile().toPath().normalize();
+ public DefaultFileSystem setWorkDir(Path d) {
+ this.workDir = d;
return this;
}
* Default predicate is used when some files/dirs should not be processed by sensors.
*/
public Iterable<InputFile> inputFiles() {
- doPreloadFiles();
return OptimizedFilePredicateAdapter.create(predicates.all()).get(cache);
}
@Override
public Iterable<InputFile> inputFiles(FilePredicate predicate) {
- doPreloadFiles();
Iterable<InputFile> iterable = OptimizedFilePredicateAdapter.create(predicate).get(cache);
if (defaultPredicate != null) {
return StreamSupport.stream(iterable.spliterator(), false)
@Override
public Iterable<File> files(FilePredicate predicate) {
- doPreloadFiles();
return () -> StreamSupport.stream(inputFiles(predicate).spliterator(), false)
.map(InputFile::file)
.iterator();
@Override
public InputDir inputDir(File dir) {
- doPreloadFiles();
String relativePath = PathUtils.sanitize(new PathResolver().relativePath(baseDir.toFile(), dir));
if (relativePath == null) {
return null;
@Override
public SortedSet<String> languages() {
- doPreloadFiles();
return cache.languages();
}
return predicates;
}
- /**
- * This method is called before each search of files.
- */
- protected void doPreloadFiles() {
- // nothing to do by default
- }
-
public abstract static class Cache implements Index {
protected abstract void doAdd(InputFile inputFile);
package org.sonar.api.batch.fs.internal;
import java.io.File;
+import java.io.IOException;
+import java.nio.file.LinkOption;
+import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
-
import javax.annotation.CheckForNull;
import javax.annotation.concurrent.Immutable;
-
+import org.apache.commons.io.FileUtils;
import org.sonar.api.batch.bootstrap.ProjectDefinition;
import org.sonar.api.batch.fs.InputModule;
*/
@Immutable
public class DefaultInputModule extends DefaultInputComponent implements InputModule {
- private final File baseDir;
- private final File workDir;
+ private final Path baseDir;
+ private final Path workDir;
private final String name;
private final String version;
private final String originalName;
private final String moduleKey;
private final ProjectDefinition definition;
- /**
- * For testing only!
- */
- public DefaultInputModule(String moduleKey) {
- this(ProjectDefinition.create().setKey(moduleKey), TestInputFileBuilder.nextBatchId());
- }
-
/**
* For testing only!
*/
public DefaultInputModule(ProjectDefinition definition, int batchId) {
super(batchId);
- this.baseDir = definition.getBaseDir();
- this.workDir = definition.getWorkDir();
+ this.baseDir = initBaseDir(definition);
+ this.workDir = initWorkingDir(definition);
this.name = definition.getName();
this.originalName = definition.getOriginalName();
this.version = definition.getVersion();
this.moduleKey = definition.getKey();
}
+ private static Path initBaseDir(ProjectDefinition module) {
+ Path result;
+ try {
+ result = module.getBaseDir().toPath().toRealPath(LinkOption.NOFOLLOW_LINKS);
+ } catch (IOException e) {
+ throw new IllegalStateException("Unable to resolve module baseDir", e);
+ }
+ return result;
+ }
+
+ private static Path initWorkingDir(ProjectDefinition module) {
+ File workingDirAsFile = module.getWorkDir();
+ try {
+ FileUtils.forceMkdir(workingDirAsFile);
+ } catch (Exception e) {
+ throw new IllegalStateException("Fail to create working dir: " + workingDirAsFile.getAbsolutePath(), e);
+ }
+ return workingDirAsFile.getAbsoluteFile().toPath().normalize();
+ }
+
/**
* Module key without branch
*/
public ProjectDefinition definition() {
return definition;
}
-
- public File getBaseDir() {
+
+ public Path getBaseDir() {
return baseDir;
}
- public File getWorkDir() {
+ public Path getWorkDir() {
return workDir;
}
import java.nio.file.LinkOption;
import java.nio.file.Path;
import java.nio.file.Paths;
-
import javax.annotation.Nullable;
-
import org.sonar.api.batch.bootstrap.ProjectDefinition;
import org.sonar.api.batch.fs.InputFile;
import org.sonar.api.utils.PathUtils;
}
public static DefaultInputModule newDefaultInputModule(String moduleKey, File baseDir) {
- ProjectDefinition definition = ProjectDefinition.create().setKey(moduleKey).setBaseDir(baseDir);
+ ProjectDefinition definition = ProjectDefinition.create().setKey(moduleKey).setBaseDir(baseDir).setWorkDir(new File(baseDir, ".sonar"));
return newDefaultInputModule(definition);
}
import java.io.File;
import java.io.Serializable;
+import java.nio.charset.Charset;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Collection;
import javax.annotation.Nullable;
import org.sonar.api.SonarQubeSide;
import org.sonar.api.SonarRuntime;
+import org.sonar.api.batch.bootstrap.ProjectDefinition;
import org.sonar.api.batch.fs.InputFile;
import org.sonar.api.batch.fs.InputModule;
import org.sonar.api.batch.fs.TextRange;
private SensorContextTester(Path moduleBaseDir) {
this.settings = new MapSettings();
- this.fs = new DefaultFileSystem(moduleBaseDir);
+ this.fs = new DefaultFileSystem(moduleBaseDir).setEncoding(Charset.defaultCharset());
this.activeRules = new ActiveRulesBuilder().build();
this.sensorStorage = new InMemorySensorStorage();
- this.module = new DefaultInputModule("projectKey");
+ this.module = new DefaultInputModule(ProjectDefinition.create().setKey("projectKey").setBaseDir(moduleBaseDir.toFile()).setWorkDir(moduleBaseDir.resolve(".sonar").toFile()));
this.runtime = SonarRuntimeImpl.forSonarQube(ApiVersion.load(System2.INSTANCE), SonarQubeSide.SCANNER);
}
import java.util.List;
import javax.annotation.CheckForNull;
import javax.annotation.concurrent.Immutable;
-
import org.apache.commons.io.FilenameUtils;
import org.sonar.api.batch.ScannerSide;
import org.sonar.api.utils.PathUtils;
@Immutable
public class PathResolver {
- public File relativeFile(File dir, String path) {
+ /**
+ * Static since 6.6
+ */
+ public static File relativeFile(File dir, String path) {
return dir.toPath().resolve(path).normalize().toFile();
}
* <li>null is returned if file is not a child of dir
* <li>the resulting path is converted to use Unix separators
* </ul>
+ * Static since 6.6
* @since 6.0
*/
@CheckForNull
- public String relativePath(Path dir, Path file) {
+ public static String relativePath(Path dir, Path file) {
Path baseDir = dir.normalize();
Path path = file.normalize();
if (!path.startsWith(baseDir)) {
*/
package org.sonar.api.batch.fs.internal;
+import java.io.File;
+import java.nio.charset.Charset;
+import java.util.Iterator;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.rules.TemporaryFolder;
-import java.io.File;
-import java.nio.charset.Charset;
-import java.util.Iterator;
-
import static org.assertj.core.api.Assertions.assertThat;
public class DefaultFileSystemTest {
assertThat(fs.baseDir().getCanonicalPath()).isEqualTo(basedir.getCanonicalPath());
File workdir = temp.newFolder();
- fs.setWorkDir(workdir);
+ fs.setWorkDir(workdir.toPath());
assertThat(fs.workDir()).isAbsolute().isDirectory().exists();
assertThat(fs.workDir().getCanonicalPath()).isEqualTo(workdir.getCanonicalPath());
}
@Test
public void test_encoding() throws Exception {
- assertThat(fs.isDefaultJvmEncoding()).isTrue();
- assertThat(fs.encoding()).isEqualTo(Charset.defaultCharset());
-
fs.setEncoding(Charset.forName("ISO-8859-1"));
assertThat(fs.encoding()).isEqualTo(Charset.forName("ISO-8859-1"));
- assertThat(fs.isDefaultJvmEncoding()).isFalse();
}
@Test
*/
package org.sonar.api.batch.fs.internal;
-import static org.assertj.core.api.Assertions.assertThat;
-
import java.io.File;
+import java.io.IOException;
import java.util.Collections;
-
+import org.junit.Rule;
import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
import org.sonar.api.batch.bootstrap.ProjectDefinition;
+import static org.assertj.core.api.Assertions.assertThat;
+
public class DefaultInputModuleTest {
+ @Rule
+ public TemporaryFolder temp = new TemporaryFolder();
+
@Test
- public void testGetters() {
+ public void testGetters() throws IOException {
ProjectDefinition def = ProjectDefinition.create();
def.setKey("projectKey");
def.setName("projectName");
- def.setBaseDir(new File("baseDir"));
+ File baseDir = temp.newFolder();
+ def.setBaseDir(baseDir);
def.setVersion("version");
def.setDescription("desc");
- def.setWorkDir(new File("workDir"));
+ File workDir = temp.newFolder();
+ def.setWorkDir(workDir);
def.setSources("file1");
def.setTests("test1");
DefaultInputModule module = new DefaultInputModule(def);
assertThat(module.getOriginalName()).isEqualTo("projectName");
assertThat(module.definition()).isEqualTo(def);
assertThat(module.getBranch()).isNull();
- assertThat(module.getBaseDir()).isEqualTo(new File("baseDir"));
+ assertThat(module.getBaseDir()).isEqualTo(baseDir.toPath());
assertThat(module.getKeyWithBranch()).isEqualTo("projectKey");
assertThat(module.getVersion()).isEqualTo("version");
assertThat(module.getOriginalVersion()).isEqualTo("version");
assertThat(module.getDescription()).isEqualTo("desc");
- assertThat(module.getWorkDir()).isEqualTo(new File("workDir"));
+ assertThat(module.getWorkDir()).isEqualTo(workDir.toPath());
assertThat(module.sources()).isEqualTo(Collections.singletonList("file1"));
assertThat(module.tests()).isEqualTo(Collections.singletonList("test1"));
*/
package org.sonar.api.batch.fs.internal;
-import static org.assertj.core.api.Assertions.assertThat;
-
import java.io.File;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
-
import org.apache.commons.io.IOUtils;
+import org.junit.Rule;
import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
import org.sonar.api.batch.fs.InputFile.Status;
import org.sonar.api.batch.fs.InputFile.Type;
+import static org.assertj.core.api.Assertions.assertThat;
+
public class TestInputFileBuilderTest {
+ @Rule
+ public TemporaryFolder temp = new TemporaryFolder();
+
@Test
public void setContent() throws IOException {
DefaultInputFile file = TestInputFileBuilder.create("module", "invalidPath")
}
@Test
- public void testCreateInputModule() {
- DefaultInputModule module = TestInputFileBuilder.newDefaultInputModule("key", new File("baseDir"));
+ public void testCreateInputModule() throws IOException {
+ File baseDir = temp.newFolder();
+ DefaultInputModule module = TestInputFileBuilder.newDefaultInputModule("key", baseDir);
assertThat(module.key()).isEqualTo("key");
- assertThat(module.getBaseDir()).isEqualTo(new File("baseDir"));
+ assertThat(module.getBaseDir()).isEqualTo(baseDir.toPath());
}
}
package org.sonar.api.batch.sensor.internal;
import java.io.File;
+import java.io.IOException;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.rules.TemporaryFolder;
+import org.sonar.api.batch.bootstrap.ProjectDefinition;
import org.sonar.api.batch.fs.InputFile;
import org.sonar.api.batch.fs.internal.DefaultFileSystem;
import org.sonar.api.batch.fs.internal.DefaultInputFile;
}
@Test
- public void testMeasures() {
+ public void testMeasures() throws IOException {
assertThat(tester.measures("foo:src/Foo.java")).isEmpty();
assertThat(tester.measure("foo:src/Foo.java", "ncloc")).isNull();
tester.<Integer>newMeasure()
assertThat(tester.measure("foo:src/Foo.java", "ncloc")).isNotNull();
assertThat(tester.measure("foo:src/Foo.java", "lines")).isNotNull();
tester.<Integer>newMeasure()
- .on(new DefaultInputModule("foo"))
+ .on(new DefaultInputModule(ProjectDefinition.create().setKey("foo").setBaseDir(temp.newFolder()).setWorkDir(temp.newFolder())))
.forMetric(CoreMetrics.DIRECTORIES)
.withValue(4)
.save();
*/
package org.sonar.api.batch.sensor.issue.internal;
+import java.io.IOException;
+import org.junit.Rule;
import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.sonar.api.batch.bootstrap.ProjectDefinition;
import org.sonar.api.batch.fs.internal.DefaultInputDir;
import org.sonar.api.batch.fs.internal.DefaultInputFile;
import org.sonar.api.batch.fs.internal.DefaultInputModule;
public class DefaultIssueTest {
+ @Rule
+ public TemporaryFolder temp = new TemporaryFolder();
+
private DefaultInputFile inputFile = new TestInputFileBuilder("foo", "src/Foo.php")
.initMetadata("Foo\nBar\n")
.build();
}
@Test
- public void build_project_issue() {
+ public void build_project_issue() throws IOException {
SensorStorage storage = mock(SensorStorage.class);
+ DefaultInputModule inputModule = new DefaultInputModule(ProjectDefinition.create().setKey("foo").setBaseDir(temp.newFolder()).setWorkDir(temp.newFolder()));
DefaultIssue issue = new DefaultIssue(storage)
.at(new DefaultIssueLocation()
- .on(new DefaultInputModule("foo"))
+ .on(inputModule)
.message("Wrong way!"))
.forRule(RuleKey.of("repo", "rule"))
.effortToFix(10.0);
- assertThat(issue.primaryLocation().inputComponent()).isEqualTo(new DefaultInputModule("foo"));
+ assertThat(issue.primaryLocation().inputComponent()).isEqualTo(inputModule);
assertThat(issue.ruleKey()).isEqualTo(RuleKey.of("repo", "rule"));
assertThat(issue.primaryLocation().textRange()).isNull();
assertThat(issue.effortToFix()).isEqualTo(10.0);
*/
package org.sonar.api.batch.sensor.measure.internal;
+import java.io.IOException;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
-import org.sonar.api.batch.fs.internal.DefaultInputFile;
+import org.junit.rules.TemporaryFolder;
+import org.sonar.api.batch.bootstrap.ProjectDefinition;
import org.sonar.api.batch.fs.internal.DefaultInputModule;
import org.sonar.api.batch.fs.internal.TestInputFileBuilder;
import org.sonar.api.batch.sensor.internal.SensorStorage;
@Rule
public ExpectedException thrown = ExpectedException.none();
+ @Rule
+ public TemporaryFolder temp = new TemporaryFolder();
+
@Test
public void build_file_measure() {
SensorStorage storage = mock(SensorStorage.class);
}
@Test
- public void build_project_measure() {
+ public void build_project_measure() throws IOException {
SensorStorage storage = mock(SensorStorage.class);
- DefaultInputModule module = new DefaultInputModule("foo");
+ DefaultInputModule module = new DefaultInputModule(ProjectDefinition.create().setKey("foo").setBaseDir(temp.newFolder()).setWorkDir(temp.newFolder()));
DefaultMeasure<Integer> newMeasure = new DefaultMeasure<Integer>(storage)
.forMetric(CoreMetrics.LINES)
.on(module)
.withValue(3);
- assertThat(newMeasure.inputComponent()).isEqualTo(new DefaultInputModule("foo"));
+ assertThat(newMeasure.inputComponent()).isEqualTo(module);
assertThat(newMeasure.metric()).isEqualTo(CoreMetrics.LINES);
assertThat(newMeasure.value()).isEqualTo(3);
}
@Test
- public void not_allowed_to_call_on_twice() {
+ public void not_allowed_to_call_on_twice() throws IOException {
thrown.expect(IllegalStateException.class);
thrown.expectMessage("on() already called");
new DefaultMeasure<Integer>()
- .on(new DefaultInputModule("foo"))
+ .on(new DefaultInputModule(ProjectDefinition.create().setKey("foo").setBaseDir(temp.newFolder()).setWorkDir(temp.newFolder())))
.on(new TestInputFileBuilder("foo", "src/Foo.php").build())
.withValue(3)
.save();
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
-
import org.picocontainer.ComponentLifecycle;
import org.picocontainer.PicoContainer;
import org.picocontainer.injectors.ProviderAdapter;
public TempFolder provide(InputModuleHierarchy moduleHierarchy) {
if (projectTempFolder == null) {
- Path workingDir = moduleHierarchy.root().getWorkDir().toPath();
+ Path workingDir = moduleHierarchy.root().getWorkDir();
Path tempDir = workingDir.normalize().resolve(TMP_NAME);
try {
Files.deleteIfExists(tempDir);
localIssueTracking.init();
}
- ScannerReportReader reader = new ScannerReportReader(reportPublisher.getReportDir());
+ ScannerReportReader reader = new ScannerReportReader(reportPublisher.getReportDir().toFile());
int nbComponents = inputComponentStore.all().size();
if (nbComponents == 0) {
}
ReportPublisher reportPublisher = container.getComponentByType(ReportPublisher.class);
- reader = new ScannerReportReader(reportPublisher.getReportDir());
+ reader = new ScannerReportReader(reportPublisher.getReportDir().toFile());
if (!container.getComponentByType(AnalysisMode.class).isIssues()) {
Metadata readMetadata = getReportReader().readMetadata();
int rootComponentRef = readMetadata.getRootComponentRef();
import org.sonar.scanner.issue.ignore.scanner.IssueExclusionsLoader;
import org.sonar.scanner.rule.QProfileVerifier;
import org.sonar.scanner.scan.filesystem.DefaultModuleFileSystem;
-import org.sonar.scanner.scan.filesystem.FileSystemLogger;
+import org.sonar.scanner.scan.filesystem.FileIndexer;
public abstract class AbstractPhaseExecutor {
private final InitializersExecutor initializersExecutor;
private final SensorsExecutor sensorsExecutor;
private final SensorContext sensorContext;
- private final FileSystemLogger fsLogger;
private final DefaultModuleFileSystem fs;
private final QProfileVerifier profileVerifier;
private final IssueExclusionsLoader issueExclusionsLoader;
private final InputModuleHierarchy hierarchy;
+ private final FileIndexer fileIndexer;
public AbstractPhaseExecutor(InitializersExecutor initializersExecutor, PostJobsExecutor postJobsExecutor, SensorsExecutor sensorsExecutor,
- SensorContext sensorContext, InputModuleHierarchy hierarchy, EventBus eventBus, FileSystemLogger fsLogger, DefaultModuleFileSystem fs, QProfileVerifier profileVerifier,
- IssueExclusionsLoader issueExclusionsLoader) {
+ SensorContext sensorContext, InputModuleHierarchy hierarchy, EventBus eventBus, DefaultModuleFileSystem fs, QProfileVerifier profileVerifier,
+ IssueExclusionsLoader issueExclusionsLoader, FileIndexer fileIndexer) {
this.postJobsExecutor = postJobsExecutor;
this.initializersExecutor = initializersExecutor;
this.sensorsExecutor = sensorsExecutor;
this.sensorContext = sensorContext;
this.eventBus = eventBus;
- this.fsLogger = fsLogger;
this.fs = fs;
this.profileVerifier = profileVerifier;
this.issueExclusionsLoader = issueExclusionsLoader;
this.hierarchy = hierarchy;
+ this.fileIndexer = fileIndexer;
}
/**
private void indexFs() {
String stepName = "Index filesystem";
eventBus.fireEvent(new BatchStepEvent(stepName, true));
- fs.index();
+ fileIndexer.index();
eventBus.fireEvent(new BatchStepEvent(stepName, false));
}
private void executeInitializersPhase() {
initializersExecutor.execute();
- fsLogger.log();
}
}
import org.sonar.scanner.issue.tracking.IssueTransition;
import org.sonar.scanner.rule.QProfileVerifier;
import org.sonar.scanner.scan.filesystem.DefaultModuleFileSystem;
-import org.sonar.scanner.scan.filesystem.FileSystemLogger;
+import org.sonar.scanner.scan.filesystem.FileIndexer;
import org.sonar.scanner.scan.report.IssuesReports;
public final class IssuesPhaseExecutor extends AbstractPhaseExecutor {
private final IssueTransition localIssueTracking;
public IssuesPhaseExecutor(InitializersExecutor initializersExecutor, PostJobsExecutor postJobsExecutor, SensorsExecutor sensorsExecutor, SensorContext sensorContext,
- EventBus eventBus, FileSystemLogger fsLogger, IssuesReports jsonReport, DefaultModuleFileSystem fs, QProfileVerifier profileVerifier,
- IssueExclusionsLoader issueExclusionsLoader, IssueTransition localIssueTracking, InputModuleHierarchy moduleHierarchy) {
- super(initializersExecutor, postJobsExecutor, sensorsExecutor, sensorContext, moduleHierarchy, eventBus, fsLogger, fs, profileVerifier, issueExclusionsLoader);
+ EventBus eventBus, IssuesReports jsonReport, DefaultModuleFileSystem fs, QProfileVerifier profileVerifier,
+ IssueExclusionsLoader issueExclusionsLoader, IssueTransition localIssueTracking, InputModuleHierarchy moduleHierarchy, FileIndexer fileIndexer) {
+ super(initializersExecutor, postJobsExecutor, sensorsExecutor, sensorContext, moduleHierarchy, eventBus, fs, profileVerifier, issueExclusionsLoader, fileIndexer);
this.eventBus = eventBus;
this.issuesReport = jsonReport;
this.localIssueTracking = localIssueTracking;
import org.sonar.scanner.report.ReportPublisher;
import org.sonar.scanner.rule.QProfileVerifier;
import org.sonar.scanner.scan.filesystem.DefaultModuleFileSystem;
-import org.sonar.scanner.scan.filesystem.FileSystemLogger;
+import org.sonar.scanner.scan.filesystem.FileIndexer;
import org.sonar.scanner.scm.ScmPublisher;
public final class PublishPhaseExecutor extends AbstractPhaseExecutor {
private final ScmPublisher scm;
public PublishPhaseExecutor(InitializersExecutor initializersExecutor, PostJobsExecutor postJobsExecutor, SensorsExecutor sensorsExecutor, SensorContext sensorContext,
- EventBus eventBus, ReportPublisher reportPublisher, FileSystemLogger fsLogger, DefaultModuleFileSystem fs, QProfileVerifier profileVerifier,
- IssueExclusionsLoader issueExclusionsLoader, CpdExecutor cpdExecutor, ScmPublisher scm, InputModuleHierarchy hierarchy) {
- super(initializersExecutor, postJobsExecutor, sensorsExecutor, sensorContext, hierarchy, eventBus, fsLogger, fs, profileVerifier, issueExclusionsLoader);
+ EventBus eventBus, ReportPublisher reportPublisher, DefaultModuleFileSystem fs, QProfileVerifier profileVerifier,
+ IssueExclusionsLoader issueExclusionsLoader, CpdExecutor cpdExecutor, ScmPublisher scm, InputModuleHierarchy hierarchy, FileIndexer fileIndexer) {
+ super(initializersExecutor, postJobsExecutor, sensorsExecutor, sensorContext, hierarchy, eventBus, fs, profileVerifier, issueExclusionsLoader, fileIndexer);
this.eventBus = eventBus;
this.reportPublisher = reportPublisher;
this.cpdExecutor = cpdExecutor;
private final ReportPublisherStep[] publishers;
private final Server server;
- private File reportDir;
+ private Path reportDir;
private ScannerReportWriter writer;
public ReportPublisher(Configuration settings, ScannerWsClient wsClient, Server server, AnalysisContextReportPublisher contextPublisher,
@Override
public void start() {
- reportDir = new File(moduleHierarchy.root().getWorkDir(), "scanner-report");
- writer = new ScannerReportWriter(reportDir);
+ reportDir = moduleHierarchy.root().getWorkDir().resolve("scanner-report");
+ writer = new ScannerReportWriter(reportDir.toFile());
contextPublisher.init(writer);
if (!analysisMode.isIssues() && !analysisMode.isMediumTest()) {
}
}
- public File getReportDir() {
+ public Path getReportDir() {
return reportDir;
}
publisher.publish(writer);
}
long stopTime = System.currentTimeMillis();
- LOG.info("Analysis report generated in {}ms, dir size={}", stopTime - startTime, FileUtils.byteCountToDisplaySize(FileUtils.sizeOfDirectory(reportDir)));
+ LOG.info("Analysis report generated in {}ms, dir size={}", stopTime - startTime, FileUtils.byteCountToDisplaySize(FileUtils.sizeOfDirectory(reportDir.toFile())));
startTime = System.currentTimeMillis();
- File reportZip = temp.newFile("batch-report", ".zip");
- ZipUtils.zipDir(reportDir, reportZip);
+ File reportZip = temp.newFile("scanner-report", ".zip");
+ ZipUtils.zipDir(reportDir.toFile(), reportZip);
stopTime = System.currentTimeMillis();
LOG.info("Analysis reports compressed in {}ms, zip size={}", stopTime - startTime, FileUtils.byteCountToDisplaySize(FileUtils.sizeOf(reportZip)));
return reportZip;
}
private void dumpMetadata(Map<String, String> metadata) {
- Path file = moduleHierarchy.root().getWorkDir().toPath().resolve(METADATA_DUMP_FILENAME);
+ Path file = moduleHierarchy.root().getWorkDir().resolve(METADATA_DUMP_FILENAME);
try (Writer output = Files.newBufferedWriter(file, StandardCharsets.UTF_8)) {
for (Map.Entry<String, String> entry : metadata.entrySet()) {
output.write(entry.getKey());
*/
package org.sonar.scanner.scan;
+import com.google.common.collect.ImmutableMultimap;
import java.nio.file.Path;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
-
import javax.annotation.CheckForNull;
import javax.annotation.concurrent.Immutable;
-
import org.sonar.api.batch.fs.InputModule;
import org.sonar.api.batch.fs.internal.DefaultInputModule;
import org.sonar.api.batch.fs.internal.InputModuleHierarchy;
import org.sonar.api.scan.filesystem.PathResolver;
-import com.google.common.collect.ImmutableMultimap;
-
@Immutable
public class DefaultInputModuleHierarchy implements InputModuleHierarchy {
private final PathResolver pathResolver = new PathResolver();
return null;
}
DefaultInputModule inputModule = (DefaultInputModule) module;
- Path parentBaseDir = parent.getBaseDir().toPath();
- Path moduleBaseDir = inputModule.getBaseDir().toPath();
+ Path parentBaseDir = parent.getBaseDir();
+ Path moduleBaseDir = inputModule.getBaseDir();
return pathResolver.relativePath(parentBaseDir, moduleBaseDir);
}
import org.sonar.scanner.scan.filesystem.DefaultModuleFileSystem;
import org.sonar.scanner.scan.filesystem.ExclusionFilters;
import org.sonar.scanner.scan.filesystem.FileIndexer;
-import org.sonar.scanner.scan.filesystem.FileSystemLogger;
import org.sonar.scanner.scan.filesystem.InputFileBuilder;
import org.sonar.scanner.scan.filesystem.LanguageDetection;
import org.sonar.scanner.scan.filesystem.MetadataGeneratorProvider;
LanguageDetection.class,
FileIndexer.class,
InputFileBuilder.class,
- FileSystemLogger.class,
DefaultModuleFileSystem.class,
ModuleFileSystemInitializer.class,
QProfileVerifier.class,
import java.nio.channels.OverlappingFileLockException;
import java.nio.file.Files;
import java.nio.file.Path;
-
import org.picocontainer.Startable;
import org.sonar.api.batch.fs.internal.InputModuleHierarchy;
import org.sonar.home.cache.DirectoryLock;
private final DirectoryLock lock;
public ProjectLock(InputModuleHierarchy moduleHierarchy) {
- Path directory = moduleHierarchy.root().getWorkDir().toPath();
+ Path directory = moduleHierarchy.root().getWorkDir();
try {
if (!directory.toFile().exists()) {
Files.createDirectories(directory);
}
this.lock = new DirectoryLock(directory.toAbsolutePath(), new Slf4jLogger());
}
-
+
public void tryLock() {
try {
if (!lock.tryLock()) {
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Iterator;
-
import org.sonar.api.batch.fs.internal.InputModuleHierarchy;
import org.sonar.core.util.FileUtils;
import org.sonar.home.cache.DirectoryLock;
private final Path workDir;
public WorkDirectoryCleaner(InputModuleHierarchy moduleHierarchy) {
- workDir = moduleHierarchy.root().getWorkDir().toPath();
+ workDir = moduleHierarchy.root().getWorkDir();
}
public void execute() {
package org.sonar.scanner.scan.filesystem;
import com.google.common.annotations.VisibleForTesting;
-import java.io.File;
-import java.nio.charset.Charset;
-import java.util.ArrayList;
-import java.util.List;
-import org.apache.commons.lang.StringUtils;
-import org.sonar.api.CoreProperties;
import org.sonar.api.batch.fs.internal.DefaultFileSystem;
import org.sonar.api.batch.fs.internal.DefaultInputModule;
-import org.sonar.api.config.Configuration;
-import org.sonar.api.utils.MessageException;
import org.sonar.scanner.analysis.DefaultAnalysisMode;
import org.sonar.scanner.repository.ProjectRepositories;
-/**
- * @since 3.5
- */
public class DefaultModuleFileSystem extends DefaultFileSystem {
- private String moduleKey;
- private FileIndexer indexer;
- private Configuration settings;
-
- private List<File> sourceDirsOrFiles = new ArrayList<>();
- private List<File> testDirsOrFiles = new ArrayList<>();
- private boolean initialized;
- private Charset charset = null;
-
- public DefaultModuleFileSystem(ModuleInputComponentStore moduleInputFileCache, DefaultInputModule module,
- Configuration settings, FileIndexer indexer, ModuleFileSystemInitializer initializer, DefaultAnalysisMode mode,
+ public DefaultModuleFileSystem(ModuleInputComponentStore moduleInputFileCache, DefaultInputModule module, ModuleFileSystemInitializer initializer, DefaultAnalysisMode mode,
ProjectRepositories projectRepositories) {
- super(initializer.baseDir(), moduleInputFileCache);
- setFields(module, settings, indexer, initializer, mode, projectRepositories);
+ super(module.getBaseDir(), moduleInputFileCache);
+ setFields(module, initializer, mode, projectRepositories);
}
@VisibleForTesting
- public DefaultModuleFileSystem(DefaultInputModule module,
- Configuration settings, FileIndexer indexer, ModuleFileSystemInitializer initializer, DefaultAnalysisMode mode,
- ProjectRepositories projectRepositories) {
- super(initializer.baseDir().toPath());
- setFields(module, settings, indexer, initializer, mode, projectRepositories);
+ public DefaultModuleFileSystem(DefaultInputModule module, ModuleFileSystemInitializer initializer, DefaultAnalysisMode mode, ProjectRepositories projectRepositories) {
+ super(module.getBaseDir());
+ setFields(module, initializer, mode, projectRepositories);
}
- private void setFields(DefaultInputModule module,
- Configuration settings, FileIndexer indexer, ModuleFileSystemInitializer initializer, DefaultAnalysisMode mode,
- ProjectRepositories projectRepositories) {
- this.moduleKey = module.key();
- this.settings = settings;
- this.indexer = indexer;
- setWorkDir(initializer.workingDir());
- this.sourceDirsOrFiles = initializer.sources();
- this.testDirsOrFiles = initializer.tests();
+ private void setFields(DefaultInputModule module, ModuleFileSystemInitializer initializer, DefaultAnalysisMode mode, ProjectRepositories projectRepositories) {
+ setWorkDir(module.getWorkDir());
+ setEncoding(initializer.defaultEncoding());
// filter the files sensors have access to
if (!mode.scanAllFiles()) {
}
}
- public boolean isInitialized() {
- return initialized;
- }
-
- public String moduleKey() {
- return moduleKey;
- }
-
- public List<File> sources() {
- return sourceDirsOrFiles;
- }
-
- public List<File> tests() {
- return testDirsOrFiles;
- }
-
- @Override
- public Charset encoding() {
- if (charset == null) {
- String encoding = settings.get(CoreProperties.ENCODING_PROPERTY).orElse(null);
- if (StringUtils.isNotEmpty(encoding)) {
- charset = Charset.forName(StringUtils.trim(encoding));
- } else {
- charset = Charset.defaultCharset();
- }
- }
- return charset;
- }
-
- @Override
- public boolean isDefaultJvmEncoding() {
- return !settings.hasKey(CoreProperties.ENCODING_PROPERTY);
- }
-
- @Override
- protected void doPreloadFiles() {
- if (!initialized) {
- throw MessageException.of("Accessing the filesystem before the Sensor phase is not supported. Please update your plugin.");
- }
- }
-
- public void index() {
- if (initialized) {
- throw MessageException.of("Module filesystem can only be indexed once");
- }
- initialized = true;
- indexer.index(this);
- }
-
- @Override
- public boolean equals(Object o) {
- if (this == o) {
- return true;
- }
- if (o == null || getClass() != o.getClass()) {
- return false;
- }
- DefaultModuleFileSystem that = (DefaultModuleFileSystem) o;
- return moduleKey.equals(that.moduleKey);
- }
-
- @Override
- public int hashCode() {
- return moduleKey.hashCode();
- }
}
package org.sonar.scanner.scan.filesystem;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
-import java.io.File;
import java.io.IOException;
import java.nio.file.FileSystemLoopException;
import java.nio.file.FileVisitOption;
private final DefaultInputModule module;
private final BatchIdGenerator batchIdGenerator;
private final InputComponentStore componentStore;
+ private final ModuleFileSystemInitializer moduleFileSystemInitializer;
private ExecutorService executorService;
private final List<Future<Void>> tasks;
+ private final DefaultModuleFileSystem defaultModuleFileSystem;
private ProgressReport progressReport;
public FileIndexer(BatchIdGenerator batchIdGenerator, InputComponentStore componentStore, DefaultInputModule module, ExclusionFilters exclusionFilters,
- DefaultComponentTree componentTree, InputFileBuilder inputFileBuilder, InputFileFilter[] filters) {
+ DefaultComponentTree componentTree, InputFileBuilder inputFileBuilder, ModuleFileSystemInitializer initializer, DefaultModuleFileSystem defaultModuleFileSystem,
+ InputFileFilter[] filters) {
this.batchIdGenerator = batchIdGenerator;
this.componentStore = componentStore;
this.module = module;
this.componentTree = componentTree;
this.inputFileBuilder = inputFileBuilder;
+ this.moduleFileSystemInitializer = initializer;
+ this.defaultModuleFileSystem = defaultModuleFileSystem;
this.filters = filters;
this.exclusionFilters = exclusionFilters;
this.tasks = new ArrayList<>();
}
public FileIndexer(BatchIdGenerator batchIdGenerator, InputComponentStore componentStore, DefaultInputModule module, ExclusionFilters exclusionFilters,
- DefaultComponentTree componentTree, InputFileBuilder inputFileBuilder) {
- this(batchIdGenerator, componentStore, module, exclusionFilters, componentTree, inputFileBuilder, new InputFileFilter[0]);
+ DefaultComponentTree componentTree, InputFileBuilder inputFileBuilder, ModuleFileSystemInitializer initializer, DefaultModuleFileSystem defaultModuleFileSystem) {
+ this(batchIdGenerator, componentStore, module, exclusionFilters, componentTree, inputFileBuilder, initializer, defaultModuleFileSystem, new InputFileFilter[0]);
}
- void index(DefaultModuleFileSystem fileSystem) {
+ public void index() {
int threads = Math.max(1, Runtime.getRuntime().availableProcessors() - 1);
this.executorService = Executors.newFixedThreadPool(threads, new ThreadFactoryBuilder().setNameFormat("FileIndexer-%d").build());
Progress progress = new Progress();
- indexFiles(fileSystem, progress, fileSystem.sources(), InputFile.Type.MAIN);
- indexFiles(fileSystem, progress, fileSystem.tests(), InputFile.Type.TEST);
+ indexFiles(moduleFileSystemInitializer.sources(), InputFile.Type.MAIN, progress);
+ indexFiles(moduleFileSystemInitializer.tests(), InputFile.Type.TEST, progress);
waitForTasksToComplete();
return count == 1 ? "file" : "files";
}
- private void indexFiles(DefaultModuleFileSystem fileSystem, Progress progress, List<File> sources, InputFile.Type type) {
+ private void indexFiles(List<Path> sources, InputFile.Type type, Progress progress) {
try {
- for (File dirOrFile : sources) {
- if (dirOrFile.isDirectory()) {
- indexDirectory(fileSystem, progress, dirOrFile.toPath(), type);
+ for (Path dirOrFile : sources) {
+ if (dirOrFile.toFile().isDirectory()) {
+ indexDirectory(dirOrFile, type, progress);
} else {
- tasks.add(executorService.submit(() -> indexFile(fileSystem, progress, dirOrFile.toPath(), type)));
+ tasks.add(executorService.submit(() -> indexFile(dirOrFile, type, progress)));
}
}
} catch (IOException e) {
}
}
- private void indexDirectory(final DefaultModuleFileSystem fileSystem, final Progress status, final Path dirToIndex, final InputFile.Type type) throws IOException {
+ private void indexDirectory(Path dirToIndex, InputFile.Type type, Progress progress) throws IOException {
Files.walkFileTree(dirToIndex.normalize(), Collections.singleton(FileVisitOption.FOLLOW_LINKS), Integer.MAX_VALUE,
- new IndexFileVisitor(fileSystem, status, type));
+ new IndexFileVisitor(type, progress));
}
- private Void indexFile(DefaultModuleFileSystem fileSystem, Progress progress, Path sourceFile, InputFile.Type type) throws IOException {
+ private Void indexFile(Path sourceFile, InputFile.Type type, Progress progress) throws IOException {
// get case of real file without resolving link
Path realFile = sourceFile.toRealPath(LinkOption.NOFOLLOW_LINKS);
- DefaultInputFile inputFile = inputFileBuilder.create(realFile, type, fileSystem.encoding());
+ DefaultInputFile inputFile = inputFileBuilder.create(realFile, type);
if (inputFile != null) {
if (exclusionFilters.accept(inputFile, type) && accept(inputFile)) {
- String parentRelativePath = getParentRelativePath(fileSystem, inputFile);
+ String parentRelativePath = getParentRelativePath(inputFile);
synchronized (this) {
- fileSystem.add(inputFile);
- indexParentDir(fileSystem, inputFile, parentRelativePath);
+ indexParentDir(inputFile, parentRelativePath);
progress.markAsIndexed(inputFile);
}
LOG.debug("'{}' indexed {}with language '{}'", inputFile.relativePath(), type == Type.TEST ? "as test " : "", inputFile.language());
return null;
}
- private static String getParentRelativePath(DefaultModuleFileSystem fileSystem, InputFile inputFile) {
+ private String getParentRelativePath(InputFile inputFile) {
Path parentDir = inputFile.path().getParent();
- String relativePath = new PathResolver().relativePath(fileSystem.baseDirPath(), parentDir);
+ String relativePath = PathResolver.relativePath(module.getBaseDir(), parentDir);
if (relativePath == null) {
throw new IllegalStateException("Failed to compute relative path of file: " + inputFile);
}
return relativePath;
}
- private void indexParentDir(DefaultModuleFileSystem fileSystem, InputFile inputFile, String parentRelativePath) {
+ private void indexParentDir(InputFile inputFile, String parentRelativePath) {
DefaultInputDir inputDir = (DefaultInputDir) componentStore.getDir(module.key(), parentRelativePath);
if (inputDir == null) {
- inputDir = new DefaultInputDir(fileSystem.moduleKey(), parentRelativePath, batchIdGenerator.get());
- inputDir.setModuleBaseDir(fileSystem.baseDirPath());
- fileSystem.add(inputDir);
+ inputDir = new DefaultInputDir(module.key(), parentRelativePath, batchIdGenerator.get());
+ inputDir.setModuleBaseDir(module.getBaseDir());
componentTree.index(inputDir, module);
+ defaultModuleFileSystem.add(inputDir);
}
componentTree.index(inputFile, inputDir);
+ defaultModuleFileSystem.add(inputFile);
}
private boolean accept(InputFile indexedFile) {
// InputFileFilter extensions. Might trigger generation of metadata
for (InputFileFilter filter : filters) {
if (!filter.accept(indexedFile)) {
- LOG.debug("'{}' excluded by {}", indexedFile.relativePath(), filter.getClass().getName());
+ LOG.debug("'{}' excluded by {}", indexedFile.toString(), filter.getClass().getName());
return false;
}
}
}
private class IndexFileVisitor implements FileVisitor<Path> {
- private DefaultModuleFileSystem fileSystem;
- private Progress status;
- private Type type;
+ private final Progress status;
+ private final Type type;
- IndexFileVisitor(DefaultModuleFileSystem fileSystem, Progress status, InputFile.Type type) {
- this.fileSystem = fileSystem;
+ IndexFileVisitor(InputFile.Type type, Progress status) {
this.status = status;
this.type = type;
}
@Override
public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
if (!Files.isHidden(file)) {
- tasks.add(executorService.submit(() -> indexFile(fileSystem, status, file, type)));
+ tasks.add(executorService.submit(() -> indexFile(file, type, status)));
}
return FileVisitResult.CONTINUE;
}
+++ /dev/null
-/*
- * SonarQube
- * Copyright (C) 2009-2017 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.scanner.scan.filesystem;
-
-import com.google.common.annotations.VisibleForTesting;
-import java.io.File;
-import java.nio.charset.Charset;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Locale;
-import javax.annotation.Nullable;
-import org.apache.commons.lang.StringUtils;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.sonar.api.batch.ScannerSide;
-import org.sonar.api.scan.filesystem.PathResolver;
-
-@ScannerSide
-public class FileSystemLogger {
-
- private final DefaultModuleFileSystem fs;
-
- public FileSystemLogger(DefaultModuleFileSystem fs) {
- this.fs = fs;
- }
-
- public void log() {
- doLog(LoggerFactory.getLogger(getClass()));
- }
-
- @VisibleForTesting
- void doLog(Logger logger) {
- logDir(logger, "Base dir: ", fs.baseDir());
- logDir(logger, "Working dir: ", fs.workDir());
- logPaths(logger, "Source paths: ", fs.baseDir(), fs.sources());
- logPaths(logger, "Test paths: ", fs.baseDir(), fs.tests());
- logEncoding(logger, fs.encoding());
- }
-
- private void logEncoding(Logger logger, Charset charset) {
- if (!fs.isDefaultJvmEncoding()) {
- logger.info("Source encoding: {}, default locale: {}", charset.displayName(), Locale.getDefault());
- } else {
- logger.warn("Source encoding is platform dependent ({}), default locale: {}", charset.displayName(), Locale.getDefault());
- }
- }
-
- private static void logPaths(Logger logger, String label, File baseDir, List<File> paths) {
- if (!paths.isEmpty()) {
- PathResolver resolver = new PathResolver();
- StringBuilder sb = new StringBuilder(label);
- for (Iterator<File> it = paths.iterator(); it.hasNext();) {
- File file = it.next();
- String relativePathToBaseDir = resolver.relativePath(baseDir, file);
- if (relativePathToBaseDir == null) {
- sb.append(file);
- } else if (StringUtils.isBlank(relativePathToBaseDir)) {
- sb.append(".");
- } else {
- sb.append(relativePathToBaseDir);
- }
- if (it.hasNext()) {
- sb.append(", ");
- }
- }
- logger.info(sb.toString());
- }
- }
-
- private static void logDir(Logger logger, String label, @Nullable File dir) {
- if (dir != null) {
- logger.info(label + dir.getAbsolutePath());
- }
- }
-}
}
private Path getProjectBaseDir() {
- return ((DefaultInputModule) root).getBaseDir().toPath();
+ return ((DefaultInputModule) root).getBaseDir();
}
@CheckForNull
*/
package org.sonar.scanner.scan.filesystem;
-import java.nio.charset.Charset;
import java.nio.file.Path;
import javax.annotation.CheckForNull;
import org.slf4j.Logger;
private static final Logger LOG = LoggerFactory.getLogger(InputFileBuilder.class);
private final String moduleKey;
private final Path moduleBaseDir;
- private final PathResolver pathResolver;
private final LanguageDetection langDetection;
private final BatchIdGenerator idGenerator;
private final MetadataGenerator metadataGenerator;
private final boolean preloadMetadata;
+ private final ModuleFileSystemInitializer moduleFileSystemInitializer;
- public InputFileBuilder(DefaultInputModule module, PathResolver pathResolver, LanguageDetection langDetection, MetadataGenerator metadataGenerator,
- BatchIdGenerator idGenerator, Configuration settings) {
+ public InputFileBuilder(DefaultInputModule module, LanguageDetection langDetection, MetadataGenerator metadataGenerator,
+ BatchIdGenerator idGenerator, Configuration settings, ModuleFileSystemInitializer moduleFileSystemInitializer) {
+ this.moduleFileSystemInitializer = moduleFileSystemInitializer;
this.moduleKey = module.key();
- this.moduleBaseDir = module.definition().getBaseDir().toPath();
- this.pathResolver = pathResolver;
+ this.moduleBaseDir = module.getBaseDir();
this.langDetection = langDetection;
this.metadataGenerator = metadataGenerator;
this.idGenerator = idGenerator;
}
@CheckForNull
- DefaultInputFile create(Path file, InputFile.Type type, Charset defaultEncoding) {
- String relativePath = pathResolver.relativePath(moduleBaseDir, file);
+ DefaultInputFile create(Path file, InputFile.Type type) {
+ String relativePath = PathResolver.relativePath(moduleBaseDir, file);
if (relativePath == null) {
LOG.warn("File '{}' is ignored. It is not located in module basedir '{}'.", file.toAbsolutePath(), moduleBaseDir);
return null;
}
DefaultIndexedFile indexedFile = new DefaultIndexedFile(moduleKey, moduleBaseDir, relativePath, type, language, idGenerator.get());
- DefaultInputFile inputFile = new DefaultInputFile(indexedFile, f -> metadataGenerator.setMetadata(f, defaultEncoding));
+ DefaultInputFile inputFile = new DefaultInputFile(indexedFile, f -> metadataGenerator.setMetadata(f, moduleFileSystemInitializer.defaultEncoding()));
if (language != null) {
inputFile.setPublish(true);
}
package org.sonar.scanner.scan.filesystem;
import java.io.File;
+import java.nio.charset.Charset;
+import java.nio.file.Path;
import java.util.ArrayList;
+import java.util.Iterator;
import java.util.List;
-
-import org.apache.commons.io.FileUtils;
+import java.util.Locale;
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.Immutable;
+import org.apache.commons.lang.StringUtils;
+import org.sonar.api.CoreProperties;
import org.sonar.api.batch.ScannerSide;
import org.sonar.api.batch.bootstrap.ProjectDefinition;
+import org.sonar.api.batch.fs.internal.DefaultInputModule;
import org.sonar.api.scan.filesystem.PathResolver;
-import org.sonar.api.utils.TempFolder;
+import org.sonar.api.utils.log.Logger;
+import org.sonar.api.utils.log.Loggers;
import static org.sonar.scanner.config.DefaultConfiguration.parseAsCsv;
-/**
- * @since 3.5
- */
@ScannerSide
+@Immutable
public class ModuleFileSystemInitializer {
- private File baseDir;
- private File workingDir;
- private List<File> sourceDirsOrFiles = new ArrayList<>();
- private List<File> testDirsOrFiles = new ArrayList<>();
+ private static final Logger LOG = Loggers.get(ModuleFileSystemInitializer.class);
- public ModuleFileSystemInitializer(ProjectDefinition module, TempFolder tempUtils, PathResolver pathResolver) {
- baseDir = module.getBaseDir();
- initWorkingDir(module, tempUtils);
- initSources(module, pathResolver);
- initTests(module, pathResolver);
- }
+ private final List<Path> sourceDirsOrFiles;
+ private final List<Path> testDirsOrFiles;
+ private final Charset encoding;
- private void initWorkingDir(ProjectDefinition module, TempFolder tempUtils) {
- workingDir = module.getWorkDir();
- if (workingDir == null) {
- workingDir = tempUtils.newDir("work");
- } else {
- try {
- FileUtils.forceMkdir(workingDir);
- } catch (Exception e) {
- throw new IllegalStateException("Fail to create working dir: " + workingDir.getAbsolutePath(), e);
- }
- }
+ public ModuleFileSystemInitializer(DefaultInputModule inputModule, ProjectDefinition module) {
+ logDir("Base dir: ", inputModule.getBaseDir());
+ logDir("Working dir: ", inputModule.getWorkDir());
+ sourceDirsOrFiles = initSources(module, inputModule.getBaseDir(), ProjectDefinition.SOURCES_PROPERTY, "Source paths: ");
+ testDirsOrFiles = initSources(module, inputModule.getBaseDir(), ProjectDefinition.TESTS_PROPERTY, "Test paths: ");
+ encoding = initEncoding(module);
}
- private void initSources(ProjectDefinition module, PathResolver pathResolver) {
- String srcPropValue = module.properties().get(ProjectDefinition.SOURCES_PROPERTY);
+ private static List<Path> initSources(ProjectDefinition module, Path baseDir, String propertyKey, String logLabel) {
+ List<Path> result = new ArrayList<>();
+ String srcPropValue = module.properties().get(propertyKey);
if (srcPropValue != null) {
- for (String sourcePath : parseAsCsv(ProjectDefinition.SOURCES_PROPERTY, srcPropValue)) {
- File dirOrFile = pathResolver.relativeFile(module.getBaseDir(), sourcePath);
+ for (String sourcePath : parseAsCsv(propertyKey, srcPropValue)) {
+ File dirOrFile = PathResolver.relativeFile(module.getBaseDir(), sourcePath);
if (dirOrFile.exists()) {
- sourceDirsOrFiles.add(dirOrFile);
+ result.add(dirOrFile.toPath());
}
}
}
+ logPaths(logLabel, baseDir, result);
+ return result;
}
- private void initTests(ProjectDefinition module, PathResolver pathResolver) {
- String testPropValue = module.properties().get(ProjectDefinition.TESTS_PROPERTY);
- if (testPropValue != null) {
- for (String testPath : parseAsCsv(ProjectDefinition.TESTS_PROPERTY, testPropValue)) {
- File dirOrFile = pathResolver.relativeFile(module.getBaseDir(), testPath);
- if (dirOrFile.exists()) {
- testDirsOrFiles.add(dirOrFile);
- }
- }
+ private static Charset initEncoding(ProjectDefinition module) {
+ String encodingStr = module.properties().get(CoreProperties.ENCODING_PROPERTY);
+ Charset result;
+ if (StringUtils.isNotEmpty(encodingStr)) {
+ result = Charset.forName(StringUtils.trim(encodingStr));
+ LOG.info("Source encoding: {}, default locale: {}", result.displayName(), Locale.getDefault());
+ } else {
+ result = Charset.defaultCharset();
+ LOG.warn("Source encoding is platform dependent ({}), default locale: {}", result.displayName(), Locale.getDefault());
}
+ return result;
}
- File baseDir() {
- return baseDir;
+ List<Path> sources() {
+ return sourceDirsOrFiles;
}
- File workingDir() {
- return workingDir;
+ List<Path> tests() {
+ return testDirsOrFiles;
}
- List<File> sources() {
- return sourceDirsOrFiles;
+ public Charset defaultEncoding() {
+ return encoding;
}
- List<File> tests() {
- return testDirsOrFiles;
+ private static void logPaths(String label, Path baseDir, List<Path> paths) {
+ if (!paths.isEmpty()) {
+ StringBuilder sb = new StringBuilder(label);
+ for (Iterator<Path> it = paths.iterator(); it.hasNext();) {
+ Path file = it.next();
+ String relativePathToBaseDir = PathResolver.relativePath(baseDir, file);
+ if (relativePathToBaseDir == null) {
+ sb.append(file);
+ } else if (StringUtils.isBlank(relativePathToBaseDir)) {
+ sb.append(".");
+ } else {
+ sb.append(relativePathToBaseDir);
+ }
+ if (it.hasNext()) {
+ sb.append(", ");
+ }
+ }
+ LOG.info(sb.toString());
+ }
+ }
+
+ private static void logDir(String label, @Nullable Path dir) {
+ if (dir != null) {
+ LOG.info(label + dir.toAbsolutePath().toString());
+ }
}
}
*/
package org.sonar.scanner.scm;
+import com.google.common.base.Joiner;
import java.util.LinkedHashMap;
import java.util.Map;
-
import org.apache.commons.lang.StringUtils;
import org.picocontainer.Startable;
import org.sonar.api.CoreProperties;
import org.sonar.api.utils.log.Logger;
import org.sonar.api.utils.log.Loggers;
-import com.google.common.base.Joiner;
-
@Properties({
@Property(
key = ScmConfiguration.FORCE_RELOAD_KEY,
private void autodetection() {
for (ScmProvider installedProvider : providerPerKey.values()) {
- if (installedProvider.supports(moduleHierarchy.root().getBaseDir())) {
+ if (installedProvider.supports(moduleHierarchy.root().getBaseDir().toFile())) {
if (this.provider == null) {
this.provider = installedProvider;
} else {
*/
package org.sonar.scanner.analysis;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
import java.io.File;
import java.io.IOException;
-
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.batch.fs.internal.InputModuleHierarchy;
import org.sonar.api.utils.TempFolder;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
public class AnalysisTempFolderProviderTest {
@Rule
moduleHierarchy = mock(InputModuleHierarchy.class);
DefaultInputModule module = mock(DefaultInputModule.class);
when(moduleHierarchy.root()).thenReturn(module);
- when(module.getWorkDir()).thenReturn(temp.getRoot());
+ when(module.getWorkDir()).thenReturn(temp.getRoot().toPath());
}
@Test
package org.sonar.scanner.bootstrap;
import com.google.common.collect.Lists;
+import java.io.IOException;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
+import org.junit.Rule;
import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
import org.sonar.api.BatchExtension;
import org.sonar.api.batch.BuildBreaker;
import org.sonar.api.batch.CheckProject;
import org.sonar.api.batch.PostJob;
import org.sonar.api.batch.Sensor;
import org.sonar.api.batch.SensorContext;
+import org.sonar.api.batch.bootstrap.ProjectDefinition;
import org.sonar.api.batch.fs.internal.DefaultInputModule;
import org.sonar.api.batch.postjob.PostJobContext;
import org.sonar.api.batch.sensor.SensorDescriptor;
public class ScannerExtensionDictionnaryTest {
+ @Rule
+ public TemporaryFolder temp = new TemporaryFolder();
+
private ScannerExtensionDictionnary newSelector(Object... extensions) {
ComponentContainer iocContainer = new ComponentContainer();
for (Object extension : extensions) {
}
@Test
- public void checkProject() {
+ public void checkProject() throws IOException {
BatchExtension ok = new CheckProjectOK();
BatchExtension ko = new CheckProjectKO();
ScannerExtensionDictionnary selector = newSelector(ok, ko);
- List<BatchExtension> extensions = Lists.newArrayList(selector.select(BatchExtension.class, new DefaultInputModule("foo"), true, null));
+ List<BatchExtension> extensions = Lists.newArrayList(selector.select(BatchExtension.class,
+ new DefaultInputModule(ProjectDefinition.create().setKey("foo").setBaseDir(temp.newFolder()).setWorkDir(temp.newFolder())), true, null));
assertThat(extensions).hasSize(1);
assertThat(extensions.get(0)).isInstanceOf(CheckProjectOK.class);
*/
package org.sonar.scanner.index;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
import java.io.IOException;
import java.util.Collections;
import org.junit.Before;
import org.sonar.scanner.scan.measure.MeasureCache;
import org.sonar.scanner.sensor.DefaultSensorStorage;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
public class DefaultIndexTest {
@org.junit.Rule
baseDir = temp.newFolder();
- ProjectDefinition rootDef = ProjectDefinition.create().setKey("project").setBaseDir(baseDir);
- ProjectDefinition moduleADef = ProjectDefinition.create().setKey("moduleA").setBaseDir(new java.io.File(baseDir, "moduleA"));
- ProjectDefinition moduleBDef = ProjectDefinition.create().setKey("moduleB").setBaseDir(new java.io.File(baseDir, "moduleB"));
- ProjectDefinition moduleB1Def = ProjectDefinition.create().setKey("moduleB1").setBaseDir(new java.io.File(baseDir, "moduleB/moduleB1"));
+ ProjectDefinition rootDef = ProjectDefinition.create().setKey("project").setBaseDir(baseDir).setWorkDir(temp.newFolder());
+ java.io.File moduleABaseDir = new java.io.File(baseDir, "moduleA");
+ moduleABaseDir.mkdir();
+ ProjectDefinition moduleADef = ProjectDefinition.create().setKey("moduleA").setBaseDir(moduleABaseDir).setWorkDir(temp.newFolder());
+ java.io.File moduleBBaseDir = new java.io.File(baseDir, "moduleB");
+ moduleBBaseDir.mkdir();
+ ProjectDefinition moduleBDef = ProjectDefinition.create().setKey("moduleB").setBaseDir(moduleBBaseDir).setWorkDir(temp.newFolder());
+ java.io.File moduleB1BaseDir = new java.io.File(baseDir, "moduleB/moduleB1");
+ moduleB1BaseDir.mkdir();
+ ProjectDefinition moduleB1Def = ProjectDefinition.create().setKey("moduleB1").setBaseDir(moduleB1BaseDir).setWorkDir(temp.newFolder());
rootDef.addSubProject(moduleADef);
rootDef.addSubProject(moduleBDef);
}
@Test
- public void shouldGetHierarchy() {
- InputComponent component = new DefaultInputModule("module1");
+ public void shouldGetHierarchy() throws IOException {
+ InputComponent component = new DefaultInputModule(ProjectDefinition.create().setKey("module1").setBaseDir(temp.newFolder()).setWorkDir(temp.newFolder()));
InputFile file1 = new TestInputFileBuilder("module1", "src/org/foo/Bar.java").build();
when(componentStore.getByKey("module1")).thenReturn(component);
}
@Test
- public void shouldTransformToResource() {
+ public void shouldTransformToResource() throws IOException {
DefaultInputModule component = new DefaultInputModule(ProjectDefinition.create()
.setKey("module1")
- .setProperty(CoreProperties.PROJECT_BRANCH_PROPERTY, "branch1"), 1);
+ .setProperty(CoreProperties.PROJECT_BRANCH_PROPERTY, "branch1")
+ .setBaseDir(temp.newFolder())
+ .setWorkDir(temp.newFolder()), 1);
InputFile file1 = new TestInputFileBuilder("module1", "src/org/foo/Bar.java").build();
InputDir dir = new DefaultInputDir("module1", "src");
*/
package org.sonar.scanner.issue;
+import java.io.IOException;
import java.util.Date;
+import org.junit.Rule;
import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.sonar.api.batch.bootstrap.ProjectDefinition;
import org.sonar.api.batch.fs.internal.DefaultInputModule;
import org.sonar.api.issue.Issue;
import org.sonar.api.rule.RuleKey;
public class DeprecatedIssueAdapterForFilterTest {
+ @Rule
+ public TemporaryFolder temp = new TemporaryFolder();
+
private static final String PROJECT_KEY = "foo";
private static final Date ANALYSIS_DATE = new Date();
private static final String COMPONENT_KEY = "foo:src/Foo.java";
@Test
- public void improve_coverage() {
- DefaultInputModule module = new DefaultInputModule(PROJECT_KEY);
+ public void improve_coverage() throws IOException {
+ DefaultInputModule module = new DefaultInputModule(ProjectDefinition.create().setKey(PROJECT_KEY).setBaseDir(temp.newFolder()).setWorkDir(temp.newFolder()));
ProjectAnalysisInfo projectAnalysisInfo = mock(ProjectAnalysisInfo.class);
when(projectAnalysisInfo.analysisDate()).thenReturn(ANALYSIS_DATE);
*/
package org.sonar.scanner.issue;
+import java.io.IOException;
+import org.junit.Rule;
import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.sonar.api.batch.bootstrap.ProjectDefinition;
import org.sonar.api.batch.fs.internal.DefaultInputModule;
import org.sonar.api.batch.fs.internal.TestInputFileBuilder;
import org.sonar.api.issue.Issuable;
public class IssuableFactoryTest {
- ModuleIssues moduleIssues = mock(ModuleIssues.class);
+ @Rule
+ public TemporaryFolder temp = new TemporaryFolder();
@Test
public void file_should_be_issuable() {
}
@Test
- public void project_should_be_issuable() {
+ public void project_should_be_issuable() throws IOException {
IssuableFactory factory = new IssuableFactory(mock(DefaultSensorContext.class));
- Issuable issuable = factory.loadPerspective(Issuable.class, new DefaultInputModule("foo"));
+ Issuable issuable = factory.loadPerspective(Issuable.class,
+ new DefaultInputModule(ProjectDefinition.create().setKey("foo").setBaseDir(temp.newFolder()).setWorkDir(temp.newFolder())));
assertThat(issuable).isNotNull();
assertThat(issuable.issues()).isEmpty();
*/
package org.sonar.scanner.issue.tracking;
-import static org.apache.commons.codec.digest.DigestUtils.md5Hex;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
import java.io.File;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
-import java.util.Collections;
-
import org.apache.commons.io.FileUtils;
import org.junit.Before;
import org.junit.Rule;
import org.sonar.api.batch.fs.internal.DefaultInputFile;
import org.sonar.api.batch.fs.internal.DefaultInputModule;
+import static org.apache.commons.codec.digest.DigestUtils.md5Hex;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
public class SourceHashHolderTest {
@Rule
@Before
public void setUp() throws Exception {
- def = mock(ProjectDefinition.class);
+ def = ProjectDefinition.create().setBaseDir(temp.newFolder()).setWorkDir(temp.newFolder());
lastSnapshots = mock(ServerLineHashesLoader.class);
file = mock(DefaultInputFile.class);
ioFile = temp.newFile();
public void should_lazy_load_reference_hashes_when_status_changed() throws Exception {
final String source = "source";
FileUtils.write(ioFile, source, StandardCharsets.UTF_8);
- when(def.getKeyWithBranch()).thenReturn("foo");
+ def.setKey("foo");
when(file.relativePath()).thenReturn("src/Foo.java");
String key = "foo:src/Foo.java";
when(file.status()).thenReturn(InputFile.Status.CHANGED);
public void should_lazy_load_reference_hashes_when_status_changed_on_branch() throws Exception {
final String source = "source";
FileUtils.write(ioFile, source, StandardCharsets.UTF_8);
- when(def.getKeyWithBranch()).thenReturn("foo:myBranch");
- when(def.properties()).thenReturn(Collections.singletonMap(CoreProperties.PROJECT_BRANCH_PROPERTY, "myBranch"));
+ def.setKey("foo");
+ def.setProperty(CoreProperties.PROJECT_BRANCH_PROPERTY, "myBranch");
when(file.relativePath()).thenReturn("src/Foo.java");
String key = "foo:myBranch:src/Foo.java";
when(file.status()).thenReturn(InputFile.Status.CHANGED);
*/
package org.sonar.scanner.phases;
+import java.io.IOException;
import java.util.Arrays;
import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
import org.sonar.api.batch.PostJob;
import org.sonar.api.batch.SensorContext;
+import org.sonar.api.batch.bootstrap.ProjectDefinition;
import org.sonar.api.batch.fs.internal.DefaultInputModule;
import org.sonar.api.resources.Project;
import org.sonar.scanner.bootstrap.ScannerExtensionDictionnary;
import static org.mockito.Mockito.when;
public class PostJobsExecutorTest {
- PostJobsExecutor executor;
+ @Rule
+ public TemporaryFolder temp = new TemporaryFolder();
- DefaultInputModule module = new DefaultInputModule("project");
- ScannerExtensionDictionnary selector = mock(ScannerExtensionDictionnary.class);
- PostJob job1 = mock(PostJob.class);
- PostJob job2 = mock(PostJob.class);
- SensorContext context = mock(SensorContext.class);
+ private PostJobsExecutor executor;
+
+ private DefaultInputModule module;
+ private ScannerExtensionDictionnary selector = mock(ScannerExtensionDictionnary.class);
+ private PostJob job1 = mock(PostJob.class);
+ private PostJob job2 = mock(PostJob.class);
+ private SensorContext context = mock(SensorContext.class);
@Before
- public void setUp() {
+ public void setUp() throws IOException {
+ module = new DefaultInputModule(ProjectDefinition.create().setKey("project").setBaseDir(temp.newFolder()).setWorkDir(temp.newFolder()));
executor = new PostJobsExecutor(selector, module, mock(EventBus.class));
}
*/
package org.sonar.scanner.phases;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
import java.io.IOException;
import java.util.Collections;
-
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.sonar.scanner.events.EventBus;
import org.sonar.scanner.sensor.SensorStrategy;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
public class SensorsExecutorTest {
@Rule
public TemporaryFolder temp = new TemporaryFolder();
when(selector.selectSensors(any(DefaultInputModule.class), eq(false))).thenReturn(Collections.singleton(perModuleSensor));
when(selector.selectSensors(any(DefaultInputModule.class), eq(true))).thenReturn(Collections.singleton(globalSensor));
- ProjectDefinition childDef = ProjectDefinition.create().setKey("sub").setBaseDir(temp.newFolder());
- ProjectDefinition rootDef = ProjectDefinition.create().setKey("root").setBaseDir(temp.newFolder());
+ ProjectDefinition childDef = ProjectDefinition.create().setKey("sub").setBaseDir(temp.newFolder()).setWorkDir(temp.newFolder());
+ ProjectDefinition rootDef = ProjectDefinition.create().setKey("root").setBaseDir(temp.newFolder()).setWorkDir(temp.newFolder());
DefaultInputModule rootModule = TestInputFileBuilder.newDefaultInputModule(rootDef);
DefaultInputModule subModule = TestInputFileBuilder.newDefaultInputModule(childDef);
package org.sonar.scanner.profiling;
import com.google.common.collect.Maps;
+import java.io.IOException;
import java.util.List;
import java.util.Map;
import org.junit.Before;
}
@Test
- public void testSimpleProject() throws InterruptedException {
+ public void testSimpleProject() throws Exception {
final Project project = mockProject("my:project", true);
}
@Test
- public void testMultimoduleProject() throws InterruptedException {
+ public void testMultimoduleProject() throws Exception {
final Project project = mockProject("project root", true);
final Project moduleA = mockProject("moduleA", false);
final Project moduleB = mockProject("moduleB", false);
}
}
- private Project mockProject(String name, boolean isRoot) {
- return new Project(new DefaultInputModule(ProjectDefinition.create().setName(name).setKey(name)));
+ private Project mockProject(String name, boolean isRoot) throws IOException {
+ return new Project(new DefaultInputModule(ProjectDefinition.create().setName(name).setKey(name).setBaseDir(temp.newFolder()).setWorkDir(temp.newFolder())));
}
private void fakeAnalysis(PhasesSumUpTimeProfiler profiler, final Project module) {
ScannerReportWriter writer = new ScannerReportWriter(temp.newFolder());
publisher.init(writer);
- publisher.dumpModuleSettings(new DefaultInputModule("foo"));
+ publisher.dumpModuleSettings(new DefaultInputModule(ProjectDefinition.create().setKey("foo").setBaseDir(temp.newFolder()).setWorkDir(temp.newFolder())));
assertThat(writer.getFileStructure().analysisLog()).doesNotExist();
}
when(projectRepos.moduleExists("foo")).thenReturn(true);
when(projectRepos.settings("foo")).thenReturn(ImmutableMap.of(COM_FOO, "bar", SONAR_SKIP, "true"));
- publisher.dumpModuleSettings(new DefaultInputModule("foo"));
+ publisher.dumpModuleSettings(new DefaultInputModule(ProjectDefinition.create().setKey("foo").setBaseDir(temp.newFolder()).setWorkDir(temp.newFolder())));
String content = FileUtils.readFileToString(writer.getFileStructure().analysisLog());
assertThat(content).doesNotContain(COM_FOO);
assertThat(content).doesNotContain(SONAR_SKIP);
publisher.dumpModuleSettings(new DefaultInputModule(ProjectDefinition.create()
+ .setBaseDir(temp.newFolder())
+ .setWorkDir(temp.newFolder())
.setProperty("sonar.projectKey", "foo")
.setProperty(COM_FOO, "bar")
.setProperty(SONAR_SKIP, "true")));
assertThat(content).containsSequence(BIZ, FOO);
publisher.dumpModuleSettings(new DefaultInputModule(ProjectDefinition.create()
+ .setBaseDir(temp.newFolder())
+ .setWorkDir(temp.newFolder())
.setProperty("sonar.projectKey", "foo")
.setProperty("env." + FOO, "BAR")));
assertThat(writer.getFileStructure().analysisLog()).exists();
publisher.dumpModuleSettings(new DefaultInputModule(ProjectDefinition.create()
+ .setBaseDir(temp.newFolder())
+ .setWorkDir(temp.newFolder())
.setProperty("sonar.projectKey", "foo")
.setProperty("sonar.projectKey", "foo")
.setProperty("sonar.login", "my_token")
publisher.init(writer);
DefaultInputModule module = new DefaultInputModule(ProjectDefinition.create()
+ .setBaseDir(temp.newFolder())
+ .setWorkDir(temp.newFolder())
.setProperty("sonar.projectKey", "foo")
.setProperty(SONAR_SKIP, "true"));
DefaultInputModule parent = new DefaultInputModule(ProjectDefinition.create()
+ .setBaseDir(temp.newFolder())
+ .setWorkDir(temp.newFolder())
.setProperty("sonar.projectKey", "parent")
.setProperty(SONAR_SKIP, "true"));
.setKey("foo")
.setProperty(CoreProperties.PROJECT_VERSION_PROPERTY, "1.0")
.setName("Root project")
- .setDescription("Root description");
+ .setDescription("Root description")
+ .setBaseDir(temp.newFolder())
+ .setWorkDir(temp.newFolder());
DefaultInputModule root = new DefaultInputModule(rootDef, 1);
ProjectDefinition module1Def = ProjectDefinition.create()
.setKey("module1")
.setName("Module1")
- .setDescription("Module description");
+ .setDescription("Module description")
+ .setBaseDir(temp.newFolder())
+ .setWorkDir(temp.newFolder());
rootDef.addSubProject(module1Def);
DefaultInputModule module1 = new DefaultInputModule(module1Def, 2);
}
@Test
- public void should_skip_dir_without_published_files() {
+ public void should_skip_dir_without_published_files() throws IOException {
ProjectAnalysisInfo projectAnalysisInfo = mock(ProjectAnalysisInfo.class);
when(projectAnalysisInfo.analysisDate()).thenReturn(DateUtils.parseDate("2012-12-12"));
.setKey("foo")
.setProperty(CoreProperties.PROJECT_VERSION_PROPERTY, "1.0")
.setName("Root project")
- .setDescription("Root description");
+ .setDescription("Root description")
+ .setBaseDir(temp.newFolder())
+ .setWorkDir(temp.newFolder());
DefaultInputModule root = new DefaultInputModule(rootDef, 1);
moduleHierarchy = mock(InputModuleHierarchy.class);
ProjectDefinition rootDef = ProjectDefinition.create()
.setKey("foo")
- .setDescription("Root description");
+ .setDescription("Root description")
+ .setBaseDir(temp.newFolder())
+ .setWorkDir(temp.newFolder());
DefaultInputModule root = new DefaultInputModule(rootDef, 1);
ProjectDefinition module1Def = ProjectDefinition.create()
.setKey("module1")
- .setDescription("Module description");
+ .setDescription("Module description")
+ .setBaseDir(temp.newFolder())
+ .setWorkDir(temp.newFolder());
rootDef.addSubProject(module1Def);
DefaultInputModule module1 = new DefaultInputModule(module1Def, 2);
.setProperty(CoreProperties.PROJECT_BRANCH_PROPERTY, "my_branch")
.setName("Root project")
.setProperty(CoreProperties.LINKS_HOME_PAGE, "http://home")
- .setDescription("Root description");
+ .setDescription("Root description")
+ .setBaseDir(temp.newFolder())
+ .setWorkDir(temp.newFolder());
DefaultInputModule root = new DefaultInputModule(rootDef, 1);
ProjectDefinition module1Def = ProjectDefinition.create()
.setKey("module1")
.setName("Module1")
.setProperty(CoreProperties.LINKS_CI, "http://ci")
- .setDescription("Module description");
+ .setDescription("Module description")
+ .setBaseDir(temp.newFolder())
+ .setWorkDir(temp.newFolder());
rootDef.addSubProject(module1Def);
DefaultInputModule module1 = new DefaultInputModule(module1Def, 2);
*/
package org.sonar.scanner.report;
-import static java.util.Arrays.asList;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.entry;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
import java.io.File;
+import java.io.IOException;
import java.util.Date;
-
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.sonar.scanner.rule.ModuleQProfiles;
import org.sonar.scanner.rule.QProfile;
+import static java.util.Arrays.asList;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.entry;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
public class MetadataPublisherTest {
@Rule
private InputModuleHierarchy inputModuleHierarchy;
@Before
- public void prepare() {
+ public void prepare() throws IOException {
projectAnalysisInfo = mock(ProjectAnalysisInfo.class);
cpdSettings = mock(CpdSettings.class);
when(projectAnalysisInfo.analysisDate()).thenReturn(new Date(1234567L));
createPublisher(ProjectDefinition.create().setKey("foo"));
}
- private void createPublisher(ProjectDefinition def) {
- rootModule = new DefaultInputModule(def, TestInputFileBuilder.nextBatchId());
+ private void createPublisher(ProjectDefinition def) throws IOException {
+ rootModule = new DefaultInputModule(def.setBaseDir(temp.newFolder()).setWorkDir(temp.newFolder()), TestInputFileBuilder.nextBatchId());
inputModuleHierarchy = mock(InputModuleHierarchy.class);
when(inputModuleHierarchy.root()).thenReturn(rootModule);
underTest = new MetadataPublisher(projectAnalysisInfo, inputModuleHierarchy, settings.asConfig(), qProfiles, cpdSettings);
AnalysisContextReportPublisher contextPublisher = mock(AnalysisContextReportPublisher.class);
@Before
- public void setUp() {
+ public void setUp() throws IOException {
wsClient = mock(ScannerWsClient.class, Mockito.RETURNS_DEEP_STUBS);
- root = new DefaultInputModule(ProjectDefinition.create().setKey("struts").setWorkDir(temp.getRoot()));
+ root = new DefaultInputModule(ProjectDefinition.create().setKey("struts").setBaseDir(temp.newFolder()).setWorkDir(temp.getRoot()));
when(moduleHierarchy.root()).thenReturn(root);
when(server.getPublicRootUrl()).thenReturn("https://localhost");
when(server.getVersion()).thenReturn("6.4");
*/
package org.sonar.scanner.scan;
+import java.io.IOException;
import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.sonar.api.batch.bootstrap.ProjectDefinition;
import org.sonar.api.batch.fs.internal.DefaultInputComponent;
import org.sonar.api.batch.fs.internal.DefaultInputModule;
import static org.assertj.core.api.Assertions.assertThat;
public class DefaultComponentTreeTest {
+
+ @Rule
+ public TemporaryFolder temp = new TemporaryFolder();
+
private DefaultComponentTree tree;
@Before
}
@Test
- public void test() {
- DefaultInputComponent root = new DefaultInputModule("root");
- DefaultInputComponent mod1 = new DefaultInputModule("mod1");
- DefaultInputComponent mod2 = new DefaultInputModule("mod2");
- DefaultInputComponent mod3 = new DefaultInputModule("mod3");
- DefaultInputComponent mod4 = new DefaultInputModule("mod4");
+ public void test() throws IOException {
+ DefaultInputComponent root = new DefaultInputModule(ProjectDefinition.create().setKey("root").setBaseDir(temp.newFolder()).setWorkDir(temp.newFolder()));
+ DefaultInputComponent mod1 = new DefaultInputModule(ProjectDefinition.create().setKey("mod1").setBaseDir(temp.newFolder()).setWorkDir(temp.newFolder()));
+ DefaultInputComponent mod2 = new DefaultInputModule(ProjectDefinition.create().setKey("mod2").setBaseDir(temp.newFolder()).setWorkDir(temp.newFolder()));
+ DefaultInputComponent mod3 = new DefaultInputModule(ProjectDefinition.create().setKey("mod3").setBaseDir(temp.newFolder()).setWorkDir(temp.newFolder()));
+ DefaultInputComponent mod4 = new DefaultInputModule(ProjectDefinition.create().setKey("mod4").setBaseDir(temp.newFolder()).setWorkDir(temp.newFolder()));
tree.index(mod1, root);
tree.index(mod2, mod1);
*/
package org.sonar.scanner.scan;
-import static org.assertj.core.api.Assertions.assertThat;
-
+import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
-
+import org.junit.Rule;
import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.sonar.api.batch.bootstrap.ProjectDefinition;
import org.sonar.api.batch.fs.internal.DefaultInputModule;
+import static org.assertj.core.api.Assertions.assertThat;
+
public class DefaultInputModuleHierarchyTest {
+
+ @Rule
+ public TemporaryFolder temp = new TemporaryFolder();
+
private DefaultInputModuleHierarchy moduleHierarchy;
@Test
- public void test() {
- DefaultInputModule root = new DefaultInputModule("root");
- DefaultInputModule mod1 = new DefaultInputModule("mod1");
- DefaultInputModule mod2 = new DefaultInputModule("mod2");
- DefaultInputModule mod3 = new DefaultInputModule("mod3");
- DefaultInputModule mod4 = new DefaultInputModule("mod4");
+ public void test() throws IOException {
+ DefaultInputModule root = new DefaultInputModule(ProjectDefinition.create().setKey("root").setBaseDir(temp.newFolder()).setWorkDir(temp.newFolder()));
+ DefaultInputModule mod1 = new DefaultInputModule(ProjectDefinition.create().setKey("mod1").setBaseDir(temp.newFolder()).setWorkDir(temp.newFolder()));
+ DefaultInputModule mod2 = new DefaultInputModule(ProjectDefinition.create().setKey("mod2").setBaseDir(temp.newFolder()).setWorkDir(temp.newFolder()));
+ DefaultInputModule mod3 = new DefaultInputModule(ProjectDefinition.create().setKey("mod3").setBaseDir(temp.newFolder()).setWorkDir(temp.newFolder()));
+ DefaultInputModule mod4 = new DefaultInputModule(ProjectDefinition.create().setKey("mod4").setBaseDir(temp.newFolder()).setWorkDir(temp.newFolder()));
Map<DefaultInputModule, DefaultInputModule> parents = new HashMap<>();
}
@Test
- public void testOnlyRoot() {
- DefaultInputModule root = new DefaultInputModule("root");
+ public void testOnlyRoot() throws IOException {
+ DefaultInputModule root = new DefaultInputModule(ProjectDefinition.create().setKey("root").setBaseDir(temp.newFolder()).setWorkDir(temp.newFolder()));
moduleHierarchy = new DefaultInputModuleHierarchy(root);
assertThat(moduleHierarchy.children(root)).isEmpty();
}
@Test
- public void testParentChild() {
- DefaultInputModule root = new DefaultInputModule("root");
- DefaultInputModule mod1 = new DefaultInputModule("mod1");
+ public void testParentChild() throws IOException {
+ DefaultInputModule root = new DefaultInputModule(ProjectDefinition.create().setKey("root").setBaseDir(temp.newFolder()).setWorkDir(temp.newFolder()));
+ DefaultInputModule mod1 = new DefaultInputModule(ProjectDefinition.create().setKey("mod1").setBaseDir(temp.newFolder()).setWorkDir(temp.newFolder()));
moduleHierarchy = new DefaultInputModuleHierarchy(root, mod1);
assertThat(moduleHierarchy.children(root)).containsOnly(mod1);
*/
package org.sonar.scanner.scan;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Path;
-
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.batch.fs.internal.InputModuleHierarchy;
import org.sonar.home.cache.DirectoryLock;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
public class ProjectLockTest {
@Rule
public TemporaryFolder tempFolder = new TemporaryFolder();
InputModuleHierarchy hierarchy = mock(InputModuleHierarchy.class);
DefaultInputModule root = mock(DefaultInputModule.class);
when(hierarchy.root()).thenReturn(root);
- when(root.getWorkDir()).thenReturn(file);
+ when(root.getWorkDir()).thenReturn(file.toPath());
return new ProjectLock(hierarchy);
}
*/
package org.sonar.scanner.scan;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
import java.io.File;
import java.io.IOException;
-
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.batch.fs.internal.InputModuleHierarchy;
import org.sonar.home.cache.DirectoryLock;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
public class WorkDirectoryCleanerTest {
private WorkDirectoryCleaner cleaner;
@Rule
InputModuleHierarchy hierarchy = mock(InputModuleHierarchy.class);
DefaultInputModule root = mock(DefaultInputModule.class);
when(hierarchy.root()).thenReturn(root);
- when(root.getWorkDir()).thenReturn(temp.getRoot());
+ when(root.getWorkDir()).thenReturn(temp.getRoot().toPath());
assertThat(temp.getRoot().list().length).isGreaterThan(1);
cleaner = new WorkDirectoryCleaner(hierarchy);
File rootBaseDir = temp.newFolder();
ProjectDefinition moduleDef = ProjectDefinition.create()
- .setKey(subModuleKey).setBaseDir(rootBaseDir);
+ .setKey(subModuleKey).setBaseDir(rootBaseDir).setWorkDir(temp.newFolder());
ProjectDefinition rootDef = ProjectDefinition.create()
- .setKey(rootModuleKey).setBaseDir(rootBaseDir).addSubProject(moduleDef);
+ .setKey(rootModuleKey).setBaseDir(rootBaseDir).setWorkDir(temp.newFolder()).addSubProject(moduleDef);
DefaultInputModule rootModule = TestInputFileBuilder.newDefaultInputModule(rootDef);
DefaultInputModule subModule = TestInputFileBuilder.newDefaultInputModule(moduleDef);
import org.sonar.api.batch.fs.internal.DefaultInputFile;
import org.sonar.api.batch.fs.internal.DefaultInputModule;
import org.sonar.api.config.internal.MapSettings;
-import org.sonar.api.scan.filesystem.PathResolver;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
public class InputFileBuilderTest {
@Rule
public TemporaryFolder temp = new TemporaryFolder();
private Path baseDir;
+ private Path workDir;
private InputFileBuilder builder;
@Before
public void setUp() throws IOException {
baseDir = temp.newFolder().toPath();
+ workDir = temp.newFolder().toPath();
DefaultInputModule module = new DefaultInputModule(ProjectDefinition.create()
- .setKey("module1")
- .setBaseDir(baseDir.toFile()), 0);
+ .setBaseDir(baseDir.toFile())
+ .setWorkDir(workDir.toFile())
+ .setKey("module1"), 0);
- PathResolver pathResolver = new PathResolver();
LanguageDetection langDetection = mock(LanguageDetection.class);
MetadataGenerator metadataGenerator = mock(MetadataGenerator.class);
BatchIdGenerator idGenerator = new BatchIdGenerator();
MapSettings settings = new MapSettings();
- builder = new InputFileBuilder(module, pathResolver, langDetection, metadataGenerator, idGenerator, settings.asConfig());
+ ModuleFileSystemInitializer moduleFileSystemInitializer = mock(ModuleFileSystemInitializer.class);
+ when(moduleFileSystemInitializer.defaultEncoding()).thenReturn(StandardCharsets.UTF_8);
+ builder = new InputFileBuilder(module, langDetection, metadataGenerator, idGenerator, settings.asConfig(), moduleFileSystemInitializer);
}
@Test
public void testBuild() {
Path filePath = baseDir.resolve("src/File1.xoo");
- DefaultInputFile inputFile = builder.create(filePath, Type.MAIN, StandardCharsets.UTF_8);
+ DefaultInputFile inputFile = builder.create(filePath, Type.MAIN);
assertThat(inputFile.moduleKey()).isEqualTo("module1");
assertThat(inputFile.absolutePath()).isEqualTo(filePath.toString().replaceAll("\\\\", "/"));
*/
package org.sonar.scanner.scan.filesystem;
+import java.io.IOException;
+import org.junit.Rule;
import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
import org.mockito.Mockito;
+import org.sonar.api.batch.bootstrap.ProjectDefinition;
import org.sonar.api.batch.fs.internal.DefaultInputModule;
import org.sonar.api.batch.fs.internal.FileMetadata;
import org.sonar.scanner.issue.ignore.pattern.IssueExclusionPatternInitializer;
import static org.mockito.Mockito.mock;
public class MetadataGeneratorProviderTest {
+
+ @Rule
+ public TemporaryFolder temp = new TemporaryFolder();
+
@Test
- public void create_builder() {
+ public void create_builder() throws IOException {
StatusDetectionFactory statusDetectionFactory = mock(StatusDetectionFactory.class, Mockito.RETURNS_MOCKS);
IssueExclusionsLoader issueExclusionsLoader = new IssueExclusionsLoader(mock(IssueExclusionPatternInitializer.class), mock(PatternMatcher.class));
MetadataGeneratorProvider factory = new MetadataGeneratorProvider();
- assertThat(factory.provide(new DefaultInputModule("module"), statusDetectionFactory, new FileMetadata(), issueExclusionsLoader)).isNotNull();
+ assertThat(factory.provide(new DefaultInputModule(ProjectDefinition.create().setKey("module").setBaseDir(temp.newFolder()).setWorkDir(temp.newFolder())),
+ statusDetectionFactory, new FileMetadata(), issueExclusionsLoader)).isNotNull();
}
}
import org.junit.rules.TemporaryFolder;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
+import org.sonar.api.batch.bootstrap.ProjectDefinition;
import org.sonar.api.batch.fs.InputFile;
import org.sonar.api.batch.fs.internal.DefaultInputFile;
import org.sonar.api.batch.fs.internal.DefaultInputModule;
private MetadataGenerator generator;
@Before
- public void setUp() {
+ public void setUp() throws IOException {
MockitoAnnotations.initMocks(this);
metadata = new FileMetadata();
IssueExclusionsLoader issueExclusionsLoader = new IssueExclusionsLoader(mock(IssueExclusionPatternInitializer.class), mock(PatternMatcher.class));
- generator = new MetadataGenerator(new DefaultInputModule("module"), statusDetection, metadata, issueExclusionsLoader);
+ generator = new MetadataGenerator(new DefaultInputModule(ProjectDefinition.create().setKey("module").setBaseDir(temp.newFolder()).setWorkDir(temp.newFolder())),
+ statusDetection, metadata, issueExclusionsLoader);
}
@Test
*/
package org.sonar.scanner.scan.filesystem;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.mock;
-
import java.io.File;
import java.io.IOException;
-
+import java.nio.file.Path;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.FilenameUtils;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.sonar.api.batch.bootstrap.ProjectDefinition;
-import org.sonar.api.scan.filesystem.PathResolver;
-import org.sonar.api.utils.TempFolder;
+import org.sonar.api.batch.fs.internal.DefaultInputModule;
+import org.sonar.api.utils.log.LogTester;
+import org.sonar.api.utils.log.LoggerLevel;
+
+import static org.assertj.core.api.Assertions.assertThat;
public class ModuleFileSystemInitializerTest {
@Rule
public TemporaryFolder temp = new TemporaryFolder();
- PathResolver pathResolver = new PathResolver();
+ @Rule
+ public LogTester logTester = new LogTester();
@Test
public void test_default_directories() throws Exception {
File workDir = temp.newFolder("work");
ProjectDefinition module = ProjectDefinition.create().setBaseDir(baseDir).setWorkDir(workDir);
- ModuleFileSystemInitializer initializer = new ModuleFileSystemInitializer(module, mock(TempFolder.class), pathResolver);
+ ModuleFileSystemInitializer initializer = new ModuleFileSystemInitializer(new DefaultInputModule(module), module);
- assertThat(initializer.baseDir().getCanonicalPath()).isEqualTo(baseDir.getCanonicalPath());
- assertThat(initializer.workingDir().getCanonicalPath()).isEqualTo(workDir.getCanonicalPath());
+ assertThat(logTester.logs(LoggerLevel.INFO)).contains("Base dir: " + baseDir.toPath().toAbsolutePath().toString());
+ assertThat(logTester.logs(LoggerLevel.INFO)).contains("Working dir: " + workDir.toPath().toAbsolutePath().toString());
assertThat(initializer.sources()).isEmpty();
assertThat(initializer.tests()).isEmpty();
}
@Test
public void should_init_directories() throws IOException {
File baseDir = temp.newFolder("base");
+ File workDir = temp.newFolder("work");
File sourceDir = new File(baseDir, "src/main/java");
FileUtils.forceMkdir(sourceDir);
File testDir = new File(baseDir, "src/test/java");
ProjectDefinition project = ProjectDefinition.create()
.setBaseDir(baseDir)
+ .setWorkDir(workDir)
.addSources("src/main/java", "src/main/unknown")
.addTests("src/test/java", "src/test/unknown");
- ModuleFileSystemInitializer initializer = new ModuleFileSystemInitializer(project, mock(TempFolder.class), pathResolver);
+ ModuleFileSystemInitializer initializer = new ModuleFileSystemInitializer(new DefaultInputModule(project), project);
- assertThat(initializer.baseDir().getCanonicalPath()).isEqualTo(baseDir.getCanonicalPath());
assertThat(initializer.sources()).hasSize(1);
assertThat(path(initializer.sources().get(0))).endsWith("src/main/java");
assertThat(initializer.tests()).hasSize(1);
@Test
public void supportFilenamesWithComma() throws IOException {
File baseDir = temp.newFolder("base");
+ File workDir = temp.newFolder("work");
File sourceFile = new File(baseDir, "my,File.cs");
sourceFile.createNewFile();
File testFile = new File(baseDir, "my,TestFile.cs");
ProjectDefinition project = ProjectDefinition.create()
.setBaseDir(baseDir)
+ .setWorkDir(workDir)
.addSources("\"my,File.cs\"")
.addTests("\"my,TestFile.cs\"");
- ModuleFileSystemInitializer initializer = new ModuleFileSystemInitializer(project, mock(TempFolder.class), pathResolver);
+ ModuleFileSystemInitializer initializer = new ModuleFileSystemInitializer(new DefaultInputModule(project), project);
- assertThat(initializer.baseDir().getCanonicalPath()).isEqualTo(baseDir.getCanonicalPath());
assertThat(initializer.sources()).hasSize(1);
- assertThat(initializer.sources().get(0)).isEqualTo(sourceFile);
+ assertThat(initializer.sources().get(0)).isEqualTo(sourceFile.toPath());
assertThat(initializer.tests()).hasSize(1);
- assertThat(initializer.tests().get(0)).isEqualTo(testFile);
+ assertThat(initializer.tests().get(0)).isEqualTo(testFile.toPath());
}
- private String path(File f) throws IOException {
- return FilenameUtils.separatorsToUnix(f.getCanonicalPath());
+ private String path(Path f) throws IOException {
+ return FilenameUtils.separatorsToUnix(f.toString());
}
}
*/
package org.sonar.scanner.scan.report;
-import static net.javacrumbs.jsonunit.assertj.JsonAssert.assertThatJson;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verifyZeroInteractions;
-import static org.mockito.Mockito.when;
-
import java.io.File;
import java.io.IOException;
import java.io.StringWriter;
import java.util.Arrays;
import java.util.Collections;
import java.util.TimeZone;
-
import org.apache.commons.io.IOUtils;
import org.junit.Before;
import org.junit.Rule;
import org.sonar.scanner.scan.DefaultComponentTree;
import org.sonar.scanner.scan.filesystem.InputComponentStore;
+import static net.javacrumbs.jsonunit.assertj.JsonAssert.assertThatJson;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.when;
+
public class JSONReportTest {
private SimpleDateFormat SIMPLE_DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd");
when(server.getVersion()).thenReturn("3.6");
DefaultComponentTree inputComponentTree = new DefaultComponentTree();
- ProjectDefinition def = ProjectDefinition.create().setBaseDir(projectBaseDir).setKey("struts");
+ ProjectDefinition def = ProjectDefinition.create().setBaseDir(projectBaseDir).setWorkDir(temp.newFolder()).setKey("struts");
DefaultInputModule rootModule = new DefaultInputModule(def, 1);
InputComponentStore inputComponentStore = new InputComponentStore(new PathResolver(), rootModule);
- DefaultInputModule moduleA = new DefaultInputModule("struts-core");
+ DefaultInputModule moduleA = new DefaultInputModule(ProjectDefinition.create().setKey("struts-core").setBaseDir(temp.newFolder()).setWorkDir(temp.newFolder()));
inputComponentTree.index(moduleA, rootModule);
- DefaultInputModule moduleB = new DefaultInputModule("struts-ui");
+ DefaultInputModule moduleB = new DefaultInputModule(ProjectDefinition.create().setKey("struts-ui").setBaseDir(temp.newFolder()).setWorkDir(temp.newFolder()));
inputComponentTree.index(moduleB, rootModule);
DefaultInputDir inputDir = new DefaultInputDir("struts", "src/main/java/org/apache/struts", TestInputFileBuilder.nextBatchId())
@Test
public void should_not_export_by_default() throws IOException {
File workDir = temp.newFolder("sonar");
- fs.setWorkDir(workDir);
+ fs.setWorkDir(workDir.toPath());
jsonReport.execute();
@Test
public void should_export_issues_to_file() throws IOException {
File workDir = temp.newFolder("sonar");
- fs.setWorkDir(workDir);
+ fs.setWorkDir(workDir.toPath());
when(issueCache.all()).thenReturn(Collections.<TrackedIssue>emptyList());
package org.sonar.scanner.sensor;
import com.google.common.collect.ImmutableMap;
+import java.io.IOException;
import java.util.Map;
import org.junit.Before;
import org.junit.Rule;
import org.junit.rules.ExpectedException;
import org.junit.rules.TemporaryFolder;
import org.mockito.ArgumentCaptor;
+import org.sonar.api.batch.bootstrap.ProjectDefinition;
import org.sonar.api.batch.fs.InputFile;
import org.sonar.api.batch.fs.internal.DefaultInputModule;
import org.sonar.api.batch.fs.internal.TestInputFileBuilder;
}
@Test
- public void shouldSaveProjectMeasureToSensorContext() {
+ public void shouldSaveProjectMeasureToSensorContext() throws IOException {
String projectKey = "myProject";
- DefaultInputModule module = new DefaultInputModule(projectKey);
+ DefaultInputModule module = new DefaultInputModule(ProjectDefinition.create().setKey(projectKey).setBaseDir(temp.newFolder()).setWorkDir(temp.newFolder()));
ArgumentCaptor<DefaultMeasure> argumentCaptor = ArgumentCaptor.forClass(DefaultMeasure.class);
when(measureCache.put(eq(module.key()), eq(CoreMetrics.NCLOC_KEY), argumentCaptor.capture())).thenReturn(null);
*/
package org.sonar.scanner.source;
+import java.io.IOException;
+import org.junit.Rule;
import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
import org.sonar.api.batch.AnalysisMode;
+import org.sonar.api.batch.bootstrap.ProjectDefinition;
import org.sonar.api.batch.fs.internal.DefaultInputModule;
import org.sonar.api.batch.fs.internal.TestInputFileBuilder;
import org.sonar.api.batch.sensor.internal.SensorStorage;
public class HighlightableBuilderTest {
+ @Rule
+ public TemporaryFolder temp = new TemporaryFolder();
+
@Test
public void should_load_default_perspective() {
HighlightableBuilder builder = new HighlightableBuilder(mock(SensorStorage.class), mock(AnalysisMode.class));
}
@Test
- public void project_should_not_be_highlightable() {
+ public void project_should_not_be_highlightable() throws IOException {
HighlightableBuilder builder = new HighlightableBuilder(mock(SensorStorage.class), mock(AnalysisMode.class));
- Highlightable perspective = builder.loadPerspective(Highlightable.class, new DefaultInputModule("struts"));
+ Highlightable perspective = builder.loadPerspective(Highlightable.class,
+ new DefaultInputModule(ProjectDefinition.create().setKey("struts").setBaseDir(temp.newFolder()).setWorkDir(temp.newFolder())));
assertThat(perspective).isNull();
}
*/
package org.sonar.scanner.source;
+import java.io.IOException;
+import org.junit.Rule;
import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
import org.sonar.api.batch.AnalysisMode;
+import org.sonar.api.batch.bootstrap.ProjectDefinition;
import org.sonar.api.batch.fs.internal.DefaultInputModule;
import org.sonar.api.batch.fs.internal.TestInputFileBuilder;
import org.sonar.api.component.Perspective;
public class SymbolizableBuilderTest {
+ @Rule
+ public TemporaryFolder temp = new TemporaryFolder();
+
@Test
public void should_load_perspective() {
SymbolizableBuilder perspectiveBuilder = new SymbolizableBuilder(mock(DefaultSensorStorage.class), mock(AnalysisMode.class));
}
@Test
- public void project_should_not_be_highlightable() {
+ public void project_should_not_be_highlightable() throws IOException {
SymbolizableBuilder builder = new SymbolizableBuilder(mock(DefaultSensorStorage.class), mock(AnalysisMode.class));
- Perspective perspective = builder.loadPerspective(Symbolizable.class, new DefaultInputModule("struts"));
+ Perspective perspective = builder.loadPerspective(Symbolizable.class,
+ new DefaultInputModule(ProjectDefinition.create().setKey("struts").setBaseDir(temp.newFolder()).setWorkDir(temp.newFolder())));
assertThat(perspective).isNull();
}
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
-
import javax.annotation.concurrent.Immutable;
-
import org.sonar.core.util.ContextException;
import org.sonar.core.util.Protobuf;
projects / sonarqube.git / commitdiff