NSubstitute mocking Mongo IFindFluent does not work

Question

I was doing dome unit tests around my repository, until I got a strange error. Searched around to see if I was not making known mistakes, I could simplify it and notice that I am getting the same error. Looks like I cannot mock IFindFluent interface properly, and I would like to know what I am doing wrong. This test:

    [Fact]
    public void Test()
    {
        var ff = Substitute.For<IFindFluent<string, string>>();
        ff.FirstOrDefaultAsync().Returns("asd");
    }

is returning this error message:

NSubstitute.Exceptions.CouldNotSetReturnDueToTypeMismatchException : Can not return value of type Task`1 for IDisposable.Dispose (expected type Void).

Make sure you called Returns() after calling your substitute (for example: mySub.SomeMethod().Returns(value)), and that you are not configuring other substitutes within Returns() (for example, avoid this: mySub.SomeMethod().Returns(ConfigOtherSub())).

If you substituted for a class rather than an interface, check that the call to your substitute was on a virtual/abstract member. Return values cannot be configured for non-virtual/non-abstract members.

Correct use: mySub.SomeMethod().Returns(returnValue);

Potentially problematic use: mySub.SomeMethod().Returns(ConfigOtherSub()); Instead try: var returnValue = ConfigOtherSub(); mySub.SomeMethod().Returns(returnValue);

at NSubstitute.Core.ConfigureCall.CheckResultIsCompatibleWithCall(IReturn valueToReturn, ICallSpecification spec) at NSubstitute.Core.ConfigureCall.SetResultForLastCall(IReturn valueToReturn, MatchArgs matchArgs) at NSubstitute.Core.SubstitutionContext.LastCallShouldReturn(IReturn value, MatchArgs matchArgs) at CorporateActions.Tests.Persistence.RepositoryTests.Test()

I've searched around, but most common mistakes about it does not fit with this simple implementation. Any thoughts why does this not work?

Can you please post the signature of `IFindFluent.FirstOrDefaultAsync`? Or is it an extension method? — David Tchepak, Apr 11 '18 at 23:49
As CodeFuller noted on answer below, it is an extension method. Did not know that I could not mock it directly. — strongwind, Apr 12 '18 at 13:18

score 6 · Accepted Answer · answered Apr 12 '18 at 06:32

FirstOrDefaultAsync is an extension method for IFindFluent<TDocument, TProjection>. Unfortunately, NSubstitute does not support mocking of extension methods.

However it does not mean you can't develop proper UT in this case. Extension methods for interfaces eventually call some method(s) of those interfaces. So the common workaround for this problem is to check what interface methods are actually called and mock them, instead of mocking whole extension method.

IFindFluentExtensions.FirstOrDefaultAsync() is defined as:

public static Task<TProjection> FirstOrDefaultAsync<TDocument, TProjection>(this IFindFluent<TDocument, TProjection> find, CancellationToken cancellationToken = default(CancellationToken))
{
    Ensure.IsNotNull(find, nameof(find));

    return IAsyncCursorSourceExtensions.FirstOrDefaultAsync(find.Limit(1), cancellationToken);
}

Now you see that you should mock IFindFluent<TDocument, TProjection>.Limit(int? limit) method and dig into IAsyncCursorSourceExtensions.FirstOrDefaultAsync() extension method.

IAsyncCursorSourceExtensions.FirstOrDefaultAsync is defined as:

public static async Task<TDocument> FirstOrDefaultAsync<TDocument>(this IAsyncCursorSource<TDocument> source, CancellationToken cancellationToken = default(CancellationToken))
{
    using (var cursor = await source.ToCursorAsync(cancellationToken).ConfigureAwait(false))
    {
        return await cursor.FirstOrDefaultAsync(cancellationToken).ConfigureAwait(false);
    }
}

So you need to mock IAsyncCursorSource<TDocument>.ToCursorAsync() and check IAsyncCursorExtensions.FirstOrDefaultAsync() extension method.

IAsyncCursorExtensions.FirstOrDefaultAsync() is defined as:

public static async Task<TDocument> FirstOrDefaultAsync<TDocument>(this IAsyncCursor<TDocument> cursor, CancellationToken cancellationToken = default(CancellationToken))
{
    using (cursor)
    {
        var batch = await GetFirstBatchAsync(cursor, cancellationToken).ConfigureAwait(false);
        return batch.FirstOrDefault();
    }
}

So the last method to analyze is IAsyncCursorExtensions.GetFirstBatchAsync(), which is defined as:

private static async Task<IEnumerable<TDocument>> GetFirstBatchAsync<TDocument>(IAsyncCursor<TDocument> cursor, CancellationToken cancellationToken)
{
    if (await cursor.MoveNextAsync(cancellationToken).ConfigureAwait(false))
    {
        return cursor.Current;
    }
    else
    {
        return Enumerable.Empty<TDocument>();
    }
}

Here we see that we should also mock IAsyncCursor.MoveNextAsync() and IAsyncCursor.Current.

Here is the test method that mocks all discovered calls:

[Fact]
public void TestMethod()
{
    var cursorMock = Substitute.For<IAsyncCursor<string>>();
    cursorMock.MoveNextAsync().Returns(Task.FromResult(true), Task.FromResult(false));
    cursorMock.Current.Returns(new[] { "asd" });

    var ff = Substitute.For<IFindFluent<string, string>>();
    ff.ToCursorAsync().Returns(Task.FromResult(cursorMock));
    ff.Limit(1).Returns(ff);

    var result = ff.FirstOrDefaultAsync().Result;
    Assert.AreEqual("asd", result);
}

An awesome explanation and a really complete answer. Thank you so much! — strongwind, Apr 12 '18 at 13:17
This is an excellent answer, but I think it is also worth mentioning the risk of this approach -- this test will be very brittle if any of the extension implementations change (unless this is what we're trying to test for?). It might be worth wrapping this function behind a testable interface the author has full control over and can be confident mocking, and then test the actual implementation in a more realistic scenario (i.e. with no mocking). — David Tchepak, Apr 12 '18 at 23:54

NSubstitute mocking Mongo IFindFluent does not work

1 Answers1