C# 如何使用FakeiTasy断言呼叫选择

对于Fakeitesy，如何断言任何呼叫都发生过

用例是我正在编写一个与存储库一起工作的类，作为一个方法的结果，该类应该从存储库中删除一些元素，或者通过调用DeleteAll，或者通过为所有元素调用Delete

现在，我用了一个像这样的试一试：

try // either
{
    A.CallTo(() => module.CardRepo.Delete(A<CardData>.That.IsEqualTo(dummy.CardData[0]))).MustHaveHappened();
    A.CallTo(() => module.CardRepo.Delete(A<CardData>.That.IsEqualTo(dummy.CardData[1]))).MustHaveHappened();
}
catch (ExpectationException) // or
{
    A.CallTo(() => module.CardRepo.DeleteAll(A<IEnumerable<CardData>>.That.Contains(dummy.CardData[0]))).MustHaveHappened();
    A.CallTo(() => module.CardRepo.DeleteAll(A<IEnumerable<CardData>>.That.Contains(dummy.CardData[1]))).MustHaveHappened();
}

try//
{
A.CallTo（（）=>module.CardRepo.Delete（A.That.IsEqualTo（dummy.CardData[0]））.musthaveOccurd（）；
A.CallTo（（）=>module.CardRepo.Delete（A.That.IsEqualTo（dummy.CardData[1]））.musthaveOccurd（）；
}
catch（ExpectationException）//或
{
A.CallTo（（）=>module.CardRepo.DeleteAll（A.That.Contains（dummy.CardData[0]））.musthaveOccurd（）；
A.CallTo（（）=>module.CardRepo.DeleteAll（A.That.Contains（dummy.CardData[1]））.musthaveOccurd（）；
}

---

但我不喜欢这样，如果有更多的选择，它很快就会变得非常丑陋。有更好的办法吗？我在Fakeitesy wiki上找不到任何东西。

我不确定你是否能用Fakeitesy做到这一点。老实说，你可能可以编写一个扩展方法来让你的代码看起来“更好”，尽管我同意这通常不是一个很好的解决方案

---

我真正想说的是，通过单元测试，您正在测试确定性行为，因此，通过方法的输入，您不应该知道是应该调用Delete还是DeleteAll吗？关键是这些测试不应该被分成不同的测试吗？也许我这里没有足够的关于您案例的信息。

不确定您是否可以用Fakeitesy做到这一点。老实说，您可能可以编写一个扩展方法，使您的代码看起来“更好”，尽管我同意这通常不是一个很好的解决方案

---

我真正想说的是，通过单元测试，您正在测试确定性行为，因此，通过方法的输入，您不应该知道是应该调用Delete还是DeleteAll吗？关键是这些测试不应该被分成不同的测试吗？也许我这里没有足够的关于您案例的信息。

下面是一个示例，说明如何验证是否对假对象调用了多个方法之一

 public interface IBlah
{
    void Delete(int x);
    int Add(int x, int y);
    int Subtract(int x, int y);
}

public class Something
{
    private readonly IBlah _blah;

    public Something(IBlah blah) { _blah = blah; }

    public void DoSomething(int x, int y )
    {
      //  _blah.Add(x, y);
        _blah.Subtract(x, y);
    }
}

以上只是一个需要测试的简单系统

   [Fact]
    public void TestFeature()
    {
        var fake = A.Fake<IBlah>();
        var something = new Something(fake);

        something.DoSomething(1, 2);

        var callResults = Fake.GetCalls(fake).Any(call =>
         {
             var x = call.GetArgument<int>("x");
             var y = call.GetArgument<int>("y");
             return call.Method.Name == "Add" || call.Method.Name == "Subtract"
                 && x == 1 && y == 2;
         });

        Assert.True(callResults);
    }

[事实]
公共void TestFeature（）
{
var fake=A.fake（）；
var某物=新某物（假）；
某物，某物（1，2）；
var callResults=false.GetCalls（false）.Any（call=>
{
var x=call.GetArgument（“x”）；
var y=call.GetArgument（“y”）；
return call.Method.Name==“Add”| | call.Method.Name==“Subtract”
&&x==1&&y==2；
});
True（callResults）；
}

---

上面的即时代码段是一个XUnit测试，用于验证是否使用参数x=1，y=2的给定值调用了Add或Subtract。下面是一个示例，说明如何验证是否对伪对象调用了多个方法之一

 public interface IBlah
{
    void Delete(int x);
    int Add(int x, int y);
    int Subtract(int x, int y);
}

public class Something
{
    private readonly IBlah _blah;

    public Something(IBlah blah) { _blah = blah; }

    public void DoSomething(int x, int y )
    {
      //  _blah.Add(x, y);
        _blah.Subtract(x, y);
    }
}

以上只是一个需要测试的简单系统

   [Fact]
    public void TestFeature()
    {
        var fake = A.Fake<IBlah>();
        var something = new Something(fake);

        something.DoSomething(1, 2);

        var callResults = Fake.GetCalls(fake).Any(call =>
         {
             var x = call.GetArgument<int>("x");
             var y = call.GetArgument<int>("y");
             return call.Method.Name == "Add" || call.Method.Name == "Subtract"
                 && x == 1 && y == 2;
         });

        Assert.True(callResults);
    }

[事实]
公共void TestFeature（）
{
var fake=A.fake（）；
var某物=新某物（假）；
某物，某物（1，2）；
var callResults=false.GetCalls（false）.Any（call=>
{
var x=call.GetArgument（“x”）；
var y=call.GetArgument（“y”）；
return call.Method.Name==“Add”| | call.Method.Name==“Subtract”
&&x==1&&y==2；
});
True（callResults）；
}

---

上面的直接代码段是一个XUnit测试，它验证是否使用参数x=1，y=2的给定值调用了Add或Subtract。这里的注释对我来说似乎是正确的。在给定一组已知输入的情况下，被测方法的行为应具有确定性。我试着想象你为什么会处于这种情况。也许测试更像是一个功能测试，其中输入来自处于不可预测的启动状态的真实数据库。为什么不知道要调用哪些方法？也许同一个测试用于多个类。不管怎样，似乎需要一个更集中的单元测试，只测试一个方法并创建一个具有已知起始条件的上下文。在给定一组已知输入的情况下，被测方法的行为应具有确定性。我试着想象你为什么会处于这种情况。也许测试更像是一个功能测试，其中输入来自处于不可预测的启动状态的真实数据库。为什么不知道要调用哪些方法？也许同一个测试用于多个类。无论哪种方式，似乎都需要更集中的单元测试，即只测试单个方法并创建具有已知起始条件的上下文。