private static long getNonNullValue(Map<String, Long> issueCountByType, RuleType type) { Long value = issueCountByType.get(type.name()); return value == null ? 0L : value; } }
public RuleDoc setType(@Nullable RuleType ruleType) { setField(RuleIndexDefinition.FIELD_RULE_TYPE, ruleType == null ? null : ruleType.name()); return this; }
protected void appendRuleType(StringBuilder message, Notification notification) { String count = notification.getFieldValue(Metric.RULE_TYPE + COUNT); message .append(String.format("%s new issue%s (new debt: %s)", count, Integer.valueOf(count) > 1 ? "s" : "", notification.getFieldValue(Metric.EFFORT + COUNT))) .append(NEW_LINE).append(NEW_LINE) .append(TAB) .append("Type") .append(NEW_LINE) .append(TAB) .append(TAB); for (Iterator<RuleType> ruleTypeIterator = Arrays.asList(RuleType.BUG, RuleType.VULNERABILITY, RuleType.CODE_SMELL).iterator(); ruleTypeIterator.hasNext();) { RuleType ruleType = ruleTypeIterator.next(); String ruleTypeLabel = i18n.message(getLocale(), "issue.type." + ruleType, ruleType.name()); message.append(ruleTypeLabel).append(": ").append(notification.getFieldValue(Metric.RULE_TYPE + DOT + ruleType + COUNT)); if (ruleTypeIterator.hasNext()) { message.append(TAB); } } message .append(NEW_LINE) .append(NEW_LINE); }
private void setRuleTypeStatistics(NewIssuesStatistics.Stats stats) { DistributedMetricStatsInt distributedMetricStats = stats.getDistributedMetricStats(RULE_TYPE); setFieldValue(RULE_TYPE + COUNT, String.valueOf(distributedMetricStats.getOnLeak())); Arrays.stream(RuleType.values()) .forEach(ruleType -> setFieldValue( RULE_TYPE + DOT + ruleType + COUNT, String.valueOf(distributedMetricStats.getForLabel(ruleType.name()).map(MetricStatsInt::getOnLeak).orElse(0)))); }
public void add(DefaultIssue issue) { boolean isOnLeak = onLeakPredicate.test(issue); distributions.get(RULE_TYPE).increment(issue.type().name(), isOnLeak); String componentUuid = issue.componentUuid(); if (componentUuid != null) { distributions.get(COMPONENT).increment(componentUuid, isOnLeak); } RuleKey ruleKey = issue.ruleKey(); if (ruleKey != null) { distributions.get(RULE).increment(ruleKey.toString(), isOnLeak); } String assigneeUuid = issue.assignee(); if (assigneeUuid != null) { distributions.get(ASSIGNEE).increment(assigneeUuid, isOnLeak); } for (String tag : issue.tags()) { distributions.get(TAG).increment(tag, isOnLeak); } Duration effort = issue.effort(); if (effort != null) { effortStats.add(effort.toMinutes(), isOnLeak); } }
@Test public void verify_fail_if_parameter_not_found() { expectedException.expect(IllegalArgumentException.class); expectedException.expectMessage("Missing parameter : 'type'"); action.verify(ImmutableMap.of("unknwown", VULNERABILITY.name()), Lists.newArrayList(), userSession); }
@Test public void insert_entry_in_changelog_when_setting_type() { IssueDto issueDto = issueDbTester.insertIssue(newIssue().setType(CODE_SMELL)); setUserWithBrowseAndAdministerIssuePermission(issueDto); call(issueDto.getKey(), BUG.name()); List<FieldDiffs> fieldDiffs = dbClient.issueChangeDao().selectChangelogByIssue(dbTester.getSession(), issueDto.getKey()); assertThat(fieldDiffs).hasSize(1); assertThat(fieldDiffs.get(0).diffs()).hasSize(1); assertThat(fieldDiffs.get(0).diffs().get("type").newValue()).isEqualTo(BUG.name()); assertThat(fieldDiffs.get(0).diffs().get("type").oldValue()).isEqualTo(CODE_SMELL.name()); }
private static void handleIssue(IssueDto issue, ScannerInput.ServerIssue.Builder issueBuilder, Map<String, String> keysByUUid, OutputStream out) { issueBuilder.setKey(issue.getKey()); String moduleUuid = extractModuleUuid(issue); issueBuilder.setModuleKey(keysByUUid.get(moduleUuid)); ofNullable(issue.getFilePath()).ifPresent(issueBuilder::setPath); issueBuilder.setRuleRepository(issue.getRuleRepo()); issueBuilder.setRuleKey(issue.getRule()); ofNullable(issue.getChecksum()).ifPresent(issueBuilder::setChecksum); ofNullable(issue.getAssigneeUuid()).ifPresent(issueBuilder::setAssigneeLogin); ofNullable(issue.getLine()).ifPresent(issueBuilder::setLine); ofNullable(issue.getMessage()).ifPresent(issueBuilder::setMsg); issueBuilder.setSeverity(org.sonar.scanner.protocol.Constants.Severity.valueOf(issue.getSeverity())); issueBuilder.setManualSeverity(issue.isManualSeverity()); issueBuilder.setStatus(issue.getStatus()); ofNullable(issue.getResolution()).ifPresent(issueBuilder::setResolution); issueBuilder.setType(RuleType.valueOf(issue.getType()).name()); issueBuilder.setCreationDate(issue.getIssueCreationTime()); try { issueBuilder.build().writeDelimitedTo(out); } catch (IOException e) { throw new IllegalStateException("Unable to serialize issue", e); } issueBuilder.clear(); }
@Test public void fail_when_not_authenticated() { expectedException.expect(UnauthorizedException.class); call("ABCD", BUG.name()); }
@Test public void add_counts_issue_per_RuleType_on_leak_globally_and_per_assignee() { String assignee = randomAlphanumeric(10); Arrays.stream(RuleType.values()) .map(ruleType -> new DefaultIssue().setType(ruleType).setAssigneeUuid(assignee).setNew(true)) .forEach(underTest::add); DistributedMetricStatsInt globalDistribution = underTest.globalStatistics().getDistributedMetricStats(Metric.RULE_TYPE); DistributedMetricStatsInt assigneeDistribution = underTest.getAssigneesStatistics().get(assignee).getDistributedMetricStats(Metric.RULE_TYPE); Stream.of(globalDistribution, assigneeDistribution) .forEach(distribution -> Arrays.stream(RuleType.values()).forEach(ruleType -> assertStats(distribution, ruleType.name(), 1, 0, 1))); }
@Test public void add_counts_issue_per_RuleType_off_leak_globally_and_per_assignee() { String assignee = randomAlphanumeric(10); Arrays.stream(RuleType.values()) .map(ruleType -> new DefaultIssue().setType(ruleType).setAssigneeUuid(assignee).setNew(false)) .forEach(underTest::add); DistributedMetricStatsInt globalDistribution = underTest.globalStatistics().getDistributedMetricStats(Metric.RULE_TYPE); DistributedMetricStatsInt assigneeDistribution = underTest.getAssigneesStatistics().get(assignee).getDistributedMetricStats(Metric.RULE_TYPE); Stream.of(globalDistribution, assigneeDistribution) .forEach(distribution -> Arrays.stream(RuleType.values()).forEach(ruleType -> assertStats(distribution, ruleType.name(), 0, 1, 1))); }
@Test public void set_type() { IssueDto issueDto = newIssue().setType(BUG); DefaultIssue issue = issueDto.toDefaultIssue(); setUserWithBrowseAndAdministerIssuePermission(issueDto); action.execute(ImmutableMap.of("type", VULNERABILITY.name()), new BulkChangeAction.ActionContext(issue, IssueChangeContext.createUser(NOW, userSession.getUuid()), null)); assertThat(issue.type()).isEqualTo(VULNERABILITY); assertThat(issue.isChanged()).isTrue(); assertThat(issue.updateDate()).isEqualTo(NOW); assertThat(issue.mustSendNotifications()).isFalse(); Map<String, FieldDiffs.Diff> change = issue.currentChange().diffs(); assertThat(change.get("type").newValue()).isEqualTo(VULNERABILITY); assertThat(change.get("type").oldValue()).isEqualTo(BUG); }
private SearchRequestBuilder prepareNonClosedVulnerabilitiesAndHotspotSearch(String projectUuid, boolean isViewOrApp) { BoolQueryBuilder componentFilter = boolQuery(); if (isViewOrApp) { componentFilter.filter(QueryBuilders.termsLookupQuery(FIELD_ISSUE_BRANCH_UUID, new TermsLookup( ViewIndexDefinition.INDEX_TYPE_VIEW.getIndex(), ViewIndexDefinition.INDEX_TYPE_VIEW.getType(), projectUuid, ViewIndexDefinition.FIELD_PROJECTS))); } else { componentFilter.filter(termQuery(FIELD_ISSUE_BRANCH_UUID, projectUuid)); } return client.prepareSearch(INDEX_TYPE_ISSUE) .setQuery( componentFilter .filter(termsQuery(FIELD_ISSUE_TYPE, RuleType.SECURITY_HOTSPOT.name(), RuleType.VULNERABILITY.name())) .mustNot(termQuery(FIELD_ISSUE_STATUS, Issue.STATUS_CLOSED))) .setSize(0); }
@Test public void return_all_rule_fields_by_default() { RuleDefinitionDto rule = db.rules().insert(r -> r.setLanguage("java")); indexRules(); Rules.SearchResponse response = ws.newRequest().executeProtobuf(Rules.SearchResponse.class); Rules.Rule result = response.getRules(0); assertThat(result.getCreatedAt()).isNotEmpty(); assertThat(result.getEffortToFixDescription()).isNotEmpty(); assertThat(result.getHtmlDesc()).isNotEmpty(); assertThat(result.hasIsTemplate()).isTrue(); assertThat(result.getLang()).isEqualTo(rule.getLanguage()); assertThat(result.getLangName()).isEqualTo(languages.get(rule.getLanguage()).getName()); assertThat(result.getName()).isNotEmpty(); assertThat(result.getRepo()).isNotEmpty(); assertThat(result.getSeverity()).isNotEmpty(); assertThat(result.getType().name()).isEqualTo(RuleType.valueOf(rule.getType()).name()); }
@Test public void fail_when_missing_administer_issue_permission() { IssueDto issueDto = issueDbTester.insertIssue(); logInAndAddProjectPermission("john", issueDto, USER); expectedException.expect(ForbiddenException.class); call(issueDto.getKey(), BUG.name()); }
@Test public void fail_when_missing_browse_permission() { IssueDto issueDto = issueDbTester.insertIssue(); String login = "john"; String permission = ISSUE_ADMIN; logInAndAddProjectPermission(login, issueDto, permission); expectedException.expect(ForbiddenException.class); call(issueDto.getKey(), BUG.name()); }
@Test public void set_type() { UserDto user = db.users().insertUser(); userSession.logIn(user); ComponentDto project = db.components().insertPrivateProject(); ComponentDto file = db.components().insertComponent(newFileDto(project)); addUserProjectPermissions(user, project, USER, ISSUE_ADMIN); RuleDefinitionDto rule = db.rules().insert(); IssueDto issue = db.issues().insert(rule, project, file, i -> i.setType(BUG) .setStatus(STATUS_OPEN).setResolution(null)); BulkChangeWsResponse response = call(builder() .setIssues(singletonList(issue.getKey())) .setSetType(RuleType.CODE_SMELL.name()) .build()); checkResponse(response, 1, 1, 0, 0); IssueDto reloaded = getIssueByKeys(issue.getKey()).get(0); assertThat(reloaded.getType()).isEqualTo(RuleType.CODE_SMELL.getDbConstant()); assertThat(reloaded.getUpdatedAt()).isEqualTo(NOW); verifyPostProcessorCalled(file); }
@Override public void store(DefaultAdHocRule adHocRule) { ScannerReportWriter writer = reportPublisher.getWriter(); final ScannerReport.AdHocRule.Builder builder = ScannerReport.AdHocRule.newBuilder(); builder.setEngineId(adHocRule.engineId()); builder.setRuleId(adHocRule.ruleId()); builder.setName(adHocRule.name()); String description = adHocRule.description(); if (description != null) { builder.setDescription(description); } builder.setSeverity(Constants.Severity.valueOf(adHocRule.severity().name())); builder.setType(ScannerReport.IssueType.valueOf(adHocRule.type().name())); writer.appendAdHocRule(builder.build()); }
@Test public void send_notification_only_on_changed_issues() { UserDto user = db.users().insertUser(); userSession.logIn(user); ComponentDto project = db.components().insertMainBranch(); ComponentDto file = db.components().insertComponent(newFileDto(project)); addUserProjectPermissions(user, project, USER, ISSUE_ADMIN); RuleDefinitionDto rule = db.rules().insert(); IssueDto issue1 = db.issues().insert(rule, project, file, i -> i.setType(BUG) .setStatus(STATUS_OPEN).setResolution(null)); IssueDto issue2 = db.issues().insert(rule, project, file, i -> i.setType(BUG) .setStatus(STATUS_OPEN).setResolution(null)); IssueDto issue3 = db.issues().insert(rule, project, file, i -> i.setType(VULNERABILITY) .setStatus(STATUS_OPEN).setResolution(null)); BulkChangeWsResponse response = call(builder() .setIssues(asList(issue1.getKey(), issue2.getKey(), issue3.getKey())) .setSetType(RuleType.BUG.name()) .setSendNotifications(true) .build()); checkResponse(response, 3, 1, 2, 0); ArgumentCaptor<IssueChangeNotification> issueChangeNotificationCaptor = ArgumentCaptor.forClass(IssueChangeNotification.class); verify(notificationManager).scheduleForSending(issueChangeNotificationCaptor.capture()); assertThat(issueChangeNotificationCaptor.getAllValues()).hasSize(1); assertThat(issueChangeNotificationCaptor.getValue().getFieldValue("key")).isEqualTo(issue3.getKey()); verifyPostProcessorCalled(file); }
@Test public void add_comment_only_on_changed_issues() { UserDto user = db.users().insertUser(); userSession.logIn(user); ComponentDto project = db.components().insertMainBranch(); ComponentDto file1 = db.components().insertComponent(newFileDto(project)); ComponentDto file2 = db.components().insertComponent(newFileDto(project)); addUserProjectPermissions(user, project, USER, ISSUE_ADMIN); RuleDefinitionDto rule = db.rules().insert(); IssueDto issue1 = db.issues().insert(rule, project, file1, i -> i.setType(BUG).setSeverity(MINOR) .setStatus(STATUS_OPEN).setResolution(null)); // These 2 issues will be ignored as there's nothing to do IssueDto issue2 = db.issues().insert(rule, project, file1, i -> i.setType(VULNERABILITY) .setStatus(STATUS_OPEN).setResolution(null)); IssueDto issue3 = db.issues().insert(rule, project, file2, i -> i.setType(VULNERABILITY) .setStatus(STATUS_OPEN).setResolution(null)); BulkChangeWsResponse response = call(builder() .setIssues(asList(issue1.getKey(), issue2.getKey(), issue3.getKey())) .setSetType(VULNERABILITY.name()) .setComment("test") .build()); checkResponse(response, 3, 1, 2, 0); assertThat(dbClient.issueChangeDao().selectByTypeAndIssueKeys(db.getSession(), singletonList(issue1.getKey()), TYPE_COMMENT)).hasSize(1); assertThat(dbClient.issueChangeDao().selectByTypeAndIssueKeys(db.getSession(), singletonList(issue2.getKey()), TYPE_COMMENT)).isEmpty(); assertThat(dbClient.issueChangeDao().selectByTypeAndIssueKeys(db.getSession(), singletonList(issue3.getKey()), TYPE_COMMENT)).isEmpty(); verifyPostProcessorCalled(file1); }