SONAR-8867 add and use RuleDao#selectDefinitionByKey

and add organization parameter to RuleDao#selectByKey

server/sonar-db-dao/src/main/java/org/sonar/db/qualityprofile/ActiveRuleDto.java

@@ -26,7 +26,7 @@ import org.apache.commons.lang.builder.ReflectionToStringBuilder;
 import org.apache.commons.lang.builder.ToStringStyle;
 import org.sonar.api.rule.RuleKey;
 import org.sonar.api.rules.ActiveRule;
-import org.sonar.db.rule.RuleDto;
+import org.sonar.db.rule.RuleDefinitionDto;
 import org.sonar.db.rule.SeverityUtil;
 
 import static java.util.Objects.requireNonNull;
@@ -142,7 +142,7 @@ public class ActiveRuleDto {
     return this;
   }
 
-  public static ActiveRuleDto createFor(QualityProfileDto profileDto, RuleDto ruleDto) {
+  public static ActiveRuleDto createFor(QualityProfileDto profileDto, RuleDefinitionDto ruleDto) {
     requireNonNull(profileDto.getId(), "Profile is not persisted");
     requireNonNull(ruleDto.getId(), "Rule is not persisted");
     ActiveRuleDto dto = new ActiveRuleDto();

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

@@ -34,10 +34,14 @@ import static org.sonar.db.DatabaseUtils.executeLargeInputs;
 
 public class RuleDao implements Dao {
 
-  public Optional<RuleDto> selectByKey(DbSession session, RuleKey key) {
+  public Optional<RuleDto> selectByKey(DbSession session, String organizationUuid, RuleKey key) {
     return Optional.fromNullable(mapper(session).selectByKey(key));
   }
 
+  public Optional<RuleDefinitionDto> selectDefinitionByKey(DbSession session, RuleKey key) {
+    return Optional.fromNullable(mapper(session).selectDefinitionByKey(key));
+  }
+
   public RuleDto selectOrFailByKey(DbSession session, RuleKey key) {
     RuleDto rule = mapper(session).selectByKey(key);
     if (rule == null) {

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

@@ -37,6 +37,8 @@ public interface RuleMapper {
 
   RuleDto selectByKey(RuleKey ruleKey);
 
+  RuleDefinitionDto selectDefinitionByKey(RuleKey ruleKey);
+
   List<RuleDto> selectByKeys(@Param("ruleKeys") List<RuleKey> keys);
 
   List<RuleDto> selectByQuery(@Param("query") RuleQuery ruleQuery);

server/sonar-db-dao/src/main/resources/org/sonar/db/rule/RuleMapper.xml

@@ -3,7 +3,7 @@
 
 <mapper namespace="org.sonar.db.rule.RuleMapper">
 
-  <sql id="selectColumns">
+  <sql id="selectDefinitionColumns">
     r.id,
     r.plugin_rule_key as "ruleKey",
     r.plugin_name as "repositoryKey",
@@ -16,34 +16,38 @@
     r.is_template as "isTemplate",
     r.language as "language",
     r.template_id as "templateId",
-    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.def_remediation_function as "defaultRemediationFunction",
-    r.remediation_gap_mult as "remediationGapMultiplier",
     r.def_remediation_gap_mult as "defaultRemediationGapMultiplier",
-    r.remediation_base_effort as "remediationBaseEffort",
     r.def_remediation_base_effort as "defaultRemediationBaseEffort",
     r.gap_description as "gapDescription",
-    r.tags as "tagsField",
     r.system_tags as "systemTagsField",
     r.rule_type as "type",
     r.created_at as "createdAt",
     r.updated_at as "updatedAt"
   </sql>
 
+  <sql id="selectRuleColumns">
+    <include refid="selectDefinitionColumns"/>,
+    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"
+  </sql>
+
   <select id="selectAll" resultType="Rule">
     select
-      <include refid="selectColumns"/>
+      <include refid="selectRuleColumns"/>
     from
       rules r
   </select>
 
   <select id="selectEnabled" resultType="Rule">
     select
-      <include refid="selectColumns"/>
+      <include refid="selectRuleColumns"/>
     from
       rules r
     where
@@ -52,7 +56,7 @@
 
   <select id="selectById" parameterType="Long" resultType="Rule">
     select
-      <include refid="selectColumns"/>
+      <include refid="selectRuleColumns"/>
     from
       rules r
     where
@@ -61,7 +65,7 @@
 
   <select id="selectByIds" parameterType="map" resultType="Rule">
     select
-      <include refid="selectColumns"/>
+      <include refid="selectRuleColumns"/>
     from
       rules r
     where
@@ -72,7 +76,17 @@
 
   <select id="selectByKey" parameterType="map" resultType="Rule">
     select
-      <include refid="selectColumns"/>
+      <include refid="selectRuleColumns"/>
+    from
+      rules r
+    where
+      r.plugin_name=#{repository,jdbcType=VARCHAR}
+      and r.plugin_rule_key=#{rule,jdbcType=VARCHAR}
+  </select>
+
+  <select id="selectDefinitionByKey" parameterType="map" resultType="org.sonar.db.rule.RuleDefinitionDto">
+    select
+      <include refid="selectDefinitionColumns"/>
     from
       rules r
     where
@@ -82,7 +96,7 @@
 
   <select id="selectByKeys" parameterType="map" resultType="Rule">
     select
-      <include refid="selectColumns"/>
+      <include refid="selectRuleColumns"/>
     from
       rules r
     where
@@ -93,7 +107,7 @@
 
   <select id="selectByQuery" parameterType="map" resultType="Rule">
     select
-      <include refid="selectColumns"/>
+      <include refid="selectRuleColumns"/>
     from
       rules r
     where

server/sonar-db-dao/src/test/java/org/sonar/db/qualityprofile/ActiveRuleDaoTest.java

@@ -37,7 +37,7 @@ import org.sonar.db.DbTester;
 import org.sonar.db.RowNotFoundException;
 import org.sonar.db.organization.OrganizationDto;
 import org.sonar.db.organization.OrganizationTesting;
-import org.sonar.db.rule.RuleDto;
+import org.sonar.db.rule.RuleDefinitionDto;
 import org.sonar.db.rule.RuleParamDto;
 import org.sonar.db.rule.RuleTesting;
 
@@ -67,9 +67,9 @@ public class ActiveRuleDaoTest {
   private QualityProfileDto profile1 = QualityProfileDto.createFor("qp1").setOrganizationUuid(organization.getUuid()).setName("QProfile1");
   private QualityProfileDto profile2 = QualityProfileDto.createFor("qp2").setOrganizationUuid(organization.getUuid()).setName("QProfile2");
 
-  private RuleDto rule1 = RuleTesting.newDto(RuleTesting.XOO_X1);
-  private RuleDto rule2 = RuleTesting.newDto(RuleTesting.XOO_X2);
-  private RuleDto rule3 = RuleTesting.newDto(RuleTesting.XOO_X3);
+  private RuleDefinitionDto rule1 = RuleTesting.newDto(RuleTesting.XOO_X1).getDefinition();
+  private RuleDefinitionDto rule2 = RuleTesting.newDto(RuleTesting.XOO_X2).getDefinition();
+  private RuleDefinitionDto rule3 = RuleTesting.newDto(RuleTesting.XOO_X3).getDefinition();
 
   private RuleParamDto rule1Param1;
   private RuleParamDto rule1Param2;
@@ -99,21 +99,21 @@ public class ActiveRuleDaoTest {
       .setName("param1")
       .setDefaultValue("value1")
       .setType(RuleParamType.STRING.toString());
-    dbClient.ruleDao().insertRuleParam(dbSession, rule1.getDefinition(), rule1Param1);
+    dbClient.ruleDao().insertRuleParam(dbSession, rule1, rule1Param1);
 
     rule1Param2 = new RuleParamDto()
       .setRuleId(rule1.getId())
       .setName("param2")
       .setDefaultValue("2")
       .setType(RuleParamType.INTEGER.toString());
-    dbClient.ruleDao().insertRuleParam(dbSession, rule1.getDefinition(), rule1Param2);
+    dbClient.ruleDao().insertRuleParam(dbSession, rule1, rule1Param2);
 
     rule2Param1 = new RuleParamDto()
       .setRuleId(rule2.getId())
       .setName("param1")
       .setDefaultValue("1")
       .setType(RuleParamType.INTEGER.toString());
-    dbClient.ruleDao().insertRuleParam(dbSession, rule2.getDefinition(), rule2Param1);
+    dbClient.ruleDao().insertRuleParam(dbSession, rule2, rule2Param1);
 
     dbSession.commit();
   }
@@ -212,8 +212,8 @@ public class ActiveRuleDaoTest {
   }
 
   @Test
-  public void select_by_profile_ignore_removed_rules() {
-    RuleDto removedRule = RuleTesting.newDto(RuleKey.of("removed", "rule")).setStatus(RuleStatus.REMOVED);
+  public void select_by_profile_ignore_removed_rules() throws Exception {
+    RuleDefinitionDto removedRule = RuleTesting.newDto(RuleKey.of("removed", "rule")).setStatus(RuleStatus.REMOVED).getDefinition();
     dbTester.rules().insertRule(removedRule);
     ActiveRuleDto activeRule = createFor(profile1, removedRule).setSeverity(BLOCKER);
     underTest.insert(dbTester.getSession(), activeRule);
@@ -361,7 +361,7 @@ public class ActiveRuleDaoTest {
     assertThat(dbTester.countRowsOfTable(dbSession, "active_rules")).isEqualTo(1);
   }
 
-  private static ActiveRuleDto newRow(QualityProfileDto profile, RuleDto rule) {
+  private static ActiveRuleDto newRow(QualityProfileDto profile, RuleDefinitionDto rule) {
     return createFor(profile, rule).setSeverity(BLOCKER);
   }
 
@@ -631,8 +631,8 @@ public class ActiveRuleDaoTest {
 
   @Test
   public void test_countActiveRulesForRuleStatusByProfileKey_for_a_specified_organization() {
-    RuleDto betaRule1 = dbTester.rules().insertRule(RuleTesting.newRuleDto().setStatus(RuleStatus.BETA));
-    RuleDto betaRule2 = dbTester.rules().insertRule(RuleTesting.newRuleDto().setStatus(RuleStatus.BETA));
+    RuleDefinitionDto betaRule1 = dbTester.rules().insertRule(RuleTesting.newRuleDto().setStatus(RuleStatus.BETA)).getDefinition();
+    RuleDefinitionDto betaRule2 = dbTester.rules().insertRule(RuleTesting.newRuleDto().setStatus(RuleStatus.BETA)).getDefinition();
     dbTester.qualityProfiles().activateRule(profile1, rule1);
     dbTester.qualityProfiles().activateRule(profile2, betaRule1);
     dbTester.qualityProfiles().activateRule(profile2, betaRule2);

server/sonar-db-dao/src/test/java/org/sonar/db/qualityprofile/QualityProfileDbTester.java

@@ -27,7 +27,7 @@ import org.sonar.db.DbSession;
 import org.sonar.db.DbTester;
 import org.sonar.db.component.ComponentDto;
 import org.sonar.db.organization.OrganizationDto;
-import org.sonar.db.rule.RuleDto;
+import org.sonar.db.rule.RuleDefinitionDto;
 
 import static org.sonar.api.rule.Severity.MAJOR;
 import static org.sonar.db.qualityprofile.ActiveRuleDto.createFor;
@@ -82,7 +82,7 @@ public class QualityProfileDbTester {
     dbSession.commit();
   }
 
-  public void activateRule(QualityProfileDto profile, RuleDto rule, Consumer<ActiveRuleDto>... consumers) {
+  public void activateRule(QualityProfileDto profile, RuleDefinitionDto rule, Consumer<ActiveRuleDto>... consumers) {
     ActiveRuleDto activeRule = createFor(profile, rule).setSeverity(MAJOR);
     for (Consumer<ActiveRuleDto> consumer : consumers) {
       consumer.accept(activeRule);

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

@@ -49,21 +49,33 @@ import static org.assertj.guava.api.Assertions.assertThat;
 
 public class RuleDaoTest {
 
+  private static final String ORGANIZATION_UUID = "org-1";
+
   @Rule
   public ExpectedException thrown = ExpectedException.none();
-
   @Rule
   public DbTester dbTester = DbTester.create(System2.INSTANCE);
 
-  RuleDao underTest = dbTester.getDbClient().ruleDao();
+  private RuleDao underTest = dbTester.getDbClient().ruleDao();
 
   @Test
   public void selectByKey() {
     dbTester.prepareDbUnit(getClass(), "shared.xml");
 
-    assertThat(underTest.selectByKey(dbTester.getSession(), RuleKey.of("NOT", "FOUND")).isPresent()).isFalse();
+    assertThat(underTest.selectByKey(dbTester.getSession(), ORGANIZATION_UUID, RuleKey.of("NOT", "FOUND")).isPresent()).isFalse();
+
+    Optional<RuleDto> rule = underTest.selectByKey(dbTester.getSession(), ORGANIZATION_UUID, RuleKey.of("java", "S001"));
+    assertThat(rule.isPresent()).isTrue();
+    assertThat(rule.get().getId()).isEqualTo(1);
+  }
+
+  @Test
+  public void selectDefinitionByKey() {
+    dbTester.prepareDbUnit(getClass(), "shared.xml");
+
+    assertThat(underTest.selectDefinitionByKey(dbTester.getSession(), RuleKey.of("NOT", "FOUND")).isPresent()).isFalse();
 
-    Optional<RuleDto> rule = underTest.selectByKey(dbTester.getSession(), RuleKey.of("java", "S001"));
+    Optional<RuleDefinitionDto> rule = underTest.selectDefinitionByKey(dbTester.getSession(), RuleKey.of("java", "S001"));
     assertThat(rule.isPresent()).isTrue();
     assertThat(rule.get().getId()).isEqualTo(1);
   }

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

@@ -35,6 +35,13 @@ public class RuleDbTester {
     this.db = db;
   }
 
+  public RuleDefinitionDto insertRule(RuleDefinitionDto ruleDto) {
+    RuleDao ruleDao = db.getDbClient().ruleDao();
+    ruleDao.insert(db.getSession(), ruleDto);
+    db.commit();
+    return ruleDto;
+  }
+
   public RuleDto insertRule(RuleDto ruleDto) {
     RuleDao ruleDao = db.getDbClient().ruleDao();
     ruleDao.insert(db.getSession(), ruleDto.getDefinition());

server/sonar-db-dao/src/test/resources/org/sonar/db/rule/RuleDaoTest/shared.xml

@@ -1,24 +1,51 @@
 <dataset>
 
-  <rules id="1" name="Null Pointer" plugin_rule_key="S001"
-         plugin_config_key="S1" plugin_name="java" description="[null]" priority="4" status="READY"
-         is_template="[false]" template_id="[null]"
-         tags="bug,performance" system_tags="cwe"
-         created_at="1500000000000" updated_at="1600000000000"
+  <rules id="1"
+         name="Null Pointer"
+         plugin_rule_key="S001"
+         plugin_config_key="S1"
+         plugin_name="java"
+         description="[null]"
+         priority="4"
+         status="READY"
+         is_template="[false]"
+         template_id="[null]"
+         tags="bug,performance"
+         system_tags="cwe"
+         created_at="1500000000000"
+         updated_at="1600000000000"
   />
 
-  <rules id="2" name="Slow" plugin_rule_key="S002"
-         plugin_config_key="S2" plugin_name="java" description="[null]" priority="4" status="BETA"
-         is_template="[false]" template_id="[null]"
-         tags="[null]" system_tags="[null]"
-         created_at="1500000000000" updated_at="1600000000000"
+  <rules id="2"
+         name="Slow"
+         plugin_rule_key="S002"
+         plugin_config_key="S2"
+         plugin_name="java"
+         description="[null]"
+         priority="4"
+         status="BETA"
+         is_template="[false]"
+         template_id="[null]"
+         tags="[null]"
+         system_tags="[null]"
+         created_at="1500000000000"
+         updated_at="1600000000000"
   />
 
-  <rules id="10" name="Removed" plugin_rule_key="S003"
-         plugin_config_key="S3" plugin_name="java" description="[null]" priority="4" status="REMOVED"
-         is_template="[false]" template_id="[null]"
-         tags="[null]" system_tags="[null]"
-         created_at="1500000000000" updated_at="1600000000000"
+  <rules id="10"
+         name="Removed"
+         plugin_rule_key="S003"
+         plugin_config_key="S3"
+         plugin_name="java"
+         description="[null]"
+         priority="4"
+         status="REMOVED"
+         is_template="[false]"
+         template_id="[null]"
+         tags="[null]"
+         system_tags="[null]"
+         created_at="1500000000000"
+         updated_at="1600000000000"
   />
 
 </dataset>

server/sonar-server/src/main/java/org/sonar/server/issue/IssueUpdater.java

@@ -28,7 +28,7 @@ import org.sonar.core.issue.IssueChangeContext;
 import org.sonar.db.DbClient;
 import org.sonar.db.DbSession;
 import org.sonar.db.component.ComponentDto;
-import org.sonar.db.rule.RuleDto;
+import org.sonar.db.rule.RuleDefinitionDto;
 import org.sonar.server.issue.notification.IssueChangeNotification;
 import org.sonar.server.notification.NotificationManager;
 
@@ -46,7 +46,7 @@ public class IssueUpdater {
 
   public void saveIssue(DbSession session, DefaultIssue issue, IssueChangeContext context, @Nullable String comment) {
     issueStorage.save(session, issue);
-    Optional<RuleDto> rule = getRuleByKey(session, issue.getRuleKey());
+    Optional<RuleDefinitionDto> rule = getRuleByKey(session, issue.getRuleKey());
     ComponentDto project = dbClient.componentDao().selectOrFailByUuid(session, issue.projectUuid());
     notificationService.scheduleForSending(new IssueChangeNotification()
       .setIssue(issue)
@@ -57,8 +57,8 @@ public class IssueUpdater {
       .setComment(comment));
   }
 
-  private Optional<RuleDto> getRuleByKey(DbSession session, RuleKey ruleKey) {
-    Optional<RuleDto> rule = Optional.ofNullable(dbClient.ruleDao().selectByKey(session, ruleKey).orNull());
+  private Optional<RuleDefinitionDto> getRuleByKey(DbSession session, RuleKey ruleKey) {
+    Optional<RuleDefinitionDto> rule = Optional.ofNullable(dbClient.ruleDao().selectDefinitionByKey(session, ruleKey).orNull());
     return (rule.isPresent() && rule.get().getStatus() != RuleStatus.REMOVED) ? rule : Optional.empty();
   }
 }

server/sonar-server/src/main/java/org/sonar/server/qualityprofile/CachingRuleActivatorContextFactory.java

@@ -32,11 +32,11 @@ import org.sonar.db.DbClient;
 import org.sonar.db.DbSession;
 import org.sonar.db.qualityprofile.ActiveRuleDto;
 import org.sonar.db.qualityprofile.ActiveRuleKey;
-import org.sonar.db.rule.RuleDto;
+import org.sonar.db.rule.RuleDefinitionDto;
 
 public class CachingRuleActivatorContextFactory extends RuleActivatorContextFactory implements Startable {
   private final DbClient dbClient;
-  private final Map<RuleKey, RuleDto> rulesByRuleKey = new HashMap<>();
+  private final Map<RuleKey, RuleDefinitionDto> rulesByRuleKey = new HashMap<>();
   private final Cache<String, Map<RuleKey, ActiveRuleDto>> childrenByParentKey = CacheBuilder.newBuilder()
     .maximumSize(10)
     .build();
@@ -49,7 +49,7 @@ public class CachingRuleActivatorContextFactory extends RuleActivatorContextFact
   @Override
   public void start() {
     try (DbSession dbSession = dbClient.openSession(false)) {
-      dbClient.ruleDao().selectAll(dbSession).forEach(rule -> rulesByRuleKey.put(rule.getKey(), rule));
+      dbClient.ruleDao().selectAll(dbSession).forEach(rule -> rulesByRuleKey.put(rule.getKey(), rule.getDefinition()));
     }
   }
 
@@ -59,7 +59,7 @@ public class CachingRuleActivatorContextFactory extends RuleActivatorContextFact
   }
 
   @Override
-  Optional<RuleDto> getRule(DbSession dbSession, RuleKey ruleKey) {
+  Optional<RuleDefinitionDto> getRule(DbSession dbSession, RuleKey ruleKey) {
     return Optional.ofNullable(rulesByRuleKey.get(ruleKey));
   }
 

server/sonar-server/src/main/java/org/sonar/server/qualityprofile/RuleActivator.java

@@ -39,7 +39,7 @@ import org.sonar.db.qualityprofile.ActiveRuleDto;
 import org.sonar.db.qualityprofile.ActiveRuleKey;
 import org.sonar.db.qualityprofile.ActiveRuleParamDto;
 import org.sonar.db.qualityprofile.QualityProfileDto;
-import org.sonar.db.rule.RuleDto;
+import org.sonar.db.rule.RuleDefinitionDto;
 import org.sonar.db.rule.RuleParamDto;
 import org.sonar.server.exceptions.BadRequestException;
 import org.sonar.server.qualityprofile.index.ActiveRuleIndexer;
@@ -345,7 +345,7 @@ public class RuleActivator {
   /**
    * Deactivate a rule on a Quality profile WITHOUT committing db session, WITHOUT checking permissions, and forcing removal of inherited rules
    */
-  public List<ActiveRuleChange> deactivate(DbSession dbSession, RuleDto ruleDto) {
+  public List<ActiveRuleChange> deactivate(DbSession dbSession, RuleDefinitionDto ruleDto) {
     List<ActiveRuleChange> changes = Lists.newArrayList();
     List<ActiveRuleDto> activeRules = db.activeRuleDao().selectByRuleId(dbSession, ruleDto.getId());
     for (ActiveRuleDto activeRule : activeRules) {

server/sonar-server/src/main/java/org/sonar/server/qualityprofile/RuleActivatorContext.java

@@ -31,7 +31,7 @@ import org.sonar.db.qualityprofile.ActiveRuleDto;
 import org.sonar.db.qualityprofile.ActiveRuleKey;
 import org.sonar.db.qualityprofile.ActiveRuleParamDto;
 import org.sonar.db.qualityprofile.QualityProfileDto;
-import org.sonar.db.rule.RuleDto;
+import org.sonar.db.rule.RuleDefinitionDto;
 import org.sonar.db.rule.RuleParamDto;
 
 import static org.sonar.server.ws.WsUtils.checkRequest;
@@ -39,7 +39,7 @@ import static org.sonar.server.ws.WsUtils.checkRequest;
 class RuleActivatorContext {
 
   private final Date initDate = new Date();
-  private RuleDto rule;
+  private RuleDefinitionDto rule;
   private final Map<String, RuleParamDto> ruleParams = Maps.newHashMap();
   private QualityProfileDto profile;
   private ActiveRuleDto activeRule;
@@ -54,11 +54,11 @@ class RuleActivatorContext {
     return ActiveRuleKey.of(profile.getKee(), rule.getKey());
   }
 
-  RuleDto rule() {
+  RuleDefinitionDto rule() {
     return rule;
   }
 
-  RuleActivatorContext setRule(RuleDto rule) {
+  RuleActivatorContext setRule(RuleDefinitionDto rule) {
     this.rule = rule;
     return this;
   }

server/sonar-server/src/main/java/org/sonar/server/qualityprofile/RuleActivatorContextFactory.java

@@ -30,7 +30,7 @@ import org.sonar.db.qualityprofile.ActiveRuleDto;
 import org.sonar.db.qualityprofile.ActiveRuleKey;
 import org.sonar.db.qualityprofile.ActiveRuleParamDto;
 import org.sonar.db.qualityprofile.QualityProfileDto;
-import org.sonar.db.rule.RuleDto;
+import org.sonar.db.rule.RuleDefinitionDto;
 
 import static org.sonar.server.ws.WsUtils.checkRequest;
 
@@ -65,8 +65,8 @@ public class RuleActivatorContextFactory {
     return context;
   }
 
-  private RuleDto initRule(RuleKey ruleKey, RuleActivatorContext context, DbSession dbSession) {
-    Optional<RuleDto> rule = getRule(dbSession, ruleKey);
+  private RuleDefinitionDto initRule(RuleKey ruleKey, RuleActivatorContext context, DbSession dbSession) {
+    Optional<RuleDefinitionDto> rule = getRule(dbSession, ruleKey);
     checkRequest(rule.isPresent(), "Rule not found: %s", ruleKey);
     context.setRule(rule.get());
     context.setRuleParams(db.ruleDao().selectRuleParamsByRuleKey(dbSession, rule.get().getKey()));
@@ -89,8 +89,8 @@ public class RuleActivatorContextFactory {
     }
   }
 
-  Optional<RuleDto> getRule(DbSession dbSession, RuleKey ruleKey) {
-    return Optional.ofNullable(db.ruleDao().selectByKey(dbSession, ruleKey).orNull());
+  Optional<RuleDefinitionDto> getRule(DbSession dbSession, RuleKey ruleKey) {
+    return Optional.ofNullable(db.ruleDao().selectDefinitionByKey(dbSession, ruleKey).orNull());
   }
 
   Optional<ActiveRuleDto> getActiveRule(DbSession session, ActiveRuleKey key) {

server/sonar-server/src/main/java/org/sonar/server/rule/DefaultRuleFinder.java

@@ -40,6 +40,7 @@ import org.sonar.db.rule.RuleDao;
 import org.sonar.db.rule.RuleDto;
 import org.sonar.db.rule.RuleParamDto;
 import org.sonar.markdown.Markdown;
+import org.sonar.server.organization.DefaultOrganizationProvider;
 
 import static com.google.common.collect.Lists.newArrayList;
 
@@ -50,10 +51,12 @@ public class DefaultRuleFinder implements RuleFinder {
 
   private final DbClient dbClient;
   private final RuleDao ruleDao;
+  private final DefaultOrganizationProvider defaultOrganizationProvider;
 
-  public DefaultRuleFinder(DbClient dbClient) {
+  public DefaultRuleFinder(DbClient dbClient, DefaultOrganizationProvider defaultOrganizationProvider) {
     this.dbClient = dbClient;
     this.ruleDao = dbClient.ruleDao();
+    this.defaultOrganizationProvider = defaultOrganizationProvider;
   }
 
   @Override
@@ -96,7 +99,7 @@ public class DefaultRuleFinder implements RuleFinder {
   @CheckForNull
   public org.sonar.api.rules.Rule findByKey(RuleKey key) {
     try (DbSession dbSession = dbClient.openSession(false)) {
-      Optional<RuleDto> rule = ruleDao.selectByKey(dbSession, key);
+      Optional<RuleDto> rule = ruleDao.selectByKey(dbSession, defaultOrganizationProvider.get().getUuid(), key);
       if (rule.isPresent() && rule.get().getStatus() != RuleStatus.REMOVED) {
         return toRule(rule.get(), ruleDao.selectRuleParamsByRuleKey(dbSession, rule.get().getKey()));
       } else {

server/sonar-server/src/main/java/org/sonar/server/rule/RegisterRules.java

@@ -474,7 +474,7 @@ public class RegisterRules implements Startable {
     for (RuleDto rule : removedRules) {
       // SONAR-4642 Remove active rules only when repository still exists
       if (repositoryKeys.contains(rule.getRepositoryKey())) {
-        changes.addAll(ruleActivator.deactivate(session, rule));
+        changes.addAll(ruleActivator.deactivate(session, rule.getDefinition()));
       }
     }
     return changes;

server/sonar-server/src/main/java/org/sonar/server/rule/RuleCreator.java

@@ -76,9 +76,9 @@ public class RuleCreator {
 
     RuleKey customRuleKey = RuleKey.of(templateRule.getRepositoryKey(), newRule.ruleKey());
 
-    Optional<RuleDto> existingRule = loadRule(customRuleKey, dbSession);
+    Optional<RuleDefinitionDto> existingRule = loadRule(customRuleKey, dbSession);
     if (existingRule.isPresent()) {
-      updateExistingRule(existingRule.get().getDefinition(), newRule, dbSession);
+      updateExistingRule(existingRule.get(), newRule, dbSession);
     } else {
       createCustomRule(customRuleKey, newRule, templateRule, dbSession);
     }
@@ -146,8 +146,8 @@ public class RuleCreator {
     }
   }
 
-  private Optional<RuleDto> loadRule(RuleKey ruleKey, DbSession dbSession) {
-    return dbClient.ruleDao().selectByKey(dbSession, ruleKey);
+  private Optional<RuleDefinitionDto> loadRule(RuleKey ruleKey, DbSession dbSession) {
+    return dbClient.ruleDao().selectDefinitionByKey(dbSession, ruleKey);
   }
 
   private RuleKey createCustomRule(RuleKey ruleKey, NewCustomRule newRule, RuleDto templateRuleDto, DbSession dbSession) {

server/sonar-server/src/main/java/org/sonar/server/rule/RuleDeleter.java

@@ -53,7 +53,7 @@ public class RuleDeleter {
 
       // For custom rule, first deactivate the rule on all profiles
       if (rule.getTemplateId() != null) {
-        ruleActivator.deactivate(dbSession, rule);
+        ruleActivator.deactivate(dbSession, rule.getDefinition());
       }
 
       rule.setStatus(RuleStatus.REMOVED);

server/sonar-server/src/main/java/org/sonar/server/rule/ws/ShowAction.java

@@ -32,6 +32,7 @@ import org.sonar.db.DbClient;
 import org.sonar.db.DbSession;
 import org.sonar.db.rule.RuleDto;
 import org.sonar.db.rule.RuleParamDto;
+import org.sonar.server.organization.DefaultOrganizationProvider;
 import org.sonarqube.ws.Rules.ShowResponse;
 
 import static java.util.Collections.singletonList;
@@ -49,11 +50,13 @@ public class ShowAction implements RulesWsAction {
   private final DbClient dbClient;
   private final RuleMapper mapper;
   private final ActiveRuleCompleter activeRuleCompleter;
+  private final DefaultOrganizationProvider defaultOrganizationProvider;
 
-  public ShowAction(DbClient dbClient, RuleMapper mapper, ActiveRuleCompleter activeRuleCompleter) {
+  public ShowAction(DbClient dbClient, RuleMapper mapper, ActiveRuleCompleter activeRuleCompleter, DefaultOrganizationProvider defaultOrganizationProvider) {
     this.dbClient = dbClient;
     this.activeRuleCompleter = activeRuleCompleter;
     this.mapper = mapper;
+    this.defaultOrganizationProvider = defaultOrganizationProvider;
   }
 
   @Override
@@ -91,7 +94,8 @@ public class ShowAction implements RulesWsAction {
   public void handle(Request request, Response response) throws Exception {
     RuleKey key = RuleKey.parse(request.mandatoryParam(PARAM_KEY));
     try (DbSession dbSession = dbClient.openSession(false)) {
-      Optional<RuleDto> optionalRule = dbClient.ruleDao().selectByKey(dbSession, key);
+      String defaultOrganizationUuid = defaultOrganizationProvider.get().getUuid();
+      Optional<RuleDto> optionalRule = dbClient.ruleDao().selectByKey(dbSession, defaultOrganizationUuid, key);
       checkFoundWithOptional(optionalRule, "Rule not found: " + key);
       RuleDto rule = optionalRule.get();
       List<RuleDto> templateRules = new ArrayList<>();

server/sonar-server/src/main/java/org/sonar/server/rule/ws/UpdateAction.java

@@ -39,6 +39,7 @@ import org.sonar.db.DbClient;
 import org.sonar.db.DbSession;
 import org.sonar.db.rule.RuleDto;
 import org.sonar.db.rule.RuleParamDto;
+import org.sonar.server.organization.DefaultOrganizationProvider;
 import org.sonar.server.rule.RuleUpdate;
 import org.sonar.server.rule.RuleUpdater;
 import org.sonar.server.user.UserSession;
@@ -71,14 +72,16 @@ public class UpdateAction implements RulesWsAction {
   private final RuleMapper mapper;
   private final UserSession userSession;
   private final RuleWsSupport ruleWsSupport;
+  private final DefaultOrganizationProvider defaultOrganizationProvider;
 
   public UpdateAction(DbClient dbClient, RuleUpdater ruleUpdater, RuleMapper mapper, UserSession userSession,
-    RuleWsSupport ruleWsSupport) {
+                      RuleWsSupport ruleWsSupport, DefaultOrganizationProvider defaultOrganizationProvider) {
     this.dbClient = dbClient;
     this.ruleUpdater = ruleUpdater;
     this.mapper = mapper;
     this.userSession = userSession;
     this.ruleWsSupport = ruleWsSupport;
+    this.defaultOrganizationProvider = defaultOrganizationProvider;
   }
 
   @Override
@@ -163,17 +166,18 @@ public class UpdateAction implements RulesWsAction {
     ruleWsSupport.checkQProfileAdminPermission();
 
     try (DbSession dbSession = dbClient.openSession(false)) {
-      RuleUpdate update = readRequest(dbSession, request);
+      String defaultOrganizationUuid = defaultOrganizationProvider.get().getUuid();
+      RuleUpdate update = readRequest(dbSession, request, defaultOrganizationUuid);
       ruleUpdater.update(dbSession, update, userSession);
-      UpdateResponse updateResponse = buildResponse(dbSession, update.getRuleKey());
+      UpdateResponse updateResponse = buildResponse(dbSession, update.getRuleKey(), defaultOrganizationUuid);
 
       writeProtobuf(updateResponse, request, response);
     }
   }
 
-  private RuleUpdate readRequest(DbSession dbSession, Request request) {
+  private RuleUpdate readRequest(DbSession dbSession, Request request, String organizationUuid) {
     RuleKey key = RuleKey.parse(request.mandatoryParam(PARAM_KEY));
-    RuleUpdate update = createRuleUpdate(dbSession, key);
+    RuleUpdate update = createRuleUpdate(dbSession, key, organizationUuid);
     readTags(request, update);
     readMarkdownNote(request, update);
     readDebt(request, update);
@@ -201,8 +205,8 @@ public class UpdateAction implements RulesWsAction {
     return update;
   }
 
-  private RuleUpdate createRuleUpdate(DbSession dbSession, RuleKey key) {
-    Optional<RuleDto> optionalRule = dbClient.ruleDao().selectByKey(dbSession, key);
+  private RuleUpdate createRuleUpdate(DbSession dbSession, RuleKey key, String organizationUuid) {
+    Optional<RuleDto> optionalRule = dbClient.ruleDao().selectByKey(dbSession, organizationUuid, key);
     checkFoundWithOptional(optionalRule, "This rule does not exists : " + key);
     RuleDto rule = optionalRule.get();
     if (rule.getTemplateId() != null) {
@@ -247,8 +251,8 @@ public class UpdateAction implements RulesWsAction {
     }
   }
 
-  private UpdateResponse buildResponse(DbSession dbSession, RuleKey key) {
-    Optional<RuleDto> optionalRule = dbClient.ruleDao().selectByKey(dbSession, key);
+  private UpdateResponse buildResponse(DbSession dbSession, RuleKey key, String organizationUuid) {
+    Optional<RuleDto> optionalRule = dbClient.ruleDao().selectByKey(dbSession, organizationUuid, key);
     checkFoundWithOptional(optionalRule, "Rule not found: " + key);
     RuleDto rule = optionalRule.get();
     List<RuleDto> templateRules = new ArrayList<>();

server/sonar-server/src/test/java/org/sonar/server/issue/IssueUpdaterTest.java

@@ -43,6 +43,8 @@ import org.sonar.server.issue.index.IssueIndexer;
 import org.sonar.server.issue.index.IssueIteratorFactory;
 import org.sonar.server.issue.notification.IssueChangeNotification;
 import org.sonar.server.notification.NotificationManager;
+import org.sonar.server.organization.DefaultOrganizationProvider;
+import org.sonar.server.organization.TestDefaultOrganizationProvider;
 import org.sonar.server.rule.DefaultRuleFinder;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -68,6 +70,7 @@ public class IssueUpdaterTest {
   public EsTester esTester = new EsTester(new IssueIndexDefinition(new MapSettings()));
 
   private DbClient dbClient = dbTester.getDbClient();
+  private DefaultOrganizationProvider defaultOrganizationProvider = TestDefaultOrganizationProvider.from(dbTester);
 
   private RuleDbTester ruleDbTester = new RuleDbTester(dbTester);
   private IssueDbTester issueDbTester = new IssueDbTester(dbTester);
@@ -78,7 +81,7 @@ public class IssueUpdaterTest {
 
   private IssueIndexer issueIndexer = new IssueIndexer(esTester.client(), new IssueIteratorFactory(dbClient));
   private IssueUpdater underTest = new IssueUpdater(dbClient,
-    new ServerIssueStorage(system2, new DefaultRuleFinder(dbClient), dbClient, issueIndexer), notificationManager);
+    new ServerIssueStorage(system2, new DefaultRuleFinder(dbClient, defaultOrganizationProvider), dbClient, issueIndexer), notificationManager);
 
   @Test
   public void update_issue() throws Exception {

server/sonar-server/src/test/java/org/sonar/server/issue/ws/AddCommentActionTest.java

@@ -46,6 +46,8 @@ import org.sonar.server.issue.index.IssueIndexDefinition;
 import org.sonar.server.issue.index.IssueIndexer;
 import org.sonar.server.issue.index.IssueIteratorFactory;
 import org.sonar.server.notification.NotificationManager;
+import org.sonar.server.organization.DefaultOrganizationProvider;
+import org.sonar.server.organization.TestDefaultOrganizationProvider;
 import org.sonar.server.rule.DefaultRuleFinder;
 import org.sonar.server.tester.UserSessionRule;
 import org.sonar.server.ws.TestRequest;
@@ -83,11 +85,12 @@ public class AddCommentActionTest {
   private System2 system2 = mock(System2.class);
 
   private DbClient dbClient = dbTester.getDbClient();
+  private DefaultOrganizationProvider defaultOrganizationProvider = TestDefaultOrganizationProvider.from(dbTester);
 
   private IssueDbTester issueDbTester = new IssueDbTester(dbTester);
 
   private IssueIndexer issueIndexer = new IssueIndexer(esTester.client(), new IssueIteratorFactory(dbClient));
-  private ServerIssueStorage serverIssueStorage = new ServerIssueStorage(system2, new DefaultRuleFinder(dbClient), dbClient, issueIndexer);
+  private ServerIssueStorage serverIssueStorage = new ServerIssueStorage(system2, new DefaultRuleFinder(dbClient, defaultOrganizationProvider), dbClient, issueIndexer);
   private IssueUpdater issueUpdater = new IssueUpdater(dbClient, serverIssueStorage, mock(NotificationManager.class));
   private OperationResponseWriter responseWriter = mock(OperationResponseWriter.class);
 

server/sonar-server/src/test/java/org/sonar/server/issue/ws/AssignActionTest.java

@@ -43,6 +43,8 @@ import org.sonar.server.issue.index.IssueIndexDefinition;
 import org.sonar.server.issue.index.IssueIndexer;
 import org.sonar.server.issue.index.IssueIteratorFactory;
 import org.sonar.server.notification.NotificationManager;
+import org.sonar.server.organization.DefaultOrganizationProvider;
+import org.sonar.server.organization.TestDefaultOrganizationProvider;
 import org.sonar.server.rule.DefaultRuleFinder;
 import org.sonar.server.tester.UserSessionRule;
 import org.sonar.server.ws.WsActionTester;
@@ -77,11 +79,14 @@ public class AssignActionTest {
   @Rule
   public DbTester db = DbTester.create(system2);
 
+  private DefaultOrganizationProvider defaultOrganizationProvider = TestDefaultOrganizationProvider.from(db);
   private IssueIndexer issueIndexer = new IssueIndexer(es.client(), new IssueIteratorFactory(db.getDbClient()));
   private OperationResponseWriter responseWriter = mock(OperationResponseWriter.class);
   private AssignAction underTest = new AssignAction(system2, userSession, db.getDbClient(), new IssueFinder(db.getDbClient(), userSession), new IssueFieldsSetter(),
     new IssueUpdater(db.getDbClient(),
-      new ServerIssueStorage(system2, new DefaultRuleFinder(db.getDbClient()), db.getDbClient(), issueIndexer), mock(NotificationManager.class)),
+      new ServerIssueStorage(system2, new DefaultRuleFinder(db.getDbClient(), defaultOrganizationProvider), db.getDbClient(), issueIndexer),
+      mock(NotificationManager.class)
+    ),
     responseWriter);
   private WsActionTester ws = new WsActionTester(underTest);
 

server/sonar-server/src/test/java/org/sonar/server/issue/ws/BulkChangeActionTest.java

@@ -56,6 +56,8 @@ import org.sonar.server.issue.notification.IssueChangeNotification;
 import org.sonar.server.issue.workflow.FunctionExecutor;
 import org.sonar.server.issue.workflow.IssueWorkflow;
 import org.sonar.server.notification.NotificationManager;
+import org.sonar.server.organization.DefaultOrganizationProvider;
+import org.sonar.server.organization.TestDefaultOrganizationProvider;
 import org.sonar.server.rule.DefaultRuleFinder;
 import org.sonar.server.tester.UserSessionRule;
 import org.sonar.server.ws.TestRequest;
@@ -102,10 +104,11 @@ public class BulkChangeActionTest {
   public UserSessionRule userSession = UserSessionRule.standalone();
 
   private DbClient dbClient = db.getDbClient();
+  private DefaultOrganizationProvider defaultOrganizationProvider = TestDefaultOrganizationProvider.from(db);
 
   private IssueFieldsSetter issueFieldsSetter = new IssueFieldsSetter();
   private IssueWorkflow issueWorkflow = new IssueWorkflow(new FunctionExecutor(issueFieldsSetter), issueFieldsSetter);
-  private IssueStorage issueStorage = new ServerIssueStorage(system2, new DefaultRuleFinder(dbClient), dbClient, new IssueIndexer(es.client(), new IssueIteratorFactory(dbClient)));
+  private IssueStorage issueStorage = new ServerIssueStorage(system2, new DefaultRuleFinder(dbClient, defaultOrganizationProvider), dbClient, new IssueIndexer(es.client(), new IssueIteratorFactory(dbClient)));
   private NotificationManager notificationManager = mock(NotificationManager.class);
   private List<Action> actions = new ArrayList<>();
 

server/sonar-server/src/test/java/org/sonar/server/issue/ws/DoTransitionActionTest.java

@@ -51,6 +51,8 @@ import org.sonar.server.issue.index.IssueIteratorFactory;
 import org.sonar.server.issue.workflow.FunctionExecutor;
 import org.sonar.server.issue.workflow.IssueWorkflow;
 import org.sonar.server.notification.NotificationManager;
+import org.sonar.server.organization.DefaultOrganizationProvider;
+import org.sonar.server.organization.TestDefaultOrganizationProvider;
 import org.sonar.server.rule.DefaultRuleFinder;
 import org.sonar.server.tester.UserSessionRule;
 import org.sonar.server.ws.TestRequest;
@@ -88,6 +90,7 @@ public class DoTransitionActionTest {
   public UserSessionRule userSession = UserSessionRule.standalone();
 
   private DbClient dbClient = dbTester.getDbClient();
+  private DefaultOrganizationProvider defaultOrganizationProvider = TestDefaultOrganizationProvider.from(dbTester);
 
   private RuleDbTester ruleDbTester = new RuleDbTester(dbTester);
   private IssueDbTester issueDbTester = new IssueDbTester(dbTester);
@@ -99,7 +102,7 @@ public class DoTransitionActionTest {
   private OperationResponseWriter responseWriter = mock(OperationResponseWriter.class);
   private IssueIndexer issueIndexer = new IssueIndexer(esTester.client(), new IssueIteratorFactory(dbClient));
   private IssueUpdater issueUpdater = new IssueUpdater(dbClient,
-    new ServerIssueStorage(system2, new DefaultRuleFinder(dbClient), dbClient, issueIndexer), mock(NotificationManager.class));
+    new ServerIssueStorage(system2, new DefaultRuleFinder(dbClient, defaultOrganizationProvider), dbClient, issueIndexer), mock(NotificationManager.class));
 
   private WsAction underTest = new DoTransitionAction(dbClient, userSession, new IssueFinder(dbClient, userSession), issueUpdater, transitionService, responseWriter);
   private WsActionTester tester = new WsActionTester(underTest);

server/sonar-server/src/test/java/org/sonar/server/issue/ws/SetSeverityActionTest.java

@@ -47,6 +47,8 @@ import org.sonar.server.issue.index.IssueIndexDefinition;
 import org.sonar.server.issue.index.IssueIndexer;
 import org.sonar.server.issue.index.IssueIteratorFactory;
 import org.sonar.server.notification.NotificationManager;
+import org.sonar.server.organization.DefaultOrganizationProvider;
+import org.sonar.server.organization.TestDefaultOrganizationProvider;
 import org.sonar.server.rule.DefaultRuleFinder;
 import org.sonar.server.tester.UserSessionRule;
 import org.sonar.server.ws.TestRequest;
@@ -84,6 +86,7 @@ public class SetSeverityActionTest {
   private System2 system2 = mock(System2.class);
 
   private DbClient dbClient = dbTester.getDbClient();
+  private DefaultOrganizationProvider defaultOrganizationProvider = TestDefaultOrganizationProvider.from(dbTester);
 
   private IssueDbTester issueDbTester = new IssueDbTester(dbTester);
 
@@ -92,7 +95,7 @@ public class SetSeverityActionTest {
   private IssueIndexer issueIndexer = new IssueIndexer(esTester.client(), new IssueIteratorFactory(dbClient));
   private WsActionTester tester = new WsActionTester(new SetSeverityAction(userSession, dbClient, new IssueFinder(dbClient, userSession), new IssueFieldsSetter(),
     new IssueUpdater(dbClient,
-      new ServerIssueStorage(system2, new DefaultRuleFinder(dbClient), dbClient, issueIndexer), mock(NotificationManager.class)),
+      new ServerIssueStorage(system2, new DefaultRuleFinder(dbClient, defaultOrganizationProvider), dbClient, issueIndexer), mock(NotificationManager.class)),
     responseWriter));
 
   @Test

server/sonar-server/src/test/java/org/sonar/server/issue/ws/SetTypeActionTest.java

@@ -47,6 +47,8 @@ import org.sonar.server.issue.index.IssueIndexDefinition;
 import org.sonar.server.issue.index.IssueIndexer;
 import org.sonar.server.issue.index.IssueIteratorFactory;
 import org.sonar.server.notification.NotificationManager;
+import org.sonar.server.organization.DefaultOrganizationProvider;
+import org.sonar.server.organization.TestDefaultOrganizationProvider;
 import org.sonar.server.rule.DefaultRuleFinder;
 import org.sonar.server.tester.UserSessionRule;
 import org.sonar.server.ws.TestRequest;
@@ -71,28 +73,26 @@ public class SetTypeActionTest {
 
   @Rule
   public ExpectedException expectedException = ExpectedException.none();
-
   @Rule
   public DbTester dbTester = DbTester.create();
-
   @Rule
   public EsTester esTester = new EsTester(new IssueIndexDefinition(new MapSettings()));
-
   @Rule
   public UserSessionRule userSession = UserSessionRule.standalone();
 
+
   private System2 system2 = mock(System2.class);
 
   private DbClient dbClient = dbTester.getDbClient();
 
   private IssueDbTester issueDbTester = new IssueDbTester(dbTester);
-
+  private DefaultOrganizationProvider defaultOrganizationProvider = TestDefaultOrganizationProvider.from(dbTester);
   private OperationResponseWriter responseWriter = mock(OperationResponseWriter.class);
 
   private IssueIndexer issueIndexer = new IssueIndexer(esTester.client(), new IssueIteratorFactory(dbClient));
   private WsActionTester tester = new WsActionTester(new SetTypeAction(userSession, dbClient, new IssueFinder(dbClient, userSession), new IssueFieldsSetter(),
     new IssueUpdater(dbClient,
-      new ServerIssueStorage(system2, new DefaultRuleFinder(dbClient), dbClient, issueIndexer), mock(NotificationManager.class)),
+      new ServerIssueStorage(system2, new DefaultRuleFinder(dbClient, defaultOrganizationProvider), dbClient, issueIndexer), mock(NotificationManager.class)),
     responseWriter));
 
   @Test

server/sonar-server/src/test/java/org/sonar/server/qualityprofile/index/ActiveRuleIndexerTest.java

@@ -32,7 +32,7 @@ import org.sonar.db.organization.OrganizationTesting;
 import org.sonar.db.qualityprofile.ActiveRuleDto;
 import org.sonar.db.qualityprofile.ActiveRuleKey;
 import org.sonar.db.qualityprofile.QualityProfileDto;
-import org.sonar.db.rule.RuleDto;
+import org.sonar.db.rule.RuleDefinitionDto;
 import org.sonar.db.rule.RuleTesting;
 import org.sonar.server.es.EsTester;
 import org.sonar.server.qualityprofile.ActiveRuleChange;
@@ -142,7 +142,7 @@ public class ActiveRuleIndexerTest {
     long now = 2000000L;
 
     // Index one active rule
-    RuleDto rule = RuleTesting.newDto(RULE_KEY_1);
+    RuleDefinitionDto rule = RuleTesting.newDto(RULE_KEY_1).getDefinition();
     dbTester.rules().insertRule(rule);
     QualityProfileDto profile = QualityProfileDto.createFor("qp")
       .setOrganizationUuid(organization.getUuid())
@@ -159,7 +159,7 @@ public class ActiveRuleIndexerTest {
     assertThat(esTester.getIds(INDEX_TYPE_ACTIVE_RULE)).containsOnly(activeRule.getKey().toString());
 
     // Index another active rule
-    RuleDto rule2 = RuleTesting.newDto(RULE_KEY_2);
+    RuleDefinitionDto rule2 = RuleTesting.newDto(RULE_KEY_2).getDefinition();
     dbTester.rules().insertRule(rule2);
     ActiveRuleDto activeRule2 = ActiveRuleDto.createFor(profile, rule2).setSeverity(Severity.CRITICAL)
       .setCreatedAt(now).setUpdatedAt(now);

server/sonar-server/src/test/java/org/sonar/server/qualityprofile/ws/ChangeParentActionTest.java

@@ -416,7 +416,7 @@ public class ChangeParentActionTest {
   }
 
   private ActiveRuleDto createActiveRule(RuleDto rule, QualityProfileDto profile) {
-    ActiveRuleDto activeRule = ActiveRuleDto.createFor(profile, rule)
+    ActiveRuleDto activeRule = ActiveRuleDto.createFor(profile, rule.getDefinition())
       .setSeverity(rule.getSeverityString());
     dbClient.activeRuleDao().insert(dbSession, activeRule);
     dbSession.commit();

server/sonar-server/src/test/java/org/sonar/server/qualityprofile/ws/CompareActionMediumTest.java

@@ -86,11 +86,11 @@ public class CompareActionMediumTest {
   public void compare_nominal() throws Exception {
     createRepository("blah", "xoo", "Blah");
 
-    RuleDto rule1 = createRule("xoo", "rule1");
-    RuleDto rule2 = createRule("xoo", "rule2");
-    RuleDto rule3 = createRule("xoo", "rule3");
-    RuleDto rule4 = createRuleWithParam("xoo", "rule4");
-    RuleDto rule5 = createRule("xoo", "rule5");
+    RuleDefinitionDto rule1 = createRule("xoo", "rule1");
+    RuleDefinitionDto rule2 = createRule("xoo", "rule2");
+    RuleDefinitionDto rule3 = createRule("xoo", "rule3");
+    RuleDefinitionDto rule4 = createRuleWithParam("xoo", "rule4");
+    RuleDefinitionDto rule5 = createRule("xoo", "rule5");
 
     /*
      * Profile 1:
@@ -127,7 +127,7 @@ public class CompareActionMediumTest {
 
   @Test
   public void compare_param_on_left() throws Exception {
-    RuleDto rule1 = createRuleWithParam("xoo", "rule1");
+    RuleDefinitionDto rule1 = createRuleWithParam("xoo", "rule1");
     createRepository("blah", "xoo", "Blah");
     QualityProfileDto profile1 = createProfile("xoo", "Profile 1", "xoo-profile-1-01234");
     createActiveRuleWithParam(rule1, profile1, "polop");
@@ -143,7 +143,7 @@ public class CompareActionMediumTest {
 
   @Test
   public void compare_param_on_right() throws Exception {
-    RuleDto rule1 = createRuleWithParam("xoo", "rule1");
+    RuleDefinitionDto rule1 = createRuleWithParam("xoo", "rule1");
     createRepository("blah", "xoo", "Blah");
     QualityProfileDto profile1 = createProfile("xoo", "Profile 1", "xoo-profile-1-01234");
     createActiveRule(rule1, profile1);
@@ -196,7 +196,7 @@ public class CompareActionMediumTest {
     return profile;
   }
 
-  private RuleDto createRule(String lang, String id) {
+  private RuleDefinitionDto createRule(String lang, String id) {
     RuleDto rule = RuleDto.createFor(RuleKey.of("blah", id))
       .setName(StringUtils.capitalize(id))
       .setLanguage(lang)
@@ -206,26 +206,26 @@ public class CompareActionMediumTest {
     db.ruleDao().insert(session, ruleDefinition);
     RuleParamDto param = RuleParamDto.createFor(ruleDefinition).setName("param_" + id).setType(RuleParamType.STRING.toString());
     db.ruleDao().insertRuleParam(session, ruleDefinition, param);
-    return rule;
+    return ruleDefinition;
   }
 
-  private RuleDto createRuleWithParam(String lang, String id) {
-    RuleDto rule = createRule(lang, id);
-    RuleParamDto param = RuleParamDto.createFor(rule.getDefinition())
+  private RuleDefinitionDto createRuleWithParam(String lang, String id) {
+    RuleDefinitionDto rule = createRule(lang, id);
+    RuleParamDto param = RuleParamDto.createFor(rule)
       .setName("param_" + id)
       .setType(RuleParamType.STRING.toString());
-    db.ruleDao().insertRuleParam(session, rule.getDefinition(), param);
+    db.ruleDao().insertRuleParam(session, rule, param);
     return rule;
   }
 
-  private ActiveRuleDto createActiveRule(RuleDto rule, QualityProfileDto profile) {
+  private ActiveRuleDto createActiveRule(RuleDefinitionDto rule, QualityProfileDto profile) {
     ActiveRuleDto activeRule = ActiveRuleDto.createFor(profile, rule)
       .setSeverity(rule.getSeverityString());
     db.activeRuleDao().insert(session, activeRule);
     return activeRule;
   }
 
-  private ActiveRuleDto createActiveRuleWithParam(RuleDto rule, QualityProfileDto profile, String value) {
+  private ActiveRuleDto createActiveRuleWithParam(RuleDefinitionDto rule, QualityProfileDto profile, String value) {
     ActiveRuleDto activeRule = createActiveRule(rule, profile);
     RuleParamDto paramDto = db.ruleDao().selectRuleParamsByRuleKey(session, rule.getKey()).get(0);
     ActiveRuleParamDto activeRuleParam = ActiveRuleParamDto.createFor(paramDto).setValue(value);
@@ -233,7 +233,7 @@ public class CompareActionMediumTest {
     return activeRule;
   }
 
-  private ActiveRuleDto createActiveRuleWithSeverity(RuleDto rule, QualityProfileDto profile, String severity) {
+  private ActiveRuleDto createActiveRuleWithSeverity(RuleDefinitionDto rule, QualityProfileDto profile, String severity) {
     ActiveRuleDto activeRule = ActiveRuleDto.createFor(profile, rule)
       .setSeverity(severity);
     db.activeRuleDao().insert(session, activeRule);

server/sonar-server/src/test/java/org/sonar/server/qualityprofile/ws/InheritanceActionTest.java

@@ -37,6 +37,7 @@ import org.sonar.db.organization.OrganizationDto;
 import org.sonar.db.qualityprofile.ActiveRuleDto;
 import org.sonar.db.qualityprofile.QualityProfileDto;
 import org.sonar.db.qualityprofile.QualityProfileTesting;
+import org.sonar.db.rule.RuleDefinitionDto;
 import org.sonar.db.rule.RuleDto;
 import org.sonar.db.rule.RuleTesting;
 import org.sonar.server.es.EsClient;
@@ -115,9 +116,9 @@ public class InheritanceActionTest {
 
   @Test
   public void inheritance_nominal() throws Exception {
-    RuleDto rule1 = createRule("xoo", "rule1");
-    RuleDto rule2 = createRule("xoo", "rule2");
-    RuleDto rule3 = createRule("xoo", "rule3");
+    RuleDefinitionDto rule1 = createRule("xoo", "rule1");
+    RuleDefinitionDto rule2 = createRule("xoo", "rule2");
+    RuleDefinitionDto rule3 = createRule("xoo", "rule3");
 
     /*
      * groupWide (2) <- companyWide (2) <- buWide (2, 1 overriding) <- (forProject1 (2), forProject2 (2))
@@ -219,7 +220,7 @@ public class InheritanceActionTest {
     ruleActivator.setParent(dbSession, parent.getKey(), profile.getKey());
   }
 
-  private RuleDto createRule(String lang, String id) {
+  private RuleDefinitionDto createRule(String lang, String id) {
     long now = new Date().getTime();
     RuleDto rule = RuleTesting.newDto(RuleKey.of("blah", id))
       .setLanguage(lang)
@@ -228,10 +229,10 @@ public class InheritanceActionTest {
       .setUpdatedAt(now)
       .setCreatedAt(now);
     dbClient.ruleDao().insert(dbSession, rule.getDefinition());
-    return rule;
+    return rule.getDefinition();
   }
 
-  private ActiveRuleDto createActiveRule(RuleDto rule, QualityProfileDto profile) {
+  private ActiveRuleDto createActiveRule(RuleDefinitionDto rule, QualityProfileDto profile) {
     long now = new Date().getTime();
     ActiveRuleDto activeRule = ActiveRuleDto.createFor(profile, rule)
       .setSeverity(rule.getSeverityString())
@@ -241,7 +242,7 @@ public class InheritanceActionTest {
     return activeRule;
   }
 
-  private void overrideActiveRuleSeverity(RuleDto rule, QualityProfileDto profile, String severity) {
+  private void overrideActiveRuleSeverity(RuleDefinitionDto rule, QualityProfileDto profile, String severity) {
     ruleActivator.activate(dbSession, new RuleActivation(rule.getKey()).setSeverity(severity), profile.getKey());
     dbSession.commit();
     activeRuleIndexer.index();

server/sonar-server/src/test/java/org/sonar/server/qualityprofile/ws/QProfilesWsMediumTest.java

@@ -36,6 +36,7 @@ import org.sonar.db.qualityprofile.ActiveRuleDao;
 import org.sonar.db.qualityprofile.ActiveRuleDto;
 import org.sonar.db.qualityprofile.ActiveRuleKey;
 import org.sonar.db.qualityprofile.QualityProfileDto;
+import org.sonar.db.rule.RuleDefinitionDto;
 import org.sonar.db.rule.RuleDto;
 import org.sonar.db.rule.RuleTesting;
 import org.sonar.server.es.SearchOptions;
@@ -94,7 +95,7 @@ public class QProfilesWsMediumTest {
   @Test
   public void deactivate_rule() throws Exception {
     QualityProfileDto profile = createProfile("java");
-    RuleDto rule = createRule(profile.getLanguage(), "toto");
+    RuleDefinitionDto rule = createRule(profile.getLanguage(), "toto");
     createActiveRule(rule, profile);
     session.commit();
     ruIndexer.index();
@@ -117,10 +118,10 @@ public class QProfilesWsMediumTest {
   @Test
   public void bulk_deactivate_rule() throws Exception {
     QualityProfileDto profile = createProfile("java");
-    RuleDto rule0 = createRule(profile.getLanguage(), "toto1");
-    RuleDto rule1 = createRule(profile.getLanguage(), "toto2");
-    RuleDto rule2 = createRule(profile.getLanguage(), "toto3");
-    RuleDto rule3 = createRule(profile.getLanguage(), "toto4");
+    RuleDefinitionDto rule0 = createRule(profile.getLanguage(), "toto1");
+    RuleDefinitionDto rule1 = createRule(profile.getLanguage(), "toto2");
+    RuleDefinitionDto rule2 = createRule(profile.getLanguage(), "toto3");
+    RuleDefinitionDto rule3 = createRule(profile.getLanguage(), "toto4");
     createActiveRule(rule0, profile);
     createActiveRule(rule2, profile);
     createActiveRule(rule3, profile);
@@ -146,8 +147,8 @@ public class QProfilesWsMediumTest {
   public void bulk_deactivate_rule_not_all() throws Exception {
     QualityProfileDto profile = createProfile("java");
     QualityProfileDto php = createProfile("php");
-    RuleDto rule0 = createRule(profile.getLanguage(), "toto1");
-    RuleDto rule1 = createRule(profile.getLanguage(), "toto2");
+    RuleDefinitionDto rule0 = createRule(profile.getLanguage(), "toto1");
+    RuleDefinitionDto rule1 = createRule(profile.getLanguage(), "toto2");
     createActiveRule(rule0, profile);
     createActiveRule(rule1, profile);
     createActiveRule(rule0, php);
@@ -173,8 +174,8 @@ public class QProfilesWsMediumTest {
   @Test
   public void bulk_deactivate_rule_by_profile() throws Exception {
     QualityProfileDto profile = createProfile("java");
-    RuleDto rule0 = createRule(profile.getLanguage(), "hello");
-    RuleDto rule1 = createRule(profile.getLanguage(), "world");
+    RuleDefinitionDto rule0 = createRule(profile.getLanguage(), "hello");
+    RuleDefinitionDto rule1 = createRule(profile.getLanguage(), "world");
     createActiveRule(rule0, profile);
     createActiveRule(rule1, profile);
     session.commit();
@@ -198,7 +199,7 @@ public class QProfilesWsMediumTest {
   @Test
   public void activate_rule() throws Exception {
     QualityProfileDto profile = createProfile("java");
-    RuleDto rule = createRule(profile.getLanguage(), "toto");
+    RuleDefinitionDto rule = createRule(profile.getLanguage(), "toto");
     session.commit();
     ruIndexer.index();
 
@@ -219,7 +220,7 @@ public class QProfilesWsMediumTest {
   @Test
   public void activate_rule_diff_languages() throws Exception {
     QualityProfileDto profile = createProfile("java");
-    RuleDto rule = createRule("php", "toto");
+    RuleDefinitionDto rule = createRule("php", "toto");
     session.commit();
     ruIndexer.index();
 
@@ -242,7 +243,7 @@ public class QProfilesWsMediumTest {
   @Test
   public void activate_rule_override_severity() throws Exception {
     QualityProfileDto profile = createProfile("java");
-    RuleDto rule = createRule(profile.getLanguage(), "toto");
+    RuleDefinitionDto rule = createRule(profile.getLanguage(), "toto");
     session.commit();
     ruIndexer.index();
 
@@ -350,8 +351,8 @@ public class QProfilesWsMediumTest {
   @Test
   public void bulk_activate_rule_by_query_with_severity() throws Exception {
     QualityProfileDto profile = createProfile("java");
-    RuleDto rule0 = createRule(profile.getLanguage(), "toto");
-    RuleDto rule1 = createRule(profile.getLanguage(), "tata");
+    RuleDefinitionDto rule0 = createRule(profile.getLanguage(), "toto");
+    RuleDefinitionDto rule1 = createRule(profile.getLanguage(), "tata");
     session.commit();
     ruIndexer.index();
 
@@ -408,7 +409,7 @@ public class QProfilesWsMediumTest {
     QualityProfileDto subProfile = QProfileTesting.newXooP2("org-123").setParentKee(QProfileTesting.XOO_P1_KEY);
     db.qualityProfileDao().insert(session, profile, subProfile);
 
-    RuleDto rule = createRule(profile.getLanguage(), "rule");
+    RuleDefinitionDto rule = createRule(profile.getLanguage(), "rule");
     ActiveRuleDto active1 = ActiveRuleDto.createFor(profile, rule)
       .setSeverity(rule.getSeverityString());
     ActiveRuleDto active2 = ActiveRuleDto.createFor(subProfile, rule)
@@ -441,16 +442,16 @@ public class QProfilesWsMediumTest {
     return profile;
   }
 
-  private RuleDto createRule(String lang, String id) {
+  private RuleDefinitionDto createRule(String lang, String id) {
     RuleDto rule = RuleTesting.newDto(RuleKey.of("blah", id))
       .setLanguage(lang)
       .setSeverity(Severity.BLOCKER)
       .setStatus(RuleStatus.READY);
     db.ruleDao().insert(session, rule.getDefinition());
-    return rule;
+    return rule.getDefinition();
   }
 
-  private ActiveRuleDto createActiveRule(RuleDto rule, QualityProfileDto profile) {
+  private ActiveRuleDto createActiveRule(RuleDefinitionDto rule, QualityProfileDto profile) {
     ActiveRuleDto activeRule = ActiveRuleDto.createFor(profile, rule)
       .setSeverity(rule.getSeverityString());
     db.activeRuleDao().insert(session, activeRule);

server/sonar-server/src/test/java/org/sonar/server/qualityprofile/ws/SearchActionTest.java

@@ -44,7 +44,7 @@ import org.sonar.db.qualityprofile.QualityProfileDao;
 import org.sonar.db.qualityprofile.QualityProfileDbTester;
 import org.sonar.db.qualityprofile.QualityProfileDto;
 import org.sonar.db.qualityprofile.QualityProfileTesting;
-import org.sonar.db.rule.RuleDto;
+import org.sonar.db.rule.RuleDefinitionDto;
 import org.sonar.server.component.ComponentFinder;
 import org.sonar.server.exceptions.BadRequestException;
 import org.sonar.server.language.LanguageTesting;
@@ -192,9 +192,9 @@ public class SearchActionTest {
   @Test
   public void response_contains_statistics_on_active_rules() {
     QualityProfileDto profile = db.qualityProfiles().insert(db.getDefaultOrganization(), p -> p.setLanguage(xoo1.getKey()));
-    RuleDto rule = db.rules().insertRule(r -> r.setLanguage(xoo1.getKey()));
-    RuleDto deprecatedRule1 = db.rules().insertRule(r -> r.setStatus(RuleStatus.DEPRECATED));
-    RuleDto deprecatedRule2 = db.rules().insertRule(r -> r.setStatus(RuleStatus.DEPRECATED));
+    RuleDefinitionDto rule = db.rules().insertRule(r -> r.setLanguage(xoo1.getKey())).getDefinition();
+    RuleDefinitionDto deprecatedRule1 = db.rules().insertRule(r -> r.setStatus(RuleStatus.DEPRECATED)).getDefinition();
+    RuleDefinitionDto deprecatedRule2 = db.rules().insertRule(r -> r.setStatus(RuleStatus.DEPRECATED)).getDefinition();
     db.qualityProfiles().activateRule(profile, rule);
     db.qualityProfiles().activateRule(profile, deprecatedRule1);
     db.qualityProfiles().activateRule(profile, deprecatedRule2);

server/sonar-server/src/test/java/org/sonar/server/rule/DefaultRuleFinderTest.java

@@ -31,6 +31,8 @@ import org.sonar.db.DbClient;
 import org.sonar.db.DbSession;
 import org.sonar.db.DbTester;
 import org.sonar.db.rule.RuleDto;
+import org.sonar.server.organization.DefaultOrganizationProvider;
+import org.sonar.server.organization.TestDefaultOrganizationProvider;
 
 import static com.google.common.collect.Lists.newArrayList;
 import static org.assertj.core.api.Assertions.assertThat;
@@ -40,10 +42,11 @@ public class DefaultRuleFinderTest {
   @org.junit.Rule
   public DbTester dbTester = DbTester.create(System2.INSTANCE);
 
-  DbClient dbClient = dbTester.getDbClient();
-  DbSession session = dbTester.getSession();
+  private DbClient dbClient = dbTester.getDbClient();
+  private DbSession session = dbTester.getSession();
+  private DefaultOrganizationProvider defaultOrganizationProvider = TestDefaultOrganizationProvider.from(dbTester);
 
-  RuleDto rule1 = new RuleDto()
+  private RuleDto rule1 = new RuleDto()
     .setName("Check Header")
     .setConfigKey("Checker/Treewalker/HeaderCheck")
     .setRuleKey("com.puppycrawl.tools.checkstyle.checks.header.HeaderCheck")
@@ -51,7 +54,7 @@ public class DefaultRuleFinderTest {
     .setSeverity(4)
     .setStatus(RuleStatus.READY);
 
-  RuleDto rule2 = new RuleDto()
+  private RuleDto rule2 = new RuleDto()
     .setName("Disabled checked")
     .setConfigKey("Checker/Treewalker/DisabledCheck")
     .setRuleKey("DisabledCheck")
@@ -59,7 +62,7 @@ public class DefaultRuleFinderTest {
     .setSeverity(4)
     .setStatus(RuleStatus.REMOVED);
 
-  RuleDto rule3 = new RuleDto()
+  private RuleDto rule3 = new RuleDto()
     .setName("Check Annotation")
     .setConfigKey("Checker/Treewalker/AnnotationUseStyleCheck")
     .setRuleKey("com.puppycrawl.tools.checkstyle.checks.annotation.AnnotationUseStyleCheck")
@@ -67,7 +70,7 @@ public class DefaultRuleFinderTest {
     .setSeverity(4)
     .setStatus(RuleStatus.READY);
 
-  RuleDto rule4 = new RuleDto()
+  private RuleDto rule4 = new RuleDto()
     .setName("Call Super First")
     .setConfigKey("rulesets/android.xml/CallSuperFirst")
     .setRuleKey("CallSuperFirst")
@@ -75,7 +78,7 @@ public class DefaultRuleFinderTest {
     .setSeverity(2)
     .setStatus(RuleStatus.READY);
 
-  DefaultRuleFinder underTest = new DefaultRuleFinder(dbClient);
+  private DefaultRuleFinder underTest = new DefaultRuleFinder(dbClient, defaultOrganizationProvider);
 
   @Before
   public void setup() {

server/sonar-server/src/test/java/org/sonar/server/rule/ws/RulesWsMediumTest.java

@@ -114,7 +114,7 @@ public class RulesWsMediumTest {
     ruleDao.insert(session, rule.getDefinition());
     ruleDao.update(session, rule.getMetadata().setRuleId(rule.getId()));
 
-    ActiveRuleDto activeRuleDto = ActiveRuleDto.createFor(profile, rule).setSeverity("BLOCKER");
+    ActiveRuleDto activeRuleDto = ActiveRuleDto.createFor(profile, rule.getDefinition()).setSeverity("BLOCKER");
     tester.get(ActiveRuleDao.class).insert(session, activeRuleDto);
 
     session.commit();

server/sonar-server/src/test/java/org/sonar/server/rule/ws/SearchActionMediumTest.java

@@ -322,8 +322,8 @@ public class SearchActionMediumTest {
     QualityProfileDto profile = QProfileTesting.newXooP1("org-123");
     tester.get(QualityProfileDao.class).insert(dbSession, profile);
 
-    RuleDto rule = RuleTesting.newXooX1();
-    ruleDao.insert(dbSession, rule.getDefinition());
+    RuleDefinitionDto rule = RuleTesting.newXooX1().getDefinition();
+    ruleDao.insert(dbSession, rule);
 
     ActiveRuleDto activeRule = newActiveRule(profile, rule);
     tester.get(ActiveRuleDao.class).insert(dbSession, activeRule);
@@ -351,31 +351,30 @@ public class SearchActionMediumTest {
 
     dbSession.commit();
 
-    RuleDto rule = RuleTesting.newXooX1();
-    RuleDefinitionDto definition = rule.getDefinition();
-    ruleDao.insert(dbSession, definition);
+    RuleDefinitionDto rule = RuleTesting.newXooX1().getDefinition();
+    ruleDao.insert(dbSession, rule);
 
-    RuleParamDto param = RuleParamDto.createFor(definition)
+    RuleParamDto param = RuleParamDto.createFor(rule)
       .setDefaultValue("some value")
       .setType("string")
       .setDescription("My small description")
       .setName("my_var");
-    ruleDao.insertRuleParam(dbSession, definition, param);
+    ruleDao.insertRuleParam(dbSession, rule, param);
 
-    RuleParamDto param2 = RuleParamDto.createFor(definition)
+    RuleParamDto param2 = RuleParamDto.createFor(rule)
       .setDefaultValue("other value")
       .setType("integer")
       .setDescription("My small description")
       .setName("the_var");
-    ruleDao.insertRuleParam(dbSession, definition, param2);
+    ruleDao.insertRuleParam(dbSession, rule, param2);
 
     // SONAR-7083
-    RuleParamDto param3 = RuleParamDto.createFor(definition)
+    RuleParamDto param3 = RuleParamDto.createFor(rule)
       .setDefaultValue(null)
       .setType("string")
       .setDescription("Empty Param")
       .setName("empty_var");
-    ruleDao.insertRuleParam(dbSession, definition, param3);
+    ruleDao.insertRuleParam(dbSession, rule, param3);
 
     ActiveRuleDto activeRule = newActiveRule(profile, rule);
     tester.get(ActiveRuleDao.class).insert(dbSession, activeRule);
@@ -424,8 +423,8 @@ public class SearchActionMediumTest {
 
     dbSession.commit();
 
-    RuleDto rule = RuleTesting.newXooX1();
-    ruleDao.insert(dbSession, rule.getDefinition());
+    RuleDefinitionDto rule = RuleTesting.newXooX1().getDefinition();
+    ruleDao.insert(dbSession, rule);
 
     ActiveRuleDto activeRule = newActiveRule(profile, rule);
     tester.get(ActiveRuleDao.class).insert(dbSession, activeRule);
@@ -449,24 +448,23 @@ public class SearchActionMediumTest {
   public void search_all_active_rules_params() throws Exception {
     QualityProfileDto profile = QProfileTesting.newXooP1("org-123");
     tester.get(QualityProfileDao.class).insert(dbSession, profile);
-    RuleDto rule = RuleTesting.newXooX1();
-    RuleDefinitionDto definition = rule.getDefinition();
-    ruleDao.insert(dbSession, definition);
+    RuleDefinitionDto rule = RuleTesting.newXooX1().getDefinition();
+    ruleDao.insert(dbSession, rule);
     dbSession.commit();
 
-    RuleParamDto param = RuleParamDto.createFor(definition)
+    RuleParamDto param = RuleParamDto.createFor(rule)
       .setDefaultValue("some value")
       .setType("string")
       .setDescription("My small description")
       .setName("my_var");
-    ruleDao.insertRuleParam(dbSession, definition, param);
+    ruleDao.insertRuleParam(dbSession, rule, param);
 
-    RuleParamDto param2 = RuleParamDto.createFor(definition)
+    RuleParamDto param2 = RuleParamDto.createFor(rule)
       .setDefaultValue("other value")
       .setType("integer")
       .setDescription("My small description")
       .setName("the_var");
-    ruleDao.insertRuleParam(dbSession, definition, param2);
+    ruleDao.insertRuleParam(dbSession, rule, param2);
 
     ActiveRuleDto activeRule = newActiveRule(profile, rule);
     tester.get(ActiveRuleDao.class).insert(dbSession, activeRule);
@@ -648,7 +646,7 @@ public class SearchActionMediumTest {
     result.assertJson(getClass(), "search_rules_with_deprecated_fields.json");
   }
 
-  private ActiveRuleDto newActiveRule(QualityProfileDto profile, RuleDto rule) {
+  private ActiveRuleDto newActiveRule(QualityProfileDto profile, RuleDefinitionDto rule) {
     return ActiveRuleDto.createFor(profile, rule)
       .setInheritance(null)
       .setSeverity("BLOCKER");