Introduction to Moq

Mocking is a technique used in unit testing to simulate the behavior of real objects. The primary reason for mocking is to isolate the unit of work from external dependencies, ensuring that tests are fast, reliable, and repeatable. Moq, a play on the word “mock”, is a powerful and flexible mocking framework for .NET that…

Evangelos Boltsis

September 30, 2023

3 minutes

.NET, c#, Moq, test, unit test, unit testing

Basic Concepts of Moq

Mock Object: This is a dynamic proxy object created by Moq to simulate the behavior of your real objects. It’s designed to be used in place of the real object in your tests.
Setup: This is how you instruct the mock object on how to behave when its methods or properties are accessed.
Verify: After running your tests, you can use this to ensure that the mock object was interacted with in the expected manner.

Creating Your First Mocks

This is how you would use the library along with XUnit:

using Moq;
using System;
using Xunit;

// Define the ICalculator interface
public interface ICalculator
{
    int Add(int a, int b);
}

// Sample class that uses ICalculator
public class MathService
{
    private readonly ICalculator _calculator;

    public MathService(ICalculator calculator)
    {
        _calculator = calculator;
    }

    public int DoubleAdd(int a, int b)
    {
        return _calculator.Add(a, b) * 2;
    }
}

// Unit test class
public class MathServiceTests
{
    [Fact]
    public void DoubleAdd_WithValidInput_ReturnsDoubleTheSum()
    {
        // Arrange
        var mockCalculator = new Mock<ICalculator>();
        mockCalculator.Setup(calc => calc.Add(2, 2)).Returns(4);
        var mathService = new MathService(mockCalculator.Object);

        // Act
        var result = mathService.DoubleAdd(2, 2);

        // Assert
        Assert.Equal(8, result);
        mockCalculator.Verify(calc => calc.Add(2, 2), Times.Once);
    }
}

In this example:

We have an ICalculator interface with an Add method.
We have a MathService class that uses the ICalculator to perform a DoubleAdd operation.
In the MathServiceTests class, we’re using xUnit (a popular testing framework for .NET) to write a unit test for the DoubleAdd method.
We create a mock for the ICalculator, set up its behavior, and then use it to test the DoubleAdd method of the MathService.
Finally, we verify that the Add method on the mock calculator was called once with the specified arguments.

Another more practical example, like the one we used to understand NSubstitute:

namespace XUnitTests;

public interface IInventory
{
    bool IsInStock(string item);
    void ReduceStock(string item);
}

public interface IPaymentGateway
{
    bool ProcessPayment(double amount);
}

public class OrderService
{
    private readonly IInventory _inventory;
    private readonly IPaymentGateway _paymentGateway;

    public OrderService(IInventory inventory, IPaymentGateway paymentGateway)
    {
        _inventory = inventory;
        _paymentGateway = paymentGateway;
    }

    public bool ProcessOrder(string item, double amount)
    {
        if (_inventory.IsInStock(item))
        {
            if (_paymentGateway.ProcessPayment(amount))
            {
                _inventory.ReduceStock(item);
                return true;
            }
        }

        return false;
    }
}

Let’s write the tests for this code:

using Moq;
using Xunit;
using XUnitTests;

namespace XUnitTests.Tests
{
    public class OrderServiceTests
    {
        private readonly Mock<IInventory> _mockInventory;
        private readonly Mock<IPaymentGateway> _mockPaymentGateway;
        private readonly OrderService _orderService;

        public OrderServiceTests()
        {
            _mockInventory = new Mock<IInventory>();
            _mockPaymentGateway = new Mock<IPaymentGateway>();
            _orderService = new OrderService(_mockInventory.Object, _mockPaymentGateway.Object);
        }

        [Fact]
        public void ProcessOrder_WhenItemInStockAndPaymentSuccess_ReturnsTrue()
        {
            // Arrange
            _mockInventory.Setup(inv => inv.IsInStock(It.IsAny<string>())).Returns(true);
            _mockPaymentGateway.Setup(pg => pg.ProcessPayment(It.IsAny<double>())).Returns(true);

            // Act
            bool result = _orderService.ProcessOrder("item1", 100.0);

            // Assert
            Assert.True(result);
            _mockInventory.Verify(inv => inv.ReduceStock("item1"), Times.Once);
        }

        [Fact]
        public void ProcessOrder_WhenItemInStockAndPaymentFails_ReturnsFalse()
        {
            // Arrange
            _mockInventory.Setup(inv => inv.IsInStock(It.IsAny<string>())).Returns(true);
            _mockPaymentGateway.Setup(pg => pg.ProcessPayment(It.IsAny<double>())).Returns(false);

            // Act
            bool result = _orderService.ProcessOrder("item1", 100.0);

            // Assert
            Assert.False(result);
            _mockInventory.Verify(inv => inv.ReduceStock("item1"), Times.Never);
        }

        [Fact]
        public void ProcessOrder_WhenItemNotInStock_ReturnsFalse()
        {
            // Arrange
            _mockInventory.Setup(inv => inv.IsInStock(It.IsAny<string>())).Returns(false);

            // Act
            bool result = _orderService.ProcessOrder("item1", 100.0);

            // Assert
            Assert.False(result);
        }
    }
}

In the above code:

We created a mock for both IInventory and IPaymentGateway interfaces.
The OrderService class is instantiated using these mocks.
We have three tests that cover the different scenarios. The mock setup allows us to dictate the behavior of the dependencies for each test scenario.
Verify is used to check if a specific method on the mock (like ReduceStock) was called or not, depending on the expected outcome.

Best Practices with Moq

Keep Mocks Simple: Only mock what’s necessary for the test. Overcomplicating mocks can make tests harder to read and maintain.
Avoid Over-mocking: If everything is mocked, you might not be testing anything meaningful. Strike a balance.
Isolate Units of Work: Use mocks to ensure that you’re only testing the specific unit of work and not its dependencies.

One response to “Introduction to Moq”

A Deep Dive into SponsorLink: Implications for Open-Source and Privacy (UPDATED) – Coding Bolt

September 30, 2023 at 1:20 pm

[…] can find an intro to Moq here: Introduction to Moq – Coding BoltYou can also check out my post that introduces you to […]

LikeLike

Reply

Coding Bolt