FunctionalDev.MoqHelpers 2.0.0

FunctionalDev.MoqHelpers

Object Activation

LazyActivator and MockActivator can be used to create instances of an object.

LazyActivator should be used for concrete types, and MockActivator should be used for abstract/interface types.

Both provide the ability to create an object without supplying all constructor arguments, absent arguments will be resolved. Protected/private constructors can also be targeted by these classes.

Object Proxy

ObjectProxy can be used to interact (set/get) private members of a given instance, and can be used to invoke protected/private methods.

Dot separated member access is supported to access members of members recursively. E.g. ObjectProxy.For(person)["Name"."FirstName"]

Static classes can be setup with ObjectProxy.ForStatic to interact with static classes.

Examples

Given the following class:

public class Person
{
  private string Name { set; get; }

  private Person(ILogger<Person> logger, string name)
  {
    Name = name;
  }
}

Creating an instance of Person can be achieved as shown below.

var person = LazyActivator.CreateLazy<Person>("Fred");
// or
var person = LazyActivator.CreateLazy<Person>();

And members can be managed as shown below.

// Get.
var name = ObjectProxy.For(person)["Name"];

// Set.
ObjectProxy.Create(person)["Name"] = "Bob";

Setup Extension Methods

Several extension methods have been provided which enable functional Moq creation (returning Mock{T} to enable chaining) and to setup private/protected members.
Given an example interface:

public interface IPerson
{
    string SetName(string name);
    int GetAge();
}

The following can be used to set up an IPerson interface.

var person = new Mock<IPerson>()
    .Setup(x => x.SetName, (string name) => "")
    .Setup(x => x.GetAge, () => 25);

Please note that this does not provide any filters on the arguments for methods (such as It.Is<T>(Func<T, bool>) filtering).

Developer Notes

It is not the intention for this library to provide the ability to test private/protected members, rather to assist the creation of objects prior to being tested correctly.