Increasing Code Test Coverage by Adding Characterization Tests

In the previous lesson, we explored the importance of code test coverage and how it ensures software quality and developer confidence. Now, we will explore a specific type of testing known as characterization tests. These tests are invaluable when working with an established codebase, as they help document the current behavior of a system without altering its functionality. By the end of this lesson, we'll understand how to use characterization tests to increase code coverage effectively.

Aren't these tests the same as unit tests but with a fancy name? In a sense yes, but we want to explore the nuance of looking at unit tests as characterization tests. Characterization tests are designed to capture the existing behavior of a system. They are particularly useful when dealing with an existing codebase that lacks documentation or tests. The primary goal of these tests is not to find bugs but to document what the code currently does.

Another important aspect of characterization tests is their ability to capture the subtle details of a system that aren't immediately apparent from class or method names alone.

For example, consider a method in an order processing system that calculates the total order amount and applies discounts. A characterization test for this method would verify that the current logic correctly calculates the total and applies discounts as expected, even if the logic is flawed. This way, we can confidently refactor the code, knowing that the test will alert us if the behavior changes unexpectedly.

Without tests, it's difficult to understand the code's behavior, making modifications risky. Characterization tests offer a solution by allowing us to explore and document the code's behavior safely. By writing tests that capture the current functionality, we create a baseline that helps identify unintended changes during future modifications.

Writing characterization tests involves creating tests that reflect the current behavior of the code. Let's look at a practical example using the OrderProcessor class from our order processing system. Suppose we have a method that processes orders and applies discounts based on the total amount:

public bool ProcessOrder(Order order)
{
    // ... processing logic before calculations ...

    decimal totalAmount = 0;
    foreach (var item in order.Items)
    {       
        decimal itemPrice = item.Price * item.Quantity;
        totalAmount += itemPrice;
    }
    
    // Apply bulk order discount if applicable
    if (totalAmount >= BULK_ORDER_THRESHOLD)
    {
        totalAmount = totalAmount * (1 - BULK_ORDER_DISCOUNT);
        order.HasBulkDiscount = true;
    }
    
    // ... additional logic before finalizing order ...
    
    return order.Status == OrderStatus.Approved;
}

[Fact]
public void WhenOrderExceedsBulkThreshold_DiscountIsApplied()
{
    // Arrange
    var order = new Order
    {
        Items = new List<OrderItem>
        {
            new OrderItem { Price = 1000m, Quantity = 1 }
        }
    };

    // Act
    var result = _processor.ProcessOrder(order);

    // Assert
    Assert.True(result);
    Assert.True(order.HasBulkDiscount);
    Assert.Equal(900m, order.OrderTotal); // 10% discount applied
}

In the above test, we arrange an order with a total amount that qualifies for a bulk discount. The test then verifies that the discount is applied correctly, capturing the current behavior of the method.