@Test
public void delete_characteristic() {
DbSession batchSession = mock(DbSession.class);
when(dbClient.openSession(true)).thenReturn(batchSession);
when(ruleDao.findRulesByDebtSubCharacteristicId(batchSession, subCharacteristicDto.getId()))
.thenReturn(
newArrayList(
new RuleDto()
.setSubCharacteristicId(subCharacteristicDto.getId())
.setRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.toString())
.setRemediationCoefficient("2h")
.setRemediationOffset("5min")));
when(dao.selectCharacteristicsByParentId(1, batchSession))
.thenReturn(newArrayList(subCharacteristicDto));
when(dao.selectById(1, batchSession)).thenReturn(characteristicDto);
service.delete(1);
verify(ruleDao).update(eq(batchSession), ruleCaptor.capture());
verify(dao, times(2)).update(characteristicCaptor.capture(), eq(batchSession));
CharacteristicDto subCharacteristicDto = characteristicCaptor.getAllValues().get(0);
CharacteristicDto characteristicDto = characteristicCaptor.getAllValues().get(1);
// Sub characteristic is disable
assertThat(subCharacteristicDto.getId()).isEqualTo(2);
assertThat(subCharacteristicDto.isEnabled()).isFalse();
assertThat(subCharacteristicDto.getUpdatedAt()).isEqualTo(now);
// Characteristic is disable
assertThat(characteristicDto.getId()).isEqualTo(1);
assertThat(characteristicDto.isEnabled()).isFalse();
assertThat(characteristicDto.getUpdatedAt()).isEqualTo(now);
}
@Test
public void delete_sub_characteristic() {
DbSession batchSession = mock(DbSession.class);
when(dbClient.openSession(true)).thenReturn(batchSession);
when(ruleDao.findRulesByDebtSubCharacteristicId(batchSession, 2))
.thenReturn(
newArrayList(
new RuleDto()
.setSubCharacteristicId(2)
.setRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.toString())
.setRemediationCoefficient("2h")
.setRemediationOffset("5min")
.setDefaultSubCharacteristicId(10)
.setDefaultRemediationFunction(
DebtRemediationFunction.Type.LINEAR_OFFSET.toString())
.setDefaultRemediationCoefficient("4h")
.setDefaultRemediationOffset("15min")));
when(dao.selectById(2, batchSession)).thenReturn(subCharacteristicDto);
service.delete(2);
verify(ruleDao).update(eq(batchSession), ruleCaptor.capture());
RuleDto ruleDto = ruleCaptor.getValue();
assertThat(ruleDto.getUpdatedAt()).isEqualTo(now);
// Overridden debt data are disabled
assertThat(ruleDto.getSubCharacteristicId()).isEqualTo(-1);
assertThat(ruleDto.getRemediationFunction()).isNull();
assertThat(ruleDto.getRemediationCoefficient()).isNull();
assertThat(ruleDto.getRemediationOffset()).isNull();
// Default debt data should not be touched
assertThat(ruleDto.getDefaultSubCharacteristicId()).isEqualTo(10);
assertThat(ruleDto.getDefaultRemediationFunction()).isEqualTo("LINEAR_OFFSET");
assertThat(ruleDto.getDefaultRemediationCoefficient()).isEqualTo("4h");
assertThat(ruleDto.getDefaultRemediationOffset()).isEqualTo("15min");
verify(dao).update(characteristicCaptor.capture(), eq(batchSession));
CharacteristicDto characteristicDto = characteristicCaptor.getValue();
// Sub characteristic is disable
assertThat(characteristicDto.getId()).isEqualTo(2);
assertThat(characteristicDto.isEnabled()).isFalse();
assertThat(characteristicDto.getUpdatedAt()).isEqualTo(now);
}
@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_model_on_custom_rules() {
when(characteristicsXMLImporter.importXML(any(Reader.class)))
.thenReturn(
new DebtModel()
.addRootCharacteristic(
new DefaultDebtCharacteristic()
.setKey("PORTABILITY")
.setName("Portability")
.setOrder(1))
.addSubCharacteristic(
new DefaultDebtCharacteristic().setKey("COMPILER").setName("Compiler"),
"PORTABILITY"));
when(dao.selectEnabledCharacteristics(session))
.thenReturn(
newArrayList(
new CharacteristicDto()
.setId(1)
.setKey("PORTABILITY")
.setName("Portability updated")
.setOrder(2)
.setCreatedAt(oldDate),
new CharacteristicDto()
.setId(2)
.setKey("COMPILER")
.setName("Compiler updated")
.setParentId(1)
.setCreatedAt(oldDate)));
when(ruleDao.selectEnabledAndNonManual(session))
.thenReturn(
newArrayList(
// Template rule
new RuleDto()
.setId(5)
.setRepositoryKey("squid")
.setRuleKey("XPath")
.setSubCharacteristicId(2)
.setRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.toString())
.setRemediationCoefficient("2h")
.setRemediationOffset("15min"),
// Custom rule
new RuleDto()
.setId(6)
.setRepositoryKey("squid")
.setRuleKey("XPath_1369910135")
.setTemplateId(5)
.setSubCharacteristicId(2)
.setRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.toString())
.setRemediationCoefficient("2h")
.setRemediationOffset("15min")));
RulesDefinition.Context context = new RulesDefinition.Context();
// Template rule
RulesDefinition.NewRepository repo = context.createRepository("squid", "java").setName("XPath");
RulesDefinition.NewRule newRule =
repo.createRule("XPath")
.setName("XPath")
.setHtmlDescription("XPath")
.setSeverity(Severity.BLOCKER)
.setStatus(RuleStatus.BETA)
.setDebtSubCharacteristic("COMPILER");
newRule.setDebtRemediationFunction(
newRule.debtRemediationFunctions().linearWithOffset("4h", "20min"));
repo.done();
when(defLoader.load()).thenReturn(context);
debtModelBackup.reset();
verify(ruleDao).selectEnabledAndNonManual(session);
verify(ruleDao, times(2)).update(eq(session), ruleCaptor.capture());
verifyNoMoreInteractions(ruleDao);
verify(session).commit();
RuleDto rule = ruleCaptor.getAllValues().get(1);
assertThat(rule.getId()).isEqualTo(6);
assertThat(rule.getDefaultSubCharacteristicId()).isEqualTo(2);
assertThat(rule.getDefaultRemediationFunction()).isEqualTo("LINEAR_OFFSET");
assertThat(rule.getDefaultRemediationCoefficient()).isEqualTo("4h");
assertThat(rule.getDefaultRemediationOffset()).isEqualTo("20min");
assertThat(rule.getUpdatedAt()).isEqualTo(now);
assertThat(rule.getSubCharacteristicId()).isNull();
assertThat(rule.getRemediationFunction()).isNull();
assertThat(rule.getRemediationCoefficient()).isNull();
assertThat(rule.getRemediationOffset()).isNull();
assertThat(rule.getUpdatedAt()).isEqualTo(now);
}
@Test
public void reset_model_when_no_default_value() {
when(characteristicsXMLImporter.importXML(any(Reader.class)))
.thenReturn(
new DebtModel()
.addRootCharacteristic(
new DefaultDebtCharacteristic()
.setKey("PORTABILITY")
.setName("Portability")
.setOrder(1))
.addSubCharacteristic(
new DefaultDebtCharacteristic().setKey("COMPILER").setName("Compiler"),
"PORTABILITY"));
when(dao.selectEnabledCharacteristics(session))
.thenReturn(
newArrayList(
new CharacteristicDto()
.setId(1)
.setKey("PORTABILITY")
.setName("Portability updated")
.setOrder(2)
.setCreatedAt(oldDate),
new CharacteristicDto()
.setId(2)
.setKey("COMPILER")
.setName("Compiler updated")
.setParentId(1)
.setCreatedAt(oldDate)));
when(ruleDao.selectEnabledAndNonManual(session))
.thenReturn(
newArrayList(
new RuleDto()
.setRepositoryKey("squid")
.setRuleKey("NPE")
.setDefaultSubCharacteristicId(10)
.setDefaultRemediationFunction(DebtRemediationFunction.Type.LINEAR.toString())
.setDefaultRemediationCoefficient("2h")
.setSubCharacteristicId(2)
.setRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.toString())
.setRemediationCoefficient("2h")
.setRemediationOffset("15min")));
RulesDefinition.Context context = new RulesDefinition.Context();
RulesDefinition.NewRepository repo = context.createRepository("squid", "java").setName("Squid");
repo.createRule("NPE")
.setName("Detect NPE")
.setHtmlDescription("Detect <code>java.lang.NullPointerException</code>")
.setSeverity(Severity.BLOCKER)
.setStatus(RuleStatus.BETA);
repo.done();
when(defLoader.load()).thenReturn(context);
debtModelBackup.reset();
verify(dao).selectEnabledCharacteristics(session);
verify(dao, times(2)).update(any(CharacteristicDto.class), eq(session));
verifyNoMoreInteractions(dao);
verify(ruleDao).selectEnabledAndNonManual(session);
verify(ruleDao).update(eq(session), ruleCaptor.capture());
verifyNoMoreInteractions(ruleDao);
verify(session).commit();
RuleDto rule = ruleCaptor.getValue();
assertThat(rule.getDefaultSubCharacteristicId()).isNull();
assertThat(rule.getDefaultRemediationFunction()).isNull();
assertThat(rule.getDefaultRemediationCoefficient()).isNull();
assertThat(rule.getDefaultRemediationOffset()).isNull();
assertThat(rule.getUpdatedAt()).isEqualTo(now);
}
@Test
public void backup() {
when(dao.selectEnabledCharacteristics(session))
.thenReturn(
newArrayList(
new CharacteristicDto()
.setId(1)
.setKey("PORTABILITY")
.setName("Portability updated")
.setOrder(2),
new CharacteristicDto()
.setId(2)
.setKey("COMPILER")
.setName("Compiler updated")
.setParentId(1)));
when(ruleDao.selectEnabledAndNonManual(session))
.thenReturn(
newArrayList(
// Rule with overridden debt values
new RuleDto()
.setRepositoryKey("squid")
.setRuleKey("UselessImportCheck")
.setSubCharacteristicId(2)
.setRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.toString())
.setRemediationCoefficient("2h")
.setRemediationOffset("15min"),
// Rule with default debt values
new RuleDto()
.setRepositoryKey("squid")
.setRuleKey("AvoidNPE")
.setDefaultSubCharacteristicId(2)
.setDefaultRemediationFunction("LINEAR")
.setDefaultRemediationCoefficient("2h")));
debtModelBackup.backup();
ArgumentCaptor<DebtModel> debtModelArgument = ArgumentCaptor.forClass(DebtModel.class);
verify(debtModelXMLExporter).export(debtModelArgument.capture(), ruleDebtListCaptor.capture());
assertThat(debtModelArgument.getValue().rootCharacteristics()).hasSize(1);
assertThat(debtModelArgument.getValue().subCharacteristics("PORTABILITY")).hasSize(1);
List<RuleDebt> rules = ruleDebtListCaptor.getValue();
assertThat(rules).hasSize(2);
RuleDebt rule = rules.get(0);
assertThat(rule.ruleKey().repository()).isEqualTo("squid");
assertThat(rule.ruleKey().rule()).isEqualTo("UselessImportCheck");
assertThat(rule.subCharacteristicKey()).isEqualTo("COMPILER");
assertThat(rule.function()).isEqualTo("LINEAR_OFFSET");
assertThat(rule.coefficient()).isEqualTo("2h");
assertThat(rule.offset()).isEqualTo("15min");
rule = rules.get(1);
assertThat(rule.ruleKey().repository()).isEqualTo("squid");
assertThat(rule.ruleKey().rule()).isEqualTo("AvoidNPE");
assertThat(rule.subCharacteristicKey()).isEqualTo("COMPILER");
assertThat(rule.function()).isEqualTo("LINEAR");
assertThat(rule.coefficient()).isEqualTo("2h");
assertThat(rule.offset()).isNull();
}
@Test
public void restore_from_xml_and_language_with_rule_not_in_xml() {
when(characteristicsXMLImporter.importXML(anyString()))
.thenReturn(
new DebtModel()
.addRootCharacteristic(
new DefaultDebtCharacteristic()
.setKey("PORTABILITY")
.setName("Portability")
.setOrder(1))
.addSubCharacteristic(
new DefaultDebtCharacteristic().setKey("COMPILER").setName("Compiler"),
"PORTABILITY"));
when(dao.selectEnabledCharacteristics(session))
.thenReturn(
newArrayList(
new CharacteristicDto()
.setId(1)
.setKey("PORTABILITY")
.setName("Portability updated")
.setOrder(2)
.setCreatedAt(oldDate),
new CharacteristicDto()
.setId(2)
.setKey("COMPILER")
.setName("Compiler updated")
.setParentId(1)
.setCreatedAt(oldDate)));
when(rulesXMLImporter.importXML(anyString(), any(ValidationMessages.class)))
.thenReturn(Collections.<RuleDebt>emptyList());
when(ruleDao.selectEnabledAndNonManual(session))
.thenReturn(
newArrayList(
// Rule does not exits in XML -> debt will be disabled
new RuleDto()
.setId(1)
.setRepositoryKey("squid")
.setRuleKey("UselessImportCheck")
.setLanguage("java")
.setDefaultSubCharacteristicId(2)
.setDefaultRemediationFunction("LINEAR")
.setDefaultRemediationCoefficient("2h")
.setSubCharacteristicId(2)
.setRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.toString())
.setRemediationCoefficient("2h")
.setRemediationOffset("15min")));
debtModelBackup.restoreFromXml("<xml/>", "java");
verify(ruleOperations)
.updateRule(
ruleCaptor.capture(),
isNull(CharacteristicDto.class),
isNull(String.class),
isNull(String.class),
isNull(String.class),
eq(session));
verify(ruleDao).selectEnabledAndNonManual(session);
verify(session).commit();
}
