How to mock a class where a variable is initialized in constructor in C#?

I have a below class which I am trying to write unit test for using Moq framework in C#.

public class CustomerClient : ICustomerClient
{
private readonly ILoggingService _loggingService;
private readonly ILoggingServiceConfigProvider _loggingServiceConfigProvider;
private readonly string _customerEndpoint;
private readonly IHttpPolicy _policy;
private readonly IHttpClientWrapper _httpClientWrapper;
private const string LOGGING_TITLE = "service";
private const string SERVICE_NAME = "service";
public CustomerClient(string customerEndpoint, ILoggingService loggingService, IConfigurationManager configManager,
ILoggingServiceConfigProvider loggingServiceConfigProvider)
{
_customerEndpoint = customerEndpoint ?? throw new ArgumentNullException(nameof(cpsEndpoint));
_loggingService = loggingService ?? throw new ArgumentNullException(nameof(loggingService));
_loggingServiceConfigProvider = loggingServiceConfigProvider ??
throw new ArgumentNullException(nameof(loggingServiceConfigProvider));
_customerEndpoint = customerEndpoint;
_policy = new HttpPolicyBuilderAsync(configManager, _loggingService, "customerPolicyOptions.json", LOGGING_TITLE);
_httpClientWrapper = new HttpClientWrapper(_cpsEndpoint, loggingService, SERVICE_NAME, _loggingServiceConfigProvider);
}
public CustomerInfo GetData(int rosterId, IList<string> leagues, IList<string> teams, LoggingContext loggingContext)
{
//....
}
}

And here is HttpPolicyBuilderAsync constructor

public HttpPolicyBuilderAsync(IConfigurationManager configManager, ILoggingService loggingService, string fileName, string svcName) : base(configManager, loggingService, fileName)
{
_configurationStateManager = new ConfigurationStateManager<HttpPolicyContainer>(configManager, fileName, RebuildConfigObjects, loggingService);
_svcName = svcName ?? throw new ArgumentNullException(nameof(svcName));
}
public void EnsureValidStatusCode(HttpStatusCode statusCode)
{
if (_configurationStateManager.GetState().RetryHttpStatusCodes.Contains(statusCode))
{
throw new HttpRequestExceptionWithStatusCode($"Status code: {statusCode} to retry for config: {_fileName}", statusCode);
}
}

I came up with below code but when I am running the unit test, I am getting an exception because I have a _policy in the constructor of CustomerClient which is giving me an error since I am not mocking that as of now. How can I mock that so that when I call CustomerClient constructor, it is already initialized for me.

[TestFixture]
public class CustomerClientTests
{
private Mock<ILoggingService> _loggingServiceMock;
private Mock<IConfigurationManager> _configManagerMock;
private Mock<ILoggingServiceConfigProvider> _loggingServiceConfigProviderMock;
private Mock<IHttpClientWrapper> _httpClientWrapperMock;
private CustomerClient _customerClient;
[SetUp]
public void Setup()
{
_loggingServiceMock = new Mock<ILoggingService>();
_configManagerMock = new Mock<IConfigurationManager>();
_loggingServiceConfigProviderMock = new Mock<ILoggingServiceConfigProvider>();
_httpClientWrapperMock = new Mock<IHttpClientWrapper>();
// exception is thrown once this is called
_customerClient = new CustomerClient("endpoint",_loggingServiceMock.Object, _configManagerMock.Object, _loggingServiceConfigProviderMock.Object);
}
[Test]
public void CustomerClient_GetData_ShouldReturnEmptyRoster_WhenResponseStatusCodeIsNotOK()
{
....
}
}

Summary

The problem is rooted in the design of your classes.

At the moment, your CustomerClient class has hard dependencies on HttpPolicyBuilderAsync and HttpClientWrapper. It's an anti-pattern and bad practice to instantiate objects of other classes, especially external ones, inside of a constructor, unless they are simple structs or records without any functionality.

This is what inversion of control (IoC) containers are for. There is a plentitude of available IoC containers for C# that you could use to resolve your hard dependencies and remove the tight coupling from your classes, such as TinyIoC and SimpleInjector.

Since you cannot change the signature of the CustomerClient constructor, as you mentioned in one of the comments, you can use an IoC container to pull in the dependencies. This, of course, means that your class will depend on the IoC container itself, which is a lot less bad than depending on an implementation inside of the constructor, because it removes tight coupling.

Solution

In order to solve your problem, you could use an IoC container to inject a provider into your class. In your production code, the provider implementation will provide a proper instance of HttpPolicyBuilderAsync.

IHttpPolicyProvider interface

public interface IHttpPolicyProvider
{
    IHttpPolicy GetPolicy(IConfigurationManager configManager, ILoggingService loggingService, string fileName, string svcName);
}

HttpPolicyBuilderProvider implementation

public class HttpPolicyBuilderProvider : IHttpPolicyProvider
{
    public IHttpPolicy GetPolicy(IConfigurationManager configManager, ILoggingService loggingService, string fileName, string svcName)
    {
        return new HttpPolicyBuilderAsync(configManager, loggingService, fileName, svcName);
    }
}

CustomerClient

Using TinyIoC, your class could be changed to look like this:

using TinyIoC;

public class CustomerClient : ICustomerClient
{
    private readonly ILoggingService _loggingService;
    private readonly ILoggingServiceConfigProvider _loggingServiceConfigProvider;
    private readonly string _customerEndpoint;
    private readonly IHttpPolicy _policy;
    private readonly IHttpClientWrapper _httpClientWrapper;
    private const string LOGGING_TITLE = "service";
    private const string SERVICE_NAME = "service";

    public CustomerClient(string customerEndpoint, ILoggingService loggingService, IConfigurationManager configManager,
        ILoggingServiceConfigProvider loggingServiceConfigProvider)
    {
        _customerEndpoint = customerEndpoint ?? throw new ArgumentNullException(nameof(cpsEndpoint));
        _loggingService = loggingService ?? throw new ArgumentNullException(nameof(loggingService));
        _loggingServiceConfigProvider = loggingServiceConfigProvider ??
                                        throw new ArgumentNullException(nameof(loggingServiceConfigProvider));
        _customerEndpoint = customerEndpoint;

        _policy = TinyIoCContainer.Current.Resolve<IHttpPolicyProvider>().GetPolicy(configManager, _loggingService, "customerPolicyOptions.json", LOGGING_TITLE);

        _httpClientWrapper = new HttpClientWrapper(_cpsEndpoint, loggingService, SERVICE_NAME, _loggingServiceConfigProvider);
    }

    //...
}

Usage in Test

In your test code, you could then create a mock of the IHttpPolicyProvider which returns a mock of IHttpPolicy and register the provider with TinyIoC:

using TinyIoC;

[TestFixture]
public class CustomerClientTests
{
    private Mock<ILoggingService> _loggingServiceMock;
    private Mock<IConfigurationManager> _configManagerMock;
    private Mock<ILoggingServiceConfigProvider> _loggingServiceConfigProviderMock;
    private Mock<IHttpClientWrapper> _httpClientWrapperMock;
    private CustomerClient _customerClient;

    private Mock<IHttpPolicyProvider> _httpPolicyProviderMock;
    private Mock<IHttpPolicy> _httpPolicyMock;

    [SetUp]
    public void Setup()
    {
        _loggingServiceMock = new Mock<ILoggingService>();
        _configManagerMock = new Mock<IConfigurationManager>();
        _loggingServiceConfigProviderMock = new Mock<ILoggingServiceConfigProvider>();
        _httpClientWrapperMock = new Mock<IHttpClientWrapper>();

        _httpPolicyProviderMock = new Mock<IHttpPolicyProvider>();
        _httpPolicyMock = new Mock<IHttpPolicy>();
        _httpPolicyProviderMock.Setup(provider => provider.GetPolicy(It.IsAny<IConfigurationManager>(), It.IsAny<ILoggingService>(), It.IsAny<string>(), It.IsAny<string>()))
            .Returns(_httpPolicyMock.Object);

        TinyIoCContainer.Current.Register<IHttpPolicyProvider>(_httpPolicyProviderMock.Object);

        _customerClient = new CustomerClient("endpoint",_loggingServiceMock.Object, _configManagerMock.Object, _loggingServiceConfigProviderMock.Object);
    }

    //...
}

Usage in Production

In your production code, you would simply register the HttpPolicyBuilderProvider using TinyIoC:

using TinyIoC;

public class YourApp()
{
    public YourApp()
    {
        TinyIoCContainer.Current.Register<IHttpPolicyProvider, HttpPolicyBuilderProvider>();
    }
}

NOTE: You'll need to do the same for the HttpClientWrapper, as far as I can tell.

If you can't modify the constructor you can isolate the code to get the IHttpPolicy in a static internal delegate with a default implementation.

public CustomerClient(string customerEndpoint, ILoggingService loggingService, IConfigurationManager configManager,
    ILoggingServiceConfigProvider loggingServiceConfigProvider) {
    // ...
    _policy = PolicyGetter(configManager, loggingService);
    // ...
}

static internal Func<IConfigurationManager, ILoggingService, IHttpPolicy> PolicyGetter =
    (configManager, loggingService) => new HttpPolicyBuilderAsync(configManager, loggingService, "customerPolicyOptions.json", LOGGING_TITLE);

Then in your test class you could change the value for PolicyGetter to anything you want, in this case simply get a mock object for IHttpPolicy.

CustomerClient.PolicyGetter = (configManager, loggingService) => _httpPolicyMock.Object;
_customerClient = new CustomerClient("endpoint",_loggingServiceMock.Object, _configManagerMock.Object, _loggingServiceConfigProviderMock.Object);

Define the field as internal, and make your assembly internal visible to the test project, so in other project you cannot change the implementation. You could also make it public but it's not a good idea.