MongoDB Java Server

Fake implementation of the core MongoDB server in Java that can be used for integration tests.

Think of H2/HSQLDB/SQLite but for MongoDB.

The MongoDB Wire Protocol is implemented with Netty. Different backends are possible and can be extended.

In-Memory backend

The in-memory backend is the default backend that is typically used to fake MongoDB for integration tests. It supports most CRUD operations, commands and the aggregation framework. Some features are not yet implemented, such as transactions, full-text search or map/reduce.

Add the following Maven dependency to your project:

<dependency>
<groupId>de.bwaldvogel</groupId>
<artifactId>mongo-java-server</artifactId>
<version>1.47.0</version>
</dependency>

Example

classSimpleTest {
privateMongoCollection<Document> collection;
privateMongoClientclient;
privateMongoServerserver;
@BeforeEachvoidsetUp() {
server = newMongoServer(newMemoryBackend());
// optionally:// server.enableSsl(key, keyPassword, certificate);// server.enableOplog();// bind on a random local portStringconnectionString = server.bindAndGetConnectionString();
client = MongoClients.create(connectionString);
collection = client.getDatabase("testdb").getCollection("testcollection");
}
@AfterEachvoidtearDown() {
client.close();
server.shutdown();
}
@TestvoidtestSimpleInsertQuery() throwsException {
assertThat(collection.countDocuments()).isZero();
// creates the database and collection in memory and insert the objectDocumentobj = newDocument("_id", 1).append("key", "value");
collection.insertOne(obj);
assertThat(collection.countDocuments()).isEqualTo(1L);
assertThat(collection.find().first()).isEqualTo(obj);
}
}

Example with SpringBoot

@RunWith(SpringRunner.class)
@SpringBootTest(classes={SimpleSpringBootTest.TestConfiguration.class})
publicclassSimpleSpringBootTest {
@AutowiredprivateMyRepositoryrepository;
@BeforepublicvoidsetUp() {
// initialize your repository with some test datarepository.deleteAll();
repository.save(...);
}
@TestpublicvoidtestMyRepository() {
// test your repository ...
...
}
@Configuration@EnableMongoTestServer@EnableMongoRepositories(basePackageClasses={MyRepository.class})
protectedstaticclassTestConfiguration {
// test bean definitions ...
...
}
}
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Import(MongoTestServerConfiguration.class)
public @interface EnableMongoTestServer {
}
publicclassMongoTestServerConfiguration {
@BeanpublicMongoTemplatemongoTemplate(MongoDatabaseFactorymongoDbFactory) {
returnnewMongoTemplate(mongoDbFactory);
}
@BeanpublicMongoDatabaseFactorymongoDbFactory(MongoServermongoServer) {
StringconnectionString = mongoServer.getConnectionString();
returnnewSimpleMongoClientDatabaseFactory(connectionString + "/test");
}
@Bean(destroyMethod = "shutdown")
publicMongoServermongoServer() {
MongoServermongoServer = newMongoServer(newMemoryBackend());
mongoServer.bind();
returnmongoServer;
}
}

H2 MVStore backend

The H2 MVStore backend connects the server to a MVStore that can either be in-memory or on-disk.

<dependency>
<groupId>de.bwaldvogel</groupId>
<artifactId>mongo-java-server-h2-backend</artifactId>
<version>1.47.0</version>
</dependency>

Example

publicclassApplication {
publicstaticvoidmain(String[] args) throwsException {
MongoServerserver = newMongoServer(newH2Backend("database.mv"));
server.bind("localhost", 27017);
}
}

PostgreSQL backend

The PostgreSQL backend is a proof-of-concept implementation that connects the server to a database in a running PostgreSQL 9.5+ instance. Each MongoDB database is mapped to a schema in Postgres and each MongoDB collection is stored as a table.

<dependency>
<groupId>de.bwaldvogel</groupId>
<artifactId>mongo-java-server-postgresql-backend</artifactId>
<version>1.47.0</version>
</dependency>

Example

publicclassApplication {
publicstaticvoidmain(String[] args) throwsException {
DataSourcedataSource = neworg.postgresql.jdbc3.Jdbc3PoolingDataSource();
dataSource.setDatabaseName(…);
dataSource.setUser(…);
dataSource.setPassword(…);
MongoServerserver = newMongoServer(newPostgresqlBackend(dataSource));
server.bind("localhost", 27017);
}
}

Building a "fat" JAR that contains all dependencies

If you want to build a version that is not on Maven Central you can do the following:

1. Build a "fat" JAR that includes all dependencies using "./gradlew shadowJar"
2. Copy build/libs/mongo-java-server-[version]-all.jar to your project, e.g. to the libs directory.
3. Import that folder (e.g. via Gradle using testCompile fileTree(dir: 'libs', include: '*.jar'))

Contributing

Please read the contributing guidelines if you want to contribute code to the project.

If you want to thank the author for this library or want to support the maintenance work, we are happy to receive a donation.

Ideas for other backends

Faulty backend

A faulty backend could randomly fail queries or cause timeouts. This could be used to test the client for error resilience.

Fuzzy backend

Fuzzing the wire protocol could be used to check the robustness of client drivers.

Transactions

Please note that transactions are currently not supported. Please see the discussion in issue #143.

When using mongo-java-server for integration tests, you can use Testcontainers or Embedded MongoDB instead to spin-up a real MongoDB that will have full transaction support.

Related Work

• Testcontainers

  • Can be used to spin-up a real MongoDB instance in a Docker container

• Embedded MongoDB

  • Spins up a real MongoDB instance

• fongo

  • focus on unit testing
  • no wire protocol implementation
  • intercepts the java mongo driver
  • currently used in nosql-unit