Adding missing files

2013-01-24 17:37:03 +00:00
parent 05de948d20
commit 54a1f186d7
66 changed files with 5243 additions and 3 deletions
--- a/src/test/java/org/springframework/data/elasticsearch/NonDocumentEntity.java
+++ b/src/test/java/org/springframework/data/elasticsearch/NonDocumentEntity.java
@@ -0,0 +1,27 @@
+package org.springframework.data.elasticsearch;
+
+
+import org.springframework.data.elasticsearch.annotations.Document;
+
+@Document(indexName = "Foo")
+public class NonDocumentEntity {
+
+    private String someField1;
+    private String someField2;
+
+    public String getSomeField1() {
+        return someField1;
+    }
+
+    public void setSomeField1(String someField1) {
+        this.someField1 = someField1;
+    }
+
+    public String getSomeField2() {
+        return someField2;
+    }
+
+    public void setSomeField2(String someField2) {
+        this.someField2 = someField2;
+    }
+}
--- a/src/test/java/org/springframework/data/elasticsearch/SampleEntity.java
+++ b/src/test/java/org/springframework/data/elasticsearch/SampleEntity.java
@@ -0,0 +1,72 @@
+package org.springframework.data.elasticsearch;
+
+import org.apache.commons.lang.builder.EqualsBuilder;
+import org.apache.commons.lang.builder.HashCodeBuilder;
+import org.springframework.data.annotation.Id;
+import org.springframework.data.elasticsearch.annotations.Document;
+
+@Document(indexName = "test-index", type = "test-type")
+public class SampleEntity {
+
+    @Id
+    private String id;
+    private String type;
+    private String message;
+    private int rate;
+
+    public String getId() {
+        return id;
+    }
+
+    public void setId(String id) {
+        this.id = id;
+    }
+
+    public String getType() {
+        return type;
+    }
+
+    public void setType(String type) {
+        this.type = type;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+
+    public void setMessage(String message) {
+        this.message = message;
+    }
+
+    public int getRate() {
+        return rate;
+    }
+
+    public void setRate(int rate) {
+        this.rate = rate;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (!(obj instanceof SampleEntity)) {
+            return false;
+        }
+        if (this == obj) {
+            return true;
+        }
+        SampleEntity rhs = (SampleEntity) obj;
+        return new EqualsBuilder().append(this.id, rhs.id)
+                .append(this.type, rhs.type)
+                .append(this.message, rhs.message)
+                .isEquals();
+    }
+
+    @Override
+    public int hashCode() {
+        return new HashCodeBuilder()
+                .append(id)
+                .append(type)
+                .append(message)
+                .toHashCode();
+    }
+}
--- a/src/test/java/org/springframework/data/elasticsearch/config/ElasticsearchNamespaceHandlerTest.java
+++ b/src/test/java/org/springframework/data/elasticsearch/config/ElasticsearchNamespaceHandlerTest.java
@@ -0,0 +1,44 @@
+package org.springframework.data.elasticsearch.config;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.ApplicationContext;
+import org.springframework.data.elasticsearch.repositories.SampleElasticsearchRepository;
+import org.springframework.data.elasticsearch.client.NodeClientFactoryBean;
+import org.springframework.data.elasticsearch.client.TransportClientFactoryBean;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.CoreMatchers.notNullValue;
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertThat;
+
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration("namespace.xml")
+public class ElasticsearchNamespaceHandlerTest {
+
+    @Autowired
+    private ApplicationContext context;
+
+    @Test
+    public void shouldCreatesNodeClient() {
+        assertThat(context.getBean(NodeClientFactoryBean.class), is(notNullValue()));
+        assertThat(context.getBean(NodeClientFactoryBean.class), is(instanceOf(NodeClientFactoryBean.class)));
+    }
+
+    @Test
+    public void shouldCreateTransportClient() {
+        assertThat(context.getBean(TransportClientFactoryBean.class), is(notNullValue()));
+        assertThat(context.getBean(TransportClientFactoryBean.class), is(instanceOf(TransportClientFactoryBean.class)));
+    }
+
+    @Test
+    public void shouldCreateRepository(){
+        assertThat(context.getBean(TransportClientFactoryBean.class), is(notNullValue()));
+        assertThat(context.getBean(SampleElasticsearchRepository.class), is(instanceOf(SampleElasticsearchRepository.class)));
+    }
+
+}
--- a/src/test/java/org/springframework/data/elasticsearch/config/EnableElasticsearchRepositoriesTest.java
+++ b/src/test/java/org/springframework/data/elasticsearch/config/EnableElasticsearchRepositoriesTest.java
@@ -0,0 +1,44 @@
+package org.springframework.data.elasticsearch.config;
+
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
+import org.springframework.data.elasticsearch.core.ElasticsearchTemplate;
+import org.springframework.data.elasticsearch.repositories.SampleElasticsearchRepository;
+import org.springframework.data.elasticsearch.repository.config.EnableElasticsearchRepositories;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import static org.elasticsearch.node.NodeBuilder.nodeBuilder;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.notNullValue;
+import static org.junit.Assert.assertThat;
+
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration
+public class EnableElasticsearchRepositoriesTest {
+
+    @Configuration
+    @EnableElasticsearchRepositories(basePackages = "org.springframework.data.elasticsearch.repositories")
+    static class Config {
+
+        @Bean
+        public ElasticsearchOperations elasticsearchTemplate() {
+            return new ElasticsearchTemplate(nodeBuilder().local(true).node().client());
+        }
+    }
+
+    @Autowired
+    private SampleElasticsearchRepository repository;
+
+    @Test
+    public void bootstrapsRepository() {
+        assertThat(repository, is(notNullValue()));
+    }
+
+}
--- a/src/test/java/org/springframework/data/elasticsearch/core/ElasticsearchTemplateTest.java
+++ b/src/test/java/org/springframework/data/elasticsearch/core/ElasticsearchTemplateTest.java
@@ -0,0 +1,338 @@
+package org.springframework.data.elasticsearch.core;
+
+
+import org.junit.Before;
+import org.junit.Ignore;
+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.domain.Sort;
+import org.springframework.data.elasticsearch.SampleEntity;
+import org.springframework.data.elasticsearch.core.query.*;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.apache.commons.lang.RandomStringUtils.randomNumeric;
+import static org.elasticsearch.index.query.FilterBuilders.boolFilter;
+import static org.elasticsearch.index.query.FilterBuilders.termFilter;
+import static org.elasticsearch.index.query.QueryBuilders.fieldQuery;
+import static org.elasticsearch.index.query.QueryBuilders.matchAllQuery;
+import static org.hamcrest.Matchers.*;
+import static org.junit.Assert.*;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration("classpath:elasticsearch-template-test.xml")
+public class ElasticsearchTemplateTest {
+
+    @Autowired
+    private ElasticsearchTemplate elasticsearchTemplate;
+
+    @Before
+    public void before(){
+        elasticsearchTemplate.createIndex(SampleEntity.class);
+        DeleteQuery deleteQuery = new DeleteQuery();
+        deleteQuery.setElasticsearchQuery(matchAllQuery());
+        elasticsearchTemplate.delete(deleteQuery,SampleEntity.class);
+        elasticsearchTemplate.refresh(SampleEntity.class, true);
+    }
+
+    @Test
+    public void shouldReturnCountForGivenSearchQuery(){
+        //given
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity = new SampleEntity();
+        sampleEntity.setId(documentId);
+        sampleEntity.setMessage("some message");
+        IndexQuery indexQuery = new IndexQuery();
+        indexQuery.setId(documentId);
+        indexQuery.setObject(sampleEntity);
+        elasticsearchTemplate.index(indexQuery);
+        elasticsearchTemplate.refresh(SampleEntity.class, true);
+        SearchQuery searchQuery = new SearchQuery();
+        searchQuery.setElasticsearchQuery(matchAllQuery());
+        //when
+        long count = elasticsearchTemplate.count(searchQuery, SampleEntity.class);
+        //then
+        assertThat(count, is(equalTo(1L)));
+    }
+
+    @Test
+    public void shouldReturnObjectForGivenId(){
+        //given
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity = new SampleEntity();
+        sampleEntity.setId(documentId);
+        sampleEntity.setMessage("some message");
+        IndexQuery indexQuery = new IndexQuery();
+        indexQuery.setId(documentId);
+        indexQuery.setObject(sampleEntity);
+        elasticsearchTemplate.index(indexQuery);
+        //when
+        GetQuery getQuery = new GetQuery();
+        getQuery.setId(documentId);
+        SampleEntity sampleEntity1 = elasticsearchTemplate.queryForObject(getQuery, SampleEntity.class);
+        //then
+        assertNotNull("not null....", sampleEntity1);
+        assertEquals(sampleEntity, sampleEntity1);
+    }
+
+    @Test
+    public void shouldReturnPageForGivenSearchQuery(){
+        //given
+        //given
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity = new SampleEntity();
+        sampleEntity.setId(documentId);
+        sampleEntity.setMessage("some message");
+        IndexQuery indexQuery = new IndexQuery();
+        indexQuery.setId(documentId);
+        indexQuery.setObject(sampleEntity);
+        elasticsearchTemplate.index(indexQuery);
+        elasticsearchTemplate.refresh(SampleEntity.class, true);
+        SearchQuery searchQuery = new SearchQuery();
+        searchQuery.setElasticsearchQuery(matchAllQuery());
+        //when
+        Page<SampleEntity> sampleEntities = elasticsearchTemplate.queryForPage(searchQuery, SampleEntity.class);
+        //then
+        assertThat(sampleEntities, is(notNullValue()));
+        assertThat(sampleEntities.getTotalElements(), greaterThanOrEqualTo(1L));
+    }
+
+    @Test
+    public void shouldDoBulkIndex(){
+        //given
+        List<IndexQuery> indexQueries = new ArrayList<IndexQuery>();
+        //first document
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity1 = new SampleEntity();
+        sampleEntity1.setId(documentId);
+        sampleEntity1.setMessage("some message");
+
+        IndexQuery indexQuery1 = new IndexQuery();
+        indexQuery1.setId(documentId);
+        indexQuery1.setObject(sampleEntity1);
+        indexQueries.add(indexQuery1);
+
+        //second document
+        String documentId2 = randomNumeric(5);
+        SampleEntity sampleEntity2 = new SampleEntity();
+        sampleEntity2.setId(documentId2);
+        sampleEntity2.setMessage("some message");
+        IndexQuery indexQuery2 = new IndexQuery();
+        indexQuery2.setId(documentId2);
+        indexQuery2.setObject(sampleEntity2);
+
+        indexQueries.add(indexQuery2);
+        //when
+        elasticsearchTemplate.bulkIndex(indexQueries);
+        elasticsearchTemplate.refresh(SampleEntity.class,true);
+        //then
+        SearchQuery searchQuery = new SearchQuery();
+        searchQuery.setElasticsearchQuery(matchAllQuery());
+        Page<SampleEntity> sampleEntities = elasticsearchTemplate.queryForPage(searchQuery,SampleEntity.class);
+        assertThat(sampleEntities.getTotalElements(), is(equalTo(2L)));
+    }
+
+    @Test
+    public void shouldDeleteDocumentForGivenId(){
+        //given
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity = new SampleEntity();
+        sampleEntity.setId(documentId);
+        sampleEntity.setMessage("some message");
+        IndexQuery indexQuery = new IndexQuery();
+        indexQuery.setId(documentId);
+        indexQuery.setObject(sampleEntity);
+        elasticsearchTemplate.index(indexQuery);
+        //when
+        elasticsearchTemplate.delete("test-index","test-type",documentId);
+        elasticsearchTemplate.refresh(SampleEntity.class, true);
+        //then
+        SearchQuery searchQuery = new SearchQuery();
+        searchQuery.setElasticsearchQuery(fieldQuery("id", documentId));
+        Page<SampleEntity> sampleEntities = elasticsearchTemplate.queryForPage(searchQuery,SampleEntity.class);
+        assertThat(sampleEntities.getTotalElements(), equalTo(0L));
+    }
+
+    @Test
+    public void shouldDeleteEntityForGivenId(){
+        //given
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity = new SampleEntity();
+        sampleEntity.setId(documentId);
+        sampleEntity.setMessage("some message");
+        IndexQuery indexQuery = new IndexQuery();
+        indexQuery.setId(documentId);
+        indexQuery.setObject(sampleEntity);
+        elasticsearchTemplate.index(indexQuery);
+        //when
+        elasticsearchTemplate.delete(SampleEntity.class,documentId);
+        elasticsearchTemplate.refresh(SampleEntity.class, true);
+        //then
+        SearchQuery searchQuery = new SearchQuery();
+        searchQuery.setElasticsearchQuery(fieldQuery("id", documentId));
+        Page<SampleEntity> sampleEntities = elasticsearchTemplate.queryForPage(searchQuery,SampleEntity.class);
+        assertThat(sampleEntities.getTotalElements(), equalTo(0L));
+    }
+
+    @Test
+    public void shouldDeleteDocumentForGivenQuery(){
+        //given
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity = new SampleEntity();
+        sampleEntity.setId(documentId);
+        sampleEntity.setMessage("some message");
+        IndexQuery indexQuery = new IndexQuery();
+        indexQuery.setId(documentId);
+        indexQuery.setObject(sampleEntity);
+        elasticsearchTemplate.index(indexQuery);
+        //when
+        DeleteQuery deleteQuery = new DeleteQuery();
+        deleteQuery.setElasticsearchQuery(fieldQuery("id", documentId));
+        elasticsearchTemplate.delete(deleteQuery,SampleEntity.class);
+        //then
+        SearchQuery searchQuery = new SearchQuery();
+        searchQuery.setElasticsearchQuery(fieldQuery("id",documentId));
+        Page<SampleEntity> sampleEntities = elasticsearchTemplate.queryForPage(searchQuery,SampleEntity.class);
+        assertThat(sampleEntities.getTotalElements(), equalTo(0L));
+    }
+
+    @Test
+    public void shouldTestFilterBuilder(){
+        //given
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity = new SampleEntity();
+        sampleEntity.setId(documentId);
+        sampleEntity.setMessage("some message");
+        IndexQuery indexQuery = new IndexQuery();
+        indexQuery.setId(documentId);
+        indexQuery.setObject(sampleEntity);
+        elasticsearchTemplate.index(indexQuery);
+        elasticsearchTemplate.refresh(SampleEntity.class, true);
+        SearchQuery searchQuery = new SearchQuery();
+        searchQuery.setElasticsearchQuery(matchAllQuery());
+        searchQuery.setElasticsearchFilter(boolFilter().must(termFilter("id", documentId)));
+        //when
+        Page<SampleEntity> sampleEntities = elasticsearchTemplate.queryForPage(searchQuery,SampleEntity.class);
+        //then
+        assertThat(sampleEntities.getTotalElements(), equalTo(1L));
+    }
+
+    @Test
+    public void testStringQuery(){
+        //given
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity = new SampleEntity();
+        sampleEntity.setId(documentId);
+        sampleEntity.setMessage("some message");
+        IndexQuery indexQuery = new IndexQuery();
+        indexQuery.setId(documentId);
+        indexQuery.setObject(sampleEntity);
+        elasticsearchTemplate.index(indexQuery);
+        elasticsearchTemplate.refresh(SampleEntity.class, true);
+        StringQuery stringQuery = new StringQuery(matchAllQuery().toString());
+        //when
+        Page<SampleEntity> sampleEntities = elasticsearchTemplate.queryForPage(stringQuery,SampleEntity.class);
+        //then
+        assertThat(sampleEntities.getTotalElements(), equalTo(1L));
+    }
+
+    @Test
+    public void testStringQueryWithPageable(){
+        //given
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity = new SampleEntity();
+        sampleEntity.setId(documentId);
+        sampleEntity.setMessage("some message");
+        IndexQuery indexQuery = new IndexQuery();
+        indexQuery.setId(documentId);
+        indexQuery.setObject(sampleEntity);
+        elasticsearchTemplate.index(indexQuery);
+        elasticsearchTemplate.refresh(SampleEntity.class, true);
+        StringQuery stringQuery = new StringQuery(matchAllQuery().toString(),new PageRequest(0,10));
+        //when
+        Page<SampleEntity> sampleEntities = elasticsearchTemplate.queryForPage(stringQuery,SampleEntity.class);
+
+        //then
+        assertThat(sampleEntities.getTotalElements(), is(greaterThanOrEqualTo(1L)));
+    }
+
+    @Test
+    @Ignore("By default, the search request will fail if there is no mapping associated with a field. The ignore_unmapped option allows to ignore fields that have no mapping and not sort by them")
+    public void testStringQueryWithPageableAndSort(){
+        //todo
+        //given
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity = new SampleEntity();
+        sampleEntity.setId(documentId);
+        sampleEntity.setMessage("some message");
+        IndexQuery indexQuery = new IndexQuery();
+        indexQuery.setId(documentId);
+        indexQuery.setObject(sampleEntity);
+        elasticsearchTemplate.index(indexQuery);
+        elasticsearchTemplate.refresh(SampleEntity.class, true);
+        StringQuery stringQuery = new StringQuery(matchAllQuery().toString(),new PageRequest(0,10), new Sort(new Sort.Order(Sort.Direction.ASC,"messsage")));
+
+        //when
+        Page<SampleEntity> sampleEntities = elasticsearchTemplate.queryForPage(stringQuery,SampleEntity.class);
+        //then
+        assertThat(sampleEntities.getTotalElements(), is(greaterThanOrEqualTo(1L)));
+    }
+
+    @Test
+    public void testStringQueryGetObject(){
+        //given
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity = new SampleEntity();
+        sampleEntity.setId(documentId);
+        sampleEntity.setMessage("some message");
+        IndexQuery indexQuery = new IndexQuery();
+        indexQuery.setId(documentId);
+        indexQuery.setObject(sampleEntity);
+        elasticsearchTemplate.index(indexQuery);
+        elasticsearchTemplate.refresh(SampleEntity.class, true);
+        StringQuery stringQuery = new StringQuery(fieldQuery("id",documentId).toString());
+
+        //when
+        SampleEntity sampleEntity1 = elasticsearchTemplate.queryForObject(stringQuery, SampleEntity.class);
+        //then
+        assertThat(sampleEntity1, is(notNullValue()));
+        assertThat(sampleEntity1.getId(), is(equalTo(documentId)));
+    }
+
+    @Test
+    public void testCreateIndex(){
+        //when
+        boolean created = elasticsearchTemplate.createIndex(SampleEntity.class);
+        //then
+        assertThat(created, is(true));
+    }
+
+
+    @Test
+    public void testCriteria(){
+        //given
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity = new SampleEntity();
+        sampleEntity.setId(documentId);
+        sampleEntity.setMessage("some test message");
+        IndexQuery indexQuery = new IndexQuery();
+        indexQuery.setId(documentId);
+        indexQuery.setObject(sampleEntity);
+        elasticsearchTemplate.index(indexQuery);
+        elasticsearchTemplate.refresh(SampleEntity.class, true);
+        CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria("message").contains("test"));
+        //when
+        SampleEntity sampleEntity1 = elasticsearchTemplate.queryForObject(criteriaQuery,SampleEntity.class);
+        //then
+        assertThat(sampleEntity1, is(notNullValue()));
+    }
+
+
+
+}
--- a/src/test/java/org/springframework/data/elasticsearch/core/convert/DateTimeConvertersTest.java
+++ b/src/test/java/org/springframework/data/elasticsearch/core/convert/DateTimeConvertersTest.java
@@ -0,0 +1,56 @@
+package org.springframework.data.elasticsearch.core.convert;
+
+import org.joda.time.DateTime;
+import org.joda.time.DateTimeZone;
+import org.joda.time.LocalDateTime;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import java.util.Calendar;
+import java.util.TimeZone;
+
+
+public class DateTimeConvertersTest {
+    @Test
+    public void testJodaDateTimeConverterWithNullValue() {
+        Assert.assertNull(DateTimeConverters.JodaDateTimeConverter.INSTANCE.convert(null));
+    }
+
+    @Test
+    public void testJodaDateTimeConverter() {
+        DateTime dateTime = new DateTime(2013, 1,24 , 6, 35, 0, DateTimeZone.UTC);
+        Assert.assertEquals("2013-01-24T06:35:00.000Z",
+                DateTimeConverters.JodaDateTimeConverter.INSTANCE.convert(dateTime));
+    }
+
+    @Test
+    public void testJodaLocalDateTimeConverterWithNullValue() {
+        Assert.assertNull(DateTimeConverters.JodaLocalDateTimeConverter.INSTANCE.convert(null));
+    }
+
+    @Test
+    public void testJodaLocalDateTimeConverter() {
+        LocalDateTime dateTime = new LocalDateTime(new DateTime(2013, 1,24, 6, 35, 0, DateTimeZone.UTC).getMillis(),
+                DateTimeZone.UTC);
+        Assert.assertEquals("2013-01-24T06:35:00.000Z",
+                DateTimeConverters.JodaLocalDateTimeConverter.INSTANCE.convert(dateTime));
+    }
+
+    @Test
+    public void testJavaDateConverterWithNullValue() {
+        Assert.assertNull(DateTimeConverters.JavaDateConverter.INSTANCE.convert(null));
+    }
+
+    @Test
+    public void testJavaDateConverter() {
+        DateTime dateTime = new DateTime(2013, 1,24, 6, 35, 0, DateTimeZone.UTC);
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTimeZone(TimeZone.getTimeZone("UTC"));
+        calendar.setTimeInMillis(dateTime.getMillis());
+
+        Assert.assertEquals("2013-01-24T06:35:00.000Z",
+                DateTimeConverters.JavaDateConverter.INSTANCE.convert(calendar.getTime()));
+    }
+}
--- a/src/test/java/org/springframework/data/elasticsearch/core/convert/MappingElasticsearchConverterTest.java
+++ b/src/test/java/org/springframework/data/elasticsearch/core/convert/MappingElasticsearchConverterTest.java
@@ -0,0 +1,40 @@
+package org.springframework.data.elasticsearch.core.convert;
+
+
+import org.junit.Test;
+import org.springframework.core.convert.ConversionService;
+import org.springframework.data.elasticsearch.core.mapping.SimpleElasticsearchMappingContext;
+import org.springframework.data.mapping.context.MappingContext;
+
+import static org.hamcrest.Matchers.*;
+import static org.junit.Assert.assertThat;
+
+public class MappingElasticsearchConverterTest {
+
+    @Test(expected = IllegalArgumentException.class)
+    public void shouldFailToInitializeGivenMappingContextIsNull(){
+        //given
+        new MappingElasticsearchConverter(null);
+    }
+
+    @Test
+    public void shouldReturnMappingContextWithWhichItWasInitialized(){
+        //given
+        MappingContext mappingContext = new SimpleElasticsearchMappingContext();
+        MappingElasticsearchConverter converter = new MappingElasticsearchConverter(mappingContext);
+        //then
+        assertThat(converter.getMappingContext(), is(notNullValue()));
+        assertThat(converter.getMappingContext(), is(sameInstance(mappingContext)));
+    }
+
+    @Test
+    public void shouldReturnDefaultConversionService(){
+        //given
+        MappingElasticsearchConverter converter = new MappingElasticsearchConverter(new SimpleElasticsearchMappingContext());
+        //when
+        ConversionService conversionService = converter.getConversionService();
+        //then
+        assertThat(conversionService, is(notNullValue()));
+    }
+
+}
--- a/src/test/java/org/springframework/data/elasticsearch/core/query/CriteriaQueryTest.java
+++ b/src/test/java/org/springframework/data/elasticsearch/core/query/CriteriaQueryTest.java
@@ -0,0 +1,627 @@
+package org.springframework.data.elasticsearch.core.query;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.data.domain.Page;
+import org.springframework.data.elasticsearch.SampleEntity;
+import org.springframework.data.elasticsearch.core.ElasticsearchTemplate;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import javax.annotation.Resource;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.apache.commons.lang.RandomStringUtils.randomNumeric;
+import static org.hamcrest.Matchers.*;
+import static org.hamcrest.Matchers.is;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration("classpath:elasticsearch-template-test.xml")
+public class CriteriaQueryTest {
+
+    @Resource
+    private ElasticsearchTemplate elasticsearchTemplate;
+
+    @Test
+    public void shouldTestAndOperation(){
+        //given
+        //given
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity = new SampleEntity();
+        sampleEntity.setId(documentId);
+        sampleEntity.setMessage("some test message");
+        IndexQuery indexQuery = new IndexQuery();
+        indexQuery.setId(documentId);
+        indexQuery.setObject(sampleEntity);
+        elasticsearchTemplate.index(indexQuery);
+        elasticsearchTemplate.refresh(SampleEntity.class, true);
+        CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria("message").contains("test").and("message").contains("some"));
+        //when
+        SampleEntity sampleEntity1 = elasticsearchTemplate.queryForObject(criteriaQuery,SampleEntity.class);
+        //then
+        assertThat(sampleEntity1, is(notNullValue()));
+    }
+
+    @Test
+    public void shouldTestOrOperation(){
+        //given
+        List<IndexQuery> indexQueries = new ArrayList<IndexQuery>();
+        //first document
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity1 = new SampleEntity();
+        sampleEntity1.setId(documentId);
+        sampleEntity1.setMessage("some message");
+
+        IndexQuery indexQuery1 = new IndexQuery();
+        indexQuery1.setId(documentId);
+        indexQuery1.setObject(sampleEntity1);
+        indexQueries.add(indexQuery1);
+
+        //second document
+        String documentId2 = randomNumeric(5);
+        SampleEntity sampleEntity2 = new SampleEntity();
+        sampleEntity2.setId(documentId2);
+        sampleEntity2.setMessage("test message");
+        IndexQuery indexQuery2 = new IndexQuery();
+        indexQuery2.setId(documentId2);
+        indexQuery2.setObject(sampleEntity2);
+
+        indexQueries.add(indexQuery2);
+        elasticsearchTemplate.bulkIndex(indexQueries);
+        elasticsearchTemplate.refresh(SampleEntity.class,true);
+        CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria("message").contains("some").or("message").contains("test"));
+        //when
+        Page<SampleEntity> page = elasticsearchTemplate.queryForPage(criteriaQuery, SampleEntity.class);
+        //then
+        assertThat(page, is(notNullValue()));
+        assertThat(page.getTotalElements(),is(greaterThanOrEqualTo(1L)));
+    }
+
+    @Test
+    public void shouldTestInnerAndCriteria(){
+        //given
+        List<IndexQuery> indexQueries = new ArrayList<IndexQuery>();
+        //first document
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity1 = new SampleEntity();
+        sampleEntity1.setId(documentId);
+        sampleEntity1.setMessage("some message");
+
+        IndexQuery indexQuery1 = new IndexQuery();
+        indexQuery1.setId(documentId);
+        indexQuery1.setObject(sampleEntity1);
+        indexQueries.add(indexQuery1);
+
+        elasticsearchTemplate.bulkIndex(indexQueries);
+        elasticsearchTemplate.refresh(SampleEntity.class,true);
+        CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria().and(new Criteria("message").contains("some")));
+        //when
+        Page<SampleEntity> page = elasticsearchTemplate.queryForPage(criteriaQuery, SampleEntity.class);
+        //then
+        assertThat(page, is(notNullValue()));
+        assertThat(page.getTotalElements(),is(greaterThanOrEqualTo(1L)));
+    }
+
+
+    @Test
+    public void shouldTestInnerOrCriteria(){
+        //given
+        List<IndexQuery> indexQueries = new ArrayList<IndexQuery>();
+        //first document
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity1 = new SampleEntity();
+        sampleEntity1.setId(documentId);
+        sampleEntity1.setMessage("some message");
+
+        IndexQuery indexQuery1 = new IndexQuery();
+        indexQuery1.setId(documentId);
+        indexQuery1.setObject(sampleEntity1);
+        indexQueries.add(indexQuery1);
+
+        elasticsearchTemplate.bulkIndex(indexQueries);
+        elasticsearchTemplate.refresh(SampleEntity.class,true);
+        CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria().or(new Criteria("message").contains("some")));
+        //when
+        Page<SampleEntity> page = elasticsearchTemplate.queryForPage(criteriaQuery, SampleEntity.class);
+        //then
+        assertThat(page, is(notNullValue()));
+        assertThat(page.getTotalElements(),is(greaterThanOrEqualTo(1L)));
+    }
+
+    @Test
+    public void testIs() {
+        //given
+        List<IndexQuery> indexQueries = new ArrayList<IndexQuery>();
+        //first document
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity1 = new SampleEntity();
+        sampleEntity1.setId(documentId);
+        sampleEntity1.setMessage("some message");
+
+        IndexQuery indexQuery1 = new IndexQuery();
+        indexQuery1.setId(documentId);
+        indexQuery1.setObject(sampleEntity1);
+        indexQueries.add(indexQuery1);
+
+        elasticsearchTemplate.bulkIndex(indexQueries);
+        elasticsearchTemplate.refresh(SampleEntity.class,true);
+        CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria("message").is("some message"));
+        //when
+        Page<SampleEntity> page= elasticsearchTemplate.queryForPage(criteriaQuery, SampleEntity.class);
+        //then
+        assertThat("message", is(criteriaQuery.getCriteria().getField().getName()));
+        assertThat(page.getTotalElements(),is(greaterThanOrEqualTo(1L)));
+    }
+
+    @Test
+    public void testMultipleIs() {
+        //given
+        List<IndexQuery> indexQueries = new ArrayList<IndexQuery>();
+        //first document
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity1 = new SampleEntity();
+        sampleEntity1.setId(documentId);
+        sampleEntity1.setMessage("some message");
+
+        IndexQuery indexQuery1 = new IndexQuery();
+        indexQuery1.setId(documentId);
+        indexQuery1.setObject(sampleEntity1);
+        indexQueries.add(indexQuery1);
+
+        //second document
+        String documentId2 = randomNumeric(5);
+        SampleEntity sampleEntity2 = new SampleEntity();
+        sampleEntity2.setId(documentId2);
+        sampleEntity2.setMessage("test message");
+        IndexQuery indexQuery2 = new IndexQuery();
+        indexQuery2.setId(documentId2);
+        indexQuery2.setObject(sampleEntity2);
+
+        indexQueries.add(indexQuery2);
+        elasticsearchTemplate.bulkIndex(indexQueries);
+        elasticsearchTemplate.refresh(SampleEntity.class,true);
+        CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria("message").is("some message").is("test message"));
+        //when
+        Page<SampleEntity> page = elasticsearchTemplate.queryForPage(criteriaQuery,SampleEntity.class);
+        //then
+        assertThat("message", is(criteriaQuery.getCriteria().getField().getName()));
+        assertThat(page.getTotalElements(),is(greaterThanOrEqualTo(2L)));
+    }
+
+    @Test
+    public void testEndsWith() {
+        //given
+        List<IndexQuery> indexQueries = new ArrayList<IndexQuery>();
+        //first document
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity1 = new SampleEntity();
+        sampleEntity1.setId(documentId);
+        sampleEntity1.setMessage("some message");
+
+        IndexQuery indexQuery1 = new IndexQuery();
+        indexQuery1.setId(documentId);
+        indexQuery1.setObject(sampleEntity1);
+        indexQueries.add(indexQuery1);
+
+        //second document
+        String documentId2 = randomNumeric(5);
+        SampleEntity sampleEntity2 = new SampleEntity();
+        sampleEntity2.setId(documentId2);
+        sampleEntity2.setMessage("test message end");
+        IndexQuery indexQuery2 = new IndexQuery();
+        indexQuery2.setId(documentId2);
+        indexQuery2.setObject(sampleEntity2);
+
+        indexQueries.add(indexQuery2);
+        elasticsearchTemplate.bulkIndex(indexQueries);
+        elasticsearchTemplate.refresh(SampleEntity.class,true);
+        Criteria criteria = new Criteria("message").endsWith("end");
+        CriteriaQuery criteriaQuery = new CriteriaQuery(criteria);
+        //when
+        SampleEntity sampleEntity = elasticsearchTemplate.queryForObject(criteriaQuery, SampleEntity.class);
+        //then
+        assertThat("message", is(criteriaQuery.getCriteria().getField().getName()));
+        assertThat(sampleEntity, is(notNullValue()));
+    }
+
+    @Test
+    public void testStartsWith() {
+        //given
+        List<IndexQuery> indexQueries = new ArrayList<IndexQuery>();
+        //first document
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity1 = new SampleEntity();
+        sampleEntity1.setId(documentId);
+        sampleEntity1.setMessage("start some message");
+
+        IndexQuery indexQuery1 = new IndexQuery();
+        indexQuery1.setId(documentId);
+        indexQuery1.setObject(sampleEntity1);
+        indexQueries.add(indexQuery1);
+
+        //second document
+        String documentId2 = randomNumeric(5);
+        SampleEntity sampleEntity2 = new SampleEntity();
+        sampleEntity2.setId(documentId2);
+        sampleEntity2.setMessage("test message");
+        IndexQuery indexQuery2 = new IndexQuery();
+        indexQuery2.setId(documentId2);
+        indexQuery2.setObject(sampleEntity2);
+
+        indexQueries.add(indexQuery2);
+        elasticsearchTemplate.bulkIndex(indexQueries);
+        elasticsearchTemplate.refresh(SampleEntity.class,true);
+        Criteria criteria = new Criteria("message").startsWith("start");
+        CriteriaQuery criteriaQuery = new CriteriaQuery(criteria);
+        //when
+        SampleEntity sampleEntity = elasticsearchTemplate.queryForObject(criteriaQuery,SampleEntity.class);
+        //then
+        assertThat("message", is(criteriaQuery.getCriteria().getField().getName()));
+        assertThat(sampleEntity,is(notNullValue()));
+    }
+
+    @Test
+    public void testContains() {
+        //given
+        List<IndexQuery> indexQueries = new ArrayList<IndexQuery>();
+        //first document
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity1 = new SampleEntity();
+        sampleEntity1.setId(documentId);
+        sampleEntity1.setMessage("contains some message");
+
+        IndexQuery indexQuery1 = new IndexQuery();
+        indexQuery1.setId(documentId);
+        indexQuery1.setObject(sampleEntity1);
+        indexQueries.add(indexQuery1);
+
+        //second document
+        String documentId2 = randomNumeric(5);
+        SampleEntity sampleEntity2 = new SampleEntity();
+        sampleEntity2.setId(documentId2);
+        sampleEntity2.setMessage("test message");
+        IndexQuery indexQuery2 = new IndexQuery();
+        indexQuery2.setId(documentId2);
+        indexQuery2.setObject(sampleEntity2);
+
+        indexQueries.add(indexQuery2);
+        elasticsearchTemplate.bulkIndex(indexQueries);
+        elasticsearchTemplate.refresh(SampleEntity.class,true);
+        CriteriaQuery criteriaQuery= new CriteriaQuery(new Criteria("message").contains("contains"));
+        //when
+        SampleEntity sampleEntity = elasticsearchTemplate.queryForObject(criteriaQuery,SampleEntity.class);
+        //then
+        assertThat("message", is(criteriaQuery.getCriteria().getField().getName()));
+        assertThat(sampleEntity,is(notNullValue()));
+    }
+
+    @Test
+    public void testExpression() {
+        //given
+        //todo
+        List<IndexQuery> indexQueries = new ArrayList<IndexQuery>();
+        //first document
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity1 = new SampleEntity();
+        sampleEntity1.setId(documentId);
+        sampleEntity1.setMessage("elasticsearch search");
+
+        IndexQuery indexQuery1 = new IndexQuery();
+        indexQuery1.setId(documentId);
+        indexQuery1.setObject(sampleEntity1);
+        indexQueries.add(indexQuery1);
+
+        //second document
+        String documentId2 = randomNumeric(5);
+        SampleEntity sampleEntity2 = new SampleEntity();
+        sampleEntity2.setId(documentId2);
+        sampleEntity2.setMessage("test message");
+        IndexQuery indexQuery2 = new IndexQuery();
+        indexQuery2.setId(documentId2);
+        indexQuery2.setObject(sampleEntity2);
+
+        indexQueries.add(indexQuery2);
+        elasticsearchTemplate.bulkIndex(indexQueries);
+        elasticsearchTemplate.refresh(SampleEntity.class,true);
+        CriteriaQuery criteriaQuery= new CriteriaQuery(new Criteria("message").expression("+elasticsearch || test"));
+        //when
+        SampleEntity sampleEntity = elasticsearchTemplate.queryForObject(criteriaQuery,SampleEntity.class);
+        //then
+        assertThat("message", is(criteriaQuery.getCriteria().getField().getName()));
+        assertThat(sampleEntity,is(notNullValue()));
+    }
+
+    @Test
+    public void testCriteriaChain() {
+        //given
+        List<IndexQuery> indexQueries = new ArrayList<IndexQuery>();
+        //first document
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity1 = new SampleEntity();
+        sampleEntity1.setId(documentId);
+        sampleEntity1.setMessage("some message search");
+
+        IndexQuery indexQuery1 = new IndexQuery();
+        indexQuery1.setId(documentId);
+        indexQuery1.setObject(sampleEntity1);
+        indexQueries.add(indexQuery1);
+
+        //second document
+        String documentId2 = randomNumeric(5);
+        SampleEntity sampleEntity2 = new SampleEntity();
+        sampleEntity2.setId(documentId2);
+        sampleEntity2.setMessage("test test message");
+        IndexQuery indexQuery2 = new IndexQuery();
+        indexQuery2.setId(documentId2);
+        indexQuery2.setObject(sampleEntity2);
+
+        indexQueries.add(indexQuery2);
+        elasticsearchTemplate.bulkIndex(indexQueries);
+        elasticsearchTemplate.refresh(SampleEntity.class,true);
+        CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria("message").startsWith("some").endsWith("search").contains("message").is("some message search"));
+        //when
+        SampleEntity sampleEntity = elasticsearchTemplate.queryForObject(criteriaQuery,SampleEntity.class);
+        //then
+        assertThat("message", is(criteriaQuery.getCriteria().getField().getName()));
+        assertThat(sampleEntity, is(notNullValue()));
+    }
+
+    @Test
+    public void testIsNot() {
+        //given
+        List<IndexQuery> indexQueries = new ArrayList<IndexQuery>();
+        //first document
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity1 = new SampleEntity();
+        sampleEntity1.setId(documentId);
+        sampleEntity1.setMessage("bar");
+
+        IndexQuery indexQuery1 = new IndexQuery();
+        indexQuery1.setId(documentId);
+        indexQuery1.setObject(sampleEntity1);
+        indexQueries.add(indexQuery1);
+
+        //second document
+        String documentId2 = randomNumeric(5);
+        SampleEntity sampleEntity2 = new SampleEntity();
+        sampleEntity2.setId(documentId2);
+        sampleEntity2.setMessage("foo");
+        IndexQuery indexQuery2 = new IndexQuery();
+        indexQuery2.setId(documentId2);
+        indexQuery2.setObject(sampleEntity2);
+
+        indexQueries.add(indexQuery2);
+        elasticsearchTemplate.bulkIndex(indexQueries);
+        elasticsearchTemplate.refresh(SampleEntity.class,true);
+        CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria("message").is("foo").not());
+        //when
+        Page<SampleEntity> page = elasticsearchTemplate.queryForPage(criteriaQuery, SampleEntity.class);
+        //then
+        assertTrue(criteriaQuery.getCriteria().isNegating());
+        assertThat(page,is(notNullValue()));
+        assertFalse(page.iterator().next().getMessage().contains("foo"));
+    }
+
+    @Test
+    public void testBetween() {
+        //given
+        List<IndexQuery> indexQueries = new ArrayList<IndexQuery>();
+        //first document
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity1 = new SampleEntity();
+        sampleEntity1.setId(documentId);
+        sampleEntity1.setRate(100);
+        sampleEntity1.setMessage("bar");
+
+        IndexQuery indexQuery1 = new IndexQuery();
+        indexQuery1.setId(documentId);
+        indexQuery1.setObject(sampleEntity1);
+        indexQueries.add(indexQuery1);
+
+        //second document
+        String documentId2 = randomNumeric(5);
+        SampleEntity sampleEntity2 = new SampleEntity();
+        sampleEntity2.setId(documentId2);
+        sampleEntity2.setRate(200);
+        sampleEntity2.setMessage("foo");
+        IndexQuery indexQuery2 = new IndexQuery();
+        indexQuery2.setId(documentId2);
+        indexQuery2.setObject(sampleEntity2);
+
+        indexQueries.add(indexQuery2);
+        elasticsearchTemplate.bulkIndex(indexQueries);
+        elasticsearchTemplate.refresh(SampleEntity.class,true);
+        CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria("rate").between(100,150));
+        //when
+        SampleEntity sampleEntity = elasticsearchTemplate.queryForObject(criteriaQuery, SampleEntity.class);
+        //then
+        assertThat(sampleEntity,is(notNullValue()));
+    }
+
+    @Test
+    public void testBetweenWithoutUpperBound() {
+        //given
+        List<IndexQuery> indexQueries = new ArrayList<IndexQuery>();
+        //first document
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity1 = new SampleEntity();
+        sampleEntity1.setId(documentId);
+        sampleEntity1.setRate(300);
+        sampleEntity1.setMessage("bar");
+
+        IndexQuery indexQuery1 = new IndexQuery();
+        indexQuery1.setId(documentId);
+        indexQuery1.setObject(sampleEntity1);
+        indexQueries.add(indexQuery1);
+
+        //second document
+        String documentId2 = randomNumeric(5);
+        SampleEntity sampleEntity2 = new SampleEntity();
+        sampleEntity2.setId(documentId2);
+        sampleEntity2.setRate(400);
+        sampleEntity2.setMessage("foo");
+        IndexQuery indexQuery2 = new IndexQuery();
+        indexQuery2.setId(documentId2);
+        indexQuery2.setObject(sampleEntity2);
+
+        indexQueries.add(indexQuery2);
+        elasticsearchTemplate.bulkIndex(indexQueries);
+        elasticsearchTemplate.refresh(SampleEntity.class,true);
+        CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria("rate").between(350,null));
+        //when
+        SampleEntity sampleEntity = elasticsearchTemplate.queryForObject(criteriaQuery, SampleEntity.class);
+        //then
+        assertThat(sampleEntity,is(notNullValue()));
+    }
+
+    @Test
+    public void testBetweenWithoutLowerBound() {
+        //given
+        List<IndexQuery> indexQueries = new ArrayList<IndexQuery>();
+        //first document
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity1 = new SampleEntity();
+        sampleEntity1.setId(documentId);
+        sampleEntity1.setRate(500);
+        sampleEntity1.setMessage("bar");
+
+        IndexQuery indexQuery1 = new IndexQuery();
+        indexQuery1.setId(documentId);
+        indexQuery1.setObject(sampleEntity1);
+        indexQueries.add(indexQuery1);
+
+        //second document
+        String documentId2 = randomNumeric(5);
+        SampleEntity sampleEntity2 = new SampleEntity();
+        sampleEntity2.setId(documentId2);
+        sampleEntity2.setRate(600);
+        sampleEntity2.setMessage("foo");
+        IndexQuery indexQuery2 = new IndexQuery();
+        indexQuery2.setId(documentId2);
+        indexQuery2.setObject(sampleEntity2);
+
+        indexQueries.add(indexQuery2);
+        elasticsearchTemplate.bulkIndex(indexQueries);
+        elasticsearchTemplate.refresh(SampleEntity.class,true);
+        CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria("rate").between(null,550));
+        //when
+        SampleEntity sampleEntity = elasticsearchTemplate.queryForObject(criteriaQuery, SampleEntity.class);
+        //then
+        assertThat(sampleEntity,is(notNullValue()));
+    }
+
+    @Test
+    public void testLessThanEqauls() {
+        //given
+        List<IndexQuery> indexQueries = new ArrayList<IndexQuery>();
+        //first document
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity1 = new SampleEntity();
+        sampleEntity1.setId(documentId);
+        sampleEntity1.setRate(700);
+        sampleEntity1.setMessage("bar");
+
+        IndexQuery indexQuery1 = new IndexQuery();
+        indexQuery1.setId(documentId);
+        indexQuery1.setObject(sampleEntity1);
+        indexQueries.add(indexQuery1);
+
+        //second document
+        String documentId2 = randomNumeric(5);
+        SampleEntity sampleEntity2 = new SampleEntity();
+        sampleEntity2.setId(documentId2);
+        sampleEntity2.setRate(800);
+        sampleEntity2.setMessage("foo");
+        IndexQuery indexQuery2 = new IndexQuery();
+        indexQuery2.setId(documentId2);
+        indexQuery2.setObject(sampleEntity2);
+
+        indexQueries.add(indexQuery2);
+        elasticsearchTemplate.bulkIndex(indexQueries);
+        elasticsearchTemplate.refresh(SampleEntity.class,true);
+        CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria("rate").lessThanEqual(750));
+        //when
+        SampleEntity sampleEntity = elasticsearchTemplate.queryForObject(criteriaQuery, SampleEntity.class);
+        //then
+        assertThat(sampleEntity,is(notNullValue()));
+    }
+
+    @Test
+    public void testGreaterThanEqauls() {
+        //given
+        List<IndexQuery> indexQueries = new ArrayList<IndexQuery>();
+        //first document
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity1 = new SampleEntity();
+        sampleEntity1.setId(documentId);
+        sampleEntity1.setRate(900);
+        sampleEntity1.setMessage("bar");
+
+        IndexQuery indexQuery1 = new IndexQuery();
+        indexQuery1.setId(documentId);
+        indexQuery1.setObject(sampleEntity1);
+        indexQueries.add(indexQuery1);
+
+        //second document
+        String documentId2 = randomNumeric(5);
+        SampleEntity sampleEntity2 = new SampleEntity();
+        sampleEntity2.setId(documentId2);
+        sampleEntity2.setRate(1000);
+        sampleEntity2.setMessage("foo");
+        IndexQuery indexQuery2 = new IndexQuery();
+        indexQuery2.setId(documentId2);
+        indexQuery2.setObject(sampleEntity2);
+
+        indexQueries.add(indexQuery2);
+        elasticsearchTemplate.bulkIndex(indexQueries);
+        elasticsearchTemplate.refresh(SampleEntity.class,true);
+        CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria("rate").greaterThanEqual(950));
+        //when
+        SampleEntity sampleEntity = elasticsearchTemplate.queryForObject(criteriaQuery, SampleEntity.class);
+        //then
+        assertThat(sampleEntity,is(notNullValue()));
+    }
+
+    @Test
+    public void testBoost() {
+        //given
+        List<IndexQuery> indexQueries = new ArrayList<IndexQuery>();
+        //first document
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity1 = new SampleEntity();
+        sampleEntity1.setId(documentId);
+        sampleEntity1.setRate(700);
+        sampleEntity1.setMessage("bar foo");
+
+        IndexQuery indexQuery1 = new IndexQuery();
+        indexQuery1.setId(documentId);
+        indexQuery1.setObject(sampleEntity1);
+        indexQueries.add(indexQuery1);
+
+        //second document
+        String documentId2 = randomNumeric(5);
+        SampleEntity sampleEntity2 = new SampleEntity();
+        sampleEntity2.setId(documentId2);
+        sampleEntity2.setRate(800);
+        sampleEntity2.setMessage("foo");
+        IndexQuery indexQuery2 = new IndexQuery();
+        indexQuery2.setId(documentId2);
+        indexQuery2.setObject(sampleEntity2);
+
+        indexQueries.add(indexQuery2);
+        elasticsearchTemplate.bulkIndex(indexQueries);
+        elasticsearchTemplate.refresh(SampleEntity.class,true);
+        CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria("message").contains("foo").boost(1));
+        //when
+        Page<SampleEntity> page = elasticsearchTemplate.queryForPage(criteriaQuery, SampleEntity.class);
+        //then
+        assertThat(page.getTotalElements(),is(greaterThanOrEqualTo(1L)));
+    }
+
+
+}
--- a/src/test/java/org/springframework/data/elasticsearch/repositories/CustomMethodRepositoryTest.java
+++ b/src/test/java/org/springframework/data/elasticsearch/repositories/CustomMethodRepositoryTest.java
@@ -0,0 +1,59 @@
+package org.springframework.data.elasticsearch.repositories;
+
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.elasticsearch.SampleEntity;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import javax.annotation.Resource;
+
+import static org.apache.commons.lang.RandomStringUtils.randomNumeric;
+import static org.hamcrest.Matchers.greaterThanOrEqualTo;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.junit.Assert.assertThat;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration("classpath:custom-method-repository-test.xml")
+public class CustomMethodRepositoryTest {
+
+    @Resource
+    private SampleCustomMethodRepository repository;
+
+    @Test
+    public void shouldExecuteCustomMethod(){
+        //given
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity = new SampleEntity();
+        sampleEntity.setId(documentId);
+        sampleEntity.setType("test");
+        sampleEntity.setMessage("some message");
+        repository.save(sampleEntity);
+        //when
+        Page<SampleEntity> page = repository.findByType("test", new PageRequest(1, 10));
+        //then
+        assertThat(page, is(notNullValue()));
+        assertThat(page.getTotalElements(), is(greaterThanOrEqualTo(1L)));
+    }
+
+    @Test
+    public void shouldExecuteCustomMethodWithQuery(){
+        //given
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity = new SampleEntity();
+        sampleEntity.setId(documentId);
+        sampleEntity.setType("test");
+        sampleEntity.setMessage("customQuery");
+        repository.save(sampleEntity);
+        //when
+        Page<SampleEntity> page  = repository.findByMessage("customQuery", new PageRequest(1, 10));
+        //then
+        assertThat(page, is(notNullValue()));
+        assertThat(page.getTotalElements(), is(greaterThanOrEqualTo(1L)));
+    }
+
+}
--- a/src/test/java/org/springframework/data/elasticsearch/repositories/RepositoryTest.java
+++ b/src/test/java/org/springframework/data/elasticsearch/repositories/RepositoryTest.java
@@ -0,0 +1,343 @@
+package org.springframework.data.elasticsearch.repositories;
+
+
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.elasticsearch.SampleEntity;
+import org.springframework.data.elasticsearch.core.query.SearchQuery;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import javax.annotation.Resource;
+import java.util.Arrays;
+
+import static org.apache.commons.lang.RandomStringUtils.randomNumeric;
+import static org.elasticsearch.index.query.QueryBuilders.*;
+import static org.hamcrest.Matchers.*;
+import static org.junit.Assert.*;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration("classpath:/repository-test.xml")
+public class RepositoryTest {
+
+    @Resource
+    private SampleElasticsearchRepository repository;
+
+
+    @Test
+    public void shouldDoBulkIndexDocument(){
+        //given
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity1 = new SampleEntity();
+        sampleEntity1.setId(documentId);
+        sampleEntity1.setMessage("some message");
+
+        SampleEntity sampleEntity2 = new SampleEntity();
+        sampleEntity2.setId(documentId);
+        sampleEntity2.setMessage("some message");
+
+        //when
+        repository.save(Arrays.asList(sampleEntity1, sampleEntity2));
+        //then
+        SampleEntity entityFromElasticSearch =  repository.findOne(documentId);
+        assertThat(entityFromElasticSearch, is(notNullValue()));
+    }
+
+    @Test
+    public void shouldSaveDocument(){
+        //given
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity = new SampleEntity();
+        sampleEntity.setId(documentId);
+        sampleEntity.setMessage("some message");
+        //when
+        repository.save(sampleEntity);
+        //then
+        SampleEntity entityFromElasticSearch =  repository.findOne(documentId);
+        assertThat(entityFromElasticSearch, is(notNullValue()));
+    }
+
+    @Test
+    public void shouldFindDocumentById(){
+        //given
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity = new SampleEntity();
+        sampleEntity.setId(documentId);
+        sampleEntity.setMessage("some message");
+        repository.save(sampleEntity);
+        //when
+        SampleEntity entityFromElasticSearch = repository.findOne(documentId);
+        //then
+        assertThat(entityFromElasticSearch, is(notNullValue()));
+        assertThat(sampleEntity, is((equalTo(sampleEntity))));
+    }
+
+    @Test
+    public void shouldReturnCountOfDocuments(){
+        //given
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity = new SampleEntity();
+        sampleEntity.setId(documentId);
+        sampleEntity.setMessage("some message");
+        repository.save(sampleEntity);
+        //when
+        Long count = repository.count();
+        //then
+        assertThat(count, is(greaterThanOrEqualTo(1L)));
+    }
+
+    @Test
+    public void shouldFindAllDocuments(){
+        //when
+        Iterable<SampleEntity> results = repository.findAll();
+        //then
+        assertThat(results, is(notNullValue()));
+    }
+
+    @Test
+    public void shouldDeleteDocument(){
+        //given
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity = new SampleEntity();
+        sampleEntity.setId(documentId);
+        sampleEntity.setMessage("some message");
+        repository.save(sampleEntity);
+        //when
+        repository.delete(documentId);
+        //then
+        SampleEntity entityFromElasticSearch = repository.findOne(documentId);
+        assertThat(entityFromElasticSearch, is(nullValue()));
+    }
+
+    @Test
+    public void shouldSearchDocumentsGivenSearchQuery(){
+        //given
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity = new SampleEntity();
+        sampleEntity.setId(documentId);
+        sampleEntity.setMessage("some test message");
+        repository.save(sampleEntity);
+
+        SearchQuery query = new SearchQuery();
+        query.setElasticsearchQuery(termQuery("message", "test"));
+        //when
+        Page<SampleEntity> page = repository.search(query);
+        //then
+        assertThat(page, is(notNullValue()));
+        assertThat(page.getNumberOfElements(), is(greaterThanOrEqualTo(1)));
+    }
+
+    @Test
+    public void shouldSearchDocumentsGivenElasticsearchQuery(){
+        //given
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity = new SampleEntity();
+        sampleEntity.setId(documentId);
+        sampleEntity.setMessage("hello world.");
+        repository.save(sampleEntity);
+        //when
+        Page<SampleEntity> page = repository.search(termQuery("message", "world"), new PageRequest(0,50));
+        //then
+        assertThat(page, is(notNullValue()));
+        assertThat(page.getNumberOfElements(), is(greaterThanOrEqualTo(1)));
+    }
+
+    @Test
+    @Ignore
+    public  void testFindAllByIdQuery(){
+        //todo : find solution for findAll(Iterable<Ids> ids)
+        //given
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity = new SampleEntity();
+        sampleEntity.setId(documentId);
+        sampleEntity.setMessage("hello world.");
+        repository.save(sampleEntity);
+
+        String documentId2 = randomNumeric(5);
+        SampleEntity sampleEntity2 = new SampleEntity();
+        sampleEntity2.setId(documentId2);
+        sampleEntity2.setMessage("hello world.");
+        repository.save(sampleEntity2);
+
+        //when
+        Iterable<SampleEntity> sampleEntities=repository.findAll(Arrays.asList(documentId,documentId2));
+
+        //then
+        assertNotNull("sample entities cant be null..", sampleEntities);
+    }
+
+    @Test
+    public void testSaveIterableEntities(){
+           //given
+
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity = new SampleEntity();
+        sampleEntity.setId(documentId);
+        sampleEntity.setMessage("hello world.");
+
+        String documentId2 = randomNumeric(5);
+        SampleEntity sampleEntity2 = new SampleEntity();
+        sampleEntity2.setId(documentId2);
+        sampleEntity2.setMessage("hello world.");
+
+        Iterable<SampleEntity> sampleEntities = Arrays.asList(sampleEntity,sampleEntity2);
+
+        //when
+        repository.save(sampleEntities);
+
+        //then
+        Page<SampleEntity> entities = repository.search(fieldQuery("id", documentId), new PageRequest(0, 50));
+        assertNotNull(entities);
+    }
+
+    @Test
+    public void testDocumentExistById(){
+        //given
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity = new SampleEntity();
+        sampleEntity.setId(documentId);
+        sampleEntity.setMessage("hello world.");
+        repository.save(sampleEntity);
+
+        //when
+        boolean exist = repository.exists(documentId);
+
+        //then
+        assertEquals(exist, true);
+    }
+
+    @Test
+    public void testSearchForGivenSearchQuery(){
+        //given
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity = new SampleEntity();
+        sampleEntity.setId(documentId);
+        sampleEntity.setMessage("hello world.");
+        repository.save(sampleEntity);
+        //when
+        SearchQuery searchQuery = new SearchQuery();
+        searchQuery.setElasticsearchQuery(fieldQuery("id",documentId));
+        Page<SampleEntity> sampleEntities= repository.search(searchQuery);
+        //then
+        assertThat(sampleEntities.getTotalElements(), equalTo(1L));
+    }
+
+    @Test
+    public void testDeleteAll(){
+        //when
+        repository.deleteAll();
+        //then
+        SearchQuery searchQuery = new SearchQuery();
+        searchQuery.setElasticsearchQuery(matchAllQuery());
+        Page<SampleEntity> sampleEntities= repository.search(searchQuery);
+        assertThat(sampleEntities.getTotalElements(), equalTo(0L));
+    }
+
+    @Test
+    public void testDeleteByEntity(){
+        //given
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity = new SampleEntity();
+        sampleEntity.setId(documentId);
+        sampleEntity.setMessage("hello world.");
+        repository.save(sampleEntity);
+        //when
+        repository.delete(sampleEntity);
+        //then
+        SearchQuery searchQuery = new SearchQuery();
+        searchQuery.setElasticsearchQuery(fieldQuery("id", documentId));
+        Page<SampleEntity> sampleEntities= repository.search(searchQuery);
+        assertThat(sampleEntities.getTotalElements(),equalTo(0L));
+    }
+
+    @Test
+    public void testSearchForReturnIterableEntities(){
+        //given
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity = new SampleEntity();
+        sampleEntity.setId(documentId);
+        sampleEntity.setMessage("hello world.");
+        repository.save(sampleEntity);
+
+        String documentId2 = randomNumeric(5);
+        SampleEntity sampleEntity2 = new SampleEntity();
+        sampleEntity2.setId(documentId2);
+        sampleEntity2.setMessage("hello world.");
+        repository.save(sampleEntity2);
+
+        //when
+        Iterable<SampleEntity> sampleEntities=repository.search(fieldQuery("id",documentId));
+       //then
+        assertNotNull("sample entities cant be null..", sampleEntities);
+    }
+
+    @Test
+    public void testDeleteIterableEntities(){
+        //given
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity = new SampleEntity();
+        sampleEntity.setId(documentId);
+        sampleEntity.setMessage("hello world.");
+        repository.save(sampleEntity);
+
+        String documentId2 = randomNumeric(5);
+        SampleEntity sampleEntity2 = new SampleEntity();
+        sampleEntity2.setId(documentId2);
+        sampleEntity2.setMessage("hello world.");
+        repository.save(sampleEntity);
+
+        Iterable<SampleEntity> sampleEntities = Arrays.asList(sampleEntity,sampleEntity2);
+
+        //when
+        repository.delete(sampleEntities);
+
+        //then
+        Page<SampleEntity> entities = repository.search(fieldQuery("id", documentId), new PageRequest(0,50));
+        assertThat(entities.getTotalElements(),equalTo(0L));
+        entities = repository.search(fieldQuery("id", documentId2), new PageRequest(0,50));
+        assertThat(entities.getTotalElements(), equalTo(0L));
+    }
+
+    @Test
+    public void testIndexEntity(){
+        //given
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity = new SampleEntity();
+        sampleEntity.setId(documentId);
+        sampleEntity.setMessage("some message");
+        //when
+        repository.index(sampleEntity);
+        //then
+        Page<SampleEntity> entities = repository.search(fieldQuery("id", documentId), new PageRequest(0,50));
+        assertThat(entities.getTotalElements(),equalTo(1L));
+    }
+
+    @Test
+    @Ignore("By default, the search request will fail if there is no mapping associated with a field. The ignore_unmapped option allows to ignore fields that have no mapping and not sort by them")
+    public void testFindBySort(){
+        //todo
+        //given
+        String documentId = randomNumeric(5);
+        SampleEntity sampleEntity = new SampleEntity();
+        sampleEntity.setId(documentId);
+        sampleEntity.setMessage("A. hello world.");
+        repository.save(sampleEntity);
+
+        String documentId2 = randomNumeric(5);
+        SampleEntity sampleEntity2 = new SampleEntity();
+        sampleEntity2.setId(documentId2);
+        sampleEntity2.setMessage("B.hello world.");
+        repository.save(sampleEntity2);
+
+        //when
+        Iterable<SampleEntity> sampleEntities=repository.findAll(new Sort(new Sort.Order(Sort.Direction.ASC,"message")));
+
+        //then
+        assertNotNull("sample entities cant be null..", sampleEntities);
+    }
+
+}
--- a/src/test/java/org/springframework/data/elasticsearch/repositories/SampleCustomMethodRepository.java
+++ b/src/test/java/org/springframework/data/elasticsearch/repositories/SampleCustomMethodRepository.java
@@ -0,0 +1,17 @@
+package org.springframework.data.elasticsearch.repositories;
+
+
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.elasticsearch.SampleEntity;
+import org.springframework.data.elasticsearch.annotations.Query;
+import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;
+
+public interface SampleCustomMethodRepository extends ElasticsearchRepository<SampleEntity,String> {
+
+    Page<SampleEntity> findByType(String type, Pageable pageable);
+
+    @Query("{\"bool\" : {\"must\" : {\"field\" : {\"message\" : \"?0\"}}}}")
+    Page<SampleEntity> findByMessage(String message, Pageable pageable);
+
+}
--- a/src/test/java/org/springframework/data/elasticsearch/repositories/SampleElasticsearchRepository.java
+++ b/src/test/java/org/springframework/data/elasticsearch/repositories/SampleElasticsearchRepository.java
@@ -0,0 +1,8 @@
+package org.springframework.data.elasticsearch.repositories;
+
+import org.springframework.data.elasticsearch.SampleEntity;
+import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;
+
+public interface SampleElasticsearchRepository extends ElasticsearchRepository<SampleEntity,String> {
+
+}
--- a/src/test/java/org/springframework/data/elasticsearch/repository/support/ElasticsearchRepositoryFactoryTest.java
+++ b/src/test/java/org/springframework/data/elasticsearch/repository/support/ElasticsearchRepositoryFactoryTest.java
@@ -0,0 +1,48 @@
+package org.springframework.data.elasticsearch.repository.support;
+
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
+import org.springframework.data.elasticsearch.core.convert.ElasticsearchConverter;
+import org.springframework.data.elasticsearch.core.convert.MappingElasticsearchConverter;
+import org.springframework.data.elasticsearch.core.mapping.ElasticsearchPersistentEntity;
+import org.springframework.data.elasticsearch.core.mapping.ElasticsearchPersistentProperty;
+import org.springframework.data.elasticsearch.core.mapping.SimpleElasticsearchMappingContext;
+import org.springframework.data.mapping.context.MappingContext;
+import org.springframework.data.querydsl.QueryDslPredicateExecutor;
+import org.springframework.data.repository.core.RepositoryMetadata;
+import org.springframework.data.repository.core.support.DefaultRepositoryMetadata;
+
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class ElasticsearchRepositoryFactoryTest {
+
+    @Mock
+    private ElasticsearchOperations operations;
+    private ElasticsearchConverter converter;
+    private ElasticsearchRepositoryFactory factory;
+    MappingContext<? extends ElasticsearchPersistentEntity<?>, ElasticsearchPersistentProperty> mappingContext= new SimpleElasticsearchMappingContext();
+
+    @Before
+    public void before(){
+        converter = new MappingElasticsearchConverter(mappingContext);
+        when(operations.getElasticsearchConverter()).thenReturn(converter);
+        factory = new ElasticsearchRepositoryFactory(operations);
+    }
+
+
+
+    @Test(expected = IllegalArgumentException.class)
+    public void shouldThrowExceptionGivenQueryDslRepository(){
+        //given
+        RepositoryMetadata metadata = new DefaultRepositoryMetadata(QueryDslPredicateExecutor.class);
+        //when
+        factory.getRepositoryBaseClass(metadata);
+    }
+
+}