C# Nsubstitute：为单元测试模拟对象参数

我对Nsubstitute和单元测试是相当陌生的。 我知道在单元测试中，您不关心任何其他依赖项。所以为了应用这个规则，我们模拟单位

我有一个要测试的示例代码，其中一个方法有一个对象参数：

class dependency {
  public int A;
  public dependency() {
    // algorithms going on ...
    A = algorithm_output;
  }
}

class toTest {
  public int Xa;
  public void Foo(dependency dep_input){
    Xa = dep_input.A;
    // Xa will be used in an algorithm ...
  }
}

我想模仿构造函数，但我不知道如何在Nsubstitute中实现。

---

那么最终，我该如何测试这一点呢？

我不能添加注释，因为它太长了，所以我添加了一个答案： 如果要测试

Foo

，则不需要模拟ctor，而是

dep\u input

。例如，如果您使用。但也可以使用存根

public interface IDependency
{
    int A { get; }
}

public class Dependency : IDependency
{
    public int A { get; private set; }

    public Dependency()
    {
        // algorithms going on ...
        A = algorithm_output();
    }

    private static int algorithm_output()
    {
        return 42;
    }
}

public class ToTest
{
    public int Xa;

    public void Foo(IDependency dep_input)
    {
        Xa = dep_input.A;
        // Xa will be used in an algorithm ...
    }
}

[TestFixture]
public class TestClass
{
    [Test]
    public void TestWithMoq()
    {
        var dependecyMock = new Mock<IDependency>();
        dependecyMock.Setup(d => d.A).Returns(23);

        var toTest = new ToTest();
        toTest.Foo(dependecyMock.Object);

        Assert.AreEqual(23, toTest.Xa);
        dependecyMock.Verify(d => d.A, Times.Once);
    }

    [Test]
    public void TestWithStub()
    {
        var dependecyStub = new DependencyTest();

        var toTest = new ToTest();
        toTest.Foo(dependecyStub);

        Assert.AreEqual(23, toTest.Xa);
    }

    internal class DependencyTest : IDependency
    {
        public int A
        {
            get
            {
                return 23;
            }
        }
    }
}

公共接口独立性
{
int A{get；}
}
公共类依赖：IDependency
{
public int A{get；private set；}
公共依赖性（）
{
//正在进行的算法。。。
A=算法_输出（）；
}
私有静态int算法_输出（）
{
返回42；
}
}
公共类图腾测试
{
公共int Xa；
公共void Foo（独立部门输入）
{
Xa=dep_输入.A；
//Xa将用于一个算法。。。
}
}
[测试夹具]
公共类TestClass
{
[测试]
使用MOQ（）的公共无效测试
{
var dependecyMock=new Mock（）；
dependecyMock.Setup（d=>d.A）.Returns（23）；
var toTest=新toTest（）；
toTest.Foo（dependcymock.Object）；
AreEqual（23，toTest.Xa）；
dependecyMock.Verify（d=>d.A，Times.one）；
}
[测试]
公共空间
{
var dependendcystub=新的DependencyTest（）；
var toTest=新toTest（）；
toTest.Foo（dependcystub）；
AreEqual（23，toTest.Xa）；
}
内部类依赖性测试：IDependency
{
公共INTA
{
得到
{
返回23；
}
}
}
}

我无法添加注释，因为注释太长，所以我添加了一个答案： 如果要测试

Foo

，则不需要模拟ctor，而是

dep\u input

。例如，如果您使用。但也可以使用存根

public interface IDependency
{
    int A { get; }
}

public class Dependency : IDependency
{
    public int A { get; private set; }

    public Dependency()
    {
        // algorithms going on ...
        A = algorithm_output();
    }

    private static int algorithm_output()
    {
        return 42;
    }
}

public class ToTest
{
    public int Xa;

    public void Foo(IDependency dep_input)
    {
        Xa = dep_input.A;
        // Xa will be used in an algorithm ...
    }
}

[TestFixture]
public class TestClass
{
    [Test]
    public void TestWithMoq()
    {
        var dependecyMock = new Mock<IDependency>();
        dependecyMock.Setup(d => d.A).Returns(23);

        var toTest = new ToTest();
        toTest.Foo(dependecyMock.Object);

        Assert.AreEqual(23, toTest.Xa);
        dependecyMock.Verify(d => d.A, Times.Once);
    }

    [Test]
    public void TestWithStub()
    {
        var dependecyStub = new DependencyTest();

        var toTest = new ToTest();
        toTest.Foo(dependecyStub);

        Assert.AreEqual(23, toTest.Xa);
    }

    internal class DependencyTest : IDependency
    {
        public int A
        {
            get
            {
                return 23;
            }
        }
    }
}

公共接口独立性
{
int A{get；}
}
公共类依赖：IDependency
{
public int A{get；private set；}
公共依赖性（）
{
//正在进行的算法。。。
A=算法_输出（）；
}
私有静态int算法_输出（）
{
返回42；
}
}
公共类图腾测试
{
公共int Xa；
公共void Foo（独立部门输入）
{
Xa=dep_输入.A；
//Xa将用于一个算法。。。
}
}
[测试夹具]
公共类TestClass
{
[测试]
使用MOQ（）的公共无效测试
{
var dependecyMock=new Mock（）；
dependecyMock.Setup（d=>d.A）.Returns（23）；
var toTest=新toTest（）；
toTest.Foo（dependcymock.Object）；
AreEqual（23，toTest.Xa）；
dependecyMock.Verify（d=>d.A，Times.one）；
}
[测试]
公共空间
{
var dependendcystub=新的DependencyTest（）；
var toTest=新toTest（）；
toTest.Foo（dependcystub）；
AreEqual（23，toTest.Xa）；
}
内部类依赖性测试：IDependency
{
公共INTA
{
得到
{
返回23；
}
}
}
}

您只能使用NSubstitute模拟接口和虚拟方法。构造函数是不可使用的，非虚拟或静态方法也是如此。也许你应该在你的类中添加一个接口？如果你想测试它的话，这个接口很可能就是你想要使用的。如果您仍然依赖于一个实际的类，那么您可能仍然在该类中运行代码，这可能会影响您的测试，并且您可能必须绕过该类中的某些行为，以使其适合您的测试。如果我无法更改要测试的代码（由于我正在工作的项目中的某些原因），该怎么办@LasseV.karlse如果您真的不能更改现有的代码，那么就不能模拟类

依赖关系。如果可以更改类
依赖关系
，则可以使用
inta添加接口
Idependency
并将
Foo
的ctor更改为
public void Foo（独立部门输入）
。现在，您可以为
dep\u输入模拟或创建存根
代码必须经过测试。许多遗留代码不能简单地测试，因为它从未被设计为允许测试。如果您无法更改代码，并且它不足以处理您想要使用它进行的测试，那么您的代码就属于这一类。您将不得不承担不测试它的风险，以及更改代码的成本和风险。如果你根本无法在梦中改变代码，并且它在当前的形式下是不可测试的，那么答案是：你不能自动测试它。增加手动测试以进行补偿。您只能使用NSubstitute模拟接口和虚拟方法。构造函数是不可使用的，非虚拟或静态方法也是如此。也许你应该在你的类中添加一个接口？如果你想测试它的话，这个接口很可能就是你想要使用的。如果您仍然依赖于一个实际的类，那么您可能仍然在该类中运行代码，这可能会影响您的测试，并且您可能必须绕过该类中的某些行为，以使其适合您的测试。如果我无法更改要测试的代码（由于我正在工作的项目中的某些原因），该怎么办@LasseV.karlse如果您真的不能更改现有的代码，那么就不能模拟类
依赖关系。如果可以更改类
依赖关系
，则可以使用
inta添加接口
Idependency
并将
Foo
的ctor更改为
public void Foo（独立部门输入）
。现在，您可以为
dep\u输入模拟或创建存根
代码必须经过测试。很多遗留代码都无法使用