Note You can check other posts on my personal website: https://hbolajraf.net
In Test-Driven Development (TDD), we write tests before writing the actual code. This example demonstrates how to create unit tests in C# using xUnit, how to use the Moq framework for mocking, and how to refactor tests using Fact and Theory attributes.
Prerequisites
Before we start, make sure you have the following installed:
- Visual Studio or Visual Studio Code (or any C# IDE of your choice)
- xUnit.net testing framework
- Moq mocking framework
Scenario
Suppose we are building a simple library that calculates the total price of items in a shopping cart.
Step 1: Set Up the Project
Create a new C# project and add references to the xUnit and Moq libraries.
Step 2: Write the Initial Test
Let's start by writing a test for our shopping cart. Create a test class, and write a Fact that checks if the cart's total price is calculated correctly:
using System;
using Xunit;
public class ShoppingCartTests
{
[Fact]
public void CalculateTotalPrice_CartWithItems_ReturnsTotalPrice()
{
// Arrange
var cart = new ShoppingCart();
cart.AddItem(new Item("Item 1", 10.0));
cart.AddItem(new Item("Item 2", 15.0));
// Act
var totalPrice = cart.CalculateTotalPrice();
// Assert
Assert.Equal(25.0, totalPrice);
}
}
Step 3: Write the Initial Code
Now, create the ShoppingCart
class and implement the CalculateTotalPrice
method:
public class ShoppingCart
{
private List<Item> items = new List<Item>();
public void AddItem(Item item)
{
items.Add(item);
}
public double CalculateTotalPrice()
{
return items.Sum(item => item.Price);
}
}
Step 4: Mocking with Moq
Suppose our ShoppingCart
class depends on an external data source (e.g., a database). To test it, we can use Moq to mock this dependency. Create an interface for the data source, implement it, and inject it into the ShoppingCart
:
public interface IDataSource
{
List<Item> GetItems();
}
public class Database : IDataSource
{
public List<Item> GetItems()
{
// Simulate database call
return new List<Item>
{
new Item("Item 1", 10.0),
new Item("Item 2", 15.0)
};
}
}
public class ShoppingCart
{
private IDataSource dataSource;
public ShoppingCart(IDataSource dataSource)
{
this.dataSource = dataSource;
}
// ...
}
Step 5: Refactor the Test with Theory
Instead of Fact, let's refactor the test using Theory. This allows us to use data from multiple test cases. For instance, we can test the CalculateTotalPrice
method with different sets of items:
[Theory]
[InlineData(new[] { 10.0, 15.0 }, 25.0)]
[InlineData(new[] { 5.0, 7.0, 8.0 }, 20.0)]
public void CalculateTotalPrice_CartWithItems_ReturnsTotalPrice(double[] itemPrices, double expectedTotalPrice)
{
// Arrange
var cart = new ShoppingCart(CreateMockDataSource(itemPrices));
// Act
var totalPrice = cart.CalculateTotalPrice();
// Assert
Assert.Equal(expectedTotalPrice, totalPrice);
}
Here, we're using Theory to run the test with different sets of item prices. The CreateMockDataSource
function sets up a Moq mock of the IDataSource
interface.
What Next?
This example demonstrates how to use TDD with xUnit, Moq for mocking, and how to refactor tests using Fact and Theory attributes. By following TDD, you can ensure that your code is thoroughly tested and that it meets the specified requirements.
Top comments (0)