如何用Moq验证两个方法对Mock接口的调用完全一致？

当然可以用Moq实现这个需求，完全不需要更换其他Mock框架！核心思路是捕获其中一个Mock的调用序列，再与另一个Mock的调用序列做全量对比——包括调用顺序、方法名称、参数值。下面我给你两种实用的实现方案：

方案一：利用Moq自带的Invocations属性（最简洁） #

Moq的Mock<T>对象自带一个Invocations属性，它会自动记录所有对Mock对象的调用细节：包括调用的方法、传入的参数，以及调用顺序。我们可以直接拿这个属性来做对比验证。

示例代码 #

[TestMethod]
public void UnitTest()
{
    var classToTest = new ClassToTest();
    var mock1 = new Mock<IMyInterface>();
    var mock2 = new Mock<IMyInterface>();

    // 执行两个待测试方法
    classToTest.MethodToTest(mock1.Object);
    classToTest.DifferentMethodToTest(mock2.Object);

    // 获取两个Mock的调用记录
    var invocationsFromMethod1 = mock1.Invocations;
    var invocationsFromMethod2 = mock2.Invocations;

    // 1. 先验证调用次数是否一致
    Assert.AreEqual(invocationsFromMethod1.Count, invocationsFromMethod2.Count, "两个方法的接口调用次数不匹配");

    // 2. 逐个对比每一次调用的细节
    for (int i = 0; i < invocationsFromMethod1.Count; i++)
    {
        var call1 = invocationsFromMethod1[i];
        var call2 = invocationsFromMethod2[i];

        // 验证调用的方法是否一致
        Assert.AreEqual(call1.Method.Name, call2.Method.Name, $"第{i+1}次调用的方法名称不匹配");
        
        // 验证参数数量是否一致
        Assert.AreEqual(call1.Arguments.Length, call2.Arguments.Length, $"第{i+1}次调用的参数数量不匹配");
        
        // 逐个验证参数值是否一致
        for (int j = 0; j < call1.Arguments.Length; j++)
        {
            Assert.AreEqual(call1.Arguments[j], call2.Arguments[j], $"第{i+1}次调用的第{j+1}个参数值不匹配");
        }
    }
}

优化：封装成扩展方法（复用性更强） #

如果需要在多个测试中复用这个验证逻辑，可以把对比逻辑封装成Moq的扩展方法：

public static class MockVerificationExtensions
{
    public static void VerifyInvocationsMatch<T>(this Mock<T> targetMock, Mock<T> referenceMock) 
        where T : class
    {
        var targetInvocations = targetMock.Invocations;
        var referenceInvocations = referenceMock.Invocations;

        Assert.AreEqual(targetInvocations.Count, referenceInvocations.Count, "调用次数不一致");

        for (int i = 0; i < targetInvocations.Count; i++)
        {
            var targetCall = targetInvocations[i];
            var referenceCall = referenceInvocations[i];

            // 验证方法签名一致
            Assert.AreEqual(targetCall.Method, referenceCall.Method, $"第{i+1}次调用的方法不匹配");
            // 验证参数列表一致
            CollectionAssert.AreEqual(targetCall.Arguments, referenceCall.Arguments, $"第{i+1}次调用的参数不匹配");
        }
    }
}

之后在测试里就可以一行代码搞定验证：

mock1.VerifyInvocationsMatch(mock2);

方案二：手动用Callback记录调用序列（更灵活） #

如果需要对调用记录做更复杂的自定义处理（比如针对复杂类型的参数做特殊相等校验），可以通过Moq的Callback方法手动记录每一次调用的细节，再对比两个记录列表。

示例代码 #

首先定义一个用于记录调用的类：

public class InterfaceCallRecord
{
    public string MethodName { get; set; }
    public object[] Arguments { get; set; }
}

然后在测试中设置Callback来记录调用：

[TestMethod]
public void UnitTest_WithManualRecording()
{
    var classToTest = new ClassToTest();
    var callsFromMethod1 = new List<InterfaceCallRecord>();
    var callsFromMethod2 = new List<InterfaceCallRecord>();

    // 配置Mock1，记录所有调用
    var mock1 = new Mock<IMyInterface>();
    mock1.Setup(x => x.Method1(It.IsAny<int>()))
         .Callback<int>(param => callsFromMethod1.Add(new InterfaceCallRecord 
         { 
             MethodName = nameof(IMyInterface.Method1), 
             Arguments = new object[] { param } 
         }));
    mock1.Setup(x => x.Method2(It.IsAny<string>()))
         .Callback<string>(param => callsFromMethod1.Add(new InterfaceCallRecord 
         { 
             MethodName = nameof(IMyInterface.Method2), 
             Arguments = new object[] { param } 
         }));

    // 配置Mock2，记录所有调用
    var mock2 = new Mock<IMyInterface>();
    mock2.Setup(x => x.Method1(It.IsAny<int>()))
         .Callback<int>(param => callsFromMethod2.Add(new InterfaceCallRecord 
         { 
             MethodName = nameof(IMyInterface.Method1), 
             Arguments = new object[] { param } 
         }));
    mock2.Setup(x => x.Method2(It.IsAny<string>()))
         .Callback<string>(param => callsFromMethod2.Add(new InterfaceCallRecord 
         { 
             MethodName = nameof(IMyInterface.Method2), 
             Arguments = new object[] { param } 
         }));

    // 执行待测试方法
    classToTest.MethodToTest(mock1.Object);
    classToTest.DifferentMethodToTest(mock2.Object);

    // 对比两个调用记录列表
    Assert.AreEqual(callsFromMethod1.Count, callsFromMethod2.Count);
    for (int i = 0; i < callsFromMethod1.Count; i++)
    {
        var call1 = callsFromMethod1[i];
        var call2 = callsFromMethod2[i];

        Assert.AreEqual(call1.MethodName, call2.MethodName);
        // 如果是复杂类型参数，可以在这里替换为自定义的相等校验逻辑
        CollectionAssert.AreEqual(call1.Arguments, call2.Arguments);
    }
}

总结 #

• 如果你只需要基础的调用一致性验证，方案一（利用Invocations）最简洁高效，不需要额外配置。
• 如果需要处理复杂参数或自定义验证逻辑，方案二（手动记录）更灵活。

两种方案都能满足你的需求，完全不需要更换其他Mock框架。

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