如何对依赖私有字段的OpcService方法进行单元测试？

问题场景 #

测试OpcService时，已Mock了INotifyVariableChangedService和OpcClient，但OpcService构造函数中直接实例化OpcUaClient并获取私有字段_symbolicsIndex，导致依赖该字段的GetVariableValue方法无法正常测试：

private readonly OpcUaClient _client;
private readonly INotifyVariableChangedService _notifyVariableChangedService;
private readonly ushort _symbolicsIndex;

public OpcService(INotifyVariableChangedService notifyVariableChangedService)
{
    this._notifyVariableChangedService = notifyVariableChangedService;
    this._client = new OpcUaClient("", "");
    _symbolicsIndex = _client.GetSymbolicsNameSpaceId();
}

GetVariableValue方法依赖该私有字段：

public async Task<KeyValuePair<string, object>> GetVariableValue(string nodeIdentifier, string variableName)
{
    var variableValue = await this._client.GetValue(nodeIdentifier, variableName, _symbolicsIndex);
    return new KeyValuePair<string, object>(variableName, variableValue.Value);
}

需求是复用_symbolicsIndex，同时让测试可正常进行。

不推荐Mock私有字段 #

直接Mock私有字段不是合理方案：

• 破坏类的封装性，违背面向对象设计原则
• 测试代码与实现细节强耦合，后续代码改动容易导致测试失效
• 多数Mock框架（如Moq）不支持直接Mock私有字段，需借助反射等hack手段，增加测试复杂度和维护成本

推荐重构方案：依赖注入解耦 #

通过重构让OpcService依赖抽象而非具体实现，从根源上解决测试问题，同时保持_symbolicsIndex的复用性：

1. 定义IOpcUaClient接口

提取OpcUaClient的核心行为到接口：

public interface IOpcUaClient
{
    ushort GetSymbolicsNameSpaceId();
    Task<VariableValue> GetValue(string nodeIdentifier, string variableName, ushort symbolicsIndex);
}

让OpcUaClient实现该接口：

public class OpcUaClient : IOpcUaClient
{
    // 原有实现代码
    public OpcUaClient(string param1, string param2) { /* ... */ }
    public ushort GetSymbolicsNameSpaceId() { /* ... */ }
    public async Task<VariableValue> GetValue(string nodeIdentifier, string variableName, ushort symbolicsIndex) { /* ... */ }
}

2. 修改OpcService构造函数注入接口

将OpcUaClient的实例化逻辑移到外部，通过构造函数注入IOpcUaClient：

private readonly IOpcUaClient _client;
private readonly INotifyVariableChangedService _notifyVariableChangedService;
private readonly ushort _symbolicsIndex;

public OpcService(INotifyVariableChangedService notifyVariableChangedService, IOpcUaClient opcClient)
{
    _notifyVariableChangedService = notifyVariableChangedService;
    _client = opcClient;
    _symbolicsIndex = _client.GetSymbolicsNameSpaceId(); // 仍只获取一次
}

3. 测试时Mock接口

测试中可以轻松MockIOpcUaClient，预设GetSymbolicsNameSpaceId的返回值，以及GetValue的行为：

// 使用Moq示例
var mockOpcClient = new Mock<IOpcUaClient>();
mockOpcClient.Setup(c => c.GetSymbolicsNameSpaceId()).Returns((ushort)1);
mockOpcClient.Setup(c => c.GetValue(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<ushort>()))
             .ReturnsAsync(new VariableValue { Value = "testValue" });

var mockNotifyService = new Mock<INotifyVariableChangedService>();
var opcService = new OpcService(mockNotifyService.Object, mockOpcClient.Object);

// 执行测试并验证结果
var result = await opcService.GetVariableValue("node1", "var1");
Assert.Equal("testValue", result.Value);

备选重构方案：测试专用构造函数（不推荐，仅作兼容参考）

如果暂时无法大范围修改依赖注入，可以添加内部构造函数供测试使用，通过InternalsVisibleTo特性让测试程序集访问内部成员：

在OpcService项目的AssemblyInfo.cs中添加：

[assembly: InternalsVisibleTo("YourTestProjectName")]

然后在OpcService中添加内部构造函数：

internal OpcService(INotifyVariableChangedService notifyVariableChangedService, ushort symbolicsIndex, IOpcUaClient opcClient)
{
    _notifyVariableChangedService = notifyVariableChangedService;
    _client = opcClient;
    _symbolicsIndex = symbolicsIndex;
}

测试时直接传入预设的symbolicsIndex和Mock的客户端，但这种方案仍存在测试与实现耦合的问题，仅适合临时过渡。

总结 #

优先选择依赖注入解耦的重构方案，既保证_symbolicsIndex只获取一次的需求，又让代码具备良好的可测试性和扩展性，是长期维护的最优解。Mock私有字段属于hack手段，不建议使用。

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