How to test a MongoDb DAO class. Mocking?

[Geane Norm]

Hi,
I have a simple MongoDB DAO class for implementing basic CRUD operations (e.g. connection to the running instance and database, etc), but I am struggling to understand how to test it. Are mocks (Mockito) recommended? Can you provide an example of how they can be used?

Thank you for your help,

I.

[Junilu Lacar]

How do you think mocks are going to help you?

Mock objects are used as "stand-ins" for the real things so that you can test something that interacts with them. The mocks are merely there to simulate the behavior of the more unwieldy things they stand in for. In the case of DAOs, the thing you are testing is usually the class that uses the DAO. A DAO is normally an interface, which makes it easier to mock out.

public interface TwitterFeedDao {
   // ... methods to access Twitter feed
}

public class RealTwitterFeed implements TwitterFeedDao {
   // ... implementation that actually hits Twitter
}

public class FakeTwitterFeed implements TwitterFeedDao {
   // ... implementation that simulates what RealTwitterFeed does
}

Those are just examples of how you might define classes based on a DAO interface.

This is an example of how you might unit test a class that uses TwitterFeedDao:

@Mock TwitterFeedDao mockTwitterFeedDao;  // Mockito mock object

// This is what is being unit tested
TwitterAnalyzer testSubject = new TwitterAnalyzer();

// hook up the mock object so we don't have to hit the real thing
testSubject.setTwitterFeedDao(mockTwitterFeedDao);

// tell the mock how to simulate the behavior of the DAO. You define the 
// method simulatedResults() to return a string that represents a realistic response value.
when(mockTwitterFeedDao.fetchTweetsAbout("#DAOtesting")).thenReturn(simulatedResults());

// exercise the method being tested. Internally, recentMentionsCount() calls
// the DAO.fetchTweetsAbout(), then analyzes the string it gets back to see
// how many tweets are within a specific "recent" period of time 
int count = testSubject.recentMentionsCount("#DAOtesting"); 

// say what you are expecting: here we're expecting that the
// class under test (TwitterAnalyzer) correctly counts more 
// than 50 recent tweets based on its evaluation of the string
// returned by simulatedResults(), which it got from the 
// the mock DAO implementation
assertThat(count, is(gt(50)));

If you are going to unit test a MongoDBDao, then you'd have to mock out the connection and anything else that represents MongoDB functionality. I wouldn't bother with that though. My approach with DAOs is to use integration tests with them. Spring has many wonderful features to help write integration tests. Google for "integration testing with Spring and MongoDB".

See also: http://docs.mockito.googlecode.com/hg/1.9.5/org/mockito/InjectMocks.html

[Raymond Tong]

Would this one helps you ? https://github.com/fakemongo/fongo