1️⃣ What is Mocking and Stubbing?

Mocking:

Mocking is a technique where you create a mock object that simulates the behavior of real dependencies in your system. A mock object can be configured to expect certain method calls and verify that the correct methods are called with the right parameters.

Purpose: Verify interaction (method calls, arguments).

Tools: Moq, NSubstitute, Rhino Mocks.

Stubbing:

Stubbing involves creating fake objects that return predefined responses when their methods are called. Stubs are mainly used for isolating the code under test by providing canned responses to method calls on external dependencies.

Purpose: Provide controlled responses for specific method calls.

Tools: Moq, NSubstitute, Microsoft Fakes (for .NET Framework).

2️⃣ Mocking and Stubbing in .NET Core with Moq

Moq is one of the most widely used mocking libraries in .NET Core. It allows you to easily create mock objects, set up method behaviors, and verify interactions.

Setting up Moq in .NET Core

To start using Moq in .NET Core, install the Moq NuGet package:

dotnet add package Moq

3️⃣ Mocking Example with Moq

Let’s consider a simple example where we have a service that depends on a repository. We want to unit test the UserService class, which interacts with the IUserRepository.

// IUserRepository.cs

public interface IUserRepository

{

Task<User> GetUserByIdAsync(int id);

Task<IEnumerable<User>> GetAllUsersAsync();

}

The UserService class that we want to test:

// UserService.cs

public class UserService

{

private readonly IUserRepository _userRepository;

public UserService(IUserRepository userRepository)

{

_userRepository = userRepository;

}

public async Task<User> GetUserAsync(int id)

{

return await _userRepository.GetUserByIdAsync(id);

}

public async Task<IEnumerable<User>> GetAllUsersAsync()

{

return await _userRepository.GetAllUsersAsync();

}

Unit Test using Moq (Mocking)

We’ll create a mock of the IUserRepository and use it to test the UserService without needing to call an actual database.

using Moq;

using Xunit;

public class UserServiceTests

{

[Fact]

public async Task GetUserAsync_ReturnsUser()

{

// Arrange

var mockUserRepo = new Mock<IUserRepository>();

var expectedUser = new User { Id = 1, Name = "John Doe" };

mockUserRepo.Setup(repo => repo.GetUserByIdAsync(1)).ReturnsAsync(expectedUser);

var userService = new UserService(mockUserRepo.Object);

// Act

var user = await userService.GetUserAsync(1);

// Assert

Assert.Equal("John Doe", user.Name);

mockUserRepo.Verify(repo => repo.GetUserByIdAsync(1), Times.Once);

}

Explanation:

Setup: mockUserRepo.Setup(...) configures the mock to return a specific value (expectedUser) when the GetUserByIdAsync(1) method is called.

Verify: mockUserRepo.Verify(...) checks that the GetUserByIdAsync method was called exactly once during the test.

In this example, Moq is used to mock the IUserRepository, allowing us to isolate the UserService class and focus only on testing its logic.

4️⃣ Stubbing with Moq

Stubbing in Moq is essentially setting up the behavior of methods in a mock object without worrying about the verification of calls.

For example, let’s test GetAllUsersAsync() in UserService:

[Fact]

public async Task GetAllUsersAsync_ReturnsUsers()

{

// Arrange

var mockUserRepo = new Mock<IUserRepository>();

var users = new List<User>

{

new User { Id = 1, Name = "John Doe" },

new User { Id = 2, Name = "Jane Doe" }

};

mockUserRepo.Setup(repo => repo.GetAllUsersAsync()).ReturnsAsync(users);

var userService = new UserService(mockUserRepo.Object);

// Act

var result = await userService.GetAllUsersAsync();

// Assert

Assert.Equal(2, result.Count());

Assert.Equal("John Doe", result.First().Name);

}

Here, we are stubbing the GetAllUsersAsync method to return a predefined list of users, allowing us to test UserService's behavior without needing a real repository.

5️⃣ Mocking vs Stubbing in Unit Tests

Aspect Mocking Stubbing

Purpose Verifies method calls and interactions. Provides predefined behavior for method calls.

Verification Yes, mocks can verify that methods are called with correct parameters. No verification, just return values.

Use Case When you need to ensure a method was called correctly. When you need to provide fixed data without checking method calls.

Example Tool Moq, NSubstitute, Rhino Mocks Moq, NSubstitute

6️⃣ Common Moq Methods for Mocking/Stubbing

Setup: Defines how a method should behave when called on a mock object.

mock.Setup(x => x.Method(It.IsAny<int>())).Returns(42);

Verify: Ensures that a method was called on the mock object.

mock.Verify(x => x.Method(It.IsAny<int>()), Times.Once);

It.IsAny<T>(): Used to match any parameter of type T.

mock.Setup(x => x.Method(It.IsAny<int>())).Returns(true);

ReturnsAsync: Returns a value for asynchronous methods.

mock.Setup(x => x.GetDataAsync()).ReturnsAsync(expectedData);

Throws: Sets up the mock to throw an exception.

mock.Setup(x => x.Method(It.IsAny<int>())).Throws<InvalidOperationException>();

Callback: Allows specifying a callback to be executed when the mocked method is called.

mock.Setup(x => x.Method(It.IsAny<int>())).Callback<int>((i) => Console.WriteLine(i));

7️⃣ Best Practices for Mocking and Stubbing in .NET Core

Limit Mocking: Mock external dependencies and services, but avoid mocking simple logic or classes that are not dependent on external systems.

Avoid Over-Mocking: Mocking too much logic can make your tests harder to maintain and less meaningful. If you’re mocking the entire class, you may not be testing the real behavior of the system.

Use It.IsAny<T>() Wisely: This allows flexibility in matching parameters but can lead to overly broad tests if used incorrectly.

Verify Method Calls: Always verify interactions when the number of calls to a method is important (e.g., Times.Once).

Test Behavior and State: While stubbing is great for returning data, combine it with behavior verification (using Verify) to ensure correct interactions.

8️⃣ Summary

In unit testing for .NET Core:

Mocking is used for verifying method interactions and ensuring that dependencies are called correctly.

Stubbing is used to provide predefined responses, isolating the code under test from external systems.

Using libraries like Moq, you can easily mock/stub dependencies, making unit tests fast and reliable. Mocking is essential when you need to verify behavior, while stubbing simplifies the process when you just need controlled data.

Learn Dot Net Course in Hyderabad

Testing Web APIs in .NET with Postman and xUnit

Debugging ASP.NET Core Applications Effectively

Visit Our Quality Thought Institute in Hyderabad

Get Directions

December 08, 2025