DATAES-91 - completion suggester support

pom.xml

@@ -133,10 +133,10 @@
                 <groupId>org.codehaus.mojo</groupId>
                 <artifactId>wagon-maven-plugin</artifactId>
             </plugin>
-			<plugin>
-				<groupId>org.asciidoctor</groupId>
-				<artifactId>asciidoctor-maven-plugin</artifactId>
-			</plugin>
+            <plugin>
+                <groupId>org.asciidoctor</groupId>
+                <artifactId>asciidoctor-maven-plugin</artifactId>
+            </plugin>
         </plugins>
     </build>
 

src/main/java/org/springframework/data/elasticsearch/annotations/CompletionField.java

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2013 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.elasticsearch.annotations;
+
+import java.lang.annotation.*;
+
+/**
+ * Based on the reference doc - http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-suggesters-completion.html
+ *
+ * @author Mewes Kochheim
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+@Documented
+public @interface CompletionField {
+
+    String searchAnalyzer() default "simple";
+
+    String indexAnalyzer() default "simple";
+
+    boolean payloads() default false;
+
+    boolean preserveSeparators() default true;
+
+    boolean preservePositionIncrements() default true;
+
+    int maxInputLength() default 50;
+}

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

@@ -51,6 +51,9 @@ 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.suggest.SuggestRequest;
+import org.elasticsearch.action.suggest.SuggestRequestBuilder;
+import org.elasticsearch.action.suggest.SuggestResponse;
 import org.elasticsearch.action.update.UpdateRequestBuilder;
 import org.elasticsearch.action.update.UpdateResponse;
 import org.elasticsearch.client.Client;
@@ -60,6 +63,7 @@ import org.elasticsearch.cluster.metadata.MappingMetaData;
 import org.elasticsearch.common.collect.ImmutableOpenMap;
 import org.elasticsearch.common.collect.MapBuilder;
 import org.elasticsearch.common.unit.TimeValue;
+import org.elasticsearch.common.xcontent.ToXContent;
 import org.elasticsearch.common.xcontent.XContentBuilder;
 import org.elasticsearch.index.query.FilterBuilder;
 import org.elasticsearch.index.query.QueryBuilder;
@@ -70,6 +74,7 @@ import org.elasticsearch.search.facet.FacetBuilder;
 import org.elasticsearch.search.highlight.HighlightBuilder;
 import org.elasticsearch.search.sort.SortBuilder;
 import org.elasticsearch.search.sort.SortOrder;
+import org.elasticsearch.search.suggest.SuggestBuilder;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.BeansException;
@@ -976,4 +981,14 @@ public class ElasticsearchTemplate implements ElasticsearchOperations, Applicati
 
 		return stringBuilder.toString();
 	}
+
+    public SuggestResponse suggest(SuggestBuilder.SuggestionBuilder<?> suggestion, String... indices) {
+	SuggestRequestBuilder suggestRequestBuilder = client.prepareSuggest(indices);
+	suggestRequestBuilder.addSuggestion(suggestion);
+	return suggestRequestBuilder.execute().actionGet();
+    }
+
+    public SuggestResponse suggest(SuggestBuilder.SuggestionBuilder<?> suggestion, Class clazz) {
+	return suggest(suggestion, retrieveIndexNameFromPersistentEntity(clazz));
+    }
 }

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

@@ -29,6 +29,7 @@ import org.elasticsearch.common.xcontent.XContentBuilder;
 import org.springframework.core.GenericCollectionTypeResolver;
 import org.springframework.data.annotation.Transient;
 import org.springframework.data.elasticsearch.annotations.*;
+import org.springframework.data.elasticsearch.core.completion.Completion;
 import org.springframework.data.elasticsearch.core.facet.FacetRequest;
 import org.springframework.data.elasticsearch.core.geo.GeoPoint;
 import org.springframework.data.mapping.model.SimpleTypeHolder;
@@ -55,7 +56,8 @@ class MappingBuilder {
 
 	public static final String INDEX_VALUE_NOT_ANALYZED = "not_analyzed";
 	public static final String TYPE_VALUE_STRING = "string";
-	public static final String TYPE_VALUE_GEO_POINT = "geo_point";
+    public static final String TYPE_VALUE_GEO_POINT = "geo_point";
+    public static final String TYPE_VALUE_COMPLETION = "completion";
 
 	private static SimpleTypeHolder SIMPLE_TYPE_HOLDER = new SimpleTypeHolder();
 
@@ -94,10 +96,11 @@ class MappingBuilder {
 				continue;
 			}
 
-			boolean isGeoField = isGeoField(field);
+	    boolean isGeoField = isGeoField(field);
+	    boolean isCompletionField = isCompletionField(field);
 
 			Field singleField = field.getAnnotation(Field.class);
-			if (!isGeoField && isEntity(field) && isAnnotated(field)) {
+			if (!isGeoField && !isCompletionField && isEntity(field) && isAnnotated(field)) {
 				if (singleField == null) {
 					continue;
 				}
@@ -110,9 +113,13 @@ class MappingBuilder {
 
 			MultiField multiField = field.getAnnotation(MultiField.class);
 
-			if (isGeoField) {
-				applyGeoPointFieldMapping(xContentBuilder, field);
-			}
+	    if (isGeoField) {
+		applyGeoPointFieldMapping(xContentBuilder, field);
+	    }
+
+	    if (isCompletionField) {
+		applyCompletionFieldMapping(xContentBuilder, field);
+	    }
 
 			if (isRootObject && singleField != null && isIdField(field, idFieldName)) {
 				applyDefaultIdFieldMapping(xContentBuilder, field);
@@ -153,6 +160,12 @@ class MappingBuilder {
 				.endObject();
 	}
 
+    private static void applyCompletionFieldMapping(XContentBuilder xContentBuilder, java.lang.reflect.Field field) throws IOException {
+	xContentBuilder.startObject(field.getName());
+	xContentBuilder.field(FIELD_TYPE, TYPE_VALUE_COMPLETION)
+		.endObject();
+    }
+
 	private static void applyDefaultIdFieldMapping(XContentBuilder xContentBuilder, java.lang.reflect.Field field)
 			throws IOException {
 		xContentBuilder.startObject(field.getName())
@@ -304,7 +317,11 @@ class MappingBuilder {
 		return fieldAnnotation != null && (FieldType.Nested == fieldAnnotation.type() || FieldType.Object == fieldAnnotation.type());
 	}
 
-	private static boolean isGeoField(java.lang.reflect.Field field) {
-		return field.getType() == GeoPoint.class || field.getAnnotation(GeoPointField.class) != null;
-	}
-}
+    private static boolean isGeoField(java.lang.reflect.Field field) {
+	return field.getType() == GeoPoint.class || field.getAnnotation(GeoPointField.class) != null;
+    }
+
+    private static boolean isCompletionField(java.lang.reflect.Field field) {
+	return field.getType() == Completion.class;
+    }
+}

src/main/java/org/springframework/data/elasticsearch/core/MappingBuilder.java.rej

@@ -0,0 +1,78 @@
+diff a/src/main/java/org/springframework/data/elasticsearch/core/MappingBuilder.java b/src/main/java/org/springframework/data/elasticsearch/core/MappingBuilder.java	(rejected hunks)
+@@ -29,6 +29,7 @@ import org.elasticsearch.common.xcontent.XContentBuilder;
+ import org.springframework.core.GenericCollectionTypeResolver;
+ import org.springframework.data.annotation.Transient;
+ import org.springframework.data.elasticsearch.annotations.*;
++import org.springframework.data.elasticsearch.core.completion.Completion;
+ import org.springframework.data.elasticsearch.core.facet.FacetRequest;
+ import org.springframework.data.elasticsearch.core.geo.GeoPoint;
+ import org.springframework.data.mapping.model.SimpleTypeHolder;
+@@ -55,7 +56,8 @@ class MappingBuilder {
+ 
+ 	public static final String INDEX_VALUE_NOT_ANALYZED = "not_analyzed";
+ 	public static final String TYPE_VALUE_STRING = "string";
+-	public static final String TYPE_VALUE_GEO_POINT = "geo_point";
++    public static final String TYPE_VALUE_GEO_POINT = "geo_point";
++    public static final String TYPE_VALUE_COMPLETION = "completion";
+ 
+ 	private static SimpleTypeHolder SIMPLE_TYPE_HOLDER = new SimpleTypeHolder();
+ 
+@@ -94,10 +96,11 @@ class MappingBuilder {
+ 				continue;
+ 			}
+ 
+-			boolean isGeoField = isGeoField(field);
++	    boolean isGeoField = isGeoField(field);
++	    boolean isCompletionField = isCompletionField(field);
+ 
+ 			Field singleField = field.getAnnotation(Field.class);
+-			if (!isGeoField && isEntity(field) && isAnnotated(field)) {
++			if (!isGeoField && !isCompletionField && isEntity(field) && isAnnotated(field)) {
+ 				if (singleField == null) {
+ 					continue;
+ 				}
+@@ -110,9 +113,13 @@ class MappingBuilder {
+ 
+ 			MultiField multiField = field.getAnnotation(MultiField.class);
+ 
+-			if (isGeoField) {
+-				applyGeoPointFieldMapping(xContentBuilder, field);
+-			}
++	    if (isGeoField) {
++		applyGeoPointFieldMapping(xContentBuilder, field);
++	    }
++
++	    if (isCompletionField) {
++		applyCompletionFieldMapping(xContentBuilder, field);
++	    }
+ 
+ 			if (isRootObject && singleField != null && isIdField(field, idFieldName)) {
+ 				applyDefaultIdFieldMapping(xContentBuilder, field);
+@@ -153,6 +160,12 @@ class MappingBuilder {
+ 				.endObject();
+ 	}
+ 
++    private static void applyCompletionFieldMapping(XContentBuilder xContentBuilder, java.lang.reflect.Field field) throws IOException {
++	xContentBuilder.startObject(field.getName());
++	xContentBuilder.field(FIELD_TYPE, TYPE_VALUE_COMPLETION)
++		.endObject();
++    }
++
+ 	private static void applyDefaultIdFieldMapping(XContentBuilder xContentBuilder, java.lang.reflect.Field field)
+ 			throws IOException {
+ 		xContentBuilder.startObject(field.getName())
+@@ -304,7 +317,11 @@ class MappingBuilder {
+ 		return fieldAnnotation != null && (FieldType.Nested == fieldAnnotation.type() || FieldType.Object == fieldAnnotation.type());
+ 	}
+ 
+-	private static boolean isGeoField(java.lang.reflect.Field field) {
+-		return field.getType() == GeoPoint.class || field.getAnnotation(GeoPointField.class) != null;
+-	}
++    private static boolean isGeoField(java.lang.reflect.Field field) {
++	return field.getType() == GeoPoint.class || field.getAnnotation(GeoPointField.class) != null;
++    }
++
++    private static boolean isCompletionField(java.lang.reflect.Field field) {
++	return field.getType() == Completion.class;
++    }
+ }

src/main/java/org/springframework/data/elasticsearch/core/completion/Completion.java

@@ -0,0 +1,57 @@
+package org.springframework.data.elasticsearch.core.completion;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+
+/**
+ * Based on the reference doc - http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-suggesters-completion.html
+ *
+ * @author Mewes Kochheim
+ */
+@JsonInclude(value = JsonInclude.Include.NON_NULL)
+public class Completion {
+
+    private String[] input;
+    private String output;
+    private Integer weight;
+    private Object payload;
+
+    private Completion() {
+	//required by mapper to instantiate object
+    }
+
+    public Completion(String[] input) {
+	this.input = input;
+    }
+
+    public String[] getInput() {
+	return input;
+    }
+
+    public void setInput(String[] input) {
+	this.input = input;
+    }
+
+    public String getOutput() {
+	return output;
+    }
+
+    public void setOutput(String output) {
+	this.output = output;
+    }
+
+    public Object getPayload() {
+	return payload;
+    }
+
+    public void setPayload(Object payload) {
+	this.payload = payload;
+    }
+
+    public Integer getWeight() {
+	return weight;
+    }
+
+    public void setWeight(Integer weight) {
+	this.weight = weight;
+    }
+}

src/test/java/org/springframework/data/elasticsearch/core/completion/AnnotatedCompletionEntity.java

@@ -0,0 +1,50 @@
+package org.springframework.data.elasticsearch.core.completion;
+
+import org.springframework.data.annotation.Id;
+import org.springframework.data.elasticsearch.annotations.CompletionField;
+import org.springframework.data.elasticsearch.annotations.Document;
+
+/**
+ * @author Mewes Kochheim
+ */
+@Document(indexName = "test-completion-index", type = "annotated-completion-type", indexStoreType = "memory", shards = 1, replicas = 0, refreshInterval = "-1")
+public class AnnotatedCompletionEntity {
+
+    @Id
+    private String id;
+    private String name;
+
+    @CompletionField(payloads = true, maxInputLength = 100)
+    private Completion suggest;
+
+    private AnnotatedCompletionEntity() {
+    }
+
+    public AnnotatedCompletionEntity(String id) {
+	this.id = id;
+    }
+
+    public String getId() {
+	return id;
+    }
+
+    public void setId(String id) {
+	this.id = id;
+    }
+
+    public String getName() {
+	return name;
+    }
+
+    public void setName(String name) {
+	this.name = name;
+    }
+
+    public Completion getSuggest() {
+	return suggest;
+    }
+
+    public void setSuggest(Completion suggest) {
+	this.suggest = suggest;
+    }
+}

src/test/java/org/springframework/data/elasticsearch/core/completion/AnnotatedCompletionEntityBuilder.java

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2013-2014 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.elasticsearch.core.completion;
+
+import org.springframework.data.elasticsearch.core.query.IndexQuery;
+
+/**
+ * @author Franck Marchand
+ * @author Mohsin Husen
+ * @author Mewes Kochheim
+ */
+public class AnnotatedCompletionEntityBuilder {
+
+    private CompletionEntity result;
+
+    public AnnotatedCompletionEntityBuilder(String id) {
+	result = new CompletionEntity(id);
+    }
+
+    public AnnotatedCompletionEntityBuilder name(String name) {
+	result.setName(name);
+	return this;
+    }
+
+    public AnnotatedCompletionEntityBuilder suggest(String[] input) {
+	return suggest(input, null, null, null);
+    }
+
+    public AnnotatedCompletionEntityBuilder suggest(String[] input, String output) {
+	return suggest(input, output, null, null);
+    }
+
+    public AnnotatedCompletionEntityBuilder suggest(String[] input, String output, Object payload) {
+	return suggest(input, output, payload, null);
+    }
+
+    public AnnotatedCompletionEntityBuilder suggest(String[] input, String output, Object payload, Integer weight) {
+	Completion suggest = new Completion(input);
+	suggest.setOutput(output);
+	suggest.setPayload(payload);
+	suggest.setWeight(weight);
+
+	result.setSuggest(suggest);
+	return this;
+    }
+
+    public CompletionEntity build() {
+	return result;
+    }
+
+    public IndexQuery buildIndex() {
+	IndexQuery indexQuery = new IndexQuery();
+	indexQuery.setId(result.getId());
+	indexQuery.setObject(result);
+	return indexQuery;
+    }
+}

src/test/java/org/springframework/data/elasticsearch/core/completion/CompletionAnnotatedEntity.java

@@ -0,0 +1,52 @@
+package org.springframework.data.elasticsearch.core.completion;
+
+import org.springframework.data.annotation.Id;
+import org.springframework.data.elasticsearch.annotations.CompletionField;
+import org.springframework.data.elasticsearch.annotations.Document;
+
+/**
+ * @author Franck Marchand
+ * @author Mohsin Husen
+ * @author Mewes Kochheim
+ */
+@Document(indexName = "test-completion-index", type = "completion-annotation-type", indexStoreType = "memory", shards = 1, replicas = 0, refreshInterval = "-1")
+public class CompletionAnnotatedEntity {
+
+    @Id
+    private String id;
+    private String name;
+
+    @CompletionField(payloads = true)
+    private Completion suggest;
+
+    private CompletionAnnotatedEntity() {
+    }
+
+    public CompletionAnnotatedEntity(String id) {
+	this.id = id;
+    }
+
+    public String getId() {
+	return id;
+    }
+
+    public void setId(String id) {
+	this.id = id;
+    }
+
+    public String getName() {
+	return name;
+    }
+
+    public void setName(String name) {
+	this.name = name;
+    }
+
+    public Completion getSuggest() {
+	return suggest;
+    }
+
+    public void setSuggest(Completion suggest) {
+	this.suggest = suggest;
+    }
+}

src/test/java/org/springframework/data/elasticsearch/core/completion/CompletionEntity.java

@@ -0,0 +1,48 @@
+package org.springframework.data.elasticsearch.core.completion;
+
+import org.springframework.data.annotation.Id;
+import org.springframework.data.elasticsearch.annotations.Document;
+
+/**
+ * @author Mewes Kochheim
+ */
+@Document(indexName = "test-completion-index", type = "completion-type", indexStoreType = "memory", shards = 1, replicas = 0, refreshInterval = "-1")
+public class CompletionEntity {
+
+    @Id
+    private String id;
+    private String name;
+
+    private Completion suggest;
+
+    private CompletionEntity() {
+    }
+
+    public CompletionEntity(String id) {
+	this.id = id;
+    }
+
+    public String getId() {
+	return id;
+    }
+
+    public void setId(String id) {
+	this.id = id;
+    }
+
+    public String getName() {
+	return name;
+    }
+
+    public void setName(String name) {
+	this.name = name;
+    }
+
+    public Completion getSuggest() {
+	return suggest;
+    }
+
+    public void setSuggest(Completion suggest) {
+	this.suggest = suggest;
+    }
+}

src/test/java/org/springframework/data/elasticsearch/core/completion/CompletionEntityAnnotatedBuilder.java

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2013-2014 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.elasticsearch.core.completion;
+
+import org.springframework.data.elasticsearch.core.query.IndexQuery;
+
+/**
+ * @author Franck Marchand
+ * @author Mohsin Husen
+ * @author Mewes Kochheim
+ */
+public class CompletionEntityAnnotatedBuilder {
+
+    private CompletionAnnotatedEntity result;
+
+    public CompletionEntityAnnotatedBuilder(String id) {
+	result = new CompletionAnnotatedEntity(id);
+    }
+
+    public CompletionEntityAnnotatedBuilder name(String name) {
+	result.setName(name);
+	return this;
+    }
+
+    public CompletionEntityAnnotatedBuilder suggest(String[] input) {
+	return suggest(input, null, null, null);
+    }
+
+    public CompletionEntityAnnotatedBuilder suggest(String[] input, String output) {
+	return suggest(input, output, null, null);
+    }
+
+    public CompletionEntityAnnotatedBuilder suggest(String[] input, String output, Object payload) {
+	return suggest(input, output, payload, null);
+    }
+
+    public CompletionEntityAnnotatedBuilder suggest(String[] input, String output, Object payload, Integer weight) {
+	Completion suggest = new Completion(input);
+	if (output != null) {
+	    suggest.setOutput(output);
+	}
+	if (payload != null) {
+	    suggest.setPayload(payload);
+	}
+	if (weight != null) {
+	    suggest.setWeight(weight);
+	}
+	result.setSuggest(suggest);
+	return this;
+    }
+
+    public CompletionAnnotatedEntity build() {
+	return result;
+    }
+
+    public IndexQuery buildIndex() {
+	IndexQuery indexQuery = new IndexQuery();
+	indexQuery.setId(result.getId());
+	indexQuery.setObject(result);
+	return indexQuery;
+    }
+}

src/test/java/org/springframework/data/elasticsearch/core/completion/CompletionEntityBuilder.java

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2013-2014 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.elasticsearch.core.completion;
+
+import org.springframework.data.elasticsearch.core.query.IndexQuery;
+
+/**
+ * @author Mewes Kochheim
+ */
+public class CompletionEntityBuilder {
+
+    private CompletionEntity result;
+
+    public CompletionEntityBuilder(String id) {
+	result = new CompletionEntity(id);
+    }
+
+    public CompletionEntityBuilder name(String name) {
+	result.setName(name);
+	return this;
+    }
+
+    public CompletionEntityBuilder suggest(String[] input) {
+	return suggest(input, null, null, null);
+    }
+
+    public CompletionEntityBuilder suggest(String[] input, String output) {
+	return suggest(input, output, null, null);
+    }
+
+    public CompletionEntityBuilder suggest(String[] input, String output, Object payload) {
+	return suggest(input, output, payload, null);
+    }
+
+    public CompletionEntityBuilder suggest(String[] input, String output, Object payload, Integer weight) {
+	Completion suggest = new Completion(input);
+	suggest.setOutput(output);
+	suggest.setPayload(payload);
+	suggest.setWeight(weight);
+
+	result.setSuggest(suggest);
+	return this;
+    }
+
+    public CompletionEntity build() {
+	return result;
+    }
+
+    public IndexQuery buildIndex() {
+	IndexQuery indexQuery = new IndexQuery();
+	indexQuery.setId(result.getId());
+	indexQuery.setObject(result);
+	return indexQuery;
+    }
+}

src/test/java/org/springframework/data/elasticsearch/core/completion/ElasticsearchTemplateCompletionTests.java

@@ -0,0 +1,132 @@
+/*
+ * Copyright 2013 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.elasticsearch.core.completion;
+
+import org.elasticsearch.action.suggest.SuggestResponse;
+import org.elasticsearch.search.suggest.completion.CompletionSuggestion;
+import org.elasticsearch.search.suggest.completion.CompletionSuggestionFuzzyBuilder;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.elasticsearch.core.ElasticsearchTemplate;
+import org.springframework.data.elasticsearch.core.query.IndexQuery;
+import org.springframework.data.elasticsearch.entities.NonDocumentEntity;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.junit.Assert.assertEquals;
+
+/**
+ * @author Rizwan Idrees
+ * @author Mohsin Husen
+ * @author Franck Marchand
+ * @author Artur Konczak
+ * @author Mewes Kochheim
+ */
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration("classpath:elasticsearch-template-test.xml")
+public class ElasticsearchTemplateCompletionTests {
+
+    @Autowired
+    private ElasticsearchTemplate elasticsearchTemplate;
+
+    private void loadCompletionObjectEntities() {
+	elasticsearchTemplate.deleteIndex(CompletionEntity.class);
+	elasticsearchTemplate.createIndex(CompletionEntity.class);
+	elasticsearchTemplate.refresh(CompletionEntity.class, true);
+	elasticsearchTemplate.putMapping(CompletionEntity.class);
+
+	List<IndexQuery> indexQueries = new ArrayList<IndexQuery>();
+	indexQueries.add(new CompletionEntityBuilder("1").name("Rizwan Idrees").suggest(new String[]{"Rizwan Idrees"}).buildIndex());
+	indexQueries.add(new CompletionEntityBuilder("2").name("Franck Marchand").suggest(new String[]{"Franck", "Marchand"}).buildIndex());
+	indexQueries.add(new CompletionEntityBuilder("3").name("Mohsin Husen").suggest(new String[]{"Mohsin", "Husen"}, "Mohsin Husen").buildIndex());
+	indexQueries.add(new CompletionEntityBuilder("4").name("Artur Konczak").suggest(new String[]{"Artur", "Konczak"}, "Artur Konczak", null, 60).buildIndex());
+
+	elasticsearchTemplate.bulkIndex(indexQueries);
+	elasticsearchTemplate.refresh(CompletionEntity.class, true);
+    }
+
+    private void loadAnnotatedCompletionObjectEntities() {
+	elasticsearchTemplate.deleteIndex(AnnotatedCompletionEntity.class);
+	elasticsearchTemplate.createIndex(AnnotatedCompletionEntity.class);
+	elasticsearchTemplate.refresh(AnnotatedCompletionEntity.class, true);
+	elasticsearchTemplate.putMapping(AnnotatedCompletionEntity.class);
+
+	NonDocumentEntity nonDocumentEntity = new NonDocumentEntity();
+	nonDocumentEntity.setSomeField1("foo");
+	nonDocumentEntity.setSomeField2("bar");
+
+	List<IndexQuery> indexQueries = new ArrayList<IndexQuery>();
+	indexQueries.add(new AnnotatedCompletionEntityBuilder("1").name("Franck Marchand").suggest(new String[]{"Franck", "Marchand"}).buildIndex());
+	indexQueries.add(new AnnotatedCompletionEntityBuilder("2").name("Mohsin Husen").suggest(new String[]{"Mohsin", "Husen"}, "Mohsin Husen").buildIndex());
+	indexQueries.add(new AnnotatedCompletionEntityBuilder("3").name("Rizwan Idrees").suggest(new String[]{"Rizwan", "Idrees"}, "Rizwan Idrees", "Payload test").buildIndex());
+	indexQueries.add(new AnnotatedCompletionEntityBuilder("4").name("Artur Konczak").suggest(new String[]{"Artur", "Konczak"}, "Artur Konczak", nonDocumentEntity, 60).buildIndex());
+
+	elasticsearchTemplate.bulkIndex(indexQueries);
+	elasticsearchTemplate.refresh(AnnotatedCompletionEntity.class, true);
+    }
+
+    @Test
+    public void shouldPutMappingForGivenEntity() throws Exception {
+	//given
+	Class entity = CompletionEntity.class;
+	elasticsearchTemplate.createIndex(entity);
+
+	//when
+	assertThat(elasticsearchTemplate.putMapping(entity), is(true));
+    }
+
+    @Test
+    public void shouldFindSuggestionsForGivenCriteriaQueryUsingCompletionObjectEntity() {
+	//given
+	loadCompletionObjectEntities();
+	CompletionSuggestionFuzzyBuilder completionSuggestionFuzzyBuilder = new CompletionSuggestionFuzzyBuilder("test-suggest")
+		.text("m")
+		.field("suggest");
+
+	//when
+	SuggestResponse suggestResponse = elasticsearchTemplate.suggest(completionSuggestionFuzzyBuilder, CompletionEntity.class);
+	CompletionSuggestion completionSuggestion = suggestResponse.getSuggest().getSuggestion("test-suggest");
+	List<CompletionSuggestion.Entry.Option> options = completionSuggestion.getEntries().get(0).getOptions();
+
+	//then
+	assertThat(options.size(), is(2));
+	assertEquals("Marchand", options.get(0).getText().string());
+    }
+
+    @Test
+    public void shouldFindSuggestionsForGivenCriteriaQueryUsingloadAnnotatedCompletionObjectEntity() {
+	//given
+	loadCompletionObjectEntities();
+	CompletionSuggestionFuzzyBuilder completionSuggestionFuzzyBuilder = new CompletionSuggestionFuzzyBuilder("test-suggest")
+		.text("m")
+		.field("suggest");
+
+	//when
+	SuggestResponse suggestResponse = elasticsearchTemplate.suggest(completionSuggestionFuzzyBuilder, CompletionEntity.class);
+	CompletionSuggestion completionSuggestion = suggestResponse.getSuggest().getSuggestion("test-suggest");
+	List<CompletionSuggestion.Entry.Option> options = completionSuggestion.getEntries().get(0).getOptions();
+
+	//then
+	assertThat(options.size(), is(2));
+	assertEquals("Marchand", options.get(0).getText().string());
+    }
+}