Isolation with Wrapper Patterns

In this lesson, you will learn how to improve testability by creating thin wrappers around third-party libraries that are otherwise difficult or impossible to mock directly.

The Problem with Third-Party Dependencies

Many third-party libraries use static methods, sealed classes, or lack interfaces, making it impossible for mocking frameworks like Moq or NSubstitute to intercept calls. If your business logic calls a static method like ThirdPartyLibrary.Process(), your unit test is forced to trigger the real implementation, which might involve network calls, file system access, or unpredictable side effects.

The Wrapper Pattern Solution

To gain control, you introduce a "Thin Wrapper"—an abstraction that mimics the required functionality of the library. You define an interface, implement it by simply delegating the work to the library, and then inject that interface into your services.

Consider an external library that provides a static EmailClient:

public interface IEmailSender {
    void Send(string message);
}

// The Thin Wrapper
public class EmailSenderWrapper : IEmailSender {
    public void Send(string message) {
        // Delegate to the static library
        ThirdPartyLibrary.EmailClient.Send(message);
    }
}

Why This Works for Testing

By depending on IEmailSender instead of the static EmailClient, your unit tests are no longer coupled to the third-party implementation. During a test, you can easily inject a mock:

[Fact]
public void ProcessOrder_SendsEmail_WhenSuccessful() {
    var mockEmail = new Mock<IEmailSender>();
    var service = new OrderService(mockEmail.Object);

    service.Process();

    // Verify the abstraction, not the static library
    mockEmail.Verify(e => e.Send(It.IsAny<string>()), Times.Once);
}

By adding this tiny layer of redirection, you decouple your code from the implementation details of external dependencies. This not only makes your code more testable but also makes it significantly easier to swap out the library later without changing your core business logic.

Key Takeaway: Create thin interface-based wrappers around unmockable third-party code to transform static or sealed dependencies into testable, injectable abstractions.