@Override public void define(Context context) { NewRepository repo = context.createRepository("fake", "java"); // almost all the attributes of rule1 are changed NewRule rule1 = repo.createRule("rule1") .setName("One v2") .setHtmlDescription("Description of One v2") .setSeverity(Severity.INFO) .setInternalKey("config1 v2") // tag2 and tag3 removed, tag4 added .setTags("tag1", "tag4") .setStatus(RuleStatus.READY) .setDebtSubCharacteristic("MEMORY_EFFICIENCY") .setEffortToFixDescription("squid.S115.effortToFix.v2"); rule1.setDebtRemediationFunction( rule1.debtRemediationFunctions().linearWithOffset("6d", "2h")); rule1.createParam("param1").setDescription("parameter one v2").setDefaultValue("default1 v2"); rule1.createParam("param2").setDescription("parameter two v2").setDefaultValue("default2 v2"); // rule2 is dropped, rule3 is new repo.createRule("rule3").setName("Three").setHtmlDescription("Rule Three"); repo.done(); }
private RuleKey createCustomRule( RuleKey ruleKey, NewRule newRule, RuleDto templateRuleDto, DbSession dbSession) { RuleDto ruleDto = RuleDto.createFor(ruleKey) .setTemplateId(templateRuleDto.getId()) .setConfigKey(templateRuleDto.getConfigKey()) .setName(newRule.name()) .setDescription(newRule.markdownDescription()) .setDescriptionFormat(Format.MARKDOWN) .setSeverity(newRule.severity()) .setStatus(newRule.status()) .setLanguage(templateRuleDto.getLanguage()) .setDefaultSubCharacteristicId(templateRuleDto.getDefaultSubCharacteristicId()) .setDefaultRemediationFunction(templateRuleDto.getDefaultRemediationFunction()) .setDefaultRemediationCoefficient(templateRuleDto.getDefaultRemediationCoefficient()) .setDefaultRemediationOffset(templateRuleDto.getDefaultRemediationOffset()) .setEffortToFixDescription(templateRuleDto.getEffortToFixDescription()) .setTags(templateRuleDto.getTags()) .setSystemTags(templateRuleDto.getSystemTags()); dbClient.ruleDao().insert(dbSession, ruleDto); for (RuleParamDto templateRuleParamDto : dbClient.ruleDao().findRuleParamsByRuleKey(dbSession, templateRuleDto.getKey())) { String customRuleParamValue = Strings.emptyToNull(newRule.parameter(templateRuleParamDto.getName())); createCustomRuleParams(customRuleParamValue, ruleDto, templateRuleParamDto, dbSession); } return ruleKey; }
private void validateCustomRule(NewRule newRule, DbSession dbSession, RuleKey templateKey) { Errors errors = new Errors(); validateRuleKey(errors, newRule.ruleKey()); validateName(errors, newRule); validateDescription(errors, newRule); String severity = newRule.severity(); if (Strings.isNullOrEmpty(severity)) { errors.add(Message.of("coding_rules.validation.missing_severity")); } else if (!Severity.ALL.contains(severity)) { errors.add(Message.of("coding_rules.validation.invalid_severity", severity)); } if (newRule.status() == null) { errors.add(Message.of("coding_rules.validation.missing_status")); } for (RuleParamDto ruleParam : dbClient.ruleDao().findRuleParamsByRuleKey(dbSession, templateKey)) { try { validateParam(ruleParam, newRule.parameter(ruleParam.getName())); } catch (BadRequestException validationError) { errors.add(validationError.errors()); } } if (!errors.isEmpty()) { throw new BadRequestException(errors); } }
private RuleKey createManualRule(RuleKey ruleKey, NewRule newRule, DbSession dbSession) { RuleDto ruleDto = RuleDto.createFor(ruleKey) .setName(newRule.name()) .setDescription(newRule.markdownDescription()) .setDescriptionFormat(Format.MARKDOWN) .setSeverity(newRule.severity()) .setStatus(RuleStatus.READY); dbClient.ruleDao().insert(dbSession, ruleDto); return ruleKey; }
private static void validateManualRule(NewRule newRule) { Errors errors = new Errors(); validateRuleKey(errors, newRule.ruleKey()); validateName(errors, newRule); validateDescription(errors, newRule); if (!newRule.parameters().isEmpty()) { errors.add(Message.of("coding_rules.validation.manual_rule_params")); } if (!errors.isEmpty()) { throw new BadRequestException(errors); } }
@Override public void define(Context context) { NewRepository repo = context.createRepository("big", "java"); for (int i = 0; i < SIZE; i++) { NewRule rule = repo.createRule("rule" + i) .setName("name of " + i) .setHtmlDescription("description of " + i); for (int j = 0; j < 20; j++) { rule.createParam("param" + j); } } repo.done(); }
@Test public void reactivate_disabled_custom_rules() { Rule templateRule = index.getByKey(RuleKey.of("xoo", "template1")); // Create custom rule RuleKey customRuleKey = tester .get(RuleCreator.class) .create( NewRule.createForCustomRule("CUSTOM_RULE", templateRule.key()) .setName("My custom") .setHtmlDescription("Some description") .setSeverity(Severity.MAJOR) .setStatus(RuleStatus.READY)); dbSession.commit(); dbSession.clearCache(); assertThat(index.getByKey(customRuleKey).status()).isEqualTo(RuleStatus.READY); // Restart without template rule rulesDefinition.includeTemplate1 = false; tester.get(Platform.class).executeStartupTasks(); dbSession.clearCache(); // Verify custom rule is removed assertThat(index.getByKey(customRuleKey).status()).isEqualTo(RuleStatus.REMOVED); // Restart with template rule rulesDefinition.includeTemplate1 = true; tester.get(Platform.class).executeStartupTasks(); dbSession.clearCache(); // Verify custom rule is reactivate assertThat(index.getByKey(customRuleKey).status()).isEqualTo(RuleStatus.READY); }
@Test public void not_update_custom_rule_from_template_if_no_change() throws Exception { Rule templateRule = index.getByKey(RuleKey.of("xoo", "template1")); // Create custom rule RuleKey customRuleKey = tester .get(RuleCreator.class) .create( NewRule.createForCustomRule("CUSTOM_RULE", templateRule.key()) .setName("My custom") .setHtmlDescription("Some description") .setSeverity(Severity.MAJOR) .setStatus(RuleStatus.READY) .setParameters(ImmutableMap.of("format", "txt"))); dbSession.commit(); dbSession.clearCache(); // Store updated at date Date updatedAt = index.getByKey(customRuleKey).updatedAt(); // Re-execute startup tasks tester.get(Platform.class).executeStartupTasks(); // Verify custom rule has not been updated Rule customRuleReloaded = index.getByKey(customRuleKey); assertThat(customRuleReloaded.updatedAt()).isEqualTo(updatedAt); }
@Override public void define(Context context) { NewRepository repository = context .createRepository(CheckList.REPOSITORY_KEY, CxxLanguage.KEY) .setName(REPOSITORY_NAME); AnnotationBasedRulesDefinition.load(repository, CxxLanguage.KEY, CheckList.getChecks()); for (NewRule rule : repository.rules()) { // FIXME: set internal key to key to ensure rule templates works properly : should be removed // when SONAR-6162 is fixed. rule.setInternalKey(rule.key()); } SqaleXmlLoader.load(repository, "/com/sonar/sqale/cxx-model.xml"); repository.done(); }
public RuleKey create(NewRule newRule) { DbSession dbSession = dbClient.openSession(false); try { if (newRule.isCustom()) { return createCustomRule(newRule, dbSession); } if (newRule.isManual()) { return createManualRule(newRule, dbSession); } throw new IllegalStateException("Only custom rule and manual rule can be created"); } finally { dbSession.close(); } }
@Override public void define(Context context) { NewRepository repo = context.createRepository("fake", "java"); NewRule rule1 = repo.createRule("rule1") .setName("One") .setHtmlDescription("Description of One") .setSeverity(Severity.BLOCKER) .setInternalKey("config1") .setTags("tag1", "tag2", "tag3") .setStatus(RuleStatus.BETA) .setDebtSubCharacteristic("MEMORY_EFFICIENCY") .setEffortToFixDescription("squid.S115.effortToFix"); rule1.setDebtRemediationFunction( rule1.debtRemediationFunctions().linearWithOffset("5d", "10h")); rule1.createParam("param1").setDescription("parameter one").setDefaultValue("default1"); rule1.createParam("param2").setDescription("parameter two").setDefaultValue("default2"); repo.createRule("rule2").setName("Two").setHtmlDescription("Minimal rule"); repo.done(); }
private RuleKey createManualRule(NewRule newRule, DbSession dbSession) { validateManualRule(newRule); RuleKey customRuleKey = RuleKey.of(RuleDoc.MANUAL_REPOSITORY, newRule.ruleKey()); RuleDto existingRule = loadRule(customRuleKey, dbSession); if (existingRule != null) { updateExistingRule(existingRule, newRule, dbSession); } else { createManualRule(customRuleKey, newRule, dbSession); } dbSession.commit(); return customRuleKey; }
private RuleKey createCustomRule(NewRule newRule, DbSession dbSession) { RuleKey templateKey = newRule.templateKey(); if (templateKey == null) { throw new IllegalArgumentException("Rule template key should not be null"); } RuleDto templateRule = dbClient.ruleDao().getByKey(dbSession, templateKey); if (!templateRule.isTemplate()) { throw new IllegalArgumentException( "This rule is not a template rule: " + templateKey.toString()); } validateCustomRule(newRule, dbSession, templateKey); RuleKey customRuleKey = RuleKey.of(templateRule.getRepositoryKey(), newRule.ruleKey()); RuleDto existingRule = loadRule(customRuleKey, dbSession); if (existingRule != null) { updateExistingRule(existingRule, newRule, dbSession); } else { createCustomRule(customRuleKey, newRule, templateRule, dbSession); } dbSession.commit(); return customRuleKey; }
private void updateExistingRule(RuleDto ruleDto, NewRule newRule, DbSession dbSession) { if (ruleDto.getStatus().equals(RuleStatus.REMOVED)) { if (newRule.isPreventReactivation()) { throw new ReactivationException( String.format( "A removed rule with the key '%s' already exists", ruleDto.getKey().rule()), ruleDto.getKey()); } else { ruleDto.setStatus(RuleStatus.READY); dbClient.ruleDao().update(dbSession, ruleDto); } } else { throw new IllegalArgumentException( String.format("A rule with the key '%s' already exists", ruleDto.getKey().rule())); } }
@Test public void update_custom_rule_from_template() throws Exception { Rule templateRule = index.getByKey(RuleKey.of("xoo", "template1")); // Create custom rule RuleKey customRuleKey = tester .get(RuleCreator.class) .create( NewRule.createForCustomRule("CUSTOM_RULE", templateRule.key()) .setName("My custom") .setHtmlDescription("Some description") .setSeverity(Severity.MAJOR) .setStatus(RuleStatus.READY) .setParameters(ImmutableMap.of("format", "txt"))); // Update custom rule RuleDto customRuleDto = db.ruleDao().getByKey(dbSession, customRuleKey); db.ruleDao() .update( dbSession, customRuleDto .setLanguage("other language") .setConfigKey("other config key") .setDefaultSubCharacteristicId(45) .setDefaultRemediationFunction("LINEAR_OFFSET") .setDefaultRemediationCoefficient("1h") .setDefaultRemediationOffset("5min") .setEffortToFixDescription("effort to fix desc")); dbSession.commit(); dbSession.clearCache(); // Re-execute startup tasks tester.get(Platform.class).executeStartupTasks(); // Verify custom rule has been restore from the template Rule customRule = index.getByKey(customRuleKey); assertThat(customRule.language()).isEqualTo("xoo"); assertThat(customRule.internalKey()).isNull(); assertThat(customRule.debtSubCharacteristicKey()).isNull(); assertThat(customRule.debtRemediationFunction()).isNull(); }
@Test public void not_disable_manual_rules() { // Create manual rule RuleKey manualRuleKey = tester .get(RuleCreator.class) .create( NewRule.createForManualRule("MANUAL_RULE") .setName("My manual") .setHtmlDescription("Some description")); dbSession.commit(); dbSession.clearCache(); assertThat(index.getByKey(manualRuleKey).status()).isEqualTo(RuleStatus.READY); // Restart tester.get(Platform.class).executeStartupTasks(); // Verify manual rule is still ready assertThat(index.getByKey(manualRuleKey).status()).isEqualTo(RuleStatus.READY); }
@Test public void not_update_custom_rule_params_from_template() throws Exception { Rule templateRule = index.getByKey(RuleKey.of("xoo", "template1")); // Create custom rule RuleKey customRuleKey = tester .get(RuleCreator.class) .create( NewRule.createForCustomRule("CUSTOM_RULE", templateRule.key()) .setName("My custom") .setHtmlDescription("Some description") .setSeverity(Severity.MAJOR) .setStatus(RuleStatus.READY) .setParameters(ImmutableMap.of("format", "txt"))); dbSession.commit(); dbSession.clearCache(); // Update custom rule param name RuleDto customRuleDto = db.ruleDao().getByKey(dbSession, customRuleKey); RuleParamDto customRuleParamDto = db.ruleDao().findRuleParamsByRuleKey(dbSession, customRuleKey).get(0); db.ruleDao().removeRuleParam(dbSession, customRuleDto, customRuleParamDto); db.ruleDao().addRuleParam(dbSession, customRuleDto, customRuleParamDto.setName("format2")); dbSession.commit(); dbSession.clearCache(); // Verify param has been updated Rule customRule = index.getByKey(customRuleKey); assertThat(customRule.params()).hasSize(1); assertThat(customRule.params().get(0).key()).isEqualTo("format2"); // Re-execute startup tasks tester.get(Platform.class).executeStartupTasks(); // Verify custom rule param has not been changed! Rule customRuleReloaded = index.getByKey(customRuleKey); assertThat(customRuleReloaded.params().get(0).key()).isEqualTo("format2"); }
private static void validateName(Errors errors, NewRule newRule) { if (Strings.isNullOrEmpty(newRule.name())) { errors.add(Message.of("coding_rules.validation.missing_name")); } }
@Override public void define(Context context) { if (includeX1 || includeX1bis || includeX2 || includeTemplate1 || includeRuleLinkedToRootCharacteristic) { NewRepository repository = context.createRepository("xoo", "xoo").setName("Xoo Repo"); if (includeX1) { NewRule x1Rule = repository .createRule(RuleTesting.XOO_X1.rule()) .setName("x1 name") .setHtmlDescription("x1 desc") .setSeverity(Severity.MINOR) .setEffortToFixDescription("x1 effort to fix") .setTags("tag1"); x1Rule .createParam("acceptWhitespace") .setType(RuleParamType.BOOLEAN) .setDefaultValue("false") .setDescription("Accept whitespaces on the line"); x1Rule .setDebtSubCharacteristic(SubCharacteristics.INTEGRATION_TESTABILITY) .setDebtRemediationFunction( x1Rule.debtRemediationFunctions().linearWithOffset("1h", "30min")); } // X1 having fields updated to simulate an update from the plugin if (includeX1bis) { NewRule x1Rule = repository .createRule(RuleTesting.XOO_X1.rule()) .setName("x1 name updated") .setHtmlDescription("x1 desc updated") .setSeverity(Severity.INFO) .setEffortToFixDescription("x1 effort to fix updated") .setTags("tag1", "tag2", "user-tag"); x1Rule .createParam("acceptWhitespace") .setType(RuleParamType.BOOLEAN) .setDefaultValue("true") .setDescription("Accept whitespaces on the line updated"); // New param x1Rule .createParam("format") .setType(RuleParamType.TEXT) .setDefaultValue("txt") .setDescription("Format"); x1Rule .setDebtSubCharacteristic(SubCharacteristics.INSTRUCTION_RELIABILITY) .setDebtRemediationFunction(x1Rule.debtRemediationFunctions().linear("2h")); } if (includeX2) { repository .createRule(RuleTesting.XOO_X2.rule()) .setName("x2 name") .setHtmlDescription("x2 desc") .setSeverity(Severity.MAJOR); } if (includeRuleLinkedToRootCharacteristic) { NewRule x1Rule = repository .createRule("RuleLinkedToRootCharacteristic") .setName("RuleLinkedToRootCharacteristic name") .setHtmlDescription("RuleLinkedToRootCharacteristic desc") .setSeverity(Severity.MINOR); x1Rule // Link to a root characteristic -> fail .setDebtSubCharacteristic("REUSABILITY") .setDebtRemediationFunction( x1Rule.debtRemediationFunctions().linearWithOffset("1h", "30min")); } if (includeTemplate1) { repository .createRule("template1") .setName("template1 name") .setHtmlDescription("template1 desc") .setSeverity(Severity.MAJOR) .setTemplate(true) .createParam("format") .setDefaultValue("csv") .setType(RuleParamType.STRING) .setDescription("format parameter"); } repository.done(); } }
private static void validateDescription(Errors errors, NewRule newRule) { if (Strings.isNullOrEmpty(newRule.htmlDescription()) && Strings.isNullOrEmpty(newRule.markdownDescription())) { errors.add(Message.of("coding_rules.validation.missing_description")); } }