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

2018-10-20 11:27:08 +05:30
parent 2404312d20
commit 21a3a43788
360 changed files with 1153 additions and 1148 deletions
@@ -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"));
+    }
+
+}
@@ -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();
+    }
+
+}
@@ -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"));
+    }
+}
@@ -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"));
+    }
+}
@@ -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());
+          });
+
+    }
+
+}
@@ -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()));
+    }
+}
@@ -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);
+    }
+}
@@ -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));
+    }
+}
@@ -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));
+    }
+}
@@ -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));
+    }
+}
@@ -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));
+    }
+
+}
@@ -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());
+            });
+    }
+
+}
@@ -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)));
+    }
+    
+}
@@ -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));
+    }
+   
+}
@@ -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);
+    }
+}
@@ -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() {
+    }
+}