From 0404aea2db6cde052c6ac4fbd5b2b8097f1a1846 Mon Sep 17 00:00:00 2001 From: =?utf8?q?S=C3=A9bastien=20Lesaint?= Date: Mon, 25 May 2015 18:02:12 +0200 Subject: [PATCH] SONAR-6590 use a CE specific interface to read batch report --- .../benchmark/PersistFileSourcesStepTest.java | 47 ++-- .../computation/ComputationContext.java | 2 +- .../computation/ComputationService.java | 19 +- .../computation/batch/BatchReportReader.java | 60 +++++ .../batch/FileBatchReportReader.java | 108 +++++++++ .../computation/batch/package-info.java | 24 ++ .../component/ComponentTreeBuilders.java | 2 +- .../computation/issue/SourceLinesCache.java | 2 +- .../computation/step/ParseReportStep.java | 2 +- .../step/PersistComponentsStep.java | 2 +- .../step/PersistDuplicationsStep.java | 5 +- .../computation/step/PersistEventsStep.java | 5 +- .../step/PersistFileSourcesStep.java | 17 +- .../computation/step/PersistMeasuresStep.java | 8 +- ...ersistNumberOfDaysSinceLastCommitStep.java | 10 +- .../step/PersistProjectLinksStep.java | 14 +- .../computation/step/PersistTestsStep.java | 19 +- .../PopulateComponentsUuidAndKeyStep.java | 2 +- .../computation/step/ValidateProjectStep.java | 2 +- .../computation/ComputationServiceTest.java | 2 +- .../batch/BatchReportReaderRule.java | 216 ++++++++++++++++++ .../issue/SourceLinesCacheTest.java | 21 +- .../step/ApplyPermissionsStepTest.java | 25 +- .../step/IndexComponentsStepTest.java | 3 +- .../step/IndexSourceLinesStepTest.java | 10 +- .../computation/step/IndexTestsStepTest.java | 3 +- .../computation/step/ParseReportStepTest.java | 41 ++-- .../step/PersistComponentsStepTest.java | 154 +++++-------- .../step/PersistDuplicationsStepTest.java | 97 ++++---- .../step/PersistEventsStepTest.java | 72 +++--- .../step/PersistFileSourcesStepTest.java | 105 +++++---- .../step/PersistMeasuresStepTest.java | 26 +-- ...stNumberOfDaysSinceLastCommitStepTest.java | 35 ++- .../step/PersistProjectLinksStepTest.java | 71 +++--- .../step/PersistTestsStepTest.java | 68 +++--- .../PopulateComponentsUuidAndKeyStepTest.java | 122 ++++------ .../step/PurgeDatastoresStepTest.java | 17 +- .../step/QualityProfileEventsStepTest.java | 2 +- .../step/SendIssueNotificationsStepTest.java | 21 +- .../step/ValidateProjectStepTest.java | 80 +++---- .../protocol/output/BatchReportWriter.java | 39 ++-- 41 files changed, 921 insertions(+), 659 deletions(-) create mode 100644 server/sonar-server/src/main/java/org/sonar/server/computation/batch/BatchReportReader.java create mode 100644 server/sonar-server/src/main/java/org/sonar/server/computation/batch/FileBatchReportReader.java create mode 100644 server/sonar-server/src/main/java/org/sonar/server/computation/batch/package-info.java create mode 100644 server/sonar-server/src/test/java/org/sonar/server/computation/batch/BatchReportReaderRule.java diff --git a/server/sonar-server-benchmarks/src/test/java/org/sonar/server/benchmark/PersistFileSourcesStepTest.java b/server/sonar-server-benchmarks/src/test/java/org/sonar/server/benchmark/PersistFileSourcesStepTest.java index b5507606e40..7068d8fe84c 100644 --- a/server/sonar-server-benchmarks/src/test/java/org/sonar/server/benchmark/PersistFileSourcesStepTest.java +++ b/server/sonar-server-benchmarks/src/test/java/org/sonar/server/benchmark/PersistFileSourcesStepTest.java @@ -31,10 +31,10 @@ import org.sonar.api.utils.System2; import org.sonar.api.utils.internal.Uuids; import org.sonar.batch.protocol.Constants; import org.sonar.batch.protocol.output.BatchReport; -import org.sonar.batch.protocol.output.BatchReportReader; import org.sonar.batch.protocol.output.BatchReportWriter; import org.sonar.core.persistence.DbTester; import org.sonar.server.computation.ComputationContext; +import org.sonar.server.computation.batch.BatchReportReaderRule; import org.sonar.server.computation.component.ComponentTreeBuilders; import org.sonar.server.computation.component.DbComponentsRefCache; import org.sonar.server.computation.component.DbComponentsRefCache.DbComponent; @@ -70,21 +70,23 @@ public class PersistFileSourcesStepTest { @Rule public Benchmark benchmark = new Benchmark(); + @Rule + public BatchReportReaderRule reportReader = new BatchReportReaderRule(); @Test public void benchmark() throws Exception { - File reportDir = prepareReport(); - persistFileSources(reportDir); + prepareReport(); + persistFileSources(); } - private void persistFileSources(File reportDir) { + private void persistFileSources() { LOGGER.info("Persist file sources"); DbClient dbClient = new DbClient(dbTester.database(), dbTester.myBatis(), new FileSourceDao(dbTester.myBatis())); long start = System.currentTimeMillis(); PersistFileSourcesStep step = new PersistFileSourcesStep(dbClient, System2.INSTANCE, dbComponentsRefCache); - step.execute(new ComputationContext(new BatchReportReader(reportDir), "PROJECT_KEY", new Settings(), dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), mock(LanguageRepository.class))); + step.execute(new ComputationContext(reportReader, "PROJECT_KEY", new Settings(), dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), mock(LanguageRepository.class))); long end = System.currentTimeMillis(); long duration = end - start; @@ -95,14 +97,13 @@ public class PersistFileSourcesStepTest { benchmark.expectAround("Duration to persist FILE_SOURCES", duration, 105000, Benchmark.DEFAULT_ERROR_MARGIN_PERCENTS); } - private File prepareReport() throws IOException { + private void prepareReport() throws IOException { LOGGER.info("Create report"); File reportDir = temp.newFolder(); - BatchReportWriter writer = new BatchReportWriter(reportDir); - writer.writeMetadata(BatchReport.Metadata.newBuilder() - .setRootComponentRef(1) - .build()); + reportReader.setMetadata(BatchReport.Metadata.newBuilder() + .setRootComponentRef(1) + .build()); BatchReport.Component.Builder project = BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT); @@ -110,13 +111,11 @@ public class PersistFileSourcesStepTest { dbComponentsRefCache.addComponent(1, new DbComponent(1L, "PROJECT", PROJECT_UUID)); for (int fileRef = 2; fileRef <= NUMBER_OF_FILES + 1; fileRef++) { - generateFileReport(writer, fileRef); + generateFileReport(new BatchReportWriter(reportDir), fileRef); project.addChildRef(fileRef); } - writer.writeComponent(project.build()); - - return reportDir; + reportReader.putComponent(project.build()); } private void generateFileReport(BatchReportWriter writer, int fileRef) throws IOException { @@ -124,20 +123,20 @@ public class PersistFileSourcesStepTest { for (int line = 1; line <= NUMBER_OF_LINES; line++) { lineData.generateLineData(line); } - writer.writeComponent(BatchReport.Component.newBuilder() - .setRef(fileRef) - .setType(Constants.ComponentType.FILE) - .setLines(NUMBER_OF_LINES) - .build()); + reportReader.putComponent(BatchReport.Component.newBuilder() + .setRef(fileRef) + .setType(Constants.ComponentType.FILE) + .setLines(NUMBER_OF_LINES) + .build()); dbComponentsRefCache.addComponent(fileRef, new DbComponent((long) fileRef, "PROJECT:" + fileRef, Uuids.create())); FileUtils.writeLines(writer.getSourceFile(fileRef), lineData.lines); - writer.writeComponentCoverage(fileRef, lineData.coverages); - writer.writeComponentChangesets(lineData.changesetsBuilder.setComponentRef(fileRef).build()); - writer.writeComponentSyntaxHighlighting(fileRef, lineData.highlightings); - writer.writeComponentSymbols(fileRef, lineData.symbols); - writer.writeComponentDuplications(fileRef, lineData.duplications); + reportReader.putCoverage(fileRef, writer.writeComponentCoverage(fileRef, lineData.coverages)); + reportReader.putChangesets(lineData.changesetsBuilder.setComponentRef(fileRef).build()); + reportReader.putSyntaxHighlighting(fileRef, writer.writeComponentSyntaxHighlighting(fileRef, lineData.highlightings)); + reportReader.putSymbols(fileRef, lineData.symbols); + reportReader.putDuplications(fileRef, lineData.duplications); } private static class LineData { diff --git a/server/sonar-server/src/main/java/org/sonar/server/computation/ComputationContext.java b/server/sonar-server/src/main/java/org/sonar/server/computation/ComputationContext.java index 2e8ac5d603d..4eac5d2c44e 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/computation/ComputationContext.java +++ b/server/sonar-server/src/main/java/org/sonar/server/computation/ComputationContext.java @@ -21,7 +21,7 @@ package org.sonar.server.computation; import org.sonar.api.config.Settings; import org.sonar.batch.protocol.output.BatchReport; -import org.sonar.batch.protocol.output.BatchReportReader; +import org.sonar.server.computation.batch.BatchReportReader; import org.sonar.server.computation.component.Component; import org.sonar.server.computation.component.ComponentTreeBuilder; import org.sonar.server.computation.language.LanguageRepository; diff --git a/server/sonar-server/src/main/java/org/sonar/server/computation/ComputationService.java b/server/sonar-server/src/main/java/org/sonar/server/computation/ComputationService.java index 6b9796f10de..0c934542a72 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/computation/ComputationService.java +++ b/server/sonar-server/src/main/java/org/sonar/server/computation/ComputationService.java @@ -21,6 +21,9 @@ package org.sonar.server.computation; import com.google.common.base.Throwables; +import java.io.File; +import java.io.IOException; +import javax.annotation.CheckForNull; import org.apache.commons.io.FileUtils; import org.sonar.api.server.ServerSide; import org.sonar.api.utils.System2; @@ -29,24 +32,19 @@ import org.sonar.api.utils.ZipUtils; import org.sonar.api.utils.log.Logger; import org.sonar.api.utils.log.Loggers; import org.sonar.api.utils.log.Profiler; -import org.sonar.batch.protocol.output.BatchReportReader; import org.sonar.core.component.ComponentDto; import org.sonar.core.computation.db.AnalysisReportDto; import org.sonar.core.persistence.DbSession; import org.sonar.core.persistence.MyBatis; import org.sonar.server.activity.Activity; import org.sonar.server.activity.ActivityService; +import org.sonar.server.computation.batch.BatchReportReader; +import org.sonar.server.computation.batch.FileBatchReportReader; import org.sonar.server.computation.component.ComponentTreeBuilders; import org.sonar.server.computation.language.LanguageRepository; import org.sonar.server.computation.step.ComputationStep; import org.sonar.server.computation.step.ComputationSteps; import org.sonar.server.db.DbClient; -import org.sonar.server.properties.ProjectSettingsFactory; - -import javax.annotation.CheckForNull; - -import java.io.File; -import java.io.IOException; import static org.sonar.api.utils.DateUtils.formatDateTimeNullSafe; import static org.sonar.api.utils.DateUtils.longToDate; @@ -61,18 +59,15 @@ public class ComputationService { private final DbClient dbClient; private final ComputationSteps steps; private final ActivityService activityService; - private final ProjectSettingsFactory projectSettingsFactory; private final TempFolder tempFolder; private final System2 system; private final LanguageRepository languageRepository; public ComputationService(DbClient dbClient, ComputationSteps steps, ActivityService activityService, - ProjectSettingsFactory projectSettingsFactory, TempFolder tempFolder, System2 system, - LanguageRepository languageRepository) { + TempFolder tempFolder, System2 system, LanguageRepository languageRepository) { this.dbClient = dbClient; this.steps = steps; this.activityService = activityService; - this.projectSettingsFactory = projectSettingsFactory; this.tempFolder = tempFolder; this.system = system; this.languageRepository = languageRepository; @@ -85,7 +80,7 @@ public class ComputationService { try { File reportDir = extractReportInDir(item); - BatchReportReader reader = new BatchReportReader(reportDir); + BatchReportReader reader = new FileBatchReportReader(new org.sonar.batch.protocol.output.BatchReportReader(reportDir)); ComputationContext context = new ComputationContext(reader, null, null, dbClient, ComponentTreeBuilders.from(reader), languageRepository); for (ComputationStep step : steps.orderedSteps()) { Profiler stepProfiler = Profiler.createIfDebug(LOG).startDebug(step.getDescription()); diff --git a/server/sonar-server/src/main/java/org/sonar/server/computation/batch/BatchReportReader.java b/server/sonar-server/src/main/java/org/sonar/server/computation/batch/BatchReportReader.java new file mode 100644 index 00000000000..3d45d9083fb --- /dev/null +++ b/server/sonar-server/src/main/java/org/sonar/server/computation/batch/BatchReportReader.java @@ -0,0 +1,60 @@ +/* + * SonarQube, open source software quality management tool. + * Copyright (C) 2008-2014 SonarSource + * mailto:contact AT sonarsource DOT com + * + * SonarQube is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * SonarQube is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ +package org.sonar.server.computation.batch; + +import java.io.File; +import java.util.List; +import javax.annotation.CheckForNull; +import org.sonar.batch.protocol.output.BatchReport; + +public interface BatchReportReader { + BatchReport.Metadata readMetadata(); + + List readComponentMeasures(int componentRef); + + @CheckForNull + BatchReport.Changesets readChangesets(int componentRef); + + BatchReport.Component readComponent(int componentRef); + + List readComponentIssues(int componentRef); + + BatchReport.Issues readDeletedComponentIssues(int deletedComponentRef); + + List readComponentDuplications(int componentRef); + + List readComponentSymbols(int componentRef); + + boolean hasSyntaxHighlighting(int componentRef); + + @CheckForNull + File readComponentSyntaxHighlighting(int fileRef); + + @CheckForNull + File readComponentCoverage(int fileRef); + + File readFileSource(int fileRef); + + @CheckForNull + File readTests(int testFileRef); + + @CheckForNull + File readCoverageDetails(int testFileRef); +} diff --git a/server/sonar-server/src/main/java/org/sonar/server/computation/batch/FileBatchReportReader.java b/server/sonar-server/src/main/java/org/sonar/server/computation/batch/FileBatchReportReader.java new file mode 100644 index 00000000000..748465b0772 --- /dev/null +++ b/server/sonar-server/src/main/java/org/sonar/server/computation/batch/FileBatchReportReader.java @@ -0,0 +1,108 @@ +/* + * SonarQube, open source software quality management tool. + * Copyright (C) 2008-2014 SonarSource + * mailto:contact AT sonarsource DOT com + * + * SonarQube is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * SonarQube is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ +package org.sonar.server.computation.batch; + +import java.io.File; +import java.util.List; +import javax.annotation.CheckForNull; +import org.sonar.batch.protocol.output.BatchReport; + +public class FileBatchReportReader implements BatchReportReader { + private final org.sonar.batch.protocol.output.BatchReportReader delegate; + + public FileBatchReportReader(org.sonar.batch.protocol.output.BatchReportReader delegate) { + this.delegate = delegate; + } + + @Override + public BatchReport.Metadata readMetadata() { + return delegate.readMetadata(); + } + + @Override + public List readComponentMeasures(int componentRef) { + return delegate.readComponentMeasures(componentRef); + } + + @Override + @CheckForNull + public BatchReport.Changesets readChangesets(int componentRef) { + return delegate.readChangesets(componentRef); + } + + @Override + public BatchReport.Component readComponent(int componentRef) { + return delegate.readComponent(componentRef); + } + + @Override + public List readComponentIssues(int componentRef) { + return delegate.readComponentIssues(componentRef); + } + + @Override + public BatchReport.Issues readDeletedComponentIssues(int deletedComponentRef) { + return delegate.readDeletedComponentIssues(deletedComponentRef); + } + + @Override + public List readComponentDuplications(int componentRef) { + return delegate.readComponentDuplications(componentRef); + } + + @Override + public List readComponentSymbols(int componentRef) { + return delegate.readComponentSymbols(componentRef); + } + + @Override + public boolean hasSyntaxHighlighting(int componentRef) { + return delegate.hasSyntaxHighlighting(componentRef); + } + + @Override + @CheckForNull + public File readComponentSyntaxHighlighting(int fileRef) { + return delegate.readComponentSyntaxHighlighting(fileRef); + } + + @Override + @CheckForNull + public File readComponentCoverage(int fileRef) { + return delegate.readComponentCoverage(fileRef); + } + + @Override + public File readFileSource(int fileRef) { + return delegate.readFileSource(fileRef); + } + + @Override + @CheckForNull + public File readTests(int testFileRef) { + return delegate.readTests(testFileRef); + } + + @Override + @CheckForNull + public File readCoverageDetails(int testFileRef) { + return delegate.readCoverageDetails(testFileRef); + } +} diff --git a/server/sonar-server/src/main/java/org/sonar/server/computation/batch/package-info.java b/server/sonar-server/src/main/java/org/sonar/server/computation/batch/package-info.java new file mode 100644 index 00000000000..a9111b70b68 --- /dev/null +++ b/server/sonar-server/src/main/java/org/sonar/server/computation/batch/package-info.java @@ -0,0 +1,24 @@ +/* + * SonarQube, open source software quality management tool. + * Copyright (C) 2008-2014 SonarSource + * mailto:contact AT sonarsource DOT com + * + * SonarQube is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * SonarQube is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +@ParametersAreNonnullByDefault +package org.sonar.server.computation.batch; + +import javax.annotation.ParametersAreNonnullByDefault; diff --git a/server/sonar-server/src/main/java/org/sonar/server/computation/component/ComponentTreeBuilders.java b/server/sonar-server/src/main/java/org/sonar/server/computation/component/ComponentTreeBuilders.java index 1ecbd9105c8..957ade019ca 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/computation/component/ComponentTreeBuilders.java +++ b/server/sonar-server/src/main/java/org/sonar/server/computation/component/ComponentTreeBuilders.java @@ -23,7 +23,7 @@ import com.google.common.base.Function; import com.google.common.collect.Iterables; import javax.annotation.Nonnull; import org.sonar.batch.protocol.output.BatchReport; -import org.sonar.batch.protocol.output.BatchReportReader; +import org.sonar.server.computation.batch.BatchReportReader; import org.sonar.server.computation.ComputationContext; import static java.util.Objects.requireNonNull; diff --git a/server/sonar-server/src/main/java/org/sonar/server/computation/issue/SourceLinesCache.java b/server/sonar-server/src/main/java/org/sonar/server/computation/issue/SourceLinesCache.java index 7f6fc739da5..d5e7a313e46 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/computation/issue/SourceLinesCache.java +++ b/server/sonar-server/src/main/java/org/sonar/server/computation/issue/SourceLinesCache.java @@ -23,7 +23,7 @@ import org.apache.commons.lang.StringUtils; import org.sonar.batch.protocol.output.BatchReport; import org.sonar.batch.protocol.output.BatchReport.Changesets.Changeset; import org.sonar.batch.protocol.output.BatchReport.Changesets.Changeset.Builder; -import org.sonar.batch.protocol.output.BatchReportReader; +import org.sonar.server.computation.batch.BatchReportReader; import org.sonar.server.source.index.SourceLineDoc; import org.sonar.server.source.index.SourceLineIndex; diff --git a/server/sonar-server/src/main/java/org/sonar/server/computation/step/ParseReportStep.java b/server/sonar-server/src/main/java/org/sonar/server/computation/step/ParseReportStep.java index bfc408816e7..f17085e67be 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/computation/step/ParseReportStep.java +++ b/server/sonar-server/src/main/java/org/sonar/server/computation/step/ParseReportStep.java @@ -22,10 +22,10 @@ package org.sonar.server.computation.step; import java.util.List; import org.sonar.batch.protocol.output.BatchReport; -import org.sonar.batch.protocol.output.BatchReportReader; import org.sonar.server.computation.ComputationContext; import org.sonar.server.computation.component.Component; import org.sonar.server.computation.component.DepthTraversalTypeAwareVisitor; +import org.sonar.server.computation.batch.BatchReportReader; import org.sonar.server.computation.issue.IssueComputation; public class ParseReportStep implements ComputationStep { diff --git a/server/sonar-server/src/main/java/org/sonar/server/computation/step/PersistComponentsStep.java b/server/sonar-server/src/main/java/org/sonar/server/computation/step/PersistComponentsStep.java index d1a37aa6579..16c0466c73d 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/computation/step/PersistComponentsStep.java +++ b/server/sonar-server/src/main/java/org/sonar/server/computation/step/PersistComponentsStep.java @@ -29,11 +29,11 @@ import org.apache.commons.lang.StringUtils; import org.sonar.api.resources.Qualifiers; import org.sonar.api.resources.Scopes; import org.sonar.batch.protocol.output.BatchReport; -import org.sonar.batch.protocol.output.BatchReportReader; import org.sonar.core.component.ComponentDto; import org.sonar.core.persistence.DbSession; import org.sonar.core.util.NonNullInputFunction; import org.sonar.server.computation.ComputationContext; +import org.sonar.server.computation.batch.BatchReportReader; import org.sonar.server.computation.component.Component; import org.sonar.server.computation.component.DbComponentsRefCache; import org.sonar.server.db.DbClient; diff --git a/server/sonar-server/src/main/java/org/sonar/server/computation/step/PersistDuplicationsStep.java b/server/sonar-server/src/main/java/org/sonar/server/computation/step/PersistDuplicationsStep.java index e6cb38a50fa..3e9ed86b7f8 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/computation/step/PersistDuplicationsStep.java +++ b/server/sonar-server/src/main/java/org/sonar/server/computation/step/PersistDuplicationsStep.java @@ -20,21 +20,20 @@ package org.sonar.server.computation.step; +import java.util.List; import org.apache.commons.lang.StringEscapeUtils; import org.sonar.api.measures.CoreMetrics; import org.sonar.batch.protocol.output.BatchReport; import org.sonar.batch.protocol.output.BatchReport.Range; -import org.sonar.batch.protocol.output.BatchReportReader; import org.sonar.core.measure.db.MeasureDto; import org.sonar.core.metric.db.MetricDto; import org.sonar.core.persistence.DbSession; import org.sonar.core.persistence.MyBatis; import org.sonar.server.computation.ComputationContext; +import org.sonar.server.computation.batch.BatchReportReader; import org.sonar.server.computation.component.DbComponentsRefCache; import org.sonar.server.db.DbClient; -import java.util.List; - /** * Persist duplications into */ diff --git a/server/sonar-server/src/main/java/org/sonar/server/computation/step/PersistEventsStep.java b/server/sonar-server/src/main/java/org/sonar/server/computation/step/PersistEventsStep.java index d45e5c80c28..1c7e7229b8f 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/computation/step/PersistEventsStep.java +++ b/server/sonar-server/src/main/java/org/sonar/server/computation/step/PersistEventsStep.java @@ -20,19 +20,18 @@ package org.sonar.server.computation.step; +import java.util.List; import org.sonar.api.utils.System2; import org.sonar.batch.protocol.Constants; import org.sonar.batch.protocol.output.BatchReport; -import org.sonar.batch.protocol.output.BatchReportReader; import org.sonar.core.event.EventDto; import org.sonar.core.persistence.DbSession; import org.sonar.core.persistence.MyBatis; import org.sonar.server.computation.ComputationContext; +import org.sonar.server.computation.batch.BatchReportReader; import org.sonar.server.computation.component.DbComponentsRefCache; import org.sonar.server.db.DbClient; -import java.util.List; - public class PersistEventsStep implements ComputationStep { private final DbClient dbClient; diff --git a/server/sonar-server/src/main/java/org/sonar/server/computation/step/PersistFileSourcesStep.java b/server/sonar-server/src/main/java/org/sonar/server/computation/step/PersistFileSourcesStep.java index c48d8c38182..52051b14e79 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/computation/step/PersistFileSourcesStep.java +++ b/server/sonar-server/src/main/java/org/sonar/server/computation/step/PersistFileSourcesStep.java @@ -21,6 +21,13 @@ package org.sonar.server.computation.step; import com.google.common.collect.ImmutableMap; +import java.io.File; +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; import org.apache.commons.codec.digest.DigestUtils; import org.apache.commons.io.FileUtils; import org.apache.commons.io.IOUtils; @@ -30,12 +37,12 @@ import org.apache.ibatis.session.ResultHandler; import org.sonar.api.utils.System2; import org.sonar.batch.protocol.Constants; import org.sonar.batch.protocol.output.BatchReport; -import org.sonar.batch.protocol.output.BatchReportReader; import org.sonar.core.persistence.DbSession; import org.sonar.core.persistence.MyBatis; import org.sonar.core.source.db.FileSourceDto; import org.sonar.core.source.db.FileSourceDto.Type; import org.sonar.server.computation.ComputationContext; +import org.sonar.server.computation.batch.BatchReportReader; import org.sonar.server.computation.component.DbComponentsRefCache; import org.sonar.server.computation.source.ComputeFileSourceData; import org.sonar.server.computation.source.CoverageLineReader; @@ -48,14 +55,6 @@ import org.sonar.server.computation.source.SymbolsLineReader; import org.sonar.server.db.DbClient; import org.sonar.server.source.db.FileSourceDb; -import java.io.File; -import java.io.IOException; -import java.nio.charset.StandardCharsets; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; - public class PersistFileSourcesStep implements ComputationStep { private final DbClient dbClient; diff --git a/server/sonar-server/src/main/java/org/sonar/server/computation/step/PersistMeasuresStep.java b/server/sonar-server/src/main/java/org/sonar/server/computation/step/PersistMeasuresStep.java index f0c46d470ee..cb83e6e2ec2 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/computation/step/PersistMeasuresStep.java +++ b/server/sonar-server/src/main/java/org/sonar/server/computation/step/PersistMeasuresStep.java @@ -21,22 +21,20 @@ package org.sonar.server.computation.step; import com.google.common.annotations.VisibleForTesting; +import java.util.List; +import javax.annotation.CheckForNull; import org.sonar.api.measures.CoreMetrics; import org.sonar.api.rule.RuleKey; import org.sonar.batch.protocol.output.BatchReport; -import org.sonar.batch.protocol.output.BatchReportReader; import org.sonar.core.measure.db.MeasureDto; import org.sonar.core.persistence.DbSession; import org.sonar.server.computation.ComputationContext; +import org.sonar.server.computation.batch.BatchReportReader; import org.sonar.server.computation.component.DbComponentsRefCache; import org.sonar.server.computation.issue.RuleCache; import org.sonar.server.computation.measure.MetricCache; import org.sonar.server.db.DbClient; -import javax.annotation.CheckForNull; - -import java.util.List; - import static com.google.common.collect.Lists.newArrayList; public class PersistMeasuresStep implements ComputationStep { diff --git a/server/sonar-server/src/main/java/org/sonar/server/computation/step/PersistNumberOfDaysSinceLastCommitStep.java b/server/sonar-server/src/main/java/org/sonar/server/computation/step/PersistNumberOfDaysSinceLastCommitStep.java index b36ba0347c4..6f3ca621fc2 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/computation/step/PersistNumberOfDaysSinceLastCommitStep.java +++ b/server/sonar-server/src/main/java/org/sonar/server/computation/step/PersistNumberOfDaysSinceLastCommitStep.java @@ -20,24 +20,22 @@ package org.sonar.server.computation.step; +import java.util.Date; +import javax.annotation.CheckForNull; +import javax.annotation.Nullable; import org.sonar.api.measures.CoreMetrics; import org.sonar.api.utils.System2; import org.sonar.batch.protocol.output.BatchReport; -import org.sonar.batch.protocol.output.BatchReportReader; import org.sonar.core.measure.db.MeasureDto; import org.sonar.core.persistence.DbSession; import org.sonar.core.persistence.MyBatis; import org.sonar.server.computation.ComputationContext; +import org.sonar.server.computation.batch.BatchReportReader; import org.sonar.server.computation.component.DbComponentsRefCache; import org.sonar.server.computation.measure.MetricCache; import org.sonar.server.db.DbClient; import org.sonar.server.source.index.SourceLineIndex; -import javax.annotation.CheckForNull; -import javax.annotation.Nullable; - -import java.util.Date; - import static com.google.common.base.Objects.firstNonNull; import static com.google.common.base.Preconditions.checkState; diff --git a/server/sonar-server/src/main/java/org/sonar/server/computation/step/PersistProjectLinksStep.java b/server/sonar-server/src/main/java/org/sonar/server/computation/step/PersistProjectLinksStep.java index 9a2bf486dec..c56388b1a2d 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/computation/step/PersistProjectLinksStep.java +++ b/server/sonar-server/src/main/java/org/sonar/server/computation/step/PersistProjectLinksStep.java @@ -23,24 +23,22 @@ package org.sonar.server.computation.step; import com.google.common.base.Predicate; import com.google.common.collect.ImmutableMap; import com.google.common.collect.Iterables; +import java.util.List; +import java.util.Locale; +import java.util.Map; +import java.util.Set; +import javax.annotation.Nullable; import org.sonar.api.i18n.I18n; import org.sonar.batch.protocol.Constants; import org.sonar.batch.protocol.output.BatchReport; -import org.sonar.batch.protocol.output.BatchReportReader; import org.sonar.core.component.ComponentLinkDto; import org.sonar.core.persistence.DbSession; import org.sonar.core.persistence.MyBatis; import org.sonar.server.computation.ComputationContext; +import org.sonar.server.computation.batch.BatchReportReader; import org.sonar.server.computation.component.DbComponentsRefCache; import org.sonar.server.db.DbClient; -import javax.annotation.Nullable; - -import java.util.List; -import java.util.Locale; -import java.util.Map; -import java.util.Set; - import static com.google.common.collect.Sets.newHashSet; /** diff --git a/server/sonar-server/src/main/java/org/sonar/server/computation/step/PersistTestsStep.java b/server/sonar-server/src/main/java/org/sonar/server/computation/step/PersistTestsStep.java index 282076d0b6f..693136d682f 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/computation/step/PersistTestsStep.java +++ b/server/sonar-server/src/main/java/org/sonar/server/computation/step/PersistTestsStep.java @@ -26,6 +26,14 @@ import com.google.common.collect.HashBasedTable; import com.google.common.collect.ImmutableMap; import com.google.common.collect.Multimap; import com.google.common.collect.Table; +import java.io.File; +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; import org.apache.ibatis.session.ResultContext; import org.apache.ibatis.session.ResultHandler; import org.sonar.api.utils.System2; @@ -33,12 +41,12 @@ import org.sonar.api.utils.internal.Uuids; import org.sonar.api.utils.log.Logger; import org.sonar.api.utils.log.Loggers; import org.sonar.batch.protocol.output.BatchReport; -import org.sonar.batch.protocol.output.BatchReportReader; import org.sonar.core.persistence.DbSession; import org.sonar.core.persistence.MyBatis; import org.sonar.core.source.db.FileSourceDto; import org.sonar.core.source.db.FileSourceDto.Type; import org.sonar.server.computation.ComputationContext; +import org.sonar.server.computation.batch.BatchReportReader; import org.sonar.server.computation.component.Component; import org.sonar.server.computation.component.DbComponentsRefCache; import org.sonar.server.computation.component.DepthTraversalTypeAwareVisitor; @@ -47,15 +55,6 @@ import org.sonar.server.db.DbClient; import org.sonar.server.source.db.FileSourceDb; import org.sonar.server.source.db.FileSourceDb.Test.TestStatus; -import java.io.File; -import java.util.ArrayList; -import java.util.Collection; -import java.util.HashMap; -import java.util.HashSet; -import java.util.List; -import java.util.Map; -import java.util.Set; - public class PersistTestsStep implements ComputationStep { private static final Logger LOG = Loggers.get(PersistTestsStep.class); diff --git a/server/sonar-server/src/main/java/org/sonar/server/computation/step/PopulateComponentsUuidAndKeyStep.java b/server/sonar-server/src/main/java/org/sonar/server/computation/step/PopulateComponentsUuidAndKeyStep.java index 9f7203905b8..4249a7097d7 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/computation/step/PopulateComponentsUuidAndKeyStep.java +++ b/server/sonar-server/src/main/java/org/sonar/server/computation/step/PopulateComponentsUuidAndKeyStep.java @@ -26,11 +26,11 @@ import java.util.Map; import javax.annotation.Nullable; import org.sonar.api.utils.internal.Uuids; import org.sonar.batch.protocol.output.BatchReport; -import org.sonar.batch.protocol.output.BatchReportReader; import org.sonar.core.component.ComponentDto; import org.sonar.core.component.ComponentKeys; import org.sonar.core.persistence.DbSession; import org.sonar.server.computation.ComputationContext; +import org.sonar.server.computation.batch.BatchReportReader; import org.sonar.server.computation.component.Component; import org.sonar.server.computation.component.ComponentImpl; import org.sonar.server.db.DbClient; diff --git a/server/sonar-server/src/main/java/org/sonar/server/computation/step/ValidateProjectStep.java b/server/sonar-server/src/main/java/org/sonar/server/computation/step/ValidateProjectStep.java index 92409fc2acf..06cee079db8 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/computation/step/ValidateProjectStep.java +++ b/server/sonar-server/src/main/java/org/sonar/server/computation/step/ValidateProjectStep.java @@ -31,12 +31,12 @@ import javax.annotation.Nonnull; import org.sonar.api.CoreProperties; import org.sonar.api.config.Settings; import org.sonar.batch.protocol.output.BatchReport; -import org.sonar.batch.protocol.output.BatchReportReader; import org.sonar.core.component.ComponentDto; import org.sonar.core.component.ComponentKeys; import org.sonar.core.persistence.DbSession; import org.sonar.server.component.db.ComponentDao; import org.sonar.server.computation.ComputationContext; +import org.sonar.server.computation.batch.BatchReportReader; import org.sonar.server.computation.component.Component; import org.sonar.server.computation.component.DepthTraversalTypeAwareVisitor; import org.sonar.server.db.DbClient; diff --git a/server/sonar-server/src/test/java/org/sonar/server/computation/ComputationServiceTest.java b/server/sonar-server/src/test/java/org/sonar/server/computation/ComputationServiceTest.java index c1efb61f6fc..6e0c2781ba8 100644 --- a/server/sonar-server/src/test/java/org/sonar/server/computation/ComputationServiceTest.java +++ b/server/sonar-server/src/test/java/org/sonar/server/computation/ComputationServiceTest.java @@ -89,7 +89,7 @@ public class ComputationServiceTest { public void setUp() { dbTester.truncateTables(); DbClient dbClient = new DbClient(dbTester.database(), dbTester.myBatis(), new ComponentDao(), new SnapshotDao(system)); - sut = new ComputationService(dbClient, steps, activityService, settingsFactory, tempFolder, system, mock(LanguageRepository.class)); + sut = new ComputationService(dbClient, steps, activityService, tempFolder, system, mock(LanguageRepository.class)); } @Test diff --git a/server/sonar-server/src/test/java/org/sonar/server/computation/batch/BatchReportReaderRule.java b/server/sonar-server/src/test/java/org/sonar/server/computation/batch/BatchReportReaderRule.java new file mode 100644 index 00000000000..4ca2c961e0c --- /dev/null +++ b/server/sonar-server/src/test/java/org/sonar/server/computation/batch/BatchReportReaderRule.java @@ -0,0 +1,216 @@ +/* + * SonarQube, open source software quality management tool. + * Copyright (C) 2008-2014 SonarSource + * mailto:contact AT sonarsource DOT com + * + * SonarQube is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * SonarQube is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ +package org.sonar.server.computation.batch; + +import java.io.File; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import javax.annotation.Nullable; +import org.junit.rules.TestRule; +import org.junit.runner.Description; +import org.junit.runners.model.Statement; +import org.sonar.batch.protocol.output.BatchReport; + +public class BatchReportReaderRule implements TestRule, BatchReportReader { + private BatchReport.Metadata metadata; + private Map> measures = new HashMap<>(); + private Map changesets = new HashMap<>(); + private Map components = new HashMap<>(); + private Map> issues = new HashMap<>(); + private Map deletedIssues = new HashMap<>(); + private Map> duplications = new HashMap<>(); + private Map> symbols = new HashMap<>(); + private Map syntaxHighlightings = new HashMap<>(); + private Map coverages = new HashMap<>(); + private Map fileSources = new HashMap<>(); + private Map tests = new HashMap<>(); + private Map coverageDetails = new HashMap<>(); + + @Override + public Statement apply(final Statement statement, Description description) { + return new Statement() { + @Override + public void evaluate() throws Throwable { + try { + statement.evaluate(); + } + finally { + clear(); + } + } + }; + } + + private void clear() { + this.metadata = null; + this.measures.clear(); + this.changesets.clear(); + this.components.clear(); + this.issues.clear(); + this.deletedIssues.clear(); + this.duplications.clear(); + this.symbols.clear(); + this.syntaxHighlightings.clear(); + this.coverages.clear(); + this.fileSources.clear(); + this.tests.clear(); + this.coverageDetails.clear(); + } + + @Override + public BatchReport.Metadata readMetadata() { + if (metadata == null) { + throw new IllegalStateException("Metadata is missing"); + } + return metadata; + } + + public void setMetadata(BatchReport.Metadata metadata) { + this.metadata = metadata; + } + + @Override + public List readComponentMeasures(int componentRef) { + return measures.get(componentRef); + } + + public void putMeasures(int componentRef, List measures) { + this.measures.put(componentRef, measures); + } + + @Override + public BatchReport.Changesets readChangesets(int componentRef) { + return changesets.get(componentRef); + } + + public void putChangesets(BatchReport.Changesets changesets) { + this.changesets.put(changesets.getComponentRef(), changesets); + } + + @Override + public BatchReport.Component readComponent(int componentRef) { + return components.get(componentRef); + } + + public void putComponent(BatchReport.Component component) { + this.components.put(component.getRef(), component); + } + + @Override + public List readComponentIssues(int componentRef) { + return nonNull(issues.get(componentRef)); + } + + public void putIssues(int componentRef, List issue) { + this.issues.put(componentRef, issue); + } + + @Override + public BatchReport.Issues readDeletedComponentIssues(int deletedComponentRef) { + BatchReport.Issues issues = this.deletedIssues.get(deletedComponentRef); + if (issues == null) { + throw new IllegalStateException("Unable to issues for deleted component #" + deletedComponentRef); + } + return issues; + } + + public void putDeletedIssues(int componentRef, BatchReport.Issues issues) { + this.deletedIssues.put(componentRef, issues); + } + + @Override + public List readComponentDuplications(int componentRef) { + return nonNull(this.duplications.get(componentRef)); + } + + public void putDuplications(int componentRef, List duplications) { + this.duplications.put(componentRef, duplications); + } + + @Override + public List readComponentSymbols(int componentRef) { + return nonNull(this.symbols.get(componentRef)); + } + + private static List nonNull(@Nullable List symbols) { + return symbols == null ? Collections.emptyList() : symbols; + } + + public void putSymbols(int componentRef, List symbols) { + this.symbols.put(componentRef, symbols); + } + + @Override + public boolean hasSyntaxHighlighting(int componentRef) { + File file = syntaxHighlightings.get(componentRef); + return file != null && file.exists(); + } + + @Override + public File readComponentSyntaxHighlighting(int fileRef) { + return syntaxHighlightings.get(fileRef); + } + + public void putSyntaxHighlighting(int fileRef, File file) { + this.syntaxHighlightings.put(fileRef, file); + } + + @Override + public File readComponentCoverage(int fileRef) { + return coverages.get(fileRef); + } + + public void putCoverage(int fileRef, File file) { + this.coverages.put(fileRef, file); + } + + @Override + public File readFileSource(int fileRef) { + File file = fileSources.get(fileRef); + if (file == null) { + throw new IllegalStateException("Unable to find source for file #" + fileRef + ". File does not exist: " + file); + } + return file; + } + + public void putFileSoure(int fileRef, File file) { + this.fileSources.put(fileRef, file); + } + + @Override + public File readTests(int testFileRef) { + return tests.get(testFileRef); + } + + public void putTests(int testFileRed, File file) { + this.tests.put(testFileRed, file); + } + + @Override + public File readCoverageDetails(int testFileRef) { + return coverageDetails.get(testFileRef); + } + + public void putCoverageDetails(int testFileRef, File file) { + this.coverageDetails.put(testFileRef, file); + } +} diff --git a/server/sonar-server/src/test/java/org/sonar/server/computation/issue/SourceLinesCacheTest.java b/server/sonar-server/src/test/java/org/sonar/server/computation/issue/SourceLinesCacheTest.java index 84074a7b032..4638933135b 100644 --- a/server/sonar-server/src/test/java/org/sonar/server/computation/issue/SourceLinesCacheTest.java +++ b/server/sonar-server/src/test/java/org/sonar/server/computation/issue/SourceLinesCacheTest.java @@ -19,25 +19,21 @@ */ package org.sonar.server.computation.issue; +import java.util.Date; import org.junit.Before; import org.junit.ClassRule; import org.junit.Rule; import org.junit.Test; import org.junit.experimental.categories.Category; -import org.junit.rules.TemporaryFolder; import org.sonar.api.config.Settings; import org.sonar.batch.protocol.output.BatchReport; -import org.sonar.batch.protocol.output.BatchReportReader; -import org.sonar.batch.protocol.output.BatchReportWriter; +import org.sonar.server.computation.batch.BatchReportReaderRule; import org.sonar.server.es.EsTester; import org.sonar.server.source.index.SourceLineDoc; import org.sonar.server.source.index.SourceLineIndex; import org.sonar.server.source.index.SourceLineIndexDefinition; import org.sonar.test.DbTests; -import java.io.File; -import java.util.Date; - import static org.assertj.core.api.Assertions.assertThat; @Category(DbTests.class) @@ -46,22 +42,19 @@ public class SourceLinesCacheTest { @ClassRule public static EsTester esTester = new EsTester().addDefinitions(new SourceLineIndexDefinition(new Settings())); @Rule - public TemporaryFolder temp = new TemporaryFolder(); + public BatchReportReaderRule reportReader = new BatchReportReaderRule(); - File dir; SourceLinesCache sut; @Before public void setUp() throws Exception { esTester.truncateIndices(); - dir = temp.newFolder(); sut = new SourceLinesCache(new SourceLineIndex(esTester.client())); } @Test public void line_author_from_report() { - BatchReportWriter reportWriter = new BatchReportWriter(dir); - reportWriter.writeComponentChangesets(BatchReport.Changesets.newBuilder() + reportReader.putChangesets(BatchReport.Changesets.newBuilder() .setComponentRef(123_456_789) .addChangeset(newChangeset("charb", "123-456-789", 123_456_789L)) .addChangeset(newChangeset("wolinski", "987-654-321", 987_654_321L)) @@ -70,7 +63,7 @@ public class SourceLinesCacheTest { .addChangesetIndexByLine(1) .build()); - sut.init("ANY_UUID", 123_456_789, new BatchReportReader(dir)); + sut.init("ANY_UUID", 123_456_789, reportReader); assertThat(sut.lineAuthor(1)).isEqualTo("charb"); assertThat(sut.lineAuthor(2)).isEqualTo("charb"); @@ -90,7 +83,7 @@ public class SourceLinesCacheTest { newSourceLine("cabu", "123-456-789", 123_456_789, 5) ); - sut.init("DEFAULT_UUID", 123, new BatchReportReader(dir)); + sut.init("DEFAULT_UUID", 123, reportReader); assertThat(sut.lineAuthor(1)).isEqualTo("cabu"); assertThat(sut.lineAuthor(2)).isEqualTo("cabu"); @@ -102,7 +95,7 @@ public class SourceLinesCacheTest { @Test(expected = IllegalStateException.class) public void fail_when_component_ref_is_not_filled() { - sut.init("ANY_UUID", null, new BatchReportReader(dir)); + sut.init("ANY_UUID", null, reportReader); sut.lineAuthor(0); } diff --git a/server/sonar-server/src/test/java/org/sonar/server/computation/step/ApplyPermissionsStepTest.java b/server/sonar-server/src/test/java/org/sonar/server/computation/step/ApplyPermissionsStepTest.java index 8aa76fad30f..3878596d250 100644 --- a/server/sonar-server/src/test/java/org/sonar/server/computation/step/ApplyPermissionsStepTest.java +++ b/server/sonar-server/src/test/java/org/sonar/server/computation/step/ApplyPermissionsStepTest.java @@ -19,8 +19,6 @@ */ package org.sonar.server.computation.step; -import java.io.File; -import java.io.IOException; import java.util.List; import java.util.Map; import org.elasticsearch.search.SearchHit; @@ -30,14 +28,11 @@ import org.junit.ClassRule; import org.junit.Rule; import org.junit.Test; import org.junit.experimental.categories.Category; -import org.junit.rules.TemporaryFolder; import org.sonar.api.config.Settings; import org.sonar.api.security.DefaultGroups; import org.sonar.api.utils.System2; import org.sonar.api.web.UserRole; import org.sonar.batch.protocol.output.BatchReport; -import org.sonar.batch.protocol.output.BatchReportReader; -import org.sonar.batch.protocol.output.BatchReportWriter; import org.sonar.core.component.ComponentDto; import org.sonar.core.permission.PermissionFacade; import org.sonar.core.permission.PermissionTemplateDao; @@ -50,6 +45,7 @@ import org.sonar.core.user.RoleDao; import org.sonar.server.component.ComponentTesting; import org.sonar.server.component.db.ComponentDao; import org.sonar.server.computation.ComputationContext; +import org.sonar.server.computation.batch.BatchReportReaderRule; import org.sonar.server.computation.component.Component; import org.sonar.server.computation.component.ComponentTreeBuilders; import org.sonar.server.computation.component.DbComponentsRefCache; @@ -68,14 +64,13 @@ public class ApplyPermissionsStepTest extends BaseStepTest { private static final String PROJECT_KEY = "PROJECT_KEY"; private static final String PROJECT_UUID = "PROJECT_UUID"; - @Rule - public TemporaryFolder temp = new TemporaryFolder(); @ClassRule public static EsTester esTester = new EsTester().addDefinitions(new IssueIndexDefinition(new Settings())); - @ClassRule public static DbTester dbTester = new DbTester(); + @Rule + public BatchReportReaderRule reportReader = new BatchReportReaderRule(); DbSession dbSession; @@ -107,6 +102,8 @@ public class ApplyPermissionsStepTest extends BaseStepTest { step = new ApplyPermissionsStep(dbClient, dbComponentsRefCache, issueAuthorizationIndexer, new PermissionFacade(roleDao, null, new ResourceDao(dbTester.myBatis(), System2.INSTANCE), permissionTemplateDao, settings)); + + reportReader.setMetadata(BatchReport.Metadata.newBuilder() .build()); } @After @@ -128,7 +125,7 @@ public class ApplyPermissionsStepTest extends BaseStepTest { dbComponentsRefCache.addComponent(1, new DbComponentsRefCache.DbComponent(projectDto.getId(), PROJECT_KEY, PROJECT_UUID)); Component project = new DumbComponent(Component.Type.PROJECT, 1, PROJECT_KEY, PROJECT_UUID); - step.execute(new ComputationContext(createDumbBatchReportReader(), null, null, null, ComponentTreeBuilders.from(project), null)); + step.execute(new ComputationContext(reportReader, null, null, null, ComponentTreeBuilders.from(project), null)); dbSession.commit(); assertThat(dbClient.componentDao().selectByKey(dbSession, PROJECT_KEY).getAuthorizationUpdatedAt()).isNotNull(); @@ -155,21 +152,13 @@ public class ApplyPermissionsStepTest extends BaseStepTest { dbComponentsRefCache.addComponent(1, new DbComponentsRefCache.DbComponent(projectDto.getId(), PROJECT_KEY, PROJECT_UUID)); Component project = new DumbComponent(Component.Type.PROJECT, 1, PROJECT_KEY, PROJECT_UUID); - step.execute(new ComputationContext(createDumbBatchReportReader(), null, null, null, ComponentTreeBuilders.from(project), null)); + step.execute(new ComputationContext(reportReader, null, null, null, ComponentTreeBuilders.from(project), null)); dbSession.commit(); // Check that authorization updated at has not been changed -> Nothing has been done assertThat(projectDto.getAuthorizationUpdatedAt()).isEqualTo(authorizationUpdatedAt); } - private BatchReportReader createDumbBatchReportReader() throws IOException { - File dir = temp.newFolder(); - BatchReportWriter writer = new BatchReportWriter(dir); - writer.writeMetadata(BatchReport.Metadata.newBuilder() - .build()); - return new BatchReportReader(dir); - } - @Override protected ComputationStep step() { return step; diff --git a/server/sonar-server/src/test/java/org/sonar/server/computation/step/IndexComponentsStepTest.java b/server/sonar-server/src/test/java/org/sonar/server/computation/step/IndexComponentsStepTest.java index 3eb6454c10a..58a94e0fa69 100644 --- a/server/sonar-server/src/test/java/org/sonar/server/computation/step/IndexComponentsStepTest.java +++ b/server/sonar-server/src/test/java/org/sonar/server/computation/step/IndexComponentsStepTest.java @@ -30,6 +30,7 @@ import org.sonar.batch.protocol.output.BatchReportWriter; import org.sonar.core.component.ComponentDto; import org.sonar.core.resource.ResourceIndexerDao; import org.sonar.server.computation.ComputationContext; +import org.sonar.server.computation.batch.FileBatchReportReader; import org.sonar.server.computation.component.DbComponentsRefCache; import org.sonar.server.computation.component.DbComponentsRefCache.DbComponent; import org.sonar.server.computation.component.ComponentTreeBuilders; @@ -67,7 +68,7 @@ public class IndexComponentsStepTest extends BaseStepTest { ComponentDto project = mock(ComponentDto.class); when(project.getId()).thenReturn(123L); - ComputationContext context = new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, new Settings(), mock(DbClient.class), ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), mock(LanguageRepository.class)); + ComputationContext context = new ComputationContext(new FileBatchReportReader(new BatchReportReader(reportDir)), PROJECT_KEY, new Settings(), mock(DbClient.class), ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), mock(LanguageRepository.class)); sut.execute(context); diff --git a/server/sonar-server/src/test/java/org/sonar/server/computation/step/IndexSourceLinesStepTest.java b/server/sonar-server/src/test/java/org/sonar/server/computation/step/IndexSourceLinesStepTest.java index f17618d51ef..24a746723c6 100644 --- a/server/sonar-server/src/test/java/org/sonar/server/computation/step/IndexSourceLinesStepTest.java +++ b/server/sonar-server/src/test/java/org/sonar/server/computation/step/IndexSourceLinesStepTest.java @@ -19,6 +19,7 @@ */ package org.sonar.server.computation.step; +import java.io.File; import java.sql.Connection; import java.util.List; import org.elasticsearch.search.SearchHit; @@ -33,8 +34,9 @@ import org.sonar.batch.protocol.output.BatchReportReader; import org.sonar.batch.protocol.output.BatchReportWriter; import org.sonar.core.persistence.DbTester; import org.sonar.server.computation.ComputationContext; -import org.sonar.server.computation.component.DbComponentsRefCache; +import org.sonar.server.computation.batch.FileBatchReportReader; import org.sonar.server.computation.component.ComponentTreeBuilders; +import org.sonar.server.computation.component.DbComponentsRefCache; import org.sonar.server.computation.component.DumbComponent; import org.sonar.server.computation.language.LanguageRepository; import org.sonar.server.db.DbClient; @@ -45,10 +47,6 @@ import org.sonar.server.source.index.SourceLineDoc; import org.sonar.server.source.index.SourceLineIndexDefinition; import org.sonar.server.source.index.SourceLineIndexer; -import java.io.File; -import java.sql.Connection; -import java.util.List; - import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.Mockito.mock; @@ -97,7 +95,7 @@ public class IndexSourceLinesStepTest extends BaseStepTest { .setRootComponentRef(1) .build()); - step().execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, new Settings(), dbClient, + step().execute(new ComputationContext(new FileBatchReportReader(new BatchReportReader(reportDir)), PROJECT_KEY, new Settings(), dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), mock(LanguageRepository.class))); List docs = esTester.getDocuments(SourceLineIndexDefinition.INDEX, SourceLineIndexDefinition.TYPE); diff --git a/server/sonar-server/src/test/java/org/sonar/server/computation/step/IndexTestsStepTest.java b/server/sonar-server/src/test/java/org/sonar/server/computation/step/IndexTestsStepTest.java index c36cf90f1a1..2d28cabfbea 100644 --- a/server/sonar-server/src/test/java/org/sonar/server/computation/step/IndexTestsStepTest.java +++ b/server/sonar-server/src/test/java/org/sonar/server/computation/step/IndexTestsStepTest.java @@ -35,6 +35,7 @@ import org.sonar.batch.protocol.output.BatchReportReader; import org.sonar.batch.protocol.output.BatchReportWriter; import org.sonar.core.persistence.DbTester; import org.sonar.server.computation.ComputationContext; +import org.sonar.server.computation.batch.FileBatchReportReader; import org.sonar.server.computation.component.ComponentTreeBuilders; import org.sonar.server.computation.component.DbComponentsRefCache; import org.sonar.server.computation.component.DumbComponent; @@ -95,7 +96,7 @@ public class IndexTestsStepTest extends BaseStepTest { .setRootComponentRef(1) .build()); - step().execute(new ComputationContext(new BatchReportReader(reportDir), "PROJECT_KEY", new Settings(), dbClient, + step().execute(new ComputationContext(new FileBatchReportReader(new BatchReportReader(reportDir)), "PROJECT_KEY", new Settings(), dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), mock(LanguageRepository.class))); List docs = esTester.getDocuments(TestIndexDefinition.INDEX, TestIndexDefinition.TYPE); diff --git a/server/sonar-server/src/test/java/org/sonar/server/computation/step/ParseReportStepTest.java b/server/sonar-server/src/test/java/org/sonar/server/computation/step/ParseReportStepTest.java index 220de7f9f63..f4787434a23 100644 --- a/server/sonar-server/src/test/java/org/sonar/server/computation/step/ParseReportStepTest.java +++ b/server/sonar-server/src/test/java/org/sonar/server/computation/step/ParseReportStepTest.java @@ -19,6 +19,10 @@ */ package org.sonar.server.computation.step; +import java.io.IOException; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; import org.junit.ClassRule; import org.junit.Rule; import org.junit.Test; @@ -26,10 +30,9 @@ import org.junit.rules.TemporaryFolder; import org.sonar.api.config.Settings; import org.sonar.batch.protocol.Constants; import org.sonar.batch.protocol.output.BatchReport; -import org.sonar.batch.protocol.output.BatchReportReader; -import org.sonar.batch.protocol.output.BatchReportWriter; import org.sonar.core.persistence.DbTester; import org.sonar.server.computation.ComputationContext; +import org.sonar.server.computation.batch.BatchReportReaderRule; import org.sonar.server.computation.component.Component; import org.sonar.server.computation.component.ComponentTreeBuilders; import org.sonar.server.computation.component.DumbComponent; @@ -37,12 +40,6 @@ import org.sonar.server.computation.issue.IssueComputation; import org.sonar.server.computation.language.LanguageRepository; import org.sonar.server.db.DbClient; -import java.io.File; -import java.io.IOException; -import java.util.Arrays; -import java.util.Collections; -import java.util.List; - import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; @@ -57,6 +54,8 @@ public class ParseReportStepTest extends BaseStepTest { @Rule public TemporaryFolder temp = new TemporaryFolder(); + @Rule + public BatchReportReaderRule reportReader = new BatchReportReaderRule(); @ClassRule public static DbTester dbTester = new DbTester(); @@ -71,10 +70,11 @@ public class ParseReportStepTest extends BaseStepTest { new DumbComponent(Component.Type.FILE, 2, "FILE1_UUID", "PROJECT_KEY:file1"), new DumbComponent(Component.Type.FILE, 3, "FILE2_UUID", "PROJECT_KEY:file2")); - File reportDir = generateReport(); + generateReport(); + + ComputationContext context = new ComputationContext(reportReader, PROJECT_KEY, new Settings(), + mock(DbClient.class), ComponentTreeBuilders.from(root), mock(LanguageRepository.class)); - ComputationContext context = new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, new Settings(), - mock(DbClient.class), ComponentTreeBuilders.from(root), mock(LanguageRepository.class)); sut.execute(context); assertThat(context.getReportMetadata().getRootComponentRef()).isEqualTo(1); @@ -88,33 +88,34 @@ public class ParseReportStepTest extends BaseStepTest { verify(issueComputation).afterReportProcessing(); } - private File generateReport() throws IOException { - File dir = temp.newFolder(); + private void generateReport() throws IOException { // project and 2 files - BatchReportWriter writer = new BatchReportWriter(dir); - writer.writeMetadata(BatchReport.Metadata.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder() .setRootComponentRef(1) .setDeletedComponentsCount(1) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .addChildRef(2) .addChildRef(3) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(2) .setType(Constants.ComponentType.FILE) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(3) .setType(Constants.ComponentType.FILE) .build()); // deleted components - writer.writeDeletedComponentIssues(1, "DELETED_UUID", ISSUES_ON_DELETED_COMPONENT); - return dir; + BatchReport.Issues.Builder issuesBuilder = BatchReport.Issues.newBuilder(); + issuesBuilder.setComponentRef(1); + issuesBuilder.setComponentUuid("DELETED_UUID"); + issuesBuilder.addAllIssue(ISSUES_ON_DELETED_COMPONENT); + reportReader.putDeletedIssues(1, issuesBuilder.build()); } @Override diff --git a/server/sonar-server/src/test/java/org/sonar/server/computation/step/PersistComponentsStepTest.java b/server/sonar-server/src/test/java/org/sonar/server/computation/step/PersistComponentsStepTest.java index 415918e0986..be55b3c03e8 100644 --- a/server/sonar-server/src/test/java/org/sonar/server/computation/step/PersistComponentsStepTest.java +++ b/server/sonar-server/src/test/java/org/sonar/server/computation/step/PersistComponentsStepTest.java @@ -20,25 +20,22 @@ package org.sonar.server.computation.step; -import java.io.File; import org.junit.After; import org.junit.Before; import org.junit.ClassRule; import org.junit.Rule; import org.junit.Test; import org.junit.experimental.categories.Category; -import org.junit.rules.TemporaryFolder; import org.sonar.api.config.Settings; import org.sonar.batch.protocol.Constants; import org.sonar.batch.protocol.output.BatchReport; -import org.sonar.batch.protocol.output.BatchReportReader; -import org.sonar.batch.protocol.output.BatchReportWriter; import org.sonar.core.component.ComponentDto; import org.sonar.core.persistence.DbSession; import org.sonar.core.persistence.DbTester; import org.sonar.server.component.ComponentTesting; import org.sonar.server.component.db.ComponentDao; import org.sonar.server.computation.ComputationContext; +import org.sonar.server.computation.batch.BatchReportReaderRule; import org.sonar.server.computation.component.Component; import org.sonar.server.computation.component.ComponentTreeBuilders; import org.sonar.server.computation.component.DbComponentsRefCache; @@ -57,11 +54,8 @@ public class PersistComponentsStepTest extends BaseStepTest { @ClassRule public static DbTester dbTester = new DbTester(); - @Rule - public TemporaryFolder temp = new TemporaryFolder(); - - File reportDir; + public BatchReportReaderRule reportReader = new BatchReportReaderRule(); DbSession session; @@ -79,8 +73,6 @@ public class PersistComponentsStepTest extends BaseStepTest { session = dbTester.myBatis().openSession(false); dbClient = new DbClient(dbTester.database(), dbTester.myBatis(), new ComponentDao()); - reportDir = temp.newFolder(); - projectSettings = new Settings(); languageRepository = mock(LanguageRepository.class); dbComponentsRefCache = new DbComponentsRefCache(); @@ -99,13 +91,11 @@ public class PersistComponentsStepTest extends BaseStepTest { @Test public void persist_components() throws Exception { - File reportDir = temp.newFolder(); - BatchReportWriter writer = new BatchReportWriter(reportDir); - writer.writeMetadata(BatchReport.Metadata.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder() .setRootComponentRef(1) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .setKey(PROJECT_KEY) @@ -113,7 +103,7 @@ public class PersistComponentsStepTest extends BaseStepTest { .setDescription("Project description") .addChildRef(2) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(2) .setType(Constants.ComponentType.MODULE) .setKey("MODULE_KEY") @@ -122,13 +112,13 @@ public class PersistComponentsStepTest extends BaseStepTest { .setDescription("Module description") .addChildRef(3) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(3) .setType(Constants.ComponentType.DIRECTORY) .setPath("src/main/java/dir") .addChildRef(4) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(4) .setType(Constants.ComponentType.FILE) .setPath("src/main/java/dir/Foo.java") @@ -139,7 +129,7 @@ public class PersistComponentsStepTest extends BaseStepTest { new DumbComponent(Component.Type.MODULE, 2, "BCDE", "MODULE_KEY", new DumbComponent(Component.Type.DIRECTORY, 3, "CDEF", "MODULE_KEY:src/main/java/dir", new DumbComponent(Component.Type.FILE, 4, "DEFG", "MODULE_KEY:src/main/java/dir/Foo.java")))); - sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, + sut.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(root), languageRepository)); assertThat(dbTester.countRowsOfTable("projects")).isEqualTo(4); @@ -205,26 +195,24 @@ public class PersistComponentsStepTest extends BaseStepTest { @Test public void persist_file_directly_attached_on_root_directory() throws Exception { - File reportDir = temp.newFolder(); - BatchReportWriter writer = new BatchReportWriter(reportDir); - writer.writeMetadata(BatchReport.Metadata.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder() .setRootComponentRef(1) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .setKey(PROJECT_KEY) .setName("Project") .addChildRef(2) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(2) .setType(Constants.ComponentType.DIRECTORY) .setPath("/") .addChildRef(3) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(3) .setType(Constants.ComponentType.FILE) .setPath("pom.xml") @@ -233,7 +221,7 @@ public class PersistComponentsStepTest extends BaseStepTest { DumbComponent root = new DumbComponent(Component.Type.PROJECT, 1, "ABCD", PROJECT_KEY, new DumbComponent(Component.Type.DIRECTORY, 2, "CDEF", PROJECT_KEY + ":/", new DumbComponent(Component.Type.FILE, 3, "DEFG", PROJECT_KEY + ":pom.xml"))); - sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, + sut.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(root), languageRepository)); ComponentDto directory = dbClient.componentDao().selectNullableByKey(session, "PROJECT_KEY:/"); @@ -249,26 +237,24 @@ public class PersistComponentsStepTest extends BaseStepTest { @Test public void persist_unit_test() throws Exception { - File reportDir = temp.newFolder(); - BatchReportWriter writer = new BatchReportWriter(reportDir); - writer.writeMetadata(BatchReport.Metadata.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder() .setRootComponentRef(1) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .setKey(PROJECT_KEY) .setName("Project") .addChildRef(2) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(2) .setType(Constants.ComponentType.DIRECTORY) .setPath("src/test/java/dir") .addChildRef(3) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(3) .setType(Constants.ComponentType.FILE) .setPath("src/test/java/dir/FooTest.java") @@ -278,7 +264,7 @@ public class PersistComponentsStepTest extends BaseStepTest { DumbComponent root = new DumbComponent(Component.Type.PROJECT, 1, "ABCD", PROJECT_KEY, new DumbComponent(Component.Type.DIRECTORY, 2, "CDEF", PROJECT_KEY + ":src/test/java/dir", new DumbComponent(Component.Type.FILE, 3, "DEFG", PROJECT_KEY + ":src/test/java/dir/FooTest.java"))); - sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, + sut.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(root), languageRepository)); ComponentDto file = dbClient.componentDao().selectNullableByKey(session, PROJECT_KEY + ":src/test/java/dir/FooTest.java"); @@ -298,33 +284,31 @@ public class PersistComponentsStepTest extends BaseStepTest { dbClient.componentDao().insert(session, module); session.commit(); - File reportDir = temp.newFolder(); - BatchReportWriter writer = new BatchReportWriter(reportDir); - writer.writeMetadata(BatchReport.Metadata.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder() .setRootComponentRef(1) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .setKey(PROJECT_KEY) .setName("Project") .addChildRef(2) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(2) .setType(Constants.ComponentType.MODULE) .setKey("MODULE_KEY") .setName("Module") .addChildRef(3) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(3) .setType(Constants.ComponentType.DIRECTORY) .setPath("src/main/java/dir") .addChildRef(4) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(4) .setType(Constants.ComponentType.FILE) .setPath("src/main/java/dir/Foo.java") @@ -334,7 +318,7 @@ public class PersistComponentsStepTest extends BaseStepTest { new DumbComponent(Component.Type.MODULE, 2, "BCDE", "MODULE_KEY", new DumbComponent(Component.Type.DIRECTORY, 3, "CDEF", "MODULE_KEY:src/main/java/dir", new DumbComponent(Component.Type.FILE, 4, "DEFG", "MODULE_KEY:src/main/java/dir/Foo.java")))); - sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, + sut.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(root), languageRepository)); assertThat(dbTester.countRowsOfTable("projects")).isEqualTo(4); @@ -368,41 +352,39 @@ public class PersistComponentsStepTest extends BaseStepTest { @Test public void compute_parent_project_id() throws Exception { - File reportDir = temp.newFolder(); - BatchReportWriter writer = new BatchReportWriter(reportDir); - writer.writeMetadata(BatchReport.Metadata.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder() .setRootComponentRef(1) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .setKey(PROJECT_KEY) .setName("Project") .addChildRef(2) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(2) .setType(Constants.ComponentType.MODULE) .setKey("MODULE_KEY") .setName("Module") .addChildRef(3) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(3) .setType(Constants.ComponentType.MODULE) .setKey("SUB_MODULE_1_KEY") .setName("Sub Module 1") .addChildRef(4) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(4) .setType(Constants.ComponentType.MODULE) .setKey("SUB_MODULE_2_KEY") .setName("Sub Module 2") .addChildRef(5) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(5) .setType(Constants.ComponentType.DIRECTORY) .setPath("src/main/java/dir") @@ -413,7 +395,7 @@ public class PersistComponentsStepTest extends BaseStepTest { new DumbComponent(Component.Type.MODULE, 3, "CDEF", "SUB_MODULE_1_KEY", new DumbComponent(Component.Type.MODULE, 4, "DEFG", "SUB_MODULE_2_KEY", new DumbComponent(Component.Type.DIRECTORY, 5, "EFGH", "SUB_MODULE_2_KEY:src/main/java/dir"))))); - sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, + sut.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(root), languageRepository)); assertThat(dbTester.countRowsOfTable("projects")).isEqualTo(5); @@ -441,13 +423,11 @@ public class PersistComponentsStepTest extends BaseStepTest { @Test public void persist_multi_modules() throws Exception { - File reportDir = temp.newFolder(); - BatchReportWriter writer = new BatchReportWriter(reportDir); - writer.writeMetadata(BatchReport.Metadata.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder() .setRootComponentRef(1) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .setKey(PROJECT_KEY) @@ -455,20 +435,20 @@ public class PersistComponentsStepTest extends BaseStepTest { .addChildRef(2) .addChildRef(4) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(2) .setType(Constants.ComponentType.MODULE) .setKey("MODULE_A") .setName("Module A") .addChildRef(3) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(3) .setType(Constants.ComponentType.MODULE) .setKey("SUB_MODULE_A") .setName("Sub Module A") .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(4) .setType(Constants.ComponentType.MODULE) .setKey("MODULE_B") @@ -479,7 +459,7 @@ public class PersistComponentsStepTest extends BaseStepTest { new DumbComponent(Component.Type.MODULE, 2, "BCDE", "MODULE_A", new DumbComponent(Component.Type.MODULE, 3, "DEFG", "SUB_MODULE_A")), new DumbComponent(Component.Type.MODULE, 4, "CDEF", "MODULE_B")); - sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, + sut.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(root), languageRepository)); assertThat(dbTester.countRowsOfTable("projects")).isEqualTo(4); @@ -520,33 +500,31 @@ public class PersistComponentsStepTest extends BaseStepTest { dbClient.componentDao().insert(session, directory, file); session.commit(); - File reportDir = temp.newFolder(); - BatchReportWriter writer = new BatchReportWriter(reportDir); - writer.writeMetadata(BatchReport.Metadata.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder() .setRootComponentRef(1) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .setKey(PROJECT_KEY) .setName("Project") .addChildRef(2) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(2) .setType(Constants.ComponentType.MODULE) .setKey("MODULE_KEY") .setName("Module") .addChildRef(3) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(3) .setType(Constants.ComponentType.DIRECTORY) .setPath("src/main/java/dir") .addChildRef(4) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(4) .setType(Constants.ComponentType.FILE) .setPath("src/main/java/dir/Foo.java") @@ -556,7 +534,7 @@ public class PersistComponentsStepTest extends BaseStepTest { new DumbComponent(Component.Type.MODULE, 2, "BCDE", "MODULE_KEY", new DumbComponent(Component.Type.DIRECTORY, 3, "CDEF", "MODULE_KEY:src/main/java/dir", new DumbComponent(Component.Type.FILE, 4, "DEFG", "MODULE_KEY:src/main/java/dir/Foo.java")))); - sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, + sut.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(root), languageRepository)); assertThat(dbTester.countRowsOfTable("projects")).isEqualTo(4); @@ -610,20 +588,18 @@ public class PersistComponentsStepTest extends BaseStepTest { dbClient.componentDao().insert(session, module); session.commit(); - File reportDir = temp.newFolder(); - BatchReportWriter writer = new BatchReportWriter(reportDir); - writer.writeMetadata(BatchReport.Metadata.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder() .setRootComponentRef(1) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .setKey(PROJECT_KEY) .setName("New project name") .addChildRef(2) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(2) .setType(Constants.ComponentType.MODULE) .setKey("MODULE_KEY") @@ -633,7 +609,7 @@ public class PersistComponentsStepTest extends BaseStepTest { DumbComponent root = new DumbComponent(Component.Type.PROJECT, 1, "ABCD", PROJECT_KEY, new DumbComponent(Component.Type.MODULE, 2, "BCDE", "MODULE_KEY")); - sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, + sut.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(root), languageRepository)); ComponentDto projectReloaded = dbClient.componentDao().selectNullableByKey(session, PROJECT_KEY); @@ -651,13 +627,11 @@ public class PersistComponentsStepTest extends BaseStepTest { dbClient.componentDao().insert(session, module); session.commit(); - File reportDir = temp.newFolder(); - BatchReportWriter writer = new BatchReportWriter(reportDir); - writer.writeMetadata(BatchReport.Metadata.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder() .setRootComponentRef(1) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .setKey(PROJECT_KEY) @@ -665,7 +639,7 @@ public class PersistComponentsStepTest extends BaseStepTest { .setDescription("New project description") .addChildRef(2) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(2) .setType(Constants.ComponentType.MODULE) .setKey("MODULE_KEY") @@ -675,7 +649,7 @@ public class PersistComponentsStepTest extends BaseStepTest { DumbComponent root = new DumbComponent(Component.Type.PROJECT, 1, "ABCD", PROJECT_KEY, new DumbComponent(Component.Type.MODULE, 2, "BCDE", "MODULE_KEY")); - sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, + sut.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(root), languageRepository)); ComponentDto projectReloaded = dbClient.componentDao().selectNullableByKey(session, PROJECT_KEY); @@ -693,20 +667,18 @@ public class PersistComponentsStepTest extends BaseStepTest { dbClient.componentDao().insert(session, module); session.commit(); - File reportDir = temp.newFolder(); - BatchReportWriter writer = new BatchReportWriter(reportDir); - writer.writeMetadata(BatchReport.Metadata.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder() .setRootComponentRef(1) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .setKey(PROJECT_KEY) .setName("Project") .addChildRef(2) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(2) .setType(Constants.ComponentType.MODULE) .setKey("MODULE_KEY") @@ -716,7 +688,7 @@ public class PersistComponentsStepTest extends BaseStepTest { DumbComponent root = new DumbComponent(Component.Type.PROJECT, 1, "ABCD", PROJECT_KEY, new DumbComponent(Component.Type.MODULE, 2, "BCDE", "MODULE_KEY")); - sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, + sut.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(root), languageRepository)); ComponentDto moduleReloaded = dbClient.componentDao().selectNullableByKey(session, "MODULE_KEY"); @@ -735,20 +707,18 @@ public class PersistComponentsStepTest extends BaseStepTest { dbClient.componentDao().insert(session, directory, file); session.commit(); - File reportDir = temp.newFolder(); - BatchReportWriter writer = new BatchReportWriter(reportDir); - writer.writeMetadata(BatchReport.Metadata.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder() .setRootComponentRef(1) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .setKey(PROJECT_KEY) .setName("Project") .addChildRef(2) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(2) .setType(Constants.ComponentType.MODULE) .setKey("MODULE_A") @@ -756,20 +726,20 @@ public class PersistComponentsStepTest extends BaseStepTest { .addChildRef(3) .build()); // Module B is now a sub module of module A - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(3) .setType(Constants.ComponentType.MODULE) .setKey("MODULE_B") .setName("Module B") .addChildRef(4) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(4) .setType(Constants.ComponentType.DIRECTORY) .setPath("src/main/java/dir") .addChildRef(5) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(5) .setType(Constants.ComponentType.FILE) .setPath("src/main/java/dir/Foo.java") @@ -780,7 +750,7 @@ public class PersistComponentsStepTest extends BaseStepTest { new DumbComponent(Component.Type.MODULE, 3, "BCDE", "MODULE_B", new DumbComponent(Component.Type.DIRECTORY, 4, "CDEF", "MODULE_B:src/main/java/dir", new DumbComponent(Component.Type.FILE, 5, "DEFG", "MODULE_B:src/main/java/dir/Foo.java"))))); - sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, + sut.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(root), languageRepository)); assertThat(dbTester.countRowsOfTable("projects")).isEqualTo(5); diff --git a/server/sonar-server/src/test/java/org/sonar/server/computation/step/PersistDuplicationsStepTest.java b/server/sonar-server/src/test/java/org/sonar/server/computation/step/PersistDuplicationsStepTest.java index 67c9dfc2781..539d3a994a2 100644 --- a/server/sonar-server/src/test/java/org/sonar/server/computation/step/PersistDuplicationsStepTest.java +++ b/server/sonar-server/src/test/java/org/sonar/server/computation/step/PersistDuplicationsStepTest.java @@ -20,37 +20,33 @@ package org.sonar.server.computation.step; +import java.util.Map; import org.junit.After; import org.junit.Before; import org.junit.ClassRule; import org.junit.Rule; import org.junit.Test; import org.junit.experimental.categories.Category; -import org.junit.rules.TemporaryFolder; import org.sonar.api.config.Settings; import org.sonar.api.measures.CoreMetrics; import org.sonar.batch.protocol.Constants; import org.sonar.batch.protocol.output.BatchReport; import org.sonar.batch.protocol.output.BatchReport.Range; -import org.sonar.batch.protocol.output.BatchReportReader; -import org.sonar.batch.protocol.output.BatchReportWriter; import org.sonar.core.metric.db.MetricDto; import org.sonar.core.persistence.DbSession; import org.sonar.core.persistence.DbTester; import org.sonar.server.computation.ComputationContext; +import org.sonar.server.computation.batch.BatchReportReaderRule; import org.sonar.server.computation.component.ComponentTreeBuilders; -import org.sonar.server.computation.component.DumbComponent; -import org.sonar.server.computation.language.LanguageRepository; import org.sonar.server.computation.component.DbComponentsRefCache; import org.sonar.server.computation.component.DbComponentsRefCache.DbComponent; +import org.sonar.server.computation.component.DumbComponent; +import org.sonar.server.computation.language.LanguageRepository; import org.sonar.server.db.DbClient; import org.sonar.server.measure.persistence.MeasureDao; import org.sonar.server.metric.persistence.MetricDao; import org.sonar.test.DbTests; -import java.io.File; -import java.util.Map; - import static com.google.common.collect.Lists.newArrayList; import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.Mockito.mock; @@ -60,14 +56,12 @@ public class PersistDuplicationsStepTest extends BaseStepTest { private static final String PROJECT_KEY = "PROJECT_KEY"; - @Rule - public TemporaryFolder temp = new TemporaryFolder(); - - File reportDir; - @ClassRule public static DbTester dbTester = new DbTester(); + @Rule + public BatchReportReaderRule reportReader = new BatchReportReaderRule(); + DbSession session; DbClient dbClient; @@ -85,8 +79,6 @@ public class PersistDuplicationsStepTest extends BaseStepTest { session = dbTester.myBatis().openSession(false); dbClient = new DbClient(dbTester.database(), dbTester.myBatis(), new MeasureDao(), new MetricDao()); - reportDir = temp.newFolder(); - projectSettings = new Settings(); dbComponentsRefCache = new DbComponentsRefCache(); languageRepository = mock(LanguageRepository.class); @@ -108,7 +100,7 @@ public class PersistDuplicationsStepTest extends BaseStepTest { saveDuplicationMetric(); initReportWithProjectAndFile(); - sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, + sut.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); assertThat(dbTester.countRowsOfTable("project_measures")).isEqualTo(0); @@ -118,7 +110,7 @@ public class PersistDuplicationsStepTest extends BaseStepTest { public void persist_duplications_on_same_file() { MetricDto duplicationMetric = saveDuplicationMetric(); - BatchReportWriter writer = initReportWithProjectAndFile(); + initReportWithProjectAndFile(); BatchReport.Duplication duplication = BatchReport.Duplication.newBuilder() .setOriginPosition(Range.newBuilder() @@ -133,9 +125,9 @@ public class PersistDuplicationsStepTest extends BaseStepTest { .build()) .build()) .build(); - writer.writeComponentDuplications(2, newArrayList(duplication)); + reportReader.putDuplications(2, newArrayList(duplication)); - sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, + sut.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); assertThat(dbTester.countRowsOfTable("project_measures")).isEqualTo(1); @@ -154,27 +146,25 @@ public class PersistDuplicationsStepTest extends BaseStepTest { saveDuplicationMetric(); - File reportDir = temp.newFolder(); - BatchReportWriter writer = new BatchReportWriter(reportDir); - writer.writeMetadata(BatchReport.Metadata.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder() .setRootComponentRef(1) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .setKey(PROJECT_KEY) .setSnapshotId(10L) .addChildRef(2) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(2) .setType(Constants.ComponentType.MODULE) .setKey("MODULE_KEY") .setSnapshotId(11L) .addChildRef(3) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(3) .setType(Constants.ComponentType.FILE) .setSnapshotId(12L) @@ -194,9 +184,9 @@ public class PersistDuplicationsStepTest extends BaseStepTest { .build()) .build()) .build(); - writer.writeComponentDuplications(3, newArrayList(duplication)); + reportReader.putDuplications(3, newArrayList(duplication)); - sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); + sut.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); assertThat(dbTester.countRowsOfTable("project_measures")).isEqualTo(1); @@ -214,26 +204,25 @@ public class PersistDuplicationsStepTest extends BaseStepTest { saveDuplicationMetric(); - BatchReportWriter writer = new BatchReportWriter(reportDir); - writer.writeMetadata(BatchReport.Metadata.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder() .setRootComponentRef(1) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .setKey(PROJECT_KEY) .setSnapshotId(10L) .addChildRef(2) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(2) .setType(Constants.ComponentType.DIRECTORY) .setSnapshotId(11L) .addChildRef(3) .setPath("dir") .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(3) .setType(Constants.ComponentType.FILE) .setSnapshotId(12L) @@ -253,9 +242,9 @@ public class PersistDuplicationsStepTest extends BaseStepTest { .build()) .build()) .build(); - writer.writeComponentDuplications(3, newArrayList(duplication)); + reportReader.putDuplications(3, newArrayList(duplication)); - sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, + sut.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); assertThat(dbTester.countRowsOfTable("project_measures")).isEqualTo(1); @@ -274,33 +263,32 @@ public class PersistDuplicationsStepTest extends BaseStepTest { saveDuplicationMetric(); - BatchReportWriter writer = new BatchReportWriter(reportDir); - writer.writeMetadata(BatchReport.Metadata.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder() .setRootComponentRef(1) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .setKey(PROJECT_KEY) .setSnapshotId(10L) .addChildRef(2) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(2) .setType(Constants.ComponentType.DIRECTORY) .setSnapshotId(11L) .addChildRef(3) .setPath("dir") .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(3) .setType(Constants.ComponentType.DIRECTORY) .setSnapshotId(12L) .addChildRef(10) .setPath("dir2") .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(10) .setType(Constants.ComponentType.FILE) .setSnapshotId(20L) @@ -320,9 +308,9 @@ public class PersistDuplicationsStepTest extends BaseStepTest { .build()) .build()) .build(); - writer.writeComponentDuplications(10, newArrayList(duplication)); + reportReader.putDuplications(10, newArrayList(duplication)); - sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, + sut.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); assertThat(dbTester.countRowsOfTable("project_measures")).isEqualTo(1); @@ -335,9 +323,9 @@ public class PersistDuplicationsStepTest extends BaseStepTest { public void persist_duplications_on_different_files() { dbComponentsRefCache.addComponent(3, new DbComponent(3L, "PROJECT_KEY:file2", "CDEF")); saveDuplicationMetric(); - BatchReportWriter writer = initReportWithProjectAndFile(); + initReportWithProjectAndFile(); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(3) .setType(Constants.ComponentType.FILE) .setSnapshotId(12L) @@ -357,9 +345,9 @@ public class PersistDuplicationsStepTest extends BaseStepTest { .build()) .build()) .build(); - writer.writeComponentDuplications(2, newArrayList(duplication)); + reportReader.putDuplications(2, newArrayList(duplication)); - sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, + sut.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); assertThat(dbTester.countRowsOfTable("project_measures")).isEqualTo(1); @@ -372,7 +360,7 @@ public class PersistDuplicationsStepTest extends BaseStepTest { @Test public void persist_duplications_on_different_projects() { saveDuplicationMetric(); - BatchReportWriter writer = initReportWithProjectAndFile(); + initReportWithProjectAndFile(); BatchReport.Duplication duplication = BatchReport.Duplication.newBuilder() .setOriginPosition(Range.newBuilder() @@ -387,9 +375,9 @@ public class PersistDuplicationsStepTest extends BaseStepTest { .build()) .build()) .build(); - writer.writeComponentDuplications(2, newArrayList(duplication)); + reportReader.putDuplications(2, newArrayList(duplication)); - sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, + sut.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); assertThat(dbTester.countRowsOfTable("project_measures")).isEqualTo(1); @@ -399,30 +387,27 @@ public class PersistDuplicationsStepTest extends BaseStepTest { assertThat(dto.get("textValue")).isEqualTo(""); } - private BatchReportWriter initReportWithProjectAndFile() { + private void initReportWithProjectAndFile() { dbComponentsRefCache.addComponent(1, new DbComponent(1L, PROJECT_KEY, "ABCD")); dbComponentsRefCache.addComponent(2, new DbComponent(2L, "PROJECT_KEY:file", "BCDE")); - BatchReportWriter writer = new BatchReportWriter(reportDir); - writer.writeMetadata(BatchReport.Metadata.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder() .setRootComponentRef(1) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .setKey(PROJECT_KEY) .setSnapshotId(10L) .addChildRef(2) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(2) .setType(Constants.ComponentType.FILE) .setSnapshotId(11L) .setPath("file") .build()); - - return writer; } private MetricDto saveDuplicationMetric() { diff --git a/server/sonar-server/src/test/java/org/sonar/server/computation/step/PersistEventsStepTest.java b/server/sonar-server/src/test/java/org/sonar/server/computation/step/PersistEventsStepTest.java index 8de9804875c..c455396ee71 100644 --- a/server/sonar-server/src/test/java/org/sonar/server/computation/step/PersistEventsStepTest.java +++ b/server/sonar-server/src/test/java/org/sonar/server/computation/step/PersistEventsStepTest.java @@ -20,28 +20,25 @@ package org.sonar.server.computation.step; -import java.io.File; import org.junit.After; import org.junit.Before; import org.junit.ClassRule; import org.junit.Rule; import org.junit.Test; import org.junit.experimental.categories.Category; -import org.junit.rules.TemporaryFolder; import org.sonar.api.config.Settings; import org.sonar.api.utils.System2; import org.sonar.batch.protocol.Constants; import org.sonar.batch.protocol.output.BatchReport; -import org.sonar.batch.protocol.output.BatchReportReader; -import org.sonar.batch.protocol.output.BatchReportWriter; import org.sonar.core.persistence.DbSession; import org.sonar.core.persistence.DbTester; import org.sonar.server.computation.ComputationContext; +import org.sonar.server.computation.batch.BatchReportReaderRule; import org.sonar.server.computation.component.ComponentTreeBuilders; -import org.sonar.server.computation.component.DumbComponent; -import org.sonar.server.computation.language.LanguageRepository; import org.sonar.server.computation.component.DbComponentsRefCache; import org.sonar.server.computation.component.DbComponentsRefCache.DbComponent; +import org.sonar.server.computation.component.DumbComponent; +import org.sonar.server.computation.language.LanguageRepository; import org.sonar.server.db.DbClient; import org.sonar.server.event.db.EventDao; import org.sonar.test.DbTests; @@ -53,12 +50,11 @@ import static org.mockito.Mockito.when; public class PersistEventsStepTest extends BaseStepTest { private static final String PROJECT_KEY = "PROJECT_KEY"; - - @Rule - public TemporaryFolder temp = new TemporaryFolder(); @ClassRule public static DbTester dbTester = new DbTester(); + @Rule + public BatchReportReaderRule reportReader = new BatchReportReaderRule(); DbSession session; DbClient dbClient; @@ -106,21 +102,19 @@ public class PersistEventsStepTest extends BaseStepTest { dbComponentsRefCache.addComponent(1, new DbComponent(1L, PROJECT_KEY, "ABCD")); - File reportDir = temp.newFolder(); - BatchReportWriter writer = new BatchReportWriter(reportDir); - writer.writeMetadata(BatchReport.Metadata.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder() .setRootComponentRef(1) .setProjectKey(PROJECT_KEY) .setAnalysisDate(150000000L) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .build()); - step.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, - dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); + step.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, + dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); dbTester.assertDbUnit(getClass(), "nothing_to_do_when_no_events_in_report.xml", "events"); } @@ -131,15 +125,13 @@ public class PersistEventsStepTest extends BaseStepTest { dbComponentsRefCache.addComponent(1, new DbComponent(1L, PROJECT_KEY, "ABCD")); - File reportDir = temp.newFolder(); - BatchReportWriter writer = new BatchReportWriter(reportDir); - writer.writeMetadata(BatchReport.Metadata.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder() .setRootComponentRef(1) .setProjectKey(PROJECT_KEY) .setAnalysisDate(150000000L) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .setSnapshotId(1000L) @@ -157,8 +149,8 @@ public class PersistEventsStepTest extends BaseStepTest { ) .build()); - step.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, - dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); + step.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, + dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); dbTester.assertDbUnit(getClass(), "add_events-result.xml", "events"); } @@ -170,15 +162,13 @@ public class PersistEventsStepTest extends BaseStepTest { dbComponentsRefCache.addComponent(1, new DbComponent(1L, PROJECT_KEY, "ABCD")); dbComponentsRefCache.addComponent(2, new DbComponent(2L, "MODULE_KEY", "BCDE")); - File reportDir = temp.newFolder(); - BatchReportWriter writer = new BatchReportWriter(reportDir); - writer.writeMetadata(BatchReport.Metadata.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder() .setRootComponentRef(1) .setProjectKey(PROJECT_KEY) .setAnalysisDate(150000000L) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .setSnapshotId(1000L) @@ -190,19 +180,19 @@ public class PersistEventsStepTest extends BaseStepTest { .addChildRef(2) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(2) .setType(Constants.ComponentType.MODULE) .setSnapshotId(1001L) .addEvent(BatchReport.Event.newBuilder() - .setName("Red (was Orange)") - .setCategory(Constants.EventCategory.ALERT) - .setDescription("Open issues > 0") - .build() + .setName("Red (was Orange)") + .setCategory(Constants.EventCategory.ALERT) + .setDescription("Open issues > 0") + .build() ).build()); - step.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, - dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); + step.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, + dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); dbTester.assertDbUnit(getClass(), "persist_report_events_with_component_children-result.xml", "events"); } @@ -213,23 +203,21 @@ public class PersistEventsStepTest extends BaseStepTest { dbComponentsRefCache.addComponent(1, new DbComponent(1L, PROJECT_KEY, "ABCD")); - File reportDir = temp.newFolder(); - BatchReportWriter writer = new BatchReportWriter(reportDir); - writer.writeMetadata(BatchReport.Metadata.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder() .setRootComponentRef(1) .setProjectKey(PROJECT_KEY) .setAnalysisDate(150000000L) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .setSnapshotId(1000L) .setVersion("1.0") .build()); - step.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, - dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); + step.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, + dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); dbTester.assertDbUnit(getClass(), "add_version_event-result.xml", "events"); } @@ -240,22 +228,20 @@ public class PersistEventsStepTest extends BaseStepTest { dbComponentsRefCache.addComponent(1, new DbComponent(1L, PROJECT_KEY, "ABCD")); - File reportDir = temp.newFolder(); - BatchReportWriter writer = new BatchReportWriter(reportDir); - writer.writeMetadata(BatchReport.Metadata.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder() .setRootComponentRef(1) .setProjectKey(PROJECT_KEY) .setAnalysisDate(150000000L) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .setSnapshotId(1001L) .setVersion("1.5-SNAPSHOT") .build()); - step.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, + step.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); dbTester.assertDbUnit(getClass(), "keep_one_event_by_version-result.xml", "events"); diff --git a/server/sonar-server/src/test/java/org/sonar/server/computation/step/PersistFileSourcesStepTest.java b/server/sonar-server/src/test/java/org/sonar/server/computation/step/PersistFileSourcesStepTest.java index 05464f560c9..9ba629f459f 100644 --- a/server/sonar-server/src/test/java/org/sonar/server/computation/step/PersistFileSourcesStepTest.java +++ b/server/sonar-server/src/test/java/org/sonar/server/computation/step/PersistFileSourcesStepTest.java @@ -38,7 +38,6 @@ import org.sonar.api.resources.Language; import org.sonar.api.utils.System2; import org.sonar.batch.protocol.Constants; import org.sonar.batch.protocol.output.BatchReport; -import org.sonar.batch.protocol.output.BatchReportReader; import org.sonar.batch.protocol.output.BatchReportWriter; import org.sonar.batch.protocol.output.FileStructure; import org.sonar.core.persistence.DbSession; @@ -46,10 +45,11 @@ import org.sonar.core.persistence.DbTester; import org.sonar.core.source.db.FileSourceDto; import org.sonar.core.source.db.FileSourceDto.Type; import org.sonar.server.computation.ComputationContext; +import org.sonar.server.computation.batch.BatchReportReaderRule; import org.sonar.server.computation.component.ComponentTreeBuilders; +import org.sonar.server.computation.component.DbComponentsRefCache; import org.sonar.server.computation.component.DumbComponent; import org.sonar.server.computation.language.LanguageRepository; -import org.sonar.server.computation.component.DbComponentsRefCache; import org.sonar.server.db.DbClient; import org.sonar.server.source.db.FileSourceDao; import org.sonar.server.source.db.FileSourceDb; @@ -70,14 +70,16 @@ public class PersistFileSourcesStepTest extends BaseStepTest { private static final String PROJECT_KEY = "PROJECT_KEY"; private static final String FILE_UUID = "FILE"; + @ClassRule + public static DbTester dbTester = new DbTester(); + @Rule + public BatchReportReaderRule reportReader = new BatchReportReaderRule(); + @Rule public TemporaryFolder temp = new TemporaryFolder(); File reportDir; - @ClassRule - public static DbTester dbTester = new DbTester(); - DbSession session; DbClient dbClient; @@ -123,8 +125,8 @@ public class PersistFileSourcesStepTest extends BaseStepTest { public void persist_sources() throws Exception { initBasicReport(2); - sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, - dbClient, ComponentTreeBuilders .from(DumbComponent.DUMB_PROJECT), new EmptyLanguageRepository())); + sut.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, + dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), new EmptyLanguageRepository())); assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1); FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectSource(FILE_UUID); @@ -150,25 +152,27 @@ public class PersistFileSourcesStepTest extends BaseStepTest { dbComponentsRefCache.addComponent(FILE_REF, new DbComponentsRefCache.DbComponent(2L, "PROJECT_KEY:file", FILE_UUID)); BatchReportWriter writer = new BatchReportWriter(reportDir); - FileUtils.writeLines(writer.getFileStructure().fileFor(FileStructure.Domain.SOURCE, FILE_REF), Lists.newArrayList("line1", "line2")); - writer.writeMetadata(BatchReport.Metadata.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder() .setRootComponentRef(1) .setProjectKey(PROJECT_KEY) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .addChildRef(FILE_REF) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(FILE_REF) .setType(Constants.ComponentType.FILE) // Lines is set to 3 but only 2 lines are read from the file -> the last lines should be added .setLines(3) .build()); + File file = writer.getFileStructure().fileFor(FileStructure.Domain.SOURCE, FILE_REF); + reportReader.putFileSoure(FILE_REF, file); + FileUtils.writeLines(file, Lists.newArrayList("line1", "line2")); - sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, - dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); + sut.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, + dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1); FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectSource(FILE_UUID); @@ -182,8 +186,8 @@ public class PersistFileSourcesStepTest extends BaseStepTest { public void persist_source_hashes() throws Exception { initBasicReport(2); - sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, - dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); + sut.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, + dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1); FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectSource("FILE"); @@ -195,7 +199,7 @@ public class PersistFileSourcesStepTest extends BaseStepTest { public void persist_coverage() throws Exception { BatchReportWriter writer = initBasicReport(1); - writer.writeComponentCoverage(FILE_REF, newArrayList(BatchReport.Coverage.newBuilder() + File file = writer.writeComponentCoverage(FILE_REF, newArrayList(BatchReport.Coverage.newBuilder() .setLine(1) .setConditions(10) .setUtHits(true) @@ -204,9 +208,10 @@ public class PersistFileSourcesStepTest extends BaseStepTest { .setItCoveredConditions(3) .setOverallCoveredConditions(4) .build())); + reportReader.putCoverage(FILE_REF, file); - sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, - dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); + sut.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, + dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1); FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectSource(FILE_UUID); @@ -227,9 +232,9 @@ public class PersistFileSourcesStepTest extends BaseStepTest { @Test public void persist_scm() throws Exception { - BatchReportWriter writer = initBasicReport(1); + initBasicReport(1); - writer.writeComponentChangesets(BatchReport.Changesets.newBuilder() + reportReader.putChangesets(BatchReport.Changesets.newBuilder() .setComponentRef(FILE_REF) .addChangeset(BatchReport.Changesets.Changeset.newBuilder() .setAuthor("john") @@ -239,8 +244,8 @@ public class PersistFileSourcesStepTest extends BaseStepTest { .addChangesetIndexByLine(0) .build()); - sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, - dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); + sut.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, + dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1); FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectSource(FILE_UUID); @@ -257,7 +262,7 @@ public class PersistFileSourcesStepTest extends BaseStepTest { public void persist_highlighting() throws Exception { BatchReportWriter writer = initBasicReport(1); - writer.writeComponentSyntaxHighlighting(FILE_REF, newArrayList(BatchReport.SyntaxHighlighting.newBuilder() + File file = writer.writeComponentSyntaxHighlighting(FILE_REF, newArrayList(BatchReport.SyntaxHighlighting.newBuilder() .setRange(BatchReport.Range.newBuilder() .setStartLine(1).setEndLine(1) .setStartOffset(2).setEndOffset(4) @@ -265,9 +270,10 @@ public class PersistFileSourcesStepTest extends BaseStepTest { .setType(Constants.HighlightingType.ANNOTATION) .build() )); + reportReader.putSyntaxHighlighting(FILE_REF, file); - sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, - dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); + sut.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, + dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1); FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectSource(FILE_UUID); @@ -280,9 +286,9 @@ public class PersistFileSourcesStepTest extends BaseStepTest { @Test public void persist_symbols() throws Exception { - BatchReportWriter writer = initBasicReport(3); + initBasicReport(3); - writer.writeComponentSymbols(FILE_REF, newArrayList( + reportReader.putSymbols(FILE_REF, newArrayList( BatchReport.Symbols.Symbol.newBuilder() .setDeclaration(BatchReport.Range.newBuilder() .setStartLine(1).setEndLine(1).setStartOffset(2).setEndOffset(4) @@ -293,8 +299,8 @@ public class PersistFileSourcesStepTest extends BaseStepTest { ).build() )); - sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, - dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); + sut.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, + dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1); FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectSource(FILE_UUID); @@ -309,9 +315,9 @@ public class PersistFileSourcesStepTest extends BaseStepTest { @Test public void persist_duplication() throws Exception { - BatchReportWriter writer = initBasicReport(1); + initBasicReport(1); - writer.writeComponentDuplications(FILE_REF, newArrayList( + reportReader.putDuplications(FILE_REF, newArrayList( BatchReport.Duplication.newBuilder() .setOriginPosition(BatchReport.Range.newBuilder() .setStartLine(1) @@ -326,8 +332,8 @@ public class PersistFileSourcesStepTest extends BaseStepTest { .build() )); - sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, - dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); + sut.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, + dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1); FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectSource(FILE_UUID); @@ -365,8 +371,8 @@ public class PersistFileSourcesStepTest extends BaseStepTest { // Sources from the report initBasicReport(1); - sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, - dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); + sut.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, + dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1); FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectSource(FILE_UUID); @@ -400,8 +406,8 @@ public class PersistFileSourcesStepTest extends BaseStepTest { initBasicReport(1); - sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, - dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); + sut.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, + dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1); FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectSource(FILE_UUID); @@ -432,8 +438,8 @@ public class PersistFileSourcesStepTest extends BaseStepTest { initBasicReport(1); - sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, - dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); + sut.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, + dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1); FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectSource(FILE_UUID); @@ -447,7 +453,7 @@ public class PersistFileSourcesStepTest extends BaseStepTest { public void display_file_path_when_exception_is_generated() throws Exception { BatchReportWriter writer = initBasicReport(1); - writer.writeComponentSyntaxHighlighting(FILE_REF, newArrayList(BatchReport.SyntaxHighlighting.newBuilder() + File file = writer.writeComponentSyntaxHighlighting(FILE_REF, newArrayList(BatchReport.SyntaxHighlighting.newBuilder() .setRange(BatchReport.Range.newBuilder() .setStartLine(1).setEndLine(1) // Wrong offset -> fail @@ -456,10 +462,11 @@ public class PersistFileSourcesStepTest extends BaseStepTest { .setType(Constants.HighlightingType.ANNOTATION) .build() )); + reportReader.putSyntaxHighlighting(FILE_REF, file); try { - sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, - dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); + sut.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, + dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); failBecauseExceptionWasNotThrown(IllegalStateException.class); } catch (IllegalStateException e) { assertThat(e).hasMessage("Cannot persist sources of src/Foo.java").hasCauseInstanceOf(IllegalArgumentException.class); @@ -471,34 +478,36 @@ public class PersistFileSourcesStepTest extends BaseStepTest { dbComponentsRefCache.addComponent(2, new DbComponentsRefCache.DbComponent(2L, "MODULE_KEY", "MODULE")); dbComponentsRefCache.addComponent(FILE_REF, new DbComponentsRefCache.DbComponent(3L, "MODULE_KEY:src/Foo.java", FILE_UUID)); - BatchReportWriter writer = new BatchReportWriter(reportDir); - writer.writeMetadata(BatchReport.Metadata.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder() .setRootComponentRef(1) .setProjectKey(PROJECT_KEY) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .addChildRef(2) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(2) .setType(Constants.ComponentType.MODULE) .addChildRef(FILE_REF) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(FILE_REF) .setType(Constants.ComponentType.FILE) .setPath("src/Foo.java") .setLines(numberOfLines) .build()); + BatchReportWriter writer = new BatchReportWriter(reportDir); List lines = newArrayList(); for (int i = 1; i <= numberOfLines; i++) { lines.add("line" + i); } - FileUtils.writeLines(writer.getSourceFile(FILE_REF), lines); + File file = writer.getSourceFile(FILE_REF); + FileUtils.writeLines(file, lines); + reportReader.putFileSoure(FILE_REF, file); return writer; } diff --git a/server/sonar-server/src/test/java/org/sonar/server/computation/step/PersistMeasuresStepTest.java b/server/sonar-server/src/test/java/org/sonar/server/computation/step/PersistMeasuresStepTest.java index bd845ac6ffd..661733feef6 100644 --- a/server/sonar-server/src/test/java/org/sonar/server/computation/step/PersistMeasuresStepTest.java +++ b/server/sonar-server/src/test/java/org/sonar/server/computation/step/PersistMeasuresStepTest.java @@ -20,7 +20,6 @@ package org.sonar.server.computation.step; -import java.io.File; import java.util.Arrays; import java.util.Date; import java.util.List; @@ -31,7 +30,6 @@ import org.junit.ClassRule; import org.junit.Rule; import org.junit.Test; import org.junit.experimental.categories.Category; -import org.junit.rules.TemporaryFolder; import org.sonar.api.config.Settings; import org.sonar.api.rule.RuleKey; import org.sonar.api.rule.Severity; @@ -40,8 +38,6 @@ import org.sonar.api.utils.internal.Uuids; import org.sonar.batch.protocol.Constants; import org.sonar.batch.protocol.Constants.MeasureValueType; import org.sonar.batch.protocol.output.BatchReport; -import org.sonar.batch.protocol.output.BatchReportReader; -import org.sonar.batch.protocol.output.BatchReportWriter; import org.sonar.core.component.ComponentDto; import org.sonar.core.measure.db.MeasureDto; import org.sonar.core.metric.db.MetricDto; @@ -50,6 +46,7 @@ import org.sonar.core.persistence.DbTester; import org.sonar.core.rule.RuleDto; import org.sonar.server.component.db.ComponentDao; import org.sonar.server.computation.ComputationContext; +import org.sonar.server.computation.batch.BatchReportReaderRule; import org.sonar.server.computation.component.ComponentTreeBuilders; import org.sonar.server.computation.component.DbComponentsRefCache; import org.sonar.server.computation.component.DumbComponent; @@ -76,12 +73,12 @@ public class PersistMeasuresStepTest extends BaseStepTest { DbSession session; - @Rule - public TemporaryFolder temp = new TemporaryFolder(); - @ClassRule public static DbTester dbTester = new DbTester(); + @Rule + public BatchReportReaderRule reportReader = new BatchReportReaderRule(); + DbClient dbClient; RuleCache ruleCache; MetricCache metricCache; @@ -126,25 +123,22 @@ public class PersistMeasuresStepTest extends BaseStepTest { ComponentDto project = addComponent(1, "project-key"); ComponentDto file = addComponent(2, "file-key"); - File dir = temp.newFolder(); - BatchReportWriter report = new BatchReportWriter(dir); - - report.writeMetadata(BatchReport.Metadata.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder() .setAnalysisDate(new Date().getTime()) .setRootComponentRef(1) .setProjectKey("project-key") .setSnapshotId(3) .build()); - report.writeComponent(defaultComponent() + reportReader.putComponent(defaultComponent() .addChildRef(2) .build()); - report.writeComponent( + reportReader.putComponent( defaultComponent() .setRef(2) .build()); - report.writeComponentMeasures(1, Arrays.asList( + reportReader.putMeasures(1, Arrays.asList( BatchReport.Measure.newBuilder() .setValueType(MeasureValueType.STRING) .setStringValue("measure-data") @@ -162,7 +156,7 @@ public class PersistMeasuresStepTest extends BaseStepTest { .setCharactericId(123456) .build())); - report.writeComponentMeasures(2, Arrays.asList( + reportReader.putMeasures(2, Arrays.asList( BatchReport.Measure.newBuilder() .setValueType(MeasureValueType.DOUBLE) .setDoubleValue(123.123d) @@ -180,7 +174,7 @@ public class PersistMeasuresStepTest extends BaseStepTest { .setCharactericId(123456) .build())); - sut.execute(new ComputationContext(new BatchReportReader(dir), PROJECT_KEY, new Settings(), + sut.execute(new ComputationContext(reportReader, PROJECT_KEY, new Settings(), dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), mock(LanguageRepository.class))); session.commit(); diff --git a/server/sonar-server/src/test/java/org/sonar/server/computation/step/PersistNumberOfDaysSinceLastCommitStepTest.java b/server/sonar-server/src/test/java/org/sonar/server/computation/step/PersistNumberOfDaysSinceLastCommitStepTest.java index b764fed9939..2cb1937fe29 100644 --- a/server/sonar-server/src/test/java/org/sonar/server/computation/step/PersistNumberOfDaysSinceLastCommitStepTest.java +++ b/server/sonar-server/src/test/java/org/sonar/server/computation/step/PersistNumberOfDaysSinceLastCommitStepTest.java @@ -20,25 +20,22 @@ package org.sonar.server.computation.step; -import java.io.File; import java.util.Date; import org.junit.Before; import org.junit.ClassRule; import org.junit.Rule; import org.junit.Test; -import org.junit.rules.TemporaryFolder; import org.sonar.api.config.Settings; import org.sonar.api.utils.DateUtils; import org.sonar.api.utils.System2; import org.sonar.batch.protocol.Constants; import org.sonar.batch.protocol.output.BatchReport; -import org.sonar.batch.protocol.output.BatchReportReader; -import org.sonar.batch.protocol.output.BatchReportWriter; import org.sonar.core.metric.db.MetricDto; import org.sonar.core.persistence.DbTester; import org.sonar.server.computation.ComputationContext; -import org.sonar.server.computation.component.DbComponentsRefCache; +import org.sonar.server.computation.batch.BatchReportReaderRule; import org.sonar.server.computation.component.ComponentTreeBuilders; +import org.sonar.server.computation.component.DbComponentsRefCache; import org.sonar.server.computation.component.DumbComponent; import org.sonar.server.computation.language.LanguageRepository; import org.sonar.server.computation.measure.MetricCache; @@ -55,8 +52,7 @@ public class PersistNumberOfDaysSinceLastCommitStepTest extends BaseStepTest { @ClassRule public static DbTester db = new DbTester(); @Rule - public TemporaryFolder temp = new TemporaryFolder(); - File dir; + public BatchReportReaderRule reportReader = new BatchReportReaderRule(); PersistNumberOfDaysSinceLastCommitStep sut; @@ -78,7 +74,6 @@ public class PersistNumberOfDaysSinceLastCommitStepTest extends BaseStepTest { languageRepository = mock(LanguageRepository.class); when(metricCache.get(anyString())).thenReturn(new MetricDto().setId(10)); dbComponentsRefCache = new DbComponentsRefCache(); - dir = temp.newFolder(); sut = new PersistNumberOfDaysSinceLastCommitStep(System2.INSTANCE, dbClient, sourceLineIndex, metricCache, dbComponentsRefCache); } @@ -91,8 +86,8 @@ public class PersistNumberOfDaysSinceLastCommitStepTest extends BaseStepTest { @Test public void persist_number_of_days_since_last_commit_from_report() { long threeDaysAgo = DateUtils.addDays(new Date(), -3).getTime(); - BatchReportWriter reportWriter = initReportWithProjectAndFile(); - reportWriter.writeComponentChangesets( + initReportWithProjectAndFile(); + reportReader.putChangesets( BatchReport.Changesets.newBuilder() .setComponentRef(2) .addChangeset( @@ -101,7 +96,8 @@ public class PersistNumberOfDaysSinceLastCommitStepTest extends BaseStepTest { ) .build() ); - ComputationContext context = new ComputationContext(new BatchReportReader(dir), "PROJECT_KEY", projectSettings, dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository); + ComputationContext context = new ComputationContext(reportReader, "PROJECT_KEY", projectSettings, dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), + languageRepository); sut.execute(context); @@ -113,7 +109,8 @@ public class PersistNumberOfDaysSinceLastCommitStepTest extends BaseStepTest { Date sixDaysAgo = DateUtils.addDays(new Date(), -6); when(sourceLineIndex.lastCommitDateOnProject("project-uuid")).thenReturn(sixDaysAgo); initReportWithProjectAndFile(); - ComputationContext context = new ComputationContext(new BatchReportReader(dir), "PROJECT_KEY", projectSettings, dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository); + ComputationContext context = new ComputationContext(reportReader, "PROJECT_KEY", projectSettings, dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), + languageRepository); sut.execute(context); @@ -123,36 +120,34 @@ public class PersistNumberOfDaysSinceLastCommitStepTest extends BaseStepTest { @Test public void no_scm_information_in_report_and_index() { initReportWithProjectAndFile(); - ComputationContext context = new ComputationContext(new BatchReportReader(dir),"PROJECT_KEY", projectSettings, dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository); + ComputationContext context = new ComputationContext(reportReader, "PROJECT_KEY", projectSettings, dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), + languageRepository); sut.execute(context); db.assertDbUnit(getClass(), "empty.xml"); } - private BatchReportWriter initReportWithProjectAndFile() { + private void initReportWithProjectAndFile() { dbComponentsRefCache.addComponent(1, new DbComponentsRefCache.DbComponent(1L, "PROJECT_KEY", "project-uuid")); dbComponentsRefCache.addComponent(2, new DbComponentsRefCache.DbComponent(2L, "PROJECT_KEY:file", "file-uuid")); - BatchReportWriter writer = new BatchReportWriter(dir); - writer.writeMetadata(BatchReport.Metadata.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder() .setRootComponentRef(1) .setSnapshotId(1000) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .setKey("PROJECT_KEY") .setSnapshotId(10L) .addChildRef(2) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(2) .setType(Constants.ComponentType.FILE) .setSnapshotId(11L) .build()); - - return writer; } } diff --git a/server/sonar-server/src/test/java/org/sonar/server/computation/step/PersistProjectLinksStepTest.java b/server/sonar-server/src/test/java/org/sonar/server/computation/step/PersistProjectLinksStepTest.java index b8ea9f7ed00..46a5c95cfd9 100644 --- a/server/sonar-server/src/test/java/org/sonar/server/computation/step/PersistProjectLinksStepTest.java +++ b/server/sonar-server/src/test/java/org/sonar/server/computation/step/PersistProjectLinksStepTest.java @@ -20,7 +20,6 @@ package org.sonar.server.computation.step; -import java.io.File; import java.util.Locale; import org.junit.After; import org.junit.Before; @@ -28,21 +27,19 @@ import org.junit.ClassRule; import org.junit.Rule; import org.junit.Test; import org.junit.experimental.categories.Category; -import org.junit.rules.TemporaryFolder; import org.sonar.api.config.Settings; import org.sonar.api.i18n.I18n; import org.sonar.batch.protocol.Constants; import org.sonar.batch.protocol.output.BatchReport; -import org.sonar.batch.protocol.output.BatchReportReader; -import org.sonar.batch.protocol.output.BatchReportWriter; import org.sonar.core.persistence.DbSession; import org.sonar.core.persistence.DbTester; import org.sonar.server.component.db.ComponentLinkDao; import org.sonar.server.computation.ComputationContext; +import org.sonar.server.computation.batch.BatchReportReaderRule; import org.sonar.server.computation.component.ComponentTreeBuilders; +import org.sonar.server.computation.component.DbComponentsRefCache; import org.sonar.server.computation.component.DumbComponent; import org.sonar.server.computation.language.LanguageRepository; -import org.sonar.server.computation.component.DbComponentsRefCache; import org.sonar.server.db.DbClient; import org.sonar.test.DbTests; @@ -56,12 +53,12 @@ public class PersistProjectLinksStepTest extends BaseStepTest { private static final String PROJECT_KEY = "PROJECT_KEY"; - @Rule - public TemporaryFolder temp = new TemporaryFolder(); - @ClassRule public static DbTester dbTester = new DbTester(); + @Rule + public BatchReportReaderRule reportReader = new BatchReportReaderRule(); + DbSession session; DbClient dbClient; Settings projectSettings; @@ -111,16 +108,14 @@ public class PersistProjectLinksStepTest extends BaseStepTest { dbComponentsRefCache.addComponent(1, new DbComponentsRefCache.DbComponent(1L, PROJECT_KEY, "ABCD")); dbComponentsRefCache.addComponent(2, new DbComponentsRefCache.DbComponent(2L, "MODULE_KEY", "BCDE")); - File reportDir = temp.newFolder(); // project and 1 module - BatchReportWriter writer = new BatchReportWriter(reportDir); - writer.writeMetadata(BatchReport.Metadata.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder() .setRootComponentRef(1) .setProjectKey(PROJECT_KEY) .setAnalysisDate(150000000L) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .addChildRef(2) @@ -130,13 +125,13 @@ public class PersistProjectLinksStepTest extends BaseStepTest { .addLink(BatchReport.ComponentLink.newBuilder().setType(Constants.ComponentLinkType.ISSUE).setHref("http://jira.sonarsource.com/").build()) .addLink(BatchReport.ComponentLink.newBuilder().setType(Constants.ComponentLinkType.CI).setHref("http://bamboo.ci.codehaus.org/browse/SONAR").build()) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(2) .setType(Constants.ComponentType.MODULE) .addLink(BatchReport.ComponentLink.newBuilder().setType(Constants.ComponentLinkType.SCM).setHref("https://github.com/SonarSource/sonar/server").build()) .build()); - step.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); + step.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); dbTester.assertDbUnit(getClass(), "add_links_on_project_and_module-result.xml", "project_links"); } @@ -147,20 +142,18 @@ public class PersistProjectLinksStepTest extends BaseStepTest { dbComponentsRefCache.addComponent(1, new DbComponentsRefCache.DbComponent(1L, PROJECT_KEY, "ABCD")); - File reportDir = temp.newFolder(); - BatchReportWriter writer = new BatchReportWriter(reportDir); - writer.writeMetadata(BatchReport.Metadata.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder() .setRootComponentRef(1) .setProjectKey(PROJECT_KEY) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .addLink(BatchReport.ComponentLink.newBuilder().setType(Constants.ComponentLinkType.HOME).setHref("http://www.sonarqube.org").build()) .build()); - step.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); + step.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); dbTester.assertDbUnit(getClass(), "nothing_to_do_when_link_already_exists.xml", "project_links"); } @@ -171,20 +164,18 @@ public class PersistProjectLinksStepTest extends BaseStepTest { dbComponentsRefCache.addComponent(1, new DbComponentsRefCache.DbComponent(1L, PROJECT_KEY, "ABCD")); - File reportDir = temp.newFolder(); - BatchReportWriter writer = new BatchReportWriter(reportDir); - writer.writeMetadata(BatchReport.Metadata.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder() .setRootComponentRef(1) .setProjectKey(PROJECT_KEY) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.FILE) .addLink(BatchReport.ComponentLink.newBuilder().setType(Constants.ComponentLinkType.HOME).setHref("http://www.sonarqube.org").build()) .build()); - step.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); + step.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); assertThat(dbTester.countRowsOfTable("project_links")).isEqualTo(0); } @@ -195,20 +186,18 @@ public class PersistProjectLinksStepTest extends BaseStepTest { dbComponentsRefCache.addComponent(1, new DbComponentsRefCache.DbComponent(1L, PROJECT_KEY, "ABCD")); - File reportDir = temp.newFolder(); - BatchReportWriter writer = new BatchReportWriter(reportDir); - writer.writeMetadata(BatchReport.Metadata.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder() .setRootComponentRef(1) .setProjectKey(PROJECT_KEY) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .addLink(BatchReport.ComponentLink.newBuilder().setType(Constants.ComponentLinkType.HOME).setHref("http://www.sonarqube.org").build()) .build()); - step.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); + step.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); dbTester.assertDbUnit(getClass(), "update_link-result.xml", "project_links"); } @@ -219,19 +208,17 @@ public class PersistProjectLinksStepTest extends BaseStepTest { dbComponentsRefCache.addComponent(1, new DbComponentsRefCache.DbComponent(1L, PROJECT_KEY, "ABCD")); - File reportDir = temp.newFolder(); - BatchReportWriter writer = new BatchReportWriter(reportDir); - writer.writeMetadata(BatchReport.Metadata.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder() .setRootComponentRef(1) .setProjectKey(PROJECT_KEY) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .build()); - step.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); + step.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); assertThat(dbTester.countRowsOfTable("project_links")).isEqualTo(0); } @@ -242,19 +229,17 @@ public class PersistProjectLinksStepTest extends BaseStepTest { dbComponentsRefCache.addComponent(1, new DbComponentsRefCache.DbComponent(1L, PROJECT_KEY, "ABCD")); - File reportDir = temp.newFolder(); - BatchReportWriter writer = new BatchReportWriter(reportDir); - writer.writeMetadata(BatchReport.Metadata.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder() .setRootComponentRef(1) .setProjectKey(PROJECT_KEY) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .build()); - step.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); + step.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); dbTester.assertDbUnit(getClass(), "not_delete_custom_link.xml", "project_links"); } @@ -265,14 +250,12 @@ public class PersistProjectLinksStepTest extends BaseStepTest { dbComponentsRefCache.addComponent(1, new DbComponentsRefCache.DbComponent(1L, PROJECT_KEY, "ABCD")); - File reportDir = temp.newFolder(); - BatchReportWriter writer = new BatchReportWriter(reportDir); - writer.writeMetadata(BatchReport.Metadata.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder() .setRootComponentRef(1) .setProjectKey(PROJECT_KEY) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .addLink(BatchReport.ComponentLink.newBuilder().setType(Constants.ComponentLinkType.HOME).setHref("http://www.sonarqube.org").build()) @@ -280,7 +263,7 @@ public class PersistProjectLinksStepTest extends BaseStepTest { .build()); try { - step.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); + step.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), languageRepository)); failBecauseExceptionWasNotThrown(IllegalArgumentException.class); } catch (IllegalArgumentException e) { assertThat(e).hasMessage("Link of type 'homepage' has already been declared on component 'ABCD'"); diff --git a/server/sonar-server/src/test/java/org/sonar/server/computation/step/PersistTestsStepTest.java b/server/sonar-server/src/test/java/org/sonar/server/computation/step/PersistTestsStepTest.java index 143052a7c23..6cea2bbd740 100644 --- a/server/sonar-server/src/test/java/org/sonar/server/computation/step/PersistTestsStepTest.java +++ b/server/sonar-server/src/test/java/org/sonar/server/computation/step/PersistTestsStepTest.java @@ -36,13 +36,13 @@ import org.sonar.api.utils.log.LoggerLevel; import org.sonar.batch.protocol.Constants; import org.sonar.batch.protocol.output.BatchReport; import org.sonar.batch.protocol.output.BatchReport.CoverageDetail; -import org.sonar.batch.protocol.output.BatchReportReader; import org.sonar.batch.protocol.output.BatchReportWriter; import org.sonar.core.persistence.DbSession; import org.sonar.core.persistence.DbTester; import org.sonar.core.persistence.MyBatis; import org.sonar.core.source.db.FileSourceDto; import org.sonar.server.computation.ComputationContext; +import org.sonar.server.computation.batch.BatchReportReaderRule; import org.sonar.server.computation.component.Component; import org.sonar.server.computation.component.ComponentTreeBuilders; import org.sonar.server.computation.component.DbComponentsRefCache; @@ -72,11 +72,14 @@ public class PersistTestsStepTest extends BaseStepTest { private static final String TEST_FILE_PATH_1 = "TEST-PATH-1"; private static final String TEST_FILE_PATH_2 = "TEST-PATH-2"; + @ClassRule + public static DbTester db = new DbTester(); + @Rule public TemporaryFolder temp = new TemporaryFolder(); - @ClassRule - public static DbTester db = new DbTester(); + @Rule + public BatchReportReaderRule reportReader = new BatchReportReaderRule(); @Rule public LogTester log = new LogTester(); @@ -134,7 +137,7 @@ public class PersistTestsStepTest extends BaseStepTest { @Test public void no_test_in_database_and_batch_report() { - sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(root), languageRepository)); + sut.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(root), languageRepository)); assertThat(dbClient.fileSourceDao().selectTest(TEST_FILE_UUID_1)).isNull(); assertThat(log.logs()).isEmpty(); @@ -146,13 +149,13 @@ public class PersistTestsStepTest extends BaseStepTest { List batchTests = Arrays.asList( newTest(1), newTest(2) ); - writer.writeTests(TEST_FILE_REF_1, batchTests); + reportReader.putTests(TEST_FILE_REF_1, writer.writeTests(TEST_FILE_REF_1, batchTests)); List coverageDetails = Arrays.asList( newCoverageDetail(1, MAIN_FILE_REF_1) ); - writer.writeCoverageDetails(TEST_FILE_REF_1, coverageDetails); + reportReader.putCoverageDetails(TEST_FILE_REF_1, writer.writeCoverageDetails(TEST_FILE_REF_1, coverageDetails)); - sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(root), languageRepository)); + sut.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(root), languageRepository)); assertThat(db.countRowsOfTable("file_sources")).isEqualTo(1); @@ -173,10 +176,10 @@ public class PersistTestsStepTest extends BaseStepTest { @Test public void insert_all_data_of_a_test() { BatchReportWriter writer = new BatchReportWriter(reportDir); - writer.writeTests(TEST_FILE_REF_1, Arrays.asList(newTest(1))); - writer.writeCoverageDetails(TEST_FILE_REF_1, Arrays.asList(newCoverageDetail(1, MAIN_FILE_REF_1))); + reportReader.putTests(TEST_FILE_REF_1, writer.writeTests(TEST_FILE_REF_1, Arrays.asList(newTest(1)))); + reportReader.putCoverageDetails(TEST_FILE_REF_1, writer.writeCoverageDetails(TEST_FILE_REF_1, Arrays.asList(newCoverageDetail(1, MAIN_FILE_REF_1)))); - sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(root), languageRepository)); + sut.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(root), languageRepository)); FileSourceDto dto = dbClient.fileSourceDao().selectTest(TEST_FILE_UUID_1); assertThat(dto.getCreatedAt()).isEqualTo(now); @@ -201,9 +204,9 @@ public class PersistTestsStepTest extends BaseStepTest { public void insert_tests_without_coverage_details() { BatchReportWriter writer = new BatchReportWriter(reportDir); List batchTests = Arrays.asList(newTest(1)); - writer.writeTests(TEST_FILE_REF_1, batchTests); + reportReader.putTests(TEST_FILE_REF_1, writer.writeTests(TEST_FILE_REF_1, batchTests)); - sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(root), languageRepository)); + sut.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(root), languageRepository)); FileSourceDto dto = dbClient.fileSourceDao().selectTest(TEST_FILE_UUID_1); assertThat(dto.getFileUuid()).isEqualTo(TEST_FILE_UUID_1); @@ -217,12 +220,12 @@ public class PersistTestsStepTest extends BaseStepTest { public void insert_coverage_details_not_taken_into_account() { BatchReportWriter writer = new BatchReportWriter(reportDir); List batchTests = Arrays.asList(newTest(1)); - writer.writeTests(TEST_FILE_REF_1, batchTests); + reportReader.putTests(TEST_FILE_REF_1, writer.writeTests(TEST_FILE_REF_1, batchTests)); List coverageDetails = Arrays.asList(newCoverageDetail(1, MAIN_FILE_REF_1), newCoverageDetail(2, MAIN_FILE_REF_2)); - writer.writeCoverageDetails(TEST_FILE_REF_1, coverageDetails); - writer.writeCoverageDetails(TEST_FILE_REF_2, coverageDetails); + reportReader.putCoverageDetails(TEST_FILE_REF_1, writer.writeCoverageDetails(TEST_FILE_REF_1, coverageDetails)); + reportReader.putCoverageDetails(TEST_FILE_REF_2, writer.writeCoverageDetails(TEST_FILE_REF_2, coverageDetails)); - sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(root), languageRepository)); + sut.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(root), languageRepository)); assertThat(log.logs(LoggerLevel.WARN)).hasSize(1); assertThat(log.logs(LoggerLevel.WARN).get(0)).isEqualTo("Some coverage tests are not taken into account during analysis of project 'PROJECT_KEY'"); @@ -235,12 +238,12 @@ public class PersistTestsStepTest extends BaseStepTest { @Test public void aggregate_coverage_details() { BatchReportWriter writer = new BatchReportWriter(reportDir); - writer.writeTests(TEST_FILE_REF_1, Arrays.asList(newTest(1))); - writer.writeCoverageDetails(TEST_FILE_REF_1, Arrays.asList( + reportReader.putTests(TEST_FILE_REF_1, writer.writeTests(TEST_FILE_REF_1, Arrays.asList(newTest(1)))); + reportReader.putCoverageDetails(TEST_FILE_REF_1, writer.writeCoverageDetails(TEST_FILE_REF_1, Arrays.asList( newCoverageDetailWithLines(1, MAIN_FILE_REF_1, 1, 3), - newCoverageDetailWithLines(1, MAIN_FILE_REF_1, 2, 4))); + newCoverageDetailWithLines(1, MAIN_FILE_REF_1, 2, 4)))); - sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(root), languageRepository)); + sut.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(root), languageRepository)); FileSourceDto dto = dbClient.fileSourceDao().selectTest(TEST_FILE_UUID_1); List coveredLines = dto.getTestData().get(0).getCoveredFile(0).getCoveredLineList(); @@ -268,13 +271,13 @@ public class PersistTestsStepTest extends BaseStepTest { BatchReportWriter writer = new BatchReportWriter(reportDir); BatchReport.Test newBatchTest = newTest(1); - writer.writeTests(TEST_FILE_REF_1, Arrays.asList(newBatchTest)); + reportReader.putTests(TEST_FILE_REF_1, writer.writeTests(TEST_FILE_REF_1, Arrays.asList(newBatchTest))); CoverageDetail newCoverageDetail = newCoverageDetail(1, MAIN_FILE_REF_1); - writer.writeCoverageDetails(TEST_FILE_REF_1, Arrays.asList(newCoverageDetail)); + reportReader.putCoverageDetails(TEST_FILE_REF_1, writer.writeCoverageDetails(TEST_FILE_REF_1, Arrays.asList(newCoverageDetail))); // ACT - sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(root), languageRepository)); + sut.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, dbClient, ComponentTreeBuilders.from(root), languageRepository)); // ASSERT FileSourceDto dto = dbClient.fileSourceDao().selectTest(TEST_FILE_UUID_1); @@ -319,7 +322,7 @@ public class PersistTestsStepTest extends BaseStepTest { .build(); } - private BatchReportWriter initBasicReport() { + private void initBasicReport() { dbComponentsRefCache.addComponent(1, new DbComponent(1L, "PROJECT_KEY", PROJECT_UUID)); dbComponentsRefCache.addComponent(2, new DbComponent(2L, "MODULE_KEY", "MODULE")); dbComponentsRefCache.addComponent(3, new DbComponent(3L, "TEST_FILE1_KEY", TEST_FILE_UUID_1)); @@ -327,43 +330,40 @@ public class PersistTestsStepTest extends BaseStepTest { dbComponentsRefCache.addComponent(5, new DbComponent(5L, "MAIN_FILE1_KEY", MAIN_FILE_UUID_1)); dbComponentsRefCache.addComponent(6, new DbComponent(6L, "MAIN_FILE2_KEY", MAIN_FILE_UUID_2)); - BatchReportWriter writer = new BatchReportWriter(reportDir); - writer.writeMetadata(BatchReport.Metadata.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder() .setRootComponentRef(1) .setProjectKey(PROJECT_KEY) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .addChildRef(2) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(2) .setType(Constants.ComponentType.MODULE) .addAllChildRef(Arrays.asList(TEST_FILE_REF_1, TEST_FILE_REF_2, MAIN_FILE_REF_1, MAIN_FILE_REF_2)) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(TEST_FILE_REF_1) .setIsTest(true) .setType(Constants.ComponentType.FILE) .setPath(TEST_FILE_PATH_1) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(TEST_FILE_REF_2) .setIsTest(true) .setType(Constants.ComponentType.FILE) .setPath(TEST_FILE_PATH_2) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(MAIN_FILE_REF_1) .setType(Constants.ComponentType.FILE) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(MAIN_FILE_REF_2) .setType(Constants.ComponentType.FILE) .build()); - - return writer; } } diff --git a/server/sonar-server/src/test/java/org/sonar/server/computation/step/PopulateComponentsUuidAndKeyStepTest.java b/server/sonar-server/src/test/java/org/sonar/server/computation/step/PopulateComponentsUuidAndKeyStepTest.java index 6625ca01266..385d00354be 100644 --- a/server/sonar-server/src/test/java/org/sonar/server/computation/step/PopulateComponentsUuidAndKeyStepTest.java +++ b/server/sonar-server/src/test/java/org/sonar/server/computation/step/PopulateComponentsUuidAndKeyStepTest.java @@ -20,7 +20,6 @@ package org.sonar.server.computation.step; -import java.io.File; import java.util.HashMap; import java.util.Map; import org.junit.After; @@ -29,18 +28,16 @@ import org.junit.ClassRule; import org.junit.Rule; import org.junit.Test; import org.junit.experimental.categories.Category; -import org.junit.rules.TemporaryFolder; import org.sonar.api.config.Settings; import org.sonar.batch.protocol.Constants; import org.sonar.batch.protocol.output.BatchReport; -import org.sonar.batch.protocol.output.BatchReportReader; -import org.sonar.batch.protocol.output.BatchReportWriter; import org.sonar.core.component.ComponentDto; import org.sonar.core.persistence.DbSession; import org.sonar.core.persistence.DbTester; import org.sonar.server.component.ComponentTesting; import org.sonar.server.component.db.ComponentDao; import org.sonar.server.computation.ComputationContext; +import org.sonar.server.computation.batch.BatchReportReaderRule; import org.sonar.server.computation.component.Component; import org.sonar.server.computation.component.ComponentTreeBuilders; import org.sonar.server.computation.language.LanguageRepository; @@ -57,11 +54,8 @@ public class PopulateComponentsUuidAndKeyStepTest extends BaseStepTest { @ClassRule public static DbTester dbTester = new DbTester(); - @Rule - public TemporaryFolder temp = new TemporaryFolder(); - - File reportDir; + public BatchReportReaderRule reportReader = new BatchReportReaderRule(); DbSession session; @@ -79,8 +73,6 @@ public class PopulateComponentsUuidAndKeyStepTest extends BaseStepTest { session = dbTester.myBatis().openSession(false); dbClient = new DbClient(dbTester.database(), dbTester.myBatis(), new ComponentDao()); - reportDir = temp.newFolder(); - projectSettings = new Settings(); sut = new PopulateComponentsUuidAndKeyStep(dbClient); } @@ -97,39 +89,36 @@ public class PopulateComponentsUuidAndKeyStepTest extends BaseStepTest { @Test public void compute_keys_and_uuids() throws Exception { - File reportDir = temp.newFolder(); - BatchReportWriter writer = new BatchReportWriter(reportDir); - writer.writeMetadata(BatchReport.Metadata.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder() .setRootComponentRef(1) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .setKey(PROJECT_KEY) .addChildRef(2) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(2) .setType(Constants.ComponentType.MODULE) .setKey("MODULE_KEY") .addChildRef(3) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(3) .setType(Constants.ComponentType.DIRECTORY) .setPath("src/main/java/dir") .addChildRef(4) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(4) .setType(Constants.ComponentType.FILE) .setPath("src/main/java/dir/Foo.java") .build()); - BatchReportReader batchReportReader = new BatchReportReader(reportDir); - ComputationContext context = new ComputationContext(batchReportReader, PROJECT_KEY, projectSettings, - dbClient, ComponentTreeBuilders.from(batchReportReader), languageRepository); + ComputationContext context = new ComputationContext(reportReader, PROJECT_KEY, projectSettings, + dbClient, ComponentTreeBuilders.from(reportReader), languageRepository); sut.execute(context); Map componentsByRef = getComponentsByRef(context.getRoot()); @@ -158,39 +147,36 @@ public class PopulateComponentsUuidAndKeyStepTest extends BaseStepTest { dbClient.componentDao().insert(session, directory, file); session.commit(); - File reportDir = temp.newFolder(); - BatchReportWriter writer = new BatchReportWriter(reportDir); - writer.writeMetadata(BatchReport.Metadata.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder() .setRootComponentRef(1) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .setKey(PROJECT_KEY) .addChildRef(2) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(2) .setType(Constants.ComponentType.MODULE) .setKey("MODULE_KEY") .addChildRef(3) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(3) .setType(Constants.ComponentType.DIRECTORY) .setPath("src/main/java/dir") .addChildRef(4) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(4) .setType(Constants.ComponentType.FILE) .setPath("src/main/java/dir/Foo.java") .build()); - BatchReportReader batchReportReader = new BatchReportReader(reportDir); - ComputationContext context = new ComputationContext(batchReportReader, PROJECT_KEY, projectSettings, - dbClient, ComponentTreeBuilders.from(batchReportReader), languageRepository); + ComputationContext context = new ComputationContext(reportReader, PROJECT_KEY, projectSettings, + dbClient, ComponentTreeBuilders.from(reportReader), languageRepository); sut.execute(context); Map componentsByRef = getComponentsByRef(context.getRoot()); @@ -210,48 +196,45 @@ public class PopulateComponentsUuidAndKeyStepTest extends BaseStepTest { @Test public void use_latest_module_for_files_key() throws Exception { - File reportDir = temp.newFolder(); - BatchReportWriter writer = new BatchReportWriter(reportDir); - writer.writeMetadata(BatchReport.Metadata.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder() .setRootComponentRef(1) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .setKey(PROJECT_KEY) .setName("Project") .addChildRef(2) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(2) .setType(Constants.ComponentType.MODULE) .setKey("MODULE_KEY") .setName("Module") .addChildRef(3) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(3) .setType(Constants.ComponentType.MODULE) .setKey("SUB_MODULE_KEY") .setName("Sub Module") .addChildRef(4) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(4) .setType(Constants.ComponentType.DIRECTORY) .setPath("src/main/java/dir") .addChildRef(5) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(5) .setType(Constants.ComponentType.FILE) .setPath("src/main/java/dir/Foo.java") .build()); - BatchReportReader batchReportReader = new BatchReportReader(reportDir); - ComputationContext context = new ComputationContext(batchReportReader, PROJECT_KEY, projectSettings, - dbClient, ComponentTreeBuilders.from(batchReportReader), languageRepository); + ComputationContext context = new ComputationContext(reportReader, PROJECT_KEY, projectSettings, + dbClient, ComponentTreeBuilders.from(reportReader), languageRepository); sut.execute(context); Map componentsByRef = getComponentsByRef(context.getRoot()); @@ -262,43 +245,40 @@ public class PopulateComponentsUuidAndKeyStepTest extends BaseStepTest { @Test public void use_branch_to_generate_keys() throws Exception { - File reportDir = temp.newFolder(); - BatchReportWriter writer = new BatchReportWriter(reportDir); - writer.writeMetadata(BatchReport.Metadata.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder() .setRootComponentRef(1) .setBranch("origin/master") .setProjectKey("") .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .setKey(PROJECT_KEY) .setName("Project") .addChildRef(2) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(2) .setType(Constants.ComponentType.MODULE) .setKey("MODULE_KEY") .setName("Module") .addChildRef(3) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(3) .setType(Constants.ComponentType.DIRECTORY) .setPath("src/main/java/dir") .addChildRef(4) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(4) .setType(Constants.ComponentType.FILE) .setPath("src/main/java/dir/Foo.java") .build()); - BatchReportReader batchReportReader = new BatchReportReader(reportDir); - ComputationContext context = new ComputationContext(batchReportReader, PROJECT_KEY, projectSettings, - dbClient, ComponentTreeBuilders.from(batchReportReader), languageRepository); + ComputationContext context = new ComputationContext(reportReader, PROJECT_KEY, projectSettings, + dbClient, ComponentTreeBuilders.from(reportReader), languageRepository); sut.execute(context); Map componentsByRef = getComponentsByRef(context.getRoot()); @@ -311,51 +291,48 @@ public class PopulateComponentsUuidAndKeyStepTest extends BaseStepTest { @Test public void compute_keys_and_uuids_on_project_having_module_and_directory() throws Exception { - File reportDir = temp.newFolder(); - BatchReportWriter writer = new BatchReportWriter(reportDir); - writer.writeMetadata(BatchReport.Metadata.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder() .setRootComponentRef(1) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .setKey(PROJECT_KEY) .addChildRef(2) .addChildRef(5) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(2) .setType(Constants.ComponentType.MODULE) .setKey("MODULE_KEY") .addChildRef(3) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(3) .setType(Constants.ComponentType.DIRECTORY) .setPath("src/main/java/dir") .addChildRef(4) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(4) .setType(Constants.ComponentType.FILE) .setPath("src/main/java/dir/Foo.java") .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(5) .setType(Constants.ComponentType.DIRECTORY) .setPath("/") .addChildRef(6) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(6) .setType(Constants.ComponentType.FILE) .setPath("pom.xml") .build()); - BatchReportReader batchReportReader = new BatchReportReader(reportDir); - ComputationContext context = new ComputationContext(batchReportReader, PROJECT_KEY, projectSettings, - dbClient, ComponentTreeBuilders.from(batchReportReader), languageRepository); + ComputationContext context = new ComputationContext(reportReader, PROJECT_KEY, projectSettings, + dbClient, ComponentTreeBuilders.from(reportReader), languageRepository); sut.execute(context); Map componentsByRef = getComponentsByRef(context.getRoot()); @@ -381,45 +358,42 @@ public class PopulateComponentsUuidAndKeyStepTest extends BaseStepTest { @Test public void compute_keys_and_uuids_on_multi_modules() throws Exception { - File reportDir = temp.newFolder(); - BatchReportWriter writer = new BatchReportWriter(reportDir); - writer.writeMetadata(BatchReport.Metadata.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder() .setRootComponentRef(1) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .setKey(PROJECT_KEY) .addChildRef(2) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(2) .setType(Constants.ComponentType.MODULE) .setKey("MODULE_KEY") .addChildRef(3) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(3) .setType(Constants.ComponentType.MODULE) .setKey("SUB_MODULE_KEY") .addChildRef(4) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(4) .setType(Constants.ComponentType.DIRECTORY) .setPath("src/main/java/dir") .addChildRef(5) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(5) .setType(Constants.ComponentType.FILE) .setPath("src/main/java/dir/Foo.java") .build()); - BatchReportReader batchReportReader = new BatchReportReader(reportDir); - ComputationContext context = new ComputationContext(batchReportReader, PROJECT_KEY, projectSettings, - dbClient, ComponentTreeBuilders.from(batchReportReader), languageRepository); + ComputationContext context = new ComputationContext(reportReader, PROJECT_KEY, projectSettings, + dbClient, ComponentTreeBuilders.from(reportReader), languageRepository); sut.execute(context); Map componentsByRef = getComponentsByRef(context.getRoot()); diff --git a/server/sonar-server/src/test/java/org/sonar/server/computation/step/PurgeDatastoresStepTest.java b/server/sonar-server/src/test/java/org/sonar/server/computation/step/PurgeDatastoresStepTest.java index 7ea5c1e066d..db909759c88 100644 --- a/server/sonar-server/src/test/java/org/sonar/server/computation/step/PurgeDatastoresStepTest.java +++ b/server/sonar-server/src/test/java/org/sonar/server/computation/step/PurgeDatastoresStepTest.java @@ -20,22 +20,19 @@ package org.sonar.server.computation.step; -import java.io.File; import java.io.IOException; import org.junit.Before; import org.junit.Rule; import org.junit.Test; -import org.junit.rules.TemporaryFolder; import org.mockito.ArgumentCaptor; import org.mockito.Mockito; import org.sonar.api.config.Settings; import org.sonar.batch.protocol.output.BatchReport; -import org.sonar.batch.protocol.output.BatchReportReader; -import org.sonar.batch.protocol.output.BatchReportWriter; import org.sonar.core.computation.dbcleaner.ProjectCleaner; import org.sonar.core.persistence.DbSession; import org.sonar.core.purge.IdUuidPair; import org.sonar.server.computation.ComputationContext; +import org.sonar.server.computation.batch.BatchReportReaderRule; import org.sonar.server.computation.component.ComponentTreeBuilders; import org.sonar.server.computation.component.DbComponentsRefCache; import org.sonar.server.computation.component.DumbComponent; @@ -51,11 +48,11 @@ import static org.mockito.Mockito.when; public class PurgeDatastoresStepTest extends BaseStepTest { - @Rule - public TemporaryFolder temp = new TemporaryFolder(); - private static final String PROJECT_KEY = "PROJECT_KEY"; + @Rule + public BatchReportReaderRule reportReader = new BatchReportReaderRule(); + ProjectCleaner projectCleaner = mock(ProjectCleaner.class); DbComponentsRefCache dbComponentsRefCache = new DbComponentsRefCache(); ProjectSettingsRepository projectSettingsRepository = mock(ProjectSettingsRepository.class); @@ -73,13 +70,11 @@ public class PurgeDatastoresStepTest extends BaseStepTest { public void call_purge_method_of_the_purge_task() throws IOException { dbComponentsRefCache.addComponent(1, new DbComponentsRefCache.DbComponent(123L, PROJECT_KEY, "UUID-1234")); - File reportDir = temp.newFolder(); - BatchReportWriter writer = new BatchReportWriter(reportDir); - writer.writeMetadata(BatchReport.Metadata.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder() .setRootComponentRef(1) .build()); - ComputationContext context = new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, new Settings(), + ComputationContext context = new ComputationContext(reportReader, PROJECT_KEY, new Settings(), mock(DbClient.class), ComponentTreeBuilders.from(DumbComponent.DUMB_PROJECT), mock(LanguageRepository.class)); sut.execute(context); diff --git a/server/sonar-server/src/test/java/org/sonar/server/computation/step/QualityProfileEventsStepTest.java b/server/sonar-server/src/test/java/org/sonar/server/computation/step/QualityProfileEventsStepTest.java index 93003167e09..e2dd85639f8 100644 --- a/server/sonar-server/src/test/java/org/sonar/server/computation/step/QualityProfileEventsStepTest.java +++ b/server/sonar-server/src/test/java/org/sonar/server/computation/step/QualityProfileEventsStepTest.java @@ -27,10 +27,10 @@ import org.sonar.api.measures.CoreMetrics; import org.sonar.api.resources.AbstractLanguage; import org.sonar.api.resources.Language; import org.sonar.batch.protocol.output.BatchReport; -import org.sonar.batch.protocol.output.BatchReportReader; import org.sonar.core.UtcDateUtils; import org.sonar.core.measure.db.MeasureDto; import org.sonar.server.computation.ComputationContext; +import org.sonar.server.computation.batch.BatchReportReader; import org.sonar.server.computation.component.Component; import org.sonar.server.computation.component.ComponentTreeBuilder; import org.sonar.server.computation.component.DumbComponent; diff --git a/server/sonar-server/src/test/java/org/sonar/server/computation/step/SendIssueNotificationsStepTest.java b/server/sonar-server/src/test/java/org/sonar/server/computation/step/SendIssueNotificationsStepTest.java index 317cb70cd76..a6ffa61757b 100644 --- a/server/sonar-server/src/test/java/org/sonar/server/computation/step/SendIssueNotificationsStepTest.java +++ b/server/sonar-server/src/test/java/org/sonar/server/computation/step/SendIssueNotificationsStepTest.java @@ -19,6 +19,7 @@ */ package org.sonar.server.computation.step; +import java.io.IOException; import org.junit.Before; import org.junit.Rule; import org.junit.Test; @@ -31,9 +32,8 @@ import org.sonar.api.rule.Severity; import org.sonar.api.utils.System2; import org.sonar.batch.protocol.Constants; import org.sonar.batch.protocol.output.BatchReport; -import org.sonar.batch.protocol.output.BatchReportReader; -import org.sonar.batch.protocol.output.BatchReportWriter; import org.sonar.server.computation.ComputationContext; +import org.sonar.server.computation.batch.BatchReportReaderRule; import org.sonar.server.computation.component.Component; import org.sonar.server.computation.component.ComponentTreeBuilders; import org.sonar.server.computation.component.DbComponentsRefCache; @@ -47,9 +47,6 @@ import org.sonar.server.issue.notification.NewIssuesNotification; import org.sonar.server.issue.notification.NewIssuesNotificationFactory; import org.sonar.server.notifications.NotificationService; -import java.io.File; -import java.io.IOException; - import static org.mockito.Mockito.any; import static org.mockito.Mockito.atLeastOnce; import static org.mockito.Mockito.mock; @@ -62,6 +59,8 @@ public class SendIssueNotificationsStepTest extends BaseStepTest { private static final String PROJECT_UUID = "PROJECT_UUID"; private static final String PROJECT_KEY = "PROJECT_KEY"; + @Rule + public BatchReportReaderRule reportReader = new BatchReportReaderRule(); @Rule public TemporaryFolder temp = new TemporaryFolder(); @@ -73,8 +72,6 @@ public class SendIssueNotificationsStepTest extends BaseStepTest { Settings projectSettings = new Settings(); SendIssueNotificationsStep sut; - File reportDir; - @Before public void setUp() throws Exception { issueCache = new IssueCache(temp.newFile(), System2.INSTANCE); @@ -83,12 +80,10 @@ public class SendIssueNotificationsStepTest extends BaseStepTest { dbComponentsRefCache.addComponent(1, new DbComponentsRefCache.DbComponent(1L, PROJECT_KEY, PROJECT_UUID)); - reportDir = temp.newFolder(); - BatchReportWriter writer = new BatchReportWriter(reportDir); - writer.writeMetadata(BatchReport.Metadata.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder() .setRootComponentRef(1) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .setKey(PROJECT_KEY) @@ -100,7 +95,7 @@ public class SendIssueNotificationsStepTest extends BaseStepTest { public void do_not_send_notifications_if_no_subscribers() throws IOException { when(notifService.hasProjectSubscribersForTypes(PROJECT_UUID, SendIssueNotificationsStep.NOTIF_TYPES)).thenReturn(false); - sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, + sut.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, mock(DbClient.class), ComponentTreeBuilders.from(new DumbComponent(Component.Type.PROJECT, 1, null, null)), mock(LanguageRepository.class))); verify(notifService, never()).deliver(any(Notification.class)); @@ -113,7 +108,7 @@ public class SendIssueNotificationsStepTest extends BaseStepTest { when(notifService.hasProjectSubscribersForTypes(PROJECT_UUID, SendIssueNotificationsStep.NOTIF_TYPES)).thenReturn(true); - sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY, projectSettings, + sut.execute(new ComputationContext(reportReader, PROJECT_KEY, projectSettings, mock(DbClient.class), ComponentTreeBuilders.from(new DumbComponent(Component.Type.PROJECT, 1, null, null)), mock(LanguageRepository.class))); verify(notifService).deliver(any(NewIssuesNotification.class)); diff --git a/server/sonar-server/src/test/java/org/sonar/server/computation/step/ValidateProjectStepTest.java b/server/sonar-server/src/test/java/org/sonar/server/computation/step/ValidateProjectStepTest.java index 8bfcf5a067a..33b34698f0f 100644 --- a/server/sonar-server/src/test/java/org/sonar/server/computation/step/ValidateProjectStepTest.java +++ b/server/sonar-server/src/test/java/org/sonar/server/computation/step/ValidateProjectStepTest.java @@ -20,26 +20,23 @@ package org.sonar.server.computation.step; -import java.io.File; import org.junit.After; import org.junit.Before; import org.junit.ClassRule; import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; -import org.junit.rules.TemporaryFolder; import org.sonar.api.CoreProperties; import org.sonar.api.config.Settings; import org.sonar.batch.protocol.Constants; import org.sonar.batch.protocol.output.BatchReport; -import org.sonar.batch.protocol.output.BatchReportReader; -import org.sonar.batch.protocol.output.BatchReportWriter; import org.sonar.core.component.ComponentDto; import org.sonar.core.persistence.DbSession; import org.sonar.core.persistence.DbTester; import org.sonar.server.component.ComponentTesting; import org.sonar.server.component.db.ComponentDao; import org.sonar.server.computation.ComputationContext; +import org.sonar.server.computation.batch.BatchReportReaderRule; import org.sonar.server.computation.component.Component; import org.sonar.server.computation.component.ComponentTreeBuilders; import org.sonar.server.computation.component.DumbComponent; @@ -50,14 +47,12 @@ public class ValidateProjectStepTest { private static final String PROJECT_KEY = "PROJECT_KEY"; private static final String MODULE_KEY = "MODULE_KEY"; - @Rule - public ExpectedException thrown = ExpectedException.none(); - @ClassRule public static DbTester dbTester = new DbTester(); - @Rule - public TemporaryFolder temp = new TemporaryFolder(); + public ExpectedException thrown = ExpectedException.none(); + @Rule + public BatchReportReaderRule reportReader = new BatchReportReaderRule(); DbClient dbClient; @@ -65,9 +60,6 @@ public class ValidateProjectStepTest { Settings settings; - File reportDir; - BatchReportWriter writer; - ValidateProjectStep sut; @Before @@ -76,8 +68,6 @@ public class ValidateProjectStepTest { dbClient = new DbClient(dbTester.database(), dbTester.myBatis(), new ComponentDao()); dbSession = dbClient.openSession(false); settings = new Settings(); - reportDir = temp.newFolder(); - writer = new BatchReportWriter(reportDir); sut = new ValidateProjectStep(dbClient, settings); } @@ -89,8 +79,8 @@ public class ValidateProjectStepTest { @Test public void not_fail_if_provisioning_enforced_and_project_exists() throws Exception { - writer.writeMetadata(BatchReport.Metadata.newBuilder().build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder().build()); + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .setKey(PROJECT_KEY) @@ -100,7 +90,7 @@ public class ValidateProjectStepTest { dbClient.componentDao().insert(dbSession, ComponentTesting.newProjectDto("ABCD").setKey(PROJECT_KEY)); dbSession.commit(); - sut.execute(new ComputationContext(new BatchReportReader(reportDir), null, null, null, + sut.execute(new ComputationContext(reportReader, null, null, null, ComponentTreeBuilders.from(new DumbComponent(Component.Type.PROJECT, 1, "ABCD", PROJECT_KEY)), null)); } @@ -109,8 +99,8 @@ public class ValidateProjectStepTest { thrown.expect(IllegalArgumentException.class); thrown.expectMessage("Unable to scan non-existing project '" + PROJECT_KEY + "'"); - writer.writeMetadata(BatchReport.Metadata.newBuilder().build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder().build()); + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .setKey(PROJECT_KEY) @@ -118,14 +108,14 @@ public class ValidateProjectStepTest { settings.appendProperty(CoreProperties.CORE_PREVENT_AUTOMATIC_PROJECT_CREATION, "true"); - sut.execute(new ComputationContext(new BatchReportReader(reportDir), null, null, null, + sut.execute(new ComputationContext(reportReader, null, null, null, ComponentTreeBuilders.from(new DumbComponent(Component.Type.PROJECT, 1, "ABCD", PROJECT_KEY)), null)); } @Test public void fail_if_provisioning_not_enforced_and_project_does_not_exists() throws Exception { - writer.writeMetadata(BatchReport.Metadata.newBuilder().build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder().build()); + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .setKey(PROJECT_KEY) @@ -133,22 +123,22 @@ public class ValidateProjectStepTest { settings.appendProperty(CoreProperties.CORE_PREVENT_AUTOMATIC_PROJECT_CREATION, "false"); - sut.execute(new ComputationContext(new BatchReportReader(reportDir), null, null, null, + sut.execute(new ComputationContext(reportReader, null, null, null, ComponentTreeBuilders.from(new DumbComponent(Component.Type.PROJECT, 1, "ABCD", PROJECT_KEY)), null)); } @Test public void not_fail_on_valid_branch() throws Exception { - writer.writeMetadata(BatchReport.Metadata.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder() .setBranch("origin/master") .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .setKey(PROJECT_KEY) .build()); - sut.execute(new ComputationContext(new BatchReportReader(reportDir), null, null, null, + sut.execute(new ComputationContext(reportReader, null, null, null, ComponentTreeBuilders.from(new DumbComponent(Component.Type.PROJECT, 1, "ABCD", PROJECT_KEY + ":origin/master")), null)); } @@ -158,16 +148,16 @@ public class ValidateProjectStepTest { thrown.expectMessage("Validation of project failed:\n" + " o \"bran#ch\" is not a valid branch name. Allowed characters are alphanumeric, '-', '_', '.' and '/'."); - writer.writeMetadata(BatchReport.Metadata.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder() .setBranch("bran#ch") .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .setKey(PROJECT_KEY) .build()); - sut.execute(new ComputationContext(new BatchReportReader(reportDir), null, null, null, + sut.execute(new ComputationContext(reportReader, null, null, null, ComponentTreeBuilders.from(new DumbComponent(Component.Type.PROJECT, 1, "ABCD", PROJECT_KEY + ":bran#ch")), null)); } @@ -180,14 +170,14 @@ public class ValidateProjectStepTest { " o \"Project\\Key\" is not a valid project or module key. Allowed characters are alphanumeric, '-', '_', '.' and ':', with at least one non-digit.\n" + " o \"Module$Key\" is not a valid project or module key. Allowed characters are alphanumeric, '-', '_', '.' and ':', with at least one non-digit"); - writer.writeMetadata(BatchReport.Metadata.newBuilder().build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder().build()); + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .setKey(invalidProjectKey) .addChildRef(2) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(2) .setType(Constants.ComponentType.MODULE) .setKey("Module$Key") @@ -195,7 +185,7 @@ public class ValidateProjectStepTest { DumbComponent root = new DumbComponent(Component.Type.PROJECT, 1, "ABCD", invalidProjectKey, new DumbComponent(Component.Type.MODULE, 2, "BCDE", "Module$Key")); - sut.execute(new ComputationContext(new BatchReportReader(reportDir), null, null, null, ComponentTreeBuilders.from(root), null)); + sut.execute(new ComputationContext(reportReader, null, null, null, ComponentTreeBuilders.from(root), null)); } @Test @@ -206,14 +196,14 @@ public class ValidateProjectStepTest { "If you really want to stop directly analysing project \"" + MODULE_KEY + "\", please first delete it from SonarQube and then relaunch the analysis of project \"" + PROJECT_KEY + "\"."); - writer.writeMetadata(BatchReport.Metadata.newBuilder().build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder().build()); + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .setKey(PROJECT_KEY) .addChildRef(2) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(2) .setType(Constants.ComponentType.MODULE) .setKey(MODULE_KEY) @@ -225,7 +215,7 @@ public class ValidateProjectStepTest { DumbComponent root = new DumbComponent(Component.Type.PROJECT, 1, "ABCD", PROJECT_KEY, new DumbComponent(Component.Type.MODULE, 2, "BCDE", MODULE_KEY)); - sut.execute(new ComputationContext(new BatchReportReader(reportDir), null, null, null, + sut.execute(new ComputationContext(reportReader, null, null, null, ComponentTreeBuilders.from(root), null)); } @@ -236,14 +226,14 @@ public class ValidateProjectStepTest { thrown.expectMessage("Validation of project failed:\n" + " o Module \"" + MODULE_KEY + "\" is already part of project \"" + anotherProjectKey + "\""); - writer.writeMetadata(BatchReport.Metadata.newBuilder().build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder().build()); + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .setKey(PROJECT_KEY) .addChildRef(2) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(2) .setType(Constants.ComponentType.MODULE) .setKey(MODULE_KEY) @@ -258,7 +248,7 @@ public class ValidateProjectStepTest { DumbComponent root = new DumbComponent(Component.Type.PROJECT, 1, "ABCD", PROJECT_KEY, new DumbComponent(Component.Type.MODULE, 2, "BCDE", MODULE_KEY)); - sut.execute(new ComputationContext(new BatchReportReader(reportDir), null, null, null, + sut.execute(new ComputationContext(reportReader, null, null, null, ComponentTreeBuilders.from(root), null)); } @@ -271,14 +261,14 @@ public class ValidateProjectStepTest { "If you really want to stop directly analysing project \"" + anotherProjectKey + "\", please first delete it from SonarQube and then relaunch the analysis of project \"" + PROJECT_KEY + "\"."); - writer.writeMetadata(BatchReport.Metadata.newBuilder().build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.setMetadata(BatchReport.Metadata.newBuilder().build()); + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(1) .setType(Constants.ComponentType.PROJECT) .setKey(PROJECT_KEY) .addChildRef(2) .build()); - writer.writeComponent(BatchReport.Component.newBuilder() + reportReader.putComponent(BatchReport.Component.newBuilder() .setRef(2) .setType(Constants.ComponentType.MODULE) .setKey(MODULE_KEY) @@ -292,7 +282,7 @@ public class ValidateProjectStepTest { DumbComponent root = new DumbComponent(Component.Type.PROJECT, 1, "ABCD", PROJECT_KEY, new DumbComponent(Component.Type.MODULE, 2, "BCDE", MODULE_KEY)); - sut.execute(new ComputationContext(new BatchReportReader(reportDir), null, null, null, + sut.execute(new ComputationContext(reportReader, null, null, null, ComponentTreeBuilders.from(root), null)); } diff --git a/sonar-batch-protocol/src/main/java/org/sonar/batch/protocol/output/BatchReportWriter.java b/sonar-batch-protocol/src/main/java/org/sonar/batch/protocol/output/BatchReportWriter.java index 9a58c825c0b..1a771af3b41 100644 --- a/sonar-batch-protocol/src/main/java/org/sonar/batch/protocol/output/BatchReportWriter.java +++ b/sonar-batch-protocol/src/main/java/org/sonar/batch/protocol/output/BatchReportWriter.java @@ -19,9 +19,8 @@ */ package org.sonar.batch.protocol.output; -import org.sonar.batch.protocol.ProtobufUtil; - import java.io.File; +import org.sonar.batch.protocol.ProtobufUtil; public class BatchReportWriter { @@ -46,83 +45,95 @@ public class BatchReportWriter { /** * Metadata is mandatory */ - public void writeMetadata(BatchReport.Metadata metadata) { + public File writeMetadata(BatchReport.Metadata metadata) { ProtobufUtil.writeToFile(metadata, fileStructure.metadataFile()); + return fileStructure.metadataFile(); } - public void writeComponent(BatchReport.Component component) { + public File writeComponent(BatchReport.Component component) { File file = fileStructure.fileFor(FileStructure.Domain.COMPONENT, component.getRef()); ProtobufUtil.writeToFile(component, file); + return file; } - public void writeComponentIssues(int componentRef, Iterable issues) { + public File writeComponentIssues(int componentRef, Iterable issues) { BatchReport.Issues.Builder issuesBuilder = BatchReport.Issues.newBuilder(); issuesBuilder.setComponentRef(componentRef); issuesBuilder.addAllIssue(issues); File file = fileStructure.fileFor(FileStructure.Domain.ISSUES, componentRef); ProtobufUtil.writeToFile(issuesBuilder.build(), file); + return file; } - public void writeComponentMeasures(int componentRef, Iterable measures) { + public File writeComponentMeasures(int componentRef, Iterable measures) { BatchReport.Measures.Builder measuresBuilder = BatchReport.Measures.newBuilder(); measuresBuilder.setComponentRef(componentRef); measuresBuilder.addAllMeasure(measures); File file = fileStructure.fileFor(FileStructure.Domain.MEASURES, componentRef); ProtobufUtil.writeToFile(measuresBuilder.build(), file); + return file; } - public void writeComponentChangesets(BatchReport.Changesets changesets) { + public File writeComponentChangesets(BatchReport.Changesets changesets) { File file = fileStructure.fileFor(FileStructure.Domain.CHANGESETS, changesets.getComponentRef()); ProtobufUtil.writeToFile(changesets, file); + return file; } /** * Issues on components which have been deleted are stored in another location. * Temporary hack, waiting for computation stack */ - public void writeDeletedComponentIssues(int componentRef, String componentUuid, Iterable issues) { + public File writeDeletedComponentIssues(int componentRef, String componentUuid, Iterable issues) { BatchReport.Issues.Builder issuesBuilder = BatchReport.Issues.newBuilder(); issuesBuilder.setComponentRef(componentRef); issuesBuilder.setComponentUuid(componentUuid); issuesBuilder.addAllIssue(issues); File file = fileStructure.fileFor(FileStructure.Domain.ISSUES_ON_DELETED, componentRef); ProtobufUtil.writeToFile(issuesBuilder.build(), file); + return file; } - public void writeComponentDuplications(int componentRef, Iterable duplications) { + public File writeComponentDuplications(int componentRef, Iterable duplications) { BatchReport.Duplications.Builder builder = BatchReport.Duplications.newBuilder(); builder.setComponentRef(componentRef); builder.addAllDuplication(duplications); File file = fileStructure.fileFor(FileStructure.Domain.DUPLICATIONS, componentRef); ProtobufUtil.writeToFile(builder.build(), file); + return file; } - public void writeComponentSymbols(int componentRef, Iterable symbols) { + public File writeComponentSymbols(int componentRef, Iterable symbols) { BatchReport.Symbols.Builder builder = BatchReport.Symbols.newBuilder(); builder.setFileRef(componentRef); builder.addAllSymbol(symbols); File file = fileStructure.fileFor(FileStructure.Domain.SYMBOLS, componentRef); ProtobufUtil.writeToFile(builder.build(), file); + return file; } - public void writeComponentSyntaxHighlighting(int componentRef, Iterable syntaxHighlightingRules) { + public File writeComponentSyntaxHighlighting(int componentRef, Iterable syntaxHighlightingRules) { File file = fileStructure.fileFor(FileStructure.Domain.SYNTAX_HIGHLIGHTINGS, componentRef); ProtobufUtil.writeMessagesToFile(syntaxHighlightingRules, file); + return file; } - public void writeComponentCoverage(int componentRef, Iterable coverageList) { + public File writeComponentCoverage(int componentRef, Iterable coverageList) { File file = fileStructure.fileFor(FileStructure.Domain.COVERAGES, componentRef); ProtobufUtil.writeMessagesToFile(coverageList, file); + return file; } - public void writeTests(int componentRef, Iterable tests) { + public File writeTests(int componentRef, Iterable tests) { File file = fileStructure.fileFor(FileStructure.Domain.TESTS, componentRef); ProtobufUtil.writeMessagesToFile(tests, file); + return file; } - public void writeCoverageDetails(int componentRef, Iterable tests) { + public File writeCoverageDetails(int componentRef, Iterable tests) { File file = fileStructure.fileFor(FileStructure.Domain.COVERAGE_DETAILS, componentRef); ProtobufUtil.writeMessagesToFile(tests, file); + return file; } public File getSourceFile(int componentRef) { -- 2.39.5