@Test public void no_changes() { ruleDao.insert( dbSession, RuleTesting.newDto(RULE_KEY) // the following fields are not supposed to be updated .setNoteData("my *note*") .setNoteUserLogin("me") .setTags(ImmutableSet.of("tag1")) .setSubCharacteristicId(33) .setRemediationFunction(DebtRemediationFunction.Type.CONSTANT_ISSUE.name()) .setRemediationCoefficient("1d") .setRemediationOffset("5min")); dbSession.commit(); RuleUpdate update = RuleUpdate.createForPluginRule(RULE_KEY); assertThat(update.isEmpty()).isTrue(); updater.update(update, userSessionRule); dbSession.clearCache(); RuleDto rule = ruleDao.getNullableByKey(dbSession, RULE_KEY); assertThat(rule.getNoteData()).isEqualTo("my *note*"); assertThat(rule.getNoteUserLogin()).isEqualTo("me"); assertThat(rule.getTags()).containsOnly("tag1"); assertThat(rule.getSubCharacteristicId()).isEqualTo(33); assertThat(rule.getRemediationFunction()) .isEqualTo(DebtRemediationFunction.Type.CONSTANT_ISSUE.name()); assertThat(rule.getRemediationCoefficient()).isEqualTo("1d"); assertThat(rule.getRemediationOffset()).isEqualTo("5min"); }
@Test public void do_not_update_rule_with_removed_status() { ruleDao.insert(dbSession, RuleTesting.newDto(RULE_KEY).setStatus(RuleStatus.REMOVED)); dbSession.commit(); RuleUpdate update = RuleUpdate.createForPluginRule(RULE_KEY).setTags(Sets.newHashSet("java9")); try { updater.update(update, userSessionRule); fail(); } catch (IllegalArgumentException e) { assertThat(e).hasMessage("Rule with REMOVED status cannot be updated: squid:S001"); } }
// sqale public void updateRule(Map<String, Object> params) { RuleUpdate update = RuleUpdate.createForPluginRule(RuleKey.parse((String) params.get("ruleKey"))); String fn = (String) params.get("debtRemediationFunction"); if (fn == null) { update.setDebtRemediationFunction(null); } else { update.setDebtRemediationFunction( new DefaultDebtRemediationFunction( DebtRemediationFunction.Type.valueOf(fn), Strings.emptyToNull((String) params.get("debtRemediationCoefficient")), Strings.emptyToNull((String) params.get("debtRemediationOffset")))); } updater.update(update, userSession); }
@Test public void remove_markdown_note() { ruleDao.insert( dbSession, RuleTesting.newDto(RULE_KEY).setNoteData("my *note*").setNoteUserLogin("me")); dbSession.commit(); RuleUpdate update = RuleUpdate.createForPluginRule(RULE_KEY).setMarkdownNote(null); updater.update(update, userSessionRule); dbSession.clearCache(); RuleDto rule = ruleDao.getNullableByKey(dbSession, RULE_KEY); assertThat(rule.getNoteData()).isNull(); assertThat(rule.getNoteUserLogin()).isNull(); assertThat(rule.getNoteCreatedAt()).isNull(); assertThat(rule.getNoteUpdatedAt()).isNull(); }
@Test public void fail_to_update_plugin_rule_if_severity_is_set() { // Create rule rule RuleDto ruleDto = RuleTesting.newDto(RuleKey.of("squid", "S01")); ruleDao.insert(dbSession, ruleDto); dbSession.commit(); try { // Update rule RuleUpdate.createForPluginRule(ruleDto.getKey()).setSeverity(Severity.CRITICAL); fail(); } catch (Exception e) { assertThat(e) .isInstanceOf(IllegalStateException.class) .hasMessage("Not a custom or a manual rule"); } }
@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 remove_tags() { ruleDao.insert( dbSession, RuleTesting.newDto(RULE_KEY) .setTags(Sets.newHashSet("security")) .setSystemTags(Sets.newHashSet("java8", "javadoc"))); dbSession.commit(); RuleUpdate update = RuleUpdate.createForPluginRule(RULE_KEY).setTags(null); updater.update(update, userSessionRule); dbSession.clearCache(); RuleDto rule = ruleDao.getNullableByKey(dbSession, RULE_KEY); assertThat(rule.getTags()).isEmpty(); assertThat(rule.getSystemTags()).containsOnly("java8", "javadoc"); // verify that tags are indexed in index Set<String> tags = tester.get(RuleService.class).listTags(); assertThat(tags).containsOnly("java8", "javadoc"); }
@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(); }
@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 remove_end_user_tags_that_are_declared_as_system() { verifyRulesInDb(); Rule rule = index.getByKey(RuleTesting.XOO_X1); assertThat(rule.systemTags()).contains("tag1"); assertThat(rule.tags()).isEmpty(); // Add a user tag tester .get(RuleUpdater.class) .update( RuleUpdate.createForPluginRule(rule.key()).setTags(newHashSet("user-tag")), UserSession.get()); dbSession.clearCache(); // Verify tags Rule ruleUpdated = index.getByKey(RuleTesting.XOO_X1); assertThat(ruleUpdated.systemTags()).contains("tag1"); assertThat(ruleUpdated.tags()).contains("user-tag"); // The plugin X1 will be updated rulesDefinition.includeX1 = false; rulesDefinition.includeX1bis = true; tester.get(Platform.class).executeStartupTasks(); dbSession.clearCache(); // User tag should become a system tag RuleDto ruleDtoReloaded = db.ruleDao().getByKey(dbSession, RuleTesting.XOO_X1); assertThat(ruleDtoReloaded.getSystemTags()).contains("tag1", "tag2", "user-tag"); assertThat(ruleDtoReloaded.getTags()).isEmpty(); // User tag should become a system tag Rule ruleReloaded = index.getByKey(RuleTesting.XOO_X1); assertThat(ruleReloaded.systemTags()).contains("tag1", "tag2", "user-tag"); assertThat(ruleReloaded.tags()).isEmpty(); }