public IssueDto setType(RuleType type) { this.type = type.getDbConstant(); return this; }
public RuleDefinitionDto setType(RuleType type) { this.type = type.getDbConstant(); return this; }
/** * 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)); }
@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)); }
public RuleMetadataDto setAdHocType(@Nullable RuleType adHocType) { setAdHocType(adHocType != null ? adHocType.getDbConstant() : null); return this; }
void add(IssueGroupDto group) { if (group.getRuleType() != SECURITY_HOTSPOT.getDbConstant()) { absolute += group.getCount(); if (group.isInLeak()) { leak += group.getCount(); } } } }
@Test public void selectByTypeAndProfileUuids_ignores_rules_in_other_profiles() { RuleDefinitionDto rule1 = db.rules().insert(r -> r.setType(RuleType.VULNERABILITY.getDbConstant())); ActiveRuleDto activeRule1 = createFor(profile2, rule1).setSeverity(BLOCKER); underTest.insert(dbSession, activeRule1); assertThat(underTest.selectByTypeAndProfileUuids(dbSession, singletonList(RuleType.VULNERABILITY.getDbConstant()), singletonList(profile1.getKee()))) .isEmpty(); }
@Test public void selectByTypeAndProfileUuids_ignores_rules_with_another_rule_type() { RuleDefinitionDto rule1 = db.rules().insert(r -> r.setType(RuleType.VULNERABILITY.getDbConstant())); ActiveRuleDto activeRule1 = createFor(profile1, rule1).setSeverity(BLOCKER); underTest.insert(dbSession, activeRule1); assertThat( underTest.selectByTypeAndProfileUuids(dbSession, singletonList(RuleType.VULNERABILITY.getDbConstant()), singletonList(profile1.getKee()))) .extracting(OrgActiveRuleDto::getProfileUuid, OrgActiveRuleDto::getOrganizationUuid, OrgActiveRuleDto::getRuleId) .contains(tuple(profile1.getKee(), profile1.getOrganizationUuid(), rule1.getId())); assertThat( underTest.selectByTypeAndProfileUuids(dbSession, asList(RuleType.CODE_SMELL.getDbConstant(), RuleType.SECURITY_HOTSPOT.getDbConstant(), RuleType.BUG.getDbConstant()), singletonList(profile1.getKee()))) .isEmpty(); }
@Test public void iterator_over_one_issue() { dbTester.prepareDbUnit(getClass(), "one_issue.xml"); Map<String, IssueDoc> issuesByKey = issuesByKey(); assertThat(issuesByKey).hasSize(1); IssueDoc issue = issuesByKey.get("ABC"); assertThat(issue.key()).isEqualTo("ABC"); assertThat(issue.resolution()).isEqualTo("FIXED"); assertThat(issue.status()).isEqualTo("RESOLVED"); assertThat(issue.severity()).isEqualTo("BLOCKER"); assertThat(issue.assigneeUuid()).isEqualTo("uuid-of-guy1"); assertThat(issue.authorLogin()).isEqualTo("guy2"); assertThat(issue.line()).isEqualTo(444); assertThat(issue.ruleId()).isEqualTo(200); assertThat(issue.componentUuid()).isEqualTo("FILE1"); assertThat(issue.projectUuid()).isEqualTo("PROJECT1"); assertThat(issue.moduleUuid()).isEqualTo("PROJECT1"); assertThat(issue.modulePath()).isEqualTo(".PROJECT1."); assertThat(issue.directoryPath()).isEqualTo("src/main/java"); assertThat(issue.filePath()).isEqualTo("src/main/java/Action.java"); assertThat(issue.getTags()).containsOnly("tag1", "tag2", "tag3"); assertThat(issue.effort().toMinutes()).isGreaterThan(0L); assertThat(issue.type().getDbConstant()).isEqualTo(2); }
@Test public void selectByTypeAndProfileUuids() { RuleDefinitionDto rule1 = db.rules().insert(r -> r.setType(RuleType.VULNERABILITY.getDbConstant())); ActiveRuleDto activeRule1 = createFor(profile1, rule1).setSeverity(BLOCKER); underTest.insert(dbSession, activeRule1); assertThat(underTest.selectByTypeAndProfileUuids(dbSession, singletonList(RuleType.VULNERABILITY.getDbConstant()), singletonList(profile1.getKee()))) .extracting(OrgActiveRuleDto::getProfileUuid, OrgActiveRuleDto::getOrganizationUuid, OrgActiveRuleDto::getRuleId) .contains(tuple(profile1.getKee(), profile1.getOrganizationUuid(), rule1.getId())); }
@Test public void create_ad_hoc_rule_from_scanner_report() { OrganizationDto organization = db.organizations().insert(); NewAdHocRule addHocRule = new NewAdHocRule(ScannerReport.AdHocRule.newBuilder() .setEngineId("eslint") .setRuleId("no-cond-assign") .setName("No condition assigned") .setDescription("A description") .setSeverity(Constants.Severity.BLOCKER) .setType(ScannerReport.IssueType.BUG) .build()); RuleDto rule = underTest.persistAndIndex(dbSession, addHocRule, organization); assertThat(rule).isNotNull(); assertThat(rule.isExternal()).isTrue(); assertThat(rule.isAdHoc()).isTrue(); assertThat(rule.getId()).isGreaterThan(0); assertThat(rule.getKey()).isEqualTo(RuleKey.of("external_eslint", "no-cond-assign")); assertThat(rule.getName()).isEqualTo("eslint:no-cond-assign"); assertThat(rule.getDescription()).isNull(); assertThat(rule.getSeverity()).isNull(); assertThat(rule.getType()).isEqualTo(0); assertThat(rule.getMetadata().getAdHocName()).isEqualTo("No condition assigned"); assertThat(rule.getMetadata().getAdHocDescription()).isEqualTo("A description"); assertThat(rule.getMetadata().getAdHocSeverity()).isEqualTo(Severity.BLOCKER); assertThat(rule.getMetadata().getAdHocType()).isEqualTo(RuleType.BUG.getDbConstant()); }
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 selectByTypeAndLanguages_ignores_template_rules() { OrganizationDto organization = db.organizations().insert(); RuleDefinitionDto rule1 = db.rules().insert( r -> r.setKey(RuleKey.of("java", "S001")) .setConfigKey("S1") .setType(RuleType.VULNERABILITY) .setIsTemplate(true) .setLanguage("java")); db.rules().insertOrUpdateMetadata(rule1, organization); assertThat(underTest.selectByTypeAndLanguages(db.getSession(), organization.getUuid(), singletonList(RuleType.VULNERABILITY.getDbConstant()), singletonList("java"))) .extracting(RuleDto::getOrganizationUuid, RuleDto::getId, RuleDto::getLanguage, RuleDto::getType) .isEmpty(); }
@Test public void selectByTypeAndLanguages_ignores_external_rules() { OrganizationDto organization = db.organizations().insert(); RuleDefinitionDto rule1 = db.rules().insert( r -> r.setKey(RuleKey.of("java", "S001")) .setConfigKey("S1") .setType(RuleType.VULNERABILITY) .setIsExternal(true) .setLanguage("java")); db.rules().insertOrUpdateMetadata(rule1, organization); assertThat(underTest.selectByTypeAndLanguages(db.getSession(), organization.getUuid(), singletonList(RuleType.VULNERABILITY.getDbConstant()), singletonList("java"))) .extracting(RuleDto::getOrganizationUuid, RuleDto::getId, RuleDto::getLanguage, RuleDto::getType) .isEmpty(); }
assertThat(result.getSeverity()).isEqualTo(BLOCKER); assertThat(result.getStatus()).isEqualTo(STATUS_OPEN); assertThat(result.getType()).isEqualTo(RuleType.BUG.getDbConstant()); assertThat(context.getStatistics().getAll()).containsOnly( entry("inserts", "1"), entry("updates", "0"), entry("merged", "0"), entry("untouched", "0"));
@Test public void selectByTypeAndLanguages_return_nothing_when_no_rule_on_languages() { OrganizationDto organization = db.organizations().insert(); RuleDefinitionDto rule1 = db.rules().insert( r -> r.setKey(RuleKey.of("java", "S001")) .setConfigKey("S1") .setType(RuleType.VULNERABILITY) .setLanguage("java")); db.rules().insertOrUpdateMetadata(rule1, organization); RuleDefinitionDto rule2 = db.rules().insert( r -> r.setKey(RuleKey.of("js", "S002")) .setType(RuleType.VULNERABILITY) .setLanguage("js")); db.rules().insertOrUpdateMetadata(rule2, organization); assertThat(underTest.selectByTypeAndLanguages(db.getSession(), organization.getUuid(), singletonList(RuleType.VULNERABILITY.getDbConstant()), singletonList("cpp"))) .isEmpty(); }
@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); }
@Test public void selectByTypeAndLanguages_return_nothing_when_no_rule_with_type() { OrganizationDto organization = db.organizations().insert(); RuleDefinitionDto rule1 = db.rules().insert( r -> r.setKey(RuleKey.of("java", "S001")) .setConfigKey("S1") .setType(RuleType.VULNERABILITY) .setLanguage("java")); db.rules().insertOrUpdateMetadata(rule1, organization); RuleDefinitionDto rule2 = db.rules().insert( r -> r.setKey(RuleKey.of("java", "S002")) .setType(RuleType.SECURITY_HOTSPOT) .setLanguage("java")); db.rules().insertOrUpdateMetadata(rule2, organization); RuleDefinitionDto rule3 = db.rules().insert( r -> r.setKey(RuleKey.of("java", "S003")) .setType(RuleType.CODE_SMELL) .setLanguage("java")); db.rules().insertOrUpdateMetadata(rule3, organization); assertThat(underTest.selectByTypeAndLanguages(db.getSession(), organization.getUuid(), singletonList(RuleType.BUG.getDbConstant()), singletonList("java"))) .isEmpty(); }
@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 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); }