Returning mocked object from partially mocked object not working

Question

I'm writing a unit test where I'm trying to partially mock a service. What I mean is I want one of the methods of the service to return a different mocked object and another method to behave as normal. This is the method I'm testing:

public async Task<List<string>> GetDeletedRecordIds<T>(DateTime startDate)
        where T : ISalesForceObject
    {
        List<string> result;
        try
        {
            var client = await this.GetForceClient();
            var init = await client.GetDeleted<DeletedRecordRootObject>(typeof(T).Name, startDate, DateTime.Now);
            result = init?.DeletedRecords.Select(d => d.Id).ToList();
        }
        catch (Exception e)
        {
            this._logger.LogError(LoggingEvents.GENERAL_ERROR, e, "GetDeletedRecordIds");
            throw;
        }

        return result;
    }

This is the method that I need to return a mocked object:

public async Task<IForceClient> GetForceClient()
    {
        ForceClient forceClient = null;
        try
        {
            var auth = new AuthenticationClient();

            var consumerKey = this._settingService.GetSetting("SalesForceConsumerKey");
            var consumerSecret = this._settingService.GetSetting("SalesForceConsumerSecret");
            var password = this._settingService.GetSetting("SalesForcePassword");
            var securityToken = this._settingService.GetSetting("SalesForceSecurityToken");
            var username = this._settingService.GetSetting("SalesForceUsername");
            var tokenUrl = $"{this._settingService.GetSetting("SalesForceUrl")}/services/oauth2/token";

            await auth.UsernamePasswordAsync(
                consumerKey,
                consumerSecret,
                username,
                password + securityToken,
                tokenUrl);

            forceClient = new ForceClient(auth.InstanceUrl, auth.AccessToken, auth.ApiVersion);
        }
        catch (Exception e)
        {
            this._logger.LogError(LoggingEvents.GENERAL_ERROR, e, $"GetForceClient");
            throw;
        }

        return forceClient;
    }

And this is what I currently have in my unit test:

        var mockForceClient = new Mock<IForceClient>();
        mockForceClient
            .Setup(
                i => i.GetDeleted<DeletedRecordRootObject>(
                    It.IsAny<string>(),
                    It.IsAny<DateTime>(),
                    It.IsAny<DateTime>())).ReturnsAsync(deletedRecordRootObject);

        var mockService = new Mock<IForceDotComService>();
        mockService.Setup(m => m.GetDeletedRecordIds<sf.Account>(It.IsAny<DateTime>()))
            .Returns(async (DateTime d) => await this._service.GetDeletedRecordIds<sf.Account>(d));
        mockService.Setup(m => m.GetForceClient())
            .ReturnsAsync(mockForceClient.Object);

Currently, the test runs in GetDeletedRecordIds until it hits the call to the GetForceClient method. Then instead of returning the mocked ForceClient object, it actually tries to run the method which of course fails.

Thanks in advance for any help.

SOLUTION: Here's how I solved my problem.

First, I created a service to return the ForceClient as follows:

public class ForceClientService : IForceClientService
{
    private readonly ILogger _logger;

    private readonly ISettingService _settingService;

    public ForceClientService(
        ILogger<ForceClientService> logger,
        ISettingService settingService)
    {
        this._logger = logger;
        this._settingService = settingService;
    }

    public async Task<IForceClient> GetForceClient()
    {
        ForceClient forceClient = null;
        try
        {
            var auth = new AuthenticationClient();

            var consumerKey = this._settingService.GetSetting("SalesForceConsumerKey");
            var consumerSecret = this._settingService.GetSetting("SalesForceConsumerSecret");
            var password = this._settingService.GetSetting("SalesForcePassword");
            var securityToken = this._settingService.GetSetting("SalesForceSecurityToken");
            var username = this._settingService.GetSetting("SalesForceUsername");
            var tokenUrl = $"{this._settingService.GetSetting("SalesForceUrl")}/services/oauth2/token";

            await auth.UsernamePasswordAsync(
                consumerKey,
                consumerSecret,
                username,
                password + securityToken,
                tokenUrl);

            forceClient = new ForceClient(auth.InstanceUrl, auth.AccessToken, auth.ApiVersion);
        }
        catch (Exception e)
        {
            this._logger.LogError(LoggingEvents.GENERAL_ERROR, e, $"GetForceClient");
            throw;
        }

        return forceClient;
    }
}

Then I changed the method I am testing:

public async Task DeleteRecord<TSf>(TSf record)
        where TSf : ISalesForceObject
    {
        try
        {
            var client = await this._forceClientService.GetForceClient();
            var response = await client.DeleteAsync(typeof(TSf).Name, record.Id);
            if (!response)
            {
                throw new Exception($"Error deleting record with ID {record.Id}");
            }
        }
        catch (Exception e)
        {
            this._logger.LogError(LoggingEvents.GENERAL_ERROR, e, $"ForceDotComService.DeleteRecord");
            throw;
        }
    }

Then I rebuilt my mock to mock the dependencies vs. the methods:

var mockForceClient = new Mock<IForceClient>();
        mockForceClient
            .Setup(
                i => i.GetDeleted<DeletedRecordRootObject>(
                    It.IsAny<string>(),
                    It.IsAny<DateTime>(),
                    It.IsAny<DateTime>())).ReturnsAsync(deletedRecordRootObject);

        var mockLogger = new Mock<ILogger<ForceDotComService>>();
        var mockForceClientService = new Mock<IForceClientService>();
        mockForceClientService.Setup(m => m.GetForceClient()).ReturnsAsync(mockForceClient.Object);

        this._service = new ForceDotComService(mockLogger.Object, mockForceClientService.Object);

It is now working as expected. Thanks so much for the help!

Answer 1

Extract this.GetForceClient() out into its own service backed by an abstraction

public IForceClientProvider {
    Task<IForceClient> GetForceClient();
}

you would then refactor your current class under test to explicitly depend on that interface via constructor injection.

public class ForceDotComService : IForceDotComService {
    private readonly IForceClientProvider provider;

    public ForceDotComService(IForceClientProvider provider) {
        this.provider = provider;
    }

    public async Task<List<string>> GetDeletedRecordIds<T>(DateTime startDate)
        where T : ISalesForceObject {
        List<string> result;
        try {
            var client = await provider.GetForceClient();
            var init = await client.GetDeleted<DeletedRecordRootObject>(typeof(T).Name, startDate, DateTime.Now);
            result = init?.DeletedRecords.Select(d => d.Id).ToList();
        } catch (Exception e) {
            this._logger.LogError(LoggingEvents.GENERAL_ERROR, e, "GetDeletedRecordIds");
            throw;
        }

        return result;
    }
}

This would then allow you to mock the desired behavior when testing. In implementation code you would have the same code presented above in the GetForceClient() method.

Answer 2

You mock dependencies, not methods on the class under test.

You need to inject the dependency IForceClient, for example by making it a constructor parameter. Because now your GetForceClient() is simply being called on the class under test, which runs in that class and not on your mock, and so simply returns the new ForceClient() stated in there.