void add(IssueGroupDto group) { if (group.getRuleType() != SECURITY_HOTSPOT.getDbConstant()) { absolute += group.getCount(); if (group.isInLeak()) { leak += group.getCount(); } } } }
void add(IssueGroupDto group) { int severity = SeverityUtil.getOrdinalFromSeverity(group.getSeverity()); absolute = Math.max(severity, absolute); if (group.isInLeak()) { leak = Math.max(severity, leak); } }
IssueCounter(Collection<IssueGroupDto> groups) { for (IssueGroupDto group : groups) { RuleType ruleType = RuleType.valueOf(group.getRuleType()); if (group.getResolution() == null) { highestSeverityOfUnresolved .computeIfAbsent(ruleType, k -> new HighestSeverity()) .add(group); effortOfUnresolved .computeIfAbsent(ruleType, k -> new Effort()) .add(group); unresolvedBySeverity .computeIfAbsent(group.getSeverity(), k -> new Count()) .add(group); unresolvedByType .computeIfAbsent(ruleType, k -> new Count()) .add(group); unresolved.add(group); } else { byResolution .computeIfAbsent(group.getResolution(), k -> new Count()) .add(group); } if (group.getStatus() != null) { byStatus .computeIfAbsent(group.getStatus(), k -> new Count()) .add(group); } } }
@Test public void test_new_vulnerabilities() { withNoIssues().assertThatLeakValueIs(CoreMetrics.NEW_VULNERABILITIES, 0.0); with( newGroup(RuleType.VULNERABILITY).setInLeak(false).setSeverity(Severity.MAJOR).setCount(3), newGroup(RuleType.VULNERABILITY).setInLeak(true).setSeverity(Severity.CRITICAL).setCount(5), newGroup(RuleType.VULNERABILITY).setInLeak(true).setSeverity(Severity.MINOR).setCount(7), // not vulnerabilities newGroup(RuleType.BUG).setInLeak(true).setCount(9), newGroup(RuleType.CODE_SMELL).setInLeak(true).setCount(11)) .assertThatLeakValueIs(CoreMetrics.NEW_VULNERABILITIES, 5 + 7); }
private static IssueGroupDto newGroup(RuleType ruleType) { IssueGroupDto dto = new IssueGroupDto(); // set non-null fields dto.setRuleType(ruleType.getDbConstant()); dto.setCount(1); dto.setEffort(0.0); dto.setSeverity(Severity.INFO); dto.setStatus(Issue.STATUS_OPEN); dto.setInLeak(false); return dto; }
@Test public void test_bugs() { withNoIssues().assertThatValueIs(CoreMetrics.BUGS, 0); with( newGroup(RuleType.BUG).setSeverity(Severity.MAJOR).setCount(3), newGroup(RuleType.BUG).setSeverity(Severity.CRITICAL).setCount(5), // exclude resolved newResolvedGroup(RuleType.BUG).setCount(7), // not bugs newGroup(RuleType.CODE_SMELL).setCount(11)) .assertThatValueIs(CoreMetrics.BUGS, 3 + 5); }
@Test public void test_new_technical_debt() { withNoIssues().assertThatLeakValueIs(CoreMetrics.NEW_TECHNICAL_DEBT, 0.0); with( newGroup(RuleType.CODE_SMELL).setEffort(3.0).setInLeak(true), // not in leak newGroup(RuleType.CODE_SMELL).setEffort(5.0).setInLeak(false), // not code smells newGroup(RuleType.SECURITY_HOTSPOT).setEffort(9.0).setInLeak(true), newGroup(RuleType.BUG).setEffort(7.0).setInLeak(true), // exclude resolved newResolvedGroup(RuleType.CODE_SMELL).setEffort(17.0).setInLeak(true)) .assertThatLeakValueIs(CoreMetrics.NEW_TECHNICAL_DEBT, 3.0); }
@Test public void count_by_status() { withNoIssues() .assertThatValueIs(CoreMetrics.CONFIRMED_ISSUES, 0) .assertThatValueIs(CoreMetrics.OPEN_ISSUES, 0) .assertThatValueIs(CoreMetrics.REOPENED_ISSUES, 0); with( newGroup().setStatus(Issue.STATUS_CONFIRMED).setSeverity(Severity.BLOCKER).setCount(3), newGroup().setStatus(Issue.STATUS_CONFIRMED).setSeverity(Severity.INFO).setCount(5), newGroup().setStatus(Issue.STATUS_REOPENED).setCount(7), newGroup(RuleType.CODE_SMELL).setStatus(Issue.STATUS_OPEN).setCount(9), newGroup(RuleType.BUG).setStatus(Issue.STATUS_OPEN).setCount(11), // exclude security hotspot newGroup(RuleType.SECURITY_HOTSPOT).setStatus(Issue.STATUS_OPEN).setCount(12), newResolvedGroup(Issue.RESOLUTION_FALSE_POSITIVE, Issue.STATUS_CLOSED).setCount(13)) .assertThatValueIs(CoreMetrics.CONFIRMED_ISSUES, 3 + 5) .assertThatValueIs(CoreMetrics.OPEN_ISSUES, 9 + 11) .assertThatValueIs(CoreMetrics.REOPENED_ISSUES, 7); }
@Test public void count_resolved() { withNoIssues() .assertThatValueIs(CoreMetrics.FALSE_POSITIVE_ISSUES, 0) .assertThatValueIs(CoreMetrics.WONT_FIX_ISSUES, 0); with( newResolvedGroup(Issue.RESOLUTION_FIXED, Issue.STATUS_RESOLVED).setCount(3), newResolvedGroup(Issue.RESOLUTION_FALSE_POSITIVE, Issue.STATUS_CLOSED).setCount(5), newResolvedGroup(Issue.RESOLUTION_WONT_FIX, Issue.STATUS_CLOSED).setSeverity(Severity.MAJOR).setCount(7), newResolvedGroup(Issue.RESOLUTION_WONT_FIX, Issue.STATUS_CLOSED).setSeverity(Severity.BLOCKER).setCount(11), newResolvedGroup(Issue.RESOLUTION_REMOVED, Issue.STATUS_CLOSED).setCount(13), // exclude security hotspot newResolvedGroup(Issue.RESOLUTION_WONT_FIX, Issue.STATUS_RESOLVED).setCount(15).setRuleType(RuleType.SECURITY_HOTSPOT.getDbConstant()), // exclude unresolved newGroup(RuleType.VULNERABILITY).setCount(17), newGroup(RuleType.BUG).setCount(19)) .assertThatValueIs(CoreMetrics.FALSE_POSITIVE_ISSUES, 5) .assertThatValueIs(CoreMetrics.WONT_FIX_ISSUES, 7 + 11); }
@Test public void test_security_remediation_effort() { withNoIssues().assertThatValueIs(CoreMetrics.SECURITY_REMEDIATION_EFFORT, 0); with( newGroup(RuleType.VULNERABILITY).setEffort(3.0), newGroup(RuleType.VULNERABILITY).setEffort(5.0).setSeverity(Severity.BLOCKER), // not vulnerability newGroup(RuleType.CODE_SMELL).setEffort(7.0), // exclude resolved newResolvedGroup(RuleType.VULNERABILITY).setEffort(17.0)) .assertThatValueIs(CoreMetrics.SECURITY_REMEDIATION_EFFORT, 3.0 + 5.0); }
@Test public void test_new_violations() { withNoIssues().assertThatLeakValueIs(CoreMetrics.NEW_VIOLATIONS, 0.0); with( newGroup(RuleType.BUG).setInLeak(true).setCount(5), newGroup(RuleType.CODE_SMELL).setInLeak(true).setCount(7), newGroup(RuleType.VULNERABILITY).setInLeak(true).setCount(9), // not in leak newGroup(RuleType.BUG).setInLeak(false).setCount(11), newGroup(RuleType.CODE_SMELL).setInLeak(false).setCount(13), newGroup(RuleType.VULNERABILITY).setInLeak(false).setCount(17)) .assertThatLeakValueIs(CoreMetrics.NEW_VIOLATIONS, 5 + 7 + 9); }
IssueCounter(Collection<IssueGroupDto> groups) { for (IssueGroupDto group : groups) { RuleType ruleType = RuleType.valueOf(group.getRuleType()); if (group.getResolution() == null) { highestSeverityOfUnresolved .computeIfAbsent(ruleType, k -> new HighestSeverity()) .add(group); effortOfUnresolved .computeIfAbsent(ruleType, k -> new Effort()) .add(group); unresolvedBySeverity .computeIfAbsent(group.getSeverity(), k -> new Count()) .add(group); unresolvedByType .computeIfAbsent(ruleType, k -> new Count()) .add(group); unresolved.add(group); } else { byResolution .computeIfAbsent(group.getResolution(), k -> new Count()) .add(group); } if (group.getStatus() != null) { byStatus .computeIfAbsent(group.getStatus(), k -> new Count()) .add(group); } } }
@Test public void test_new_bugs() { withNoIssues().assertThatLeakValueIs(CoreMetrics.NEW_BUGS, 0.0); with( newGroup(RuleType.BUG).setInLeak(false).setSeverity(Severity.MAJOR).setCount(3), newGroup(RuleType.BUG).setInLeak(true).setSeverity(Severity.CRITICAL).setCount(5), newGroup(RuleType.BUG).setInLeak(true).setSeverity(Severity.MINOR).setCount(7), // not bugs newGroup(RuleType.CODE_SMELL).setInLeak(true).setCount(9), newGroup(RuleType.VULNERABILITY).setInLeak(true).setCount(11)) .assertThatLeakValueIs(CoreMetrics.NEW_BUGS, 5 + 7); }
@Test public void test_reliability_rating() { withNoIssues() .assertThatValueIs(CoreMetrics.RELIABILITY_RATING, Rating.A); with( newGroup(RuleType.BUG).setSeverity(Severity.CRITICAL).setCount(1), newGroup(RuleType.BUG).setSeverity(Severity.MINOR).setCount(5), // excluded, not a bug newGroup(RuleType.CODE_SMELL).setSeverity(Severity.BLOCKER).setCount(3)) // highest severity of bugs is CRITICAL --> D .assertThatValueIs(CoreMetrics.RELIABILITY_RATING, Rating.D); with( newGroup(RuleType.CODE_SMELL).setSeverity(Severity.MAJOR).setCount(3), newGroup(RuleType.VULNERABILITY).setSeverity(Severity.CRITICAL).setCount(5)) // no bugs --> A .assertThatValueIs(CoreMetrics.RELIABILITY_RATING, Rating.A); }
@Test public void test_new_security_remediation_effort() { withNoIssues().assertThatLeakValueIs(CoreMetrics.NEW_SECURITY_REMEDIATION_EFFORT, 0.0); with( newGroup(RuleType.VULNERABILITY).setEffort(3.0).setInLeak(true), // not in leak newGroup(RuleType.VULNERABILITY).setEffort(5.0).setInLeak(false), // not vulnerability newGroup(RuleType.CODE_SMELL).setEffort(7.0).setInLeak(true), // exclude resolved newResolvedGroup(RuleType.VULNERABILITY).setEffort(17.0).setInLeak(true)) .assertThatLeakValueIs(CoreMetrics.NEW_SECURITY_REMEDIATION_EFFORT, 3.0); }
@Test public void test_reliability_remediation_effort() { withNoIssues().assertThatValueIs(CoreMetrics.RELIABILITY_REMEDIATION_EFFORT, 0); with( newGroup(RuleType.BUG).setEffort(3.0), newGroup(RuleType.BUG).setEffort(5.0).setSeverity(Severity.BLOCKER), // not bugs newGroup(RuleType.CODE_SMELL).setEffort(7.0), // exclude resolved newResolvedGroup(RuleType.BUG).setEffort(17.0)) .assertThatValueIs(CoreMetrics.RELIABILITY_REMEDIATION_EFFORT, 3.0 + 5.0); }
@Test public void test_violations() { withNoIssues().assertThatValueIs(CoreMetrics.VIOLATIONS, 0); with(newGroup(), newGroup().setCount(4)).assertThatValueIs(CoreMetrics.VIOLATIONS, 5); // exclude resolved IssueGroupDto resolved = newResolvedGroup(Issue.RESOLUTION_FIXED, Issue.STATUS_RESOLVED); with(newGroup(), newGroup(), resolved).assertThatValueIs(CoreMetrics.VIOLATIONS, 2); // include issues on leak IssueGroupDto onLeak = newGroup().setCount(11).setInLeak(true); with(newGroup(), newGroup(), onLeak).assertThatValueIs(CoreMetrics.VIOLATIONS, 1 + 1 + 11); }
@Test public void test_new_critical_violations() { withNoIssues() .assertThatLeakValueIs(CoreMetrics.NEW_CRITICAL_VIOLATIONS, 0.0); with( newGroup(RuleType.CODE_SMELL).setSeverity(Severity.CRITICAL).setInLeak(true).setCount(3), newGroup(RuleType.BUG).setSeverity(Severity.CRITICAL).setInLeak(true).setCount(5), newGroup(RuleType.VULNERABILITY).setSeverity(Severity.CRITICAL).setInLeak(true).setCount(7), // not CRITICAL newGroup(RuleType.CODE_SMELL).setSeverity(Severity.MAJOR).setInLeak(true).setCount(9), // not in leak newGroup(RuleType.CODE_SMELL).setSeverity(Severity.CRITICAL).setInLeak(false).setCount(11), newGroup(RuleType.BUG).setSeverity(Severity.CRITICAL).setInLeak(false).setCount(13)) .assertThatLeakValueIs(CoreMetrics.NEW_CRITICAL_VIOLATIONS, 3 + 5 + 7); }