SONAR-16518 Remove replaceRuleDescriptionSectionDtos method

server/sonar-db-dao/src/main/java/org/sonar/db/rule/RuleDto.java

@@ -19,13 +19,11 @@
  */
 package org.sonar.db.rule;
 
-import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Splitter;
 import com.google.common.collect.ImmutableSet;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.HashSet;
-import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
@@ -215,12 +213,6 @@ public class RuleDto {
     return this;
   }
 
-  @VisibleForTesting
-  public RuleDto replaceRuleDescriptionSectionDtos(RuleDescriptionSectionDto ruleDescriptionSectionDto) {
-    replaceRuleDescriptionSectionDtos(List.of(ruleDescriptionSectionDto));
-    return this;
-  }
-
   public RuleDto addRuleDescriptionSectionDto(RuleDescriptionSectionDto ruleDescriptionSectionDto) {
     checkArgument(!hasDescriptionSectionWithSameKeyAndContext(ruleDescriptionSectionDto),
       ERROR_MESSAGE_SECTION_ALREADY_EXISTS, ruleDescriptionSectionDto.getKey(),
@@ -235,12 +227,12 @@ public class RuleDto {
   }
 
   private static boolean hasSameKeyAndContextKey(RuleDescriptionSectionDto ruleDescriptionSectionDto, RuleDescriptionSectionDto other) {
-    if (!ruleDescriptionSectionDto.getKey().equals(other.getKey())){
+    if (!ruleDescriptionSectionDto.getKey().equals(other.getKey())) {
       return false;
     }
 
     String contextKey = ofNullable(ruleDescriptionSectionDto.getContext()).map(RuleDescriptionSectionContextDto::getKey).orElse(null);
-    String otherContextKey =  ofNullable(other.getContext()).map(RuleDescriptionSectionContextDto::getKey).orElse(null);
+    String otherContextKey = ofNullable(other.getContext()).map(RuleDescriptionSectionContextDto::getKey).orElse(null);
     return Objects.equals(contextKey, otherContextKey);
   }
 

server/sonar-db-dao/src/test/java/org/sonar/db/rule/RuleDaoTest.java

@@ -574,20 +574,19 @@ public class RuleDaoTest {
   @Test
   public void update_rule_sections_replaces_section() {
     RuleDto rule = db.rules().insert();
-    RuleDescriptionSectionDto existingSection = rule.getRuleDescriptionSectionDtos().iterator().next();
+    Set<RuleDescriptionSectionDto> ruleDescriptionSectionDtos = rule.getRuleDescriptionSectionDtos();
+    RuleDescriptionSectionDto existingSection = ruleDescriptionSectionDtos.iterator().next();
     RuleDescriptionSectionDto replacingSection = RuleDescriptionSectionDto.builder()
       .uuid(randomAlphanumeric(20))
       .key(existingSection.getKey())
       .content(randomAlphanumeric(1000))
       .build();
 
-    rule.replaceRuleDescriptionSectionDtos(replacingSection);
-
+    rule.replaceRuleDescriptionSectionDtos(List.of(replacingSection));
     underTest.update(db.getSession(), rule);
     db.getSession().commit();
 
     RuleDto ruleDto = underTest.selectOrFailByKey(db.getSession(), RuleKey.of(rule.getRepositoryKey(), rule.getRuleKey()));
-
     assertThat(ruleDto.getRuleDescriptionSectionDtos())
       .usingRecursiveFieldByFieldElementComparator()
       .containsOnly(replacingSection);
@@ -596,20 +595,21 @@ public class RuleDaoTest {
   @Test
   public void update_rule_sections_replaces_section_with_context() {
     RuleDto rule = db.rules().insert();
-    RuleDescriptionSectionDto existingSection = rule.getRuleDescriptionSectionDtos().iterator().next();
+    Set<RuleDescriptionSectionDto> ruleDescriptionSectionDtos = rule.getRuleDescriptionSectionDtos();
+    RuleDescriptionSectionDto existingSection = ruleDescriptionSectionDtos.iterator().next();
+    RuleDescriptionSectionContextDto contextDto = RuleDescriptionSectionContextDto.of(randomAlphanumeric(10), randomAlphanumeric(10));
     RuleDescriptionSectionDto replacingSection = RuleDescriptionSectionDto.builder()
       .uuid(randomAlphanumeric(20))
       .key(existingSection.getKey())
       .content(randomAlphanumeric(1000))
+      .context(contextDto)
       .build();
 
-    rule.replaceRuleDescriptionSectionDtos(replacingSection);
-
+    rule.replaceRuleDescriptionSectionDtos(List.of(replacingSection));
     underTest.update(db.getSession(), rule);
     db.getSession().commit();
 
     RuleDto ruleDto = underTest.selectOrFailByKey(db.getSession(), RuleKey.of(rule.getRepositoryKey(), rule.getRuleKey()));
-
     assertThat(ruleDto.getRuleDescriptionSectionDtos())
       .usingRecursiveFieldByFieldElementComparator()
       .containsOnly(replacingSection);
@@ -742,7 +742,7 @@ public class RuleDaoTest {
 
     List<RuleParamDto> ruleDtos = underTest.selectAllRuleParams(db.getSession());
 
-    assertThat(ruleDtos.size()).isEqualTo(4);
+    assertThat(ruleDtos).hasSize(4);
     assertThat(ruleDtos).extracting(RuleParamDto::getUuid)
       .containsExactlyInAnyOrder(ruleParam1.getUuid(), ruleParam12.getUuid(),
         ruleParam2.getUuid(), ruleParam3.getUuid());

server/sonar-db-dao/src/testFixtures/java/org/sonar/db/rule/RuleTesting.java

@@ -37,10 +37,12 @@ import org.sonar.db.rule.RuleDto.Scope;
 import static com.google.common.base.Preconditions.checkNotNull;
 import static com.google.common.collect.ImmutableSet.copyOf;
 import static com.google.common.collect.Sets.newHashSet;
+import static java.util.Arrays.stream;
 import static org.apache.commons.lang.RandomStringUtils.randomAlphabetic;
 import static org.apache.commons.lang.RandomStringUtils.randomAlphanumeric;
 import static org.apache.commons.lang.math.RandomUtils.nextInt;
 import static org.sonar.api.rule.RuleKey.EXTERNAL_RULE_REPO_PREFIX;
+import static org.sonar.api.rules.RuleType.CODE_SMELL;
 import static org.sonar.db.rule.RuleDescriptionSectionDto.createDefaultRuleDescriptionSection;
 
 /**
@@ -59,13 +61,17 @@ public class RuleTesting {
     // only static helpers
   }
 
-  public static RuleDto newRule() {
-    return newRule(randomRuleKey());
+  public static RuleDto newRule(RuleDescriptionSectionDto... ruleDescriptionSectionDtos) {
+    return newRule(randomRuleKey(), ruleDescriptionSectionDtos);
   }
 
-  public static RuleDto newRule(RuleKey key) {
+  public static RuleDto newRule(RuleKey key, RuleDescriptionSectionDto... ruleDescriptionSectionDtos) {
     RuleDto ruleDto = newRuleWithoutDescriptionSection(key);
-    ruleDto.addRuleDescriptionSectionDto(createDefaultRuleDescriptionSection(uuidFactory.create(), "description_" + randomAlphabetic(5)));
+    if (ruleDescriptionSectionDtos.length == 0) {
+      ruleDto.addRuleDescriptionSectionDto(createDefaultRuleDescriptionSection(uuidFactory.create(), "description_" + randomAlphabetic(5)));
+    } else {
+      stream(ruleDescriptionSectionDtos).forEach(ruleDto::addRuleDescriptionSectionDto);
+    }
     return ruleDto;
   }
 
@@ -81,7 +87,7 @@ public class RuleTesting {
       .setUuid("rule_uuid_" + randomAlphanumeric(5))
       .setName("name_" + randomAlphanumeric(5))
       .setDescriptionFormat(RuleDto.Format.HTML)
-      .setType(RuleType.values()[nextInt(RuleType.values().length)])
+      .setType(CODE_SMELL)
       .setStatus(RuleStatus.READY)
       .setConfigKey("configKey_" + randomAlphanumeric(5))
       .setSeverity(Severity.ALL.get(nextInt(Severity.ALL.size())))
@@ -177,7 +183,7 @@ public class RuleTesting {
       .setDefRemediationGapMultiplier("5d")
       .setDefRemediationBaseEffort("10h")
       .setGapDescription(ruleKey.repository() + "." + ruleKey.rule() + ".effortToFix")
-      .setType(RuleType.CODE_SMELL)
+      .setType(CODE_SMELL)
       .setCreatedAt(new Date().getTime())
       .setUpdatedAt(new Date().getTime())
       .setScope(Scope.MAIN)
@@ -199,10 +205,14 @@ public class RuleTesting {
       .setIsTemplate(true);
   }
 
-
   public static RuleDto newCustomRule(RuleDto templateRule) {
+    return newCustomRule(templateRule, "description_" + randomAlphabetic(5));
+  }
+
+  public static RuleDto newCustomRule(RuleDto templateRule, String description) {
     checkNotNull(templateRule.getUuid(), "The template rule need to be persisted before creating this custom rule.");
-    return newRule(RuleKey.of(templateRule.getRepositoryKey(), templateRule.getRuleKey() + "_" + System.currentTimeMillis()))
+    RuleDescriptionSectionDto defaultRuleDescriptionSection = createDefaultRuleDescriptionSection(uuidFactory.create(), description);
+    return newRule(RuleKey.of(templateRule.getRepositoryKey(), templateRule.getRuleKey() + "_" + System.currentTimeMillis()), defaultRuleDescriptionSection)
       .setLanguage(templateRule.getLanguage())
       .setTemplateUuid(templateRule.getUuid())
       .setType(templateRule.getType());

server/sonar-server-common/src/test/java/org/sonar/server/rule/index/RuleDocTest.java

@@ -24,10 +24,11 @@ import org.sonar.db.rule.RuleDescriptionSectionContextDto;
 import org.sonar.db.rule.RuleDescriptionSectionDto;
 import org.sonar.db.rule.RuleDto;
 import org.sonar.db.rule.RuleForIndexingDto;
-import org.sonar.db.rule.RuleTesting;
 import org.sonar.server.security.SecurityStandards;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.sonar.db.rule.RuleTesting.newRule;
+import static org.sonar.db.rule.RuleTesting.newRuleWithoutDescriptionSection;
 import static org.sonar.markdown.Markdown.convertToHtml;
 import static org.sonar.server.security.SecurityStandards.fromSecurityStandards;
 
@@ -35,7 +36,7 @@ public class RuleDocTest {
 
   @Test
   public void ruleDocOf_mapsFieldCorrectly() {
-    RuleDto ruleDto = RuleTesting.newRule();
+    RuleDto ruleDto = newRule();
     RuleForIndexingDto ruleForIndexingDto = RuleForIndexingDto.fromRuleDto(ruleDto);
     ruleForIndexingDto.setTemplateRuleKey("templateKey");
     ruleForIndexingDto.setTemplateRepository("repoKey");
@@ -72,9 +73,8 @@ public class RuleDocTest {
 
   @Test
   public void ruleDocOf_whenGivenNoHtmlSections_hasEmptyStringInHtmlDescription() {
-    RuleDto ruleDto = RuleTesting.newRule();
+    RuleDto ruleDto = newRuleWithoutDescriptionSection();
     ruleDto.setDescriptionFormat(RuleDto.Format.HTML);
-    ruleDto.getRuleDescriptionSectionDtos().clear();
 
     RuleForIndexingDto ruleForIndexingDto = RuleForIndexingDto.fromRuleDto(ruleDto);
     SecurityStandards securityStandards = fromSecurityStandards(ruleDto.getSecurityStandards());
@@ -85,17 +85,12 @@ public class RuleDocTest {
 
   @Test
   public void ruleDocOf_whenGivenMultipleHtmlSections_hasConcatenationInHtmlDescription() {
-    RuleDto ruleDto = RuleTesting.newRule();
-    ruleDto.setDescriptionFormat(RuleDto.Format.HTML);
-    ruleDto.getRuleDescriptionSectionDtos().clear();
     RuleDescriptionSectionDto section1 = buildRuleDescriptionSectionDto("section1", "<p>html content 1</p>");
     RuleDescriptionSectionDto section2 = buildRuleDescriptionSectionDto("section2", "<p>html content 2</p>");
     RuleDescriptionSectionDto section3ctx1 = buildRuleDescriptionSectionDtoWithContext("section3", "<p>html content 3.1</p>", "ctx1");
     RuleDescriptionSectionDto section3ctx2 = buildRuleDescriptionSectionDtoWithContext("section3", "<p>html content 3.2</p>", "ctx2");
-    ruleDto.addRuleDescriptionSectionDto(section1);
-    ruleDto.addRuleDescriptionSectionDto(section2);
-    ruleDto.addRuleDescriptionSectionDto(section3ctx1);
-    ruleDto.addRuleDescriptionSectionDto(section3ctx2);
+    RuleDto ruleDto = newRule(section1, section2, section3ctx1, section3ctx2);
+    ruleDto.setDescriptionFormat(RuleDto.Format.HTML);
 
     RuleForIndexingDto ruleForIndexingDto = RuleForIndexingDto.fromRuleDto(ruleDto);
     SecurityStandards securityStandards = fromSecurityStandards(ruleDto.getSecurityStandards());
@@ -111,13 +106,11 @@ public class RuleDocTest {
 
   @Test
   public void ruleDocOf_whenGivenMultipleMarkdownSections_transformToHtmlAndConcatenatesInHtmlDescription() {
-    RuleDto ruleDto = RuleTesting.newRule();
-    ruleDto.setDescriptionFormat(RuleDto.Format.MARKDOWN);
-    ruleDto.getRuleDescriptionSectionDtos().clear();
     RuleDescriptionSectionDto section1 = buildRuleDescriptionSectionDto("section1", "*html content 1*");
     RuleDescriptionSectionDto section2 = buildRuleDescriptionSectionDto("section2", "*html content 2*");
-    ruleDto.addRuleDescriptionSectionDto(section1);
-    ruleDto.addRuleDescriptionSectionDto(section2);
+
+    RuleDto ruleDto = newRule(section1, section2);
+    ruleDto.setDescriptionFormat(RuleDto.Format.MARKDOWN);
 
     RuleForIndexingDto ruleForIndexingDto = RuleForIndexingDto.fromRuleDto(ruleDto);
     SecurityStandards securityStandards = fromSecurityStandards(ruleDto.getSecurityStandards());

server/sonar-server-common/src/test/java/org/sonar/server/rule/index/RuleIndexTest.java

@@ -65,6 +65,7 @@ import static org.sonar.api.rules.RuleType.CODE_SMELL;
 import static org.sonar.api.rules.RuleType.SECURITY_HOTSPOT;
 import static org.sonar.api.rules.RuleType.VULNERABILITY;
 import static org.sonar.db.rule.RuleDescriptionSectionDto.createDefaultRuleDescriptionSection;
+import static org.sonar.db.rule.RuleTesting.newRule;
 import static org.sonar.db.rule.RuleTesting.setCreatedAt;
 import static org.sonar.db.rule.RuleTesting.setIsExternal;
 import static org.sonar.db.rule.RuleTesting.setIsTemplate;
@@ -93,18 +94,18 @@ import static org.sonar.server.security.SecurityStandards.SANS_TOP_25_RISKY_RESO
 
 public class RuleIndexTest {
 
-  private System2 system2 = new AlwaysIncreasingSystem2();
+  private final System2 system2 = new AlwaysIncreasingSystem2();
 
   @Rule
   public EsTester es = EsTester.create();
   @Rule
   public DbTester db = DbTester.create(system2);
 
-  private RuleIndexer ruleIndexer = new RuleIndexer(es.client(), db.getDbClient());
-  private ActiveRuleIndexer activeRuleIndexer = new ActiveRuleIndexer(db.getDbClient(), es.client());
+  private final RuleIndexer ruleIndexer = new RuleIndexer(es.client(), db.getDbClient());
+  private final ActiveRuleIndexer activeRuleIndexer = new ActiveRuleIndexer(db.getDbClient(), es.client());
 
-  private RuleIndex underTest = new RuleIndex(es.client(), system2);
-  private UuidFactory uuidFactory = UuidFactoryFast.getInstance();
+  private final RuleIndex underTest = new RuleIndex(es.client(), system2);
+  private final UuidFactory uuidFactory = UuidFactoryFast.getInstance();
 
   @Test
   public void search_all_rules() {
@@ -214,22 +215,11 @@ public class RuleIndexTest {
   public void search_content_by_query() {
     // it's important to set all the fields being used by the search (name, desc, key, lang, ...),
     // otherwise the generated random values may raise false-positives
-    RuleDto rule1 = createJavaRule(rule -> rule.setRuleKey("123")
-      .setName("rule 123")
-      .replaceRuleDescriptionSectionDtos(createDefaultRuleDescriptionSection(uuidFactory.create(), "My great rule CWE-123 which makes your code 1000 times better!")));
-    RuleDto rule2 = createJavaRule(rule -> rule.setRuleKey("124")
-      .setName("rule 124")
-      .replaceRuleDescriptionSectionDtos(createDefaultRuleDescriptionSection(uuidFactory.create(), "Another great and shiny rule CWE-124")));
-    RuleDto rule3 = createJavaRule(rule -> rule.setRuleKey("1000")
-      .setName("rule 1000")
-      .replaceRuleDescriptionSectionDtos(createDefaultRuleDescriptionSection(uuidFactory.create(), "Another great rule CWE-1000")));
-    RuleDto rule4 = createJavaRule(rule -> rule.setRuleKey("404")
-      .setName("rule 404")
-      .replaceRuleDescriptionSectionDtos(createDefaultRuleDescriptionSection(uuidFactory.create(),
-        "<h1>HTML-Geeks</h1><p style=\"color:blue\">special formatting!</p><table><tr><td>inside</td><td>tables</td></tr></table>")));
-    RuleDto rule5 = createJavaRule(rule -> rule.setRuleKey("405")
-      .setName("rule 405")
-      .replaceRuleDescriptionSectionDtos(createDefaultRuleDescriptionSection(uuidFactory.create(), "internationalization missunderstandings alsdkjfnadklsjfnadkdfnsksdjfn")));
+    RuleDto rule1 = insertJavaRule("My great rule CWE-123 which makes your code 1000 times better!", "123", "rule 123");
+    RuleDto rule2 = insertJavaRule("Another great and shiny rule CWE-124", "124", "rule 124");
+    RuleDto rule3 = insertJavaRule("Another great rule CWE-1000", "1000", "rule 1000");
+    RuleDto rule4 = insertJavaRule("<h1>HTML-Geeks</h1><p style=\"color:blue\">special formatting!</p><table><tr><td>inside</td><td>tables</td></tr></table>", "404", "rule 404");
+    RuleDto rule5 = insertJavaRule("internationalization missunderstandings alsdkjfnadklsjfnadkdfnsksdjfn", "405", "rule 405");
     index();
 
     // partial match at word boundary
@@ -269,6 +259,14 @@ public class RuleIndexTest {
     assertThat(underTest.search(new RuleQuery().setQueryText("internationalizationBlaBla"), new SearchOptions()).getUuids()).isEmpty();
   }
 
+  private RuleDto insertJavaRule(String description, String ruleKey, String name) {
+    RuleDto javaRule = newRule(createDefaultRuleDescriptionSection(uuidFactory.create(), description))
+      .setLanguage("java")
+      .setRuleKey(ruleKey)
+      .setName(name);
+    return db.rules().insert(javaRule);
+  }
+
   @Test
   public void search_by_any_of_repositories() {
     RuleDto findbugs = createRule(
@@ -555,7 +553,7 @@ public class RuleIndexTest {
   }
 
   @SafeVarargs
-  private final RuleDto createRule(Consumer<RuleDto>... consumers) {
+  private RuleDto createRule(Consumer<RuleDto>... consumers) {
     return db.rules().insert(consumers);
   }
 
@@ -563,10 +561,6 @@ public class RuleIndexTest {
     return createRule(r -> r.setLanguage("java"));
   }
 
-  private RuleDto createJavaRule(Consumer<RuleDto> consumer) {
-    return createRule(r -> r.setLanguage("java"), consumer);
-  }
-
   @Test
   public void search_by_any_of_severities() {
     createRule(setSeverity(BLOCKER));
@@ -592,7 +586,7 @@ public class RuleIndexTest {
 
   @Test
   public void search_by_any_of_statuses() {
-    RuleDto beta = createRule(setStatus(RuleStatus.BETA));
+    createRule(setStatus(RuleStatus.BETA));
     RuleDto ready = createRule(setStatus(RuleStatus.READY));
     index();
 
@@ -710,7 +704,7 @@ public class RuleIndexTest {
   public void search_by_activation_and_severity() {
     RuleDto major = createRule(setSeverity(MAJOR));
     RuleDto minor = createRule(setSeverity(MINOR));
-    RuleDto info = createRule(setSeverity(INFO));
+    createRule(setSeverity(INFO));
     QProfileDto profile1 = createJavaProfile();
     QProfileDto profile2 = createJavaProfile();
     db.qualityProfiles().activateRule(profile1, major, ar -> ar.setSeverity(BLOCKER));

server/sonar-server-common/src/test/java/org/sonar/server/rule/index/RuleIndexerTest.java

@@ -23,6 +23,11 @@ import com.google.common.collect.ImmutableSet;
 import com.tngtech.java.junit.dataprovider.DataProvider;
 import com.tngtech.java.junit.dataprovider.DataProviderRunner;
 import com.tngtech.java.junit.dataprovider.UseDataProvider;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+import java.util.stream.Stream;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -38,25 +43,19 @@ import org.sonar.db.DbTester;
 import org.sonar.db.rule.RuleDescriptionSectionDto;
 import org.sonar.db.rule.RuleDto;
 import org.sonar.db.rule.RuleDto.Scope;
-import org.sonar.db.rule.RuleTesting;
 import org.sonar.server.es.EsTester;
 import org.sonar.server.security.SecurityStandards;
 import org.sonar.server.security.SecurityStandards.SQCategory;
 
-import java.util.EnumSet;
-import java.util.List;
-import java.util.Random;
-import java.util.Set;
-import java.util.stream.IntStream;
-import java.util.stream.Stream;
-
 import static com.google.common.collect.Sets.newHashSet;
 import static java.lang.String.format;
 import static java.util.Collections.emptyList;
 import static java.util.stream.Collectors.joining;
 import static java.util.stream.Collectors.toSet;
+import static org.apache.commons.lang.RandomStringUtils.randomAlphanumeric;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.sonar.db.rule.RuleDescriptionSectionDto.createDefaultRuleDescriptionSection;
+import static org.sonar.db.rule.RuleTesting.newRule;
 import static org.sonar.server.rule.index.RuleIndexDefinition.TYPE_RULE;
 import static org.sonar.server.security.SecurityStandards.CWES_BY_SQ_CATEGORY;
 import static org.sonar.server.security.SecurityStandards.SQ_CATEGORY_KEYS_ORDERING;
@@ -85,10 +84,10 @@ public class RuleIndexerTest {
   @Rule
   public LogTester logTester = new LogTester();
 
-  private DbClient dbClient = dbTester.getDbClient();
+  private final DbClient dbClient = dbTester.getDbClient();
   private final RuleIndexer underTest = new RuleIndexer(es.client(), dbClient);
-  private DbSession dbSession = dbTester.getSession();
-  private RuleDto rule = new RuleDto()
+  private final DbSession dbSession = dbTester.getSession();
+  private final RuleDto rule = new RuleDto()
     .setUuid("rule-uuid")
     .setRuleKey("S001")
     .setRepositoryKey("xoo")
@@ -137,10 +136,9 @@ public class RuleIndexerTest {
 
   @Test
   public void index_long_rule_description() {
-    String description = IntStream.range(0, 100000).map(i -> i % 100).mapToObj(Integer::toString).collect(joining(" "));
-    RuleDescriptionSectionDto ruleDescriptionSectionDto = createDefaultRuleDescriptionSection(uuidFactory.create(), description);
+    RuleDescriptionSectionDto ruleDescriptionSectionDto = createDefaultRuleDescriptionSection(uuidFactory.create(), randomAlphanumeric(100000));
+    RuleDto rule = dbTester.rules().insert(newRule(ruleDescriptionSectionDto));
 
-    RuleDto rule = dbTester.rules().insert(r -> r.replaceRuleDescriptionSectionDtos(ruleDescriptionSectionDto));
     underTest.commitAndIndex(dbTester.getSession(), rule.getUuid());
 
     assertThat(es.countDocuments(TYPE_RULE)).isOne();
@@ -148,10 +146,7 @@ public class RuleIndexerTest {
 
   @Test
   public void index_long_rule_with_several_sections() {
-    RuleDto rule = dbTester.rules().insert(r -> {
-      r.replaceRuleDescriptionSectionDtos(RULE_DESCRIPTION_SECTION_DTO);
-      r.addRuleDescriptionSectionDto(RULE_DESCRIPTION_SECTION_DTO2);
-    });
+    RuleDto rule = dbTester.rules().insert(newRule(RULE_DESCRIPTION_SECTION_DTO, RULE_DESCRIPTION_SECTION_DTO2));
 
     underTest.commitAndIndex(dbTester.getSession(), rule.getUuid());
 
@@ -165,10 +160,7 @@ public class RuleIndexerTest {
 
   @Test
   public void index_long_rule_with_section_in_markdown() {
-    RuleDto rule = dbTester.rules().insert(r -> {
-      r.setDescriptionFormat(RuleDto.Format.MARKDOWN);
-      r.replaceRuleDescriptionSectionDtos(RULE_DESCRIPTION_SECTION_DTO);
-    });
+    RuleDto rule = dbTester.rules().insert(newRule(RULE_DESCRIPTION_SECTION_DTO).setDescriptionFormat(RuleDto.Format.MARKDOWN));
 
     underTest.commitAndIndex(dbTester.getSession(), rule.getUuid());
 
@@ -186,10 +178,9 @@ public class RuleIndexerTest {
       .flatMap(t -> CWES_BY_SQ_CATEGORY.get(t).stream().map(e -> "cwe:" + e))
       .collect(toSet());
     SecurityStandards securityStandards = SecurityStandards.fromSecurityStandards(standards);
-    RuleDto rule = dbTester.rules().insert(RuleTesting.newRuleWithoutDescriptionSection()
+    RuleDto rule = dbTester.rules().insert(newRule(RULE_DESCRIPTION_SECTION_DTO)
       .setType(RuleType.SECURITY_HOTSPOT)
-      .setSecurityStandards(standards)
-      .addRuleDescriptionSectionDto(RULE_DESCRIPTION_SECTION_DTO));
+      .setSecurityStandards(standards));
     underTest.commitAndIndex(dbTester.getSession(), rule.getUuid());
 
     assertThat(logTester.getLogs()).hasSize(1);
@@ -214,7 +205,7 @@ public class RuleIndexerTest {
     SQCategory sqCategory1 = sqCategories.toArray(new SQCategory[0])[random.nextInt(sqCategories.size())];
     sqCategories.remove(sqCategory1);
     SQCategory sqCategory2 = sqCategories.toArray(new SQCategory[0])[random.nextInt(sqCategories.size())];
-    return new Object[][] {
+    return new Object[][]{
       {sqCategory1, sqCategory2}
     };
   }

server/sonar-webserver-pushapi/src/test/java/org/sonar/server/pushapi/qualityprofile/QualityProfileChangeEventServiceImplTest.java

@@ -62,16 +62,14 @@ public class QualityProfileChangeEventServiceImplTest {
   public void distributeRuleChangeEvent() {
     QProfileDto qualityProfileDto = QualityProfileTesting.newQualityProfileDto();
 
-    // Template rule
     RuleDto templateRule = newTemplateRule(RuleKey.of("xoo", "template-key"));
     db.rules().insert(templateRule);
-    // Custom rule
-    RuleDto rule1 = newCustomRule(templateRule)
+
+    RuleDto rule1 = newCustomRule(templateRule, "<div>line1\nline2</div>")
       .setLanguage("xoo")
       .setRepositoryKey("repo")
       .setRuleKey("ruleKey")
-      .setDescriptionFormat(RuleDto.Format.MARKDOWN)
-      .replaceRuleDescriptionSectionDtos(createDefaultRuleDescriptionSection("uuid", "<div>line1\nline2</div>"));
+      .setDescriptionFormat(RuleDto.Format.MARKDOWN);
     db.rules().insert(rule1);
 
     ActiveRuleDto activeRuleDto = ActiveRuleDto.createFor(qualityProfileDto, rule1);

server/sonar-webserver-webapi/src/test/java/org/sonar/server/issue/ws/SearchActionTest.java

@@ -101,6 +101,9 @@ import static org.sonar.db.component.ComponentDto.PULL_REQUEST_SEPARATOR;
 import static org.sonar.db.component.ComponentTesting.newFileDto;
 import static org.sonar.db.issue.IssueTesting.newDto;
 import static org.sonar.db.rule.RuleDescriptionSectionDto.createDefaultRuleDescriptionSection;
+import static org.sonar.db.rule.RuleTesting.XOO_X1;
+import static org.sonar.db.rule.RuleTesting.XOO_X2;
+import static org.sonar.db.rule.RuleTesting.newRule;
 import static org.sonar.server.issue.CommentAction.COMMENT_KEY;
 import static org.sonar.server.tester.UserSessionRule.standalone;
 import static org.sonarqube.ws.Common.RuleType.BUG;
@@ -1487,18 +1490,18 @@ public class SearchActionTest {
   }
 
   private RuleDto newIssueRule() {
-    RuleDto rule = RuleTesting.newXooX1()
+    RuleDto rule = newRule(XOO_X1, createDefaultRuleDescriptionSection(uuidFactory.create(), "Rule desc"))
+      .setLanguage("xoo")
       .setName("Rule name")
-      .replaceRuleDescriptionSectionDtos(createDefaultRuleDescriptionSection(uuidFactory.create(), "Rule desc"))
       .setStatus(RuleStatus.READY);
     db.rules().insert(rule);
     return rule;
   }
 
   private RuleDto newHotspotRule() {
-    RuleDto rule = RuleTesting.newXooX2()
+    RuleDto rule = newRule(XOO_X2, createDefaultRuleDescriptionSection(uuidFactory.create(), "Rule desc"))
+      .setLanguage("xoo")
       .setName("Rule name")
-      .replaceRuleDescriptionSectionDtos(createDefaultRuleDescriptionSection(uuidFactory.create(), "Rule desc"))
       .setStatus(RuleStatus.READY)
       .setType(SECURITY_HOTSPOT_VALUE);
     db.rules().insert(rule);

server/sonar-webserver-webapi/src/test/java/org/sonar/server/qualityprofile/QProfileBackuperImplTest.java

@@ -20,6 +20,14 @@
 package org.sonar.server.qualityprofile;
 
 import com.google.common.io.Resources;
+import java.io.Reader;
+import java.io.StringReader;
+import java.io.StringWriter;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import javax.annotation.Nullable;
 import org.junit.Rule;
 import org.junit.Test;
 import org.sonar.api.impl.utils.AlwaysIncreasingSystem2;
@@ -39,15 +47,6 @@ import org.sonar.db.rule.RuleParamDto;
 import org.sonar.server.qualityprofile.builtin.QProfileName;
 import org.sonar.server.rule.RuleCreator;
 
-import javax.annotation.Nullable;
-import java.io.Reader;
-import java.io.StringReader;
-import java.io.StringWriter;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.List;
-
 import static java.nio.charset.StandardCharsets.UTF_8;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
@@ -57,6 +56,7 @@ import static org.mockito.ArgumentMatchers.anyList;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 import static org.sonar.db.rule.RuleDescriptionSectionDto.createDefaultRuleDescriptionSection;
+import static org.sonar.db.rule.RuleTesting.newRule;
 import static org.sonar.db.rule.RuleTesting.newRuleWithoutDescriptionSection;
 
 public class QProfileBackuperImplTest {
@@ -144,11 +144,11 @@ public class QProfileBackuperImplTest {
   public void backup_custom_rules_with_params() {
     RuleDto templateRule = db.rules().insert(ruleDefinitionDto -> ruleDefinitionDto
       .setIsTemplate(true));
-    RuleDto rule = db.rules().insert(ruleDefinitionDto -> ruleDefinitionDto
-      .replaceRuleDescriptionSectionDtos(createDefaultRuleDescriptionSection(UuidFactoryFast.getInstance().create(), "custom rule description"))
-      .setName("custom rule name")
-      .setStatus(RuleStatus.READY)
-      .setTemplateUuid(templateRule.getUuid()));
+    RuleDto rule = db.rules().insert(
+      newRule(createDefaultRuleDescriptionSection(UuidFactoryFast.getInstance().create(), "custom rule description"))
+        .setName("custom rule name")
+        .setStatus(RuleStatus.READY)
+        .setTemplateUuid(templateRule.getUuid()));
     RuleParamDto param = db.rules().insertRuleParam(rule);
     QProfileDto profile = createProfile(rule.getLanguage());
     ActiveRuleDto activeRule = activate(profile, rule, param);
@@ -403,11 +403,11 @@ public class QProfileBackuperImplTest {
   public void copy_profile_with_custom_rule() {
     RuleDto templateRule = db.rules().insert(ruleDefinitionDto -> ruleDefinitionDto
       .setIsTemplate(true));
-    RuleDto rule = db.rules().insert(ruleDefinitionDto -> ruleDefinitionDto
-      .replaceRuleDescriptionSectionDtos(createDefaultRuleDescriptionSection(UuidFactoryFast.getInstance().create(), "custom rule description"))
-      .setName("custom rule name")
-      .setStatus(RuleStatus.READY)
-      .setTemplateUuid(templateRule.getUuid()));
+    RuleDto rule = db.rules().insert(
+      newRule(createDefaultRuleDescriptionSection(UuidFactoryFast.getInstance().create(), "custom rule description"))
+        .setName("custom rule name")
+        .setStatus(RuleStatus.READY)
+        .setTemplateUuid(templateRule.getUuid()));
 
     RuleParamDto param = db.rules().insertRuleParam(rule);
     QProfileDto from = createProfile(rule.getLanguage());

server/sonar-webserver-webapi/src/test/java/org/sonar/server/rule/RuleUpdaterTest.java

@@ -60,6 +60,7 @@ import static org.sonar.api.rule.Severity.CRITICAL;
 import static org.sonar.db.rule.RuleDescriptionSectionDto.createDefaultRuleDescriptionSection;
 import static org.sonar.db.rule.RuleTesting.newCustomRule;
 import static org.sonar.db.rule.RuleTesting.newRule;
+import static org.sonar.db.rule.RuleTesting.newTemplateRule;
 import static org.sonar.server.rule.RuleUpdate.createForCustomRule;
 import static org.sonar.server.rule.RuleUpdate.createForPluginRule;
 
@@ -329,19 +330,15 @@ public class RuleUpdaterTest {
 
   @Test
   public void update_custom_rule() {
-    // Create template rule
-    RuleDto templateRule = RuleTesting.newTemplateRule(RuleKey.of("java", "S001"));
+    RuleDto templateRule = newTemplateRule(RuleKey.of("java", "S001"));
     db.rules().insert(templateRule);
     db.rules().insertRuleParam(templateRule, param -> param.setName("regex").setType("STRING").setDescription("Reg ex").setDefaultValue(".*"));
     db.rules().insertRuleParam(templateRule, param -> param.setName("format").setType("STRING").setDescription("Format"));
 
-    // Create custom rule
-    RuleDto customRule = newCustomRule(templateRule)
+    RuleDto customRule = newCustomRule(templateRule, "Old description")
       .setName("Old name")
-      .replaceRuleDescriptionSectionDtos(createDefaultRuleDescriptionSection(uuidFactory.create(), "Old description"))
       .setSeverity(Severity.MINOR)
-      .setStatus(RuleStatus.BETA)
-      ;
+      .setStatus(RuleStatus.BETA);
     db.rules().insert(customRule);
     db.rules().insertRuleParam(customRule, param -> param.setName("regex").setType("STRING").setDescription("Reg ex").setDefaultValue("a.*"));
     db.rules().insertRuleParam(customRule, param -> param.setName("format").setType("STRING").setDescription("Format").setDefaultValue(null));
@@ -378,15 +375,12 @@ public class RuleUpdaterTest {
 
   @Test
   public void update_custom_rule_with_empty_parameter() {
-    // Create template rule
-    RuleDto templateRule = RuleTesting.newTemplateRule(RuleKey.of("java", "S001"));
+    RuleDto templateRule = newTemplateRule(RuleKey.of("java", "S001"));
     db.rules().insert(templateRule);
     db.rules().insertRuleParam(templateRule, param -> param.setName("regex").setType("STRING").setDescription("Reg ex").setDefaultValue(null));
 
-    // Create custom rule
-    RuleDto customRule = newCustomRule(templateRule)
+    RuleDto customRule = newCustomRule(templateRule, "Old description")
       .setName("Old name")
-      .replaceRuleDescriptionSectionDtos(createDefaultRuleDescriptionSection(uuidFactory.create(), "Old description"))
       .setSeverity(Severity.MINOR)
       .setStatus(RuleStatus.BETA);
     db.rules().insert(customRule);
@@ -412,7 +406,7 @@ public class RuleUpdaterTest {
   @Test
   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");
+    RuleDto templateRule = newTemplateRule(RuleKey.of("java", "S001")).setLanguage("xoo");
     RuleDto templateRuleDefinition = templateRule;
     db.rules().insert(templateRuleDefinition);
     db.rules().insertRuleParam(templateRuleDefinition, param -> param.setName("regex").setType("STRING").setDescription("Reg ex").setDefaultValue(".*"));
@@ -422,8 +416,7 @@ public class RuleUpdaterTest {
     // Create custom rule
     RuleDto customRule = newCustomRule(templateRule)
       .setSeverity(Severity.MAJOR)
-      .setLanguage("xoo")
-      ;
+      .setLanguage("xoo");
     db.rules().insert(customRule);
     RuleParamDto ruleParam1 = db.rules().insertRuleParam(customRule, param -> param.setName("regex").setType("STRING").setDescription("Reg ex").setDefaultValue("a.*"));
     db.rules().insertRuleParam(customRule, param -> param.setName("format").setType("STRING").setDescription("format").setDefaultValue("txt"));
@@ -481,7 +474,7 @@ public class RuleUpdaterTest {
   @Test
   public void fail_to_update_custom_rule_when_empty_name() {
     // Create template rule
-    RuleDto templateRule = RuleTesting.newTemplateRule(RuleKey.of("java", "S001"));
+    RuleDto templateRule = newTemplateRule(RuleKey.of("java", "S001"));
     db.rules().insert(templateRule);
 
     // Create custom rule
@@ -505,7 +498,7 @@ public class RuleUpdaterTest {
   @Test
   public void fail_to_update_custom_rule_when_empty_description() {
     // Create template rule
-    RuleDto templateRule = RuleTesting.newTemplateRule(RuleKey.of("java", "S001"));
+    RuleDto templateRule = newTemplateRule(RuleKey.of("java", "S001"));
     db.rules().insert(templateRule);
 
     // Create custom rule

server/sonar-webserver-webapi/src/test/java/org/sonar/server/rule/ws/CreateActionTest.java

@@ -59,7 +59,7 @@ import static org.sonar.test.JsonAssert.assertJson;
 
 public class CreateActionTest {
 
-  private System2 system2 = mock(System2.class);
+  private final System2 system2 = mock(System2.class);
 
   @Rule
   public UserSessionRule userSession = UserSessionRule.standalone();
@@ -70,9 +70,9 @@ public class CreateActionTest {
   @Rule
   public EsTester es = EsTester.create();
 
-  private UuidFactory uuidFactory = new SequenceUuidFactory();
+  private final UuidFactory uuidFactory = new SequenceUuidFactory();
 
-  private WsActionTester ws = new WsActionTester(new CreateAction(db.getDbClient(),
+  private final WsActionTester ws = new WsActionTester(new CreateAction(db.getDbClient(),
     new RuleCreator(system2, new RuleIndexer(es.client(), db.getDbClient()), db.getDbClient(), newFullTypeValidations(), uuidFactory),
     new RuleMapper(new Languages(), createMacroInterpreter(), new RuleDescriptionFormatter()),
     new RuleWsSupport(db.getDbClient(), userSession)));
@@ -136,11 +136,10 @@ public class CreateActionTest {
     RuleDto templateRule = newTemplateRule(RuleKey.of("java", "S001"));
     db.rules().insert(templateRule);
     // insert a removed rule
-    RuleDto customRule = newCustomRule(templateRule)
+    RuleDto customRule = newCustomRule(templateRule, "Description")
       .setRuleKey("MY_CUSTOM")
       .setStatus(RuleStatus.REMOVED)
       .setName("My custom rule")
-      .replaceRuleDescriptionSectionDtos(createDefaultRuleDescriptionSection(uuidFactory.create(), "Description"))
       .setDescriptionFormat(RuleDto.Format.MARKDOWN)
       .setSeverity(Severity.MAJOR);
     db.rules().insert(customRule);

server/sonar-webserver-webapi/src/test/java/org/sonar/server/rule/ws/SearchActionTest.java

@@ -89,6 +89,7 @@ import static org.mockito.Mockito.mock;
 import static org.sonar.api.rule.Severity.BLOCKER;
 import static org.sonar.api.server.rule.RuleDescriptionSection.RuleDescriptionSectionKeys.RESOURCES_SECTION_KEY;
 import static org.sonar.db.rule.RuleDescriptionSectionDto.createDefaultRuleDescriptionSection;
+import static org.sonar.db.rule.RuleTesting.newRule;
 import static org.sonar.db.rule.RuleTesting.newRuleWithoutDescriptionSection;
 import static org.sonar.db.rule.RuleTesting.setSystemTags;
 import static org.sonar.db.rule.RuleTesting.setTags;
@@ -242,11 +243,9 @@ public class SearchActionTest {
 
   @Test
   public void filter_by_rule_description() {
-    RuleDto rule1 = db.rules()
-      .insert(
-        r1 -> r1
-          .replaceRuleDescriptionSectionDtos(createDefaultRuleDescriptionSection(uuidFactory.create(), "This is the <bold>best</bold> rule now&amp;for<b>ever</b>"))
-          .setNoteUserUuid(null));
+    RuleDto rule1 = db.rules().insert(
+      newRule(createDefaultRuleDescriptionSection(uuidFactory.create(), "This is the <bold>best</bold> rule now&amp;for<b>ever</b>"))
+        .setNoteUserUuid(null));
     db.rules().insert(r1 -> r1.setName("Some other stuff").setNoteUserUuid(null));
     indexRules();
 

server/sonar-webserver-webapi/src/test/java/org/sonar/server/rule/ws/ShowActionTest.java

@@ -64,6 +64,7 @@ import static org.sonar.db.rule.RuleDescriptionSectionDto.DEFAULT_KEY;
 import static org.sonar.db.rule.RuleDescriptionSectionDto.createDefaultRuleDescriptionSection;
 import static org.sonar.db.rule.RuleDto.Format.MARKDOWN;
 import static org.sonar.db.rule.RuleTesting.newCustomRule;
+import static org.sonar.db.rule.RuleTesting.newRule;
 import static org.sonar.db.rule.RuleTesting.newRuleWithoutDescriptionSection;
 import static org.sonar.db.rule.RuleTesting.newTemplateRule;
 import static org.sonar.db.rule.RuleTesting.setTags;
@@ -296,12 +297,10 @@ public class ShowActionTest {
 
   @Test
   public void encode_html_description_of_custom_rule() {
-    // Template rule
     RuleDto templateRule = newTemplateRule(RuleKey.of("java", "S001"));
     db.rules().insert(templateRule);
-    // Custom rule
-    RuleDto customRule = newCustomRule(templateRule)
-      .replaceRuleDescriptionSectionDtos(createDefaultRuleDescriptionSection(uuidFactory.create(), "<div>line1\nline2</div>"))
+
+    RuleDto customRule = newCustomRule(templateRule, "<div>line1\nline2</div>")
       .setDescriptionFormat(MARKDOWN)
       .setNoteUserUuid(userDto.getUuid());
     db.rules().insert(customRule);
@@ -333,19 +332,16 @@ public class ShowActionTest {
 
   @Test
   public void show_adhoc_rule() {
-    RuleDto externalRule = db.rules().insert(r -> {
-        r.setIsExternal(true)
-          .setIsAdHoc(true)
-          .setAdHocName("adhoc name")
-          .setAdHocDescription("<div>desc</div>")
-          .setAdHocSeverity(Severity.BLOCKER)
-          .setAdHocType(RuleType.VULNERABILITY)
-          .setNoteData(null)
-          .setNoteUserUuid(null);
-        //Ad-hoc description has no description sections defined
-        r.getRuleDescriptionSectionDtos().clear();
-      }
-    );
+    //Ad-hoc description has no description sections defined
+    RuleDto externalRule = db.rules().insert(newRuleWithoutDescriptionSection()
+      .setIsExternal(true)
+      .setIsAdHoc(true)
+      .setAdHocName("adhoc name")
+      .setAdHocDescription("<div>desc</div>")
+      .setAdHocSeverity(Severity.BLOCKER)
+      .setAdHocType(RuleType.VULNERABILITY)
+      .setNoteData(null)
+      .setNoteUserUuid(null));
 
     doReturn("&lt;div&gt;desc2&lt;/div&gt;").when(macroInterpreter).interpret(externalRule.getAdHocDescription());
 
@@ -435,11 +431,10 @@ public class ShowActionTest {
 
   @Test
   public void ignore_predefined_info_on_adhoc_rule() {
-    RuleDto externalRule = db.rules().insert(r -> r
+    RuleDto externalRule = newRule(createDefaultRuleDescriptionSection(uuidFactory.create(), "<div>predefined desc</div>"))
       .setIsExternal(true)
       .setIsAdHoc(true)
       .setName("predefined name")
-      .replaceRuleDescriptionSectionDtos(createDefaultRuleDescriptionSection(uuidFactory.create(), "<div>predefined desc</div>"))
       .setSeverity(Severity.BLOCKER)
       .setType(RuleType.VULNERABILITY)
       .setAdHocName("adhoc name")
@@ -447,7 +442,8 @@ public class ShowActionTest {
       .setAdHocSeverity(Severity.MAJOR)
       .setAdHocType(RuleType.CODE_SMELL)
       .setNoteData(null)
-      .setNoteUserUuid(null));
+      .setNoteUserUuid(null);
+    externalRule = db.rules().insert(externalRule);
     doReturn("&lt;div&gt;adhoc desc&lt;/div&gt;").when(macroInterpreter).interpret(externalRule.getAdHocDescription());
 
     ShowResponse result = ws.newRequest()

server/sonar-webserver-webapi/src/test/java/org/sonar/server/rule/ws/UpdateActionTest.java

@@ -56,6 +56,7 @@ import static org.sonar.api.server.debt.DebtRemediationFunction.Type.LINEAR;
 import static org.sonar.api.server.debt.DebtRemediationFunction.Type.LINEAR_OFFSET;
 import static org.sonar.db.permission.GlobalPermission.ADMINISTER_QUALITY_PROFILES;
 import static org.sonar.db.rule.RuleDescriptionSectionDto.createDefaultRuleDescriptionSection;
+import static org.sonar.db.rule.RuleTesting.newRule;
 import static org.sonar.db.rule.RuleTesting.setSystemTags;
 import static org.sonar.db.rule.RuleTesting.setTags;
 import static org.sonar.server.rule.ws.UpdateAction.PARAM_KEY;
@@ -79,18 +80,18 @@ public class UpdateActionTest {
   @Rule
   public UserSessionRule userSession = UserSessionRule.standalone();
 
-  private DbClient dbClient = db.getDbClient();
-  private EsClient esClient = es.client();
-  private RuleDescriptionFormatter ruleDescriptionFormatter = new RuleDescriptionFormatter();
+  private final DbClient dbClient = db.getDbClient();
+  private final EsClient esClient = es.client();
+  private final RuleDescriptionFormatter ruleDescriptionFormatter = new RuleDescriptionFormatter();
 
-  private Languages languages = new Languages();
-  private RuleMapper mapper = new RuleMapper(languages, createMacroInterpreter(), ruleDescriptionFormatter);
-  private RuleIndexer ruleIndexer = new RuleIndexer(esClient, dbClient);
-  private UuidFactoryFast uuidFactory = UuidFactoryFast.getInstance();
+  private final Languages languages = new Languages();
+  private final RuleMapper mapper = new RuleMapper(languages, createMacroInterpreter(), ruleDescriptionFormatter);
+  private final RuleIndexer ruleIndexer = new RuleIndexer(esClient, dbClient);
+  private final UuidFactoryFast uuidFactory = UuidFactoryFast.getInstance();
 
-  private RuleUpdater ruleUpdater = new RuleUpdater(dbClient, ruleIndexer, uuidFactory, System2.INSTANCE);
-  private WsAction underTest = new UpdateAction(dbClient, ruleUpdater, mapper, userSession, new RuleWsSupport(db.getDbClient(), userSession));
-  private WsActionTester ws = new WsActionTester(underTest);
+  private final RuleUpdater ruleUpdater = new RuleUpdater(dbClient, ruleIndexer, uuidFactory, System2.INSTANCE);
+  private final WsAction underTest = new UpdateAction(dbClient, ruleUpdater, mapper, userSession, new RuleWsSupport(db.getDbClient(), userSession));
+  private final WsActionTester ws = new WsActionTester(underTest);
 
   @Test
   public void check_definition() {
@@ -110,17 +111,17 @@ public class UpdateActionTest {
       r -> r.setCreatedAt(PAST),
       r -> r.setUpdatedAt(PAST));
     db.rules().insertRuleParam(templateRule, param -> param.setName("regex").setType("STRING").setDescription("Reg ex").setDefaultValue(".*"));
-    RuleDto customRule = db.rules().insert(
-      r -> r.setRuleKey(RuleKey.of("java", "MY_CUSTOM")),
-      r -> r.setName("Old custom"),
-      r -> r.replaceRuleDescriptionSectionDtos(createRuleDescriptionSectionDto()),
-      r -> r.setSeverity(Severity.MINOR),
-      r -> r.setStatus(RuleStatus.BETA),
-      r -> r.setTemplateUuid(templateRule.getUuid()),
-      r -> r.setLanguage("js"),
-      r -> r.setNoteUserUuid(null),
-      r -> r.setCreatedAt(PAST),
-      r -> r.setUpdatedAt(PAST));
+
+    RuleDto customRule = newRule(RuleKey.of("java", "MY_CUSTOM"), createRuleDescriptionSectionDto())
+      .setName("Old custom")
+      .setSeverity(Severity.MINOR)
+      .setStatus(RuleStatus.BETA)
+      .setTemplateUuid(templateRule.getUuid())
+      .setLanguage("js")
+      .setNoteUserUuid(null)
+      .setCreatedAt(PAST)
+      .setUpdatedAt(PAST);
+    customRule = db.rules().insert(customRule);
     db.rules().insertRuleParam(customRule, param -> param.setName("regex").setType("a").setDescription("Reg ex"));
 
     TestResponse request = ws.newRequest().setMethod("POST")
@@ -246,13 +247,14 @@ public class UpdateActionTest {
       r -> r.setIsTemplate(true),
       r -> r.setCreatedAt(PAST),
       r -> r.setUpdatedAt(PAST));
+
     RuleDto customRule = db.rules().insert(
-      r -> r.setRuleKey(RuleKey.of("java", "MY_CUSTOM")),
-      r -> r.setName("Old custom"),
-      r -> r.replaceRuleDescriptionSectionDtos(createRuleDescriptionSectionDto()),
-      r -> r.setTemplateUuid(templateRule.getUuid()),
-      r -> r.setCreatedAt(PAST),
-      r -> r.setUpdatedAt(PAST));
+      newRule(RuleKey.of("java", "MY_CUSTOM"), createRuleDescriptionSectionDto())
+        .setRuleKey(RuleKey.of("java", "MY_CUSTOM"))
+        .setName("Old custom")
+        .setTemplateUuid(templateRule.getUuid())
+        .setCreatedAt(PAST)
+        .setUpdatedAt(PAST));
 
     assertThatThrownBy(() -> {
       ws.newRequest().setMethod("POST")