Advanced Usage

New to Telerik JustMock? Download free 30-day trial

Private Accessor

The Telerik JustMock PrivateAccessor feature allows you to call non-public members of the tested code right in your unit tests. The feature is enabled for both Free and Commercial versions of JustMock.

For arranging the behavior of non-public members, refer to the Mocking Non-public Members and Types topic.

Calling Private Methods

To call non-public methods with PrivateAccessor, you must:

  1. Wrap the instance holding the private method
  2. Call the non-public method by giving its exact name
  3. Assert against the result value

Let's take the following class as a sample that we need to test:

Sample setup

public class ClassWithNonPublicMembers 
{ 
    private int EchoPrivate() 
    { 
        return 1000; 
    } 
 
    private T EchoPrivateGeneric<T>(T arg) 
    { 
        return arg; 
    } 
}

Example 1: Call non-public method

[TestMethod] 
public void PrivateAccessor_ShouldCallMethod() 
{ 
    // Act 
    var inst = new PrivateAccessor(new ClassWithNonPublicMembers()); 
    var actual = inst.CallMethod("EchoPrivate"); 
 
    // Assert 
    Assert.AreEqual(1000, actual); 
}

You can also invoke a non-public method from a mocked instance. The following steps and code snippet demonstrate how to achieve that:

  1. Create a mocked instance of your class under test (you can also use original instance object and perform partial mocking later on)
  2. Arrange your expectations
  3. Then, create a new PrivateAccessor with the mocked instance as an argument
  4. Call the non-public method by giving its exact name
  5. Finally, you can assert against its expected return value

Example 2: Call non-public methods from a mocked instance

[TestMethod] 
public void ShouldCallArrangedPrivateMethod() 
{ 
    // Arrange 
    var mockedClass = Mock.Create<ClassWithNonPublicMembers>(Behavior.CallOriginal); 
 
    Mock.NonPublic.Arrange<int>(mockedClass, "EchoPrivate").Returns(5); 
 
    // Act 
    var inst = new PrivateAccessor(mockedClass); 
    var actual = inst.CallMethod("EchoPrivate"); 
 
    // Assert 
    Assert.AreEqual(5, actual); 
}

Using the steps listed above and supplying the type arguments, you can call non-public generic methods as well:

Example 3: Call non-public generic methods

[TestMethod] 
public void ShouldCallArrangedPrivateGenericMethod() 
{ 
    // Arrange 
    var mockedClass = Mock.Create<ClassWithNonPublicMembers>(Behavior.CallOriginal); 
 
    Mock.NonPublic.Arrange<int>(mockedClass, "EchoPrivateGeneric", new Type[] { typeof(int) }, 10).Returns(5); 
 
    // Act 
    var inst = new PrivateAccessor(mockedClass); 
    var actual = inst.CallMethodWithTypeArguments("EchoPrivateGeneric", new Type[] { typeof(int) }, 10); 
 
    // Assert 
    Assert.AreEqual(5, actual); 
}

Calling Static Private Methods

To call non-public static methods with the PrivateAccessor, you must:

  1. Wrap the instance holding the private method by type
  2. Call the non-public static method by giving its exact name
  3. Assert against the result value

Following is the sample class we will be using in the next examples:

Sample setup

public class ClassWithNonPublicMembers 
{ 
    private static int EchoStaticPrivate() 
    { 
        return 2000; 
    } 
 
    private static T EchoStaticPrivateGeneric<T>(T arg) 
    { 
        return arg; 
    } 
}

Example 4: Call non-public static method

[TestMethod] 
public void PrivateAccessor_ShouldCallStaticMethod() 
{ 
    // Act 
    var inst = PrivateAccessor.ForType(typeof(ClassWithNonPublicMembers)); 
    var actual = inst.CallMethod("EchoStaticPrivate"); 
 
    // Assert 
    Assert.AreEqual(2000, actual); 
}

If you need to call non-public static methods from a mocked instance, you should follow the steps listed below:

  1. Setup your class for static mocking (this is not needed if you are to perform partial mocking later on)
  2. Arrange your expectations
  3. Then, create new PrivateAccessor with the mocked instance type as an argument
  4. Call the non-public method by giving its exact name
  5. Finally, you can assert against its expected return value

Example 5: Call non-public static method from a mocked instance

[TestMethod] 
public void ShouldCallArrangedStaticPrivateMethod() 
{ 
    // Arrange 
    Mock.SetupStatic(typeof(ClassWithNonPublicMembers)); 
 
    Mock.NonPublic.Arrange<int>(typeof(ClassWithNonPublicMembers), "EchoStaticPrivate").Returns(5); 
 
    // Act 
    var inst = PrivateAccessor.ForType(typeof(ClassWithNonPublicMembers)); 
    var actual = inst.CallMethod("EchoStaticPrivate"); 
 
    // Assert 
    Assert.AreEqual(5, actual); 
}

Like a non-public generic instance methods, you can use PrivateAccessor to call non-public generic static ones, here is the sample test:

Example 6: Call non-public generic static method

[TestMethod] 
public void ShouldCallArrangedStaticPrivateGenericMethod() 
{ 
    // Arrange 
    Mock.SetupStatic(typeof(ClassWithNonPublicMembers)); 
 
    Mock.NonPublic.Arrange<int>(typeof(ClassWithNonPublicMembers), "EchoStaticPrivateGeneric", new Type[] { typeof(int) }, 10).Returns(5); 
 
    // Act 
    var inst = PrivateAccessor.ForType(typeof(ClassWithNonPublicMembers)); 
    var actual = inst.CallMethodWithTypeArguments("EchoStaticPrivateGeneric", new Type[] { typeof(int) }, 10); 
 
    // Assert 
    Assert.AreEqual(5, actual); 
}

Methods with ref and out Parameters

With PrivateAccessor, you can also test non-public methods that use ref or out parameters. The following list summarizes the steps you need to perform:

  1. Create an instance of the class (mocked or not)
  2. Arrange the desired behavior using Mock.NonPublic.Arrange
  3. Create an object[] that will hold the parameter values for the method under test
  4. Invoke the method using PrivateAccessor
  5. Assert the result

Let's take the following class as a sample:

Sample setup

public class Calculator 
{ 
    private void Sum(int a, int b, out int result) 
    { 
        result = a + b; 
    } 
 
    private void Add(ref int a, int b) 
    { 
        a += b; 
    } 
}

And following is how you can arrange tests for the Sum method and its out parameter.

Example 7: Arrange that a private method with out parameter should be called and verify the produced value

[TestMethod] 
public void TestMethodWithAnyOutParameter() 
{ 
    // Arrange 
    var calculator = new Calculator(); 
 
    // Arrange that the Sum method must be called at least once during the test execution with any int values for its parameters. 
    Mock.NonPublic.Arrange(calculator, "Sum", Arg.Expr.IsAny<int>(), Arg.Expr.IsAny<int>(), Arg.Expr.Ref(Arg.Expr.IsAny<int>())).CallOriginal().MustBeCalled(); 
 
    PrivateAccessor privateAccessor = new PrivateAccessor(calculator); 
 
    // This array corresponds to the parameters that are passed to the tested method. 
    var values = new object[] { 8, 2, 0 }; 
 
    // Act 
    privateAccessor.CallMethod("Sum", values); 
 
    // Assert 
    // Verify that the expectations set to the calculator object are met. 
    Mock.Assert(calculator); 
    // Check the value returned by the out parameter of the Sum method. 
    // It is stored as the last item of the values array as it is the last argument in the method signature.  
    Assert.AreEqual(10, values[2]); 
}

Example 8: Arrange that a private method with out parameter should be called and its out parameter should hold specific value

[TestMethod] 
public void TestMethodWithSpecificValueForOutParameter() 
{ 
    // Arrange 
    var calculator = new Calculator(); 
 
    // Arrange that the Sum method will output value of 22 and must be called at least once during the test execution. 
    Mock.NonPublic.Arrange(calculator, "Sum", Arg.Expr.AnyInt, Arg.Expr.AnyInt, Arg.Expr.Out(22)).MustBeCalled(); 
 
    PrivateAccessor privateAccessor = new PrivateAccessor(calculator); 
 
    // This array corresponds to the parameters that are passed to the tested method. 
    var values = new object[] { 8, 2, 0 }; 
 
    // Act 
    privateAccessor.CallMethod("Sum", values); 
 
    // Assert 
    // The last parameter of the method is its out parameter. 
    Assert.AreEqual(22, values[2]); 
 
    // Verify that the expectations set to the calculator object are met. 
    Mock.Assert(calculator); 
}

As you can see in our sample setup above, the Add method accepts a parameter by reference and directly modifies it. Testing methods with ref parameters is pretty similar to how that is done for the ones with out arguments. The next examples illustrate that.

Example 9: Arrange that a private method with ref parameter should be called and verify the produced value

[TestMethod] 
public void TestMethodWithAnyRefParameter() 
{ 
    // Arrange 
    var calculator = new Calculator(); 
 
    // Arrange that the Add method must be called at least once during the test execution with any int values for its parameters. 
    Mock.NonPublic.Arrange(calculator, "Add", Arg.Expr.Ref(Arg.Expr.IsAny<int>()), Arg.Expr.IsAny<int>()).CallOriginal().MustBeCalled(); 
 
    PrivateAccessor privateAccessor = new PrivateAccessor(calculator); 
 
    int input = 2; 
    // This array corresponds to the parameters that are passed to the tested method. 
    var values = new object[] { input, 6 }; 
 
    // Act 
    privateAccessor.CallMethod("Add", values); 
 
    // Assert 
    // Verify that the expectations set to the calculator object are met. 
    Mock.Assert(calculator); 
    // Check the value stored in the first argument of the Add method after its execution. 
    // It is stored as the first item of the values array as it is the first argument in the method signature.  
    Assert.AreEqual(8, values[0]); 
}

Private Async Methods

Invoking private async methods is also not an issue for the PrivateAccessor class. What you should do is to cast the result of the method to the expected type and make sure to await the execution of the logic.

Sample setup

public class Calculator 
{ 
    private async Task<int> PerformTimeConsumingCalculation(int input) 
    { 
        await Task.Delay(3000); 
        return input * 2; 
    } 
}

Example 10: Arrange and execute private async method

[TestMethod] 
public async Task TestAsync() 
{ 
    // Arrange 
    var calculator = new Calculator(); 
 
    // Arrange that the PerformTimeConsumingCalculation method must be called at least once during the test execution with any int value for its parameter. 
    Mock.NonPublic.Arrange<Task<int>>(calculator, "PerformTimeConsumingCalculation", Arg.Expr.IsAny<int>()).CallOriginal().MustBeCalled(); 
 
    PrivateAccessor privateAccessor = new PrivateAccessor(calculator); 
 
    // Act 
    // Make sure to await the async operation to complete 
    var result = await (privateAccessor.CallMethod("PerformTimeConsumingCalculation", 3) as Task<int>); 
 
    // Assert 
    // Verify that the expectations set to the calculator object are met. 
    Mock.Assert(calculator); 
    // Verify the result is correct. 
    Assert.AreEqual(6, result); 
}

Get or Set Private Properties

To get or set the value of a non-public property, you should:

  1. Pass the instance holding the private property to the PrivateAccessor
  2. Set the value of the private property (Prop to 555)
  3. Assert that the getter must return the value set above

Sample setup

public class ClassWithNonPublicMembers 
{ 
    private int Prop { get; set; } 
}

Example 11: Set private property

[TestMethod] 
public void PrivateAccessor_ShouldGetSetProperty() 
{ 
    // Act 
    var inst = new PrivateAccessor(new ClassWithNonPublicMembers()); 
    inst.SetProperty("Prop", 555); 
 
    // Assert 
    Assert.AreEqual(555, inst.GetProperty("Prop")); 
}

When you need to use a mocked instance:

  1. Create a mocked instance of your class under test (you can also use original instance object and perform partial mocking later on)
  2. Arrange your expectations
  3. Then, create new PrivateAccessor with the mocked instance as an argument
  4. Set the non-public property by giving its exact name
  5. Finally, you can assert against its expected return value

Example 12: Arrange and get non-public property from a mocked instance

[TestMethod] 
public void ShouldGetArrangedPrivateProperty() 
{ 
    // Arrange 
    var mockedClass = Mock.Create<ClassWithNonPublicMembers>(Behavior.CallOriginal); 
 
    Mock.NonPublic.Arrange<int>(mockedClass, "Prop").Returns(5); 
 
    // Act 
    var inst = new PrivateAccessor(mockedClass); 
    var actual = inst.GetProperty("Prop"); 
 
    // Assert 
    Assert.AreEqual(5, actual); 
}

Private Indexer Get and Set

Indexers are special kind of properties that enable objects to be indexed in a similar manner to arrays. Testing private indexers is usually not an easy task but PrivateAccessor enables you to implement it effortless. To achieve that, you should use the get_Item and set_Item methods. These methods are internally generated compile-time by the CLR to provide you with access to a getter and setter, respectively.

To show you the usage of this functionality, let's take the following class as a sample that should be tested:

Sample setup

public class MyCollection 
{ 
    private string[] arr = new string[2]; 
 
    // Define the indexer to allow client code to use [] notation. 
    private string this[int i] 
    { 
        get { return arr[i]; } 
        set { arr[i] = value; } 
    } 
 
    public MyCollection(string[] array) 
    { 
        arr[0] = array[0]; 
        arr[1] = array[1]; 
    } 
}

Example 13: Arrange the getter of a private indexer

[TestMethod] 
public void TestPrivateIndexerGetOperation() 
{ 
    // Arrange 
    var array = new string[2] { "a", "b" }; 
    var collection = new MyCollection(array); 
 
    // Arrange that the getter of the indexer should always return "test" when the 0 element is accessed. 
    Mock.NonPublic.Arrange<string>(collection, "get_Item", 0).Returns("test"); 
 
    PrivateAccessor privateAccessor = new PrivateAccessor(collection); 
 
    // Act 
    var result = privateAccessor.CallMethod("get_Item", 0); 
 
    // Assert 
    Assert.AreEqual("test", result); 
}

Example 14: Arrange the setter of a private indexer

[TestMethod] 
public void TestPrivateIndexerSetOperation() 
{ 
    // Arrange 
    bool calledItemSet = false; 
    var array = new string[2] { "a", "b" }; 
    var collection = new MyCollection(array); 
 
    // Arrange that the setter for any collection item should skip its original implementation and set calledItemSet to true instead. 
    Mock.NonPublic.Arrange(collection, "set_Item", Arg.Expr.IsAny<int>(), Arg.Expr.IsAny<string>()).DoInstead(() => calledItemSet = true); 
 
    PrivateAccessor privateAccessor = new PrivateAccessor(collection); 
 
    // Act 
    var result = privateAccessor.CallMethod("set_Item", 0, "value"); 
 
    // Assert 
    Assert.AreEqual(true, calledItemSet); 
}

Throw the Original Exception When Calling Method

PrivateAccessor is using the reflection API to invoke the required method. When that method throws exception, the reflection API is automatically wrapping it in a TargetInvocationException. This could cause inconvenience in determining what the original problem is.

PrivateAccessor.RethrowOriginalOnCallMethod is a boolean property that solves that problem by controling whether the original exception should be thrown or not. For backward compatibility, the default value is false.

To better illustrate the usage of this property consinder the following code sample:

Sample setup

public class Foo 
{ 
    private void ThrowsException() 
    { 
        throw new NotImplementedException("There is no implementation for this method."); 
    } 
}

And here is how a test for the ThrowsException method will look like:

Example 15: Throw the original exception using RethrowOriginalOnCallMethod

[TestMethod] 
[ExpectedException(typeof(NotImplementedException))] 
public void PrivateAccessor_CallMethod_ThrowsException() 
{ 
    var instance = new PrivateAccessor(new Foo()); 
    instance.RethrowOriginalOnCallMethod = true; 
    instance.CallMethod("ThrowsException"); 
}
In this article
Related articles
Not finding the help you need? Improve this article