public RuleType type() { return RuleType.valueOf(getField(IssueIndexDefinition.FIELD_ISSUE_TYPE)); }
public IssueDto setType(RuleType type) { this.type = type.getDbConstant(); return this; }
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(); }
/** * Returns the enum constant of the specified DB column value. */ public static RuleType valueOf(int dbConstant) { // iterating the array is fast-enough as size is small. No need for a map. for (RuleType type : values()) { if (type.getDbConstant() == dbConstant) { return type; } } throw new IllegalArgumentException(format("Unsupported type value : %d", dbConstant)); }
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)))); }
changed = true; RuleType type = RuleType.valueOf(def.type().name()); if (!ObjectUtils.equals(dto.getType(), type.getDbConstant())) { dto.setType(type); changed = true;
@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); }
private static long getNonNullValue(Map<String, Long> issueCountByType, RuleType type) { Long value = issueCountByType.get(type.name()); return value == null ? 0L : value; } }
private static DefaultIssue newDefaultIssue(String projectUuid) { DefaultIssue defaultIssue = new DefaultIssue(); defaultIssue.setKey("issue_" + issueIdCounter++); defaultIssue.setProjectUuid(projectUuid); defaultIssue.setType(RuleType.values()[new Random().nextInt(RuleType.values().length)]); defaultIssue.setStatus(POSSIBLE_STATUSES[new Random().nextInt(POSSIBLE_STATUSES.length)]); String[] possibleResolutions = possibleResolutions(defaultIssue.getStatus()); if (possibleResolutions.length > 0) { defaultIssue.setResolution(possibleResolutions[new Random().nextInt(possibleResolutions.length)]); } return defaultIssue; }
private static String verifyTypeParameter(Map<String, Object> properties) { String type = (String) properties.get(TYPE_PARAMETER); checkArgument(!isNullOrEmpty(type), "Missing parameter : '%s'", TYPE_PARAMETER); checkArgument(RuleType.names().contains(type), "Unknown type : %s", type); return type; } }
@CheckForNull public RuleType getTypeAsRuleType() { return RuleType.valueOfNullable(type); }
public IssueDoc setType(RuleType type) { setField(IssueIndexDefinition.FIELD_ISSUE_TYPE, type.toString()); return this; }
@CheckForNull public static RuleType valueOfNullable(int dbConstant) { // iterating the array is fast-enough as size is small. No need for a map. for (RuleType type : values()) { if (type.getDbConstant() == dbConstant) { return type; } } if (dbConstant == 0) { return null; } throw new IllegalArgumentException(format("Unsupported type value : %d", dbConstant)); }
@Test public void issues_on_which_user_has_not_browse_permission_are_ignored() { UserDto user = db.users().insertUser(); userSession.logIn(user); ComponentDto project1 = db.components().insertPrivateProject(); addUserProjectPermissions(user, project1, USER, ISSUE_ADMIN); ComponentDto project2 = db.components().insertPrivateProject(); RuleDefinitionDto rule = db.rules().insert(); IssueDto authorizedIssue = db.issues().insert(rule, project1, project1, i -> i.setType(BUG) .setStatus(STATUS_OPEN).setResolution(null)); // User has not browse permission on these 2 issues IssueDto notAuthorizedIssue1 = db.issues().insert(rule, project2, project2, i -> i.setType(BUG) .setStatus(STATUS_OPEN).setResolution(null)); IssueDto notAuthorizedIssue2 = db.issues().insert(rule, project2, project2, i -> i.setType(BUG) .setStatus(STATUS_OPEN).setResolution(null)); BulkChangeWsResponse response = call(builder() .setIssues(asList(authorizedIssue.getKey(), notAuthorizedIssue1.getKey(), notAuthorizedIssue2.getKey())) .setSetType(VULNERABILITY.name()) .build()); checkResponse(response, 1, 1, 0, 0); assertThat(getIssueByKeys(authorizedIssue.getKey(), notAuthorizedIssue1.getKey(), notAuthorizedIssue2.getKey())) .extracting(IssueDto::getKey, IssueDto::getType, IssueDto::getUpdatedAt) .containsOnly( tuple(authorizedIssue.getKey(), VULNERABILITY.getDbConstant(), NOW), tuple(notAuthorizedIssue1.getKey(), BUG.getDbConstant(), notAuthorizedIssue1.getUpdatedAt()), tuple(notAuthorizedIssue2.getKey(), BUG.getDbConstant(), notAuthorizedIssue2.getUpdatedAt())); verifyPostProcessorCalled(project1); }
@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))); }
public RuleDoc setType(@Nullable RuleType ruleType) { setField(RuleIndexDefinition.FIELD_RULE_TYPE, ruleType == null ? null : ruleType.name()); return this; }
private void sendIssueChangeNotification(long issueCreatedAt) { UserDto user = db.users().insertUser(); ComponentDto project = newPrivateProjectDto(newOrganizationDto()).setDbKey(PROJECT.getDbKey()).setLongName(PROJECT.getName()); ComponentDto file = newFileDto(project).setDbKey(FILE.getDbKey()).setLongName(FILE.getName()); RuleDefinitionDto ruleDefinitionDto = newRule(); RuleType randomTypeExceptHotspot = RuleType.values()[nextInt(RuleType.values().length - 1)]; DefaultIssue issue = prepareIssue(issueCreatedAt, user, project, file, ruleDefinitionDto, randomTypeExceptHotspot); underTest.execute(new TestComputationStepContext()); ArgumentCaptor<IssueChangeNotification> issueChangeNotificationCaptor = forClass(IssueChangeNotification.class); verify(notificationService).deliver(issueChangeNotificationCaptor.capture()); IssueChangeNotification issueChangeNotification = issueChangeNotificationCaptor.getValue(); assertThat(issueChangeNotification.getFieldValue("key")).isEqualTo(issue.key()); assertThat(issueChangeNotification.getFieldValue("message")).isEqualTo(issue.message()); assertThat(issueChangeNotification.getFieldValue("ruleName")).isEqualTo(ruleDefinitionDto.getName()); assertThat(issueChangeNotification.getFieldValue("projectName")).isEqualTo(project.longName()); assertThat(issueChangeNotification.getFieldValue("projectKey")).isEqualTo(project.getKey()); assertThat(issueChangeNotification.getFieldValue("componentKey")).isEqualTo(file.getKey()); assertThat(issueChangeNotification.getFieldValue("componentName")).isEqualTo(file.longName()); assertThat(issueChangeNotification.getFieldValue("assignee")).isEqualTo(user.getLogin()); }
@Test public void ALL_NAMES_is_immutable() { expectedException.expect(UnsupportedOperationException.class); RuleType.names().add("foo"); } }
@CheckForNull public RuleType type() { return RuleType.valueOfNullable(getNullableField(RuleIndexDefinition.FIELD_RULE_TYPE)); }