Question

我想做模拟扩展方法，但它不起作用。如何才能做到这一点？

public static class RandomExtensions
{
    public static IEnumerable<int> NextInt32s(this System.Random random, int neededValuesNumber, int minInclusive, int maxExclusive)
    {
        // ...
    }
}

[Fact]
public void Select()
{
    var randomizer = Substitute.For<DefaultRandom>();
    randomizer.NextInt32s(3, 1, 10).Returns(new int[] { 1, 2, 3 });
}

Answer 1

NSubstitute不能按照Sriram的注释模拟扩展方法，但你仍然可以将一个模拟参数传递给扩展方法。

在这种情况下，Random类具有虚方法，因此我们可以直接使用NSubstitute和其他基于DynamicProxy的模拟工具来模拟它。（特别是对于NSubstitute，我们需要非常小心地模拟课程。请阅读the documentation中的警告。）

public static class RandomExtensions {
    public static IEnumerable<int> NextInt32s(this System.Random random, int neededValuesNumber, int minInclusive, int maxExclusive) { /* ... */ }
}
public class RandomExtensionsTests {
    [Test]
    public void Select()
    {
        const int min = 0, max = 10;
        var randomizer = Substitute.For<Random>();
        randomizer.Next(min, max).Returns(1, 2, 3);

        var result = randomizer.NextInt32s(3, 0, 10).ToArray();

        Assert.AreEqual(new[] {1, 2, 3}, result);
    }
}

Answer 2

是的，如果您创建IRandom之类的接口并扩展接口而不是实际实现，则可以进行模拟。然后你应该可以在你的测试类中模拟接口。

public interface IRandom
{   
}

public class Random : IRandom
{     
}

public static class RandomExtensions
{
    public static string NextInt32s(
        this IRandom random, 
        int neededValuesNumber, 
        int minInclusive, 
        int maxExclusive)
    {
    }
}

在您的测试类中添加：

IRandom randomizer = Substitute.For<IRandom>();
var result = randomizer.NextInt32s(3,0,10);

通过这个过程，你只是嘲笑界面而不是实际的类。

Answer 3

作为其他答案的扩展，这是我的解决方法。

想象一下，有一个接口IDoStuff，还有一个扩展了IDoStuff的库。您有一个实现MyClass的类IDoStuff，并且某人对接口使用扩展方法。看起来像这样；

using System;

interface IDoStuff
{
    string SayHello();
}

class MyClass : IDoStuff
{
    public string SayHello()
    {
        return "Hello";
    }
}

// somewhere someone wrote an extension method for IDoStuff

static class DoStuffExtensions
{
    static string SayHelloToBob(this IDoStuff other)
    {
        return other.SayHello() + " Bob";
    }
}

class UserOfIDoStuff
{
    void UseIDoStuff(IDoStuff incoming)
    {
        Console.WriteLine(incoming.SayHelloToBob());
    }
}

您要模拟IDoStuff，但不能模拟扩展方法SayHelloToBob。您可以做的是创建另一个实现IDoStuff但也包含SayHelloToBob的接口。

interface IDoStuffWithExtensions : IDoStuff
{
    string SayHelloToBob();
}

class MyClass : IDoStuffWithExtensions
{
    public string SayHello()
    {
        return "Hello";
    }

    // Wrap / internalise the extension method
    public string SayHelloToBob()
    {
        return DoStuffExtensions.SayHelloToBob(this);
    }
}

class UserOfIDoStuff
{
    void UseIDoStuff(IDoStuffWithExtensions incoming)
    {
        Console.WriteLine(incoming.SayHelloToBob());
    }
}

现在您可以愉快地嘲笑IDoStuffWithExtensions。

Answer 4

根据SOLID原则，依赖性反演定义了较低级别的模型不应该依赖于高级模型，而是依赖于类似接口的抽象，而模拟概念主要用于模拟接口，以便不测试低级模型。

NSubstitute模拟扩展方法

4 个答案: