How to write unit test for private method in c# using moq framework?

Question

I want to write unit test for private method in C# using moq framework, I've search in StackOverFlow and Google, but I cannot find the expected result. Please help me if you can.

Answer 1

You can't, at least not with Moq.

But more importantly, you shouldn't. First off, you don't test methods, you test behaviours. Second, in order to test behaviours, you exercise a type's public API and verify the outcomes of that exercise.

Private methods are implementation details. You don't want to verify how things get done, you want to verify that things do get done.

Answer 2

In the AssemblyInfo.cs of your project add

[assembly: InternalsVisibleTo("Namespace.OfYourUnitTest.Project")]

then you make the method internal instead of private.

It has the benefit of avoiding to make it public.

However as pointed by dcastro, some people strongly disagree with this way of testing.

Answer 3

Perhaps you shouldn't (see other answers for why), but you can do this using Microsoft's Visual Studio Test Tools. A simplified example is given below.

Given the following class which you want to test:

public class ClassToTest
{
    private int Duplicate(int n)
    {
        return n*2;
    }
}

You can use the following code to test the private Duplicate method:

using Microsoft.VisualStudio.TestTools.UnitTesting;

// ...

[TestMethod]
public void MyTestMethod()
{
    // Arrange
    var testClass = new ClassToTest();
    var privateObject = new PrivateObject(testClass);

    // Act
    var output = (int) privateObject.Invoke("Duplicate", 21);

    // Assert
    Assert.AreEqual(42, output);
}

Answer 4

Simply, you don't. Private methods are not visible to other classes.

There are a number of ways around this:

• Treat the private as part of the method you're testing, cover it in their unit tests. Think of the public methods as black boxes and test their operations.
• Make it protected and inherit your test class from the class you're testing (or use a partial - same idea)
• Make it public (which if you're coding to an interface doesn't actually expose it to your consumers)

For public methods (option three) it is possible to partial mock the class where you can replace the method. In Moq you can do this like this:

var moq = new Mock<MyClass>();
moq.CallBase = true;
moq.Setup(x => x.MyPublicMethodToOverride()).Returns(true);

There are more details here.

Answer 5

Moq supports mocking protected methods. Changing the methods to protected, instead of private, would allow you to mock their implementation.

The following is from Moq Quickstart Documentation (deep link):

Setting expectations for protected members (you can't get IntelliSense for these, so you access them using the member name as a string). Assuming the following class with a protected function should be mocked:

public class CommandBase {
    protected virtual int Execute();            // (1) 
    protected virtual bool Execute(string arg); // (2)
}
// at the top of the test fixture
using Moq.Protected;

// In the test, mocking the `int Execute()` method (1) 
var mock = new Mock<CommandBase>();
mock.Protected()
     .Setup<int>("Execute")
     .Returns(5);

// If you need argument matching, you MUST use ItExpr rather than It
// planning on improving this for vNext (see below for an alternative in Moq 4.8)
// Mocking the `bool Execute(string arg)` method (2)
mock.Protected()
    .Setup<bool>("Execute",
        ItExpr.IsAny<string>())
    .Returns(true);

Moq 4.8 and later allows you to set up protected members through a completely unrelated type that has the same members and thus provides the type information necessary for IntelliSense to work. Pickin up the example from the bullet point above, you can also use this interface to set up protected generic methods and those having by-ref parameters:

// Completely unrelated Interface (CommandBase is not derived from it) only created for the test.
// It contains a method with an identical method signature to the protected method in the actual class which should be mocked
interface CommandBaseProtectedMembers
{
    bool Execute(string arg);
}

mock.Protected().As<CommandBaseProtectedMembers>()
    .Setup(m => m.Execute(It.IsAny<string>()))  // will set up CommandBase.Execute
    .Returns(true);