public boolean setPastSeverity(DefaultIssue issue, @Nullable String previousSeverity, IssueChangeContext context) { String currentSeverity = issue.severity(); issue.setSeverity(previousSeverity); return setSeverity(issue, currentSeverity, context); }
private void resolveSeverity(IssueDto dbIssue, DefaultIssue issue) { if (dbIssue.isManualSeverity()) { issue.setManualSeverity(true); issue.setSeverity(dbIssue.getSeverity()); } // else keep severity as declared in quality profile }
@Test public void fail_on_bad_severity() { try { issue.setSeverity("FOO"); fail(); } catch (IllegalArgumentException e) { assertThat(e).hasMessage("Not a valid severity: FOO"); } }
public boolean setSeverity(DefaultIssue issue, String severity, IssueChangeContext context) { checkState(!issue.manualSeverity(), "Severity can't be changed"); if (!Objects.equals(severity, issue.severity())) { issue.setFieldChange(context, SEVERITY, issue.severity(), severity); issue.setSeverity(severity); issue.setUpdateDate(context.date()); issue.setChanged(true); return true; } return false; }
@Test public void not_revert_manual_severity() { issue.setSeverity("MINOR").setManualSeverity(true); try { underTest.setSeverity(issue, "MAJOR", context); } catch (IllegalStateException e) { assertThat(e).hasMessage("Severity can't be changed"); } }
@Test public void not_change_severity() { issue.setSeverity("MINOR"); boolean updated = underTest.setSeverity(issue, "MINOR", context); assertThat(updated).isFalse(); assertThat(issue.mustSendNotifications()).isFalse(); assertThat(issue.currentChange()).isNull(); }
@Test public void set_manual_severity() { issue.setSeverity("BLOCKER"); boolean updated = underTest.setManualSeverity(issue, "MINOR", context); assertThat(updated).isTrue(); assertThat(issue.severity()).isEqualTo("MINOR"); assertThat(issue.manualSeverity()).isTrue(); assertThat(issue.mustSendNotifications()).isTrue(); FieldDiffs.Diff diff = issue.currentChange().get(SEVERITY); assertThat(diff.oldValue()).isEqualTo("BLOCKER"); assertThat(diff.newValue()).isEqualTo("MINOR"); }
@Test public void set_past_severity() { issue.setSeverity("BLOCKER"); boolean updated = underTest.setPastSeverity(issue, "INFO", context); assertThat(updated).isTrue(); assertThat(issue.severity()).isEqualTo("BLOCKER"); assertThat(issue.mustSendNotifications()).isFalse(); FieldDiffs.Diff diff = issue.currentChange().get(SEVERITY); assertThat(diff.oldValue()).isEqualTo("INFO"); assertThat(diff.newValue()).isEqualTo("BLOCKER"); }
@Test public void update_severity() { issue.setSeverity("BLOCKER"); boolean updated = underTest.setSeverity(issue, "MINOR", context); assertThat(updated).isTrue(); assertThat(issue.severity()).isEqualTo("MINOR"); assertThat(issue.mustSendNotifications()).isFalse(); FieldDiffs.Diff diff = issue.currentChange().get(SEVERITY); assertThat(diff.oldValue()).isEqualTo("BLOCKER"); assertThat(diff.newValue()).isEqualTo("MINOR"); }
@Test public void not_change_manual_severity() { issue.setSeverity("MINOR").setManualSeverity(true); boolean updated = underTest.setManualSeverity(issue, "MINOR", context); assertThat(updated).isFalse(); assertThat(issue.currentChange()).isNull(); assertThat(issue.mustSendNotifications()).isFalse(); }
@CheckForNull public DefaultIssue processFile(Component file, String fileLanguage) { DefaultIssue issue = null; RuleKey ruleKey = RuleKey.of(commonRepositoryForLang(fileLanguage), key); Optional<ActiveRule> activeRule = activeRulesHolder.get(ruleKey); if (activeRule.isPresent()) { CommonRuleIssue cri = doProcessFile(file, activeRule.get()); if (cri != null) { issue = new DefaultIssue(); issue.setGap(cri.effortToFix); issue.setMessage(cri.message); issue.setRuleKey(ruleKey); issue.setSeverity(activeRule.get().getSeverity()); issue.setLine(null); issue.setChecksum(""); issue.setIsFromExternalRuleEngine(false); } } return issue; }
private void copyAttributesOfIssueFromOtherBranch(DefaultIssue to, DefaultIssue from) { to.setCopied(true); copyFields(to, from); if (from.manualSeverity()) { to.setManualSeverity(true); to.setSeverity(from.severity()); } copyChangesOfIssueFromOtherBranch(to, from); }
public boolean setManualSeverity(DefaultIssue issue, String severity, IssueChangeContext context) { if (!issue.manualSeverity() || !Objects.equals(severity, issue.severity())) { issue.setFieldChange(context, SEVERITY, issue.severity(), severity); issue.setSeverity(severity); issue.setManualSeverity(true); issue.setUpdateDate(context.date()); issue.setChanged(true); issue.setSendNotifications(true); return true; } return false; }
private static DefaultIssue createIssue(@Nullable String resolution, String status, String severity, RuleType ruleType, long creationDate) { return new DefaultIssue() .setResolution(resolution).setStatus(status) .setSeverity(severity).setRuleKey(RuleTesting.XOO_X1) .setType(ruleType) .setCreationDate(new Date(creationDate)); }
private static DefaultIssue newIssue(String severity, RuleType type) { return new DefaultIssue() .setKey(Uuids.create()) .setSeverity(severity) .setType(type) .setCreationDate(new Date(1000l)); }
@Test public void test_nullable_fields() { issue.setGap(null).setSeverity(null).setLine(null); assertThat(issue.gap()).isNull(); assertThat(issue.severity()).isNull(); assertThat(issue.line()).isNull(); }
private static DefaultIssue newIssue(String severity, RuleType type) { return new DefaultIssue() .setKey(Uuids.create()) .setSeverity(severity) .setType(type) .setCreationDate(DEFAULT_ISSUE_CREATION_DATE); }
@Test public void mergeExistingOpenIssue_with_manual_severity() { DefaultIssue raw = new DefaultIssue() .setNew(true) .setKey("RAW_KEY") .setRuleKey(XOO_X1); DefaultIssue base = new DefaultIssue() .setKey("BASE_KEY") .setResolution(RESOLUTION_FIXED) .setStatus(STATUS_CLOSED) .setSeverity(BLOCKER) .setManualSeverity(true); underTest.mergeExistingOpenIssue(raw, base); assertThat(raw.manualSeverity()).isTrue(); assertThat(raw.severity()).isEqualTo(BLOCKER); verify(updater, never()).setPastSeverity(raw, BLOCKER, issueChangeContext); }
@Test public void should_get_all_issues() { DefaultIssue issueOnModule = new DefaultIssue().setKey("1").setRuleKey(SQUID_RULE_KEY).setComponentKey("org.apache:struts-core"); DefaultIssue issueInModule = new DefaultIssue().setKey("2").setRuleKey(SQUID_RULE_KEY).setComponentKey("org.apache:struts-core:Action"); DefaultIssue resolvedIssueInModule = new DefaultIssue().setKey("3").setRuleKey(SQUID_RULE_KEY).setComponentKey("org.apache:struts-core:Action") .setResolution(Issue.RESOLUTION_FIXED); DefaultIssue issueOnRoot = new DefaultIssue().setKey("4").setRuleKey(SQUID_RULE_KEY).setSeverity(Severity.CRITICAL).setComponentKey("org.apache:struts"); DefaultIssue issueInRoot = new DefaultIssue().setKey("5").setRuleKey(SQUID_RULE_KEY).setSeverity(Severity.CRITICAL).setComponentKey("org.apache:struts:FileInRoot"); when(cache.all()).thenReturn(Arrays.<TrackedIssue>asList( toTrackedIssue(issueOnRoot), toTrackedIssue(issueInRoot), toTrackedIssue(issueOnModule), toTrackedIssue(issueInModule), toTrackedIssue(resolvedIssueInModule) )); // unresolved issues List<Issue> issues = Lists.newArrayList(projectIssues.issues()); assertThat(issues).containsOnly(issueOnRoot, issueInRoot, issueInModule, issueOnModule); List<Issue> resolvedIssues = Lists.newArrayList(projectIssues.resolvedIssues()); assertThat(resolvedIssues).containsOnly(resolvedIssueInModule); }
@Test public void mergeExistingOpenIssue_with_attributes() { DefaultIssue raw = new DefaultIssue() .setNew(true) .setKey("RAW_KEY") .setRuleKey(XOO_X1); DefaultIssue base = new DefaultIssue() .setKey("BASE_KEY") .setResolution(RESOLUTION_FIXED) .setStatus(STATUS_CLOSED) .setSeverity(BLOCKER) .setAttributes(ImmutableMap.of("JIRA", "SONAR-01")); underTest.mergeExistingOpenIssue(raw, base); assertThat(raw.attributes()).containsEntry("JIRA", "SONAR-01"); } }