From 4b25bc908dd178cd656002d28851e0b4ec0fdb95 Mon Sep 17 00:00:00 2001 From: =?utf8?q?S=C3=A9bastien=20Lesaint?= Date: Wed, 22 Mar 2017 11:49:05 +0100 Subject: [PATCH] SONAR-8867 read and write into table RULES_METADATA --- .../main/java/org/sonar/db/rule/RuleDao.java | 42 +++- .../main/java/org/sonar/db/rule/RuleDto.java | 68 +++++-- .../java/org/sonar/db/rule/RuleMapper.java | 18 +- .../org/sonar/db/rule/RuleMetadataDto.java | 24 ++- .../org/sonar/db/rule/RuleMapper.xml | 122 ++++++++--- .../java/org/sonar/db/rule/RuleDaoTest.java | 192 ++++++++++++++++-- .../java/org/sonar/db/rule/RuleTesting.java | 2 +- .../index/IssueIteratorForSingleChunk.java | 2 +- .../org/sonar/server/rule/RuleCreator.java | 2 + .../org/sonar/server/rule/RuleUpdater.java | 112 +++++----- .../server/rule/RuleCreatorMediumTest.java | 25 ++- .../server/rule/RuleServiceMediumTest.java | 6 +- .../server/rule/RuleUpdaterMediumTest.java | 46 +++-- .../server/rule/ws/RulesWsMediumTest.java | 4 +- .../rule/ws/SearchActionMediumTest.java | 10 +- .../server/rule/ws/ShowActionMediumTest.java | 22 +- .../rule/ws/UpdateActionMediumTest.java | 1 + 17 files changed, 500 insertions(+), 198 deletions(-) diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/rule/RuleDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/rule/RuleDao.java index 3aa63aff07d..1323982ceec 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/rule/RuleDao.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/rule/RuleDao.java @@ -22,6 +22,7 @@ package org.sonar.db.rule; import com.google.common.base.Optional; import java.util.Collection; import java.util.List; +import javax.annotation.Nullable; import org.apache.ibatis.session.ResultHandler; import org.sonar.api.rule.RuleKey; import org.sonar.api.rules.RuleQuery; @@ -35,7 +36,9 @@ import static org.sonar.db.DatabaseUtils.executeLargeInputs; public class RuleDao implements Dao { public Optional selectByKey(DbSession session, String organizationUuid, RuleKey key) { - return Optional.fromNullable(mapper(session).selectByKey(key)); + RuleDto res = mapper(session).selectByKey(organizationUuid, key); + ensureOrganizationIsSet(organizationUuid, res); + return Optional.fromNullable(res); } public Optional selectDefinitionByKey(DbSession session, RuleKey key) { @@ -43,10 +46,11 @@ public class RuleDao implements Dao { } public RuleDto selectOrFailByKey(DbSession session, String organizationUuid, RuleKey key) { - RuleDto rule = mapper(session).selectByKey(key); + RuleDto rule = mapper(session).selectByKey(organizationUuid, key); if (rule == null) { throw new RowNotFoundException(String.format("Rule with key '%s' does not exist", key)); } + ensureOrganizationIsSet(organizationUuid, rule); return rule; } @@ -59,7 +63,9 @@ public class RuleDao implements Dao { } public Optional selectById(long id, String organizationUuid, DbSession session) { - return Optional.fromNullable(mapper(session).selectById(id)); + RuleDto res = mapper(session).selectById(organizationUuid, id); + ensureOrganizationIsSet(organizationUuid, res); + return Optional.fromNullable(res); } public Optional selectDefinitionById(long id, DbSession session) { @@ -67,7 +73,9 @@ public class RuleDao implements Dao { } public List selectByIds(DbSession session, String organizationUuid, List ids) { - return executeLargeInputs(ids, mapper(session)::selectByIds); + return ensureOrganizationIsSet( + organizationUuid, + executeLargeInputs(ids, chunk -> mapper(session).selectByIds(organizationUuid, chunk))); } public List selectDefinitionByIds(DbSession session, List ids) { @@ -75,7 +83,8 @@ public class RuleDao implements Dao { } public List selectByKeys(DbSession session, String organizationUuid, Collection keys) { - return executeLargeInputs(keys, mapper(session)::selectByKeys); + return ensureOrganizationIsSet(organizationUuid, + executeLargeInputs(keys, chunk -> mapper(session).selectByKeys(organizationUuid, chunk))); } public List selectDefinitionByKeys(DbSession session, Collection keys) { @@ -87,7 +96,7 @@ public class RuleDao implements Dao { } public List selectAll(DbSession session, String organizationUuid) { - return mapper(session).selectAll(); + return ensureOrganizationIsSet(organizationUuid, mapper(session).selectAll(organizationUuid)); } public List selectAllDefinitions(DbSession session) { @@ -95,11 +104,22 @@ public class RuleDao implements Dao { } public List selectByQuery(DbSession session, String organizationUuid, RuleQuery ruleQuery) { - return mapper(session).selectByQuery(ruleQuery); + return ensureOrganizationIsSet(organizationUuid, mapper(session).selectByQuery(organizationUuid, ruleQuery)); + } + + private static void ensureOrganizationIsSet(String organizationUuid, @Nullable RuleDto res) { + if (res != null) { + res.setOrganizationUuid(organizationUuid); + } + } + + private static List ensureOrganizationIsSet(String organizationUuid, List res) { + res.forEach(dto -> ensureOrganizationIsSet(organizationUuid, dto)); + return res; } public void insert(DbSession session, RuleDefinitionDto dto) { - mapper(session).insert(dto); + mapper(session).insertDefinition(dto); } public void update(DbSession session, RuleDefinitionDto dto) { @@ -107,7 +127,11 @@ public class RuleDao implements Dao { } public void update(DbSession session, RuleMetadataDto dto) { - mapper(session).updateMetadata(dto); + if (mapper(session).countMetadata(dto) > 0) { + mapper(session).updateMetadata(dto); + } else { + mapper(session).insertMetadata(dto); + } } private static RuleMapper mapper(DbSession session) { diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/rule/RuleDto.java b/server/sonar-db-dao/src/main/java/org/sonar/db/rule/RuleDto.java index 962537dd74e..66267ab3e96 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/rule/RuleDto.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/rule/RuleDto.java @@ -19,7 +19,6 @@ */ package org.sonar.db.rule; -import java.util.Date; import java.util.Set; import javax.annotation.CheckForNull; import javax.annotation.Nullable; @@ -234,15 +233,45 @@ public class RuleDto { return this; } + public Set getSystemTags() { + return definition.getSystemTags(); + } + + /** + * Used in MyBatis mapping. + */ + private void setSystemTagsField(String s) { + definition.setSystemTagsField(s); + } + public long getCreatedAt() { return definition.getCreatedAt(); } public RuleDto setCreatedAt(long createdAt) { definition.setCreatedAt(createdAt); + metadata.setCreatedAt(createdAt); return this; } + /** + * Used in MyBatis mapping. + */ + private void setCreatedAtFromDefinition(@Nullable Long createdAt) { + if (createdAt != null && createdAt > definition.getCreatedAt()) { + setCreatedAt(createdAt); + } + } + + /** + * Used in MyBatis mapping. + */ + private void setCreatedAtFromMetadata(@Nullable Long createdAt) { + if (createdAt != null && createdAt > definition.getCreatedAt()) { + setCreatedAt(createdAt); + } + } + public long getUpdatedAt() { return definition.getUpdatedAt(); } @@ -253,6 +282,24 @@ public class RuleDto { return this; } + /** + * Used in MyBatis mapping. + */ + private void setUpdatedAtFromDefinition(@Nullable Long updatedAt) { + if (updatedAt != null && updatedAt > definition.getUpdatedAt()) { + setUpdatedAt(updatedAt); + } + } + + /** + * Used in MyBatis mapping. + */ + private void setUpdatedAtFromMetadata(@Nullable Long updatedAt) { + if (updatedAt != null && updatedAt > definition.getUpdatedAt()) { + setUpdatedAt(updatedAt); + } + } + public String getOrganizationUuid() { return metadata.getOrganizationUuid(); } @@ -283,21 +330,21 @@ public class RuleDto { } @CheckForNull - public Date getNoteCreatedAt() { + public Long getNoteCreatedAt() { return metadata.getNoteCreatedAt(); } - public RuleDto setNoteCreatedAt(@Nullable Date noteCreatedAt) { + public RuleDto setNoteCreatedAt(@Nullable Long noteCreatedAt) { metadata.setNoteCreatedAt(noteCreatedAt); return this; } @CheckForNull - public Date getNoteUpdatedAt() { + public Long getNoteUpdatedAt() { return metadata.getNoteUpdatedAt(); } - public RuleDto setNoteUpdatedAt(@Nullable Date noteUpdatedAt) { + public RuleDto setNoteUpdatedAt(@Nullable Long noteUpdatedAt) { metadata.setNoteUpdatedAt(noteUpdatedAt); return this; } @@ -336,18 +383,13 @@ public class RuleDto { return metadata.getTags(); } + /** + * Used in MyBatis mapping. + */ private void setTagsField(String s) { metadata.setTagsField(s); } - public Set getSystemTags() { - return definition.getSystemTags(); - } - - private void setSystemTagsField(String s) { - definition.setSystemTagsField(s); - } - public RuleDto setTags(Set tags) { this.metadata.setTags(tags); return this; diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/rule/RuleMapper.java b/server/sonar-db-dao/src/main/java/org/sonar/db/rule/RuleMapper.java index b9c20bfdf54..f753a624f80 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/rule/RuleMapper.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/rule/RuleMapper.java @@ -27,34 +27,38 @@ import org.sonar.api.rules.RuleQuery; public interface RuleMapper { - List selectAll(); + List selectAll(@Param("organizationUuid") String organizationUuid); List selectAllDefinitions(); void selectEnabled(ResultHandler resultHandler); - RuleDto selectById(long id); + RuleDto selectById(@Param("organizationUuid") String organizationUuid, @Param("id") long id); RuleDefinitionDto selectDefinitionById(long id); - List selectByIds(@Param("ids") List ids); + List selectByIds(@Param("organizationUuid") String organizationUuid, @Param("ids") List ids); List selectDefinitionByIds(@Param("ids") List ids); - RuleDto selectByKey(RuleKey ruleKey); + RuleDto selectByKey(@Param("organizationUuid") String organizationUuid, @Param("ruleKey") RuleKey ruleKey); RuleDefinitionDto selectDefinitionByKey(RuleKey ruleKey); - List selectByKeys(@Param("ruleKeys") List keys); + List selectByKeys(@Param("organizationUuid") String organizationUuid, @Param("ruleKeys") List keys); List selectDefinitionByKeys(@Param("ruleKeys") List keys); - List selectByQuery(@Param("query") RuleQuery ruleQuery); + List selectByQuery(@Param("organizationUuid") String organizationUuid, @Param("query") RuleQuery ruleQuery); - void insert(RuleDefinitionDto ruleDefinitionDto); + void insertDefinition(RuleDefinitionDto ruleDefinitionDto); void updateDefinition(RuleDefinitionDto ruleDefinitionDto); + int countMetadata(RuleMetadataDto ruleMetadataDto); + + void insertMetadata(RuleMetadataDto ruleMetadataDto); + void updateMetadata(RuleMetadataDto ruleMetadataDto); List selectParamsByRuleIds(@Param("ruleIds") List ruleIds); diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/rule/RuleMetadataDto.java b/server/sonar-db-dao/src/main/java/org/sonar/db/rule/RuleMetadataDto.java index 3ce1e937f04..594611079fc 100644 --- a/server/sonar-db-dao/src/main/java/org/sonar/db/rule/RuleMetadataDto.java +++ b/server/sonar-db-dao/src/main/java/org/sonar/db/rule/RuleMetadataDto.java @@ -20,7 +20,6 @@ package org.sonar.db.rule; import java.util.Arrays; -import java.util.Date; import java.util.HashSet; import java.util.Set; import java.util.TreeSet; @@ -35,12 +34,13 @@ public class RuleMetadataDto { private String organizationUuid; private String noteData; private String noteUserLogin; - private Date noteCreatedAt; - private Date noteUpdatedAt; + private Long noteCreatedAt; + private Long noteUpdatedAt; private String remediationFunction; private String remediationGapMultiplier; private String remediationBaseEffort; private String tags; + private long createdAt; private long updatedAt; public int getRuleId() { @@ -82,21 +82,21 @@ public class RuleMetadataDto { } @CheckForNull - public Date getNoteCreatedAt() { + public Long getNoteCreatedAt() { return noteCreatedAt; } - public RuleMetadataDto setNoteCreatedAt(@Nullable Date noteCreatedAt) { + public RuleMetadataDto setNoteCreatedAt(@Nullable Long noteCreatedAt) { this.noteCreatedAt = noteCreatedAt; return this; } @CheckForNull - public Date getNoteUpdatedAt() { + public Long getNoteUpdatedAt() { return noteUpdatedAt; } - public RuleMetadataDto setNoteUpdatedAt(@Nullable Date noteUpdatedAt) { + public RuleMetadataDto setNoteUpdatedAt(@Nullable Long noteUpdatedAt) { this.noteUpdatedAt = noteUpdatedAt; return this; } @@ -150,6 +150,15 @@ public class RuleMetadataDto { tags = s; } + public long getCreatedAt() { + return createdAt; + } + + public RuleMetadataDto setCreatedAt(long createdAt) { + this.createdAt = createdAt; + return this; + } + public long getUpdatedAt() { return updatedAt; } @@ -172,6 +181,7 @@ public class RuleMetadataDto { ", remediationGapMultiplier='" + remediationGapMultiplier + '\'' + ", remediationBaseEffort='" + remediationBaseEffort + '\'' + ", tags='" + tags + '\'' + + ", createdAt=" + createdAt + ", updatedAt=" + updatedAt + '}'; } diff --git a/server/sonar-db-dao/src/main/resources/org/sonar/db/rule/RuleMapper.xml b/server/sonar-db-dao/src/main/resources/org/sonar/db/rule/RuleMapper.xml index 9cabba05d38..487a9837300 100644 --- a/server/sonar-db-dao/src/main/resources/org/sonar/db/rule/RuleMapper.xml +++ b/server/sonar-db-dao/src/main/resources/org/sonar/db/rule/RuleMapper.xml @@ -22,57 +22,73 @@ r.gap_description as "gapDescription", r.system_tags as "systemTagsField", r.rule_type as "type", + + + + r.created_at as "createdAt", r.updated_at as "updatedAt" - - , - r.note_data as "noteData", - r.note_user_login as "noteUserLogin", - r.note_created_at as "noteCreatedAt", - r.note_updated_at as "noteUpdatedAt", - r.remediation_function as "remediationFunction", - r.remediation_gap_mult as "remediationGapMultiplier", - r.remediation_base_effort as "remediationBaseEffort", - r.tags as "tagsField" + + + r.created_at as "createdAtFromDefinition", + r.updated_at as "updatedAtFromDefinition", + rm.note_data as "noteData", + rm.note_user_login as "noteUserLogin", + rm.note_created_at as "noteCreatedAt", + rm.note_updated_at as "noteUpdatedAt", + rm.remediation_function as "remediationFunction", + rm.remediation_gap_mult as "remediationGapMultiplier", + rm.remediation_base_effort as "remediationBaseEffort", + rm.tags as "tagsField", + rm.created_at as "createdAtFromMetadata", + rm.updated_at as "updatedAtFromMetadata" + + + + left outer join rules_metadata rm on + rm.rule_id = r.id + and rm.organization_uuid = #{organizationUuid,jdbcType=VARCHAR} - select - + from rules r + where r.id=#{id,jdbcType=INTEGER} select - + from rules r + where r.id=#{id,jdbcType=INTEGER} @@ -92,7 +109,7 @@ select - + from rules r + where - r.plugin_name=#{repository,jdbcType=VARCHAR} - and r.plugin_rule_key=#{rule,jdbcType=VARCHAR} + r.plugin_name=#{ruleKey.repository,jdbcType=VARCHAR} + and r.plugin_rule_key=#{ruleKey.rule,jdbcType=VARCHAR} select - + from rules r + where (r.plugin_name=#{ruleKey.repository,jdbcType=VARCHAR} and r.plugin_rule_key=#{ruleKey.rule,jdbcType=VARCHAR}) @@ -134,7 +153,7 @@ select - + from rules r + where r.status != 'REMOVED' @@ -163,7 +183,7 @@ r.updated_at desc - + insert into rules ( plugin_rule_key, plugin_name, @@ -232,19 +252,61 @@ id=#{id,jdbcType=INTEGER} + + + + insert into rules_metadata ( + rule_id, + organization_uuid, + note_data, + note_user_login, + note_created_at, + note_updated_at, + remediation_function, + remediation_gap_mult, + remediation_base_effort, + tags, + created_at, + updated_at + ) + values ( + #{ruleId,jdbcType=INTEGER}, + #{organizationUuid,jdbcType=VARCHAR}, + #{noteData,jdbcType=CLOB}, + #{noteUserLogin,jdbcType=VARCHAR}, + #{noteCreatedAt,jdbcType=BIGINT}, + #{noteUpdatedAt,jdbcType=BIGINT}, + #{remediationFunction,jdbcType=VARCHAR}, + #{remediationGapMultiplier,jdbcType=VARCHAR}, + #{remediationBaseEffort,jdbcType=VARCHAR}, + #{tagsField,jdbcType=VARCHAR}, + #{createdAt,jdbcType=BIGINT}, + #{updatedAt,jdbcType=BIGINT} + ) + + - update rules set + update rules_metadata set note_data=#{noteData,jdbcType=CLOB}, note_user_login=#{noteUserLogin,jdbcType=VARCHAR}, - note_created_at=#{noteCreatedAt,jdbcType=TIMESTAMP}, - note_updated_at=#{noteUpdatedAt,jdbcType=TIMESTAMP}, + note_created_at=#{noteCreatedAt,jdbcType=BIGINT}, + note_updated_at=#{noteUpdatedAt,jdbcType=BIGINT}, remediation_function=#{remediationFunction,jdbcType=VARCHAR}, remediation_gap_mult=#{remediationGapMultiplier,jdbcType=VARCHAR}, remediation_base_effort=#{remediationBaseEffort,jdbcType=VARCHAR}, tags=#{tagsField,jdbcType=VARCHAR}, updated_at=#{updatedAt,jdbcType=BIGINT} where - id=#{ruleId,jdbcType=INTEGER} + rule_id=#{ruleId,jdbcType=INTEGER} + and organization_uuid=#{organizationUuid,jdbcType=VARCHAR} diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/rule/RuleDaoTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/rule/RuleDaoTest.java index 38a85c7bddd..d1d062dd790 100644 --- a/server/sonar-db-dao/src/test/java/org/sonar/db/rule/RuleDaoTest.java +++ b/server/sonar-db-dao/src/test/java/org/sonar/db/rule/RuleDaoTest.java @@ -68,6 +68,14 @@ public class RuleDaoTest { assertThat(rule.get().getId()).isEqualTo(1); } + @Test + public void selectByKey_populates_organizationUuid_even_when_organization_has_no_metadata() { + dbTester.prepareDbUnit(getClass(), "shared.xml"); + + assertThat(underTest.selectByKey(dbTester.getSession(), ORGANIZATION_UUID, RuleKey.of("java", "S001")).get().getOrganizationUuid()) + .isEqualTo(ORGANIZATION_UUID); + } + @Test public void selectDefinitionByKey() { dbTester.prepareDbUnit(getClass(), "shared.xml"); @@ -90,6 +98,15 @@ public class RuleDaoTest { assertThat(ruleDtoOptional.get().getId()).isEqualTo(1); } + @Test + public void selectById_populates_organizationUuid_even_when_organization_has_no_metadata() { + dbTester.prepareDbUnit(getClass(), "shared.xml"); + String organizationUuid = "org-1"; + + assertThat(underTest.selectById(1l, organizationUuid, dbTester.getSession()).get().getOrganizationUuid()) + .isEqualTo(organizationUuid); + } + @Test public void selectDefinitionById() { dbTester.prepareDbUnit(getClass(), "shared.xml"); @@ -103,8 +120,8 @@ public class RuleDaoTest { @Test public void selectByIds() { dbTester.prepareDbUnit(getClass(), "shared.xml"); - String organizationUuid = "org-1"; + assertThat(underTest.selectByIds(dbTester.getSession(), organizationUuid, asList(1))).hasSize(1); assertThat(underTest.selectByIds(dbTester.getSession(), organizationUuid, asList(1, 2))).hasSize(2); assertThat(underTest.selectByIds(dbTester.getSession(), organizationUuid, asList(1, 2, 3))).hasSize(2); @@ -112,6 +129,16 @@ public class RuleDaoTest { assertThat(underTest.selectByIds(dbTester.getSession(), organizationUuid, asList(123))).isEmpty(); } + @Test + public void selectByIds_populates_organizationUuid_even_when_organization_has_no_metadata() { + dbTester.prepareDbUnit(getClass(), "shared.xml"); + String organizationUuid = "org-1"; + + assertThat(underTest.selectByIds(dbTester.getSession(), organizationUuid, asList(1, 2))) + .extracting(RuleDto::getOrganizationUuid) + .containsExactly(organizationUuid, organizationUuid); + } + @Test public void selectDefinitionByIds() { dbTester.prepareDbUnit(getClass(), "shared.xml"); @@ -127,7 +154,7 @@ public class RuleDaoTest { public void selectOrFailByKey() { dbTester.prepareDbUnit(getClass(), "shared.xml"); - RuleDefinitionDto rule = underTest.selectOrFailDefinitionByKey(dbTester.getSession(), RuleKey.of("java", "S001")); + RuleDto rule = underTest.selectOrFailByKey(dbTester.getSession(), "org-1", RuleKey.of("java", "S001")); assertThat(rule.getId()).isEqualTo(1); } @@ -141,6 +168,15 @@ public class RuleDaoTest { underTest.selectOrFailByKey(dbTester.getSession(), "org-1", RuleKey.of("NOT", "FOUND")); } + @Test + public void selectOrFailByKey_populates_organizationUuid_even_when_organization_has_no_metadata() { + dbTester.prepareDbUnit(getClass(), "shared.xml"); + String organizationUuid = "org-1"; + + assertThat(underTest.selectOrFailByKey(dbTester.getSession(), organizationUuid, RuleKey.of("java", "S001")).getOrganizationUuid()) + .isEqualTo(organizationUuid); + } + @Test public void selectOrFailDefinitionByKey_fails_if_rule_not_found() { dbTester.prepareDbUnit(getClass(), "shared.xml"); @@ -164,6 +200,16 @@ public class RuleDaoTest { assertThat(rules.get(0).getId()).isEqualTo(1); } + @Test + public void selectByKeys_populates_organizationUuid_even_when_organization_has_no_metadata() { + dbTester.prepareDbUnit(getClass(), "shared.xml"); + String organizationUuid = "org-1"; + + assertThat(underTest.selectByKeys(dbTester.getSession(), organizationUuid, asList(RuleKey.of("java", "S001"), RuleKey.of("java", "OTHER")))) + .extracting(RuleDto::getOrganizationUuid) + .containsExactly(organizationUuid); + } + @Test public void selectDefinitionByKeys() { dbTester.prepareDbUnit(getClass(), "shared.xml"); @@ -180,9 +226,19 @@ public class RuleDaoTest { public void selectAll() { dbTester.prepareDbUnit(getClass(), "shared.xml"); - List ruleDtos = underTest.selectAll(dbTester.getSession(), "org-1"); + assertThat(underTest.selectAll(dbTester.getSession(), "org-1")) + .extracting(RuleDto::getId) + .containsOnly(1, 2, 10); + } - assertThat(ruleDtos).extracting("id").containsOnly(1, 2, 10); + @Test + public void selectAll_populates_organizationUuid_even_when_organization_has_no_metadata() { + dbTester.prepareDbUnit(getClass(), "shared.xml"); + String organizationUuid = "org-1"; + + assertThat(underTest.selectAll(dbTester.getSession(), organizationUuid)) + .extracting(RuleDto::getOrganizationUuid) + .containsExactly(organizationUuid, organizationUuid, organizationUuid); } @Test @@ -229,6 +285,16 @@ public class RuleDaoTest { RuleQuery.create().withKey("S001").withConfigKey("S1").withRepositoryKey("java"))).hasSize(1); } + @Test + public void select_by_query_populates_organizationUuid_even_when_organization_has_no_metadata() { + dbTester.prepareDbUnit(getClass(), "shared.xml"); + String organizationUuid = "org-1"; + + assertThat(underTest.selectByQuery(dbTester.getSession(), organizationUuid, RuleQuery.create())) + .extracting(RuleDto::getOrganizationUuid) + .containsExactly(organizationUuid, organizationUuid); + } + @Test public void insert() throws Exception { RuleDefinitionDto newRule = new RuleDefinitionDto() @@ -249,8 +315,8 @@ public class RuleDaoTest { .setGapDescription("squid.S115.effortToFix") .setSystemTags(newHashSet("systag1", "systag2")) .setType(RuleType.BUG) - .setCreatedAt(1500000000000L) - .setUpdatedAt(2000000000000L); + .setCreatedAt(1_500_000_000_000L) + .setUpdatedAt(2_000_000_000_000L); underTest.insert(dbTester.getSession(), newRule); dbTester.getSession().commit(); @@ -273,8 +339,8 @@ public class RuleDaoTest { assertThat(ruleDto.getGapDescription()).isEqualTo("squid.S115.effortToFix"); assertThat(ruleDto.getSystemTags()).containsOnly("systag1", "systag2"); assertThat(ruleDto.getType()).isEqualTo(RuleType.BUG.getDbConstant()); - assertThat(ruleDto.getCreatedAt()).isEqualTo(1500000000000L); - assertThat(ruleDto.getUpdatedAt()).isEqualTo(2000000000000L); + assertThat(ruleDto.getCreatedAt()).isEqualTo(1_500_000_000_000L); + assertThat(ruleDto.getUpdatedAt()).isEqualTo(2_000_000_000_000L); } @Test @@ -300,7 +366,7 @@ public class RuleDaoTest { .setGapDescription("squid.S115.effortToFix") .setSystemTags(newHashSet("systag1", "systag2")) .setType(RuleType.BUG) - .setUpdatedAt(2000000000000L); + .setUpdatedAt(2_000_000_000_000L); underTest.update(dbTester.getSession(), ruleToUpdate); dbTester.getSession().commit(); @@ -323,27 +389,28 @@ public class RuleDaoTest { assertThat(ruleDto.getGapDescription()).isEqualTo("squid.S115.effortToFix"); assertThat(ruleDto.getSystemTags()).containsOnly("systag1", "systag2"); assertThat(ruleDto.getType()).isEqualTo(RuleType.BUG.getDbConstant()); - assertThat(ruleDto.getCreatedAt()).isEqualTo(1500000000000L); - assertThat(ruleDto.getUpdatedAt()).isEqualTo(2000000000000L); + assertThat(ruleDto.getCreatedAt()).isEqualTo(1_500_000_000_000L); + assertThat(ruleDto.getUpdatedAt()).isEqualTo(2_000_000_000_000L); } @Test - public void update_RuleMetadataDto() { + public void update_RuleMetadataDto_inserts_row_in_RULE_METADATA_if_not_exists_yet() { dbTester.prepareDbUnit(getClass(), "update.xml"); - String organizationUuid = "org-1"; + RuleMetadataDto ruleToUpdate = new RuleMetadataDto() .setRuleId(1) .setOrganizationUuid(organizationUuid) .setNoteData("My note") .setNoteUserLogin("admin") - .setNoteCreatedAt(DateUtils.parseDate("2013-12-19")) - .setNoteUpdatedAt(DateUtils.parseDate("2013-12-20")) + .setNoteCreatedAt(DateUtils.parseDate("2013-12-19").getTime()) + .setNoteUpdatedAt(DateUtils.parseDate("2013-12-20").getTime()) .setRemediationFunction(DebtRemediationFunction.Type.LINEAR.toString()) .setRemediationGapMultiplier("1h") .setRemediationBaseEffort("5min") .setTags(newHashSet("tag1", "tag2")) - .setUpdatedAt(2000000000000L); + .setCreatedAt(3_500_000_000_000L) + .setUpdatedAt(4_000_000_000_000L); underTest.update(dbTester.getSession(), ruleToUpdate); dbTester.getSession().commit(); @@ -374,8 +441,97 @@ public class RuleDaoTest { assertThat(ruleDto.getTags()).containsOnly("tag1", "tag2"); assertThat(ruleDto.getSystemTags()).isEmpty(); assertThat(ruleDto.getType()).isEqualTo(0); - assertThat(ruleDto.getCreatedAt()).isEqualTo(1500000000000L); - assertThat(ruleDto.getUpdatedAt()).isEqualTo(2000000000000L); + assertThat(ruleDto.getCreatedAt()).isEqualTo(3_500_000_000_000L); + assertThat(ruleDto.getUpdatedAt()).isEqualTo(4_000_000_000_000L); + } + + @Test + public void update_RuleMetadataDto_updates_row_in_RULE_METADATA_if_already_exists() { + dbTester.prepareDbUnit(getClass(), "update.xml"); + String organizationUuid = "org-1"; + RuleMetadataDto metadataV1 = new RuleMetadataDto() + .setRuleId(1) + .setOrganizationUuid(organizationUuid) + .setCreatedAt(3_500_000_000_000L) + .setUpdatedAt(4_000_000_000_000L); + RuleMetadataDto metadataV2 = new RuleMetadataDto() + .setRuleId(1) + .setOrganizationUuid(organizationUuid) + .setNoteData("My note") + .setNoteUserLogin("admin") + .setNoteCreatedAt(DateUtils.parseDate("2013-12-19").getTime()) + .setNoteUpdatedAt(DateUtils.parseDate("2013-12-20").getTime()) + .setRemediationFunction(DebtRemediationFunction.Type.LINEAR.toString()) + .setRemediationGapMultiplier("1h") + .setRemediationBaseEffort("5min") + .setTags(newHashSet("tag1", "tag2")) + .setCreatedAt(6_500_000_000_000L) + .setUpdatedAt(7_000_000_000_000L); + + underTest.update(dbTester.getSession(), metadataV1); + dbTester.commit(); + + assertThat(dbTester.countRowsOfTable("RULES_METADATA")).isEqualTo(1); + RuleDto ruleDto = underTest.selectOrFailByKey(dbTester.getSession(), organizationUuid, 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()).isNull(); + assertThat(ruleDto.getNoteUserLogin()).isNull(); + assertThat(ruleDto.getNoteCreatedAt()).isNull(); + assertThat(ruleDto.getNoteUpdatedAt()).isNull(); + assertThat(ruleDto.getRemediationFunction()).isNull(); + assertThat(ruleDto.getDefaultRemediationFunction()).isNull(); + assertThat(ruleDto.getRemediationGapMultiplier()).isNull(); + assertThat(ruleDto.getDefaultRemediationGapMultiplier()).isNull(); + assertThat(ruleDto.getRemediationBaseEffort()).isNull(); + assertThat(ruleDto.getDefaultRemediationBaseEffort()).isNull(); + assertThat(ruleDto.getGapDescription()).isNull(); + assertThat(ruleDto.getTags()).isEmpty(); + assertThat(ruleDto.getSystemTags()).isEmpty(); + assertThat(ruleDto.getType()).isEqualTo(0); + assertThat(ruleDto.getCreatedAt()).isEqualTo(3_500_000_000_000L); + assertThat(ruleDto.getUpdatedAt()).isEqualTo(4_000_000_000_000L); + + underTest.update(dbTester.getSession(), metadataV2); + dbTester.commit(); + + ruleDto = underTest.selectOrFailByKey(dbTester.getSession(), organizationUuid, 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()).isNull(); + assertThat(ruleDto.getRemediationGapMultiplier()).isEqualTo("1h"); + assertThat(ruleDto.getDefaultRemediationGapMultiplier()).isNull(); + assertThat(ruleDto.getRemediationBaseEffort()).isEqualTo("5min"); + assertThat(ruleDto.getDefaultRemediationBaseEffort()).isNull(); + assertThat(ruleDto.getGapDescription()).isNull(); + assertThat(ruleDto.getTags()).containsOnly("tag1", "tag2"); + assertThat(ruleDto.getSystemTags()).isEmpty(); + assertThat(ruleDto.getType()).isEqualTo(0); + assertThat(ruleDto.getCreatedAt()).isEqualTo(3_500_000_000_000L); + assertThat(ruleDto.getUpdatedAt()).isEqualTo(7_000_000_000_000L); } @Test diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/rule/RuleTesting.java b/server/sonar-db-dao/src/test/java/org/sonar/db/rule/RuleTesting.java index a657a2edffa..c56015f0adf 100644 --- a/server/sonar-db-dao/src/test/java/org/sonar/db/rule/RuleTesting.java +++ b/server/sonar-db-dao/src/test/java/org/sonar/db/rule/RuleTesting.java @@ -100,7 +100,7 @@ public class RuleTesting { return newDto(ruleKey, null); } - private static RuleDto newDto(RuleKey ruleKey, @Nullable OrganizationDto organization) { + public static RuleDto newDto(RuleKey ruleKey, @Nullable OrganizationDto organization) { RuleDto res = new RuleDto() .setRuleKey(ruleKey.rule()) .setRepositoryKey(ruleKey.repository()) diff --git a/server/sonar-server/src/main/java/org/sonar/server/issue/index/IssueIteratorForSingleChunk.java b/server/sonar-server/src/main/java/org/sonar/server/issue/index/IssueIteratorForSingleChunk.java index 91f45308ecf..edb57e5bd16 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/issue/index/IssueIteratorForSingleChunk.java +++ b/server/sonar-server/src/main/java/org/sonar/server/issue/index/IssueIteratorForSingleChunk.java @@ -65,7 +65,7 @@ class IssueIteratorForSingleChunk implements IssueIterator { "i.resolution", "i.severity", - // column 11 + // column 11RegisterRulesMediumTest "i.manual_severity", "i.checksum", "i.status", diff --git a/server/sonar-server/src/main/java/org/sonar/server/rule/RuleCreator.java b/server/sonar-server/src/main/java/org/sonar/server/rule/RuleCreator.java index 2ca1100fda9..03a4fc948d1 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/rule/RuleCreator.java +++ b/server/sonar-server/src/main/java/org/sonar/server/rule/RuleCreator.java @@ -177,8 +177,10 @@ public class RuleCreator { Set tags = templateRuleDto.getTags(); if (!tags.isEmpty()) { RuleMetadataDto ruleMetadata = new RuleMetadataDto() + .setOrganizationUuid(defaultOrganizationProvider.get().getUuid()) .setRuleId(ruleDefinition.getId()) .setTags(tags) + .setCreatedAt(system2.now()) .setUpdatedAt(system2.now()); dbClient.ruleDao().update(dbSession, ruleMetadata); } diff --git a/server/sonar-server/src/main/java/org/sonar/server/rule/RuleUpdater.java b/server/sonar-server/src/main/java/org/sonar/server/rule/RuleUpdater.java index 90b95a974ab..0425bf7bf66 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/rule/RuleUpdater.java +++ b/server/sonar-server/src/main/java/org/sonar/server/rule/RuleUpdater.java @@ -26,7 +26,6 @@ import com.google.common.collect.Lists; import com.google.common.collect.Multimap; import java.util.Collection; import java.util.Collections; -import java.util.Date; import java.util.List; import java.util.Map; import java.util.Set; @@ -94,11 +93,11 @@ public class RuleUpdater { return false; } - Context context = newContext(update); + RuleDto rule = getRuleDto(update); // validate only the changes, not all the rule fields - apply(update, context, userSession); - update(dbSession, context.rule); - updateParameters(dbSession, update, context); + apply(update, rule, userSession); + update(dbSession, rule); + updateParameters(dbSession, update, rule); dbSession.commit(); ruleIndexer.index(); return true; @@ -107,116 +106,115 @@ public class RuleUpdater { /** * Load all the DTOs required for validating changes and updating rule */ - private Context newContext(RuleUpdate change) { + private RuleDto getRuleDto(RuleUpdate change) { try (DbSession dbSession = dbClient.openSession(false)) { - Context context = new Context(); - context.rule = dbClient.ruleDao().selectOrFailByKey(dbSession, defaultOrganizationProvider.get().getUuid(), change.getRuleKey()); - if (RuleStatus.REMOVED == context.rule.getStatus()) { + RuleDto rule = dbClient.ruleDao().selectOrFailByKey(dbSession, defaultOrganizationProvider.get().getUuid(), change.getRuleKey()); + if (RuleStatus.REMOVED == rule.getStatus()) { throw new IllegalArgumentException("Rule with REMOVED status cannot be updated: " + change.getRuleKey()); } - return context; + return rule; } } - private void apply(RuleUpdate update, Context context, UserSession userSession) { + private void apply(RuleUpdate update, RuleDto rule, UserSession userSession) { if (update.isChangeName()) { - updateName(update, context); + updateName(update, rule); } if (update.isChangeDescription()) { - updateDescription(update, context); + updateDescription(update, rule); } if (update.isChangeSeverity()) { - updateSeverity(update, context); + updateSeverity(update, rule); } if (update.isChangeStatus()) { - updateStatus(update, context); + updateStatus(update, rule); } if (update.isChangeMarkdownNote()) { - updateMarkdownNote(update, context, userSession); + updateMarkdownNote(update, rule, userSession); } if (update.isChangeTags()) { - updateTags(update, context); + updateTags(update, rule); } // order is important -> sub-characteristic must be set if (update.isChangeDebtRemediationFunction()) { - updateDebtRemediationFunction(update, context); + updateDebtRemediationFunction(update, rule); } } - private static void updateName(RuleUpdate update, Context context) { + private static void updateName(RuleUpdate update, RuleDto rule) { String name = update.getName(); if (isNullOrEmpty(name)) { throw new IllegalArgumentException("The name is missing"); } - context.rule.setName(name); + rule.setName(name); } - private static void updateDescription(RuleUpdate update, Context context) { + private static void updateDescription(RuleUpdate update, RuleDto rule) { String description = update.getMarkdownDescription(); if (isNullOrEmpty(description)) { throw new IllegalArgumentException("The description is missing"); } - context.rule.setDescription(description); - context.rule.setDescriptionFormat(RuleDto.Format.MARKDOWN); + rule.setDescription(description); + rule.setDescriptionFormat(RuleDto.Format.MARKDOWN); } - private static void updateSeverity(RuleUpdate update, Context context) { + private static void updateSeverity(RuleUpdate update, RuleDto rule) { String severity = update.getSeverity(); if (isNullOrEmpty(severity) || !Severity.ALL.contains(severity)) { throw new IllegalArgumentException("The severity is invalid"); } - context.rule.setSeverity(severity); + rule.setSeverity(severity); } - private static void updateStatus(RuleUpdate update, Context context) { + private static void updateStatus(RuleUpdate update, RuleDto rule) { RuleStatus status = update.getStatus(); if (status == null) { throw new IllegalArgumentException("The status is missing"); } - context.rule.setStatus(status); + rule.setStatus(status); } - private static void updateTags(RuleUpdate update, Context context) { + private static void updateTags(RuleUpdate update, RuleDto rule) { Set tags = update.getTags(); if (tags == null || tags.isEmpty()) { - context.rule.setTags(Collections.emptySet()); + rule.setTags(Collections.emptySet()); } else { - RuleTagHelper.applyTags(context.rule, tags); + RuleTagHelper.applyTags(rule, tags); } } - private static void updateDebtRemediationFunction(RuleUpdate update, Context context) { + private static void updateDebtRemediationFunction(RuleUpdate update, RuleDto rule) { DebtRemediationFunction function = update.getDebtRemediationFunction(); if (function == null) { - context.rule.setRemediationFunction(null); - context.rule.setRemediationGapMultiplier(null); - context.rule.setRemediationBaseEffort(null); + rule.setRemediationFunction(null); + rule.setRemediationGapMultiplier(null); + rule.setRemediationBaseEffort(null); } else { - if (isSameAsDefaultFunction(function, context.rule)) { + if (isSameAsDefaultFunction(function, rule)) { // reset to default - context.rule.setRemediationFunction(null); - context.rule.setRemediationGapMultiplier(null); - context.rule.setRemediationBaseEffort(null); + rule.setRemediationFunction(null); + rule.setRemediationGapMultiplier(null); + rule.setRemediationBaseEffort(null); } else { - context.rule.setRemediationFunction(function.type().name()); - context.rule.setRemediationGapMultiplier(function.gapMultiplier()); - context.rule.setRemediationBaseEffort(function.baseEffort()); + rule.setRemediationFunction(function.type().name()); + rule.setRemediationGapMultiplier(function.gapMultiplier()); + rule.setRemediationBaseEffort(function.baseEffort()); } } } - private void updateMarkdownNote(RuleUpdate update, Context context, UserSession userSession) { + private void updateMarkdownNote(RuleUpdate update, RuleDto rule, UserSession userSession) { if (isBlank(update.getMarkdownNote())) { - context.rule.setNoteData(null); - context.rule.setNoteCreatedAt(null); - context.rule.setNoteUpdatedAt(null); - context.rule.setNoteUserLogin(null); + rule.setNoteData(null); + rule.setNoteCreatedAt(null); + rule.setNoteUpdatedAt(null); + rule.setNoteUserLogin(null); } else { - Date now = new Date(system.now()); - context.rule.setNoteData(update.getMarkdownNote()); - context.rule.setNoteCreatedAt(context.rule.getNoteCreatedAt() != null ? context.rule.getNoteCreatedAt() : now); - context.rule.setNoteUpdatedAt(now); - context.rule.setNoteUserLogin(userSession.getLogin()); + long now = system.now(); + rule.setNoteData(update.getMarkdownNote()); + rule.setNoteCreatedAt(rule.getNoteCreatedAt() != null ? rule.getNoteCreatedAt() : now); + rule.setNoteUpdatedAt(now); + rule.setNoteUserLogin(userSession.getLogin()); } } @@ -228,9 +226,9 @@ public class RuleUpdater { .isEquals(); } - private void updateParameters(DbSession dbSession, RuleUpdate update, Context context) { + private void updateParameters(DbSession dbSession, RuleUpdate update, RuleDto rule) { if (update.isChangeParameters() && update.isCustomRule()) { - RuleDto customRule = context.rule; + RuleDto customRule = rule; Integer templateId = customRule.getTemplateId(); checkNotNull(templateId, "Rule '%s' has no persisted template!", customRule); Optional templateRule = dbClient.ruleDao().selectDefinitionById(templateId, dbSession); @@ -345,14 +343,6 @@ public class RuleUpdater { } } - /** - * Data loaded before update - */ - private static class Context { - private RuleDto rule; - - } - private void update(DbSession session, RuleDto rule) { rule.setUpdatedAt(system.now()); dbClient.ruleDao().update(session, rule.getDefinition()); diff --git a/server/sonar-server/src/test/java/org/sonar/server/rule/RuleCreatorMediumTest.java b/server/sonar-server/src/test/java/org/sonar/server/rule/RuleCreatorMediumTest.java index 7ecddbd014a..3162c1acab7 100644 --- a/server/sonar-server/src/test/java/org/sonar/server/rule/RuleCreatorMediumTest.java +++ b/server/sonar-server/src/test/java/org/sonar/server/rule/RuleCreatorMediumTest.java @@ -34,6 +34,7 @@ import org.sonar.api.rule.Severity; import org.sonar.api.server.debt.DebtRemediationFunction; 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; @@ -61,20 +62,22 @@ public class RuleCreatorMediumTest { @org.junit.Rule public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester); - DbSession dbSession; - DbClient db = tester.get(DbClient.class); - RuleDao dao = tester.get(RuleDao.class); - RuleCreator creator = tester.get(RuleCreator.class); - RuleIndex ruleIndex = tester.get(RuleIndex.class); - RuleIndexer ruleIndexer; - private String defaultOrganizationUuid; + private DbSession dbSession; + private DbClient db = tester.get(DbClient.class); + private RuleDao dao = tester.get(RuleDao.class); + private RuleCreator creator = tester.get(RuleCreator.class); + private RuleIndex ruleIndex = tester.get(RuleIndex.class); + private RuleIndexer ruleIndexer; + private OrganizationDto defaultOrganization; @Before public void before() { tester.clearDbAndIndexes(); - dbSession = tester.get(DbClient.class).openSession(false); + DbClient dbClient = tester.get(DbClient.class); + dbSession = dbClient.openSession(false); ruleIndexer = tester.get(RuleIndexer.class); - defaultOrganizationUuid = tester.get(DefaultOrganizationProvider.class).get().getUuid(); + String defaultOrganizationUuid = tester.get(DefaultOrganizationProvider.class).get().getUuid(); + defaultOrganization = dbClient.organizationDao().selectByUuid(dbSession, defaultOrganizationUuid).get(); } @After @@ -98,7 +101,7 @@ public class RuleCreatorMediumTest { dbSession.clearCache(); - RuleDto rule = db.ruleDao().selectOrFailByKey(dbSession, defaultOrganizationUuid, customRuleKey); + RuleDto rule = db.ruleDao().selectOrFailByKey(dbSession, defaultOrganization.getUuid(), customRuleKey); assertThat(rule).isNotNull(); assertThat(rule.getKey()).isEqualTo(RuleKey.of("java", "CUSTOM_RULE")); assertThat(rule.getTemplateId()).isEqualTo(templateRule.getId()); @@ -499,7 +502,7 @@ public class RuleCreatorMediumTest { } private RuleDto createTemplateRule() { - RuleDto templateRule = RuleTesting.newDto(RuleKey.of("java", "S001")) + RuleDto templateRule = RuleTesting.newDto(RuleKey.of("java", "S001"), defaultOrganization) .setIsTemplate(true) .setLanguage("java") .setConfigKey("S001") diff --git a/server/sonar-server/src/test/java/org/sonar/server/rule/RuleServiceMediumTest.java b/server/sonar-server/src/test/java/org/sonar/server/rule/RuleServiceMediumTest.java index e405b41076c..e74c74f3372 100644 --- a/server/sonar-server/src/test/java/org/sonar/server/rule/RuleServiceMediumTest.java +++ b/server/sonar-server/src/test/java/org/sonar/server/rule/RuleServiceMediumTest.java @@ -29,9 +29,11 @@ import org.junit.rules.ExpectedException; import org.sonar.api.rule.RuleKey; 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.RuleDto; import org.sonar.db.rule.RuleTesting; +import org.sonar.server.organization.DefaultOrganizationProvider; import org.sonar.server.rule.index.RuleIndexer; import org.sonar.server.tester.ServerTester; import org.sonar.server.tester.UserSessionRule; @@ -54,12 +56,14 @@ public class RuleServiceMediumTest { private RuleService service = tester.get(RuleService.class); private DbSession dbSession; private RuleIndexer ruleIndexer; + private OrganizationDto defaultOrganization; @Before public void before() { tester.clearDbAndIndexes(); dbSession = tester.get(DbClient.class).openSession(false); ruleIndexer = tester.get(RuleIndexer.class); + defaultOrganization = tester.get(DbClient.class).organizationDao().selectByUuid(dbSession, tester.get(DefaultOrganizationProvider.class).get().getUuid()).get(); } @After @@ -110,7 +114,7 @@ public class RuleServiceMediumTest { } private void insertRule(RuleKey key, Set tags, Set systemTags) { - RuleDto ruleDto = RuleTesting.newDto(key).setTags(tags).setSystemTags(systemTags); + RuleDto ruleDto = RuleTesting.newDto(key, defaultOrganization).setTags(tags).setSystemTags(systemTags); dao.insert(dbSession, ruleDto.getDefinition()); dao.update(dbSession, ruleDto.getMetadata().setRuleId(ruleDto.getId())); dbSession.commit(); diff --git a/server/sonar-server/src/test/java/org/sonar/server/rule/RuleUpdaterMediumTest.java b/server/sonar-server/src/test/java/org/sonar/server/rule/RuleUpdaterMediumTest.java index ee893019f23..09ef46d77d7 100644 --- a/server/sonar-server/src/test/java/org/sonar/server/rule/RuleUpdaterMediumTest.java +++ b/server/sonar-server/src/test/java/org/sonar/server/rule/RuleUpdaterMediumTest.java @@ -39,6 +39,7 @@ import org.sonar.api.server.debt.DebtRemediationFunction; import org.sonar.api.server.debt.internal.DefaultDebtRemediationFunction; import org.sonar.db.DbClient; import org.sonar.db.DbSession; +import org.sonar.db.organization.OrganizationDto; import org.sonar.db.qualityprofile.ActiveRuleDto; import org.sonar.db.qualityprofile.ActiveRuleKey; import org.sonar.db.qualityprofile.ActiveRuleParamDto; @@ -73,18 +74,19 @@ public class RuleUpdaterMediumTest { @org.junit.Rule public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester); - DbClient db = tester.get(DbClient.class); - RuleDao ruleDao = tester.get(RuleDao.class); - DbSession dbSession = db.openSession(false); - RuleIndex ruleIndex = tester.get(RuleIndex.class); - private String defaultOrganizationUuid; + private DbClient db = tester.get(DbClient.class); + private RuleDao ruleDao = tester.get(RuleDao.class); + private DbSession dbSession = db.openSession(false); + private RuleIndex ruleIndex = tester.get(RuleIndex.class); + private OrganizationDto defaultOrganization; RuleUpdater underTest = tester.get(RuleUpdater.class); @Before public void before() { tester.clearDbAndIndexes(); - defaultOrganizationUuid = tester.get(DefaultOrganizationProvider.class).get().getUuid(); + String defaultOrganizationUuid = tester.get(DefaultOrganizationProvider.class).get().getUuid(); + defaultOrganization = db.organizationDao().selectByUuid(dbSession, defaultOrganizationUuid).get(); } @After @@ -108,7 +110,7 @@ public class RuleUpdaterMediumTest { @Test public void no_changes() { - RuleDto ruleDto = RuleTesting.newDto(RULE_KEY) + RuleDto ruleDto = RuleTesting.newDto(RULE_KEY, defaultOrganization) // the following fields are not supposed to be updated .setNoteData("my *note*") .setNoteUserLogin("me") @@ -125,7 +127,7 @@ public class RuleUpdaterMediumTest { underTest.update(update, userSessionRule); dbSession.clearCache(); - RuleDto rule = ruleDao.selectOrFailByKey(dbSession, defaultOrganizationUuid, RULE_KEY); + RuleDto rule = ruleDao.selectOrFailByKey(dbSession, defaultOrganization.getUuid(), RULE_KEY); assertThat(rule.getNoteData()).isEqualTo("my *note*"); assertThat(rule.getNoteUserLogin()).isEqualTo("me"); assertThat(rule.getTags()).containsOnly("tag1"); @@ -138,7 +140,7 @@ public class RuleUpdaterMediumTest { public void set_markdown_note() { userSessionRule.logIn("me"); - RuleDto ruleDto = RuleTesting.newDto(RULE_KEY) + RuleDto ruleDto = RuleTesting.newDto(RULE_KEY, defaultOrganization) .setNoteData(null) .setNoteUserLogin(null) @@ -156,7 +158,7 @@ public class RuleUpdaterMediumTest { underTest.update(update, userSessionRule); dbSession.clearCache(); - RuleDto rule = ruleDao.selectOrFailByKey(dbSession, defaultOrganizationUuid, RULE_KEY); + RuleDto rule = ruleDao.selectOrFailByKey(dbSession, defaultOrganization.getUuid(), RULE_KEY); assertThat(rule.getNoteData()).isEqualTo("my *note*"); assertThat(rule.getNoteUserLogin()).isEqualTo("me"); assertThat(rule.getNoteCreatedAt()).isNotNull(); @@ -170,7 +172,7 @@ public class RuleUpdaterMediumTest { @Test public void remove_markdown_note() { - RuleDto ruleDto = RuleTesting.newDto(RULE_KEY) + RuleDto ruleDto = RuleTesting.newDto(RULE_KEY, defaultOrganization) .setNoteData("my *note*") .setNoteUserLogin("me"); ruleDao.insert(dbSession, ruleDto.getDefinition()); @@ -181,7 +183,7 @@ public class RuleUpdaterMediumTest { underTest.update(update, userSessionRule); dbSession.clearCache(); - RuleDto rule = ruleDao.selectOrFailByKey(dbSession, defaultOrganizationUuid, RULE_KEY); + RuleDto rule = ruleDao.selectOrFailByKey(dbSession, defaultOrganization.getUuid(), RULE_KEY); assertThat(rule.getNoteData()).isNull(); assertThat(rule.getNoteUserLogin()).isNull(); assertThat(rule.getNoteCreatedAt()).isNull(); @@ -191,7 +193,7 @@ public class RuleUpdaterMediumTest { @Test public void set_tags() { // insert db - ruleDao.insert(dbSession, RuleTesting.newDto(RULE_KEY) + ruleDao.insert(dbSession, RuleTesting.newDto(RULE_KEY, defaultOrganization) .setTags(Sets.newHashSet("security")) .setSystemTags(Sets.newHashSet("java8", "javadoc")).getDefinition()); dbSession.commit(); @@ -201,7 +203,7 @@ public class RuleUpdaterMediumTest { underTest.update(update, userSessionRule); dbSession.clearCache(); - RuleDto rule = ruleDao.selectOrFailByKey(dbSession, defaultOrganizationUuid, RULE_KEY); + RuleDto rule = ruleDao.selectOrFailByKey(dbSession, defaultOrganization.getUuid(), RULE_KEY); assertThat(rule.getTags()).containsOnly("bug"); assertThat(rule.getSystemTags()).containsOnly("java8", "javadoc"); @@ -212,7 +214,7 @@ public class RuleUpdaterMediumTest { @Test public void remove_tags() { - RuleDto ruleDto = RuleTesting.newDto(RULE_KEY) + RuleDto ruleDto = RuleTesting.newDto(RULE_KEY, defaultOrganization) .setTags(Sets.newHashSet("security")) .setSystemTags(Sets.newHashSet("java8", "javadoc")); ruleDao.insert(dbSession, ruleDto.getDefinition()); @@ -223,7 +225,7 @@ public class RuleUpdaterMediumTest { underTest.update(update, userSessionRule); dbSession.clearCache(); - RuleDto rule = ruleDao.selectOrFailByKey(dbSession, defaultOrganizationUuid, RULE_KEY); + RuleDto rule = ruleDao.selectOrFailByKey(dbSession, defaultOrganization.getUuid(), RULE_KEY); assertThat(rule.getTags()).isEmpty(); assertThat(rule.getSystemTags()).containsOnly("java8", "javadoc"); @@ -248,7 +250,7 @@ public class RuleUpdaterMediumTest { dbSession.clearCache(); // verify debt is overridden - RuleDto rule = ruleDao.selectOrFailByKey(dbSession, defaultOrganizationUuid, RULE_KEY); + RuleDto rule = ruleDao.selectOrFailByKey(dbSession, defaultOrganization.getUuid(), RULE_KEY); assertThat(rule.getRemediationFunction()).isEqualTo(DebtRemediationFunction.Type.CONSTANT_ISSUE.name()); assertThat(rule.getRemediationGapMultiplier()).isNull(); assertThat(rule.getRemediationBaseEffort()).isEqualTo("1min"); @@ -273,7 +275,7 @@ public class RuleUpdaterMediumTest { dbSession.clearCache(); // verify debt is overridden - RuleDto rule = ruleDao.selectOrFailByKey(dbSession, defaultOrganizationUuid, RULE_KEY); + RuleDto rule = ruleDao.selectOrFailByKey(dbSession, defaultOrganization.getUuid(), RULE_KEY); assertThat(rule.getRemediationFunction()).isEqualTo(DebtRemediationFunction.Type.LINEAR.name()); assertThat(rule.getRemediationGapMultiplier()).isEqualTo("2d"); assertThat(rule.getRemediationBaseEffort()).isNull(); @@ -298,7 +300,7 @@ public class RuleUpdaterMediumTest { dbSession.clearCache(); // verify debt is overridden - RuleDto rule = ruleDao.selectOrFailByKey(dbSession, defaultOrganizationUuid, RULE_KEY); + RuleDto rule = ruleDao.selectOrFailByKey(dbSession, defaultOrganization.getUuid(), RULE_KEY); assertThat(rule.getRemediationFunction()).isEqualTo(DebtRemediationFunction.Type.CONSTANT_ISSUE.name()); assertThat(rule.getRemediationGapMultiplier()).isNull(); assertThat(rule.getRemediationBaseEffort()).isEqualTo("10min"); @@ -310,7 +312,7 @@ public class RuleUpdaterMediumTest { @Test public void reset_remediation_function() { - RuleDto ruleDto = RuleTesting.newDto(RULE_KEY) + RuleDto ruleDto = RuleTesting.newDto(RULE_KEY, defaultOrganization) .setDefaultRemediationFunction(DebtRemediationFunction.Type.LINEAR.name()) .setDefaultRemediationGapMultiplier("1d") .setDefaultRemediationBaseEffort("5min") @@ -326,7 +328,7 @@ public class RuleUpdaterMediumTest { dbSession.clearCache(); // verify debt is coming from default values - RuleDto rule = ruleDao.selectOrFailByKey(dbSession, defaultOrganizationUuid, RULE_KEY); + RuleDto rule = ruleDao.selectOrFailByKey(dbSession, defaultOrganization.getUuid(), RULE_KEY); assertThat(rule.getDefaultRemediationFunction()).isEqualTo(DebtRemediationFunction.Type.LINEAR.name()); assertThat(rule.getDefaultRemediationGapMultiplier()).isEqualTo("1d"); assertThat(rule.getDefaultRemediationBaseEffort()).isEqualTo("5min"); @@ -371,7 +373,7 @@ public class RuleUpdaterMediumTest { dbSession.clearCache(); // Verify custom rule is updated - RuleDto customRuleReloaded = ruleDao.selectOrFailByKey(dbSession, defaultOrganizationUuid, customRule.getKey()); + RuleDto customRuleReloaded = ruleDao.selectOrFailByKey(dbSession, defaultOrganization.getUuid(), customRule.getKey()); assertThat(customRuleReloaded).isNotNull(); assertThat(customRuleReloaded.getName()).isEqualTo("New name"); assertThat(customRuleReloaded.getDescription()).isEqualTo("New description"); diff --git a/server/sonar-server/src/test/java/org/sonar/server/rule/ws/RulesWsMediumTest.java b/server/sonar-server/src/test/java/org/sonar/server/rule/ws/RulesWsMediumTest.java index 93d63af4cfc..a208d75a510 100644 --- a/server/sonar-server/src/test/java/org/sonar/server/rule/ws/RulesWsMediumTest.java +++ b/server/sonar-server/src/test/java/org/sonar/server/rule/ws/RulesWsMediumTest.java @@ -141,13 +141,13 @@ public class RulesWsMediumTest { QualityProfileDto profile = QProfileTesting.newXooP1("org-123"); tester.get(QualityProfileDao.class).insert(session, profile); - RuleDto rule = RuleTesting.newXooX1() + RuleDto rule = RuleTesting.newXooX1(defaultOrganization) .setTags(ImmutableSet.of("hello", "world")) .setSystemTags(Collections.emptySet()); ruleDao.insert(session, rule.getDefinition()); ruleDao.update(session, rule.getMetadata().setRuleId(rule.getId())); - RuleDto rule2 = RuleTesting.newXooX2() + RuleDto rule2 = RuleTesting.newXooX2(defaultOrganization) .setTags(ImmutableSet.of("hello", "java")) .setSystemTags(ImmutableSet.of("sys1")); ruleDao.insert(session, rule2.getDefinition()); diff --git a/server/sonar-server/src/test/java/org/sonar/server/rule/ws/SearchActionMediumTest.java b/server/sonar-server/src/test/java/org/sonar/server/rule/ws/SearchActionMediumTest.java index 8eb22438d12..6c63c850e5a 100644 --- a/server/sonar-server/src/test/java/org/sonar/server/rule/ws/SearchActionMediumTest.java +++ b/server/sonar-server/src/test/java/org/sonar/server/rule/ws/SearchActionMediumTest.java @@ -227,7 +227,7 @@ public class SearchActionMediumTest { @Test public void search_debt_rules_with_default_and_overridden_debt_values() throws Exception { - RuleDto ruleDto = RuleTesting.newXooX1() + RuleDto ruleDto = RuleTesting.newXooX1(defaultOrganization) .setDefaultRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.name()) .setDefaultRemediationGapMultiplier("1h") .setDefaultRemediationBaseEffort("15min") @@ -247,7 +247,7 @@ public class SearchActionMediumTest { @Test public void search_debt_rules_with_default_linear_offset_and_overridden_constant_debt() throws Exception { - RuleDto ruleDto = RuleTesting.newXooX1() + RuleDto ruleDto = RuleTesting.newXooX1(defaultOrganization) .setDefaultRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.name()) .setDefaultRemediationGapMultiplier("1h") .setDefaultRemediationBaseEffort("15min") @@ -267,7 +267,7 @@ public class SearchActionMediumTest { @Test public void search_debt_rules_with_default_linear_offset_and_overridden_linear_debt() throws Exception { - RuleDto ruleDto = RuleTesting.newXooX1() + RuleDto ruleDto = RuleTesting.newXooX1(defaultOrganization) .setDefaultRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.name()) .setDefaultRemediationGapMultiplier("1h") .setDefaultRemediationBaseEffort("15min") @@ -494,7 +494,7 @@ public class SearchActionMediumTest { public void get_note_as_markdown_and_html() throws Exception { QualityProfileDto profile = QProfileTesting.newXooP1("org-123"); tester.get(QualityProfileDao.class).insert(dbSession, profile); - RuleDto rule = RuleTesting.newXooX1().setNoteData("this is *bold*"); + RuleDto rule = RuleTesting.newXooX1(defaultOrganization).setNoteData("this is *bold*"); ruleDao.insert(dbSession, rule.getDefinition()); ruleDao.update(dbSession, rule.getMetadata().setRuleId(rule.getId())); @@ -626,7 +626,7 @@ public class SearchActionMediumTest { @Test public void search_rules_with_deprecated_fields() throws Exception { - RuleDto ruleDto = RuleTesting.newXooX1() + RuleDto ruleDto = RuleTesting.newXooX1(defaultOrganization) .setDefaultRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.name()) .setDefaultRemediationGapMultiplier("1h") .setDefaultRemediationBaseEffort("15min") diff --git a/server/sonar-server/src/test/java/org/sonar/server/rule/ws/ShowActionMediumTest.java b/server/sonar-server/src/test/java/org/sonar/server/rule/ws/ShowActionMediumTest.java index be804d4df27..831fef98d40 100644 --- a/server/sonar-server/src/test/java/org/sonar/server/rule/ws/ShowActionMediumTest.java +++ b/server/sonar-server/src/test/java/org/sonar/server/rule/ws/ShowActionMediumTest.java @@ -30,6 +30,7 @@ import org.sonar.api.rule.RuleStatus; import org.sonar.api.rules.RuleType; import org.sonar.db.DbClient; import org.sonar.db.DbSession; +import org.sonar.db.organization.OrganizationDto; import org.sonar.db.qualityprofile.ActiveRuleDao; import org.sonar.db.qualityprofile.ActiveRuleDto; import org.sonar.db.qualityprofile.ActiveRuleParamDto; @@ -66,11 +67,11 @@ public class ShowActionMediumTest { public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester).logIn() .addPermission(ADMINISTER_QUALITY_PROFILES, defaultOrganizationProvider.get().getUuid()); - WsTester wsTester; - - RuleService ruleService; - RuleDao ruleDao; - DbSession session; + private WsTester wsTester; + private RuleService ruleService; + private RuleDao ruleDao; + private DbSession session; + private OrganizationDto defaultOrganization; @Before public void setUp() { @@ -79,6 +80,7 @@ public class ShowActionMediumTest { ruleService = tester.get(RuleService.class); ruleDao = tester.get(RuleDao.class); session = tester.get(DbClient.class).openSession(false); + defaultOrganization = tester.get(DbClient.class).organizationDao().selectByUuid(session, defaultOrganizationProvider.get().getUuid()).get(); } @After @@ -88,7 +90,7 @@ public class ShowActionMediumTest { @Test public void show_rule() throws Exception { - RuleDto ruleDto = RuleTesting.newDto(RuleKey.of("java", "S001")) + RuleDto ruleDto = RuleTesting.newDto(RuleKey.of("java", "S001"), defaultOrganization) .setName("Rule S001") .setDescription("Rule S001 description") .setDescriptionFormat(Format.HTML) @@ -114,7 +116,7 @@ public class ShowActionMediumTest { @Test public void show_rule_with_default_debt_infos() throws Exception { - RuleDto ruleDto = RuleTesting.newDto(RuleKey.of("java", "S001")) + RuleDto ruleDto = RuleTesting.newDto(RuleKey.of("java", "S001"), defaultOrganization) .setName("Rule S001") .setDescription("Rule S001 description") .setSeverity(MINOR) @@ -141,7 +143,7 @@ public class ShowActionMediumTest { @Test public void show_rule_with_overridden_debt() throws Exception { - RuleDto ruleDto = RuleTesting.newDto(RuleKey.of("java", "S001")) + RuleDto ruleDto = RuleTesting.newDto(RuleKey.of("java", "S001"), defaultOrganization) .setName("Rule S001") .setDescription("Rule S001 description") .setSeverity(MINOR) @@ -166,7 +168,7 @@ public class ShowActionMediumTest { @Test public void show_rule_with_default_and_overridden_debt_infos() throws Exception { - RuleDto ruleDto = RuleTesting.newDto(RuleKey.of("java", "S001")) + RuleDto ruleDto = RuleTesting.newDto(RuleKey.of("java", "S001"), defaultOrganization) .setName("Rule S001") .setDescription("Rule S001 description") .setSeverity(MINOR) @@ -234,7 +236,7 @@ public class ShowActionMediumTest { @Test public void show_deprecated_rule_rem_function_fields() throws Exception { - RuleDto ruleDto = RuleTesting.newDto(RuleKey.of("java", "S001")) + RuleDto ruleDto = RuleTesting.newDto(RuleKey.of("java", "S001"), defaultOrganization) .setName("Rule S001") .setDescription("Rule S001 description") .setSeverity(MINOR) diff --git a/server/sonar-server/src/test/java/org/sonar/server/rule/ws/UpdateActionMediumTest.java b/server/sonar-server/src/test/java/org/sonar/server/rule/ws/UpdateActionMediumTest.java index f8120b08f3d..dff837287de 100644 --- a/server/sonar-server/src/test/java/org/sonar/server/rule/ws/UpdateActionMediumTest.java +++ b/server/sonar-server/src/test/java/org/sonar/server/rule/ws/UpdateActionMediumTest.java @@ -103,6 +103,7 @@ public class UpdateActionMediumTest { @Test public void update_custom_rule_with_deprecated_remediation_function_parameters() throws Exception { RuleDto rule = RuleTesting.newXooX1() + .setOrganizationUuid(defaultOrganization.getUuid()) .setDefaultRemediationFunction(LINEAR_OFFSET.toString()) .setDefaultRemediationGapMultiplier("10d") .setDefaultRemediationBaseEffort("5min") -- 2.39.5