Mocking generic methods in Moq without specifying T

Question

I have an interface with a method as follows:

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

I would like to mock the class that contains this method without having to specify Setup methods for every type it could be used for. Ideally, I'd just like it to return a new mock<T>.Object.

How do I achieve this?

It seems my explanation was unclear. Here's an example - this is possible right now, when I specify the T (here, string):

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

What I would like to achieve is something like this:

[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. } 

Some methods of the object under test might call reserve for three or four different types. If I have to setup all the types I have to write a lot of setup code for every test. But in a single test, I am not concerned with all of them, I simply need non-null mocked objects except for the one that I am actually testing (and for which I gladly write a more complex setup).

Answer 1

In Moq 4.13 they introduced the It.IsAnyType type which you can using to mock generic methods. E.g.

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

Simply do this:

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

Since your mock does not have behavior Strict, it will be happy with calls that you haven't even set up. In that case a "default" is simply returned. Then

DefaultValue.Mock 

ensures that this "default" is a new Mock<> of appropriate type, instead of just a null reference.

The limitation here is that you cannot control (e.g. make special setups on) the individual "sub-mocks" that are returned.