MongoDB – Mock and Unit Test MongoCollection

admin — Thu, 11 Aug 2022 14:44:00 +0000

MongoDB – Mock and Unit Test MongoCollection

Today in this short tutorial, we will see how to Mock and Unit Test MongoCollection and IMongoCollection used in the MongoDB .NET driver library.

MongoCollection mocking could be useful considering the complex extension method supported by MongoDB drivers which is not only difficult to mock but also unit tested.

Below is a sample code for the Mocking MongoCollection class

        var settings = new MongoCollectionSettings();
            var mockCollection = new Mock> { DefaultValue = DefaultValue.Mock };
            mockCollection.SetupGet(s => s.DocumentSerializer).Returns(settings.SerializerRegistry.GetSerializer());
            mockCollection.SetupGet(s => s.Settings).Returns(settings);
            return mockCollection;

Above the “Book” class is a model object supporting book schema within the MongoDB database.

public class Book
    {
        [BsonId]
        [BsonRepresentation(BsonType.ObjectId)]
        public string Id { get; set; }

        public string BookName { get; set; }

        public decimal Price { get; set; }

        public string Category { get; set; }

        public string Author { get; set; }
    }

Below is a sample example using the above mock scenario,

       [Fact]
        public async void Test_GetBooksAsync_Verify()
        {
            //Arrange
            var mockContext = new Mock<IMongoContext>();
            var mockCollection = CreateMockCollection();
            var collection = mockCollection.Object;

            Book document = new Book();
            document.Author = "asdas";
            document.BookName = "sadasd";
            document.Id = ObjectId.GenerateNewId().ToString();
            mockCollection.Object.InsertOne(document);

            BookstoreDatabaseSettings setting = new BookstoreDatabaseSettings();
            setting.BooksCollectionName = "Book";
            var mockIDBsettings = new Mock<IOptions<BookstoreDatabaseSettings>>();

            mockContext.Setup(x => x.GetCollection<Book>("Book")).Returns(mockCollection.Object);
            mockIDBsettings.Setup(x => x.Value).Returns(setting);

            //Act

            BookService service = new BookService(mockIDBsettings.Object, mockContext.Object);
            var result = await service.GetBooksAsync();

            //ASSERT
            mockContext.Verify(x => x.GetCollection<Book>("Book"), Times.Once);
            mockCollection.Verify(m => m.FindAsync<Book>(FilterDefinition<Book>.Empty, null, CancellationToken.None), Times.Once);
        }

Above extension, methods are Asserted for verifying, if they are called in the code execution or not. Additionally, you can add more assertions for the results you get from the method. Please visit this article for more information on how to verify controller methods

Do you have any comments or ideas or any better suggestions to share?

Please sound off your comments below.

Happy Coding !!

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post MongoDB – Mock and Unit Test MongoCollection first appeared on TheCodeBuzz.

Unit Test and Mock MongoDB extension Method in ASP.NET Core

admin — Fri, 01 Jan 2021 00:00:00 +0000

Unit Testing and Mocking MongoDB Extension Method in ASP.NET Core – Part1

In this post, we will see howto Unit Test and Mock MongoDB extension method. Look at how to mock complex Synchronous or Asynchronous extension methods in MongoDB.

We will see the approach to unit test InsertOneAsync or UpdateOne or UpdateMany or UpdateManyAsync.

Today in this article, we will cover below aspects,

Unit Test 1
Unit Test 2

In this post, we will look at the Create/Insert operation where we perform the insertion of new records into the database.

Please see below the sample code for which we shall write unit testing.

   


public async Task Create(TEntity obj)
        {
            if(obj == null)
            {
                throw new ArgumentNullException(typeof(TEntity).Name + " object is null");
            }
            _dbCollection = _mongoContext.GetCollection(typeof(TEntity).Name);

            await _dbCollection.InsertOneAsync(obj);
        }

We shall be using the same naming conventions for unit testing that we learned in our last article,

How to Name Unit Test Cases – Best Practices

Below is an example of how we can mock and write unit testing

Unit Test 1

As shown above, the target method is Asynchronous. We shall write a method with the ‘await’ keyword in our Unit test case.

        
        [Fact]
        public async void BookRepository_CreateNewBook_Valid_Success()
        {
            //Arrange
            _mockCollection.Setup(op=> op.InsertOneAsync(_book, null,
            default(CancellationToken))).Returns(Task.CompletedTask);

            _mockContext.Setup(c => c.GetCollection 
    (typeof(Book).Name)).Returns(_mockCollection.Object);
            var bookRepo = new BookRepository(_mockContext.Object);

            //Act
            await bookRepo.Create(_book);

            //Assert 

            //Verify if InsertOneAsync is called once 
            _mockCollection.Verify(c => c.InsertOneAsync(_book, null, default(CancellationToken)), Times.Once);
        }

Unit Test 2

We shall write a test for capturing the specific exception. Here we are raising ‘ArgumentNullException’ in the target method.

       
        [Fact]
        public async void BookRepository_CreateNewBook_Null_Book_Failure()
        {
             // Arrange
            _book = null;

            //Act 
            var bookRepo = new BookRepository(_mockContext.Object);

            // Assert
            await Assert.ThrowsAsync<ArgumentNullException>(() => bookRepo.Create(_book));
        }

Sometimes framework-dependent extension methods are really difficult to test. In such scenarios, we should only test for its execution once or twice, etc. rather than actual results.

We can very much make use of the Assertion method like ‘Verify’ to validate the same.

Using the above similar approach you can unit test other extension methods like UpdateOne or UpdateMany or UpdateManyAsync.

Mocking IAsyncCursor: MongoDB Mock and Unit Test a method returning IAsyncCursor

Do you have any better suggestions to test the method with AsyncCursor?

Please sound off your comments below!

References :

Getting Started MongoDB in .NET Core with Examples

MongoDB Repository implementation in .NET Core with example

The post Unit Test and Mock MongoDB extension Method in ASP.NET Core first appeared on TheCodeBuzz.

how to mock mongodb repository c# - TheCodeBuzz

MongoDB – Mock and Unit Test MongoCollection

MongoDB – Mock and Unit Test MongoCollection

Unit Test and Mock MongoDB extension Method in ASP.NET Core

Unit Testing and Mocking MongoDB Extension Method in ASP.NET Core – Part1

Unit Test 1

Unit Test 2