To mock an object, does it have to be either implementing an interface or marked virtual?

by

To mock a type, it must either be an interface (this is also called being pure virtual) or have virtual members (abstract members are also virtual).

By this definition, you can mock everything which is virtual.

Essentially, dynamic mocks don’t do anything you couldn’t do by hand.

Let’s say you are programming against an interface such as this one:

public interface IMyInterface
{
    string Foo(string s);
}

You could manually create a test-specific implementation of IMyInterface that ignores the input parameter and always returns the same output:

public class MyClass : IMyInterface
{
    public string Foo(string s)
    {
        return "Bar";
    }
}

However, that becomes repetitive really fast if you want to test how the consumer responds to different return values, so instead of coding up your Test Doubles by hand, you can have a framework dynamically create them for you.

Imagine that dynamic mocks really write code similar to the MyClass implementation above (they don’t actually write the code, they dynamically emit the types, but it’s an accurate enough analogy).

Here’s how you could define the same behavior as MyClass with Moq:

var mock = new Mock<IMyInterface>();
mock.Setup(x => x.Foo(It.IsAny<string>())).Returns("Bar");

In both cases, the construcor of the created class will be called when the object is created. As an interface has no constructor, this will normally be the default constructor (of MyClass and the dynamically emitted class, respectively).

You can do the same with concrete types such as this one:

public class MyBase
{
    public virtual string Ploeh()
    {
        return "Fnaah";
    }
}

By hand, you would be able to derive from MyBase and override the Ploeh method because it’s virtual:

public class TestSpecificChild : MyBase
{
    public override string Ploeh()
    {
        return "Ndøh";
    }
}

A dynamic mock library can do the same, and the same is true for abstract methods.

However, you can’t write code that overrides a non-virtual or internal member, and neither can dynamic mocks. They can only do what you can do by hand.

Caveat: The above description is true for most dynamic mocks with the exception of TypeMock, which is different and… scary.

More Related Contents:

  1. Using Moq to mock only some methods
  2. What is the purpose of Verifiable() in Moq?
  3. Mocking Extension Methods with Moq
  4. How do I mock the HttpContext in ASP.NET MVC using Moq?
  5. How do I use Moq to mock an extension method?
  6. How to mock non virtual methods?
  7. How to mock an async repository with Entity Framework Core
  8. Mocking Asp.net-mvc Controller Context
  9. Mocking Static Methods
  10. How to mock static methods in c# using MOQ framework?
  11. Mock static property with moq
  12. How to mock the new HttpClientFactory in .NET Core 2.1 using Moq
  13. How can I tell Moq to return a Task?
  14. Using Moq to mock an asynchronous method for a unit test
  15. Is it possible to mock out a .NET HttpWebResponse?
  16. Using Moq to determine if a method is called
  17. Moq + Unit Testing – System.Reflection.TargetParameterCountException: Parameter count mismatch
  18. How to unit test with ILogger in ASP.NET Core
  19. How to mock ConfigurationManager.AppSettings with moq
  20. Why does the property I want to mock need to be virtual?
  21. How to test method call order with Moq
  22. What is the difference between passing It.IsAny() and the value of It.IsAny() to a method setup
  23. Moq – Non-overridable members may not be used in setup / verification expressions
  24. How do I mock User.Identity.GetUserId()?
  25. How do I Moq a method that has an optional argument in its signature without explicitly specifying it or using an overload?
  26. Mocking generic methods in Moq without specifying T
  27. How to throw a SqlException when needed for mocking and unit testing?
  28. Mocking generic method call for any given type parameter
  29. Using Moq to override virtual methods in the same class
  30. How to (should I) mock DocumentClient for DocumentDb unit testing?

Leave a Comment