Mocking an interface that extends another interface using Moq

Question

Hej Buddies!

I'm trying to create a mock for an interface like the one below:

public interface ITheInterface: IEnumerable
{
...
}

In these manners:

var theInterfaceMock = new Mock<ITheInterface>();
theInterfaceMock.Setup(x => x.OfType<SomeType>()).Returns(something);

and

var theInterfaceMock = new Mock<ITheInterface>();
theInterfaceMock.As<IEnumerable>();
theInterfaceMock.Setup(x => x.OfType<SomeType>()).Returns(something);

And in both cases I'm getting a System.NotSupportedException that basically tells me that that ITheInterface doesn't have the OfType() method (when it actually does have it). Anybody knows any way to solve this issue?.

Thank you!

Answer 1

OfType is not a method on the IEnumerable, it's an extension method called Enumberable.OfType .

This is why Moq is complaining I think. Since these are static classes, I think you'll need to use a tool like typemock .

Question is however. Why you need to mock OfType()? You can trust that the microsoft implementation of Enumberable.OfType works. So just mock the the IEnumberable interface (GetEnumerator) , and return a mock that support IEnumerator, that OfType will use.

Answer 2

IEnumerable has no method named OfType ... are you looking for IEnumerable? - Even there OfType is just an extension method and you would have to mock the Enumerable-class and it's static members. I don't think Moq can do this - sorry.

Here are some related questions (with possible workarounds): How do I use Moq to mock an extension method? and Mock static property with moq

Answer 3

I believe the issue here is that OfType is an extension method. Since Moq (and other mocking frameworks) work by creating proxy objects/classes of the interfaces being mocked, it only has the ability to mock instance methods. Extension methods are just static methods in disguise.

Answer 4

As other already told OfType is not a method of the IEnumerable interface. However, you don't really need to mock it, all you need is to mock IEnumerable.GetEnumerator method which is pretty easy to do:

    var enumerable = new Mock<IEnumerable>();
    var something = new List<SomeType>
    {
        new SomeType(),
        new SomeType(),
        new SomeType(),
    };
    enumerable.Setup(_ => _.GetEnumerator()).Returns(something.GetEnumerator());

    Assert.That(enumerable.Object.OfType<SomeType>(), Is.EquivalentTo(something));

You just forward GetEnumerator method to one of the 'something' collection and that is all. You'll get all extension methods working for your mock automatically.