SONAR-6818 Split batch/project WS in several simpler WS

13 files changed, 262 insertions, 222 deletions

diff --git a/sonar-batch/src/main/java/org/sonar/batch/rule/ActiveRulesLoader.java b/sonar-batch/src/main/java/org/sonar/batch/rule/ActiveRulesLoader.java
index 72f33bdb43c..e66d8ef7403 100644
--- a/sonar-batch/src/main/java/org/sonar/batch/rule/ActiveRulesLoader.java
+++ b/sonar-batch/src/main/java/org/sonar/batch/rule/ActiveRulesLoader.java
@@ -19,7 +19,6 @@
  */
 package org.sonar.batch.rule;
 
-import org.sonarqube.ws.Rules.Rule;
 import org.apache.commons.lang.mutable.MutableBoolean;
 
 import javax.annotation.Nullable;
@@ -27,5 +26,5 @@ import javax.annotation.Nullable;
 import java.util.List;
 
 public interface ActiveRulesLoader {
-  List<Rule> load(String qualityProfileKey, @Nullable MutableBoolean fromCache);
+  List<LoadedActiveRule> load(String qualityProfileKey, @Nullable MutableBoolean fromCache);
 }
diff --git a/sonar-batch/src/main/java/org/sonar/batch/rule/ActiveRulesProvider.java b/sonar-batch/src/main/java/org/sonar/batch/rule/ActiveRulesProvider.java
index 76fffd15264..da9f5211994 100644
--- a/sonar-batch/src/main/java/org/sonar/batch/rule/ActiveRulesProvider.java
+++ b/sonar-batch/src/main/java/org/sonar/batch/rule/ActiveRulesProvider.java
@@ -23,8 +23,6 @@ import org.sonar.api.utils.log.Profiler;
 
 import org.sonar.api.utils.log.Logger;
 import org.sonar.api.utils.log.Loggers;
-import org.sonarqube.ws.Rules.Rule.Param;
-import org.sonarqube.ws.Rules.Rule;
 import org.picocontainer.injectors.ProviderAdapter;
 import org.sonar.api.batch.rule.ActiveRules;
 import org.sonar.api.batch.rule.internal.ActiveRulesBuilder;
@@ -59,16 +57,16 @@ public class ActiveRulesProvider extends ProviderAdapter {
   private static ActiveRules load(ActiveRulesLoader loader, ModuleQProfiles qProfiles) {
 
     Collection<String> qProfileKeys = getKeys(qProfiles);
-    Map<String, Rule> loadedRulesByKey = new HashMap<>();
+    Map<RuleKey, LoadedActiveRule> loadedRulesByKey = new HashMap<>();
 
     try {
       for (String qProfileKey : qProfileKeys) {
-        Collection<Rule> qProfileRules;
+        Collection<LoadedActiveRule> qProfileRules;
         qProfileRules = load(loader, qProfileKey);
 
-        for (Rule r : qProfileRules) {
-          if (!loadedRulesByKey.containsKey(r.getKey())) {
-            loadedRulesByKey.put(r.getKey(), r);
+        for (LoadedActiveRule r : qProfileRules) {
+          if (!loadedRulesByKey.containsKey(r.getRuleKey())) {
+            loadedRulesByKey.put(r.getRuleKey(), r);
           }
         }
       }
@@ -79,20 +77,22 @@ public class ActiveRulesProvider extends ProviderAdapter {
     return transform(loadedRulesByKey.values());
   }
 
-  private static ActiveRules transform(Collection<Rule> loadedRules) {
+  private static ActiveRules transform(Collection<LoadedActiveRule> loadedRules) {
     ActiveRulesBuilder builder = new ActiveRulesBuilder();
 
-    for (Rule activeRule : loadedRules) {
-      NewActiveRule newActiveRule = builder.create(RuleKey.parse(activeRule.getKey()));
+    for (LoadedActiveRule activeRule : loadedRules) {
+      NewActiveRule newActiveRule = builder.create(activeRule.getRuleKey());
       newActiveRule.setName(activeRule.getName());
       newActiveRule.setSeverity(activeRule.getSeverity());
-      newActiveRule.setLanguage(activeRule.getLang());
+      newActiveRule.setLanguage(activeRule.getLanguage());
       newActiveRule.setInternalKey(activeRule.getInternalKey());
-      newActiveRule.setTemplateRuleKey(activeRule.getTemplateKey());
+      newActiveRule.setTemplateRuleKey(activeRule.getTemplateRuleKey());
 
       // load parameters
-      for (Param param : activeRule.getParams().getParamsList()) {
-        newActiveRule.setParam(param.getKey(), param.getDefaultValue());
+      if (activeRule.getParams() != null) {
+        for (Map.Entry<String, String> params : activeRule.getParams().entrySet()) {
+          newActiveRule.setParam(params.getKey(), params.getValue());
+        }
       }
 
       newActiveRule.activate();
@@ -100,7 +100,7 @@ public class ActiveRulesProvider extends ProviderAdapter {
     return builder.build();
   }
 
-  private static List<Rule> load(ActiveRulesLoader loader, String qProfileKey) throws IOException {
+  private static List<LoadedActiveRule> load(ActiveRulesLoader loader, String qProfileKey) throws IOException {
     return loader.load(qProfileKey, null);
   }
 
diff --git a/sonar-batch/src/main/java/org/sonar/batch/rule/DefaultActiveRulesLoader.java b/sonar-batch/src/main/java/org/sonar/batch/rule/DefaultActiveRulesLoader.java
index c752b2f3871..14c37bf1745 100644
--- a/sonar-batch/src/main/java/org/sonar/batch/rule/DefaultActiveRulesLoader.java
+++ b/sonar-batch/src/main/java/org/sonar/batch/rule/DefaultActiveRulesLoader.java
@@ -19,8 +19,11 @@
  */
 package org.sonar.batch.rule;
 
+import org.sonarqube.ws.Rules.Active.Param;
+import org.sonarqube.ws.Rules.Active;
+import org.sonar.api.rule.RuleKey;
+import org.sonarqube.ws.Rules.ActiveList;
 import org.sonarqube.ws.Rules.SearchResponse;
-
 import org.apache.commons.io.IOUtils;
 import org.apache.commons.lang.mutable.MutableBoolean;
 import org.sonar.batch.cache.WSLoader;
@@ -32,10 +35,13 @@ import org.sonarqube.ws.Rules.Rule;
 
 import java.io.IOException;
 import java.io.InputStream;
+import java.util.HashMap;
+import java.util.LinkedList;
 import java.util.List;
+import java.util.Map;
 
 public class DefaultActiveRulesLoader implements ActiveRulesLoader {
-  private static final String RULES_SEARCH_URL = "/api/rules/search.protobuf?ps=500&f=repo,name,severity,lang,internalKey,templateKey,params&activation=true";
+  private static final String RULES_SEARCH_URL = "/api/rules/search.protobuf?f=repo,name,severity,lang,internalKey,templateKey,params,actives&activation=true";
 
   private final WSLoader wsLoader;
 
@@ -44,23 +50,40 @@ public class DefaultActiveRulesLoader implements ActiveRulesLoader {
   }
 
   @Override
-  public List<Rule> load(String qualityProfileKey, @Nullable MutableBoolean fromCache) {
-    WSLoaderResult<InputStream> result = wsLoader.loadStream(getUrl(qualityProfileKey));
-    List<Rule> ruleList = loadFromStream(result.get());
-    if (fromCache != null) {
-      fromCache.setValue(result.isFromCache());
+  public List<LoadedActiveRule> load(String qualityProfileKey, @Nullable MutableBoolean fromCache) {
+    List<LoadedActiveRule> ruleList = new LinkedList<>();
+    int page = 1;
+    int pageSize = 500;
+    int loaded = 0;
+
+    while (true) {
+      WSLoaderResult<InputStream> result = wsLoader.loadStream(getUrl(qualityProfileKey, page, pageSize));
+      SearchResponse response = loadFromStream(result.get());
+      List<LoadedActiveRule> pageRules = readPage(response);
+      ruleList.addAll(pageRules);
+      loaded += response.getPs();
+
+      if (response.getTotal() <= loaded) {
+        break;
+      }
+      page++;
     }
+
     return ruleList;
   }
 
-  private static String getUrl(String qualityProfileKey) {
-    return RULES_SEARCH_URL + "&qprofile=" + qualityProfileKey;
+  private static String getUrl(String qualityProfileKey, int page, int pageSize) {
+    StringBuilder builder = new StringBuilder(1024);
+    builder.append(RULES_SEARCH_URL);
+    builder.append("&qprofile=").append(qualityProfileKey);
+    builder.append("&p=").append(page);
+    builder.append("&ps=").append(pageSize);
+    return builder.toString();
   }
 
-  private static List<Rule> loadFromStream(InputStream is) {
+  private static SearchResponse loadFromStream(InputStream is) {
     try {
-      SearchResponse response = SearchResponse.parseFrom(is);
-      return response.getRulesList();
+      return SearchResponse.parseFrom(is);
     } catch (IOException e) {
       throw new IllegalStateException("Failed to load quality profiles", e);
     } finally {
@@ -68,4 +91,33 @@ public class DefaultActiveRulesLoader implements ActiveRulesLoader {
     }
   }
 
+  private static List<LoadedActiveRule> readPage(SearchResponse response) {
+    List<LoadedActiveRule> loadedRules = new LinkedList<>();
+
+    List<Rule> rulesList = response.getRulesList();
+    Map<String, ActiveList> actives = response.getActives().getActives();
+
+    for (Rule r : rulesList) {
+      ActiveList activeList = actives.get(r.getKey());
+      Active active = activeList.getActiveList(0);
+
+      LoadedActiveRule loadedRule = new LoadedActiveRule();
+      Map<String, String> params = new HashMap<>();
+
+      loadedRule.setRuleKey(RuleKey.parse(r.getKey()));
+      loadedRule.setName(r.getName());
+      loadedRule.setSeverity(active.getSeverity());
+      loadedRule.setLanguage(r.getLang());
+      loadedRule.setInternalKey(r.getInternalKey());
+      loadedRule.setTemplateRuleKey(r.getTemplateKey());
+
+      for (Param param : active.getParamsList()) {
+        params.put(param.getKey(), param.getValue());
+      }
+      loadedRule.setParams(params);
+      loadedRules.add(loadedRule);
+    }
+
+    return loadedRules;
+  }
 }
diff --git a/sonar-batch/src/main/java/org/sonar/batch/rule/LoadedActiveRule.java b/sonar-batch/src/main/java/org/sonar/batch/rule/LoadedActiveRule.java
new file mode 100644
index 00000000000..edd5b2c421e
--- /dev/null
+++ b/sonar-batch/src/main/java/org/sonar/batch/rule/LoadedActiveRule.java
@@ -0,0 +1,91 @@
+/*
+ * 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.batch.rule;
+
+import java.util.Map;
+
+import org.sonar.api.rule.RuleKey;
+
+public class LoadedActiveRule {
+  private RuleKey ruleKey;
+  private String severity;
+  private String name;
+  private String language;
+  private Map<String, String> params;
+  private String templateRuleKey;
+  private String internalKey;
+
+  public RuleKey getRuleKey() {
+    return ruleKey;
+  }
+
+  public void setRuleKey(RuleKey ruleKey) {
+    this.ruleKey = ruleKey;
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  public void setName(String name) {
+    this.name = name;
+  }
+
+  public String getSeverity() {
+    return severity;
+  }
+
+  public void setSeverity(String severity) {
+    this.severity = severity;
+  }
+
+  public String getLanguage() {
+    return language;
+  }
+
+  public void setLanguage(String language) {
+    this.language = language;
+  }
+
+  public Map<String, String> getParams() {
+    return params;
+  }
+
+  public void setParams(Map<String, String> params) {
+    this.params = params;
+  }
+
+  public String getTemplateRuleKey() {
+    return templateRuleKey;
+  }
+
+  public void setTemplateRuleKey(String templateRuleKey) {
+    this.templateRuleKey = templateRuleKey;
+  }
+
+  public String getInternalKey() {
+    return internalKey;
+  }
+
+  public void setInternalKey(String internalKey) {
+    this.internalKey = internalKey;
+  }
+
+}
diff --git a/sonar-batch/src/test/java/org/sonar/batch/cache/NonAssociatedCacheSynchronizerTest.java b/sonar-batch/src/test/java/org/sonar/batch/cache/NonAssociatedCacheSynchronizerTest.java
index 4181b2f16b2..7934c0fed45 100644
--- a/sonar-batch/src/test/java/org/sonar/batch/cache/NonAssociatedCacheSynchronizerTest.java
+++ b/sonar-batch/src/test/java/org/sonar/batch/cache/NonAssociatedCacheSynchronizerTest.java
@@ -19,23 +19,21 @@
  */
 package org.sonar.batch.cache;
 
-import static org.mockito.Mockito.when;
-
-import org.sonarqube.ws.Rules.Rule;
-
-import org.sonarqube.ws.QualityProfiles.WsSearchResponse.QualityProfile;
 import com.google.common.collect.ImmutableList;
+import org.junit.Before;
 import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.sonar.batch.repository.QualityProfileLoader;
+import org.sonar.batch.rule.ActiveRulesLoader;
+import org.sonar.batch.rule.LoadedActiveRule;
+import org.sonarqube.ws.QualityProfiles.WsSearchResponse.QualityProfile;
 
 import java.util.Date;
 
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyNoMoreInteractions;
-import org.mockito.MockitoAnnotations;
-import org.junit.Before;
-import org.mockito.Mock;
-import org.sonar.batch.rule.ActiveRulesLoader;
-import org.sonar.batch.repository.QualityProfileLoader;
+import static org.mockito.Mockito.when;
 
 public class NonAssociatedCacheSynchronizerTest {
   private NonAssociatedCacheSynchronizer synchronizer;
@@ -52,7 +50,7 @@ public class NonAssociatedCacheSynchronizerTest {
     MockitoAnnotations.initMocks(this);
 
     QualityProfile pf = QualityProfile.newBuilder().setKey("profile").setName("profile").setLanguage("lang").build();
-    Rule ar = Rule.newBuilder().build();
+    LoadedActiveRule ar = new LoadedActiveRule();
 
     when(qualityProfileLoader.loadDefault(null)).thenReturn(ImmutableList.of(pf));
     when(activeRulesLoader.load("profile", null)).thenReturn(ImmutableList.of(ar));
diff --git a/sonar-batch/src/test/java/org/sonar/batch/cache/ProjectCacheSynchronizerTest.java b/sonar-batch/src/test/java/org/sonar/batch/cache/ProjectCacheSynchronizerTest.java
index 0d46388d01c..548e6124313 100644
--- a/sonar-batch/src/test/java/org/sonar/batch/cache/ProjectCacheSynchronizerTest.java
+++ b/sonar-batch/src/test/java/org/sonar/batch/cache/ProjectCacheSynchronizerTest.java
@@ -19,6 +19,8 @@
  */
 package org.sonar.batch.cache;
 
+import org.sonar.batch.rule.LoadedActiveRule;
+
 import com.google.common.base.Function;
 import com.google.common.collect.ImmutableList;
 import org.apache.commons.lang.mutable.MutableBoolean;
@@ -49,7 +51,6 @@ import java.util.Date;
 import java.util.HashMap;
 
 import static org.mockito.Matchers.anyBoolean;
-
 import static org.mockito.Matchers.any;
 import static org.mockito.Matchers.anyString;
 import static org.mockito.Matchers.eq;
@@ -97,7 +98,7 @@ public class ProjectCacheSynchronizerTest {
     projectRepositoriesLoader = mock(DefaultProjectRepositoriesLoader.class);
 
     QualityProfile pf = QualityProfile.newBuilder().setKey("profile").setName("profile").setLanguage("lang").build();
-    org.sonarqube.ws.Rules.Rule ar = org.sonarqube.ws.Rules.Rule.newBuilder().build();
+    LoadedActiveRule ar = new LoadedActiveRule();
     ProjectRepositories repo = mock(ProjectRepositories.class);
 
     when(qualityProfileLoader.load(PROJECT_KEY, null, null)).thenReturn(ImmutableList.of(pf));
diff --git a/sonar-batch/src/test/java/org/sonar/batch/mediumtest/BatchMediumTester.java b/sonar-batch/src/test/java/org/sonar/batch/mediumtest/BatchMediumTester.java
index f488d8bfe65..ab8ee270983 100644
--- a/sonar-batch/src/test/java/org/sonar/batch/mediumtest/BatchMediumTester.java
+++ b/sonar-batch/src/test/java/org/sonar/batch/mediumtest/BatchMediumTester.java
@@ -19,8 +19,10 @@
  */
 package org.sonar.batch.mediumtest;
 
-import org.sonar.batch.repository.FileData;
+import org.sonar.api.rule.RuleKey;
 
+import org.sonar.batch.rule.LoadedActiveRule;
+import org.sonar.batch.repository.FileData;
 import org.sonar.api.utils.DateUtils;
 import com.google.common.collect.Table;
 import com.google.common.collect.HashBasedTable;
@@ -217,33 +219,23 @@ public class BatchMediumTester {
       return this;
     }
 
-    public BatchMediumTesterBuilder activateRule(org.sonarqube.ws.Rules.Rule activeRule) {
+    public BatchMediumTesterBuilder activateRule(LoadedActiveRule activeRule) {
       activeRules.addActiveRule(activeRule);
       return this;
     }
 
     public BatchMediumTesterBuilder addActiveRule(String repositoryKey, String ruleKey, @Nullable String templateRuleKey, String name, @Nullable String severity,
       @Nullable String internalKey, @Nullable String languag) {
-
-      org.sonarqube.ws.Rules.Rule.Builder builder = org.sonarqube.ws.Rules.Rule.newBuilder();
-      builder.setRepo(repositoryKey);
-      if (internalKey != null) {
-        builder.setInternalKey(internalKey);
-      }
-      builder.setKey(repositoryKey + ":" + ruleKey);
-      builder.setName(name);
-
-      if (templateRuleKey != null) {
-        builder.setTemplateKey(templateRuleKey);
-      }
-      if (languag != null) {
-        builder.setLang(languag);
-      }
-      if (severity != null) {
-        builder.setSeverity(severity);
-      }
-
-      activeRules.addActiveRule(builder.build());
+      LoadedActiveRule r = new LoadedActiveRule();
+
+      r.setInternalKey(internalKey);
+      r.setRuleKey(RuleKey.of(repositoryKey, ruleKey));
+      r.setName(name);
+      r.setTemplateRuleKey(templateRuleKey);
+      r.setLanguage(languag);
+      r.setSeverity(severity);
+      
+      activeRules.addActiveRule(r);
       return this;
     }
 
@@ -379,14 +371,14 @@ public class BatchMediumTester {
   }
 
   private static class FakeActiveRulesLoader implements ActiveRulesLoader {
-    private List<org.sonarqube.ws.Rules.Rule> activeRules = new LinkedList<>();
+    private List<LoadedActiveRule> activeRules = new LinkedList<>();
 
-    public void addActiveRule(org.sonarqube.ws.Rules.Rule activeRule) {
+    public void addActiveRule(LoadedActiveRule activeRule) {
       this.activeRules.add(activeRule);
     }
 
     @Override
-    public List<org.sonarqube.ws.Rules.Rule> load(String qualityProfileKey, MutableBoolean fromCache) {
+    public List<LoadedActiveRule> load(String qualityProfileKey, MutableBoolean fromCache) {
       return activeRules;
     }
   }
diff --git a/sonar-batch/src/test/java/org/sonar/batch/mediumtest/issues/ChecksMediumTest.java b/sonar-batch/src/test/java/org/sonar/batch/mediumtest/issues/ChecksMediumTest.java
index 29531f3e537..4c58eb3eb68 100644
--- a/sonar-batch/src/test/java/org/sonar/batch/mediumtest/issues/ChecksMediumTest.java
+++ b/sonar-batch/src/test/java/org/sonar/batch/mediumtest/issues/ChecksMediumTest.java
@@ -19,28 +19,28 @@
  */
 package org.sonar.batch.mediumtest.issues;
 
-import org.sonarqube.ws.Rules.Rule.Param;
-
-import org.sonarqube.ws.Rules.Rule.Params;
-
-import javax.annotation.Nullable;
-
 import com.google.common.collect.ImmutableMap;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.List;
-
 import org.apache.commons.io.FileUtils;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
+import org.sonar.api.rule.RuleKey;
 import org.sonar.batch.mediumtest.BatchMediumTester;
 import org.sonar.batch.mediumtest.TaskResult;
 import org.sonar.batch.protocol.output.BatchReport.Issue;
+import org.sonar.batch.rule.LoadedActiveRule;
 import org.sonar.xoo.XooPlugin;
 import org.sonar.xoo.rule.XooRulesDefinition;
+
+import javax.annotation.Nullable;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
 import static org.assertj.core.api.Assertions.assertThat;
 
 public class ChecksMediumTest {
@@ -109,29 +109,21 @@ public class ChecksMediumTest {
     assertThat(foundIssueAtLine2).isTrue();
   }
 
-  private org.sonarqube.ws.Rules.Rule createActiveRuleWithParam(String repositoryKey, String ruleKey, @Nullable String templateRuleKey, String name, @Nullable String severity,
+  private LoadedActiveRule createActiveRuleWithParam(String repositoryKey, String ruleKey, @Nullable String templateRuleKey, String name, @Nullable String severity,
     @Nullable String internalKey, @Nullable String languag, String paramKey, String paramValue) {
-    org.sonarqube.ws.Rules.Rule.Builder builder = org.sonarqube.ws.Rules.Rule.newBuilder();
-    builder.setRepo(repositoryKey);
-    builder.setKey(repositoryKey + ":" + ruleKey);
-    if (templateRuleKey != null) {
-      builder.setTemplateKey(templateRuleKey);
-    }
-    if (languag != null) {
-      builder.setLang(languag);
-    }
-    if (internalKey != null) {
-      builder.setInternalKey(internalKey);
-    }
-    if (severity != null) {
-      builder.setSeverity(severity);
-    }
-    builder.setName(name);
-
-    Param param = Param.newBuilder().setKey(paramKey).setDefaultValue(paramValue).build();
-    Params params = Params.newBuilder().addParams(param).build();
-    builder.setParams(params);
-    return builder.build();
+    LoadedActiveRule r = new LoadedActiveRule();
+
+    r.setInternalKey(internalKey);
+    r.setRuleKey(RuleKey.of(repositoryKey, ruleKey));
+    r.setName(name);
+    r.setTemplateRuleKey(templateRuleKey);
+    r.setLanguage(languag);
+    r.setSeverity(severity);
+
+    Map<String, String> params = new HashMap<>();
+    params.put(paramKey, paramValue);
+    r.setParams(params);
+    return r;
   }
 
 }
diff --git a/sonar-batch/src/test/java/org/sonar/batch/rule/ActiveRulesProviderTest.java b/sonar-batch/src/test/java/org/sonar/batch/rule/ActiveRulesProviderTest.java
index 76a5cf1b07d..f459a341341 100644
--- a/sonar-batch/src/test/java/org/sonar/batch/rule/ActiveRulesProviderTest.java
+++ b/sonar-batch/src/test/java/org/sonar/batch/rule/ActiveRulesProviderTest.java
@@ -28,7 +28,6 @@ import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 import org.sonar.api.batch.rule.ActiveRules;
 import org.sonar.api.rule.RuleKey;
-import org.sonarqube.ws.Rules.Rule;
 
 import java.util.LinkedList;
 import java.util.List;
@@ -52,13 +51,13 @@ public class ActiveRulesProviderTest {
 
   @Test
   public void testCombinationOfRules() {
-    Rule r1 = mockRule("rule1");
-    Rule r2 = mockRule("rule2");
-    Rule r3 = mockRule("rule3");
+    LoadedActiveRule r1 = mockRule("rule1");
+    LoadedActiveRule r2 = mockRule("rule2");
+    LoadedActiveRule r3 = mockRule("rule3");
 
-    List<Rule> qp1Rules = ImmutableList.of(r1, r2);
-    List<Rule> qp2Rules = ImmutableList.of(r2, r3);
-    List<Rule> qp3Rules = ImmutableList.of(r1, r3);
+    List<LoadedActiveRule> qp1Rules = ImmutableList.of(r1, r2);
+    List<LoadedActiveRule> qp2Rules = ImmutableList.of(r2, r3);
+    List<LoadedActiveRule> qp3Rules = ImmutableList.of(r1, r3);
 
     when(loader.load("qp1", null)).thenReturn(qp1Rules);
     when(loader.load("qp2", null)).thenReturn(qp2Rules);
@@ -88,7 +87,10 @@ public class ActiveRulesProviderTest {
     return new ModuleQProfiles(profiles);
   }
 
-  private static Rule mockRule(String name) {
-    return Rule.newBuilder().setName(name).setRepo(name).setKey(name + ":" + name).build();
+  private static LoadedActiveRule mockRule(String name) {
+    LoadedActiveRule r = new LoadedActiveRule();
+    r.setName(name);
+    r.setRuleKey(RuleKey.of(name, name));
+    return r;
   }
 }
diff --git a/sonar-batch/src/test/java/org/sonar/batch/rule/DefaultActiveRulesLoaderTest.java b/sonar-batch/src/test/java/org/sonar/batch/rule/DefaultActiveRulesLoaderTest.java
index 9e96042319f..6c63d0545dc 100644
--- a/sonar-batch/src/test/java/org/sonar/batch/rule/DefaultActiveRulesLoaderTest.java
+++ b/sonar-batch/src/test/java/org/sonar/batch/rule/DefaultActiveRulesLoaderTest.java
@@ -19,7 +19,8 @@
  */
 package org.sonar.batch.rule;
 
-import org.sonarqube.ws.Rules.Rule;
+import org.sonar.api.rule.RuleKey;
+
 import org.sonar.batch.cache.WSLoaderResult;
 import org.sonar.batch.cache.WSLoader;
 import com.google.common.io.Resources;
@@ -30,8 +31,6 @@ import java.io.InputStream;
 import java.util.Collection;
 
 import static org.mockito.Mockito.verify;
-
-import static org.mockito.Matchers.anyString;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verifyNoMoreInteractions;
@@ -50,14 +49,33 @@ public class DefaultActiveRulesLoaderTest {
 
   @Test
   public void feed_real_response() throws IOException {
-    InputStream response = loadResource("active_rule_search.protobuf");
-    when(ws.loadStream(anyString())).thenReturn(new WSLoaderResult<InputStream>(response, false));
-    Collection<Rule> activeRules = loader.load("java-sonar-way-26368", null);
-    assertThat(activeRules).hasSize(100);
+    InputStream response1 = loadResource("active_rule_search1.protobuf");
+    InputStream response2 = loadResource("active_rule_search2.protobuf");
+
+    String req1 = "/api/rules/search.protobuf?f=repo,name,severity,lang,internalKey,templateKey,params,actives&activation=true&qprofile=java-sonar-way-26368&p=1&ps=500";
+    String req2 = "/api/rules/search.protobuf?f=repo,name,severity,lang,internalKey,templateKey,params,actives&activation=true&qprofile=java-sonar-way-26368&p=2&ps=500";
+    when(ws.loadStream(req1)).thenReturn(new WSLoaderResult<InputStream>(response1, false));
+    when(ws.loadStream(req2)).thenReturn(new WSLoaderResult<InputStream>(response2, false));
 
-    verify(ws).loadStream("/api/rules/search.protobuf?ps=500&f=repo,name,severity,lang,internalKey,templateKey,params&activation=true&qprofile=java-sonar-way-26368");
+    Collection<LoadedActiveRule> activeRules = loader.load("java-sonar-way-26368", null);
+    assertThat(activeRules).hasSize(226);
+    assertActiveRule(activeRules);
+    
+    verify(ws).loadStream(req1);
+    verify(ws).loadStream(req2);
     verifyNoMoreInteractions(ws);
+  }
+
+  private static void assertActiveRule(Collection<LoadedActiveRule> activeRules) {
+    RuleKey key = RuleKey.of("squid", "S3008");
+    for (LoadedActiveRule r : activeRules) {
+      if (!r.getRuleKey().equals(key)) {
+        continue;
+      }
 
+      assertThat(r.getParams().get("format")).isEqualTo("^[a-z][a-zA-Z0-9]*$");
+      assertThat(r.getSeverity()).isEqualTo("MINOR");
+    }
   }
 
   private InputStream loadResource(String name) throws IOException {
diff --git a/sonar-batch/src/test/resources/org/sonar/batch/rule/DefaultActiveRulesLoaderTest/active_rule_search.protobuf b/sonar-batch/src/test/resources/org/sonar/batch/rule/DefaultActiveRulesLoaderTest/active_rule_search.protobuf
deleted file mode 100644
index 18d0a1284a8..00000000000
--- a/sonar-batch/src/test/resources/org/sonar/batch/rule/DefaultActiveRulesLoaderTest/active_rule_search.protobuf
+++ /dev/null
@@ -1,105 +0,0 @@
-¾
d"Z
-squid:S1194squid("java.lang.Error" should not be extendedRMAJORbS1194š
java¢
Java"×

-4squid:ObjectFinalizeOverridenCallsSuperFinalizeChecksquidQsuper.finalize() should be called at the end of Object.finalize() implementationsRBLOCKERb.ObjectFinalizeOverridenCallsSuperFinalizeCheckš
java¢
Java"f
-squid:S2078squid1Values passed to LDAP queries should be sanitizedRCRITICALbS2078š
java¢
Java"~
-squid:S1195squidLArray designators "[]" should be located after the type in method signaturesRMINORbS1195š
java¢
Java"k
-
-squid:S106squid;Standard ouputs should not be used directly to log anythingRMAJORbS106š
java¢
Java"Z
-squid:S1192squid(String literals should not be duplicatedRMINORbS1192š
java¢
Java"P
-
-squid:S109squid Magic numbers should not be usedRMINORbS109š
java¢
Java"f
-squid:S2077squid1Values passed to SQL commands should be sanitizedRCRITICALbS2077š
java¢
Java"e
-squid:S2076squid0Values passed to OS commands should be sanitizedRCRITICALbS2076š
java¢
Java"y
-squid:S1193squidGException types should not be tested using "instanceof" in catch blocksRMAJORbS1193š
java¢
Java"]
-squid:S1190squid+Future keywords should not be used as namesRMAJORbS1190š
java¢
Java"b
-squid:S1191squid0Classes from "sun.*" packages should not be usedRMAJORbS1191š
java¢
Java"6
-squid:S1444squid
:RCRITICALbS1444š
java¢
Java"x
-squid:S2864squidF"entrySet()" should be iterated when both the key and value are neededRMAJORbS2864š
java¢
Java"¢

-#squid:RightCurlyBraceStartLineChecksquid@A close curly brace should be located at the beginning of a lineRMINORbRightCurlyBraceStartLineCheckš
java¢
Java"p
-squid:S2070squid;SHA-1 and Message-Digest hash algorithms should not be usedRCRITICALbS2070š
java¢
Java"j
-squid:S1849squid6"Iterator.hasNext()" should not call "Iterator.next()"RBLOCKERbS1849š
java¢
Java"f
-squid:S2301squid4Public methods should not contain selector argumentsRMAJORbS2301š
java¢
Java"
-squid:S1848squidJObjects should not be created to be dropped immediately without being usedRCRITICALbS1848š
java¢
Java"W
-squid:S1199squid%Nested code blocks should not be usedRMAJORbS1199š
java¢
Java"ž

-squid:S1844squidj"Object.wait(...)" should never be called on objects that implement "java.util.concurrent.locks.Condition"RBLOCKERbS1844š
java¢
Java"p
-squid:S1197squid>Array designators "[]" should be on the type, not the variableRMINORbS1197š
java¢
Java"€

-squid:S2066squidK"Serializable" inner classes of non-serializable classes should be "static"RCRITICALbS2066š
java¢
Java"n
-squid:S2065squid<Fields in non-serializable classes should not be "transient"RMINORbS2065š
java¢
Java"R
-squid:S2970squidAssertions should be completeRCRITICALbS2970š
java¢
Java"Y
-squid:S2068squid$Credentials should not be hard-codedRCRITICALbS2068š
java¢
Java"i
-squid:S2974squid7Classes without "public" constructors should be "final"RMAJORbS2974š
java¢
Java"s
-squid:S2976squid>"File.createTempFile" should not be used to create a directoryRCRITICALbS2976š
java¢
Java"Y
-squid:S1068squid'Unused private fields should be removedRMAJORbS1068š
java¢
Java"Q
-squid:S1065squidUnused labels should be removedRMAJORbS1065š
java¢
Java"}
- squid:MethodCyclomaticComplexitysquid!Methods should not be too complexRMAJORbMethodCyclomaticComplexityš
java¢
Java"z
-squid:EmptyStatementUsageChecksquid"Empty statements should be removedRMINORbEmptyStatementUsageCheckš
java¢
Java"W
-squid:S1067squid%Expressions should not be too complexRMAJORbS1067š
java¢
Java"^
-squid:S1066squid,Collapsible "if" statements should be mergedRMAJORbS1066š
java¢
Java"t
-squid:S2061squid?Custom serialization method signatures should meet requirementsRCRITICALbS2061š
java¢
Java"Þ

--squid:RightCurlyBraceSameLineAsNextBlockChecksquidhClose curly brace and the next "else", "catch" and "finally" keywords should be located on the same lineRMINORb'RightCurlyBraceSameLineAsNextBlockCheckš
java¢
Java"V
-squid:S2063squid$Comparators should be "Serializable"RMAJORbS2063š
java¢
Java"i
-squid:S2701squid7Literal boolean values should not be used in assertionsRMAJORbS2701š
java¢
Java"y
-squid:S2059squidG"Serializable" inner classes of "Serializable" classes should be staticRMAJORbS2059š
java¢
Java"a
-squid:S2057squid/"Serializable" classes should have a version idRMAJORbS2057š
java¢
Java"®

-squid:S1596squid|Collections.emptyList(), emptyMap() and emptySet() should be used instead of Collections.EMPTY_LIST, EMPTY_MAP and EMPTY_SETRMAJORbS1596š
java¢
Java"“

-squid:S2055squid^The non-serializable super class of a "Serializable" class must have a no-argument constructorRCRITICALbS2055š
java¢
Java"h
-squid:S1598squid6Package declaration should match source file directoryRMAJORbS1598š
java¢
Java"S
-squid:ParsingErrorsquidJava parser failureRMAJORbParsingErrorš
java¢
Java"•

-
-squid:S881squideIncrement (++) and decrement (--) operators should not be mixed with other operators in an expressionRMAJORbS881š
java¢
Java"v
-squid:S1724squidDDeprecated classes and interfaces should not be extended/implementedRMAJORbS1724š
java¢
Java"w
-squid:S1862squidBRelated "if/else if" statements should not have the same conditionRCRITICALbS1862š
java¢
Java"v
-squid:S1860squidBSynchronization should not be based on Strings or boxed primitivesRBLOCKERbS1860š
java¢
Java"€

-squid:S1317squidN"StringBuilder" and "StringBuffer" should not be instantiated with a characterRMAJORbS1317š
java¢
Java"Q
-squid:S1314squidOctal values should not be usedRMAJORbS1314š
java¢
Java"j
-squid:S1315squid8"CHECKSTYLE:OFF" suppression comments should not be usedRMINORbS1315š
java¢
Java"}
-squid:S2718squidH"DateUtils.truncate" from Apache Commons Lang library should not be usedRCRITICALbS2718š
java¢
Java"s
-squid:IndentationChecksquid+Source code should be indented consistentlyRMINORbIndentationCheckš
java¢
Java"c
-squid:S1451squid/Copyright and license headers should be definedRBLOCKERbS1451š
java¢
Java"p
-squid:S1452squid>Generic wildcard types should not be used in return parametersRMAJORbS1452š
java¢
Java"u
-squid:S1318squid@"object == null" should be used instead of "object.equals(null)"RCRITICALbS1318š
java¢
Java"µ

-squid:S1319squid‚
Declarations should use Java collection interfaces such as "List" rather than specific implementation classes such as "LinkedList"RMAJORbS1319š
java¢
Java"
-squid:S1312squidMLoggers should be "private static final" and should share a naming conventionRMINORbS1312š
java¢
Java"V
-squid:S1313squid$IP addresses should not be hardcodedRMAJORbS1313š
java¢
Java"
-
-squid:S864squidOLimited dependence should be placed on operator precedence rules in expressionsRMAJORbS864š
java¢
Java"a
-squid:S1310squid/"NOPMD" suppression comments should not be usedRMINORbS1310š
java¢
Java"h
-squid:S2447squid3Null should not be returned from a "Boolean" methodRCRITICALbS2447š
java¢
Java"
-squid:S1850squidM"instanceof" operators that always return "true" or "false" should be removedRMAJORbS1850š
java¢
Java"z
-squid:S2583squidFConditions should not unconditionally evaluate to "TRUE" or to "FALSE"RBLOCKERbS2583š
java¢
Java"^
-squid:S1710squid,Annotation repetitions should not be wrappedRMAJORbS1710š
java¢
Java"o
-squid:S2440squid=Classes with only "static" methods should not be instantiatedRMAJORbS2440š
java¢
Java"t
-squid:S2441squid?Non-serializable objects should not be stored in "HttpSessions"RCRITICALbS2441š
java¢
Java"_
-squid:S2442squid+"Lock" objects should not be "synchronized"RBLOCKERbS2442š
java¢
Java"—

-"squid:ObjectFinalizeOverridenChecksquid4The Object.finalize() method should not be overridenRCRITICALbObjectFinalizeOverridenCheckš
java¢
Java"h
-squid:S1858squid6"toString()" should never be called on a String objectRMAJORbS1858š
java¢
Java"t
-squid:S2444squid?Lazy initialization of "static" fields should be "synchronized"RCRITICALbS2444š
java¢
Java"�

-squid:S2445squid[Blocks synchronized on fields should not contain assignments of new objects to those fieldsRBLOCKERbS2445š
java¢
Java"O
-squid:S2446squid"notifyAll" should be usedRCRITICALbS2446š
java¢
Java"k
-squid:S1301squid9"switch" statements should have at least 3 "case" clausesRMINORbS1301š
java¢
Java"f
-squid:S1607squid4Skipped unit tests should be either removed or fixedRMAJORbS1607š
java¢
Java"d
-squid:S1309squid3The @SuppressWarnings annotation should not be usedRINFObS1309š
java¢
Java"z
-squid:S1604squidHAnonymous inner classes containing only one method should become lambdasRMAJORbS1604š
java¢
Java"�

-squid:S1602squidOLamdbas containing only one statement should not nest this statement in a blockRMAJORbS1602š
java¢
Java"{
-squid:ClassCyclomaticComplexitysquid!Classes should not be too complexRMAJORbClassCyclomaticComplexityš
java¢
Java"‹

-squid:S1200squidYClasses should not be coupled to too many other classes (Single Responsibility Principle)RMAJORbS1200š
java¢
Java"q
-squid:S1201squid<Methods named "equals" should override Object.equals(Object)RCRITICALbS1201š
java¢
Java"f
-squid:S1701squid4Fields and methods should not have conflicting namesRMAJORbS1701š
java¢
Java"w
-squid:S1206squidC"equals(Object obj)" and "hashCode()" should be overridden in pairsRBLOCKERbS1206š
java¢
Java"o
-squid:S1700squid=A field should not duplicate the name of its containing classRMAJORbS1700š
java¢
Java"k
-squid:S2178squid6Short-circuit logic should be used in boolean contextsRCRITICALbS2178š
java¢
Java"j
-squid:S2176squid8Class names should not shadow interfaces or superclassesRMAJORbS2176š
java¢
Java"Š

- squid:ForLoopCounterChangedChecksquid."for" loop stop conditions should be invariantRMAJORbForLoopCounterChangedCheckš
java¢
Java"h
-squid:S2175squid3Inappropriate "Collection" calls should not be madeRCRITICALbS2175š
java¢
Java"e
-squid:S2160squid3Subclasses that add fields should override "equals"RMAJORbS2160š
java¢
Java"q
-squid:S2162squid<"equals" methods should be symmetric and work for subclassesRCRITICALbS2162š
java¢
Java"“

-%squid:RedundantThrowsDeclarationChecksquid-Throws declarations should not be superfluousRMINORbRedundantThrowsDeclarationCheckš
java¢
Java"‘

-squid:S1994squid\"for" loop incrementers should modify the variable being tested in the loop's stop conditionRCRITICALbS1994š
java¢
Java"\
-squid:S2165squid*"finalize" should not set fields to "null"RMAJORbS2165š
java¢
Java"[
-squid:S2164squid&Math should not be performed on floatsRCRITICALbS2164š
java¢
Java"f
-squid:S2167squid1"compareTo" should not return "Integer.MIN_VALUE"RCRITICALbS2167š
java¢
Java"x
-squid:S2166squidFClasses named like "Exception" should extend "Exception" or a subclassRMAJORbS2166š
java¢
Java"g
-squid:S2885squid2"Calendars" and "DateFormats" should not be staticRCRITICALbS2885š
java¢
Java"~
-squid:S2694squidLInner classes which do not reference their owning classes should be "static"RMAJORbS2694š
java¢
Java"ƒ

-squid:S2695squidO"PreparedStatement" and "ResultSet" methods should be called with valid indicesRBLOCKERbS2695š
java¢
Java"h
-squid:S2692squid3"indexOf" checks should not be for positive numbersRCRITICALbS2692š
java¢
Java
\ No newline at end of file
diff --git a/sonar-batch/src/test/resources/org/sonar/batch/rule/DefaultActiveRulesLoaderTest/active_rule_search1.protobuf b/sonar-batch/src/test/resources/org/sonar/batch/rule/DefaultActiveRulesLoaderTest/active_rule_search1.protobuf
new file mode 100644
index 00000000000..5544968df4b
--- /dev/null
+++ b/sonar-batch/src/test/resources/org/sonar/batch/rule/DefaultActiveRulesLoaderTest/active_rule_search1.protobuf
diff --git a/sonar-batch/src/test/resources/org/sonar/batch/rule/DefaultActiveRulesLoaderTest/active_rule_search2.protobuf b/sonar-batch/src/test/resources/org/sonar/batch/rule/DefaultActiveRulesLoaderTest/active_rule_search2.protobuf
new file mode 100644
index 00000000000..a23bd1d5d81
--- /dev/null
+++ b/sonar-batch/src/test/resources/org/sonar/batch/rule/DefaultActiveRulesLoaderTest/active_rule_search2.protobuf