具有统一容器和泛型的模拟（Moq）

Question

I have a Container interface with a generic resolve method which, when implemented, resolves using Unity.

public interface IContainer
{
    T Resolve<T>();
}

Currently there is a Mock Container class:

public class MockContainer : IContainer {
    public T Resolve<T>()
    {            
        return default(T);
    }
}

But I want to use Moq for consistency and do the equivalent:

mockContainer
    .Setup(container => container.Resolve<T>())
    .Returns(default(T));

But I get 2 compile errors 'T' could not be found

Is the Moq syntax wrong, am I missing a reference or can this just not be done?

Edit I know that mocking the container is not ideal. I could resolve each class one-by-one in my setup code.

My question is whether there is some Moq syntax to perform the equivalent of my actual container.

Answer 1

You usually can't do this (set up generic methods without specifying a type), but if you only want to return default(T) and don't care if the function is called at all, it's enough to simply create the mock without calling Setup :

var mockZincContainer = new Mock<IContainer>();

// works just fine
mockZincContainer.Object.Resolve<DateTime>(); // returns default(DateTime)
mockZincContainer.Object.Resolve<object>(); // returns default(object)

You can even return mocks instead of default(T) by changing the DefaultValue property of the mock from DefaultValue.Empty to DefaultValue.Mock .

Answer 2

You don't need to derive a mock object from your interface. So get rid of MockContainer.

In your unit test you should at that point know what types you want to test. So at that point, just give it a real type and tell it what to return.

ie

//arrange
mockZincContainer
    .Setup(container => container.Resolve<ISomeInterface>())
    .Returns(new ConcreteClassThatDerivesFromSomeInterface());
var testClass = new ClassToBeTested(mockZincContainer.Object);

//act
testClass.DoYourMethod();

//assert
mockZincContainer.Verify(c => c.Resolve<ISomeInterface>(), Times.Once);

Answer 3

Why would you mock the container? This is more of an integration concern. All of your code should be testable without having a container wire them up. Mocking the container to return a dependency which you are then passing in to consuming classes seems like a big waste of time to me.