private void persistRepositories(DbSession dbSession, List<RulesDefinition.Repository> repositories) { List<RuleRepositoryDto> dtos = repositories .stream() .map(r -> new RuleRepositoryDto(r.key(), r.language(), r.name())) .collect(toList(repositories.size())); List<String> keys = dtos.stream().map(RuleRepositoryDto::getKey).collect(toList(repositories.size())); dbClient.ruleRepositoryDao().insertOrUpdate(dbSession, dtos); dbClient.ruleRepositoryDao().deleteIfKeyNotIn(dbSession, keys); dbSession.commit(); }
private RepositoryImpl(NewRepositoryImpl newRepository, @Nullable Repository mergeInto) { this.key = newRepository.key; this.language = newRepository.language; this.isExternal = newRepository.isExternal; Map<String, Rule> ruleBuilder = new HashMap<>(); if (mergeInto != null) { if (!StringUtils.equals(newRepository.language, mergeInto.language()) || !StringUtils.equals(newRepository.key, mergeInto.key())) { throw new IllegalArgumentException(format("Bug - language and key of the repositories to be merged should be the sames: %s and %s", newRepository, mergeInto)); } this.name = StringUtils.defaultIfBlank(mergeInto.name(), newRepository.name); for (Rule rule : mergeInto.rules()) { if (!newRepository.key().startsWith("common-") && ruleBuilder.containsKey(rule.key())) { Loggers.get(getClass()).warn("The rule '{}' of repository '{}' is declared several times", rule.key(), mergeInto.key()); } ruleBuilder.put(rule.key(), rule); } } else { this.name = newRepository.name; } for (NewRule newRule : newRepository.newRules.values()) { newRule.validate(); ruleBuilder.put(newRule.key, new Rule(this, newRule)); } this.rulesByKey = unmodifiableMap(ruleBuilder); }
@Test public void define_xoo2_rules() { RulesDefinition.Repository repo = context.repository("xoo2"); assertThat(repo).isNotNull(); assertThat(repo.name()).isEqualTo("Xoo2"); assertThat(repo.language()).isEqualTo("xoo2"); assertThat(repo.rules()).hasSize(2); } }
@Test public void test_external_repositories() { GoRulesDefinition rulesDefinition = new GoRulesDefinition(true); RulesDefinition.Context context = new RulesDefinition.Context(); rulesDefinition.define(context); RulesDefinition.Repository golintRepository = context.repository("external_golint"); RulesDefinition.Repository govetRepository = context.repository("external_govet"); assertThat(context.repositories()).hasSize(3); assertThat(golintRepository.name()).isEqualTo("Golint"); assertThat(govetRepository.name()).isEqualTo("go vet"); assertThat(golintRepository.language()).isEqualTo("go"); assertThat(govetRepository.language()).isEqualTo("go"); assertThat(golintRepository.isExternal()).isEqualTo(true); assertThat(govetRepository.isExternal()).isEqualTo(true); assertThat(golintRepository.rules().size()).isEqualTo(18); assertThat(ExternalKeyUtils.GO_LINT_KEYS.size()).isEqualTo(18); assertThat(govetRepository.rules().size()).isEqualTo(21); assertThat(ExternalKeyUtils.GO_VET_KEYS.size()).isEqualTo(21); List<String> govetKeysWithoutDefinition = ExternalKeyUtils.GO_VET_KEYS.stream() .map(x -> x.key) .filter(key -> govetRepository.rule(key) == null) .collect(Collectors.toList()); assertThat(govetKeysWithoutDefinition).isEmpty(); List<String> golintKeysWithoutDefinition = ExternalKeyUtils.GO_LINT_KEYS.stream() .map(x -> x.key) .filter(key -> golintRepository.rule(key) == null) .collect(Collectors.toList()); assertThat(golintKeysWithoutDefinition).isEmpty(); }
private RepositoryImpl(NewRepositoryImpl newRepository, @Nullable Repository mergeInto) { this.key = newRepository.key; this.language = newRepository.language; this.isExternal = newRepository.isExternal; Map<String, Rule> ruleBuilder = new HashMap<>(); if (mergeInto != null) { if (!StringUtils.equals(newRepository.language, mergeInto.language()) || !StringUtils.equals(newRepository.key, mergeInto.key())) { throw new IllegalArgumentException(format("Bug - language and key of the repositories to be merged should be the sames: %s and %s", newRepository, mergeInto)); } this.name = StringUtils.defaultIfBlank(mergeInto.name(), newRepository.name); for (Rule rule : mergeInto.rules()) { if (!newRepository.key().startsWith("common-") && ruleBuilder.containsKey(rule.key())) { Loggers.get(getClass()).warn("The rule '{}' of repository '{}' is declared several times", rule.key(), mergeInto.key()); } ruleBuilder.put(rule.key(), rule); } } else { this.name = newRepository.name; } for (NewRule newRule : newRepository.newRules.values()) { newRule.validate(); ruleBuilder.put(newRule.key, new Rule(this, newRule)); } this.rulesByKey = unmodifiableMap(ruleBuilder); }
@Test public void test() { MyCustomPhpRulesDefinition rulesDefinition = new MyCustomPhpRulesDefinition(); RulesDefinition.Context context = new RulesDefinition.Context(); rulesDefinition.define(context); RulesDefinition.Repository repository = context.repository(REPOSITORY_KEY); assertThat(repository.name()).isEqualTo(REPOSITORY_NAME); assertThat(repository.language()).isEqualTo(PHPCustomRulesDefinition.LANGUAGE_KEY); assertThat(repository.rules()).hasSize(1); RulesDefinition.Rule customRule = repository.rule(RULE_KEY); assertThat(customRule).isNotNull(); assertThat(customRule.name()).isEqualTo(RULE_NAME); assertThat(customRule.htmlDescription()).isEqualTo("desc"); assertThat(customRule.tags()).contains("mybug"); assertThat(customRule.params()).hasSize(1); RulesDefinition.Param param = customRule.param("customParam"); assertThat(param.key()).isEqualTo("customParam"); assertThat(param.description()).isEqualTo("Custom parameter"); assertThat(param.defaultValue()).isEqualTo("value"); }
@Test public void test() { PerlCriticRulesDefinition def = new PerlCriticRulesDefinition(); RulesDefinition.Context context = new RulesDefinition.Context(); def.define(context); RulesDefinition.Repository repository = context.repository(PerlCriticRulesDefinition.getRepositoryKey()); assertThat(repository.name()).isEqualTo(PerlCriticRulesDefinition.getRepositoryName()); assertThat(repository.language()).isEqualTo(PerlLanguage.KEY); List<Rule> rules = repository.rules(); assertThat(rules).hasSize(272); for (Rule rule : rules) { assertThat(rule.debtRemediationFunction()).describedAs(rule.key()).isNotNull(); assertThat(rule.debtRemediationFunction().type()).describedAs(rule.key()).isEqualTo(LINEAR); } }
@Test void test() { GoRulesDefinition rulesDefinition = new GoRulesDefinition(false); RulesDefinition.Context context = new RulesDefinition.Context(); rulesDefinition.define(context); assertThat(context.repositories()).hasSize(1); RulesDefinition.Repository goRepository = context.repository("go"); assertThat(goRepository.name()).isEqualTo("SonarAnalyzer"); assertThat(goRepository.language()).isEqualTo("go"); assertThat(goRepository.rules()).hasSize(GoChecks.getChecks().size()); assertRuleProperties(goRepository); assertAllRuleParametersHaveDescription(goRepository); }
private void persistRepositories(DbSession dbSession, List<RulesDefinition.Repository> repositories) { List<RuleRepositoryDto> dtos = repositories .stream() .map(r -> new RuleRepositoryDto(r.key(), r.language(), r.name())) .collect(toList(repositories.size())); List<String> keys = dtos.stream().map(RuleRepositoryDto::getKey).collect(toList(repositories.size())); dbClient.ruleRepositoryDao().insertOrUpdate(dbSession, dtos); dbClient.ruleRepositoryDao().deleteIfKeyNotIn(dbSession, keys); dbSession.commit(); }
assertThat(checkstyle).isNotNull(); assertThat(checkstyle.key()).isEqualTo("checkstyle"); assertThat(checkstyle.name()).isEqualTo("Checkstyle"); assertThat(checkstyle.language()).isEqualTo("java"); assertThat(checkstyle.rules()).hasSize(1);
@Test public void define_repositories() { assertThat(context.repositories()).isEmpty(); context.createRepository("findbugs", "java").setName("Findbugs").done(); context.createRepository("checkstyle", "java").done(); assertThat(context.repositories()).hasSize(2); RulesDefinition.Repository findbugs = context.repository("findbugs"); assertThat(findbugs).isNotNull(); assertThat(findbugs.key()).isEqualTo("findbugs"); assertThat(findbugs.language()).isEqualTo("java"); assertThat(findbugs.name()).isEqualTo("Findbugs"); assertThat(findbugs.rules()).isEmpty(); RulesDefinition.Repository checkstyle = context.repository("checkstyle"); assertThat(checkstyle).isNotNull(); assertThat(checkstyle.key()).isEqualTo("checkstyle"); assertThat(checkstyle.language()).isEqualTo("java"); // default name is key assertThat(checkstyle.name()).isEqualTo("checkstyle"); assertThat(checkstyle.rules()).isEmpty(); assertThat(context.repository("unknown")).isNull(); // test equals() and hashCode() assertThat(findbugs).isEqualTo(findbugs).isNotEqualTo(checkstyle).isNotEqualTo("findbugs").isNotEqualTo(null); assertThat(findbugs.hashCode()).isEqualTo(findbugs.hashCode()); }
@Test public void add_rules_to_existing_repository() { RulesDefinition.NewRepository newFindbugs = context.createRepository("findbugs", "java").setName("Findbugs"); newFindbugs.createRule("NPE").setName("NPE").setHtmlDescription("NPE"); newFindbugs.done(); RulesDefinition.NewRepository newFbContrib = context.createRepository("findbugs", "java"); newFbContrib.createRule("VULNERABILITY").setName("Vulnerability").setMarkdownDescription("Detect vulnerability"); newFbContrib.done(); assertThat(context.repositories()).hasSize(1); RulesDefinition.Repository findbugs = context.repository("findbugs"); assertThat(findbugs.key()).isEqualTo("findbugs"); assertThat(findbugs.language()).isEqualTo("java"); assertThat(findbugs.name()).isEqualTo("Findbugs"); assertThat(findbugs.rules()).extracting("key").containsOnly("NPE", "VULNERABILITY"); }
@Test public void define_xoo_rules() { RulesDefinition.Repository repo = context.repository("xoo"); assertThat(repo).isNotNull(); assertThat(repo.name()).isEqualTo("Xoo"); assertThat(repo.language()).isEqualTo("xoo"); assertThat(repo.rules()).hasSize(19); RulesDefinition.Rule rule = repo.rule(OneIssuePerLineSensor.RULE_KEY); assertThat(rule.name()).isNotEmpty(); assertThat(rule.debtRemediationFunction().type()).isEqualTo(DebtRemediationFunction.Type.LINEAR); assertThat(rule.debtRemediationFunction().gapMultiplier()).isEqualTo("1min"); assertThat(rule.debtRemediationFunction().baseEffort()).isNull(); assertThat(rule.gapDescription()).isNotEmpty(); }
@Test public void define_xoo_hotspot_rule() { RulesDefinition.Repository repo = context.repository("xoo"); assertThat(repo).isNotNull(); assertThat(repo.name()).isEqualTo("Xoo"); assertThat(repo.language()).isEqualTo("xoo"); assertThat(repo.rules()).hasSize(19); RulesDefinition.Rule rule = repo.rule(HotspotSensor.RULE_KEY); assertThat(rule.name()).isNotEmpty(); assertThat(rule.securityStandards()) .isNotEmpty() .containsExactlyInAnyOrder("cwe:1", "cwe:123", "cwe:863", "owaspTop10:a1", "owaspTop10:a3"); }
@Test public void define_xooExternal_rules() { RulesDefinition.Repository repo = context.repository("external_XooEngine"); assertThat(repo).isNotNull(); assertThat(repo.name()).isEqualTo("XooEngine"); assertThat(repo.language()).isEqualTo("xoo"); assertThat(repo.rules()).hasSize(1); }
@Test public void cant_set_blank_repository_name() { context.createRepository("findbugs", "java").setName(null).done(); assertThat(context.repository("findbugs").name()).isEqualTo("findbugs"); }