NoSQLUnit

First step is defining which lifecycle management strategy is required for your tests. Depending on kind of test you are implementing (unit test, integration test, deployment test, ...) you will require an in-memory approach, managed approach or remote approach.

To configure in-memory approach you should only instantiate next rule :

@ClassRule
InMemoryMongoDb inMemoryMongoDb = new InMemoryMongoDb();

To configure the managed way, you should use ManagedMongoDb rule and may require some configuration parameters.

import static com.lordofthejars.nosqlunit.mongodb.ManagedMongoDb.MongoServerRuleBuilder.newManagedMongoDbRule;

@ClassRule
public static ManagedMongoDb managedMongoDb = newManagedMongoDbRule().build();

By default managed MongoDb rule uses next default values:

ManagedMongoDb can be created from scratch, but for making life easier, a DSL is provided using MongoServerRuleBuilder class. For example :

import static com.lordofthejars.nosqlunit.mongodb.ManagedMongoDb.MongoServerRuleBuilder.newManagedMongoDbRule;

@ClassRule
public static ManagedMongoDb managedMongoDb =
newManagedMongoDbRule().mongodPath("/opt/mongo").appendSingleCommandLineArguments("-vvv").build();

In example we are overriding MONGO_HOME variable (in case has been set) and set mongo home at /opt/mongo . Moreover we are appending a single argument to MongoDb executable, in this case setting log level to number 3 (-vvv). Also you can append property=value arguments using appendCommandLineArguments(String argumentName, String argumentValue) method.

To stop MongoDb instance, NoSQLUnit sends a shutdown command to server using Java Mongo AP I. When this command is sent, the server is stopped and because connection is lost, Java Mongo API logs automatically an exception (read here information about the problem and how to "resolve" it). Do not confuse with a testing failure. You will see something like:

java.io.EOFException
	at org.bson.io.Bits.readFully(Bits.java:37)
	at org.bson.io.Bits.readFully(Bits.java:28)
	at com.mongodb.Response.<init>;(Response.java:39)
	at com.mongodb.DBPort.go(DBPort.java:128)
	at com.mongodb.DBPort.call(DBPort.java:79)
	at com.mongodb.DBTCPConnector.call(DBTCPConnector.java:218)
	at com.mongodb.DBApiLayer$MyCollection.__find(DBApiLayer.java:305)
	at com.mongodb.DB.command(DB.java:160)
	at com.mongodb.DB.command(DB.java:183)
	at com.mongodb.DB.command(DB.java:144)
	at
	com.lordofthejars.nosqlunit.mongodb.MongoDbLowLevelOps.shutdown(MongoDbLowLevelOps.java:44)
	at
	com.lordofthejars.nosqlunit.mongodb.ManagedMongoDb.after(ManagedMongoDb.java:157)
	at
	org.junit.rules.ExternalResource$1.evaluate(ExternalResource.java:48)
	at org.junit.rules.RunRules.evaluate(RunRules.java:18)
	at org.junit.runners.ParentRunner.run(ParentRunner.java:300)
	at
	org.apache.maven.surefire.junit4.JUnit4Provider.execute(JUnit4Provider.java:236)
	at
	org.apache.maven.surefire.junit4.JUnit4Provider.executeTestSet(JUnit4Provider.java:134)
	at
	org.apache.maven.surefire.junit4.JUnit4Provider.invoke(JUnit4Provider.java:113)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at
	sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)
	at
	sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.lang.reflect.Method.invoke(Method.java:616)
	at
	org.apache.maven.surefire.util.ReflectionUtils.invokeMethodWithArray(ReflectionUtils.java:189)
	at
	org.apache.maven.surefire.booter.ProviderFactory$ProviderProxy.invoke(ProviderFactory.java:165)
	at
	org.apache.maven.surefire.booter.ProviderFactory.invokeProvider(ProviderFactory.java:85)
	at
	org.apache.maven.surefire.booter.ForkedBooter.runSuitesInProcess(ForkedBooter.java:103)
	at
	org.apache.maven.surefire.booter.ForkedBooter.main(ForkedBooter.java:74)

Configuring remote approach does not require any special rule because you (or System like Maven ) is the responsible of starting and stopping the server. This mode is used in deployment tests where you are testing your application on real environment.

Next step is configuring Mongodb rule in charge of maintaining MongoDb database into known state by inserting and deleting defined datasets. You must register MongoDbRule JUnit rule class, which requires a configuration parameter with information like host, port or database name.

To make developer's life easier and code more readable, a fluent interface can be used to create these configuration objects. Two different kind of configuration builders exist.

The first one is for configuring a connection to in-memory jmockmongo server. Default connection values are:

Notice that these values are the default ones of jmockmongo project, so if you are thinking to use jmockmongo , no modifications are required.

import static com.lordofthejars.nosqlunit.mongodb.InMemoryMongoDbConfigurationBuilder.inMemoryMongoDb;

@Rule
public MongoDbRule remoteMongoDbRule = new MongoDbRule(inMemoryMongoDb().databaseName("test").build());

The second one is for configuring a connection to remote MongoDb server. Default values are:

import static com.lordofthejars.nosqlunit.mongodb.MongoDbConfigurationBuilder.mongoDb;

@Rule
public MongoDbRule remoteMongoDbRule = new MongoDbRule(mongoDb().databaseName("test").build());

import static com.lordofthejars.nosqlunit.mongodb.MongoDbConfigurationBuilder.mongoDb;

@Rule
public MongoDbRule remoteMongoDbRule = new MongoDbRule(mongoDb().databaseName("test").host("my_remote_host").build());

Consider a library application, which apart from multiple operations, it allow us to add new books to system. Our model is as simple as:

public class Book {

	private String title;

	private int numberOfPages;

	public Book(String title, int numberOfPages) {
		super();
		this.title = title;
		this.numberOfPages = numberOfPages;
	}

	public void setTitle(String title) {
		this.title = title;
	}

	public void setNumberOfPages(int numberOfPages) {
		this.numberOfPages = numberOfPages;
	}


	public String getTitle() {
		return title;
	}

	public int getNumberOfPages() {
		return numberOfPages;
	}
}

Next business class is the responsible of managing access to MongoDb server:

public class BookManager {

	private static final Logger LOGGER = LoggerFactory.getLogger(BookManager.class);

	private static final MongoDbBookConverter MONGO_DB_BOOK_CONVERTER = new	MongoDbBookConverter();
	private static final DbObjectBookConverter DB_OBJECT_BOOK_CONVERTER = new DbObjectBookConverter();

			
	private DBCollection booksCollection;

	public BookManager(DBCollection booksCollection) {
		this.booksCollection = booksCollection;
	}

	public void create(Book book) {
		DBObject dbObject = MONGO_DB_BOOK_CONVERTER.convert(book);
		booksCollection.insert(dbObject);
	}
}

And now it is time for testing. In next test we are going to validate that a book is inserted correctly into database.

package com.lordofthejars.nosqlunit.demo.mongodb;

public class WhenANewBookIsCreated {

	@ClassRule
	public static ManagedMongoDb managedMongoDb = newManagedMongoDbRule().mongodPath("/opt/mongo").build();

	@Rule
	public MongoDbRule remoteMongoDbRule = new MongoDbRule(mongoDb().databaseName("test").build());

	@Test
	@UsingDataSet(locations="initialData.json", loadStrategy=LoadStrategyEnum.CLEAN_INSERT)
	@ShouldMatchDataSet(location="expectedData.json")
	public void book_should_be_inserted_into_repository() {

		BookManager bookManager = new BookManager(MongoDbUtil.getCollection(Book.class.getSimpleName()));

		Book book = new Book("The Lord Of The Rings", 1299);
		bookManager.create(book);
	}

}

In previous test we have defined that MongoDb will be managed by test by starting an instance of server located at /opt/mongo . Moreover we are setting an initial dataset in file initialData.json located at classpath com/lordofthejars/nosqlunit/demo/mongodb/initialData.json and expected dataset called expectedData.json .

{
	"Book":
	[
		{"title":"The Hobbit","numberOfPages":293}
	]
}

{
	"Book":
	[
		{"title":"The Hobbit","numberOfPages":293},
		{"title":"The Lord Of The Rings","numberOfPages":1299}
	]
}

You can watch full example at github .