Mongodian unit testing in .NET

Question

I am trying to make tdd and use mongodb as a database. But I can not solve the problem of mongodb bullying. Is it possible to mock mongodb for unit testing in .NET?

---

Update

I found a very good blog for reading soltion. You can find it here :

Answer 1

Instead of bullying MongoDB, you should make fun of the layer on top of MongoDB.

You might want to consider an interface that provides operations in your repository that are incompatible with the underlying data store. For example, you may need an interface that abstracts operations on Student types, for example:

 public interface IStudentOperations { void Add(Student student); } 

When you create other dependencies, you add instances of the above interface or select any higher level abstractions.

The fact is that you are not opening MongoDB directly.

Once you do this, you can scoff at the interfaces you create, having one implementation for testing against a mock implementation, and then the actual implementation with its own tests to verify that the operations on the implementation are correct when the main implementation is done using MongoDB.

While you can definitely mock most MongoDB classes (as virtual methods) , you benefit from persistence of persistence; if you want to switch to say CouchDB or elasticsearch, you do not need to change the calls to these interfaces, you just create a new implementation.

---

Since you are trying to test the implementation of the repository , then you are usually fine, as mentioned earlier, most of the features of MongoDB virtual , which is friendly to most mocking libraries.

However, you will need to make sure that you pass MongoDatabase to your repository (do not create it in the repository) so that in your unit tests you can create the appropriate layout and then transfer it to your repository for testing.

Answer 2

Have a look at this similar question: Mocking database in node.js?

In short, mocking MongoDB is the wrong approach. Mocking your repository is enough to test your own blocks, but you still need to test MongoDB if you want to make sure you use it correctly, or if you rely on unique constraints, etc.

Answer 3

You need a repository / DAL layer to hide implementation details. Something like that:

 public interface IDataContext<T> { // Query IList<T> GetAll<T>(); IList<T> GetByCriteria<T>(Query query); T GetByID<T>(string id); // CUD void Add(T item); void Delete(T item); void Save(T item); } 

• For production code, implement the interface using mongo db operations using the C # driver.
• For unit test codes, mock interface with in-memory collection

It seems like making fun of Add / Delete / Save, and the middle part is a query function. Fortunately, since the Mongo C # driver supports LINQ expressions, we can use LINQ as a query language, rather than reinvent the wheels.

For example, production code might look like this:

 // collection is a MongoCollection<T> object var items = collection.AsQueryable().Where(...linq expression...); 

And unit test code (if you go with the Shim test, MS):

 using (ShimsContext.Create()) { ShimLinqExtensionMethods.AsQueryableOf1MongoCollectionOfM0( (MongoCollection<T> x) => Fake_DB_Collection.AsQueryable()); // After this, the above "collection.AsQueryable()" will be mocked as // an in-memory collection, which can be any subclass of IEnumerable<T> }