SONAR-9567 disable storage of doc source in ES index issues/issue

server/sonar-server/src/main/java/org/sonar/server/issue/index/IssueIndex.java

@@ -58,7 +58,6 @@ import org.sonar.db.organization.OrganizationDto;
 import org.sonar.server.es.EsClient;
 import org.sonar.server.es.EsUtils;
 import org.sonar.server.es.SearchOptions;
-import org.sonar.server.es.SearchResult;
 import org.sonar.server.es.Sorting;
 import org.sonar.server.es.StickyFacetBuilder;
 import org.sonar.server.issue.IssueQuery;
@@ -171,9 +170,8 @@ public class IssueIndex {
     this.sorting.addDefault(IssueIndexDefinition.FIELD_ISSUE_KEY);
   }
 
-  public SearchResult<IssueDoc> search(IssueQuery query, SearchOptions options) {
-    SearchRequestBuilder requestBuilder = client
-      .prepareSearch(INDEX_TYPE_ISSUE);
+  public SearchResponse search(IssueQuery query, SearchOptions options) {
+    SearchRequestBuilder requestBuilder = client.prepareSearch(INDEX_TYPE_ISSUE);
 
     configureSorting(query, requestBuilder);
     configurePagination(options, requestBuilder);
@@ -194,8 +192,8 @@ public class IssueIndex {
     }
 
     configureStickyFacets(query, options, filters, esQuery, requestBuilder);
-    SearchResponse response = requestBuilder.get();
-    return new SearchResult<>(response, IssueDoc::new);
+    requestBuilder.setFetchSource(false);
+    return requestBuilder.get();
   }
 
   /**

server/sonar-server/src/main/java/org/sonar/server/issue/index/IssueIndexDefinition.java

@@ -19,6 +19,7 @@
  */
 package org.sonar.server.issue.index;
 
+import com.google.common.annotations.VisibleForTesting;
 import org.sonar.api.config.Configuration;
 import org.sonar.server.es.IndexDefinition;
 import org.sonar.server.es.IndexType;
@@ -66,9 +67,24 @@ public class IssueIndexDefinition implements IndexDefinition {
   public static final String FIELD_ISSUE_TYPE = "type";
 
   private final Configuration config;
+  private final boolean enableSource;
 
   public IssueIndexDefinition(Configuration config) {
+    this(config, false);
+  }
+
+  private IssueIndexDefinition(Configuration config, boolean enableSource) {
     this.config = config;
+    this.enableSource = enableSource;
+  }
+
+  /**
+   * Keep the document sources in index so that indexer tests can verify content
+   * of indexed documents.
+   */
+  @VisibleForTesting
+  public static IssueIndexDefinition createForTest(Configuration config) {
+    return new IssueIndexDefinition(config, true);
   }
 
   @Override
@@ -80,6 +96,7 @@ public class IssueIndexDefinition implements IndexDefinition {
 
     NewIndex.NewIndexType type = index.createType(INDEX_TYPE_ISSUE.getType());
     type.requireProjectAuthorization();
+    type.setEnableSource(enableSource);
 
     type.stringFieldBuilder(FIELD_ISSUE_ASSIGNEE).disableNorms().addSubFields(SORTABLE_ANALYZER).build();
     type.stringFieldBuilder(FIELD_ISSUE_AUTHOR_LOGIN).disableNorms().build();

server/sonar-server/src/main/java/org/sonar/server/issue/ws/SearchAction.java

@@ -21,6 +21,7 @@ package org.sonar.server.issue.ws;
 
 import com.google.common.collect.Collections2;
 import com.google.common.collect.Lists;
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.EnumSet;
 import java.util.LinkedHashMap;
@@ -28,6 +29,8 @@ import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import javax.annotation.Nullable;
+import org.elasticsearch.action.search.SearchResponse;
+import org.elasticsearch.search.SearchHit;
 import org.sonar.api.issue.Issue;
 import org.sonar.api.rule.RuleKey;
 import org.sonar.api.rule.Severity;
@@ -41,10 +44,8 @@ import org.sonar.api.utils.Paging;
 import org.sonar.core.util.stream.MoreCollectors;
 import org.sonar.server.es.Facets;
 import org.sonar.server.es.SearchOptions;
-import org.sonar.server.es.SearchResult;
 import org.sonar.server.issue.IssueQuery;
 import org.sonar.server.issue.IssueQueryFactory;
-import org.sonar.server.issue.index.IssueDoc;
 import org.sonar.server.issue.index.IssueIndex;
 import org.sonar.server.user.UserSession;
 import org.sonarqube.ws.Issues.SearchWsResponse;
@@ -112,7 +113,7 @@ public class SearchAction implements IssuesWsAction {
   private final SearchResponseFormat searchResponseFormat;
 
   public SearchAction(UserSession userSession, IssueIndex issueIndex, IssueQueryFactory issueQueryFactory,
-    SearchResponseLoader searchResponseLoader, SearchResponseFormat searchResponseFormat) {
+                      SearchResponseLoader searchResponseLoader, SearchResponseFormat searchResponseFormat) {
     this.userSession = userSession;
     this.issueIndex = issueIndex;
     this.issueQueryFactory = issueQueryFactory;
@@ -308,8 +309,10 @@ public class SearchAction implements IssuesWsAction {
     IssueQuery query = issueQueryFactory.create(request);
 
     // execute request
-    SearchResult<IssueDoc> result = issueIndex.search(query, options);
-    List<String> issueKeys = result.getDocs().stream().map(IssueDoc::key).collect(MoreCollectors.toList(result.getDocs().size()));
+    SearchResponse result = issueIndex.search(query, options);
+    List<String> issueKeys = Arrays.stream(result.getHits().getHits())
+      .map(SearchHit::getId)
+      .collect(MoreCollectors.toList(result.getHits().getHits().length));
 
     // load the additional information to be returned in response
     SearchResponseLoader.Collector collector = new SearchResponseLoader.Collector(additionalFields, issueKeys);
@@ -317,7 +320,7 @@ public class SearchAction implements IssuesWsAction {
     collectRequestParams(collector, request);
     Facets facets = null;
     if (!options.getFacets().isEmpty()) {
-      facets = result.getFacets();
+      facets = new Facets(result);
       // add missing values to facets. For example if assignee "john" and facet on "assignees" are requested, then
       // "john" should always be listed in the facet. If it is not present, then it is added with value zero.
       // This is a constraint from webapp UX.
@@ -334,7 +337,7 @@ public class SearchAction implements IssuesWsAction {
     facets = reorderFacets(facets, options.getFacets());
 
     // FIXME allow long in Paging
-    Paging paging = forPageIndex(options.getPage()).withPageSize(options.getLimit()).andTotal((int) result.getTotal());
+    Paging paging = forPageIndex(options.getPage()).withPageSize(options.getLimit()).andTotal((int) result.getHits().totalHits());
 
     return searchResponseFormat.formatSearch(additionalFields, data, paging, facets);
   }

server/sonar-server/src/main/java/org/sonar/server/rule/index/RuleIndexDefinition.java

@@ -19,6 +19,7 @@
  */
 package org.sonar.server.rule.index;
 
+import com.google.common.annotations.VisibleForTesting;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.ImmutableSortedMap;
@@ -93,6 +94,7 @@ public class RuleIndexDefinition implements IndexDefinition {
    * Keep the document sources in index so that indexer tests can verify content
    * of indexed documents.
    */
+  @VisibleForTesting
   public static RuleIndexDefinition createForTest(Configuration config) {
     return new RuleIndexDefinition(config, true);
   }

server/sonar-server/src/test/java/org/sonar/server/issue/index/IssueIndexDebtTest.java

@@ -35,8 +35,8 @@ import org.sonar.db.component.ComponentDto;
 import org.sonar.db.component.ComponentTesting;
 import org.sonar.db.organization.OrganizationDto;
 import org.sonar.server.es.EsTester;
+import org.sonar.server.es.Facets;
 import org.sonar.server.es.SearchOptions;
-import org.sonar.server.es.SearchResult;
 import org.sonar.server.issue.IssueDocTesting;
 import org.sonar.server.issue.IssueQuery;
 import org.sonar.server.issue.IssueQuery.Builder;
@@ -46,7 +46,6 @@ import org.sonar.server.permission.index.PermissionIndexerTester;
 import org.sonar.server.tester.UserSessionRule;
 import org.sonar.server.view.index.ViewIndexDefinition;
 
-import static com.google.common.collect.Lists.newArrayList;
 import static java.util.Arrays.asList;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.entry;
@@ -59,22 +58,22 @@ import static org.sonarqube.ws.client.issue.IssuesWsParameters.FACET_MODE_EFFORT
 public class IssueIndexDebtTest {
 
   @Rule
-  public EsTester tester = new EsTester(new IssueIndexDefinition(new MapSettings().asConfig()), new ViewIndexDefinition(new MapSettings().asConfig()));
+  public EsTester es = new EsTester(new IssueIndexDefinition(new MapSettings().asConfig()), new ViewIndexDefinition(new MapSettings().asConfig()));
 
   @Rule
   public UserSessionRule userSessionRule = UserSessionRule.standalone();
 
   private System2 system2 = System2.INSTANCE;
-  private IssueIndex index;
-  private IssueIndexer issueIndexer = new IssueIndexer(tester.client(), new IssueIteratorFactory(null));
-  private PermissionIndexerTester authorizationIndexerTester = new PermissionIndexerTester(tester, issueIndexer);
+  private IssueIndex underTest;
+  private IssueIndexer issueIndexer = new IssueIndexer(es.client(), new IssueIteratorFactory(null));
+  private PermissionIndexerTester authorizationIndexerTester = new PermissionIndexerTester(es, issueIndexer);
 
   @Before
   public void setUp() {
     System2 system = mock(System2.class);
     when(system.getDefaultTimeZone()).thenReturn(TimeZone.getTimeZone("+01:00"));
     when(system.now()).thenReturn(System.currentTimeMillis());
-    index = new IssueIndex(tester.client(), system, userSessionRule, new AuthorizationTypeSupport(userSessionRule));
+    underTest = new IssueIndex(es.client(), system, userSessionRule, new AuthorizationTypeSupport(userSessionRule));
   }
 
   @Test
@@ -84,15 +83,14 @@ public class IssueIndexDebtTest {
     ComponentDto project2 = ComponentTesting.newPrivateProjectDto(organizationDto, "EFGH");
 
     indexIssues(
-      IssueDocTesting.newDoc("ISSUE1", ComponentTesting.newFileDto(project, null)).setEffort(10L),
-      IssueDocTesting.newDoc("ISSUE2", ComponentTesting.newFileDto(project, null)).setEffort(10L),
-      IssueDocTesting.newDoc("ISSUE3", ComponentTesting.newFileDto(project2, null)).setEffort(10L));
-
-    SearchResult<IssueDoc> result = index.search(newQueryBuilder().build(),
-      new SearchOptions().addFacets(newArrayList("projectUuids")));
-    assertThat(result.getFacets().getNames()).containsOnly("projectUuids", FACET_MODE_EFFORT);
-    assertThat(result.getFacets().get("projectUuids")).containsOnly(entry("ABCD", 20L), entry("EFGH", 10L));
-    assertThat(result.getFacets().get(FACET_MODE_EFFORT)).containsOnly(entry("total", 30L));
+      IssueDocTesting.newDoc("I1", ComponentTesting.newFileDto(project, null)).setEffort(10L),
+      IssueDocTesting.newDoc("I2", ComponentTesting.newFileDto(project, null)).setEffort(10L),
+      IssueDocTesting.newDoc("I3", ComponentTesting.newFileDto(project2, null)).setEffort(10L));
+
+    Facets facets = search("projectUuids");
+    assertThat(facets.getNames()).containsOnly("projectUuids", FACET_MODE_EFFORT);
+    assertThat(facets.get("projectUuids")).containsOnly(entry("ABCD", 20L), entry("EFGH", 10L));
+    assertThat(facets.get(FACET_MODE_EFFORT)).containsOnly(entry("total", 30L));
   }
 
   @Test
@@ -103,17 +101,17 @@ public class IssueIndexDebtTest {
     ComponentDto file3 = ComponentTesting.newFileDto(project, null, "CDEF");
 
     indexIssues(
-      IssueDocTesting.newDoc("ISSUE1", project),
-      IssueDocTesting.newDoc("ISSUE2", file1),
-      IssueDocTesting.newDoc("ISSUE3", file2),
-      IssueDocTesting.newDoc("ISSUE4", file2),
-      IssueDocTesting.newDoc("ISSUE5", file3));
-
-    SearchResult<IssueDoc> result = index.search(newQueryBuilder().build(), new SearchOptions().addFacets(newArrayList("fileUuids")));
-    assertThat(result.getFacets().getNames()).containsOnly("fileUuids", FACET_MODE_EFFORT);
-    assertThat(result.getFacets().get("fileUuids"))
+      IssueDocTesting.newDoc("I1", project),
+      IssueDocTesting.newDoc("I2", file1),
+      IssueDocTesting.newDoc("I3", file2),
+      IssueDocTesting.newDoc("I4", file2),
+      IssueDocTesting.newDoc("I5", file3));
+
+    Facets facets = search("fileUuids");
+    assertThat(facets.getNames()).containsOnly("fileUuids", FACET_MODE_EFFORT);
+    assertThat(facets.get("fileUuids"))
       .containsOnly(entry("A", 10L), entry("ABCD", 10L), entry("BCDE", 20L), entry("CDEF", 10L));
-    assertThat(result.getFacets().get(FACET_MODE_EFFORT)).containsOnly(entry("total", 50L));
+    assertThat(facets.get(FACET_MODE_EFFORT)).containsOnly(entry("total", 50L));
   }
 
   @Test
@@ -123,13 +121,13 @@ public class IssueIndexDebtTest {
     ComponentDto file2 = ComponentTesting.newFileDto(project, null).setPath("F2.xoo");
 
     indexIssues(
-      IssueDocTesting.newDoc("ISSUE1", file1).setDirectoryPath("/src/main/xoo"),
-      IssueDocTesting.newDoc("ISSUE2", file2).setDirectoryPath("/"));
+      IssueDocTesting.newDoc("I1", file1).setDirectoryPath("/src/main/xoo"),
+      IssueDocTesting.newDoc("I2", file2).setDirectoryPath("/"));
 
-    SearchResult<IssueDoc> result = index.search(newQueryBuilder().build(), new SearchOptions().addFacets(newArrayList("directories")));
-    assertThat(result.getFacets().getNames()).containsOnly("directories", FACET_MODE_EFFORT);
-    assertThat(result.getFacets().get("directories")).containsOnly(entry("/src/main/xoo", 10L), entry("/", 10L));
-    assertThat(result.getFacets().get(FACET_MODE_EFFORT)).containsOnly(entry("total", 20L));
+    Facets facets = search("directories");
+    assertThat(facets.getNames()).containsOnly("directories", FACET_MODE_EFFORT);
+    assertThat(facets.get("directories")).containsOnly(entry("/src/main/xoo", 10L), entry("/", 10L));
+    assertThat(facets.get(FACET_MODE_EFFORT)).containsOnly(entry("total", 20L));
   }
 
   @Test
@@ -138,14 +136,14 @@ public class IssueIndexDebtTest {
     ComponentDto file = ComponentTesting.newFileDto(project, null);
 
     indexIssues(
-      IssueDocTesting.newDoc("ISSUE1", file).setSeverity(Severity.INFO),
-      IssueDocTesting.newDoc("ISSUE2", file).setSeverity(Severity.INFO),
-      IssueDocTesting.newDoc("ISSUE3", file).setSeverity(Severity.MAJOR));
-
-    SearchResult<IssueDoc> result = index.search(newQueryBuilder().build(), new SearchOptions().addFacets(newArrayList("severities")));
-    assertThat(result.getFacets().getNames()).containsOnly("severities", FACET_MODE_EFFORT);
-    assertThat(result.getFacets().get("severities")).containsOnly(entry("INFO", 20L), entry("MAJOR", 10L));
-    assertThat(result.getFacets().get(FACET_MODE_EFFORT)).containsOnly(entry("total", 30L));
+      IssueDocTesting.newDoc("I1", file).setSeverity(Severity.INFO),
+      IssueDocTesting.newDoc("I2", file).setSeverity(Severity.INFO),
+      IssueDocTesting.newDoc("I3", file).setSeverity(Severity.MAJOR));
+
+    Facets facets = search("severities");
+    assertThat(facets.getNames()).containsOnly("severities", FACET_MODE_EFFORT);
+    assertThat(facets.get("severities")).containsOnly(entry("INFO", 20L), entry("MAJOR", 10L));
+    assertThat(facets.get(FACET_MODE_EFFORT)).containsOnly(entry("total", 30L));
   }
 
   @Test
@@ -154,14 +152,14 @@ public class IssueIndexDebtTest {
     ComponentDto file = ComponentTesting.newFileDto(project, null);
 
     indexIssues(
-      IssueDocTesting.newDoc("ISSUE1", file).setStatus(Issue.STATUS_CLOSED),
-      IssueDocTesting.newDoc("ISSUE2", file).setStatus(Issue.STATUS_CLOSED),
-      IssueDocTesting.newDoc("ISSUE3", file).setStatus(Issue.STATUS_OPEN));
-
-    SearchResult<IssueDoc> result = index.search(newQueryBuilder().build(), new SearchOptions().addFacets(newArrayList("statuses")));
-    assertThat(result.getFacets().getNames()).containsOnly("statuses", FACET_MODE_EFFORT);
-    assertThat(result.getFacets().get("statuses")).containsOnly(entry("CLOSED", 20L), entry("OPEN", 10L));
-    assertThat(result.getFacets().get(FACET_MODE_EFFORT)).containsOnly(entry("total", 30L));
+      IssueDocTesting.newDoc("I1", file).setStatus(Issue.STATUS_CLOSED),
+      IssueDocTesting.newDoc("I2", file).setStatus(Issue.STATUS_CLOSED),
+      IssueDocTesting.newDoc("I3", file).setStatus(Issue.STATUS_OPEN));
+
+    Facets facets = search("statuses");
+    assertThat(facets.getNames()).containsOnly("statuses", FACET_MODE_EFFORT);
+    assertThat(facets.get("statuses")).containsOnly(entry("CLOSED", 20L), entry("OPEN", 10L));
+    assertThat(facets.get(FACET_MODE_EFFORT)).containsOnly(entry("total", 30L));
   }
 
   @Test
@@ -170,14 +168,14 @@ public class IssueIndexDebtTest {
     ComponentDto file = ComponentTesting.newFileDto(project, null);
 
     indexIssues(
-      IssueDocTesting.newDoc("ISSUE1", file).setResolution(Issue.RESOLUTION_FALSE_POSITIVE),
-      IssueDocTesting.newDoc("ISSUE2", file).setResolution(Issue.RESOLUTION_FALSE_POSITIVE),
-      IssueDocTesting.newDoc("ISSUE3", file).setResolution(Issue.RESOLUTION_FIXED));
-
-    SearchResult<IssueDoc> result = index.search(newQueryBuilder().build(), new SearchOptions().addFacets(newArrayList("resolutions")));
-    assertThat(result.getFacets().getNames()).containsOnly("resolutions", FACET_MODE_EFFORT);
-    assertThat(result.getFacets().get("resolutions")).containsOnly(entry("FALSE-POSITIVE", 20L), entry("FIXED", 10L));
-    assertThat(result.getFacets().get(FACET_MODE_EFFORT)).containsOnly(entry("total", 30L));
+      IssueDocTesting.newDoc("I1", file).setResolution(Issue.RESOLUTION_FALSE_POSITIVE),
+      IssueDocTesting.newDoc("I2", file).setResolution(Issue.RESOLUTION_FALSE_POSITIVE),
+      IssueDocTesting.newDoc("I3", file).setResolution(Issue.RESOLUTION_FIXED));
+
+    Facets facets = search("resolutions");
+    assertThat(facets.getNames()).containsOnly("resolutions", FACET_MODE_EFFORT);
+    assertThat(facets.get("resolutions")).containsOnly(entry("FALSE-POSITIVE", 20L), entry("FIXED", 10L));
+    assertThat(facets.get(FACET_MODE_EFFORT)).containsOnly(entry("total", 30L));
   }
 
   @Test
@@ -186,12 +184,16 @@ public class IssueIndexDebtTest {
     ComponentDto file = ComponentTesting.newFileDto(project, null);
     RuleKey ruleKey = RuleKey.of("repo", "X1");
 
-    indexIssues(IssueDocTesting.newDoc("ISSUE1", file).setRuleKey(ruleKey.toString()).setLanguage("xoo").setEffort(10L));
+    indexIssues(IssueDocTesting.newDoc("I1", file).setRuleKey(ruleKey.toString()).setLanguage("xoo").setEffort(10L));
 
-    SearchResult<IssueDoc> result = index.search(newQueryBuilder().build(), new SearchOptions().addFacets(newArrayList("languages")));
-    assertThat(result.getFacets().getNames()).containsOnly("languages", FACET_MODE_EFFORT);
-    assertThat(result.getFacets().get("languages")).containsOnly(entry("xoo", 10L));
-    assertThat(result.getFacets().get(FACET_MODE_EFFORT)).containsOnly(entry("total", 10L));
+    Facets facets = search("languages");
+    assertThat(facets.getNames()).containsOnly("languages", FACET_MODE_EFFORT);
+    assertThat(facets.get("languages")).containsOnly(entry("xoo", 10L));
+    assertThat(facets.get(FACET_MODE_EFFORT)).containsOnly(entry("total", 10L));
+  }
+
+  private Facets search(String additionalFacet) {
+    return new Facets(underTest.search(newQueryBuilder().build(), new SearchOptions().addFacets(asList(additionalFacet))));
   }
 
   @Test
@@ -200,15 +202,15 @@ public class IssueIndexDebtTest {
     ComponentDto file = ComponentTesting.newFileDto(project, null);
 
     indexIssues(
-      IssueDocTesting.newDoc("ISSUE1", file).setAssignee("steph"),
-      IssueDocTesting.newDoc("ISSUE2", file).setAssignee("simon"),
-      IssueDocTesting.newDoc("ISSUE3", file).setAssignee("simon"),
-      IssueDocTesting.newDoc("ISSUE4", file).setAssignee(null));
-
-    SearchResult<IssueDoc> result = index.search(newQueryBuilder().build(), new SearchOptions().addFacets(newArrayList("assignees")));
-    assertThat(result.getFacets().getNames()).containsOnly("assignees", FACET_MODE_EFFORT);
-    assertThat(result.getFacets().get("assignees")).containsOnly(entry("steph", 10L), entry("simon", 20L), entry("", 10L));
-    assertThat(result.getFacets().get(FACET_MODE_EFFORT)).containsOnly(entry("total", 40L));
+      IssueDocTesting.newDoc("I1", file).setAssignee("steph"),
+      IssueDocTesting.newDoc("I2", file).setAssignee("simon"),
+      IssueDocTesting.newDoc("I3", file).setAssignee("simon"),
+      IssueDocTesting.newDoc("I4", file).setAssignee(null));
+
+    Facets facets = new Facets(underTest.search(newQueryBuilder().build(), new SearchOptions().addFacets(asList("assignees"))));
+    assertThat(facets.getNames()).containsOnly("assignees", FACET_MODE_EFFORT);
+    assertThat(facets.get("assignees")).containsOnly(entry("steph", 10L), entry("simon", 20L), entry("", 10L));
+    assertThat(facets.get(FACET_MODE_EFFORT)).containsOnly(entry("total", 40L));
   }
 
   @Test
@@ -217,24 +219,23 @@ public class IssueIndexDebtTest {
     ComponentDto file = ComponentTesting.newFileDto(project, null);
 
     indexIssues(
-      IssueDocTesting.newDoc("ISSUE1", file).setAuthorLogin("steph"),
-      IssueDocTesting.newDoc("ISSUE2", file).setAuthorLogin("simon"),
-      IssueDocTesting.newDoc("ISSUE3", file).setAuthorLogin("simon"),
-      IssueDocTesting.newDoc("ISSUE4", file).setAuthorLogin(null));
-
-    SearchResult<IssueDoc> result = index.search(newQueryBuilder().build(), new SearchOptions().addFacets(newArrayList("authors")));
-    assertThat(result.getFacets().getNames()).containsOnly("authors", FACET_MODE_EFFORT);
-    assertThat(result.getFacets().get("authors")).containsOnly(entry("steph", 10L), entry("simon", 20L));
-    assertThat(result.getFacets().get(FACET_MODE_EFFORT)).containsOnly(entry("total", 40L));
+      IssueDocTesting.newDoc("I1", file).setAuthorLogin("steph"),
+      IssueDocTesting.newDoc("I2", file).setAuthorLogin("simon"),
+      IssueDocTesting.newDoc("I3", file).setAuthorLogin("simon"),
+      IssueDocTesting.newDoc("I4", file).setAuthorLogin(null));
+
+    Facets facets = new Facets(underTest.search(newQueryBuilder().build(), new SearchOptions().addFacets(asList("authors"))));
+    assertThat(facets.getNames()).containsOnly("authors", FACET_MODE_EFFORT);
+    assertThat(facets.get("authors")).containsOnly(entry("steph", 10L), entry("simon", 20L));
+    assertThat(facets.get(FACET_MODE_EFFORT)).containsOnly(entry("total", 40L));
   }
 
   @Test
   public void facet_on_created_at() {
-    SearchOptions SearchOptions = fixtureForCreatedAtFacet();
+    SearchOptions searchOptions = fixtureForCreatedAtFacet();
 
-    Map<String, Long> createdAt = index.search(newQueryBuilder()
-      .createdBefore(DateUtils.parseDateTime("2016-01-01T00:00:00+0100")).build(),
-      SearchOptions).getFacets().get("createdAt");
+    Builder query = newQueryBuilder().createdBefore(DateUtils.parseDateTime("2016-01-01T00:00:00+0100"));
+    Map<String, Long> createdAt = new Facets(underTest.search(query.build(), searchOptions)).get("createdAt");
     assertThat(createdAt).containsOnly(
       entry("2011-01-01T00:00:00+0000", 10L),
       entry("2012-01-01T00:00:00+0000", 0L),
@@ -250,28 +251,28 @@ public class IssueIndexDebtTest {
     ComponentDto project2 = ComponentTesting.newPrivateProjectDto(organizationDto, "EFGH");
 
     indexIssues(
-      IssueDocTesting.newDoc("ISSUE1", ComponentTesting.newFileDto(project, null)).setEffort(10L),
-      IssueDocTesting.newDoc("ISSUE2", ComponentTesting.newFileDto(project, null)).setEffort(10L),
-      IssueDocTesting.newDoc("ISSUE3", ComponentTesting.newFileDto(project2, null)).setEffort(10L));
-
-    SearchResult<IssueDoc> result = index.search(IssueQuery.builder().facetMode(DEPRECATED_FACET_MODE_DEBT).build(),
-      new SearchOptions().addFacets(newArrayList("projectUuids")));
-    assertThat(result.getFacets().getNames()).containsOnly("projectUuids", FACET_MODE_EFFORT);
-    assertThat(result.getFacets().get("projectUuids")).containsOnly(entry("ABCD", 20L), entry("EFGH", 10L));
-    assertThat(result.getFacets().get(FACET_MODE_EFFORT)).containsOnly(entry("total", 30L));
+      IssueDocTesting.newDoc("I1", ComponentTesting.newFileDto(project, null)).setEffort(10L),
+      IssueDocTesting.newDoc("I2", ComponentTesting.newFileDto(project, null)).setEffort(10L),
+      IssueDocTesting.newDoc("I3", ComponentTesting.newFileDto(project2, null)).setEffort(10L));
+
+    Facets facets = new Facets(underTest.search(IssueQuery.builder().facetMode(DEPRECATED_FACET_MODE_DEBT).build(),
+      new SearchOptions().addFacets(asList("projectUuids"))));
+    assertThat(facets.getNames()).containsOnly("projectUuids", FACET_MODE_EFFORT);
+    assertThat(facets.get("projectUuids")).containsOnly(entry("ABCD", 20L), entry("EFGH", 10L));
+    assertThat(facets.get(FACET_MODE_EFFORT)).containsOnly(entry("total", 30L));
   }
 
-  protected SearchOptions fixtureForCreatedAtFacet() {
+  private SearchOptions fixtureForCreatedAtFacet() {
     ComponentDto project = ComponentTesting.newPrivateProjectDto(newOrganizationDto());
     ComponentDto file = ComponentTesting.newFileDto(project, null);
 
     IssueDoc issue0 = IssueDocTesting.newDoc("ISSUE0", file).setFuncCreationDate(DateUtils.parseDateTime("2011-04-25T01:05:13+0100"));
-    IssueDoc issue1 = IssueDocTesting.newDoc("ISSUE1", file).setFuncCreationDate(DateUtils.parseDateTime("2014-09-01T12:34:56+0100"));
-    IssueDoc issue2 = IssueDocTesting.newDoc("ISSUE2", file).setFuncCreationDate(DateUtils.parseDateTime("2014-09-01T23:46:00+0100"));
-    IssueDoc issue3 = IssueDocTesting.newDoc("ISSUE3", file).setFuncCreationDate(DateUtils.parseDateTime("2014-09-02T12:34:56+0100"));
-    IssueDoc issue4 = IssueDocTesting.newDoc("ISSUE4", file).setFuncCreationDate(DateUtils.parseDateTime("2014-09-05T12:34:56+0100"));
-    IssueDoc issue5 = IssueDocTesting.newDoc("ISSUE5", file).setFuncCreationDate(DateUtils.parseDateTime("2014-09-20T12:34:56+0100"));
-    IssueDoc issue6 = IssueDocTesting.newDoc("ISSUE6", file).setFuncCreationDate(DateUtils.parseDateTime("2015-01-18T12:34:56+0100"));
+    IssueDoc issue1 = IssueDocTesting.newDoc("I1", file).setFuncCreationDate(DateUtils.parseDateTime("2014-09-01T12:34:56+0100"));
+    IssueDoc issue2 = IssueDocTesting.newDoc("I2", file).setFuncCreationDate(DateUtils.parseDateTime("2014-09-01T23:46:00+0100"));
+    IssueDoc issue3 = IssueDocTesting.newDoc("I3", file).setFuncCreationDate(DateUtils.parseDateTime("2014-09-02T12:34:56+0100"));
+    IssueDoc issue4 = IssueDocTesting.newDoc("I4", file).setFuncCreationDate(DateUtils.parseDateTime("2014-09-05T12:34:56+0100"));
+    IssueDoc issue5 = IssueDocTesting.newDoc("I5", file).setFuncCreationDate(DateUtils.parseDateTime("2014-09-20T12:34:56+0100"));
+    IssueDoc issue6 = IssueDocTesting.newDoc("I6", file).setFuncCreationDate(DateUtils.parseDateTime("2015-01-18T12:34:56+0100"));
 
     indexIssues(issue0, issue1, issue2, issue3, issue4, issue5, issue6);
 

server/sonar-server/src/test/java/org/sonar/server/issue/index/IssueIndexerTest.java

@@ -54,7 +54,7 @@ public class IssueIndexerTest {
   private System2 system2 = System2.INSTANCE;
 
   @Rule
-  public EsTester esTester = new EsTester(new IssueIndexDefinition(new MapSettings().asConfig()));
+  public EsTester esTester = new EsTester(IssueIndexDefinition.createForTest(new MapSettings().asConfig()));
   @Rule
   public DbTester dbTester = DbTester.create(system2);
   @Rule

server/sonar-server/src/test/java/org/sonar/server/view/index/ViewIndexerTest.java

@@ -22,6 +22,7 @@ package org.sonar.server.view.index;
 import com.google.common.collect.Maps;
 import java.util.List;
 import java.util.Map;
+import org.elasticsearch.action.search.SearchResponse;
 import org.junit.Rule;
 import org.junit.Test;
 import org.sonar.api.config.internal.MapSettings;
@@ -38,9 +39,7 @@ import org.sonar.db.rule.RuleDto;
 import org.sonar.db.rule.RuleTesting;
 import org.sonar.server.es.EsTester;
 import org.sonar.server.es.SearchOptions;
-import org.sonar.server.es.SearchResult;
 import org.sonar.server.issue.IssueQuery;
-import org.sonar.server.issue.index.IssueDoc;
 import org.sonar.server.issue.index.IssueIndex;
 import org.sonar.server.issue.index.IssueIndexDefinition;
 import org.sonar.server.issue.index.IssueIndexer;
@@ -145,8 +144,8 @@ public class ViewIndexerTest {
     underTest.index(viewUuid);
 
     // Execute issue query on view -> 1 issue on view
-    SearchResult<IssueDoc> docs = issueIndex.search(IssueQuery.builder().viewUuids(newArrayList(viewUuid)).build(), new SearchOptions());
-    assertThat(docs.getDocs()).hasSize(1);
+    SearchResponse issueResponse = issueIndex.search(IssueQuery.builder().viewUuids(newArrayList(viewUuid)).build(), new SearchOptions());
+    assertThat(issueResponse.getHits().getHits()).hasSize(1);
 
     // Add a project to the view and index it again
     ComponentDto project2 = addProjectWithIssue(rule, organizationDto);
@@ -159,7 +158,7 @@ public class ViewIndexerTest {
     underTest.index(viewUuid);
 
     // Execute issue query on view -> issue of project2 are well taken into account : the cache has been cleared
-    assertThat(issueIndex.search(IssueQuery.builder().viewUuids(newArrayList(viewUuid)).build(), new SearchOptions()).getDocs()).hasSize(2);
+    assertThat(issueIndex.search(IssueQuery.builder().viewUuids(newArrayList(viewUuid)).build(), new SearchOptions()).getHits()).hasSize(2);
   }
 
   private ComponentDto addProjectWithIssue(RuleDto rule, OrganizationDto org) {