Spring Data Couchbase tutorial: multiple buckets and spatial queries

2016-06-03 07:26:42 -05:00
parent 167187f732
commit 2e9efa16bc
28 changed files with 1423 additions and 3 deletions
@@ -0,0 +1,79 @@
+package org.baeldung.spring.data.couchbase;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.baeldung.spring.data.couchbase.model.Campus;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.couchbase.config.AbstractCouchbaseConfiguration;
+import org.springframework.data.couchbase.core.CouchbaseTemplate;
+import org.springframework.data.couchbase.core.mapping.event.ValidatingCouchbaseEventListener;
+import org.springframework.data.couchbase.core.query.Consistency;
+import org.springframework.data.couchbase.repository.config.EnableCouchbaseRepositories;
+import org.springframework.data.couchbase.repository.config.RepositoryOperationsMapping;
+import org.springframework.validation.beanvalidation.LocalValidatorFactoryBean;
+
+import com.couchbase.client.java.Bucket;
+
+@Configuration
+@EnableCouchbaseRepositories(basePackages={"org.baeldung.spring.data.couchbase"})
+public class MyCouchbaseConfig extends AbstractCouchbaseConfiguration {
+    
+    public static final List<String> NODE_LIST = Arrays.asList("localhost");
+    public static final String DEFAULT_BUCKET_NAME = "baeldung";
+    public static final String DEFAULT_BUCKET_PASSWORD = "";
+
+    @Override
+    protected List<String> getBootstrapHosts() {
+        return NODE_LIST;
+    }
+
+    @Override
+    protected String getBucketName() {
+        return DEFAULT_BUCKET_NAME;
+    }
+
+    @Override
+    protected String getBucketPassword() {
+        return DEFAULT_BUCKET_PASSWORD;
+    }
+    
+    @Bean
+    public Bucket campusBucket() throws Exception {
+        return couchbaseCluster().openBucket("baeldung2", "");
+    }
+    
+    @Bean
+    public CouchbaseTemplate campusTemplate() throws Exception {
+        CouchbaseTemplate template = new CouchbaseTemplate(
+          couchbaseClusterInfo(), campusBucket(),
+          mappingCouchbaseConverter(), translationService());
+        template.setDefaultConsistency(getDefaultConsistency());
+        return template;
+    }
+    
+    @Override
+    public void configureRepositoryOperationsMapping(RepositoryOperationsMapping baseMapping) {
+        try {
+            baseMapping.mapEntity(Campus.class, campusTemplate());
+        } catch (Exception e) {
+            //custom Exception handling
+        }
+    }
+
+    @Override
+    protected Consistency getDefaultConsistency() {
+        return Consistency.READ_YOUR_OWN_WRITES;
+    }
+
+    @Bean
+    public LocalValidatorFactoryBean localValidatorFactoryBean() {
+        return new LocalValidatorFactoryBean();
+    }
+
+    @Bean
+    public ValidatingCouchbaseEventListener validatingCouchbaseEventListener() {
+        return new ValidatingCouchbaseEventListener(localValidatorFactoryBean());
+    }
+}
@@ -0,0 +1,102 @@
+package org.baeldung.spring.data.couchbase.model;
+
+import javax.validation.constraints.NotNull;
+
+import org.springframework.data.annotation.Id;
+import org.springframework.data.couchbase.core.mapping.Document;
+import org.springframework.data.geo.Point;
+
+import com.couchbase.client.java.repository.annotation.Field;
+
+@Document
+public class Campus {
+
+    @Id
+    private String id;
+    @Field
+    @NotNull
+    private String name;
+    @Field
+    @NotNull
+    private Point location;
+    
+    public String getId() {
+        return id;
+    }
+    public void setId(String id) {
+        this.id = id;
+    }
+    public String getName() {
+        return name;
+    }
+    public void setName(String name) {
+        this.name = name;
+    }
+    public Point getLocation() {
+        return location;
+    }
+    public void setLocation(Point location) {
+        this.location = location;
+    }
+
+    @Override
+    public int hashCode() {
+        int hash = 1;
+        if(id != null) {
+            hash = hash * 31 + id.hashCode();
+        }
+        if(name != null) {
+            hash = hash * 31 + name.hashCode();
+        }
+        if(location != null) {
+            hash = hash * 31 + location.hashCode();
+        }
+        return hash;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if((obj == null) || (obj.getClass() != this.getClass())) return false;
+        if(obj == this) return true;
+        Campus other = (Campus) obj;
+        return this.hashCode() == other.hashCode();
+    }
+    
+    @SuppressWarnings("unused")
+    private Campus() {}
+    
+    public Campus(Builder b) {
+        this.id = b.id;
+        this.name = b.name;
+        this.location = b.location;
+    }
+    
+    public static class Builder {
+        private String id;
+        private String name;
+        private Point location;
+        
+        public static Builder newInstance() {
+            return new Builder();
+        }
+        
+        public Campus build() {
+            return new Campus(this);
+        }
+
+        public Builder id(String id) {
+            this.id = id;
+            return this;
+        }
+
+        public Builder name(String name) {
+            this.name = name;
+            return this;
+        }
+        
+        public Builder location(Point location) {
+            this.location = location;
+            return this;
+        }
+    }
+}
@@ -0,0 +1,87 @@
+package org.baeldung.spring.data.couchbase.model;
+
+import javax.validation.constraints.NotNull;
+
+import org.joda.time.DateTime;
+import org.springframework.data.annotation.Id;
+import org.springframework.data.couchbase.core.mapping.Document;
+
+import com.couchbase.client.java.repository.annotation.Field;
+
+@Document
+public class Person {
+
+    @Id
+    private String id;
+    @Field
+    @NotNull
+    private String firstName;
+    @Field
+    @NotNull
+    private String lastName;
+    @Field
+    @NotNull
+    private DateTime created;
+    @Field
+    private DateTime updated;
+    
+    public Person(String id, String firstName, String lastName) {
+        this.id = id;
+        this.firstName = firstName;
+        this.lastName = lastName;
+    }
+
+    public String getId() {
+        return id;
+    }
+    public void setId(String id) {
+        this.id = id;
+    }
+    public String getFirstName() {
+        return firstName;
+    }
+    public void setFirstName(String firstName) {
+        this.firstName = firstName;
+    }
+    public String getLastName() {
+        return lastName;
+    }
+    public void setLastName(String lastName) {
+        this.lastName = lastName;
+    }
+    public DateTime getCreated() {
+        return created;
+    }
+    public void setCreated(DateTime created) {
+        this.created = created;
+    }
+    public DateTime getUpdated() {
+        return updated;
+    }
+    public void setUpdated(DateTime updated) {
+        this.updated = updated;
+    }
+    
+    @Override
+    public int hashCode() {
+        int hash = 1;
+        if(id != null) {
+            hash = hash * 31 + id.hashCode();
+        }
+        if(firstName != null) {
+            hash = hash * 31 + firstName.hashCode();
+        }
+        if(lastName != null) {
+            hash = hash * 31 + lastName.hashCode();
+        }
+        return hash;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if((obj == null) || (obj.getClass() != this.getClass())) return false;
+        if(obj == this) return true;
+        Person other = (Person) obj;
+        return this.hashCode() == other.hashCode();
+    }
+}
@@ -0,0 +1,113 @@
+package org.baeldung.spring.data.couchbase.model;
+
+import javax.validation.constraints.NotNull;
+import javax.validation.constraints.Past;
+import javax.validation.constraints.Pattern;
+import javax.validation.constraints.Size;
+
+import org.joda.time.DateTime;
+import org.springframework.data.annotation.Id;
+import org.springframework.data.annotation.Version;
+import org.springframework.data.couchbase.core.mapping.Document;
+
+import com.couchbase.client.java.repository.annotation.Field;
+
+@Document
+public class Student {
+    private static final String NAME_REGEX = "^[a-zA-Z .'-]+$";
+
+    @Id
+    private String id;
+    @Field
+    @NotNull
+    @Size(min=1, max=20)
+    @Pattern(regexp=NAME_REGEX)
+    private String firstName;
+    @Field
+    @NotNull
+    @Size(min=1, max=20)
+    @Pattern(regexp=NAME_REGEX)
+    private String lastName;
+    @Field
+    @Past
+    private DateTime dateOfBirth;
+    @Field
+    @NotNull
+    private DateTime created;
+    @Field
+    private DateTime updated;
+    @Version
+    private long version;
+    
+    public Student() {}
+
+    public Student(String id, String firstName, String lastName, DateTime dateOfBirth) {
+        this.id = id;
+        this.firstName = firstName;
+        this.lastName = lastName;
+        this.dateOfBirth = dateOfBirth;
+    }
+
+    public String getId() {
+        return id;
+    }
+    public void setId(String id) {
+        this.id = id;
+    }
+    public String getFirstName() {
+        return firstName;
+    }
+    public void setFirstName(String firstName) {
+        this.firstName = firstName;
+    }
+    public String getLastName() {
+        return lastName;
+    }
+    public void setLastName(String lastName) {
+        this.lastName = lastName;
+    }
+    public DateTime getDateOfBirth() {
+        return dateOfBirth;
+    }
+    public void setDateOfBirth(DateTime dateOfBirth) {
+        this.dateOfBirth = dateOfBirth;
+    }
+    public DateTime getCreated() {
+        return created;
+    }
+    public void setCreated(DateTime created) {
+        this.created = created;
+    }
+    public DateTime getUpdated() {
+        return updated;
+    }
+    public void setUpdated(DateTime updated) {
+        this.updated = updated;
+    }
+
+    @Override
+    public int hashCode() {
+        int hash = 1;
+        if(id != null) {
+            hash = hash * 31 + id.hashCode();
+        }
+        if(firstName != null) {
+            hash = hash * 31 + firstName.hashCode();
+        }
+        if(lastName != null) {
+            hash = hash * 31 + lastName.hashCode();
+        }
+        if(dateOfBirth != null) {
+            hash = hash * 31 + dateOfBirth.hashCode();
+        }
+        return hash;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if((obj == null) || (obj.getClass() != this.getClass())) return false;
+        if(obj == this) return true;
+        Student other = (Student) obj;
+        return this.hashCode() == other.hashCode();
+    }
+}
@@ -0,0 +1,19 @@
+package org.baeldung.spring.data.couchbase.repos;
+
+import java.util.Set;
+
+import org.baeldung.spring.data.couchbase.model.Campus;
+import org.springframework.data.couchbase.core.query.Dimensional;
+import org.springframework.data.couchbase.core.query.View;
+import org.springframework.data.geo.Distance;
+import org.springframework.data.geo.Point;
+import org.springframework.data.repository.CrudRepository;
+
+public interface CampusRepository extends CrudRepository<Campus, String> {
+
+    @View(designDocument="campus", viewName="byName")
+    Set<Campus> findByName(String name);
+
+    @Dimensional(dimensions=2, designDocument="campus_spatial", spatialViewName="byLocation")
+    Set<Campus> findByLocationNear(Point point, Distance distance);
+}
@@ -0,0 +1,11 @@
+package org.baeldung.spring.data.couchbase.repos;
+
+import java.util.List;
+
+import org.baeldung.spring.data.couchbase.model.Person;
+import org.springframework.data.repository.CrudRepository;
+
+public interface PersonRepository extends CrudRepository<Person, String> {
+    List<Person> findByFirstName(String firstName);
+    List<Person> findByLastName(String lastName);
+}
@@ -0,0 +1,11 @@
+package org.baeldung.spring.data.couchbase.repos;
+
+import java.util.List;
+
+import org.baeldung.spring.data.couchbase.model.Student;
+import org.springframework.data.repository.CrudRepository;
+
+public interface StudentRepository extends CrudRepository<Student, String> {
+    List<Student> findByFirstName(String firstName);
+    List<Student> findByLastName(String lastName);
+}
@@ -0,0 +1,54 @@
+package org.baeldung.spring.data.couchbase.service;
+
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+
+import org.baeldung.spring.data.couchbase.model.Campus;
+import org.baeldung.spring.data.couchbase.repos.CampusRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.data.geo.Distance;
+import org.springframework.data.geo.Point;
+import org.springframework.stereotype.Service;
+
+@Service
+@Qualifier("CampusRepositoryService")
+public class CampusRepositoryService implements CampusService {
+
+    private CampusRepository repo;
+    @Autowired
+    public void setCampusRepository(CampusRepository repo) {
+        this.repo = repo;
+    }
+    
+    @Override
+    public Campus find(String id) {
+        return repo.findOne(id);
+    }
+    
+    @Override
+    public Set<Campus> findByName(String name) {
+        return repo.findByName(name);
+    }
+    
+    @Override
+    public Set<Campus> findByLocationNear(Point point, Distance distance) {
+        return repo.findByLocationNear(point, distance);
+    }
+
+    @Override
+    public Set<Campus> findAll() {
+        Set<Campus> campuses = new HashSet<>();
+        Iterator<Campus> it = repo.findAll().iterator();
+        while(it.hasNext()) {
+            campuses.add(it.next());
+        }
+        return campuses;
+    }
+
+    @Override
+    public void save(Campus campus) {
+        repo.save(campus);
+    }
+}
@@ -0,0 +1,20 @@
+package org.baeldung.spring.data.couchbase.service;
+
+import java.util.Set;
+
+import org.baeldung.spring.data.couchbase.model.Campus;
+import org.springframework.data.geo.Distance;
+import org.springframework.data.geo.Point;
+
+public interface CampusService {
+    
+    Campus find(String id);
+
+    Set<Campus> findByName(String name);
+
+    Set<Campus> findByLocationNear(Point point, Distance distance);
+    
+    Set<Campus> findAll();
+    
+    void save(Campus campus);
+}
@@ -0,0 +1,58 @@
+package org.baeldung.spring.data.couchbase.service;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import org.baeldung.spring.data.couchbase.model.Person;
+import org.baeldung.spring.data.couchbase.repos.PersonRepository;
+import org.joda.time.DateTime;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.stereotype.Service;
+
+@Service
+@Qualifier("PersonRepositoryService")
+public class PersonRepositoryService implements PersonService {
+    
+    private PersonRepository repo;
+    @Autowired
+    public void setPersonRepository(PersonRepository repo) {
+        this.repo = repo;
+    }
+
+    public Person findOne(String id) {
+        return repo.findOne(id);
+    }
+
+    public List<Person> findAll() {
+        List<Person> people = new ArrayList<Person>();
+        Iterator<Person> it = repo.findAll().iterator();
+        while(it.hasNext()) {
+            people.add(it.next());
+        }
+        return people;
+    }
+
+    public List<Person> findByFirstName(String firstName) {
+        return repo.findByFirstName(firstName);
+    }
+
+    public List<Person> findByLastName(String lastName) {
+        return repo.findByLastName(lastName);
+    }
+
+    public void create(Person person) {
+        person.setCreated(DateTime.now());
+        repo.save(person);
+    }
+
+    public void update(Person person) {
+        person.setUpdated(DateTime.now());
+        repo.save(person);
+    }
+
+    public void delete(Person person) {
+        repo.delete(person);
+    }
+}
@@ -0,0 +1,22 @@
+package org.baeldung.spring.data.couchbase.service;
+
+import java.util.List;
+
+import org.baeldung.spring.data.couchbase.model.Person;
+
+public interface PersonService {
+
+    Person findOne(String id);
+
+    List<Person> findAll();
+
+    List<Person> findByFirstName(String firstName);
+
+    List<Person> findByLastName(String lastName);
+
+    void create(Person person);
+
+    void update(Person person);
+
+    void delete(Person person);
+}
@@ -0,0 +1,58 @@
+package org.baeldung.spring.data.couchbase.service;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import org.baeldung.spring.data.couchbase.model.Student;
+import org.baeldung.spring.data.couchbase.repos.StudentRepository;
+import org.joda.time.DateTime;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.stereotype.Service;
+
+@Service
+@Qualifier("StudentRepositoryService")
+public class StudentRepositoryService implements StudentService {
+    
+    private StudentRepository repo;
+    @Autowired
+    public void setStudentRepository(StudentRepository repo) {
+        this.repo = repo;
+    }
+
+    public Student findOne(String id) {
+        return repo.findOne(id);
+    }
+
+    public List<Student> findAll() {
+        List<Student> people = new ArrayList<Student>();
+        Iterator<Student> it = repo.findAll().iterator();
+        while(it.hasNext()) {
+            people.add(it.next());
+        }
+        return people;
+    }
+
+    public List<Student> findByFirstName(String firstName) {
+        return repo.findByFirstName(firstName);
+    }
+
+    public List<Student> findByLastName(String lastName) {
+        return repo.findByLastName(lastName);
+    }
+
+    public void create(Student student) {
+        student.setCreated(DateTime.now());
+        repo.save(student);
+    }
+
+    public void update(Student student) {
+        student.setUpdated(DateTime.now());
+        repo.save(student);
+    }
+
+    public void delete(Student student) {
+        repo.delete(student);
+    }
+}
@@ -0,0 +1,22 @@
+package org.baeldung.spring.data.couchbase.service;
+
+import java.util.List;
+
+import org.baeldung.spring.data.couchbase.model.Student;
+
+public interface StudentService {
+
+    Student findOne(String id);
+
+    List<Student> findAll();
+
+    List<Student> findByFirstName(String firstName);
+
+    List<Student> findByLastName(String lastName);
+
+    void create(Student student);
+
+    void update(Student student);
+
+    void delete(Student student);
+}
@@ -0,0 +1,17 @@
+<configuration>
+
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>web - %date [%thread] %-5level %logger{36} - %message%n
+            </pattern>
+        </encoder>
+    </appender>
+
+    <logger name="org.springframework" level="WARN" />
+    <logger name="org.baeldung" level="DEBUG" />
+
+    <root level="INFO">
+        <appender-ref ref="STDOUT" />
+    </root>
+
+</configuration>
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="ISO-8859-1"?>
+<project name="Spring Batch: ${project.name}">
+
+	<bannerLeft>
+		<name>Spring Sample: ${project.name}</name>
+    	<href>index.html</href>
+	</bannerLeft>
+
+  <skin>
+    <groupId>org.springframework.maven.skins</groupId>
+    <artifactId>maven-spring-skin</artifactId>
+    <version>1.0.5</version>
+  </skin>
+
+	<body>
+
+		<links>
+			<item name="${project.name}" href="index.html"/>
+		</links>
+		
+		<menu ref="reports"/>
+	
+	</body>
+
+</project>
@@ -0,0 +1,13 @@
+package org.baeldung.spring.data.couchbase;
+
+import org.junit.runner.RunWith;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.TestExecutionListeners;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.support.DependencyInjectionTestExecutionListener;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = { MyCouchbaseConfig.class, IntegrationTestConfig.class })
+@TestExecutionListeners(listeners = { DependencyInjectionTestExecutionListener.class })
+public abstract class IntegrationTest {
+}
@@ -0,0 +1,9 @@
+package org.baeldung.spring.data.couchbase;
+
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+@ComponentScan(basePackages = "org.baeldung.spring.data.couchbase")
+public class IntegrationTestConfig {
+}
@@ -0,0 +1,17 @@
+package org.baeldung.spring.data.couchbase;
+
+import org.springframework.data.couchbase.core.convert.MappingCouchbaseConverter;
+import org.springframework.data.couchbase.core.query.Consistency;
+
+public class TestCouchbaseConfig extends MyCouchbaseConfig {
+
+    @Override
+    public String typeKey() {
+        return MappingCouchbaseConverter.TYPEKEY_SYNCGATEWAY_COMPATIBLE;
+    }
+    
+    @Override
+    public Consistency getDefaultConsistency() {
+        return Consistency.READ_YOUR_OWN_WRITES;
+    }
+}
@@ -0,0 +1,135 @@
+package org.baeldung.spring.data.couchbase.service;
+
+import static org.junit.Assert.*;
+
+import java.util.Set;
+
+import javax.annotation.PostConstruct;
+
+import org.baeldung.spring.data.couchbase.IntegrationTest;
+import org.baeldung.spring.data.couchbase.model.Campus;
+import org.baeldung.spring.data.couchbase.repos.CampusRepository;
+import org.junit.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.data.geo.Distance;
+import org.springframework.data.geo.Metrics;
+import org.springframework.data.geo.Point;
+
+public class CampusRepositoryServiceTest extends IntegrationTest {
+    
+    @Autowired
+    @Qualifier("CampusRepositoryService")
+    private CampusRepositoryService campusService;
+    
+    @Autowired
+    private CampusRepository campusRepo;
+    
+    private final Campus Brown = Campus.Builder.newInstance()
+            .id("campus:Brown")
+            .name("Brown")
+            .location(new Point(71.4025, 51.8268))
+            .build();
+
+    private final Campus Cornell = Campus.Builder.newInstance()
+            .id("campus:Cornell")
+            .name("Cornell")
+            .location(new Point(76.4833, 42.4459))
+            .build();    
+    
+    private final Campus Columbia = Campus.Builder.newInstance()
+            .id("campus:Columbia")
+            .name("Columbia")
+            .location(new Point(73.9626, 40.8075))
+            .build();    
+ 
+    private final Campus Dartmouth = Campus.Builder.newInstance()
+            .id("campus:Dartmouth")
+            .name("Dartmouth")
+            .location(new Point(72.2887, 43.7044))
+            .build();    
+
+    private final Campus Harvard = Campus.Builder.newInstance()
+            .id("campus:Harvard")
+            .name("Harvard")
+            .location(new Point(71.1167, 42.3770))
+            .build();    
+
+    private final Campus Penn = Campus.Builder.newInstance()
+            .id("campus:Penn")
+            .name("Penn")
+            .location(new Point(75.1932, 39.9522))
+            .build();
+
+    private final Campus Princeton = Campus.Builder.newInstance()
+            .id("campus:Princeton")
+            .name("Princeton")
+            .location(new Point(74.6514, 40.3340))
+            .build();
+    
+    private final Campus Yale = Campus.Builder.newInstance()
+            .id("campus:Yale")
+            .name("Yale")
+            .location(new Point(72.9223, 41.3163))
+            .build();
+    
+    private final Point Boston = new Point(71.0589, 42.3601);
+    private final Point NewYorkCity = new Point(74.0059, 40.7128);
+
+    @PostConstruct
+    private void loadCampuses() throws Exception {
+        campusRepo.save(Brown);
+        campusRepo.save(Columbia);
+        campusRepo.save(Cornell);
+        campusRepo.save(Dartmouth);
+        campusRepo.save(Harvard);
+        campusRepo.save(Penn);
+        campusRepo.save(Princeton);
+        campusRepo.save(Yale);
+    }
+    
+    @Test
+    public final void givenNameHarvard_whenFindByName_thenReturnsHarvard() throws Exception {
+        Set<Campus> campuses = campusService.findByName(Harvard.getName());
+        assertNotNull(campuses);
+        assertFalse(campuses.isEmpty());
+        assertTrue(campuses.size() == 1);
+        assertTrue(campuses.contains(Harvard));
+    }
+    
+    @Test
+    public final void givenHarvardId_whenFind_thenReturnsHarvard() throws Exception {
+        Campus actual = campusService.find(Harvard.getId());
+        assertNotNull(actual);
+        assertEquals(Harvard, actual);
+    }
+    
+    @Test
+    public final void whenFindAll_thenReturnsAll() throws Exception {
+        Set<Campus> campuses = campusService.findAll();
+        assertTrue(campuses.contains(Brown));
+        assertTrue(campuses.contains(Columbia));
+        assertTrue(campuses.contains(Cornell));
+        assertTrue(campuses.contains(Dartmouth));
+        assertTrue(campuses.contains(Harvard));
+        assertTrue(campuses.contains(Penn));
+        assertTrue(campuses.contains(Princeton));
+        assertTrue(campuses.contains(Yale));
+    }
+
+    @Test
+    public final void whenFindByLocationNearBoston_thenResultContainsHarvard() throws Exception {
+        Set<Campus> campuses = campusService.findByLocationNear(Boston, new Distance(1, Metrics.NEUTRAL));
+        assertFalse(campuses.isEmpty());
+        assertTrue(campuses.contains(Harvard));
+        assertFalse(campuses.contains(Columbia));
+    }
+    
+    @Test
+    public final void whenFindByLocationNearNewYorkCity_thenResultContainsColumbia() throws Exception {
+        Set<Campus> campuses = campusService.findByLocationNear(NewYorkCity, new Distance(1, Metrics.NEUTRAL));
+        assertFalse(campuses.isEmpty());
+        assertTrue(campuses.contains(Columbia));
+        assertFalse(campuses.contains(Harvard));
+    }
+}
@@ -0,0 +1,130 @@
+package org.baeldung.spring.data.couchbase.service;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import java.util.List;
+
+import org.baeldung.spring.data.couchbase.IntegrationTest;
+import org.baeldung.spring.data.couchbase.MyCouchbaseConfig;
+import org.baeldung.spring.data.couchbase.model.Person;
+import org.joda.time.DateTime;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+
+import com.couchbase.client.java.Bucket;
+import com.couchbase.client.java.Cluster;
+import com.couchbase.client.java.CouchbaseCluster;
+import com.couchbase.client.java.document.JsonDocument;
+import com.couchbase.client.java.document.json.JsonObject;
+
+public class PersonRepositoryServiceTest extends IntegrationTest {
+
+    private static final String typeField = "_class";
+    private static final String john = "John";
+    private static final String smith = "Smith";
+    private static final String johnSmithId = "person:" + john + ":" + smith;
+    private static final Person johnSmith = new Person(johnSmithId, john, smith);
+    private static final JsonObject jsonJohnSmith = JsonObject.empty()
+            .put(typeField, Person.class.getName())
+            .put("firstName", john)
+            .put("lastName", smith)
+            .put("created", DateTime.now().getMillis());
+
+    private static final String foo = "Foo";
+    private static final String bar = "Bar";
+    private static final String foobarId = "person:" + foo + ":" + bar;
+    private static final Person foobar = new Person(foobarId, foo, bar);
+    private static final JsonObject jsonFooBar = JsonObject.empty()
+            .put(typeField, Person.class.getName())
+            .put("firstName", foo)
+            .put("lastName", bar)
+            .put("created", DateTime.now().getMillis());
+    
+    @Autowired
+    @Qualifier("PersonRepositoryService")
+    private PersonService personService;
+    
+    @BeforeClass
+    public static void setupBeforeClass() {
+        Cluster cluster = CouchbaseCluster.create(MyCouchbaseConfig.NODE_LIST);
+        Bucket bucket = cluster.openBucket(MyCouchbaseConfig.DEFAULT_BUCKET_NAME, MyCouchbaseConfig.DEFAULT_BUCKET_PASSWORD);
+        bucket.upsert(JsonDocument.create(johnSmithId, jsonJohnSmith));
+        bucket.upsert(JsonDocument.create(foobarId, jsonFooBar));
+        bucket.close();
+        cluster.disconnect();
+    }
+
+    @Test
+    public void whenFindingPersonByJohnSmithId_thenReturnsJohnSmith() {
+        Person actualPerson = personService.findOne(johnSmithId);
+        assertNotNull(actualPerson);
+        assertNotNull(actualPerson.getCreated());
+        assertEquals(johnSmith, actualPerson);
+    }
+
+    @Test
+    public void whenFindingAllPersons_thenReturnsTwoOrMorePersonsIncludingJohnSmithAndFooBar() {
+        List<Person> resultList = personService.findAll();
+        assertNotNull(resultList);
+        assertFalse(resultList.isEmpty());
+        assertTrue(resultContains(resultList, johnSmith));
+        assertTrue(resultContains(resultList, foobar));
+        assertTrue(resultList.size() >= 2);
+    }
+
+    @Test
+    public void whenFindingByFirstNameJohn_thenReturnsOnlyPersonsNamedJohn() {
+        String expectedFirstName = john;
+        List<Person> resultList = personService.findByFirstName(expectedFirstName);
+        assertNotNull(resultList);
+        assertFalse(resultList.isEmpty());
+        assertTrue(allResultsContainExpectedFirstName(resultList, expectedFirstName));
+    }
+
+    @Test
+    public void whenFindingByLastNameSmith_thenReturnsOnlyPersonsNamedSmith() {
+        String expectedLastName = smith;
+        List<Person> resultList = personService.findByLastName(expectedLastName);
+        assertNotNull(resultList);
+        assertFalse(resultList.isEmpty());
+        assertTrue(allResultsContainExpectedLastName(resultList, expectedLastName));
+    }
+    
+    private boolean resultContains(List<Person> resultList, Person person) {
+        boolean found = false;
+        for(Person p : resultList) {
+            if(p.equals(person)) {
+                found = true;
+                break;
+            }
+        }
+        return found;
+    }
+
+    private boolean allResultsContainExpectedFirstName(List<Person> resultList, String firstName) {
+        boolean found = false;
+        for(Person p : resultList) {
+            if(p.getFirstName().equals(firstName)) {
+                found = true;
+                break;
+            }
+        }
+        return found;
+    }
+
+    private boolean allResultsContainExpectedLastName(List<Person> resultList, String lastName) {
+        boolean found = false;
+        for(Person p : resultList) {
+            if(p.getLastName().equals(lastName)) {
+                found = true;
+                break;
+            }
+        }
+        return found;
+    }
+}
@@ -0,0 +1,170 @@
+package org.baeldung.spring.data.couchbase.service;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import java.util.List;
+
+import javax.validation.ConstraintViolationException;
+
+import org.baeldung.spring.data.couchbase.IntegrationTest;
+import org.baeldung.spring.data.couchbase.MyCouchbaseConfig;
+import org.baeldung.spring.data.couchbase.model.Student;
+import org.joda.time.DateTime;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+
+import com.couchbase.client.java.Bucket;
+import com.couchbase.client.java.Cluster;
+import com.couchbase.client.java.CouchbaseCluster;
+import com.couchbase.client.java.document.JsonDocument;
+import com.couchbase.client.java.document.json.JsonObject;
+
+public class StudentRepositoryServiceTest extends IntegrationTest {
+
+    private static final String typeField = "_class";
+    private static final String joe = "Joe";
+    private static final String college = "College";
+    private static final String joeCollegeId = "student:" + joe + ":" + college;
+    private static final DateTime joeCollegeDob = DateTime.now().minusYears(21);
+    private static final Student joeCollege = new Student(joeCollegeId, joe, college, joeCollegeDob);
+    private static final JsonObject jsonJoeCollege = JsonObject.empty()
+            .put(typeField, Student.class.getName())
+            .put("firstName", joe)
+            .put("lastName", college)
+            .put("created", DateTime.now().getMillis())
+            .put("version", 1);
+
+    private static final String judy = "Judy";
+    private static final String jetson = "Jetson";
+    private static final String judyJetsonId = "student:" + judy + ":" + jetson;
+    private static final DateTime judyJetsonDob = DateTime.now().minusYears(19).minusMonths(5).minusDays(3);
+    private static final Student judyJetson = new Student(judyJetsonId, judy, jetson, judyJetsonDob);
+    private static final JsonObject jsonJudyJetson = JsonObject.empty()
+            .put(typeField, Student.class.getName())
+            .put("firstName", judy)
+            .put("lastName", jetson)
+            .put("created", DateTime.now().getMillis())
+            .put("version", 1);
+
+    @Autowired
+    @Qualifier("StudentRepositoryService")
+    private StudentService studentService;
+
+    @BeforeClass
+    public static void setupBeforeClass() {
+        Cluster cluster = CouchbaseCluster.create(MyCouchbaseConfig.NODE_LIST);
+        Bucket bucket = cluster.openBucket(MyCouchbaseConfig.DEFAULT_BUCKET_NAME, MyCouchbaseConfig.DEFAULT_BUCKET_PASSWORD);
+        bucket.upsert(JsonDocument.create(joeCollegeId, jsonJoeCollege));
+        bucket.upsert(JsonDocument.create(judyJetsonId, jsonJudyJetson));
+        bucket.close();
+        cluster.disconnect();
+    }
+
+    @Test
+    public void whenCreatingStudent_thenDocumentIsPersisted() {
+        String firstName = "Eric";
+        String lastName = "Stratton";
+        DateTime dateOfBirth = DateTime.now().minusYears(25);
+        String id = "student:" + firstName + ":" + lastName;
+        Student expectedStudent = new Student(id, firstName, lastName, dateOfBirth);
+        studentService.create(expectedStudent);
+        Student actualStudent = studentService.findOne(id);
+        assertNotNull(actualStudent.getCreated());
+        assertNotNull(actualStudent);
+        assertEquals(expectedStudent.getId(), actualStudent.getId());
+    }
+
+    @Test(expected=ConstraintViolationException.class)
+    public void whenCreatingStudentWithInvalidFirstName_thenConstraintViolationException() {
+        String firstName = "Er+ic";
+        String lastName = "Stratton";
+        DateTime dateOfBirth = DateTime.now().minusYears(25);
+        String id = "student:" + firstName + ":" + lastName;
+        Student student = new Student(id, firstName, lastName, dateOfBirth);
+        studentService.create(student);
+    }
+
+    @Test(expected=ConstraintViolationException.class)
+    public void whenCreatingStudentWithFutureDob_thenConstraintViolationException() {
+        String firstName = "Jane";
+        String lastName = "Doe";
+        DateTime dateOfBirth = DateTime.now().plusDays(1);
+        String id = "student:" + firstName + ":" + lastName;
+        Student student = new Student(id, firstName, lastName, dateOfBirth);
+        studentService.create(student);
+    }
+
+    @Test
+    public void whenFindingStudentByJohnSmithId_thenReturnsJohnSmith() {
+        Student actualStudent = studentService.findOne(joeCollegeId);
+        assertNotNull(actualStudent);
+        assertNotNull(actualStudent.getCreated());
+        assertEquals(joeCollegeId, actualStudent.getId());
+    }
+
+    @Test
+    public void whenFindingAllStudents_thenReturnsTwoOrMoreStudentsIncludingJoeCollegeAndJudyJetson() {
+        List<Student> resultList = studentService.findAll();
+        assertNotNull(resultList);
+        assertFalse(resultList.isEmpty());
+        assertTrue(resultContains(resultList, joeCollege));
+        assertTrue(resultContains(resultList, judyJetson));
+        assertTrue(resultList.size() >= 2);
+    }
+
+    @Test
+    public void whenFindingByFirstNameJohn_thenReturnsOnlyStudentsNamedJohn() {
+        String expectedFirstName = joe;
+        List<Student> resultList = studentService.findByFirstName(expectedFirstName);
+        assertNotNull(resultList);
+        assertFalse(resultList.isEmpty());
+        assertTrue(allResultsContainExpectedFirstName(resultList, expectedFirstName));
+    }
+
+    @Test
+    public void whenFindingByLastNameSmith_thenReturnsOnlyStudentsNamedSmith() {
+        String expectedLastName = college;
+        List<Student> resultList = studentService.findByLastName(expectedLastName);
+        assertNotNull(resultList);
+        assertFalse(resultList.isEmpty());
+        assertTrue(allResultsContainExpectedLastName(resultList, expectedLastName));
+    }
+
+    private boolean resultContains(List<Student> resultList, Student student) {
+        boolean found = false;
+        for(Student p : resultList) {
+            if(p.getId().equals(student.getId())) {
+                found = true;
+                break;
+            }
+        }
+        return found;
+    }
+
+    private boolean allResultsContainExpectedFirstName(List<Student> resultList, String firstName) {
+        boolean found = false;
+        for(Student p : resultList) {
+            if(p.getFirstName().equals(firstName)) {
+                found = true;
+                break;
+            }
+        }
+        return found;
+    }
+
+    private boolean allResultsContainExpectedLastName(List<Student> resultList, String lastName) {
+        boolean found = false;
+        for(Student p : resultList) {
+            if(p.getLastName().equals(lastName)) {
+                found = true;
+                break;
+            }
+        }
+        return found;
+    }
+}
@@ -0,0 +1,17 @@
+<configuration>
+
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>web - %date [%thread] %-5level %logger{36} - %message%n
+            </pattern>
+        </encoder>
+    </appender>
+
+    <logger name="org.springframework" level="WARN" />
+    <logger name="org.baeldung" level="DEBUG" />
+
+    <root level="INFO">
+        <appender-ref ref="STDOUT" />
+    </root>
+
+</configuration>