From 391f5c52c68e381679bb07177b51c0afa5337fd1 Mon Sep 17 00:00:00 2001 From: Julien Lancelot Date: Mon, 22 Feb 2016 12:31:36 +0100 Subject: [PATCH] SONAR-7330 RuleCreator is now using RuleIndexer --- .../org/sonar/server/rule/RuleCreator.java | 42 ++-- .../server/rule/RuleCreatorMediumTest.java | 193 +++++++++--------- 2 files changed, 121 insertions(+), 114 deletions(-) diff --git a/server/sonar-server/src/main/java/org/sonar/server/rule/RuleCreator.java b/server/sonar-server/src/main/java/org/sonar/server/rule/RuleCreator.java index 11b28a75d1a..a7adbd6af2e 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/rule/RuleCreator.java +++ b/server/sonar-server/src/main/java/org/sonar/server/rule/RuleCreator.java @@ -19,6 +19,7 @@ */ package org.sonar.server.rule; +import com.google.common.base.Optional; import com.google.common.base.Splitter; import com.google.common.base.Strings; import java.util.List; @@ -29,15 +30,16 @@ import org.sonar.api.rule.RuleStatus; import org.sonar.api.rule.Severity; import org.sonar.api.server.ServerSide; import org.sonar.api.server.rule.RuleParamType; +import org.sonar.db.DbClient; import org.sonar.db.DbSession; import org.sonar.db.rule.RuleDto; import org.sonar.db.rule.RuleDto.Format; import org.sonar.db.rule.RuleParamDto; -import org.sonar.server.db.DbClient; import org.sonar.server.exceptions.BadRequestException; import org.sonar.server.exceptions.Errors; import org.sonar.server.exceptions.Message; import org.sonar.server.rule.index.RuleDoc; +import org.sonar.server.rule.index.RuleIndexer; import org.sonar.server.util.TypeValidations; import static com.google.common.collect.Lists.newArrayList; @@ -45,11 +47,12 @@ import static com.google.common.collect.Lists.newArrayList; @ServerSide public class RuleCreator { + private final RuleIndexer ruleIndexer; private final DbClient dbClient; - private final TypeValidations typeValidations; - public RuleCreator(DbClient dbClient, TypeValidations typeValidations) { + public RuleCreator(RuleIndexer ruleIndexer, DbClient dbClient, TypeValidations typeValidations) { + this.ruleIndexer = ruleIndexer; this.dbClient = dbClient; this.typeValidations = typeValidations; } @@ -77,7 +80,7 @@ public class RuleCreator { if (templateKey == null) { throw new IllegalArgumentException("Rule template key should not be null"); } - RuleDto templateRule = dbClient.deprecatedRuleDao().getByKey(dbSession, templateKey); + RuleDto templateRule = dbClient.ruleDao().selectOrFailByKey(dbSession, templateKey); if (!templateRule.isTemplate()) { throw new IllegalArgumentException("This rule is not a template rule: " + templateKey.toString()); } @@ -85,14 +88,15 @@ public class RuleCreator { RuleKey customRuleKey = RuleKey.of(templateRule.getRepositoryKey(), newRule.ruleKey()); - RuleDto existingRule = loadRule(customRuleKey, dbSession); - if (existingRule != null) { - updateExistingRule(existingRule, newRule, dbSession); + Optional existingRule = loadRule(customRuleKey, dbSession); + if (existingRule.isPresent()) { + updateExistingRule(existingRule.get(), newRule, dbSession); } else { createCustomRule(customRuleKey, newRule, templateRule, dbSession); } dbSession.commit(); + ruleIndexer.setEnabled(true).index(); return customRuleKey; } @@ -100,14 +104,15 @@ public class RuleCreator { validateManualRule(newRule); RuleKey customRuleKey = RuleKey.of(RuleDoc.MANUAL_REPOSITORY, newRule.ruleKey()); - RuleDto existingRule = loadRule(customRuleKey, dbSession); - if (existingRule != null) { - updateExistingRule(existingRule, newRule, dbSession); + Optional existingRule = loadRule(customRuleKey, dbSession); + if (existingRule.isPresent()) { + updateExistingRule(existingRule.get(), newRule, dbSession); } else { createManualRule(customRuleKey, newRule, dbSession); } dbSession.commit(); + ruleIndexer.setEnabled(true).index(); return customRuleKey; } @@ -128,7 +133,7 @@ public class RuleCreator { errors.add(Message.of("coding_rules.validation.missing_status")); } - for (RuleParamDto ruleParam : dbClient.deprecatedRuleDao().selectRuleParamsByRuleKey(dbSession, templateKey)) { + for (RuleParamDto ruleParam : dbClient.ruleDao().selectRuleParamsByRuleKey(dbSession, templateKey)) { try { validateParam(ruleParam, newRule.parameter(ruleParam.getName())); } catch (BadRequestException validationError) { @@ -187,9 +192,8 @@ public class RuleCreator { } } - @CheckForNull - private RuleDto loadRule(RuleKey ruleKey, DbSession dbSession) { - return dbClient.deprecatedRuleDao().getNullableByKey(dbSession, ruleKey); + private Optional loadRule(RuleKey ruleKey, DbSession dbSession) { + return dbClient.ruleDao().selectByKey(dbSession, ruleKey); } private RuleKey createCustomRule(RuleKey ruleKey, NewRule newRule, RuleDto templateRuleDto, DbSession dbSession) { @@ -208,9 +212,9 @@ public class RuleCreator { .setEffortToFixDescription(templateRuleDto.getEffortToFixDescription()) .setTags(templateRuleDto.getTags()) .setSystemTags(templateRuleDto.getSystemTags()); - dbClient.deprecatedRuleDao().insert(dbSession, ruleDto); + dbClient.ruleDao().insert(dbSession, ruleDto); - for (RuleParamDto templateRuleParamDto : dbClient.deprecatedRuleDao().selectRuleParamsByRuleKey(dbSession, templateRuleDto.getKey())) { + for (RuleParamDto templateRuleParamDto : dbClient.ruleDao().selectRuleParamsByRuleKey(dbSession, templateRuleDto.getKey())) { String customRuleParamValue = Strings.emptyToNull(newRule.parameter(templateRuleParamDto.getName())); createCustomRuleParams(customRuleParamValue, ruleDto, templateRuleParamDto, dbSession); } @@ -223,7 +227,7 @@ public class RuleCreator { .setType(templateRuleParam.getType()) .setDescription(templateRuleParam.getDescription()) .setDefaultValue(paramValue); - dbClient.deprecatedRuleDao().insertRuleParam(dbSession, ruleDto, ruleParamDto); + dbClient.ruleDao().insertRuleParam(dbSession, ruleDto, ruleParamDto); } private RuleKey createManualRule(RuleKey ruleKey, NewRule newRule, DbSession dbSession) { @@ -233,7 +237,7 @@ public class RuleCreator { .setDescriptionFormat(Format.MARKDOWN) .setSeverity(newRule.severity()) .setStatus(RuleStatus.READY); - dbClient.deprecatedRuleDao().insert(dbSession, ruleDto); + dbClient.ruleDao().insert(dbSession, ruleDto); return ruleKey; } @@ -243,7 +247,7 @@ public class RuleCreator { 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.deprecatedRuleDao().update(dbSession, ruleDto); + dbClient.ruleDao().update(dbSession, ruleDto); } } else { throw new IllegalArgumentException(String.format("A rule with the key '%s' already exists", ruleDto.getKey().rule())); diff --git a/server/sonar-server/src/test/java/org/sonar/server/rule/RuleCreatorMediumTest.java b/server/sonar-server/src/test/java/org/sonar/server/rule/RuleCreatorMediumTest.java index 091c3e74d04..38c7c984cd7 100644 --- a/server/sonar-server/src/test/java/org/sonar/server/rule/RuleCreatorMediumTest.java +++ b/server/sonar-server/src/test/java/org/sonar/server/rule/RuleCreatorMediumTest.java @@ -21,6 +21,7 @@ package org.sonar.server.rule; import com.google.common.collect.ImmutableMap; import com.google.common.collect.Sets; +import java.util.List; import org.assertj.core.api.Fail; import org.junit.After; import org.junit.Before; @@ -30,24 +31,24 @@ import org.sonar.api.rule.RuleKey; import org.sonar.api.rule.RuleStatus; import org.sonar.api.rule.Severity; import org.sonar.api.server.debt.DebtRemediationFunction; +import org.sonar.db.DbClient; import org.sonar.db.DbSession; +import org.sonar.db.rule.RuleDao; import org.sonar.db.rule.RuleDto; import org.sonar.db.rule.RuleDto.Format; import org.sonar.db.rule.RuleParamDto; import org.sonar.db.rule.RuleTesting; -import org.sonar.server.db.DbClient; +import org.sonar.server.es.SearchOptions; import org.sonar.server.exceptions.BadRequestException; -import org.sonar.server.rule.db.RuleDao; -import org.sonar.server.rule.index.RuleIndex; -import org.sonar.server.search.BaseIndex; +import org.sonar.server.rule.index.RuleIndex2; +import org.sonar.server.rule.index.RuleQuery; import org.sonar.server.tester.ServerTester; - -import java.util.List; import org.sonar.server.tester.UserSessionRule; import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.fail; +// TODO replace ServerTester by EsTester / DbTester public class RuleCreatorMediumTest { @ClassRule @@ -59,7 +60,7 @@ public class RuleCreatorMediumTest { DbClient db = tester.get(DbClient.class); RuleDao dao = tester.get(RuleDao.class); RuleCreator creator = tester.get(RuleCreator.class); - BaseIndex ruleIndex = tester.get(RuleIndex.class); + RuleIndex2 ruleIndex = tester.get(RuleIndex2.class); @Before public void before() { @@ -88,7 +89,7 @@ public class RuleCreatorMediumTest { dbSession.clearCache(); - RuleDto rule = db.deprecatedRuleDao().getNullableByKey(dbSession, customRuleKey); + RuleDto rule = db.ruleDao().selectOrFailByKey(dbSession, customRuleKey); assertThat(rule).isNotNull(); assertThat(rule.getKey()).isEqualTo(RuleKey.of("java", "CUSTOM_RULE")); assertThat(rule.getTemplateId()).isEqualTo(templateRule.getId()); @@ -105,7 +106,7 @@ public class RuleCreatorMediumTest { assertThat(rule.getTags()).containsOnly("usertag1", "usertag2"); assertThat(rule.getSystemTags()).containsOnly("tag1", "tag4"); - List params = db.deprecatedRuleDao().selectRuleParamsByRuleKey(dbSession, customRuleKey); + List params = db.ruleDao().selectRuleParamsByRuleKey(dbSession, customRuleKey); assertThat(params).hasSize(1); RuleParamDto param = params.get(0); @@ -115,6 +116,8 @@ public class RuleCreatorMediumTest { assertThat(param.getType()).isEqualTo("STRING"); // From user assertThat(param.getDefaultValue()).isEqualTo("a.*"); + + assertThat(ruleIndex.search(new RuleQuery(), new SearchOptions()).getIds()).containsOnly(customRuleKey, templateRule.getKey()); } @Test @@ -132,7 +135,7 @@ public class RuleCreatorMediumTest { RuleKey customRuleKey = creator.create(newRule); dbSession.clearCache(); - List params = db.deprecatedRuleDao().selectRuleParamsByRuleKey(dbSession, customRuleKey); + List params = db.ruleDao().selectRuleParamsByRuleKey(dbSession, customRuleKey); assertThat(params).hasSize(1); RuleParamDto param = params.get(0); @@ -156,7 +159,7 @@ public class RuleCreatorMediumTest { RuleKey customRuleKey = creator.create(newRule); dbSession.clearCache(); - List params = db.deprecatedRuleDao().selectRuleParamsByRuleKey(dbSession, customRuleKey); + List params = db.ruleDao().selectRuleParamsByRuleKey(dbSession, customRuleKey); assertThat(params).hasSize(1); RuleParamDto param = params.get(0); @@ -181,7 +184,7 @@ public class RuleCreatorMediumTest { RuleKey customRuleKey = creator.create(newRule); dbSession.clearCache(); - List params = db.deprecatedRuleDao().selectRuleParamsByRuleKey(dbSession, customRuleKey); + List params = db.ruleDao().selectRuleParamsByRuleKey(dbSession, customRuleKey); assertThat(params).hasSize(1); RuleParamDto param = params.get(0); @@ -235,7 +238,6 @@ public class RuleCreatorMediumTest { dbSession.clearCache(); } - @Test public void reactivate_custom_rule_if_already_exists_in_removed_status() { String key = "CUSTOM_RULE"; @@ -244,13 +246,14 @@ public class RuleCreatorMediumTest { RuleDto templateRule = createTemplateRule(); // insert a removed rule - RuleDto rule = dao.insert(dbSession, RuleTesting.newCustomRule(templateRule) + RuleDto rule = RuleTesting.newCustomRule(templateRule) .setRuleKey(key) .setStatus(RuleStatus.REMOVED) .setName("Old name") .setDescription("Old description") .setDescriptionFormat(Format.MARKDOWN) - .setSeverity(Severity.INFO)); + .setSeverity(Severity.INFO); + dao.insert(dbSession, rule); dao.insertRuleParam(dbSession, rule, dao.selectRuleParamsByRuleKey(dbSession, templateRule.getKey()).get(0).setDefaultValue("a.*")); dbSession.commit(); dbSession.clearCache(); @@ -266,18 +269,18 @@ public class RuleCreatorMediumTest { dbSession.clearCache(); - Rule result = ruleIndex.getByKey(customRuleKey); - assertThat(result.key()).isEqualTo(RuleKey.of("java", key)); - assertThat(result.status()).isEqualTo(RuleStatus.READY); + RuleDto result = db.ruleDao().selectOrFailByKey(dbSession, customRuleKey); + assertThat(result.getKey()).isEqualTo(RuleKey.of("java", key)); + assertThat(result.getStatus()).isEqualTo(RuleStatus.READY); // These values should be the same than before - assertThat(result.name()).isEqualTo("Old name"); - assertThat(result.markdownDescription()).isEqualTo("Old description"); - assertThat(result.severity()).isEqualTo(Severity.INFO); - assertThat(result.param("regex").defaultValue()).isEqualTo("a.*"); + assertThat(result.getName()).isEqualTo("Old name"); + assertThat(result.getDescription()).isEqualTo("Old description"); + assertThat(result.getSeverityString()).isEqualTo(Severity.INFO); - // Check that the id is the same - assertThat(db.deprecatedRuleDao().getByKey(dbSession, result.key()).getId()).isEqualTo(rule.getId()); + List params = db.ruleDao().selectRuleParamsByRuleKey(dbSession, customRuleKey); + assertThat(params).hasSize(1); + assertThat(params.get(0).getDefaultValue()).isEqualTo("a.*"); } @Test @@ -288,12 +291,13 @@ public class RuleCreatorMediumTest { RuleDto templateRule = createTemplateRule(); // insert a removed rule - RuleDto rule = dao.insert(dbSession, RuleTesting.newCustomRule(templateRule) + RuleDto rule = RuleTesting.newCustomRule(templateRule) .setRuleKey(key) .setStatus(RuleStatus.REMOVED) .setName("Old name") .setDescription("Old description") - .setSeverity(Severity.INFO)); + .setSeverity(Severity.INFO); + dao.insert(dbSession, rule); dao.insertRuleParam(dbSession, rule, dao.selectRuleParamsByRuleKey(dbSession, templateRule.getKey()).get(0).setDefaultValue("a.*")); dbSession.commit(); dbSession.clearCache(); @@ -465,8 +469,8 @@ public class RuleCreatorMediumTest { @Test public void fail_to_create_custom_rule_when_wrong_rule_template() { // insert rule - RuleDto rule = dao.insert(dbSession, - RuleTesting.newDto(RuleKey.of("java", "S001")).setIsTemplate(false)); + RuleDto rule = RuleTesting.newDto(RuleKey.of("java", "S001")).setIsTemplate(false); + dao.insert(dbSession, rule); dbSession.commit(); // Create custom rule with unknown template rule @@ -494,19 +498,22 @@ public class RuleCreatorMediumTest { dbSession.clearCache(); - Rule rule = ruleIndex.getByKey(ruleKey); + RuleDto rule = db.ruleDao().selectOrFailByKey(dbSession, ruleKey); assertThat(rule).isNotNull(); - assertThat(rule.key()).isEqualTo(RuleKey.of("manual", "MANUAL_RULE")); - assertThat(rule.name()).isEqualTo("My manual"); - assertThat(rule.markdownDescription()).isEqualTo("Some description"); - assertThat(rule.severity()).isNull(); - assertThat(rule.status()).isEqualTo(RuleStatus.READY); - assertThat(rule.language()).isNull(); - assertThat(rule.internalKey()).isNull(); - assertThat(rule.debtRemediationFunction()).isNull(); - assertThat(rule.tags()).isEmpty(); - assertThat(rule.systemTags()).isEmpty(); - assertThat(rule.params()).isEmpty(); + assertThat(rule.getKey()).isEqualTo(RuleKey.of("manual", "MANUAL_RULE")); + assertThat(rule.getName()).isEqualTo("My manual"); + assertThat(rule.getDescription()).isEqualTo("Some description"); + assertThat(rule.getSeverityString()).isNull(); + assertThat(rule.getStatus()).isEqualTo(RuleStatus.READY); + assertThat(rule.getLanguage()).isNull(); + assertThat(rule.getConfigKey()).isNull(); + assertThat(rule.getDefaultRemediationOffset()).isNull(); + assertThat(rule.getTags()).isEmpty(); + assertThat(rule.getSystemTags()).isEmpty(); + + assertThat(db.ruleDao().selectRuleParamsByRuleKey(dbSession, ruleKey)).isEmpty(); + + assertThat(ruleIndex.search(new RuleQuery(), new SearchOptions()).getIds()).containsOnly(ruleKey); } @Test @@ -519,19 +526,20 @@ public class RuleCreatorMediumTest { dbSession.clearCache(); - Rule rule = ruleIndex.getByKey(ruleKey); + RuleDto rule = db.ruleDao().selectOrFailByKey(dbSession, ruleKey); assertThat(rule).isNotNull(); - assertThat(rule.key()).isEqualTo(RuleKey.of("manual", "MANUAL_RULE")); - assertThat(rule.name()).isEqualTo("My manual"); - assertThat(rule.markdownDescription()).isEqualTo("Some description"); - assertThat(rule.severity()).isEqualTo(Severity.BLOCKER); - assertThat(rule.status()).isEqualTo(RuleStatus.READY); - assertThat(rule.language()).isNull(); - assertThat(rule.internalKey()).isNull(); - assertThat(rule.debtRemediationFunction()).isNull(); - assertThat(rule.tags()).isEmpty(); - assertThat(rule.systemTags()).isEmpty(); - assertThat(rule.params()).isEmpty(); + assertThat(rule.getKey()).isEqualTo(RuleKey.of("manual", "MANUAL_RULE")); + assertThat(rule.getName()).isEqualTo("My manual"); + assertThat(rule.getDescription()).isEqualTo("Some description"); + assertThat(rule.getSeverityString()).isEqualTo(Severity.BLOCKER); + assertThat(rule.getStatus()).isEqualTo(RuleStatus.READY); + assertThat(rule.getLanguage()).isNull(); + assertThat(rule.getConfigKey()).isNull(); + assertThat(rule.getDefaultRemediationFunction()).isNull(); + assertThat(rule.getTags()).isEmpty(); + assertThat(rule.getSystemTags()).isEmpty(); + + assertThat(db.ruleDao().selectRuleParamsByRuleKey(dbSession, ruleKey)).isEmpty(); } @Test @@ -539,11 +547,12 @@ public class RuleCreatorMediumTest { String key = "MANUAL_RULE"; // insert a removed rule - RuleDto rule = dao.insert(dbSession, RuleTesting.newManualRule(key) + RuleDto rule = RuleTesting.newManualRule(key) .setStatus(RuleStatus.REMOVED) .setName("Old name") .setDescription("Old description") - .setSeverity(Severity.INFO)); + .setSeverity(Severity.INFO); + dao.insert(dbSession, rule); dbSession.commit(); dbSession.clearCache(); @@ -555,17 +564,14 @@ public class RuleCreatorMediumTest { dbSession.clearCache(); - Rule result = ruleIndex.getByKey(ruleKey); - assertThat(result.key()).isEqualTo(RuleKey.of("manual", key)); - assertThat(result.status()).isEqualTo(RuleStatus.READY); + RuleDto result = db.ruleDao().selectOrFailByKey(dbSession, ruleKey); + assertThat(result.getKey()).isEqualTo(RuleKey.of("manual", key)); + assertThat(result.getStatus()).isEqualTo(RuleStatus.READY); // Name, description and severity should be the same than before - assertThat(result.name()).isEqualTo("Old name"); - assertThat(result.markdownDescription()).isEqualTo("Old description"); - assertThat(result.severity()).isEqualTo(Severity.INFO); - - // Check that the id is the same - assertThat(db.deprecatedRuleDao().getByKey(dbSession, result.key()).getId()).isEqualTo(rule.getId()); + assertThat(result.getName()).isEqualTo("Old name"); + assertThat(result.getDescription()).isEqualTo("Old description"); + assertThat(result.getSeverityString()).isEqualTo(Severity.INFO); } @Test @@ -666,18 +672,17 @@ public class RuleCreatorMediumTest { } private RuleDto createTemplateRule() { - RuleDto templateRule = dao.insert(dbSession, - RuleTesting.newDto(RuleKey.of("java", "S001")) - .setIsTemplate(true) - .setLanguage("java") - .setConfigKey("S001") - .setDefaultRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.name()) - .setDefaultRemediationCoefficient("1h") - .setDefaultRemediationOffset("5min") - .setEffortToFixDescription("desc") - .setTags(Sets.newHashSet("usertag1", "usertag2")) - .setSystemTags(Sets.newHashSet("tag1", "tag4")) - ); + RuleDto templateRule = RuleTesting.newDto(RuleKey.of("java", "S001")) + .setIsTemplate(true) + .setLanguage("java") + .setConfigKey("S001") + .setDefaultRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.name()) + .setDefaultRemediationCoefficient("1h") + .setDefaultRemediationOffset("5min") + .setEffortToFixDescription("desc") + .setTags(Sets.newHashSet("usertag1", "usertag2")) + .setSystemTags(Sets.newHashSet("tag1", "tag4")); + dao.insert(dbSession, templateRule); RuleParamDto ruleParamDto = RuleParamDto.createFor(templateRule).setName("regex").setType("STRING").setDescription("Reg ex").setDefaultValue(".*"); dao.insertRuleParam(dbSession, templateRule, ruleParamDto); dbSession.commit(); @@ -685,16 +690,15 @@ public class RuleCreatorMediumTest { } private RuleDto createTemplateRuleWithIntArrayParam() { - RuleDto templateRule = dao.insert(dbSession, - RuleTesting.newDto(RuleKey.of("java", "S002")) - .setIsTemplate(true) - .setLanguage("java") - .setConfigKey("S002") - .setDefaultRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.name()) - .setDefaultRemediationCoefficient("1h") - .setDefaultRemediationOffset("5min") - .setEffortToFixDescription("desc") - ); + RuleDto templateRule = RuleTesting.newDto(RuleKey.of("java", "S002")) + .setIsTemplate(true) + .setLanguage("java") + .setConfigKey("S002") + .setDefaultRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.name()) + .setDefaultRemediationCoefficient("1h") + .setDefaultRemediationOffset("5min") + .setEffortToFixDescription("desc"); + dao.insert(dbSession, templateRule); RuleParamDto ruleParamDto = RuleParamDto.createFor(templateRule) .setName("myIntegers").setType("INTEGER,multiple=true,values=1;2;3").setDescription("My Integers").setDefaultValue("1"); dao.insertRuleParam(dbSession, templateRule, ruleParamDto); @@ -703,16 +707,15 @@ public class RuleCreatorMediumTest { } private RuleDto createTemplateRuleWithTwoIntParams() { - RuleDto templateRule = dao.insert(dbSession, - RuleTesting.newDto(RuleKey.of("java", "S003")) - .setIsTemplate(true) - .setLanguage("java") - .setConfigKey("S003") - .setDefaultRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.name()) - .setDefaultRemediationCoefficient("1h") - .setDefaultRemediationOffset("5min") - .setEffortToFixDescription("desc") - ); + RuleDto templateRule = RuleTesting.newDto(RuleKey.of("java", "S003")) + .setIsTemplate(true) + .setLanguage("java") + .setConfigKey("S003") + .setDefaultRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.name()) + .setDefaultRemediationCoefficient("1h") + .setDefaultRemediationOffset("5min") + .setEffortToFixDescription("desc"); + dao.insert(dbSession, templateRule); RuleParamDto ruleParam1Dto = RuleParamDto.createFor(templateRule) .setName("first").setType("INTEGER").setDescription("First integer").setDefaultValue("0"); dao.insertRuleParam(dbSession, templateRule, ruleParam1Dto); -- 2.39.5