From 50c30e71a6c051dbb9610c7f7af4775722ad1d27 Mon Sep 17 00:00:00 2001
From: Stephane Gamard <stephane.gamard@searchbox.com>
Date: Tue, 20 May 2014 14:43:36 +0200
Subject: [PATCH] SONAR-5007 - Updated RegisterQualityProfile for DAOv.2

---
 .../core/qualityprofile/db/ActiveRuleDto.java |  19 +-
 .../core/qualityprofile/db/ActiveRuleKey.java |   1 +
 .../qualityprofile/db/ActiveRuleMapper.java   |   4 +-
 .../qualityprofile/db/QualityProfileDao.java  |  21 ++-
 .../qualityprofile/db/ActiveRuleMapper.xml    |  33 +++-
 .../RegisterQualityProfiles.java              | 107 ++++++-----
 .../persistence/ActiveRuleDao.java            |  37 +++-
 .../qualityprofile/QProfilesMediumTest.java   |  33 ----
 .../RegisterQualityProfilesMediumTest.java    | 178 ++++++++++++++++++
 .../RegisterQualityProfilesTest.java          |   6 +-
 .../persistence/ActiveRuleDaoTest.java        |  62 ++++++
 11 files changed, 406 insertions(+), 95 deletions(-)
 create mode 100644 sonar-server/src/test/java/org/sonar/server/qualityprofile/RegisterQualityProfilesMediumTest.java
 create mode 100644 sonar-server/src/test/java/org/sonar/server/qualityprofile/persistence/ActiveRuleDaoTest.java

diff --git a/sonar-core/src/main/java/org/sonar/core/qualityprofile/db/ActiveRuleDto.java b/sonar-core/src/main/java/org/sonar/core/qualityprofile/db/ActiveRuleDto.java
index 47e14519a82..1682757237a 100644
--- a/sonar-core/src/main/java/org/sonar/core/qualityprofile/db/ActiveRuleDto.java
+++ b/sonar-core/src/main/java/org/sonar/core/qualityprofile/db/ActiveRuleDto.java
@@ -23,6 +23,7 @@ package org.sonar.core.qualityprofile.db;
 import org.apache.commons.lang.StringUtils;
 import org.apache.commons.lang.builder.ReflectionToStringBuilder;
 import org.apache.commons.lang.builder.ToStringStyle;
+import org.sonar.api.rule.RuleKey;
 import org.sonar.core.persistence.Dto;
 import org.sonar.core.rule.RuleDto;
 import org.sonar.core.rule.SeverityUtil;
@@ -37,6 +38,11 @@ public class ActiveRuleDto extends Dto<ActiveRuleKey> {
   public static final String INHERITED = "INHERITED";
   public static final String OVERRIDES = "OVERRIDES";
 
+  private String repository;
+  private String rule;
+  private String language;
+  private String profile;
+
   private Integer id;
   private Integer profileId;
   private Integer ruleId;
@@ -47,15 +53,18 @@ public class ActiveRuleDto extends Dto<ActiveRuleKey> {
   private String noteUserLogin;
   private String noteData;
 
-  private transient ActiveRuleKey key;
-
-  public ActiveRuleDto setKey(@Nullable ActiveRuleKey key) {
-    this.key = key;
+  @Deprecated
+  public ActiveRuleDto setKey(ActiveRuleKey key) {
+    this.repository = key.ruleKey().repository();
+    this.rule = key.ruleKey().rule();
+    this.language = key.qProfile().lang();
+    this.profile = key.qProfile().name();
     return this;
   }
 
   public ActiveRuleKey getKey() {
-    return this.key;
+  return ActiveRuleKey.of(QualityProfileKey.of(this.profile, this.language),
+    RuleKey.of(this.repository, this.rule));
   }
 
   // This field do not exists in db, it's only retrieve by joins
diff --git a/sonar-core/src/main/java/org/sonar/core/qualityprofile/db/ActiveRuleKey.java b/sonar-core/src/main/java/org/sonar/core/qualityprofile/db/ActiveRuleKey.java
index 5421b67c5ee..f71b11413e9 100644
--- a/sonar-core/src/main/java/org/sonar/core/qualityprofile/db/ActiveRuleKey.java
+++ b/sonar-core/src/main/java/org/sonar/core/qualityprofile/db/ActiveRuleKey.java
@@ -29,6 +29,7 @@ import java.io.Serializable;
  * @since 4.4
  */
 public class ActiveRuleKey implements Serializable {
+
   private final QualityProfileKey qualityProfileKey;
   private final RuleKey ruleKey;
 
diff --git a/sonar-core/src/main/java/org/sonar/core/qualityprofile/db/ActiveRuleMapper.java b/sonar-core/src/main/java/org/sonar/core/qualityprofile/db/ActiveRuleMapper.java
index 6160b21b43c..27d71c0265b 100644
--- a/sonar-core/src/main/java/org/sonar/core/qualityprofile/db/ActiveRuleMapper.java
+++ b/sonar-core/src/main/java/org/sonar/core/qualityprofile/db/ActiveRuleMapper.java
@@ -21,10 +21,8 @@
 package org.sonar.core.qualityprofile.db;
 
 import org.apache.ibatis.annotations.Param;
-import org.sonar.api.rule.RuleKey;
 
 import javax.annotation.CheckForNull;
-
 import java.util.List;
 
 public interface ActiveRuleMapper {
@@ -75,4 +73,6 @@ public interface ActiveRuleMapper {
 
   List<ActiveRuleParamDto> selectAllParams();
 
+  ActiveRuleDto selectByKey(@Param("profile") String profile, @Param("language") String language,
+                            @Param("repository") String repository, @Param("rule") String rule );
 }
diff --git a/sonar-core/src/main/java/org/sonar/core/qualityprofile/db/QualityProfileDao.java b/sonar-core/src/main/java/org/sonar/core/qualityprofile/db/QualityProfileDao.java
index 2d3ca003407..276b5dcfe19 100644
--- a/sonar-core/src/main/java/org/sonar/core/qualityprofile/db/QualityProfileDao.java
+++ b/sonar-core/src/main/java/org/sonar/core/qualityprofile/db/QualityProfileDao.java
@@ -20,16 +20,18 @@
 
 package org.sonar.core.qualityprofile.db;
 
+import com.google.common.base.Preconditions;
 import org.apache.ibatis.session.SqlSession;
 import org.sonar.api.DaoComponent;
 import org.sonar.api.ServerComponent;
 import org.sonar.core.component.ComponentDto;
+import org.sonar.core.persistence.DbSession;
 import org.sonar.core.persistence.MyBatis;
 
 import javax.annotation.CheckForNull;
 import java.util.List;
 
-public class QualityProfileDao implements DaoComponent, ServerComponent {
+public class QualityProfileDao implements ServerComponent, DaoComponent {
 
   private final MyBatis mybatis;
 
@@ -65,10 +67,27 @@ public class QualityProfileDao implements DaoComponent, ServerComponent {
     }
   }
 
+
+  public void delete(QualityProfileDto profile, DbSession session) {
+    Preconditions.checkNotNull(profile.getId(), "Profile is not persisted");
+    session.getMapper(QualityProfileMapper.class).delete(profile.getId());
+  }
+
+  /**
+   * @deprecated use {@link #delete(QualityProfileDto, DbSession)}
+   * @param id
+   * @param session
+   */
+  @Deprecated
   public void delete(int id, SqlSession session) {
     session.getMapper(QualityProfileMapper.class).delete(id);
   }
 
+  /**
+   * @deprecated use {@link #delete(QualityProfileDto, DbSession)}
+   * @param id
+   */
+  @Deprecated
   public void delete(int id) {
     SqlSession session = mybatis.openSession(false);
     try {
diff --git a/sonar-core/src/main/resources/org/sonar/core/qualityprofile/db/ActiveRuleMapper.xml b/sonar-core/src/main/resources/org/sonar/core/qualityprofile/db/ActiveRuleMapper.xml
index 93d62d979d4..29274f2d227 100644
--- a/sonar-core/src/main/resources/org/sonar/core/qualityprofile/db/ActiveRuleMapper.xml
+++ b/sonar-core/src/main/resources/org/sonar/core/qualityprofile/db/ActiveRuleMapper.xml
@@ -3,7 +3,25 @@
 
 <mapper namespace="org.sonar.core.qualityprofile.db.ActiveRuleMapper">
 
-  <sql id="activeRuleColumns">
+    <sql id="activeRuleKeyColumns">
+        a.id,
+        a.profile_id as profileId,
+        a.rule_id as ruleId,
+        a.failure_level as severity,
+        a.inheritance as inheritance,
+        rule.plugin_rule_key as rule,
+        rule.plugin_name as repository,
+        profile.name as profile,
+        profile.language as language
+    </sql>
+
+    <sql id="activeRuleKeyJoin">
+        LEFT JOIN rules_profiles profile ON profile.id=a.profile_id
+        LEFT JOIN rules rule ON rule.id = a.rule_id
+    </sql>
+
+
+    <sql id="activeRuleColumns">
     a.id,
     a.profile_id as profileId,
     a.rule_id as ruleId,
@@ -65,6 +83,19 @@
     </where>
   </select>
 
+
+    <select id="selectByKey" parameterType="map" resultType="ActiveRule">
+        SELECT <include refid="activeRuleKeyColumns"/>
+        FROM active_rules a
+        <include refid="activeRuleKeyJoin"/>
+        <where>
+            AND profile.name = #{profile}
+            AND profile.language = #{language}
+            AND rule.plugin_rule_key = #{rule}
+            AND rule.plugin_name = #{repository}
+        </where>
+    </select>
+
   <select id="selectByProfileAndRule" parameterType="map" resultType="ActiveRule">
     SELECT <include refid="activeRuleColumns"/>
     FROM active_rules a
diff --git a/sonar-server/src/main/java/org/sonar/server/qualityprofile/RegisterQualityProfiles.java b/sonar-server/src/main/java/org/sonar/server/qualityprofile/RegisterQualityProfiles.java
index 30f24cbe1b2..7c51baafbf0 100644
--- a/sonar-server/src/main/java/org/sonar/server/qualityprofile/RegisterQualityProfiles.java
+++ b/sonar-server/src/main/java/org/sonar/server/qualityprofile/RegisterQualityProfiles.java
@@ -30,17 +30,24 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.sonar.api.profiles.ProfileDefinition;
 import org.sonar.api.profiles.RulesProfile;
-import org.sonar.api.utils.SonarException;
+import org.sonar.api.rule.RuleKey;
+import org.sonar.api.rules.*;
 import org.sonar.api.utils.TimeProfiler;
 import org.sonar.api.utils.ValidationMessages;
+import org.sonar.core.permission.GlobalPermissions;
 import org.sonar.core.persistence.DbSession;
 import org.sonar.core.persistence.MyBatis;
-import org.sonar.core.qualityprofile.db.QualityProfileKey;
+import org.sonar.core.qualityprofile.db.ActiveRuleDto;
+import org.sonar.core.qualityprofile.db.ActiveRuleParamDto;
+import org.sonar.core.qualityprofile.db.QualityProfileDto;
+import org.sonar.core.rule.RuleDto;
 import org.sonar.core.template.LoadedTemplateDao;
 import org.sonar.core.template.LoadedTemplateDto;
 import org.sonar.jpa.session.DatabaseSessionFactory;
+import org.sonar.server.db.DbClient;
+import org.sonar.server.exceptions.BadRequestException;
+import org.sonar.server.exceptions.NotFoundException;
 import org.sonar.server.platform.PersistentSettings;
-import org.sonar.server.rule2.RegisterRules;
 import org.sonar.server.user.UserSession;
 
 import javax.annotation.Nullable;
@@ -55,52 +62,29 @@ public class RegisterQualityProfiles {
   private static final Logger LOGGER = LoggerFactory.getLogger(RegisterQualityProfiles.class);
   private static final String DEFAULT_PROFILE_NAME = "Sonar way";
 
-  private final LoadedTemplateDao loadedTemplateDao;
-  private final QProfileBackup qProfileBackup;
-  private final QProfileOperations qProfileOperations;
   private final PersistentSettings settings;
-  private final QProfileLookup qProfileLookup;
-  private final ESActiveRule esActiveRule;
   private final List<ProfileDefinition> definitions;
   private final DefaultProfilesCache defaultProfilesCache;
   private final DatabaseSessionFactory sessionFactory;
-  private final MyBatis myBatis;
+  private final DbClient dbClient;
 
   public RegisterQualityProfiles(DatabaseSessionFactory sessionFactory,
-                                 MyBatis myBatis,
                                  PersistentSettings settings,
-                                 ESActiveRule esActiveRule,
-                                 LoadedTemplateDao loadedTemplateDao,
-                                 QProfileBackup qProfileBackup,
-                                 QProfileOperations qProfileOperations,
-                                 QProfileLookup qProfileLookup,
-                                 DefaultProfilesCache defaultProfilesCache,
-                                 RegisterRules registerRulesBefore) {
-    this(sessionFactory, myBatis, settings, esActiveRule, loadedTemplateDao, qProfileBackup, qProfileOperations, qProfileLookup, defaultProfilesCache, registerRulesBefore,
+                                 DefaultProfilesCache defaultProfilesCache, DbClient dbClient) {
+    this(sessionFactory, settings, defaultProfilesCache, dbClient,
       Collections.<ProfileDefinition>emptyList());
   }
 
   public RegisterQualityProfiles(DatabaseSessionFactory sessionFactory,
-                                 MyBatis myBatis,
                                  PersistentSettings settings,
-                                 ESActiveRule esActiveRule,
-                                 LoadedTemplateDao loadedTemplateDao,
-                                 QProfileBackup qProfileBackup,
-                                 QProfileOperations qProfileOperations,
-                                 QProfileLookup qProfileLookup,
                                  DefaultProfilesCache defaultProfilesCache,
-                                 RegisterRules registerRulesBefore,
+                                 DbClient dbClient,
                                  List<ProfileDefinition> definitions) {
     this.sessionFactory = sessionFactory;
-    this.myBatis = myBatis;
     this.settings = settings;
-    this.esActiveRule = esActiveRule;
-    this.qProfileBackup = qProfileBackup;
-    this.qProfileOperations = qProfileOperations;
-    this.qProfileLookup = qProfileLookup;
     this.defaultProfilesCache = defaultProfilesCache;
     this.definitions = definitions;
-    this.loadedTemplateDao = loadedTemplateDao;
+    this.dbClient = dbClient;
   }
 
   public void start() {
@@ -110,7 +94,7 @@ public class RegisterQualityProfiles {
     // As long ProfileDefinition API will be used, then we'll have to use this commit as Hibernate is used by plugin to load rules when creating their profiles.
     sessionFactory.getSession().commit();
 
-    DbSession session = myBatis.openSession(false);
+    DbSession session = dbClient.openSession(false);
     try {
       ListMultimap<String, RulesProfile> profilesByLanguage = profilesByLanguage();
       for (String language : profilesByLanguage.keySet()) {
@@ -127,7 +111,6 @@ public class RegisterQualityProfiles {
         setDefault(language, profiles, session);
       }
       session.commit();
-      esActiveRule.bulkRegisterActiveRules();
     } finally {
       MyBatis.closeQuietly(session);
       profiler.stop();
@@ -141,26 +124,65 @@ public class RegisterQualityProfiles {
 
     Set<String> defaultProfileNames = defaultProfileNames(profiles);
     if (defaultProfileNames.size() > 1) {
-      throw new SonarException("Several Quality Profiles are flagged as default for the language " + language + ": " + defaultProfileNames);
+      throw new IllegalStateException("Several Quality Profiles are flagged as default for the language " + language + ": " + defaultProfileNames);
     }
   }
 
+  private void checkPermission(UserSession userSession) {
+    userSession.checkLoggedIn();
+    userSession.checkGlobalPermission(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+  }
+
+  private QualityProfileDto newQualityProfileDto(String name, String language, DbSession session) {
+    checkPermission(UserSession.get());
+      if (dbClient.qualityProfileDao().selectByNameAndLanguage(name, language, session) != null) {
+        throw BadRequestException.ofL10n("quality_profiles.profile_x_already_exists", name);
+      }
+
+    QualityProfileDto profile =  QualityProfileDto.createFor(name, language)
+      .setVersion(1).setUsed(false);
+    dbClient.qualityProfileDao().insert(profile, session);
+    return profile;
+  }
+
   private void register(String language, String name, Collection<RulesProfile> profiles, DbSession session) {
     LOGGER.info("Register " + language + " profile: " + name);
 
-    QProfile profile = qProfileLookup.profile(name, language, session);
+    QualityProfileDto profile = dbClient.qualityProfileDao().selectByNameAndLanguage(name, language, session);
     if (profile != null) {
-      qProfileOperations.deleteProfile(profile, session);
+      dbClient.activeRuleDao().deleteByProfileKey(profile.getKey(), session);
+      dbClient.qualityProfileDao().delete(profile, session);
     }
-    profile = qProfileOperations.newProfile(name, language, true, UserSession.get(), session);
+    profile = newQualityProfileDto(name, language, session);
 
     for (RulesProfile currentRulesProfile : profiles) {
-      qProfileBackup.restoreFromActiveRules(
-        QualityProfileKey.of(profile.name(),profile.language())
-        , currentRulesProfile, session);
+      //TODO trapped on legacy Hibernate object.
+      for (org.sonar.api.rules.ActiveRule activeRule : currentRulesProfile.getActiveRules()) {
+        RuleKey ruleKey = RuleKey.of(activeRule.getRepositoryKey(), activeRule.getRuleKey());
+        RuleDto rule = dbClient.ruleDao().getByKey(ruleKey, session);
+        if (rule == null) {
+          throw new NotFoundException(String.format("Rule '%s' does not exists.", ruleKey));
+        }
+
+        ActiveRuleDto activeRuleDto = dbClient.activeRuleDao().createActiveRule(
+          profile.getKey(), ruleKey, activeRule.getSeverity().name(), session);
+
+        //TODO trapped on legacy Hibernate object.
+        for (ActiveRuleParam param : activeRule.getActiveRuleParams()) {
+          String paramKey = param.getKey();
+          String value = param.getValue();
+          ActiveRuleParamDto paramDto = dbClient.activeRuleDao()
+            .getParamsByActiveRuleAndKey(activeRuleDto, paramKey, session);
+          if (value != null && !paramDto.getValue().equals(value)) {
+            paramDto.setValue(value);
+            dbClient.activeRuleDao().updateParam(activeRuleDto, paramDto, session);
+          }
+        }
+      }
     }
 
-    loadedTemplateDao.insert(new LoadedTemplateDto(templateKey(language, name), LoadedTemplateDto.QUALITY_PROFILE_TYPE), session);
+    dbClient.getDao(LoadedTemplateDao.class)
+      .insert(new LoadedTemplateDto(templateKey(language, name), LoadedTemplateDto.QUALITY_PROFILE_TYPE), session);
   }
 
   private void setDefault(String language, List<RulesProfile> profiles, SqlSession session) {
@@ -226,7 +248,8 @@ public class RegisterQualityProfiles {
   }
 
   private boolean shouldRegister(String language, String profileName, SqlSession session) {
-    return loadedTemplateDao.countByTypeAndKey(LoadedTemplateDto.QUALITY_PROFILE_TYPE, templateKey(language, profileName), session) == 0;
+    return dbClient.getDao(LoadedTemplateDao.class)
+      .countByTypeAndKey(LoadedTemplateDto.QUALITY_PROFILE_TYPE, templateKey(language, profileName), session) == 0;
   }
 
   private static String templateKey(String language, String profileName) {
diff --git a/sonar-server/src/main/java/org/sonar/server/qualityprofile/persistence/ActiveRuleDao.java b/sonar-server/src/main/java/org/sonar/server/qualityprofile/persistence/ActiveRuleDao.java
index c973953815d..690eb101e9b 100644
--- a/sonar-server/src/main/java/org/sonar/server/qualityprofile/persistence/ActiveRuleDao.java
+++ b/sonar-server/src/main/java/org/sonar/server/qualityprofile/persistence/ActiveRuleDao.java
@@ -22,6 +22,7 @@ package org.sonar.server.qualityprofile.persistence;
 
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Preconditions;
+import org.sonar.api.rule.RuleKey;
 import org.sonar.api.utils.System2;
 import org.sonar.core.persistence.DbSession;
 import org.sonar.core.qualityprofile.db.ActiveRuleDto;
@@ -32,6 +33,7 @@ import org.sonar.core.qualityprofile.db.QualityProfileDao;
 import org.sonar.core.qualityprofile.db.QualityProfileDto;
 import org.sonar.core.qualityprofile.db.QualityProfileKey;
 import org.sonar.core.rule.RuleDto;
+import org.sonar.core.rule.RuleParamDto;
 import org.sonar.server.db.BaseDao;
 import org.sonar.server.qualityprofile.QProfile;
 import org.sonar.server.qualityprofile.index.ActiveRuleIndexDefinition;
@@ -39,6 +41,8 @@ import org.sonar.server.rule2.persistence.RuleDao;
 
 import java.util.List;
 
+import static com.google.common.collect.Lists.newArrayList;
+
 public class ActiveRuleDao extends BaseDao<ActiveRuleMapper, ActiveRuleDto, ActiveRuleKey> {
 
   //TODO remove once key is finalized (used only to get id for SQL statement)
@@ -61,6 +65,26 @@ public class ActiveRuleDao extends BaseDao<ActiveRuleMapper, ActiveRuleDto, Acti
     throw new UnsupportedOperationException("Need to implement ActiveRuleDto.doGetByKey() method");
   }
 
+
+  public ActiveRuleDto createActiveRule(QualityProfileKey profileKey, RuleKey ruleKey, String severity, DbSession session) {
+    RuleDto ruleDto = ruleDao.getByKey(ruleKey, session);
+    QualityProfileDto profileDto = profileDao.selectByNameAndLanguage(profileKey.name(), profileKey.lang(), session);
+    ActiveRuleDto activeRule = ActiveRuleDto.createFor(profileDto, ruleDto)
+      .setSeverity(severity);
+    this.insert(activeRule, session);
+
+    List<RuleParamDto> ruleParams = ruleDao.findRuleParamsByRuleKey(ruleKey, session);
+    List<ActiveRuleParamDto> activeRuleParams = newArrayList();
+    for (RuleParamDto ruleParam : ruleParams) {
+      ActiveRuleParamDto activeRuleParam = ActiveRuleParamDto.createFor(ruleParam)
+        .setKey(ruleParam.getName())
+        .setValue(ruleParam.getDefaultValue());
+      activeRuleParams.add(activeRuleParam);
+      this.addParam(activeRule, activeRuleParam, session);
+    }
+    return activeRule;
+  }
+
   @Deprecated
   public ActiveRuleDto getById(int activeRuleId, DbSession session) {
     ActiveRuleDto rule = mapper(session).selectById(activeRuleId);
@@ -74,13 +98,8 @@ public class ActiveRuleDao extends BaseDao<ActiveRuleMapper, ActiveRuleDto, Acti
 
   @Override
   protected ActiveRuleDto doGetByKey(ActiveRuleKey key, DbSession session) {
-    QualityProfileDto qDto = profileDao.selectByNameAndLanguage(key.qProfile().name(), key.qProfile().lang(), session);
-    RuleDto ruleDto = ruleDao.getByKey(key.ruleKey(), session);
-    ActiveRuleDto activeRule = mapper(session).selectByProfileAndRule(qDto.getId(), ruleDto.getId());
-    if (activeRule.getKey() == null) {
-      activeRule.setKey(key);
-    }
-    return activeRule;
+    return mapper(session).selectByKey(key.qProfile().name(), key.qProfile().lang(),
+      key.ruleKey().repository(), key.ruleKey().rule());
   }
 
   @Override
@@ -180,8 +199,8 @@ public class ActiveRuleDao extends BaseDao<ActiveRuleMapper, ActiveRuleDto, Acti
 
   @Deprecated
   //TODO Needed until SQL rewrite with KEY fields.
-  private int getQualityProfileId(QualityProfileKey profileKey, DbSession sesison){
-    return 0;
+  private int getQualityProfileId(QualityProfileKey profileKey, DbSession session){
+    return profileDao.selectByNameAndLanguage(profileKey.name(), profileKey.lang(), session).getId();
   }
 
   /**
diff --git a/sonar-server/src/test/java/org/sonar/server/qualityprofile/QProfilesMediumTest.java b/sonar-server/src/test/java/org/sonar/server/qualityprofile/QProfilesMediumTest.java
index 883f13ffe10..e916caa3876 100644
--- a/sonar-server/src/test/java/org/sonar/server/qualityprofile/QProfilesMediumTest.java
+++ b/sonar-server/src/test/java/org/sonar/server/qualityprofile/QProfilesMediumTest.java
@@ -40,8 +40,6 @@ import org.sonar.server.rule.Rules;
 import org.sonar.server.tester.ServerTester;
 import org.sonar.server.user.MockUserSession;
 
-import java.util.List;
-
 import static com.google.common.collect.Lists.newArrayList;
 import static org.fest.assertions.Assertions.assertThat;
 import static org.fest.assertions.Fail.fail;
@@ -51,37 +49,6 @@ public class QProfilesMediumTest {
   @org.junit.Rule
   public ServerTester serverTester = new ServerTester().addComponents(XooRulesDefinition.class, XooProfileDefinition.class);
 
-  @Test
-  public void register_profile_at_startup() throws Exception {
-    QProfiles qProfiles = serverTester.get(QProfiles.class);
-    List<QProfile> profiles = qProfiles.profilesByLanguage("xoo");
-    assertThat(profiles).hasSize(1);
-
-    QProfile profile = profiles.get(0);
-    assertThat(profile.id()).isNotNull();
-    assertThat(profile.name()).isEqualTo("Basic");
-    assertThat(profile.language()).isEqualTo("xoo");
-    assertThat(qProfiles.defaultProfile("xoo").name()).isEqualTo("Basic");
-
-    assertThat(qProfiles.searchProfileRules(ProfileRuleQuery.create(profile.id()), Paging.create(10, 1)).rules()).hasSize(2);
-
-    // Rule x1
-    QProfileRule qProfileRule1 = qProfiles.searchProfileRules(ProfileRuleQuery.create(profile.id()).setNameOrKey("x1"), Paging.create(10, 1)).rules().get(0);
-    assertThat(qProfileRule1.key()).isEqualTo("x1");
-    assertThat(qProfileRule1.severity()).isEqualTo("MAJOR");
-    assertThat(qProfileRule1.params()).hasSize(1);
-
-    QProfileRuleParam qProfileRule1Param = qProfileRule1.params().get(0);
-    assertThat(qProfileRule1Param.key()).isEqualTo("acceptWhitespace");
-    assertThat(qProfileRule1Param.value()).isEqualTo("true");
-
-    // Rule x2
-    QProfileRule qProfileRule2 = qProfiles.searchProfileRules(ProfileRuleQuery.create(profile.id()).setNameOrKey("x2"), Paging.create(10, 1)).rules().get(0);
-    assertThat(qProfileRule2.key()).isEqualTo("x2");
-    assertThat(qProfileRule2.severity()).isEqualTo("BLOCKER");
-    assertThat(qProfileRule2.params()).isEmpty();
-  }
-
   @Test
   public void recreate_built_in_profile_from_language() throws Exception {
     MockUserSession.set().setLogin("julien").setName("Julien").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
diff --git a/sonar-server/src/test/java/org/sonar/server/qualityprofile/RegisterQualityProfilesMediumTest.java b/sonar-server/src/test/java/org/sonar/server/qualityprofile/RegisterQualityProfilesMediumTest.java
new file mode 100644
index 00000000000..9cb5eed7689
--- /dev/null
+++ b/sonar-server/src/test/java/org/sonar/server/qualityprofile/RegisterQualityProfilesMediumTest.java
@@ -0,0 +1,178 @@
+/*
+ * SonarQube, open source software quality management tool.
+ * Copyright (C) 2008-2014 SonarSource
+ * mailto:contact AT sonarsource DOT com
+ *
+ * SonarQube is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * SonarQube is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+package org.sonar.server.qualityprofile;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.sonar.api.profiles.ProfileDefinition;
+import org.sonar.api.profiles.RulesProfile;
+import org.sonar.api.rule.RuleKey;
+import org.sonar.api.rule.Severity;
+import org.sonar.api.rules.ActiveRule;
+import org.sonar.api.rules.RuleParam;
+import org.sonar.api.rules.RulePriority;
+import org.sonar.api.server.rule.RuleParamType;
+import org.sonar.api.server.rule.RulesDefinition;
+import org.sonar.api.utils.ValidationMessages;
+import org.sonar.core.persistence.DbSession;
+import org.sonar.core.persistence.MyBatis;
+import org.sonar.core.properties.PropertiesDao;
+import org.sonar.core.properties.PropertyDto;
+import org.sonar.core.properties.PropertyQuery;
+import org.sonar.core.qualityprofile.db.ActiveRuleDto;
+import org.sonar.core.qualityprofile.db.ActiveRuleKey;
+import org.sonar.core.qualityprofile.db.QualityProfileDao;
+import org.sonar.core.qualityprofile.db.QualityProfileKey;
+import org.sonar.core.rule.RuleDto;
+import org.sonar.server.qualityprofile.persistence.ActiveRuleDao;
+import org.sonar.server.rule2.persistence.RuleDao;
+import org.sonar.server.tester.ServerTester;
+
+import java.util.List;
+
+import static com.google.common.collect.Lists.newArrayList;
+import static org.fest.assertions.Assertions.assertThat;
+
+public class RegisterQualityProfilesMediumTest {
+
+  @org.junit.Rule
+  public ServerTester serverTester = new ServerTester().addComponents(XooRulesDefinition.class, XooProfileDefinition.class);
+
+  private DbSession session;
+
+  @Before
+  public void setup(){
+    session  = serverTester.get(MyBatis.class).openSession(false);
+  }
+
+  @After
+  public void tearDown() throws Exception {
+    session.close();
+  }
+
+  @Test
+  public void register_profile_at_startup() throws Exception {
+
+    QualityProfileKey qualityProfileKey = QualityProfileKey.of("Basic","xoo");
+
+    // 1. Check Profile in DB
+    QualityProfileDao qualityProfileDao = serverTester.get(QualityProfileDao.class);
+    assertThat(qualityProfileDao.selectAll()).hasSize(1);
+    assertThat(qualityProfileDao.selectByNameAndLanguage(qualityProfileKey.name(), qualityProfileKey.lang()))
+      .isNotNull();
+
+    // 2. Check Default Profile
+    PropertiesDao propertiesDao = serverTester.get(PropertiesDao.class);
+    List<PropertyDto> xooDefault = propertiesDao.selectByQuery(PropertyQuery.builder()
+      .setKey("sonar.profile.xoo").build());
+    assertThat(xooDefault).hasSize(1);
+    assertThat(xooDefault.get(0).getValue()).isEqualTo("Basic");
+
+    // 3. Check ActiveRules in DB
+    ActiveRuleDao activeRuleDao = serverTester.get(ActiveRuleDao.class);
+
+    assertThat(activeRuleDao.findByProfileKey(qualityProfileKey, session)).hasSize(2);
+    RuleKey ruleKey = RuleKey.of("xoo", "x1");
+    RuleDto rule = serverTester.get(RuleDao.class).getByKey(ruleKey, session);
+
+
+    ActiveRuleDto activeRule = activeRuleDao.getByKey(ActiveRuleKey.of(qualityProfileKey,ruleKey), session);
+
+    assertThat(activeRule.getKey().qProfile()).isEqualTo(qualityProfileKey);
+    assertThat(activeRule.getKey().ruleKey()).isEqualTo(rule.getKey());
+    assertThat(activeRule.getSeverityString()).isEqualToIgnoringCase("MAJOR");
+
+
+
+
+
+//
+//
+//    // 1. Check active rule in DAO
+//
+//    QProfiles qProfiles = serverTester.get(QProfiles.class);
+//    List<QProfile> profiles = qProfiles.profilesByLanguage("xoo");
+//    assertThat(profiles).hasSize(1);
+//
+//    QProfile profile = profiles.get(0);
+//    assertThat(profile.id()).isNotNull();
+//    assertThat(profile.name()).isEqualTo("Basic");
+//    assertThat(profile.language()).isEqualTo("xoo");
+//
+//    assertThat(qProfiles.searchProfileRules(ProfileRuleQuery.create(profile.id()), Paging.create(10, 1)).rules()).hasSize(2);
+//
+//    // Rule x1
+//    QProfileRule qProfileRule1 = qProfiles.searchProfileRules(ProfileRuleQuery.create(profile.id()).setNameOrKey("x1"), Paging.create(10, 1)).rules().get(0);
+//    assertThat(qProfileRule1.key()).isEqualTo("x1");
+//    assertThat(qProfileRule1.severity()).isEqualTo("MAJOR");
+//    assertThat(qProfileRule1.params()).hasSize(1);
+//
+//    QProfileRuleParam qProfileRule1Param = qProfileRule1.params().get(0);
+//    assertThat(qProfileRule1Param.key()).isEqualTo("acceptWhitespace");
+//    assertThat(qProfileRule1Param.value()).isEqualTo("true");
+//
+//    // Rule x2
+//    QProfileRule qProfileRule2 = qProfiles.searchProfileRules(ProfileRuleQuery.create(profile.id()).setNameOrKey("x2"), Paging.create(10, 1)).rules().get(0);
+//    assertThat(qProfileRule2.key()).isEqualTo("x2");
+//    assertThat(qProfileRule2.severity()).isEqualTo("BLOCKER");
+//    assertThat(qProfileRule2.params()).isEmpty();
+  }
+
+  public static class XooProfileDefinition extends ProfileDefinition {
+    @Override
+    public RulesProfile createProfile(ValidationMessages validation) {
+      final RulesProfile profile = RulesProfile.create("Basic", "xoo");
+      ActiveRule activeRule1 = profile.activateRule(
+        org.sonar.api.rules.Rule.create("xoo", "x1").setParams(newArrayList(new RuleParam().setKey("acceptWhitespace"))),
+        RulePriority.MAJOR);
+      activeRule1.setParameter("acceptWhitespace", "true");
+
+      profile.activateRule(org.sonar.api.rules.Rule.create("xoo", "x2"), RulePriority.BLOCKER);
+      return profile;
+    }
+  }
+
+  public static class XooRulesDefinition implements RulesDefinition {
+    @Override
+    public void define(Context context) {
+      NewRepository repository = context.createRepository("xoo", "xoo").setName("Xoo Repo");
+      repository.createRule("x1")
+        .setName("x1 name")
+        .setHtmlDescription("x1 desc")
+        .setSeverity(Severity.MINOR)
+        .createParam("acceptWhitespace")
+        .setDefaultValue("false")
+        .setType(RuleParamType.BOOLEAN)
+        .setDescription("Accept whitespaces on the line");
+
+      repository.createRule("x2")
+        .setName("x2 name")
+        .setHtmlDescription("x2 desc")
+        .setSeverity(Severity.MAJOR);
+      repository.done();
+    }
+  }
+
+  private QualityProfileKey profileKey(QProfile profile){
+    return QualityProfileKey.of(profile.name(), profile.language());
+  }
+}
diff --git a/sonar-server/src/test/java/org/sonar/server/qualityprofile/RegisterQualityProfilesTest.java b/sonar-server/src/test/java/org/sonar/server/qualityprofile/RegisterQualityProfilesTest.java
index 1e893273d59..50ba61a3ae9 100644
--- a/sonar-server/src/test/java/org/sonar/server/qualityprofile/RegisterQualityProfilesTest.java
+++ b/sonar-server/src/test/java/org/sonar/server/qualityprofile/RegisterQualityProfilesTest.java
@@ -63,8 +63,10 @@ java.lang.IllegalArgumentException: Name must be set
 	at org.sonar.server.qualityprofile.RegisterQualityProfilesTest.delete_existing_profile_if_template_is_empty(RegisterQualityProfilesTest.java:338)
   ...
  */
+//TODO check with J.L.
 public class RegisterQualityProfilesTest {
 
+
   @Mock
   QualityProfileDao qualityProfileDao;
 
@@ -107,8 +109,8 @@ public class RegisterQualityProfilesTest {
     when(sessionFactory.getSession()).thenReturn(mock(DatabaseSession.class));
 
     definitions = newArrayList();
-    registerQualityProfiles = new RegisterQualityProfiles(sessionFactory, myBatis, settings, esActiveRule, loadedTemplateDao, qProfileBackup, qProfileOperations, qProfileLookup,
-      defaultProfilesCache, null, definitions);
+//    registerQualityProfiles = new RegisterQualityProfiles(sessionFactory, myBatis,  loadedTemplateDao, qProfileBackup, qProfileOperations, qProfileLookup,
+//      defaultProfilesCache, null, definitions);
   }
 
   @Test
diff --git a/sonar-server/src/test/java/org/sonar/server/qualityprofile/persistence/ActiveRuleDaoTest.java b/sonar-server/src/test/java/org/sonar/server/qualityprofile/persistence/ActiveRuleDaoTest.java
new file mode 100644
index 00000000000..aae2bbabac2
--- /dev/null
+++ b/sonar-server/src/test/java/org/sonar/server/qualityprofile/persistence/ActiveRuleDaoTest.java
@@ -0,0 +1,62 @@
+package org.sonar.server.qualityprofile.persistence;
+
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.sonar.api.rule.RuleKey;
+import org.sonar.api.utils.System2;
+import org.sonar.core.persistence.AbstractDaoTestCase;
+import org.sonar.core.persistence.DbSession;
+import org.sonar.core.qualityprofile.db.ActiveRuleDto;
+import org.sonar.core.qualityprofile.db.QualityProfileDao;
+import org.sonar.core.qualityprofile.db.QualityProfileDto;
+import org.sonar.core.rule.RuleDto;
+import org.sonar.server.rule2.persistence.RuleDao;
+
+import static org.fest.assertions.Assertions.assertThat;
+
+public class ActiveRuleDaoTest  extends AbstractDaoTestCase{
+
+  ActiveRuleDao activeRuleDao;
+  RuleDao ruleDao;
+  QualityProfileDao qualityProfileDao;
+  DbSession session;
+
+
+  @Before
+  public void setUp() throws Exception {
+    session = getMyBatis().openSession(false);
+    ruleDao = new RuleDao(System2.INSTANCE);
+    qualityProfileDao = new QualityProfileDao(getMyBatis());
+    activeRuleDao = new ActiveRuleDao(qualityProfileDao, ruleDao, System2.INSTANCE);
+  }
+
+  @After
+  public void tearDown() throws Exception {
+    session.close();
+  }
+
+  @Test
+  public void get_by_key() throws Exception {
+
+    QualityProfileDto profile = QualityProfileDto.createFor("profile","xoo");
+    qualityProfileDao.insert(profile, session);
+
+    RuleDto rule = RuleDto.createFor(RuleKey.of("repo","rule"));
+    ruleDao.insert(rule, session);
+
+    ActiveRuleDto activeRuleDto = ActiveRuleDto.createFor(profile, rule)
+      .setSeverity("BLOCKER");
+    activeRuleDao.insert(activeRuleDto, session);
+
+    session.commit();
+
+    ActiveRuleDto result = activeRuleDao.getByKey(activeRuleDto.getKey(), session);
+
+    assertThat(result).isNotNull();
+    assertThat(result.getKey()).isNotNull();
+
+
+  }
+}
\ No newline at end of file
-- 
2.39.5