Match a func delegate in argument matcher in nsubstitute Received method

Question

I am trying to check if a method is called a specific number of times on a mock instance of a class. The problem is the method has a func delegate and that is not matching.

I have the following scenario:

public interface ISomeService: IService
{
    Task CleanupMethod(CancellationToken cancellationToken);
}

public interface I
{
    Task invokedMethod(string aName, Func<IService, Task> action);
}


public class ClassGoingToBeUnitTested
{
    // instance of I
    private I instanceOfI;

    // a list of names.
    private static readonly string[] serviceNames =
    {
        "Name1",
        "Name2"
    };

    // constructor
    public ClassGoingToBeUnitTested(I passedInstance)
    {
        this.instanceOfI = passedInstance;
    }


    public void methodToBeUnitTested(object cancellationToken)
    {
        // my logic here

        // here I am calling invokedMethod method to known number of times.
        // something like this.

        try
        {
            IEnumerable<Task> someTasks = serviceNames.Select(
                name => this.instanceOfI.invokedMethod(
                    name,
                    service => ((ISomeService)service).CleanupMethod((CancellationToken)cancellationToken)
                    ));

            // here I run the tasks
            Task.WaitAll(someTasks.ToArray());

        }
        catch
        {
            // proper catching of exceptions
        }

        // other logic
    }
}


[TestClass]
public class ClassGoingToBeUnitTestedTest
{
    // mock of I interface
    private I IMock;

    // ClassGoingToBeUnitTested object
    ClassGoingToBeUnitTested classGoingToBeUnitTested;

    [TestInitialize]
    public void init()
    {
        this.IMock = Substitute.For<I>();
        this.classGoingToBeUnitTested = new ClassGoingToBeUnitTested(this.IMock);
    }


    [TestMethod]
    public void methodToBeUnitTested_Success()
    {
        // Arrange
        var cancellationTokenSource = new CancellationTokenSource();

        // Act
        this.classGoingToBeUnitTested.methodToBeUnitTested(cancellationTokenSource.Token);

        // Assert
        // this is throwing exception.
        this.IMock.Received(1).invokedMethod(
             "Name1",
             service => ((ISomeService)service).CleanupMethod((CancellationToken)cancellationTokenSource.Token)); // problem lies in this line.

    }
}

In the above code if I change ((ISomeService)service).CleanupMethod((CancellationToken)cancellationTokenSource.Token)) to Arg.Any<Func<IService, Task>(), it runs perfectly. But I don't want to check that for my use case.

Till now, I have been able to debug that the argument matcher is matching the delegates by reference and hence is not able to match the arguments correctly. But I am not able to correctly match the arguments.

I also tried to invoke the delegate but I did not succeed. I think I am missing something. Any help would be highly appreciated.

Answer 1

I solved this by using Invoke. I first mocked the behaviour of invokedMethod to invoke a mocked serviceInstanceMock whenever it is called and then checked the number of times CleanupMethod is called on the serviceInstanceMock itself.

[TestClass]
public class ClassGoingToBeUnitTestedTest
{
    // mock of I interface
    private I IMock;

    // mock of ISomeService
    private ISomeService someServiceMockInstance;

    // ClassGoingToBeUnitTested object
    ClassGoingToBeUnitTested classGoingToBeUnitTested;

    [TestInitialize]
    public void init()
    {
        this.IMock = Substitute.For<I>();
        this.ISomeService = Substitute.For<ISomeService>();
        this.classGoingToBeUnitTested = new ClassGoingToBeUnitTested(this.IMock);
    }


    [TestMethod]
    public void methodToBeUnitTested_Success()
    {
        // Arrange
        var cancellationTokenSource = new CancellationTokenSource();
        this.IMock.invokedMethod(
            Arg.Any<string>,
            Arg.Do<Func<IService, Task>(x => x.Invoke(this.someServiceMockInstance)));

        // Act
        this.classGoingToBeUnitTested.methodToBeUnitTested(cancellationTokenSource.Token);

        // Assert
        this.IMock.Received(1).invokedMethod(
             "Name1",
             Arg.Any<Func<IService, Task>()); // changed this

        this.IMock.Received(1).invokedMethod(
             "Name2",
             Arg.Any<Func<IService, Task>()); // added this as well

        // adding to check the Received call on the service instance
        this.someServiceMockInstance.Received(2).CleanupMethod(cancellationTokenSource.Token);
    }
}