return mapper(session).selectByQuery(ruleQuery);
}
- public void insert(DbSession session, RuleDto dto) {
- RuleDefinitionDto ruleDefinitionDto = definitionOf(dto);
- mapper(session).insert(ruleDefinitionDto);
- dto.setId(ruleDefinitionDto.getId());
- // FIXME it doesn't make sense to insert metadata when creating a new rule in table RULES unless it is a custom rule
- mapper(session).updateMetadata(metadataOf(dto));
- }
-
- public void update(DbSession session, RuleDto dto) {
- mapper(session).updateDefinition(definitionOf(dto).setId(dto.getId()));
- RuleMetadataDto ruleMetadata = metadataOf(dto);
- mapper(session).updateMetadata(ruleMetadata);
- }
-
- private static RuleMetadataDto metadataOf(RuleDto dto) {
- return new RuleMetadataDto()
- .setRuleId(dto.getId())
- .setNoteData(dto.getNoteData())
- .setNoteUserLogin(dto.getNoteUserLogin())
- .setNoteCreatedAt(dto.getNoteCreatedAt())
- .setNoteUpdatedAt(dto.getNoteUpdatedAt())
- .setRemediationFunction(dto.getRemediationFunction())
- .setRemediationGapMultiplier(dto.getRemediationGapMultiplier())
- .setRemediationBaseEffort(dto.getRemediationBaseEffort())
- .setTags(dto.getTags())
- .setUpdatedAt(dto.getUpdatedAt());
- }
-
- private static RuleDefinitionDto definitionOf(RuleDto dto) {
- return new RuleDefinitionDto()
- .setRepositoryKey(dto.getRepositoryKey())
- .setRuleKey(dto.getRuleKey())
- .setDescription(dto.getDescription())
- .setDescriptionFormat(dto.getDescriptionFormat())
- .setStatus(dto.getStatus())
- .setName(dto.getName())
- .setConfigKey(dto.getConfigKey())
- .setSeverity(dto.getSeverity())
- .setIsTemplate(dto.isTemplate())
- .setLanguage(dto.getLanguage())
- .setTemplateId(dto.getTemplateId())
- .setDefaultRemediationFunction(dto.getDefaultRemediationFunction())
- .setDefaultRemediationGapMultiplier(dto.getDefaultRemediationGapMultiplier())
- .setDefaultRemediationBaseEffort(dto.getDefaultRemediationBaseEffort())
- .setGapDescription(dto.getGapDescription())
- .setSystemTags(dto.getSystemTags())
- .setType(dto.getType())
- .setCreatedAt(dto.getCreatedAt())
- .setUpdatedAt(dto.getUpdatedAt());
+ public void insert(DbSession session, RuleDefinitionDto dto) {
+ mapper(session).insert(dto);
+ }
+
+ public void update(DbSession session, RuleDefinitionDto dto) {
+ mapper(session).updateDefinition(dto);
+ }
+
+ public void update(DbSession session, RuleMetadataDto dto) {
+ mapper(session).updateMetadata(dto);
}
private static RuleMapper mapper(DbSession session) {
return executeLargeInputs(ruleIds, mapper(dbSession)::selectParamsByRuleIds);
}
- public void insertRuleParam(DbSession session, RuleDto rule, RuleParamDto param) {
+ public void insertRuleParam(DbSession session, RuleDefinitionDto rule, RuleParamDto param) {
checkNotNull(rule.getId(), "Rule id must be set");
param.setRuleId(rule.getId());
mapper(session).insertParameter(param);
}
- public RuleParamDto updateRuleParam(DbSession session, RuleDto rule, RuleParamDto param) {
+ public RuleParamDto updateRuleParam(DbSession session, RuleDefinitionDto rule, RuleParamDto param) {
checkNotNull(rule.getId(), "Rule id must be set");
checkNotNull(param.getId(), "Rule parameter is not yet persisted must be set");
param.setRuleId(rule.getId());
public RuleDto setUpdatedAt(long updatedAt) {
definition.setUpdatedAt(updatedAt);
+ metadata.setUpdatedAt(updatedAt);
return this;
}
return new ReflectionToStringBuilder(this, ToStringStyle.SHORT_PREFIX_STYLE).toString();
}
- public static RuleParamDto createFor(RuleDto rule) {
+ public static RuleParamDto createFor(RuleDefinitionDto rule) {
// Should eventually switch to RuleKey (RuleKey is available before insert)
return new RuleParamDto().setRuleId(rule.getId());
}
}
private void prepareTables() {
- dbTester.getDbClient().ruleDao().insert(dbTester.getSession(), RULE);
+ dbTester.rules().insertRule(RULE);
OrganizationDto organizationDto = dbTester.organizations().insert();
ComponentDto projectDto = dbTester.components().insertProject(organizationDto, (t) -> t.setUuid(PROJECT_UUID).setKey(PROJECT_KEY));
dbTester.components().insertComponent(ComponentTesting.newFileDto(projectDto).setUuid(FILE_UUID).setKey(FILE_KEY));
file2 = ComponentTesting.newFileDto(project, null).setUuid("file2 uuid");
dbTester.getDbClient().componentDao().insert(dbSession, file2);
rule = RuleTesting.newXooX1();
- dbTester.getDbClient().ruleDao().insert(dbSession, rule);
+ dbTester.rules().insertRule(rule);
dbSession.commit();
}
dbClient.qualityProfileDao().insert(dbSession, profile1);
dbClient.qualityProfileDao().insert(dbSession, profile2);
- dbClient.ruleDao().insert(dbSession, rule1);
- dbClient.ruleDao().insert(dbSession, rule2);
- dbClient.ruleDao().insert(dbSession, rule3);
+ dbTester.rules().insertRule(rule1);
+ dbTester.rules().insertRule(rule2);
+ dbTester.rules().insertRule(rule3);
rule1Param1 = new RuleParamDto()
.setName("param1")
.setDefaultValue("value1")
.setType(RuleParamType.STRING.toString());
- dbClient.ruleDao().insertRuleParam(dbSession, rule1, rule1Param1);
+ dbClient.ruleDao().insertRuleParam(dbSession, rule1.getDefinition(), rule1Param1);
rule1Param2 = new RuleParamDto()
.setRuleId(rule1.getId())
.setName("param2")
.setDefaultValue("2")
.setType(RuleParamType.INTEGER.toString());
- dbClient.ruleDao().insertRuleParam(dbSession, rule1, rule1Param2);
+ dbClient.ruleDao().insertRuleParam(dbSession, rule1.getDefinition(), rule1Param2);
rule2Param1 = new RuleParamDto()
.setRuleId(rule2.getId())
.setName("param1")
.setDefaultValue("1")
.setType(RuleParamType.INTEGER.toString());
- dbClient.ruleDao().insertRuleParam(dbSession, rule2, rule2Param1);
+ dbClient.ruleDao().insertRuleParam(dbSession, rule2.getDefinition(), rule2Param1);
dbSession.commit();
}
@Test
public void select_by_profile_ignore_removed_rules() {
RuleDto removedRule = RuleTesting.newDto(RuleKey.of("removed", "rule")).setStatus(RuleStatus.REMOVED);
- dbClient.ruleDao().insert(dbTester.getSession(), removedRule);
+ dbTester.rules().insertRule(removedRule);
ActiveRuleDto activeRule = createFor(profile1, removedRule).setSeverity(BLOCKER);
underTest.insert(dbTester.getSession(), activeRule);
dbSession.commit();
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.guava.api.Assertions.assertThat;
-
public class RuleDaoTest {
@Rule
dbTester.prepareDbUnit(getClass(), "shared.xml");
assertThat(underTest.selectByIds(dbTester.getSession(), asList(1))).hasSize(1);
- assertThat(underTest.selectByIds(dbTester.getSession(), asList(1,2))).hasSize(2);
- assertThat(underTest.selectByIds(dbTester.getSession(), asList(1,2,3))).hasSize(2);
+ assertThat(underTest.selectByIds(dbTester.getSession(), asList(1, 2))).hasSize(2);
+ assertThat(underTest.selectByIds(dbTester.getSession(), asList(1, 2, 3))).hasSize(2);
assertThat(underTest.selectByIds(dbTester.getSession(), asList(123))).isEmpty();
}
@Test
public void insert() throws Exception {
- RuleDto newRule = new RuleDto()
+ RuleDefinitionDto newRule = new RuleDefinitionDto()
.setRuleKey("NewRuleKey")
.setRepositoryKey("plugin")
.setName("new name")
.setIsTemplate(true)
.setLanguage("dart")
.setTemplateId(3)
- .setNoteData("My note")
- .setNoteUserLogin("admin")
- .setNoteCreatedAt(DateUtils.parseDate("2013-12-19"))
- .setNoteUpdatedAt(DateUtils.parseDate("2013-12-20"))
- .setRemediationFunction(DebtRemediationFunction.Type.LINEAR.toString())
.setDefaultRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.toString())
- .setRemediationGapMultiplier("1h")
.setDefaultRemediationGapMultiplier("5d")
- .setRemediationBaseEffort("5min")
.setDefaultRemediationBaseEffort("10h")
.setGapDescription("squid.S115.effortToFix")
- .setTags(newHashSet("tag1", "tag2"))
.setSystemTags(newHashSet("systag1", "systag2"))
.setType(RuleType.BUG)
.setCreatedAt(1500000000000L)
assertThat(ruleDto.getLanguage()).isEqualTo("dart");
assertThat(ruleDto.isTemplate()).isTrue();
assertThat(ruleDto.getTemplateId()).isEqualTo(3);
- assertThat(ruleDto.getNoteData()).isEqualTo("My note");
- assertThat(ruleDto.getNoteUserLogin()).isEqualTo("admin");
- assertThat(ruleDto.getNoteCreatedAt()).isNotNull();
- assertThat(ruleDto.getNoteUpdatedAt()).isNotNull();
- assertThat(ruleDto.getRemediationFunction()).isEqualTo("LINEAR");
+ assertThat(ruleDto.getNoteData()).isNull();
+ assertThat(ruleDto.getNoteUserLogin()).isNull();
+ assertThat(ruleDto.getNoteCreatedAt()).isNull();
+ assertThat(ruleDto.getNoteUpdatedAt()).isNull();
+ assertThat(ruleDto.getRemediationFunction()).isNull();
assertThat(ruleDto.getDefaultRemediationFunction()).isEqualTo("LINEAR_OFFSET");
- assertThat(ruleDto.getRemediationGapMultiplier()).isEqualTo("1h");
+ assertThat(ruleDto.getRemediationGapMultiplier()).isNull();
assertThat(ruleDto.getDefaultRemediationGapMultiplier()).isEqualTo("5d");
- assertThat(ruleDto.getRemediationBaseEffort()).isEqualTo("5min");
+ assertThat(ruleDto.getRemediationBaseEffort()).isNull();
assertThat(ruleDto.getDefaultRemediationBaseEffort()).isEqualTo("10h");
assertThat(ruleDto.getGapDescription()).isEqualTo("squid.S115.effortToFix");
- assertThat(ruleDto.getTags()).containsOnly("tag1", "tag2");
+ assertThat(ruleDto.getTags()).isEmpty();
assertThat(ruleDto.getSystemTags()).containsOnly("systag1", "systag2");
assertThat(ruleDto.getType()).isEqualTo(RuleType.BUG.getDbConstant());
assertThat(ruleDto.getCreatedAt()).isEqualTo(1500000000000L);
}
@Test
- public void update() {
+ public void update_RuleDefinitionDto() {
dbTester.prepareDbUnit(getClass(), "update.xml");
- RuleDto ruleToUpdate = new RuleDto()
+ RuleDefinitionDto ruleToUpdate = new RuleDefinitionDto()
.setId(1)
.setRuleKey("NewRuleKey")
.setRepositoryKey("plugin")
.setIsTemplate(true)
.setLanguage("dart")
.setTemplateId(3)
- .setNoteData("My note")
- .setNoteUserLogin("admin")
- .setNoteCreatedAt(DateUtils.parseDate("2013-12-19"))
- .setNoteUpdatedAt(DateUtils.parseDate("2013-12-20"))
- .setRemediationFunction(DebtRemediationFunction.Type.LINEAR.toString())
.setDefaultRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.toString())
- .setRemediationGapMultiplier("1h")
.setDefaultRemediationGapMultiplier("5d")
- .setRemediationBaseEffort("5min")
.setDefaultRemediationBaseEffort("10h")
.setGapDescription("squid.S115.effortToFix")
- .setTags(newHashSet("tag1", "tag2"))
.setSystemTags(newHashSet("systag1", "systag2"))
.setType(RuleType.BUG)
.setUpdatedAt(2000000000000L);
assertThat(ruleDto.getLanguage()).isEqualTo("dart");
assertThat(ruleDto.isTemplate()).isTrue();
assertThat(ruleDto.getTemplateId()).isEqualTo(3);
+ assertThat(ruleDto.getNoteData()).isNull();
+ assertThat(ruleDto.getNoteUserLogin()).isNull();
+ assertThat(ruleDto.getNoteCreatedAt()).isNull();
+ assertThat(ruleDto.getNoteUpdatedAt()).isNull();
+ assertThat(ruleDto.getRemediationFunction()).isNull();
+ assertThat(ruleDto.getDefaultRemediationFunction()).isEqualTo("LINEAR_OFFSET");
+ assertThat(ruleDto.getRemediationGapMultiplier()).isNull();
+ assertThat(ruleDto.getDefaultRemediationGapMultiplier()).isEqualTo("5d");
+ assertThat(ruleDto.getRemediationBaseEffort()).isNull();
+ assertThat(ruleDto.getDefaultRemediationBaseEffort()).isEqualTo("10h");
+ assertThat(ruleDto.getGapDescription()).isEqualTo("squid.S115.effortToFix");
+ assertThat(ruleDto.getTags()).isEmpty();
+ assertThat(ruleDto.getSystemTags()).containsOnly("systag1", "systag2");
+ assertThat(ruleDto.getType()).isEqualTo(RuleType.BUG.getDbConstant());
+ assertThat(ruleDto.getCreatedAt()).isEqualTo(1500000000000L);
+ assertThat(ruleDto.getUpdatedAt()).isEqualTo(2000000000000L);
+ }
+
+ @Test
+ public void update_RuleMetadataDto() {
+ dbTester.prepareDbUnit(getClass(), "update.xml");
+
+ RuleMetadataDto ruleToUpdate = new RuleMetadataDto()
+ .setRuleId(1)
+ .setNoteData("My note")
+ .setNoteUserLogin("admin")
+ .setNoteCreatedAt(DateUtils.parseDate("2013-12-19"))
+ .setNoteUpdatedAt(DateUtils.parseDate("2013-12-20"))
+ .setRemediationFunction(DebtRemediationFunction.Type.LINEAR.toString())
+ .setRemediationGapMultiplier("1h")
+ .setRemediationBaseEffort("5min")
+ .setTags(newHashSet("tag1", "tag2"))
+ .setUpdatedAt(2000000000000L);
+
+ underTest.update(dbTester.getSession(), ruleToUpdate);
+ dbTester.getSession().commit();
+
+ RuleDto ruleDto = underTest.selectOrFailByKey(dbTester.getSession(), RuleKey.of("checkstyle", "AvoidNull"));
+ assertThat(ruleDto.getName()).isEqualTo("Avoid Null");
+ assertThat(ruleDto.getDescription()).isEqualTo("Should avoid NULL");
+ assertThat(ruleDto.getDescriptionFormat()).isNull();
+ assertThat(ruleDto.getStatus()).isEqualTo(RuleStatus.READY);
+ assertThat(ruleDto.getRuleKey()).isEqualTo("AvoidNull");
+ assertThat(ruleDto.getRepositoryKey()).isEqualTo("checkstyle");
+ assertThat(ruleDto.getConfigKey()).isEqualTo("AvoidNull");
+ assertThat(ruleDto.getSeverity()).isEqualTo(2);
+ assertThat(ruleDto.getLanguage()).isEqualTo("golo");
+ assertThat(ruleDto.isTemplate()).isFalse();
+ assertThat(ruleDto.getTemplateId()).isNull();
assertThat(ruleDto.getNoteData()).isEqualTo("My note");
assertThat(ruleDto.getNoteUserLogin()).isEqualTo("admin");
assertThat(ruleDto.getNoteCreatedAt()).isNotNull();
assertThat(ruleDto.getNoteUpdatedAt()).isNotNull();
assertThat(ruleDto.getRemediationFunction()).isEqualTo("LINEAR");
- assertThat(ruleDto.getDefaultRemediationFunction()).isEqualTo("LINEAR_OFFSET");
+ assertThat(ruleDto.getDefaultRemediationFunction()).isNull();
assertThat(ruleDto.getRemediationGapMultiplier()).isEqualTo("1h");
- assertThat(ruleDto.getDefaultRemediationGapMultiplier()).isEqualTo("5d");
+ assertThat(ruleDto.getDefaultRemediationGapMultiplier()).isNull();
assertThat(ruleDto.getRemediationBaseEffort()).isEqualTo("5min");
- assertThat(ruleDto.getDefaultRemediationBaseEffort()).isEqualTo("10h");
- assertThat(ruleDto.getGapDescription()).isEqualTo("squid.S115.effortToFix");
+ assertThat(ruleDto.getDefaultRemediationBaseEffort()).isNull();
+ assertThat(ruleDto.getGapDescription()).isNull();
assertThat(ruleDto.getTags()).containsOnly("tag1", "tag2");
- assertThat(ruleDto.getSystemTags()).containsOnly("systag1", "systag2");
- assertThat(ruleDto.getType()).isEqualTo(RuleType.BUG.getDbConstant());
+ assertThat(ruleDto.getSystemTags()).isEmpty();
+ assertThat(ruleDto.getType()).isEqualTo(0);
assertThat(ruleDto.getCreatedAt()).isEqualTo(1500000000000L);
assertThat(ruleDto.getUpdatedAt()).isEqualTo(2000000000000L);
}
dbTester.prepareDbUnit(getClass(), "select_parameters_by_rule_key.xml");
assertThat(underTest.selectRuleParamsByRuleKeys(dbTester.getSession(),
- Arrays.asList(RuleKey.of("checkstyle", "AvoidNull"), RuleKey.of("unused", "Unused"))
- )).hasSize(2);
+ Arrays.asList(RuleKey.of("checkstyle", "AvoidNull"), RuleKey.of("unused", "Unused")))).hasSize(2);
assertThat(underTest.selectRuleParamsByRuleKeys(dbTester.getSession(),
- singletonList(RuleKey.of("unknown", "Unknown"))
- )).isEmpty();
+ singletonList(RuleKey.of("unknown", "Unknown")))).isEmpty();
}
@Test
public void insert_parameter() {
dbTester.prepareDbUnit(getClass(), "insert_parameter.xml");
- RuleDto rule1 = underTest.selectOrFailByKey(dbTester.getSession(), RuleKey.of("plugin", "NewRuleKey"));
+ RuleDefinitionDto rule1 = underTest.selectOrFailByKey(dbTester.getSession(), RuleKey.of("plugin", "NewRuleKey"))
+ .getDefinition();
RuleParamDto param = RuleParamDto.createFor(rule1)
.setName("max")
public void update_parameter() {
dbTester.prepareDbUnit(getClass(), "update_parameter.xml");
- RuleDto rule1 = underTest.selectOrFailByKey(dbTester.getSession(), RuleKey.of("checkstyle", "AvoidNull"));
+ RuleDefinitionDto rule1 = underTest.selectOrFailByKey(dbTester.getSession(), RuleKey.of("checkstyle", "AvoidNull"))
+ .getDefinition();
List<RuleParamDto> params = underTest.selectRuleParamsByRuleKey(dbTester.getSession(), rule1.getKey());
assertThat(params).hasSize(1);
import org.apache.commons.lang.RandomStringUtils;
import org.sonar.api.server.rule.RuleParamType;
import org.sonar.db.DbTester;
+import org.sonar.db.organization.OrganizationDto;
import static org.sonar.db.rule.RuleTesting.newRuleDto;
}
public RuleDto insertRule(RuleDto ruleDto) {
- db.getDbClient().ruleDao().insert(db.getSession(), ruleDto);
+ RuleDao ruleDao = db.getDbClient().ruleDao();
+ ruleDao.insert(db.getSession(), ruleDto.getDefinition());
db.commit();
+ RuleMetadataDto metadata = ruleDto.getMetadata();
+ if (metadata.getOrganizationUuid() != null) {
+ ruleDao.update(db.getSession(), metadata.setRuleId(ruleDto.getId()));
+ db.commit();
+ }
return ruleDto;
}
});
}
+ public RuleDto insertRule(OrganizationDto organization, Consumer<RuleDto> populateRuleDto) {
+ RuleDto ruleDto = newRuleDto(organization);
+ populateRuleDto.accept(ruleDto);
+ return insertRule(ruleDto);
+ }
+
public RuleDto insertRule(Consumer<RuleDto> populateRuleDto) {
RuleDto ruleDto = newRuleDto();
populateRuleDto.accept(ruleDto);
- db.getDbClient().ruleDao().insert(db.getSession(), ruleDto);
- db.commit();
- return ruleDto;
+ return insertRule(ruleDto);
}
public RuleParamDto insertRuleParam(RuleDto rule) {
param.setRuleId(rule.getId());
param.setName(RandomStringUtils.random(10));
param.setType(RuleParamType.STRING.type());
- db.getDbClient().ruleDao().insertRuleParam(db.getSession(), rule, param);
+ db.getDbClient().ruleDao().insertRuleParam(db.getSession(), rule.getDefinition(), param);
db.commit();
return param;
}
return newDto(RuleKey.of(randomAlphanumeric(30), randomAlphanumeric(30)));
}
+
+ public static RuleDto newRuleDto(OrganizationDto organization) {
+ return newDto(RuleKey.of(randomAlphanumeric(30), randomAlphanumeric(30)), organization);
+ }
+
/**
* Creates a new rule to be used as a template for a custom rule.
*/
import com.google.common.base.Function;
import com.google.common.base.Optional;
-import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterables;
import com.google.common.collect.Maps;
import java.util.ArrayList;
import org.sonar.db.DbSession;
import org.sonar.db.qualityprofile.ActiveRuleDto;
import org.sonar.db.qualityprofile.ActiveRuleParamDto;
+import org.sonar.db.rule.RuleDefinitionDto;
import org.sonar.db.rule.RuleDto;
import org.sonar.db.rule.RuleDto.Format;
+import org.sonar.db.rule.RuleMetadataDto;
import org.sonar.db.rule.RuleParamDto;
import org.sonar.db.rule.RuleRepositoryDto;
import org.sonar.server.qualityprofile.ActiveRuleChange;
import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.collect.Lists.newArrayList;
-import static com.google.common.collect.Sets.intersection;
/**
* Register rules at server startup
private void registerRule(RulesDefinition.Rule ruleDef, Map<RuleKey, RuleDto> allRules, DbSession session) {
RuleKey ruleKey = RuleKey.of(ruleDef.repository().key(), ruleDef.key());
- RuleDto rule = allRules.containsKey(ruleKey) ? allRules.remove(ruleKey) : createRuleDto(ruleDef, session);
+ RuleDto existingRule = allRules.remove(ruleKey);
+ RuleDefinitionDto rule = existingRule == null ? createRuleDto(ruleDef, session) : existingRule.getDefinition();
boolean executeUpdate = false;
if (mergeRule(ruleDef, rule)) {
return repositories;
}
- private RuleDto createRuleDto(RulesDefinition.Rule ruleDef, DbSession session) {
- RuleDto ruleDto = RuleDto.createFor(RuleKey.of(ruleDef.repository().key(), ruleDef.key()))
+ private RuleDefinitionDto createRuleDto(RulesDefinition.Rule ruleDef, DbSession session) {
+ RuleDefinitionDto ruleDto = new RuleDefinitionDto()
+ .setRuleKey(RuleKey.of(ruleDef.repository().key(), ruleDef.key()))
.setIsTemplate(ruleDef.template())
.setConfigKey(ruleDef.internalKey())
.setLanguage(ruleDef.repository().language())
return ruleDto;
}
- private boolean mergeRule(RulesDefinition.Rule def, RuleDto dto) {
+ private boolean mergeRule(RulesDefinition.Rule def, RuleDefinitionDto dto) {
boolean changed = false;
if (!StringUtils.equals(dto.getName(), def.name())) {
dto.setName(def.name());
return changed;
}
- private boolean mergeDescription(RulesDefinition.Rule def, RuleDto dto) {
+ private boolean mergeDescription(RulesDefinition.Rule def, RuleDefinitionDto dto) {
boolean changed = false;
if (def.htmlDescription() != null && !StringUtils.equals(dto.getDescription(), def.htmlDescription())) {
dto.setDescription(def.htmlDescription());
return changed;
}
- private boolean mergeDebtDefinitions(RulesDefinition.Rule def, RuleDto dto) {
+ private boolean mergeDebtDefinitions(RulesDefinition.Rule def, RuleDefinitionDto dto) {
// Debt definitions are set to null if the sub-characteristic and the remediation function are null
DebtRemediationFunction debtRemediationFunction = def.debtRemediationFunction();
boolean hasDebt = debtRemediationFunction != null;
return mergeDebtDefinitions(dto, null, null, null, null);
}
- private boolean mergeDebtDefinitions(RuleDto dto, @Nullable String remediationFunction,
+ private boolean mergeDebtDefinitions(RuleDefinitionDto dto, @Nullable String remediationFunction,
@Nullable String remediationCoefficient, @Nullable String remediationOffset, @Nullable String effortToFixDescription) {
boolean changed = false;
return changed;
}
- private void mergeParams(RulesDefinition.Rule ruleDef, RuleDto rule, DbSession session) {
+ private void mergeParams(RulesDefinition.Rule ruleDef, RuleDefinitionDto rule, DbSession session) {
List<RuleParamDto> paramDtos = dbClient.ruleDao().selectRuleParamsByRuleKey(session, rule.getKey());
Map<String, RuleParamDto> existingParamsByName = Maps.newHashMap();
return changed;
}
- private static boolean mergeTags(RulesDefinition.Rule ruleDef, RuleDto dto) {
+ private static boolean mergeTags(RulesDefinition.Rule ruleDef, RuleDefinitionDto dto) {
boolean changed = false;
if (RuleStatus.REMOVED == ruleDef.status()) {
- dto.setSystemTags(Collections.<String>emptySet());
+ dto.setSystemTags(Collections.emptySet());
changed = true;
} else if (dto.getSystemTags().size() != ruleDef.tags().size() ||
- !dto.getSystemTags().containsAll(ruleDef.tags())
- || !intersection(dto.getTags(), ruleDef.tags()).isEmpty()) {
+ !dto.getSystemTags().containsAll(ruleDef.tags())) {
dto.setSystemTags(ruleDef.tags());
- // remove end-user tags that are now declared as system
- RuleTagHelper.applyTags(dto, ImmutableSet.copyOf(dto.getTags()));
+ // FIXME this can't be implemented easily with organization support: remove end-user tags that are now declared as system
+ // RuleTagHelper.applyTags(dto, ImmutableSet.copyOf(dto.getTags()));
changed = true;
}
return changed;
checkNotNull(templateId, "Template id of the custom rule '%s' is null", customRule);
Optional<RuleDto> template = dbClient.ruleDao().selectById(templateId, session);
if (template.isPresent() && template.get().getStatus() != RuleStatus.REMOVED) {
- if (updateCustomRuleFromTemplateRule(customRule, template.get())) {
- update(session, customRule);
+ if (updateCustomRuleFromTemplateRule(customRule, template.get().getDefinition())) {
+ update(session, customRule.getDefinition());
}
} else {
removeRule(session, removedRules, customRule);
private void removeRule(DbSession session, List<RuleDto> removedRules, RuleDto rule) {
LOG.info(String.format("Disable rule %s", rule.getKey()));
rule.setStatus(RuleStatus.REMOVED);
- rule.setSystemTags(Collections.<String>emptySet());
- rule.setTags(Collections.<String>emptySet());
- update(session, rule);
+ rule.setSystemTags(Collections.emptySet());
+ rule.setTags(Collections.emptySet());
+ update(session, rule.getDefinition());
+ update(session, rule.getMetadata());
removedRules.add(rule);
if (removedRules.size() % 100 == 0) {
session.commit();
}
}
- private static boolean updateCustomRuleFromTemplateRule(RuleDto customRule, RuleDto templateRule) {
+ private static boolean updateCustomRuleFromTemplateRule(RuleDto customRule, RuleDefinitionDto templateRule) {
boolean changed = false;
if (!StringUtils.equals(customRule.getLanguage(), templateRule.getLanguage())) {
customRule.setLanguage(templateRule.getLanguage());
return changes;
}
- private void update(DbSession session, RuleDto rule) {
+ private void update(DbSession session, RuleDefinitionDto rule) {
+ rule.setUpdatedAt(system2.now());
+ dbClient.ruleDao().update(session, rule);
+ }
+
+ private void update(DbSession session, RuleMetadataDto rule) {
rule.setUpdatedAt(system2.now());
dbClient.ruleDao().update(session, rule);
}
import com.google.common.base.Strings;
import java.util.ArrayList;
import java.util.List;
+import java.util.Set;
import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
import org.sonar.api.rule.RuleKey;
import org.sonar.api.utils.System2;
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
+import org.sonar.db.rule.RuleDefinitionDto;
import org.sonar.db.rule.RuleDto;
import org.sonar.db.rule.RuleDto.Format;
+import org.sonar.db.rule.RuleMetadataDto;
import org.sonar.db.rule.RuleParamDto;
import org.sonar.server.exceptions.BadRequestException;
import org.sonar.server.rule.index.RuleIndexer;
Optional<RuleDto> existingRule = loadRule(customRuleKey, dbSession);
if (existingRule.isPresent()) {
- updateExistingRule(existingRule.get(), newRule, dbSession);
+ updateExistingRule(existingRule.get().getDefinition(), newRule, dbSession);
} else {
createCustomRule(customRuleKey, newRule, templateRule, dbSession);
}
}
private RuleKey createCustomRule(RuleKey ruleKey, NewCustomRule newRule, RuleDto templateRuleDto, DbSession dbSession) {
- RuleDto ruleDto = RuleDto.createFor(ruleKey)
+ RuleDefinitionDto ruleDefinition = new RuleDefinitionDto()
+ .setRuleKey(ruleKey)
.setTemplateId(templateRuleDto.getId())
.setConfigKey(templateRuleDto.getConfigKey())
.setName(newRule.name())
.setDefaultRemediationGapMultiplier(templateRuleDto.getDefaultRemediationGapMultiplier())
.setDefaultRemediationBaseEffort(templateRuleDto.getDefaultRemediationBaseEffort())
.setGapDescription(templateRuleDto.getGapDescription())
- .setTags(templateRuleDto.getTags())
.setSystemTags(templateRuleDto.getSystemTags())
.setType(templateRuleDto.getType())
.setCreatedAt(system2.now())
.setUpdatedAt(system2.now());
- dbClient.ruleDao().insert(dbSession, ruleDto);
+ dbClient.ruleDao().insert(dbSession, ruleDefinition);
+ Set<String> tags = templateRuleDto.getTags();
+ if (!tags.isEmpty()) {
+ RuleMetadataDto ruleMetadata = new RuleMetadataDto()
+ .setRuleId(ruleDefinition.getId())
+ .setTags(tags)
+ .setUpdatedAt(system2.now());
+ dbClient.ruleDao().update(dbSession, ruleMetadata);
+ }
for (RuleParamDto templateRuleParamDto : dbClient.ruleDao().selectRuleParamsByRuleKey(dbSession, templateRuleDto.getKey())) {
String customRuleParamValue = Strings.emptyToNull(newRule.parameter(templateRuleParamDto.getName()));
- createCustomRuleParams(customRuleParamValue, ruleDto, templateRuleParamDto, dbSession);
+ createCustomRuleParams(customRuleParamValue, ruleDefinition, templateRuleParamDto, dbSession);
}
return ruleKey;
}
- private void createCustomRuleParams(@Nullable String paramValue, RuleDto ruleDto, RuleParamDto templateRuleParam, DbSession dbSession) {
+ private void createCustomRuleParams(@Nullable String paramValue, RuleDefinitionDto ruleDto, RuleParamDto templateRuleParam, DbSession dbSession) {
RuleParamDto ruleParamDto = RuleParamDto.createFor(ruleDto)
.setName(templateRuleParam.getName())
.setType(templateRuleParam.getType())
dbClient.ruleDao().insertRuleParam(dbSession, ruleDto, ruleParamDto);
}
- private void updateExistingRule(RuleDto ruleDto, NewCustomRule newRule, DbSession dbSession) {
+ private void updateExistingRule(RuleDefinitionDto ruleDto, NewCustomRule newRule, DbSession dbSession) {
if (ruleDto.getStatus().equals(RuleStatus.REMOVED)) {
if (newRule.isPreventReactivation()) {
throw new ReactivationException(format("A removed rule with the key '%s' already exists", ruleDto.getKey().rule()), ruleDto.getKey());
rule.setStatus(RuleStatus.REMOVED);
rule.setUpdatedAt(system2.now());
- dbClient.ruleDao().update(dbSession, rule);
+ dbClient.ruleDao().update(dbSession, rule.getDefinition());
+ dbClient.ruleDao().update(dbSession, rule.getMetadata());
dbSession.commit();
ruleIndexer.index();
// Update rule param
ruleParamDto.setDefaultValue(value);
- dbClient.ruleDao().updateRuleParam(dbSession, customRule, ruleParamDto);
+ dbClient.ruleDao().updateRuleParam(dbSession, customRule.getDefinition(), ruleParamDto);
if (value != null) {
// Update linked active rule params or create new one
private void update(DbSession session, RuleDto rule) {
rule.setUpdatedAt(system.now());
- dbClient.ruleDao().update(session, rule);
+ dbClient.ruleDao().update(session, rule.getDefinition());
+ dbClient.ruleDao().update(session, rule.getMetadata());
}
}
ComponentDto project = newProjectDto(db.organizations().insert(), "project-uuid-" + suffix)
.setKey("project-key-" + suffix);
RuleDto rule = RuleTesting.newDto(RuleKey.of("sonarqube", "rule-" + suffix));
- dbClient.ruleDao().insert(dbSession, rule);
+ dbClient.ruleDao().insert(dbSession, rule.getDefinition());
IssueDto issue = IssueTesting.newDto(rule, project, project).setKee("issue-key-" + suffix).setUpdatedAt(new Date().getTime());
dbClient.componentDao().insert(dbSession, project);
SnapshotDto snapshot = dbClient.snapshotDao().insert(dbSession, SnapshotTesting.newAnalysis(project));
dbTester.getDbClient().componentDao().insert(dbTester.getSession(), project, file);
RuleDto ruleDto = RuleTesting.newDto(ruleKey);
- dbTester.getDbClient().ruleDao().insert(dbTester.getSession(), ruleDto);
+ dbTester.rules().insertRule(ruleDto);
ruleRepositoryRule.add(ruleKey);
IssueDto issue = IssueTesting.newDto(ruleDto, file, project)
@Test
public void insert_new_issue() {
RuleDto rule = RuleTesting.newDto(RuleKey.of("xoo", "S01"));
- dbClient.ruleDao().insert(session, rule);
+ dbTester.rules().insertRule(rule);
OrganizationDto organizationDto = dbTester.organizations().insert();
ComponentDto project = ComponentTesting.newProjectDto(organizationDto);
dbClient.componentDao().insert(session, project);
}
private RuleDto newRule(RuleDto rule) {
- tester.get(RuleDao.class).insert(session, rule);
+ RuleDao ruleDao = tester.get(RuleDao.class);
+ ruleDao.insert(session, rule.getDefinition());
+ if (rule.getOrganizationUuid() != null) {
+ ruleDao.update(session, rule.getMetadata().setRuleId(rule.getId()));
+ }
session.commit();
ruleIndexer.index();
return rule;
.setName("Rule name")
.setDescription("Rule desc")
.setStatus(RuleStatus.READY);
- tester.get(RuleDao.class).insert(session, rule);
+ tester.get(RuleDao.class).insert(session, rule.getDefinition());
session.commit();
return rule;
}
.setName("Rule name")
.setDescription("Rule desc")
.setStatus(RuleStatus.READY);
- tester.get(RuleDao.class).insert(session, rule);
+ tester.get(RuleDao.class).insert(session, rule.getDefinition());
session.commit();
return rule;
}
@Rule
public UserSessionRule userSession = UserSessionRule.standalone();
-
@Rule
public DbTester db = DbTester.create();
-
@Rule
public EsTester es = new EsTester(new IssueIndexDefinition(new MapSettings()), new RuleIndexDefinition(new MapSettings()));
@Test
public void return_tags_from_rules() throws Exception {
- db.rules().insertRule(rule -> rule.setSystemTags(ImmutableSet.of("tag1")).setTags(ImmutableSet.of("tag2")));
- db.rules().insertRule(rule -> rule.setSystemTags(ImmutableSet.of("tag3")).setTags(ImmutableSet.of("tag4", "tag5")));
+ db.rules().insertRule(db.getDefaultOrganization(), rule -> rule.setSystemTags(ImmutableSet.of("tag1")).setTags(ImmutableSet.of("tag2")));
+ db.rules().insertRule(db.getDefaultOrganization(), rule -> rule.setSystemTags(ImmutableSet.of("tag3")).setTags(ImmutableSet.of("tag4", "tag5")));
ruleIndexer.index();
String result = tester.newRequest().execute().getInput();
insertIssueWithBrowsePermission(insertRuleWithoutTags(), "tag1", "tag2");
insertIssueWithBrowsePermission(insertRuleWithoutTags(), "tag3", "tag4", "tag5");
issueIndexer.indexOnStartup(null);
- db.rules().insertRule(rule -> rule.setSystemTags(ImmutableSet.of("tag6")).setTags(ImmutableSet.of("tag7")));
+ db.rules().insertRule(db.getDefaultOrganization(), rule -> rule.setSystemTags(ImmutableSet.of("tag6")).setTags(ImmutableSet.of("tag7")));
ruleIndexer.index();
String result = tester.newRequest().execute().getInput();
public void test_example() throws Exception {
insertIssueWithBrowsePermission(insertRuleWithoutTags(), "convention");
issueIndexer.indexOnStartup(null);
- db.rules().insertRule(rule -> rule.setSystemTags(ImmutableSet.of("cwe")).setTags(ImmutableSet.of("security")));
+ db.rules().insertRule(db.getDefaultOrganization(), rule -> rule.setSystemTags(ImmutableSet.of("cwe")).setTags(ImmutableSet.of("security")));
ruleIndexer.index();
String result = tester.newRequest().execute().getInput();
}
private RuleDto insertRuleWithoutTags() {
- RuleDto ruleDto = newRuleDto().setTags(emptySet()).setSystemTags(emptySet());
+ RuleDto ruleDto = newRuleDto(db.getDefaultOrganization()).setTags(emptySet()).setSystemTags(emptySet());
db.rules().insertRule(ruleDto);
return ruleDto;
}
import org.sonar.db.rule.RuleDto;
import org.sonar.db.rule.RuleParamDto;
import org.sonar.server.qualityprofile.index.ActiveRuleIndexer;
-import org.sonar.server.qualityprofile.ws.QProfileWsSupport;
import org.sonar.server.rule.index.RuleIndex;
import org.sonar.server.rule.index.RuleIndexer;
import org.sonar.server.rule.index.RuleQuery;
// create pre-defined rules
RuleDto xooRule1 = newXooX1().setSeverity("MINOR").setLanguage("xoo");
RuleDto xooRule2 = newXooX2().setSeverity("MAJOR").setLanguage("xoo");
- db.ruleDao().insert(dbSession, xooRule1);
- db.ruleDao().insert(dbSession, xooRule2);
- db.ruleDao().insertRuleParam(dbSession, xooRule1, RuleParamDto.createFor(xooRule1)
+ db.ruleDao().insert(dbSession, xooRule1.getDefinition());
+ db.ruleDao().insert(dbSession, xooRule2.getDefinition());
+ db.ruleDao().insertRuleParam(dbSession, xooRule1.getDefinition(), RuleParamDto.createFor(xooRule1.getDefinition())
.setName("max").setDefaultValue("10").setType(RuleParamType.INTEGER.type()));
dbSession.commit();
dbSession.clearCache();
public void backup() throws Exception {
RuleKey blahRuleKey = RuleKey.of("blah", "my-rule");
RuleDto blahRule = newDto(blahRuleKey).setSeverity("INFO").setLanguage("xoo");
- db.ruleDao().insert(dbSession, blahRule);
+ db.ruleDao().insert(dbSession, blahRule.getDefinition());
dbSession.commit();
dbSession.clearCache();
ruleIndexer.index();
xooRule1 = RuleTesting.newXooX1().setSeverity("MINOR");
xooRule2 = RuleTesting.newXooX2().setSeverity("MAJOR");
- db.ruleDao().insert(dbSession, xooRule1);
- db.ruleDao().insert(dbSession, xooRule2);
- db.ruleDao().insertRuleParam(dbSession, xooRule1, RuleParamDto.createFor(xooRule1)
+ db.ruleDao().insert(dbSession, xooRule1.getDefinition());
+ db.ruleDao().insert(dbSession, xooRule2.getDefinition());
+ db.ruleDao().insertRuleParam(dbSession, xooRule1.getDefinition(), RuleParamDto.createFor(xooRule1.getDefinition())
.setName("max").setType(RuleParamType.INTEGER.type()));
- db.ruleDao().insertRuleParam(dbSession, xooRule1, RuleParamDto.createFor(xooRule1)
+ db.ruleDao().insertRuleParam(dbSession, xooRule1.getDefinition(), RuleParamDto.createFor(xooRule1.getDefinition())
.setName("min").setType(RuleParamType.INTEGER.type()));
left = QProfileTesting.newXooP1("org-123");
// create pre-defined rules
RuleDto xooRule1 = RuleTesting.newXooX1().setSeverity("MINOR");
RuleDto xooRule2 = RuleTesting.newXooX2().setSeverity("MAJOR");
- db.ruleDao().insert(dbSession, xooRule1);
- db.ruleDao().insert(dbSession, xooRule2);
- db.ruleDao().insertRuleParam(dbSession, xooRule1, RuleParamDto.createFor(xooRule1)
+ db.ruleDao().insert(dbSession, xooRule1.getDefinition());
+ db.ruleDao().insert(dbSession, xooRule2.getDefinition());
+ db.ruleDao().insertRuleParam(dbSession, xooRule1.getDefinition(), RuleParamDto.createFor(xooRule1.getDefinition())
.setName("max").setDefaultValue("10").setType(RuleParamType.INTEGER.type()));
// create pre-defined profile
RuleDto xooRule2 = newXooX2().setSeverity("INFO");
RuleDto xooTemplateRule1 = newTemplateRule(TEMPLATE_RULE_KEY)
.setSeverity("MINOR").setLanguage("xoo");
- db.ruleDao().insert(dbSession, javaRule);
- db.ruleDao().insert(dbSession, xooRule1);
- db.ruleDao().insert(dbSession, xooRule2);
- db.ruleDao().insert(dbSession, xooTemplateRule1);
- db.ruleDao().insertRuleParam(dbSession, xooRule1, RuleParamDto.createFor(xooRule1)
+ db.ruleDao().insert(dbSession, javaRule.getDefinition());
+ db.ruleDao().insert(dbSession, xooRule1.getDefinition());
+ db.ruleDao().insert(dbSession, xooRule2.getDefinition());
+ db.ruleDao().insert(dbSession, xooTemplateRule1.getDefinition());
+ db.ruleDao().insertRuleParam(dbSession, xooRule1.getDefinition(), RuleParamDto.createFor(xooRule1.getDefinition())
.setName("max").setDefaultValue("10").setType(RuleParamType.INTEGER.type()));
- db.ruleDao().insertRuleParam(dbSession, xooRule1, RuleParamDto.createFor(xooRule1)
+ db.ruleDao().insertRuleParam(dbSession, xooRule1.getDefinition(), RuleParamDto.createFor(xooRule1.getDefinition())
.setName("min").setType(RuleParamType.INTEGER.type()));
- db.ruleDao().insertRuleParam(dbSession, xooTemplateRule1, RuleParamDto.createFor(xooTemplateRule1)
+ db.ruleDao().insertRuleParam(dbSession, xooTemplateRule1.getDefinition(), RuleParamDto.createFor(xooTemplateRule1.getDefinition())
.setName("format").setType(RuleParamType.STRING.type()));
RuleDto xooCustomRule1 = newCustomRule(xooTemplateRule1).setRuleKey(CUSTOM_RULE_KEY.rule())
.setSeverity("MINOR").setLanguage("xoo");
- db.ruleDao().insert(dbSession, xooCustomRule1);
- db.ruleDao().insertRuleParam(dbSession, xooCustomRule1, RuleParamDto.createFor(xooTemplateRule1)
+ db.ruleDao().insert(dbSession, xooCustomRule1.getDefinition());
+ db.ruleDao().insertRuleParam(dbSession, xooCustomRule1.getDefinition(), RuleParamDto.createFor(xooTemplateRule1.getDefinition())
.setName("format").setDefaultValue("txt").setType(RuleParamType.STRING.type()));
// create pre-defined profile P1
public void fail_to_activate_if_rule_with_removed_status() {
RuleDto ruleDto = db.ruleDao().selectOrFailByKey(dbSession, XOO_X1);
ruleDto.setStatus(RuleStatus.REMOVED);
- db.ruleDao().update(dbSession, ruleDto);
+ db.ruleDao().update(dbSession, ruleDto.getDefinition());
dbSession.commit();
dbSession.clearCache();
// set rule as removed
RuleDto rule = db.ruleDao().selectOrFailByKey(dbSession, XOO_X1);
rule.setStatus(RuleStatus.REMOVED);
- db.ruleDao().update(dbSession, rule);
+ db.ruleDao().update(dbSession, rule.getDefinition());
dbSession.commit();
dbSession.clearCache();
// Generate more rules than the search's max limit
int bulkSize = SearchOptions.MAX_LIMIT + 10;
for (int i = 0; i < bulkSize; i++) {
- db.ruleDao().insert(dbSession, newDto(RuleKey.of("bulk", "r_" + i)).setLanguage("xoo"));
+ db.ruleDao().insert(dbSession, newDto(RuleKey.of("bulk", "r_" + i)).setLanguage("xoo").getDefinition());
}
dbSession.commit();
ruleIndexer.index();
// mark rule x1 as REMOVED
RuleDto rule = db.ruleDao().selectOrFailByKey(dbSession, XOO_X1);
rule.setStatus(RuleStatus.REMOVED);
- db.ruleDao().update(dbSession, rule);
+ db.ruleDao().update(dbSession, rule.getDefinition());
dbSession.commit();
dbSession.clearCache();
// Index one active rule
RuleDto rule = RuleTesting.newDto(RULE_KEY_1);
- dbTester.getDbClient().ruleDao().insert(dbTester.getSession(), rule);
+ dbTester.rules().insertRule(rule);
QualityProfileDto profile = QualityProfileDto.createFor("qp")
.setOrganizationUuid(organization.getUuid())
.setLanguage("xoo")
// Index another active rule
RuleDto rule2 = RuleTesting.newDto(RULE_KEY_2);
- dbTester.getDbClient().ruleDao().insert(dbTester.getSession(), rule2);
+ dbTester.rules().insertRule(rule2);
ActiveRuleDto activeRule2 = ActiveRuleDto.createFor(profile, rule2).setSeverity(Severity.CRITICAL)
.setCreatedAt(now).setUpdatedAt(now);
dbTester.getDbClient().activeRuleDao().insert(dbTester.getSession(), activeRule2);
.setLanguage(language.getKey())
.setSeverity(Severity.BLOCKER)
.setStatus(RuleStatus.READY);
- dbClient.ruleDao().insert(dbSession, rule);
+ dbClient.ruleDao().insert(dbSession, rule.getDefinition());
dbSession.commit();
return rule;
}
private void insertRule(RuleKey key, String name) {
RuleDto dto = RuleTesting.newDto(key).setName(name);
- dbTester.getDbClient().ruleDao().insert(dbTester.getSession(), dto);
+ dbTester.rules().insertRule(dto);
dbTester.getSession().commit();
}
import org.sonar.db.qualityprofile.ActiveRuleDto;
import org.sonar.db.qualityprofile.ActiveRuleParamDto;
import org.sonar.db.qualityprofile.QualityProfileDto;
+import org.sonar.db.rule.RuleDefinitionDto;
import org.sonar.db.rule.RuleDto;
import org.sonar.db.rule.RuleParamDto;
import org.sonar.db.rule.RuleRepositoryDto;
.setLanguage(lang)
.setSeverity(Severity.BLOCKER)
.setStatus(RuleStatus.READY);
- db.ruleDao().insert(session, rule);
- RuleParamDto param = RuleParamDto.createFor(rule).setName("param_" + id).setType(RuleParamType.STRING.toString());
- db.ruleDao().insertRuleParam(session, rule, param);
+ RuleDefinitionDto ruleDefinition = rule.getDefinition();
+ db.ruleDao().insert(session, ruleDefinition);
+ RuleParamDto param = RuleParamDto.createFor(ruleDefinition).setName("param_" + id).setType(RuleParamType.STRING.toString());
+ db.ruleDao().insertRuleParam(session, ruleDefinition, param);
return rule;
}
private RuleDto createRuleWithParam(String lang, String id) {
RuleDto rule = createRule(lang, id);
- RuleParamDto param = RuleParamDto.createFor(rule).setName("param_" + id).setType(RuleParamType.STRING.toString());
- db.ruleDao().insertRuleParam(session, rule, param);
+ RuleParamDto param = RuleParamDto.createFor(rule.getDefinition())
+ .setName("param_" + id)
+ .setType(RuleParamType.STRING.toString());
+ db.ruleDao().insertRuleParam(session, rule.getDefinition(), param);
return rule;
}
import org.sonar.db.DbTester;
import org.sonar.db.organization.OrganizationDto;
import org.sonar.db.qualityprofile.QualityProfileDto;
-import org.sonar.db.rule.RuleDto;
+import org.sonar.db.rule.RuleDefinitionDto;
import org.sonar.db.rule.RuleTesting;
import org.sonar.server.es.EsTester;
import org.sonar.server.exceptions.BadRequestException;
public class CreateActionTest {
private static final String XOO_LANGUAGE = "xoo";
- private static final RuleDto RULE = RuleTesting.newXooX1().setSeverity("MINOR").setLanguage(XOO_LANGUAGE);
+ private static final RuleDefinitionDto RULE = RuleTesting.newXooX1()
+ .setSeverity("MINOR")
+ .setLanguage(XOO_LANGUAGE)
+ .getDefinition();
private System2 system2 = System2.INSTANCE;
@Rule
assertThat(response.getMediaType()).isEqualTo(MediaTypes.JSON);
}
- private void insertRule(RuleDto ruleDto) {
+ private void insertRule(RuleDefinitionDto ruleDto) {
dbClient.ruleDao().insert(dbSession, ruleDto);
dbSession.commit();
ruleIndexer.index();
RuleDto rule = RuleTesting.newRuleDto()
.setSeverity("MINOR")
.setLanguage(profile1.getLanguage());
- dbClient.ruleDao().insert(dbSession, rule);
+ dbClient.ruleDao().insert(dbSession, rule.getDefinition());
dbSession.commit();
userSession.logIn()
.setStatus(RuleStatus.READY)
.setUpdatedAt(now)
.setCreatedAt(now);
- dbClient.ruleDao().insert(dbSession, rule);
+ dbClient.ruleDao().insert(dbSession, rule.getDefinition());
return rule;
}
.setLanguage(lang)
.setSeverity(Severity.BLOCKER)
.setStatus(RuleStatus.READY);
- db.ruleDao().insert(session, rule);
+ db.ruleDao().insert(session, rule.getDefinition());
return rule;
}
@Before
public void setup() {
- dbClient.ruleDao().insert(session, rule1);
- dbClient.ruleDao().insert(session, rule2);
- dbClient.ruleDao().insert(session, rule3);
- dbClient.ruleDao().insert(session, rule4);
+ dbTester.rules().insertRule(rule1);
+ dbTester.rules().insertRule(rule2);
+ dbTester.rules().insertRule(rule3);
+ dbTester.rules().insertRule(rule4);
session.commit();
}
assertThat(rule.getSystemTags()).containsOnly("tag1");
assertThat(rule.getTags()).containsOnly("tag2");
- // Definition updated -> user tag "tag2" becomes a system tag
- register(new Rules() {
- @Override
- public void init(RulesDefinition.NewRepository repository) {
- repository.createRule("x1").setName("x1 name").setHtmlDescription("x1 desc").setTags("tag1", "tag2");
- }
- });
- rule = ruleDao.selectOrFailByKey(dbSession, RuleTesting.XOO_X1);
- assertThat(rule.getSystemTags()).containsOnly("tag1", "tag2");
- assertThat(rule.getTags()).isEmpty();
+ // FIXME: not supported anymore because information specific to an organization: Definition updated -> user tag "tag2" becomes a system tag
+// register(new Rules() {
+// @Override
+// public void init(RulesDefinition.NewRepository repository) {
+// repository.createRule("x1").setName("x1 name").setHtmlDescription("x1 desc").setTags("tag1", "tag2");
+// }
+// });
+// rule = ruleDao.selectOrFailByKey(dbSession, RuleTesting.XOO_X1);
+// assertThat(rule.getSystemTags()).containsOnly("tag1", "tag2");
+// assertThat(rule.getTags()).isEmpty();
}
@Test
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
import org.sonar.db.DbTester;
+import org.sonar.db.rule.RuleDefinitionDto;
import org.sonar.db.rule.RuleDto;
import org.sonar.db.rule.RuleParamDto;
import org.sonar.db.rule.RuleRepositoryDto;
rule1.setTags(newHashSet("usertag1", "usertag2"));
rule1.setNoteData("user *note*");
rule1.setNoteUserLogin("marius");
- dbClient.ruleDao().update(dbTester.getSession(), rule1);
+ dbClient.ruleDao().update(dbTester.getSession(), rule1.getMetadata());
dbTester.getSession().commit();
when(system.now()).thenReturn(DATE2.getTime());
execute(new FakeRepositoryV2());
// On MySQL, need to update a rule otherwise rule2 will be seen as READY, but why ???
- dbClient.ruleDao().update(dbTester.getSession(), dbClient.ruleDao().selectOrFailByKey(dbTester.getSession(), RULE_KEY1));
+ dbClient.ruleDao().update(dbTester.getSession(), dbClient.ruleDao().selectOrFailByKey(dbTester.getSession(), RULE_KEY1).getDefinition());
dbTester.getSession().commit();
// rule2 is removed
@Test
public void remove_system_tags_when_plugin_does_not_provide_any() {
// Rule already exists in DB, with some system tags
- dbClient.ruleDao().insert(dbTester.getSession(), new RuleDto()
+ dbClient.ruleDao().insert(dbTester.getSession(), new RuleDefinitionDto()
.setRuleKey("rule1")
.setRepositoryKey("findbugs")
.setName("Rule One")
.setDescription("Rule one description")
.setDescriptionFormat(RuleDto.Format.HTML)
- .setSystemTags(newHashSet("tag1", "tag2"))
- );
+ .setSystemTags(newHashSet("tag1", "tag2")));
dbTester.getSession().commit();
// Synchronize rule without tag
.setDescription("Old description")
.setDescriptionFormat(Format.MARKDOWN)
.setSeverity(Severity.INFO);
- dao.insert(dbSession, rule);
- dao.insertRuleParam(dbSession, rule, dao.selectRuleParamsByRuleKey(dbSession, templateRule.getKey()).get(0).setDefaultValue("a.*"));
+ dao.insert(dbSession, rule.getDefinition());
+ dao.insertRuleParam(dbSession, rule.getDefinition(), dao.selectRuleParamsByRuleKey(dbSession, templateRule.getKey()).get(0).setDefaultValue("a.*"));
dbSession.commit();
dbSession.clearCache();
.setName("Old name")
.setDescription("Old description")
.setSeverity(Severity.INFO);
- dao.insert(dbSession, rule);
- dao.insertRuleParam(dbSession, rule, dao.selectRuleParamsByRuleKey(dbSession, templateRule.getKey()).get(0).setDefaultValue("a.*"));
+ dao.insert(dbSession, rule.getDefinition());
+ dao.insertRuleParam(dbSession, rule.getDefinition(), dao.selectRuleParamsByRuleKey(dbSession, templateRule.getKey()).get(0).setDefaultValue("a.*"));
dbSession.commit();
dbSession.clearCache();
public void fail_to_create_custom_rule_when_wrong_rule_template() {
// insert rule
RuleDto rule = RuleTesting.newDto(RuleKey.of("java", "S001")).setIsTemplate(false);
- dao.insert(dbSession, rule);
+ dao.insert(dbSession, rule.getDefinition());
dbSession.commit();
// Create custom rule with unknown template rule
.setSystemTags(Sets.newHashSet("tag1", "tag4"))
.setCreatedAt(new Date().getTime())
.setUpdatedAt(new Date().getTime());
- dao.insert(dbSession, templateRule);
- RuleParamDto ruleParamDto = RuleParamDto.createFor(templateRule).setName("regex").setType("STRING").setDescription("Reg ex").setDefaultValue(".*");
- dao.insertRuleParam(dbSession, templateRule, ruleParamDto);
+ dao.insert(dbSession, templateRule.getDefinition());
+ dao.update(dbSession, templateRule.getMetadata().setRuleId(templateRule.getId()));
+ RuleParamDto ruleParamDto = RuleParamDto.createFor(templateRule.getDefinition()).setName("regex").setType("STRING").setDescription("Reg ex").setDefaultValue(".*");
+ dao.insertRuleParam(dbSession, templateRule.getDefinition(), ruleParamDto);
dbSession.commit();
ruleIndexer.index();
return templateRule;
.setGapDescription("desc")
.setCreatedAt(new Date().getTime())
.setUpdatedAt(new Date().getTime());
- dao.insert(dbSession, templateRule);
- RuleParamDto ruleParamDto = RuleParamDto.createFor(templateRule)
+ dao.insert(dbSession, templateRule.getDefinition());
+ RuleParamDto ruleParamDto = RuleParamDto.createFor(templateRule.getDefinition())
.setName("myIntegers").setType("INTEGER,multiple=true,values=1;2;3").setDescription("My Integers").setDefaultValue("1");
- dao.insertRuleParam(dbSession, templateRule, ruleParamDto);
+ dao.insertRuleParam(dbSession, templateRule.getDefinition(), ruleParamDto);
dbSession.commit();
ruleIndexer.index();
return templateRule;
.setGapDescription("desc")
.setCreatedAt(new Date().getTime())
.setUpdatedAt(new Date().getTime());
- dao.insert(dbSession, templateRule);
- RuleParamDto ruleParam1Dto = RuleParamDto.createFor(templateRule)
+ dao.insert(dbSession, templateRule.getDefinition());
+ RuleParamDto ruleParam1Dto = RuleParamDto.createFor(templateRule.getDefinition())
.setName("first").setType("INTEGER").setDescription("First integer").setDefaultValue("0");
- dao.insertRuleParam(dbSession, templateRule, ruleParam1Dto);
- RuleParamDto ruleParam2Dto = RuleParamDto.createFor(templateRule)
+ dao.insertRuleParam(dbSession, templateRule.getDefinition(), ruleParam1Dto);
+ RuleParamDto ruleParam2Dto = RuleParamDto.createFor(templateRule.getDefinition())
.setName("second").setType("INTEGER").setDescription("Second integer").setDefaultValue("0");
- dao.insertRuleParam(dbSession, templateRule, ruleParam2Dto);
+ dao.insertRuleParam(dbSession, templateRule.getDefinition(), ruleParam2Dto);
dbSession.commit();
return templateRule;
}
.setLanguage("xoo")
.setCreatedAt(PAST)
.setUpdatedAt(PAST);
- dao.insert(dbSession, templateRule);
+ dao.insert(dbSession, templateRule.getDefinition());
// Create custom rule
RuleDto customRule = RuleTesting.newCustomRule(templateRule)
.setLanguage("xoo")
.setCreatedAt(PAST)
.setUpdatedAt(PAST);
- dao.insert(dbSession, customRule);
+ dao.insert(dbSession, customRule.getDefinition());
// Create a quality profile
QualityProfileDto profileDto = QProfileTesting.newXooP1("org-123");
public void fail_to_delete_if_not_custom() {
// Create rule
RuleKey ruleKey = RuleKey.of("java", "S001");
- dao.insert(dbSession, RuleTesting.newDto(ruleKey));
+ dao.insert(dbSession, RuleTesting.newDto(ruleKey).getDefinition());
dbSession.commit();
try {
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.RuleTesting;
import org.sonar.server.rule.index.RuleIndexer;
import org.sonar.server.tester.ServerTester;
}
private void insertRule(RuleKey key, Set<String> tags, Set<String> systemTags) {
- dao.insert(dbSession,
- RuleTesting.newDto(key).setTags(tags).setSystemTags(systemTags));
+ RuleDto ruleDto = RuleTesting.newDto(key).setTags(tags).setSystemTags(systemTags);
+ dao.insert(dbSession, ruleDto.getDefinition());
+ dao.update(dbSession, ruleDto.getMetadata().setRuleId(ruleDto.getId()));
dbSession.commit();
ruleIndexer.index();
}
import org.sonar.db.qualityprofile.ActiveRuleParamDto;
import org.sonar.db.qualityprofile.QualityProfileDto;
import org.sonar.db.rule.RuleDao;
+import org.sonar.db.rule.RuleDefinitionDto;
import org.sonar.db.rule.RuleDto;
import org.sonar.db.rule.RuleParamDto;
import org.sonar.db.rule.RuleTesting;
@Test
public void do_not_update_rule_with_removed_status() {
- ruleDao.insert(dbSession, RuleTesting.newDto(RULE_KEY).setStatus(RuleStatus.REMOVED));
+ ruleDao.insert(dbSession, RuleTesting.newDto(RULE_KEY).setStatus(RuleStatus.REMOVED).getDefinition());
dbSession.commit();
RuleUpdate update = RuleUpdate.createForPluginRule(RULE_KEY).setTags(Sets.newHashSet("java9"));
@Test
public void no_changes() {
- ruleDao.insert(dbSession, RuleTesting.newDto(RULE_KEY)
+ RuleDto ruleDto = RuleTesting.newDto(RULE_KEY)
// the following fields are not supposed to be updated
.setNoteData("my *note*")
.setNoteUserLogin("me")
.setTags(ImmutableSet.of("tag1"))
.setRemediationFunction(DebtRemediationFunction.Type.CONSTANT_ISSUE.name())
.setRemediationGapMultiplier("1d")
- .setRemediationBaseEffort("5min"));
+ .setRemediationBaseEffort("5min");
+ ruleDao.insert(dbSession, ruleDto.getDefinition());
+ ruleDao.update(dbSession, ruleDto.getMetadata().setRuleId(ruleDto.getId()));
dbSession.commit();
RuleUpdate update = RuleUpdate.createForPluginRule(RULE_KEY);
public void set_markdown_note() {
userSessionRule.logIn("me");
- ruleDao.insert(dbSession, RuleTesting.newDto(RULE_KEY)
+ RuleDto ruleDto = RuleTesting.newDto(RULE_KEY)
.setNoteData(null)
.setNoteUserLogin(null)
.setTags(ImmutableSet.of("tag1"))
.setRemediationFunction(DebtRemediationFunction.Type.CONSTANT_ISSUE.name())
.setRemediationGapMultiplier("1d")
- .setRemediationBaseEffort("5min"));
+ .setRemediationBaseEffort("5min");
+ ruleDao.insert(dbSession, ruleDto.getDefinition());
+ ruleDao.update(dbSession, ruleDto.getMetadata().setRuleId(ruleDto.getId()));
dbSession.commit();
RuleUpdate update = RuleUpdate.createForPluginRule(RULE_KEY);
@Test
public void remove_markdown_note() {
- ruleDao.insert(dbSession, RuleTesting.newDto(RULE_KEY)
+ RuleDto ruleDto = RuleTesting.newDto(RULE_KEY)
.setNoteData("my *note*")
- .setNoteUserLogin("me"));
+ .setNoteUserLogin("me");
+ ruleDao.insert(dbSession, ruleDto.getDefinition());
+ ruleDao.update(dbSession, ruleDto.getMetadata().setRuleId(ruleDto.getId()));
dbSession.commit();
RuleUpdate update = RuleUpdate.createForPluginRule(RULE_KEY).setMarkdownNote(null);
// insert db
ruleDao.insert(dbSession, RuleTesting.newDto(RULE_KEY)
.setTags(Sets.newHashSet("security"))
- .setSystemTags(Sets.newHashSet("java8", "javadoc")));
+ .setSystemTags(Sets.newHashSet("java8", "javadoc")).getDefinition());
dbSession.commit();
// java8 is a system tag -> ignore
@Test
public void remove_tags() {
- ruleDao.insert(dbSession, RuleTesting.newDto(RULE_KEY)
+ RuleDto ruleDto = RuleTesting.newDto(RULE_KEY)
.setTags(Sets.newHashSet("security"))
- .setSystemTags(Sets.newHashSet("java8", "javadoc")));
+ .setSystemTags(Sets.newHashSet("java8", "javadoc"));
+ ruleDao.insert(dbSession, ruleDto.getDefinition());
+ ruleDao.update(dbSession, ruleDto.getMetadata());
dbSession.commit();
RuleUpdate update = RuleUpdate.createForPluginRule(RULE_KEY).setTags(null);
.setDefaultRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.name())
.setDefaultRemediationGapMultiplier("1d")
.setDefaultRemediationBaseEffort("5min")
- .setRemediationFunction(null)
- .setRemediationGapMultiplier(null)
- .setRemediationBaseEffort(null));
+ .getDefinition());
dbSession.commit();
DefaultDebtRemediationFunction fn = new DefaultDebtRemediationFunction(DebtRemediationFunction.Type.CONSTANT_ISSUE, null, "1min");
.setDefaultRemediationFunction(DebtRemediationFunction.Type.LINEAR.name())
.setDefaultRemediationGapMultiplier("1d")
.setDefaultRemediationBaseEffort(null)
- .setRemediationFunction(null)
- .setRemediationGapMultiplier(null)
- .setRemediationBaseEffort(null));
+ .getDefinition());
dbSession.commit();
RuleUpdate update = RuleUpdate.createForPluginRule(RULE_KEY)
.setDefaultRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.name())
.setDefaultRemediationGapMultiplier("1d")
.setDefaultRemediationBaseEffort("5min")
- .setRemediationFunction(null)
- .setRemediationGapMultiplier(null)
- .setRemediationBaseEffort(null));
+ .getDefinition());
dbSession.commit();
RuleUpdate update = RuleUpdate.createForPluginRule(RULE_KEY)
@Test
public void reset_remediation_function() {
- ruleDao.insert(dbSession, RuleTesting.newDto(RULE_KEY)
+ RuleDto ruleDto = RuleTesting.newDto(RULE_KEY)
.setDefaultRemediationFunction(DebtRemediationFunction.Type.LINEAR.name())
.setDefaultRemediationGapMultiplier("1d")
.setDefaultRemediationBaseEffort("5min")
.setRemediationFunction(DebtRemediationFunction.Type.CONSTANT_ISSUE.name())
.setRemediationGapMultiplier(null)
- .setRemediationBaseEffort("1min"));
+ .setRemediationBaseEffort("1min");
+ ruleDao.insert(dbSession, ruleDto.getDefinition());
+ ruleDao.update(dbSession, ruleDto.getMetadata().setRuleId(ruleDto.getId()));
dbSession.commit();
RuleUpdate update = RuleUpdate.createForPluginRule(RULE_KEY).setDebtRemediationFunction(null);
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);
+ ruleDao.insert(dbSession, templateRule.getDefinition());
+ RuleParamDto templateRuleParam1 = RuleParamDto.createFor(templateRule.getDefinition()).setName("regex").setType("STRING").setDescription("Reg ex").setDefaultValue(".*");
+ RuleParamDto templateRuleParam2 = RuleParamDto.createFor(templateRule.getDefinition()).setName("format").setType("STRING").setDescription("Format");
+ ruleDao.insertRuleParam(dbSession, templateRule.getDefinition(), templateRuleParam1);
+ ruleDao.insertRuleParam(dbSession, templateRule.getDefinition(), templateRuleParam2);
// Create custom rule
- RuleDto customRule = RuleTesting.newCustomRule(templateRule)
+ RuleDefinitionDto customRule = RuleTesting.newCustomRule(templateRule)
.setName("Old name")
.setDescription("Old description")
.setSeverity(Severity.MINOR)
- .setStatus(RuleStatus.BETA);
+ .setStatus(RuleStatus.BETA)
+ .getDefinition();
ruleDao.insert(dbSession, customRule);
ruleDao.insertRuleParam(dbSession, customRule, templateRuleParam1.setDefaultValue("a.*"));
ruleDao.insertRuleParam(dbSession, customRule, templateRuleParam2.setDefaultValue(null));
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);
+ ruleDao.insert(dbSession, templateRule.getDefinition());
+ RuleParamDto templateRuleParam = RuleParamDto.createFor(templateRule.getDefinition()).setName("regex").setType("STRING").setDescription("Reg ex");
+ ruleDao.insertRuleParam(dbSession, templateRule.getDefinition(), templateRuleParam);
// Create custom rule
- RuleDto customRule = RuleTesting.newCustomRule(templateRule)
+ RuleDefinitionDto customRule = RuleTesting.newCustomRule(templateRule)
.setName("Old name")
.setDescription("Old description")
.setSeverity(Severity.MINOR)
- .setStatus(RuleStatus.BETA);
+ .setStatus(RuleStatus.BETA)
+ .getDefinition();
ruleDao.insert(dbSession, customRule);
ruleDao.insertRuleParam(dbSession, customRule, templateRuleParam);
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);
+ RuleDefinitionDto templateRuleDefinition = templateRule.getDefinition();
+ ruleDao.insert(dbSession, templateRuleDefinition);
+ RuleParamDto templateRuleParam1 = RuleParamDto.createFor(templateRuleDefinition).setName("regex").setType("STRING").setDescription("Reg ex").setDefaultValue(".*");
+ ruleDao.insertRuleParam(dbSession, templateRuleDefinition, templateRuleParam1);
+ RuleParamDto templateRuleParam2 = RuleParamDto.createFor(templateRuleDefinition).setName("format").setType("STRING").setDescription("format").setDefaultValue("csv");
+ ruleDao.insertRuleParam(dbSession, templateRuleDefinition, templateRuleParam2);
+ RuleParamDto templateRuleParam3 = RuleParamDto.createFor(templateRuleDefinition).setName("message").setType("STRING").setDescription("message");
+ ruleDao.insertRuleParam(dbSession, templateRuleDefinition, templateRuleParam3);
// Create custom rule
- RuleDto customRule = RuleTesting.newCustomRule(templateRule).setSeverity(Severity.MAJOR).setLanguage("xoo");
+ RuleDefinitionDto customRule = RuleTesting.newCustomRule(templateRule)
+ .setSeverity(Severity.MAJOR)
+ .setLanguage("xoo")
+ .getDefinition();
ruleDao.insert(dbSession, customRule);
ruleDao.insertRuleParam(dbSession, customRule, templateRuleParam1.setDefaultValue("a.*"));
ruleDao.insertRuleParam(dbSession, customRule, templateRuleParam2.setDefaultValue("txt"));
public void fail_to_update_custom_rule_when_empty_name() {
// Create template rule
RuleDto templateRule = RuleTesting.newTemplateRule(RuleKey.of("java", "S001"));
- ruleDao.insert(dbSession, templateRule);
+ ruleDao.insert(dbSession, templateRule.getDefinition());
// Create custom rule
RuleDto customRule = RuleTesting.newCustomRule(templateRule);
- ruleDao.insert(dbSession, customRule);
+ ruleDao.insert(dbSession, customRule.getDefinition());
dbSession.commit();
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);
+ ruleDao.insert(dbSession, templateRule.getDefinition());
// Create custom rule
RuleDto customRule = RuleTesting.newCustomRule(templateRule);
- ruleDao.insert(dbSession, customRule);
+ ruleDao.insert(dbSession, customRule.getDefinition());
dbSession.commit();
public void fail_to_update_plugin_rule_if_name_is_set() {
// Create rule rule
RuleDto ruleDto = RuleTesting.newDto(RuleKey.of("squid", "S01"));
- ruleDao.insert(dbSession, ruleDto);
+ ruleDao.insert(dbSession, ruleDto.getDefinition());
dbSession.commit();
public void fail_to_update_plugin_rule_if_description_is_set() {
// Create rule rule
RuleDto ruleDto = RuleTesting.newDto(RuleKey.of("squid", "S01"));
- ruleDao.insert(dbSession, ruleDto);
+ ruleDao.insert(dbSession, ruleDto.getDefinition());
dbSession.commit();
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);
+ ruleDao.insert(dbSession, ruleDto.getDefinition());
dbSession.commit();
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
import org.sonar.db.DbTester;
+import org.sonar.db.rule.RuleDefinitionDto;
import org.sonar.db.rule.RuleDto;
import org.sonar.server.es.EsTester;
private DbClient dbClient = dbTester.getDbClient();
private DbSession dbSession = dbTester.getSession();
- private RuleDto rule = new RuleDto()
+ private RuleDefinitionDto rule = new RuleDefinitionDto()
.setRuleKey("S001")
.setRepositoryKey("xoo")
.setConfigKey("S1")
.setSeverity(Severity.BLOCKER)
.setStatus(RuleStatus.READY)
.setIsTemplate(true)
- .setTags(newHashSet("performance"))
.setSystemTags(newHashSet("cwe"))
.setType(RuleType.BUG)
.setCreatedAt(1500000000000L)
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
import org.sonar.db.DbTester;
+import org.sonar.db.rule.RuleDefinitionDto;
import org.sonar.db.rule.RuleDto;
import static com.google.common.collect.Sets.newHashSet;
.setSeverity(Severity.BLOCKER)
.setStatus(RuleStatus.READY)
.setIsTemplate(true)
- .setTags(newHashSet("performance"))
.setSystemTags(newHashSet("cwe"))
.setType(RuleType.BUG)
.setCreatedAt(1500000000000L)
- .setUpdatedAt(1600000000000L);
+ .setUpdatedAt(1600000000000L)
+ .setOrganizationUuid("foo-org")
+ .setTags(newHashSet("performance"));
- RuleDto customRule = new RuleDto()
+ RuleDefinitionDto customRule = new RuleDefinitionDto()
.setRuleKey("S002")
.setRepositoryKey("xoo")
.setConfigKey("S2")
@Test
public void iterator_over_one_rule() {
- dbClient.ruleDao().insert(dbSession, templateRule);
- dbSession.commit();
+ dbTester.rules().insertRule(templateRule);
RuleResultSetIterator it = RuleResultSetIterator.create(dbTester.getDbClient(), dbTester.getSession(), 0L);
Map<String, RuleDoc> rulesByKey = rulesByKey(it);
@Test
public void iterator_over_rules() {
- dbClient.ruleDao().insert(dbSession, templateRule);
+ dbTester.rules().insertRule(templateRule);
dbClient.ruleDao().insert(dbSession, customRule);
dbSession.commit();
@Test
public void custom_rule() {
- dbClient.ruleDao().insert(dbSession, templateRule);
+ dbTester.rules().insertRule(templateRule);
dbClient.ruleDao().insert(dbSession, customRule.setTemplateId(templateRule.getId()));
dbSession.commit();
@Test
public void removed_rule_is_returned() {
- dbClient.ruleDao().insert(dbSession, templateRule.setStatus(RuleStatus.REMOVED));
+ dbTester.rules().insertRule(templateRule.setStatus(RuleStatus.REMOVED));
dbSession.commit();
RuleResultSetIterator it = RuleResultSetIterator.create(dbTester.getDbClient(), dbTester.getSession(), 0L);
public void create_custom_rule() throws Exception {
// Template rule
RuleDto templateRule = RuleTesting.newTemplateRule(RuleKey.of("java", "S001"), defaultOrganization);
- ruleDao.insert(session, templateRule);
- RuleParamDto param = RuleParamDto.createFor(templateRule).setName("regex").setType("STRING").setDescription("Reg ex").setDefaultValue(".*");
- ruleDao.insertRuleParam(session, templateRule, param);
+ ruleDao.insert(session, templateRule.getDefinition());
+ ruleDao.update(session, templateRule.getMetadata().setRuleId(templateRule.getId()));
+ RuleParamDto param = RuleParamDto.createFor(templateRule.getDefinition()).setName("regex").setType("STRING").setDescription("Reg ex").setDefaultValue(".*");
+ ruleDao.insertRuleParam(session, templateRule.getDefinition(), param);
session.commit();
WsTester.TestRequest request = wsTester.newPostRequest("api/rules", "create")
@Test
public void create_custom_rule_with_prevent_reactivation_param_to_true() throws Exception {
RuleDto templateRule = RuleTesting.newTemplateRule(RuleKey.of("java", "S001"));
- ruleDao.insert(session, templateRule);
+ ruleDao.insert(session, templateRule.getDefinition());
// insert a removed rule
RuleDto customRule = RuleTesting.newCustomRule(templateRule)
.setDescription("Description")
.setDescriptionFormat(RuleDto.Format.MARKDOWN)
.setSeverity(Severity.MAJOR);
- tester.get(RuleDao.class).insert(session, customRule);
+ tester.get(RuleDao.class).insert(session, customRule.getDefinition());
session.commit();
WsTester.TestRequest request = wsTester.newPostRequest("api/rules", "create")
@Test
public void return_rules_in_protobuf() throws Exception {
- dbTester.getDbClient().ruleDao().insert(dbTester.getSession(), RuleTesting.newDto(RuleKey.of("java", "S001")).setConfigKey(null).setName(null));
- dbTester.getDbClient().ruleDao().insert(dbTester.getSession(), RuleTesting.newDto(RuleKey.of("java", "S002")).setConfigKey("I002").setName("Rule Two"));
+ dbTester.rules().insertRule(RuleTesting.newDto(RuleKey.of("java", "S001")).setConfigKey(null).setName(null));
+ dbTester.rules().insertRule(RuleTesting.newDto(RuleKey.of("java", "S002")).setConfigKey("I002").setName("Rule Two"));
dbTester.getSession().commit();
TestResponse response = tester.newRequest()
tester.get(QualityProfileDao.class).insert(session, profile);
RuleDto rule = RuleTesting.newXooX1(defaultOrganization);
- ruleDao.insert(session, rule);
+ ruleDao.insert(session, rule.getDefinition());
+ ruleDao.update(session, rule.getMetadata().setRuleId(rule.getId()));
ActiveRuleDto activeRuleDto = ActiveRuleDto.createFor(profile, rule).setSeverity("BLOCKER");
tester.get(ActiveRuleDao.class).insert(session, activeRuleDto);
QualityProfileDto profile = QProfileTesting.newXooP1("org-123");
tester.get(QualityProfileDao.class).insert(session, profile);
- RuleDto rule = RuleTesting.newXooX1().
- setTags(ImmutableSet.of("hello", "world"))
+ RuleDto rule = RuleTesting.newXooX1()
+ .setTags(ImmutableSet.of("hello", "world"))
.setSystemTags(Collections.<String>emptySet());
- ruleDao.insert(session, rule);
+ ruleDao.insert(session, rule.getDefinition());
+ ruleDao.update(session, rule.getMetadata().setRuleId(rule.getId()));
RuleDto rule2 = RuleTesting.newXooX2()
.setTags(ImmutableSet.of("hello", "java"))
.setSystemTags(ImmutableSet.of("sys1"));
- ruleDao.insert(session, rule2);
+ ruleDao.insert(session, rule2.getDefinition());
+ ruleDao.update(session, rule2.getMetadata().setRuleId(rule2.getId()));
session.commit();
ruleIndexer.index();
package org.sonar.server.rule.ws;
import com.google.common.collect.ImmutableSet;
-import java.util.Collections;
import java.util.Date;
import org.junit.After;
import org.junit.Before;
import org.sonar.db.qualityprofile.QualityProfileDao;
import org.sonar.db.qualityprofile.QualityProfileDto;
import org.sonar.db.rule.RuleDao;
+import org.sonar.db.rule.RuleDefinitionDto;
import org.sonar.db.rule.RuleDto;
import org.sonar.db.rule.RuleParamDto;
import org.sonar.db.rule.RuleTesting;
private static final String API_SEARCH_METHOD = "search";
private DbClient db;
- private RulesWs ws;
private RuleDao ruleDao;
private DbSession dbSession;
private RuleIndexer ruleIndexer;
tester.clearDbAndIndexes();
db = tester.get(DbClient.class);
ruleDao = tester.get(RuleDao.class);
- ws = tester.get(RulesWs.class);
dbSession = tester.get(DbClient.class).openSession(false);
ruleIndexer = tester.get(RuleIndexer.class);
activeRuleIndexer = tester.get(ActiveRuleIndexer.class);
@Test
public void filter_by_key_rules() throws Exception {
- ruleDao.insert(dbSession, RuleTesting.newXooX1());
- ruleDao.insert(dbSession, RuleTesting.newXooX2());
+ ruleDao.insert(dbSession, RuleTesting.newXooX1().getDefinition());
+ ruleDao.insert(dbSession, RuleTesting.newXooX2().getDefinition());
dbSession.commit();
ruleIndexer.index();
@Test
public void search_2_rules() throws Exception {
- ruleDao.insert(dbSession, RuleTesting.newXooX1(defaultOrganization)
- .setType(RuleType.BUG));
- ruleDao.insert(dbSession, RuleTesting.newXooX2(defaultOrganization)
- .setType(RuleType.VULNERABILITY));
+ RuleDto rule1 = RuleTesting.newXooX1(defaultOrganization)
+ .setType(RuleType.BUG);
+ ruleDao.insert(dbSession, rule1.getDefinition());
+ ruleDao.update(dbSession, rule1.getMetadata().setRuleId(rule1.getId()));
+ RuleDto rule2 = RuleTesting.newXooX2(defaultOrganization)
+ .setType(RuleType.VULNERABILITY);
+ ruleDao.insert(dbSession, rule2.getDefinition());
+ ruleDao.update(dbSession, rule2.getMetadata().setRuleId(rule2.getId()));
dbSession.commit();
ruleIndexer.index();
@Test
public void search_2_rules_with_fields_selection() throws Exception {
ruleDao.insert(dbSession, RuleTesting.newXooX1()
- .setType(RuleType.CODE_SMELL))
- ;
+ .setType(RuleType.CODE_SMELL)
+ .getDefinition());
ruleDao.insert(dbSession, RuleTesting.newXooX2()
.setType(RuleType.BUG)
.setDescription("A *Xoo* rule")
- .setDescriptionFormat(RuleDto.Format.MARKDOWN))
- ;
+ .setDescriptionFormat(RuleDto.Format.MARKDOWN)
+ .getDefinition());
dbSession.commit();
ruleIndexer.index();
public void return_mandatory_fields_even_when_setting_f_param() throws Exception {
ruleDao.insert(dbSession, RuleTesting.newXooX1()
.setName("Rule x1")
- .setType(RuleType.CODE_SMELL))
- ;
+ .setType(RuleType.CODE_SMELL)
+ .getDefinition());
dbSession.commit();
ruleIndexer.index();
@Test
public void return_lang_field() throws Exception {
- ruleDao.insert(dbSession, RuleTesting.newXooX1());
+ ruleDao.insert(dbSession, RuleTesting.newXooX1().getDefinition());
dbSession.commit();
ruleIndexer.index();
@Test
public void return_lang_name_field() throws Exception {
- ruleDao.insert(dbSession, RuleTesting.newXooX1());
+ ruleDao.insert(dbSession, RuleTesting.newXooX1().getDefinition());
dbSession.commit();
ruleIndexer.index();
@Test
public void return_lang_key_field_when_language_name_is_not_available() throws Exception {
- ruleDao.insert(dbSession, RuleTesting.newDto(RuleKey.of("other", "rule")).setLanguage("unknown"));
+ ruleDao.insert(dbSession, RuleTesting.newDto(RuleKey.of("other", "rule")).setLanguage("unknown").getDefinition());
dbSession.commit();
ruleIndexer.index();
@Test
public void search_debt_rules_with_default_and_overridden_debt_values() throws Exception {
- ruleDao.insert(dbSession, RuleTesting.newXooX1()
+ RuleDto ruleDto = RuleTesting.newXooX1()
.setDefaultRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.name())
.setDefaultRemediationGapMultiplier("1h")
.setDefaultRemediationBaseEffort("15min")
.setRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.name())
.setRemediationGapMultiplier("2h")
- .setRemediationBaseEffort("25min"));
+ .setRemediationBaseEffort("25min");
+ ruleDao.insert(dbSession, ruleDto.getDefinition());
+ ruleDao.update(dbSession, ruleDto.getMetadata().setRuleId(ruleDto.getId()));
dbSession.commit();
ruleIndexer.index();
@Test
public void search_debt_rules_with_default_linear_offset_and_overridden_constant_debt() throws Exception {
- ruleDao.insert(dbSession, RuleTesting.newXooX1()
+ RuleDto ruleDto = RuleTesting.newXooX1()
.setDefaultRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.name())
.setDefaultRemediationGapMultiplier("1h")
.setDefaultRemediationBaseEffort("15min")
.setRemediationFunction(DebtRemediationFunction.Type.CONSTANT_ISSUE.name())
.setRemediationGapMultiplier(null)
- .setRemediationBaseEffort("5min"));
+ .setRemediationBaseEffort("5min");
+ ruleDao.insert(dbSession, ruleDto.getDefinition());
+ ruleDao.update(dbSession, ruleDto.getMetadata().setRuleId(ruleDto.getId()));
dbSession.commit();
ruleIndexer.index();
@Test
public void search_debt_rules_with_default_linear_offset_and_overridden_linear_debt() throws Exception {
- ruleDao.insert(dbSession, RuleTesting.newXooX1()
+ RuleDto ruleDto = RuleTesting.newXooX1()
.setDefaultRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.name())
.setDefaultRemediationGapMultiplier("1h")
.setDefaultRemediationBaseEffort("15min")
.setRemediationFunction(DebtRemediationFunction.Type.LINEAR.name())
.setRemediationGapMultiplier("1h")
- .setRemediationBaseEffort(null));
+ .setRemediationBaseEffort(null);
+ ruleDao.insert(dbSession, ruleDto.getDefinition());
+ ruleDao.update(dbSession, ruleDto.getMetadata().setRuleId(ruleDto.getId()));
dbSession.commit();
ruleIndexer.index();
@Test
public void search_template_rules() throws Exception {
RuleDto templateRule = RuleTesting.newXooX1().setIsTemplate(true);
- ruleDao.insert(dbSession, templateRule);
+ ruleDao.insert(dbSession, templateRule.getDefinition());
RuleDto rule = RuleTesting.newXooX2();
rule.setTemplateId(templateRule.getId());
- ruleDao.insert(dbSession, rule);
+ ruleDao.insert(dbSession, rule.getDefinition());
dbSession.commit();
ruleIndexer.index();
@Test
public void search_custom_rules_from_template_key() throws Exception {
RuleDto templateRule = RuleTesting.newXooX1().setIsTemplate(true);
- ruleDao.insert(dbSession, templateRule);
- ruleDao.insert(dbSession, RuleTesting.newXooX2().setTemplateId(templateRule.getId()));
+ ruleDao.insert(dbSession, templateRule.getDefinition());
+ ruleDao.insert(dbSession, RuleTesting.newXooX2().setTemplateId(templateRule.getId()).getDefinition());
dbSession.commit();
ruleIndexer.index();
tester.get(QualityProfileDao.class).insert(dbSession, profile);
RuleDto rule = RuleTesting.newXooX1();
- ruleDao.insert(dbSession, rule);
+ ruleDao.insert(dbSession, rule.getDefinition());
ActiveRuleDto activeRule = newActiveRule(profile, rule);
tester.get(ActiveRuleDao.class).insert(dbSession, activeRule);
dbSession.commit();
RuleDto rule = RuleTesting.newXooX1();
- ruleDao.insert(dbSession, rule);
+ RuleDefinitionDto definition = rule.getDefinition();
+ ruleDao.insert(dbSession, definition);
- RuleParamDto param = RuleParamDto.createFor(rule)
+ RuleParamDto param = RuleParamDto.createFor(definition)
.setDefaultValue("some value")
.setType("string")
.setDescription("My small description")
.setName("my_var");
- ruleDao.insertRuleParam(dbSession, rule, param);
+ ruleDao.insertRuleParam(dbSession, definition, param);
- RuleParamDto param2 = RuleParamDto.createFor(rule)
+ RuleParamDto param2 = RuleParamDto.createFor(definition)
.setDefaultValue("other value")
.setType("integer")
.setDescription("My small description")
.setName("the_var");
- ruleDao.insertRuleParam(dbSession, rule, param2);
+ ruleDao.insertRuleParam(dbSession, definition, param2);
// SONAR-7083
- RuleParamDto param3 = RuleParamDto.createFor(rule)
+ RuleParamDto param3 = RuleParamDto.createFor(definition)
.setDefaultValue(null)
.setType("string")
.setDescription("Empty Param")
.setName("empty_var");
- ruleDao.insertRuleParam(dbSession, rule, param3);
+ ruleDao.insertRuleParam(dbSession, definition, param3);
ActiveRuleDto activeRule = newActiveRule(profile, rule);
tester.get(ActiveRuleDao.class).insert(dbSession, activeRule);
dbSession.commit();
RuleDto rule = RuleTesting.newXooX1();
- ruleDao.insert(dbSession, rule);
+ ruleDao.insert(dbSession, rule.getDefinition());
ActiveRuleDto activeRule = newActiveRule(profile, rule);
tester.get(ActiveRuleDao.class).insert(dbSession, activeRule);
QualityProfileDto profile = QProfileTesting.newXooP1("org-123");
tester.get(QualityProfileDao.class).insert(dbSession, profile);
RuleDto rule = RuleTesting.newXooX1();
- ruleDao.insert(dbSession, rule);
+ RuleDefinitionDto definition = rule.getDefinition();
+ ruleDao.insert(dbSession, definition);
dbSession.commit();
- RuleParamDto param = RuleParamDto.createFor(rule)
+ RuleParamDto param = RuleParamDto.createFor(definition)
.setDefaultValue("some value")
.setType("string")
.setDescription("My small description")
.setName("my_var");
- ruleDao.insertRuleParam(dbSession, rule, param);
+ ruleDao.insertRuleParam(dbSession, definition, param);
- RuleParamDto param2 = RuleParamDto.createFor(rule)
+ RuleParamDto param2 = RuleParamDto.createFor(definition)
.setDefaultValue("other value")
.setType("integer")
.setDescription("My small description")
.setName("the_var");
- ruleDao.insertRuleParam(dbSession, rule, param2);
+ ruleDao.insertRuleParam(dbSession, definition, param2);
ActiveRuleDto activeRule = newActiveRule(profile, rule);
tester.get(ActiveRuleDao.class).insert(dbSession, activeRule);
QualityProfileDto profile = QProfileTesting.newXooP1("org-123");
tester.get(QualityProfileDao.class).insert(dbSession, profile);
RuleDto rule = RuleTesting.newXooX1().setNoteData("this is *bold*");
- ruleDao.insert(dbSession, rule);
+ ruleDao.insert(dbSession, rule.getDefinition());
+ ruleDao.update(dbSession, rule.getMetadata().setRuleId(rule.getId()));
dbSession.commit();
ruleIndexer.index();
@Test
public void filter_by_tags() throws Exception {
ruleDao.insert(dbSession, RuleTesting.newXooX1()
- .setTags(Collections.<String>emptySet())
- .setSystemTags(ImmutableSet.of("tag1")));
+ .setSystemTags(ImmutableSet.of("tag1"))
+ .getDefinition());
ruleDao.insert(dbSession, RuleTesting.newXooX2()
- .setTags(Collections.<String>emptySet())
- .setSystemTags(ImmutableSet.of("tag2")));
+ .setSystemTags(ImmutableSet.of("tag2"))
+ .getDefinition());
dbSession.commit();
ruleIndexer.index();
@Test
public void statuses_facet_should_be_sticky() throws Exception {
- ruleDao.insert(dbSession, RuleTesting.newXooX1());
- ruleDao.insert(dbSession, RuleTesting.newXooX2().setStatus(RuleStatus.BETA));
- ruleDao.insert(dbSession, RuleTesting.newXooX3().setStatus(RuleStatus.DEPRECATED));
+ ruleDao.insert(dbSession, RuleTesting.newXooX1().getDefinition());
+ ruleDao.insert(dbSession, RuleTesting.newXooX2().setStatus(RuleStatus.BETA).getDefinition());
+ ruleDao.insert(dbSession, RuleTesting.newXooX3().setStatus(RuleStatus.DEPRECATED).getDefinition());
dbSession.commit();
ruleIndexer.index();
@Test
public void sort_by_name() throws Exception {
- ruleDao.insert(dbSession, RuleTesting.newXooX1().setName("Dodgy - Consider returning a zero length array rather than null "));
- ruleDao.insert(dbSession, RuleTesting.newXooX2().setName("Bad practice - Creates an empty zip file entry"));
- ruleDao.insert(dbSession, RuleTesting.newXooX3().setName("XPath rule"));
+ ruleDao.insert(dbSession, RuleTesting.newXooX1()
+ .setName("Dodgy - Consider returning a zero length array rather than null ")
+ .getDefinition());
+ ruleDao.insert(dbSession, RuleTesting.newXooX2()
+ .setName("Bad practice - Creates an empty zip file entry")
+ .getDefinition());
+ ruleDao.insert(dbSession, RuleTesting.newXooX3()
+ .setName("XPath rule")
+ .getDefinition());
dbSession.commit();
ruleIndexer.index();
Date since = new Date();
ruleDao.insert(dbSession, RuleTesting.newXooX1()
.setUpdatedAt(since.getTime())
- .setCreatedAt(since.getTime()));
+ .setCreatedAt(since.getTime())
+ .getDefinition());
ruleDao.insert(dbSession, RuleTesting.newXooX2()
.setUpdatedAt(since.getTime())
- .setCreatedAt(since.getTime()));
+ .setCreatedAt(since.getTime())
+ .getDefinition());
dbSession.commit();
dbSession.clearCache();
@Test
public void search_rules_with_deprecated_fields() throws Exception {
- ruleDao.insert(dbSession, RuleTesting.newXooX1()
- .setDefaultRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.name())
- .setDefaultRemediationGapMultiplier("1h")
- .setDefaultRemediationBaseEffort("15min")
- .setRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.name())
- .setRemediationGapMultiplier("2h")
- .setRemediationBaseEffort("25min"));
+ RuleDto ruleDto = RuleTesting.newXooX1()
+ .setDefaultRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.name())
+ .setDefaultRemediationGapMultiplier("1h")
+ .setDefaultRemediationBaseEffort("15min")
+ .setRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.name())
+ .setRemediationGapMultiplier("2h")
+ .setRemediationBaseEffort("25min");
+ ruleDao.insert(dbSession, ruleDto.getDefinition());
+ ruleDao.update(dbSession, ruleDto.getMetadata().setRuleId(ruleDto.getId()));
dbSession.commit();
ruleIndexer.index();
import org.sonar.db.qualityprofile.QualityProfileDao;
import org.sonar.db.qualityprofile.QualityProfileDto;
import org.sonar.db.rule.RuleDao;
+import org.sonar.db.rule.RuleDefinitionDto;
import org.sonar.db.rule.RuleDto;
import org.sonar.db.rule.RuleDto.Format;
import org.sonar.db.rule.RuleParamDto;
.setTags(newHashSet("tag1", "tag2"))
.setSystemTags(newHashSet("systag1", "systag2"))
.setType(RuleType.BUG);
- ruleDao.insert(session, ruleDto);
- RuleParamDto param = RuleParamDto.createFor(ruleDto).setName("regex").setType("STRING").setDescription("Reg *exp*").setDefaultValue(".*");
- ruleDao.insertRuleParam(session, ruleDto, param);
+ RuleDefinitionDto definition = ruleDto.getDefinition();
+ ruleDao.insert(session, definition);
+ ruleDao.update(session, ruleDto.getMetadata().setRuleId(ruleDto.getId()));
+ RuleParamDto param = RuleParamDto.createFor(definition).setName("regex").setType("STRING").setDescription("Reg *exp*").setDefaultValue(".*");
+ ruleDao.insertRuleParam(session, definition, param);
session.commit();
session.clearCache();
.setRemediationFunction(null)
.setRemediationGapMultiplier(null)
.setRemediationBaseEffort(null);
- ruleDao.insert(session, ruleDto);
+ ruleDao.insert(session, ruleDto.getDefinition());
+ ruleDao.update(session, ruleDto.getMetadata());
session.commit();
session.clearCache();
.setRemediationFunction("LINEAR_OFFSET")
.setRemediationGapMultiplier("5d")
.setRemediationBaseEffort("10h");
- ruleDao.insert(session, ruleDto);
+ ruleDao.insert(session, ruleDto.getDefinition());
+ ruleDao.update(session, ruleDto.getMetadata().setRuleId(ruleDto.getId()));
session.commit();
session.clearCache();
.setRemediationFunction("LINEAR_OFFSET")
.setRemediationGapMultiplier("5d")
.setRemediationBaseEffort("10h");
- ruleDao.insert(session, ruleDto);
+ ruleDao.insert(session, ruleDto.getDefinition());
+ ruleDao.update(session, ruleDto.getMetadata().setRuleId(ruleDto.getId()));
session.commit();
session.clearCache();
.setLanguage("xoo")
.setDefaultRemediationFunction(null)
.setDefaultRemediationGapMultiplier(null)
- .setDefaultRemediationBaseEffort(null)
- .setRemediationFunction(null)
- .setRemediationGapMultiplier(null)
- .setRemediationBaseEffort(null);
- ruleDao.insert(session, ruleDto);
+ .setDefaultRemediationBaseEffort(null);
+ ruleDao.insert(session, ruleDto.getDefinition());
session.commit();
session.clearCache();
public void encode_html_description_of_custom_rule() throws Exception {
// Template rule
RuleDto templateRule = RuleTesting.newTemplateRule(RuleKey.of("java", "S001"));
- ruleDao.insert(session, templateRule);
+ ruleDao.insert(session, templateRule.getDefinition());
session.commit();
// Custom rule
.setRemediationFunction("LINEAR_OFFSET")
.setRemediationGapMultiplier("5d")
.setRemediationBaseEffort("10h");
- ruleDao.insert(session, ruleDto);
+ ruleDao.insert(session, ruleDto.getDefinition());
+ ruleDao.update(session, ruleDto.getMetadata().setRuleId(ruleDto.getId()));
session.commit();
WsTester.TestRequest request = wsTester.newGetRequest("api/rules", "show")
.setType(RuleType.BUG)
.setCreatedAt(new Date().getTime())
.setUpdatedAt(new Date().getTime());
- ruleDao.insert(session, ruleDto);
- RuleParamDto regexParam = RuleParamDto.createFor(ruleDto).setName("regex").setType("STRING").setDescription("Reg *exp*").setDefaultValue(".*");
- ruleDao.insertRuleParam(session, ruleDto, regexParam);
+ RuleDefinitionDto definition = ruleDto.getDefinition();
+ ruleDao.insert(session, definition);
+ RuleParamDto regexParam = RuleParamDto.createFor(definition).setName("regex").setType("STRING").setDescription("Reg *exp*").setDefaultValue(".*");
+ ruleDao.insertRuleParam(session, definition, regexParam);
QualityProfileDto profile = QualityProfileDto.createFor("profile")
.setOrganizationUuid(defaultOrganizationProvider.get().getUuid())
import org.sonar.db.DbSession;
import org.sonar.db.organization.OrganizationDto;
import org.sonar.db.rule.RuleDao;
+import org.sonar.db.rule.RuleDefinitionDto;
import org.sonar.db.rule.RuleDto;
import org.sonar.db.rule.RuleParamDto;
import org.sonar.db.rule.RuleTesting;
import org.sonar.server.organization.DefaultOrganizationProvider;
import org.sonar.server.rule.NewCustomRule;
import org.sonar.server.rule.RuleCreator;
-import org.sonar.server.rule.RuleService;
import org.sonar.server.tester.ServerTester;
import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
private WsTester wsTester;
- private RuleService ruleService;
private RuleDao ruleDao;
private DbSession session;
private OrganizationDto defaultOrganization;
public void setUp() {
tester.clearDbAndIndexes();
wsTester = tester.get(WsTester.class);
- ruleService = tester.get(RuleService.class);
ruleDao = tester.get(RuleDao.class);
DbClient dbClient = tester.get(DbClient.class);
session = dbClient.openSession(false);
RuleDto rule = RuleTesting.newXooX1()
.setDefaultRemediationFunction(LINEAR.toString())
.setDefaultRemediationGapMultiplier("10d")
- .setDefaultRemediationBaseEffort(null)
- .setRemediationFunction(null)
- .setRemediationGapMultiplier(null)
- .setRemediationBaseEffort(null);
- ruleDao.insert(session, rule);
+ .setDefaultRemediationBaseEffort(null);
+ ruleDao.insert(session, rule.getDefinition());
session.commit();
WsTester.TestRequest request = wsTester.newPostRequest("api/rules", "update")
.setRemediationFunction(LINEAR_OFFSET.toString())
.setRemediationGapMultiplier("15min")
.setRemediationBaseEffort("3h");
- ruleDao.insert(session, rule);
+ ruleDao.insert(session, rule.getDefinition());
+ ruleDao.update(session, rule.getMetadata().setRuleId(rule.getId()));
session.commit();
WsTester.TestRequest request = wsTester.newPostRequest("api/rules", "update")
public void update_custom_rule() throws Exception {
// Template rule
RuleDto templateRule = RuleTesting.newTemplateRule(RuleKey.of("java", "S001"), defaultOrganization);
- ruleDao.insert(session, templateRule);
- RuleParamDto param = RuleParamDto.createFor(templateRule).setName("regex").setType("STRING").setDescription("Reg ex").setDefaultValue(".*");
- ruleDao.insertRuleParam(session, templateRule, param);
+ RuleDefinitionDto definition = templateRule.getDefinition();
+ ruleDao.insert(session, definition);
+ ruleDao.update(session, templateRule.getMetadata().setRuleId(templateRule.getId()));
+ RuleParamDto param = RuleParamDto.createFor(definition).setName("regex").setType("STRING").setDescription("Reg ex").setDefaultValue(".*");
+ ruleDao.insertRuleParam(session, definition, param);
session.commit();
// Custom rule
public void fail_to_update_custom_when_description_is_empty() {
// Template rule
RuleDto templateRule = RuleTesting.newTemplateRule(RuleKey.of("java", "S001"));
- ruleDao.insert(session, templateRule);
+ ruleDao.insert(session, templateRule.getDefinition());
// Custom rule
RuleDto customRule = RuleTesting.newCustomRule(templateRule);
- ruleDao.insert(session, customRule);
+ ruleDao.insert(session, customRule.getDefinition());
session.commit();
session.clearCache();
String viewUuid = "ABCD";
RuleDto rule = RuleTesting.newXooX1();
- dbClient.ruleDao().insert(dbSession, rule);
+ dbClient.ruleDao().insert(dbSession, rule.getDefinition());
ComponentDto project1 = addProjectWithIssue(rule, dbTester.organizations().insert());
issueIndexer.indexOnStartup(issueIndexer.getIndexTypes());
permissionIndexer.indexProjectsByUuids(dbSession, asList(project1.uuid()));
projects / sonarqube.git / commitdiff