Testing Side-Effect-Heavy Methods

Break functions that perform multiple IO actions into pure and impure parts.

In this lesson, you will learn how to make "untestable" side-effect-heavy methods testable by separating the decision-making logic from the actual execution of IO actions.

When a method performs multiple IO operations—like reading a file, calling an API, and updating a database—it becomes a nightmare to test. You end up with brittle tests that require extensive mocking or, worse, real environmental dependencies. The secret to clean testing is to split the method into two parts: a pure logic function (which calculates the result) and an impure executor (which performs the IO).

The Refactoring Pattern

Imagine a method ProcessReport() that fetches data from a database, calculates a complex discount, and saves the result to a disk. Instead of testing the whole flow, extract the calculation:

// The pure part (testable in isolation)
public decimal CalculateDiscount(decimal amount, bool isVip) 
    => isVip ? amount * 0.8m : amount * 0.95m;

// The impure part (orchestration)
public void ProcessReport(int userId) {
    var data = _db.Fetch(userId); // IO
    var result = CalculateDiscount(data.Amount, data.IsVip); // Pure logic
    _fileSystem.Write("report.txt", result); // IO
}

By extracting the CalculateDiscount method, you can now write dozens of unit tests covering every possible edge case (VIP, non-VIP, zero amounts, negative numbers) without needing to mock a single database or file system.

Why this works

Once you move the logic into pure methods, you stop fighting the environment. Your unit tests focus on the computation (the "what"), while your integration tests focus on the orchestration (the "how"). By isolating the IO, you reduce the surface area that requires complex mocking. If the calculation logic changes, your unit tests catch it instantly; if the file path or database schema changes, only your integration test setup needs an update.

Key Takeaway: Never bury your business rules inside IO-heavy methods; extract them into pure, deterministic functions so you can verify your logic without ever needing to touch the outside world.