@Test
public void register_rules_at_startup() throws Exception {
verifyRulesInDb();
Result<Rule> searchResult = index.search(new RuleQuery(), new QueryOptions());
assertThat(searchResult.getTotal()).isEqualTo(3);
assertThat(searchResult.getHits()).hasSize(3);
Rule rule = index.getByKey(RuleTesting.XOO_X1);
assertThat(rule.severity()).isEqualTo(Severity.MINOR);
assertThat(rule.name()).isEqualTo("x1 name");
assertThat(rule.htmlDescription()).isEqualTo("x1 desc");
assertThat(rule.systemTags()).contains("tag1");
assertThat(rule.params()).hasSize(1);
assertThat(rule.param("acceptWhitespace").type()).isEqualTo(RuleParamType.BOOLEAN);
assertThat(rule.param("acceptWhitespace").defaultValue()).isEqualTo("false");
assertThat(rule.param("acceptWhitespace").description())
.isEqualTo("Accept whitespaces on the line");
assertThat(rule.debtSubCharacteristicKey())
.isEqualTo(RulesDefinition.SubCharacteristics.INTEGRATION_TESTABILITY);
assertThat(rule.debtRemediationFunction().type())
.isEqualTo(DebtRemediationFunction.Type.LINEAR_OFFSET);
assertThat(rule.debtRemediationFunction().coefficient()).isEqualTo("1h");
assertThat(rule.debtRemediationFunction().offset()).isEqualTo("30min");
assertThat(rule.effortToFixDescription()).isEqualTo("x1 effort to fix");
}
@Test
public void update_debt_rule() throws Exception {
verifyRulesInDb();
// Update x1 rule
RuleDto ruleDto = db.ruleDao().getByKey(dbSession, RuleTesting.XOO_X1);
db.ruleDao()
.update(
dbSession,
ruleDto
.setDefaultSubCharacteristicId(123456)
.setDefaultRemediationFunction("LINEAR_OFFSET")
.setDefaultRemediationCoefficient("2h")
.setDefaultRemediationOffset("35min"));
dbSession.commit();
dbSession.clearCache();
// Re-execute startup tasks
tester.get(Platform.class).executeStartupTasks();
// Verify default debt has been reset to plugin definition
Rule ruleReloaded = index.getByKey(RuleTesting.XOO_X1);
assertThat(ruleReloaded.debtSubCharacteristicKey())
.isEqualTo(RulesDefinition.SubCharacteristics.INTEGRATION_TESTABILITY);
assertThat(ruleReloaded.debtRemediationFunction().type())
.isEqualTo(DebtRemediationFunction.Type.LINEAR_OFFSET);
assertThat(ruleReloaded.debtRemediationFunction().coefficient()).isEqualTo("1h");
assertThat(ruleReloaded.debtRemediationFunction().offset()).isEqualTo("30min");
}
@Test
public void update_rule() {
verifyRulesInDb();
// The plugin X1 will be updated
rulesDefinition.includeX1 = false;
rulesDefinition.includeX1bis = true;
tester.get(Platform.class).executeStartupTasks();
Rule rule = index.getByKey(RuleTesting.XOO_X1);
assertThat(rule.severity()).isEqualTo(Severity.INFO);
assertThat(rule.name()).isEqualTo("x1 name updated");
assertThat(rule.htmlDescription()).isEqualTo("x1 desc updated");
assertThat(rule.systemTags()).contains("tag1", "tag2");
assertThat(rule.params()).hasSize(2);
assertThat(rule.param("acceptWhitespace").type()).isEqualTo(RuleParamType.BOOLEAN);
assertThat(rule.param("acceptWhitespace").defaultValue()).isEqualTo("true");
assertThat(rule.param("acceptWhitespace").description())
.isEqualTo("Accept whitespaces on the line updated");
// New parameter
assertThat(rule.param("format").type()).isEqualTo(RuleParamType.TEXT);
assertThat(rule.param("format").defaultValue()).isEqualTo("txt");
assertThat(rule.param("format").description()).isEqualTo("Format");
assertThat(rule.debtSubCharacteristicKey())
.isEqualTo(RulesDefinition.SubCharacteristics.INSTRUCTION_RELIABILITY);
assertThat(rule.debtRemediationFunction().type())
.isEqualTo(DebtRemediationFunction.Type.LINEAR);
assertThat(rule.debtRemediationFunction().coefficient()).isEqualTo("2h");
assertThat(rule.debtRemediationFunction().offset()).isNull();
assertThat(rule.effortToFixDescription()).isEqualTo("x1 effort to fix updated");
}
@Test
public void remove_debt_rule() throws Exception {
verifyRulesInDb();
// Set some default debt on x2 rule, which has no debt provided by th plugin
RuleDto ruleDto = db.ruleDao().getByKey(dbSession, RuleTesting.XOO_X2);
db.ruleDao()
.update(
dbSession,
ruleDto
.setDefaultSubCharacteristicId(
db.debtCharacteristicDao()
.selectByKey(
RulesDefinition.SubCharacteristics.INTEGRATION_TESTABILITY, dbSession)
.getId())
.setDefaultRemediationFunction("LINEAR_OFFSET")
.setDefaultRemediationCoefficient("2h")
.setDefaultRemediationOffset("35min"));
dbSession.commit();
dbSession.clearCache();
// Re-execute startup tasks
tester.get(Platform.class).executeStartupTasks();
// Verify default debt has been removed
Rule ruleReloaded = index.getByKey(RuleTesting.XOO_X2);
assertThat(ruleReloaded.debtSubCharacteristicKey()).isNull();
assertThat(ruleReloaded.debtRemediationFunction()).isNull();
}
@Test
public void override_debt() {
insertDebtCharacteristics(dbSession);
ruleDao.insert(
dbSession,
RuleTesting.newDto(RULE_KEY)
.setDefaultSubCharacteristicId(hardReliabilityId)
.setDefaultRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.name())
.setDefaultRemediationCoefficient("1d")
.setDefaultRemediationOffset("5min")
.setSubCharacteristicId(null)
.setRemediationFunction(null)
.setRemediationCoefficient(null)
.setRemediationOffset(null));
dbSession.commit();
DefaultDebtRemediationFunction fn =
new DefaultDebtRemediationFunction(
DebtRemediationFunction.Type.CONSTANT_ISSUE, null, "1min");
RuleUpdate update =
RuleUpdate.createForPluginRule(RULE_KEY)
.setDebtSubCharacteristic("SOFT_RELIABILITY")
.setDebtRemediationFunction(fn);
updater.update(update, userSessionRule);
dbSession.clearCache();
// verify debt is overridden
Rule indexedRule = tester.get(RuleIndex.class).getByKey(RULE_KEY);
assertThat(indexedRule.debtCharacteristicKey()).isEqualTo("RELIABILITY");
assertThat(indexedRule.debtSubCharacteristicKey()).isEqualTo("SOFT_RELIABILITY");
assertThat(indexedRule.debtRemediationFunction().type())
.isEqualTo(DebtRemediationFunction.Type.CONSTANT_ISSUE);
assertThat(indexedRule.debtRemediationFunction().coefficient()).isNull();
assertThat(indexedRule.debtRemediationFunction().offset()).isEqualTo("1min");
assertThat(indexedRule.debtOverloaded()).isTrue();
assertThat(indexedRule.defaultDebtCharacteristicKey()).isEqualTo("RELIABILITY");
assertThat(indexedRule.defaultDebtSubCharacteristicKey()).isEqualTo("HARD_RELIABILITY");
assertThat(indexedRule.defaultDebtRemediationFunction().type())
.isEqualTo(DebtRemediationFunction.Type.LINEAR_OFFSET);
assertThat(indexedRule.defaultDebtRemediationFunction().coefficient()).isEqualTo("1d");
assertThat(indexedRule.defaultDebtRemediationFunction().offset()).isEqualTo("5min");
}
@Test
public void reset_debt() {
insertDebtCharacteristics(dbSession);
ruleDao.insert(
dbSession,
RuleTesting.newDto(RULE_KEY)
.setDefaultSubCharacteristicId(hardReliabilityId)
.setDefaultRemediationFunction(DebtRemediationFunction.Type.LINEAR.name())
.setDefaultRemediationCoefficient("1d")
.setDefaultRemediationOffset("5min")
.setSubCharacteristicId(softReliabilityId)
.setRemediationFunction(DebtRemediationFunction.Type.CONSTANT_ISSUE.name())
.setRemediationCoefficient(null)
.setRemediationOffset("1min"));
dbSession.commit();
RuleUpdate update =
RuleUpdate.createForPluginRule(RULE_KEY)
.setDebtSubCharacteristic(RuleUpdate.DEFAULT_DEBT_CHARACTERISTIC);
updater.update(update, userSessionRule);
dbSession.clearCache();
// verify debt is coming from default values
Rule indexedRule = tester.get(RuleIndex.class).getByKey(RULE_KEY);
assertThat(indexedRule.debtCharacteristicKey()).isEqualTo("RELIABILITY");
assertThat(indexedRule.debtSubCharacteristicKey()).isEqualTo("HARD_RELIABILITY");
assertThat(indexedRule.debtRemediationFunction().type())
.isEqualTo(DebtRemediationFunction.Type.LINEAR);
assertThat(indexedRule.debtRemediationFunction().coefficient()).isEqualTo("1d");
assertThat(indexedRule.debtRemediationFunction().offset()).isEqualTo("5min");
assertThat(indexedRule.debtOverloaded()).isFalse();
assertThat(indexedRule.defaultDebtCharacteristicKey()).isEqualTo("RELIABILITY");
assertThat(indexedRule.defaultDebtSubCharacteristicKey()).isEqualTo("HARD_RELIABILITY");
assertThat(indexedRule.defaultDebtRemediationFunction().type())
.isEqualTo(DebtRemediationFunction.Type.LINEAR);
assertThat(indexedRule.defaultDebtRemediationFunction().coefficient()).isEqualTo("1d");
assertThat(indexedRule.defaultDebtRemediationFunction().offset()).isEqualTo("5min");
}
@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 unset_debt() {
insertDebtCharacteristics(dbSession);
ruleDao.insert(
dbSession,
RuleTesting.newDto(RULE_KEY)
.setDefaultSubCharacteristicId(hardReliabilityId)
.setDefaultRemediationFunction(DebtRemediationFunction.Type.LINEAR.name())
.setDefaultRemediationCoefficient("1d")
.setDefaultRemediationOffset("5min")
.setSubCharacteristicId(softReliabilityId)
.setRemediationFunction(DebtRemediationFunction.Type.CONSTANT_ISSUE.name())
.setRemediationCoefficient(null)
.setRemediationOffset("1min"));
dbSession.commit();
RuleUpdate update = RuleUpdate.createForPluginRule(RULE_KEY).setDebtSubCharacteristic(null);
updater.update(update, userSessionRule);
// verify db
dbSession.clearCache();
RuleDto rule = ruleDao.getNullableByKey(dbSession, RULE_KEY);
assertThat(rule.getSubCharacteristicId()).isEqualTo(-1);
assertThat(rule.getRemediationFunction()).isNull();
assertThat(rule.getRemediationCoefficient()).isNull();
assertThat(rule.getRemediationOffset()).isNull();
assertThat(rule.getDefaultSubCharacteristicId()).isNotNull();
assertThat(rule.getDefaultRemediationFunction()).isNotNull();
assertThat(rule.getDefaultRemediationCoefficient()).isNotNull();
assertThat(rule.getDefaultRemediationOffset()).isNotNull();
// verify index
Rule indexedRule = tester.get(RuleIndex.class).getByKey(RULE_KEY);
assertThat(indexedRule.debtCharacteristicKey()).isEqualTo("NONE");
assertThat(indexedRule.debtSubCharacteristicKey()).isEqualTo("NONE");
assertThat(indexedRule.debtRemediationFunction()).isNull();
assertThat(indexedRule.debtOverloaded()).isTrue();
}