diff --git a/spring-data-mongodb/pom.xml b/spring-data-mongodb/pom.xml index 332245adc8..bf72e70b25 100644 --- a/spring-data-mongodb/pom.xml +++ b/spring-data-mongodb/pom.xml @@ -8,9 +8,9 @@ com.baeldung - parent-spring-4 + parent-spring-5 0.0.1-SNAPSHOT - ../parent-spring-4 + ../parent-spring-5 @@ -19,6 +19,28 @@ spring-data-mongodb ${org.springframework.data.version} + + + org.springframework.data + spring-data-releasetrain + Lovelace-M3 + pom + import + + + + org.mongodb + mongodb-driver-reactivestreams + 1.9.2 + + + + io.projectreactor + reactor-test + 3.2.0.RELEASE + test + + org.springframework spring-core @@ -48,6 +70,17 @@ + + + spring-milestones + Spring Milestones + https://repo.spring.io/milestone + + false + + + + @@ -70,10 +103,11 @@ - 1.10.4.RELEASE - 2.9.0 + 2.1.0.RELEASE 4.1.4 1.1.3 + 5.1.0.RELEASE + diff --git a/spring-data-mongodb/src/main/java/com/baeldung/config/MongoConfig.java b/spring-data-mongodb/src/main/java/com/baeldung/config/MongoConfig.java index 551a9142a6..8221d299ed 100644 --- a/spring-data-mongodb/src/main/java/com/baeldung/config/MongoConfig.java +++ b/spring-data-mongodb/src/main/java/com/baeldung/config/MongoConfig.java @@ -1,20 +1,22 @@ package com.baeldung.config; -import com.mongodb.Mongo; -import com.mongodb.MongoClient; -import com.baeldung.converter.UserWriterConverter; -import com.baeldung.event.CascadeSaveMongoEventListener; -import com.baeldung.event.UserCascadeSaveMongoEventListener; +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.CustomConversions; import org.springframework.data.mongodb.gridfs.GridFsTemplate; import org.springframework.data.mongodb.repository.config.EnableMongoRepositories; -import java.util.ArrayList; -import java.util.List; +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") @@ -28,7 +30,7 @@ public class MongoConfig extends AbstractMongoConfiguration { } @Override - public Mongo mongo() throws Exception { + public MongoClient mongoClient() { return new MongoClient("127.0.0.1", 27017); } @@ -57,4 +59,10 @@ public class MongoConfig extends AbstractMongoConfiguration { public GridFsTemplate gridFsTemplate() throws Exception { return new GridFsTemplate(mongoDbFactory(), mappingMongoConverter()); } + + @Bean + MongoTransactionManager transactionManager(MongoDbFactory dbFactory) { + return new MongoTransactionManager(dbFactory); + } + } diff --git a/spring-data-mongodb/src/main/java/com/baeldung/config/MongoReactiveConfig.java b/spring-data-mongodb/src/main/java/com/baeldung/config/MongoReactiveConfig.java new file mode 100644 index 0000000000..b4042b5550 --- /dev/null +++ b/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"; + } +} diff --git a/spring-data-mongodb/src/main/java/com/baeldung/config/SimpleMongoConfig.java b/spring-data-mongodb/src/main/java/com/baeldung/config/SimpleMongoConfig.java index 95f192811f..c3ddad5a82 100644 --- a/spring-data-mongodb/src/main/java/com/baeldung/config/SimpleMongoConfig.java +++ b/spring-data-mongodb/src/main/java/com/baeldung/config/SimpleMongoConfig.java @@ -1,18 +1,18 @@ package com.baeldung.config; -import com.mongodb.Mongo; -import com.mongodb.MongoClient; 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 Mongo mongo() throws Exception { + public MongoClient mongo() throws Exception { return new MongoClient("localhost"); } diff --git a/spring-data-mongodb/src/main/java/com/baeldung/reactive/repository/UserRepository.java b/spring-data-mongodb/src/main/java/com/baeldung/reactive/repository/UserRepository.java new file mode 100644 index 0000000000..7e754aa680 --- /dev/null +++ b/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 { +} diff --git a/spring-data-mongodb/src/main/java/com/baeldung/repository/UserRepository.java b/spring-data-mongodb/src/main/java/com/baeldung/repository/UserRepository.java index e9dc0f5c95..4c69d7f9c6 100644 --- a/spring-data-mongodb/src/main/java/com/baeldung/repository/UserRepository.java +++ b/spring-data-mongodb/src/main/java/com/baeldung/repository/UserRepository.java @@ -1,13 +1,14 @@ package com.baeldung.repository; -import com.baeldung.model.User; -import org.springframework.data.mongodb.repository.MongoRepository; -import org.springframework.data.mongodb.repository.Query; -import org.springframework.data.querydsl.QueryDslPredicateExecutor; - import java.util.List; -public interface UserRepository extends MongoRepository, QueryDslPredicateExecutor { +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, QuerydslPredicateExecutor { @Query("{ 'name' : ?0 }") List findUsersByName(String name); diff --git a/spring-data-mongodb/src/main/resources/mongoConfig.xml b/spring-data-mongodb/src/main/resources/mongoConfig.xml index 2b32863fb6..324f7f60c2 100644 --- a/spring-data-mongodb/src/main/resources/mongoConfig.xml +++ b/spring-data-mongodb/src/main/resources/mongoConfig.xml @@ -3,17 +3,17 @@ 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-3.2.xsd + 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-1.0.xsd + http://www.springframework.org/schema/data/mongo/spring-mongo.xsd http://www.springframework.org/schema/context - http://www.springframework.org/schema/context/spring-context-3.2.xsd" + http://www.springframework.org/schema/context/spring-context.xsd" > - + - + @@ -27,12 +27,12 @@ - + - + - + diff --git a/spring-data-mongodb/src/test/java/com/baeldung/aggregation/ZipsAggregationLiveTest.java b/spring-data-mongodb/src/test/java/com/baeldung/aggregation/ZipsAggregationLiveTest.java index a4bea45fcf..bb54a5487f 100644 --- a/spring-data-mongodb/src/test/java/com/baeldung/aggregation/ZipsAggregationLiveTest.java +++ b/spring-data-mongodb/src/test/java/com/baeldung/aggregation/ZipsAggregationLiveTest.java @@ -1,12 +1,24 @@ package com.baeldung.aggregation; -import com.mongodb.DB; -import com.mongodb.DBCollection; -import com.mongodb.DBObject; -import com.mongodb.MongoClient; -import com.mongodb.util.JSON; -import com.baeldung.aggregation.model.StatePopulation; -import com.baeldung.config.MongoConfig; +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; @@ -26,23 +38,13 @@ import org.springframework.data.mongodb.core.query.Criteria; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; -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 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 com.baeldung.aggregation.model.StatePopulation; +import com.baeldung.config.MongoConfig; +import com.mongodb.DB; +import com.mongodb.DBCollection; +import com.mongodb.DBObject; +import com.mongodb.MongoClient; +import com.mongodb.util.JSON; @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(classes = MongoConfig.class) @@ -140,13 +142,13 @@ public class ZipsAggregationLiveTest { Aggregation aggregation = newAggregation(sumZips, sortByCount, groupFirstAndLast); - AggregationResults result = mongoTemplate.aggregate(aggregation, "zips", DBObject.class); - DBObject dbObject = result.getUniqueMappedResult(); + AggregationResults result = mongoTemplate.aggregate(aggregation, "zips", Document.class); + Document document = result.getUniqueMappedResult(); - assertEquals("DC", dbObject.get("minZipState")); - assertEquals(24, dbObject.get("minZipCount")); - assertEquals("TX", dbObject.get("maxZipState")); - assertEquals(1671, dbObject.get("maxZipCount")); + assertEquals("DC", document.get("minZipState")); + assertEquals(24, document.get("minZipCount")); + assertEquals("TX", document.get("maxZipState")); + assertEquals(1671, document.get("maxZipCount")); } } diff --git a/spring-data-mongodb/src/test/java/com/baeldung/gridfs/GridFSLiveTest.java b/spring-data-mongodb/src/test/java/com/baeldung/gridfs/GridFSLiveTest.java index 02485e8517..7befaf8fbd 100644 --- a/spring-data-mongodb/src/test/java/com/baeldung/gridfs/GridFSLiveTest.java +++ b/spring-data-mongodb/src/test/java/com/baeldung/gridfs/GridFSLiveTest.java @@ -1,8 +1,19 @@ package com.baeldung.gridfs; -import com.mongodb.BasicDBObject; -import com.mongodb.DBObject; -import com.mongodb.gridfs.GridFSDBFile; +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; @@ -16,18 +27,9 @@ import org.springframework.data.mongodb.gridfs.GridFsTemplate; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; -import java.io.FileInputStream; -import java.io.FileNotFoundException; -import java.io.IOException; -import java.io.InputStream; -import java.util.List; - -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.assertNull; -import static org.junit.Assert.assertThat; +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) @@ -40,8 +42,9 @@ public class GridFSLiveTest { @After public void tearDown() { - List fileList = gridFsTemplate.find(null); - for (GridFSDBFile file : fileList) { + List fileList = new ArrayList(); + gridFsTemplate.find(new Query()).into(fileList); + for (GridFSFile file : fileList) { gridFsTemplate.delete(new Query(Criteria.where("filename").is(file.getFilename()))); } } @@ -54,7 +57,7 @@ public class GridFSLiveTest { String id = ""; try { inputStream = new FileInputStream("src/main/resources/test.png"); - id = gridFsTemplate.store(inputStream, "test.png", "image/png", metaData).getId().toString(); + id = gridFsTemplate.store(inputStream, "test.png", "image/png", metaData).toString(); } catch (FileNotFoundException ex) { logger.error("File not found", ex); } finally { @@ -75,10 +78,10 @@ public class GridFSLiveTest { DBObject metaData = new BasicDBObject(); metaData.put("user", "alex"); InputStream inputStream = null; - String id = ""; + ObjectId id = null; try { inputStream = new FileInputStream("src/main/resources/test.png"); - id = gridFsTemplate.store(inputStream, "test.png", "image/png", metaData).getId().toString(); + id = gridFsTemplate.store(inputStream, "test.png", "image/png", metaData); } catch (FileNotFoundException ex) { logger.error("File not found", ex); } finally { @@ -91,22 +94,22 @@ public class GridFSLiveTest { } } - GridFSDBFile gridFSDBFile = gridFsTemplate.findOne(new Query(Criteria.where("_id").is(id))); + GridFSFile gridFSFile = gridFsTemplate.findOne(new Query(Criteria.where("_id").is(id))); - assertNotNull(gridFSDBFile); - assertNotNull(gridFSDBFile.getInputStream()); - assertThat(gridFSDBFile.numChunks(), is(1)); - assertThat(gridFSDBFile.containsField("filename"), is(true)); - assertThat(gridFSDBFile.get("filename"), is("test.png")); - assertThat(gridFSDBFile.getId(), is(id)); - assertThat(gridFSDBFile.keySet().size(), is(9)); - assertNotNull(gridFSDBFile.getMD5()); - assertNotNull(gridFSDBFile.getUploadDate()); - assertNull(gridFSDBFile.getAliases()); - assertNotNull(gridFSDBFile.getChunkSize()); - assertThat(gridFSDBFile.getContentType(), is("image/png")); - assertThat(gridFSDBFile.getFilename(), is("test.png")); - assertThat(gridFSDBFile.getMetaData().get("user"), is("alex")); + 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 @@ -133,10 +136,11 @@ public class GridFSLiveTest { } } - List gridFSDBFiles = gridFsTemplate.find(null); + List gridFSFiles = new ArrayList(); + gridFsTemplate.find(new Query()).into(gridFSFiles); - assertNotNull(gridFSDBFiles); - assertThat(gridFSDBFiles.size(), is(2)); + assertNotNull(gridFSFiles); + assertThat(gridFSFiles.size(), is(2)); } @Test @@ -163,10 +167,11 @@ public class GridFSLiveTest { } } - List gridFSDBFiles = gridFsTemplate.find(new Query(Criteria.where("metadata.user").is("alex"))); + List gridFSFiles = new ArrayList(); + gridFsTemplate.find(new Query(Criteria.where("metadata.user").is("alex"))).into(gridFSFiles); - assertNotNull(gridFSDBFiles); - assertThat(gridFSDBFiles.size(), is(1)); + assertNotNull(gridFSFiles); + assertThat(gridFSFiles.size(), is(1)); } @Test @@ -177,7 +182,7 @@ public class GridFSLiveTest { String id = ""; try { inputStream = new FileInputStream("src/main/resources/test.png"); - id = gridFsTemplate.store(inputStream, "test.png", "image/png", metaData).getId().toString(); + id = gridFsTemplate.store(inputStream, "test.png", "image/png", metaData).toString(); } catch (FileNotFoundException ex) { logger.error("File not found", ex); } finally { @@ -203,7 +208,7 @@ public class GridFSLiveTest { String id = ""; try { inputStream = new FileInputStream("src/main/resources/test.png"); - id = gridFsTemplate.store(inputStream, "test.png", "image/png", metaData).getId().toString(); + id = gridFsTemplate.store(inputStream, "test.png", "image/png", metaData).toString(); } catch (FileNotFoundException ex) { logger.error("File not found", ex); } finally { diff --git a/spring-data-mongodb/src/test/java/com/baeldung/repository/UserRepositoryLiveTest.java b/spring-data-mongodb/src/test/java/com/baeldung/repository/UserRepositoryLiveTest.java index da4e91baec..3daa58dd19 100644 --- a/spring-data-mongodb/src/test/java/com/baeldung/repository/UserRepositoryLiveTest.java +++ b/spring-data-mongodb/src/test/java/com/baeldung/repository/UserRepositoryLiveTest.java @@ -5,8 +5,6 @@ import static org.junit.Assert.assertThat; import java.util.List; -import com.baeldung.config.MongoConfig; -import com.baeldung.model.User; import org.junit.After; import org.junit.Before; import org.junit.Test; @@ -22,6 +20,9 @@ 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 { @@ -72,8 +73,7 @@ public class UserRepositoryLiveTest { user.setName("Jim"); userRepository.save(user); - - assertThat(mongoOps.findAll(User.class).size(), is(2)); + assertThat(mongoOps.findAll(User.class).size(), is(1)); } @Test @@ -94,7 +94,7 @@ public class UserRepositoryLiveTest { mongoOps.insert(user); user = mongoOps.findOne(Query.query(Criteria.where("name").is("Chris")), User.class); - final User foundUser = userRepository.findOne(user.getId()); + final User foundUser = userRepository.findById(user.getId()).get(); assertThat(user.getName(), is(foundUser.getName())); } @@ -106,7 +106,7 @@ public class UserRepositoryLiveTest { mongoOps.insert(user); user = mongoOps.findOne(Query.query(Criteria.where("name").is("Harris")), User.class); - final boolean isExists = userRepository.exists(user.getId()); + final boolean isExists = userRepository.existsById(user.getId()); assertThat(isExists, is(true)); } diff --git a/spring-data-mongodb/src/test/java/com/baeldung/transaction/MongoTransactionReactiveIntegrationTest.java b/spring-data-mongodb/src/test/java/com/baeldung/transaction/MongoTransactionReactiveIntegrationTest.java new file mode 100644 index 0000000000..43aa865e91 --- /dev/null +++ b/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))); + } + +} diff --git a/spring-data-mongodb/src/test/java/com/baeldung/transaction/MongoTransactionTemplateIntegrationTest.java b/spring-data-mongodb/src/test/java/com/baeldung/transaction/MongoTransactionTemplateIntegrationTest.java new file mode 100644 index 0000000000..1dbe724d87 --- /dev/null +++ b/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 users = mongoTemplate.find(query, User.class); + + assertThat(users.size(), is(1)); + } + +} diff --git a/spring-data-mongodb/src/test/java/com/baeldung/transaction/MongoTransactionalIntegrationTest.java b/spring-data-mongodb/src/test/java/com/baeldung/transaction/MongoTransactionalIntegrationTest.java new file mode 100644 index 0000000000..4d747789a0 --- /dev/null +++ b/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 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 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); + } +}