import org.sonar.batch.protocol.output.BatchReportReader;
import org.sonar.batch.protocol.output.BatchReportWriter;
import org.sonar.core.persistence.DbTester;
-import org.sonar.server.component.ComponentTesting;
import org.sonar.server.computation.ComputationContext;
import org.sonar.server.computation.component.DbComponentsRefCache;
import org.sonar.server.computation.component.DbComponentsRefCache.DbComponent;
long start = System.currentTimeMillis();
PersistFileSourcesStep step = new PersistFileSourcesStep(dbClient, System2.INSTANCE, dbComponentsRefCache);
- step.execute(new ComputationContext(new BatchReportReader(reportDir), ComponentTesting.newProjectDto(PROJECT_UUID)));
+ step.execute(new ComputationContext(new BatchReportReader(reportDir), "PROJECT_KEY"));
long end = System.currentTimeMillis();
long duration = end - start;
import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.Maps;
import com.google.common.collect.Multimap;
-import org.sonar.api.server.ServerSide;
import org.sonar.api.resources.Language;
import org.sonar.api.resources.Languages;
import org.sonar.api.rule.RuleKey;
+import org.sonar.api.server.ServerSide;
import org.sonar.api.utils.log.Logger;
import org.sonar.api.utils.log.Loggers;
import org.sonar.api.web.UserRole;
Map<String, String> parentProperties = newHashMap();
for (ComponentDto parent : parents) {
- parentProperties.putAll(getPropertiesMap(dbClient.propertiesDao().selectProjectProperties(parent.key(), session), hasScanPerm));
+ parentProperties.putAll(getPropertiesMap(dbClient.propertiesDao().selectProjectProperties(session, parent.key()), hasScanPerm));
}
return parentProperties;
}
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 static com.google.common.base.Preconditions.checkState;
public class ComputationContext {
private final BatchReportReader reportReader;
- private final ComponentDto project;
+ // Project key (including branch if any)
+ private final String projectKey;
// cache of metadata as it's frequently accessed
private final BatchReport.Metadata reportMetadata;
private Settings projectSettings;
- public ComputationContext(BatchReportReader reportReader, ComponentDto project) {
+ public ComputationContext(BatchReportReader reportReader, String projectKey) {
this.reportReader = reportReader;
- this.project = project;
+ this.projectKey = projectKey;
this.reportMetadata = reportReader.readMetadata();
}
return reportMetadata;
}
- public ComponentDto getProject() {
- return project;
+ public String getProjectKey() {
+ return projectKey;
}
public BatchReportReader getReportReader() {
import org.sonar.api.utils.log.Profiler;
import org.sonar.batch.protocol.output.BatchReportReader;
import org.sonar.core.component.ComponentDto;
-import org.sonar.core.component.SnapshotDto;
import org.sonar.core.computation.db.AnalysisReportDto;
import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.MyBatis;
import org.sonar.server.db.DbClient;
import org.sonar.server.properties.ProjectSettingsFactory;
-import javax.annotation.Nullable;
+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;
-import static org.sonar.core.computation.db.AnalysisReportDto.Status.CANCELLED;
import static org.sonar.core.computation.db.AnalysisReportDto.Status.FAILED;
import static org.sonar.core.computation.db.AnalysisReportDto.Status.SUCCESS;
}
public void process(ReportQueue.Item item) {
+ String projectKey = item.dto.getProjectKey();
Profiler profiler = Profiler.create(LOG).startDebug(String.format(
- "Analysis of project %s (report %d)", item.dto.getProjectKey(), item.dto.getId()));
-
- ComponentDto project = null;
+ "Analysis of project %s (report %d)", projectKey, item.dto.getId()));
try {
- project = loadProject(item);
File reportDir = extractReportInDir(item);
BatchReportReader reader = new BatchReportReader(reportDir);
- if (isSnapshotMissing(item, reader.readMetadata().getSnapshotId())) {
- return;
- }
- ComputationContext context = new ComputationContext(reader, project);
- context.setProjectSettings(projectSettingsFactory.newProjectSettings(project.getId()));
+ ComputationContext context = new ComputationContext(reader, projectKey);
+ context.setProjectSettings(projectSettingsFactory.newProjectSettings(projectKey));
for (ComputationStep step : steps.orderedSteps()) {
Profiler stepProfiler = Profiler.createIfDebug(LOG).startDebug(step.getDescription());
step.execute(context);
throw Throwables.propagate(e);
} finally {
item.dto.setFinishedAt(system.now());
- saveActivity(item.dto, project);
+ saveActivity(item.dto);
profiler.stopInfo();
}
}
}
}
- private ComponentDto loadProject(ReportQueue.Item item) {
- DbSession session = dbClient.openSession(false);
- try {
- return dbClient.componentDao().selectByKey(session, item.dto.getProjectKey());
- } finally {
- MyBatis.closeQuietly(session);
- }
- }
-
- private boolean isSnapshotMissing(ReportQueue.Item item, long snapshotId) {
- DbSession session = dbClient.openSession(false);
- try {
- SnapshotDto snapshot = dbClient.snapshotDao().getNullableByKey(session, snapshotId);
- if (snapshot == null) {
- item.dto.setStatus(CANCELLED);
- LOG.info("Processing of report #{} is canceled because it was submitted while another report of the same project was already being processed.", item.dto.getId());
- LOG.debug("The snapshot ID #{} provided by the report #{} does not exist anymore.", snapshotId, item.dto.getId());
- }
- return snapshot == null;
- } finally {
- MyBatis.closeQuietly(session);
- }
-
- }
-
- private void saveActivity(AnalysisReportDto report, @Nullable ComponentDto project) {
+ private void saveActivity(AnalysisReportDto report) {
+ ComponentDto project = loadProject(report.getProjectKey());
Activity activity = new Activity();
activity.setType(Activity.Type.ANALYSIS_REPORT);
activity.setAction("LOG_ANALYSIS_REPORT");
}
activityService.save(activity);
}
+
+ @CheckForNull
+ private ComponentDto loadProject(String projectKey) {
+ DbSession session = dbClient.openSession(false);
+ try {
+ return dbClient.componentDao().selectNullableByKey(session, projectKey);
+ } finally {
+ MyBatis.closeQuietly(session);
+ }
+ }
}
DbSession session = dbClient.openSession(false);
try {
- checkThatProjectExistsInDatabase(projectKey, session);
-
saveReportOnDisk(reportData, file);
AnalysisReportDto dto = saveReportMetadataInDatabase(projectKey, projectName, uuid, session);
FileUtils.copyInputStreamToFile(reportData, file);
}
- private void checkThatProjectExistsInDatabase(String projectKey, DbSession session) {
- dbClient.componentDao().selectByKey(session, projectKey);
- }
-
public void remove(Item item) {
DbSession session = dbClient.openSession(false);
try {
public void execute(ComputationContext context) {
DbSession session = dbClient.openSession(false);
try {
- List<ComponentDto> components = dbClient.componentDao().selectComponentsFromProjectKey(session, context.getProject().key());
+ List<ComponentDto> components = dbClient.componentDao().selectComponentsFromProjectKey(session, context.getProjectKey());
Map<String, ComponentDto> componentDtosByKey = componentDtosByKey(components);
int rootComponentRef = context.getReportMetadata().getRootComponentRef();
recursivelyProcessComponent(context, rootComponentRef, context.getReportReader().readComponent(rootComponentRef), componentDtosByKey);
public void execute(ComputationContext context) {
DbSession session = dbClient.openSession(false);
try {
- List<ComponentDto> components = dbClient.componentDao().selectComponentsFromProjectKey(session, context.getProject().key());
+ List<ComponentDto> components = dbClient.componentDao().selectComponentsFromProjectKey(session, context.getProjectKey());
Map<String, ComponentDto> componentDtosByKey = componentDtosByKey(components);
int rootComponentRef = context.getReportMetadata().getRootComponentRef();
ComponentContext componentContext = new ComponentContext(context, session, componentDtosByKey);
recursivelyProcessComponent(context, rootComponentRef);
session.commit();
if (context.hasUnprocessedCoverageDetails) {
- LOG.warn("Some coverage tests are not taken into account during analysis of project '{}'", computationContext.getProject().getKey());
+ LOG.warn("Some coverage tests are not taken into account during analysis of project '{}'", computationContext.getProjectKey());
}
} finally {
MyBatis.closeQuietly(session);
import com.google.common.collect.ImmutableSet;
import org.sonar.api.issue.internal.DefaultIssue;
-import org.sonar.core.component.ComponentDto;
import org.sonar.server.computation.ComputationContext;
+import org.sonar.server.computation.component.DbComponentsRefCache;
+import org.sonar.server.computation.component.DbComponentsRefCache.DbComponent;
import org.sonar.server.computation.issue.IssueCache;
import org.sonar.server.computation.issue.RuleCache;
import org.sonar.server.issue.notification.IssueChangeNotification;
private final IssueCache issueCache;
private final RuleCache rules;
+ private final DbComponentsRefCache dbComponentsRefCache;
private final NotificationService service;
private NewIssuesNotificationFactory newIssuesNotificationFactory;
- public SendIssueNotificationsStep(IssueCache issueCache, RuleCache rules, NotificationService service, NewIssuesNotificationFactory newIssuesNotificationFactory) {
+ public SendIssueNotificationsStep(IssueCache issueCache, RuleCache rules, DbComponentsRefCache dbComponentsRefCache, NotificationService service,
+ NewIssuesNotificationFactory newIssuesNotificationFactory) {
this.issueCache = issueCache;
this.rules = rules;
+ this.dbComponentsRefCache = dbComponentsRefCache;
this.service = service;
this.newIssuesNotificationFactory = newIssuesNotificationFactory;
}
@Override
public void execute(ComputationContext context) {
- if (service.hasProjectSubscribersForTypes(context.getProject().uuid(), NOTIF_TYPES)) {
- doExecute(context);
+ DbComponent project = dbComponentsRefCache.getByRef(context.getReportMetadata().getRootComponentRef());
+ if (service.hasProjectSubscribersForTypes(project.getUuid(), NOTIF_TYPES)) {
+ doExecute(context, project);
}
}
- private void doExecute(ComputationContext context) {
+ private void doExecute(ComputationContext context, DbComponent project) {
NewIssuesStatistics newIssuesStats = new NewIssuesStatistics();
CloseableIterator<DefaultIssue> issues = issueCache.traverse();
+ String projectName = context.getReportReader().readComponent(context.getReportMetadata().getRootComponentRef()).getName();
try {
while (issues.hasNext()) {
DefaultIssue issue = issues.next();
IssueChangeNotification changeNotification = new IssueChangeNotification();
changeNotification.setRuleName(rules.ruleName(issue.ruleKey()));
changeNotification.setIssue(issue);
- changeNotification.setProject(context.getProject());
+ changeNotification.setProject(project.getKey(), projectName);
service.deliver(changeNotification);
}
}
} finally {
issues.close();
}
- sendNewIssuesStatistics(context, newIssuesStats);
+ sendNewIssuesStatistics(context, newIssuesStats, project, projectName);
}
- private void sendNewIssuesStatistics(ComputationContext context, NewIssuesStatistics statistics) {
+ private void sendNewIssuesStatistics(ComputationContext context, NewIssuesStatistics statistics, DbComponent project, String projectName) {
if (statistics.hasIssues()) {
NewIssuesStatistics.Stats globalStatistics = statistics.globalStatistics();
- ComponentDto project = context.getProject();
NewIssuesNotification notification = newIssuesNotificationFactory
.newNewIssuesNotication()
- .setProject(project)
+ .setProject(project.getKey(), project.getUuid(), projectName)
.setAnalysisDate(new Date(context.getReportMetadata().getAnalysisDate()))
- .setStatistics(project, globalStatistics)
+ .setStatistics(projectName, globalStatistics)
.setDebt(globalStatistics.debt());
service.deliver(notification);
.newMyNewIssuesNotification()
.setAssignee(assignee);
myNewIssuesNotification
- .setProject(project)
+ .setProject(project.getKey(), project.getUuid(), projectName)
.setAnalysisDate(new Date(context.getReportMetadata().getAnalysisDate()))
- .setStatistics(project, assigneeStatistics)
+ .setStatistics(projectName, assigneeStatistics)
.setDebt(assigneeStatistics.debt());
service.deliver(myNewIssuesNotification);
.setIssue((DefaultIssue) issue)
.setChangeAuthorLogin(issueChangeContext.login())
.setRuleName(rule != null ? rule.getName() : null)
- .setProject(repository.project(projectKey))
+ .setProject(projectKey, repository.project(projectKey).name())
.setComponent(repository.component(issue.componentKey())));
}
}
import com.google.common.base.Objects;
import com.google.common.base.Strings;
import org.apache.commons.lang.StringUtils;
-import org.sonar.api.server.ServerSide;
import org.sonar.api.issue.ActionPlan;
import org.sonar.api.issue.Issue;
import org.sonar.api.issue.internal.DefaultIssue;
import org.sonar.api.rule.Severity;
import org.sonar.api.rules.Rule;
import org.sonar.api.rules.RuleFinder;
+import org.sonar.api.server.ServerSide;
import org.sonar.api.user.User;
import org.sonar.api.user.UserFinder;
import org.sonar.api.web.UserRole;
}
issueStorage.save(session, issue);
Rule rule = getNullableRuleByKey(issue.ruleKey());
+ ComponentDto project = dbClient.componentDao().selectByKey(session, projectKey);
notificationService.scheduleForSending(new IssueChangeNotification()
.setIssue(issue)
.setChangeAuthorLogin(context.login())
.setRuleName(rule != null ? rule.getName() : null)
- .setProject(dbClient.componentDao().selectByKey(session, projectKey))
+ .setProject(project.getKey(), project.name())
.setComponent(dbClient.componentDao().selectNullableByKey(session, issue.componentKey()))
.setComment(comment));
}
return this;
}
+ public IssueChangeNotification setProject(String projectKey, String projectName) {
+ setFieldValue("projectName", projectName);
+ setFieldValue("projectKey", projectKey);
+ return this;
+ }
+
public IssueChangeNotification setComponent(Component component) {
setFieldValue("componentName", component.longName());
return this;
package org.sonar.server.issue.notification;
import com.google.common.collect.Multiset;
-import org.sonar.api.component.Component;
import org.sonar.api.notifications.Notification;
import org.sonar.api.rule.RuleKey;
import org.sonar.api.rule.Severity;
import org.sonar.api.utils.DateUtils;
import org.sonar.api.utils.Duration;
import org.sonar.api.utils.Durations;
-import org.sonar.core.component.ComponentDto;
import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.MyBatis;
import org.sonar.server.db.DbClient;
return this;
}
- public NewIssuesNotification setProject(ComponentDto project) {
- setFieldValue(FIELD_PROJECT_NAME, project.longName());
- setFieldValue(FIELD_PROJECT_KEY, project.key());
- setFieldValue(FIELD_PROJECT_UUID, project.uuid());
+ public NewIssuesNotification setProject(String projectKey, String projectUuid, String projectName) {
+ setFieldValue(FIELD_PROJECT_NAME, projectName);
+ setFieldValue(FIELD_PROJECT_KEY, projectKey);
+ setFieldValue(FIELD_PROJECT_UUID, projectUuid);
return this;
}
- public NewIssuesNotification setStatistics(Component project, NewIssuesStatistics.Stats stats) {
- setDefaultMessage(stats.countForMetric(SEVERITY) + " new issues on " + project.longName() + ".\n");
+ public NewIssuesNotification setStatistics(String projectName, NewIssuesStatistics.Stats stats) {
+ setDefaultMessage(stats.countForMetric(SEVERITY) + " new issues on " + projectName + ".\n");
setSeverityStatistics(stats);
setAssigneesStatistics(stats);
import com.google.common.annotations.VisibleForTesting;
import com.google.common.collect.Maps;
-import org.sonar.api.server.ServerSide;
import org.sonar.api.config.Settings;
+import org.sonar.api.server.ServerSide;
import org.sonar.core.properties.PropertiesDao;
import org.sonar.core.properties.PropertyDto;
this.settings = settings;
}
- public Settings newProjectSettings(long projectId) {
- List<PropertyDto> propertyList = dao.selectProjectProperties(projectId);
+ public Settings newProjectSettings(String projectKey) {
+ List<PropertyDto> propertyList = dao.selectProjectProperties(projectKey);
return new ProjectSettings(settings, getPropertyMap(propertyList));
}
import org.junit.Test;
import org.sonar.api.config.Settings;
import org.sonar.batch.protocol.output.BatchReportReader;
-import org.sonar.core.component.ComponentDto;
import static org.mockito.Mockito.mock;
public class ComputationContextTest {
- ComputationContext sut = new ComputationContext(mock(BatchReportReader.class), mock(ComponentDto.class));
+ ComputationContext sut = new ComputationContext(mock(BatchReportReader.class), "ProjectKey");
@Test(expected = IllegalStateException.class)
public void setProjectSettings() {
sut.setProjectSettings(mock(Settings.class));
sut.setProjectSettings(mock(Settings.class));
}
-}
\ No newline at end of file
+}
import org.junit.ClassRule;
import org.junit.Rule;
import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
import org.sonar.api.utils.System2;
import org.sonar.api.utils.ZipUtils;
import org.sonar.api.utils.internal.JUnitTempFolder;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+@RunWith(MockitoJUnitRunner.class)
public class ComputationServiceTest {
- private static final long ANY_SNAPSHOT_ID = 54987654231L;
@ClassRule
public static DbTester dbTester = new DbTester();
+
@Rule
public JUnitTempFolder tempFolder = new JUnitTempFolder();
+
@Rule
public LogTester logTester = new LogTester();
+
+ @Captor
+ ArgumentCaptor<Activity> activityArgumentCaptor;
+
ComputationStep projectStep1 = mockStep();
ComputationStep projectStep2 = mockStep();
ComputationSteps steps = mock(ComputationSteps.class);
@Before
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);
+ }
- // db contains project with key "P1"
- dbTester.prepareDbUnit(getClass(), "shared.xml");
+ @Test
+ public void process_new_project() throws Exception {
+ logTester.setLevel(LoggerLevel.INFO);
+
+ when(steps.orderedSteps()).thenReturn(Arrays.asList(projectStep1, projectStep2));
+ AnalysisReportDto dto = newDefaultReport();
+ File zip = generateZip();
+
+ sut.process(new ReportQueue.Item(dto, zip));
+
+ // report is integrated -> status is set to SUCCESS
+ assertThat(dto.getStatus()).isEqualTo(Status.SUCCESS);
+ assertThat(dto.getFinishedAt()).isNotNull();
+
+ // one info log at the end
+ assertThat(logTester.logs(LoggerLevel.INFO)).hasSize(1);
+ assertThat(logTester.logs(LoggerLevel.INFO).get(0)).startsWith("Analysis of project P1 (report 1) (done) | time=");
+
+ // execute only the steps supporting the project qualifier
+ verify(projectStep1).execute(any(ComputationContext.class));
+ verify(projectStep2).execute(any(ComputationContext.class));
+ verify(activityService).save(activityArgumentCaptor.capture());
+
+ assertThat(activityArgumentCaptor.getValue().getType()).isEqualTo(Activity.Type.ANALYSIS_REPORT);
+ assertThat(activityArgumentCaptor.getValue().getAction()).isEqualTo("LOG_ANALYSIS_REPORT");
+ assertThat(activityArgumentCaptor.getValue().getData()).containsEntry("projectKey", "P1");
}
@Test
- public void process_project() throws Exception {
+ public void process_existing_project() throws Exception {
+ dbTester.prepareDbUnit(getClass(), "shared.xml");
+
logTester.setLevel(LoggerLevel.INFO);
- // view step is not supposed to be executed
when(steps.orderedSteps()).thenReturn(Arrays.asList(projectStep1, projectStep2));
AnalysisReportDto dto = newDefaultReport();
File zip = generateZip();
// execute only the steps supporting the project qualifier
verify(projectStep1).execute(any(ComputationContext.class));
verify(projectStep2).execute(any(ComputationContext.class));
- verify(activityService).save(any(Activity.class));
+ verify(activityService).save(activityArgumentCaptor.capture());
+
+ assertThat(activityArgumentCaptor.getValue().getType()).isEqualTo(Activity.Type.ANALYSIS_REPORT);
+ assertThat(activityArgumentCaptor.getValue().getAction()).isEqualTo("LOG_ANALYSIS_REPORT");
+ assertThat(activityArgumentCaptor.getValue().getData()).containsEntry("projectKey", "P1");
+ assertThat(activityArgumentCaptor.getValue().getData()).containsEntry("projectName", "Project 1");
+ assertThat(activityArgumentCaptor.getValue().getData().get("projectUuid")).isEqualTo("ABCD");
}
private AnalysisReportDto newDefaultReport() {
}
}
- @Test
- public void analysis_cancelled_when_snapshot_not_found() throws Exception {
- AnalysisReportDto report = newDefaultReport();
- File zip = generateZip(ANY_SNAPSHOT_ID);
- logTester.setLevel(LoggerLevel.DEBUG);
-
- sut.process(new ReportQueue.Item(report, zip));
-
- assertThat(report.getStatus()).isEqualTo(Status.CANCELLED);
- assertThat(logTester.logs()).contains(
- String.format("Processing of report #%s is canceled because it was submitted while another report of the same project was already being processed.", report.getId()));
- assertThat(logTester.logs()).contains(String.format("The snapshot ID #%s provided by the report #%s does not exist anymore.", ANY_SNAPSHOT_ID, report.getId()));
- }
-
private ComputationStep mockStep() {
ComputationStep step = mock(ComputationStep.class);
when(step.getDescription()).thenReturn(RandomStringUtils.randomAscii(5));
import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.DbTester;
import org.sonar.process.ProcessProperties;
-import org.sonar.server.component.ComponentTesting;
import org.sonar.server.component.db.ComponentDao;
import org.sonar.server.computation.db.AnalysisReportDao;
import org.sonar.server.db.DbClient;
when(system.now()).thenReturn(NOW);
dbClient = new DbClient(db.database(), db.myBatis(), new ComponentDao(), new AnalysisReportDao(system));
- sut = new ReportQueue(dbClient, settings);
-
session = dbClient.openSession(false);
- dbClient.componentDao().insert(session, ComponentTesting.newProjectDto().setKey("P1"));
- dbClient.componentDao().insert(session, ComponentTesting.newProjectDto().setKey("P2"));
- dbClient.componentDao().insert(session, ComponentTesting.newProjectDto().setKey("P3"));
- session.commit();
+ sut = new ReportQueue(dbClient, settings);
}
@After
sut.clear();
}
- @Test(expected = IllegalStateException.class)
- public void add_on_non_existent_project() {
- sut.add("UNKNOWN_PROJECT_KEY", "Unknown project", generateData());
- }
-
@Test
public void reset_to_pending_status() {
// 2 pending
sut.resetToPendingStatus();
assertThat(sut.all()).extracting("status").containsOnly(PENDING).hasSize(2);
+
}
private InputStream generateData() {
import org.sonar.batch.protocol.output.BatchReportWriter;
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.component.ComputeComponentsRefCache;
@Category(DbTests.class)
public class FeedComponentsCacheStepTest extends BaseStepTest {
+ private static final String PROJECT_KEY = "PROJECT_KEY";
+
@ClassRule
public static DbTester dbTester = new DbTester();
writer.writeComponent(BatchReport.Component.newBuilder()
.setRef(1)
.setType(Constants.ComponentType.PROJECT)
- .setKey("PROJECT_KEY")
+ .setKey(PROJECT_KEY)
.addChildRef(2)
.build());
writer.writeComponent(BatchReport.Component.newBuilder()
.setPath("src/main/java/dir/Foo.java")
.build());
- sut.execute(new ComputationContext(new BatchReportReader(reportDir), ComponentTesting.newProjectDto()));
+ sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
- assertThat(computeComponentsRefCache.getByRef(1).getKey()).isEqualTo("PROJECT_KEY");
+ assertThat(computeComponentsRefCache.getByRef(1).getKey()).isEqualTo(PROJECT_KEY);
assertThat(computeComponentsRefCache.getByRef(1).getUuid()).isNotNull();
assertThat(computeComponentsRefCache.getByRef(2).getKey()).isEqualTo("MODULE_KEY");
writer.writeComponent(BatchReport.Component.newBuilder()
.setRef(1)
.setType(Constants.ComponentType.PROJECT)
- .setKey("PROJECT_KEY")
+ .setKey(PROJECT_KEY)
.setName("Project")
.addChildRef(2)
.build());
.setPath("src/main/java/dir/Foo.java")
.build());
- sut.execute(new ComputationContext(new BatchReportReader(reportDir), ComponentTesting.newProjectDto()));
+ sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
assertThat(computeComponentsRefCache.getByRef(4).getKey()).isEqualTo("SUB_MODULE_KEY:src/main/java/dir");
assertThat(computeComponentsRefCache.getByRef(5).getKey()).isEqualTo("SUB_MODULE_KEY:src/main/java/dir/Foo.java");
writer.writeComponent(BatchReport.Component.newBuilder()
.setRef(1)
.setType(Constants.ComponentType.PROJECT)
- .setKey("PROJECT_KEY")
+ .setKey(PROJECT_KEY)
.setName("Project")
.addChildRef(2)
.build());
.setPath("src/main/java/dir/Foo.java")
.build());
- sut.execute(new ComputationContext(new BatchReportReader(reportDir), ComponentTesting.newProjectDto()));
+ sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
assertThat(computeComponentsRefCache.getByRef(1).getKey()).isEqualTo("PROJECT_KEY:origin/master");
assertThat(computeComponentsRefCache.getByRef(2).getKey()).isEqualTo("MODULE_KEY:origin/master");
public class IndexComponentsStepTest extends BaseStepTest {
+ private static final String PROJECT_KEY = "PROJECT_KEY";
+
@Rule
public TemporaryFolder temp = new TemporaryFolder();
@Test
public void call_indexProject_of_dao() throws IOException {
- dbComponentsRefCache.addComponent(1, new DbComponent(123L, "PROJECT_KEY", "PROJECT_UUID"));
+ dbComponentsRefCache.addComponent(1, new DbComponent(123L, PROJECT_KEY, "PROJECT_UUID"));
File reportDir = temp.newFolder();
BatchReportWriter writer = new BatchReportWriter(reportDir);
ComponentDto project = mock(ComponentDto.class);
when(project.getId()).thenReturn(123L);
- ComputationContext context = new ComputationContext(new BatchReportReader(reportDir), project);
+ ComputationContext context = new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY);
sut.execute(context);
import org.sonar.batch.protocol.output.BatchReportReader;
import org.sonar.batch.protocol.output.BatchReportWriter;
import org.sonar.core.persistence.DbTester;
-import org.sonar.server.component.ComponentTesting;
import org.sonar.server.computation.ComputationContext;
import org.sonar.server.computation.component.DbComponentsRefCache;
import org.sonar.server.db.DbClient;
public class IndexSourceLinesStepTest extends BaseStepTest {
+ private static final String PROJECT_KEY = "PROJECT_KEY";
+
@Rule
public TemporaryFolder temp = new TemporaryFolder();
@Test
public void index_source() throws Exception {
- dbComponentsRefCache.addComponent(1, new DbComponentsRefCache.DbComponent(1L, "PROJECT_KEY", "ABCD"));
+ dbComponentsRefCache.addComponent(1, new DbComponentsRefCache.DbComponent(1L, PROJECT_KEY, "ABCD"));
dbTester.prepareDbUnit(getClass(), "index_source.xml");
Connection connection = dbTester.openConnection();
.setRootComponentRef(1)
.build());
- step().execute(new ComputationContext(new BatchReportReader(reportDir), ComponentTesting.newProjectDto("ABCD")));
+ step().execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
List<SearchHit> docs = esTester.getDocuments(SourceLineIndexDefinition.INDEX, SourceLineIndexDefinition.TYPE);
assertThat(docs).hasSize(1);
import org.sonar.batch.protocol.output.BatchReportReader;
import org.sonar.batch.protocol.output.BatchReportWriter;
import org.sonar.core.persistence.DbTester;
-import org.sonar.server.component.ComponentTesting;
import org.sonar.server.computation.ComputationContext;
import org.sonar.server.computation.component.DbComponentsRefCache;
import org.sonar.server.db.DbClient;
.setRootComponentRef(1)
.build());
- step().execute(new ComputationContext(new BatchReportReader(reportDir), ComponentTesting.newProjectDto("ABCD")));
+ step().execute(new ComputationContext(new BatchReportReader(reportDir), "PROJECT_KEY"));
List<SearchHit> docs = esTester.getDocuments(TestIndexDefinition.INDEX, TestIndexDefinition.TYPE);
assertThat(docs).hasSize(1);
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.DbTester;
import org.sonar.server.computation.ComputationContext;
import org.sonar.server.computation.component.ComputeComponentsRefCache;
public class ParseReportStepTest extends BaseStepTest {
+ private static final String PROJECT_KEY = "PROJECT_KEY";
+
private static final List<BatchReport.Issue> ISSUES_ON_DELETED_COMPONENT = Arrays.asList(BatchReport.Issue.newBuilder()
.setUuid("DELETED_ISSUE_UUID")
.build());
@Test
public void extract_report_from_db_and_browse_components() throws Exception {
- computeComponentsRefCache.addComponent(1, new ComputeComponentsRefCache.ComputeComponent("PROJECT_KEY", "PROJECT_UUID"));
+ computeComponentsRefCache.addComponent(1, new ComputeComponentsRefCache.ComputeComponent(PROJECT_KEY, "PROJECT_UUID"));
computeComponentsRefCache.addComponent(2, new ComputeComponentsRefCache.ComputeComponent("PROJECT_KEY:file1", "FILE1_UUID"));
computeComponentsRefCache.addComponent(3, new ComputeComponentsRefCache.ComputeComponent("PROJECT_KEY:file2", "FILE2_UUID"));
File reportDir = generateReport();
- ComputationContext context = new ComputationContext(new BatchReportReader(reportDir), mock(ComponentDto.class));
+ ComputationContext context = new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY);
sut.execute(context);
assertThat(context.getReportMetadata().getRootComponentRef()).isEqualTo(1);
assertThat(context.getReportMetadata().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(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).afterReportProcessing();
}
BatchReportWriter writer = new BatchReportWriter(dir);
writer.writeMetadata(BatchReport.Metadata.newBuilder()
.setRootComponentRef(1)
- .setProjectKey("PROJECT_KEY")
+ .setProjectKey(PROJECT_KEY)
.setAnalysisDate(150000000L)
.setDeletedComponentsCount(1)
.build());
@Category(DbTests.class)
public class PersistComponentsStepTest extends BaseStepTest {
+ private static final String PROJECT_KEY = "PROJECT_KEY";
+
@ClassRule
public static DbTester dbTester = new DbTester();
@Test
public void persist_components() throws Exception {
- computeComponentsRefCache.addComponent(1, new ComputeComponentsRefCache.ComputeComponent("PROJECT_KEY", "ABCD"));
+ computeComponentsRefCache.addComponent(1, new ComputeComponentsRefCache.ComputeComponent(PROJECT_KEY, "ABCD"));
computeComponentsRefCache.addComponent(2, new ComputeComponentsRefCache.ComputeComponent("MODULE_KEY", "BCDE"));
computeComponentsRefCache.addComponent(3, new ComputeComponentsRefCache.ComputeComponent("MODULE_KEY:src/main/java/dir", "CDEF"));
computeComponentsRefCache.addComponent(4, new ComputeComponentsRefCache.ComputeComponent("MODULE_KEY:src/main/java/dir/Foo.java", "DEFG"));
writer.writeComponent(BatchReport.Component.newBuilder()
.setRef(1)
.setType(Constants.ComponentType.PROJECT)
- .setKey("PROJECT_KEY")
+ .setKey(PROJECT_KEY)
.setName("Project")
.setDescription("Project description")
.addChildRef(2)
.setLanguage("java")
.build());
- sut.execute(new ComputationContext(new BatchReportReader(reportDir), ComponentTesting.newProjectDto()));
+ sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
assertThat(dbTester.countRowsOfTable("projects")).isEqualTo(4);
- ComponentDto project = dbClient.componentDao().selectNullableByKey(session, "PROJECT_KEY");
+ ComponentDto project = dbClient.componentDao().selectNullableByKey(session, PROJECT_KEY);
assertThat(project).isNotNull();
assertThat(project.name()).isEqualTo("Project");
assertThat(project.description()).isEqualTo("Project description");
@Test
public void persist_file_directly_attached_on_root_directory() throws Exception {
- computeComponentsRefCache.addComponent(1, new ComputeComponentsRefCache.ComputeComponent("PROJECT_KEY", "ABCD"));
+ computeComponentsRefCache.addComponent(1, new ComputeComponentsRefCache.ComputeComponent(PROJECT_KEY, "ABCD"));
computeComponentsRefCache.addComponent(2, new ComputeComponentsRefCache.ComputeComponent("PROJECT_KEY:/", "CDEF"));
computeComponentsRefCache.addComponent(3, new ComputeComponentsRefCache.ComputeComponent("PROJECT_KEY:pom.xml", "DEFG"));
writer.writeComponent(BatchReport.Component.newBuilder()
.setRef(1)
.setType(Constants.ComponentType.PROJECT)
- .setKey("PROJECT_KEY")
+ .setKey(PROJECT_KEY)
.setName("Project")
.addChildRef(2)
.build());
.setPath("pom.xml")
.build());
- sut.execute(new ComputationContext(new BatchReportReader(reportDir), ComponentTesting.newProjectDto()));
+ sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
ComponentDto directory = dbClient.componentDao().selectNullableByKey(session, "PROJECT_KEY:/");
assertThat(directory).isNotNull();
@Test
public void persist_unit_test() throws Exception {
- computeComponentsRefCache.addComponent(1, new ComputeComponentsRefCache.ComputeComponent("PROJECT_KEY", "ABCD"));
+ computeComponentsRefCache.addComponent(1, new ComputeComponentsRefCache.ComputeComponent(PROJECT_KEY, "ABCD"));
computeComponentsRefCache.addComponent(2, new ComputeComponentsRefCache.ComputeComponent("PROJECT_KEY:src/test/java/dir", "CDEF"));
computeComponentsRefCache.addComponent(3, new ComputeComponentsRefCache.ComputeComponent("PROJECT_KEY:src/test/java/dir/FooTest.java", "DEFG"));
writer.writeComponent(BatchReport.Component.newBuilder()
.setRef(1)
.setType(Constants.ComponentType.PROJECT)
- .setKey("PROJECT_KEY")
+ .setKey(PROJECT_KEY)
.setName("Project")
.addChildRef(2)
.build());
.setIsTest(true)
.build());
- sut.execute(new ComputationContext(new BatchReportReader(reportDir), ComponentTesting.newProjectDto()));
+ sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
ComponentDto file = dbClient.componentDao().selectNullableByKey(session, "PROJECT_KEY:src/test/java/dir/FooTest.java");
assertThat(file).isNotNull();
@Test
public void persist_only_new_components() throws Exception {
- computeComponentsRefCache.addComponent(1, new ComputeComponentsRefCache.ComputeComponent("PROJECT_KEY", "ABCD"));
+ computeComponentsRefCache.addComponent(1, new ComputeComponentsRefCache.ComputeComponent(PROJECT_KEY, "ABCD"));
computeComponentsRefCache.addComponent(2, new ComputeComponentsRefCache.ComputeComponent("MODULE_KEY", "BCDE"));
computeComponentsRefCache.addComponent(3, new ComputeComponentsRefCache.ComputeComponent("MODULE_KEY:src/main/java/dir", "CDEF"));
computeComponentsRefCache.addComponent(4, new ComputeComponentsRefCache.ComputeComponent("MODULE_KEY:src/main/java/dir/Foo.java", "DEFG"));
// Project amd module already exists
- ComponentDto project = ComponentTesting.newProjectDto("ABCD").setKey("PROJECT_KEY").setName("Project");
+ ComponentDto project = ComponentTesting.newProjectDto("ABCD").setKey(PROJECT_KEY).setName("Project");
dbClient.componentDao().insert(session, project);
ComponentDto module = ComponentTesting.newModuleDto("BCDE", project).setKey("MODULE_KEY").setName("Module");
dbClient.componentDao().insert(session, module);
writer.writeComponent(BatchReport.Component.newBuilder()
.setRef(1)
.setType(Constants.ComponentType.PROJECT)
- .setKey("PROJECT_KEY")
+ .setKey(PROJECT_KEY)
.setName("Project")
.addChildRef(2)
.build());
.setPath("src/main/java/dir/Foo.java")
.build());
- sut.execute(new ComputationContext(new BatchReportReader(reportDir), project));
+ sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
assertThat(dbTester.countRowsOfTable("projects")).isEqualTo(4);
- ComponentDto projectReloaded = dbClient.componentDao().selectNullableByKey(session, "PROJECT_KEY");
+ ComponentDto projectReloaded = dbClient.componentDao().selectNullableByKey(session, PROJECT_KEY);
assertThat(projectReloaded.getId()).isEqualTo(project.getId());
assertThat(projectReloaded.uuid()).isEqualTo(project.uuid());
writer.writeComponent(BatchReport.Component.newBuilder()
.setRef(1)
.setType(Constants.ComponentType.PROJECT)
- .setKey("PROJECT_KEY")
+ .setKey(PROJECT_KEY)
.setName("Project")
.addChildRef(2)
.build());
.setPath("src/main/java/dir")
.build());
- sut.execute(new ComputationContext(new BatchReportReader(reportDir), ComponentTesting.newProjectDto()));
+ sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
assertThat(dbTester.countRowsOfTable("projects")).isEqualTo(5);
- ComponentDto project = dbClient.componentDao().selectNullableByKey(session, "PROJECT_KEY");
+ ComponentDto project = dbClient.componentDao().selectNullableByKey(session, PROJECT_KEY);
assertThat(project).isNotNull();
assertThat(project.parentProjectId()).isNull();
@Test
public void nothing_to_persist() throws Exception {
- computeComponentsRefCache.addComponent(1, new ComputeComponentsRefCache.ComputeComponent("PROJECT_KEY", "ABCD"));
+ computeComponentsRefCache.addComponent(1, new ComputeComponentsRefCache.ComputeComponent(PROJECT_KEY, "ABCD"));
computeComponentsRefCache.addComponent(2, new ComputeComponentsRefCache.ComputeComponent("MODULE_KEY", "BCDE"));
computeComponentsRefCache.addComponent(3, new ComputeComponentsRefCache.ComputeComponent("MODULE_KEY:src/main/java/dir", "CDEF"));
computeComponentsRefCache.addComponent(4, new ComputeComponentsRefCache.ComputeComponent("MODULE_KEY:src/main/java/dir/Foo.java", "DEFG"));
- ComponentDto project = ComponentTesting.newProjectDto("ABCD").setKey("PROJECT_KEY").setName("Project");
+ ComponentDto project = ComponentTesting.newProjectDto("ABCD").setKey(PROJECT_KEY).setName("Project");
dbClient.componentDao().insert(session, project);
ComponentDto module = ComponentTesting.newModuleDto("BCDE", project).setKey("MODULE_KEY").setName("Module");
dbClient.componentDao().insert(session, module);
writer.writeComponent(BatchReport.Component.newBuilder()
.setRef(1)
.setType(Constants.ComponentType.PROJECT)
- .setKey("PROJECT_KEY")
- .setName("Project")
- .addChildRef(2)
- .build());
+ .setKey(PROJECT_KEY)
+ .setName("Project")
+ .addChildRef(2)
+ .build());
writer.writeComponent(BatchReport.Component.newBuilder()
.setRef(2)
.setType(Constants.ComponentType.MODULE)
.setPath("src/main/java/dir/Foo.java")
.build());
- sut.execute(new ComputationContext(new BatchReportReader(reportDir), project));
+ sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
assertThat(dbTester.countRowsOfTable("projects")).isEqualTo(4);
- assertThat(dbClient.componentDao().selectNullableByKey(session, "PROJECT_KEY").getId()).isEqualTo(project.getId());
+ assertThat(dbClient.componentDao().selectNullableByKey(session, PROJECT_KEY).getId()).isEqualTo(project.getId());
assertThat(dbClient.componentDao().selectNullableByKey(session, "MODULE_KEY").getId()).isEqualTo(module.getId());
assertThat(dbClient.componentDao().selectNullableByKey(session, "MODULE_KEY:src/main/java/dir").getId()).isEqualTo(directory.getId());
assertThat(dbClient.componentDao().selectNullableByKey(session, "MODULE_KEY:src/main/java/dir/Foo.java").getId()).isEqualTo(file.getId());
- ComponentDto projectReloaded = dbClient.componentDao().selectNullableByKey(session, "PROJECT_KEY");
+ ComponentDto projectReloaded = dbClient.componentDao().selectNullableByKey(session, PROJECT_KEY);
assertThat(projectReloaded.getId()).isEqualTo(project.getId());
assertThat(projectReloaded.uuid()).isEqualTo(project.uuid());
assertThat(projectReloaded.moduleUuid()).isEqualTo(project.moduleUuid());
@Test
public void update_name_and_description() throws Exception {
- computeComponentsRefCache.addComponent(1, new ComputeComponentsRefCache.ComputeComponent("PROJECT_KEY", "ABCD"));
+ computeComponentsRefCache.addComponent(1, new ComputeComponentsRefCache.ComputeComponent(PROJECT_KEY, "ABCD"));
computeComponentsRefCache.addComponent(2, new ComputeComponentsRefCache.ComputeComponent("MODULE_KEY", "BCDE"));
- ComponentDto project = ComponentTesting.newProjectDto("ABCD").setKey("PROJECT_KEY").setName("Project");
+ ComponentDto project = ComponentTesting.newProjectDto("ABCD").setKey(PROJECT_KEY).setName("Project");
dbClient.componentDao().insert(session, project);
ComponentDto module = ComponentTesting.newModuleDto("BCDE", project).setKey("MODULE_KEY").setName("Module");
dbClient.componentDao().insert(session, module);
writer.writeComponent(BatchReport.Component.newBuilder()
.setRef(1)
.setType(Constants.ComponentType.PROJECT)
- .setKey("PROJECT_KEY")
+ .setKey(PROJECT_KEY)
.setName("New project name")
.setDescription("New project description")
.addChildRef(2)
.setDescription("New module description")
.build());
- sut.execute(new ComputationContext(new BatchReportReader(reportDir), project));
+ sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
- ComponentDto projectReloaded = dbClient.componentDao().selectNullableByKey(session, "PROJECT_KEY");
+ ComponentDto projectReloaded = dbClient.componentDao().selectNullableByKey(session, PROJECT_KEY);
assertThat(projectReloaded.name()).isEqualTo("New project name");
assertThat(projectReloaded.description()).isEqualTo("New project description");
@Test
public void update_module_uuid_when_moving_a_module() throws Exception {
- computeComponentsRefCache.addComponent(1, new ComputeComponentsRefCache.ComputeComponent("PROJECT_KEY", "ABCD"));
+ computeComponentsRefCache.addComponent(1, new ComputeComponentsRefCache.ComputeComponent(PROJECT_KEY, "ABCD"));
computeComponentsRefCache.addComponent(2, new ComputeComponentsRefCache.ComputeComponent("MODULE_A", "EDCB"));
computeComponentsRefCache.addComponent(3, new ComputeComponentsRefCache.ComputeComponent("MODULE_B", "BCDE"));
computeComponentsRefCache.addComponent(4, new ComputeComponentsRefCache.ComputeComponent("MODULE_B:src/main/java/dir", "CDEF"));
computeComponentsRefCache.addComponent(5, new ComputeComponentsRefCache.ComputeComponent("MODULE_B:src/main/java/dir/Foo.java", "DEFG"));
- ComponentDto project = ComponentTesting.newProjectDto("ABCD").setKey("PROJECT_KEY").setName("Project");
+ ComponentDto project = ComponentTesting.newProjectDto("ABCD").setKey(PROJECT_KEY).setName("Project");
dbClient.componentDao().insert(session, project);
ComponentDto moduleA = ComponentTesting.newModuleDto("EDCB", project).setKey("MODULE_A").setName("Module A");
ComponentDto moduleB = ComponentTesting.newModuleDto("BCDE", project).setKey("MODULE_B").setName("Module B");
writer.writeComponent(BatchReport.Component.newBuilder()
.setRef(1)
.setType(Constants.ComponentType.PROJECT)
- .setKey("PROJECT_KEY")
+ .setKey(PROJECT_KEY)
.setName("Project")
.addChildRef(2)
.build());
.setPath("src/main/java/dir/Foo.java")
.build());
- sut.execute(new ComputationContext(new BatchReportReader(reportDir), project));
+ sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
assertThat(dbTester.countRowsOfTable("projects")).isEqualTo(5);
import org.sonar.core.measure.db.MetricDto;
import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.DbTester;
-import org.sonar.server.component.ComponentTesting;
import org.sonar.server.computation.ComputationContext;
import org.sonar.server.computation.component.DbComponentsRefCache;
import org.sonar.server.computation.component.DbComponentsRefCache.DbComponent;
@Category(DbTests.class)
public class PersistDuplicationsStepTest extends BaseStepTest {
+ private static final String PROJECT_KEY = "PROJECT_KEY";
+
@Rule
public TemporaryFolder temp = new TemporaryFolder();
saveDuplicationMetric();
initReportWithProjectAndFile();
- sut.execute(new ComputationContext(new BatchReportReader(reportDir), ComponentTesting.newProjectDto("PROJECT")));
+ sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
assertThat(dbTester.countRowsOfTable("project_measures")).isEqualTo(0);
}
.build();
writer.writeComponentDuplications(2, newArrayList(duplication));
- sut.execute(new ComputationContext(new BatchReportReader(reportDir), ComponentTesting.newProjectDto("PROJECT")));
+ sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
assertThat(dbTester.countRowsOfTable("project_measures")).isEqualTo(1);
@Test
public void persist_duplications_on_same_file_linked_on_a_module() throws Exception {
- dbComponentsRefCache.addComponent(1, new DbComponent(1L, "PROJECT_KEY", "ABCD"));
+ dbComponentsRefCache.addComponent(1, new DbComponent(1L, PROJECT_KEY, "ABCD"));
dbComponentsRefCache.addComponent(2, new DbComponent(2L, "MODULE_KEY", "BCDE"));
dbComponentsRefCache.addComponent(3, new DbComponent(3L, "MODULE_KEY:file", "CDEF"));
writer.writeComponent(BatchReport.Component.newBuilder()
.setRef(1)
.setType(Constants.ComponentType.PROJECT)
- .setKey("PROJECT_KEY")
+ .setKey(PROJECT_KEY)
.setSnapshotId(10L)
.addChildRef(2)
.build());
.build();
writer.writeComponentDuplications(3, newArrayList(duplication));
- sut.execute(new ComputationContext(new BatchReportReader(reportDir), ComponentTesting.newProjectDto("PROJECT")));
+ sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
assertThat(dbTester.countRowsOfTable("project_measures")).isEqualTo(1);
@Test
public void persist_duplications_on_same_file_linked_on_a_folder() {
- dbComponentsRefCache.addComponent(1, new DbComponent(1L, "PROJECT_KEY", "ABCD"));
+ dbComponentsRefCache.addComponent(1, new DbComponent(1L, PROJECT_KEY, "ABCD"));
dbComponentsRefCache.addComponent(2, new DbComponent(2L, "PROJECT_KEY:dir", "BCDE"));
dbComponentsRefCache.addComponent(3, new DbComponent(3L, "PROJECT_KEY:file", "CDEF"));
writer.writeComponent(BatchReport.Component.newBuilder()
.setRef(1)
.setType(Constants.ComponentType.PROJECT)
- .setKey("PROJECT_KEY")
+ .setKey(PROJECT_KEY)
.setSnapshotId(10L)
.addChildRef(2)
.build());
.build();
writer.writeComponentDuplications(3, newArrayList(duplication));
- sut.execute(new ComputationContext(new BatchReportReader(reportDir), ComponentTesting.newProjectDto("PROJECT")));
+ sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
assertThat(dbTester.countRowsOfTable("project_measures")).isEqualTo(1);
@Test
public void persist_duplications_on_same_file_linked_on_sub_folder() {
- dbComponentsRefCache.addComponent(1, new DbComponent(1L, "PROJECT_KEY", "ABCD"));
+ dbComponentsRefCache.addComponent(1, new DbComponent(1L, PROJECT_KEY, "ABCD"));
dbComponentsRefCache.addComponent(2, new DbComponent(2L, "PROJECT_KEY:dir", "BCDE"));
dbComponentsRefCache.addComponent(3, new DbComponent(3L, "PROJECT_KEY:dir", "CDEF"));
dbComponentsRefCache.addComponent(10, new DbComponent(10L, "PROJECT_KEY:file", "DEFG"));
writer.writeComponent(BatchReport.Component.newBuilder()
.setRef(1)
.setType(Constants.ComponentType.PROJECT)
- .setKey("PROJECT_KEY")
+ .setKey(PROJECT_KEY)
.setSnapshotId(10L)
.addChildRef(2)
.build());
.build();
writer.writeComponentDuplications(10, newArrayList(duplication));
- sut.execute(new ComputationContext(new BatchReportReader(reportDir), ComponentTesting.newProjectDto("PROJECT")));
+ sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
assertThat(dbTester.countRowsOfTable("project_measures")).isEqualTo(1);
.build();
writer.writeComponentDuplications(2, newArrayList(duplication));
- sut.execute(new ComputationContext(new BatchReportReader(reportDir), ComponentTesting.newProjectDto("PROJECT")));
+ sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
assertThat(dbTester.countRowsOfTable("project_measures")).isEqualTo(1);
.build();
writer.writeComponentDuplications(2, newArrayList(duplication));
- sut.execute(new ComputationContext(new BatchReportReader(reportDir), ComponentTesting.newProjectDto("PROJECT")));
+ sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
assertThat(dbTester.countRowsOfTable("project_measures")).isEqualTo(1);
}
private BatchReportWriter initReportWithProjectAndFile() {
- dbComponentsRefCache.addComponent(1, new DbComponent(1L, "PROJECT_KEY", "ABCD"));
+ 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.writeComponent(BatchReport.Component.newBuilder()
.setRef(1)
.setType(Constants.ComponentType.PROJECT)
- .setKey("PROJECT_KEY")
+ .setKey(PROJECT_KEY)
.setSnapshotId(10L)
.addChildRef(2)
.build());
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.computation.ComputationContext;
@Category(DbTests.class)
public class PersistEventsStepTest extends BaseStepTest {
+ private static final String PROJECT_KEY = "PROJECT_KEY";
+
@Rule
public TemporaryFolder temp = new TemporaryFolder();
public void nothing_to_do_when_no_events_in_report() throws Exception {
dbTester.prepareDbUnit(getClass(), "nothing_to_do_when_no_events_in_report.xml");
- dbComponentsRefCache.addComponent(1, new DbComponent(1L, "PROJECT_KEY", "ABCD"));
+ dbComponentsRefCache.addComponent(1, new DbComponent(1L, PROJECT_KEY, "ABCD"));
File reportDir = temp.newFolder();
BatchReportWriter writer = new BatchReportWriter(reportDir);
writer.writeMetadata(BatchReport.Metadata.newBuilder()
.setRootComponentRef(1)
- .setProjectKey("PROJECT_KEY")
+ .setProjectKey(PROJECT_KEY)
.setAnalysisDate(150000000L)
.build());
.setType(Constants.ComponentType.PROJECT)
.build());
- step.execute(new ComputationContext(new BatchReportReader(reportDir), mock(ComponentDto.class)));
+ step.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
dbTester.assertDbUnit(getClass(), "nothing_to_do_when_no_events_in_report.xml", "events");
}
public void persist_report_events() throws Exception {
dbTester.prepareDbUnit(getClass(), "empty.xml");
- dbComponentsRefCache.addComponent(1, new DbComponent(1L, "PROJECT_KEY", "ABCD"));
+ dbComponentsRefCache.addComponent(1, new DbComponent(1L, PROJECT_KEY, "ABCD"));
File reportDir = temp.newFolder();
BatchReportWriter writer = new BatchReportWriter(reportDir);
writer.writeMetadata(BatchReport.Metadata.newBuilder()
.setRootComponentRef(1)
- .setProjectKey("PROJECT_KEY")
+ .setProjectKey(PROJECT_KEY)
.setAnalysisDate(150000000L)
.build());
)
.build());
- step.execute(new ComputationContext(new BatchReportReader(reportDir), mock(ComponentDto.class)));
+ step.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
dbTester.assertDbUnit(getClass(), "add_events-result.xml", "events");
}
public void persist_report_events_with_component_children() throws Exception {
dbTester.prepareDbUnit(getClass(), "empty.xml");
- dbComponentsRefCache.addComponent(1, new DbComponent(1L, "PROJECT_KEY", "ABCD"));
+ 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()
.setRootComponentRef(1)
- .setProjectKey("PROJECT_KEY")
+ .setProjectKey(PROJECT_KEY)
.setAnalysisDate(150000000L)
.build());
.build()
).build());
- step.execute(new ComputationContext(new BatchReportReader(reportDir), mock(ComponentDto.class)));
+ step.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
dbTester.assertDbUnit(getClass(), "persist_report_events_with_component_children-result.xml", "events");
}
public void create_version_event() throws Exception {
dbTester.prepareDbUnit(getClass(), "empty.xml");
- dbComponentsRefCache.addComponent(1, new DbComponent(1L, "PROJECT_KEY", "ABCD"));
+ dbComponentsRefCache.addComponent(1, new DbComponent(1L, PROJECT_KEY, "ABCD"));
File reportDir = temp.newFolder();
BatchReportWriter writer = new BatchReportWriter(reportDir);
writer.writeMetadata(BatchReport.Metadata.newBuilder()
.setRootComponentRef(1)
- .setProjectKey("PROJECT_KEY")
+ .setProjectKey(PROJECT_KEY)
.setAnalysisDate(150000000L)
.build());
.setVersion("1.0")
.build());
- step.execute(new ComputationContext(new BatchReportReader(reportDir), mock(ComponentDto.class)));
+ step.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
dbTester.assertDbUnit(getClass(), "add_version_event-result.xml", "events");
}
public void keep_one_event_by_version() throws Exception {
dbTester.prepareDbUnit(getClass(), "keep_one_event_by_version.xml");
- dbComponentsRefCache.addComponent(1, new DbComponent(1L, "PROJECT_KEY", "ABCD"));
+ dbComponentsRefCache.addComponent(1, new DbComponent(1L, PROJECT_KEY, "ABCD"));
File reportDir = temp.newFolder();
BatchReportWriter writer = new BatchReportWriter(reportDir);
writer.writeMetadata(BatchReport.Metadata.newBuilder()
.setRootComponentRef(1)
- .setProjectKey("PROJECT_KEY")
+ .setProjectKey(PROJECT_KEY)
.setAnalysisDate(150000000L)
.build());
.setVersion("1.5-SNAPSHOT")
.build());
- step.execute(new ComputationContext(new BatchReportReader(reportDir), mock(ComponentDto.class)));
+ step.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
dbTester.assertDbUnit(getClass(), "keep_one_event_by_version-result.xml", "events");
}
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.component.ComponentTesting;
import org.sonar.server.computation.ComputationContext;
import org.sonar.server.computation.component.DbComponentsRefCache;
import org.sonar.server.db.DbClient;
private static final int FILE_REF = 3;
private static final String PROJECT_UUID = "PROJECT";
+ private static final String PROJECT_KEY = "PROJECT_KEY";
private static final String FILE_UUID = "FILE";
@Rule
public void persist_sources() throws Exception {
initBasicReport(2);
- sut.execute(new ComputationContext(new BatchReportReader(reportDir), ComponentTesting.newProjectDto(PROJECT_UUID)));
+ sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1);
FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectSource(FILE_UUID);
@Test
public void persist_last_line() throws Exception {
- dbComponentsRefCache.addComponent(1, new DbComponentsRefCache.DbComponent(1L, "PROJECT_KEY", PROJECT_UUID));
+ dbComponentsRefCache.addComponent(1, new DbComponentsRefCache.DbComponent(1L, PROJECT_KEY, PROJECT_UUID));
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()
.setRootComponentRef(1)
- .setProjectKey("PROJECT_KEY")
+ .setProjectKey(PROJECT_KEY)
.build());
writer.writeComponent(BatchReport.Component.newBuilder()
.setRef(1)
.setLines(3)
.build());
- sut.execute(new ComputationContext(new BatchReportReader(reportDir), ComponentTesting.newProjectDto(PROJECT_UUID)));
+ sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1);
FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectSource(FILE_UUID);
public void persist_source_hashes() throws Exception {
initBasicReport(2);
- sut.execute(new ComputationContext(new BatchReportReader(reportDir), ComponentTesting.newProjectDto(PROJECT_UUID)));
+ sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1);
FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectSource("FILE");
.setOverallCoveredConditions(4)
.build()));
- sut.execute(new ComputationContext(new BatchReportReader(reportDir), ComponentTesting.newProjectDto(PROJECT_UUID)));
+ sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1);
FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectSource(FILE_UUID);
.addChangesetIndexByLine(0)
.build());
- sut.execute(new ComputationContext(new BatchReportReader(reportDir), ComponentTesting.newProjectDto(PROJECT_UUID)));
+ sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1);
FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectSource(FILE_UUID);
.build()
));
- sut.execute(new ComputationContext(new BatchReportReader(reportDir), ComponentTesting.newProjectDto(PROJECT_UUID)));
+ sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1);
FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectSource(FILE_UUID);
).build()
));
- sut.execute(new ComputationContext(new BatchReportReader(reportDir), ComponentTesting.newProjectDto(PROJECT_UUID)));
+ sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1);
FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectSource(FILE_UUID);
.build()
));
- sut.execute(new ComputationContext(new BatchReportReader(reportDir), ComponentTesting.newProjectDto(PROJECT_UUID)));
+ sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1);
FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectSource(FILE_UUID);
// Sources from the report
initBasicReport(1);
- sut.execute(new ComputationContext(new BatchReportReader(reportDir), ComponentTesting.newProjectDto(PROJECT_UUID)));
+ sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1);
FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectSource(FILE_UUID);
initBasicReport(1);
- sut.execute(new ComputationContext(new BatchReportReader(reportDir), ComponentTesting.newProjectDto(PROJECT_UUID)));
+ sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1);
FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectSource(FILE_UUID);
initBasicReport(1);
- sut.execute(new ComputationContext(new BatchReportReader(reportDir), ComponentTesting.newProjectDto(PROJECT_UUID)));
+ sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1);
FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectSource(FILE_UUID);
));
try {
- sut.execute(new ComputationContext(new BatchReportReader(reportDir), ComponentTesting.newProjectDto(PROJECT_UUID)));
+ sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
failBecauseExceptionWasNotThrown(IllegalStateException.class);
} catch (IllegalStateException e){
assertThat(e).hasMessage("Cannot persist sources of src/Foo.java").hasCauseInstanceOf(IllegalArgumentException.class);
}
private BatchReportWriter initBasicReport(int numberOfLines) throws IOException {
- dbComponentsRefCache.addComponent(1, new DbComponentsRefCache.DbComponent(1L, "PROJECT_KEY", PROJECT_UUID));
+ dbComponentsRefCache.addComponent(1, new DbComponentsRefCache.DbComponent(1L, PROJECT_KEY, PROJECT_UUID));
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()
.setRootComponentRef(1)
- .setProjectKey("PROJECT_KEY")
+ .setProjectKey(PROJECT_KEY)
.build());
writer.writeComponent(BatchReport.Component.newBuilder()
import java.util.Map;
import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.mock;
@Category(DbTests.class)
public class PersistMeasuresStepTest extends BaseStepTest {
+ private static final String PROJECT_KEY = "PROJECT_KEY";
private static final String METRIC_KEY = "metric-key";
private static final RuleKey RULE_KEY = RuleKey.of("repo", "rule-key");
.setCharactericId(123456)
.build()));
- sut.execute(new ComputationContext(new BatchReportReader(dir), mock(ComponentDto.class)));
+ sut.execute(new ComputationContext(new BatchReportReader(dir), PROJECT_KEY));
session.commit();
assertThat(dbTester.countRowsOfTable("project_measures")).isEqualTo(2);
import org.sonar.batch.protocol.output.BatchReportWriter;
import org.sonar.core.measure.db.MetricDto;
import org.sonar.core.persistence.DbTester;
-import org.sonar.server.component.ComponentTesting;
import org.sonar.server.computation.ComputationContext;
import org.sonar.server.computation.component.DbComponentsRefCache;
import org.sonar.server.computation.measure.MetricCache;
)
.build()
);
- ComputationContext context = new ComputationContext(new BatchReportReader(dir), ComponentTesting.newProjectDto("project-uuid"));
+ ComputationContext context = new ComputationContext(new BatchReportReader(dir), "PROJECT_KEY");
sut.execute(context);
Date sixDaysAgo = DateUtils.addDays(new Date(), -6);
when(sourceLineIndex.lastCommitDateOnProject("project-uuid")).thenReturn(sixDaysAgo);
initReportWithProjectAndFile();
- ComputationContext context = new ComputationContext(new BatchReportReader(dir), ComponentTesting.newProjectDto("project-uuid"));
+ ComputationContext context = new ComputationContext(new BatchReportReader(dir), "PROJECT_KEY");
sut.execute(context);
@Test
public void no_scm_information_in_report_and_index() {
initReportWithProjectAndFile();
- ComputationContext context = new ComputationContext(new BatchReportReader(dir), ComponentTesting.newProjectDto("project-uuid"));
+ ComputationContext context = new ComputationContext(new BatchReportReader(dir),"PROJECT_KEY");
sut.execute(context);
}
private BatchReportWriter initReportWithProjectAndFile() {
- dbComponentsRefCache.addComponent(1, new DbComponentsRefCache.DbComponent(1L, "project-key", "project-uuid"));
- dbComponentsRefCache.addComponent(2, new DbComponentsRefCache.DbComponent(2L, "project-key:file", "file-uuid"));
+ 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()
writer.writeComponent(BatchReport.Component.newBuilder()
.setRef(1)
.setType(Constants.ComponentType.PROJECT)
- .setKey("project-key")
+ .setKey("PROJECT_KEY")
.setSnapshotId(10L)
.addChildRef(2)
.build());
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.db.ComponentLinkDao;
@Category(DbTests.class)
public class PersistProjectLinksStepTest extends BaseStepTest {
+ private static final String PROJECT_KEY = "PROJECT_KEY";
+
@Rule
public TemporaryFolder temp = new TemporaryFolder();
public void add_links_on_project_and_module() throws Exception {
dbTester.prepareDbUnit(getClass(), "empty.xml");
- dbComponentsRefCache.addComponent(1, new DbComponentsRefCache.DbComponent(1L, "PROJECT_KEY", "ABCD"));
+ dbComponentsRefCache.addComponent(1, new DbComponentsRefCache.DbComponent(1L, PROJECT_KEY, "ABCD"));
dbComponentsRefCache.addComponent(2, new DbComponentsRefCache.DbComponent(2L, "MODULE_KEY", "BCDE"));
File reportDir = temp.newFolder();
BatchReportWriter writer = new BatchReportWriter(reportDir);
writer.writeMetadata(BatchReport.Metadata.newBuilder()
.setRootComponentRef(1)
- .setProjectKey("PROJECT_KEY")
+ .setProjectKey(PROJECT_KEY)
.setAnalysisDate(150000000L)
.build());
.addLink(BatchReport.ComponentLink.newBuilder().setType(Constants.ComponentLinkType.SCM).setHref("https://github.com/SonarSource/sonar/server").build())
.build());
- step.execute(new ComputationContext(new BatchReportReader(reportDir), mock(ComponentDto.class)));
+ step.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
dbTester.assertDbUnit(getClass(), "add_links_on_project_and_module-result.xml", "project_links");
}
public void nothing_to_do_when_link_already_exists() throws Exception {
dbTester.prepareDbUnit(getClass(), "nothing_to_do_when_link_already_exists.xml");
- dbComponentsRefCache.addComponent(1, new DbComponentsRefCache.DbComponent(1L, "PROJECT_KEY", "ABCD"));
+ dbComponentsRefCache.addComponent(1, new DbComponentsRefCache.DbComponent(1L, PROJECT_KEY, "ABCD"));
File reportDir = temp.newFolder();
BatchReportWriter writer = new BatchReportWriter(reportDir);
writer.writeMetadata(BatchReport.Metadata.newBuilder()
.setRootComponentRef(1)
- .setProjectKey("PROJECT_KEY")
+ .setProjectKey(PROJECT_KEY)
.build());
writer.writeComponent(BatchReport.Component.newBuilder()
.addLink(BatchReport.ComponentLink.newBuilder().setType(Constants.ComponentLinkType.HOME).setHref("http://www.sonarqube.org").build())
.build());
- step.execute(new ComputationContext(new BatchReportReader(reportDir), mock(ComponentDto.class)));
+ step.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
dbTester.assertDbUnit(getClass(), "nothing_to_do_when_link_already_exists.xml", "project_links");
}
public void do_not_add_links_on_file() throws Exception {
dbTester.prepareDbUnit(getClass(), "empty.xml");
- dbComponentsRefCache.addComponent(1, new DbComponentsRefCache.DbComponent(1L, "PROJECT_KEY", "ABCD"));
+ dbComponentsRefCache.addComponent(1, new DbComponentsRefCache.DbComponent(1L, PROJECT_KEY, "ABCD"));
File reportDir = temp.newFolder();
BatchReportWriter writer = new BatchReportWriter(reportDir);
writer.writeMetadata(BatchReport.Metadata.newBuilder()
.setRootComponentRef(1)
- .setProjectKey("PROJECT_KEY")
+ .setProjectKey(PROJECT_KEY)
.build());
writer.writeComponent(BatchReport.Component.newBuilder()
.addLink(BatchReport.ComponentLink.newBuilder().setType(Constants.ComponentLinkType.HOME).setHref("http://www.sonarqube.org").build())
.build());
- step.execute(new ComputationContext(new BatchReportReader(reportDir), mock(ComponentDto.class)));
+ step.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
assertThat(dbTester.countRowsOfTable("project_links")).isEqualTo(0);
}
public void update_link() throws Exception {
dbTester.prepareDbUnit(getClass(), "update_link.xml");
- dbComponentsRefCache.addComponent(1, new DbComponentsRefCache.DbComponent(1L, "PROJECT_KEY", "ABCD"));
+ dbComponentsRefCache.addComponent(1, new DbComponentsRefCache.DbComponent(1L, PROJECT_KEY, "ABCD"));
File reportDir = temp.newFolder();
BatchReportWriter writer = new BatchReportWriter(reportDir);
writer.writeMetadata(BatchReport.Metadata.newBuilder()
.setRootComponentRef(1)
- .setProjectKey("PROJECT_KEY")
+ .setProjectKey(PROJECT_KEY)
.build());
writer.writeComponent(BatchReport.Component.newBuilder()
.addLink(BatchReport.ComponentLink.newBuilder().setType(Constants.ComponentLinkType.HOME).setHref("http://www.sonarqube.org").build())
.build());
- step.execute(new ComputationContext(new BatchReportReader(reportDir), mock(ComponentDto.class)));
+ step.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
dbTester.assertDbUnit(getClass(), "update_link-result.xml", "project_links");
}
public void delete_link() throws Exception {
dbTester.prepareDbUnit(getClass(), "delete_link.xml");
- dbComponentsRefCache.addComponent(1, new DbComponentsRefCache.DbComponent(1L, "PROJECT_KEY", "ABCD"));
+ dbComponentsRefCache.addComponent(1, new DbComponentsRefCache.DbComponent(1L, PROJECT_KEY, "ABCD"));
File reportDir = temp.newFolder();
BatchReportWriter writer = new BatchReportWriter(reportDir);
writer.writeMetadata(BatchReport.Metadata.newBuilder()
.setRootComponentRef(1)
- .setProjectKey("PROJECT_KEY")
+ .setProjectKey(PROJECT_KEY)
.build());
writer.writeComponent(BatchReport.Component.newBuilder()
.setType(Constants.ComponentType.PROJECT)
.build());
- step.execute(new ComputationContext(new BatchReportReader(reportDir), mock(ComponentDto.class)));
+ step.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
assertThat(dbTester.countRowsOfTable("project_links")).isEqualTo(0);
}
public void not_delete_custom_link() throws Exception {
dbTester.prepareDbUnit(getClass(), "not_delete_custom_link.xml");
- dbComponentsRefCache.addComponent(1, new DbComponentsRefCache.DbComponent(1L, "PROJECT_KEY", "ABCD"));
+ dbComponentsRefCache.addComponent(1, new DbComponentsRefCache.DbComponent(1L, PROJECT_KEY, "ABCD"));
File reportDir = temp.newFolder();
BatchReportWriter writer = new BatchReportWriter(reportDir);
writer.writeMetadata(BatchReport.Metadata.newBuilder()
.setRootComponentRef(1)
- .setProjectKey("PROJECT_KEY")
+ .setProjectKey(PROJECT_KEY)
.build());
writer.writeComponent(BatchReport.Component.newBuilder()
.setType(Constants.ComponentType.PROJECT)
.build());
- step.execute(new ComputationContext(new BatchReportReader(reportDir), mock(ComponentDto.class)));
+ step.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
dbTester.assertDbUnit(getClass(), "not_delete_custom_link.xml", "project_links");
}
public void fail_when_trying_to_add_same_link_type_multiple_times() throws Exception {
dbTester.prepareDbUnit(getClass(), "empty.xml");
- dbComponentsRefCache.addComponent(1, new DbComponentsRefCache.DbComponent(1L, "PROJECT_KEY", "ABCD"));
+ dbComponentsRefCache.addComponent(1, new DbComponentsRefCache.DbComponent(1L, PROJECT_KEY, "ABCD"));
File reportDir = temp.newFolder();
BatchReportWriter writer = new BatchReportWriter(reportDir);
writer.writeMetadata(BatchReport.Metadata.newBuilder()
.setRootComponentRef(1)
- .setProjectKey("PROJECT_KEY")
+ .setProjectKey(PROJECT_KEY)
.build());
writer.writeComponent(BatchReport.Component.newBuilder()
.build());
try {
- step.execute(new ComputationContext(new BatchReportReader(reportDir), mock(ComponentDto.class)));
+ step.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
failBecauseExceptionWasNotThrown(IllegalArgumentException.class);
} catch (IllegalArgumentException e) {
assertThat(e).hasMessage("Link of type 'homepage' has already been declared on component 'ABCD'");
import static org.assertj.core.api.Assertions.tuple;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
-import static org.sonar.server.component.ComponentTesting.newProjectDto;
public class PersistTestsStepTest extends BaseStepTest {
private static final String PROJECT_UUID = "PROJECT";
+ private static final String PROJECT_KEY = "PROJECT_KEY";
private static final int TEST_FILE_REF_1 = 3;
private static final int TEST_FILE_REF_2 = 4;
private static final int MAIN_FILE_REF_1 = 5;
@Test
public void no_test_in_database_and_batch_report() {
- sut.execute(new ComputationContext(new BatchReportReader(reportDir), newProjectDto()));
+ sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
assertThat(dbClient.fileSourceDao().selectTest(TEST_FILE_UUID_1)).isNull();
assertThat(log.logs()).isEmpty();
);
writer.writeCoverageDetails(TEST_FILE_REF_1, coverageDetails);
- sut.execute(new ComputationContext(new BatchReportReader(reportDir), newProjectDto(PROJECT_UUID)));
+ sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
assertThat(db.countRowsOfTable("file_sources")).isEqualTo(1);
writer.writeTests(TEST_FILE_REF_1, Arrays.asList(newTest(1)));
writer.writeCoverageDetails(TEST_FILE_REF_1, Arrays.asList(newCoverageDetail(1, MAIN_FILE_REF_1)));
- sut.execute(new ComputationContext(new BatchReportReader(reportDir), newProjectDto(PROJECT_UUID)));
+ sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
FileSourceDto dto = dbClient.fileSourceDao().selectTest(TEST_FILE_UUID_1);
assertThat(dto.getCreatedAt()).isEqualTo(now);
List<BatchReport.Test> batchTests = Arrays.asList(newTest(1));
writer.writeTests(TEST_FILE_REF_1, batchTests);
- sut.execute(new ComputationContext(new BatchReportReader(reportDir), newProjectDto(PROJECT_UUID)));
+ sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
FileSourceDto dto = dbClient.fileSourceDao().selectTest(TEST_FILE_UUID_1);
assertThat(dto.getFileUuid()).isEqualTo(TEST_FILE_UUID_1);
writer.writeCoverageDetails(TEST_FILE_REF_1, coverageDetails);
writer.writeCoverageDetails(TEST_FILE_REF_2, coverageDetails);
- sut.execute(new ComputationContext(new BatchReportReader(reportDir), newProjectDto(PROJECT_UUID)));
+ sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
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 'KEY_PROJECT'");
+ assertThat(log.logs(LoggerLevel.WARN).get(0)).isEqualTo("Some coverage tests are not taken into account during analysis of project 'PROJECT_KEY'");
assertThat(log.logs(LoggerLevel.TRACE)).hasSize(2);
assertThat(log.logs(LoggerLevel.TRACE).get(0)).isEqualTo("The following test coverages for file 'TEST-PATH-1' have not been taken into account: name#2");
assertThat(log.logs(LoggerLevel.TRACE).get(1)).startsWith("The following test coverages for file 'TEST-PATH-2' have not been taken into account: ");
newCoverageDetailWithLines(1, MAIN_FILE_REF_1, 1, 3),
newCoverageDetailWithLines(1, MAIN_FILE_REF_1, 2, 4)));
- sut.execute(new ComputationContext(new BatchReportReader(reportDir), newProjectDto(PROJECT_UUID)));
+ sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
FileSourceDto dto = dbClient.fileSourceDao().selectTest(TEST_FILE_UUID_1);
List<Integer> coveredLines = dto.getTestData().get(0).getCoveredFile(0).getCoveredLineList();
writer.writeCoverageDetails(TEST_FILE_REF_1, Arrays.asList(newCoverageDetail));
// ACT
- sut.execute(new ComputationContext(new BatchReportReader(reportDir), newProjectDto(PROJECT_UUID)));
+ sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
// ASSERT
FileSourceDto dto = dbClient.fileSourceDao().selectTest(TEST_FILE_UUID_1);
BatchReportWriter writer = new BatchReportWriter(reportDir);
writer.writeMetadata(BatchReport.Metadata.newBuilder()
.setRootComponentRef(1)
- .setProjectKey("PROJECT_KEY")
+ .setProjectKey(PROJECT_KEY)
.build());
writer.writeComponent(BatchReport.Component.newBuilder()
public class PurgeDatastoresStepTest extends BaseStepTest {
+ private static final String PROJECT_KEY = "PROJECT_KEY";
+
ProjectCleaner projectCleaner = mock(ProjectCleaner.class);
DbComponentsRefCache dbComponentsRefCache = new DbComponentsRefCache();
PurgeDatastoresStep sut = new PurgeDatastoresStep(mock(DbClient.class, Mockito.RETURNS_DEEP_STUBS), projectCleaner, dbComponentsRefCache);
@Test
public void call_purge_method_of_the_purge_task() throws IOException {
- dbComponentsRefCache.addComponent(1, new DbComponentsRefCache.DbComponent(123L, "PROJECT_KEY", "UUID-1234"));
+ dbComponentsRefCache.addComponent(1, new DbComponentsRefCache.DbComponent(123L, PROJECT_KEY, "UUID-1234"));
File reportDir = temp.newFolder();
BatchReportWriter writer = new BatchReportWriter(reportDir);
.build());
ComponentDto project = mock(ComponentDto.class);
- ComputationContext context = new ComputationContext(new BatchReportReader(reportDir), project);
+ ComputationContext context = new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY);
sut.execute(context);
import org.sonar.api.notifications.Notification;
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.component.DbComponentsRefCache;
import org.sonar.server.computation.issue.IssueCache;
import org.sonar.server.computation.issue.RuleCache;
import org.sonar.server.issue.notification.IssueChangeNotification;
import org.sonar.server.issue.notification.NewIssuesNotificationFactory;
import org.sonar.server.notifications.NotificationService;
-import static org.mockito.Mockito.*;
+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;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
public class SendIssueNotificationsStepTest extends BaseStepTest {
+ private static final String PROJECT_UUID = "PROJECT_UUID";
+ private static final String PROJECT_KEY = "PROJECT_KEY";
+
@Rule
public TemporaryFolder temp = new TemporaryFolder();
RuleCache ruleCache = mock(RuleCache.class);
NotificationService notifService = mock(NotificationService.class);
- ComputationContext context = mock(ComputationContext.class, Mockito.RETURNS_DEEP_STUBS);
IssueCache issueCache;
+ DbComponentsRefCache dbComponentsRefCache;
NewIssuesNotificationFactory newIssuesNotificationFactory = mock(NewIssuesNotificationFactory.class, Mockito.RETURNS_DEEP_STUBS);
SendIssueNotificationsStep sut;
+ File reportDir;
+
@Before
public void setUp() throws Exception {
issueCache = new IssueCache(temp.newFile(), System2.INSTANCE);
- sut = new SendIssueNotificationsStep(issueCache, ruleCache, notifService, newIssuesNotificationFactory);
+ dbComponentsRefCache = new DbComponentsRefCache();
+ sut = new SendIssueNotificationsStep(issueCache, ruleCache, dbComponentsRefCache, notifService, newIssuesNotificationFactory);
+
+ dbComponentsRefCache.addComponent(1, new DbComponentsRefCache.DbComponent(1L, PROJECT_KEY, PROJECT_UUID));
+
+ reportDir = temp.newFolder();
+ BatchReportWriter writer = new BatchReportWriter(reportDir);
+ writer.writeMetadata(BatchReport.Metadata.newBuilder()
+ .setRootComponentRef(1)
+ .build());
+ writer.writeComponent(BatchReport.Component.newBuilder()
+ .setRef(1)
+ .setType(Constants.ComponentType.PROJECT)
+ .setKey(PROJECT_KEY)
+ .setName("Project name")
+ .build());
}
@Test
- public void do_not_send_notifications_if_no_subscribers() {
- when(context.getProject().uuid()).thenReturn("PROJECT_UUID");
- when(notifService.hasProjectSubscribersForTypes("PROJECT_UUID", SendIssueNotificationsStep.NOTIF_TYPES)).thenReturn(false);
+ public void do_not_send_notifications_if_no_subscribers() throws IOException {
+ when(notifService.hasProjectSubscribersForTypes(PROJECT_UUID, SendIssueNotificationsStep.NOTIF_TYPES)).thenReturn(false);
- sut.execute(context);
+ sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
verify(notifService, never()).deliver(any(Notification.class));
}
issueCache.newAppender().append(new DefaultIssue()
.setSeverity(Severity.BLOCKER)).close();
- when(context.getProject().uuid()).thenReturn("PROJECT_UUID");
- when(context.getReportMetadata()).thenReturn(BatchReport.Metadata.newBuilder().build());
- when(notifService.hasProjectSubscribersForTypes("PROJECT_UUID", SendIssueNotificationsStep.NOTIF_TYPES)).thenReturn(true);
+ when(notifService.hasProjectSubscribersForTypes(PROJECT_UUID, SendIssueNotificationsStep.NOTIF_TYPES)).thenReturn(true);
- sut.execute(context);
+ sut.execute(new ComputationContext(new BatchReportReader(reportDir), PROJECT_KEY));
verify(notifService).deliver(any(NewIssuesNotification.class));
verify(notifService, atLeastOnce()).deliver(any(IssueChangeNotification.class));
@Test
public void set_project() {
- IssueChangeNotification result = notification.setProject(new ComponentDto().setKey("MyService").setLongName("My Service"));
+ IssueChangeNotification result = notification.setProject("MyService", "My Service");
assertThat(result.getFieldValue("projectKey")).isEqualTo("MyService");
assertThat(result.getFieldValue("projectName")).isEqualTo("My Service");
}
import org.sonar.api.notifications.Notification;
import org.sonar.api.user.User;
import org.sonar.api.user.UserFinder;
-import org.sonar.core.component.ComponentDto;
import org.sonar.plugins.emailnotifications.api.EmailMessage;
import java.nio.charset.StandardCharsets;
Notification notification = new IssueChangeNotification()
.setChangeAuthorLogin("simon")
- .setProject(new ComponentDto().setLongName("Struts").setKey("org.apache:struts"));
+ .setProject("Struts", "org.apache:struts");
EmailMessage message = template.format(notification);
assertThat(message.getFrom()).isEqualTo("Simon");
import org.sonar.api.utils.DateUtils;
import org.sonar.api.utils.Duration;
import org.sonar.api.utils.Durations;
-import org.sonar.core.component.ComponentDto;
import org.sonar.core.persistence.DbSession;
-import org.sonar.server.component.ComponentTesting;
import org.sonar.server.db.DbClient;
import org.sonar.server.rule.Rule;
import org.sonar.server.rule.index.RuleDoc;
@Test
public void set_project() {
- ComponentDto component = ComponentTesting.newProjectDto()
- .setLongName("project-long-name")
- .setUuid("project-uuid")
- .setKey("project-key");
-
- sut.setProject(component);
+ sut.setProject("project-key", "project-uuid", "project-long-name");
assertThat(sut.getFieldValue(NewIssuesEmailTemplate.FIELD_PROJECT_NAME)).isEqualTo("project-long-name");
assertThat(sut.getFieldValue(NewIssuesEmailTemplate.FIELD_PROJECT_UUID)).isEqualTo("project-uuid");
@Test
public void set_statistics() {
- ComponentDto component = ComponentTesting.newProjectDto()
- .setLongName("project-long-name");
addIssueNTimes(newIssue1(), 5);
addIssueNTimes(newIssue2(), 3);
when(dbClient.componentDao().selectByUuid(any(DbSession.class), eq("file-uuid")).name()).thenReturn("file-name");
when(ruleIndex.getByKey(RuleKey.of("SonarQube", "rule-the-world"))).thenReturn(newRule("Rule the World", "Java"));
when(ruleIndex.getByKey(RuleKey.of("SonarQube", "rule-the-universe"))).thenReturn(newRule("Rule the Universe", "Clojure"));
- sut.setStatistics(component, stats);
+ sut.setStatistics("project-long-name", stats);
assertThat(sut.getFieldValue(SEVERITY + ".INFO.count")).isEqualTo("5");
assertThat(sut.getFieldValue(SEVERITY + ".BLOCKER.count")).isEqualTo("3");
public class ProjectSettingsFactoryTest {
private ProjectSettingsFactory sut;
- private Settings settings;
- private PropertiesDao dao;
@Before
public void before() {
- this.settings = mock(Settings.class);
- this.dao = mock(PropertiesDao.class);
+ Settings settings = mock(Settings.class);
+ PropertiesDao dao = mock(PropertiesDao.class);
this.sut = new ProjectSettingsFactory(settings, dao);
}
@Test
public void newProjectSettings_returns_a_ProjectSettings() {
- Settings projectSettings = sut.newProjectSettings(1L);
+ Settings projectSettings = sut.newProjectSettings("PROJECT_KEY");
assertThat(projectSettings).isInstanceOf(ProjectSettings.class);
}
<dataset>
- <projects id="10" kee="P1" qualifier="TRK"/>
+ <projects id="10" kee="P1" qualifier="TRK" uuid="ABCD" name="Project 1"/>
<snapshots
id="110" project_id="10" parent_snapshot_id="[null]" root_project_id="10" root_snapshot_id="[null]"
purge_status="[null]" period1_mode="[null]" period1_param="[null]" period1_date="[null]"
import org.apache.commons.lang.StringUtils;
import org.apache.ibatis.session.SqlSession;
import org.sonar.api.batch.BatchSide;
-import org.sonar.api.server.ServerSide;
import org.sonar.api.resources.Scopes;
+import org.sonar.api.server.ServerSide;
import org.sonar.core.persistence.DaoComponent;
import org.sonar.core.persistence.DaoUtils;
import org.sonar.core.persistence.DbSession;
}
}
- public List<PropertyDto> selectProjectProperties(String resourceKey, SqlSession session) {
- return session.getMapper(PropertiesMapper.class).selectProjectProperties(resourceKey);
- }
-
- public List<PropertyDto> selectProjectProperties(long resourceId) {
- SqlSession session = mybatis.openSession(false);
- try {
- return selectProjectProperties(resourceId, session);
- } finally {
- MyBatis.closeQuietly(session);
- }
- }
-
- public List<PropertyDto> selectProjectProperties(long resourceId, SqlSession session) {
- return session.getMapper(PropertiesMapper.class).selectProjectPropertiesByResourceId(resourceId);
+ public List<PropertyDto> selectProjectProperties(DbSession session, String projectKey) {
+ return session.getMapper(PropertiesMapper.class).selectProjectProperties(projectKey);
}
public List<PropertyDto> selectProjectProperties(String resourceKey) {
- SqlSession session = mybatis.openSession(false);
+ DbSession session = mybatis.openSession(false);
try {
- return selectProjectProperties(resourceKey, session);
+ return selectProjectProperties(session, resourceKey);
} finally {
MyBatis.closeQuietly(session);
}
assertThat(first.getValue(), is("one"));
}
- @Test
- public void selectProjectPropertiesByResourceId() {
- setupData("selectProjectPropertiesByResourceId");
-
- List<PropertyDto> properties = dao.selectProjectProperties(10L);
-
- assertThat(properties.size(), is(2));
- assertThat(properties).extracting("key").containsOnly("struts.one", "user.two");
- assertThat(properties).extracting("value").containsOnly("one", "two");
- }
-
@Test
public void select_module_properties_tree() {
setupData("select_module_properties_tree");
projects / sonarqube.git / commitdiff