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

persistence-modules/spring-data-mongodb/README.md

@@ -0,0 +1,13 @@
+=========
+
+## Spring Data MongoDB
+
+
+### Relevant Articles: 
+- [A Guide to Queries in Spring Data MongoDB](http://www.baeldung.com/queries-in-spring-data-mongodb)
+- [Spring Data MongoDB – Indexes, Annotations and Converters](http://www.baeldung.com/spring-data-mongodb-index-annotations-converter)
+- [Custom Cascading in Spring Data MongoDB](http://www.baeldung.com/cascading-with-dbref-and-lifecycle-events-in-spring-data-mongodb)
+- [GridFS in Spring Data MongoDB](http://www.baeldung.com/spring-data-mongodb-gridfs)
+- [Introduction to Spring Data MongoDB](http://www.baeldung.com/spring-data-mongodb-tutorial)
+- [Spring Data MongoDB: Projections and Aggregations](http://www.baeldung.com/spring-data-mongodb-projections-aggregations)
+- [Spring Data Annotations](http://www.baeldung.com/spring-data-annotations)

persistence-modules/spring-data-mongodb/pom.xml

@@ -0,0 +1,121 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>com.baeldung</groupId>
+    <artifactId>spring-data-mongodb</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+    <name>spring-data-mongodb</name>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-spring-5</artifactId>
+        <version>0.0.1-SNAPSHOT</version>
+        <relativePath>../../parent-spring-5</relativePath>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.springframework.data</groupId>
+            <artifactId>spring-data-mongodb</artifactId>
+            <version>${org.springframework.data.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.data</groupId>
+            <artifactId>spring-data-releasetrain</artifactId>
+            <version>Lovelace-M3</version>
+            <type>pom</type>
+            <scope>import</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.mongodb</groupId>
+            <artifactId>mongodb-driver-reactivestreams</artifactId>
+            <version>${mongodb-reactivestreams.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>io.projectreactor</groupId>
+            <artifactId>reactor-core</artifactId>
+            <version>${projectreactor.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>io.projectreactor</groupId>
+            <artifactId>reactor-test</artifactId>
+            <version>${projectreactor.version}</version>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-core</artifactId>
+            <version>${spring.version}</version>
+            <exclusions>
+                <exclusion>
+                    <artifactId>commons-logging</artifactId>
+                    <groupId>commons-logging</groupId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-test</artifactId>
+            <version>${spring.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.querydsl</groupId>
+            <artifactId>querydsl-mongodb</artifactId>
+            <version>${querydsl.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.querydsl</groupId>
+            <artifactId>querydsl-apt</artifactId>
+            <version>${querydsl.version}</version>
+        </dependency>
+    </dependencies>
+
+    <repositories>
+        <repository>
+            <id>spring-milestones</id>
+            <name>Spring Milestones</name>
+            <url>https://repo.spring.io/milestone</url>
+            <snapshots>
+                <enabled>false</enabled>
+            </snapshots>
+        </repository>
+    </repositories>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>com.mysema.maven</groupId>
+                <artifactId>apt-maven-plugin</artifactId>
+                <version>${mysema.maven.version}</version>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>process</goal>
+                        </goals>
+                        <configuration>
+                            <outputDirectory>target/generated-sources/java</outputDirectory>
+                            <processor>org.springframework.data.mongodb.repository.support.MongoAnnotationProcessor</processor>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+
+    <properties>
+        <org.springframework.data.version>2.1.0.RELEASE</org.springframework.data.version>
+        <querydsl.version>4.1.4</querydsl.version>
+        <mysema.maven.version>1.1.3</mysema.maven.version>
+        <spring.version>5.1.0.RELEASE</spring.version>
+        <mongodb-reactivestreams.version>1.9.2</mongodb-reactivestreams.version>
+        <projectreactor.version>3.2.0.RELEASE</projectreactor.version>
+
+    </properties>
+
+</project>

persistence-modules/spring-data-mongodb/src/main/java/com/baeldung/annotation/CascadeSave.java

@@ -0,0 +1,11 @@
+package com.baeldung.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+public @interface CascadeSave {
+}

persistence-modules/spring-data-mongodb/src/main/java/com/baeldung/config/MongoConfig.java

@@ -0,0 +1,68 @@
+package com.baeldung.config;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.core.convert.converter.Converter;
+import org.springframework.data.mongodb.MongoDbFactory;
+import org.springframework.data.mongodb.MongoTransactionManager;
+import org.springframework.data.mongodb.config.AbstractMongoConfiguration;
+import org.springframework.data.mongodb.core.convert.MongoCustomConversions;
+import org.springframework.data.mongodb.gridfs.GridFsTemplate;
+import org.springframework.data.mongodb.repository.config.EnableMongoRepositories;
+
+import com.baeldung.converter.UserWriterConverter;
+import com.baeldung.event.CascadeSaveMongoEventListener;
+import com.baeldung.event.UserCascadeSaveMongoEventListener;
+import com.mongodb.MongoClient;
+
+@Configuration
+@EnableMongoRepositories(basePackages = "com.baeldung.repository")
+public class MongoConfig extends AbstractMongoConfiguration {
+
+    private final List<Converter<?, ?>> converters = new ArrayList<Converter<?, ?>>();
+
+    @Override
+    protected String getDatabaseName() {
+        return "test";
+    }
+
+    @Override
+    public MongoClient mongoClient() {
+        return new MongoClient("127.0.0.1", 27017);
+    }
+
+    @Override
+    public String getMappingBasePackage() {
+        return "com.baeldung";
+    }
+
+    @Bean
+    public UserCascadeSaveMongoEventListener userCascadingMongoEventListener() {
+        return new UserCascadeSaveMongoEventListener();
+    }
+
+    @Bean
+    public CascadeSaveMongoEventListener cascadingMongoEventListener() {
+        return new CascadeSaveMongoEventListener();
+    }
+
+    @Override
+    public MongoCustomConversions customConversions() {
+        converters.add(new UserWriterConverter());
+        return new MongoCustomConversions(converters);
+    }
+
+    @Bean
+    public GridFsTemplate gridFsTemplate() throws Exception {
+        return new GridFsTemplate(mongoDbFactory(), mappingMongoConverter());
+    }
+
+    @Bean
+    MongoTransactionManager transactionManager(MongoDbFactory dbFactory) {
+            return new MongoTransactionManager(dbFactory);
+    }
+    
+}

persistence-modules/spring-data-mongodb/src/main/java/com/baeldung/config/MongoReactiveConfig.java

@@ -0,0 +1,23 @@
+package com.baeldung.config;
+
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.mongodb.config.AbstractReactiveMongoConfiguration;
+import org.springframework.data.mongodb.repository.config.EnableReactiveMongoRepositories;
+
+import com.mongodb.reactivestreams.client.MongoClient;
+import com.mongodb.reactivestreams.client.MongoClients;
+
+@Configuration
+@EnableReactiveMongoRepositories(basePackages = "com.baeldung.reactive.repository")
+public class MongoReactiveConfig extends AbstractReactiveMongoConfiguration {
+
+    @Override
+    public MongoClient reactiveMongoClient() {
+        return MongoClients.create();
+    }
+
+    @Override
+    protected String getDatabaseName() {
+        return "reactive";
+    }
+}

persistence-modules/spring-data-mongodb/src/main/java/com/baeldung/config/SimpleMongoConfig.java

@@ -0,0 +1,24 @@
+package com.baeldung.config;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.repository.config.EnableMongoRepositories;
+
+import com.mongodb.MongoClient;
+
+@Configuration
+@EnableMongoRepositories(basePackages = "com.baeldung.repository")
+public class SimpleMongoConfig {
+
+    @Bean
+    public MongoClient mongo() throws Exception {
+        return new MongoClient("localhost");
+    }
+
+    @Bean
+    public MongoTemplate mongoTemplate() throws Exception {
+        return new MongoTemplate(mongo(), "test");
+    }
+
+}

persistence-modules/spring-data-mongodb/src/main/java/com/baeldung/converter/UserWriterConverter.java

@@ -0,0 +1,26 @@
+package com.baeldung.converter;
+
+import com.mongodb.BasicDBObject;
+import com.mongodb.DBObject;
+import com.baeldung.model.User;
+import org.springframework.core.convert.converter.Converter;
+import org.springframework.stereotype.Component;
+
+@Component
+public class UserWriterConverter implements Converter<User, DBObject> {
+
+    @Override
+    public DBObject convert(final User user) {
+        final DBObject dbObject = new BasicDBObject();
+        dbObject.put("name", user.getName());
+        dbObject.put("age", user.getAge());
+        if (user.getEmailAddress() != null) {
+            final DBObject emailDbObject = new BasicDBObject();
+            emailDbObject.put("value", user.getEmailAddress().getValue());
+            dbObject.put("email", emailDbObject);
+        }
+        dbObject.removeField("_class");
+        return dbObject;
+    }
+
+}

persistence-modules/spring-data-mongodb/src/main/java/com/baeldung/event/CascadeCallback.java

@@ -0,0 +1,53 @@
+package com.baeldung.event;
+
+import java.lang.reflect.Field;
+
+import com.baeldung.annotation.CascadeSave;
+import org.springframework.data.mongodb.core.MongoOperations;
+import org.springframework.data.mongodb.core.mapping.DBRef;
+import org.springframework.util.ReflectionUtils;
+
+public class CascadeCallback implements ReflectionUtils.FieldCallback {
+
+    private Object source;
+    private MongoOperations mongoOperations;
+
+    CascadeCallback(final Object source, final MongoOperations mongoOperations) {
+        this.source = source;
+        this.setMongoOperations(mongoOperations);
+    }
+
+    @Override
+    public void doWith(final Field field) throws IllegalArgumentException, IllegalAccessException {
+        ReflectionUtils.makeAccessible(field);
+
+        if (field.isAnnotationPresent(DBRef.class) && field.isAnnotationPresent(CascadeSave.class)) {
+            final Object fieldValue = field.get(getSource());
+
+            if (fieldValue != null) {
+                final FieldCallback callback = new FieldCallback();
+
+                ReflectionUtils.doWithFields(fieldValue.getClass(), callback);
+
+                getMongoOperations().save(fieldValue);
+            }
+        }
+
+    }
+
+    private Object getSource() {
+        return source;
+    }
+
+    public void setSource(final Object source) {
+        this.source = source;
+    }
+
+    private MongoOperations getMongoOperations() {
+        return mongoOperations;
+    }
+
+    private void setMongoOperations(final MongoOperations mongoOperations) {
+        this.mongoOperations = mongoOperations;
+    }
+}

persistence-modules/spring-data-mongodb/src/main/java/com/baeldung/event/CascadeSaveMongoEventListener.java

@@ -0,0 +1,19 @@
+package com.baeldung.event;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.mongodb.core.MongoOperations;
+import org.springframework.data.mongodb.core.mapping.event.AbstractMongoEventListener;
+import org.springframework.data.mongodb.core.mapping.event.BeforeConvertEvent;
+import org.springframework.util.ReflectionUtils;
+
+public class CascadeSaveMongoEventListener extends AbstractMongoEventListener<Object> {
+
+    @Autowired
+    private MongoOperations mongoOperations;
+
+    @Override
+    public void onBeforeConvert(final BeforeConvertEvent<Object> event) {
+        final Object source = event.getSource();
+        ReflectionUtils.doWithFields(source.getClass(), new CascadeCallback(source, mongoOperations));
+    }
+}

persistence-modules/spring-data-mongodb/src/main/java/com/baeldung/event/FieldCallback.java

@@ -0,0 +1,23 @@
+package com.baeldung.event;
+
+import java.lang.reflect.Field;
+
+import org.springframework.data.annotation.Id;
+import org.springframework.util.ReflectionUtils;
+
+public class FieldCallback implements ReflectionUtils.FieldCallback {
+    private boolean idFound;
+
+    @Override
+    public void doWith(final Field field) throws IllegalArgumentException, IllegalAccessException {
+        ReflectionUtils.makeAccessible(field);
+
+        if (field.isAnnotationPresent(Id.class)) {
+            idFound = true;
+        }
+    }
+
+    public boolean isIdFound() {
+        return idFound;
+    }
+}

persistence-modules/spring-data-mongodb/src/main/java/com/baeldung/event/UserCascadeSaveMongoEventListener.java

@@ -0,0 +1,20 @@
+package com.baeldung.event;
+
+import com.baeldung.model.User;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.mongodb.core.MongoOperations;
+import org.springframework.data.mongodb.core.mapping.event.AbstractMongoEventListener;
+import org.springframework.data.mongodb.core.mapping.event.BeforeConvertEvent;
+
+public class UserCascadeSaveMongoEventListener extends AbstractMongoEventListener<Object> {
+    @Autowired
+    private MongoOperations mongoOperations;
+
+    @Override
+    public void onBeforeConvert(final BeforeConvertEvent<Object> event) {
+        final Object source = event.getSource();
+        if ((source instanceof User) && (((User) source).getEmailAddress() != null)) {
+            mongoOperations.save(((User) source).getEmailAddress());
+        }
+    }
+}

persistence-modules/spring-data-mongodb/src/main/java/com/baeldung/model/EmailAddress.java

@@ -0,0 +1,27 @@
+package com.baeldung.model;
+
+import org.springframework.data.annotation.Id;
+import org.springframework.data.mongodb.core.mapping.Document;
+
+@Document
+public class EmailAddress {
+    @Id
+    private String id;
+    private String value;
+
+    public String getId() {
+        return id;
+    }
+
+    public void setId(final String id) {
+        this.id = id;
+    }
+
+    public String getValue() {
+        return value;
+    }
+
+    public void setValue(final String value) {
+        this.value = value;
+    }
+}

persistence-modules/spring-data-mongodb/src/main/java/com/baeldung/model/User.java

@@ -0,0 +1,93 @@
+package com.baeldung.model;
+
+import com.baeldung.annotation.CascadeSave;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.data.annotation.Id;
+import org.springframework.data.annotation.PersistenceConstructor;
+import org.springframework.data.annotation.Transient;
+import org.springframework.data.mongodb.core.index.CompoundIndex;
+import org.springframework.data.mongodb.core.index.CompoundIndexes;
+import org.springframework.data.mongodb.core.index.IndexDirection;
+import org.springframework.data.mongodb.core.index.Indexed;
+import org.springframework.data.mongodb.core.mapping.DBRef;
+import org.springframework.data.mongodb.core.mapping.Document;
+import org.springframework.data.mongodb.core.mapping.Field;
+
+import com.querydsl.core.annotations.QueryEntity;
+
+@QueryEntity
+@Document
+@CompoundIndexes({ @CompoundIndex(name = "email_age", def = "{'email.id' : 1, 'age': 1}") })
+public class User {
+
+    @Id
+    private String id;
+    @Indexed(direction = IndexDirection.ASCENDING)
+    private String name;
+    @Indexed(direction = IndexDirection.ASCENDING)
+    private Integer age;
+
+    @DBRef
+    @Field("email")
+    @CascadeSave
+    private EmailAddress emailAddress;
+
+    @Transient
+    private Integer yearOfBirth;
+
+    public User() {
+    }
+    
+    public User(String name, Integer age) {
+        this.name = name;
+        this.age = age;
+    }
+
+    @PersistenceConstructor
+    public User(final String name, @Value("#root.age ?: 0") final Integer age, final EmailAddress emailAddress) {
+        this.name = name;
+        this.age = age;
+        this.emailAddress = emailAddress;
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public void setId(final String id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(final String name) {
+        this.name = name;
+    }
+
+    public Integer getAge() {
+        return age;
+    }
+
+    public void setAge(final Integer age) {
+        this.age = age;
+    }
+
+    public EmailAddress getEmailAddress() {
+        return emailAddress;
+    }
+
+    public void setEmailAddress(final EmailAddress emailAddress) {
+        this.emailAddress = emailAddress;
+    }
+
+    public Integer getYearOfBirth() {
+        return yearOfBirth;
+    }
+
+    public void setYearOfBirth(final Integer yearOfBirth) {
+        this.yearOfBirth = yearOfBirth;
+    }
+
+}

persistence-modules/spring-data-mongodb/src/main/java/com/baeldung/reactive/repository/UserRepository.java

@@ -0,0 +1,9 @@
+package com.baeldung.reactive.repository;
+
+import org.springframework.data.mongodb.repository.ReactiveMongoRepository;
+
+import com.baeldung.model.User;
+
+
+public interface UserRepository extends ReactiveMongoRepository<User, String> {
+}

persistence-modules/spring-data-mongodb/src/main/java/com/baeldung/repository/UserRepository.java

@@ -0,0 +1,36 @@
+package com.baeldung.repository;
+
+import java.util.List;
+
+import org.springframework.data.mongodb.repository.MongoRepository;
+import org.springframework.data.mongodb.repository.Query;
+import org.springframework.data.querydsl.QuerydslPredicateExecutor;
+
+import com.baeldung.model.User;
+
+public interface UserRepository extends MongoRepository<User, String>, QuerydslPredicateExecutor<User> {
+    @Query("{ 'name' : ?0 }")
+    List<User> findUsersByName(String name);
+
+    @Query("{ 'age' : { $gt: ?0, $lt: ?1 } }")
+    List<User> findUsersByAgeBetween(int ageGT, int ageLT);
+
+    @Query("{ 'name' : { $regex: ?0 } }")
+    List<User> findUsersByRegexpName(String regexp);
+
+    List<User> findByName(String name);
+
+    List<User> findByNameLikeOrderByAgeAsc(String name);
+
+    List<User> findByAgeBetween(int ageGT, int ageLT);
+
+    List<User> findByNameStartingWith(String regexp);
+
+    List<User> findByNameEndingWith(String regexp);
+
+    @Query(value = "{}", fields = "{name : 1}")
+    List<User> findNameAndId();
+
+    @Query(value = "{}", fields = "{_id : 0}")
+    List<User> findNameAndAgeExcludeId();
+}

persistence-modules/spring-data-mongodb/src/main/resources/logback.xml

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
+            </pattern>
+        </encoder>
+    </appender>
+
+    <logger name="org.springframework" level="WARN" />
+    <logger name="org.springframework.transaction" level="WARN" />
+
+    <!-- in order to debug some marshalling issues, this needs to be TRACE -->
+    <logger name="org.springframework.web.servlet.mvc" level="WARN" />
+
+    <root level="INFO">
+        <appender-ref ref="STDOUT" />
+    </root>
+</configuration>

persistence-modules/spring-data-mongodb/src/main/resources/mongoConfig.xml

@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
+    xmlns:p="http://www.springframework.org/schema/p" xmlns:mongo="http://www.springframework.org/schema/data/mongo"
+    xsi:schemaLocation="
+       http://www.springframework.org/schema/beans 
+       http://www.springframework.org/schema/beans/spring-beans.xsd
+       http://www.springframework.org/schema/data/mongo
+       http://www.springframework.org/schema/data/mongo/spring-mongo.xsd
+       http://www.springframework.org/schema/context 
+       http://www.springframework.org/schema/context/spring-context.xsd"
+>
+    <context:annotation-config/>
+    
+    <mongo:mongo-client id="mongoClient" host="localhost" />
+    
+    <mongo:db-factory id="mongoDbFactory" dbname="test" mongo-ref="mongoClient" />
+    
+    <bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate">
+        <constructor-arg ref="mongoDbFactory" />
+        <constructor-arg ref="mongoConverter" />
+    </bean>
+
+    <bean id="mongoTemplate" class="org.springframework.data.mongodb.core.MongoTemplate">
+        <constructor-arg ref="mongoDbFactory"/>
+        <constructor-arg ref="mongoConverter" />
+    </bean>
+
+    <bean class="org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor"/>
+
+    <mongo:repositories base-package="com.baeldung.repository" mongo-template-ref="mongoTemplate"/>
+
+    <bean class="com.baeldung.event.CascadeSaveMongoEventListener">
+    </bean>
+
+    <mongo:mapping-converter id="mongoConverter" base-package="com.baeldung.converter">
+        <mongo:custom-converters base-package="org.baeldung.converter"/>
+    </mongo:mapping-converter>
+
+</beans>

persistence-modules/spring-data-mongodb/src/test/java/com/baeldung/aggregation/ZipsAggregationLiveTest.java

@@ -0,0 +1,151 @@
+package com.baeldung.aggregation;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.springframework.data.mongodb.core.aggregation.Aggregation.group;
+import static org.springframework.data.mongodb.core.aggregation.Aggregation.limit;
+import static org.springframework.data.mongodb.core.aggregation.Aggregation.match;
+import static org.springframework.data.mongodb.core.aggregation.Aggregation.newAggregation;
+import static org.springframework.data.mongodb.core.aggregation.Aggregation.project;
+import static org.springframework.data.mongodb.core.aggregation.Aggregation.sort;
+
+import java.io.BufferedReader;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.StreamSupport;
+
+import org.bson.Document;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.domain.Sort.Direction;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.aggregation.Aggregation;
+import org.springframework.data.mongodb.core.aggregation.AggregationResults;
+import org.springframework.data.mongodb.core.aggregation.GroupOperation;
+import org.springframework.data.mongodb.core.aggregation.LimitOperation;
+import org.springframework.data.mongodb.core.aggregation.MatchOperation;
+import org.springframework.data.mongodb.core.aggregation.ProjectionOperation;
+import org.springframework.data.mongodb.core.aggregation.SortOperation;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import com.baeldung.aggregation.model.StatePopulation;
+import com.baeldung.config.MongoConfig;
+import com.mongodb.MongoClient;
+import com.mongodb.client.MongoCollection;
+import com.mongodb.client.MongoDatabase;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = MongoConfig.class)
+public class ZipsAggregationLiveTest {
+
+    private static MongoClient client;
+
+    @Autowired
+    private MongoTemplate mongoTemplate;
+
+    @BeforeClass
+    public static void setupTests() throws Exception {
+        client = new MongoClient();
+        MongoDatabase testDB = client.getDatabase("test");
+        MongoCollection<Document> zipsCollection = testDB.getCollection("zips");
+        zipsCollection.drop();
+
+        InputStream zipsJsonStream = ZipsAggregationLiveTest.class.getResourceAsStream("/zips.json");
+        BufferedReader reader = new BufferedReader(new InputStreamReader(zipsJsonStream));
+        reader.lines()
+          .forEach(line -> zipsCollection.insertOne(Document.parse(line)));
+        reader.close();
+    }
+
+    @AfterClass
+    public static void tearDown() throws Exception {
+        client = new MongoClient();
+        MongoDatabase testDB = client.getDatabase("test");
+        MongoCollection<Document> zipsCollection = testDB.getCollection("zips");
+        zipsCollection.drop();
+        client.close();
+    }
+
+    @Test
+    public void whenStatesHavePopGrtrThan10MillionAndSorted_thenSuccess() {
+
+        GroupOperation groupByStateAndSumPop = group("state").sum("pop").as("statePop");
+        MatchOperation filterStates = match(new Criteria("statePop").gt(10000000));
+        SortOperation sortByPopDesc = sort(new Sort(Direction.DESC, "statePop"));
+
+        Aggregation aggregation = newAggregation(groupByStateAndSumPop, filterStates, sortByPopDesc);
+        AggregationResults<StatePopulation> result = mongoTemplate.aggregate(aggregation, "zips", StatePopulation.class);
+
+        /*
+         * Assert that all states have population
+         * greater than 10000000
+         */
+        result.forEach(statePop -> {
+            assertTrue(statePop.getStatePop() > 10000000);
+        });
+
+        /*
+         * Assert that states fetched are in sorted by
+         * decreasing population
+         */
+        List<StatePopulation> actualList = StreamSupport.stream(result.spliterator(), false)
+          .collect(Collectors.toList());
+
+        List<StatePopulation> expectedList = new ArrayList<>(actualList);
+        Collections.sort(expectedList, (sp1, sp2) -> sp2.getStatePop() - sp1.getStatePop());
+
+        assertEquals(expectedList, actualList);
+
+    }
+
+    @Test
+    public void whenStateWithLowestAvgCityPopIsND_theSuccess() {
+
+        GroupOperation sumTotalCityPop = group("state", "city").sum("pop").as("cityPop");
+        GroupOperation averageStatePop = group("_id.state").avg("cityPop").as("avgCityPop");
+        SortOperation sortByAvgPopAsc = sort(new Sort(Direction.ASC, "avgCityPop"));
+        ProjectionOperation projectToMatchModel = project().andExpression("_id").as("state")
+          .andExpression("avgCityPop").as("statePop");
+        LimitOperation limitToOnlyFirstDoc = limit(1);
+
+        Aggregation aggregation = newAggregation(sumTotalCityPop, averageStatePop, sortByAvgPopAsc, limitToOnlyFirstDoc, projectToMatchModel);
+
+        AggregationResults<StatePopulation> result = mongoTemplate.aggregate(aggregation, "zips", StatePopulation.class);
+        StatePopulation smallestState = result.getUniqueMappedResult();
+
+        assertEquals("ND", smallestState.getState());
+        assertTrue(smallestState.getStatePop()
+          .equals(1645));
+    }
+
+    @Test
+    public void whenMaxTXAndMinDC_theSuccess() {
+
+        GroupOperation sumZips = group("state").count().as("zipCount");
+        SortOperation sortByCount = sort(Direction.ASC, "zipCount");
+        GroupOperation groupFirstAndLast = group().first("_id").as("minZipState")
+          .first("zipCount").as("minZipCount").last("_id").as("maxZipState")
+          .last("zipCount").as("maxZipCount");
+
+        Aggregation aggregation = newAggregation(sumZips, sortByCount, groupFirstAndLast);
+
+        AggregationResults<Document> result = mongoTemplate.aggregate(aggregation, "zips", Document.class);
+        Document document = result.getUniqueMappedResult();
+
+        assertEquals("DC", document.get("minZipState"));
+        assertEquals(24, document.get("minZipCount"));
+        assertEquals("TX", document.get("maxZipState"));
+        assertEquals(1671, document.get("maxZipCount"));
+    }
+
+}

persistence-modules/spring-data-mongodb/src/test/java/com/baeldung/aggregation/model/StatePopulation.java

@@ -0,0 +1,38 @@
+package com.baeldung.aggregation.model;
+
+import org.springframework.data.annotation.Id;
+
+public class StatePopulation {
+
+    @Id
+    private String state;
+    private Integer statePop;
+
+    public String getState() {
+        return state;
+    }
+
+    public void setState(String state) {
+        this.state = state;
+    }
+
+    public Integer getStatePop() {
+        return statePop;
+    }
+
+    public void setStatePop(Integer statePop) {
+        this.statePop = statePop;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder builder = new StringBuilder();
+        builder.append("StatePopulation [state=");
+        builder.append(state);
+        builder.append(", statePop=");
+        builder.append(statePop);
+        builder.append("]");
+        return builder.toString();
+    }
+
+}

persistence-modules/spring-data-mongodb/src/test/java/com/baeldung/gridfs/GridFSLiveTest.java

@@ -0,0 +1,229 @@
+package com.baeldung.gridfs;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.Matchers.nullValue;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertThat;
+
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.bson.types.ObjectId;
+import org.junit.After;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.data.mongodb.gridfs.GridFsResource;
+import org.springframework.data.mongodb.gridfs.GridFsTemplate;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import com.mongodb.BasicDBObject;
+import com.mongodb.DBObject;
+import com.mongodb.client.gridfs.model.GridFSFile;
+
+@ContextConfiguration("file:src/main/resources/mongoConfig.xml")
+@RunWith(SpringJUnit4ClassRunner.class)
+public class GridFSLiveTest {
+
+    private final Logger logger = LoggerFactory.getLogger(getClass());
+
+    @Autowired
+    private GridFsTemplate gridFsTemplate;
+
+    @After
+    public void tearDown() {
+        List<GridFSFile> fileList = new ArrayList<GridFSFile>();
+        gridFsTemplate.find(new Query()).into(fileList);
+        for (GridFSFile file : fileList) {
+            gridFsTemplate.delete(new Query(Criteria.where("filename").is(file.getFilename())));
+        }
+    }
+
+    @Test
+    public void whenStoringFileWithMetadata_thenFileAndMetadataAreStored() {
+        DBObject metaData = new BasicDBObject();
+        metaData.put("user", "alex");
+        InputStream inputStream = null;
+        String id = "";
+        try {
+            inputStream = new FileInputStream("src/main/resources/test.png");
+            id = gridFsTemplate.store(inputStream, "test.png", "image/png", metaData).toString();
+        } catch (FileNotFoundException ex) {
+            logger.error("File not found", ex);
+        } finally {
+            if (inputStream != null) {
+                try {
+                    inputStream.close();
+                } catch (IOException ex) {
+                    logger.error("Failed to close", ex);
+                }
+            }
+        }
+
+        assertNotNull(id);
+    }
+
+    @Test
+    public void givenFileWithMetadataExist_whenFindingFileById_thenFileWithMetadataIsFound() {
+        DBObject metaData = new BasicDBObject();
+        metaData.put("user", "alex");
+        InputStream inputStream = null;
+        ObjectId id = null;
+        try {
+            inputStream = new FileInputStream("src/main/resources/test.png");
+            id = gridFsTemplate.store(inputStream, "test.png", "image/png", metaData);
+        } catch (FileNotFoundException ex) {
+            logger.error("File not found", ex);
+        } finally {
+            if (inputStream != null) {
+                try {
+                    inputStream.close();
+                } catch (IOException ex) {
+                    logger.error("Failed to close", ex);
+                }
+            }
+        }
+
+        GridFSFile gridFSFile = gridFsTemplate.findOne(new Query(Criteria.where("_id").is(id)));
+
+        assertNotNull(gridFSFile);
+//        assertNotNull(gridFSFile.getInputStream());
+//        assertThat(gridFSFile.numChunks(), is(1));
+//        assertThat(gridFSFile.containsField("filename"), is(true));
+        assertThat(gridFSFile.getFilename(), is("test.png"));
+        assertThat(gridFSFile.getObjectId(), is(id));
+//        assertThat(gridFSFile.keySet().size(), is(9));
+//        assertNotNull(gridFSFile.getMD5());
+        assertNotNull(gridFSFile.getUploadDate());
+//        assertNull(gridFSFile.getAliases());
+        assertNotNull(gridFSFile.getChunkSize());
+        assertThat(gridFSFile.getMetadata().get("_contentType"), is("image/png"));
+        assertThat(gridFSFile.getFilename(), is("test.png"));
+        assertThat(gridFSFile.getMetadata().get("user"), is("alex"));
+    }
+
+    @Test
+    public void givenMetadataAndFilesExist_whenFindingAllFiles_thenFilesWithMetadataAreFound() {
+        DBObject metaDataUser1 = new BasicDBObject();
+        metaDataUser1.put("user", "alex");
+        DBObject metaDataUser2 = new BasicDBObject();
+        metaDataUser2.put("user", "david");
+        InputStream inputStream = null;
+
+        try {
+            inputStream = new FileInputStream("src/main/resources/test.png");
+            gridFsTemplate.store(inputStream, "test.png", "image/png", metaDataUser1);
+            gridFsTemplate.store(inputStream, "test.png", "image/png", metaDataUser2);
+        } catch (FileNotFoundException ex) {
+            logger.error("File not found", ex);
+        } finally {
+            if (inputStream != null) {
+                try {
+                    inputStream.close();
+                } catch (IOException ex) {
+                    logger.error("Failed to close", ex);
+                }
+            }
+        }
+
+        List<GridFSFile> gridFSFiles = new ArrayList<GridFSFile>();
+        gridFsTemplate.find(new Query()).into(gridFSFiles);
+
+        assertNotNull(gridFSFiles);
+        assertThat(gridFSFiles.size(), is(2));
+    }
+
+    @Test
+    public void givenMetadataAndFilesExist_whenFindingAllFilesOnQuery_thenFilesWithMetadataAreFoundOnQuery() {
+        DBObject metaDataUser1 = new BasicDBObject();
+        metaDataUser1.put("user", "alex");
+        DBObject metaDataUser2 = new BasicDBObject();
+        metaDataUser2.put("user", "david");
+        InputStream inputStream = null;
+
+        try {
+            inputStream = new FileInputStream("src/main/resources/test.png");
+            gridFsTemplate.store(inputStream, "test.png", "image/png", metaDataUser1);
+            gridFsTemplate.store(inputStream, "test.png", "image/png", metaDataUser2);
+        } catch (FileNotFoundException ex) {
+            logger.error("File not found", ex);
+        } finally {
+            if (inputStream != null) {
+                try {
+                    inputStream.close();
+                } catch (IOException ex) {
+                    logger.error("Failed to close", ex);
+                }
+            }
+        }
+
+        List<GridFSFile> gridFSFiles = new ArrayList<GridFSFile>();
+        gridFsTemplate.find(new Query(Criteria.where("metadata.user").is("alex"))).into(gridFSFiles);
+
+        assertNotNull(gridFSFiles);
+        assertThat(gridFSFiles.size(), is(1));
+    }
+
+    @Test
+    public void givenFileWithMetadataExist_whenDeletingFileById_thenFileWithMetadataIsDeleted() {
+        DBObject metaData = new BasicDBObject();
+        metaData.put("user", "alex");
+        InputStream inputStream = null;
+        String id = "";
+        try {
+            inputStream = new FileInputStream("src/main/resources/test.png");
+            id = gridFsTemplate.store(inputStream, "test.png", "image/png", metaData).toString();
+        } catch (FileNotFoundException ex) {
+            logger.error("File not found", ex);
+        } finally {
+            if (inputStream != null) {
+                try {
+                    inputStream.close();
+                } catch (IOException ex) {
+                    logger.error("Failed to close", ex);
+                }
+            }
+        }
+
+        gridFsTemplate.delete(new Query(Criteria.where("_id").is(id)));
+
+        assertThat(gridFsTemplate.findOne(new Query(Criteria.where("_id").is(id))), is(nullValue()));
+    }
+
+    @Test
+    public void givenFileWithMetadataExist_whenGettingFileByResource_thenFileWithMetadataIsGotten() {
+        DBObject metaData = new BasicDBObject();
+        metaData.put("user", "alex");
+        InputStream inputStream = null;
+        try {
+            inputStream = new FileInputStream("src/main/resources/test.png");
+            gridFsTemplate.store(inputStream, "test.png", "image/png", metaData).toString();
+        } catch (FileNotFoundException ex) {
+            logger.error("File not found", ex);
+        } finally {
+            if (inputStream != null) {
+                try {
+                    inputStream.close();
+                } catch (IOException ex) {
+                    logger.error("Failed to close", ex);
+                }
+            }
+        }
+
+        GridFsResource[] gridFsResource = gridFsTemplate.getResources("test*");
+
+        assertNotNull(gridFsResource);
+        assertEquals(gridFsResource.length, 1);
+        assertThat(gridFsResource[0].getFilename(), is("test.png"));
+    }
+}

persistence-modules/spring-data-mongodb/src/test/java/com/baeldung/mongotemplate/DocumentQueryLiveTest.java

@@ -0,0 +1,193 @@
+package com.baeldung.mongotemplate;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.util.Iterator;
+import java.util.List;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import com.baeldung.config.MongoConfig;
+import com.baeldung.model.EmailAddress;
+import com.baeldung.model.User;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = MongoConfig.class)
+public class DocumentQueryLiveTest {
+
+    @Autowired
+    private MongoTemplate mongoTemplate;
+
+    @Before
+    public void testSetup() {
+        if (!mongoTemplate.collectionExists(User.class)) {
+            mongoTemplate.createCollection(User.class);
+        }
+    }
+
+    @After
+    public void tearDown() {
+        mongoTemplate.dropCollection(EmailAddress.class);
+        mongoTemplate.dropCollection(User.class);
+    }
+
+    @Test
+    public void givenUsersExist_whenFindingUsersByName_thenUsersAreFound() {
+        User user = new User();
+        user.setName("Eric");
+        user.setAge(45);
+        mongoTemplate.insert(user);
+        user = new User();
+        user.setName("Antony");
+        user.setAge(55);
+        mongoTemplate.insert(user);
+
+        Query query = new Query();
+        query.addCriteria(Criteria.where("name").is("Eric"));
+        List<User> users = mongoTemplate.find(query, User.class);
+
+        assertThat(users.size(), is(1));
+    }
+
+    @Test
+    public void givenUsersExist_whenFindingUserWithAgeLessThan50AndGreateThan20_thenUsersAreFound() {
+        User user = new User();
+        user.setAge(20);
+        user.setName("Jon");
+        mongoTemplate.insert(user);
+
+        user = new User();
+        user.setAge(50);
+        user.setName("Jon");
+        mongoTemplate.insert(user);
+
+        user = new User();
+        user.setAge(33);
+        user.setName("Jim");
+        mongoTemplate.insert(user);
+
+        Query query = new Query();
+        query.addCriteria(Criteria.where("age").lt(40).gt(26));
+        List<User> users = mongoTemplate.find(query, User.class);
+
+        assertThat(users.size(), is(1));
+    }
+
+    @Test
+    public void givenUsersExist_whenFindingUserWithNameStartWithA_thenUsersAreFound() {
+        User user = new User();
+        user.setName("Eric");
+        user.setAge(45);
+        mongoTemplate.insert(user);
+
+        user = new User();
+        user.setName("Antony");
+        user.setAge(33);
+        mongoTemplate.insert(user);
+
+        user = new User();
+        user.setName("Alice");
+        user.setAge(35);
+        mongoTemplate.insert(user);
+
+        Query query = new Query();
+        query.addCriteria(Criteria.where("name").regex("^A"));
+
+        List<User> users = mongoTemplate.find(query, User.class);
+
+        assertThat(users.size(), is(2));
+    }
+
+    @Test
+    public void givenUsersExist_whenFindingUserWithNameEndWithC_thenUsersAreFound() {
+        User user = new User();
+        user.setName("Eric");
+        user.setAge(45);
+        mongoTemplate.insert(user);
+
+        user = new User();
+        user.setName("Antony");
+        user.setAge(33);
+        mongoTemplate.insert(user);
+
+        user = new User();
+        user.setName("Alice");
+        user.setAge(35);
+        mongoTemplate.insert(user);
+
+        Query query = new Query();
+        query.addCriteria(Criteria.where("name").regex("c$"));
+
+        List<User> users = mongoTemplate.find(query, User.class);
+
+        assertThat(users.size(), is(1));
+    }
+
+    @Test
+    public void givenUsersExist_whenFindingByPage_thenUsersAreFoundByPage() {
+        User user = new User();
+        user.setName("Eric");
+        user.setAge(45);
+        mongoTemplate.insert(user);
+
+        user = new User();
+        user.setName("Antony");
+        user.setAge(33);
+        mongoTemplate.insert(user);
+
+        user = new User();
+        user.setName("Alice");
+        user.setAge(35);
+        mongoTemplate.insert(user);
+
+        final Pageable pageableRequest = PageRequest.of(0, 2);
+        Query query = new Query();
+        query.with(pageableRequest);
+
+        List<User> users = mongoTemplate.find(query, User.class);
+
+        assertThat(users.size(), is(2));
+    }
+
+    @Test
+    public void givenUsersExist_whenFindingUsersAndSortThem_thenUsersAreFoundAndSorted() {
+        User user = new User();
+        user.setName("Eric");
+        user.setAge(45);
+        mongoTemplate.insert(user);
+
+        user = new User();
+        user.setName("Antony");
+        user.setAge(33);
+        mongoTemplate.insert(user);
+
+        user = new User();
+        user.setName("Alice");
+        user.setAge(35);
+        mongoTemplate.insert(user);
+
+        Query query = new Query();
+        query.with(new Sort(Sort.Direction.ASC, "age"));
+
+        List<User> users = mongoTemplate.find(query, User.class);
+
+        Iterator<User> iter = users.iterator();
+        assertThat(users.size(), is(3));
+        assertThat(iter.next().getName(), is("Antony"));
+        assertThat(iter.next().getName(), is("Alice"));
+        assertThat(iter.next().getName(), is("Eric"));
+    }
+}

persistence-modules/spring-data-mongodb/src/test/java/com/baeldung/mongotemplate/MongoTemplateProjectionLiveTest.java

@@ -0,0 +1,72 @@
+package com.baeldung.mongotemplate;
+
+import com.baeldung.config.SimpleMongoConfig;
+import com.baeldung.model.User;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = SimpleMongoConfig.class)
+public class MongoTemplateProjectionLiveTest {
+
+    @Autowired
+    private MongoTemplate mongoTemplate;
+
+    @Before
+    public void testSetup() {
+        if (!mongoTemplate.collectionExists(User.class)) {
+            mongoTemplate.createCollection(User.class);
+        }
+    }
+
+    @After
+    public void tearDown() {
+        mongoTemplate.dropCollection(User.class);
+    }
+
+    @Test
+    public void givenUserExists_whenAgeZero_thenSuccess() {
+        mongoTemplate.insert(new User("John", 30));
+        mongoTemplate.insert(new User("Ringo", 35));
+
+        final Query query = new Query();
+        query.fields()
+          .include("name");
+
+        mongoTemplate.find(query, User.class)
+          .forEach(user -> {
+              assertNotNull(user.getName());
+              assertTrue(user.getAge()
+                .equals(0));
+          });
+    }
+
+    @Test
+    public void givenUserExists_whenIdNull_thenSuccess() {
+        mongoTemplate.insert(new User("John", 30));
+        mongoTemplate.insert(new User("Ringo", 35));
+
+        final Query query = new Query();
+        query.fields()
+          .exclude("_id");
+
+        mongoTemplate.find(query, User.class)
+          .forEach(user -> {
+              assertNull(user.getId());
+              assertNotNull(user.getAge());
+          });
+
+    }
+
+}

persistence-modules/spring-data-mongodb/src/test/java/com/baeldung/mongotemplate/MongoTemplateQueryLiveTest.java

@@ -0,0 +1,196 @@
+package com.baeldung.mongotemplate;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.Matchers.nullValue;
+import static org.junit.Assert.assertThat;
+
+import java.util.List;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.domain.Sort.Direction;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.index.Index;
+import org.springframework.data.mongodb.core.index.IndexInfo;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import com.baeldung.config.MongoConfig;
+import com.baeldung.model.EmailAddress;
+import com.baeldung.model.User;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = MongoConfig.class)
+public class MongoTemplateQueryLiveTest {
+
+    @Autowired
+    private MongoTemplate mongoTemplate;
+
+    @Before
+    public void testSetup() {
+        if (!mongoTemplate.collectionExists(User.class)) {
+            mongoTemplate.createCollection(User.class);
+        }
+    }
+
+    @After
+    public void tearDown() {
+        mongoTemplate.dropCollection(User.class);
+    }
+
+    @Test
+    public void givenUsersExist_whenFindingUserWithAgeLessThan50AndGreateThan20_thenUsersAreFound() {
+        User user = new User();
+        user.setName("Eric");
+        user.setAge(45);
+        mongoTemplate.insert(user);
+        user = new User();
+        user.setName("Antony");
+        user.setAge(55);
+        mongoTemplate.insert(user);
+
+        Query query = new Query();
+        query.addCriteria(Criteria.where("age").lt(50).gt(20));
+        List<User> users = mongoTemplate.find(query, User.class);
+
+        assertThat(users.size(), is(1));
+    }
+
+    @Test
+    public void givenUsersExist_whenFindingUserWithNameStartWithA_thenUsersAreFound() {
+        User user = new User();
+        user.setName("Eric");
+        user.setAge(45);
+        mongoTemplate.insert(user);
+
+        user = new User();
+        user.setName("Antony");
+        user.setAge(33);
+        mongoTemplate.insert(user);
+
+        user = new User();
+        user.setName("Alice");
+        user.setAge(35);
+        mongoTemplate.insert(user);
+
+        Query query = new Query();
+        query.addCriteria(Criteria.where("name").regex("^A"));
+
+        List<User> users = mongoTemplate.find(query, User.class);
+        assertThat(users.size(), is(2));
+    }
+
+    @Test
+    public void givenUsersExist_whenFindingByPage_thenUsersAreFoundByPage() {
+        User user = new User();
+        user.setName("Eric");
+        user.setAge(45);
+        mongoTemplate.insert(user);
+
+        user = new User();
+        user.setName("Antony");
+        user.setAge(33);
+        mongoTemplate.insert(user);
+
+        user = new User();
+        user.setName("Alice");
+        user.setAge(35);
+        mongoTemplate.insert(user);
+
+        final Pageable pageableRequest = PageRequest.of(0, 2);
+        Query query = new Query();
+        query.with(pageableRequest);
+
+        List<User> users = mongoTemplate.find(query, User.class);
+        assertThat(users.size(), is(2));
+    }
+
+    @Test
+    public void givenUsersExist_whenFindingUsersAndSortThem_thenUsersAreFoundAndSorted() {
+        User user = new User();
+        user.setName("Eric");
+        user.setAge(45);
+        mongoTemplate.insert(user);
+
+        user = new User();
+        user.setName("Antony");
+        user.setAge(33);
+        mongoTemplate.insert(user);
+
+        user = new User();
+        user.setName("Alice");
+        user.setAge(35);
+        mongoTemplate.insert(user);
+
+        Query query = new Query();
+        query.with(new Sort(Sort.Direction.ASC, "age"));
+
+        List<User> users = mongoTemplate.find(query, User.class);
+        assertThat(users.size(), is(3));
+    }
+
+    @Test
+    public void givenUserExistsWithIndexAddedFromMapping_whenCheckingIndex_thenIndexIsExisted() {
+        final User user = new User();
+        user.setName("Brendan");
+        EmailAddress emailAddress = new EmailAddress();
+        emailAddress.setValue("a@gmail.com");
+        user.setEmailAddress(emailAddress);
+        mongoTemplate.insert(user);
+
+        List<IndexInfo> indexInfos = mongoTemplate.indexOps("user").getIndexInfo();
+
+        assertThat(indexInfos.size(), is(1));
+    }
+
+    @Test
+    public void whenSavingUserWithEmailAddress_thenUserandEmailAddressSaved() {
+        final User user = new User();
+        user.setName("Brendan");
+        final EmailAddress emailAddress = new EmailAddress();
+        emailAddress.setValue("b@gmail.com");
+        user.setEmailAddress(emailAddress);
+        mongoTemplate.insert(user);
+
+        assertThat(mongoTemplate.findOne(Query.query(Criteria.where("name").is("Brendan")), User.class).getEmailAddress().getValue(), is("b@gmail.com"));
+    }
+
+    @Test
+    public void givenUserExistsWithIndexAddedFromCode_whenCheckingIndex_thenIndexIsExisted() {
+        final User user = new User();
+        user.setName("Brendan");
+        mongoTemplate.indexOps(User.class).ensureIndex(new Index().on("name", Direction.ASC));
+        mongoTemplate.insert(user);
+
+        List<IndexInfo> indexInfos = mongoTemplate.indexOps("user").getIndexInfo();
+
+        assertThat(indexInfos.size(), is(2));
+    }
+
+    @Test
+    public void whenSavingUserWithoutSettingAge_thenAgeIsSetByDefault() {
+        final User user = new User();
+        user.setName("Alex");
+        mongoTemplate.insert(user);
+
+        assertThat(mongoTemplate.findOne(Query.query(Criteria.where("name").is("Alex")), User.class).getAge(), is(0));
+    }
+
+    @Test
+    public void whenSavingUser_thenYearOfBirthIsCalculated() {
+        final User user = new User();
+        user.setName("Alex");
+        user.setYearOfBirth(1985);
+        mongoTemplate.insert(user);
+
+        assertThat(mongoTemplate.findOne(Query.query(Criteria.where("name").is("Alex")), User.class).getYearOfBirth(), is(nullValue()));
+    }
+}

persistence-modules/spring-data-mongodb/src/test/java/com/baeldung/repository/BaseQueryLiveTest.java

@@ -0,0 +1,29 @@
+package com.baeldung.repository;
+
+import com.baeldung.model.User;
+import com.baeldung.repository.UserRepository;
+import org.junit.After;
+import org.junit.Before;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.mongodb.core.MongoOperations;
+
+public class BaseQueryLiveTest {
+
+    @Autowired
+    protected UserRepository userRepository;
+
+    @Autowired
+    protected MongoOperations mongoOps;
+
+    @Before
+    public void testSetup() {
+        if (!mongoOps.collectionExists(User.class)) {
+            mongoOps.createCollection(User.class);
+        }
+    }
+
+    @After
+    public void tearDown() {
+        mongoOps.dropCollection(User.class);
+    }
+}

persistence-modules/spring-data-mongodb/src/test/java/com/baeldung/repository/DSLQueryLiveTest.java

@@ -0,0 +1,115 @@
+package com.baeldung.repository;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.util.List;
+
+import com.baeldung.config.MongoConfig;
+import com.baeldung.model.QUser;
+import com.baeldung.model.User;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import com.querydsl.core.types.Predicate;
+
+
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = MongoConfig.class)
+public class DSLQueryLiveTest extends BaseQueryLiveTest {
+
+    @Test
+    public void givenUsersExist_whenFindingUsersByName_thenUserAreFound() {
+        User user = new User();
+        user.setName("Eric");
+        user.setAge(45);
+        mongoOps.insert(user);
+        user = new User();
+        user.setName("Antony");
+        user.setAge(55);
+        mongoOps.insert(user);
+
+        QUser qUser = new QUser("user");
+
+        Predicate predicate = qUser.name.eq("Eric");
+        List<User> users = (List<User>) userRepository.findAll(predicate);
+
+        assertThat(users.size(), is(1));
+    }
+
+    @Test
+    public void givenUsersExist_whenFindingUsersWithAgeCreaterThanAndLessThan_thenUsersAreFound() {
+        User user = new User();
+        user.setAge(20);
+        user.setName("Jon");
+        mongoOps.insert(user);
+
+        user = new User();
+        user.setAge(50);
+        user.setName("Jon");
+        mongoOps.insert(user);
+
+        user = new User();
+        user.setAge(33);
+        user.setName("Jim");
+        mongoOps.insert(user);
+
+        QUser qUser = new QUser("user");
+
+        Predicate predicate = qUser.age.between(26, 40);
+        List<User> users = (List<User>) userRepository.findAll(predicate);
+
+        assertThat(users.size(), is(1));
+    }
+
+    @Test
+    public void givenUsersExist_whenFindingUserWithNameStartWithA_thenUsersAreFound() {
+        User user = new User();
+        user.setName("Eric");
+        user.setAge(45);
+        mongoOps.insert(user);
+
+        user = new User();
+        user.setName("Antony");
+        user.setAge(33);
+        mongoOps.insert(user);
+
+        user = new User();
+        user.setName("Alice");
+        user.setAge(35);
+        mongoOps.insert(user);
+
+        QUser qUser = new QUser("user");
+
+        Predicate predicate = qUser.name.startsWith("A");
+        List<User> users = (List<User>) userRepository.findAll(predicate);
+        assertThat(users.size(), is(2));
+    }
+
+    @Test
+    public void givenUsersExist_whenFindingUserWithNameEndWithC_thenUsersAreFound() {
+        User user = new User();
+        user.setName("Eric");
+        user.setAge(45);
+        mongoOps.insert(user);
+
+        user = new User();
+        user.setName("Antony");
+        user.setAge(33);
+        mongoOps.insert(user);
+
+        user = new User();
+        user.setName("Alice");
+        user.setAge(35);
+        mongoOps.insert(user);
+
+        QUser qUser = new QUser("user");
+        Predicate predicate = qUser.name.endsWith("c");
+        List<User> users = (List<User>) userRepository.findAll(predicate);
+
+        assertThat(users.size(), is(1));
+    }
+}

persistence-modules/spring-data-mongodb/src/test/java/com/baeldung/repository/JSONQueryLiveTest.java

@@ -0,0 +1,98 @@
+package com.baeldung.repository;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.util.List;
+
+import com.baeldung.config.MongoConfig;
+import com.baeldung.model.User;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = MongoConfig.class)
+public class JSONQueryLiveTest extends BaseQueryLiveTest {
+
+    @Test
+    public void givenUsersExist_whenFindingUsersByName_thenUsersAreFound() {
+        User user = new User();
+        user.setName("Eric");
+        user.setAge(45);
+        mongoOps.insert(user);
+        user = new User();
+        user.setName("Antony");
+        user.setAge(55);
+        mongoOps.insert(user);
+
+        List<User> users = userRepository.findUsersByName("Eric");
+        assertThat(users.size(), is(1));
+    }
+
+    @Test
+    public void givenUsersExist_whenFindingUsersWithAgeCreaterThanAndLessThan_thenUsersAreFound() {
+        User user = new User();
+        user.setAge(20);
+        user.setName("Jon");
+        mongoOps.insert(user);
+
+        user = new User();
+        user.setAge(50);
+        user.setName("Jon");
+        mongoOps.insert(user);
+
+        user = new User();
+        user.setAge(33);
+        user.setName("Jim");
+        mongoOps.insert(user);
+
+        List<User> users = userRepository.findUsersByAgeBetween(26, 40);
+        assertThat(users.size(), is(1));
+    }
+
+    @Test
+    public void givenUsersExist_whenFindingUserWithNameStartWithA_thenUsersAreFound() {
+        User user = new User();
+        user.setName("Eric");
+        user.setAge(45);
+        mongoOps.insert(user);
+
+        user = new User();
+        user.setName("Antony");
+        user.setAge(33);
+        mongoOps.insert(user);
+
+        user = new User();
+        user.setName("Alice");
+        user.setAge(35);
+        mongoOps.insert(user);
+
+        List<User> users = userRepository.findUsersByRegexpName("^A");
+
+        assertThat(users.size(), is(2));
+    }
+
+    @Test
+    public void givenUsersExist_whenFindingUserWithNameEndWithC_thenUsersAreFound() {
+        User user = new User();
+        user.setName("Eric");
+        user.setAge(45);
+        mongoOps.insert(user);
+
+        user = new User();
+        user.setName("Antony");
+        user.setAge(33);
+        mongoOps.insert(user);
+
+        user = new User();
+        user.setName("Alice");
+        user.setAge(35);
+        mongoOps.insert(user);
+
+        List<User> users = userRepository.findUsersByRegexpName("c$");
+
+        assertThat(users.size(), is(1));
+    }
+}

persistence-modules/spring-data-mongodb/src/test/java/com/baeldung/repository/QueryMethodsLiveTest.java

@@ -0,0 +1,119 @@
+package com.baeldung.repository;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.util.List;
+
+import com.baeldung.config.MongoConfig;
+import com.baeldung.model.User;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = MongoConfig.class)
+public class QueryMethodsLiveTest extends BaseQueryLiveTest {
+
+    @Test
+    public void givenUsersExist_whenFindingUsersByName_thenUsersAreFound() {
+        User user = new User();
+        user.setName("Eric");
+        user.setAge(45);
+        mongoOps.insert(user);
+        user = new User();
+        user.setName("Antony");
+        user.setAge(55);
+        mongoOps.insert(user);
+
+        List<User> users = userRepository.findByName("Eric");
+        assertThat(users.size(), is(1));
+    }
+
+    @Test
+    public void givenUsersExist_whenFindingUsersWithAgeCreaterThanAndLessThan_thenUsersAreFound() {
+        User user = new User();
+        user.setAge(20);
+        user.setName("Jon");
+        mongoOps.insert(user);
+
+        user = new User();
+        user.setAge(50);
+        user.setName("Jon");
+        mongoOps.insert(user);
+
+        user = new User();
+        user.setAge(33);
+        user.setName("Jim");
+        mongoOps.insert(user);
+
+        List<User> users = userRepository.findByAgeBetween(26, 40);
+        assertThat(users.size(), is(1));
+    }
+
+    @Test
+    public void givenUsersExist_whenFindingUserWithNameStartWithA_thenUsersAreFound() {
+        User user = new User();
+        user.setName("Eric");
+        user.setAge(45);
+        mongoOps.insert(user);
+
+        user = new User();
+        user.setName("Antony");
+        user.setAge(33);
+        mongoOps.insert(user);
+
+        user = new User();
+        user.setName("Alice");
+        user.setAge(35);
+        mongoOps.insert(user);
+
+        List<User> users = userRepository.findByNameStartingWith("A");
+        assertThat(users.size(), is(2));
+    }
+
+    @Test
+    public void givenUsersExist_whenFindingUserWithNameEndWithC_thenUsersAreFound() {
+        User user = new User();
+        user.setName("Eric");
+        user.setAge(45);
+        mongoOps.insert(user);
+
+        user = new User();
+        user.setName("Antony");
+        user.setAge(33);
+        mongoOps.insert(user);
+
+        user = new User();
+        user.setName("Alice");
+        user.setAge(35);
+        mongoOps.insert(user);
+
+        List<User> users = userRepository.findByNameEndingWith("c");
+
+        assertThat(users.size(), is(1));
+    }
+
+    @Test
+    public void givenUsersExist_whenFindingUsersAndSortThem_thenUsersAreFoundAndSorted() {
+        User user = new User();
+        user.setName("Eric");
+        user.setAge(45);
+        mongoOps.insert(user);
+
+        user = new User();
+        user.setName("Antony");
+        user.setAge(33);
+        mongoOps.insert(user);
+
+        user = new User();
+        user.setName("Alice");
+        user.setAge(35);
+        mongoOps.insert(user);
+
+        List<User> users = userRepository.findByNameLikeOrderByAgeAsc("A");
+
+        assertThat(users.size(), is(2));
+    }
+}

persistence-modules/spring-data-mongodb/src/test/java/com/baeldung/repository/UserRepositoryLiveTest.java

@@ -0,0 +1,150 @@
+package com.baeldung.repository;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.util.List;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.mongodb.core.MongoOperations;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import com.baeldung.config.MongoConfig;
+import com.baeldung.model.User;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = MongoConfig.class)
+public class UserRepositoryLiveTest {
+
+    @Autowired
+    private UserRepository userRepository;
+
+    @Autowired
+    private MongoOperations mongoOps;
+
+    @Before
+    public void testSetup() {
+        if (!mongoOps.collectionExists(User.class)) {
+            mongoOps.createCollection(User.class);
+        }
+    }
+
+    @After
+    public void tearDown() {
+        mongoOps.dropCollection(User.class);
+    }
+
+    @Test
+    public void whenInsertingUser_thenUserIsInserted() {
+        final User user = new User();
+        user.setName("Jon");
+        userRepository.insert(user);
+
+        assertThat(mongoOps.findOne(Query.query(Criteria.where("name").is("Jon")), User.class).getName(), is("Jon"));
+    }
+
+    @Test
+    public void whenSavingNewUser_thenUserIsInserted() {
+        final User user = new User();
+        user.setName("Albert");
+        userRepository.save(user);
+
+        assertThat(mongoOps.findOne(Query.query(Criteria.where("name").is("Albert")), User.class).getName(), is("Albert"));
+    }
+
+    @Test
+    public void givenUserExists_whenSavingExistUser_thenUserIsUpdated() {
+        User user = new User();
+        user.setName("Jack");
+        mongoOps.insert(user);
+
+        user = mongoOps.findOne(Query.query(Criteria.where("name").is("Jack")), User.class);
+
+        user.setName("Jim");
+        userRepository.save(user);
+        assertThat(mongoOps.findAll(User.class).size(), is(1));
+    }
+
+    @Test
+    public void givenUserExists_whenDeletingUser_thenUserIsDeleted() {
+        final User user = new User();
+        user.setName("Benn");
+        mongoOps.insert(user);
+
+        userRepository.delete(user);
+
+        assertThat(mongoOps.find(Query.query(Criteria.where("name").is("Benn")), User.class).size(), is(0));
+    }
+
+    @Test
+    public void givenUserExists_whenFindingUser_thenUserIsFound() {
+        User user = new User();
+        user.setName("Chris");
+        mongoOps.insert(user);
+
+        user = mongoOps.findOne(Query.query(Criteria.where("name").is("Chris")), User.class);
+        final User foundUser = userRepository.findById(user.getId()).get();
+
+        assertThat(user.getName(), is(foundUser.getName()));
+    }
+
+    @Test
+    public void givenUserExists_whenCheckingDoesUserExist_thenUserIsExist() {
+        User user = new User();
+        user.setName("Harris");
+        mongoOps.insert(user);
+
+        user = mongoOps.findOne(Query.query(Criteria.where("name").is("Harris")), User.class);
+        final boolean isExists = userRepository.existsById(user.getId());
+
+        assertThat(isExists, is(true));
+    }
+
+    @Test
+    public void givenUsersExist_whenFindingAllUsersWithSorting_thenUsersAreFoundAndSorted() {
+        User user = new User();
+        user.setName("Brendan");
+        mongoOps.insert(user);
+
+        user = new User();
+        user.setName("Adam");
+        mongoOps.insert(user);
+
+        final List<User> users = userRepository.findAll(new Sort(Sort.Direction.ASC, "name"));
+
+        assertThat(users.size(), is(2));
+        assertThat(users.get(0).getName(), is("Adam"));
+        assertThat(users.get(1).getName(), is("Brendan"));
+    }
+
+    @Test
+    public void givenUsersExist_whenFindingAllUsersWithPagination_thenUsersAreFoundAndOrderedOnPage() {
+        User user = new User();
+        user.setName("Brendan");
+        mongoOps.insert(user);
+
+        user = new User();
+        user.setName("Adam");
+        mongoOps.insert(user);
+
+        final Pageable pageableRequest = PageRequest.of(0, 1);
+
+        final Page<User> page = userRepository.findAll(pageableRequest);
+        List<User> users = page.getContent();
+
+        assertThat(users.size(), is(1));
+        assertThat(page.getTotalPages(), is(2));
+    }
+
+}

persistence-modules/spring-data-mongodb/src/test/java/com/baeldung/repository/UserRepositoryProjectionLiveTest.java

@@ -0,0 +1,62 @@
+package com.baeldung.repository;
+
+import static org.junit.Assert.*;
+
+import com.baeldung.config.MongoConfig;
+import com.baeldung.model.User;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.mongodb.core.MongoOperations;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = MongoConfig.class)
+public class UserRepositoryProjectionLiveTest {
+
+    @Autowired
+    private UserRepository userRepository;
+
+    @Autowired
+    private MongoOperations mongoOps;
+
+    @Before
+    public void testSetup() {
+        if (!mongoOps.collectionExists(User.class)) {
+            mongoOps.createCollection(User.class);
+        }
+    }
+
+    @After
+    public void tearDown() {
+        mongoOps.dropCollection(User.class);
+    }
+
+    @Test
+    public void givenUserExists_whenAgeZero_thenSuccess() {
+        mongoOps.insert(new User("John", 30));
+        mongoOps.insert(new User("Ringo", 35));
+
+        userRepository.findNameAndId()
+            .forEach(user -> {
+                assertNotNull(user.getName());
+                assertTrue(user.getAge().equals(0));
+            });
+    }
+
+    @Test
+    public void givenUserExists_whenIdNull_thenSuccess() {
+        mongoOps.insert(new User("John", 30));
+        mongoOps.insert(new User("Ringo", 35));
+
+        userRepository.findNameAndAgeExcludeId()
+            .forEach(user -> {
+                assertNull(user.getId());
+                assertNotNull(user.getAge());
+            });
+    }
+
+}

persistence-modules/spring-data-mongodb/src/test/java/com/baeldung/transaction/MongoTransactionReactiveIntegrationTest.java

@@ -0,0 +1,47 @@
+package com.baeldung.transaction;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.mongodb.core.ReactiveMongoOperations;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import com.baeldung.config.MongoReactiveConfig;
+import com.baeldung.model.User;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = MongoReactiveConfig.class)
+public class MongoTransactionReactiveIntegrationTest {
+
+    @Autowired
+    private ReactiveMongoOperations reactiveOps;
+
+    @Before
+    public void testSetup() {
+        if (!reactiveOps.collectionExists(User.class)
+            .block()) {
+            reactiveOps.createCollection(User.class);
+        }
+    }
+
+    @After
+    public void tearDown() {
+        System.out.println(reactiveOps.findAll(User.class)
+            .count()
+            .block());
+        reactiveOps.dropCollection(User.class);
+    }
+
+    @Test
+    public void whenPerformTransaction_thenSuccess() {
+        User user1 = new User("Jane", 23);
+        User user2 = new User("John", 34);
+        reactiveOps.inTransaction()
+            .execute(action -> action.insert(user1)
+                .then(action.insert(user2)));
+    }
+    
+}

persistence-modules/spring-data-mongodb/src/test/java/com/baeldung/transaction/MongoTransactionTemplateIntegrationTest.java

@@ -0,0 +1,68 @@
+package com.baeldung.transaction;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.util.List;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.mongodb.MongoTransactionManager;
+import org.springframework.data.mongodb.SessionSynchronization;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.transaction.TransactionStatus;
+import org.springframework.transaction.support.TransactionCallbackWithoutResult;
+import org.springframework.transaction.support.TransactionTemplate;
+
+import com.baeldung.config.MongoConfig;
+import com.baeldung.model.User;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = MongoConfig.class)
+public class MongoTransactionTemplateIntegrationTest {
+
+    @Autowired
+    private MongoTemplate mongoTemplate;
+    
+    @Autowired
+    private MongoTransactionManager mongoTransactionManager;
+
+    @Before
+    public void testSetup() {
+        if (!mongoTemplate.collectionExists(User.class)) {
+            mongoTemplate.createCollection(User.class);
+        }
+    }
+
+    @After
+    public void tearDown() {
+        mongoTemplate.dropCollection(User.class);
+    }
+
+    @Test
+    public void givenTransactionTemplate_whenPerformTransaction_thenSuccess() {
+        mongoTemplate.setSessionSynchronization(SessionSynchronization.ALWAYS);                                     
+        TransactionTemplate transactionTemplate = new TransactionTemplate(mongoTransactionManager);
+        transactionTemplate.execute(new TransactionCallbackWithoutResult() {
+            @Override
+            protected void doInTransactionWithoutResult(TransactionStatus status) {
+                mongoTemplate.insert(new User("Kim", 20));
+                mongoTemplate.insert(new User("Jack", 45));
+            };
+        });
+
+        Query query = new Query().addCriteria(Criteria.where("name")
+            .is("Jack"));
+        List<User> users = mongoTemplate.find(query, User.class);
+        
+        assertThat(users.size(), is(1));
+    }
+   
+}

persistence-modules/spring-data-mongodb/src/test/java/com/baeldung/transaction/MongoTransactionalIntegrationTest.java

@@ -0,0 +1,90 @@
+package com.baeldung.transaction;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
+
+import java.util.List;
+
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.MethodSorters;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.mongodb.MongoTransactionException;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.transaction.annotation.Transactional;
+
+import com.baeldung.config.MongoConfig;
+import com.baeldung.model.User;
+import com.baeldung.repository.UserRepository;
+import com.mongodb.MongoCommandException;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = MongoConfig.class)
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class MongoTransactionalIntegrationTest {
+
+    @Autowired
+    private MongoTemplate mongoTemplate;
+
+    @Autowired
+    private UserRepository userRepository;
+
+    @Test
+    @Transactional
+    public void whenPerformMongoTransaction_thenSuccess() {
+        userRepository.save(new User("John", 30));
+        userRepository.save(new User("Ringo", 35));
+        Query query = new Query().addCriteria(Criteria.where("name")
+            .is("John"));
+        List<User> users = mongoTemplate.find(query, User.class);
+
+        assertThat(users.size(), is(1));
+    }
+
+    @Test(expected = MongoTransactionException.class)
+    @Transactional
+    public void whenListCollectionDuringMongoTransaction_thenException() {
+        if (mongoTemplate.collectionExists(User.class)) {
+            mongoTemplate.save(new User("John", 30));
+            mongoTemplate.save(new User("Ringo", 35));
+        }
+    }
+
+    @Test(expected = MongoCommandException.class)
+    @Transactional
+    public void whenCountDuringMongoTransaction_thenException() {
+        userRepository.save(new User("John", 30));
+        userRepository.save(new User("Ringo", 35));
+        userRepository.count();
+    }
+
+    @Test
+    @Transactional
+    public void whenQueryDuringMongoTransaction_thenSuccess() {
+        userRepository.save(new User("Jane", 20));
+        userRepository.save(new User("Nick", 33));
+        List<User> users = mongoTemplate.find(new Query(), User.class);
+
+        assertTrue(users.size() > 1);
+    }
+
+    // ==== Using test instead of before and after due to @transactional doesn't allow list collection
+
+    @Test
+    public void setup() {
+        if (!mongoTemplate.collectionExists(User.class)) {
+            mongoTemplate.createCollection(User.class);
+        }
+    }
+
+    @Test
+    public void ztearDown() {
+        mongoTemplate.dropCollection(User.class);
+    }
+}

persistence-modules/spring-data-mongodb/src/test/java/org/baeldung/SpringContextIntegrationTest.java

@@ -0,0 +1,18 @@
+package org.baeldung;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import com.baeldung.config.MongoConfig;
+import com.baeldung.config.SimpleMongoConfig;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = { MongoConfig.class, SimpleMongoConfig.class })
+public class SpringContextIntegrationTest {
+
+    @Test
+    public void whenSpringContextIsBootstrapped_thenNoExceptions() {
+    }
+}