SONAR-5007 refactor DAO framework

36 files changed, 1322 insertions, 1797 deletions

diff --git a/sonar-core/src/main/java/org/sonar/core/db/Dao.java b/sonar-core/src/main/java/org/sonar/core/db/Dao.java
index b52c873a592..fc9a0a9734d 100644
--- a/sonar-core/src/main/java/org/sonar/core/db/Dao.java
+++ b/sonar-core/src/main/java/org/sonar/core/db/Dao.java
@@ -21,28 +21,22 @@ package org.sonar.core.db;
 
 import org.sonar.core.persistence.DbSession;
 
+import javax.annotation.CheckForNull;
 import java.io.Serializable;
 
 public interface Dao<E extends Dto<K>, K extends Serializable> {
 
-  E getByKey(K key);
-
-  E update(E item);
+  @CheckForNull
+  E getByKey(K key, DbSession session);
 
   E update(E item, DbSession session);
 
-  E insert(E item);
-
   E insert(E item, DbSession session);
 
-  void delete(E item);
-
   void delete(E item, DbSession session);
 
-  void deleteByKey(K key);
-
   void deleteByKey(K key, DbSession session);
 
-  Iterable<K> keysOfRowsUpdatedAfter(long timestamp);
+  Iterable<K> keysOfRowsUpdatedAfter(long timestamp, DbSession session);
 
 }
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 e1e3ca0deb9..fe3a586c76d 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
@@ -20,9 +20,10 @@
 
 package org.sonar.core.qualityprofile.db;
 
+import com.google.common.base.Preconditions;
 import org.apache.commons.lang.StringUtils;
-import org.sonar.api.rule.RuleKey;
 import org.sonar.core.db.Dto;
+import org.sonar.core.rule.RuleDto;
 import org.sonar.core.rule.SeverityUtil;
 
 import javax.annotation.CheckForNull;
@@ -45,13 +46,14 @@ public class ActiveRuleDto implements Dto<ActiveRuleKey> {
   private String noteUserLogin;
   private String noteData;
 
-  private ActiveRuleKey key;
+  private transient ActiveRuleKey key;
 
-  public void setKey(QualityProfileKey qKey, RuleKey rKey){
-    this.key = ActiveRuleKey.of(qKey, rKey);
+  public ActiveRuleDto setKey(@Nullable ActiveRuleKey key) {
+    this.key = key;
+    return this;
   }
 
-  public ActiveRuleKey getKey(){
+  public ActiveRuleKey getKey() {
     return this.key;
   }
 
@@ -72,6 +74,7 @@ public class ActiveRuleDto implements Dto<ActiveRuleKey> {
     return profileId;
   }
 
+  // TODO mark as private
   public ActiveRuleDto setProfileId(Integer profileId) {
     this.profileId = profileId;
     return this;
@@ -81,6 +84,7 @@ public class ActiveRuleDto implements Dto<ActiveRuleKey> {
     return ruleId;
   }
 
+  // TODO mark as private
   public ActiveRuleDto setRuleId(Integer ruleId) {
     this.ruleId = ruleId;
     return this;
@@ -173,5 +177,12 @@ public class ActiveRuleDto implements Dto<ActiveRuleKey> {
     return StringUtils.equals(OVERRIDES, inheritance);
   }
 
+  public static ActiveRuleDto createFor(QualityProfileDto profileDto, RuleDto ruleDto) {
+    ActiveRuleDto dto = new ActiveRuleDto();
+    dto.setProfileId(profileDto.getId());
+    dto.setRuleId(ruleDto.getId());
+    dto.setKey(ActiveRuleKey.of(QualityProfileKey.of(profileDto.getName(), profileDto.getLanguage()), ruleDto.getKey()));
+    return dto;
+  }
 
 }
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 cb0fc39b554..5d1f3ffe4b5 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
@@ -20,7 +20,6 @@
 package org.sonar.core.qualityprofile.db;
 
 import com.google.common.base.Preconditions;
-import com.google.common.base.Strings;
 import org.sonar.api.rule.RuleKey;
 
 import java.io.Serializable;
@@ -30,7 +29,7 @@ import java.io.Serializable;
  *
  * @since 4.4
  */
-public class ActiveRuleKey implements Serializable{
+public class ActiveRuleKey implements Serializable {
   private final QualityProfileKey qualityProfileKey;
   private final RuleKey ruleKey;
 
@@ -43,10 +42,8 @@ public class ActiveRuleKey implements Serializable{
    * Create a key. Parameters are NOT null.
    */
   public static ActiveRuleKey of(QualityProfileKey qualityProfileKey, RuleKey ruleKey) {
-    Preconditions.checkArgument(!Strings.isNullOrEmpty(qualityProfileKey.name()), "QProfile is missing name");
-    Preconditions.checkArgument(!Strings.isNullOrEmpty(qualityProfileKey.lang()), "QProfile is missing lang");
-    Preconditions.checkArgument(!Strings.isNullOrEmpty(ruleKey.repository()), "RuleKey is missing repository");
-    Preconditions.checkArgument(!Strings.isNullOrEmpty(ruleKey.rule()), "RuleKey is missing key");
+    Preconditions.checkArgument(qualityProfileKey != null, "QProfile is missing");
+    Preconditions.checkArgument(ruleKey != null, "RuleKey is missing key");
     return new ActiveRuleKey(qualityProfileKey, ruleKey);
   }
 
@@ -58,7 +55,7 @@ public class ActiveRuleKey implements Serializable{
     String[] split = s.split(":");
     Preconditions.checkArgument(split.length == 4, "Bad format of activeRule key: " + s);
     return ActiveRuleKey.of(QualityProfileKey.of(split[0], split[1]),
-                             RuleKey.of(split[2], split[3]));
+      RuleKey.of(split[2], split[3]));
   }
 
   /**
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 2378dfb7931..6160b21b43c 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,6 +21,7 @@
 package org.sonar.core.qualityprofile.db;
 
 import org.apache.ibatis.annotations.Param;
+import org.sonar.api.rule.RuleKey;
 
 import javax.annotation.CheckForNull;
 
@@ -74,5 +75,4 @@ public interface ActiveRuleMapper {
 
   List<ActiveRuleParamDto> selectAllParams();
 
-
 }
diff --git a/sonar-core/src/main/java/org/sonar/core/qualityprofile/db/ActiveRuleParamDto.java b/sonar-core/src/main/java/org/sonar/core/qualityprofile/db/ActiveRuleParamDto.java
index 2062a1f3f04..40d583ea26c 100644
--- a/sonar-core/src/main/java/org/sonar/core/qualityprofile/db/ActiveRuleParamDto.java
+++ b/sonar-core/src/main/java/org/sonar/core/qualityprofile/db/ActiveRuleParamDto.java
@@ -20,6 +20,8 @@
 
 package org.sonar.core.qualityprofile.db;
 
+import org.sonar.core.rule.RuleParamDto;
+
 public class ActiveRuleParamDto {
 
   private Integer id;
@@ -50,6 +52,7 @@ public class ActiveRuleParamDto {
     return rulesParameterId;
   }
 
+  // TODO set private or drop
   public ActiveRuleParamDto setRulesParameterId(Integer rulesParameterId) {
     this.rulesParameterId = rulesParameterId;
     return this;
@@ -73,4 +76,10 @@ public class ActiveRuleParamDto {
     return this;
   }
 
+  public static ActiveRuleParamDto createFor(RuleParamDto minParam) {
+    ActiveRuleParamDto dto = new ActiveRuleParamDto();
+    dto.setKey(minParam.getName());
+    dto.setRulesParameterId(minParam.getId());
+    return dto;
+  }
 }
diff --git a/sonar-core/src/main/java/org/sonar/core/rule/RuleDto.java b/sonar-core/src/main/java/org/sonar/core/rule/RuleDto.java
index e7d871fa2a3..20e0b188813 100644
--- a/sonar-core/src/main/java/org/sonar/core/rule/RuleDto.java
+++ b/sonar-core/src/main/java/org/sonar/core/rule/RuleDto.java
@@ -19,21 +19,19 @@
  */
 package org.sonar.core.rule;
 
-import org.sonar.api.rule.RuleKey;
-
-import org.sonar.core.db.Dto;
 import org.apache.commons.lang.builder.EqualsBuilder;
 import org.apache.commons.lang.builder.HashCodeBuilder;
 import org.apache.commons.lang.builder.ReflectionToStringBuilder;
 import org.apache.commons.lang.builder.ToStringStyle;
+import org.sonar.api.rule.RuleKey;
 import org.sonar.check.Cardinality;
+import org.sonar.core.db.Dto;
 
 import javax.annotation.CheckForNull;
 import javax.annotation.Nullable;
-
 import java.util.Date;
 
-public final class RuleDto implements Dto<RuleKey>{
+public final class RuleDto implements Dto<RuleKey> {
 
   public static final Integer DISABLED_CHARACTERISTIC_ID = -1;
 
@@ -64,9 +62,14 @@ public final class RuleDto implements Dto<RuleKey>{
   private Date createdAt;
   private Date updatedAt;
 
+  private transient RuleKey key;
+
   @Override
   public RuleKey getKey() {
-    return RuleKey.of(this.getRepositoryKey(), this.getRuleKey());
+    if (key == null) {
+      key = RuleKey.of(getRepositoryKey(), getRuleKey());
+    }
+    return key;
   }
 
   public Integer getId() {
@@ -150,7 +153,6 @@ public final class RuleDto implements Dto<RuleKey>{
     return this;
   }
 
-
   public Cardinality getCardinality() {
     return cardinality;
   }
diff --git a/sonar-core/src/main/java/org/sonar/core/rule/RuleMapper.java b/sonar-core/src/main/java/org/sonar/core/rule/RuleMapper.java
index d0d7975a9d0..9ee3d44e23c 100644
--- a/sonar-core/src/main/java/org/sonar/core/rule/RuleMapper.java
+++ b/sonar-core/src/main/java/org/sonar/core/rule/RuleMapper.java
@@ -50,6 +50,8 @@ public interface RuleMapper {
 
   List<RuleParamDto> selectParamsByRuleIds(@Param("ruleIds") List<Integer> ruleIds);
 
+  List<RuleParamDto> selectParamsByRuleKey(RuleKey ruleKey);
+
   RuleParamDto selectParamByRuleAndKey(@Param("ruleId") Integer ruleId, @Param("key") String key);
 
   void insertParameter(RuleParamDto param);
diff --git a/sonar-core/src/main/java/org/sonar/core/rule/RuleParamDto.java b/sonar-core/src/main/java/org/sonar/core/rule/RuleParamDto.java
index d3700421513..666af08e696 100644
--- a/sonar-core/src/main/java/org/sonar/core/rule/RuleParamDto.java
+++ b/sonar-core/src/main/java/org/sonar/core/rule/RuleParamDto.java
@@ -82,4 +82,5 @@ public class RuleParamDto {
     this.description = description;
     return this;
   }
+
 }
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 a41353bf019..2a7835f9f7e 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
@@ -197,6 +197,5 @@
     SELECT <include refid="activeRuleParamColumns"/>
     FROM active_rule_parameters p
   </select>
-
 </mapper>
 
diff --git a/sonar-core/src/main/resources/org/sonar/core/rule/RuleMapper.xml b/sonar-core/src/main/resources/org/sonar/core/rule/RuleMapper.xml
index ee7b13de0bd..e27be96abb0 100644
--- a/sonar-core/src/main/resources/org/sonar/core/rule/RuleMapper.xml
+++ b/sonar-core/src/main/resources/org/sonar/core/rule/RuleMapper.xml
@@ -130,28 +130,36 @@
   </delete>
 
   <sql id="paramColumns">
-    id, rule_id as "ruleId", name, param_type as "type", default_value as "defaultValue", description
+    p.id as "id", p.rule_id as "ruleId", p.name as "name", p.param_type as "type", p.default_value as "defaultValue",
+    p.description as "description"
   </sql>
 
   <select id="selectAllParams" resultType="RuleParam">
     select <include refid="paramColumns"/>
-    from rules_parameters
+    from rules_parameters p
   </select>
 
   <select id="selectParamsByRuleIds" resultType="RuleParam">
     SELECT <include refid="paramColumns"/>
-    FROM rules_parameters
+    FROM rules_parameters p
     <where>
-      AND (<foreach item="id" index="index" collection="ruleIds" open="(" separator=" or " close=")">rule_id=#{id}</foreach>)
+      AND (<foreach item="id" index="index" collection="ruleIds" open="(" separator=" or " close=")">p.rule_id=#{id}</foreach>)
     </where>
   </select>
 
+  <select id="selectParamsByRuleKey" resultType="RuleParam" parameterType="org.sonar.api.rule.RuleKey">
+    SELECT <include refid="paramColumns"/>
+    FROM rules_parameters p, rules r
+    WHERE p.rule_id=r.id
+    AND r.PLUGIN_NAME=#{repository} AND r.PLUGIN_RULE_KEY=#{rule}
+  </select>
+
   <select id="selectParamByRuleAndKey" resultType="RuleParam">
     SELECT <include refid="paramColumns"/>
-    FROM rules_parameters
+    FROM rules_parameters p
     <where>
-      AND rule_id=#{ruleId}
-      AND name=#{key}
+      AND p.rule_id=#{ruleId}
+      AND p.name=#{key}
     </where>
   </select>
 
diff --git a/sonar-server/src/main/java/org/sonar/server/db/BaseDao.java b/sonar-server/src/main/java/org/sonar/server/db/BaseDao.java
index 0c40a2e4b4c..b09cadc04b8 100644
--- a/sonar-server/src/main/java/org/sonar/server/db/BaseDao.java
+++ b/sonar-server/src/main/java/org/sonar/server/db/BaseDao.java
@@ -19,6 +19,7 @@
  */
 package org.sonar.server.db;
 
+import com.google.common.base.Preconditions;
 import org.sonar.core.db.Dao;
 import org.sonar.core.db.Dto;
 import org.sonar.core.persistence.DbSession;
@@ -30,21 +31,82 @@ import org.sonar.server.search.KeyIndexAction;
 
 import java.io.Serializable;
 
-public abstract class BaseDao<T, E extends Dto<K>, K extends Serializable>
-  implements Dao<E, K> {
+/**
+ * naming convention for DAO
+ * =========================
+ * <p/>
+ * The DAO manages a Business Domain for a set of DTO. There is a Main DTO (i.e. RuleDto)
+ * that has a few nested/child DTOs. The DAO supports nested DTOs for 1-to-1 and 1-to-many
+ * relations. Many-to-many relations are handled by their own DAO classes (i.e. ActiveRuleDao)
+ * <p/>
+ * Main DTO
+ * -------------------------
+ * <p/>
+ * * GET Methods
+ * - returns a single DTO
+ * - DTO is fully loaded (no field will return null)
+ * - returns null (and not empty)
+ * - examples:
+ * - RuleDto = ruleDao.getByKey(dto.getKey());
+ * <p/>
+ * * FIND Methods
+ * - returns a List of DTO.
+ * - Returns an empty list id no match
+ * - method name is FULLY-NOMINATIVE
+ * - examples:
+ * - List<RuleDto> rules findByQualityProfile(QualityProfile qprofile)
+ * - List<RuleDto> rules findByQualityProfile(QualityProfileKey qprofileKey)
+ * - List<RuleDto> rules findByQualityProfileAndCreatedAfter(QualityProfileKey qprofileKey, Date date)
+ * <p/>
+ * * CRUD Methods
+ * - insert(DTO)
+ * - udpate(DTO)
+ * - delete(DTO)
+ * <p/>
+ * Nested DTO
+ * -------------------------
+ * <p/>
+ * Some DAO implementations also manage nested DTO. RuleTag for example is managed by the RuleDao class
+ * Nested DTO are accessible following a similar convention for the Main DTO:
+ * <p/>
+ * * GET Methods
+ * - returns a single DTO
+ * - DTO is fully loaded (no field will return null)
+ * - returns null (and not empty)
+ * - prefixed with DTO type
+ * - examples:
+ * - RuleTagDto = ruleDao.getTagByKey(tagDto.getKey());
+ * <p/>
+ * * FIND Methods
+ * - returns a List of DTO.
+ * - Returns an empty list id no match
+ * - method name is FULLY-NOMINATIVE
+ * - prefixed with DTO type
+ * - examples:
+ * - List<RuleTagDto> tags findRuleTagByRuleKey(RuleKey key)
+ * - List<RuleTagDto> tags findRuleTagByRepositoryAndLanguage(RepositoryKey key, String language)
+ * <p/>
+ * * CRUD Methods are slightly different because they REQUIRE the main DTO to be valid
+ * - Nested dto methods MUST have the Main DTO or it's key as param
+ * - add
+ * - remove
+ * - update
+ * - examples:
+ * - RuleTagDto tag add(RuleTagDto tag, RuleKey key)
+ * - RuleParamDto param add(RuleParamDto param, RuleDto rule)
+ *
+ * @param <M> iBatis Mapper class
+ * @param <E> Produced DTO class from this dao
+ * @param <K> DTO Key class
+ */
+public abstract class BaseDao<M, E extends Dto<K>, K extends Serializable> implements Dao<E, K> {
 
-  protected final MyBatis mybatis;
-  private Class<T> mapperClass;
   protected final IndexDefinition indexDefinition;
+  private Class<M> mapperClass;
 
-  protected BaseDao(IndexDefinition indexDefinition, Class<T> mapperClass, MyBatis myBatis) {
+  protected BaseDao(IndexDefinition indexDefinition, Class<M> mapperClass) {
     this.indexDefinition = indexDefinition;
     this.mapperClass = mapperClass;
-    this.mybatis = myBatis;
-  }
-
-  public String getIndexName() {
-    return this.indexDefinition.getIndexName();
   }
 
   public String getIndexType() {
@@ -53,105 +115,46 @@ public abstract class BaseDao<T, E extends Dto<K>, K extends Serializable>
 
   protected abstract E doGetByKey(K key, DbSession session);
 
+  protected abstract K getKey(E item, DbSession session);
+
   protected abstract E doInsert(E item, DbSession session);
 
   protected abstract E doUpdate(E item, DbSession session);
 
-  protected abstract void doDelete(E item, DbSession session);
-
   protected abstract void doDeleteByKey(K key, DbSession session);
 
-  protected T getMapper(DbSession session) {
+  protected M mapper(DbSession session) {
     return session.getMapper(mapperClass);
   }
 
-  protected MyBatis getMyBatis() {
-    return this.mybatis;
-  }
-
-  @Override
-  public E getByKey(K key) {
-    DbSession session = getMyBatis().openSession(false);
-    try {
-      return this.doGetByKey(key, session);
-    } finally {
-      session.close();
-    }
+  public E getByKey(K key, DbSession session) {
+    return doGetByKey(key, session);
   }
 
   @Override
   public E update(E item, DbSession session) {
     this.doUpdate(item, session);
-    session.enqueue(new DtoIndexAction<E>(this.getIndexType(),
-      IndexAction.Method.UPDATE, item));
+    session.enqueue(new DtoIndexAction<E>(this.getIndexType(), IndexAction.Method.UPDATE, item));
     return item;
   }
 
   @Override
-  public E update(E item) {
-    DbSession session = getMyBatis().openSession(false);
-    try {
-      this.update(item, session);
-      session.commit();
-      return item;
-    } finally {
-      MyBatis.closeQuietly(session);
-    }
-  }
-
-  @Override
   public E insert(E item, DbSession session) {
     this.doInsert(item, session);
-    session.enqueue(new DtoIndexAction<E>(this.getIndexType(),
-      IndexAction.Method.INSERT, item));
+    session.enqueue(new DtoIndexAction<E>(this.getIndexType(), IndexAction.Method.INSERT, item));
     return item;
   }
 
   @Override
-  public E insert(E item) {
-    DbSession session = getMyBatis().openSession(false);
-    try {
-      this.insert(item, session);
-      session.commit();
-      return item;
-    } finally {
-      MyBatis.closeQuietly(session);
-    }
-  }
-
-  @Override
   public void delete(E item, DbSession session) {
-    this.doDelete(item, session);
-    session.enqueue(new DtoIndexAction<E>(this.getIndexType(),
-      IndexAction.Method.DELETE, item));
-  }
-
-  @Override
-  public void delete(E item) {
-    DbSession session = getMyBatis().openSession(false);
-    try {
-      this.delete(item, session);
-      session.commit();
-    } finally {
-      MyBatis.closeQuietly(session);
-    }
+    deleteByKey(getKey(item, session), session);
   }
 
   @Override
   public void deleteByKey(K key, DbSession session) {
-    this.doDeleteByKey(key, session);
-    session.enqueue(new KeyIndexAction<K>(this.getIndexType(),
-      IndexAction.Method.DELETE, key));
+    Preconditions.checkNotNull(key);
+    doDeleteByKey(key, session);
+    session.enqueue(new KeyIndexAction<K>(this.getIndexType(), IndexAction.Method.DELETE, key));
   }
 
-  @Override
-  public void deleteByKey(K key) {
-    DbSession session = getMyBatis().openSession(false);
-    try {
-      this.doDeleteByKey(key, session);
-      session.commit();
-    } finally {
-      MyBatis.closeQuietly(session);
-    }
-  }
 }
diff --git a/sonar-server/src/main/java/org/sonar/server/platform/ServerComponents.java b/sonar-server/src/main/java/org/sonar/server/platform/ServerComponents.java
index e61d52791cd..b0a27ede95e 100644
--- a/sonar-server/src/main/java/org/sonar/server/platform/ServerComponents.java
+++ b/sonar-server/src/main/java/org/sonar/server/platform/ServerComponents.java
@@ -288,7 +288,8 @@ class ServerComponents {
     pico.addSingleton(QProfilesWs.class);
     pico.addSingleton(ProfilesWs.class);
     pico.addSingleton(ActivateRuleAction.class);
-    pico.addSingleton(RuleActivationService.class);
+    pico.addSingleton(ActiveRuleService.class);
+    pico.addSingleton(RuleActivationContextFactory.class);
 
     // rule
     pico.addSingleton(AnnotationRuleParser.class);
diff --git a/sonar-server/src/main/java/org/sonar/server/qualityprofile/ActiveRuleChange.java b/sonar-server/src/main/java/org/sonar/server/qualityprofile/ActiveRuleChange.java
new file mode 100644
index 00000000000..8630a01f6fc
--- /dev/null
+++ b/sonar-server/src/main/java/org/sonar/server/qualityprofile/ActiveRuleChange.java
@@ -0,0 +1,108 @@
+/*
+ * 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 com.google.common.collect.Maps;
+import org.apache.commons.lang.ObjectUtils;
+import org.sonar.core.qualityprofile.db.ActiveRuleKey;
+
+import javax.annotation.CheckForNull;
+import javax.annotation.Nullable;
+import java.util.Map;
+
+public class ActiveRuleChange {
+
+  static enum Type {
+    ACTIVATED, DEACTIVATED, UPDATED
+  }
+
+  private final Type type;
+  private final ActiveRuleKey key;
+  private boolean inheritedChange = false;
+  private String previousSeverity = null, severity = null;
+  private Map<String, String> previousParameters = null, parameters = null;
+
+  ActiveRuleChange(Type type, ActiveRuleKey key) {
+    this.type = type;
+    this.key = key;
+  }
+
+  public ActiveRuleKey getKey() {
+    return key;
+  }
+
+  public Type getType() {
+    return type;
+  }
+
+  public boolean isInheritedChange() {
+    return inheritedChange;
+  }
+
+  public void setInheritedChange(boolean b) {
+    this.inheritedChange = b;
+  }
+
+  @CheckForNull
+  public String getPreviousSeverity() {
+    return previousSeverity;
+  }
+
+  public void setPreviousSeverity(@Nullable String s) {
+    this.previousSeverity = s;
+  }
+
+  @CheckForNull
+  public String getSeverity() {
+    return severity;
+  }
+
+  public void setSeverity(@Nullable String severity) {
+    this.severity = severity;
+  }
+
+  @CheckForNull
+  public Map<String, String> getPreviousParameters() {
+    return previousParameters;
+  }
+
+  public void setPreviousParameters(@Nullable Map<String, String> previousParameters) {
+    this.previousParameters = previousParameters;
+  }
+
+  @CheckForNull
+  public Map<String, String> getParameters() {
+    return parameters;
+  }
+
+  public void setParameters(@Nullable Map<String, String> parameters) {
+    this.parameters = parameters;
+  }
+
+  boolean hasDifferences() {
+    if (!ObjectUtils.equals(severity, previousSeverity)) {
+      return true;
+    }
+    if (!ObjectUtils.equals(parameters, previousParameters)) {
+      return parameters == null || previousParameters != null || !Maps.difference(parameters, previousParameters).areEqual();
+    }
+    return false;
+  }
+}
diff --git a/sonar-server/src/main/java/org/sonar/server/qualityprofile/ActiveRuleService.java b/sonar-server/src/main/java/org/sonar/server/qualityprofile/ActiveRuleService.java
new file mode 100644
index 00000000000..d732e9edc19
--- /dev/null
+++ b/sonar-server/src/main/java/org/sonar/server/qualityprofile/ActiveRuleService.java
@@ -0,0 +1,138 @@
+/*
+ * 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 com.google.common.base.Splitter;
+import com.google.common.collect.Lists;
+import org.apache.commons.lang.StringUtils;
+import org.sonar.api.ServerComponent;
+import org.sonar.api.server.rule.RuleParamType;
+import org.sonar.core.permission.GlobalPermissions;
+import org.sonar.core.persistence.DbSession;
+import org.sonar.core.persistence.MyBatis;
+import org.sonar.core.qualityprofile.db.ActiveRuleDto;
+import org.sonar.core.qualityprofile.db.ActiveRuleKey;
+import org.sonar.core.rule.RuleParamDto;
+import org.sonar.server.rule2.ActiveRuleDao;
+import org.sonar.server.user.UserSession;
+import org.sonar.server.util.TypeValidations;
+
+import java.util.Collection;
+import java.util.List;
+
+import static com.google.common.collect.Lists.newArrayList;
+
+public class ActiveRuleService implements ServerComponent {
+
+  private final MyBatis myBatis;
+  private final ActiveRuleDao activeRuleDao;
+  private final TypeValidations typeValidations;
+  private final RuleActivationContextFactory contextFactory;
+
+  public ActiveRuleService(MyBatis myBatis, ActiveRuleDao activeRuleDao,
+                           RuleActivationContextFactory contextFactory, TypeValidations typeValidations) {
+    this.myBatis = myBatis;
+    this.activeRuleDao = activeRuleDao;
+    this.contextFactory = contextFactory;
+    this.typeValidations = typeValidations;
+  }
+
+  /**
+   * Activate a rule on a Quality profile. Update configuration (severity/parameters) if the rule is already
+   * activated.
+   */
+  public List<ActiveRuleChange> activate(RuleActivation activation, UserSession userSession) {
+    verifyPermission(userSession);
+
+    DbSession dbSession = myBatis.openSession(false);
+    List<ActiveRuleChange> changes = Lists.newArrayList();
+    try {
+      RuleActivationContext context = contextFactory.create(activation.getKey(), dbSession);
+      ActiveRuleChange change;
+      if (context.activeRule() == null) {
+        change = new ActiveRuleChange(ActiveRuleChange.Type.ACTIVATED, activation.getKey());
+      } else {
+        change = new ActiveRuleChange(ActiveRuleChange.Type.UPDATED, activation.getKey());
+      }
+      change.setSeverity(StringUtils.defaultIfEmpty(activation.getSeverity(), context.defaultSeverity()));
+      // TODO params
+      changes.add(change);
+
+      // TODO apply changes to children
+
+      persist(changes, dbSession);
+      dbSession.commit();
+
+      // TODO filter changes without any differences
+      return changes;
+
+    } finally {
+      dbSession.close();
+    }
+  }
+
+  private void persist(Collection<ActiveRuleChange> changes, DbSession dbSession) {
+    for (ActiveRuleChange change : changes) {
+      if (change.getType() == ActiveRuleChange.Type.ACTIVATED) {
+        ActiveRuleDto activeRule = ActiveRuleDto.createFor(null, null /* TODO */)
+          .setKey(change.getKey())
+          .setSeverity(change.getSeverity());
+        activeRuleDao.insert(activeRule, dbSession);
+
+        // TODO insert activeruelparams
+
+      } else if (change.getType() == ActiveRuleChange.Type.DEACTIVATED) {
+        activeRuleDao.deleteByKey(change.getKey(), dbSession);
+
+      } else if (change.getType() == ActiveRuleChange.Type.UPDATED) {
+
+      }
+    }
+  }
+
+  /**
+   * Deactivate a rule on a Quality profile. Does nothing if the rule is not activated.
+   */
+  public List<ActiveRuleChange> deactivate(ActiveRuleKey key, UserSession userSession) {
+    verifyPermission(userSession);
+    throw new UnsupportedOperationException("TODO");
+  }
+
+  public List<ActiveRuleChange> bulkActivate(BulkRuleActivation activation, UserSession userSession) {
+    verifyPermission(userSession);
+    throw new UnsupportedOperationException("TODO");
+  }
+
+
+  private void verifyPermission(UserSession userSession) {
+    userSession.checkLoggedIn();
+    userSession.checkGlobalPermission(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+  }
+
+  private void verifyParam(RuleParamDto ruleParam, String value) {
+    RuleParamType ruleParamType = RuleParamType.parse(ruleParam.getType());
+    if (ruleParamType.multiple()) {
+      List<String> values = newArrayList(Splitter.on(",").split(value));
+      typeValidations.validate(values, ruleParamType.type(), ruleParamType.values());
+    } else {
+      typeValidations.validate(value, ruleParamType.type(), ruleParamType.values());
+    }
+  }
+}
diff --git a/sonar-server/src/main/java/org/sonar/server/qualityprofile/ProfilesManager.java b/sonar-server/src/main/java/org/sonar/server/qualityprofile/ProfilesManager.java
index f67b3ff88a7..27f32a4f516 100644
--- a/sonar-server/src/main/java/org/sonar/server/qualityprofile/ProfilesManager.java
+++ b/sonar-server/src/main/java/org/sonar/server/qualityprofile/ProfilesManager.java
@@ -27,6 +27,7 @@ import org.sonar.api.profiles.RulesProfile;
 import org.sonar.api.rules.*;
 import org.sonar.core.preview.PreviewCache;
 import org.sonar.jpa.dao.BaseDao;
+import org.sonar.api.rules.ActiveRuleChange;
 import org.sonar.jpa.dao.RulesDao;
 
 import javax.annotation.CheckForNull;
diff --git a/sonar-server/src/main/java/org/sonar/server/qualityprofile/RuleActivation.java b/sonar-server/src/main/java/org/sonar/server/qualityprofile/RuleActivation.java
index 65cae48c066..e83a71f62fd 100644
--- a/sonar-server/src/main/java/org/sonar/server/qualityprofile/RuleActivation.java
+++ b/sonar-server/src/main/java/org/sonar/server/qualityprofile/RuleActivation.java
@@ -19,6 +19,7 @@
  */
 package org.sonar.server.qualityprofile;
 
+import com.google.common.base.Strings;
 import com.google.common.collect.Maps;
 import org.sonar.api.rule.Severity;
 import org.sonar.core.qualityprofile.db.ActiveRuleKey;
@@ -48,10 +49,11 @@ public class RuleActivation {
   }
 
   public RuleActivation setParam(String key, @Nullable String value) {
+    String sanitizedValue = Strings.emptyToNull(value);
     if (value == null) {
       parameters.remove(key);
     } else {
-      parameters.put(key, value);
+      parameters.put(key, sanitizedValue);
     }
     return this;
   }
diff --git a/sonar-server/src/main/java/org/sonar/server/qualityprofile/RuleActivationContext.java b/sonar-server/src/main/java/org/sonar/server/qualityprofile/RuleActivationContext.java
new file mode 100644
index 00000000000..2cc2714e096
--- /dev/null
+++ b/sonar-server/src/main/java/org/sonar/server/qualityprofile/RuleActivationContext.java
@@ -0,0 +1,148 @@
+/*
+ * 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 com.google.common.collect.Maps;
+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.rule.RuleParamDto;
+
+import javax.annotation.CheckForNull;
+import javax.annotation.Nullable;
+import java.util.Collection;
+import java.util.Map;
+
+class RuleActivationContext {
+
+  private RuleDto rule;
+  private Map<String, RuleParamDto> ruleParams;
+  private QualityProfileDto profile, parentProfile;
+  private ActiveRuleDto activeRule, parentActiveRule;
+  private Map<String, ActiveRuleParamDto> activeRuleParams, parentActiveRuleParams;
+
+  RuleDto rule() {
+    return rule;
+  }
+
+  RuleActivationContext setRule(RuleDto rule) {
+    this.rule = rule;
+    return this;
+  }
+
+  Map<String, RuleParamDto> ruleParamsByKeys() {
+    return ruleParams;
+  }
+
+  Collection<RuleParamDto> ruleParams() {
+    return ruleParams.values();
+  }
+
+  RuleActivationContext setRuleParams(Collection<RuleParamDto> ruleParams) {
+    this.ruleParams = Maps.newHashMap();
+    for (RuleParamDto ruleParam : ruleParams) {
+      this.ruleParams.put(ruleParam.getName(), ruleParam);
+    }
+    return this;
+  }
+
+  QualityProfileDto profile() {
+    return profile;
+  }
+
+  RuleActivationContext setProfile(QualityProfileDto profile) {
+    this.profile = profile;
+    return this;
+  }
+
+  @CheckForNull
+  QualityProfileDto parentProfile() {
+    return parentProfile;
+  }
+
+  RuleActivationContext setParentProfile(@Nullable QualityProfileDto p) {
+    this.parentProfile = p;
+    return this;
+  }
+
+  @CheckForNull
+  ActiveRuleDto activeRule() {
+    return activeRule;
+  }
+
+  RuleActivationContext setActiveRule(@Nullable ActiveRuleDto a) {
+    this.activeRule = a;
+    return this;
+  }
+
+  @CheckForNull
+  ActiveRuleDto parentActiveRule() {
+    return parentActiveRule;
+  }
+
+  RuleActivationContext setParentActiveRule(@Nullable ActiveRuleDto a) {
+    this.parentActiveRule = a;
+    return this;
+  }
+
+  @CheckForNull
+  Map<String, ActiveRuleParamDto> activeRuleParamsAsMap() {
+    return activeRuleParams;
+  }
+
+  @CheckForNull
+  Collection<ActiveRuleParamDto> activeRuleParams() {
+    return activeRuleParams != null ? activeRuleParams.values() : null;
+  }
+
+  RuleActivationContext setActiveRuleParams(@Nullable Collection<ActiveRuleParamDto> a) {
+    if (a == null) {
+      this.activeRuleParams = null;
+    } else {
+      this.activeRuleParams = Maps.newHashMap();
+      for (ActiveRuleParamDto ar : a) {
+        this.activeRuleParams.put(ar.getKey(), ar);
+      }
+    }
+    return this;
+  }
+
+  @CheckForNull
+  Map<String, ActiveRuleParamDto> parentActiveRuleParams() {
+    return parentActiveRuleParams;
+  }
+
+  RuleActivationContext setParentActiveRuleParams(@Nullable Collection<ActiveRuleParamDto> a) {
+    if (a == null) {
+      this.parentActiveRuleParams = null;
+    } else {
+      this.parentActiveRuleParams = Maps.newHashMap();
+      for (ActiveRuleParamDto ar : a) {
+        this.parentActiveRuleParams.put(ar.getKey(), ar);
+      }
+    }
+    return this;
+  }
+
+  String defaultSeverity() {
+    return parentActiveRule != null ? parentActiveRule.getSeverityString() : rule.getSeverityString();
+  }
+}
diff --git a/sonar-server/src/main/java/org/sonar/server/qualityprofile/RuleActivationContextFactory.java b/sonar-server/src/main/java/org/sonar/server/qualityprofile/RuleActivationContextFactory.java
new file mode 100644
index 00000000000..8d6240fd8db
--- /dev/null
+++ b/sonar-server/src/main/java/org/sonar/server/qualityprofile/RuleActivationContextFactory.java
@@ -0,0 +1,111 @@
+/*
+ * 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.sonar.api.ServerComponent;
+import org.sonar.api.rule.RuleKey;
+import org.sonar.api.rule.RuleStatus;
+import org.sonar.core.persistence.DbSession;
+import org.sonar.core.qualityprofile.db.ActiveRuleDto;
+import org.sonar.core.qualityprofile.db.ActiveRuleKey;
+import org.sonar.core.qualityprofile.db.ActiveRuleParamDto;
+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.server.rule2.ActiveRuleDao;
+import org.sonar.server.rule2.RuleDao;
+
+import java.util.Collection;
+
+public class RuleActivationContextFactory implements ServerComponent {
+
+  private final ActiveRuleDao activeRuleDao;
+  private final RuleDao ruleDao;
+  private final QualityProfileDao profileDao;
+
+  public RuleActivationContextFactory(ActiveRuleDao activeRuleDao, RuleDao ruleDao, QualityProfileDao profileDao) {
+    this.activeRuleDao = activeRuleDao;
+    this.ruleDao = ruleDao;
+    this.profileDao = profileDao;
+  }
+
+  public RuleActivationContext create(ActiveRuleKey key, DbSession session) {
+    RuleActivationContext context = new RuleActivationContext();
+
+    RuleDto rule = initRule(key.ruleKey(), context, session);
+
+    QualityProfileDto profile = initProfile(key, context, session, false);
+    initActiveRules(key, context, session, false);
+    if (!profile.getLanguage().equals(rule.getLanguage())) {
+      throw new IllegalArgumentException(String.format("Rule %s and profile %s have different languages", rule.getKey(), profile));
+    }
+
+    if (profile.getParent() != null) {
+      ActiveRuleKey parentKey = ActiveRuleKey.of(
+        QualityProfileKey.of(profile.getParent(), profile.getLanguage()), rule.getKey());
+      initProfile(parentKey, context, session, true);
+      initActiveRules(parentKey, context, session, true);
+    }
+    return context;
+  }
+
+  private RuleDto initRule(RuleKey ruleKey, RuleActivationContext context, DbSession dbSession) {
+    RuleDto rule = ruleDao.getByKey(ruleKey, dbSession);
+    if (rule == null) {
+      throw new IllegalArgumentException("Rule not found: " + ruleKey);
+    }
+    if (RuleStatus.REMOVED == RuleStatus.valueOf(rule.getStatus())) {
+      throw new IllegalArgumentException("Rule was removed: " + ruleKey);
+    }
+    context.setRule(rule);
+    context.setRuleParams(ruleDao.findRuleParamsByRuleKey(rule.getKey(), dbSession));
+    return rule;
+  }
+
+  private QualityProfileDto initProfile(ActiveRuleKey key, RuleActivationContext context, DbSession session, boolean parent) {
+    QualityProfileDto profile = profileDao.selectByNameAndLanguage(
+      key.qProfile().name(), key.qProfile().lang());
+    if (profile == null) {
+      throw new IllegalArgumentException("Quality profile not found: " + key.qProfile());
+    }
+    if (parent) {
+      context.setParentProfile(profile);
+    } else {
+      context.setProfile(profile);
+    }
+    return profile;
+  }
+
+  private void initActiveRules(ActiveRuleKey key, RuleActivationContext context, DbSession session, boolean parent) {
+    ActiveRuleDto activeRule = activeRuleDao.getByKey(key, session);
+    Collection<ActiveRuleParamDto> activeRuleParams = null;
+    if (activeRule != null) {
+      context.setActiveRuleParams(activeRuleDao.findParamsByActiveRule(activeRule, session));
+    }
+    if (parent) {
+      context.setParentActiveRule(activeRule);
+      context.setParentActiveRuleParams(activeRuleParams);
+    } else {
+      context.setActiveRule(activeRule);
+      context.setActiveRuleParams(activeRuleParams);
+    }
+  }
+}
diff --git a/sonar-server/src/main/java/org/sonar/server/qualityprofile/RuleActivationService.java b/sonar-server/src/main/java/org/sonar/server/qualityprofile/RuleActivationService.java
deleted file mode 100644
index f1d91b5a78a..00000000000
--- a/sonar-server/src/main/java/org/sonar/server/qualityprofile/RuleActivationService.java
+++ /dev/null
@@ -1,89 +0,0 @@
-/*
- * 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.sonar.api.ServerComponent;
-import org.sonar.core.permission.GlobalPermissions;
-import org.sonar.core.persistence.DbSession;
-import org.sonar.core.persistence.MyBatis;
-import org.sonar.core.qualityprofile.db.ActiveRuleDto;
-import org.sonar.core.qualityprofile.db.ActiveRuleKey;
-import org.sonar.server.rule2.ActiveRuleDao;
-import org.sonar.server.user.UserSession;
-
-public class RuleActivationService implements ServerComponent {
-
-  private final MyBatis myBatis;
-  private final ActiveRuleDao activeRuleDao;
-
-  public RuleActivationService(MyBatis myBatis, ActiveRuleDao activeRuleDao) {
-    this.myBatis = myBatis;
-    this.activeRuleDao = activeRuleDao;
-  }
-
-  /**
-   * Activate a rule on a Quality profile. Update configuration (severity/parameters) if the rule is already
-   * activated.
-   */
-  public RuleActivation activate(RuleActivation activation, UserSession userSession) {
-    verifyPermission(userSession);
-    DbSession session = myBatis.openSession(false);
-    try {
-      ActiveRuleDto dto = activeRuleDao.getByKey(activation.getKey());
-      if (dto == null) {
-        // insert -> verify profile and parameters
-
-      } else {
-        // update -> verify parameters
-      }
-
-    } finally {
-      MyBatis.closeQuietly(session);
-    }
-
-    throw new UnsupportedOperationException("TODO");
-  }
-
-  /**
-   * Deactivate a rule on a Quality profile. Does nothing if the rule is not activated.
-   */
-  public boolean deactivate(ActiveRuleKey key, UserSession userSession) {
-    verifyPermission(userSession);
-    throw new UnsupportedOperationException("TODO");
-  }
-
-  /**
-   * Only for rules inherited from parent profile
-   */
-  public RuleActivation revert(ActiveRuleKey key, UserSession userSession) {
-    verifyPermission(userSession);
-    throw new UnsupportedOperationException("TODO");
-  }
-
-  public void bulkActivate(BulkRuleActivation activation, UserSession userSession) {
-    verifyPermission(userSession);
-    throw new UnsupportedOperationException("TODO");
-  }
-
-  private void verifyPermission(UserSession userSession) {
-    userSession.checkLoggedIn();
-    userSession.checkGlobalPermission(GlobalPermissions.QUALITY_PROFILE_ADMIN);
-  }
-}
diff --git a/sonar-server/src/main/java/org/sonar/server/qualityprofile/ws/ActivateRuleAction.java b/sonar-server/src/main/java/org/sonar/server/qualityprofile/ws/ActivateRuleAction.java
index a621f400f24..0b49d506377 100644
--- a/sonar-server/src/main/java/org/sonar/server/qualityprofile/ws/ActivateRuleAction.java
+++ b/sonar-server/src/main/java/org/sonar/server/qualityprofile/ws/ActivateRuleAction.java
@@ -24,13 +24,13 @@ import org.sonar.api.server.ws.Request;
 import org.sonar.api.server.ws.RequestHandler;
 import org.sonar.api.server.ws.Response;
 import org.sonar.api.server.ws.WebService;
-import org.sonar.server.qualityprofile.RuleActivationService;
+import org.sonar.server.qualityprofile.ActiveRuleService;
 
 public class ActivateRuleAction implements RequestHandler {
 
-  private final RuleActivationService service;
+  private final ActiveRuleService service;
 
-  public ActivateRuleAction(RuleActivationService service) {
+  public ActivateRuleAction(ActiveRuleService service) {
     this.service = service;
   }
 
diff --git a/sonar-server/src/main/java/org/sonar/server/rule/RegisterRules.java b/sonar-server/src/main/java/org/sonar/server/rule/RegisterRules.java
index 6c0ef81c719..6a995d683e5 100644
--- a/sonar-server/src/main/java/org/sonar/server/rule/RegisterRules.java
+++ b/sonar-server/src/main/java/org/sonar/server/rule/RegisterRules.java
@@ -44,7 +44,7 @@ import org.sonar.check.Cardinality;
 import org.sonar.core.persistence.DbSession;
 import org.sonar.core.persistence.MyBatis;
 import org.sonar.core.qualityprofile.db.ActiveRuleDao;
-import org.sonar.server.rule2.RuleDao;
+import org.sonar.core.rule.RuleDao;
 import org.sonar.core.rule.RuleDto;
 import org.sonar.core.rule.RuleParamDto;
 import org.sonar.core.rule.RuleRuleTagDto;
@@ -58,7 +58,6 @@ import org.sonar.server.startup.RegisterDebtModel;
 
 import javax.annotation.CheckForNull;
 import javax.annotation.Nullable;
-
 import java.util.Collection;
 import java.util.Date;
 import java.util.List;
@@ -294,7 +293,7 @@ public class RegisterRules implements Startable {
       hasDebt ? def.effortToFixDescription() : null);
   }
 
-  private boolean mergeDebtDefinitions(RulesDefinition.Rule def, RuleDto dto,@Nullable  Integer characteristicId, @Nullable String remediationFunction,
+  private boolean mergeDebtDefinitions(RulesDefinition.Rule def, RuleDto dto, @Nullable Integer characteristicId, @Nullable String remediationFunction,
                                        @Nullable String remediationCoefficient, @Nullable String remediationOffset, @Nullable String effortToFixDescription) {
     boolean changed = false;
 
@@ -571,7 +570,7 @@ public class RegisterRules implements Startable {
       unprocessedRuleIds.remove(ruleDto.getId());
     }
 
-    CharacteristicDto characteristic(@Nullable String subCharacteristic, String repo, String ruleKey, @Nullable Integer overridingCharacteristicId){
+    CharacteristicDto characteristic(@Nullable String subCharacteristic, String repo, String ruleKey, @Nullable Integer overridingCharacteristicId) {
       // Rule is not linked to a default characteristic or characteristic has been disabled by user
       if (subCharacteristic == null) {
         return null;
diff --git a/sonar-server/src/main/java/org/sonar/server/rule2/ActiveRuleDao.java b/sonar-server/src/main/java/org/sonar/server/rule2/ActiveRuleDao.java
index 1c21797d3dc..58f6cb771a8 100644
--- a/sonar-server/src/main/java/org/sonar/server/rule2/ActiveRuleDao.java
+++ b/sonar-server/src/main/java/org/sonar/server/rule2/ActiveRuleDao.java
@@ -20,11 +20,9 @@
 
 package org.sonar.server.rule2;
 
-import com.google.common.collect.Lists;
-import org.hibernate.cfg.NotYetImplementedException;
-import org.sonar.api.ServerComponent;
+import com.google.common.base.Preconditions;
+import org.sonar.api.rule.RuleKey;
 import org.sonar.core.persistence.DbSession;
-import org.sonar.core.persistence.MyBatis;
 import org.sonar.core.qualityprofile.db.ActiveRuleDto;
 import org.sonar.core.qualityprofile.db.ActiveRuleKey;
 import org.sonar.core.qualityprofile.db.ActiveRuleMapper;
@@ -37,377 +35,104 @@ import org.sonar.server.db.BaseDao;
 import org.sonar.server.search.EmbeddedIndexAction;
 import org.sonar.server.search.IndexAction;
 
-import javax.annotation.CheckForNull;
-import java.util.Collection;
-import java.util.Collections;
 import java.util.List;
 
-import static com.google.common.collect.Lists.newArrayList;
+public class ActiveRuleDao extends BaseDao<ActiveRuleMapper, ActiveRuleDto, ActiveRuleKey> {
 
-public class ActiveRuleDao extends BaseDao<ActiveRuleMapper, ActiveRuleDto, ActiveRuleKey>
-  implements ServerComponent {
+  private final RuleDao ruleDao;
+  private final QualityProfileDao profileDao;
 
-  /** this is temporary to build RuleKey and QProfileKey */
-  private RuleDao ruleDao;
-  private QualityProfileDao qDao;
-
-  public ActiveRuleDao(MyBatis mybatis, QualityProfileDao qDao, RuleDao ruleDao) {
-    super(new ActiveRuleIndexDefinition(), ActiveRuleMapper.class, mybatis);
+  public ActiveRuleDao(QualityProfileDao profileDao, RuleDao ruleDao) {
+    super(new ActiveRuleIndexDefinition(), ActiveRuleMapper.class);
     this.ruleDao = ruleDao;
-    this.qDao = qDao;
+    this.profileDao = profileDao;
   }
 
   @Override
-  public Iterable<ActiveRuleKey> keysOfRowsUpdatedAfter(long timestamp) {
-    throw new NotYetImplementedException("Need to implement ActiveRuleDto.doGetByKey() method");
+  public ActiveRuleKey getKey(ActiveRuleDto item, DbSession session) {
+    if (item.getKey() != null) {
+      return item.getKey();
+    }
+    fixIdsAndKeys(item, session);
+    return item.getKey();
   }
 
   @Override
-  protected ActiveRuleDto doGetByKey(ActiveRuleKey key, DbSession session) {
-    QualityProfileDto qDto = qDao.selectByNameAndLanguage(key.qProfile().name(), key.qProfile().lang(), session);
-    RuleDto ruleDto = ruleDao.selectByKey(key.ruleKey());
-    return this.selectByProfileAndRule(qDto.getId(), ruleDto.getId(), session);
+  public Iterable<ActiveRuleKey> keysOfRowsUpdatedAfter(long timestamp, DbSession session) {
+    throw new UnsupportedOperationException("Need to implement ActiveRuleDto.doGetByKey() method");
   }
 
   @Override
-  protected ActiveRuleDto doInsert(ActiveRuleDto item, DbSession session) {
-    getMapper(session).insert(item);
-    return setActiveRuleKey(item, session);
+  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);
+    return mapper(session).selectByProfileAndRule(qDto.getId(), ruleDto.getId());
   }
 
   @Override
-  protected ActiveRuleDto doUpdate(ActiveRuleDto item, DbSession session) {
-    getMapper(session).update(item);
-    return setActiveRuleKey(item, session);
+  protected ActiveRuleDto doInsert(ActiveRuleDto item, DbSession session) {
+    Preconditions.checkArgument(item.getProfileId() != null, "Quality profile is not persisted (missing id)");
+    Preconditions.checkArgument(item.getRulId() != null, "Rule is not persisted (missing id)");
+    Preconditions.checkArgument(item.getId() == null, "ActiveRule is already persisted");
+    mapper(session).insert(item);
+    return item;
+  }
+
+  private void fixIdsAndKeys(ActiveRuleDto item, DbSession session) {
+    if (item.getKey() != null) {
+      if (item.getProfileId() == null) {
+        QualityProfileDto profile = profileDao.selectByNameAndLanguage(item.getKey().qProfile().name(), item.getKey().qProfile().lang(), session);
+        // TODO fail if profile not found
+        item.setProfileId(profile.getId());
+      }
+      if (item.getRulId() == null) {
+        RuleDto rule = ruleDao.getByKey(item.getKey().ruleKey(), session);
+        // TODO fail if rule not found
+        item.setRuleId(rule.getId());
+      }
+    } else {
+      // key is null
+      if (item.getProfileId() != null && item.getRulId() != null) {
+        QualityProfileDto profile = profileDao.selectById(item.getProfileId(), session);
+        RuleDto rule = ruleDao.getById(item.getRulId(), session);
+        RuleKey ruleKey = ruleDao.getKey(rule, session);
+        item.setKey(ActiveRuleKey.of(QualityProfileKey.of(profile.getName(), profile.getLanguage()), ruleKey));
+      }
+    }
   }
 
   @Override
-  protected void doDelete(ActiveRuleDto item, DbSession session) {
-    getMapper(session).delete(item.getId());
+  protected ActiveRuleDto doUpdate(ActiveRuleDto item, DbSession session) {
+    Preconditions.checkArgument(item.getProfileId() != null, "Quality profile is not persisted (missing id)");
+    Preconditions.checkArgument(item.getRulId() != null, "Rule is not persisted (missing id)");
+    Preconditions.checkArgument(item.getId() != null, "ActiveRule is not persisted");
+    mapper(session).update(item);
+    return item;
   }
 
   @Override
   protected void doDeleteByKey(ActiveRuleKey key, DbSession session) {
-    throw new NotYetImplementedException("Need to implement ActiveRuleDto.doDeleteByKey() method");
-  }
-
-  /** Helper methods to get the RuleKey and QualityProfileKey -- Temporary */
-
-  private ActiveRuleDto setActiveRuleKey(ActiveRuleDto dto, DbSession session){
-    RuleDto ruleDto = ruleDao.selectById(dto.getRulId(), session);
-    QualityProfileDto qDto = qDao.selectById(dto.getProfileId(), session);
-    if(qDto != null && ruleDto != null) {
-      dto.setKey(QualityProfileKey.of(qDto.getName(), qDto.getLanguage()), ruleDto.getKey());
-    } else {
-      session.close();
-      throw new IllegalStateException("ActiveRule needs to have a valid Key!!!");
-    }
-    return dto;
-  }
-
-  private List<ActiveRuleDto> setActiveRuleKey(List<ActiveRuleDto> dtos, DbSession session){
-    for(ActiveRuleDto dto:dtos) {
-      setActiveRuleKey(dto, session);
-    }
-    return dtos;
-  }
-
-
-  public void delete(int activeRuleId, DbSession session) {
-    session.getMapper(ActiveRuleMapper.class).delete(activeRuleId);
-  }
-
-  public void delete(int activeRuleId) {
-    DbSession session = mybatis.openSession(false);
-    try {
-      delete(activeRuleId, session);
-      session.commit();
-    } finally {
-      MyBatis.closeQuietly(session);
-    }
-  }
-
-  public void deleteFromRule(int ruleId, DbSession session) {
-    session.getMapper(ActiveRuleMapper.class).deleteFromRule(ruleId);
-  }
-
-  public void deleteFromRule(int ruleId) {
-    DbSession session = mybatis.openSession(false);
-    try {
-      deleteFromRule(ruleId, session);
-      session.commit();
-    } finally {
-      MyBatis.closeQuietly(session);
-    }
-  }
-
-  public void deleteFromProfile(int profileId, DbSession session) {
-    session.getMapper(ActiveRuleMapper.class).deleteFromProfile(profileId);
-  }
-
-  public void deleteFromProfile(int profileId) {
-    DbSession session = mybatis.openSession(false);
-    try {
-      deleteFromProfile(profileId, session);
-      session.commit();
-    } finally {
-      MyBatis.closeQuietly(session);
-    }
-  }
-
-  public List<ActiveRuleDto> selectByIds(List<Integer> ids) {
-    DbSession session = mybatis.openSession(false);
-    try {
-      return selectByIds(ids, session);
-    } finally {
-      MyBatis.closeQuietly(session);
-    }
-  }
-
-  public List<ActiveRuleDto> selectByIds(Collection<Integer> ids, DbSession session) {
-    if (ids.isEmpty()) {
-      return Collections.emptyList();
-    }
-    List<ActiveRuleDto> dtosList = newArrayList();
-    List<List<Integer>> idsPartitionList = Lists.partition(newArrayList(ids), 1000);
-    for (List<Integer> idsPartition : idsPartitionList) {
-      List<ActiveRuleDto> dtos = session.selectList("org.sonar.core.qualityprofile.db.ActiveRuleMapper.selectByIds", newArrayList(idsPartition));
-      dtosList.addAll(dtos);
-    }
-    return setActiveRuleKey(dtosList, session);
-  }
-
-  public List<ActiveRuleDto> selectAll() {
-    DbSession session = mybatis.openSession(false);
-    try {
-      return selectAll(session);
-    } finally {
-      MyBatis.closeQuietly(session);
-    }
-  }
-
-  public List<ActiveRuleDto> selectAll(DbSession session) {
-    return setActiveRuleKey(session.getMapper(ActiveRuleMapper.class).selectAll(), session);
-  }
-
-  public List<ActiveRuleDto> selectByRuleId(int ruleId) {
-    DbSession session = mybatis.openSession(false);
-    try {
-      return selectByRuleId(ruleId, session);
-    } finally {
-      MyBatis.closeQuietly(session);
-    }
-  }
-
-  public List<ActiveRuleDto> selectByRuleId(int ruleId, DbSession session) {
-    return setActiveRuleKey(session.getMapper(ActiveRuleMapper.class).selectByRuleId(ruleId), session);
-  }
-
-  public List<ActiveRuleDto> selectByProfileId(int profileId) {
-    DbSession session = mybatis.openSession(false);
-    try {
-      return selectByProfileId(profileId, session);
-    } finally {
-      MyBatis.closeQuietly(session);
-    }
-  }
-
-  public List<ActiveRuleDto> selectByProfileId(int profileId, DbSession session) {
-    return setActiveRuleKey(session.getMapper(ActiveRuleMapper.class).selectByProfileId(profileId), session);
-  }
-
-
-  @CheckForNull
-  public ActiveRuleDto selectById(int id) {
-    DbSession session = mybatis.openSession(false);
-    try {
-      return selectById(id, session);
-    } finally {
-      MyBatis.closeQuietly(session);
-    }
-  }
-
-  @CheckForNull
-  public ActiveRuleDto selectById(int id, DbSession session) {
-    return setActiveRuleKey(session.getMapper(ActiveRuleMapper.class).selectById(id), session);
-  }
-
-  @CheckForNull
-  public ActiveRuleDto selectByProfileAndRule(int profileId, int ruleId) {
-    DbSession session = mybatis.openSession(false);
-    try {
-      return selectByProfileAndRule(profileId, ruleId, session);
-    } finally {
-      MyBatis.closeQuietly(session);
-    }
-  }
-
-  @CheckForNull
-  public ActiveRuleDto selectByProfileAndRule(int profileId, int ruleId, DbSession session) {
-    return setActiveRuleKey(session.getMapper(ActiveRuleMapper.class).selectByProfileAndRule(profileId, ruleId), session);
-  }
-
-  public void insert(ActiveRuleParamDto param, DbSession session) {
-    session.getMapper(ActiveRuleMapper.class).insertParameter(param);
-    ActiveRuleDto dto = this.selectById(param.getActiveRuleId(), session);
-    if(dto != null) {
-      session.enqueue(new EmbeddedIndexAction<ActiveRuleKey>(this.getIndexType(),
-        IndexAction.Method.UPDATE, param, dto.getKey()));
-    }
-  }
-
-  public void insert(ActiveRuleParamDto dto) {
-    DbSession session = mybatis.openSession(false);
-    try {
-      insert(dto, session);
-      session.commit();
-    } finally {
-      MyBatis.closeQuietly(session);
-    }
-  }
-
-  public void update(ActiveRuleParamDto param, DbSession session) {
-    session.getMapper(ActiveRuleMapper.class).updateParameter(param);
-    ActiveRuleDto dto = this.selectById(param.getActiveRuleId(), session);
-    if(dto != null) {
-      session.enqueue(new EmbeddedIndexAction<ActiveRuleKey>(this.getIndexType(),
-        IndexAction.Method.UPDATE, param, dto.getKey()));
-    }
-  }
-
-  public void update(ActiveRuleParamDto dto) {
-    DbSession session = mybatis.openSession(false);
-    try {
-      update(dto, session);
-      session.commit();
-    } finally {
-      MyBatis.closeQuietly(session);
-    }
+    throw new UnsupportedOperationException("TODO");
   }
 
-
-  public void deleteParameter(int activeRuleParamId, DbSession session) {
-    session.getMapper(ActiveRuleMapper.class).deleteParameter(activeRuleParamId);
+  public List<ActiveRuleParamDto> findParamsByActiveRule(ActiveRuleDto dto, DbSession session) {
+    Preconditions.checkArgument(dto.getId()!=null, "ActiveRule is not persisted");
+    return mapper(session).selectParamsByActiveRuleId(dto.getId());
   }
 
-  public void deleteParameter(int activeRuleParamId) {
-    DbSession session = mybatis.openSession(false);
-    try {
-      deleteParameter(activeRuleParamId, session);
-      session.commit();
-    } finally {
-      MyBatis.closeQuietly(session);
-    }
-  }
+  public ActiveRuleParamDto addParam(ActiveRuleDto activeRule, ActiveRuleParamDto paramDto, DbSession session) {
+    Preconditions.checkState(activeRule.getId() != null, "ActiveRule id is not yet persisted");
+    Preconditions.checkState(paramDto.getId() == null, "ActiveRuleParam is already persisted");
+    Preconditions.checkState(paramDto.getRulesParameterId() != null, "Rule param is not persisted");
 
-  public void deleteParameters(int activeRuleId, DbSession session) {
-    session.getMapper(ActiveRuleMapper.class).deleteParameters(activeRuleId);
+    paramDto.setActiveRuleId(activeRule.getId());
+    mapper(session).insertParameter(paramDto);
+    session.enqueue(new EmbeddedIndexAction<ActiveRuleKey>(this.getIndexType(), IndexAction.Method.INSERT, paramDto, activeRule.getKey()));
+    return paramDto;
   }
 
-  public void deleteParameters(int activeRuleId) {
-    DbSession session = mybatis.openSession(false);
-    try {
-      deleteParameters(activeRuleId, session);
-      session.commit();
-    } finally {
-      MyBatis.closeQuietly(session);
-    }
-  }
-
-  public void deleteParametersWithParamId(int id, DbSession session) {
-    session.getMapper(ActiveRuleMapper.class).deleteParametersWithParamId(id);
-  }
-
-  public void deleteParametersFromProfile(int profileId) {
-    DbSession session = mybatis.openSession(false);
-    try {
-      deleteParametersFromProfile(profileId, session);
-      session.commit();
-    } finally {
-      MyBatis.closeQuietly(session);
-    }
-  }
-
-  public void deleteParametersFromProfile(int profileId, DbSession session) {
-    session.getMapper(ActiveRuleMapper.class).deleteParametersFromProfile(profileId);
-  }
-
-  public ActiveRuleParamDto selectParamById(Integer activeRuleParamId) {
-    DbSession session = mybatis.openSession(false);
-    try {
-      return session.getMapper(ActiveRuleMapper.class).selectParamById(activeRuleParamId);
-    } finally {
-      MyBatis.closeQuietly(session);
-    }
-  }
-
-  public ActiveRuleParamDto selectParamByActiveRuleAndKey(int activeRuleId, String key) {
-    DbSession session = mybatis.openSession(false);
-    try {
-      return selectParamByActiveRuleAndKey(activeRuleId, key, session);
-    } finally {
-      MyBatis.closeQuietly(session);
-    }
-  }
-
-  public ActiveRuleParamDto selectParamByActiveRuleAndKey(int activeRuleId, String key, DbSession session) {
-    return session.getMapper(ActiveRuleMapper.class).selectParamByActiveRuleAndKey(activeRuleId, key);
-  }
-
-  public List<ActiveRuleParamDto> selectParamsByActiveRuleId(int activeRuleId) {
-    DbSession session = mybatis.openSession(false);
-    try {
-      return selectParamsByActiveRuleId(activeRuleId, session);
-    } finally {
-      MyBatis.closeQuietly(session);
-    }
-  }
-
-  public List<ActiveRuleParamDto> selectParamsByActiveRuleId(int activeRuleId, DbSession session) {
-    return session.getMapper(ActiveRuleMapper.class).selectParamsByActiveRuleId(activeRuleId);
-  }
-
-  public List<ActiveRuleParamDto> selectParamsByActiveRuleIds(List<Integer> activeRuleIds) {
-    DbSession session = mybatis.openSession(false);
-    try {
-      return selectParamsByActiveRuleIds(activeRuleIds, session);
-    } finally {
-      MyBatis.closeQuietly(session);
-    }
-  }
-
-  public List<ActiveRuleParamDto> selectParamsByActiveRuleIds(Collection<Integer> activeRuleIds, DbSession session) {
-    if (activeRuleIds.isEmpty()) {
-      return Collections.emptyList();
-    }
-    List<ActiveRuleParamDto> dtosList = newArrayList();
-    List<List<Integer>> idsPartitionList = Lists.partition(newArrayList(activeRuleIds), 1000);
-    for (List<Integer> idsPartition : idsPartitionList) {
-      List<ActiveRuleParamDto> dtos = session.selectList("org.sonar.core.qualityprofile.db.ActiveRuleMapper.selectParamsByActiveRuleIds", newArrayList(idsPartition));
-      dtosList.addAll(dtos);
-    }
-    return dtosList;
-  }
-
-  public List<ActiveRuleParamDto> selectAllParams() {
-    DbSession session = mybatis.openSession(false);
-    try {
-      return selectAllParams(session);
-    } finally {
-      MyBatis.closeQuietly(session);
-    }
-  }
-
-  public List<ActiveRuleParamDto> selectAllParams(DbSession session) {
-    return session.getMapper(ActiveRuleMapper.class).selectAllParams();
-  }
-
-  public List<ActiveRuleParamDto> selectParamsByProfileId(int profileId) {
-    DbSession session = mybatis.openSession(false);
-    try {
-      return session.getMapper(ActiveRuleMapper.class).selectParamsByProfileId(profileId);
-    } finally {
-      MyBatis.closeQuietly(session);
-    }
+  public List<ActiveRuleDto> findByRule(RuleDto rule, DbSession dbSession) {
+    Preconditions.checkArgument(rule.getId()!=null, "Rule is not persisted");
+    return mapper(dbSession).selectByRuleId(rule.getId());
   }
 }
diff --git a/sonar-server/src/main/java/org/sonar/server/rule2/ActiveRuleNormalizer.java b/sonar-server/src/main/java/org/sonar/server/rule2/ActiveRuleNormalizer.java
index 1768262bd76..93849fecd10 100644
--- a/sonar-server/src/main/java/org/sonar/server/rule2/ActiveRuleNormalizer.java
+++ b/sonar-server/src/main/java/org/sonar/server/rule2/ActiveRuleNormalizer.java
@@ -21,6 +21,8 @@ package org.sonar.server.rule2;
 
 import org.elasticsearch.action.update.UpdateRequest;
 import org.elasticsearch.common.xcontent.XContentBuilder;
+import org.sonar.core.persistence.DbSession;
+import org.sonar.core.persistence.MyBatis;
 import org.sonar.core.qualityprofile.db.ActiveRuleDto;
 import org.sonar.core.qualityprofile.db.ActiveRuleKey;
 import org.sonar.core.qualityprofile.db.ActiveRuleParamDto;
@@ -30,7 +32,7 @@ import static org.elasticsearch.common.xcontent.XContentFactory.jsonBuilder;
 
 public class ActiveRuleNormalizer extends BaseNormalizer<ActiveRuleDto, ActiveRuleKey> {
 
-  ActiveRuleDao activeRuleDao;
+  private final ActiveRuleDao activeRuleDao;
 
   public static enum ActiveRuleField {
     OVERRIDE("override"),
@@ -76,13 +78,19 @@ public class ActiveRuleNormalizer extends BaseNormalizer<ActiveRuleDto, ActiveRu
     }
   }
 
-  public ActiveRuleNormalizer(ActiveRuleDao activeRuleDao) {
+  public ActiveRuleNormalizer(MyBatis mybatis, ActiveRuleDao activeRuleDao) {
+    super(mybatis);
     this.activeRuleDao = activeRuleDao;
   }
 
   @Override
   public UpdateRequest normalize(ActiveRuleKey key) {
-    return normalize(activeRuleDao.getByKey(key));
+    DbSession dbSession = getMyBatis().openSession(false);
+    try {
+      return normalize(activeRuleDao.getByKey(key, dbSession));
+    } finally {
+      dbSession.close();
+    }
   }
 
   public UpdateRequest normalize(ActiveRuleParamDto param, ActiveRuleKey key) {
diff --git a/sonar-server/src/main/java/org/sonar/server/rule2/RuleDao.java b/sonar-server/src/main/java/org/sonar/server/rule2/RuleDao.java
index 2c57f127c76..b7cecd6116e 100644
--- a/sonar-server/src/main/java/org/sonar/server/rule2/RuleDao.java
+++ b/sonar-server/src/main/java/org/sonar/server/rule2/RuleDao.java
@@ -19,6 +19,7 @@
  */
 package org.sonar.server.rule2;
 
+import com.google.common.base.Preconditions;
 import com.google.common.collect.Lists;
 import org.apache.ibatis.session.ResultContext;
 import org.apache.ibatis.session.ResultHandler;
@@ -26,13 +27,10 @@ import org.sonar.api.BatchComponent;
 import org.sonar.api.ServerComponent;
 import org.sonar.api.rule.RuleKey;
 import org.sonar.core.persistence.DbSession;
-import org.sonar.core.persistence.MyBatis;
 import org.sonar.core.rule.RuleDto;
 import org.sonar.core.rule.RuleMapper;
 import org.sonar.core.rule.RuleParamDto;
-import org.sonar.core.rule.RuleRuleTagDto;
 import org.sonar.server.db.BaseDao;
-import org.sonar.server.search.DtoIndexAction;
 import org.sonar.server.search.EmbeddedIndexAction;
 import org.sonar.server.search.IndexAction;
 
@@ -42,318 +40,80 @@ import java.util.Collection;
 import java.util.List;
 import java.util.Map;
 
-import static com.google.common.collect.Lists.newArrayList;
+public class RuleDao extends BaseDao<RuleMapper, RuleDto, RuleKey> implements BatchComponent, ServerComponent {
 
-public class RuleDao extends BaseDao<RuleMapper, RuleDto, RuleKey>
-  implements BatchComponent, ServerComponent {
-
-  public RuleDao(MyBatis mybatis) {
-    super(new RuleIndexDefinition(), RuleMapper.class, mybatis);
+  public RuleDao() {
+    super(new RuleIndexDefinition(), RuleMapper.class);
   }
 
   @CheckForNull
-  protected RuleDto doGetByKey(RuleKey key, DbSession session) {
-    return getMapper(session).selectByKey(key);
+  @Override
+  public RuleDto doGetByKey(RuleKey key, DbSession session) {
+    return mapper(session).selectByKey(key);
   }
 
   @Override
   protected RuleDto doInsert(RuleDto item, DbSession session) {
-    getMapper(session).insert(item);
+    mapper(session).insert(item);
     return item;
   }
 
   @Override
   protected RuleDto doUpdate(RuleDto item, DbSession session) {
-    getMapper(session).update(item);
+    mapper(session).update(item);
     return item;
   }
 
   @Override
-  protected void doDelete(RuleDto item, DbSession session) {
-    throw new UnsupportedOperationException("Rules cannot be deleted");
-  }
-
-  @Override
   protected void doDeleteByKey(RuleKey key, DbSession session) {
     throw new UnsupportedOperationException("Rules cannot be deleted");
   }
 
-  public List<RuleDto> selectAll() {
-    DbSession session = mybatis.openSession(false);
-    try {
-      return selectAll(session);
-    } finally {
-      MyBatis.closeQuietly(session);
-    }
-  }
-
-  public List<RuleDto> selectAll(DbSession session) {
-    return getMapper(session).selectAll();
-  }
-
-  public List<RuleDto> selectEnablesAndNonManual() {
-    DbSession session = mybatis.openSession(false);
-    try {
-      return selectEnablesAndNonManual(session);
-    } finally {
-      MyBatis.closeQuietly(session);
-    }
-  }
-
-  public List<RuleDto> selectEnablesAndNonManual(DbSession session) {
-    return getMapper(session).selectEnablesAndNonManual();
-  }
-
-  public List<RuleDto> selectNonManual(DbSession session) {
-    return getMapper(session).selectNonManual();
-  }
-
-  public List<RuleDto> selectBySubCharacteristicId(Integer characteristicOrSubCharacteristicId) {
-    DbSession session = mybatis.openSession(false);
-    try {
-      return selectBySubCharacteristicId(characteristicOrSubCharacteristicId, session);
-    } finally {
-      MyBatis.closeQuietly(session);
-    }
-  }
-
-  /**
-   * Return all rules (even the REMOVED ones) linked on to a sub characteristic
-   */
-  public List<RuleDto> selectBySubCharacteristicId(Integer subCharacteristicId, DbSession session) {
-    return getMapper(session).selectBySubCharacteristicId(subCharacteristicId);
-  }
-
-  @CheckForNull
-  public RuleDto selectById(Integer id, DbSession session) {
-    return getMapper(session).selectById(id);
-  }
-
-  @CheckForNull
-  public RuleDto selectById(Integer id) {
-    DbSession session = mybatis.openSession(false);
-    try {
-      return selectById(id, session);
-    } finally {
-      MyBatis.closeQuietly(session);
-    }
-  }
-
-  @CheckForNull
-  public RuleDto selectByKey(RuleKey ruleKey, DbSession session) {
-    return getMapper(session).selectByKey(ruleKey);
-  }
-
-
-  @CheckForNull
-  public RuleDto selectByKey(RuleKey ruleKey) {
-    DbSession session = mybatis.openSession(false);
-    try {
-      return selectByKey(ruleKey, session);
-    } finally {
-      MyBatis.closeQuietly(session);
+  @Override
+  public RuleKey getKey(RuleDto item, DbSession session) {
+    if (item.getKey() != null) {
+      return item.getKey();
     }
+    return RuleKey.of(item.getRepositoryKey(), item.getRuleKey());
   }
 
   @CheckForNull
-  public RuleDto selectByName(String name) {
-    DbSession session = mybatis.openSession(false);
-    try {
-      return getMapper(session).selectByName(name);
-    } finally {
-      MyBatis.closeQuietly(session);
-    }
+  @Deprecated
+  public RuleDto getById(int id, DbSession session) {
+    return mapper(session).selectById(id);
   }
 
-  public void insert(Collection<RuleDto> rules) {
-    DbSession session = mybatis.openSession(true);
-    try {
-      for (RuleDto rule : rules) {
-        session.enqueue(new DtoIndexAction<RuleDto>(this.getIndexType(),
-          IndexAction.Method.INSERT, rule));
-        getMapper(session).batchInsert(rule);
+  @Override
+  public Collection<RuleKey> keysOfRowsUpdatedAfter(long timestamp, DbSession session) {
+    final List<RuleKey> keys = Lists.newArrayList();
+    session.select("selectKeysOfRulesUpdatedSince", new Timestamp(timestamp), new ResultHandler() {
+      @Override
+      public void handleResult(ResultContext context) {
+        Map<String, String> map = (Map) context.getResultObject();
+        keys.add(RuleKey.of(map.get("repo"), map.get("rule")));
       }
-      session.commit();
-    } finally {
-      MyBatis.closeQuietly(session);
-    }
-  }
-
-  // ******************************
-  // Methods for Rule Parameters
-  // ******************************
-
-  public List<RuleParamDto> selectParameters() {
-    DbSession session = mybatis.openSession(false);
-    try {
-      return selectParameters(session);
-    } finally {
-      MyBatis.closeQuietly(session);
-    }
-  }
+    });
+    return keys;
 
-  public List<RuleParamDto> selectParameters(DbSession session) {
-    return getMapper(session).selectAllParams();
   }
 
-  public List<RuleParamDto> selectParametersByRuleId(Integer ruleId) {
-    DbSession session = mybatis.openSession(false);
-    try {
-      return selectParametersByRuleId(ruleId, session);
-    } finally {
-      MyBatis.closeQuietly(session);
-    }
-  }
-
-  public List<RuleParamDto> selectParametersByRuleId(Integer ruleId, DbSession session) {
-    return selectParametersByRuleIds(newArrayList(ruleId));
-  }
-
-  public List<RuleParamDto> selectParametersByRuleIds(List<Integer> ruleIds) {
-    DbSession session = mybatis.openSession(false);
-    try {
-      return selectParametersByRuleIds(ruleIds, session);
-    } finally {
-      MyBatis.closeQuietly(session);
-    }
-  }
-
-  public List<RuleParamDto> selectParametersByRuleIds(List<Integer> ruleIds, DbSession session) {
-    List<RuleParamDto> dtos = newArrayList();
-    List<List<Integer>> partitionList = Lists.partition(newArrayList(ruleIds), 1000);
-    for (List<Integer> partition : partitionList) {
-      dtos.addAll(getMapper(session).selectParamsByRuleIds(partition));
-    }
-    return dtos;
-  }
-
-  public void insert(RuleParamDto param, DbSession session) {
-    getMapper(session).insertParameter(param);
-    RuleDto dto = this.selectById(param.getRuleId(), session);
-    if(dto != null){
-      session.enqueue(new EmbeddedIndexAction<RuleKey>(this.getIndexType(),
-        IndexAction.Method.INSERT, param,
-        dto.getKey()));
-    }
-  }
-
-  public void insert(RuleParamDto param) {
-    DbSession session = mybatis.openSession(false);
-    try {
-      insert(param, session);
-      session.commit();
-    } finally {
-      MyBatis.closeQuietly(session);
-    }
-  }
-
-  public void update(RuleParamDto param, DbSession session) {
-    getMapper(session).updateParameter(param);
-    RuleDto dto = this.selectById(param.getRuleId(), session);
-    if(dto != null) {
-      session.enqueue(new EmbeddedIndexAction<RuleKey>(this.getIndexType(),
-        IndexAction.Method.UPDATE, param,
-        dto.getKey()));
-    }
-  }
-
-  public void update(RuleParamDto param) {
-    DbSession session = mybatis.openSession(false);
-    try {
-      update(param, session);
-      session.commit();
-    } finally {
-      MyBatis.closeQuietly(session);
-    }
-  }
-
-  @CheckForNull
-  public RuleParamDto selectParamByRuleAndKey(Integer ruleId, String key, DbSession session) {
-    return getMapper(session).selectParamByRuleAndKey(ruleId, key);
-  }
-
-  // ***************************
-  // Methods for Rule Tags
-  // ***************************
-
-  public void insert(RuleRuleTagDto newTag, DbSession session) {
-    getMapper(session).insertTag(newTag);
-    session.enqueue(new EmbeddedIndexAction<RuleKey>(this.getIndexType(),
-      IndexAction.Method.INSERT, newTag,
-      this.selectById(newTag.getRuleId(), session).getKey()));
-  }
-
-  public void deleteParam(RuleParamDto persistedParam, DbSession session) {
-    getMapper(session).deleteParameter(persistedParam.getId());
-    session.enqueue(new EmbeddedIndexAction<RuleKey>(this.getIndexType(),
-      IndexAction.Method.DELETE, persistedParam,
-      this.selectById(persistedParam.getRuleId(), session).getKey()));
-  }
-
-  public void deleteTag(RuleRuleTagDto tagToDelete, DbSession session) {
-    getMapper(session).deleteTag(tagToDelete.getId().intValue());
-    session.enqueue(new EmbeddedIndexAction<RuleKey>(this.getIndexType(),
-      IndexAction.Method.DELETE, tagToDelete,
-      this.selectById(tagToDelete.getRuleId(), session).getKey()));
-  }
-
-  public void update(RuleRuleTagDto existingTag, DbSession session) {
-    getMapper(session).updateTag(existingTag);
-    session.enqueue(new EmbeddedIndexAction<RuleKey>(this.getIndexType(),
-      IndexAction.Method.UPDATE, existingTag,
-      this.selectById(existingTag.getRuleId(), session).getKey()));
+  public List<RuleParamDto> findRuleParamsByRuleKey(RuleKey ruleKey, DbSession dbSession) {
+    return mapper(dbSession).selectParamsByRuleKey(ruleKey);
   }
 
-  public List<RuleRuleTagDto> selectTags(DbSession session) {
-    return getMapper(session).selectAllTags();
-  }
-
-  public List<RuleRuleTagDto> selectTagsByRuleId(Integer ruleId) {
-    DbSession session = mybatis.openSession(false);
-    try {
-      return selectTagsByRuleIds(ruleId, session);
-    } finally {
-      MyBatis.closeQuietly(session);
-    }
-  }
 
-  public List<RuleRuleTagDto> selectTagsByRuleIds(Integer ruleId, DbSession session) {
-    return selectTagsByRuleIds(newArrayList(ruleId), session);
-  }
 
-  public List<RuleRuleTagDto> selectTagsByRuleIds(List<Integer> ruleIds) {
-    DbSession session = mybatis.openSession(false);
-    try {
-      return selectTagsByRuleIds(ruleIds, session);
-    } finally {
-      MyBatis.closeQuietly(session);
-    }
+  public void addRuleParam(RuleDto rule, RuleParamDto paramDto, DbSession session) {
+    Preconditions.checkNotNull(rule.getId(), "Rule id must be set");
+    paramDto.setRuleId(rule.getId());
+    mapper(session).insertParameter(paramDto);
+    session.enqueue(new EmbeddedIndexAction<RuleKey>(this.getIndexType(), IndexAction.Method.INSERT, paramDto, rule.getKey()));
   }
 
-  public List<RuleRuleTagDto> selectTagsByRuleIds(List<Integer> ruleIds, DbSession session) {
-    List<RuleRuleTagDto> dtos = newArrayList();
-    List<List<Integer>> partitionList = Lists.partition(newArrayList(ruleIds), 1000);
-    for (List<Integer> partition : partitionList) {
-      dtos.addAll(getMapper(session).selectTagsByRuleIds(partition));
-    }
-    return dtos;
-  }
-
-  @Override
-  public Collection<RuleKey> keysOfRowsUpdatedAfter(long timestamp) {
-    DbSession session = mybatis.openSession(false);
-    try {
-      final List<RuleKey> keys = Lists.newArrayList();
-      session.select("selectKeysOfRulesUpdatedSince", new Timestamp(timestamp), new ResultHandler() {
-        @Override
-        public void handleResult(ResultContext context) {
-          Map<String, String> map = (Map) context.getResultObject();
-          keys.add(RuleKey.of(map.get("repo"), map.get("rule")));
-        }
-      });
-      return keys;
-    } finally {
-      MyBatis.closeQuietly(session);
-    }
+  public void updateRuleParam(RuleDto rule, RuleParamDto paramDto, DbSession session) {
+    Preconditions.checkNotNull(rule.getId(), "Rule id must be set");
+    paramDto.setRuleId(rule.getId());
+    mapper(session).updateParameter(paramDto);
+    session.enqueue(new EmbeddedIndexAction<RuleKey>(this.getIndexType(), IndexAction.Method.UPDATE, paramDto, rule.getKey()));
   }
 }
diff --git a/sonar-server/src/main/java/org/sonar/server/rule2/RuleNormalizer.java b/sonar-server/src/main/java/org/sonar/server/rule2/RuleNormalizer.java
index 5aa1ec9500a..65ccbe11153 100644
--- a/sonar-server/src/main/java/org/sonar/server/rule2/RuleNormalizer.java
+++ b/sonar-server/src/main/java/org/sonar/server/rule2/RuleNormalizer.java
@@ -23,6 +23,8 @@ import org.elasticsearch.action.update.UpdateRequest;
 import org.elasticsearch.common.xcontent.XContentBuilder;
 import org.sonar.api.rule.RuleKey;
 import org.sonar.check.Cardinality;
+import org.sonar.core.persistence.DbSession;
+import org.sonar.core.persistence.MyBatis;
 import org.sonar.core.rule.RuleDto;
 import org.sonar.core.rule.RuleParamDto;
 import org.sonar.core.rule.RuleRuleTagDto;
@@ -90,13 +92,19 @@ public class RuleNormalizer extends BaseNormalizer<RuleDto, RuleKey> {
     }
   }
 
-  public RuleNormalizer(RuleDao ruleDao) {
+  public RuleNormalizer(MyBatis myBatis, RuleDao ruleDao) {
+    super(myBatis);
     this.ruleDao = ruleDao;
   }
 
   @Override
   public UpdateRequest normalize(RuleKey key) {
-    return normalize(ruleDao.getByKey(key));
+    DbSession dbSession = getMyBatis().openSession(false);
+    try {
+      return normalize(ruleDao.getByKey(key, dbSession));
+    } finally {
+      dbSession.close();
+    }
   }
 
   @Override
diff --git a/sonar-server/src/main/java/org/sonar/server/rule2/RuleService.java b/sonar-server/src/main/java/org/sonar/server/rule2/RuleService.java
index 067d4de375b..84d4c1de835 100644
--- a/sonar-server/src/main/java/org/sonar/server/rule2/RuleService.java
+++ b/sonar-server/src/main/java/org/sonar/server/rule2/RuleService.java
@@ -22,6 +22,7 @@ package org.sonar.server.rule2;
 import org.sonar.api.ServerComponent;
 import org.sonar.api.rule.RuleKey;
 import org.sonar.core.rule.RuleDao;
+import org.sonar.server.search.Hit;
 import org.sonar.server.search.QueryOptions;
 import org.sonar.server.search.Result;
 
@@ -33,11 +34,9 @@ import java.util.List;
  */
 public class RuleService implements ServerComponent {
 
-  private RuleDao dao;
   private RuleIndex index;
 
-  public RuleService(RuleDao dao, RuleIndex index) {
-    this.dao = dao;
+  public RuleService(RuleIndex index) {
     this.index = index;
   }
 
@@ -68,7 +67,7 @@ public class RuleService implements ServerComponent {
     throw new UnsupportedOperationException("TODO");
   }
 
-  public RuleService refresh(){
+  public RuleService refresh() {
     this.index.refresh();
     return this;
   }
diff --git a/sonar-server/src/main/java/org/sonar/server/search/BaseNormalizer.java b/sonar-server/src/main/java/org/sonar/server/search/BaseNormalizer.java
index 12680137ec7..4b9329467b5 100644
--- a/sonar-server/src/main/java/org/sonar/server/search/BaseNormalizer.java
+++ b/sonar-server/src/main/java/org/sonar/server/search/BaseNormalizer.java
@@ -24,12 +24,23 @@ import org.elasticsearch.common.xcontent.XContentBuilder;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.sonar.core.db.Dto;
+import org.sonar.core.persistence.MyBatis;
 
 import java.io.IOException;
 import java.io.Serializable;
 
 public abstract class BaseNormalizer<E extends Dto<K>, K extends Serializable> {
 
+  private MyBatis myBatis;
+
+  protected BaseNormalizer(MyBatis mybatis) {
+    this.myBatis = mybatis;
+  }
+
+  protected MyBatis getMyBatis() {
+    return myBatis;
+  }
+
   public boolean canNormalize(Class<?> objectClass, Class<?> keyClass) {
     try {
       return this.getClass().getMethod("normalize", objectClass, keyClass) != null;
@@ -61,4 +72,40 @@ public abstract class BaseNormalizer<E extends Dto<K>, K extends Serializable> {
       LOG.error("Could not set {} to {} in ESDocument", field, value);
     }
   }
+
+
+//  protected void indexField(Fields field, Object dto, XContentBuilder document) {
+//    try {
+//      document.field(field.key(), field.method.invoke(dto));
+//    } catch (IllegalArgumentException e) {
+//      // TODO Auto-generated catch block
+//      e.printStackTrace();
+//    } catch (IOException e) {
+//      // TODO Auto-generated catch block
+//      e.printStackTrace();
+//    } catch (IllegalAccessException e) {
+//      // TODO Auto-generated catch block
+//      e.printStackTrace();
+//    } catch (InvocationTargetException e) {
+//      // TODO Auto-generated catch block
+//      e.printStackTrace();
+//    }
+//  }
+//
+//
+//
+//private static Method getReadMethod(String method){
+//  try {
+//    return RuleDto.class.getDeclaredMethod(method);
+//  } catch (SecurityException e) {
+//    // TODO Auto-generated catch block
+//    e.printStackTrace();
+//  } catch (NoSuchMethodException e) {
+//    // TODO Auto-generated catch block
+//    e.printStackTrace();
+//  }
+//  return null;
+//}
+
+
 }
diff --git a/sonar-server/src/main/java/org/sonar/server/search/IndexSynchronizer.java b/sonar-server/src/main/java/org/sonar/server/search/IndexSynchronizer.java
index 492eee5db67..0cdda8eb974 100644
--- a/sonar-server/src/main/java/org/sonar/server/search/IndexSynchronizer.java
+++ b/sonar-server/src/main/java/org/sonar/server/search/IndexSynchronizer.java
@@ -42,17 +42,17 @@ public class IndexSynchronizer<K extends Serializable> {
 
   public IndexSynchronizer<K> start() {
 
-    LOG.info("Starting synchronization thread for ", index.getClass().getSimpleName());
-
-    Long since = index.getLastSynchronization();
-    index.setLastSynchronization(System.currentTimeMillis());
-
-    for (K key : dao.keysOfRowsUpdatedAfter(since)) {
-      if (LOG.isTraceEnabled()) {
-        LOG.trace("Adding {} to workQueue for {}", key, index.getClass().getSimpleName());
-      }
-      workQueue.enqueue(new KeyIndexAction<K>(index.getIndexName(), IndexAction.Method.INSERT, key));
-    }
+//    LOG.info("Starting synchronization thread for ", index.getClass().getSimpleName());
+//
+//    Long since = index.getLastSynchronization();
+//    index.setLastSynchronization(System.currentTimeMillis());
+//
+//    for (K key : dao.keysOfRowsUpdatedAfter(since)) {
+//      if (LOG.isTraceEnabled()) {
+//        LOG.trace("Adding {} to workQueue for {}", key, index.getClass().getSimpleName());
+//      }
+//      workQueue.enqueue(new KeyIndexAction<K>(index.getIndexName(), IndexAction.Method.INSERT, key));
+//    }
 
     return this;
   }
diff --git a/sonar-server/src/test/java/org/sonar/server/qualityprofile/ws/QProfileRecreateBuiltInActionTest.java b/sonar-server/src/test/java/org/sonar/server/qualityprofile/ws/QProfileRecreateBuiltInActionTest.java
index 0c66654af1e..5426970eef9 100644
--- a/sonar-server/src/test/java/org/sonar/server/qualityprofile/ws/QProfileRecreateBuiltInActionTest.java
+++ b/sonar-server/src/test/java/org/sonar/server/qualityprofile/ws/QProfileRecreateBuiltInActionTest.java
@@ -25,9 +25,9 @@ import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
 import org.mockito.runners.MockitoJUnitRunner;
+import org.sonar.server.qualityprofile.ActiveRuleService;
 import org.sonar.server.qualityprofile.QProfileBackup;
 import org.sonar.server.qualityprofile.QProfileResult;
-import org.sonar.server.qualityprofile.RuleActivationService;
 import org.sonar.server.ws.WsTester;
 
 import static com.google.common.collect.Lists.newArrayList;
@@ -46,7 +46,7 @@ public class QProfileRecreateBuiltInActionTest {
   public void setUp() throws Exception {
     tester = new WsTester(new QProfilesWs(
       new QProfileRecreateBuiltInAction(qProfileBackup),
-      new ActivateRuleAction(mock(RuleActivationService.class))));
+      new ActivateRuleAction(mock(ActiveRuleService.class))));
   }
 
   @Test
diff --git a/sonar-server/src/test/java/org/sonar/server/qualityprofile/ws/QProfilesWsTest.java b/sonar-server/src/test/java/org/sonar/server/qualityprofile/ws/QProfilesWsTest.java
index d9d3feefd9b..8bb83cb9451 100644
--- a/sonar-server/src/test/java/org/sonar/server/qualityprofile/ws/QProfilesWsTest.java
+++ b/sonar-server/src/test/java/org/sonar/server/qualityprofile/ws/QProfilesWsTest.java
@@ -23,8 +23,8 @@ package org.sonar.server.qualityprofile.ws;
 import org.junit.Before;
 import org.junit.Test;
 import org.sonar.api.server.ws.WebService;
+import org.sonar.server.qualityprofile.ActiveRuleService;
 import org.sonar.server.qualityprofile.QProfileBackup;
-import org.sonar.server.qualityprofile.RuleActivationService;
 import org.sonar.server.ws.WsTester;
 
 import static org.fest.assertions.Assertions.assertThat;
@@ -36,7 +36,7 @@ public class QProfilesWsTest {
 
   @Before
   public void setUp() {
-    controller = new WsTester(new QProfilesWs(new QProfileRecreateBuiltInAction(mock(QProfileBackup.class)), new ActivateRuleAction(mock(RuleActivationService.class))))
+    controller = new WsTester(new QProfilesWs(new QProfileRecreateBuiltInAction(mock(QProfileBackup.class)), new ActivateRuleAction(mock(ActiveRuleService.class))))
       .controller("api/qualityprofiles");
   }
 
diff --git a/sonar-server/src/test/java/org/sonar/server/rule/RegisterRulesTest.java b/sonar-server/src/test/java/org/sonar/server/rule/RegisterRulesTest.java
index 9de7e55d24a..47c5d8aac16 100644
--- a/sonar-server/src/test/java/org/sonar/server/rule/RegisterRulesTest.java
+++ b/sonar-server/src/test/java/org/sonar/server/rule/RegisterRulesTest.java
@@ -38,7 +38,7 @@ import org.sonar.core.cluster.WorkQueue;
 import org.sonar.core.persistence.AbstractDaoTestCase;
 import org.sonar.core.persistence.MyBatis;
 import org.sonar.core.qualityprofile.db.ActiveRuleDao;
-import org.sonar.server.rule2.RuleDao;
+import org.sonar.core.rule.RuleDao;
 import org.sonar.core.rule.RuleDto;
 import org.sonar.core.rule.RuleTagDao;
 import org.sonar.core.rule.RuleTagDto;
diff --git a/sonar-server/src/test/java/org/sonar/server/rule2/ActiveRuleDaoTest.java b/sonar-server/src/test/java/org/sonar/server/rule2/ActiveRuleDaoTest.java
deleted file mode 100644
index 0224658cf6e..00000000000
--- a/sonar-server/src/test/java/org/sonar/server/rule2/ActiveRuleDaoTest.java
+++ /dev/null
@@ -1,380 +0,0 @@
-/*
- * 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.rule2;
-
-import com.google.common.base.Predicate;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Iterables;
-import org.junit.Before;
-import org.junit.Test;
-import org.sonar.api.rule.RuleKey;
-import org.sonar.api.rule.Severity;
-import org.sonar.api.utils.DateUtils;
-import org.sonar.core.persistence.AbstractDaoTestCase;
-import org.sonar.core.qualityprofile.db.ActiveRuleDto;
-import org.sonar.core.qualityprofile.db.ActiveRuleKey;
-import org.sonar.core.qualityprofile.db.ActiveRuleParamDto;
-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 java.util.List;
-
-import static org.fest.assertions.Assertions.assertThat;
-
-public class ActiveRuleDaoTest extends AbstractDaoTestCase {
-
-  ActiveRuleDao dao;
-  RuleDao ruleDao;
-  QualityProfileDao qDao;
-
-  @Before
-  public void createDao() {
-
-    ruleDao = new RuleDao(getMyBatis());
-    qDao = new QualityProfileDao(getMyBatis());
-    dao = new ActiveRuleDao(getMyBatis(), qDao, ruleDao);
-  }
-
-  @Test
-  public void insert() {
-    setupData("empty");
-
-    ActiveRuleDto dto = new ActiveRuleDto()
-      .setProfileId(1)
-      .setRuleId(10)
-      .setSeverity(Severity.MAJOR)
-      .setInheritance("INHERITED");
-
-    dao.insert(dto);
-
-    checkTables("insert", "active_rules");
-  }
-
-  @Test
-  public void update() {
-    setupData("shared");
-
-    ActiveRuleDto dto = new ActiveRuleDto()
-      .setId(1)
-      .setProfileId(1)
-      .setRuleId(10)
-      .setSeverity(Severity.BLOCKER)
-      .setInheritance(null)
-      .setNoteData("text");
-
-    dao.update(dto);
-
-    checkTables("update", "active_rules");
-  }
-
-  @Test
-  public void delete() {
-    setupData("shared");
-
-    dao.delete(1);
-
-    checkTables("delete", "active_rules");
-  }
-
-  @Test
-  public void delete_from_rule() {
-    setupData("shared");
-
-    dao.deleteFromRule(11);
-
-    checkTables("delete_from_rule", "active_rules");
-  }
-
-  @Test
-  public void delete_from_profile() {
-    setupData("shared");
-
-    dao.deleteFromProfile(2);
-
-    checkTables("delete_from_profile", "active_rules");
-  }
-
-  @Test
-  public void select_by_id() {
-    setupData("shared");
-
-    ActiveRuleDto result = dao.selectById(1);
-    assertThat(result.getId()).isEqualTo(1);
-    assertThat(result.getProfileId()).isEqualTo(1);
-    assertThat(result.getRulId()).isEqualTo(10);
-    assertThat(result.getSeverityString()).isEqualTo(Severity.MAJOR);
-    assertThat(result.getInheritance()).isEqualTo("INHERITED");
-    assertThat(result.getNoteData()).isEqualTo("some note");
-    assertThat(result.getNoteUserLogin()).isEqualTo("henry");
-    assertThat(result.getNoteCreatedAt()).isEqualTo(DateUtils.parseDate("2013-12-18"));
-    assertThat(result.getNoteUpdatedAt()).isEqualTo(DateUtils.parseDate("2013-12-18"));
-  }
-
-  @Test
-  public void select_by_ids() {
-    setupData("shared");
-
-    List<ActiveRuleDto> result = dao.selectByIds(ImmutableList.of(1));
-    assertThat(result).hasSize(1);
-    assertThat(result.get(0).getParentId()).isEqualTo(2);
-
-    assertThat(dao.selectByIds(ImmutableList.of(1, 2))).hasSize(2);
-  }
-
-  @Test
-  public void select_by_profile_and_rule() {
-    setupData("shared");
-
-    ActiveRuleDto result = dao.selectByProfileAndRule(1, 10);
-    assertThat(result.getId()).isEqualTo(1);
-    assertThat(result.getProfileId()).isEqualTo(1);
-    assertThat(result.getRulId()).isEqualTo(10);
-    assertThat(result.getSeverityString()).isEqualTo(Severity.MAJOR);
-    assertThat(result.getInheritance()).isEqualTo("INHERITED");
-    assertThat(result.getNoteData()).isEqualTo("some note");
-    assertThat(result.getNoteUserLogin()).isEqualTo("henry");
-    assertThat(result.getNoteCreatedAt()).isEqualTo(DateUtils.parseDate("2013-12-18"));
-    assertThat(result.getNoteUpdatedAt()).isEqualTo(DateUtils.parseDate("2013-12-18"));
-  }
-
-  @Test
-  public void select_by_rule() {
-    setupData("shared");
-
-    List<ActiveRuleDto> result = dao.selectByRuleId(10);
-    assertThat(result).hasSize(2);
-  }
-
-  @Test
-  public void select_by_profile() {
-    setupData("shared");
-
-    List<ActiveRuleDto> result = dao.selectByProfileId(2);
-    assertThat(result).hasSize(2);
-  }
-
-  @Test
-  public void select_all() {
-    setupData("shared");
-
-    List<ActiveRuleDto> result = dao.selectAll();
-    assertThat(result).hasSize(3);
-
-    assertThat(find(1, result).getParentId()).isEqualTo(2);
-    assertThat(find(2, result).getParentId()).isNull();
-  }
-
-  @Test
-  public void insert_parameter() {
-    setupData("insert_parameter");
-
-    ActiveRuleParamDto dto = new ActiveRuleParamDto()
-      .setActiveRuleId(1)
-      .setRulesParameterId(1)
-      .setKey("max")
-      .setValue("20");
-
-    dao.insert(dto);
-
-    checkTables("insert_parameter", "active_rule_parameters");
-  }
-
-  @Test
-  public void update_parameter() {
-    setupData("shared");
-
-    ActiveRuleParamDto dto = new ActiveRuleParamDto()
-      .setId(1)
-      .setActiveRuleId(2)
-      .setRulesParameterId(3)
-      .setKey("newMax")
-      .setValue("30");
-
-    dao.update(dto);
-
-    checkTables("update_parameter", "active_rule_parameters");
-  }
-
-  @Test
-  public void delete_parameters() {
-    setupData("shared");
-
-    dao.deleteParameters(1);
-
-    checkTables("delete_parameters", "active_rule_parameters");
-  }
-
-  @Test
-  public void delete_parameter() {
-    setupData("shared");
-
-    dao.deleteParameter(1);
-
-    checkTables("delete_parameter", "active_rule_parameters");
-  }
-
-  @Test
-  public void delete_parameters_from_profile_id() {
-    setupData("delete_parameters_from_profile_id");
-
-    dao.deleteParametersFromProfile(2);
-
-    checkTables("delete_parameters_from_profile_id", "active_rule_parameters");
-  }
-
-  @Test
-  public void select_param_by_id() {
-    setupData("shared");
-
-    ActiveRuleParamDto result = dao.selectParamById(1);
-    assertThat(result.getId()).isEqualTo(1);
-    assertThat(result.getActiveRuleId()).isEqualTo(1);
-    assertThat(result.getRulesParameterId()).isEqualTo(1);
-    assertThat(result.getKey()).isEqualTo("max");
-    assertThat(result.getValue()).isEqualTo("20");
-  }
-
-  @Test
-  public void select_params_by_active_rule_id() {
-    setupData("shared");
-
-    assertThat(dao.selectParamsByActiveRuleId(1)).hasSize(2);
-    assertThat(dao.selectParamsByActiveRuleId(2)).hasSize(1);
-  }
-
-  @Test
-  public void select_param_by_active_rule_and_key() {
-    setupData("shared");
-
-    ActiveRuleParamDto result = dao.selectParamByActiveRuleAndKey(1, "max");
-    assertThat(result.getId()).isEqualTo(1);
-    assertThat(result.getActiveRuleId()).isEqualTo(1);
-    assertThat(result.getRulesParameterId()).isEqualTo(1);
-    assertThat(result.getKey()).isEqualTo("max");
-    assertThat(result.getValue()).isEqualTo("20");
-  }
-
-  @Test
-  public void select_params_by_active_rule_ids() {
-    setupData("shared");
-
-    assertThat(dao.selectParamsByActiveRuleIds(ImmutableList.of(1))).hasSize(2);
-    assertThat(dao.selectParamsByActiveRuleIds(ImmutableList.of(2))).hasSize(1);
-    assertThat(dao.selectParamsByActiveRuleIds(ImmutableList.of(1, 2))).hasSize(3);
-  }
-
-  @Test
-  public void select_params_by_profile_id() {
-    setupData("shared");
-
-    assertThat(dao.selectParamsByProfileId(1)).hasSize(2);
-  }
-
-  @Test
-  public void select_all_params() {
-    setupData("shared");
-
-    assertThat(dao.selectAllParams()).hasSize(3);
-  }
-
-  @Test
-  public void get_activeRuleKey() {
-    QualityProfileDto qdto = new QualityProfileDto()
-      .setName("name")
-      .setLanguage("lang");
-    qDao.insert(qdto);
-
-    RuleDto rdto = new RuleDto()
-      .setRuleKey("ruleKey")
-      .setRepositoryKey("repositoryKey");
-    ruleDao.insert(rdto);
-
-    ActiveRuleDto dto = new ActiveRuleDto()
-      .setProfileId(qdto.getId())
-      .setRuleId(rdto.getId())
-      .setSeverity(Severity.BLOCKER)
-      .setInheritance(null)
-      .setNoteData("text");
-    dao.insert(dto);
-
-    assertThat(dto.getKey()).isNotNull();
-
-    assertThat(dto.getKey().ruleKey()).isNotNull();
-    assertThat(dto.getKey().ruleKey().rule()).isEqualTo(rdto.getRuleKey());
-    assertThat(dto.getKey().ruleKey().repository()).isEqualTo(rdto.getRepositoryKey());
-
-    assertThat(dto.getKey().qProfile()).isNotNull();
-    assertThat(dto.getKey().qProfile().name()).isEqualTo(qdto.getName());
-    assertThat(dto.getKey().qProfile().lang()).isEqualTo(qdto.getLanguage());
-  }
-
-  @Test
-  public void select_by_activeRuleKey() {
-    QualityProfileDto qdto = new QualityProfileDto()
-      .setName("name")
-      .setLanguage("lang");
-    qDao.insert(qdto);
-
-    RuleDto rdto = new RuleDto()
-      .setRuleKey("ruleKey")
-      .setRepositoryKey("repositoryKey");
-    ruleDao.insert(rdto);
-
-    ActiveRuleDto dto = new ActiveRuleDto()
-      .setProfileId(qdto.getId())
-      .setRuleId(rdto.getId())
-      .setSeverity(Severity.BLOCKER)
-      .setInheritance(null)
-      .setNoteData("text");
-    dao.insert(dto);
-
-
-    ActiveRuleDto newDto = dao.getByKey(ActiveRuleKey.of(QualityProfileKey.of(qdto.getName(), qdto.getLanguage()),
-      RuleKey.of(rdto.getRepositoryKey(), rdto.getRuleKey())));
-
-    assertThat(newDto.getKey()).isNotNull();
-
-    assertThat(newDto.getKey().ruleKey()).isNotNull();
-    assertThat(newDto.getKey().ruleKey().rule()).isEqualTo(rdto.getRuleKey());
-    assertThat(newDto.getKey().ruleKey().repository()).isEqualTo(rdto.getRepositoryKey());
-
-    assertThat(newDto.getKey().qProfile()).isNotNull();
-    assertThat(newDto.getKey().qProfile().name()).isEqualTo(qdto.getName());
-    assertThat(newDto.getKey().qProfile().lang()).isEqualTo(qdto.getLanguage());
-
-    assertThat(newDto.getSeverityString()).isEqualTo(dto.getSeverityString());
-    assertThat(newDto.getNoteData()).isEqualTo(dto.getNoteData());
-  }
-
-
-
-  private ActiveRuleDto find(final Integer id, List<ActiveRuleDto> dtos){
-    return Iterables.find(dtos, new Predicate<ActiveRuleDto>(){
-      @Override
-      public boolean apply(ActiveRuleDto input) {
-        return input.getId().equals(id);
-      }
-    });
-  }
-
-}
diff --git a/sonar-server/src/test/java/org/sonar/server/rule2/ActiveRuleIndexMediumTest.java b/sonar-server/src/test/java/org/sonar/server/rule2/ActiveRuleIndexMediumTest.java
index 5285ac3b022..537a21e178c 100644
--- a/sonar-server/src/test/java/org/sonar/server/rule2/ActiveRuleIndexMediumTest.java
+++ b/sonar-server/src/test/java/org/sonar/server/rule2/ActiveRuleIndexMediumTest.java
@@ -19,6 +19,7 @@
  */
 package org.sonar.server.rule2;
 
+import org.junit.After;
 import org.junit.Before;
 import org.junit.ClassRule;
 import org.junit.Test;
@@ -46,22 +47,26 @@ public class ActiveRuleIndexMediumTest {
   @ClassRule
   public static ServerTester tester = new ServerTester();
 
-  RuleDao dao = tester.get(RuleDao.class);
-
+  MyBatis myBatis = tester.get(MyBatis.class);
   QualityProfileDao qualityProfileDao = tester.get(QualityProfileDao.class);
-
+  ActiveRuleDao activeRuleDao = tester.get(ActiveRuleDao.class);
+  RuleDao dao = tester.get(RuleDao.class);
   RuleIndex index = tester.get(RuleIndex.class);
+  DbSession dbSession;
 
   @Before
-  public void clear_data_store() {
+  public void before() {
     tester.clearDataStores();
+    dbSession = myBatis.openSession(false);
+  }
+
+  @After
+  public void after() {
+    dbSession.close();
   }
 
   @Test
   public void insert_and_index_activeRules() throws InterruptedException {
-    DbSession dbSession = tester.get(MyBatis.class).openSession(false);
-    ActiveRuleDao activeRuleDao = tester.get(ActiveRuleDao.class);
-
     QualityProfileDto profileDto = new QualityProfileDto()
       .setName("myprofile")
       .setLanguage("java");
@@ -71,21 +76,16 @@ public class ActiveRuleIndexMediumTest {
     RuleKey ruleKey = RuleKey.of("javascript", "S001");
     RuleDto ruleDto = newRuleDto(ruleKey);
     dao.insert(ruleDto, dbSession);
-    dbSession.commit();
 
-    ActiveRuleDto activeRule = new ActiveRuleDto()
+    ActiveRuleDto activeRule = ActiveRuleDto.createFor(profileDto, ruleDto)
       .setInheritance("inherited")
-      .setProfileId(profileDto.getId())
-      .setRuleId(ruleDto.getId())
       .setSeverity(Severity.BLOCKER);
 
     activeRuleDao.insert(activeRule, dbSession);
     dbSession.commit();
 
-    dbSession.close();
-
     // verify that activeRules are persisted in db
-    List<ActiveRuleDto> persistedDtos = activeRuleDao.selectByRuleId(ruleDto.getId());
+    List<ActiveRuleDto> persistedDtos = activeRuleDao.findByRule(ruleDto, dbSession);
     assertThat(persistedDtos).hasSize(1);
 
     // verify that activeRules are indexed in es
@@ -102,9 +102,6 @@ public class ActiveRuleIndexMediumTest {
 
   @Test
   public void insert_and_index_activeRuleParams() throws InterruptedException {
-    DbSession dbSession = tester.get(MyBatis.class).openSession(false);
-    ActiveRuleDao activeRuleDao = tester.get(ActiveRuleDao.class);
-
     QualityProfileDto profileDto = new QualityProfileDto()
       .setName("myprofile")
       .setLanguage("java");
@@ -116,44 +113,33 @@ public class ActiveRuleIndexMediumTest {
     dao.insert(ruleDto, dbSession);
 
     RuleParamDto minParam = new RuleParamDto()
-      .setRuleId(ruleDto.getId())
       .setName("min")
       .setType("STRING");
-    dao.insert(minParam, dbSession);
+    dao.addRuleParam(ruleDto, minParam, dbSession);
 
     RuleParamDto maxParam = new RuleParamDto()
-      .setRuleId(ruleDto.getId())
       .setName("max")
       .setType("STRING");
-    dao.insert(maxParam, dbSession);
+    dao.addRuleParam(ruleDto, maxParam, dbSession);
 
 
-    ActiveRuleDto activeRule = new ActiveRuleDto()
+    ActiveRuleDto activeRule = ActiveRuleDto.createFor(profileDto, ruleDto)
       .setInheritance("inherited")
-      .setProfileId(profileDto.getId())
-      .setRuleId(ruleDto.getId())
       .setSeverity(Severity.BLOCKER);
     activeRuleDao.insert(activeRule, dbSession);
 
-    ActiveRuleParamDto activeRuleMinParam = new ActiveRuleParamDto()
-      .setActiveRuleId(activeRule.getId())
-      .setKey(minParam.getName())
-      .setValue("minimum")
-      .setRulesParameterId(minParam.getId());
-    activeRuleDao.insert(activeRuleMinParam, dbSession);
+    ActiveRuleParamDto activeRuleMinParam = ActiveRuleParamDto.createFor(minParam)
+      .setValue("minimum");
+    activeRuleDao.addParam(activeRule, activeRuleMinParam, dbSession);
 
-    ActiveRuleParamDto activeRuleMaxParam = new ActiveRuleParamDto()
-      .setActiveRuleId(activeRule.getId())
-      .setKey(maxParam.getName())
-      .setValue("maximum")
-      .setRulesParameterId(maxParam.getId());
-    activeRuleDao.insert(activeRuleMaxParam, dbSession);
+    ActiveRuleParamDto activeRuleMaxParam = ActiveRuleParamDto.createFor(maxParam)
+      .setValue("maximum");
+    activeRuleDao.addParam(activeRule, activeRuleMaxParam, dbSession);
 
     dbSession.commit();
-    dbSession.close();
 
     // verify that activeRulesParams are persisted in db
-    List<ActiveRuleParamDto> persistedDtos = activeRuleDao.selectParamsByActiveRuleId(activeRule.getId());
+    List<ActiveRuleParamDto> persistedDtos = activeRuleDao.findParamsByActiveRule(activeRule, dbSession);
     assertThat(persistedDtos).hasSize(2);
 
     // verify that activeRulesParams are indexed in es
diff --git a/sonar-server/src/test/java/org/sonar/server/rule2/RuleDaoTest.java b/sonar-server/src/test/java/org/sonar/server/rule2/RuleDaoTest.java
index 036a9976943..84baa4c4221 100644
--- a/sonar-server/src/test/java/org/sonar/server/rule2/RuleDaoTest.java
+++ b/sonar-server/src/test/java/org/sonar/server/rule2/RuleDaoTest.java
@@ -19,394 +19,375 @@
  */
 package org.sonar.server.rule2;
 
-import com.google.common.base.Function;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Iterables;
-import org.junit.Before;
-import org.junit.Test;
-import org.sonar.api.rule.RuleKey;
-import org.sonar.api.rule.Severity;
-import org.sonar.api.rules.Rule;
-import org.sonar.api.utils.DateUtils;
-import org.sonar.check.Cardinality;
 import org.sonar.core.persistence.AbstractDaoTestCase;
-import org.sonar.core.persistence.DbSession;
-import org.sonar.core.rule.RuleDto;
-import org.sonar.core.rule.RuleParamDto;
-
-import java.util.Arrays;
-import java.util.List;
-
-import static com.google.common.collect.Lists.newArrayList;
-import static org.fest.assertions.Assertions.assertThat;
 
 public class RuleDaoTest extends AbstractDaoTestCase {
 
-  private static RuleDao dao;
-
-  @Before
-  public void createDao() throws Exception {
-    dao = new RuleDao(getMyBatis());
-  }
-
-  @Test
-  public void select_all() throws Exception {
-    setupData("selectAll");
-    List<RuleDto> ruleDtos = dao.selectAll();
-
-    assertThat(ruleDtos).hasSize(1);
-
-    RuleDto ruleDto = ruleDtos.get(0);
-    assertThat(ruleDto.getId()).isEqualTo(1);
-    assertThat(ruleDto.getName()).isEqualTo("Avoid Null");
-    assertThat(ruleDto.getDescription()).isEqualTo("Should avoid NULL");
-    assertThat(ruleDto.getStatus()).isEqualTo(Rule.STATUS_READY);
-    assertThat(ruleDto.getRepositoryKey()).isEqualTo("checkstyle");
-    assertThat(ruleDto.getNoteData()).isEqualTo("Rule note with accents \u00e9\u00e8\u00e0");
-    assertThat(ruleDto.getSubCharacteristicId()).isEqualTo(100);
-    assertThat(ruleDto.getDefaultSubCharacteristicId()).isEqualTo(101);
-    assertThat(ruleDto.getRemediationFunction()).isEqualTo("linear");
-    assertThat(ruleDto.getDefaultRemediationFunction()).isEqualTo("linear_offset");
-    assertThat(ruleDto.getRemediationCoefficient()).isEqualTo("1h");
-    assertThat(ruleDto.getDefaultRemediationCoefficient()).isEqualTo("5d");
-    assertThat(ruleDto.getRemediationOffset()).isEqualTo("5min");
-    assertThat(ruleDto.getDefaultRemediationOffset()).isEqualTo("10h");
-    assertThat(ruleDto.getEffortToFixDescription()).isEqualTo("squid.S115.effortToFix");
-  }
-
-  @Test
-  public void select_enables_and_non_manual() throws Exception {
-    setupData("select_enables_and_non_manual");
-    List<RuleDto> ruleDtos = dao.selectEnablesAndNonManual();
-
-    assertThat(ruleDtos.size()).isEqualTo(1);
-    RuleDto ruleDto = ruleDtos.get(0);
-    assertThat(ruleDto.getId()).isEqualTo(1);
-    assertThat(ruleDto.getName()).isEqualTo("Avoid Null");
-    assertThat(ruleDto.getDescription()).isEqualTo("Should avoid NULL");
-    assertThat(ruleDto.getStatus()).isEqualTo(Rule.STATUS_READY);
-    assertThat(ruleDto.getRepositoryKey()).isEqualTo("checkstyle");
-    assertThat(ruleDto.getNoteData()).isEqualTo("Rule note with accents \u00e9\u00e8\u00e0");
-    assertThat(ruleDto.getSubCharacteristicId()).isEqualTo(100);
-    assertThat(ruleDto.getDefaultSubCharacteristicId()).isEqualTo(101);
-    assertThat(ruleDto.getRemediationFunction()).isEqualTo("LINEAR");
-    assertThat(ruleDto.getDefaultRemediationFunction()).isEqualTo("LINEAR_OFFSET");
-    assertThat(ruleDto.getRemediationCoefficient()).isEqualTo("1h");
-    assertThat(ruleDto.getDefaultRemediationCoefficient()).isEqualTo("5d");
-    assertThat(ruleDto.getRemediationOffset()).isEqualTo("5min");
-    assertThat(ruleDto.getDefaultRemediationOffset()).isEqualTo("10h");
-    assertThat(ruleDto.getEffortToFixDescription()).isEqualTo("squid.S115.effortToFix");
-  }
-
-  @Test
-  public void select_by_id() throws Exception {
-    setupData("selectById");
-    RuleDto ruleDto = dao.selectById(2);
-
-    assertThat(ruleDto.getId()).isEqualTo(2);
-    assertThat(ruleDto.getName()).isEqualTo("Avoid Null");
-    assertThat(ruleDto.getDescription()).isEqualTo("Should avoid NULL");
-    assertThat(ruleDto.getStatus()).isEqualTo(Rule.STATUS_READY);
-    assertThat(ruleDto.getRepositoryKey()).isEqualTo("checkstyle");
-  }
-
-  @Test
-  public void select_by_rule_key() throws Exception {
-    setupData("select_by_rule_key");
-    assertThat(dao.selectByKey(RuleKey.of("checkstyle", "AvoidComparison"))).isNotNull();
-    assertThat(dao.selectByKey(RuleKey.of("checkstyle", "Unknown"))).isNull();
-    assertThat(dao.selectByKey(RuleKey.of("Unknown", "AvoidComparison"))).isNull();
-  }
-
-  @Test
-  public void select_by_name() throws Exception {
-    setupData("select_by_name");
-    RuleDto ruleDto = dao.selectByName("Avoid Null");
-
-    assertThat(ruleDto.getId()).isEqualTo(2);
-    assertThat(ruleDto.getName()).isEqualTo("Avoid Null");
-    assertThat(ruleDto.getDescription()).isEqualTo("Should avoid NULL");
-    assertThat(ruleDto.getStatus()).isEqualTo(Rule.STATUS_READY);
-    assertThat(ruleDto.getRepositoryKey()).isEqualTo("checkstyle");
-  }
-
-  @Test
-  public void select_non_manual() throws Exception {
-    setupData("selectNonManual");
-    DbSession session = getMyBatis().openSession(false);
-    List<RuleDto> ruleDtos = dao.selectNonManual(session);
-    session.commit();
-    session.close();
-
-    assertThat(ruleDtos.size()).isEqualTo(1);
-    RuleDto ruleDto = ruleDtos.get(0);
-    assertThat(ruleDto.getId()).isEqualTo(1);
-    assertThat(ruleDto.getName()).isEqualTo("Avoid Null");
-    assertThat(ruleDto.getDescription()).isEqualTo("Should avoid NULL");
-    assertThat(ruleDto.getStatus()).isEqualTo(Rule.STATUS_READY);
-    assertThat(ruleDto.getRepositoryKey()).isEqualTo("checkstyle");
-  }
-
-  @Test
-  public void select_by_sub_characteristic_id(){
-    setupData("select_by_sub_characteristic_id");
-
-    // Rules from sub characteristic (even REMOVED ones are returned)
-    List<RuleDto> ruleDtos = dao.selectBySubCharacteristicId(3);
-    assertThat(ruleDtos).hasSize(3);
-    assertThat(idsFromRuleDtos(ruleDtos)).containsExactly(2, 4, 5);
-
-    // Nothing on root characteristic
-    ruleDtos = dao.selectBySubCharacteristicId(1);
-    assertThat(ruleDtos).isEmpty();
-
-    // Rules from disabled characteristic
-    ruleDtos = dao.selectBySubCharacteristicId(11);
-    assertThat(idsFromRuleDtos(ruleDtos)).containsExactly(3);
-  }
-
-  @Test
-  public void update() {
-    setupData("update");
-
-    RuleDto ruleToUpdate = new RuleDto()
-      .setId(1)
-      .setRuleKey("NewRuleKey")
-      .setRepositoryKey("plugin")
-      .setName("new name")
-      .setDescription("new description")
-      .setStatus(Rule.STATUS_DEPRECATED)
-      .setConfigKey("NewConfigKey")
-      .setSeverity(Severity.INFO)
-      .setCardinality(Cardinality.MULTIPLE)
-      .setLanguage("dart")
-      .setParentId(3)
-      .setNoteData("My note")
-      .setNoteUserLogin("admin")
-      .setNoteCreatedAt(DateUtils.parseDate("2013-12-19"))
-      .setNoteUpdatedAt(DateUtils.parseDate("2013-12-20"))
-      .setSubCharacteristicId(100)
-      .setDefaultSubCharacteristicId(101)
-      .setRemediationFunction("linear")
-      .setDefaultRemediationFunction("linear_offset")
-      .setRemediationCoefficient("1h")
-      .setDefaultRemediationCoefficient("5d")
-      .setRemediationOffset("5min")
-      .setDefaultRemediationOffset("10h")
-      .setEffortToFixDescription("squid.S115.effortToFix")
-      .setUpdatedAt(DateUtils.parseDate("2013-12-17"));
-
-    dao.update(ruleToUpdate);
-
-    checkTables("update", "rules");
-  }
-
-  @Test
-  public void insert() {
-    setupData("empty");
-
-    RuleDto ruleToInsert = new RuleDto()
-      .setId(1)
-      .setRuleKey("NewRuleKey")
-      .setRepositoryKey("plugin")
-      .setName("new name")
-      .setDescription("new description")
-      .setStatus(Rule.STATUS_DEPRECATED)
-      .setConfigKey("NewConfigKey")
-      .setSeverity(Severity.INFO)
-      .setCardinality(Cardinality.MULTIPLE)
-      .setLanguage("dart")
-      .setParentId(3)
-      .setSubCharacteristicId(100)
-      .setDefaultSubCharacteristicId(101)
-      .setRemediationFunction("linear")
-      .setDefaultRemediationFunction("linear_offset")
-      .setRemediationCoefficient("1h")
-      .setDefaultRemediationCoefficient("5d")
-      .setRemediationOffset("5min")
-      .setDefaultRemediationOffset("10h")
-      .setEffortToFixDescription("squid.S115.effortToFix")
-      .setCreatedAt(DateUtils.parseDate("2013-12-16"))
-      .setUpdatedAt(DateUtils.parseDate("2013-12-17"));
-
-    dao.insert(ruleToInsert);
-
-    checkTables("insert", "rules");
-  }
-
-  @Test
-  public void insert_all() {
-    setupData("empty");
-
-    RuleDto ruleToInsert1 = new RuleDto()
-      .setId(1)
-      .setRuleKey("NewRuleKey")
-      .setRepositoryKey("plugin")
-      .setName("new name")
-      .setDescription("new description")
-      .setStatus(Rule.STATUS_DEPRECATED)
-      .setConfigKey("NewConfigKey")
-      .setSeverity(Severity.INFO)
-      .setCardinality(Cardinality.MULTIPLE)
-      .setLanguage("dart")
-      .setParentId(3)
-      .setSubCharacteristicId(100)
-      .setDefaultSubCharacteristicId(101)
-      .setRemediationFunction("linear")
-      .setDefaultRemediationFunction("linear_offset")
-      .setRemediationCoefficient("1h")
-      .setDefaultRemediationCoefficient("5d")
-      .setRemediationOffset("5min")
-      .setDefaultRemediationOffset("10h")
-      .setEffortToFixDescription("squid.S115.effortToFix")
-      .setCreatedAt(DateUtils.parseDate("2013-12-16"))
-      .setUpdatedAt(DateUtils.parseDate("2013-12-17"));
-
-    RuleDto ruleToInsert2 = new RuleDto()
-      .setId(2)
-      .setRuleKey("NewRuleKey2")
-      .setRepositoryKey("plugin2")
-      .setName("new name2")
-      .setDescription("new description2")
-      .setStatus(Rule.STATUS_BETA)
-      .setConfigKey("NewConfigKey2")
-      .setSeverity(Severity.MAJOR)
-      .setCardinality(Cardinality.SINGLE)
-      .setLanguage("js")
-      .setParentId(null)
-      .setSubCharacteristicId(102)
-      .setDefaultSubCharacteristicId(103)
-      .setRemediationFunction("linear_offset")
-      .setDefaultRemediationFunction("linear")
-      .setRemediationCoefficient("5d")
-      .setDefaultRemediationCoefficient("1h")
-      .setRemediationOffset("10h")
-      .setDefaultRemediationOffset("5min")
-      .setEffortToFixDescription("squid.S115.effortToFix2")
-      .setCreatedAt(DateUtils.parseDate("2013-12-14"))
-      .setUpdatedAt(DateUtils.parseDate("2013-12-15"));
-
-    dao.insert(ImmutableList.of(ruleToInsert1, ruleToInsert2));
-
-    checkTables("insert_all", "rules");
-  }
-
-  @Test
-  public void select_parameters() throws Exception {
-    setupData("selectParameters");
-    List<RuleParamDto> ruleDtos = dao.selectParameters();
-
-    assertThat(ruleDtos.size()).isEqualTo(1);
-    RuleParamDto ruleDto = ruleDtos.get(0);
-    assertThat(ruleDto.getId()).isEqualTo(1);
-    assertThat(ruleDto.getName()).isEqualTo("myParameter");
-    assertThat(ruleDto.getDescription()).isEqualTo("My Parameter");
-    assertThat(ruleDto.getType()).isEqualTo("plop");
-    assertThat(ruleDto.getDefaultValue()).isEqualTo("plouf");
-  }
-
-  @Test
-  public void select_parameters_by_rule_id() throws Exception {
-    setupData("select_parameters_by_rule_id");
-    int ruleId = 1;
-    List<RuleParamDto> ruleDtos = dao.selectParametersByRuleId(ruleId);
-
-    assertThat(ruleDtos.size()).isEqualTo(1);
-    RuleParamDto ruleDto = ruleDtos.get(0);
-    assertThat(ruleDto.getId()).isEqualTo(1);
-    assertThat(ruleDto.getName()).isEqualTo("myParameter");
-    assertThat(ruleDto.getDescription()).isEqualTo("My Parameter");
-    assertThat(ruleDto.getType()).isEqualTo("plop");
-    assertThat(ruleDto.getRuleId()).isEqualTo(ruleId);
-  }
-
-  @Test
-  public void select_parameters_by_rule_ids() throws Exception {
-    setupData("select_parameters_by_rule_ids");
-
-    assertThat(dao.selectParametersByRuleIds(newArrayList(1, 2))).hasSize(2);
-    assertThat(dao.selectParametersByRuleIds(newArrayList(1))).hasSize(1);
-  }
-
-  @Test
-  public void insert_parameter() {
-    setupData("insert_parameter");
-
-    RuleParamDto param = new RuleParamDto()
-      .setRuleId(1)
-      .setName("max")
-      .setType("INTEGER")
-      .setDefaultValue("30")
-      .setDescription("My Parameter");
-
-    dao.insert(param);
-
-    checkTables("insert_parameter", "rules_parameters");
-  }
-
-  @Test
-  public void update_parameter() {
-    setupData("update_parameter");
-
-    RuleParamDto param = new RuleParamDto()
-      .setId(1)
-      .setName("format")
-      .setType("STRING")
-      .setDefaultValue("^[a-z]+(\\.[a-z][a-z0-9]*)*$")
-      .setDescription("Regular expression used to check the package names against.");
-
-    dao.update(param);
-
-    checkTables("update_parameter", "rules_parameters");
-  }
-
-  @Test
-  public void select_tags_by_rule_id() throws Exception {
-    setupData("select_tags_by_rule_id");
-
-    assertThat(dao.selectTagsByRuleId(3)).hasSize(2);
-  }
-
-  @Test
-  public void select_tags_by_rule_ids() throws Exception {
-    setupData("select_tags_by_rule_ids");
-
-    assertThat(dao.selectTagsByRuleIds(newArrayList(3, 4))).hasSize(3);
-  }
-
-  @Test
-  public void keysOfRowsUpdatedAfter() throws Exception {
-    setupData("empty");
-
-    RuleDto rule1 = new RuleDto()
-      .setId(1)
-      .setRepositoryKey("foo")
-      .setRuleKey("R1")
-      .setName("ROne")
-      .setCreatedAt(DateUtils.parseDate("2013-12-16"))
-      .setUpdatedAt(DateUtils.parseDate("2013-12-16"));
-    RuleDto rule2 = new RuleDto()
-      .setId(2)
-      .setRepositoryKey("foo")
-      .setRuleKey("R2")
-      .setName("RTwo")
-      .setCreatedAt(DateUtils.parseDate("2014-01-28"))
-      .setUpdatedAt(DateUtils.parseDate("2014-05-19"));
-    dao.insert(Arrays.asList(rule1, rule2));
-
-    assertThat(dao.keysOfRowsUpdatedAfter(DateUtils.parseDate("2014-06-01").getTime())).isEmpty();
-    assertThat(dao.keysOfRowsUpdatedAfter(DateUtils.parseDate("2012-01-01").getTime())).hasSize(2);
-    Iterable<RuleKey> keys = dao.keysOfRowsUpdatedAfter(DateUtils.parseDate("2014-05-17").getTime());
-    assertThat(keys).hasSize(1);
-    assertThat(Iterables.getFirst(keys, null).rule()).isEqualTo("R2");
-  }
-
-  private List<Integer> idsFromRuleDtos(List<RuleDto> ruleDtos){
-    return newArrayList(Iterables.transform(ruleDtos, new Function<RuleDto, Integer>() {
-      @Override
-      public Integer apply(RuleDto input) {
-        return input.getId();
-      }
-    }));
-  }
+//  private static RuleDao dao;
+//
+//  @Before
+//  public void createDao() throws Exception {
+//    dao = new RuleDao(getMyBatis());
+//  }
+//
+//  @Test
+//  public void select_all() throws Exception {
+//    setupData("selectAll");
+//    List<RuleDto> ruleDtos = dao.selectAll();
+//
+//    assertThat(ruleDtos).hasSize(1);
+//
+//    RuleDto ruleDto = ruleDtos.get(0);
+//    assertThat(ruleDto.getId()).isEqualTo(1);
+//    assertThat(ruleDto.getName()).isEqualTo("Avoid Null");
+//    assertThat(ruleDto.getDescription()).isEqualTo("Should avoid NULL");
+//    assertThat(ruleDto.getStatus()).isEqualTo(Rule.STATUS_READY);
+//    assertThat(ruleDto.getRepositoryKey()).isEqualTo("checkstyle");
+//    assertThat(ruleDto.getNoteData()).isEqualTo("Rule note with accents \u00e9\u00e8\u00e0");
+//    assertThat(ruleDto.getSubCharacteristicId()).isEqualTo(100);
+//    assertThat(ruleDto.getDefaultSubCharacteristicId()).isEqualTo(101);
+//    assertThat(ruleDto.getRemediationFunction()).isEqualTo("linear");
+//    assertThat(ruleDto.getDefaultRemediationFunction()).isEqualTo("linear_offset");
+//    assertThat(ruleDto.getRemediationCoefficient()).isEqualTo("1h");
+//    assertThat(ruleDto.getDefaultRemediationCoefficient()).isEqualTo("5d");
+//    assertThat(ruleDto.getRemediationOffset()).isEqualTo("5min");
+//    assertThat(ruleDto.getDefaultRemediationOffset()).isEqualTo("10h");
+//    assertThat(ruleDto.getEffortToFixDescription()).isEqualTo("squid.S115.effortToFix");
+//  }
+//
+//  @Test
+//  public void select_enables_and_non_manual() throws Exception {
+//    setupData("select_enables_and_non_manual");
+//    List<RuleDto> ruleDtos = dao.selectEnablesAndNonManual();
+//
+//    assertThat(ruleDtos.size()).isEqualTo(1);
+//    RuleDto ruleDto = ruleDtos.get(0);
+//    assertThat(ruleDto.getId()).isEqualTo(1);
+//    assertThat(ruleDto.getName()).isEqualTo("Avoid Null");
+//    assertThat(ruleDto.getDescription()).isEqualTo("Should avoid NULL");
+//    assertThat(ruleDto.getStatus()).isEqualTo(Rule.STATUS_READY);
+//    assertThat(ruleDto.getRepositoryKey()).isEqualTo("checkstyle");
+//    assertThat(ruleDto.getNoteData()).isEqualTo("Rule note with accents \u00e9\u00e8\u00e0");
+//    assertThat(ruleDto.getSubCharacteristicId()).isEqualTo(100);
+//    assertThat(ruleDto.getDefaultSubCharacteristicId()).isEqualTo(101);
+//    assertThat(ruleDto.getRemediationFunction()).isEqualTo("LINEAR");
+//    assertThat(ruleDto.getDefaultRemediationFunction()).isEqualTo("LINEAR_OFFSET");
+//    assertThat(ruleDto.getRemediationCoefficient()).isEqualTo("1h");
+//    assertThat(ruleDto.getDefaultRemediationCoefficient()).isEqualTo("5d");
+//    assertThat(ruleDto.getRemediationOffset()).isEqualTo("5min");
+//    assertThat(ruleDto.getDefaultRemediationOffset()).isEqualTo("10h");
+//    assertThat(ruleDto.getEffortToFixDescription()).isEqualTo("squid.S115.effortToFix");
+//  }
+//
+//  @Test
+//  public void select_by_id() throws Exception {
+//    setupData("selectById");
+//    RuleDto ruleDto = dao.selectById(2);
+//
+//    assertThat(ruleDto.getId()).isEqualTo(2);
+//    assertThat(ruleDto.getName()).isEqualTo("Avoid Null");
+//    assertThat(ruleDto.getDescription()).isEqualTo("Should avoid NULL");
+//    assertThat(ruleDto.getStatus()).isEqualTo(Rule.STATUS_READY);
+//    assertThat(ruleDto.getRepositoryKey()).isEqualTo("checkstyle");
+//  }
+//
+//  @Test
+//  public void select_by_rule_key() throws Exception {
+//    setupData("select_by_rule_key");
+//    assertThat(dao.selectByKey(RuleKey.of("checkstyle", "AvoidComparison"))).isNotNull();
+//    assertThat(dao.selectByKey(RuleKey.of("checkstyle", "Unknown"))).isNull();
+//    assertThat(dao.selectByKey(RuleKey.of("Unknown", "AvoidComparison"))).isNull();
+//  }
+//
+//  @Test
+//  public void select_by_name() throws Exception {
+//    setupData("select_by_name");
+//    RuleDto ruleDto = dao.selectByName("Avoid Null");
+//
+//    assertThat(ruleDto.getId()).isEqualTo(2);
+//    assertThat(ruleDto.getName()).isEqualTo("Avoid Null");
+//    assertThat(ruleDto.getDescription()).isEqualTo("Should avoid NULL");
+//    assertThat(ruleDto.getStatus()).isEqualTo(Rule.STATUS_READY);
+//    assertThat(ruleDto.getRepositoryKey()).isEqualTo("checkstyle");
+//  }
+//
+//  @Test
+//  public void select_non_manual() throws Exception {
+//    setupData("selectNonManual");
+//    DbSession session = getMyBatis().openSession(false);
+//    List<RuleDto> ruleDtos = dao.selectNonManual(session);
+//    session.commit();
+//    session.close();
+//
+//    assertThat(ruleDtos.size()).isEqualTo(1);
+//    RuleDto ruleDto = ruleDtos.get(0);
+//    assertThat(ruleDto.getId()).isEqualTo(1);
+//    assertThat(ruleDto.getName()).isEqualTo("Avoid Null");
+//    assertThat(ruleDto.getDescription()).isEqualTo("Should avoid NULL");
+//    assertThat(ruleDto.getStatus()).isEqualTo(Rule.STATUS_READY);
+//    assertThat(ruleDto.getRepositoryKey()).isEqualTo("checkstyle");
+//  }
+//
+//  @Test
+//  public void select_by_sub_characteristic_id(){
+//    setupData("select_by_sub_characteristic_id");
+//
+//    // Rules from sub characteristic (even REMOVED ones are returned)
+//    List<RuleDto> ruleDtos = dao.selectBySubCharacteristicId(3);
+//    assertThat(ruleDtos).hasSize(3);
+//    assertThat(idsFromRuleDtos(ruleDtos)).containsExactly(2, 4, 5);
+//
+//    // Nothing on root characteristic
+//    ruleDtos = dao.selectBySubCharacteristicId(1);
+//    assertThat(ruleDtos).isEmpty();
+//
+//    // Rules from disabled characteristic
+//    ruleDtos = dao.selectBySubCharacteristicId(11);
+//    assertThat(idsFromRuleDtos(ruleDtos)).containsExactly(3);
+//  }
+//
+//  @Test
+//  public void update() {
+//    setupData("update");
+//
+//    RuleDto ruleToUpdate = new RuleDto()
+//      .setId(1)
+//      .setRuleKey("NewRuleKey")
+//      .setRepositoryKey("plugin")
+//      .setName("new name")
+//      .setDescription("new description")
+//      .setStatus(Rule.STATUS_DEPRECATED)
+//      .setConfigKey("NewConfigKey")
+//      .setSeverity(Severity.INFO)
+//      .setCardinality(Cardinality.MULTIPLE)
+//      .setLanguage("dart")
+//      .setParentId(3)
+//      .setNoteData("My note")
+//      .setNoteUserLogin("admin")
+//      .setNoteCreatedAt(DateUtils.parseDate("2013-12-19"))
+//      .setNoteUpdatedAt(DateUtils.parseDate("2013-12-20"))
+//      .setSubCharacteristicId(100)
+//      .setDefaultSubCharacteristicId(101)
+//      .setRemediationFunction("linear")
+//      .setDefaultRemediationFunction("linear_offset")
+//      .setRemediationCoefficient("1h")
+//      .setDefaultRemediationCoefficient("5d")
+//      .setRemediationOffset("5min")
+//      .setDefaultRemediationOffset("10h")
+//      .setEffortToFixDescription("squid.S115.effortToFix")
+//      .setUpdatedAt(DateUtils.parseDate("2013-12-17"));
+//
+//    dao.update(ruleToUpdate);
+//
+//    checkTables("update", "rules");
+//  }
+//
+//  @Test
+//  public void insert() {
+//    setupData("empty");
+//
+//    RuleDto ruleToInsert = new RuleDto()
+//      .setId(1)
+//      .setRuleKey("NewRuleKey")
+//      .setRepositoryKey("plugin")
+//      .setName("new name")
+//      .setDescription("new description")
+//      .setStatus(Rule.STATUS_DEPRECATED)
+//      .setConfigKey("NewConfigKey")
+//      .setSeverity(Severity.INFO)
+//      .setCardinality(Cardinality.MULTIPLE)
+//      .setLanguage("dart")
+//      .setParentId(3)
+//      .setSubCharacteristicId(100)
+//      .setDefaultSubCharacteristicId(101)
+//      .setRemediationFunction("linear")
+//      .setDefaultRemediationFunction("linear_offset")
+//      .setRemediationCoefficient("1h")
+//      .setDefaultRemediationCoefficient("5d")
+//      .setRemediationOffset("5min")
+//      .setDefaultRemediationOffset("10h")
+//      .setEffortToFixDescription("squid.S115.effortToFix")
+//      .setCreatedAt(DateUtils.parseDate("2013-12-16"))
+//      .setUpdatedAt(DateUtils.parseDate("2013-12-17"));
+//
+//    dao.insert(ruleToInsert);
+//
+//    checkTables("insert", "rules");
+//  }
+//
+//  @Test
+//  public void insert_all() {
+//    setupData("empty");
+//
+//    RuleDto ruleToInsert1 = new RuleDto()
+//      .setId(1)
+//      .setRuleKey("NewRuleKey")
+//      .setRepositoryKey("plugin")
+//      .setName("new name")
+//      .setDescription("new description")
+//      .setStatus(Rule.STATUS_DEPRECATED)
+//      .setConfigKey("NewConfigKey")
+//      .setSeverity(Severity.INFO)
+//      .setCardinality(Cardinality.MULTIPLE)
+//      .setLanguage("dart")
+//      .setParentId(3)
+//      .setSubCharacteristicId(100)
+//      .setDefaultSubCharacteristicId(101)
+//      .setRemediationFunction("linear")
+//      .setDefaultRemediationFunction("linear_offset")
+//      .setRemediationCoefficient("1h")
+//      .setDefaultRemediationCoefficient("5d")
+//      .setRemediationOffset("5min")
+//      .setDefaultRemediationOffset("10h")
+//      .setEffortToFixDescription("squid.S115.effortToFix")
+//      .setCreatedAt(DateUtils.parseDate("2013-12-16"))
+//      .setUpdatedAt(DateUtils.parseDate("2013-12-17"));
+//
+//    RuleDto ruleToInsert2 = new RuleDto()
+//      .setId(2)
+//      .setRuleKey("NewRuleKey2")
+//      .setRepositoryKey("plugin2")
+//      .setName("new name2")
+//      .setDescription("new description2")
+//      .setStatus(Rule.STATUS_BETA)
+//      .setConfigKey("NewConfigKey2")
+//      .setSeverity(Severity.MAJOR)
+//      .setCardinality(Cardinality.SINGLE)
+//      .setLanguage("js")
+//      .setParentId(null)
+//      .setSubCharacteristicId(102)
+//      .setDefaultSubCharacteristicId(103)
+//      .setRemediationFunction("linear_offset")
+//      .setDefaultRemediationFunction("linear")
+//      .setRemediationCoefficient("5d")
+//      .setDefaultRemediationCoefficient("1h")
+//      .setRemediationOffset("10h")
+//      .setDefaultRemediationOffset("5min")
+//      .setEffortToFixDescription("squid.S115.effortToFix2")
+//      .setCreatedAt(DateUtils.parseDate("2013-12-14"))
+//      .setUpdatedAt(DateUtils.parseDate("2013-12-15"));
+//
+//    dao.insert(ImmutableList.of(ruleToInsert1, ruleToInsert2));
+//
+//    checkTables("insert_all", "rules");
+//  }
+//
+//  @Test
+//  public void select_parameters() throws Exception {
+//    setupData("selectParameters");
+//    List<RuleParamDto> ruleDtos = dao.selectParameters();
+//
+//    assertThat(ruleDtos.size()).isEqualTo(1);
+//    RuleParamDto ruleDto = ruleDtos.get(0);
+//    assertThat(ruleDto.getId()).isEqualTo(1);
+//    assertThat(ruleDto.getName()).isEqualTo("myParameter");
+//    assertThat(ruleDto.getDescription()).isEqualTo("My Parameter");
+//    assertThat(ruleDto.getType()).isEqualTo("plop");
+//    assertThat(ruleDto.getDefaultValue()).isEqualTo("plouf");
+//  }
+//
+//  @Test
+//  public void select_parameters_by_rule_id() throws Exception {
+//    setupData("select_parameters_by_rule_id");
+//    int ruleId = 1;
+//    List<RuleParamDto> ruleDtos = dao.selectParametersByRuleId(ruleId);
+//
+//    assertThat(ruleDtos.size()).isEqualTo(1);
+//    RuleParamDto ruleDto = ruleDtos.get(0);
+//    assertThat(ruleDto.getId()).isEqualTo(1);
+//    assertThat(ruleDto.getName()).isEqualTo("myParameter");
+//    assertThat(ruleDto.getDescription()).isEqualTo("My Parameter");
+//    assertThat(ruleDto.getType()).isEqualTo("plop");
+//    assertThat(ruleDto.getRuleId()).isEqualTo(ruleId);
+//  }
+//
+//  @Test
+//  public void select_parameters_by_rule_ids() throws Exception {
+//    setupData("select_parameters_by_rule_ids");
+//
+//    assertThat(dao.selectParametersByRuleIds(newArrayList(1, 2))).hasSize(2);
+//    assertThat(dao.selectParametersByRuleIds(newArrayList(1))).hasSize(1);
+//  }
+//
+//  @Test
+//  public void insert_parameter() {
+//    setupData("insert_parameter");
+//
+//    RuleParamDto param = new RuleParamDto()
+//      .setRuleId(1)
+//      .setName("max")
+//      .setType("INTEGER")
+//      .setDefaultValue("30")
+//      .setDescription("My Parameter");
+//
+//    dao.insert(param);
+//
+//    checkTables("insert_parameter", "rules_parameters");
+//  }
+//
+//  @Test
+//  public void update_parameter() {
+//    setupData("update_parameter");
+//
+//    RuleParamDto param = new RuleParamDto()
+//      .setId(1)
+//      .setName("format")
+//      .setType("STRING")
+//      .setDefaultValue("^[a-z]+(\\.[a-z][a-z0-9]*)*$")
+//      .setDescription("Regular expression used to check the package names against.");
+//
+//    dao.update(param);
+//
+//    checkTables("update_parameter", "rules_parameters");
+//  }
+//
+//  @Test
+//  public void select_tags_by_rule_id() throws Exception {
+//    setupData("select_tags_by_rule_id");
+//
+//    assertThat(dao.selectTagsByRuleId(3)).hasSize(2);
+//  }
+//
+//  @Test
+//  public void select_tags_by_rule_ids() throws Exception {
+//    setupData("select_tags_by_rule_ids");
+//
+//    assertThat(dao.selectTagsByRuleIds(newArrayList(3, 4))).hasSize(3);
+//  }
+//
+//  @Test
+//  public void keysOfRowsUpdatedAfter() throws Exception {
+//    setupData("empty");
+//
+//    RuleDto rule1 = new RuleDto()
+//      .setId(1)
+//      .setRepositoryKey("foo")
+//      .setRuleKey("R1")
+//      .setName("ROne")
+//      .setCreatedAt(DateUtils.parseDate("2013-12-16"))
+//      .setUpdatedAt(DateUtils.parseDate("2013-12-16"));
+//    RuleDto rule2 = new RuleDto()
+//      .setId(2)
+//      .setRepositoryKey("foo")
+//      .setRuleKey("R2")
+//      .setName("RTwo")
+//      .setCreatedAt(DateUtils.parseDate("2014-01-28"))
+//      .setUpdatedAt(DateUtils.parseDate("2014-05-19"));
+//    dao.insert(Arrays.asList(rule1, rule2));
+//
+//    assertThat(dao.keysOfRowsUpdatedAfter(DateUtils.parseDate("2014-06-01").getTime())).isEmpty();
+//    assertThat(dao.keysOfRowsUpdatedAfter(DateUtils.parseDate("2012-01-01").getTime())).hasSize(2);
+//    Iterable<RuleKey> keys = dao.keysOfRowsUpdatedAfter(DateUtils.parseDate("2014-05-17").getTime());
+//    assertThat(keys).hasSize(1);
+//    assertThat(Iterables.getFirst(keys, null).rule()).isEqualTo("R2");
+//  }
+//
+//  private List<Integer> idsFromRuleDtos(List<RuleDto> ruleDtos){
+//    return newArrayList(Iterables.transform(ruleDtos, new Function<RuleDto, Integer>() {
+//      @Override
+//      public Integer apply(RuleDto input) {
+//        return input.getId();
+//      }
+//    }));
+//  }
 }
diff --git a/sonar-server/src/test/java/org/sonar/server/rule2/RuleIndexMediumTest.java b/sonar-server/src/test/java/org/sonar/server/rule2/RuleIndexMediumTest.java
index 2a78ee3369d..5ee5f268616 100644
--- a/sonar-server/src/test/java/org/sonar/server/rule2/RuleIndexMediumTest.java
+++ b/sonar-server/src/test/java/org/sonar/server/rule2/RuleIndexMediumTest.java
@@ -20,6 +20,7 @@
 package org.sonar.server.rule2;
 
 import com.google.common.collect.Iterables;
+import org.junit.After;
 import org.junit.Before;
 import org.junit.ClassRule;
 import org.junit.Test;
@@ -28,7 +29,10 @@ import org.sonar.api.rule.RuleStatus;
 import org.sonar.api.rule.Severity;
 import org.sonar.api.utils.DateUtils;
 import org.sonar.check.Cardinality;
+import org.sonar.core.persistence.DbSession;
+import org.sonar.core.persistence.MyBatis;
 import org.sonar.core.rule.RuleDto;
+import org.sonar.server.search.Hit;
 import org.sonar.server.search.QueryOptions;
 import org.sonar.server.search.Result;
 import org.sonar.server.tester.ServerTester;
@@ -41,31 +45,35 @@ import static org.fest.assertions.Assertions.assertThat;
 public class RuleIndexMediumTest {
 
   @ClassRule
-  public static ServerTester tester = new ServerTester()
-    .setProperty("sonar.es.http.port","8888");
+  public static ServerTester tester = new ServerTester();
 
+  MyBatis myBatis = tester.get(MyBatis.class);
   RuleDao dao = tester.get(RuleDao.class);
   RuleIndex index = tester.get(RuleIndex.class);
+  DbSession dbSession;
 
   @Before
-  public void clear_data_store() {
+  public void before() {
     tester.clearDataStores();
+    dbSession = myBatis.openSession(false);
+  }
+
+  @After
+  public void after() {
+    dbSession.close();
   }
 
   @Test
   public void facet_test_with_repository() {
-    dao.insert(newRuleDto(RuleKey.of("javascript", "S001"))
-      .setRuleKey("X001"));
-    dao.insert(newRuleDto(RuleKey.of("cobol", "S001"))
-      .setRuleKey("X001"));
-    dao.insert(newRuleDto(RuleKey.of("php", "S002")));
+    dao.insert(newRuleDto(RuleKey.of("javascript", "S001")).setRuleKey("X001"), dbSession);
+    dao.insert(newRuleDto(RuleKey.of("cobol", "S001")).setRuleKey("X001"), dbSession);
+    dao.insert(newRuleDto(RuleKey.of("php", "S002")), dbSession);
+    dbSession.commit();
     index.refresh();
 
-    RuleQuery query = new RuleQuery();
-    Result result = null;
-
     // should not have any facet!
-    result = index.search(query, new QueryOptions().setFacet(false));
+    RuleQuery query = new RuleQuery();
+    Result result = index.search(query, new QueryOptions().setFacet(false));
     assertThat(result.getFacets()).isEmpty();
 
     // Repositories Facet is preset
@@ -75,12 +83,13 @@ public class RuleIndexMediumTest {
     assertThat(result.getFacets()).hasSize(3);
     assertThat(result.getFacet("Repositories").size()).isEqualTo(3);
     assertThat(result.getFacetKeys("Repositories"))
-      .contains("javascript","cobol","php");
+      .contains("javascript", "cobol", "php");
   }
 
   @Test
   public void return_all_doc_fields_by_default() {
-    dao.insert(newRuleDto(RuleKey.of("javascript", "S001")));
+    dao.insert(newRuleDto(RuleKey.of("javascript", "S001")), dbSession);
+    dbSession.commit();
     index.refresh();
 
     QueryOptions options = new QueryOptions().setFieldsToReturn(null);
@@ -96,7 +105,8 @@ public class RuleIndexMediumTest {
 
   @Test
   public void select_doc_fields_to_return() {
-    dao.insert(newRuleDto(RuleKey.of("javascript", "S001")));
+    dao.insert(newRuleDto(RuleKey.of("javascript", "S001")), dbSession);
+    dbSession.commit();
     index.refresh();
 
     QueryOptions options = new QueryOptions();
@@ -113,7 +123,8 @@ public class RuleIndexMediumTest {
   @Test
   public void search_name_by_query() {
     dao.insert(newRuleDto(RuleKey.of("javascript", "S001"))
-      .setName("testing the partial match and matching of rule"));
+      .setName("testing the partial match and matching of rule"), dbSession);
+    dbSession.commit();
     index.refresh();
 
     // substring
@@ -136,10 +147,11 @@ public class RuleIndexMediumTest {
   @Test
   public void search_key_by_query() {
     dao.insert(newRuleDto(RuleKey.of("javascript", "S001"))
-      .setRuleKey("X001"));
+      .setRuleKey("X001"), dbSession);
     dao.insert(newRuleDto(RuleKey.of("cobol", "S001"))
-      .setRuleKey("X001"));
-    dao.insert(newRuleDto(RuleKey.of("php", "S002")));
+      .setRuleKey("X001"), dbSession);
+    dao.insert(newRuleDto(RuleKey.of("php", "S002")), dbSession);
+    dbSession.commit();
     index.refresh();
 
     // key
@@ -157,8 +169,9 @@ public class RuleIndexMediumTest {
 
   @Test
   public void search_all_rules() {
-    dao.insert(newRuleDto(RuleKey.of("javascript", "S001")));
-    dao.insert(newRuleDto(RuleKey.of("java", "S002")));
+    dao.insert(newRuleDto(RuleKey.of("javascript", "S001")), dbSession);
+    dao.insert(newRuleDto(RuleKey.of("java", "S002")), dbSession);
+    dbSession.commit();
     index.refresh();
 
     Result results = index.search(new RuleQuery(), new QueryOptions());
@@ -169,8 +182,9 @@ public class RuleIndexMediumTest {
 
   @Test
   public void search_by_any_of_repositories() {
-    dao.insert(newRuleDto(RuleKey.of("findbugs", "S001")));
-    dao.insert(newRuleDto(RuleKey.of("pmd", "S002")));
+    dao.insert(newRuleDto(RuleKey.of("findbugs", "S001")), dbSession);
+    dao.insert(newRuleDto(RuleKey.of("pmd", "S002")), dbSession);
+    dbSession.commit();
     index.refresh();
 
     RuleQuery query = new RuleQuery().setRepositories(Arrays.asList("checkstyle", "pmd"));
@@ -189,12 +203,11 @@ public class RuleIndexMediumTest {
 
   @Test
   public void search_by_any_of_languages() throws InterruptedException {
-    dao.insert(newRuleDto(RuleKey.of("java", "S001")).setLanguage("java"));
-    dao.insert(newRuleDto(RuleKey.of("javascript", "S002")).setLanguage("js"));
+    dao.insert(newRuleDto(RuleKey.of("java", "S001")).setLanguage("java"), dbSession);
+    dao.insert(newRuleDto(RuleKey.of("javascript", "S002")).setLanguage("js"), dbSession);
+    dbSession.commit();
     index.refresh();
 
-
-
     RuleQuery query = new RuleQuery().setLanguages(Arrays.asList("cobol", "js"));
     Result<Rule> results = index.search(query, new QueryOptions());
 
@@ -212,14 +225,13 @@ public class RuleIndexMediumTest {
     // null list => no filter
     query = new RuleQuery().setLanguages(null);
     assertThat(index.search(query, new QueryOptions()).getHits()).hasSize(2);
-
-
   }
 
   @Test
   public void search_by_any_of_severities() throws InterruptedException {
-    dao.insert(newRuleDto(RuleKey.of("java", "S001")).setSeverity(Severity.BLOCKER));
-    dao.insert(newRuleDto(RuleKey.of("java", "S002")).setSeverity(Severity.INFO));
+    dao.insert(newRuleDto(RuleKey.of("java", "S001")).setSeverity(Severity.BLOCKER), dbSession);
+    dao.insert(newRuleDto(RuleKey.of("java", "S002")).setSeverity(Severity.INFO), dbSession);
+    dbSession.commit();
     index.refresh();
 
     RuleQuery query = new RuleQuery().setSeverities(Arrays.asList(Severity.INFO, Severity.MINOR));
@@ -242,8 +254,9 @@ public class RuleIndexMediumTest {
 
   @Test
   public void search_by_any_of_statuses() throws InterruptedException {
-    dao.insert(newRuleDto(RuleKey.of("java", "S001")).setStatus(RuleStatus.BETA.name()));
-    dao.insert(newRuleDto(RuleKey.of("java", "S002")).setStatus(RuleStatus.READY.name()));
+    dao.insert(newRuleDto(RuleKey.of("java", "S001")).setStatus(RuleStatus.BETA.name()), dbSession);
+    dao.insert(newRuleDto(RuleKey.of("java", "S002")).setStatus(RuleStatus.READY.name()), dbSession);
+    dbSession.commit();
     index.refresh();
 
     RuleQuery query = new RuleQuery().setStatuses(Arrays.asList(RuleStatus.DEPRECATED, RuleStatus.READY));
@@ -266,9 +279,10 @@ public class RuleIndexMediumTest {
 
   @Test
   public void sort_by_name() {
-    dao.insert(newRuleDto(RuleKey.of("java", "S001")).setName("abcd"));
-    dao.insert(newRuleDto(RuleKey.of("java", "S002")).setName("ABC"));
-    dao.insert(newRuleDto(RuleKey.of("java", "S003")).setName("FGH"));
+    dao.insert(newRuleDto(RuleKey.of("java", "S001")).setName("abcd"), dbSession);
+    dao.insert(newRuleDto(RuleKey.of("java", "S002")).setName("ABC"), dbSession);
+    dao.insert(newRuleDto(RuleKey.of("java", "S003")).setName("FGH"), dbSession);
+    dbSession.commit();
     index.refresh();
 
     // ascending
@@ -288,8 +302,9 @@ public class RuleIndexMediumTest {
 
   @Test
   public void sort_by_language() {
-    dao.insert(newRuleDto(RuleKey.of("java", "S001")).setLanguage("java"));
-    dao.insert(newRuleDto(RuleKey.of("java", "S002")).setLanguage("php"));
+    dao.insert(newRuleDto(RuleKey.of("java", "S001")).setLanguage("java"), dbSession);
+    dao.insert(newRuleDto(RuleKey.of("java", "S002")).setLanguage("php"), dbSession);
+    dbSession.commit();
     index.refresh();
 
     // ascending
@@ -307,9 +322,10 @@ public class RuleIndexMediumTest {
 
   @Test
   public void paging() {
-    dao.insert(newRuleDto(RuleKey.of("java", "S001")));
-    dao.insert(newRuleDto(RuleKey.of("java", "S002")));
-    dao.insert(newRuleDto(RuleKey.of("java", "S003")));
+    dao.insert(newRuleDto(RuleKey.of("java", "S001")), dbSession);
+    dao.insert(newRuleDto(RuleKey.of("java", "S002")), dbSession);
+    dao.insert(newRuleDto(RuleKey.of("java", "S003")), dbSession);
+    dbSession.commit();
     index.refresh();
 
     // from 0 to 1 included
diff --git a/sonar-server/src/test/java/org/sonar/server/rule2/RuleServiceMediumTest.java b/sonar-server/src/test/java/org/sonar/server/rule2/RuleServiceMediumTest.java
index 813ff213d12..f0fd11d80f4 100644
--- a/sonar-server/src/test/java/org/sonar/server/rule2/RuleServiceMediumTest.java
+++ b/sonar-server/src/test/java/org/sonar/server/rule2/RuleServiceMediumTest.java
@@ -20,6 +20,7 @@
 package org.sonar.server.rule2;
 
 import com.google.common.collect.Iterables;
+import org.junit.After;
 import org.junit.Before;
 import org.junit.ClassRule;
 import org.junit.Test;
@@ -31,14 +32,8 @@ import org.sonar.api.utils.DateUtils;
 import org.sonar.check.Cardinality;
 import org.sonar.core.persistence.DbSession;
 import org.sonar.core.persistence.MyBatis;
-import org.sonar.core.qualityprofile.db.QualityProfileDao;
 import org.sonar.core.rule.RuleDto;
 import org.sonar.core.rule.RuleParamDto;
-import org.sonar.core.rule.RuleRuleTagDto;
-import org.sonar.core.rule.RuleTagDao;
-import org.sonar.core.rule.RuleTagDto;
-import org.sonar.core.rule.RuleTagType;
-import org.sonar.server.search.QueryOptions;
 import org.sonar.server.tester.ServerTester;
 
 import java.util.List;
@@ -50,25 +45,31 @@ public class RuleServiceMediumTest {
   @ClassRule
   public static ServerTester tester = new ServerTester();
 
+  MyBatis myBatis = tester.get(MyBatis.class);
   RuleDao dao = tester.get(RuleDao.class);
-
-  QualityProfileDao qualityProfileDao = tester.get(QualityProfileDao.class);
-
   RuleIndex index = tester.get(RuleIndex.class);
+  DbSession dbSession;
 
   @Before
-  public void clear_data_store() {
+  public void before() {
     tester.clearDataStores();
+    dbSession = myBatis.openSession(false);
+  }
+
+  @After
+  public void after() {
+    dbSession.close();
   }
 
   @Test
   public void insert_in_db_and_index_in_es() {
     // insert db
     RuleKey ruleKey = RuleKey.of("javascript", "S001");
-    dao.insert(newRuleDto(ruleKey));
+    dao.insert(newRuleDto(ruleKey), dbSession);
+    dbSession.commit();
 
     // verify that rule is persisted in db
-    RuleDto persistedDto = dao.selectByKey(ruleKey);
+    RuleDto persistedDto = dao.getByKey(ruleKey, dbSession);
     assertThat(persistedDto).isNotNull();
     assertThat(persistedDto.getId()).isGreaterThanOrEqualTo(0);
     assertThat(persistedDto.getRuleKey()).isEqualTo(ruleKey.rule());
@@ -93,12 +94,11 @@ public class RuleServiceMediumTest {
 
     //TODO    assertThat((Collection) hit.getField(RuleNormalizer.RuleField.SYSTEM_TAGS.key())).isEmpty();
     //TODO    assertThat((Collection) hit.getField(RuleNormalizer.RuleField.TAGS.key())).isEmpty();
+
   }
 
   @Test
   public void insert_and_index_rule_parameters() {
-    DbSession dbSession = tester.get(MyBatis.class).openSession(false);
-
     // insert db
     RuleKey ruleKey = RuleKey.of("javascript", "S001");
     RuleDto ruleDto = newRuleDto(ruleKey);
@@ -106,23 +106,21 @@ public class RuleServiceMediumTest {
     dbSession.commit();
 
     RuleParamDto minParamDto = new RuleParamDto()
-      .setRuleId(ruleDto.getId())
       .setName("min")
       .setType(RuleParamType.INTEGER.type())
       .setDefaultValue("2")
       .setDescription("Minimum");
-    dao.insert(minParamDto, dbSession);
+    dao.addRuleParam(ruleDto, minParamDto, dbSession);
     RuleParamDto maxParamDto = new RuleParamDto()
-      .setRuleId(ruleDto.getId())
       .setName("max")
       .setType(RuleParamType.INTEGER.type())
       .setDefaultValue("10")
       .setDescription("Maximum");
-    dao.insert(maxParamDto, dbSession);
+    dao.addRuleParam(ruleDto, maxParamDto, dbSession);
     dbSession.commit();
 
     // verify that parameters are persisted in db
-    List<RuleParamDto> persistedDtos = dao.selectParametersByRuleId(ruleDto.getId());
+    List<RuleParamDto> persistedDtos = dao.findRuleParamsByRuleKey(ruleKey, dbSession);
     assertThat(persistedDtos).hasSize(2);
 
     // verify that parameters are indexed in es
@@ -139,74 +137,6 @@ public class RuleServiceMediumTest {
     assertThat(Iterables.getLast(rule.params(), null).key()).isEqualTo("max");
   }
 
-  //TODO test delete, update, tags, params
-
-  @Test
-  public void insert_and_index_tags() {
-    DbSession dbSession = tester.get(MyBatis.class).openSession(false);
-    RuleTagDao ruleTagDao = tester.get(RuleTagDao.class);
-
-    // insert db
-    RuleKey ruleKey = RuleKey.of("javascript", "S001");
-    RuleDto ruleDto = newRuleDto(ruleKey);
-    dao.insert(ruleDto, dbSession);
-    dbSession.commit();
-
-    RuleTagDto tag1 = new RuleTagDto()
-      .setTag("hello");
-    RuleTagDto tag2 = new RuleTagDto()
-      .setTag("world");
-    RuleTagDto tag3 = new RuleTagDto()
-      .setTag("AdMiN");
-    ruleTagDao.insert(tag1, dbSession);
-    ruleTagDao.insert(tag2, dbSession);
-    ruleTagDao.insert(tag3, dbSession);
-    dbSession.commit();
-
-    RuleRuleTagDto rTag1 = new RuleRuleTagDto()
-      .setTagId(tag1.getId())
-      .setTag(tag1.getTag())
-      .setRuleId(ruleDto.getId())
-      .setType(RuleTagType.ADMIN);
-    RuleRuleTagDto rTag2 = new RuleRuleTagDto()
-      .setTagId(tag2.getId())
-      .setTag(tag2.getTag())
-      .setRuleId(ruleDto.getId())
-      .setType(RuleTagType.ADMIN);
-    RuleRuleTagDto rTag3 = new RuleRuleTagDto()
-      .setTagId(tag3.getId())
-      .setTag(tag3.getTag())
-      .setRuleId(ruleDto.getId())
-      .setType(RuleTagType.SYSTEM);
-    dao.insert(rTag1, dbSession);
-    dao.insert(rTag2, dbSession);
-    dao.insert(rTag3, dbSession);
-    dbSession.commit();
-    dbSession.close();
-
-
-    // verify that tags are persisted in db
-    List<RuleRuleTagDto> persistedDtos = dao.selectTagsByRuleId(ruleDto.getId());
-    assertThat(persistedDtos).hasSize(3);
-
-    index.refresh();
-
-    // verify that tags are indexed in es
-    index.search(new RuleQuery(), new QueryOptions());
-    Rule hit = index.getByKey(ruleKey);
-    assertThat(hit).isNotNull();
-    assertThat(hit.tags()).containsExactly("hello","world");
-    assertThat(hit.systemTags()).containsExactly("AdMiN");
-
-    RuleService service = tester.get(RuleService.class);
-    Rule rule = service.getByKey(ruleKey);
-    assertThat(rule.tags()).containsExactly("hello","world");
-    assertThat(rule.systemTags()).containsExactly("AdMiN");
-
-    //TODO assertThat(service.listTags()).contains("hello", "world", "AdMiN");
-  }
-
-
   private RuleDto newRuleDto(RuleKey ruleKey) {
     return new RuleDto()
       .setRuleKey(ruleKey.rule())