public boolean setPastSeverity(DefaultIssue issue, @Nullable String previousSeverity, IssueChangeContext context) { String currentSeverity = issue.severity(); issue.setSeverity(previousSeverity); return setSeverity(issue, currentSeverity, context); }
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; }
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 void processIssues(Component component, Path<Counter> path) { componentIssuesRepository.getIssues(component) .stream() .filter(issue -> issue.resolution() == null) .forEach(issue -> { Rating rating = RATING_BY_SEVERITY.get(issue.severity()); if (issue.type().equals(BUG)) { path.current().ratingValueByMetric.get(RELIABILITY_RATING_KEY).increment(rating); } else if (issue.type().equals(VULNERABILITY)) { path.current().ratingValueByMetric.get(SECURITY_RATING_KEY).increment(rating); } }); }
void add(DefaultIssue issue) { if (issue.resolution() == null) { unresolved++; typeBag.add(issue.type()); severityBag.add(issue.severity()); } else if (RESOLUTION_FALSE_POSITIVE.equals(issue.resolution())) { falsePositives++; } else if (RESOLUTION_WONT_FIX.equals(issue.resolution())) { wontFix++; } switch (issue.status()) { case STATUS_OPEN: open++; break; case STATUS_REOPENED: reopened++; break; case STATUS_CONFIRMED: confirmed++; break; default: // Other statuses are ignored } } }
@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 issue_if_not_enough_comments__test_ceil() { prepareForIssue("25", FILE, 0.0, 0, 1); DefaultIssue issue = underTest.processFile(FILE, PLUGIN_KEY); assertThat(issue.ruleKey()).isEqualTo(RULE_KEY); assertThat(issue.severity()).isEqualTo(Severity.CRITICAL); // 1 ncloc requires 1 comment line to reach 25% of comment density assertThat(issue.gap()).isEqualTo(1.0); assertThat(issue.message()).isEqualTo("1 more comment lines need to be written to reach the minimum threshold of 25.0% comment density."); }
@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 issue_if_not_enough_comments() { prepareForIssue("25", FILE, 10.0, 40, 360); DefaultIssue issue = underTest.processFile(FILE, PLUGIN_KEY); assertThat(issue.ruleKey()).isEqualTo(RULE_KEY); assertThat(issue.severity()).isEqualTo(Severity.CRITICAL); // min_comments = (min_percent * ncloc) / (1 - min_percent) // -> threshold of 25% for 360 ncloc is 120 comment lines. 40 are already written. assertThat(issue.gap()).isEqualTo(120.0 - 40.0); assertThat(issue.message()).isEqualTo("80 more comment lines need to be written to reach the minimum threshold of 25.0% comment density."); }
@Test public void set_severity() { boolean updated = underTest.setSeverity(issue, "BLOCKER", context); assertThat(updated).isTrue(); assertThat(issue.severity()).isEqualTo("BLOCKER"); assertThat(issue.manualSeverity()).isFalse(); assertThat(issue.mustSendNotifications()).isFalse(); FieldDiffs.Diff diff = issue.currentChange().get(SEVERITY); assertThat(diff.oldValue()).isNull(); assertThat(diff.newValue()).isEqualTo("BLOCKER"); }
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); }
@Test public void process_existing_issue() { RuleKey ruleKey = RuleTesting.XOO_X1; // Issue from db has severity major addBaseIssue(ruleKey); // Issue from report has severity blocker ScannerReport.Issue reportIssue = ScannerReport.Issue.newBuilder() .setMsg("the message") .setRuleRepository(ruleKey.repository()) .setRuleKey(ruleKey.rule()) .setSeverity(Constants.Severity.BLOCKER) .build(); reportReader.putIssues(FILE_REF, asList(reportIssue)); fileSourceRepository.addLine(FILE_REF, "line1"); underTest.visitAny(FILE); ArgumentCaptor<DefaultIssue> rawIssueCaptor = ArgumentCaptor.forClass(DefaultIssue.class); ArgumentCaptor<DefaultIssue> baseIssueCaptor = ArgumentCaptor.forClass(DefaultIssue.class); verify(issueLifecycle).mergeExistingOpenIssue(rawIssueCaptor.capture(), baseIssueCaptor.capture()); assertThat(rawIssueCaptor.getValue().severity()).isEqualTo(Severity.BLOCKER); assertThat(baseIssueCaptor.getValue().severity()).isEqualTo(Severity.MAJOR); verify(issueLifecycle).doAutomaticTransition(defaultIssueCaptor.capture()); assertThat(defaultIssueCaptor.getValue().ruleKey()).isEqualTo(ruleKey); List<DefaultIssue> issues = newArrayList(issueCache.traverse()); assertThat(issues).hasSize(1); assertThat(issues.get(0).severity()).isEqualTo(Severity.BLOCKER); }
@Test public void set_severity() { IssueDto issueDto = newIssue().setSeverity(MAJOR); DefaultIssue issue = issueDto.toDefaultIssue(); setUserWithBrowseAndAdministerIssuePermission(issueDto); BulkChangeAction.ActionContext context = new BulkChangeAction.ActionContext(issue, IssueChangeContext.createUser(NOW, userSession.getUuid()), null); action.execute(ImmutableMap.of("severity", MINOR), context); assertThat(issue.severity()).isEqualTo(MINOR); assertThat(issue.isChanged()).isTrue(); assertThat(issue.manualSeverity()).isTrue(); assertThat(issue.updateDate()).isEqualTo(NOW); assertThat(issue.mustSendNotifications()).isTrue(); Map<String, FieldDiffs.Diff> change = issue.currentChange().diffs(); assertThat(change.get("severity").newValue()).isEqualTo(MINOR); assertThat(change.get("severity").oldValue()).isEqualTo(MAJOR); }
@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(); }
@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 load_external_issues_from_report_with_default_effort() { when(sourceLinesHash.getLineHashesMatchingDBVersion(FILE)).thenReturn(Collections.singletonList("line")); ScannerReport.ExternalIssue reportIssue = ScannerReport.ExternalIssue.newBuilder() .setTextRange(TextRange.newBuilder().setStartLine(2).build()) .setMsg("the message") .setEngineId("eslint") .setRuleId("S001") .setSeverity(Constants.Severity.BLOCKER) .setType(ScannerReport.IssueType.BUG) .build(); reportReader.putExternalIssues(FILE.getReportAttributes().getRef(), asList(reportIssue)); Input<DefaultIssue> input = underTest.create(FILE); Collection<DefaultIssue> issues = input.getIssues(); assertThat(issues).hasSize(1); DefaultIssue issue = Iterators.getOnlyElement(issues.iterator()); // fields set by analysis report assertThat(issue.ruleKey()).isEqualTo(RuleKey.of("external_eslint", "S001")); assertThat(issue.severity()).isEqualTo(Severity.BLOCKER); assertThat(issue.line()).isEqualTo(2); assertThat(issue.effort()).isEqualTo(Duration.create(0l)); assertThat(issue.message()).isEqualTo("the message"); // fields set by compute engine assertThat(issue.checksum()).isEqualTo(input.getLineHashSequence().getHashForLine(2)); assertThat(issue.tags()).isEmpty(); assertInitializedExternalIssue(issue); }
@Test public void load_external_issues_from_report() { when(sourceLinesHash.getLineHashesMatchingDBVersion(FILE)).thenReturn(Collections.singletonList("line")); ScannerReport.ExternalIssue reportIssue = ScannerReport.ExternalIssue.newBuilder() .setTextRange(TextRange.newBuilder().setStartLine(2).build()) .setMsg("the message") .setEngineId("eslint") .setRuleId("S001") .setSeverity(Constants.Severity.BLOCKER) .setEffort(20l) .setType(ScannerReport.IssueType.SECURITY_HOTSPOT) .build(); reportReader.putExternalIssues(FILE.getReportAttributes().getRef(), asList(reportIssue)); Input<DefaultIssue> input = underTest.create(FILE); Collection<DefaultIssue> issues = input.getIssues(); assertThat(issues).hasSize(1); DefaultIssue issue = Iterators.getOnlyElement(issues.iterator()); // fields set by analysis report assertThat(issue.ruleKey()).isEqualTo(RuleKey.of("external_eslint", "S001")); assertThat(issue.severity()).isEqualTo(Severity.BLOCKER); assertThat(issue.line()).isEqualTo(2); assertThat(issue.effort()).isEqualTo(Duration.create(20l)); assertThat(issue.message()).isEqualTo("the message"); assertThat(issue.type()).isEqualTo(RuleType.SECURITY_HOTSPOT); // fields set by compute engine assertThat(issue.checksum()).isEqualTo(input.getLineHashSequence().getHashForLine(2)); assertThat(issue.tags()).isEmpty(); assertInitializedExternalIssue(issue); }
@Test public void severity_changed_by_user_should_be_kept() { DefaultIssue issue = new DefaultIssue() .setKey("ABCDE") .setRuleKey(RuleKey.of("squid", "AvoidCycles")) .setComponentKey("struts:org.apache.struts.Action") .setNew(false) .setStatus(STATUS_OPEN); // Changed by scan issue.setSeverity(Severity.BLOCKER); issue.setManualSeverity(false); // Issue as seen and changed by end-user IssueDto dbIssue = new IssueDto() .setKee("ABCDE") .setStatus(STATUS_OPEN) .setSeverity(Severity.INFO) .setManualSeverity(true); new UpdateConflictResolver().mergeFields(dbIssue, issue); assertThat(issue.severity()).isEqualTo(Severity.INFO); assertThat(issue.manualSeverity()).isTrue(); } }
private TrackedIssue toTrackedIssue(DefaultIssue issue) { TrackedIssue trackedIssue = new TrackedIssue(); trackedIssue.setKey(issue.key()); trackedIssue.setRuleKey(issue.ruleKey()); trackedIssue.setComponentKey(issue.componentKey()); trackedIssue.setSeverity(issue.severity()); trackedIssue.setResolution(issue.resolution()); return trackedIssue; } }