Functional Seams with Functions as Parameters

Welcome back! This is the first lesson of the "Using Seams to Enable Testability and Expand Capabilities" course! Here, we will explore the concept of functional seams and how they can be utilized to enhance the flexibility and testability of our code. Seams are strategic points in our code where behavior can be modified without altering the existing implementation. By using functions as parameters, we can create functional seams that allow us to inject new behavior into our code.

In software development, the ability to change code behavior without breaking existing functionality is crucial. Seams play a pivotal role in enabling these safe code changes. They allow us to introduce new behavior, test different scenarios, and refactor established codebases incrementally. By using functional seams, we can inject dependencies and modify behavior without altering the core logic of our code. This approach not only improves testability but also expands the capabilities of our software.

Let's look at how we can use functions as parameters. Consider the following example:

public class OrderProcessor
{
    public bool ProcessOrder(Order order, Func<List<OrderItem>, decimal> calculateTotal = null)
    {
        var totalAmountCalculation = calculateTotal ?? DefaultTotalCalculation;
        // ...order processing logic ...
        order.OrderTotal = totalAmountCalculation(order.Items);
        return true;
    }

    private decimal DefaultTotalCalculation(List<OrderItem> items)
    {
        // ...default calculation logic ...
    }
}

In this example, the ProcessOrder method accepts a function parameter calculateTotal. This function is used to calculate the total amount for an order. If no function is provided, the method defaults to using DefaultTotalCalculation. This approach allows us to inject custom behavior into the ProcessOrder method without altering its core logic.

Functional seams can be applied in various real-world scenarios. For instance, we might want to apply a discount or surcharge to an order total. By using functional seams, we can easily inject these calculations without modifying the existing code.

When writing tests, the following test case demonstrates the use of a custom discount calculation:

[Fact]
public void ProcessOrder_WithCustomDiscountCalculation_AppliesDiscount()
{
    // ... Arrange related code ...

    // Custom calculation with 10% discount
    Func<List<OrderItem>, decimal> discountCalculation = (items) =>
    {
        decimal total = 0;
        foreach (var item in items)
        {
            decimal itemPrice = item.Price * item.Quantity;
            total += itemPrice;
        }
        return total * 0.9m; // 10% discount
    };

    // Act
    orderProcessor.ProcessOrder(order, discountCalculation);

    // Assert related code ...
}

In this test case, we inject a custom discount calculation into the ProcessOrder method. This demonstrates the flexibility and power of functional seams in adapting to different business scenarios.