C# 如何使用NSubstitute测试函数是否收到特定委托？

我想测试函数是否接收到一个特定的委托作为参数。在NUnit中是否可以使用NSubstitute

我的界面：

public interface IMyInterface
{
    void Sort(Func<IEnumerable<int>, IOrderedEnumerable<int>> f);
}

公共接口IMyInterface
{
无效排序（Func f）；
}

我的测试班：

[TestFixture]
public class Class1
{
    [Test]
    public void Sort_WhenCalled_CallsWithPassedArgument()
    {
        // Arrange
        IMyInterface mock = Substitute.For<IMyInterface>();

        // Act
        mock.Sort(x => x.OrderBy(y => y));

        // Assert
        mock.Received().Sort(x => x.OrderBy(y => y));
    }
}

[TestFixture]
公共班级1
{
[测试]
当调用调用传递参数（）时的公共无效排序
{
//安排
IMyInterface mock=替换.For（）；
//表演
mock.Sort（x=>x.OrderBy（y=>y））；
//断言
mock.Received（）.Sort（x=>x.OrderBy（y=>y））；
}
}

---

我也尝试了参数匹配器，但总是失败。

挑战在于您的参数类型是

Func

，而不是

Expression

。使用表达式，您可以检查树以检查方法名称等

但是，您可以针对具体的示例对

OrderBy

进行单元测试（例如，与

OrderByDescending（）

相反，因为给定一组整数

6,4

OrderBy（）

将始终将其重新排序为

4,6

。因此，以下方法可行：

  [TestFixture]
  public class Class1
  {
    [Test]
    public void Sort_WhenCalled_CallsWithPassedArgument()
    {
      // Arrange
      IMyInterface mock = Substitute.For<IMyInterface>();

      Func<IEnumerable<int>, IOrderedEnumerable<int>> func = null;
      mock.WhenForAnyArgs(x => x.Sort(Arg.Any<Func<IEnumerable<int>, IOrderedEnumerable<int>>>())).Do(
        x =>
          {
            func = x.Arg<Func<IEnumerable<int>, IOrderedEnumerable<int>>>();
          });

      // Act
      mock.Sort(x => x.OrderBy(y => y));

      // Assert
      var result = func(new[] { 6, 4 });

      Assert.That(result.FirstOrDefault(), Is.Not.EqualTo(6));
      Assert.That(result.FirstOrDefault(), Is.EqualTo(4));
    }
  }

[TestFixture]
公共班级1
{
[测试]
当调用调用传递参数（）时的公共无效排序
{
//安排
IMyInterface mock=替换.For（）；
Func Func=null；
mock.WhenForAnyArgs（x=>x.Sort（Arg.Any（））.Do(
x=>
{
func=x.Arg（）；
});
//表演
mock.Sort（x=>x.OrderBy（y=>y））；
//断言
var result=func（新[]{6,4}）；
Assert.That（result.FirstOrDefault（），Is.Not.EqualTo（6））；
Assert.That（result.FirstOrDefault（），Is.EqualTo（4））；
}
}

---

当然，逻辑有些脆弱，因此您需要确定是否真的要测试func中是否使用了精确的方法（然后可能重构代码以允许通过其他方式检查此特定方法，或者切换到

表达式
）或者仅仅是行为就足够了。
挑战在于您的参数类型是
Func
，而不是
Expression
。使用Expression，您可以检查树以检查方法名称等

但是，您可以针对具体的示例对
OrderBy
进行单元测试（例如，与
OrderByDescending（）
相反，因为给定一组整数
6,4
OrderBy（）
将始终将其重新排序为
4,6
。因此，以下方法可行：

  [TestFixture]
  public class Class1
  {
    [Test]
    public void Sort_WhenCalled_CallsWithPassedArgument()
    {
      // Arrange
      IMyInterface mock = Substitute.For<IMyInterface>();

      Func<IEnumerable<int>, IOrderedEnumerable<int>> func = null;
      mock.WhenForAnyArgs(x => x.Sort(Arg.Any<Func<IEnumerable<int>, IOrderedEnumerable<int>>>())).Do(
        x =>
          {
            func = x.Arg<Func<IEnumerable<int>, IOrderedEnumerable<int>>>();
          });

      // Act
      mock.Sort(x => x.OrderBy(y => y));

      // Assert
      var result = func(new[] { 6, 4 });

      Assert.That(result.FirstOrDefault(), Is.Not.EqualTo(6));
      Assert.That(result.FirstOrDefault(), Is.EqualTo(4));
    }
  }

[TestFixture]
公共班级1
{
[测试]
当调用调用传递参数（）时的公共无效排序
{
//安排
IMyInterface mock=替换.For（）；
Func Func=null；
mock.WhenForAnyArgs（x=>x.Sort（Arg.Any（））.Do(
x=>
{
func=x.Arg（）；
});
//表演
mock.Sort（x=>x.OrderBy（y=>y））；
//断言
var result=func（新[]{6,4}）；
Assert.That（result.FirstOrDefault（），Is.Not.EqualTo（6））；
Assert.That（result.FirstOrDefault（），Is.EqualTo（4））；
}
}

当然，逻辑有些脆弱，因此您需要确定是否真的要测试func中是否使用了精确的方法（然后可能重构代码以允许通过其他方式检查此特定方法，或者切换到
表达式
）或者你的行为就足够了。
作为参考谢谢。这不是我所期望的，但现在我知道它不像我想的那么简单。作为参考谢谢。这不是我所期望的，但现在我知道它不像我想的那么简单。