C# 如何测试eventhandler的结果

我有一个ViewModel，它在构造函数中接收带有Eventhandler的接口：

public VehiclesViewModel(IVehicles vehicles)
{
    _vehicles = vehicles;
    VehicleRows = new ObservableCollection<VehicleRowViewModel>();
    _vehicles.ListVehicles("secret", callback);
}

以下是代码的其余部分：

public interface IVehicles
{
    void ListVehicles(string category, MyAsyncCompletedEventHandler callback);
}

public delegate void MyAsyncCompletedEventHandler(object sender, MyAsyncCompletedEventArgs e);

public class MyAsyncCompletedEventArgs : AsyncCompletedEventArgs
{
    public MyAsyncCompletedEventArgs(Exception ex) : base(ex, true, null)
    {
    }

    public object Result { get; set; }
}

现在，我想测试车辆数量是否正确添加到VehiclerRows：

[TestFixture]
public class VehiclesViewModelTests
{
    [Test]
    public void AllVehiclesFromCallBackEndUpInProperty()
    {
        var vehiclesMock = new Mock<IVehicles>();
        vehiclesMock.Setup(x => x.ListVehicles(It.IsAny<string>(), It.IsAny<MyAsyncCompletedEventHandler>())).Callback<string, MyAsyncCompletedEventHandler>(
            (s, c) =>
            {
                c = (sender, args) =>
                    args.Result = new List<Vehicle>
                    {
                        new Vehicle {Name = "TR3B"},
                        new Vehicle {Name = "Aurora"},
                        new Vehicle {Name = "HAUC"}
                    }.ToArray();
            });
        var testee = new VehiclesViewModel(vehiclesMock.Object);
        Assert.AreEqual(3,testee.VehicleRows.Count);
    }
}

[TestFixture]
公共类车辆视图模型测试
{
[测试]
public void callbackendupinproperty（）中的所有车辆
{
var vehiclesMock=new Mock（）；
vehiclesMock.Setup（x=>x.ListVehicles（It.IsAny（），It.IsAny（））。回调(
（s，c）=>
{
c=（发送方，参数）=>
args.Result=新列表
{
新车{Name=“TR3B”}，
新车{Name=“Aurora”}，
新车{Name=“HAUC”}
}.ToArray（）；
});
var testee=新的VehiclesViewModel（vehiclesMock.Object）；
Assert.AreEqual（3，被测者车辆数）；
}
}

但测试失败了。如何模拟回调以正确测试ViewModel

---

我有一个github repo，示例是：

在您的示例测试中，您试图在模拟回调中定义委托，而您应该调用传递到模拟回调中的委托

查看所提供测试的以下重构，该重构捕获回调、调用回调并验证预期行为

[Test]
public void AllVehiclesFromCallBackEndUpInProperty() {
    //Arrange
    MyAsyncCompletedEventHandler handler = null;

    var vehiclesMock = new Mock<IVehicles>();
    vehiclesMock
        .Setup(_ => _.ListVehicles(It.IsAny<string>(), It.IsAny<MyAsyncCompletedEventHandler>()))
        .Callback<string, MyAsyncCompletedEventHandler>((secret, callback) => {
            //capture the delegate for later use;
            handler = callback;
        });

    var subjectUnderTest = new VehiclesViewModel(vehiclesMock.Object);
    //check to make sure the hanler as been set at this point
    Assert.IsNotNull(handler);

    var vehicles = new List<Vehicle> {
        new Vehicle {Name = "TR3B"},
        new Vehicle {Name = "Aurora"},
        new Vehicle {Name = "HAUC"}
    }.ToArray();
    int expected = vehicles.Length;
    var eventArgs = new MyAsyncCompletedEventArgs(null) {
        Result = vehicles
    };

    //Act (invoke the delegate)
    handler.Invoke(vehiclesMock.Object, eventArgs);

    //Assert
    int actual = subjectUnderTest.VehicleRows.Count;
    Assert.AreEqual(expected, actual);
}

[测试]
public void callbackendupinproperty（）中的所有车辆{
//安排
MyAsyncCompletedEventHandler=null；
var vehiclesMock=new Mock（）；
车辆模拟
.Setup（=>u.ListVehicles（It.IsAny（），It.IsAny（）））
.Callback（（秘密，回调）=>{
//捕获代理以供以后使用；
handler=回调；
});
var subjectiondertest=新的VehiclesViewModel（vehiclesMock.Object）；
//检查以确保此时已设置hanler
IsNotNull（处理程序）；
var车辆=新列表{
新车{Name=“TR3B”}，
新车{Name=“Aurora”}，
新车{Name=“HAUC”}
}.ToArray（）；
int预期=车辆。长度；
var eventArgs=新的MyAsyncCompletedEventArgs（空）{
结果=车辆
};
//Act（调用委托）
调用（vehiclesMock.Object、eventArgs）；
//断言
int实际值=subjectUnderTest.VehiclerRows.Count；
断言.AreEqual（预期、实际）；
}

这个测试更好地代表了被测试对象的实际行为

[TestFixture]
public class VehiclesViewModelTests
{
    [Test]
    public void AllVehiclesFromCallBackEndUpInProperty()
    {
        var vehiclesMock = new Mock<IVehicles>();
        vehiclesMock.Setup(x => x.ListVehicles(It.IsAny<string>(), It.IsAny<MyAsyncCompletedEventHandler>())).Callback<string, MyAsyncCompletedEventHandler>(
            (s, c) =>
            {
                c = (sender, args) =>
                    args.Result = new List<Vehicle>
                    {
                        new Vehicle {Name = "TR3B"},
                        new Vehicle {Name = "Aurora"},
                        new Vehicle {Name = "HAUC"}
                    }.ToArray();
            });
        var testee = new VehiclesViewModel(vehiclesMock.Object);
        Assert.AreEqual(3,testee.VehicleRows.Count);
    }
}

[Test]
public void AllVehiclesFromCallBackEndUpInProperty() {
    //Arrange
    MyAsyncCompletedEventHandler handler = null;

    var vehiclesMock = new Mock<IVehicles>();
    vehiclesMock
        .Setup(_ => _.ListVehicles(It.IsAny<string>(), It.IsAny<MyAsyncCompletedEventHandler>()))
        .Callback<string, MyAsyncCompletedEventHandler>((secret, callback) => {
            //capture the delegate for later use;
            handler = callback;
        });

    var subjectUnderTest = new VehiclesViewModel(vehiclesMock.Object);
    //check to make sure the hanler as been set at this point
    Assert.IsNotNull(handler);

    var vehicles = new List<Vehicle> {
        new Vehicle {Name = "TR3B"},
        new Vehicle {Name = "Aurora"},
        new Vehicle {Name = "HAUC"}
    }.ToArray();
    int expected = vehicles.Length;
    var eventArgs = new MyAsyncCompletedEventArgs(null) {
        Result = vehicles
    };

    //Act (invoke the delegate)
    handler.Invoke(vehiclesMock.Object, eventArgs);

    //Assert
    int actual = subjectUnderTest.VehicleRows.Count;
    Assert.AreEqual(expected, actual);
}