@Test public void select_by_query() { OrganizationDto organization = db.organizations().insert(); RuleDefinitionDto rule1 = db.rules().insert(r -> r.setKey(RuleKey.of("java", "S001")).setConfigKey("S1")); db.rules().insertOrUpdateMetadata(rule1, organization); RuleDefinitionDto rule2 = db.rules().insert(r -> r.setKey(RuleKey.of("java", "S002"))); db.rules().insertOrUpdateMetadata(rule2, organization); RuleDefinitionDto removedRule = db.rules().insert(r -> r.setStatus(REMOVED)); assertThat(underTest.selectByQuery(db.getSession(), organization.getUuid(), RuleQuery.create())).hasSize(2); assertThat(underTest.selectByQuery(db.getSession(), organization.getUuid(), RuleQuery.create().withKey("S001"))).hasSize(1); assertThat(underTest.selectByQuery(db.getSession(), organization.getUuid(), RuleQuery.create().withConfigKey("S1"))).hasSize(1); assertThat(underTest.selectByQuery(db.getSession(), organization.getUuid(), RuleQuery.create().withRepositoryKey("java"))).hasSize(2); assertThat(underTest.selectByQuery(db.getSession(), organization.getUuid(), RuleQuery.create().withKey("S001").withConfigKey("S1").withRepositoryKey("java"))).hasSize(1); }
private static boolean matchQuery(RuleDefinitionDto ruleDefinition, RuleQuery ruleQuery) { if (RuleStatus.REMOVED.equals(ruleDefinition.getStatus())) { return false; } String repositoryKey = ruleQuery.getRepositoryKey(); if (ruleQuery.getRepositoryKey() != null && !repositoryKey.equals(ruleDefinition.getRepositoryKey())) { return false; } String key = ruleQuery.getKey(); if (key != null && !key.equals(ruleDefinition.getRuleKey())) { return false; } String configKey = ruleQuery.getConfigKey(); return configKey == null || configKey.equals(ruleDefinition.getConfigKey()); }
@Test public void find_searches_by_exact_match_of_ruleKey_and_returns_most_recent_rule() { String ruleKey = "ABCD"; RuleDefinitionDto[] sameRuleKey = { dbTester.rules().insert(rule -> rule.setRuleKey(ruleKey).setUpdatedAt(system2.now())), dbTester.rules().insert(rule -> rule.setRuleKey(ruleKey).setUpdatedAt(system2.now())) }; RuleDefinitionDto otherRule = dbTester.rules().insert(rule -> rule.setUpdatedAt(system2.now())); CachingRuleFinder underTest = new CachingRuleFinder(dbClient); assertThat(toRuleKey(underTest.find(RuleQuery.create().withKey(ruleKey)))) .isEqualTo(sameRuleKey[1].getKey()); assertThat(toRuleKey(underTest.find(RuleQuery.create().withKey(otherRule.getRuleKey())))) .isEqualTo(otherRule.getKey()); assertThat(underTest.find(RuleQuery.create().withKey(ruleKey.toLowerCase()))) .isNull(); assertThat(underTest.find(RuleQuery.create().withKey(randomAlphabetic(3)))) .isNull(); }
@Test public void should_success_finder_wrap() { // has Id assertThat(underTest.findById(rule1.getId()).getId()).isEqualTo(rule1.getId()); // should_find_by_id assertThat(underTest.findById(rule3.getId()).getConfigKey()).isEqualTo("Checker/Treewalker/AnnotationUseStyleCheck"); // should_not_find_disabled_rule_by_id assertThat(underTest.findById(rule2.getId())).isNull(); // should_find_by_key Rule rule = underTest.findByKey("checkstyle", "com.puppycrawl.tools.checkstyle.checks.header.HeaderCheck"); assertThat(rule).isNotNull(); assertThat(rule.getKey()).isEqualTo(("com.puppycrawl.tools.checkstyle.checks.header.HeaderCheck")); assertThat(rule.isEnabled()).isTrue(); // find_should_return_null_if_no_results assertThat(underTest.findByKey("checkstyle", "unknown")).isNull(); assertThat(underTest.find(RuleQuery.create().withRepositoryKey("checkstyle").withConfigKey("unknown"))).isNull(); // find_repository_rules assertThat(underTest.findAll(RuleQuery.create().withRepositoryKey("checkstyle"))).hasSize(2); // find_all_enabled assertThat(underTest.findAll(RuleQuery.create())).extracting("id").containsOnly(rule1.getId(), rule3.getId(), rule4.getId()); assertThat(underTest.findAll(RuleQuery.create())).hasSize(3); // do_not_find_disabled_rules assertThat(underTest.findByKey("checkstyle", "DisabledCheck")).isNull(); // do_not_find_unknown_rules assertThat(underTest.findAll(RuleQuery.create().withRepositoryKey("unknown_repository"))).isEmpty(); }
private void createViolationFromMessageAtProjectLevel(SMInputCursor messagesCursor) throws XMLStreamException { Rule currentRule = ruleFinder.find(RuleQuery.create().withRepositoryKey(repositoryKey) .withKey(messagesCursor.getAttrValue(TYPENAME))); if (currentRule != null) { // the violation is saved at project level, not on a specific resource Violation violation = Violation.create(currentRule, project); violation.setMessage(messagesCursor.collectDescendantText().trim()); violation.setSeverity(currentRule.getSeverity()); context.saveViolation(violation); } else { LOG.debug("Could not find the following rule in the FxCop rule repository: " + messagesCursor.getAttrValue(TYPENAME)); } }
@Test public void find_searches_by_exact_match_of_repository_key_and_returns_most_recent_rule() { String repoKey = "ABCD"; RuleDefinitionDto[] sameRepoKey = { dbTester.rules().insert(rule -> rule.setRepositoryKey(repoKey).setUpdatedAt(system2.now())), dbTester.rules().insert(rule -> rule.setRepositoryKey(repoKey).setUpdatedAt(system2.now())) }; RuleDefinitionDto otherRule = dbTester.rules().insert(rule -> rule.setUpdatedAt(system2.now())); CachingRuleFinder underTest = new CachingRuleFinder(dbClient); assertThat(toRuleKey(underTest.find(RuleQuery.create().withRepositoryKey(repoKey)))) .isEqualTo(sameRepoKey[1].getKey()); assertThat(toRuleKey(underTest.find(RuleQuery.create().withRepositoryKey(otherRule.getRepositoryKey())))) .isEqualTo(otherRule.getKey()); assertThat(underTest.find(RuleQuery.create().withRepositoryKey(repoKey.toLowerCase()))) .isNull(); assertThat(underTest.find(RuleQuery.create().withRepositoryKey(randomAlphabetic(3)))) .isNull(); }
@Test public void find_searches_by_exact_match_of_configKey_and_returns_most_recent_rule() { String configKey = "ABCD"; RuleDefinitionDto[] sameConfigKey = { dbTester.rules().insert(rule -> rule.setConfigKey(configKey).setUpdatedAt(system2.now())), dbTester.rules().insert(rule -> rule.setConfigKey(configKey).setUpdatedAt(system2.now())) }; RuleDefinitionDto otherRule = dbTester.rules().insert(rule -> rule.setUpdatedAt(system2.now())); CachingRuleFinder underTest = new CachingRuleFinder(dbClient); assertThat(toRuleKey(underTest.find(RuleQuery.create().withConfigKey(configKey)))) .isEqualTo(sameConfigKey[1].getKey()); assertThat(toRuleKey(underTest.find(RuleQuery.create().withConfigKey(otherRule.getConfigKey())))) .isEqualTo(otherRule.getKey()); assertThat(underTest.find(RuleQuery.create().withConfigKey(configKey.toLowerCase()))) .isNull(); assertThat(underTest.find(RuleQuery.create().withConfigKey(randomAlphabetic(3)))) .isNull(); }
@Test public void findAll_returns_all_rules_when_RuleQuery_has_no_non_null_field() { assertThat(underTest.findAll(RuleQuery.create())) .extracting(CachingRuleFinderTest::toRuleKey) .containsOnly(Arrays.stream(ruleDefinitions).map(RuleDefinitionDto::getKey).toArray(RuleKey[]::new)); }
private void createActiveRule(SMInputCursor rulesCursor, Map<String, ActiveRule> activeRules, String gendarmeCategory, RulesProfile profile, RulePriority rulePriority) throws XMLStreamException { String[] includedRules = StringUtils.split(rulesCursor.getAttrValue("include"), '|'); for (int i = 0; i < includedRules.length; i++) { String configKey = includedRules[i].trim() + "@" + gendarmeCategory; ActiveRule activeRule = activeRules.get(configKey); if (activeRule == null) { Rule rule = ruleFinder.find(ruleQuery.withConfigKey(configKey)); if (rule != null) { activeRule = profile.activateRule(rule, rulePriority); activeRules.put(configKey, activeRule); } } else if (activeRule.getSeverity().equals(RulePriority.MAJOR)) { // MAJOR is the default one: maybe another priority has been defined and we must set it activeRule.setSeverity(rulePriority); } } }
private Collection<Rule> byKey(RuleQuery query) { Rule rule = findByKey(query.getRepositoryKey(), query.getKey()); return rule != null ? Arrays.asList(rule) : Collections.<Rule>emptyList(); }
private Collection<Rule> byInternalKey(RuleQuery query) { return Collections2.transform(rules.findByInternalKey(query.getRepositoryKey(), query.getConfigKey()), ruleTransformer); }
private Collection<Rule> byRepository(RuleQuery query) { return Collections2.transform(rules.findByRepository(query.getRepositoryKey()), ruleTransformer); }
messages.addWarningText(message.toString()); } else { Rule rule = ruleFinder.find(RuleQuery.create().withRepositoryKey(PHPMD_REPOSITORY_KEY).withConfigKey(configKey)); if (rule == null) { StringBuilder message = new StringBuilder("Unable to import unknown PMD rule '");
private void parseRuleBlocs(SMInputCursor cursor) throws XMLStreamException { RuleQuery ruleQuery = RuleQuery.create().withRepositoryKey(repositoryKey); // Cursor is on <rule> while (cursor.getNext() != null) { if (cursor.getCurrEvent().equals(SMEvent.START_ELEMENT)) { Rule currentRule = ruleFinder.find(ruleQuery.withKey(cursor.getAttrValue("Name"))); if (currentRule != null) { String type = cursor.getAttrValue("Type"); if (StringUtils.isEmpty(type)) { parseRuleDefects(cursor, currentRule); } else { gendarmeViolationMaker.registerRuleType(currentRule, type); } } } } }
@Test public void findAll_returns_all_rules_with_exact_same_repository_key_and_order_them_most_recent_first() { String repoKey = "ABCD"; RuleDefinitionDto[] sameRepoKey = { dbTester.rules().insert(rule -> rule.setRepositoryKey(repoKey).setUpdatedAt(system2.now())), dbTester.rules().insert(rule -> rule.setRepositoryKey(repoKey).setUpdatedAt(system2.now())) }; RuleDefinitionDto otherRule = dbTester.rules().insert(rule -> rule.setUpdatedAt(system2.now())); CachingRuleFinder underTest = new CachingRuleFinder(dbClient); assertThat(underTest.findAll(RuleQuery.create().withRepositoryKey(repoKey))) .extracting(CachingRuleFinderTest::toRuleKey) .containsExactly(sameRepoKey[1].getKey(), sameRepoKey[0].getKey()); assertThat(underTest.findAll(RuleQuery.create().withRepositoryKey(otherRule.getRepositoryKey()))) .extracting(CachingRuleFinderTest::toRuleKey) .containsExactly(otherRule.getKey()); assertThat(underTest.findAll(RuleQuery.create().withRepositoryKey(repoKey.toLowerCase()))) .isEmpty(); assertThat(underTest.findAll(RuleQuery.create().withRepositoryKey(randomAlphabetic(3)))) .isEmpty(); }
@Test public void findAll_returns_all_rules_with_exact_same_configkey_and_order_them_most_recent_first() { String configKey = "ABCD"; RuleDefinitionDto[] sameConfigKey = { dbTester.rules().insert(rule -> rule.setConfigKey(configKey).setUpdatedAt(system2.now())), dbTester.rules().insert(rule -> rule.setConfigKey(configKey).setUpdatedAt(system2.now())) }; RuleDefinitionDto otherRule = dbTester.rules().insert(rule -> rule.setUpdatedAt(system2.now())); CachingRuleFinder underTest = new CachingRuleFinder(dbClient); assertThat(underTest.findAll(RuleQuery.create().withConfigKey(configKey))) .extracting(CachingRuleFinderTest::toRuleKey) .containsExactly(sameConfigKey[1].getKey(), sameConfigKey[0].getKey()); assertThat(underTest.findAll(RuleQuery.create().withConfigKey(otherRule.getConfigKey()))) .extracting(CachingRuleFinderTest::toRuleKey) .containsExactly(otherRule.getKey()); assertThat(underTest.findAll(RuleQuery.create().withConfigKey(configKey.toLowerCase()))) .isEmpty(); assertThat(underTest.findAll(RuleQuery.create().withConfigKey(randomAlphabetic(3)))) .isEmpty(); }
@Test public void findAll_returns_all_rules_with_exact_same_rulekey_and_order_them_most_recent_first() { String ruleKey = "ABCD"; RuleDefinitionDto[] sameRuleKey = { dbTester.rules().insert(rule -> rule.setRuleKey(ruleKey).setUpdatedAt(system2.now())), dbTester.rules().insert(rule -> rule.setRuleKey(ruleKey).setUpdatedAt(system2.now())) }; RuleDefinitionDto otherRule = dbTester.rules().insert(rule -> rule.setUpdatedAt(system2.now())); CachingRuleFinder underTest = new CachingRuleFinder(dbClient); assertThat(underTest.findAll(RuleQuery.create().withKey(ruleKey))) .extracting(CachingRuleFinderTest::toRuleKey) .containsExactly(sameRuleKey[1].getKey(), sameRuleKey[0].getKey()); assertThat(underTest.findAll(RuleQuery.create().withKey(otherRule.getRuleKey()))) .extracting(CachingRuleFinderTest::toRuleKey) .containsExactly(otherRule.getKey()); assertThat(underTest.findAll(RuleQuery.create().withKey(ruleKey.toLowerCase()))) .isEmpty(); assertThat(underTest.findAll(RuleQuery.create().withKey(randomAlphabetic(3)))) .isEmpty(); }
@Test public void find_returns_most_recent_rule_when_RuleQuery_has_no_non_null_field() { Rule rule = underTest.find(RuleQuery.create()); assertThat(toRuleKey(rule)).isEqualTo(ruleDefinitions[5].getKey()); }
private Collection<Rule> byKey(RuleQuery query) { Rule rule = toRule(rules.find(RuleKey.of(query.getRepositoryKey(), query.getKey()))); return rule != null ? Arrays.asList(rule) : Collections.<Rule>emptyList(); }
private Collection<Rule> byRepository(RuleQuery query) { Repository repository = context.repository(query.getRepositoryKey()); return repository != null ? repository.rules().stream().map(ruleTransformer).collect(Collectors.toList()) : Collections.<Rule>emptyList(); }