package org.sonar.server.computation;
import org.sonar.api.config.Settings;
-import org.sonar.batch.protocol.output.BatchReport;
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.db.DbClient;
public class ComputationContext implements org.sonar.server.computation.context.ComputationContext {
- private final BatchReportReader reportReader;
private final DbClient dbClient;
- // cache of metadata as it's frequently accessed
- private final BatchReport.Metadata reportMetadata;
private final Component component;
private final LanguageRepository languageRepository;
public ComputationContext(BatchReportReader reportReader, String projectKey, Settings projectSettings, DbClient dbClient,
ComponentTreeBuilder componentTreeBuilder, LanguageRepository languageRepository) {
- this.reportReader = reportReader;
this.dbClient = dbClient;
- this.reportMetadata = reportReader.readMetadata();
this.component = componentTreeBuilder.build(this);
this.languageRepository = languageRepository;
}
- public BatchReport.Metadata getReportMetadata() {
- return reportMetadata;
- }
-
- public BatchReportReader getReportReader() {
- return reportReader;
- }
-
@Override
public Component getRoot() {
return component;
}
private Component buildComponentRoot(ComputationContext computationContext, BatchReportReader reportReader) {
- int rootComponentRef = computationContext.getReportMetadata().getRootComponentRef();
+ int rootComponentRef = reportReader.readMetadata().getRootComponentRef();
BatchReport.Component component = reportReader.readComponent(rootComponentRef);
return new ComponentImpl(computationContext, component, reportReader, buildComponent(computationContext, rootComponentRef));
}
import org.sonar.api.utils.log.Loggers;
import org.sonar.batch.protocol.output.BatchReport;
import org.sonar.core.rule.RuleDto;
-import org.sonar.server.computation.ComputationContext;
import org.sonar.server.computation.batch.BatchReportReader;
import org.sonar.server.computation.component.ProjectSettingsRepository;
import org.sonar.server.user.index.UserDoc;
this.diskIssuesAppender = issueCache.newAppender();
}
- public void processComponentIssues(ComputationContext context, Iterable<BatchReport.Issue> issues, String componentUuid, @Nullable Integer componentReportRef,
+ public void processComponentIssues(Iterable<BatchReport.Issue> issues, String componentUuid, @Nullable Integer componentReportRef,
String projectKey, String projectUuid) {
linesCache.init(componentUuid, componentReportRef, reportReader);
computeDefaultAssignee(projectSettingsRepository.getProjectSettings(projectKey).getString(CoreProperties.DEFAULT_ISSUE_ASSIGNEE));
for (BatchReport.Issue reportIssue : issues) {
- DefaultIssue issue = toDefaultIssue(context, componentUuid, reportIssue, projectKey, projectUuid);
+ DefaultIssue issue = toDefaultIssue(componentUuid, reportIssue, projectKey, projectUuid);
if (issue.isNew()) {
guessAuthor(issue);
autoAssign(issue, defaultAssignee);
linesCache.clear();
}
- private DefaultIssue toDefaultIssue(ComputationContext context, String componentUuid, BatchReport.Issue issue, String projectKey, String projectUuid) {
+ private DefaultIssue toDefaultIssue(String componentUuid, BatchReport.Issue issue, String projectKey, String projectUuid) {
DefaultIssue target = new DefaultIssue();
target.setKey(issue.getUuid());
target.setComponentUuid(componentUuid);
target.setDebt(issue.hasDebtInMinutes() ? Duration.create(issue.getDebtInMinutes()) : null);
if (issue.hasDiffFields()) {
FieldDiffs fieldDiffs = FieldDiffs.parse(issue.getDiffFields());
- fieldDiffs.setCreationDate(new Date(context.getReportMetadata().getAnalysisDate()));
+ fieldDiffs.setCreationDate(new Date(reportReader.readMetadata().getAnalysisDate()));
target.setCurrentChange(fieldDiffs);
}
target.setStatus(issue.getStatus());
import org.sonar.core.resource.ResourceIndexerDao;
import org.sonar.server.computation.ComputationContext;
+import org.sonar.server.computation.batch.BatchReportReader;
import org.sonar.server.computation.component.DbComponentsRefCache;
/**
public class IndexComponentsStep implements ComputationStep {
private final ResourceIndexerDao resourceIndexerDao;
private final DbComponentsRefCache dbComponentsRefCache;
+ private final BatchReportReader reportReader;
- public IndexComponentsStep(ResourceIndexerDao resourceIndexerDao, DbComponentsRefCache dbComponentsRefCache) {
+ public IndexComponentsStep(ResourceIndexerDao resourceIndexerDao, DbComponentsRefCache dbComponentsRefCache, BatchReportReader reportReader) {
this.resourceIndexerDao = resourceIndexerDao;
this.dbComponentsRefCache = dbComponentsRefCache;
+ this.reportReader = reportReader;
}
@Override
public void execute(ComputationContext context) {
- resourceIndexerDao.indexProject(dbComponentsRefCache.getByRef(context.getReportMetadata().getRootComponentRef()).getId());
+ resourceIndexerDao.indexProject(dbComponentsRefCache.getByRef(reportReader.readMetadata().getRootComponentRef()).getId());
}
@Override
package org.sonar.server.computation.step;
import org.sonar.server.computation.ComputationContext;
+import org.sonar.server.computation.batch.BatchReportReader;
import org.sonar.server.computation.component.DbComponentsRefCache;
import org.sonar.server.source.index.SourceLineIndexer;
private final SourceLineIndexer indexer;
private final DbComponentsRefCache dbComponentsRefCache;
+ private final BatchReportReader reportReader;
- public IndexSourceLinesStep(SourceLineIndexer indexer, DbComponentsRefCache dbComponentsRefCache) {
+ public IndexSourceLinesStep(SourceLineIndexer indexer, DbComponentsRefCache dbComponentsRefCache, BatchReportReader reportReader) {
this.indexer = indexer;
this.dbComponentsRefCache = dbComponentsRefCache;
+ this.reportReader = reportReader;
}
@Override
public void execute(ComputationContext context) {
- indexer.index(dbComponentsRefCache.getByRef(context.getReportMetadata().getRootComponentRef()).getUuid());
+ indexer.index(dbComponentsRefCache.getByRef(reportReader.readMetadata().getRootComponentRef()).getUuid());
}
@Override
package org.sonar.server.computation.step;
import org.sonar.server.computation.ComputationContext;
+import org.sonar.server.computation.batch.BatchReportReader;
import org.sonar.server.computation.component.DbComponentsRefCache;
import org.sonar.server.test.index.TestIndexer;
private final TestIndexer indexer;
private final DbComponentsRefCache dbComponentsRefCache;
+ private final BatchReportReader reportReader;
- public IndexTestsStep(TestIndexer indexer, DbComponentsRefCache dbComponentsRefCache) {
+ public IndexTestsStep(TestIndexer indexer, DbComponentsRefCache dbComponentsRefCache, BatchReportReader reportReader) {
this.indexer = indexer;
this.dbComponentsRefCache = dbComponentsRefCache;
+ this.reportReader = reportReader;
}
@Override
public void execute(ComputationContext context) {
- indexer.index(dbComponentsRefCache.getByRef(context.getReportMetadata().getRootComponentRef()).getUuid());
+ indexer.index(dbComponentsRefCache.getByRef(reportReader.readMetadata().getRootComponentRef()).getUuid());
}
@Override
}
private void processDeletedComponents(ComputationContext context, IssueDepthTraversalTypeAwareVisitor visitor) {
- int deletedComponentsCount = context.getReportMetadata().getDeletedComponentsCount();
+ int deletedComponentsCount = reportReader.readMetadata().getDeletedComponentsCount();
for (int componentRef = 1; componentRef <= deletedComponentsCount; componentRef++) {
BatchReport.Issues issues = reportReader.readDeletedComponentIssues(componentRef);
- issueComputation.processComponentIssues(context, issues.getIssueList(), issues.getComponentUuid(), null, visitor.projectKey, visitor.projectUuid);
+ issueComputation.processComponentIssues(issues.getIssueList(), issues.getComponentUuid(), null, visitor.projectKey, visitor.projectUuid);
}
}
private void executeForComponent(Component component, ComputationContext context) {
int componentRef = component.getRef();
List<BatchReport.Issue> issues = reportReader.readComponentIssues(componentRef);
- issueComputation.processComponentIssues(context, issues, component.getUuid(), componentRef, projectKey, projectUuid);
+ issueComputation.processComponentIssues(issues, component.getUuid(), componentRef, projectKey, projectUuid);
}
}
}
try {
MetricDto duplicationMetric = dbClient.metricDao().selectByKey(session, CoreMetrics.DUPLICATIONS_DATA_KEY);
DuplicationContext duplicationContext = new DuplicationContext(context, duplicationMetric, session);
- int rootComponentRef = context.getReportMetadata().getRootComponentRef();
+ int rootComponentRef = reportReader.readMetadata().getRootComponentRef();
recursivelyProcessComponent(duplicationContext, rootComponentRef);
session.commit();
} finally {
public void execute(ComputationContext context) {
DbSession session = dbClient.openSession(false);
try {
- int rootComponentRef = context.getReportMetadata().getRootComponentRef();
+ int rootComponentRef = reportReader.readMetadata().getRootComponentRef();
recursivelyProcessComponent(session, context, rootComponentRef);
session.commit();
} finally {
private void recursivelyProcessComponent(DbSession session, ComputationContext context, int componentRef) {
BatchReport.Component component = reportReader.readComponent(componentRef);
- processEvents(session, component, context.getReportMetadata().getAnalysisDate());
- saveVersionEvent(session, component, context.getReportMetadata().getAnalysisDate());
+ long analysisDate = reportReader.readMetadata().getAnalysisDate();
+ processEvents(session, component, analysisDate);
+ saveVersionEvent(session, component, analysisDate);
for (Integer childRef : component.getChildRefList()) {
recursivelyProcessComponent(session, context, childRef);
@Override
public void execute(ComputationContext context) {
- int rootComponentRef = context.getReportMetadata().getRootComponentRef();
+ int rootComponentRef = reportReader.readMetadata().getRootComponentRef();
// Don't use batch insert for file_sources since keeping all data in memory can produce OOM for big files
DbSession session = dbClient.openSession(false);
try {
final Map<String, FileSourceDto> previousFileSourcesByUuid = new HashMap<>();
- String projectUuid = dbComponentsRefCache.getByRef(context.getReportMetadata().getRootComponentRef()).getUuid();
+ String projectUuid = dbComponentsRefCache.getByRef(rootComponentRef).getUuid();
session.select("org.sonar.core.source.db.FileSourceMapper.selectHashesForProject", ImmutableMap.of("projectUuid", projectUuid, "dataType", Type.SOURCE),
new ResultHandler() {
@Override
@Override
public void execute(ComputationContext context) {
- int rootComponentRef = context.getReportMetadata().getRootComponentRef();
+ int rootComponentRef = reportReader.readMetadata().getRootComponentRef();
try (DbSession dbSession = dbClient.openSession(true)) {
recursivelyProcessComponent(dbSession, context, rootComponentRef);
dbSession.commit();
@Override
public void execute(ComputationContext context) {
- int rootComponentRef = context.getReportMetadata().getRootComponentRef();
+ int rootComponentRef = reportReader.readMetadata().getRootComponentRef();
recursivelyProcessComponent(context, rootComponentRef);
if (!commitFound()) {
- Long lastCommitFromIndex = lastCommitFromIndex(dbComponentsRefCache.getByRef(context.getReportMetadata().getRootComponentRef()).getUuid());
+ Long lastCommitFromIndex = lastCommitFromIndex(dbComponentsRefCache.getByRef(rootComponentRef).getUuid());
lastCommitTimestamp = firstNonNull(lastCommitFromIndex, lastCommitTimestamp);
}
dbClient.measureDao().insert(dbSession, new MeasureDto()
.setValue((double) numberOfDaysSinceLastCommit)
.setMetricId(metricCache.get(CoreMetrics.DAYS_SINCE_LAST_COMMIT_KEY).getId())
- .setSnapshotId(context.getReportMetadata().getSnapshotId()));
+ .setSnapshotId(reportReader.readMetadata().getSnapshotId()));
dbSession.commit();
} finally {
MyBatis.closeQuietly(dbSession);
public void execute(ComputationContext context) {
DbSession session = dbClient.openSession(false);
try {
- int rootComponentRef = context.getReportMetadata().getRootComponentRef();
+ int rootComponentRef = reportReader.readMetadata().getRootComponentRef();
recursivelyProcessComponent(session, context, rootComponentRef);
session.commit();
} finally {
visitor.visit(context.getRoot());
session.commit();
if (visitor.hasUnprocessedCoverageDetails) {
- String projectKey = dbComponentsRefCache.getByRef(context.getReportMetadata().getRootComponentRef()).getKey();
+ String projectKey = dbComponentsRefCache.getByRef(reportReader.readMetadata().getRootComponentRef()).getKey();
LOG.warn("Some coverage tests are not taken into account during analysis of project '{}'", projectKey);
}
} finally {
public void execute(ComputationContext context) {
DbSession session = dbClient.openSession(false);
try {
- String branch = context.getReportMetadata().hasBranch() ? context.getReportMetadata().getBranch() : null;
- BatchReport.Component project = reportReader.readComponent(context.getReportMetadata().getRootComponentRef());
+ BatchReport.Metadata metadata = reportReader.readMetadata();
+ String branch = metadata.hasBranch() ? metadata.getBranch() : null;
+ BatchReport.Component project = reportReader.readComponent(metadata.getRootComponentRef());
String projectKey = ComponentKeys.createKey(project.getKey(), branch);
Map<String, String> componentUuidsByKey = new HashMap<>();
import org.sonar.core.persistence.MyBatis;
import org.sonar.core.purge.IdUuidPair;
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.component.ProjectSettingsRepository;
import org.sonar.server.db.DbClient;
private final DbClient dbClient;
private final DbComponentsRefCache dbComponentsRefCache;
private final ProjectSettingsRepository projectSettingsRepository;
+ private final BatchReportReader reportReader;
- public PurgeDatastoresStep(DbClient dbClient, ProjectCleaner projectCleaner, DbComponentsRefCache dbComponentsRefCache, ProjectSettingsRepository projectSettingsRepository) {
+ public PurgeDatastoresStep(DbClient dbClient, ProjectCleaner projectCleaner, DbComponentsRefCache dbComponentsRefCache, ProjectSettingsRepository projectSettingsRepository, BatchReportReader reportReader) {
this.projectCleaner = projectCleaner;
this.dbClient = dbClient;
this.dbComponentsRefCache = dbComponentsRefCache;
this.projectSettingsRepository = projectSettingsRepository;
+ this.reportReader = reportReader;
}
@Override
public void execute(ComputationContext context) {
DbSession session = dbClient.openSession(true);
try {
- DbComponentsRefCache.DbComponent project = dbComponentsRefCache.getByRef(context.getReportMetadata().getRootComponentRef());
+ DbComponentsRefCache.DbComponent project = dbComponentsRefCache.getByRef(reportReader.readMetadata().getRootComponentRef());
projectCleaner.purge(session, new IdUuidPair(project.getId(), project.getUuid()), projectSettingsRepository.getProjectSettings(project.getKey()));
session.commit();
} finally {
@Override
public void execute(ComputationContext context) {
- DbComponent project = dbComponentsRefCache.getByRef(context.getReportMetadata().getRootComponentRef());
+ DbComponent project = dbComponentsRefCache.getByRef(reportReader.readMetadata().getRootComponentRef());
if (service.hasProjectSubscribersForTypes(project.getUuid(), NOTIF_TYPES)) {
- doExecute(context, project);
+ doExecute(project);
}
}
- private void doExecute(ComputationContext context, DbComponent project) {
+ private void doExecute(DbComponent project) {
NewIssuesStatistics newIssuesStats = new NewIssuesStatistics();
CloseableIterator<DefaultIssue> issues = issueCache.traverse();
- String projectName = reportReader.readComponent(context.getReportMetadata().getRootComponentRef()).getName();
+ String projectName = reportReader.readComponent(reportReader.readMetadata().getRootComponentRef()).getName();
try {
while (issues.hasNext()) {
DefaultIssue issue = issues.next();
} finally {
issues.close();
}
- sendNewIssuesStatistics(context, newIssuesStats, project, projectName);
+ sendNewIssuesStatistics(newIssuesStats, project, projectName);
}
- private void sendNewIssuesStatistics(ComputationContext context, NewIssuesStatistics statistics, DbComponent project, String projectName) {
+ private void sendNewIssuesStatistics(NewIssuesStatistics statistics, DbComponent project, String projectName) {
if (statistics.hasIssues()) {
NewIssuesStatistics.Stats globalStatistics = statistics.globalStatistics();
+ long analysisDate = reportReader.readMetadata().getAnalysisDate();
NewIssuesNotification notification = newIssuesNotificationFactory
.newNewIssuesNotication()
.setProject(project.getKey(), project.getUuid(), projectName)
- .setAnalysisDate(new Date(context.getReportMetadata().getAnalysisDate()))
+ .setAnalysisDate(new Date(analysisDate))
.setStatistics(projectName, globalStatistics)
.setDebt(globalStatistics.debt());
service.deliver(notification);
.setAssignee(assignee);
myNewIssuesNotification
.setProject(project.getKey(), project.getUuid(), projectName)
- .setAnalysisDate(new Date(context.getReportMetadata().getAnalysisDate()))
+ .setAnalysisDate(new Date(analysisDate))
.setStatistics(projectName, assigneeStatistics)
.setDebt(assigneeStatistics.debt());
import org.sonar.core.persistence.MyBatis;
import org.sonar.server.component.db.SnapshotDao;
import org.sonar.server.computation.ComputationContext;
+import org.sonar.server.computation.batch.BatchReportReader;
import org.sonar.server.db.DbClient;
import java.util.List;
public class SwitchSnapshotStep implements ComputationStep {
private final DbClient dbClient;
+ private final BatchReportReader reportReader;
- public SwitchSnapshotStep(DbClient dbClient) {
+ public SwitchSnapshotStep(DbClient dbClient, BatchReportReader reportReader) {
this.dbClient = dbClient;
+ this.reportReader = reportReader;
}
@Override
public void execute(ComputationContext context) {
DbSession session = dbClient.openSession(true);
try {
- long snapshotId = context.getReportMetadata().getSnapshotId();
+ long snapshotId = reportReader.readMetadata().getSnapshotId();
disablePreviousSnapshot(session, snapshotId);
enableCurrentSnapshot(session, snapshotId);
} finally {
private final DbClient dbClient;
private final Settings settings;
+ private final BatchReportReader reportReader;
- public ValidateProjectStep(DbClient dbClient, Settings settings) {
+ public ValidateProjectStep(DbClient dbClient, Settings settings, BatchReportReader reportReader) {
this.dbClient = dbClient;
this.settings = settings;
+ this.reportReader = reportReader;
}
@Override
return input.key();
}
});
- ValidateProjectsVisitor visitor = new ValidateProjectsVisitor(session, dbClient.componentDao(), context.getReportMetadata(),
- context.getReportReader(), settings.getBoolean(CoreProperties.CORE_PREVENT_AUTOMATIC_PROJECT_CREATION), modulesByKey);
+ ValidateProjectsVisitor visitor = new ValidateProjectsVisitor(session, dbClient.componentDao(), settings.getBoolean(CoreProperties.CORE_PREVENT_AUTOMATIC_PROJECT_CREATION), modulesByKey);
visitor.visit(context.getRoot());
if (!visitor.validationMessages.isEmpty()) {
return "Validate project and modules keys";
}
- private static class ValidateProjectsVisitor extends DepthTraversalTypeAwareVisitor {
+ private class ValidateProjectsVisitor extends DepthTraversalTypeAwareVisitor {
private final DbSession session;
private final ComponentDao componentDao;
- private final BatchReport.Metadata reportMetadata;
- private final BatchReportReader batchReportReader;
private final boolean preventAutomaticProjectCreation;
private final Map<String, ComponentDto> modulesByKey;
private final List<String> validationMessages = new ArrayList<>();
private Component root;
- public ValidateProjectsVisitor(DbSession session, ComponentDao componentDao, BatchReport.Metadata reportMetadata, BatchReportReader batchReportReader,
- boolean preventAutomaticProjectCreation, Map<String, ComponentDto> modulesByKey) {
+ public ValidateProjectsVisitor(DbSession session, ComponentDao componentDao, boolean preventAutomaticProjectCreation, Map<String, ComponentDto> modulesByKey) {
super(Component.Type.MODULE, Order.PRE_ORDER);
this.session = session;
this.componentDao = componentDao;
- this.reportMetadata = reportMetadata;
- this.batchReportReader = batchReportReader;
this.preventAutomaticProjectCreation = preventAutomaticProjectCreation;
this.modulesByKey = modulesByKey;
}
private void validateBatchKey(Component component) {
- String batchKey = batchReportReader.readComponent(component.getRef()).getKey();
+ String batchKey = reportReader.readComponent(component.getRef()).getKey();
if (!ComponentKeys.isValidModuleKey(batchKey)) {
validationMessages.add(String.format("\"%s\" is not a valid project or module key. "
+ "Allowed characters are alphanumeric, '-', '_', '.' and ':', with at least one non-digit.", batchKey));
@CheckForNull
private void validateBranch() {
- if (!reportMetadata.hasBranch()) {
+ BatchReport.Metadata metadata = reportReader.readMetadata();
+ if (!metadata.hasBranch()) {
return;
}
- String branch = reportMetadata.getBranch();
+ String branch = metadata.getBranch();
if (!ComponentKeys.isValidBranch(branch)) {
validationMessages.add(String.format("\"%s\" is not a valid branch name. "
+ "Allowed characters are alphanumeric, '-', '_', '.' and '/'.", branch));
}
private void process() {
- sut.processComponentIssues(context, Arrays.asList(inputIssue.build()), "FILE_A", 1, PROJECT_KEY, "PROJECT_UUID");
+ sut.processComponentIssues(Arrays.asList(inputIssue.build()), "FILE_A", 1, PROJECT_KEY, "PROJECT_UUID");
}
}
ResourceIndexerDao resourceIndexerDao = mock(ResourceIndexerDao.class);
DbComponentsRefCache dbComponentsRefCache = new DbComponentsRefCache();
- IndexComponentsStep sut = new IndexComponentsStep(resourceIndexerDao, dbComponentsRefCache);
+ IndexComponentsStep sut = new IndexComponentsStep(resourceIndexerDao, dbComponentsRefCache, reportReader);
@Test
public void call_indexProject_of_dao() throws IOException {
import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.config.Settings;
-import org.sonar.batch.protocol.Constants;
import org.sonar.batch.protocol.output.BatchReport;
import org.sonar.core.persistence.DbTester;
import org.sonar.server.computation.ComputationContext;
protected ComputationStep step() {
SourceLineIndexer sourceLineIndexer = new SourceLineIndexer(dbClient, esTester.client());
sourceLineIndexer.setEnabled(true);
- return new IndexSourceLinesStep(sourceLineIndexer, dbComponentsRefCache);
+ return new IndexSourceLinesStep(sourceLineIndexer, dbComponentsRefCache, reportReader);
}
@Test
protected ComputationStep step() {
TestIndexer testIndexer = new TestIndexer(dbClient, esTester.client());
testIndexer.setEnabled(true);
- return new IndexTestsStep(testIndexer, dbComponentsRefCache);
+ return new IndexTestsStep(testIndexer, dbComponentsRefCache, reportReader);
}
@Test
sut.execute(context);
- assertThat(context.getReportMetadata().getRootComponentRef()).isEqualTo(1);
- assertThat(context.getReportMetadata().getDeletedComponentsCount()).isEqualTo(1);
+ assertThat(reportReader.readMetadata().getRootComponentRef()).isEqualTo(1);
+ assertThat(reportReader.readMetadata().getDeletedComponentsCount()).isEqualTo(1);
// verify that all components are processed (currently only for issues)
- verify(issueComputation).processComponentIssues(context, Collections.<BatchReport.Issue>emptyList(), "PROJECT_UUID", 1, PROJECT_KEY, "PROJECT_UUID");
- verify(issueComputation).processComponentIssues(context, Collections.<BatchReport.Issue>emptyList(), "FILE1_UUID", 2, PROJECT_KEY, "PROJECT_UUID");
- verify(issueComputation).processComponentIssues(context, Collections.<BatchReport.Issue>emptyList(), "FILE2_UUID", 3, PROJECT_KEY, "PROJECT_UUID");
- verify(issueComputation).processComponentIssues(context, ISSUES_ON_DELETED_COMPONENT, "DELETED_UUID", null, PROJECT_KEY, "PROJECT_UUID");
+ verify(issueComputation).processComponentIssues(Collections.<BatchReport.Issue>emptyList(), "PROJECT_UUID", 1, PROJECT_KEY, "PROJECT_UUID");
+ verify(issueComputation).processComponentIssues(Collections.<BatchReport.Issue>emptyList(), "FILE1_UUID", 2, PROJECT_KEY, "PROJECT_UUID");
+ verify(issueComputation).processComponentIssues(Collections.<BatchReport.Issue>emptyList(), "FILE2_UUID", 3, PROJECT_KEY, "PROJECT_UUID");
+ verify(issueComputation).processComponentIssues(ISSUES_ON_DELETED_COMPONENT, "DELETED_UUID", null, PROJECT_KEY, "PROJECT_UUID");
verify(issueComputation).afterReportProcessing();
}
ProjectCleaner projectCleaner = mock(ProjectCleaner.class);
DbComponentsRefCache dbComponentsRefCache = new DbComponentsRefCache();
ProjectSettingsRepository projectSettingsRepository = mock(ProjectSettingsRepository.class);
- PurgeDatastoresStep sut = new PurgeDatastoresStep(mock(DbClient.class, Mockito.RETURNS_DEEP_STUBS), projectCleaner, dbComponentsRefCache, projectSettingsRepository);
+ PurgeDatastoresStep sut = new PurgeDatastoresStep(mock(DbClient.class, Mockito.RETURNS_DEEP_STUBS), projectCleaner, dbComponentsRefCache, projectSettingsRepository, reportReader);
Settings projectSettings;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.junit.experimental.categories.Category;
import org.sonar.api.utils.DateUtils;
import org.sonar.core.persistence.DbTester;
import org.sonar.server.component.db.SnapshotDao;
import org.sonar.server.computation.ComputationContext;
+import org.sonar.server.computation.batch.BatchReportReaderRule;
import org.sonar.server.db.DbClient;
import org.sonar.test.DbTests;
@ClassRule
public static DbTester db = new DbTester();
+ @Rule
+ public BatchReportReaderRule reportReader = new BatchReportReaderRule();
SwitchSnapshotStep sut;
db.truncateTables();
System2 system2 = mock(System2.class);
when(system2.now()).thenReturn(DateUtils.parseDate("2011-09-29").getTime());
- this.sut = new SwitchSnapshotStep(new DbClient(db.database(), db.myBatis(), new SnapshotDao(system2)));
+ this.sut = new SwitchSnapshotStep(new DbClient(db.database(), db.myBatis(), new SnapshotDao(system2)), reportReader);
}
@Test
public void one_switch_with_a_snapshot_and_his_children() {
db.prepareDbUnit(getClass(), "snapshots.xml");
- BatchReport.Metadata metadata = BatchReport.Metadata.newBuilder()
- .setSnapshotId(1L).build();
- ComputationContext context = mock(ComputationContext.class);
- when(context.getReportMetadata()).thenReturn(metadata);
+ reportReader.setMetadata(BatchReport.Metadata.newBuilder()
+ .setSnapshotId(1L).build());
- sut.execute(context);
+ sut.execute(mock(ComputationContext.class));
db.assertDbUnit(getClass(), "snapshots-result.xml", "snapshots");
}
dbSession = dbClient.openSession(false);
settings = new Settings();
- sut = new ValidateProjectStep(dbClient, settings);
+ sut = new ValidateProjectStep(dbClient, settings, reportReader);
}
@After
public void not_fail_if_provisioning_enforced_and_project_exists() throws Exception {
reportReader.setMetadata(BatchReport.Metadata.newBuilder().build());
reportReader.putComponent(BatchReport.Component.newBuilder()
- .setRef(1)
- .setType(Constants.ComponentType.PROJECT)
- .setKey(PROJECT_KEY)
- .build());
+ .setRef(1)
+ .setType(Constants.ComponentType.PROJECT)
+ .setKey(PROJECT_KEY)
+ .build());
settings.appendProperty(CoreProperties.CORE_PREVENT_AUTOMATIC_PROJECT_CREATION, "true");
dbClient.componentDao().insert(dbSession, ComponentTesting.newProjectDto("ABCD").setKey(PROJECT_KEY));
reportReader.setMetadata(BatchReport.Metadata.newBuilder().build());
reportReader.putComponent(BatchReport.Component.newBuilder()
- .setRef(1)
- .setType(Constants.ComponentType.PROJECT)
- .setKey(PROJECT_KEY)
- .build());
+ .setRef(1)
+ .setType(Constants.ComponentType.PROJECT)
+ .setKey(PROJECT_KEY)
+ .build());
settings.appendProperty(CoreProperties.CORE_PREVENT_AUTOMATIC_PROJECT_CREATION, "true");
public void fail_if_provisioning_not_enforced_and_project_does_not_exists() throws Exception {
reportReader.setMetadata(BatchReport.Metadata.newBuilder().build());
reportReader.putComponent(BatchReport.Component.newBuilder()
- .setRef(1)
- .setType(Constants.ComponentType.PROJECT)
- .setKey(PROJECT_KEY)
- .build());
+ .setRef(1)
+ .setType(Constants.ComponentType.PROJECT)
+ .setKey(PROJECT_KEY)
+ .build());
settings.appendProperty(CoreProperties.CORE_PREVENT_AUTOMATIC_PROJECT_CREATION, "false");
@Test
public void not_fail_on_valid_branch() throws Exception {
reportReader.setMetadata(BatchReport.Metadata.newBuilder()
- .setBranch("origin/master")
- .build());
+ .setBranch("origin/master")
+ .build());
reportReader.putComponent(BatchReport.Component.newBuilder()
- .setRef(1)
- .setType(Constants.ComponentType.PROJECT)
- .setKey(PROJECT_KEY)
- .build());
+ .setRef(1)
+ .setType(Constants.ComponentType.PROJECT)
+ .setKey(PROJECT_KEY)
+ .build());
sut.execute(new ComputationContext(reportReader, null, null, null,
ComponentTreeBuilders.from(new DumbComponent(Component.Type.PROJECT, 1, "ABCD", PROJECT_KEY + ":origin/master")), null));
" o \"bran#ch\" is not a valid branch name. Allowed characters are alphanumeric, '-', '_', '.' and '/'.");
reportReader.setMetadata(BatchReport.Metadata.newBuilder()
- .setBranch("bran#ch")
- .build());
+ .setBranch("bran#ch")
+ .build());
reportReader.putComponent(BatchReport.Component.newBuilder()
- .setRef(1)
- .setType(Constants.ComponentType.PROJECT)
- .setKey(PROJECT_KEY)
- .build());
+ .setRef(1)
+ .setType(Constants.ComponentType.PROJECT)
+ .setKey(PROJECT_KEY)
+ .build());
sut.execute(new ComputationContext(reportReader, null, null, null,
ComponentTreeBuilders.from(new DumbComponent(Component.Type.PROJECT, 1, "ABCD", PROJECT_KEY + ":bran#ch")), null));
reportReader.setMetadata(BatchReport.Metadata.newBuilder().build());
reportReader.putComponent(BatchReport.Component.newBuilder()
- .setRef(1)
- .setType(Constants.ComponentType.PROJECT)
- .setKey(invalidProjectKey)
- .addChildRef(2)
- .build());
+ .setRef(1)
+ .setType(Constants.ComponentType.PROJECT)
+ .setKey(invalidProjectKey)
+ .addChildRef(2)
+ .build());
reportReader.putComponent(BatchReport.Component.newBuilder()
- .setRef(2)
- .setType(Constants.ComponentType.MODULE)
- .setKey("Module$Key")
- .build());
+ .setRef(2)
+ .setType(Constants.ComponentType.MODULE)
+ .setKey("Module$Key")
+ .build());
DumbComponent root = new DumbComponent(Component.Type.PROJECT, 1, "ABCD", invalidProjectKey,
new DumbComponent(Component.Type.MODULE, 2, "BCDE", "Module$Key"));
reportReader.setMetadata(BatchReport.Metadata.newBuilder().build());
reportReader.putComponent(BatchReport.Component.newBuilder()
- .setRef(1)
- .setType(Constants.ComponentType.PROJECT)
- .setKey(PROJECT_KEY)
- .addChildRef(2)
- .build());
+ .setRef(1)
+ .setType(Constants.ComponentType.PROJECT)
+ .setKey(PROJECT_KEY)
+ .addChildRef(2)
+ .build());
reportReader.putComponent(BatchReport.Component.newBuilder()
- .setRef(2)
- .setType(Constants.ComponentType.MODULE)
- .setKey(MODULE_KEY)
- .build());
+ .setRef(2)
+ .setType(Constants.ComponentType.MODULE)
+ .setKey(MODULE_KEY)
+ .build());
ComponentDto project = ComponentTesting.newProjectDto("ABCD").setKey(MODULE_KEY);
dbClient.componentDao().insert(dbSession, project);
reportReader.setMetadata(BatchReport.Metadata.newBuilder().build());
reportReader.putComponent(BatchReport.Component.newBuilder()
- .setRef(1)
- .setType(Constants.ComponentType.PROJECT)
- .setKey(PROJECT_KEY)
- .addChildRef(2)
- .build());
+ .setRef(1)
+ .setType(Constants.ComponentType.PROJECT)
+ .setKey(PROJECT_KEY)
+ .addChildRef(2)
+ .build());
reportReader.putComponent(BatchReport.Component.newBuilder()
- .setRef(2)
- .setType(Constants.ComponentType.MODULE)
- .setKey(MODULE_KEY)
- .build());
+ .setRef(2)
+ .setType(Constants.ComponentType.MODULE)
+ .setKey(MODULE_KEY)
+ .build());
ComponentDto project = ComponentTesting.newProjectDto("ABCD").setKey(PROJECT_KEY);
ComponentDto anotherProject = ComponentTesting.newProjectDto().setKey(anotherProjectKey);
reportReader.setMetadata(BatchReport.Metadata.newBuilder().build());
reportReader.putComponent(BatchReport.Component.newBuilder()
- .setRef(1)
- .setType(Constants.ComponentType.PROJECT)
- .setKey(PROJECT_KEY)
- .addChildRef(2)
- .build());
+ .setRef(1)
+ .setType(Constants.ComponentType.PROJECT)
+ .setKey(PROJECT_KEY)
+ .addChildRef(2)
+ .build());
reportReader.putComponent(BatchReport.Component.newBuilder()
- .setRef(2)
- .setType(Constants.ComponentType.MODULE)
- .setKey(MODULE_KEY)
- .build());
+ .setRef(2)
+ .setType(Constants.ComponentType.MODULE)
+ .setKey(MODULE_KEY)
+ .build());
ComponentDto anotherProject = ComponentTesting.newProjectDto().setKey(anotherProjectKey);
dbClient.componentDao().insert(dbSession, anotherProject);