import com.google.common.base.Objects;
import com.google.common.collect.*;
import org.apache.commons.lang.StringUtils;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
import org.sonar.api.BatchExtension;
import org.sonar.api.batch.SonarIndex;
import org.sonar.api.resources.Project;
public class IssueTracking implements BatchExtension {
- private static final Logger LOG = LoggerFactory.getLogger(IssueTracking.class);
-
private static final Comparator<LinePair> LINE_PAIR_COMPARATOR = new Comparator<LinePair>() {
public int compare(LinePair o1, LinePair o2) {
- int weightDiff = o2.weight - o1.weight;
- if (weightDiff != 0) {
- return weightDiff;
- } else {
- return Math.abs(o1.lineA -o1.lineB) - Math.abs(o2.lineA - o2.lineB);
- }
+ return o2.weight - o1.weight;
}
};
private final Project project;
}
public void track(Resource resource, Collection<IssueDto> referenceIssues, Collection<DefaultIssue> newIssues) {
- LOG.debug("Tracking : " + resource);
-
referenceIssuesMap.clear();
String source = index.getSource(resource);
unmappedLastIssues.addAll(lastIssues);
for (IssueDto lastIssue : lastIssues) {
- lastIssuesByRule.put(getRuleId(lastIssue), lastIssue);
+ lastIssuesByRule.put(getRule(lastIssue), lastIssue);
}
// Match the key of the issue. (For manual issues)
for (DefaultIssue newIssue : newIssues) {
mapIssue(newIssue,
- findLastIssueWithSameKey(newIssue, lastIssuesByRule.get(getRuleId(newIssue))),
+ findLastIssueWithSameKey(newIssue, lastIssuesByRule.get(getRule(newIssue))),
lastIssuesByRule, referenceIssuesMap);
}
for (DefaultIssue newIssue : newIssues) {
if (isNotAlreadyMapped(newIssue)) {
mapIssue(newIssue,
- findLastIssueWithSameLineAndChecksum(newIssue, lastIssuesByRule.get(getRuleId(newIssue))),
+ findLastIssueWithSameLineAndChecksum(newIssue, lastIssuesByRule.get(getRule(newIssue))),
lastIssuesByRule, referenceIssuesMap);
}
}
for (HashOccurrence hashOccurrence : map.values()) {
if (hashOccurrence.countA == 1 && hashOccurrence.countB == 1) {
// Guaranteed that lineA has been moved to lineB, so we can map all issues on lineA to all issues on lineB
- LOG.debug("*** Guaranteed that lineA has been moved to lineB, so we can map all issues on lineA to all issues on lineB");
map(newIssuesByLines.get(hashOccurrence.lineB), lastIssuesByLines.get(hashOccurrence.lineA), lastIssuesByRule);
lastIssuesByLines.removeAll(hashOccurrence.lineA);
newIssuesByLines.removeAll(hashOccurrence.lineB);
Collections.sort(possibleLinePairs, LINE_PAIR_COMPARATOR);
for (LinePair linePair : possibleLinePairs) {
// High probability that lineA has been moved to lineB, so we can map all Issues on lineA to all Issues on lineB
- LOG.debug("*** High probability that lineA has been moved to lineB, so we can map all Issues on lineA to all Issues on lineB");
map(newIssuesByLines.get(linePair.lineB), lastIssuesByLines.get(linePair.lineA), lastIssuesByRule);
}
}
// Try then to match issues on same rule with same message and with same checksum
for (DefaultIssue newIssue : newIssues) {
if (isNotAlreadyMapped(newIssue)) {
- LOG.debug("*** Try then to match issues on same rule with same message and with same checksum");
mapIssue(newIssue,
- findLastIssueWithSameChecksumAndMessage(newIssue, lastIssuesByRule.get(getRuleId(newIssue))),
+ findLastIssueWithSameChecksumAndMessage(newIssue, lastIssuesByRule.get(getRule(newIssue))),
lastIssuesByRule, referenceIssuesMap);
}
}
// Try then to match issues on same rule with same line and with same message
for (DefaultIssue newIssue : newIssues) {
if (isNotAlreadyMapped(newIssue)) {
- LOG.debug("*** Try then to match issues on same rule with same line and with same message");
mapIssue(newIssue,
- findLastIssueWithSameLineAndMessage(newIssue, lastIssuesByRule.get(getRuleId(newIssue))),
+ findLastIssueWithSameLineAndMessage(newIssue, lastIssuesByRule.get(getRule(newIssue))),
lastIssuesByRule, referenceIssuesMap);
}
}
// See SONAR-2812
for (DefaultIssue newIssue : newIssues) {
if (isNotAlreadyMapped(newIssue)) {
- LOG.debug("*** Last check: match issue if same rule and same checksum but different line and different message");
mapIssue(newIssue,
- findLastIssueWithSameChecksum(newIssue, lastIssuesByRule.get(getRuleId(newIssue))),
+ findLastIssueWithSameChecksum(newIssue, lastIssuesByRule.get(getRule(newIssue))),
lastIssuesByRule, referenceIssuesMap);
}
}
}
+ @VisibleForTesting
+ IssueDto getReferenceIssue(DefaultIssue issue) {
+ return referenceIssuesMap.get(issue);
+ }
+
+ private Integer getRule(DefaultIssue issue) {
+ return ruleFinder.findByKey(issue.ruleKey()).getId();
+ }
+
+ private Integer getRule(IssueDto issue) {
+ return ruleFinder.findById(issue.getRuleId()).getId();
+ }
+
private void map(Collection<DefaultIssue> newIssues, Collection<IssueDto> lastIssues, Multimap<Integer, IssueDto> lastIssuesByRule) {
for (DefaultIssue newIssue : newIssues) {
if (isNotAlreadyMapped(newIssue)) {
for (IssueDto pastIssue : lastIssues) {
- if (isNotAlreadyMapped(pastIssue) && Objects.equal(getRuleId(newIssue), getRuleId(pastIssue))) {
- LOG.debug("mapIssue newIssue : "+ newIssue + " with : "+ pastIssue);
+ if (isNotAlreadyMapped(pastIssue) && Objects.equal(getRule(newIssue), getRule(pastIssue))) {
mapIssue(newIssue, pastIssue, lastIssuesByRule, referenceIssuesMap);
break;
- } else {
- LOG.debug("Not mapIssue newIssue : "+ newIssue + " with : "+ pastIssue);
}
}
}
}
private boolean isNotAlreadyMapped(IssueDto pastIssue) {
- return unmappedLastIssues.contains(pastIssue);
+ return !unmappedLastIssues.contains(pastIssue);
}
private boolean isNotAlreadyMapped(DefaultIssue newIssue) {
}
private boolean isSameChecksum(DefaultIssue newIssue, IssueDto pastIssue) {
- return StringUtils.equals(pastIssue.getChecksum(), newIssue.getChecksum());
+ return Objects.equal(pastIssue.getChecksum(), newIssue.getChecksum());
}
private boolean isSameLine(DefaultIssue newIssue, IssueDto pastIssue) {
}
private boolean isSameMessage(DefaultIssue newIssue, IssueDto pastIssue) {
- return StringUtils.equals(IssueDto.abbreviateMessage(newIssue.message()), pastIssue.getMessage());
+ return Objects.equal(StringUtils.trim(newIssue.description()), StringUtils.trim(pastIssue.getDescription()));
}
private boolean isSameKey(DefaultIssue newIssue, IssueDto pastIssue) {
private void mapIssue(DefaultIssue newIssue, IssueDto pastIssue, Multimap<Integer, IssueDto> lastIssuesByRule, Map<DefaultIssue, IssueDto> issueMap) {
if (pastIssue != null) {
- LOG.debug("Mapping with old issue from newIssue : "+ newIssue + " and pastIssue : "+ pastIssue);
-
newIssue.setKey(pastIssue.getUuid());
if (pastIssue.isManualSeverity()) {
newIssue.setSeverity(pastIssue.getSeverity());
// TODO
// newIssue.setPersonId(pastIssue.getPersonId());
- lastIssuesByRule.remove(getRuleId(newIssue), pastIssue);
+ lastIssuesByRule.remove(getRule(newIssue), pastIssue);
issueMap.put(newIssue, pastIssue);
unmappedLastIssues.remove(pastIssue);
} else {
- LOG.debug("No old issue, creating new one with newIssue : "+ newIssue + " and pastIssue : "+ pastIssue);
-
newIssue.setNew(true);
newIssue.setCreatedAt(project.getAnalysisDate());
}
}
- @VisibleForTesting
- IssueDto getReferenceIssue(DefaultIssue issue) {
- return referenceIssuesMap.get(issue);
- }
-
- private Integer getRuleId(DefaultIssue issue) {
- return ruleFinder.findByKey(issue.ruleKey()).getId();
- }
-
- private Integer getRuleId(IssueDto issue) {
- return issue.getRuleId();
- }
-
@Override
public String toString() {
return getClass().getSimpleName();
import org.sonar.api.resources.Resource;
import org.sonar.api.resources.ResourceUtils;
import org.sonar.api.resources.Scopes;
-import org.sonar.api.rules.Rule;
import org.sonar.api.rules.RuleFinder;
-import org.sonar.api.utils.KeyValueFormat;
import org.sonar.batch.issue.InitialOpenIssuesStack;
import org.sonar.batch.issue.ModuleIssues;
import org.sonar.core.issue.DefaultIssue;
import org.sonar.core.issue.IssueDto;
import javax.annotation.Nullable;
-
import java.util.Collection;
import java.util.Date;
import java.util.Set;
Set<String> issueKeys = Sets.newHashSet(Collections2.transform(newIssues, new IssueToKeyfunction()));
for (IssueDto openIssue : openIssues) {
- addManualIssuesAndCloseResolvedOnes(openIssue, resource);
- closeResolvedStandardIssues(openIssue, issueKeys, resource);
- keepFalsePositiveIssues(openIssue, resource);
- reopenUnresolvedIssues(openIssue, resource);
+ addManualIssuesAndCloseResolvedOnes(openIssue);
+ closeResolvedStandardIssues(openIssue, issueKeys);
+ keepFalsePositiveIssues(openIssue);
+ reopenUnresolvedIssues(openIssue);
}
if (ResourceUtils.isRootProject(resource)) {
- closeIssuesOnDeletedResources(initialOpenIssuesStack.getAllIssues(), resource);
+ closeIssuesOnDeletedResources(initialOpenIssuesStack.getAllIssues());
}
}
}
}
}
- private void addManualIssuesAndCloseResolvedOnes(IssueDto openIssue, Resource resource) {
+ private void addManualIssuesAndCloseResolvedOnes(IssueDto openIssue) {
if (openIssue.isManualIssue()) {
- DefaultIssue issue = toIssue(openIssue, resource);
+ DefaultIssue issue = openIssue.toDefaultIssue();
if (Issue.STATUS_RESOLVED.equals(issue.status())) {
close(issue);
}
}
}
- private void closeResolvedStandardIssues(IssueDto openIssue, Set<String> issueKeys, Resource resource) {
+ private void closeResolvedStandardIssues(IssueDto openIssue, Set<String> issueKeys) {
if (!openIssue.isManualIssue() && !issueKeys.contains(openIssue.getUuid())) {
- closeAndSave(openIssue, resource);
+ closeAndSave(openIssue);
}
}
- private void keepFalsePositiveIssues(IssueDto openIssue, Resource resource) {
+ private void keepFalsePositiveIssues(IssueDto openIssue) {
if (!openIssue.isManualIssue() && Issue.RESOLUTION_FALSE_POSITIVE.equals(openIssue.getResolution())) {
- DefaultIssue issue = toIssue(openIssue, resource);
+ DefaultIssue issue = openIssue.toDefaultIssue();
issue.setResolution(openIssue.getResolution());
issue.setStatus(openIssue.getStatus());
issue.setUpdatedAt(new Date());
}
- private void reopenUnresolvedIssues(IssueDto openIssue, Resource resource) {
+ private void reopenUnresolvedIssues(IssueDto openIssue) {
if (Issue.STATUS_RESOLVED.equals(openIssue.getStatus()) && !Issue.RESOLUTION_FALSE_POSITIVE.equals(openIssue.getResolution())
- && !openIssue.isManualIssue()) {
- reopenAndSave(openIssue, resource);
+ && !openIssue.isManualIssue()) {
+ reopenAndSave(openIssue);
}
}
/**
* Close issues that relate to resources that have been deleted or renamed.
*/
- private void closeIssuesOnDeletedResources(Collection<IssueDto> openIssues, Resource resource) {
+ private void closeIssuesOnDeletedResources(Collection<IssueDto> openIssues) {
for (IssueDto openIssue : openIssues) {
- closeAndSave(openIssue, resource);
+ closeAndSave(openIssue);
}
}
issue.setUpdatedAt(new Date());
}
- private void closeAndSave(IssueDto openIssue, Resource resource) {
- DefaultIssue issue = toIssue(openIssue, resource);
+ private void closeAndSave(IssueDto openIssue) {
+ DefaultIssue issue = openIssue.toDefaultIssue();
close(issue);
moduleIssues.addOrUpdate(issue);
}
- private void reopenAndSave(IssueDto openIssue, Resource resource) {
- DefaultIssue issue = toIssue(openIssue, resource);
+ private void reopenAndSave(IssueDto openIssue) {
+ DefaultIssue issue = openIssue.toDefaultIssue();
issue.setStatus(Issue.STATUS_REOPENED);
issue.setResolution(null);
issue.setUpdatedAt(new Date());
moduleIssues.addOrUpdate(issue);
}
- private DefaultIssue toIssue(IssueDto dto, Resource resource) {
- DefaultIssue issue = new DefaultIssue();
- issue.setKey(dto.getUuid());
- issue.setStatus(dto.getStatus());
- issue.setResolution(dto.getResolution());
- issue.setMessage(dto.getMessage());
- issue.setTitle(dto.getTitle());
- issue.setCost(dto.getCost());
- issue.setLine(dto.getLine());
- issue.setSeverity(dto.getSeverity());
- issue.setUserLogin(dto.getUserLogin());
- issue.setAssigneeLogin(dto.getAssigneeLogin());
- issue.setCreatedAt(dto.getCreatedAt());
- issue.setUpdatedAt(dto.getUpdatedAt());
- issue.setClosedAt(dto.getClosedAt());
- issue.setAttributes(KeyValueFormat.parse(dto.getData()));
- issue.setComponentKey(resource.getKey());
- issue.setManual(dto.isManualIssue());
- issue.setManualSeverity(dto.isManualSeverity());
-
- // TODO add person
-
- Rule rule = ruleFinder.findById(dto.getRuleId());
- issue.setRuleKey(rule.ruleKey());
- return issue;
- }
private Collection<DefaultIssue> toDefaultIssues(Collection<Issue> issues) {
return newArrayList(Iterables.transform(issues, new Function<Issue, DefaultIssue>() {
package org.sonar.plugins.core.issue;
-import com.google.common.base.Charsets;
import com.google.common.collect.Lists;
-import com.google.common.io.Resources;
import org.junit.Before;
import org.junit.Test;
import org.sonar.api.resources.Project;
import org.sonar.api.rules.Rule;
import org.sonar.api.rules.RuleFinder;
import org.sonar.api.utils.DateUtils;
-import org.sonar.batch.scan.LastSnapshots;
import org.sonar.core.issue.DefaultIssue;
import org.sonar.core.issue.IssueDto;
-import java.io.IOException;
-import java.util.Arrays;
import java.util.Date;
import java.util.Map;
private final Date analysisDate = DateUtils.parseDate("2013-04-11");
private IssueTracking decorator;
-
- private Project project;
- private RuleFinder ruleFinder;
-
- private LastSnapshots lastSnapshots;
-
private long violationId = 0;
@Before
rule1.setId(1);
Rule rule2 = Rule.create("squid", "NullDeref");
rule2.setId(2);
- Rule rule3 = Rule.create("pmd", "UnusedLocalVariable");
- rule3.setId(3);
- ruleFinder = mock(RuleFinder.class);
+ RuleFinder ruleFinder = mock(RuleFinder.class);
when(ruleFinder.findById(1)).thenReturn(rule1);
when(ruleFinder.findById(2)).thenReturn(rule2);
- when(ruleFinder.findById(3)).thenReturn(rule3);
when(ruleFinder.findByKey(RuleKey.of("squid", "AvoidCycle"))).thenReturn(rule1);
when(ruleFinder.findByKey(RuleKey.of("squid", "NullDeref"))).thenReturn(rule2);
- when(ruleFinder.findByKey(RuleKey.of("pmd", "UnusedLocalVariable"))).thenReturn(rule3);
-
- lastSnapshots = mock(LastSnapshots.class);
- project = mock(Project.class);
+ Project project = mock(Project.class);
when(project.getAnalysisDate()).thenReturn(analysisDate);
- decorator = new IssueTracking(project, ruleFinder, lastSnapshots, null);
+ decorator = new IssueTracking(project, ruleFinder, null, null);
}
@Test
assertThat(newIssue.isNew()).isFalse();
}
- @Test
- public void past_issue_not_assiciated_with_line_should_not_cause_npe() throws Exception {
- when(lastSnapshots.getSource(project)).thenReturn(load("example2-v1"));
- String source = load("example2-v2");
-
- DefaultIssue newIssue = newDefaultIssue("Indentation", 9, RuleKey.of("squid", "AvoidCycle"), "foo");
- IssueDto referenceIssue = newReferenceIssue("2 branches need to be covered", null, 1, null);
-
-
- Map<DefaultIssue, IssueDto> mapping = decorator.mapIssues(
- newArrayList(newIssue),
- newArrayList(referenceIssue),
- source, project);
-
- assertThat(mapping.isEmpty()).isTrue();
- assertThat(newIssue.isNew()).isTrue();
- }
-
- @Test
- public void new_issue_not_assiciated_with_line_should_not_cause_npe() throws Exception {
- when(lastSnapshots.getSource(project)).thenReturn(load("example2-v1"));
- String source = load("example2-v2");
-
- DefaultIssue newIssue = newDefaultIssue("1 branch need to be covered", null, RuleKey.of("squid", "AvoidCycle"), "foo");
- IssueDto referenceIssue = newReferenceIssue("Indentationd", 7, 1, null);
-
- Map<DefaultIssue, IssueDto> mapping = decorator.mapIssues(
- newArrayList(newIssue),
- newArrayList(referenceIssue),
- source, project);
-
- assertThat(mapping.isEmpty()).isTrue();
- assertThat(newIssue.isNew()).isTrue();
- }
-
- /**
- * SONAR-2928
- */
- @Test
- public void issue_not_associated_with_line() throws Exception {
- when(lastSnapshots.getSource(project)).thenReturn(load("example2-v1"));
- String source = load("example2-v2");
-
- DefaultIssue newIssue = newDefaultIssue("1 branch need to be covered", null, RuleKey.of("squid", "AvoidCycle"), null);
- IssueDto referenceIssue = newReferenceIssue("2 branches need to be covered", null, 1, null);
-
- Map<DefaultIssue, IssueDto> mapping = decorator.mapIssues(
- newArrayList(newIssue),
- newArrayList(referenceIssue),
- source, project);
-
- assertThat(newIssue.isNew()).isFalse();
- assertThat(mapping.get(newIssue)).isEqualTo(referenceIssue);
- }
-
- /**
- * SONAR-3072
- */
- @Test
- public void should_track_issues_based_on_blocks_recognition_on_example1() throws Exception {
- when(lastSnapshots.getSource(project)).thenReturn(load("example1-v1"));
- String source = load("example1-v2");
-
- IssueDto referenceIssue1 = newReferenceIssue("Indentation", 7, 1, null);
- IssueDto referenceIssue2 = newReferenceIssue("Indentation", 11, 1, null);
-
- DefaultIssue newIssue1 = newDefaultIssue("Indentation", 9, RuleKey.of("squid", "AvoidCycle"), null);
- DefaultIssue newIssue2 = newDefaultIssue("Indentation", 13, RuleKey.of("squid", "AvoidCycle"), null);
- DefaultIssue newIssue3 = newDefaultIssue("Indentation", 17, RuleKey.of("squid", "AvoidCycle"), null);
- DefaultIssue newIssue4 = newDefaultIssue("Indentation", 21, RuleKey.of("squid", "AvoidCycle"), null);
-
- Map<DefaultIssue, IssueDto> mapping = decorator.mapIssues(
- Arrays.asList(newIssue1, newIssue2, newIssue3, newIssue4),
- Arrays.asList(referenceIssue1, referenceIssue2),
- source, project);
-
- assertThat(newIssue1.isNew()).isTrue();
- assertThat(newIssue2.isNew()).isTrue();
- assertThat(newIssue3.isNew()).isFalse();
- assertThat(mapping.get(newIssue3)).isEqualTo(referenceIssue1);
- assertThat(newIssue4.isNew()).isFalse();
- assertThat(mapping.get(newIssue4)).isEqualTo(referenceIssue2);
+ private DefaultIssue newDefaultIssue(String description, Integer line, RuleKey ruleKey, String checksum) {
+ return new DefaultIssue().setDescription(description).setLine(line).setRuleKey(ruleKey).setChecksum(checksum);
}
- /**
- * SONAR-3072
- */
- @Test
- public void should_track_issues_based_on_blocks_recognition_on_example2() throws Exception {
- when(lastSnapshots.getSource(project)).thenReturn(load("example2-v1"));
- String source = load("example2-v2");
-
- IssueDto referenceIssue1 = newReferenceIssue("SystemPrintln", 5, 1, null);
-
- DefaultIssue newIssue1 = newDefaultIssue("SystemPrintln", 6, RuleKey.of("squid", "AvoidCycle"), null);
- DefaultIssue newIssue2 = newDefaultIssue("SystemPrintln", 10, RuleKey.of("squid", "AvoidCycle"), null);
- DefaultIssue newIssue3 = newDefaultIssue("SystemPrintln", 14, RuleKey.of("squid", "AvoidCycle"), null);
-
- Map<DefaultIssue, IssueDto> mapping = decorator.mapIssues(
- Arrays.asList(newIssue1, newIssue2, newIssue3),
- Arrays.asList(referenceIssue1),
- source, project);
-
- assertThat(newIssue1.isNew()).isTrue();
- assertThat(newIssue2.isNew()).isFalse();
- assertThat(mapping.get(newIssue2)).isEqualTo(referenceIssue1);
- assertThat(newIssue3.isNew()).isTrue();
- }
-
- @Test
- public void should_track_issues_based_on_blocks_recognition_on_example3() throws Exception {
- when(lastSnapshots.getSource(project)).thenReturn(load("example3-v1"));
- String source = load("example3-v2");
-
- IssueDto referenceIssue1 = newReferenceIssue("Avoid unused local variables such as 'j'.", 6, 1, "63c11570fc0a76434156be5f8138fa03");
- IssueDto referenceIssue2 = newReferenceIssue("Avoid unused private methods such as 'myMethod()'.", 13, 2, "ef23288705d1ef1e512448ace287586e");
- IssueDto referenceIssue3 = newReferenceIssue("Method 'avoidUtilityClass' is not designed for extension - needs to be abstract, final or empty.", 9, 3, "ed5cdd046fda82727d6fedd1d8e3a310");
-
- // New issue
- DefaultIssue newIssue1 = newDefaultIssue("Avoid unused local variables such as 'msg'.", 18, RuleKey.of("squid", "AvoidCycle"), "a24254126be2bf1a9b9a8db43f633733");
- // Same as referenceIssue2
- DefaultIssue newIssue2 = newDefaultIssue("Avoid unused private methods such as 'myMethod()'.", 13, RuleKey.of("squid", "NullDeref"), "ef23288705d1ef1e512448ace287586e");
- // Same as referenceIssue3
- DefaultIssue newIssue3 = newDefaultIssue("Method 'avoidUtilityClass' is not designed for extension - needs to be abstract, final or empty.", 9, RuleKey.of("pmd", "UnusedLocalVariable"), "ed5cdd046fda82727d6fedd1d8e3a310");
- // New issue
- DefaultIssue newIssue4 = newDefaultIssue("Method 'newViolation' is not designed for extension - needs to be abstract, final or empty.", 17, RuleKey.of("pmd", "UnusedLocalVariable"), "7d58ac9040c27e4ca2f11a0269e251e2");
- // Same as referenceIssue1
- DefaultIssue newIssue5 = newDefaultIssue("Avoid unused local variables such as 'j'.", 6, RuleKey.of("squid", "AvoidCycle"), "4432a2675ec3e1620daefe38386b51ef");
-
- Map<DefaultIssue, IssueDto> mapping = decorator.mapIssues(
- Arrays.asList(newIssue1, newIssue2, newIssue3, newIssue4, newIssue5),
- Arrays.asList(referenceIssue1, referenceIssue2, referenceIssue3),
- source, project);
-
- assertThat(newIssue1.isNew()).isTrue();
- assertThat(newIssue2.isNew()).isFalse();
- assertThat(newIssue3.isNew()).isFalse();
- assertThat(newIssue4.isNew()).isTrue();
- assertThat(newIssue5.isNew()).isFalse();
- assertThat(mapping.get(newIssue2)).isEqualTo(referenceIssue2);
- assertThat(mapping.get(newIssue3)).isEqualTo(referenceIssue3);
- assertThat(mapping.get(newIssue5)).isEqualTo(referenceIssue1);
- }
-
- private static String load(String name) throws IOException {
- return Resources.toString(IssueTrackingTest.class.getResource("IssueTrackingTest/" + name + ".txt"), Charsets.UTF_8);
- }
-
- private DefaultIssue newDefaultIssue(String message, Integer line, RuleKey ruleKey, String checksum) {
- return new DefaultIssue().setMessage(message).setLine(line).setRuleKey(ruleKey).setChecksum(checksum);
- }
-
- private IssueDto newReferenceIssue(String message, Integer lineId, int ruleId, String lineChecksum) {
+ private IssueDto newReferenceIssue(String description, Integer lineId, int ruleId, String lineChecksum) {
IssueDto referenceIssue = new IssueDto();
Long id = violationId++;
referenceIssue.setId(id);
referenceIssue.setUuid(Long.toString(id));
referenceIssue.setLine(lineId);
- referenceIssue.setMessage(message);
+ referenceIssue.setDescription(description);
referenceIssue.setRuleId(ruleId);
referenceIssue.setChecksum(lineChecksum);
return referenceIssue;
}
- public void test(){
- IssueDto referenceIssue1 = newReferenceIssue("Avoid unused local variables such as 'j'.", 6, 1, "63c11570fc0a76434156be5f8138fa03");
- IssueDto referenceIssue2 = newReferenceIssue("Avoid unused private methods such as 'myMethod()'.", 13, 2, "ef23288705d1ef1e512448ace287586e");
- IssueDto referenceIssue3 = newReferenceIssue("Method 'avoidUtilityClass' is not designed for extension - needs to be abstract, final or empty.", 9, 3, "ed5cdd046fda82727d6fedd1d8e3a310");
-
- DefaultIssue newIssue1 = newDefaultIssue("Avoid unused local variables such as 'msg'.", 18, RuleKey.of("squid", "AvoidCycle"), "a24254126be2bf1a9b9a8db43f633733");
- DefaultIssue newIssue2 = newDefaultIssue("Avoid unused private methods such as 'myMethod()'.", 13, RuleKey.of("squid", "NullDeref"), "ef23288705d1ef1e512448ace287586e");
- DefaultIssue newIssue3 = newDefaultIssue("Method 'avoidUtilityClass' is not designed for extension - needs to be abstract, final or empty.", 9, RuleKey.of("pmd", "UnusedLocalVariable"), "ed5cdd046fda82727d6fedd1d8e3a310");
- DefaultIssue newIssue4 = newDefaultIssue("Method 'newViolation' is not designed for extension - needs to be abstract, final or empty.", 17, RuleKey.of("pmd", "UnusedLocalVariable"), "7d58ac9040c27e4ca2f11a0269e251e2");
- DefaultIssue newIssue5 = newDefaultIssue("Avoid unused local variables such as 'j'.", 6, RuleKey.of("squid", "AvoidCycle"), "4432a2675ec3e1620daefe38386b51ef");
-
- }
-
}
public void should_close_resolved_issue() {
when(moduleIssues.issues(anyString())).thenReturn(Collections.<Issue>emptyList());
when(initialOpenIssuesStack.selectAndRemove(anyInt())).thenReturn(newArrayList(
- new IssueDto().setUuid("100").setRuleId(10)));
+ new IssueDto().setUuid("100").setRuleId(10).setRuleKey_unit_test_only("squid", "AvoidCycle")));
decorator.decorate(mock(Resource.class), null);
public void should_close_resolved_manual_issue() {
when(moduleIssues.issues(anyString())).thenReturn(Collections.<Issue>emptyList());
when(initialOpenIssuesStack.selectAndRemove(anyInt())).thenReturn(newArrayList(
- new IssueDto().setUuid("100").setRuleId(1).setManualIssue(true).setStatus(Issue.STATUS_RESOLVED)));
+ new IssueDto().setUuid("100").setRuleId(1).setManualIssue(true).setStatus(Issue.STATUS_RESOLVED).setRuleKey_unit_test_only("squid", "AvoidCycle")));
decorator.decorate(mock(Resource.class), null);
when(moduleIssues.issues(anyString())).thenReturn(Lists.<Issue>newArrayList(
new DefaultIssue().setKey("100")));
when(initialOpenIssuesStack.selectAndRemove(anyInt())).thenReturn(newArrayList(
- new IssueDto().setUuid("100").setRuleId(1).setStatus(Issue.STATUS_RESOLVED).setResolution(Issue.RESOLUTION_FIXED)));
+ new IssueDto().setUuid("100").setRuleId(1).setStatus(Issue.STATUS_RESOLVED).setResolution(Issue.RESOLUTION_FIXED)
+ .setRuleKey_unit_test_only("squid", "AvoidCycle")));
decorator.decorate(mock(Resource.class), null);
when(moduleIssues.issues(anyString())).thenReturn(Lists.<Issue>newArrayList(
new DefaultIssue().setKey("100")));
when(initialOpenIssuesStack.selectAndRemove(anyInt())).thenReturn(newArrayList(
- new IssueDto().setUuid("100").setRuleId(1).setStatus(Issue.STATUS_RESOLVED).setResolution(Issue.RESOLUTION_FALSE_POSITIVE)));
+ new IssueDto().setUuid("100").setRuleId(1).setStatus(Issue.STATUS_RESOLVED).setResolution(Issue.RESOLUTION_FALSE_POSITIVE)
+ .setRuleKey_unit_test_only("squid", "AvoidCycle")));
decorator.decorate(mock(Resource.class), null);
when(moduleIssues.issues(anyString())).thenReturn(Collections.<Issue>emptyList());
when(initialOpenIssuesStack.selectAndRemove(anyInt())).thenReturn(Collections.<IssueDto>emptyList());
- when(initialOpenIssuesStack.getAllIssues()).thenReturn(newArrayList(new IssueDto().setUuid("100").setRuleId(1)));
+ when(initialOpenIssuesStack.getAllIssues()).thenReturn(newArrayList(new IssueDto().setUuid("100").setRuleId(1).setRuleKey_unit_test_only("squid", "AvoidCycle")));
Resource resource = mock(Resource.class);
when(resource.getQualifier()).thenReturn(Qualifiers.PROJECT);
.setRuleKey(RuleKey.of(violation.getRule().getRepositoryKey(), violation.getRule().getKey()))
.setCost(violation.getCost())
.setLine(violation.getLineId())
- .setMessage(violation.getMessage())
+ .setDescription(violation.getMessage())
.setStatus(Issue.STATUS_OPEN)
.setSeverity(violation.getSeverity() != null ? violation.getSeverity().name() : null);
import org.sonar.api.issue.Issue;
import org.sonar.api.rules.Rule;
import org.sonar.api.rules.RuleFinder;
-import org.sonar.api.utils.KeyValueFormat;
import org.sonar.batch.index.ScanPersister;
import org.sonar.batch.index.SnapshotCache;
import org.sonar.core.issue.DefaultIssue;
throw new IllegalStateException("Rule not found: " + issue.ruleKey());
}
- IssueDto dto = toIssueDto((DefaultIssue) issue, snapshot.getResourceId(), rule.getId());
+ IssueDto dto = IssueDto.toDto((DefaultIssue) issue, snapshot.getResourceId(), rule.getId());
if (issue.isNew()) {
dao.insert(dto);
} else {
}
}
- private IssueDto toIssueDto(DefaultIssue issue, Integer componentId, Integer ruleId) {
- return new IssueDto()
- .setUuid(issue.key())
- .setLine(issue.line())
- .setTitle(issue.title())
- .setMessage(issue.message())
- .setCost(issue.cost())
- .setResolution(issue.resolution())
- .setStatus(issue.status())
- .setSeverity(issue.severity())
- .setChecksum(issue.getChecksum())
- .setManualIssue(issue.isManual())
- .setManualSeverity(issue.isManualSeverity())
- .setUserLogin(issue.userLogin())
- .setAssigneeLogin(issue.assigneeLogin())
- .setCreatedAt(issue.createdAt())
- .setUpdatedAt(issue.updatedAt())
- .setClosedAt(issue.closedAt())
- .setRuleId(ruleId)
- .setResourceId(componentId)
- .setData(issue.attributes() != null ? KeyValueFormat.format(issue.attributes()) : null)
- // TODO
-// .setPersonId()
- ;
- }
+
}
rulesBag.add(rulefinder.findByKey(issue.ruleKey().repository(), issue.ruleKey().rule()));
issuesPerSeverities.put(RulePriority.valueOf(issue.severity()), issue);
- if (issue.assigneeLogin() == null) {
+ if (issue.assignee() == null) {
countUnassigned++;
}
if (Issue.RESOLUTION_FALSE_POSITIVE.equals(issue.resolution())) {
issue.setCost(change.cost());
}
if (change.manualSeverity() != null) {
- change.setManualSeverity(change.manualSeverity().booleanValue());
+ change.setManualSeverity(change.manualSeverity());
}
if (change.severity() != null) {
issue.setSeverity(change.severity());
}
if (change.isAssigneeChanged()) {
- issue.setAssigneeLogin(change.assignee());
+ issue.setAssignee(change.assignee());
}
if (change.resolution() != null) {
issue.setResolution(change.resolution());
List<Issue> issues = newArrayList();
issues.add(new DefaultIssue().setRuleKey(ruleA1.ruleKey()).setStatus(Issue.STATUS_OPEN).setSeverity(RulePriority.CRITICAL.name()));
issues.add(new DefaultIssue().setRuleKey(ruleA1.ruleKey()).setStatus(Issue.STATUS_REOPENED).setSeverity(RulePriority.CRITICAL.name()));
- issues.add(new DefaultIssue().setRuleKey(ruleA2.ruleKey()).setStatus(Issue.STATUS_OPEN).setAssigneeLogin("arthur").setSeverity(RulePriority.CRITICAL.name()));
+ issues.add(new DefaultIssue().setRuleKey(ruleA2.ruleKey()).setStatus(Issue.STATUS_OPEN).setAssignee("arthur").setSeverity(RulePriority.CRITICAL.name()));
when(issuable.issues()).thenReturn(issues);
decorator.decorate(resource, context);
import static org.fest.assertions.Assertions.assertThat;
import static org.fest.assertions.Fail.fail;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyZeroInteractions;
-import static org.mockito.Mockito.when;
+import static org.mockito.Mockito.*;
public class ScanIssueChangesTest {
assertThat(changed.resolution()).isEqualTo(Issue.RESOLUTION_FALSE_POSITIVE);
assertThat(changed.attribute("JIRA")).isEqualTo("FOO-123");
assertThat(changed.severity()).isEqualTo(Severity.CRITICAL);
- assertThat(changed.assigneeLogin()).isEqualTo("arthur");
+ assertThat(changed.assignee()).isEqualTo("arthur");
assertThat(changed.cost()).isEqualTo(4.2);
assertThat(changed.updatedAt()).isNotNull();
}
private String severity;
private boolean manualSeverity = false;
private String title;
- private String message;
+ private String description;
private Integer line;
private Double cost;
private String status;
private String resolution;
private String userLogin;
- private String assigneeLogin;
+ private String assignee;
private Date createdAt;
private Date updatedAt;
private Date closedAt;
return this;
}
- public String message() {
- return message;
+ public String description() {
+ return description;
}
- public DefaultIssue setMessage(@Nullable String message) {
- this.message = message;
+ public DefaultIssue setDescription(@Nullable String s) {
+ if (s != null) {
+ Preconditions.checkArgument(s.length() < Issue.DESCRIPTION_MAX_SIZE,
+ "Description must not be longer than " + Issue.DESCRIPTION_MAX_SIZE + " characters (got " + s.length() + ")");
+ }
+ this.description = s;
return this;
}
return this;
}
- public String assigneeLogin() {
- return assigneeLogin;
+ public String assignee() {
+ return assignee;
}
- public DefaultIssue setAssigneeLogin(@Nullable String assigneeLogin) {
- this.assigneeLogin = assigneeLogin;
+ public DefaultIssue setAssignee(@Nullable String s) {
+ this.assignee = s;
return this;
}
}
public Map<String, String> attributes() {
- return attributes == null ? Collections.<String,String>emptyMap() : ImmutableMap.copyOf(attributes);
+ return attributes == null ? Collections.<String, String>emptyMap() : ImmutableMap.copyOf(attributes);
}
public DefaultIssue setAttributes(Map<String, String> attributes) {
private final String componentKey;
private RuleKey ruleKey;
private Integer line;
- private String message;
+ private String description;
private String title;
private String severity;
private Double cost;
}
@Override
- public Issuable.IssueBuilder message(String message) {
- this.message = message;
+ public Issuable.IssueBuilder description(String s) {
+ this.description = s;
return this;
}
DefaultIssue issue = new DefaultIssue();
issue.setComponentKey(componentKey);
issue.setRuleKey(ruleKey);
- issue.setMessage(message);
+ issue.setDescription(description);
issue.setTitle(title);
issue.setSeverity(severity);
import org.sonar.api.issue.Issue;
import org.sonar.api.issue.IssueFinder;
import org.sonar.api.issue.IssueQuery;
-import org.sonar.api.rule.RuleKey;
-import org.sonar.api.utils.KeyValueFormat;
import org.sonar.core.persistence.MyBatis;
import org.sonar.core.user.AuthorizationDao;
private static final Logger LOG = LoggerFactory.getLogger(DefaultIssueFinder.class);
- /**
- * The role required to access issues
- */
- private static final String ROLE = "user";
-
private final MyBatis myBatis;
private final IssueDao issueDao;
private final AuthorizationDao authorizationDao;
this.authorizationDao = authorizationDao;
}
- public Results find(IssueQuery query, @Nullable Integer currentUserId) {
+ public Results find(IssueQuery query, @Nullable Integer currentUserId, String role) {
LOG.debug("IssueQuery : {}", query);
SqlSession sqlSession = myBatis.openSession();
try {
for (IssueDto issueDto : dtos) {
componentIds.add(issueDto.getResourceId());
}
- Set<Integer> authorizedComponentIds = authorizationDao.keepAuthorizedComponentIds(componentIds, currentUserId, ROLE, sqlSession);
+ Set<Integer> authorizedComponentIds = authorizationDao.keepAuthorizedComponentIds(componentIds, currentUserId, role, sqlSession);
List<Issue> issues = Lists.newArrayList();
for (IssueDto dto : dtos) {
if (authorizedComponentIds.contains(dto.getResourceId())) {
- issues.add(toIssue(dto));
+ issues.add(dto.toDefaultIssue());
}
}
return new DefaultResults(issues);
public Issue findByKey(String key) {
IssueDto dto = issueDao.selectByKey(key);
- return dto != null ? toIssue(dto) : null;
- }
-
- private Issue toIssue(IssueDto dto) {
- DefaultIssue issue = new DefaultIssue();
- issue.setKey(dto.getUuid());
- issue.setStatus(dto.getStatus());
- issue.setResolution(dto.getResolution());
- issue.setMessage(dto.getMessage());
- issue.setTitle(dto.getTitle());
- issue.setCost(dto.getCost());
- issue.setLine(dto.getLine());
- issue.setSeverity(dto.getSeverity());
- issue.setUserLogin(dto.getUserLogin());
- issue.setAssigneeLogin(dto.getAssigneeLogin());
- issue.setCreatedAt(dto.getCreatedAt());
- issue.setUpdatedAt(dto.getUpdatedAt());
- issue.setClosedAt(dto.getClosedAt());
- issue.setAttributes(KeyValueFormat.parse(dto.getData()));
- issue.setManual(dto.isManualIssue());
- issue.setManualSeverity(dto.isManualSeverity());
- issue.setComponentKey(dto.getComponentKey());
- issue.setRuleKey(RuleKey.of(dto.getRuleRepo(), dto.getRule()));
- return issue;
+ return dto != null ? dto.toDefaultIssue() : null;
}
static class DefaultResults implements Results {
*/
package org.sonar.core.issue;
+import com.google.common.base.Objects;
import com.google.common.base.Preconditions;
-import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.builder.ToStringBuilder;
import org.apache.commons.lang.builder.ToStringStyle;
+import org.sonar.api.rule.RuleKey;
+import org.sonar.api.utils.KeyValueFormat;
import javax.annotation.Nullable;
import java.util.Date;
*/
public final class IssueDto {
- public static final int MESSAGE_MAX_SIZE = 4000;
-
private Long id;
private String uuid;
private Integer resourceId;
private boolean manualSeverity;
private boolean manualIssue;
private String title;
- private String message;
+ private String description;
private Integer line;
private Double cost;
private String status;
private String resolution;
private String checksum;
private String userLogin;
- private String assigneeLogin;
+ private String assignee;
private Long personId;
private String data;
private Date createdAt;
return this;
}
- public String getMessage() {
- return message;
+ public String getDescription() {
+ return description;
}
- public IssueDto setMessage(String message) {
- this.message = abbreviateMessage(message);
+ public IssueDto setDescription(String s) {
+ this.description = s;
return this;
}
return this;
}
- public String getAssigneeLogin() {
- return assigneeLogin;
+ public String getAssignee() {
+ return assignee;
}
- public IssueDto setAssigneeLogin(@Nullable String assigneeLogin) {
- this.assigneeLogin = assigneeLogin;
+ public IssueDto setAssignee(@Nullable String s) {
+ this.assignee = s;
return this;
}
return this;
}
- public static String abbreviateMessage(String message) {
- return message != null ? StringUtils.abbreviate(StringUtils.trim(message), MESSAGE_MAX_SIZE) : null;
- }
-
public String getRule() {
return rule;
}
/**
* Only for unit tests
*/
- public IssueDto setRule_unit_test_only(String rule) {
+ public IssueDto setRuleKey_unit_test_only(String repo, String rule) {
+ this.ruleRepo = repo;
this.rule = rule;
return this;
}
- /**
- * Only for unit tests
- */
- public IssueDto setRuleRepo_unit_test_only(String ruleRepo) {
- this.ruleRepo = ruleRepo;
- return this;
- }
-
/**
* Only for unit tests
*/
public int hashCode() {
return id != null ? id.hashCode() : 0;
}
+
+
+ public static IssueDto toDto(DefaultIssue issue, Integer componentId, Integer ruleId) {
+ return new IssueDto()
+ .setUuid(issue.key())
+ .setLine(issue.line())
+ .setTitle(issue.title())
+ .setDescription(issue.description())
+ .setCost(issue.cost())
+ .setResolution(issue.resolution())
+ .setStatus(issue.status())
+ .setSeverity(issue.severity())
+ .setChecksum(issue.getChecksum())
+ .setManualIssue(issue.isManual())
+ .setManualSeverity(issue.isManualSeverity())
+ .setUserLogin(issue.userLogin())
+ .setAssignee(issue.assignee())
+ .setCreatedAt(issue.createdAt())
+ .setUpdatedAt(issue.updatedAt())
+ .setClosedAt(issue.closedAt())
+ .setRuleId(ruleId)
+ .setResourceId(componentId)
+ .setData(issue.attributes() != null ? KeyValueFormat.format(issue.attributes()) : "")
+ // TODO
+// .setPersonId()
+ ;
+ }
+
+ public DefaultIssue toDefaultIssue() {
+ DefaultIssue issue = new DefaultIssue();
+ issue.setKey(uuid);
+ issue.setStatus(status);
+ issue.setResolution(resolution);
+ issue.setDescription(description);
+ issue.setTitle(title);
+ issue.setCost(cost);
+ issue.setLine(line);
+ issue.setSeverity(severity);
+ issue.setUserLogin(userLogin);
+ issue.setAssignee(assignee);
+ issue.setCreatedAt(createdAt);
+ issue.setUpdatedAt(updatedAt);
+ issue.setClosedAt(closedAt);
+ issue.setAttributes(KeyValueFormat.parse(Objects.firstNonNull(data, "")));
+ issue.setComponentKey(componentKey);
+ issue.setManual(manualIssue);
+ issue.setManualSeverity(manualSeverity);
+ issue.setRuleKey(RuleKey.of(ruleRepo, rule));
+ // TODO personId
+ return issue;
+ }
}
import org.sonar.core.persistence.MyBatis;
import javax.annotation.Nullable;
-
import java.util.Collections;
import java.util.Map;
import java.util.Set;
return Sets.newHashSet(session.<Integer>selectList(sql, params));
}
+
+ public boolean isAuthorizedComponentId(int componentId, @Nullable Integer userId, String role) {
+ return keepAuthorizedComponentIds(Sets.newHashSet(componentId), userId, role).size() == 1;
+ }
}
i.manual_severity as manualSeverity,
i.manual_issue as manualIssue,
i.title as title,
- i.message as message,
+ i.message as description,
i.line as line,
i.cost as cost,
i.status as status,
i.resolution as resolution,
i.checksum as checksum,
i.user_login as userLogin,
- i.assignee_login as assigneeLogin,
+ i.assignee_login as assignee,
i.person_id as personId,
i.data as data,
i.created_at as createdAt,
<insert id="insert" parameterType="Issue" useGeneratedKeys="true" keyProperty="id">
INSERT INTO issues (uuid, resource_id, rule_id, severity, manual_severity, manual_issue, title, message, line, cost, status,
resolution, checksum, user_login, assignee_login, person_id, data, created_at, updated_at, closed_at)
- VALUES (#{uuid}, #{resourceId}, #{ruleId}, #{severity}, #{manualSeverity}, #{manualIssue}, #{title}, #{message}, #{line}, #{cost}, #{status},
- #{resolution}, #{checksum}, #{userLogin}, #{assigneeLogin}, #{personId}, #{data}, #{createdAt}, #{updatedAt}, #{closedAt})
+ VALUES (#{uuid}, #{resourceId}, #{ruleId}, #{severity}, #{manualSeverity}, #{manualIssue}, #{title}, #{description}, #{line}, #{cost}, #{status},
+ #{resolution}, #{checksum}, #{userLogin}, #{assignee}, #{personId}, #{data}, #{createdAt}, #{updatedAt}, #{closedAt})
</insert>
<!-- Oracle -->
</selectKey>
INSERT INTO issues (id, uuid, resource_id, rule_id, severity, manual_severity, manual_issue, title, message, line, cost, status,
resolution, checksum, user_login, assignee_login, person_id, data, created_at, updated_at, closed_at)
- VALUES (#{id}, #{uuid}, #{resourceId}, #{ruleId}, #{severity}, #{manualSeverity}, #{manualIssue}, #{title}, #{message}, #{line}, #{cost}, #{status},
- #{resolution}, #{checksum}, #{userLogin}, #{assigneeLogin}, #{personId}, #{data}, #{createdAt}, #{updatedAt}, #{closedAt})
+ VALUES (#{id}, #{uuid}, #{resourceId}, #{ruleId}, #{severity}, #{manualSeverity}, #{manualIssue}, #{title}, #{description}, #{line}, #{cost}, #{status},
+ #{resolution}, #{checksum}, #{userLogin}, #{assignee}, #{personId}, #{data}, #{createdAt}, #{updatedAt}, #{closedAt})
</insert>
<update id="update" parameterType="Issue">
update issues set
- resource_id=#{resourceId},
- rule_id=#{ruleId},
- severity=#{severity},
- manual_severity=#{manualSeverity},
- manual_issue=#{manualIssue},
- title=#{title},
- message=#{message},
- line=#{line},
- cost=#{cost},
- status=#{status},
- resolution=#{resolution},
- checksum=#{checksum},
- user_login=#{userLogin},
- assignee_login=#{assigneeLogin},
- person_id=#{personId},
- data=#{data},
- created_at=#{createdAt},
- updated_at=#{updatedAt},
- closed_at=#{closedAt}
+ resource_id=#{resourceId},
+ rule_id=#{ruleId},
+ severity=#{severity},
+ manual_severity=#{manualSeverity},
+ manual_issue=#{manualIssue},
+ title=#{title},
+ message=#{description},
+ line=#{line},
+ cost=#{cost},
+ status=#{status},
+ resolution=#{resolution},
+ checksum=#{checksum},
+ user_login=#{userLogin},
+ assignee_login=#{assignee},
+ person_id=#{personId},
+ data=#{data},
+ created_at=#{createdAt},
+ updated_at=#{updatedAt},
+ closed_at=#{closedAt}
where uuid = #{uuid}
</update>
select
<include refid="issueColumns"/>
from issues i, rules r, projects p
- where i.id=#{id} and i.rule_id=r.id and p.id=i.resource_id
+ where
+ i.id=#{id} and
+ i.rule_id=r.id and
+ p.id=i.resource_id
</select>
<select id="selectByKey" parameterType="String" resultType="Issue">
<foreach item="userLogin" index="index" collection="userLogins" open="(" separator="," close=")">#{userLogin}
</foreach>
</if>
- <if test="assigneeLogins != null">
+ <if test="assignees != null">
and i.assignee_login in
- <foreach item="assigneeLogin" index="index" collection="assigneeLogins" open="(" separator="," close=")">#{assigneeLogin}
+ <foreach item="assignee" index="index" collection="assignees" open="(" separator="," close=")">#{assignee}
</foreach>
</if>
<if test="rules != null and rules.size() > 0">
public void should_create_issue() throws Exception {
String componentKey = "org.apache.struts:struts-core:Action.java";
DefaultIssue issue = (DefaultIssue) new DefaultIssueBuilder(callback, componentKey)
- .message("msg")
+ .description("the desc")
.line(123)
.cost(10000.0)
.ruleKey(RuleKey.of("squid", "NullDereference"))
assertThat(issue.key()).isNull();
assertThat(issue.cost()).isEqualTo(10000.0);
assertThat(issue.componentKey()).isEqualTo(componentKey);
- assertThat(issue.message()).isEqualTo("msg");
+ assertThat(issue.description()).isEqualTo("the desc");
assertThat(issue.line()).isEqualTo(123);
assertThat(issue.ruleKey().repository()).isEqualTo("squid");
assertThat(issue.ruleKey().rule()).isEqualTo("NullDereference");
assertThat(issue.severity()).isEqualTo(Severity.CRITICAL);
assertThat(issue.updatedAt()).isNull();
assertThat(issue.closedAt()).isNull();
- assertThat(issue.assigneeLogin()).isNull();
+ assertThat(issue.assignee()).isNull();
assertThat(issue.isNew()).isTrue();
verify(callback).onIssueCreation(issue);
}
import org.sonar.api.issue.Issue;
import org.sonar.api.issue.IssueFinder;
import org.sonar.api.issue.IssueQuery;
+import org.sonar.api.web.UserRole;
import org.sonar.core.persistence.MyBatis;
import org.sonar.core.user.AuthorizationDao;
IssueDto issue1 = new IssueDto().setId(1L).setRuleId(50).setResourceId(123)
.setComponentKey_unit_test_only("Action.java")
- .setRuleRepo_unit_test_only("squid")
- .setRule_unit_test_only("AvoidCycle");
+ .setRuleKey_unit_test_only("squid", "AvoidCycle");
IssueDto issue2 = new IssueDto().setId(2L).setRuleId(50).setResourceId(123)
.setComponentKey_unit_test_only("Action.java")
- .setRuleRepo_unit_test_only("squid")
- .setRule_unit_test_only("AvoidCycle");
+ .setRuleKey_unit_test_only("squid", "AvoidCycle");
List<IssueDto> dtoList = newArrayList(issue1, issue2);
when(issueDao.select(eq(issueQuery), any(SqlSession.class))).thenReturn(dtoList);
- IssueFinder.Results results = finder.find(issueQuery, null);
+ IssueFinder.Results results = finder.find(issueQuery, null, UserRole.USER);
assertThat(results.issues()).hasSize(2);
Issue issue = results.issues().iterator().next();
assertThat(issue.componentKey()).isEqualTo("Action.java");
public void should_find_by_key() {
IssueDto issueDto = new IssueDto().setId(1L).setRuleId(1).setResourceId(1)
.setComponentKey_unit_test_only("Action.java")
- .setRuleRepo_unit_test_only("squid")
- .setRule_unit_test_only("AvoidCycle");
+ .setRuleKey_unit_test_only("squid", "AvoidCycle");
when(issueDao.selectByKey("ABCDE")).thenReturn(issueDto);
Issue issue = finder.findByKey("ABCDE");
*/
package org.sonar.core.issue;
+import org.apache.commons.lang.StringUtils;
import org.junit.Test;
import static org.fest.assertions.Assertions.assertThat;
assertThat(e).hasMessage("Not a valid severity: FOO");
}
}
+
+ @Test
+ public void size_of_description_should_be_limited() {
+ try {
+ issue.setDescription(StringUtils.repeat("a", 5000));
+ fail();
+ } catch (IllegalArgumentException e) {
+ assertThat(e).hasMessage("Description must not be longer than 4000 characters (got 5000)");
+ }
+ }
}
issueDto.setSeverity("BLOCKER");
issueDto.setLine(200);
issueDto.setStatus("OPEN");
- issueDto.setAssigneeLogin("user");
- issueDto.setMessage("message");
+ issueDto.setAssignee("user");
+ issueDto.setDescription("the description");
issueDto.setCost(10.0);
issueDto.setChecksum("checksum");
issueDto.setPersonId(100L);
issue.setResolution("NEW_RESOLUTION");
issue.setStatus("NEW_STATUS");
issue.setSeverity("NEW_SEV");
- issue.setAssigneeLogin("new_user");
+ issue.setAssignee("new_user");
issue.setManualSeverity(true);
issue.setManualIssue(false);
issue.setTitle("NEW_TITLE");
assertThat(issue.isManualSeverity()).isFalse();
assertThat(issue.isManualIssue()).isFalse();
assertThat(issue.getTitle()).isNull();
- assertThat(issue.getMessage()).isNull();
+ assertThat(issue.getDescription()).isNull();
assertThat(issue.getLine()).isEqualTo(200);
assertThat(issue.getCost()).isEqualTo(4.2);
assertThat(issue.getStatus()).isEqualTo("OPEN");
assertThat(issue.getChecksum()).isEqualTo("XXX");
assertThat(issue.getPersonId()).isNull();
assertThat(issue.getUserLogin()).isEqualTo("arthur");
- assertThat(issue.getAssigneeLogin()).isEqualTo("perceval");
+ assertThat(issue.getAssignee()).isEqualTo("perceval");
assertThat(issue.getData()).isEqualTo("JIRA=FOO-1234");
assertThat(issue.getCreatedAt()).isNotNull();
assertThat(issue.getUpdatedAt()).isNotNull();
IssueQuery query = IssueQuery.builder()
.keys(newArrayList("ABCDE"))
.userLogins(newArrayList("arthur", "otherguy"))
- .assigneeLogins(newArrayList("perceval", "otherguy"))
+ .assignees(newArrayList("perceval", "otherguy"))
.components(newArrayList("Action.java"))
.resolutions(newArrayList("FIXED"))
.severities(newArrayList("BLOCKER"))
manual_severity="[false]"
manual_issue="[false]"
title="[null]"
- message="message"
+ message="the description"
line="200"
cost="10.0"
status="OPEN"
IssueBuilder line(Integer line);
- IssueBuilder message(String message);
+ IssueBuilder description(String description);
IssueBuilder title(String title);
*/
public interface Issue {
+ int DESCRIPTION_MAX_SIZE = 4000;
String STATUS_OPEN = "OPEN";
String STATUS_REOPENED = "REOPENED";
String STATUS_RESOLVED = "RESOLVED";
String title();
- String message();
+ String description();
Integer line();
String userLogin();
- String assigneeLogin();
+ String assignee();
Date createdAt();
private String comment = null;
private String commentLogin = null;
private Boolean manualSeverity = null;
- private String message = null;
+ private String description = null;
private boolean lineChanged = false;
private Integer line = null;
private boolean costChanged = false;
private Double cost = null;
private String resolution = null;
- private boolean assigneeLoginChanged = false;
+ private boolean assigneeChanged = false;
private String assignee = null;
private Map<String, String> attributes = null;
}
public boolean hasChanges() {
- return severity != null || comment != null || manualSeverity != null || message != null ||
- lineChanged || costChanged || resolution != null || assigneeLoginChanged || attributes != null;
+ return severity != null || comment != null || manualSeverity != null || description != null ||
+ lineChanged || costChanged || resolution != null || assigneeChanged || attributes != null;
}
public IssueChange setSeverity(String s) {
return this;
}
- public IssueChange setMessage(String message) {
- this.message = message;
+ public IssueChange setDescription(String s) {
+ this.description = s;
return this;
}
}
public IssueChange setAssignee(@Nullable String assigneeLogin) {
- this.assigneeLoginChanged = true;
+ this.assigneeChanged = true;
this.assignee = assigneeLogin;
return this;
}
return manualSeverity;
}
- public String message() {
- return message;
+ public String description() {
+ return description;
}
public Integer line() {
}
public boolean isAssigneeChanged() {
- return assigneeLoginChanged;
+ return assigneeChanged;
}
public Map<String, String> attributes() {
* Change existing issues
* @since 3.6
*/
-public interface IssueChanges extends BatchComponent, ServerComponent {
+public interface IssueChanges extends BatchComponent {
Issue apply(Issue issue, IssueChange change);
List<Issue> issues();
}
- Results find(IssueQuery query, @Nullable Integer currentUserId);
+ Results find(IssueQuery query, @Nullable Integer currentUserId, String role);
Issue findByKey(String key /* TODO @Nullable Integer currentUserId */);
/*
import org.apache.commons.lang.builder.ReflectionToStringBuilder;
import org.sonar.api.rule.RuleKey;
-import javax.annotation.Nullable;
-
import java.util.Collection;
import java.util.Date;
private final Collection<String> componentRoots;
private final Collection<RuleKey> rules;
private final Collection<String> userLogins;
- private final Collection<String> assigneeLogins;
+ private final Collection<String> assignees;
private final Date createdAfter;
private final Date createdBefore;
private final int limit, offset;
this.componentRoots = builder.componentRoots;
this.rules = builder.rules;
this.userLogins = builder.userLogins;
- this.assigneeLogins = builder.assigneeLogins;
+ this.assignees = builder.assignees;
this.createdAfter = builder.createdAfter;
this.createdBefore = builder.createdBefore;
this.limit = builder.limit;
return userLogins;
}
- public Collection<String> assigneeLogins() {
- return assigneeLogins;
+ public Collection<String> assignees() {
+ return assignees;
}
public Date createdAfter() {
private Collection<String> componentRoots;
private Collection<RuleKey> rules;
private Collection<String> userLogins;
- private Collection<String> assigneeLogins;
+ private Collection<String> assignees;
private Date createdAfter;
private Date createdBefore;
private int limit = DEFAULT_LIMIT;
return this;
}
- public Builder assigneeLogins(Collection<String> l) {
- this.assigneeLogins = l;
+ public Builder assignees(Collection<String> l) {
+ this.assignees = l;
return this;
}
return this;
}
- public Builder limit(@Nullable Integer i) {
+ public Builder limit(Integer i) {
Preconditions.checkArgument(i == null || i.intValue() > 0, "Limit must be greater than 0 (got " + i + ")");
Preconditions.checkArgument(i == null || i.intValue() < MAX_LIMIT, "Limit must be less than " + MAX_LIMIT + " (got " + i + ")");
this.limit = (i == null ? DEFAULT_LIMIT : i.intValue());
return this;
}
- public Builder offset(@Nullable Integer i) {
+ public Builder offset(Integer i) {
Preconditions.checkArgument(i == null || i.intValue() >= 0, "Offset must be greater than or equal to 0 (got " + i + ")");
this.offset = (i == null ? DEFAULT_OFFSET : i.intValue());
return this;
assertThat(change.isLineChanged()).isFalse();
assertThat(change.line()).isNull();
assertThat(change.comment()).isNull();
- assertThat(change.message()).isNull();
+ assertThat(change.description()).isNull();
assertThat(change.resolution()).isNull();
assertThat(change.manualSeverity()).isNull();
assertThat(change.attributes()).isEmpty();
@Test
public void should_change_message() {
IssueChange change = IssueChange.create();
- change.setMessage("foo");
- assertThat(change.message()).isEqualTo("foo");
+ change.setDescription("foo");
+ assertThat(change.description()).isEqualTo("foo");
assertThat(change.hasChanges()).isTrue();
}
.componentRoots(Lists.newArrayList("org.struts:core"))
.rules(Lists.newArrayList(RuleKey.of("squid", "AvoidCycle")))
.userLogins(Lists.newArrayList("crunky"))
- .assigneeLogins(Lists.newArrayList("gargantua"))
+ .assignees(Lists.newArrayList("gargantua"))
.createdAfter(new Date())
.createdBefore(new Date())
.limit(125)
assertThat(query.components()).containsOnly("org/struts/Action.java");
assertThat(query.componentRoots()).containsOnly("org.struts:core");
assertThat(query.userLogins()).containsOnly("crunky");
- assertThat(query.assigneeLogins()).containsOnly("gargantua");
+ assertThat(query.assignees()).containsOnly("gargantua");
assertThat(query.rules()).containsOnly(RuleKey.of("squid", "AvoidCycle"));
assertThat(query.createdAfter()).isNotNull();
assertThat(query.createdBefore()).isNotNull();
import org.sonar.api.issue.JRubyIssues;
import org.sonar.api.rule.RuleKey;
import org.sonar.api.utils.DateUtils;
+import org.sonar.api.web.UserRole;
import org.sonar.server.ui.JRubyFacades;
import javax.annotation.Nullable;
JRubyFacades.setIssues(this);
}
+ /**
+ * Requires the role {@link org.sonar.api.web.UserRole#CODEVIEWER}
+ */
public IssueFinder.Results find(Map<String, Object> params, Integer currentUserId) {
- return finder.find(newQuery(params), currentUserId);
+ return finder.find(newQuery(params), currentUserId, UserRole.CODEVIEWER);
}
IssueQuery newQuery(Map<String, Object> props) {
builder.componentRoots(toStrings(props.get("componentRoots")));
builder.rules(toRules(props.get("rules")));
builder.userLogins(toStrings(props.get("userLogins")));
- builder.assigneeLogins(toStrings(props.get("assigneeLogins")));
+ builder.assignees(toStrings(props.get("assignees")));
builder.createdAfter(toDate(props.get("createdAfter")));
builder.createdBefore(toDate(props.get("createdBefore")));
builder.limit(toInteger(props.get("limit")));
--- /dev/null
+/*
+ * Sonar, open source software quality management tool.
+ * Copyright (C) 2008-2012 SonarSource
+ * mailto:contact AT sonarsource DOT com
+ *
+ * Sonar is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * Sonar is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with Sonar; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02
+ */
+package org.sonar.server.issue;
+
+import org.sonar.api.issue.Issue;
+import org.sonar.api.issue.IssueChange;
+import org.sonar.api.web.UserRole;
+import org.sonar.core.issue.DefaultIssue;
+import org.sonar.core.issue.IssueDao;
+import org.sonar.core.issue.IssueDto;
+import org.sonar.core.user.AuthorizationDao;
+
+import javax.annotation.Nullable;
+import java.util.Arrays;
+
+/**
+ * @since 3.6
+ */
+public class ServerIssueChanges {
+
+ private final IssueDao issueDao;
+ private final AuthorizationDao authorizationDao;
+
+ public ServerIssueChanges(IssueDao issueDao, AuthorizationDao authorizationDao) {
+ this.issueDao = issueDao;
+ this.authorizationDao = authorizationDao;
+ }
+
+ public Issue change(String issueKey, IssueChange change, @Nullable Integer userId) {
+ if (userId == null) {
+ // must be logged
+ throw new IllegalStateException("User is not logged in");
+ }
+ IssueDto dto = issueDao.selectByKey(issueKey);
+ if (dto == null) {
+ throw new IllegalStateException("Unknown issue: " + issueKey);
+ }
+ String requiredRole = UserRole.USER;
+ if (!authorizationDao.isAuthorizedComponentId(dto.getResourceId(), userId, requiredRole)) {
+ throw new IllegalStateException("User does not have the role " + requiredRole + " required to change the issue: " + issueKey);
+ }
+ DefaultIssue issue = dto.toDefaultIssue();
+ if (change.hasChanges()) {
+ // TODO apply changes
+ issueDao.update(Arrays.asList(IssueDto.toDto(issue, dto.getResourceId(), dto.getRuleId())));
+ }
+
+
+ return issue;
+ }
+}
import org.sonar.server.configuration.ProfilesManager;
import org.sonar.server.database.EmbeddedDatabaseFactory;
import org.sonar.server.issue.DefaultJRubyIssues;
+import org.sonar.server.issue.ServerIssueChanges;
import org.sonar.server.macro.MacroInterpreter;
import org.sonar.server.notifications.NotificationCenter;
import org.sonar.server.notifications.NotificationService;
servicesContainer.addSingleton(Periods.class);
servicesContainer.addSingleton(DefaultIssueFinder.class);
servicesContainer.addSingleton(DefaultJRubyIssues.class);
+ servicesContainer.addSingleton(ServerIssueChanges.class);
// Notifications
servicesContainer.addSingleton(EmailSettings.class);
:key => issue.key,
:component => issue.componentKey,
:rule => issue.ruleKey.toString(),
- :status => issue.status,
- :resolution => issue.resolution
+ :resolution => issue.resolution,
+ :status => issue.status
}
json[:severity] = issue.severity if issue.severity
json[:title] = issue.title if issue.title
- json[:desc] = issue.message if issue.message
+ json[:desc] = issue.description if issue.description
json[:line] = issue.line if issue.line
json[:cost] = issue.cost if issue.cost
json[:userLogin] = issue.userLogin if issue.userLogin
- json[:assignee] = issue.assigneeLogin if issue.assigneeLogin
+ json[:assignee] = issue.assignee if issue.assignee
json[:createdAt] = format_java_datetime(issue.createdAt) if issue.createdAt
json[:updatedAt] = format_java_datetime(issue.updatedAt) if issue.updatedAt
json[:closedAt] = format_java_datetime(issue.closedAt) if issue.closedAt
def find_issues(map)
user = current_user ? current_user.id : nil
- issues = []
- Api.issues.find(map, user).issues.each {|issue| issues << issue}
- issues
+ Api.issues.find(map, user).issues
end
end
\ No newline at end of file
</th>
</tr>
</thead>
- <tfoot>
- <tr>
- <td colspan="6">
- <%= paginate(@issues) -%>
- </td>
- </tr>
- </tfoot>
<tbody>
<%
@issues.each do |issue|
<%= h(issue.title) %>
</td>
<td>
- <%= h(issue.message) %>
+ <%= h(issue.description) %>
</td>
<td>
<%= h issue.componentKey -%>
<%= issue.cost -%>
</td>
<td>
- <%= issue.user_login -%>
+ <%= issue.userLogin -%>
</td>
<td>
- <%= issue.assignee_login -%>
+ <%= issue.assignee -%>
</td>
<td>
<%= issue.attributes -%>
import org.sonar.api.issue.IssueQuery;
import org.sonar.api.rule.RuleKey;
import org.sonar.api.utils.DateUtils;
+import org.sonar.api.web.UserRole;
import java.util.Map;
public boolean matches(Object o) {
return ((IssueQuery) o).keys().contains("ABCDE");
}
- }), eq(123));
+ }), eq(123), eq(UserRole.CODEVIEWER));
}
@Test
map.put("components", newArrayList("org.apache"));
map.put("componentRoots", newArrayList("org.sonar"));
map.put("userLogins", newArrayList("marilyn"));
- map.put("assigneeLogins", newArrayList("joanna"));
+ map.put("assignees", newArrayList("joanna"));
map.put("createdAfter", "2013-04-16T09:08:24+0200");
map.put("createdBefore", "2013-04-17T09:08:24+0200");
map.put("rules", "squid:AvoidCycle,findbugs:NullReference");
assertThat(query.components()).containsOnly("org.apache");
assertThat(query.componentRoots()).containsOnly("org.sonar");
assertThat(query.userLogins()).containsOnly("marilyn");
- assertThat(query.assigneeLogins()).containsOnly("joanna");
+ assertThat(query.assignees()).containsOnly("joanna");
assertThat(query.rules()).hasSize(2);
assertThat(query.createdAfter()).isEqualTo(DateUtils.parseDateTime("2013-04-16T09:08:24+0200"));
assertThat(query.createdBefore()).isEqualTo(DateUtils.parseDateTime("2013-04-17T09:08:24+0200"));
return this;
}
- public String getAssigneeLogin() {
+ public String getAssignee() {
return assigneeLogin;
}
appendUrlParameter(url, "componentRoots", componentRoots);
appendUrlParameter(url, "rules", rules);
appendUrlParameter(url, "userLogins", userLogins);
- appendUrlParameter(url, "assigneeLogins", assigneeLogins);
+ appendUrlParameter(url, "assignees", assigneeLogins);
appendUrlParameter(url, "createdAfter", createdAfter);
appendUrlParameter(url, "createdBefore", createdBefore);
appendUrlParameter(url, "limit", limit);
.setStatus(utils.getString(json, "status"))
.setResolution(utils.getString(json, "resolution"))
.setUserLogin(utils.getString(json, "userLogin"))
- .setAssigneeLogin(utils.getString(json, "assigneeLogin"))
+ .setAssigneeLogin(utils.getString(json, "assignee"))
.setCreatedAt(utils.getDateTime(json, "createdAt"))
.setUpdatedAt(utils.getDateTime(json, "updatedAt"))
.setClosedAt(utils.getDateTime(json, "closedAt"));
;
assertThat(query.getUrl()).isEqualTo("/api/issues/search?keys=ABCDE,FGHIJ&severities=BLOCKER,INFO&statuses=OPEN,CLOSED&" +
"resolutions=resolution1,resolution2&components=component1,component2&componentRoots=componentRoot1,componentRoot2&rules=squid%3AAvoidCycle&" +
- "userLogins=userLogin1,userLogin2&assigneeLogins=arthur,perceval&limit=1&");
+ "userLogins=userLogin1,userLogin2&assignees=arthur,perceval&limit=1&");
}
@Test
assertThat(issue.getStatus()).isEqualTo("OPEN");
assertThat(issue.getResolution()).isEqualTo("FIXED");
assertThat(issue.getUserLogin()).isEqualTo("admin");
- assertThat(issue.getAssigneeLogin()).isEqualTo("admin");
+ assertThat(issue.getAssignee()).isEqualTo("admin");
assertThat(issue.getCreatedAt()).isNotNull();
assertThat(issue.getUpdatedAt()).isNotNull();
assertThat(issue.getClosedAt()).isNull();
"status": "OPEN",
"resolution": "FIXED",
"userLogin": "admin",
- "assigneeLogin": "admin",
+ "assignee": "admin",
"createdAt": "2013-04-10T18:21:15+0200",
"updatedAt": "2013-04-10T18:21:15+0200",
"closedAt": null
"status": "OPEN",
"resolution": null,
"userLogin": null,
- "assigneeLogin": null,
+ "assignee": null,
"createdAt": "2013-04-10T18:21:15+0200",
"updatedAt": "2013-04-10T18:21:15+0200",
"closedAt": null
"status": "OPEN",
"resolution": "FIXED",
"userLogin": "admin",
- "assigneeLogin": "admin",
+ "assignee": "admin",
"createdAt": "2013-04-10T18:21:15+0200",
"updatedAt": "2013-04-10T18:21:15+0200",
"closedAt": null
projects / sonarqube.git / commitdiff