@Test
public void fail_to_update_custom_when_description_is_empty() {
// Template rule
RuleDto templateRule =
ruleDao.insert(session, RuleTesting.newTemplateRule(RuleKey.of("java", "S001")));
// Custom rule
RuleDto customRule = RuleTesting.newCustomRule(templateRule);
ruleDao.insert(session, customRule);
session.commit();
session.clearCache();
WsTester.TestRequest request =
wsTester
.newPostRequest("api/rules", "update")
.setParam("key", customRule.getKey().toString())
.setParam("name", "My custom rule")
.setParam("markdown_description", "");
try {
request.execute();
fail();
} catch (Exception e) {
assertThat(e)
.isInstanceOf(IllegalArgumentException.class)
.hasMessage("The description is missing");
}
}
@Test
public void fail_to_update_custom_rule_when_empty_description() {
// Create template rule
RuleDto templateRule = RuleTesting.newTemplateRule(RuleKey.of("java", "S001"));
ruleDao.insert(dbSession, templateRule);
// Create custom rule
RuleDto customRule = RuleTesting.newCustomRule(templateRule);
ruleDao.insert(dbSession, customRule);
dbSession.commit();
// Update custom rule
RuleUpdate update =
RuleUpdate.createForCustomRule(customRule.getKey())
.setName("New name")
.setMarkdownDescription("");
try {
updater.update(update, userSessionRule);
fail();
} catch (Exception e) {
assertThat(e)
.isInstanceOf(IllegalArgumentException.class)
.hasMessage("The description is missing");
}
}
@Test
public void update_custom_rule() {
// Create template rule
RuleDto templateRule = RuleTesting.newTemplateRule(RuleKey.of("java", "S001"));
ruleDao.insert(dbSession, templateRule);
RuleParamDto templateRuleParam1 =
RuleParamDto.createFor(templateRule)
.setName("regex")
.setType("STRING")
.setDescription("Reg ex")
.setDefaultValue(".*");
RuleParamDto templateRuleParam2 =
RuleParamDto.createFor(templateRule)
.setName("format")
.setType("STRING")
.setDescription("Format");
ruleDao.insertRuleParam(dbSession, templateRule, templateRuleParam1);
ruleDao.insertRuleParam(dbSession, templateRule, templateRuleParam2);
// Create custom rule
RuleDto customRule =
RuleTesting.newCustomRule(templateRule)
.setName("Old name")
.setDescription("Old description")
.setSeverity(Severity.MINOR)
.setStatus(RuleStatus.BETA);
ruleDao.insert(dbSession, customRule);
ruleDao.insertRuleParam(dbSession, customRule, templateRuleParam1.setDefaultValue("a.*"));
ruleDao.insertRuleParam(dbSession, customRule, templateRuleParam2.setDefaultValue(null));
dbSession.commit();
// Update custom rule
RuleUpdate update =
RuleUpdate.createForCustomRule(customRule.getKey())
.setName("New name")
.setMarkdownDescription("New description")
.setSeverity("MAJOR")
.setStatus(RuleStatus.READY)
.setParameters(ImmutableMap.of("regex", "b.*"));
updater.update(update, userSessionRule);
dbSession.clearCache();
// Verify custom rule is updated
Rule customRuleReloaded = ruleIndex.getByKey(customRule.getKey());
assertThat(customRuleReloaded).isNotNull();
assertThat(customRuleReloaded.name()).isEqualTo("New name");
assertThat(customRuleReloaded.htmlDescription()).isEqualTo("New description");
assertThat(customRuleReloaded.severity()).isEqualTo("MAJOR");
assertThat(customRuleReloaded.status()).isEqualTo(RuleStatus.READY);
assertThat(customRuleReloaded.params()).hasSize(2);
assertThat(customRuleReloaded.params().get(0).defaultValue()).isEqualTo("b.*");
assertThat(customRuleReloaded.params().get(1).defaultValue()).isNull();
}
@Test
public void update_custom_rule_with_empty_parameter() {
// Create template rule
RuleDto templateRule = RuleTesting.newTemplateRule(RuleKey.of("java", "S001"));
ruleDao.insert(dbSession, templateRule);
RuleParamDto templateRuleParam =
RuleParamDto.createFor(templateRule)
.setName("regex")
.setType("STRING")
.setDescription("Reg ex");
ruleDao.insertRuleParam(dbSession, templateRule, templateRuleParam);
// Create custom rule
RuleDto customRule =
RuleTesting.newCustomRule(templateRule)
.setName("Old name")
.setDescription("Old description")
.setSeverity(Severity.MINOR)
.setStatus(RuleStatus.BETA);
ruleDao.insert(dbSession, customRule);
ruleDao.insertRuleParam(dbSession, customRule, templateRuleParam);
dbSession.commit();
// Update custom rule without setting a value for the parameter
RuleUpdate update =
RuleUpdate.createForCustomRule(customRule.getKey())
.setName("New name")
.setMarkdownDescription("New description")
.setSeverity("MAJOR")
.setStatus(RuleStatus.READY);
updater.update(update, userSessionRule);
dbSession.clearCache();
// Verify custom rule is updated
Rule customRuleReloaded = ruleIndex.getByKey(customRule.getKey());
RuleParam param = customRuleReloaded.params().get(0);
assertThat(param.defaultValue()).isNull();
}
@Test
public void update_custom_rule() throws Exception {
// Template rule
RuleDto templateRule =
ruleDao.insert(session, RuleTesting.newTemplateRule(RuleKey.of("java", "S001")));
RuleParamDto param =
RuleParamDto.createFor(templateRule)
.setName("regex")
.setType("STRING")
.setDescription("Reg ex")
.setDefaultValue(".*");
ruleDao.insertRuleParam(session, templateRule, param);
session.commit();
// Custom rule
NewRule newRule =
NewRule.createForCustomRule("MY_CUSTOM", templateRule.getKey())
.setName("Old custom")
.setHtmlDescription("Old description")
.setSeverity(Severity.MINOR)
.setStatus(RuleStatus.BETA)
.setParameters(ImmutableMap.of("regex", "a"));
RuleKey customRuleKey = ruleService.create(newRule);
session.clearCache();
WsTester.TestRequest request =
wsTester
.newPostRequest("api/rules", "update")
.setParam("key", customRuleKey.toString())
.setParam("name", "My custom rule")
.setParam("markdown_description", "Description")
.setParam("severity", "MAJOR")
.setParam("status", "BETA")
.setParam("params", "regex=a.*");
request.execute().assertJson(getClass(), "update_custom_rule.json");
}
@Test
public void update_active_rule_parameters_when_updating_custom_rule() {
// Create template rule with 3 parameters
RuleDto templateRule =
RuleTesting.newTemplateRule(RuleKey.of("java", "S001")).setLanguage("xoo");
ruleDao.insert(dbSession, templateRule);
RuleParamDto templateRuleParam1 =
RuleParamDto.createFor(templateRule)
.setName("regex")
.setType("STRING")
.setDescription("Reg ex")
.setDefaultValue(".*");
ruleDao.insertRuleParam(dbSession, templateRule, templateRuleParam1);
RuleParamDto templateRuleParam2 =
RuleParamDto.createFor(templateRule)
.setName("format")
.setType("STRING")
.setDescription("format")
.setDefaultValue("csv");
ruleDao.insertRuleParam(dbSession, templateRule, templateRuleParam2);
RuleParamDto templateRuleParam3 =
RuleParamDto.createFor(templateRule)
.setName("message")
.setType("STRING")
.setDescription("message");
ruleDao.insertRuleParam(dbSession, templateRule, templateRuleParam3);
// Create custom rule
RuleDto customRule =
RuleTesting.newCustomRule(templateRule).setSeverity(Severity.MAJOR).setLanguage("xoo");
ruleDao.insert(dbSession, customRule);
ruleDao.insertRuleParam(dbSession, customRule, templateRuleParam1.setDefaultValue("a.*"));
ruleDao.insertRuleParam(dbSession, customRule, templateRuleParam2.setDefaultValue("txt"));
ruleDao.insertRuleParam(dbSession, customRule, templateRuleParam3);
// Create a quality profile
QualityProfileDto profileDto = QProfileTesting.newXooP1();
db.qualityProfileDao().insert(dbSession, profileDto);
dbSession.commit();
// Activate the custom rule
RuleActivation activation =
new RuleActivation(customRule.getKey()).setSeverity(Severity.BLOCKER);
tester.get(RuleActivator.class).activate(dbSession, activation, QProfileTesting.XOO_P1_NAME);
dbSession.commit();
dbSession.clearCache();
// Update custom rule parameter 'regex', add 'message' and remove 'format'
RuleUpdate update =
RuleUpdate.createForCustomRule(customRule.getKey())
.setParameters(ImmutableMap.of("regex", "b.*", "message", "a message"));
updater.update(update, userSessionRule);
dbSession.clearCache();
// Verify custom rule parameters has been updated
Rule customRuleReloaded = ruleIndex.getByKey(customRule.getKey());
assertThat(customRuleReloaded.params()).hasSize(3);
assertThat(customRuleReloaded.param("regex")).isNotNull();
assertThat(customRuleReloaded.param("regex").defaultValue()).isEqualTo("b.*");
assertThat(customRuleReloaded.param("message")).isNotNull();
assertThat(customRuleReloaded.param("message").defaultValue()).isEqualTo("a message");
assertThat(customRuleReloaded.param("format")).isNotNull();
assertThat(customRuleReloaded.param("format").defaultValue()).isNull();
RuleParam param = customRuleReloaded.params().get(0);
assertThat(param.defaultValue()).isEqualTo("b.*");
// Verify active rule parameters has been updated
ActiveRule activeRule =
tester
.get(ActiveRuleIndex.class)
.getByKey(ActiveRuleKey.of(profileDto.getKey(), customRule.getKey()));
assertThat(activeRule.params()).hasSize(2);
assertThat(activeRule.params().get("regex")).isEqualTo("b.*");
assertThat(activeRule.params().get("message")).isEqualTo("a message");
assertThat(activeRule.params().get("format")).isNull();
// Verify that severity has not changed
assertThat(activeRule.severity()).isEqualTo(Severity.BLOCKER);
}
