如何模拟构造函数中初始化的子类以提升单元测试覆盖率？

临时方案：无需重构的模拟方法 #

如果不想立即重构代码，有两种可行的临时手段：

1. 动态替换Unity容器的注册 #

在测试初始化阶段，将Unity容器中ChildClassHandler的注册替换为Mock对象，测试完成后清理容器避免污染其他测试：

[TestInitialize]
public void TestSetup()
{
    // 创建IChildClassHandler的Mock实例
    var mockChildHandler = new Mock<IChildClassHandler>();
    // 注册Mock到Unity容器，覆盖原有注册
    UnityHelper.GetContainer().RegisterInstance<IChildClassHandler>(mockChildHandler.Object);
    
    // 提前设置调用预期，方便后续验证
    mockChildHandler.Setup(h => h.DoSomething(It.IsAny<string>(), It.IsAny<string>()))
                    .Verifiable();
}

[TestCleanup]
public void TestTeardown()
{
    // 清理容器中的注册，恢复初始状态
    UnityHelper.GetContainer().RemoveAll<IChildClassHandler>();
}

[TestMethod]
public void PostMessage_ValidInput_CallsChildHandler()
{
    // 初始化控制器
    var mockActionHandler = new Mock<IActionHandler>();
    var controller = new ActionController(mockActionHandler.Object);
    
    // 调用测试方法
    controller.PostMessage("testString", "testPayload");
    
    // 验证Mock方法被正确调用
    Mock.Get(UnityHelper.GetContainer().Resolve<IChildClassHandler>())
        .Verify(h => h.DoSomething("testString", "testPayload"), Times.Once);
}

2. 使用商业隔离框架拦截静态调用 #

Moq无法模拟静态方法或非虚方法，但TypeMock Isolator、JustMock等商业工具可以直接拦截UnityHelper.GetContainer().Resolve<ChildClassHandler>()的调用，强制返回Mock对象。示例（以TypeMock为例）：

[TestMethod]
public void PostMessage_ValidInput_CallsChildHandler()
{
    var mockChildHandler = new Mock<IChildClassHandler>();
    mockChildHandler.Setup(h => h.DoSomething(It.IsAny<string>(), It.IsAny<string>()))
                    .Verifiable();

    // 拦截静态容器的Resolve调用，返回Mock实例
    Isolate.WhenCalled(() => UnityHelper.GetContainer().Resolve<ChildClassHandler>())
           .WillReturn(mockChildHandler.Object);

    // 执行测试逻辑
    var mockActionHandler = new Mock<IActionHandler>();
    var controller = new ActionController(mockActionHandler.Object);
    controller.PostMessage("testString", "testPayload");

    mockChildHandler.Verify();
}

长期方案：重构代码（推荐） #

静态容器调用导致控制器与Unity框架紧耦合，违反依赖注入（DI）原则，是测试困难的根源。最彻底的解决方式是重构为构造函数注入：

重构ActionController的构造函数 #

将IChildClassHandler作为构造函数参数传入，完全移除静态容器依赖：

public class ActionController
{
    private readonly IActionHandler _actionHandler;
    private readonly IChildClassHandler _childClassHandler;

    // 构造函数注入依赖
    public ActionController(IActionHandler actionHandler, IChildClassHandler childClassHandler)
    {
        _actionHandler = actionHandler;
        _childClassHandler = childClassHandler;
    }
    
    public HttpResponseMessage PostMessage(string myString, string payload)
    {
        // 验证逻辑
        _childClassHandler.DoSomething(myString, payload);
        // 返回结果
    } 
}

重构后的测试代码 #

此时测试无需依赖Unity容器，直接传入Mock对象即可：

[TestMethod]
public void PostMessage_ValidInput_CallsChildHandler()
{
    // 创建所有依赖的Mock
    var mockActionHandler = new Mock<IActionHandler>();
    var mockChildHandler = new Mock<IChildClassHandler>();
    
    // 初始化控制器
    var controller = new ActionController(mockActionHandler.Object, mockChildHandler.Object);
    
    // 调用测试方法
    controller.PostMessage("testString", "testPayload");
    
    // 验证DoSomething被正确调用
    mockChildHandler.Verify(h => h.DoSomething("testString", "testPayload"), Times.Once);
}

结论 #

• 临时方案可以满足当前测试需求，但存在测试污染（Unity容器状态）或商业工具成本问题；
• 重构为构造函数注入是符合DI原则的长期解决方案，代码扩展性、可维护性和可测试性都会大幅提升。

内容的提问来源于stack exchange，提问作者Brett