Introduction

AutoFixture is a library in .NET that helps to create test objects for unit tests, this makes it easier to generate complex object graphs without having to manually instantiate them.

We will have to follow the below steps when writing unit tests using AutoFixture in C#.

1. Install AutoFixture

First, you need to install the AutoFixture NuGet package. You can do this using the "NuGet Package Manager" in Visual Studio or via the Package Manager Console:

Install-Package AutoFixture

2. Create a Test Project

Make sure you have a test project in your solution. You can create a new test project in Visual Studio by selecting File -> New -> Project... and then choosing a test project template like "xUnit Test Project", "NUnit Test Project", or "MSTest Test Project".

3. Write Unit Tests with AutoFixture

In this example, we will see how to use AutoFixture in a unit test. You have a class OrderService with a method CreateOrder that you want to test.

public class Order
{
    public int Id { get; set; }
    public string ProductName { get; set; }
    public int Quantity { get; set; }
    public decimal Price { get; set; }
}

public class OrderService
{
    public Order CreateOrder(string productName, int quantity, decimal price)
    {
        return new Order
        {
            Id = new Random().Next(1, 1000),
            ProductName = productName,
            Quantity = quantity,
            Price = price
        };
    }
}

Writing the Unit Test:

In the below example, we will see how you can write a unit test using AutoFixture for the CreateOrder method:

using AutoFixture;
using Xunit;

public class OrderServiceTests
{
    [Fact]
    public void CreateOrder_ShouldReturnOrderWithCorrectProperties()
    {
        // Arrange
        var fixture = new Fixture();
        var orderService = new OrderService();
        
        // Generate test data using AutoFixture
        var productName = fixture.Create<string>();
        var quantity = fixture.Create<int>();
        var price = fixture.Create<decimal>();

        // Act
        var result = orderService.CreateOrder(productName, quantity, price);

        // Assert
        Assert.NotNull(result);
        Assert.Equal(productName, result.ProductName);
        Assert.Equal(quantity, result.Quantity);
        Assert.Equal(price, result.Price);
    }
}

Arrange:

• First, we create an instance of Fixture from AutoFixture.
• Then, Instantiate the OrderService.
• And, Use AutoFixture to generate random values for productName, quantity, and price.

Act:

• Call the CreateOrder method with the generated values.

Assert:

• We verify that the returned Order object is not null and that its properties match the generated values.

4. Using AutoFixture with Customizations

AutoFixture can be customized to generate data in specific ways or to handle more complex scenarios. For example, if you want to ensure certain properties always have specific values, you can use customizations:

var fixture = new Fixture();
fixture.Customize<Order>(o => o.With(order => order.Quantity, 10));

var order = fixture.Create<Order>();
Assert.Equal(10, order.Quantity);

5. Using AutoFixture with AutoMoq

For more advanced scenarios, such as testing methods with dependencies, you can use AutoFixture with AutoMoq.

First, install the AutoFixture.AutoMoq package:

Install-Package AutoFixture.AutoMoq

In this example, AutoFixture creates the OrderService with a mocked dependency (ILogger). The test verifies that a log method was called.

using AutoFixture;
using AutoFixture.AutoMoq;
using Moq;
using Xunit;

public class OrderServiceTests
{
    [Fact]
    public void CreateOrder_ShouldCallLogger()
    {
        // Arrange
        var fixture = new Fixture().Customize(new AutoMoqCustomization());
        var mockLogger = fixture.Freeze<Mock<ILogger>>();
        var orderService = fixture.Create<OrderService>();

        // Act
        var productName = fixture.Create<string>();
        var quantity = fixture.Create<int>();
        var price = fixture.Create<decimal>();
        orderService.CreateOrder(productName, quantity, price);

        // Assert
        mockLogger.Verify(logger => logger.Log(It.IsAny<string>()), Times.Once);
    }
}

Conclusion

We can use Autofixture to write unit tests in C# easily. It also makes it easy to create test data, which helps make our unit tests easier to read and manage.