DATAES-106 - Add support for countBy projection

src/main/java/org/springframework/data/elasticsearch/core/ElasticsearchOperations.java

@@ -30,6 +30,7 @@ import org.springframework.data.elasticsearch.core.query.*;
  *
  * @author Rizwan Idrees
  * @author Mohsin Husen
+ * @author Kevin Leturc
  */
 public interface ElasticsearchOperations {
 
@@ -246,6 +247,23 @@ public interface ElasticsearchOperations {
 	 */
 	<T> List<String> queryForIds(SearchQuery query);
 
+	/**
+	 * return number of elements found by given query
+	 *
+	 * @param query
+	 * @param clazz
+	 * @return
+	 */
+	<T> long count(CriteriaQuery query, Class<T> clazz);
+
+	/**
+	 * return number of elements found by given query
+	 *
+	 * @param query
+	 * @return
+	 */
+	<T> long count(CriteriaQuery query);
+
 	/**
 	 * return number of elements found by given query
 	 *

src/main/java/org/springframework/data/elasticsearch/core/ElasticsearchTemplate.java

@@ -50,6 +50,7 @@ import org.elasticsearch.action.index.IndexRequestBuilder;
 import org.elasticsearch.action.mlt.MoreLikeThisRequestBuilder;
 import org.elasticsearch.action.search.SearchRequestBuilder;
 import org.elasticsearch.action.search.SearchResponse;
+import org.elasticsearch.action.search.SearchType;
 import org.elasticsearch.action.update.UpdateRequestBuilder;
 import org.elasticsearch.action.update.UpdateResponse;
 import org.elasticsearch.client.Client;
@@ -96,6 +97,7 @@ import org.springframework.util.Assert;
  * @author Rizwan Idrees
  * @author Mohsin Husen
  * @author Artur Konczak
+ * @author Kevin Leturc
  */
 
 public class ElasticsearchTemplate implements ElasticsearchOperations, ApplicationContextAware {
@@ -317,10 +319,65 @@ public class ElasticsearchTemplate implements ElasticsearchOperations, Applicati
 		return mapper.mapResults(response, clazz, query.getPageable());
 	}
 
+	@Override
+	public <T> long count(CriteriaQuery criteriaQuery, Class<T> clazz) {
+		QueryBuilder elasticsearchQuery = new CriteriaQueryProcessor().createQueryFromCriteria(criteriaQuery.getCriteria());
+		FilterBuilder elasticsearchFilter = new CriteriaFilterProcessor().createFilterFromCriteria(criteriaQuery.getCriteria());
+
+		if (elasticsearchFilter == null) {
+			return doCount(prepareCount(criteriaQuery, clazz), elasticsearchQuery);
+		} else {
+			// filter could not be set into CountRequestBuilder, convert request into search request
+			return doCount(prepareSearch(criteriaQuery, clazz), elasticsearchQuery, elasticsearchFilter);
+		}
+	}
+
 	@Override
 	public <T> long count(SearchQuery searchQuery, Class<T> clazz) {
-		String indexName[] = isNotEmpty(searchQuery.getIndices()) ? searchQuery.getIndices().toArray(new String[searchQuery.getIndices().size()]) : retrieveIndexNameFromPersistentEntity(clazz);
-		String types[] = isNotEmpty(searchQuery.getTypes()) ? searchQuery.getTypes().toArray(new String[searchQuery.getTypes().size()]) : retrieveTypeFromPersistentEntity(clazz);
+		QueryBuilder elasticsearchQuery = searchQuery.getQuery();
+		FilterBuilder elasticsearchFilter = searchQuery.getFilter();
+
+		if (elasticsearchFilter == null) {
+			return doCount(prepareCount(searchQuery, clazz), elasticsearchQuery);
+		} else {
+			// filter could not be set into CountRequestBuilder, convert request into search request
+			return doCount(prepareSearch(searchQuery, clazz), elasticsearchQuery, elasticsearchFilter);
+		}
+	}
+
+	@Override
+	public <T> long count(CriteriaQuery query) {
+		return count(query, null);
+	}
+
+	@Override
+	public <T> long count(SearchQuery query) {
+		return count(query, null);
+	}
+
+	private long doCount(CountRequestBuilder countRequestBuilder, QueryBuilder elasticsearchQuery) {
+		if (elasticsearchQuery != null) {
+			countRequestBuilder.setQuery(elasticsearchQuery);
+		}
+		return countRequestBuilder.execute().actionGet().getCount();
+	}
+
+	private long doCount(SearchRequestBuilder searchRequestBuilder, QueryBuilder elasticsearchQuery, FilterBuilder elasticsearchFilter) {
+		if (elasticsearchQuery != null) {
+			searchRequestBuilder.setQuery(elasticsearchQuery);
+		} else {
+			searchRequestBuilder.setQuery(QueryBuilders.matchAllQuery());
+		}
+		if (elasticsearchFilter != null) {
+			searchRequestBuilder.setPostFilter(elasticsearchFilter);
+		}
+		searchRequestBuilder.setSearchType(SearchType.COUNT);
+		return searchRequestBuilder.execute().actionGet().getHits().getTotalHits();
+	}
+
+	private <T> CountRequestBuilder prepareCount(Query query, Class<T> clazz) {
+		String indexName[] = isNotEmpty(query.getIndices()) ? query.getIndices().toArray(new String[query.getIndices().size()]) : retrieveIndexNameFromPersistentEntity(clazz);
+		String types[] = isNotEmpty(query.getTypes()) ? query.getTypes().toArray(new String[query.getTypes().size()]) : retrieveTypeFromPersistentEntity(clazz);
 
 		Assert.notNull(indexName, "No index defined for Query");
 
@@ -329,15 +386,7 @@ public class ElasticsearchTemplate implements ElasticsearchOperations, Applicati
 		if (types != null) {
 			countRequestBuilder.setTypes(types);
 		}
-		if (searchQuery.getQuery() != null) {
-			countRequestBuilder.setQuery(searchQuery.getQuery());
-		}
-		return countRequestBuilder.execute().actionGet().getCount();
-	}
-
-	@Override
-	public <T> long count(SearchQuery query) {
-		return count(query, null);
+		return countRequestBuilder;
 	}
 
 	@Override

src/main/java/org/springframework/data/elasticsearch/repository/query/ElasticsearchPartQuery.java

@@ -28,6 +28,7 @@ import org.springframework.data.repository.query.parser.PartTree;
  *
  * @author Rizwan Idrees
  * @author Mohsin Husen
+ * @author Kevin Leturc
  */
 public class ElasticsearchPartQuery extends AbstractElasticsearchRepositoryQuery {
 
@@ -52,6 +53,8 @@ public class ElasticsearchPartQuery extends AbstractElasticsearchRepositoryQuery
 				query.setPageable(accessor.getPageable());
 			}
 			return elasticsearchOperations.queryForList(query, queryMethod.getEntityInformation().getJavaType());
+		} else if (tree.isCountProjection()) {
+			return elasticsearchOperations.count(query, queryMethod.getEntityInformation().getJavaType());
 		}
 		return elasticsearchOperations.queryForObject(query, queryMethod.getEntityInformation().getJavaType());
 	}

src/main/java/org/springframework/data/elasticsearch/repository/query/ElasticsearchQueryMethod.java

@@ -19,8 +19,6 @@ import java.lang.reflect.Method;
 
 import org.springframework.core.annotation.AnnotationUtils;
 import org.springframework.data.elasticsearch.annotations.Query;
-import org.springframework.data.elasticsearch.repository.support.ElasticsearchEntityInformation;
-import org.springframework.data.elasticsearch.repository.support.ElasticsearchEntityInformationCreator;
 import org.springframework.data.repository.core.RepositoryMetadata;
 import org.springframework.data.repository.query.QueryMethod;
 import org.springframework.util.StringUtils;
@@ -33,14 +31,10 @@ import org.springframework.util.StringUtils;
  */
 public class ElasticsearchQueryMethod extends QueryMethod {
 
-	private final ElasticsearchEntityInformation<?, ?> entityInformation;
 	private Method method;
 
-	public ElasticsearchQueryMethod(Method method, RepositoryMetadata metadata,
-									ElasticsearchEntityInformationCreator elasticsearchEntityInformationCreator) {
+	public ElasticsearchQueryMethod(Method method, RepositoryMetadata metadata) {
 		super(method, metadata);
-		this.entityInformation = elasticsearchEntityInformationCreator.getEntityInformation(metadata
-				.getReturnedDomainClass(method));
 		this.method = method;
 	}
 

src/main/java/org/springframework/data/elasticsearch/repository/support/ElasticsearchRepositoryFactory.java

@@ -105,7 +105,7 @@ public class ElasticsearchRepositoryFactory extends RepositoryFactorySupport {
 		@Override
 		public RepositoryQuery resolveQuery(Method method, RepositoryMetadata metadata, NamedQueries namedQueries) {
 
-			ElasticsearchQueryMethod queryMethod = new ElasticsearchQueryMethod(method, metadata, entityInformationCreator);
+			ElasticsearchQueryMethod queryMethod = new ElasticsearchQueryMethod(method, metadata);
 			String namedQueryName = queryMethod.getNamedQueryName();
 
 			if (namedQueries.hasQuery(namedQueryName)) {

src/test/java/org/springframework/data/elasticsearch/core/ElasticsearchTemplateTests.java

@@ -58,6 +58,7 @@ import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  * @author Mohsin Husen
  * @author Franck Marchand
  * @author Abdul Mohammed
+ * @author Kevin Leturc
  */
 @RunWith(SpringJUnit4ClassRunner.class)
 @ContextConfiguration("classpath:elasticsearch-template-test.xml")
@@ -80,6 +81,26 @@ public class ElasticsearchTemplateTests {
 		elasticsearchTemplate.refresh(SampleEntity.class, true);
 	}
 
+	/*
+	DATAES-106
+	 */
+	@Test
+	public void shouldReturnCountForGivenCriteriaQuery() {
+		// given
+		String documentId = randomNumeric(5);
+		SampleEntity sampleEntity = new SampleEntityBuilder(documentId).message("some message")
+				.version(System.currentTimeMillis()).build();
+
+		IndexQuery indexQuery = getIndexQuery(sampleEntity);
+		elasticsearchTemplate.index(indexQuery);
+		elasticsearchTemplate.refresh(SampleEntity.class, true);
+		CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria());
+		// when
+		long count = elasticsearchTemplate.count(criteriaQuery, SampleEntity.class);
+		// then
+		assertThat(count, is(equalTo(1L)));
+	}
+
 	@Test
 	public void shouldReturnCountForGivenSearchQuery() {
 		// given
@@ -1187,6 +1208,27 @@ public class ElasticsearchTemplateTests {
 		assertThat(sampleEntities.getTotalElements(), greaterThanOrEqualTo(1L));
 	}
 
+	/*
+	DATAES-106
+	 */
+	@Test
+	public void shouldReturnCountForGivenCriteriaQueryWithGivenIndexUsingCriteriaQuery() {
+		// given
+		String documentId = randomNumeric(5);
+		SampleEntity sampleEntity = new SampleEntityBuilder(documentId).message("some message")
+				.version(System.currentTimeMillis()).build();
+
+		IndexQuery indexQuery = getIndexQuery(sampleEntity);
+		elasticsearchTemplate.index(indexQuery);
+		elasticsearchTemplate.refresh(SampleEntity.class, true);
+		CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria());
+		criteriaQuery.addIndices("test-index");
+		// when
+		long count = elasticsearchTemplate.count(criteriaQuery);
+		// then
+		assertThat(count, is(equalTo(1L)));
+	}
+
 	/*
 	DATAES-67
 	 */
@@ -1210,6 +1252,28 @@ public class ElasticsearchTemplateTests {
 		assertThat(count, is(equalTo(1L)));
 	}
 
+	/*
+	DATAES-106
+	 */
+	@Test
+	public void shouldReturnCountForGivenCriteriaQueryWithGivenIndexAndTypeUsingCriteriaQuery() {
+		// given
+		String documentId = randomNumeric(5);
+		SampleEntity sampleEntity = new SampleEntityBuilder(documentId).message("some message")
+				.version(System.currentTimeMillis()).build();
+
+		IndexQuery indexQuery = getIndexQuery(sampleEntity);
+		elasticsearchTemplate.index(indexQuery);
+		elasticsearchTemplate.refresh(SampleEntity.class, true);
+		CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria());
+		criteriaQuery.addIndices("test-index");
+		criteriaQuery.addTypes("test-type");
+		// when
+		long count = elasticsearchTemplate.count(criteriaQuery);
+		// then
+		assertThat(count, is(equalTo(1L)));
+	}
+
 	/*
 	DATAES-67
 	 */
@@ -1234,6 +1298,43 @@ public class ElasticsearchTemplateTests {
 		assertThat(count, is(equalTo(1L)));
 	}
 
+	/*
+	DATAES-106
+	 */
+	@Test
+	public void shouldReturnCountForGivenCriteriaQueryWithGivenMultiIndices() {
+		// given
+		cleanUpIndices();
+		String documentId1 = randomNumeric(5);
+		SampleEntity sampleEntity1 = new SampleEntityBuilder(documentId1).message("some message")
+				.version(System.currentTimeMillis()).build();
+
+		IndexQuery indexQuery1 = new IndexQueryBuilder().withId(sampleEntity1.getId())
+				.withIndexName("test-index-1")
+				.withObject(sampleEntity1)
+				.build();
+
+		String documentId2 = randomNumeric(5);
+		SampleEntity sampleEntity2 = new SampleEntityBuilder(documentId2).message("some test message")
+				.version(System.currentTimeMillis()).build();
+
+		IndexQuery indexQuery2 = new IndexQueryBuilder().withId(sampleEntity2.getId())
+				.withIndexName("test-index-2")
+				.withObject(sampleEntity2)
+				.build();
+
+		elasticsearchTemplate.bulkIndex(Arrays.asList(indexQuery1, indexQuery2));
+		elasticsearchTemplate.refresh("test-index-1", true);
+		elasticsearchTemplate.refresh("test-index-2", true);
+
+		CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria());
+		criteriaQuery.addIndices("test-index-1", "test-index-2");
+		// when
+		long count = elasticsearchTemplate.count(criteriaQuery);
+		// then
+		assertThat(count, is(equalTo(2L)));
+	}
+
 	/*
 	DATAES-67
 	 */
@@ -1310,6 +1411,43 @@ public class ElasticsearchTemplateTests {
 		assertThat(elasticsearchTemplate.indexExists("test-index"), is(false));
 	}
 
+	/*
+	DATAES-106
+	 */
+	@Test
+	public void shouldReturnCountForGivenCriteriaQueryWithGivenIndexNameForSpecificIndex() {
+		// given
+		cleanUpIndices();
+		String documentId1 = randomNumeric(5);
+		SampleEntity sampleEntity1 = new SampleEntityBuilder(documentId1).message("some message")
+				.version(System.currentTimeMillis()).build();
+
+		IndexQuery indexQuery1 = new IndexQueryBuilder().withId(sampleEntity1.getId())
+				.withIndexName("test-index-1")
+				.withObject(sampleEntity1)
+				.build();
+
+		String documentId2 = randomNumeric(5);
+		SampleEntity sampleEntity2 = new SampleEntityBuilder(documentId2).message("some test message")
+				.version(System.currentTimeMillis()).build();
+
+		IndexQuery indexQuery2 = new IndexQueryBuilder().withId(sampleEntity2.getId())
+				.withIndexName("test-index-2")
+				.withObject(sampleEntity2)
+				.build();
+
+		elasticsearchTemplate.bulkIndex(Arrays.asList(indexQuery1, indexQuery2));
+		elasticsearchTemplate.refresh("test-index-1", true);
+		elasticsearchTemplate.refresh("test-index-2", true);
+
+		CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria());
+		criteriaQuery.addIndices("test-index-1");
+		// when
+		long count = elasticsearchTemplate.count(criteriaQuery);
+		// then
+		assertThat(count, is(equalTo(1L)));
+	}
+
 	/*
 	DATAES-67
 	*/
@@ -1349,11 +1487,28 @@ public class ElasticsearchTemplateTests {
 		assertThat(count, is(equalTo(1L)));
 	}
 
+	@Test(expected = IllegalArgumentException.class)
+	public void shouldThrowAnExceptionForGivenCriteriaQueryWhenNoIndexSpecifiedForCountQuery() {
+		// given
+		String documentId = randomNumeric(5);
+		SampleEntity sampleEntity = new SampleEntityBuilder(documentId).message("some message")
+				.version(System.currentTimeMillis()).build();
+
+		IndexQuery indexQuery = getIndexQuery(sampleEntity);
+		elasticsearchTemplate.index(indexQuery);
+		elasticsearchTemplate.refresh(SampleEntity.class, true);
+		CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria());
+		// when
+		long count = elasticsearchTemplate.count(criteriaQuery);
+		// then
+		assertThat(count, is(equalTo(1L)));
+	}
+
 	/*
 	DATAES-67
 	*/
 	@Test(expected = IllegalArgumentException.class)
-	public void shouldThrowAnExceptionWhenNoIndexSpecifiedForCountQuery() {
+	public void shouldThrowAnExceptionForGivenSearchQueryWhenNoIndexSpecifiedForCountQuery() {
 		// given
 		String documentId = randomNumeric(5);
 		SampleEntity sampleEntity = new SampleEntityBuilder(documentId).message("some message")

src/test/java/org/springframework/data/elasticsearch/repositories/CustomMethodRepositoryTests.java

@@ -44,6 +44,7 @@ import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  * @author Rizwan Idrees
  * @author Mohsin Husen
  * @author Franck Marchand
+ * @author Kevin Leturc
  */
 @RunWith(SpringJUnit4ClassRunner.class)
 @ContextConfiguration("classpath:custom-method-repository-test.xml")
@@ -589,5 +590,540 @@ public class CustomMethodRepositoryTests {
 		assertThat(page, is(notNullValue()));
 		assertThat(page.getTotalElements(), is(equalTo(1L)));
 	}
+
+	/*
+	DATAES-106
+	 */
+	@Test
+	public void shouldCountCustomMethod() {
+		// given
+		String documentId = randomNumeric(5);
+		SampleEntity sampleEntity = new SampleEntity();
+		sampleEntity.setId(documentId);
+		sampleEntity.setType("test");
+		sampleEntity.setMessage("some message");
+
+		repository.save(sampleEntity);
+
+		documentId = randomNumeric(5);
+		SampleEntity sampleEntity2 = new SampleEntity();
+		sampleEntity2.setId(documentId);
+		sampleEntity2.setType("test2");
+		sampleEntity2.setMessage("some message");
+
+		repository.save(sampleEntity2);
+
+		// when
+		long count = repository.countByType("test");
+		// then
+		assertThat(count, is(equalTo(1L)));
+	}
+
+	/*
+	DATAES-106
+	 */
+	@Test
+	public void shouldCountCustomMethodForNot() {
+		// given
+		String documentId = randomNumeric(5);
+		SampleEntity sampleEntity = new SampleEntity();
+		sampleEntity.setId(documentId);
+		sampleEntity.setType("some");
+		sampleEntity.setMessage("some message");
+
+		repository.save(sampleEntity);
+
+		documentId = randomNumeric(5);
+		SampleEntity sampleEntity2 = new SampleEntity();
+		sampleEntity2.setId(documentId);
+		sampleEntity2.setType("test");
+		sampleEntity2.setMessage("some message");
+
+		repository.save(sampleEntity2);
+
+		// when
+		long count = repository.countByTypeNot("test");
+		// then
+		assertThat(count, is(equalTo(1L)));
+	}
+
+	/*
+	DATAES-106
+	 */
+	@Test
+	public void shouldCountCustomMethodWithBooleanParameter() {
+		// given
+		String documentId = randomNumeric(5);
+		SampleEntity sampleEntity = new SampleEntity();
+		sampleEntity.setId(documentId);
+		sampleEntity.setType("test");
+		sampleEntity.setMessage("foo");
+		sampleEntity.setAvailable(true);
+		repository.save(sampleEntity);
+
+		// given
+		String documentId2 = randomNumeric(5);
+		SampleEntity sampleEntity2 = new SampleEntity();
+		sampleEntity2.setId(documentId2);
+		sampleEntity2.setType("test");
+		sampleEntity2.setMessage("bar");
+		sampleEntity2.setAvailable(false);
+		repository.save(sampleEntity2);
+		// when
+		long count = repository.countByAvailable(false);
+		// then
+		assertThat(count, is(equalTo(1L)));
+	}
+
+	/*
+	DATAES-106
+	 */
+	@Test
+	public void shouldCountCustomMethodWithLessThan() {
+		// given
+		String documentId = randomNumeric(5);
+		SampleEntity sampleEntity = new SampleEntity();
+		sampleEntity.setId(documentId);
+		sampleEntity.setType("test");
+		sampleEntity.setRate(10);
+		sampleEntity.setMessage("some message");
+		repository.save(sampleEntity);
+
+		String documentId2 = randomNumeric(5);
+		SampleEntity sampleEntity2 = new SampleEntity();
+		sampleEntity2.setId(documentId2);
+		sampleEntity2.setType("test");
+		sampleEntity2.setRate(20);
+		sampleEntity2.setMessage("some message");
+		repository.save(sampleEntity2);
+
+		// when
+		long count = repository.countByRateLessThan(10);
+		// then
+		assertThat(count, is(equalTo(1L)));
+	}
+
+	/*
+	DATAES-106
+	 */
+	@Test
+	public void shouldCountCustomMethodWithBefore() {
+		// given
+		String documentId = randomNumeric(5);
+		SampleEntity sampleEntity = new SampleEntity();
+		sampleEntity.setId(documentId);
+		sampleEntity.setType("test");
+		sampleEntity.setRate(10);
+		sampleEntity.setMessage("some message");
+
+		repository.save(sampleEntity);
+
+		documentId = randomNumeric(5);
+		SampleEntity sampleEntity2 = new SampleEntity();
+		sampleEntity2.setId(documentId);
+		sampleEntity2.setType("test");
+		sampleEntity2.setRate(20);
+		sampleEntity2.setMessage("some message");
+
+		repository.save(sampleEntity2);
+
+		// when
+		long count = repository.countByRateBefore(10);
+		// then
+		assertThat(count, is(equalTo(1L)));
+	}
+
+	/*
+	DATAES-106
+	 */
+	@Test
+	public void shouldCountCustomMethodWithAfter() {
+		// given
+		String documentId = randomNumeric(5);
+		SampleEntity sampleEntity = new SampleEntity();
+		sampleEntity.setId(documentId);
+		sampleEntity.setType("test");
+		sampleEntity.setRate(10);
+		sampleEntity.setMessage("some message");
+
+		repository.save(sampleEntity);
+
+		documentId = randomNumeric(5);
+		SampleEntity sampleEntity2 = new SampleEntity();
+		sampleEntity2.setId(documentId);
+		sampleEntity2.setType("test");
+		sampleEntity2.setRate(0);
+		sampleEntity2.setMessage("some message");
+
+		repository.save(sampleEntity2);
+
+		// when
+		long count = repository.countByRateAfter(10);
+		// then
+		assertThat(count, is(equalTo(1L)));
+	}
+
+	/*
+	DATAES-106
+	 */
+	@Test
+	public void shouldCountCustomMethodWithLike() {
+		// given
+		String documentId = randomNumeric(5);
+		SampleEntity sampleEntity = new SampleEntity();
+		sampleEntity.setId(documentId);
+		sampleEntity.setType("test");
+		sampleEntity.setRate(10);
+		sampleEntity.setMessage("foo");
+
+		repository.save(sampleEntity);
+
+		documentId = randomNumeric(5);
+		SampleEntity sampleEntity2 = new SampleEntity();
+		sampleEntity2.setId(documentId);
+		sampleEntity2.setType("test");
+		sampleEntity2.setRate(10);
+		sampleEntity2.setMessage("some message");
+
+		repository.save(sampleEntity2);
+
+		// when
+		long count = repository.countByMessageLike("fo");
+		// then
+		assertThat(count, is(equalTo(1L)));
+	}
+
+	/*
+	DATAES-106
+	 */
+	@Test
+	public void shouldCountCustomMethodForStartingWith() {
+		// given
+		String documentId = randomNumeric(5);
+		SampleEntity sampleEntity = new SampleEntity();
+		sampleEntity.setId(documentId);
+		sampleEntity.setType("test");
+		sampleEntity.setRate(10);
+		sampleEntity.setMessage("foo");
+
+		repository.save(sampleEntity);
+
+		documentId = randomNumeric(5);
+		SampleEntity sampleEntity2 = new SampleEntity();
+		sampleEntity2.setId(documentId);
+		sampleEntity2.setType("test");
+		sampleEntity2.setRate(10);
+		sampleEntity2.setMessage("some message");
+
+		repository.save(sampleEntity2);
+
+		// when
+		long count = repository.countByMessageStartingWith("fo");
+		// then
+		assertThat(count, is(equalTo(1L)));
+	}
+
+	/*
+	DATAES-106
+	 */
+	@Test
+	public void shouldCountCustomMethodForEndingWith() {
+		// given
+		String documentId = randomNumeric(5);
+		SampleEntity sampleEntity = new SampleEntity();
+		sampleEntity.setId(documentId);
+		sampleEntity.setType("test");
+		sampleEntity.setRate(10);
+		sampleEntity.setMessage("foo");
+
+		repository.save(sampleEntity);
+
+		documentId = randomNumeric(5);
+		SampleEntity sampleEntity2 = new SampleEntity();
+		sampleEntity2.setId(documentId);
+		sampleEntity2.setType("test");
+		sampleEntity2.setRate(10);
+		sampleEntity2.setMessage("some message");
+
+		repository.save(sampleEntity2);
+
+		// when
+		long count = repository.countByMessageEndingWith("o");
+		// then
+		assertThat(count, is(equalTo(1L)));
+	}
+
+	/*
+	DATAES-106
+	 */
+	@Test
+	public void shouldCountCustomMethodForContains() {
+		// given
+		String documentId = randomNumeric(5);
+		SampleEntity sampleEntity = new SampleEntity();
+		sampleEntity.setId(documentId);
+		sampleEntity.setType("test");
+		sampleEntity.setRate(10);
+		sampleEntity.setMessage("foo");
+
+		repository.save(sampleEntity);
+
+		documentId = randomNumeric(5);
+		SampleEntity sampleEntity2 = new SampleEntity();
+		sampleEntity2.setId(documentId);
+		sampleEntity2.setType("test");
+		sampleEntity2.setRate(10);
+		sampleEntity2.setMessage("some message");
+
+		repository.save(sampleEntity2);
+
+		// when
+		long count = repository.countByMessageContaining("fo");
+		// then
+		assertThat(count, is(equalTo(1L)));
+	}
+
+	/*
+	DATAES-106
+	 */
+	@Test
+	public void shouldCountCustomMethodForIn() {
+		// given
+		String documentId = randomNumeric(5);
+		SampleEntity sampleEntity = new SampleEntity();
+		sampleEntity.setId(documentId);
+		sampleEntity.setType("test");
+		sampleEntity.setMessage("foo");
+		repository.save(sampleEntity);
+
+		// given
+		String documentId2 = randomNumeric(5);
+		SampleEntity sampleEntity2 = new SampleEntity();
+		sampleEntity2.setId(documentId2);
+		sampleEntity2.setType("test");
+		sampleEntity2.setMessage("bar");
+		repository.save(sampleEntity2);
+
+		List<String> ids = Arrays.asList(documentId, documentId2);
+
+		// when
+		long count = repository.countByIdIn(ids);
+		// then
+		assertThat(count, is(equalTo(2L)));
+	}
+
+	/*
+	DATAES-106
+	 */
+	@Test
+	public void shouldCountCustomMethodForNotIn() {
+		// given
+		String documentId = randomNumeric(5);
+		SampleEntity sampleEntity = new SampleEntity();
+		sampleEntity.setId(documentId);
+		sampleEntity.setType("test");
+		sampleEntity.setMessage("foo");
+		repository.save(sampleEntity);
+
+		// given
+		String documentId2 = randomNumeric(5);
+		SampleEntity sampleEntity2 = new SampleEntity();
+		sampleEntity2.setId(documentId2);
+		sampleEntity2.setType("test");
+		sampleEntity2.setMessage("bar");
+		repository.save(sampleEntity2);
+
+		List<String> ids = Arrays.asList(documentId);
+
+		// when
+		long count = repository.countByIdNotIn(ids);
+		// then
+		assertThat(count, is(equalTo(1L)));
+	}
+
+	/*
+	DATAES-106
+	 */
+	@Test
+	public void shouldCountCustomMethodForTrue() {
+		// given
+		String documentId = randomNumeric(5);
+		SampleEntity sampleEntity = new SampleEntity();
+		sampleEntity.setId(documentId);
+		sampleEntity.setType("test");
+		sampleEntity.setMessage("foo");
+		sampleEntity.setAvailable(true);
+		repository.save(sampleEntity);
+
+		// given
+		String documentId2 = randomNumeric(5);
+		SampleEntity sampleEntity2 = new SampleEntity();
+		sampleEntity2.setId(documentId2);
+		sampleEntity2.setType("test");
+		sampleEntity2.setMessage("bar");
+		sampleEntity2.setAvailable(false);
+		repository.save(sampleEntity2);
+		// when
+		long count = repository.countByAvailableTrue();
+		// then
+		assertThat(count, is(equalTo(1L)));
+	}
+
+	/*
+	DATAES-106
+	 */
+	@Test
+	public void shouldCountCustomMethodForFalse() {
+		// given
+		String documentId = randomNumeric(5);
+		SampleEntity sampleEntity = new SampleEntity();
+		sampleEntity.setId(documentId);
+		sampleEntity.setType("test");
+		sampleEntity.setMessage("foo");
+		sampleEntity.setAvailable(true);
+		repository.save(sampleEntity);
+
+		// given
+		String documentId2 = randomNumeric(5);
+		SampleEntity sampleEntity2 = new SampleEntity();
+		sampleEntity2.setId(documentId2);
+		sampleEntity2.setType("test");
+		sampleEntity2.setMessage("bar");
+		sampleEntity2.setAvailable(false);
+		repository.save(sampleEntity2);
+		// when
+		long count = repository.countByAvailableFalse();
+		// then
+		assertThat(count, is(equalTo(1L)));
+	}
+
+	/*
+	DATAES-106
+	 */
+	@Test
+	public void shouldCountCustomMethodWithWithinGeoPoint() {
+		// given
+		String documentId = randomNumeric(5);
+		SampleEntity sampleEntity = new SampleEntity();
+		sampleEntity.setId(documentId);
+		sampleEntity.setType("test");
+		sampleEntity.setRate(10);
+		sampleEntity.setMessage("foo");
+		sampleEntity.setLocation(new GeoPoint(45.7806d, 3.0875d));
+
+		repository.save(sampleEntity);
+
+		documentId = randomNumeric(5);
+		SampleEntity sampleEntity2 = new SampleEntity();
+		sampleEntity2.setId(documentId);
+		sampleEntity2.setType("test");
+		sampleEntity2.setRate(10);
+		sampleEntity2.setMessage("foo");
+		sampleEntity2.setLocation(new GeoPoint(30.7806d, 0.0875d));
+
+		repository.save(sampleEntity2);
+
+		// when
+		long count = repository.countByLocationWithin(new GeoPoint(45.7806d, 3.0875d), "2km");
+		// then
+		assertThat(count, is(equalTo(1L)));
+	}
+
+	/*
+	DATAES-106
+	 */
+	@Test
+	public void shouldCountCustomMethodWithWithinPoint() {
+		// given
+		String documentId = randomNumeric(5);
+		SampleEntity sampleEntity = new SampleEntity();
+		sampleEntity.setId(documentId);
+		sampleEntity.setType("test");
+		sampleEntity.setRate(10);
+		sampleEntity.setMessage("foo");
+		sampleEntity.setLocation(new GeoPoint(45.7806d, 3.0875d));
+
+		repository.save(sampleEntity);
+
+		documentId = randomNumeric(5);
+		SampleEntity sampleEntity2 = new SampleEntity();
+		sampleEntity2.setId(documentId);
+		sampleEntity2.setType("test");
+		sampleEntity2.setRate(10);
+		sampleEntity2.setMessage("foo");
+		sampleEntity2.setLocation(new GeoPoint(30.7806d, 0.0875d));
+
+		repository.save(sampleEntity2);
+
+		// when
+		long count = repository.countByLocationWithin(new Point(3.0875d, 45.7806d), new Distance(2, Metrics.KILOMETERS));
+		// then
+		assertThat(count, is(equalTo(1L)));
+	}
+
+	/*
+	DATAES-106
+	 */
+	@Test
+	public void shouldCountCustomMethodWithNearBox() {
+		// given
+		String documentId = randomNumeric(5);
+		SampleEntity sampleEntity = new SampleEntity();
+		sampleEntity.setId(documentId);
+		sampleEntity.setType("test");
+		sampleEntity.setRate(10);
+		sampleEntity.setMessage("foo");
+		sampleEntity.setLocation(new GeoPoint(45.7806d, 3.0875d));
+
+		repository.save(sampleEntity);
+
+		documentId = randomNumeric(5);
+		SampleEntity sampleEntity2 = new SampleEntity();
+		sampleEntity2.setId(documentId);
+		sampleEntity2.setType("test2");
+		sampleEntity2.setRate(10);
+		sampleEntity2.setMessage("foo");
+		sampleEntity2.setLocation(new GeoPoint(30.7806d, 0.0875d));
+
+		repository.save(sampleEntity2);
+
+		// when
+		long count = repository.countByLocationNear(new Box(new Point(3d, 46d), new Point(4d, 45d)));
+		// then
+		assertThat(count, is(equalTo(1L)));
+	}
+
+	/*
+	DATAES-106
+	 */
+	@Test
+	public void shouldCountCustomMethodWithNearPointAndDistance() {
+		// given
+		String documentId = randomNumeric(5);
+		SampleEntity sampleEntity = new SampleEntity();
+		sampleEntity.setId(documentId);
+		sampleEntity.setType("test");
+		sampleEntity.setRate(10);
+		sampleEntity.setMessage("foo");
+		sampleEntity.setLocation(new GeoPoint(45.7806d, 3.0875d));
+
+		repository.save(sampleEntity);
+
+		documentId = randomNumeric(5);
+		SampleEntity sampleEntity2 = new SampleEntity();
+		sampleEntity2.setId(documentId);
+		sampleEntity2.setType("test");
+		sampleEntity2.setRate(10);
+		sampleEntity2.setMessage("foo");
+		sampleEntity2.setLocation(new GeoPoint(30.7806d, 0.0875d));
+
+		repository.save(sampleEntity2);
+
+		// when
+		long count = repository.countByLocationNear(new Point(3.0875d, 45.7806d), new Distance(2, Metrics.KILOMETERS));
+		// then
+		assertThat(count, is(equalTo(1L)));
+	}
+
 }
 

src/test/java/org/springframework/data/elasticsearch/repositories/custom/SampleCustomMethodRepository.java

@@ -31,6 +31,7 @@ import org.springframework.data.geo.Point;
 /**
  * @author Rizwan Idrees
  * @author Mohsin Husen
+ * @author Kevin Leturc
  */
 public interface SampleCustomMethodRepository extends ElasticsearchRepository<SampleEntity, String> {
 
@@ -62,7 +63,7 @@ public interface SampleCustomMethodRepository extends ElasticsearchRepository<Sa
 
 	Page<SampleEntity> findByIdIn(List<String> ids, Pageable pageable);
 
-	Page<SampleEntity> findByIdNotIn(List<String> messages, Pageable pageable);
+	Page<SampleEntity> findByIdNotIn(List<String> ids, Pageable pageable);
 
 	Page<SampleEntity> findByAvailableTrue(Pageable pageable);
 
@@ -81,4 +82,45 @@ public interface SampleCustomMethodRepository extends ElasticsearchRepository<Sa
 	Page<SampleEntity> findByLocationNear(Point point, Distance distance, Pageable pageable);
 
 	Page<SampleEntity> findByLocationNear(GeoPoint point, String distance, Pageable pageable);
+
+	long countByType(String type);
+
+	long countByTypeNot(String type);
+
+	long countByAvailable(boolean available);
+
+	long countByRateLessThan(int rate);
+
+	long countByRateBefore(int rate);
+
+	long countByRateAfter(int rate);
+
+	long countByMessageLike(String message);
+
+	long countByMessageStartingWith(String message);
+
+	long countByMessageEndingWith(String message);
+
+	long countByMessageContaining(String message);
+
+	long countByIdIn(List<String> ids);
+
+	long countByIdNotIn(List<String> ids);
+
+	long countByAvailableTrue();
+
+	long countByAvailableFalse();
+
+	long countByLocationWithin(GeoPoint point, String distance);
+
+	long countByLocationWithin(Point point, Distance distance);
+
+	long countByLocationNear(GeoBox box);
+
+	long countByLocationNear(Box box);
+
+	long countByLocationNear(Point point, Distance distance);
+
+	long countByLocationNear(GeoPoint point, String distance);
+
 }