[BAEL-9538] - Move persistence-related modules into the persistence folder

2018-10-20 11:27:08 +05:30
parent 2404312d20
commit 21a3a43788
360 changed files with 1153 additions and 1148 deletions
--- a/persistence-modules/spring-data-elasticsearch/src/test/java/com/baeldung/elasticsearch/ElasticSearchManualTest.java
+++ b/persistence-modules/spring-data-elasticsearch/src/test/java/com/baeldung/elasticsearch/ElasticSearchManualTest.java
@@ -0,0 +1,154 @@
+package com.baeldung.elasticsearch;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.elasticsearch.action.DocWriteResponse.Result;
+import org.elasticsearch.action.delete.DeleteResponse;
+import org.elasticsearch.action.index.IndexResponse;
+import org.elasticsearch.action.search.SearchResponse;
+import org.elasticsearch.action.search.SearchType;
+import org.elasticsearch.client.Client;
+import org.elasticsearch.common.settings.Settings;
+import org.elasticsearch.common.transport.InetSocketTransportAddress;
+import org.elasticsearch.common.xcontent.XContentBuilder;
+import org.elasticsearch.common.xcontent.XContentFactory;
+import org.elasticsearch.common.xcontent.XContentType;
+import org.elasticsearch.index.query.QueryBuilders;
+import org.elasticsearch.search.SearchHit;
+import org.elasticsearch.transport.client.PreBuiltTransportClient;
+import org.junit.Before;
+import org.junit.Test;
+
+import com.alibaba.fastjson.JSON;
+
+public class ElasticSearchManualTest {
+    private List<Person> listOfPersons = new ArrayList<>();
+    private Client client = null;
+
+    @Before
+    public void setUp() throws UnknownHostException {
+        Person person1 = new Person(10, "John Doe", new Date());
+        Person person2 = new Person(25, "Janette Doe", new Date());
+        listOfPersons.add(person1);
+        listOfPersons.add(person2);
+        
+        client = new PreBuiltTransportClient(Settings.builder().put("client.transport.sniff", true)
+            .put("cluster.name","elasticsearch").build())
+            .addTransportAddress(new InetSocketTransportAddress(InetAddress.getByName("127.0.0.1"), 9300));
+    }
+
+    @Test
+    public void givenJsonString_whenJavaObject_thenIndexDocument() {
+        String jsonObject = "{\"age\":20,\"dateOfBirth\":1471466076564,\"fullName\":\"John Doe\"}";
+        IndexResponse response = client
+          .prepareIndex("people", "Doe")
+          .setSource(jsonObject, XContentType.JSON)
+          .get();
+        String index = response.getIndex();
+        String type = response.getType();
+
+        assertEquals(Result.CREATED, response.getResult());
+        assertEquals(index, "people");
+        assertEquals(type, "Doe");
+    }
+
+    @Test
+    public void givenDocumentId_whenJavaObject_thenDeleteDocument() {
+        String jsonObject = "{\"age\":10,\"dateOfBirth\":1471455886564,\"fullName\":\"Johan Doe\"}";
+        IndexResponse response = client
+          .prepareIndex("people", "Doe")
+          .setSource(jsonObject, XContentType.JSON)
+          .get();
+        String id = response.getId();
+        DeleteResponse deleteResponse = client
+          .prepareDelete("people", "Doe", id)
+          .get();
+
+        assertEquals(Result.DELETED,deleteResponse.getResult());
+    }
+
+    @Test
+    public void givenSearchRequest_whenMatchAll_thenReturnAllResults() {
+        SearchResponse response = client
+          .prepareSearch()
+          .execute()
+          .actionGet();
+        SearchHit[] searchHits = response
+          .getHits()
+          .getHits();
+        List<Person> results = Arrays.stream(searchHits)
+          .map(hit -> JSON.parseObject(hit.getSourceAsString(), Person.class))
+          .collect(Collectors.toList());
+    }
+
+    @Test
+    public void givenSearchParameters_thenReturnResults() {
+        SearchResponse response = client
+          .prepareSearch()
+          .setTypes()
+          .setSearchType(SearchType.DFS_QUERY_THEN_FETCH)
+          .setPostFilter(QueryBuilders
+            .rangeQuery("age")
+            .from(5)
+            .to(15))
+          .setFrom(0)
+          .setSize(60)
+          .setExplain(true)
+          .execute()
+          .actionGet();
+
+        SearchResponse response2 = client
+          .prepareSearch()
+          .setTypes()
+          .setSearchType(SearchType.DFS_QUERY_THEN_FETCH)
+          .setPostFilter(QueryBuilders.simpleQueryStringQuery("+John -Doe OR Janette"))
+          .setFrom(0)
+          .setSize(60)
+          .setExplain(true)
+          .execute()
+          .actionGet();
+
+        SearchResponse response3 = client
+          .prepareSearch()
+          .setTypes()
+          .setSearchType(SearchType.DFS_QUERY_THEN_FETCH)
+          .setPostFilter(QueryBuilders.matchQuery("John", "Name*"))
+          .setFrom(0)
+          .setSize(60)
+          .setExplain(true)
+          .execute()
+          .actionGet();
+        response2.getHits();
+        response3.getHits();
+
+        final List<Person> results = Arrays.stream(response.getHits().getHits())
+          .map(hit -> JSON.parseObject(hit.getSourceAsString(), Person.class))
+          .collect(Collectors.toList());
+    }
+
+    @Test
+    public void givenContentBuilder_whenHelpers_thanIndexJson() throws IOException {
+        XContentBuilder builder = XContentFactory
+          .jsonBuilder()
+          .startObject()
+          .field("fullName", "Test")
+          .field("salary", "11500")
+          .field("age", "10")
+          .endObject();
+        IndexResponse response = client
+          .prepareIndex("people", "Doe")
+          .setSource(builder)
+          .get();
+
+        assertEquals(Result.CREATED, response.getResult());        
+    }
+}
--- a/persistence-modules/spring-data-elasticsearch/src/test/java/com/baeldung/elasticsearch/GeoQueriesIntegrationTest.java
+++ b/persistence-modules/spring-data-elasticsearch/src/test/java/com/baeldung/elasticsearch/GeoQueriesIntegrationTest.java
@@ -0,0 +1,181 @@
+package com.baeldung.elasticsearch;
+import static org.junit.Assert.assertTrue;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.elasticsearch.action.admin.indices.create.CreateIndexRequest;
+import org.elasticsearch.action.index.IndexResponse;
+import org.elasticsearch.action.search.SearchResponse;
+import org.elasticsearch.client.Client;
+import org.elasticsearch.common.geo.GeoPoint;
+import org.elasticsearch.common.geo.ShapeRelation;
+import org.elasticsearch.common.geo.builders.ShapeBuilders;
+import org.elasticsearch.common.unit.DistanceUnit;
+import org.elasticsearch.common.xcontent.XContentType;
+import org.elasticsearch.index.query.QueryBuilder;
+import org.elasticsearch.index.query.QueryBuilders;
+import org.elasticsearch.search.SearchHit;
+import org.junit.After;
+import org.junit.Before;
+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.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import com.baeldung.spring.data.es.config.Config;
+import com.vividsolutions.jts.geom.Coordinate;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = Config.class)
+public class GeoQueriesIntegrationTest {
+
+    private static final String WONDERS_OF_WORLD = "wonders-of-world";
+    private static final String WONDERS = "Wonders";
+
+    @Autowired
+    private ElasticsearchTemplate elasticsearchTemplate;
+
+    @Autowired
+    private Client client;
+
+    @Before
+    public void setUp() {
+        String jsonObject = "{\"Wonders\":{\"properties\":{\"name\":{\"type\":\"string\",\"index\":\"not_analyzed\"},\"region\":{\"type\":\"geo_shape\",\"tree\":\"quadtree\",\"precision\":\"1m\"},\"location\":{\"type\":\"geo_point\"}}}}";
+        CreateIndexRequest req = new CreateIndexRequest(WONDERS_OF_WORLD);
+        req.mapping(WONDERS, jsonObject, XContentType.JSON);
+        client.admin()
+          .indices()
+          .create(req)
+          .actionGet();
+    }
+
+    @Test
+    public void givenGeoShapeData_whenExecutedGeoShapeQuery_thenResultNonEmpty() throws IOException{
+        String jsonObject = "{\"name\":\"Agra\",\"region\":{\"type\":\"envelope\",\"coordinates\":[[75,30.2],[80.1, 25]]}}";
+        IndexResponse response = client.prepareIndex(WONDERS_OF_WORLD, WONDERS)
+          .setSource(jsonObject, XContentType.JSON)
+          .get();
+        
+        String tajMahalId = response.getId();
+        client.admin()
+          .indices()
+          .prepareRefresh(WONDERS_OF_WORLD)
+          .get();
+
+        Coordinate topLeft =new Coordinate(74, 31.2);
+        Coordinate bottomRight =new Coordinate(81.1, 24);
+        QueryBuilder qb = QueryBuilders
+            .geoShapeQuery("region", ShapeBuilders.newEnvelope(topLeft, bottomRight))
+            .relation(ShapeRelation.WITHIN);
+
+
+        SearchResponse searchResponse = client.prepareSearch(WONDERS_OF_WORLD)
+          .setTypes(WONDERS)
+          .setQuery(qb)
+          .execute()
+          .actionGet();
+
+        List<String> ids = Arrays.stream(searchResponse.getHits()
+          .getHits())
+          .map(SearchHit::getId)
+          .collect(Collectors.toList());
+
+        assertTrue(ids.contains(tajMahalId));
+    }
+
+    @Test
+    public void givenGeoPointData_whenExecutedGeoBoundingBoxQuery_thenResultNonEmpty() {
+        String jsonObject = "{\"name\":\"Pyramids of Giza\",\"location\":[31.131302,29.976480]}";
+        IndexResponse response = client.prepareIndex(WONDERS_OF_WORLD, WONDERS)
+          .setSource(jsonObject, XContentType.JSON)
+          .get();
+        String pyramidsOfGizaId = response.getId();
+        client.admin()
+          .indices()
+          .prepareRefresh(WONDERS_OF_WORLD)
+          .get();
+
+        QueryBuilder qb = QueryBuilders.geoBoundingBoxQuery("location")
+            .setCorners(31,30,28,32);
+        
+        SearchResponse searchResponse = client.prepareSearch(WONDERS_OF_WORLD)
+          .setTypes(WONDERS)
+          .setQuery(qb)
+          .execute()
+          .actionGet();
+        List<String> ids = Arrays.stream(searchResponse.getHits()
+          .getHits())
+          .map(SearchHit::getId)
+          .collect(Collectors.toList());
+        assertTrue(ids.contains(pyramidsOfGizaId));
+    }
+
+    @Test
+    public void givenGeoPointData_whenExecutedGeoDistanceQuery_thenResultNonEmpty() {
+        String jsonObject = "{\"name\":\"Lighthouse of alexandria\",\"location\":[31.131302,29.976480]}";
+        IndexResponse response = client.prepareIndex(WONDERS_OF_WORLD, WONDERS)
+          .setSource(jsonObject, XContentType.JSON)
+          .get();
+        String lighthouseOfAlexandriaId = response.getId();
+        client.admin()
+          .indices()
+          .prepareRefresh(WONDERS_OF_WORLD)
+          .get();
+
+        QueryBuilder qb = QueryBuilders.geoDistanceQuery("location")
+          .point(29.976, 31.131)
+          .distance(10, DistanceUnit.MILES);
+
+        SearchResponse searchResponse = client.prepareSearch(WONDERS_OF_WORLD)
+          .setTypes(WONDERS)
+          .setQuery(qb)
+          .execute()
+          .actionGet();
+        List<String> ids = Arrays.stream(searchResponse.getHits()
+          .getHits())
+          .map(SearchHit::getId)
+          .collect(Collectors.toList());
+        assertTrue(ids.contains(lighthouseOfAlexandriaId));
+    }
+
+    @Test
+    public void givenGeoPointData_whenExecutedGeoPolygonQuery_thenResultNonEmpty() {
+        String jsonObject = "{\"name\":\"The Great Rann of Kutch\",\"location\":[69.859741,23.733732]}";
+        IndexResponse response = client.prepareIndex(WONDERS_OF_WORLD, WONDERS)
+          .setSource(jsonObject, XContentType.JSON)
+          .get();
+        String greatRannOfKutchid = response.getId();
+        client.admin()
+          .indices()
+          .prepareRefresh(WONDERS_OF_WORLD)
+          .get();
+
+        List<GeoPoint> allPoints = new ArrayList<GeoPoint>();
+        allPoints.add(new GeoPoint(22.733, 68.859));
+        allPoints.add(new GeoPoint(24.733, 68.859));
+        allPoints.add(new GeoPoint(23, 70.859));
+        QueryBuilder qb = QueryBuilders.geoPolygonQuery("location", allPoints);
+
+        SearchResponse searchResponse = client.prepareSearch(WONDERS_OF_WORLD)
+          .setTypes(WONDERS)
+          .setQuery(qb)
+          .execute()
+          .actionGet();
+        List<String> ids = Arrays.stream(searchResponse.getHits()
+          .getHits())
+          .map(SearchHit::getId)
+          .collect(Collectors.toList());
+        assertTrue(ids.contains(greatRannOfKutchid));
+    }
+
+    @After
+    public void destroy() {
+        elasticsearchTemplate.deleteIndex(WONDERS_OF_WORLD);
+    }
+}
--- a/persistence-modules/spring-data-elasticsearch/src/test/java/com/baeldung/spring/data/es/ElasticSearchIntegrationTest.java
+++ b/persistence-modules/spring-data-elasticsearch/src/test/java/com/baeldung/spring/data/es/ElasticSearchIntegrationTest.java
@@ -0,0 +1,155 @@
+package com.baeldung.spring.data.es;
+
+import static java.util.Arrays.asList;
+import static org.elasticsearch.index.query.Operator.AND;
+import static org.elasticsearch.index.query.QueryBuilders.fuzzyQuery;
+import static org.elasticsearch.index.query.QueryBuilders.matchQuery;
+import static org.elasticsearch.index.query.QueryBuilders.regexpQuery;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+import java.util.List;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.elasticsearch.core.ElasticsearchTemplate;
+import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
+import org.springframework.data.elasticsearch.core.query.SearchQuery;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import com.baeldung.spring.data.es.config.Config;
+import com.baeldung.spring.data.es.model.Article;
+import com.baeldung.spring.data.es.model.Author;
+import com.baeldung.spring.data.es.service.ArticleService;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = Config.class)
+public class ElasticSearchIntegrationTest {
+
+    @Autowired
+    private ElasticsearchTemplate elasticsearchTemplate;
+
+    @Autowired
+    private ArticleService articleService;
+
+    private final Author johnSmith = new Author("John Smith");
+    private final Author johnDoe = new Author("John Doe");
+
+    @Before
+    public void before() {
+        elasticsearchTemplate.deleteIndex(Article.class);
+        elasticsearchTemplate.createIndex(Article.class);
+        // don't call putMapping() to test the default mappings
+
+        Article article = new Article("Spring Data Elasticsearch");
+        article.setAuthors(asList(johnSmith, johnDoe));
+        article.setTags("elasticsearch", "spring data");
+        articleService.save(article);
+
+        article = new Article("Search engines");
+        article.setAuthors(asList(johnDoe));
+        article.setTags("search engines", "tutorial");
+        articleService.save(article);
+
+        article = new Article("Second Article About Elasticsearch");
+        article.setAuthors(asList(johnSmith));
+        article.setTags("elasticsearch", "spring data");
+        articleService.save(article);
+
+        article = new Article("Elasticsearch Tutorial");
+        article.setAuthors(asList(johnDoe));
+        article.setTags("elasticsearch");
+        articleService.save(article);
+    }
+
+    @Test
+    public void givenArticleService_whenSaveArticle_thenIdIsAssigned() {
+        final List<Author> authors = asList(new Author("John Smith"), johnDoe);
+
+        Article article = new Article("Making Search Elastic");
+        article.setAuthors(authors);
+
+        article = articleService.save(article);
+        assertNotNull(article.getId());
+    }
+
+    @Test
+    public void givenPersistedArticles_whenSearchByAuthorsName_thenRightFound() {
+
+        final Page<Article> articleByAuthorName = articleService
+          .findByAuthorName(johnSmith.getName(), PageRequest.of(0, 10));
+        assertEquals(2L, articleByAuthorName.getTotalElements());
+    }
+
+    @Test
+    public void givenCustomQuery_whenSearchByAuthorsName_thenArticleIsFound() {
+        final Page<Article> articleByAuthorName = articleService.findByAuthorNameUsingCustomQuery("Smith", PageRequest.of(0, 10));
+        assertEquals(2L, articleByAuthorName.getTotalElements());
+    }
+
+    @Test
+    public void givenTagFilterQuery_whenSearchByTag_thenArticleIsFound() {
+        final Page<Article> articleByAuthorName = articleService.findByFilteredTagQuery("elasticsearch", PageRequest.of(0, 10));
+        assertEquals(3L, articleByAuthorName.getTotalElements());
+    }
+
+    @Test
+    public void givenTagFilterQuery_whenSearchByAuthorsName_thenArticleIsFound() {
+        final Page<Article> articleByAuthorName = articleService.findByAuthorsNameAndFilteredTagQuery("Doe", "elasticsearch", PageRequest.of(0, 10));
+        assertEquals(2L, articleByAuthorName.getTotalElements());
+    }
+
+    @Test
+    public void givenPersistedArticles_whenUseRegexQuery_thenRightArticlesFound() {
+
+        final SearchQuery searchQuery = new NativeSearchQueryBuilder().withFilter(regexpQuery("title", ".*data.*"))
+          .build();
+        final List<Article> articles = elasticsearchTemplate.queryForList(searchQuery, Article.class);
+
+        assertEquals(1, articles.size());
+    }
+
+    @Test
+    public void givenSavedDoc_whenTitleUpdated_thenCouldFindByUpdatedTitle() {
+        final SearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(fuzzyQuery("title", "serch")).build();
+        final List<Article> articles = elasticsearchTemplate.queryForList(searchQuery, Article.class);
+
+        assertEquals(1, articles.size());
+
+        final Article article = articles.get(0);
+        final String newTitle = "Getting started with Search Engines";
+        article.setTitle(newTitle);
+        articleService.save(article);
+
+        assertEquals(newTitle, articleService.findOne(article.getId()).get().getTitle());
+    }
+
+    @Test
+    public void givenSavedDoc_whenDelete_thenRemovedFromIndex() {
+
+        final String articleTitle = "Spring Data Elasticsearch";
+
+        final SearchQuery searchQuery = new NativeSearchQueryBuilder()
+          .withQuery(matchQuery("title", articleTitle).minimumShouldMatch("75%")).build();
+        final List<Article> articles = elasticsearchTemplate.queryForList(searchQuery, Article.class);
+        assertEquals(1, articles.size());
+        final long count = articleService.count();
+
+        articleService.delete(articles.get(0));
+
+        assertEquals(count - 1, articleService.count());
+    }
+
+    @Test
+    public void givenSavedDoc_whenOneTermMatches_thenFindByTitle() {
+        final SearchQuery searchQuery = new NativeSearchQueryBuilder()
+          .withQuery(matchQuery("title", "Search engines").operator(AND)).build();
+        final List<Article> articles = elasticsearchTemplate.queryForList(searchQuery, Article.class);
+        assertEquals(1, articles.size());
+    }
+}
--- a/persistence-modules/spring-data-elasticsearch/src/test/java/com/baeldung/spring/data/es/ElasticSearchQueryIntegrationTest.java
+++ b/persistence-modules/spring-data-elasticsearch/src/test/java/com/baeldung/spring/data/es/ElasticSearchQueryIntegrationTest.java
@@ -0,0 +1,207 @@
+package com.baeldung.spring.data.es;
+
+import static java.util.Arrays.asList;
+import static java.util.stream.Collectors.toList;
+import static org.elasticsearch.index.query.Operator.AND;
+import static org.elasticsearch.index.query.QueryBuilders.boolQuery;
+import static org.elasticsearch.index.query.QueryBuilders.matchPhraseQuery;
+import static org.elasticsearch.index.query.QueryBuilders.matchQuery;
+import static org.elasticsearch.index.query.QueryBuilders.multiMatchQuery;
+import static org.elasticsearch.index.query.QueryBuilders.nestedQuery;
+import static org.elasticsearch.index.query.QueryBuilders.termQuery;
+import static org.junit.Assert.assertEquals;
+
+import java.util.List;
+import java.util.Map;
+
+import org.apache.lucene.search.join.ScoreMode;
+import org.elasticsearch.action.search.SearchResponse;
+import org.elasticsearch.client.Client;
+import org.elasticsearch.common.unit.Fuzziness;
+import org.elasticsearch.index.query.MultiMatchQueryBuilder;
+import org.elasticsearch.index.query.QueryBuilder;
+import org.elasticsearch.search.aggregations.Aggregation;
+import org.elasticsearch.search.aggregations.AggregationBuilders;
+import org.elasticsearch.search.aggregations.bucket.MultiBucketsAggregation;
+import org.elasticsearch.search.aggregations.bucket.terms.StringTerms;
+import org.elasticsearch.search.aggregations.bucket.terms.Terms;
+import org.elasticsearch.search.aggregations.bucket.terms.TermsAggregationBuilder;
+import org.junit.Before;
+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.NativeSearchQueryBuilder;
+import org.springframework.data.elasticsearch.core.query.SearchQuery;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import com.baeldung.spring.data.es.config.Config;
+import com.baeldung.spring.data.es.model.Article;
+import com.baeldung.spring.data.es.model.Author;
+import com.baeldung.spring.data.es.service.ArticleService;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = Config.class)
+public class ElasticSearchQueryIntegrationTest {
+
+    @Autowired
+    private ElasticsearchTemplate elasticsearchTemplate;
+
+    @Autowired
+    private ArticleService articleService;
+
+    @Autowired
+    private Client client;
+
+    private final Author johnSmith = new Author("John Smith");
+    private final Author johnDoe = new Author("John Doe");
+
+    @Before
+    public void before() {
+        elasticsearchTemplate.deleteIndex(Article.class);
+        elasticsearchTemplate.createIndex(Article.class);
+        elasticsearchTemplate.putMapping(Article.class);
+        elasticsearchTemplate.refresh(Article.class);
+
+        Article article = new Article("Spring Data Elasticsearch");
+        article.setAuthors(asList(johnSmith, johnDoe));
+        article.setTags("elasticsearch", "spring data");
+        articleService.save(article);
+
+        article = new Article("Search engines");
+        article.setAuthors(asList(johnDoe));
+        article.setTags("search engines", "tutorial");
+        articleService.save(article);
+
+        article = new Article("Second Article About Elasticsearch");
+        article.setAuthors(asList(johnSmith));
+        article.setTags("elasticsearch", "spring data");
+        articleService.save(article);
+
+        article = new Article("Elasticsearch Tutorial");
+        article.setAuthors(asList(johnDoe));
+        article.setTags("elasticsearch");
+        articleService.save(article);
+    }
+
+    @Test
+    public void givenFullTitle_whenRunMatchQuery_thenDocIsFound() {
+        final SearchQuery searchQuery = new NativeSearchQueryBuilder()
+          .withQuery(matchQuery("title", "Search engines").operator(AND)).build();
+        final List<Article> articles = elasticsearchTemplate.queryForList(searchQuery, Article.class);
+        assertEquals(1, articles.size());
+    }
+
+    @Test
+    public void givenOneTermFromTitle_whenRunMatchQuery_thenDocIsFound() {
+        final SearchQuery searchQuery = new NativeSearchQueryBuilder()
+          .withQuery(matchQuery("title", "Engines Solutions")).build();
+        final List<Article> articles = elasticsearchTemplate.queryForList(searchQuery, Article.class);
+        assertEquals(1, articles.size());
+        assertEquals("Search engines", articles.get(0).getTitle());
+    }
+
+    @Test
+    public void givenPartTitle_whenRunMatchQuery_thenDocIsFound() {
+        final SearchQuery searchQuery = new NativeSearchQueryBuilder()
+          .withQuery(matchQuery("title", "elasticsearch data")).build();
+        final List<Article> articles = elasticsearchTemplate.queryForList(searchQuery, Article.class);
+        assertEquals(3, articles.size());
+    }
+
+    @Test
+    public void givenFullTitle_whenRunMatchQueryOnVerbatimField_thenDocIsFound() {
+        SearchQuery searchQuery = new NativeSearchQueryBuilder()
+          .withQuery(matchQuery("title.verbatim", "Second Article About Elasticsearch")).build();
+        List<Article> articles = elasticsearchTemplate.queryForList(searchQuery, Article.class);
+        assertEquals(1, articles.size());
+
+        searchQuery = new NativeSearchQueryBuilder().withQuery(matchQuery("title.verbatim", "Second Article About"))
+          .build();
+        articles = elasticsearchTemplate.queryForList(searchQuery, Article.class);
+        assertEquals(0, articles.size());
+    }
+
+    @Test
+    public void givenNestedObject_whenQueryByAuthorsName_thenFoundArticlesByThatAuthor() {
+        final QueryBuilder builder = nestedQuery("authors", boolQuery().must(termQuery("authors.name", "smith")), ScoreMode.None);
+
+        final SearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(builder).build();
+        final List<Article> articles = elasticsearchTemplate.queryForList(searchQuery, Article.class);
+
+        assertEquals(2, articles.size());
+    }
+
+    @Test
+    public void givenAnalyzedQuery_whenMakeAggregationOnTermCount_thenEachTokenCountsSeparately() {
+        final TermsAggregationBuilder aggregation = AggregationBuilders.terms("top_tags").field("title");
+        final SearchResponse response = client.prepareSearch("blog").setTypes("article").addAggregation(aggregation)
+          .execute().actionGet();
+
+        final Map<String, Aggregation> results = response.getAggregations().asMap();
+        final StringTerms topTags = (StringTerms) results.get("top_tags");
+
+        final List<String> keys = topTags.getBuckets().stream()
+          .map(MultiBucketsAggregation.Bucket::getKeyAsString)
+          .sorted()
+          .collect(toList());
+        assertEquals(asList("about", "article", "data", "elasticsearch", "engines", "search", "second", "spring", "tutorial"), keys);
+    }
+
+    @Test
+    public void givenNotAnalyzedQuery_whenMakeAggregationOnTermCount_thenEachTermCountsIndividually() {
+        final TermsAggregationBuilder aggregation = AggregationBuilders.terms("top_tags").field("tags")
+          .order(Terms.Order.count(false));
+        final SearchResponse response = client.prepareSearch("blog").setTypes("article").addAggregation(aggregation)
+          .execute().actionGet();
+
+        final Map<String, Aggregation> results = response.getAggregations().asMap();
+        final StringTerms topTags = (StringTerms) results.get("top_tags");
+
+        final List<String> keys = topTags.getBuckets().stream()
+          .map(MultiBucketsAggregation.Bucket::getKeyAsString)
+          .collect(toList());
+        assertEquals(asList("elasticsearch", "spring data", "search engines", "tutorial"), keys);
+    }
+
+    @Test
+    public void givenNotExactPhrase_whenUseSlop_thenQueryMatches() {
+        final SearchQuery searchQuery = new NativeSearchQueryBuilder()
+          .withQuery(matchPhraseQuery("title", "spring elasticsearch").slop(1)).build();
+        final List<Article> articles = elasticsearchTemplate.queryForList(searchQuery, Article.class);
+        assertEquals(1, articles.size());
+    }
+
+    @Test
+    public void givenPhraseWithType_whenUseFuzziness_thenQueryMatches() {
+        final SearchQuery searchQuery = new NativeSearchQueryBuilder()
+          .withQuery(matchQuery("title", "spring date elasticserch").operator(AND).fuzziness(Fuzziness.ONE)
+            .prefixLength(3)).build();
+
+        final List<Article> articles = elasticsearchTemplate.queryForList(searchQuery, Article.class);
+        assertEquals(1, articles.size());
+    }
+
+    @Test
+    public void givenMultimatchQuery_whenDoSearch_thenAllProvidedFieldsMatch() {
+        final SearchQuery searchQuery = new NativeSearchQueryBuilder()
+          .withQuery(multiMatchQuery("tutorial").field("title").field("tags")
+            .type(MultiMatchQueryBuilder.Type.BEST_FIELDS)).build();
+
+        final List<Article> articles = elasticsearchTemplate.queryForList(searchQuery, Article.class);
+        assertEquals(2, articles.size());
+    }
+
+    @Test
+    public void givenBoolQuery_whenQueryByAuthorsName_thenFoundArticlesByThatAuthorAndFilteredTag() {
+        final QueryBuilder builder = boolQuery().must(nestedQuery("authors", boolQuery().must(termQuery("authors.name", "doe")), ScoreMode.None))
+            .filter(termQuery("tags", "elasticsearch"));
+
+        final SearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(builder)
+            .build();
+        final List<Article> articles = elasticsearchTemplate.queryForList(searchQuery, Article.class);
+
+        assertEquals(2, articles.size());
+    }
+}