使用 Typemock 伪造每个父级的所有实例

Question

我最近开始使用 Typemock 并查看了至少六个现有线程，但似乎无法找到我确切问题的答案。

我有一个派生自 B 的类 C，它本身派生自 A。C 的实例是我需要测试的，因此需要是真实的。但由于 C 派生自 B（间接派生自 A），因此我需要在创建 C 的实例时完全自动伪造这两个类。

见下文：

class A
{
    protected int methodA()
    {
        return 1;
    }
}

class B : A
{
    protected int methodB()
    {
        return 5;
    }
}

class C : B
{
    public int methodC()
    {
        return methodA() * methodB();
    }
}

class Test
{
    public Test()
    {
        A fake_A = Isolate.Fake.AllInstances<A>(Members.ReturnRecursiveFakes, ConstructorWillBe.Ignored);
        Isolate.NonPublic.WhenCalled(fake_A, "methodA").DoInstead((MethodCallContext ctx) =>
            {
                return 2;
            }
        );

        B fake_B = Isolate.Fake.AllInstances<B>(Members.ReturnRecursiveFakes, ConstructorWillBe.Ignored);
        Isolate.NonPublic.WhenCalled(fake_B, "methodB").DoInstead((MethodCallContext ctx) =>
            {
                return 10;
            }
        );

        C c = new C(); // Would expect A and B to be faked automatically since I've faked all instances above. 
        int method_c_val = c.methodC(); // I get back 5, but what I need returned is 20.
    }
}

这是我所面临问题的一​​个极其简化的版本。这不仅仅是在父类中伪造一两个方法的行为。需要伪造整个父级层次结构。所以 A 和 B 都需要完全伪造，而不是部分伪造。

我已经看过的线程之一是这个，但那里的答案指向一个不再可用的地址：

https://www.typemock.com/answers/11613/mocking-all-instances-of-a-base-class

Answer 1

正如@Nkosi 建议的那样，您可以使用：

C c = Isolate.Fake.Instance<C>(Memebers.CallOriginal);
Isoalte.NonPublic.WhenCalled(c,"methodA").WillReturn(2);
Isoalte.NonPublic.WhenCalled(c,"methodB").WillReturn(10);

你伪造了 C 对象，但它的方法仍然调用原始实现（如果需要），并且你只伪造了有问题的方法。

Answer 2

我不熟悉 typemock，但如果您无法获得答案、控制有问题的代码并能够修改它，我可以建议另一种可能的解决方法。

制作有问题的方法virtual，赋予派生类覆盖它们的能力。

class A
{
    protected virtual int methodA()
    {
        return 1;
    }
}

class B : A
{
    protected virtual int methodB()
    {
        return 5;
    }
}

class C : B
{
    public int methodC()
    {
        return methodA() * methodB();
    }
}

要单独测试 methodC，您可以创建一个派生自 C 的存根类 D，它会覆盖相关方法。

class D : C
{
    protected override int methodA()
    {
        return 2;
    }

    protected override int methodB()
    {
        return 10;
    }
}

这样，测试将按预期执行。

[TestClass]
public class Test
{
    [TestMethod]
    public void TestMethodC()
    {
        //Arrange
        var expected = 20;
        var c = new D();

        //Act
        int actual = c.methodC();

        //Assert
        Assert.AreEqual(expected, actual);
    }
}

我认为使用 typemock 你需要通过伪装C 来做类似的事情，并且只隔离有问题的两个依赖方法，让被测方法自然调用。但是我又不是很熟悉那个框架。