C# Testing Strategies

Introduction

Writing code is only half the battle in software development. Ensuring your code works correctly and continues to work after changes is equally important. This is where testing comes in. For C# developers, understanding various testing strategies is crucial to building robust and maintainable applications.

Testing helps you catch bugs early, validate that your code meets requirements, and provides confidence when refactoring or adding new features. This guide will walk you through essential testing strategies for C# developers, from basic unit testing to more comprehensive approaches.

Why Test Your C# Code?

Before diving into specific strategies, let's understand why testing is so important:

Bug Detection: Find issues before your users do
Code Quality: Well-tested code tends to be better designed
Documentation: Tests serve as living documentation of how your code should work
Refactoring Safety: Change code with confidence knowing tests will catch regressions
Reduced Debugging Time: Less time spent troubleshooting in production

Types of Tests for C# Applications

Unit Testing

Unit tests focus on testing individual components (methods, classes) in isolation. These tests are fast, repeatable, and help ensure each piece of your application works correctly on its own.

Popular C# Unit Testing Frameworks

MSTest - Microsoft's built-in testing framework
NUnit - An open-source testing framework inspired by JUnit
xUnit - A more modern testing framework focusing on simplicity and extensibility

Let's create a basic unit test using xUnit:

First, add the xUnit packages to your test project:

bash
dotnet add package xUnit
dotnet add package xUnit.runner.visualstudio

Now, let's test a simple calculator class:

csharp
// Calculator.cs (in your main project)
public class Calculator
{
    public int Add(int a, int b)
    {
        return a + b;
    }
    
    public int Subtract(int a, int b)
    {
        return a - b;
    }
}

Here's our test class:

csharp
// CalculatorTests.cs (in your test project)
using Xunit;

public class CalculatorTests
{
    [Fact]
    public void Add_TwoNumbers_ReturnsCorrectSum()
    {
        // Arrange
        Calculator calculator = new Calculator();
        int a = 5;
        int b = 7;
        
        // Act
        int result = calculator.Add(a, b);
        
        // Assert
        Assert.Equal(12, result);
    }
    
    [Fact]
    public void Subtract_TwoNumbers_ReturnsCorrectDifference()
    {
        // Arrange
        Calculator calculator = new Calculator();
        
        // Act
        int result = calculator.Subtract(10, 5);
        
        // Assert
        Assert.Equal(5, result);
    }
}

When executed, these tests verify that our calculator methods work as expected. The tests follow the "Arrange-Act-Assert" pattern:

Arrange: Set up the test conditions
Act: Perform the action being tested
Assert: Verify the expected outcome

Integration Testing

While unit tests focus on isolated components, integration tests verify that different parts of your application work together correctly. These tests are crucial for ensuring that your system functions as a whole.

Example of an integration test for a service that uses a repository:

csharp
// Integration test with MSTest
[TestClass]
public class CustomerServiceIntegrationTests
{
    private CustomerService _service;
    private CustomerRepository _repository;
    private TestDatabaseContext _dbContext;
    
    [TestInitialize]
    public void Setup()
    {
        // Create a test database
        _dbContext = new TestDatabaseContext();
        _repository = new CustomerRepository(_dbContext);
        _service = new CustomerService(_repository);
        
        // Seed the database with test data
        _dbContext.Customers.Add(new Customer { Id = 1, Name = "Test Customer" });
        _dbContext.SaveChanges();
    }
    
    [TestMethod]
    public void GetCustomerById_ExistingCustomer_ReturnsCorrectCustomer()
    {
        // Act
        Customer customer = _service.GetCustomerById(1);
        
        // Assert
        Assert.IsNotNull(customer);
        Assert.AreEqual("Test Customer", customer.Name);
    }
    
    [TestCleanup]
    public void Cleanup()
    {
        // Clean up test database
        _dbContext.Dispose();
    }
}

Test-Driven Development (TDD)

Test-Driven Development is a methodology where you write tests before writing the actual code. The process follows the "Red-Green-Refactor" cycle:

Red: Write a failing test for the functionality you want to implement
Green: Write the minimal code needed to make the test pass
Refactor: Improve the code while ensuring tests still pass

Let's see TDD in action with a simple example. Imagine we need to create a StringUtility class with a method to reverse strings:

Step 1: Write the failing test first:

csharp
[Fact]
public void ReverseString_InputHello_ReturnsOlleh()
{
    // Arrange
    StringUtility utility = new StringUtility();
    
    // Act
    string result = utility.ReverseString("Hello");
    
    // Assert
    Assert.Equal("olleH", result);
}

Step 2: Create the minimal implementation to make the test pass:

csharp
public class StringUtility
{
    public string ReverseString(string input)
    {
        char[] charArray = input.ToCharArray();
        Array.Reverse(charArray);
        return new string(charArray);
    }
}

Step 3: Run the test and make sure it passes, then look for refactoring opportunities.

Mock Objects and Dependencies

In real-world applications, your classes often depend on other components. When unit testing, you'll want to isolate the class under test by using mock objects to simulate dependencies.

Popular mocking frameworks for C# include:

Moq
NSubstitute
FakeItEasy

Here's an example using Moq:

csharp
[Fact]
public void ProcessOrder_ValidOrder_ShouldCallPaymentProcessor()
{
    // Arrange
    var mockPaymentProcessor = new Mock<IPaymentProcessor>();
    mockPaymentProcessor.Setup(x => x.ProcessPayment(It.IsAny<decimal>())).Returns(true);
    
    var orderService = new OrderService(mockPaymentProcessor.Object);
    var order = new Order 
    { 
        Id = 1, 
        CustomerName = "John Doe", 
        Amount = 100.00m 
    };
    
    // Act
    bool result = orderService.ProcessOrder(order);
    
    // Assert
    Assert.True(result);
    mockPaymentProcessor.Verify(x => x.ProcessPayment(100.00m), Times.Once);
}

This test verifies that OrderService correctly calls the payment processor without actually processing a real payment.

Testing Best Practices for C# Developers

1. Keep Tests Simple and Focused

Each test should verify one thing - follow the "Arrange-Act-Assert" pattern and avoid complex test logic.

csharp
// Good - focused test
[Fact]
public void Add_NegativeNumbers_ReturnsCorrectSum()
{
    var calc = new Calculator();
    int result = calc.Add(-5, -3);
    Assert.Equal(-8, result);
}

// Avoid - testing multiple things
[Fact]
public void TestCalculatorOperations() // Too broad!
{
    var calc = new Calculator();
    Assert.Equal(8, calc.Add(5, 3));
    Assert.Equal(2, calc.Subtract(5, 3));
    Assert.Equal(15, calc.Multiply(5, 3));
}

2. Use Descriptive Test Names

Your test names should clearly describe what the test is checking:

csharp
// Good test name
[Fact]
public void Withdraw_WithSufficientFunds_ReducesBalanceByAmount()
{
    // Test implementation
}

// Poor test name
[Fact]
public void TestWithdraw() // Not descriptive enough
{
    // Test implementation
}

3. Use Data-Driven Tests

Both xUnit and NUnit support data-driven tests, allowing you to run the same test with different inputs:

csharp
// xUnit data-driven test
[Theory]
[InlineData(1, 1, 2)]
[InlineData(5, 3, 8)]
[InlineData(-1, -1, -2)]
[InlineData(0, 0, 0)]
public void Add_VariousInputs_ReturnsCorrectSum(int a, int b, int expected)
{
    var calculator = new Calculator();
    int result = calculator.Add(a, b);
    Assert.Equal(expected, result);
}

4. Set Up Test Data Appropriately

Use setup methods (like [SetUp] in NUnit or constructors in xUnit) to create test data and clean up after tests:

csharp
// NUnit setup example
public class CustomerServiceTests
{
    private CustomerService _service;
    private Mock<ICustomerRepository> _mockRepository;
    
    [SetUp]
    public void Setup()
    {
        _mockRepository = new Mock<ICustomerRepository>();
        _service = new CustomerService(_mockRepository.Object);
    }
    
    [Test]
    public void GetActiveCustomers_ReturnsOnlyActiveCustomers()
    {
        // Test using _service and _mockRepository...
    }
}

Real-World Testing Example

Let's walk through a more complete example of testing a user registration system:

First, our UserService class:

csharp
public class UserService
{
    private readonly IUserRepository _repository;
    private readonly IEmailService _emailService;
    
    public UserService(IUserRepository repository, IEmailService emailService)
    {
        _repository = repository;
        _emailService = emailService;
    }
    
    public RegistrationResult RegisterUser(UserRegistrationModel model)
    {
        // Validate input
        if (string.IsNullOrEmpty(model.Email) || string.IsNullOrEmpty(model.Password))
        {
            return new RegistrationResult { Success = false, ErrorMessage = "Email and password are required" };
        }
        
        // Check if user already exists
        if (_repository.UserExists(model.Email))
        {
            return new RegistrationResult { Success = false, ErrorMessage = "Email already registered" };
        }
        
        // Create user
        var user = new User
        {
            Email = model.Email,
            PasswordHash = HashPassword(model.Password),
            CreatedDate = DateTime.UtcNow
        };
        
        _repository.CreateUser(user);
        
        // Send welcome email
        _emailService.SendWelcomeEmail(model.Email);
        
        return new RegistrationResult { Success = true, UserId = user.Id };
    }
    
    private string HashPassword(string password)
    {
        // In reality, use a proper password hashing algorithm
        return Convert.ToBase64String(
            System.Security.Cryptography.SHA256.Create()
                .ComputeHash(System.Text.Encoding.UTF8.GetBytes(password))
        );
    }
}

Now, let's write comprehensive tests for this service:

csharp
public class UserServiceTests
{
    private Mock<IUserRepository> _mockRepository;
    private Mock<IEmailService> _mockEmailService;
    private UserService _service;
    
    [SetUp]
    public void Setup()
    {
        _mockRepository = new Mock<IUserRepository>();
        _mockEmailService = new Mock<IEmailService>();
        _service = new UserService(_mockRepository.Object, _mockEmailService.Object);
    }
    
    [Test]
    public void RegisterUser_ValidInput_ReturnsSuccessResult()
    {
        // Arrange
        var model = new UserRegistrationModel { Email = "[email protected]", Password = "password123" };
        _mockRepository.Setup(r => r.UserExists(model.Email)).Returns(false);
        
        // Act
        var result = _service.RegisterUser(model);
        
        // Assert
        Assert.True(result.Success);
        Assert.Greater(result.UserId, 0);
        _mockRepository.Verify(r => r.CreateUser(It.IsAny<User>()), Times.Once);
        _mockEmailService.Verify(e => e.SendWelcomeEmail(model.Email), Times.Once);
    }
    
    [Test]
    public void RegisterUser_EmptyEmail_ReturnsErrorResult()
    {
        // Arrange
        var model = new UserRegistrationModel { Email = "", Password = "password123" };
        
        // Act
        var result = _service.RegisterUser(model);
        
        // Assert
        Assert.False(result.Success);
        Assert.That(result.ErrorMessage, Does.Contain("required"));
        _mockRepository.Verify(r => r.CreateUser(It.IsAny<User>()), Times.Never);
        _mockEmailService.Verify(e => e.SendWelcomeEmail(It.IsAny<string>()), Times.Never);
    }
    
    [Test]
    public void RegisterUser_DuplicateEmail_ReturnsErrorResult()
    {
        // Arrange
        var model = new UserRegistrationModel { Email = "[email protected]", Password = "password123" };
        _mockRepository.Setup(r => r.UserExists(model.Email)).Returns(true);
        
        // Act
        var result = _service.RegisterUser(model);
        
        // Assert
        Assert.False(result.Success);
        Assert.That(result.ErrorMessage, Does.Contain("already registered"));
        _mockRepository.Verify(r => r.CreateUser(It.IsAny<User>()), Times.Never);
        _mockEmailService.Verify(e => e.SendWelcomeEmail(It.IsAny<string>()), Times.Never);
    }
}

This example demonstrates:

Using mocks to isolate the class under test
Testing different scenarios (success and various failure cases)
Verifying both the returned results and that the correct methods are called

Setting Up a Test Project in Visual Studio

To create a test project in Visual Studio:

Right-click on your solution in Solution Explorer
Select "Add" > "New Project"
Search for "Test" and select "xUnit Test Project" or "MSTest Test Project"
Name your project (typically YourProjectName.Tests) and click "Create"
Add a reference to the project you want to test
Start writing tests!

Continuous Integration Testing

Integrating your tests with a CI/CD pipeline ensures they're run automatically when code changes:

yaml
# Example GitHub Actions workflow for .NET tests
name: .NET Test

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  build:
    runs-on: ubuntu-latest
    
    steps:
    - uses: actions/checkout@v2
    - name: Setup .NET
      uses: actions/setup-dotnet@v1
      with:
        dotnet-version: 6.0.x
    - name: Restore dependencies
      run: dotnet restore
    - name: Build
      run: dotnet build --no-restore
    - name: Test
      run: dotnet test --no-build --verbosity normal

Summary

Testing is an essential skill for C# developers that leads to more reliable, maintainable code. In this guide, we've covered:

Different types of tests: unit, integration, and more
Popular C# testing frameworks
Test-driven development approach
Best practices for writing effective tests
Real-world testing scenarios

By implementing these testing strategies, you'll catch bugs earlier, improve your code design, and build more confidence in your applications.

Additional Resources

Microsoft's documentation on unit testing
xUnit Documentation
The Art of Unit Testing by Roy Osherove
Test-Driven Development By Example by Kent Beck

Practice Exercises

Create a StringCalculator class with an Add method that takes a string and returns an integer. The method should take numbers separated by commas and return their sum. Write comprehensive tests for it.
Add functionality to handle newlines as separators too. Write tests first!
Create a Bank class with Deposit and Withdraw methods, and test both the happy path and edge cases (like insufficient funds).
Practice mocking by creating a WeatherService that depends on a WeatherApiClient and test it without making actual API calls.

Happy testing!

If you spot any mistakes on this website, please let me know at [email protected]. I’d greatly appreciate your feedback! :)

Introduction​

Why Test Your C# Code?​

Types of Tests for C# Applications​

Unit Testing​

Popular C# Unit Testing Frameworks​

Integration Testing​

Test-Driven Development (TDD)​

Mock Objects and Dependencies​

Testing Best Practices for C# Developers​

1. Keep Tests Simple and Focused​

2. Use Descriptive Test Names​

3. Use Data-Driven Tests​

4. Set Up Test Data Appropriately​

Real-World Testing Example​

Setting Up a Test Project in Visual Studio​

Continuous Integration Testing​

Summary​

Additional Resources​

Practice Exercises​