@@ -79,55 +79,16 @@ public class RuleDao implements Dao { | |||
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) { | |||
@@ -150,13 +111,13 @@ public class RuleDao implements Dao { | |||
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()); |
@@ -249,6 +249,7 @@ public class RuleDto { | |||
public RuleDto setUpdatedAt(long updatedAt) { | |||
definition.setUpdatedAt(updatedAt); | |||
metadata.setUpdatedAt(updatedAt); | |||
return this; | |||
} | |||
@@ -98,7 +98,7 @@ public class RuleParamDto { | |||
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()); | |||
} |
@@ -149,7 +149,7 @@ public class IssueDaoTest { | |||
} | |||
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)); |
@@ -55,7 +55,7 @@ public class IssueMapperTest { | |||
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(); | |||
} | |||
@@ -91,29 +91,29 @@ public class ActiveRuleDaoTest { | |||
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(); | |||
} | |||
@@ -214,7 +214,7 @@ public class ActiveRuleDaoTest { | |||
@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(); |
@@ -47,7 +47,6 @@ import static java.util.Collections.singletonList; | |||
import static org.assertj.core.api.Assertions.assertThat; | |||
import static org.assertj.guava.api.Assertions.assertThat; | |||
public class RuleDaoTest { | |||
@Rule | |||
@@ -84,8 +83,8 @@ public class RuleDaoTest { | |||
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(); | |||
} | |||
@@ -174,7 +173,7 @@ public class RuleDaoTest { | |||
@Test | |||
public void insert() throws Exception { | |||
RuleDto newRule = new RuleDto() | |||
RuleDefinitionDto newRule = new RuleDefinitionDto() | |||
.setRuleKey("NewRuleKey") | |||
.setRepositoryKey("plugin") | |||
.setName("new name") | |||
@@ -186,18 +185,10 @@ public class RuleDaoTest { | |||
.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) | |||
@@ -218,18 +209,18 @@ public class RuleDaoTest { | |||
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); | |||
@@ -237,10 +228,10 @@ public class RuleDaoTest { | |||
} | |||
@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") | |||
@@ -253,18 +244,10 @@ public class RuleDaoTest { | |||
.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); | |||
@@ -284,20 +267,69 @@ public class RuleDaoTest { | |||
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); | |||
} | |||
@@ -321,18 +353,17 @@ public class RuleDaoTest { | |||
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") | |||
@@ -350,7 +381,8 @@ public class RuleDaoTest { | |||
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); |
@@ -23,6 +23,7 @@ import java.util.function.Consumer; | |||
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; | |||
@@ -35,8 +36,14 @@ public class RuleDbTester { | |||
} | |||
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; | |||
} | |||
@@ -48,12 +55,16 @@ public class RuleDbTester { | |||
}); | |||
} | |||
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) { | |||
@@ -61,7 +72,7 @@ public class RuleDbTester { | |||
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; | |||
} |
@@ -134,6 +134,11 @@ public class RuleTesting { | |||
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. | |||
*/ |
@@ -21,7 +21,6 @@ package org.sonar.server.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; | |||
@@ -50,8 +49,10 @@ import org.sonar.db.DbClient; | |||
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; | |||
@@ -61,7 +62,6 @@ import org.sonar.server.rule.index.RuleIndexer; | |||
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 | |||
@@ -136,7 +136,8 @@ public class RegisterRules implements Startable { | |||
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)) { | |||
@@ -181,8 +182,9 @@ public class RegisterRules implements Startable { | |||
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()) | |||
@@ -206,7 +208,7 @@ public class RegisterRules implements Startable { | |||
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()); | |||
@@ -245,7 +247,7 @@ public class RegisterRules implements Startable { | |||
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()); | |||
@@ -259,7 +261,7 @@ public class RegisterRules implements Startable { | |||
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; | |||
@@ -273,7 +275,7 @@ public class RegisterRules implements Startable { | |||
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; | |||
@@ -296,7 +298,7 @@ public class RegisterRules implements Startable { | |||
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(); | |||
@@ -353,18 +355,17 @@ public class RegisterRules implements Startable { | |||
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; | |||
@@ -388,8 +389,8 @@ public class RegisterRules implements Startable { | |||
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); | |||
@@ -403,16 +404,17 @@ public class RegisterRules implements Startable { | |||
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()); | |||
@@ -478,7 +480,12 @@ public class RegisterRules implements Startable { | |||
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); | |||
} |
@@ -24,6 +24,7 @@ import com.google.common.base.Splitter; | |||
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; | |||
@@ -34,8 +35,10 @@ import org.sonar.api.server.rule.RuleParamType; | |||
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; | |||
@@ -75,7 +78,7 @@ public class RuleCreator { | |||
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); | |||
} | |||
@@ -148,7 +151,8 @@ public class RuleCreator { | |||
} | |||
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()) | |||
@@ -161,21 +165,28 @@ public class RuleCreator { | |||
.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()) | |||
@@ -184,7 +195,7 @@ public class RuleCreator { | |||
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()); |
@@ -58,7 +58,8 @@ public class RuleDeleter { | |||
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(); |
@@ -260,7 +260,7 @@ public class RuleUpdater { | |||
// 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 | |||
@@ -351,7 +351,8 @@ public class RuleUpdater { | |||
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()); | |||
} | |||
} |
@@ -132,7 +132,7 @@ public class ComponentCleanerServiceTest { | |||
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)); |
@@ -281,7 +281,7 @@ public class IntegrateIssuesVisitorTest { | |||
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) |
@@ -98,7 +98,7 @@ public class PersistIssuesStepTest extends BaseStepTest { | |||
@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); |
@@ -175,7 +175,11 @@ public class IssueServiceMediumTest { | |||
} | |||
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; |
@@ -657,7 +657,7 @@ public class SearchActionComponentsMediumTest { | |||
.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; | |||
} |
@@ -712,7 +712,7 @@ public class SearchActionMediumTest { | |||
.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; | |||
} |
@@ -54,10 +54,8 @@ public class TagsActionTest { | |||
@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())); | |||
@@ -79,8 +77,8 @@ public class TagsActionTest { | |||
@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(); | |||
@@ -92,7 +90,7 @@ public class TagsActionTest { | |||
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(); | |||
@@ -129,7 +127,7 @@ public class TagsActionTest { | |||
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(); | |||
@@ -158,7 +156,7 @@ public class TagsActionTest { | |||
} | |||
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; | |||
} |
@@ -44,7 +44,6 @@ import org.sonar.db.qualityprofile.QualityProfileDto; | |||
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; | |||
@@ -95,9 +94,9 @@ public class QProfileBackuperMediumTest { | |||
// 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(); | |||
@@ -114,7 +113,7 @@ public class QProfileBackuperMediumTest { | |||
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(); |
@@ -69,11 +69,11 @@ public class QProfileComparisonMediumTest { | |||
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"); |
@@ -80,9 +80,9 @@ public class QProfileCopierMediumTest { | |||
// 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 |
@@ -111,21 +111,21 @@ public class RuleActivatorMediumTest { | |||
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 | |||
@@ -457,7 +457,7 @@ public class RuleActivatorMediumTest { | |||
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(); | |||
@@ -553,7 +553,7 @@ public class RuleActivatorMediumTest { | |||
// 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(); | |||
@@ -895,7 +895,7 @@ public class RuleActivatorMediumTest { | |||
// 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(); | |||
@@ -1025,7 +1025,7 @@ public class RuleActivatorMediumTest { | |||
// 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(); | |||
@@ -143,7 +143,7 @@ public class ActiveRuleIndexerTest { | |||
// 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") | |||
@@ -160,7 +160,7 @@ public class ActiveRuleIndexerTest { | |||
// 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); |
@@ -410,7 +410,7 @@ public class ChangeParentActionTest { | |||
.setLanguage(language.getKey()) | |||
.setSeverity(Severity.BLOCKER) | |||
.setStatus(RuleStatus.READY); | |||
dbClient.ruleDao().insert(dbSession, rule); | |||
dbClient.ruleDao().insert(dbSession, rule.getDefinition()); | |||
dbSession.commit(); | |||
return rule; | |||
} |
@@ -160,7 +160,7 @@ public class ChangelogLoaderTest { | |||
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(); | |||
} | |||
@@ -35,6 +35,7 @@ import org.sonar.db.DbSession; | |||
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; | |||
@@ -201,16 +202,19 @@ public class CompareActionMediumTest { | |||
.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; | |||
} | |||
@@ -40,7 +40,7 @@ import org.sonar.db.DbSession; | |||
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; | |||
@@ -74,7 +74,10 @@ import static org.sonarqube.ws.QualityProfiles.CreateWsResponse.parseFrom; | |||
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 | |||
@@ -236,7 +239,7 @@ public class CreateActionTest { | |||
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(); |
@@ -194,7 +194,7 @@ public class InheritanceActionTest { | |||
RuleDto rule = RuleTesting.newRuleDto() | |||
.setSeverity("MINOR") | |||
.setLanguage(profile1.getLanguage()); | |||
dbClient.ruleDao().insert(dbSession, rule); | |||
dbClient.ruleDao().insert(dbSession, rule.getDefinition()); | |||
dbSession.commit(); | |||
userSession.logIn() | |||
@@ -227,7 +227,7 @@ public class InheritanceActionTest { | |||
.setStatus(RuleStatus.READY) | |||
.setUpdatedAt(now) | |||
.setCreatedAt(now); | |||
dbClient.ruleDao().insert(dbSession, rule); | |||
dbClient.ruleDao().insert(dbSession, rule.getDefinition()); | |||
return rule; | |||
} | |||
@@ -446,7 +446,7 @@ public class QProfilesWsMediumTest { | |||
.setLanguage(lang) | |||
.setSeverity(Severity.BLOCKER) | |||
.setStatus(RuleStatus.READY); | |||
db.ruleDao().insert(session, rule); | |||
db.ruleDao().insert(session, rule.getDefinition()); | |||
return rule; | |||
} | |||
@@ -79,10 +79,10 @@ public class DefaultRuleFinderTest { | |||
@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(); | |||
} | |||
@@ -233,16 +233,16 @@ public class RegisterRulesMediumTest { | |||
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 |
@@ -36,6 +36,7 @@ import org.sonar.api.utils.System2; | |||
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; | |||
@@ -145,7 +146,7 @@ public class RegisterRulesTest { | |||
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()); | |||
@@ -342,7 +343,7 @@ public class RegisterRulesTest { | |||
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 | |||
@@ -384,14 +385,13 @@ public class RegisterRulesTest { | |||
@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 |
@@ -258,8 +258,8 @@ public class RuleCreatorMediumTest { | |||
.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(); | |||
@@ -302,8 +302,8 @@ public class RuleCreatorMediumTest { | |||
.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(); | |||
@@ -475,7 +475,7 @@ public class RuleCreatorMediumTest { | |||
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 | |||
@@ -507,9 +507,10 @@ public class RuleCreatorMediumTest { | |||
.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; | |||
@@ -526,10 +527,10 @@ public class RuleCreatorMediumTest { | |||
.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; | |||
@@ -546,13 +547,13 @@ public class RuleCreatorMediumTest { | |||
.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; | |||
} |
@@ -80,14 +80,14 @@ public class RuleDeleterMediumTest { | |||
.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"); | |||
@@ -120,7 +120,7 @@ public class RuleDeleterMediumTest { | |||
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 { |
@@ -30,6 +30,7 @@ import org.sonar.api.rule.RuleKey; | |||
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; | |||
@@ -109,8 +110,9 @@ public class RuleServiceMediumTest { | |||
} | |||
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(); | |||
} |
@@ -44,6 +44,7 @@ import org.sonar.db.qualityprofile.ActiveRuleKey; | |||
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; | |||
@@ -90,7 +91,7 @@ public class RuleUpdaterMediumTest { | |||
@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")); | |||
@@ -104,14 +105,16 @@ public class RuleUpdaterMediumTest { | |||
@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); | |||
@@ -132,7 +135,7 @@ public class RuleUpdaterMediumTest { | |||
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) | |||
@@ -140,7 +143,9 @@ public class RuleUpdaterMediumTest { | |||
.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); | |||
@@ -162,9 +167,11 @@ public class RuleUpdaterMediumTest { | |||
@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); | |||
@@ -183,7 +190,7 @@ public class RuleUpdaterMediumTest { | |||
// 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 | |||
@@ -202,9 +209,11 @@ public class RuleUpdaterMediumTest { | |||
@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); | |||
@@ -226,9 +235,7 @@ public class RuleUpdaterMediumTest { | |||
.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"); | |||
@@ -254,9 +261,7 @@ public class RuleUpdaterMediumTest { | |||
.setDefaultRemediationFunction(DebtRemediationFunction.Type.LINEAR.name()) | |||
.setDefaultRemediationGapMultiplier("1d") | |||
.setDefaultRemediationBaseEffort(null) | |||
.setRemediationFunction(null) | |||
.setRemediationGapMultiplier(null) | |||
.setRemediationBaseEffort(null)); | |||
.getDefinition()); | |||
dbSession.commit(); | |||
RuleUpdate update = RuleUpdate.createForPluginRule(RULE_KEY) | |||
@@ -281,9 +286,7 @@ public class RuleUpdaterMediumTest { | |||
.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) | |||
@@ -304,13 +307,15 @@ public class RuleUpdaterMediumTest { | |||
@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); | |||
@@ -332,18 +337,19 @@ public class RuleUpdaterMediumTest { | |||
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)); | |||
@@ -386,16 +392,17 @@ public class RuleUpdaterMediumTest { | |||
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); | |||
@@ -420,16 +427,20 @@ public class RuleUpdaterMediumTest { | |||
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")); | |||
@@ -483,11 +494,11 @@ public class RuleUpdaterMediumTest { | |||
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(); | |||
@@ -507,11 +518,11 @@ public class RuleUpdaterMediumTest { | |||
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(); | |||
@@ -531,7 +542,7 @@ public class RuleUpdaterMediumTest { | |||
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(); | |||
@@ -549,7 +560,7 @@ public class RuleUpdaterMediumTest { | |||
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(); | |||
@@ -567,7 +578,7 @@ public class RuleUpdaterMediumTest { | |||
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(); | |||
@@ -30,6 +30,7 @@ import org.sonar.api.utils.System2; | |||
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; | |||
@@ -48,7 +49,7 @@ public class RuleIndexerTest { | |||
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") | |||
@@ -59,7 +60,6 @@ public class RuleIndexerTest { | |||
.setSeverity(Severity.BLOCKER) | |||
.setStatus(RuleStatus.READY) | |||
.setIsTemplate(true) | |||
.setTags(newHashSet("performance")) | |||
.setSystemTags(newHashSet("cwe")) | |||
.setType(RuleType.BUG) | |||
.setCreatedAt(1500000000000L) |
@@ -31,6 +31,7 @@ import org.sonar.api.utils.System2; | |||
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; | |||
@@ -56,13 +57,14 @@ public class RuleResultSetIteratorTest { | |||
.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") | |||
@@ -79,8 +81,7 @@ public class RuleResultSetIteratorTest { | |||
@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); | |||
@@ -107,7 +108,7 @@ public class RuleResultSetIteratorTest { | |||
@Test | |||
public void iterator_over_rules() { | |||
dbClient.ruleDao().insert(dbSession, templateRule); | |||
dbTester.rules().insertRule(templateRule); | |||
dbClient.ruleDao().insert(dbSession, customRule); | |||
dbSession.commit(); | |||
@@ -150,7 +151,7 @@ public class RuleResultSetIteratorTest { | |||
@Test | |||
public void custom_rule() { | |||
dbClient.ruleDao().insert(dbSession, templateRule); | |||
dbTester.rules().insertRule(templateRule); | |||
dbClient.ruleDao().insert(dbSession, customRule.setTemplateId(templateRule.getId())); | |||
dbSession.commit(); | |||
@@ -171,7 +172,7 @@ public class RuleResultSetIteratorTest { | |||
@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); |
@@ -76,9 +76,10 @@ public class CreateActionMediumTest { | |||
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") | |||
@@ -95,7 +96,7 @@ public class CreateActionMediumTest { | |||
@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) | |||
@@ -105,7 +106,7 @@ public class CreateActionMediumTest { | |||
.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") |
@@ -50,8 +50,8 @@ public class ListActionTest { | |||
@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() |
@@ -111,7 +111,8 @@ public class RulesWsMediumTest { | |||
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); | |||
@@ -140,15 +141,17 @@ public class RulesWsMediumTest { | |||
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(); |
@@ -20,7 +20,6 @@ | |||
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; | |||
@@ -43,6 +42,7 @@ import org.sonar.db.qualityprofile.ActiveRuleParamDto; | |||
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; | |||
@@ -77,7 +77,6 @@ public class SearchActionMediumTest { | |||
private static final String API_SEARCH_METHOD = "search"; | |||
private DbClient db; | |||
private RulesWs ws; | |||
private RuleDao ruleDao; | |||
private DbSession dbSession; | |||
private RuleIndexer ruleIndexer; | |||
@@ -89,7 +88,6 @@ public class SearchActionMediumTest { | |||
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); | |||
@@ -113,8 +111,8 @@ public class SearchActionMediumTest { | |||
@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(); | |||
@@ -133,10 +131,14 @@ public class SearchActionMediumTest { | |||
@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(); | |||
@@ -149,13 +151,13 @@ public class SearchActionMediumTest { | |||
@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(); | |||
@@ -169,8 +171,8 @@ public class SearchActionMediumTest { | |||
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(); | |||
@@ -182,7 +184,7 @@ public class SearchActionMediumTest { | |||
@Test | |||
public void return_lang_field() throws Exception { | |||
ruleDao.insert(dbSession, RuleTesting.newXooX1()); | |||
ruleDao.insert(dbSession, RuleTesting.newXooX1().getDefinition()); | |||
dbSession.commit(); | |||
ruleIndexer.index(); | |||
@@ -197,7 +199,7 @@ public class SearchActionMediumTest { | |||
@Test | |||
public void return_lang_name_field() throws Exception { | |||
ruleDao.insert(dbSession, RuleTesting.newXooX1()); | |||
ruleDao.insert(dbSession, RuleTesting.newXooX1().getDefinition()); | |||
dbSession.commit(); | |||
ruleIndexer.index(); | |||
@@ -212,7 +214,7 @@ public class SearchActionMediumTest { | |||
@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(); | |||
@@ -225,13 +227,15 @@ public class SearchActionMediumTest { | |||
@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(); | |||
@@ -243,13 +247,15 @@ public class SearchActionMediumTest { | |||
@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(); | |||
@@ -261,13 +267,15 @@ public class SearchActionMediumTest { | |||
@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(); | |||
@@ -280,10 +288,10 @@ public class SearchActionMediumTest { | |||
@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(); | |||
@@ -297,8 +305,8 @@ public class SearchActionMediumTest { | |||
@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(); | |||
@@ -315,7 +323,7 @@ public class SearchActionMediumTest { | |||
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); | |||
@@ -344,29 +352,30 @@ public class SearchActionMediumTest { | |||
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); | |||
@@ -416,7 +425,7 @@ public class SearchActionMediumTest { | |||
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); | |||
@@ -441,22 +450,23 @@ public class SearchActionMediumTest { | |||
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); | |||
@@ -487,7 +497,8 @@ public class SearchActionMediumTest { | |||
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(); | |||
@@ -502,11 +513,11 @@ public class SearchActionMediumTest { | |||
@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(); | |||
@@ -536,9 +547,9 @@ public class SearchActionMediumTest { | |||
@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(); | |||
@@ -551,9 +562,15 @@ public class SearchActionMediumTest { | |||
@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(); | |||
@@ -582,10 +599,12 @@ public class SearchActionMediumTest { | |||
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(); | |||
@@ -609,13 +628,15 @@ public class SearchActionMediumTest { | |||
@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(); | |||
@@ -36,6 +36,7 @@ import org.sonar.db.qualityprofile.ActiveRuleParamDto; | |||
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; | |||
@@ -98,9 +99,11 @@ public class ShowActionMediumTest { | |||
.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(); | |||
@@ -124,7 +127,8 @@ public class ShowActionMediumTest { | |||
.setRemediationFunction(null) | |||
.setRemediationGapMultiplier(null) | |||
.setRemediationBaseEffort(null); | |||
ruleDao.insert(session, ruleDto); | |||
ruleDao.insert(session, ruleDto.getDefinition()); | |||
ruleDao.update(session, ruleDto.getMetadata()); | |||
session.commit(); | |||
session.clearCache(); | |||
@@ -150,7 +154,8 @@ public class ShowActionMediumTest { | |||
.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(); | |||
@@ -174,7 +179,8 @@ public class ShowActionMediumTest { | |||
.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(); | |||
@@ -195,11 +201,8 @@ public class ShowActionMediumTest { | |||
.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(); | |||
@@ -212,7 +215,7 @@ public class ShowActionMediumTest { | |||
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 | |||
@@ -244,7 +247,8 @@ public class ShowActionMediumTest { | |||
.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") | |||
@@ -264,9 +268,10 @@ public class ShowActionMediumTest { | |||
.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()) |
@@ -32,6 +32,7 @@ import org.sonar.db.DbClient; | |||
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; | |||
@@ -39,7 +40,6 @@ import org.sonar.server.organization.DefaultOrganization; | |||
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; | |||
@@ -62,7 +62,6 @@ public class UpdateActionMediumTest { | |||
public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester); | |||
private WsTester wsTester; | |||
private RuleService ruleService; | |||
private RuleDao ruleDao; | |||
private DbSession session; | |||
private OrganizationDto defaultOrganization; | |||
@@ -71,7 +70,6 @@ public class UpdateActionMediumTest { | |||
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); | |||
@@ -90,11 +88,8 @@ public class UpdateActionMediumTest { | |||
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") | |||
@@ -114,7 +109,8 @@ public class UpdateActionMediumTest { | |||
.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") | |||
@@ -129,9 +125,11 @@ public class UpdateActionMediumTest { | |||
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 | |||
@@ -159,11 +157,11 @@ public class UpdateActionMediumTest { | |||
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(); | |||
@@ -131,7 +131,7 @@ public class ViewIndexerTest { | |||
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())); |