调用相同类中其他方法的单元测试方法的最佳方法

我最近正在和一些朋友讨论以下两种方法中哪一种最适合从同一个类中的方法中返回结果或调用同一个类中的方法。

这是一个非常简化的示例。实际上，功能要复杂得多。

例：

public class MyClass
{
     public bool FunctionA()
     {
         return FunctionB() % 2 == 0;
     }

     protected int FunctionB()
     {
         return new Random().Next();
     }
}

因此，要测试这一点，我们有2种方法。

方法1：使用函数和操作来替换方法的功能。例：

public class MyClass
{
     public Func<int> FunctionB { get; set; }

     public MyClass()
     {
         FunctionB = FunctionBImpl;
     }

     public bool FunctionA()
     {
         return FunctionB() % 2 == 0;
     }

     protected int FunctionBImpl()
     {
         return new Random().Next();
     }
}

[TestClass]
public class MyClassTests
{
    private MyClass _subject;

    [TestInitialize]
    public void Initialize()
    {
        _subject = new MyClass();
    }

    [TestMethod]
    public void FunctionA_WhenNumberIsOdd_ReturnsTrue()
    {
        _subject.FunctionB = () => 1;

        var result = _subject.FunctionA();

        Assert.IsFalse(result);
    }
}

方法2：使成员成为虚拟成员，派生类，并在派生类中使用“功能和操作”替换功能示例：

public class MyClass
{     
     public bool FunctionA()
     {
         return FunctionB() % 2 == 0;
     }

     protected virtual int FunctionB()
     {
         return new Random().Next();
     }
}

public class TestableMyClass
{
     public Func<int> FunctionBFunc { get; set; }

     public MyClass()
     {
         FunctionBFunc = base.FunctionB;
     }

     protected override int FunctionB()
     {
         return FunctionBFunc();
     }
}

[TestClass]
public class MyClassTests
{
    private TestableMyClass _subject;

    [TestInitialize]
    public void Initialize()
    {
        _subject = new TestableMyClass();
    }

    [TestMethod]
    public void FunctionA_WhenNumberIsOdd_ReturnsTrue()
    {
        _subject.FunctionBFunc = () => 1;

        var result = _subject.FunctionA();

        Assert.IsFalse(result);
    }
}

我想知道更好，为什么？

更新：注意：FunctionB也可以是公共的

在原始海报更新后进行编辑。

免责声明：不是C＃程序员（主要是Java或Ruby）。我的答案是：我根本不会测试它，而且我不认为您应该这样做。

较长的版本是：私有/受保护的方法不是API的组成部分，它们基本上是实现选择，您可以决定对其进行查看，更新或完全丢弃，而不会影响外部。

我想您对FunctionA（）进行了测试，这是从外部可见的类的一部分。它应该是唯一具有实施合同（并且可以进行测试）的合同。您的私人/受保护方法没有履行和/或测试的合同。

在那里查看相关讨论：https : //stackoverflow.com/questions/105007/should-i-test-private-methods-or-only-public-ones

注释之后，如果FunctionB是公共的，我将仅使用单元测试对它们进行测试。您可能会认为FunctionA的测试并非完全是“单元”（因为它称为FunctionB），但我对此不必太担心：如果FunctionB测试有效但FunctionA测试无效，则意味着问题不在FunctionB的子域，对我来说，足以作为区分符。

如果您确实希望能够将两个测试完全分开，那么在测试FunctionA时（通常，返回固定的已知正确值），我将使用某种模拟技术来模拟FunctionB。我缺乏C＃生态系统知识来建议特定的模拟库，但是您可能会看到这个问题。

我赞成这样一种理论，即如果一个功能对测试很重要或对替换很重要，那么它就足够重要，而不是成为被测类的私有实现细节，而是成为不同类的公共实现细节。

因此，如果我处于

class A 
{
     public B C()
     {
         D();
     }

     private E D();
     {
         // i actually want to control what this produces when I test C()
         // or this is important enough to test on its own
         // and, typically, both of the above
     }
}

然后我要重构。

class A 
{
     ICollaborator collaborator;

     public A(ICollaborator collaborator)
     {
         this.collaborator = collaborator;
     }

     public B C()
     {
         collaborator.D();
     }
}

现在，我有一个方案，其中D（）是可独立测试的，并且可以完全替换。

作为组织的一种方式，我的协作者可能不在同一个命名空间级别。例如，如果A在FooCorp.BLL中，则我的协作者可能会更深一层，例如在FooCorp.BLL.Collaborators中（或任何合适的名称）。我的合作者可能还只能通过internalaccess修饰符在程序集内部可见，然后我也可以通过InternalsVisibleToassembly属性将其公开给我的单元测试项目。得出的结论是，就调用者而言，您仍然可以保持API干净，同时生成可验证的代码。

再加上马丁指出，

如果您的方法是私有/受保护的-请勿对其进行测试。它是类的内部内容，不应在类外部访问。

在您提到的两种方法中，我都有这些担忧-

方法1-这实际上更改了测试中被测类的行为。

方法2-这实际上不测试生产代码，而是测试另一个实现。

在陈述的问题中，我看到A的唯一逻辑是查看FunctionB的输出是否为偶数。尽管是说明性的，但FunctionB给出了Random值，很难测试。

我期望有一个现实的场景，在这里我们可以设置MyClass，以便我们知道FunctionB将返回什么。然后我们的预期结果已知，我们可以调用FunctionA并对实际结果进行断言。

我个人使用Method1，即将所有方法都转换为Actions或Funcs，因为这对我来说极大地提高了代码可测试性。与任何解决方案一样，此方法也有优缺点：

优点

1. 允许使用简单的代码结构，其中仅将代码模式用于单元测试可能会增加额外的复杂性。
2. 允许密封类，并消除流行的模拟框架（如Moq）所需的虚拟方法。密封类并消除虚拟方法使它们成为内联和其他编译器优化的候选对象。（https://msdn.microsoft.com/zh-cn/library/ff647802.aspx）
3. 简化可测试性，因为在单元测试中替换Func / Action实现就像将新值分配给Func / Action一样简单
4. 还允许测试是否从另一个方法调用了静态Func，因为无法模拟静态方法。
5. 易于将现有方法重构为Funcs / Action，因为在调用站点上调用方法的语法保持不变。（对于无法将方法重构为Func / Action的情况，请参见缺点）

缺点

1. 如果可以派生您的类，则不能使用Funcs / Action，因为Funcs / Action没有像方法那样的继承路径
2. 无法使用默认参数。使用默认参数创建Func需要创建一个新的委托，这可能会使代码根据使用情况而造成混乱
3. 不能使用命名参数语法来调用类似方法（firstName：“ S”，lastName：“ K”）
4. 最大的缺点是您无法访问Funcs and Actions中的“ this”引用，因此必须将对类的任何依赖项显式传递为参数。如您所知，所有依赖关系都很好，但是如果您有Func将依赖的许多属性，那么就不好了。您的里程将根据您的用例而有所不同。

综上所述，如果您知道自己的类永远不会被覆盖，那么使用Funcs和Actions进行单元测试非常有用。

另外，我通常不为Funcs创建属性，而是直接内联它们

public class MyClass
{
     public Func<int> FunctionB = () => new Random().Next();

     public bool FunctionA()
     {
         return FunctionB() % 2 == 0;
     }
}

希望这可以帮助！

使用模拟可能。Nuget：https：//www.nuget.org/packages/moq/

并相信我，它相当简单且有意义。

public class SomeClass
{
    public SomeClass(int a) { }

    public void A()
    {
        B();
    }

    public virtual void B()
    {

    }
}

[TestFixture]
public class Test
{
    [Test]
    public void Test_A_Calls_B()
    {
        var mockedObject = new Mock<SomeClass>(5); // You can also specify constructor arguments.
        //You can also setup what a function can return.
        var obj = mockedObject.Object;
        obj.A();

        Mock.Get(obj).Verify(x=>x.B(),Times.AtLeastOnce);//This test passes
    }
}

模拟需要虚拟方法来覆盖。