在 Moq 中模拟通用方法而不指定 T

Question

我有一个带有方法的接口，如下所示：

public interface IRepo
{
    IA<T> Reserve<T>();
}

我想模拟包含此方法的类，而不必为它可以用于的每种类型指定 Setup 方法。 理想情况下，我只想返回一个new mock<T>.Object 。

我如何实现这一目标？

看来我的解释不清楚。 这是一个示例 - 当我指定 T（此处为字符串）时，这现在是可能的：

[TestMethod]
public void ExampleTest()
{
    var mock = new Mock<IRepo>();
    mock.Setup(pa => pa.Reserve<string>()).Returns(new Mock<IA<string>>().Object);
}

我想实现的是这样的：

[TestMethod]
public void ExampleTest()
{
    var mock = new Mock<IRepo>();
    mock.Setup(pa => pa.Reserve<T>()).Returns(new Mock<IA<T>>().Object);
    // of course T doesn't exist here. But I would like to specify all types
    // without having to repeat the .Setup(...) line for each of them.
}

被测对象的某些方法可能会为三种或四种不同类型调用储备。 如果我必须设置所有类型，我必须为每个测试编写大量设置代码。 但是在单个测试中，我并不关心所有这些，我只需要非空的模拟对象，除了我实际测试的对象（我很乐意为其编写更复杂的设置）。

Answer 1

在 Moq 4.13 中，他们引入了 It.IsAnyType 类型，您可以使用它来模拟泛型方法。 例如

public interface IFoo
{
    bool M1<T>();
    bool M2<T>(T arg);
}

var mock = new Mock<IFoo>();
// matches any type argument:
mock.Setup(m => m.M1<It.IsAnyType>()).Returns(true);

// matches only type arguments that are subtypes of / implement T:
mock.Setup(m => m.M1<It.IsSubtype<T>>()).Returns(true);

// use of type matchers is allowed in the argument list:
mock.Setup(m => m.M2(It.IsAny<It.IsAnyType>())).Returns(true);
mock.Setup(m => m.M2(It.IsAny<It.IsSubtype<T>>())).Returns(true);

Answer 2

只需这样做：

[TestMethod]
public void ExampleTest()
{
  var mock = new Mock<IRepo> { DefaultValue = DefaultValue.Mock, };
  // no setups needed!

  ...
}

由于您的模拟没有行为Strict ，它会对您甚至没有设置的调用感到满意。 在这种情况下，只会返回“默认值”。 然后

DefaultValue.Mock

确保这个“默认”是一个适当类型的新Mock<> ，而不仅仅是一个空引用。

这里的限制是您无法控制（例如对其进行特殊设置）返回的各个“子模拟”。

Answer 3

除非我误解了您的需求，否则您可以构建这样的方法：

private Mock<IRepo> MockObject<T>()
{
    var mock = new Mock<IRepo>();
    return mock.Setup(pa => pa.Reserve<T>())
        .Returns(new Mock<IA<T>>().Object).Object;
}

Answer 4

我找到了一个我认为更接近你想要的选择。 无论如何，它对我很有用，所以在这里。 这个想法是创建一个几乎完全抽象的中间类，并实现您的接口。 不抽象的部分是 Moq 无法处理的部分。 例如

public abstract class RepoFake : IRepo
{
    public IA<T> Reserve<T>()
    {
        return (IA<T>)ReserveProxy(typeof(T));
    }

    // This will be mocked, you can call Setup with it
    public abstract object ReserveProxy(Type t);

    // TODO: add abstract implementations of any other interface members so they can be mocked
}

现在你可以模拟RepoFake而不是 IRepo。 除了您在ReserveProxy而不是Reserve上编写设置之外，一切都相同。 如果您想根据类型执行断言，您可以处理回调，尽管ReserveProxy的Type参数是完全可选的。

Answer 5

这是一种似乎有效的方法。 如果您在 IRepo 中使用的所有类都继承自一个基类，您可以按原样使用它，而不必更新它。

public Mock<IRepo> SetupGenericReserve<TBase>() where TBase : class
{
    var mock = new Mock<IRepo>();
    var types = GetDerivedTypes<TBase>();
    var setupMethod = this.GetType().GetMethod("Setup");

    foreach (var type in types)
    {
        var genericMethod = setupMethod.MakeGenericMethod(type)
            .Invoke(null,new[] { mock });
    }

    return mock;
}

public void Setup<TDerived>(Mock<IRepo> mock) where TDerived : class
{
    // Make this return whatever you want. Can also return another mock
    mock.Setup(x => x.Reserve<TDerived>())
        .Returns(new IA<TDerived>());
}

public IEnumerable<Type> GetDerivedTypes<T>() where T : class
{
    var types = new List<Type>();
    var myType = typeof(T);

    var assemblyTypes = myType.GetTypeInfo().Assembly.GetTypes();

    var applicableTypes = assemblyTypes
        .Where(x => x.GetTypeInfo().IsClass 
                && !x.GetTypeInfo().IsAbstract 
                 && x.GetTypeInfo().IsSubclassOf(myType));

    foreach (var type in applicableTypes)
    {
        types.Add(type);
    }

    return types;
}

否则，如果您没有基类，您可以修改 SetupGenericReserve 以不使用 TBase 类型参数，而只是创建您要设置的所有类型的列表，如下所示：

public IEnumerable<Type> Alternate()
{
    return new [] 
    {
        MyClassA.GetType(),
        MyClassB.GetType()
    }
}

注意：这是为 ASP.NET Core 编写的，但应该适用于除 GetDerivedTypes 方法之外的其他版本。

Answer 6

我找不到任何关于使用 Moq 使用通用模拟方法模拟通用方法的信息。 到目前为止，我发现的唯一一件事是模拟每个特定类型的泛型方法，这无济于事，因为一般来说，您无法真正提前预见泛型参数的所有可能情况/变化。

所以我通过创建我自己的那个接口的假/空实现来解决这种问题，而不是使用 Moq。

在您的情况下，它看起来像这样：

public interface IRepo
{
    IA<T> Reserve<T>();
}

public class FakeRepo : IRepo
{
    public IA<T> Reserve<T>()
    {
        // your logic here
    }
}

之后，只需注入那个虚假的实现来代替 IRepo 的使用。

Answer 7

在我的例子中，我有一个泛型函数 begin 被测试类调用。 由于决定具体类型的测试类我无法通过测试。 我找到了一个解决方案，我只调用 setup 两次，对于测试类使用的每个具体类型一次，显示比解释更容易。

顺便说一句，我正在使用Moq.AutoMock库

using Xunit;
using System;
using Moq;
using Moq.AutoMock;

namespace testexample
{
    public class Foo
    {
        // This is the generic method that I need to mock
        public virtual T Call<T>(Func<T> f) => f();
    }

    public class Bar
    {
        private readonly Foo Foo;
        public Bar(Foo foo)
        {
            Foo = foo;
        }

        public string DoSomething()
        {
            // Here I call it twice, with distinct concrete types.
            var x1 = Foo.Call<string>(() => "hello");
            var x2 = Foo.Call<int>(() => 1);
            return $"{x1} {x2}";
        }
    }

    public class UnitTest1
    {
        [Fact]
        public void Test1()
        {
            var mock = new AutoMocker();

            // Here I setup Call twice, one for string
            // and one for int.
            mock.Setup<Foo, string>(x => x.Call<string>(It.IsAny<Func<string>>()))
                .Returns<Func<string>>(f => "mocked");
            mock.Setup<Foo, int>(x => x.Call<int>(It.IsAny<Func<int>>()))
                .Returns<Func<int>>(f => 2000);

            var bar = mock.CreateInstance<Bar>();

            // ... and Voila!
            Assert.Equal("mocked 2000", bar.DoSomething());
        }

        [Fact]
        public void Test2()
        {
            var bar = new Bar(new Foo());
            Assert.Equal("hello 1", bar.DoSomething());
        }
    }
}