Moq4: Cannot verify calls to ILogger in .NET Core 3.0 Preview 8 (Generic Type Matcher doesn't work with Verify)

Created on 3 Sep 2019 · 21Comments · Source: moq/moq4

In .NET Core 2.2, I am able to use Moq to test calls made to an ILogger. For example the following code;

``` C#
using System.Diagnostics;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;

namespace WebApi.HttpMessageHandlers
{
public class RequestLoggingHttpMessageHandler : DelegatingHandler
{
private const string MessageTemplate = "Outbound HTTP {HttpMethod} {Uri} responded with {StatusCode} in {ElapsedMilliseconds}ms";

    private readonly ILogger logger;

    public RequestLoggingHttpMessageHandler(ILogger<RequestLoggingHttpMessageHandler> logger)
    {
        this.logger = logger;
    }

    protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
    {
        Stopwatch stopwatch = Stopwatch.StartNew();
        HttpResponseMessage response = await base.SendAsync(request, cancellationToken);
        stopwatch.Stop();

        int statusCode = (int)response.StatusCode;
        LogLevel logLevel = LogLevel.Information;

        if (statusCode < 200 || statusCode > 299)
        {
            logLevel = LogLevel.Warning;
        }

        if (statusCode >= 500)
        {
            logLevel = LogLevel.Error;
        }

        this.logger.Log(
            logLevel,
            MessageTemplate,
            request.Method,
            request.RequestUri,
            statusCode,
            stopwatch.ElapsedMilliseconds);

        return response;
    }
}

}


could be tested with the following Xunit Theory;

``` C#
using System;
using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using Moq;
using Xunit;

namespace WebApi.HttpMessageHandlers
{
    public class RequestLoggingHttpMessageHandlerUnitTests
    {
        [Theory]
        [InlineData(199, LogLevel.Warning)]
        [InlineData(200, LogLevel.Information)]
        [InlineData(299, LogLevel.Information)]
        [InlineData(300, LogLevel.Warning)]
        [InlineData(499, LogLevel.Warning)]
        [InlineData(500, LogLevel.Error)]
        [InlineData(501, LogLevel.Error)]
        public async Task When_SendingAsync_Expect_LogLevel(int statusCode, LogLevel expectedLogLevel)
        {
            // Arrange
            Mock<ILogger<RequestLoggingHttpMessageHandler>> mock = new Mock<ILogger<RequestLoggingHttpMessageHandler>>();

            // Act
            using (RequestLoggingHttpMessageHandler handler = new RequestLoggingHttpMessageHandler(mock.Object)
            {
                InnerHandler = new InnerHandler(statusCode),
            })
            using (HttpClient client = new HttpClient(handler))
            {
                (await client.GetAsync(new Uri("http://localhost"))).Dispose();
            }

            // Assert
            mock.Verify(
                m => m.Log(
                    expectedLogLevel,
                    It.IsAny<EventId>(),
                    It.IsAny<object>(),
                    null,
                    It.IsAny<Func<object, Exception, string>>()),
                Times.Once);
        }

        private class InnerHandler : DelegatingHandler
        {
            private readonly int statusCode;

            public InnerHandler(int statusCode)
            {
                this.statusCode = statusCode;
            }

            protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
            {
                return await Task.FromResult(new HttpResponseMessage { StatusCode = (HttpStatusCode)this.statusCode });
            }
        }
    }
}

However when targeting .NET Core 3.0 (Preview 8), Moq now fails to verify these calls. The reason these calls now fail is because there was a behaviour change in that the Type that is being passed in to the logger.Log() generic has changed. It is now the Internal type FormattedLogValues.

I noticed that Moq 4.13.0 introduced the generic type matcher It.IsAnyType. I tried to use it like this;

C# mock.Verify( m => m.Log<It.IsAnyType>( expectedLogLevel, It.IsAny<EventId>(), It.IsAny<It.IsAnyType>(), null, It.IsAny<Func<It.IsAnyType, Exception, string>>()), Times.Once);

Strangly it works in .NET Core 2.2 but is still failing in .NET Core 3.0 Preview 8.

question

Source

hannahchan

👍9 🚀1

Most helpful comment

The problem is with the "Func<>". Thats works

mock.Verify(
                x => x.Log(
                        It.IsAny<LogLevel>(),
                        It.IsAny<EventId>(),
                        It.Is<It.IsAnyType>((v,t) => true),
                        It.IsAny<Exception>(),
                        It.Is<Func<It.IsAnyType, Exception, string>>((v,t) => true))

sergiomcalzada on 25 Sep 2019

👍28 🎉1

All 21 comments

@hannahchan: Thanks for reporting!

TL;DR: Not yet quite sure why it works in .NET Core 2.2, but with 3.0 Preview 8 it is due to the last parameter It.IsAny<Func<It.IsAnyType, Exception, string>>(), where the It.IsAnyType does not appear as a "top-level" generic type argument, but "inside" of a composite type. I'm planning to add support for that kind of thing eventually; for the moment, there's a fairly easy workaround:

        mock.Verify(
            m => m.Log(
                expectedLogLevel,
                It.IsAny<EventId>(),
                It.IsAny<It.IsAnyType>(),
                null,
-               It.IsAny<Func<It.IsAnyType, Exception, string>>()),
+               (Func<It.IsAnyType, Exception, string>)It.IsAny<object>()),
            Times.Once);

The important bit (for now) is that It.IsAnyType is not used in a nested position in the It.IsAny<> type argument.

The new generic type argument matcher support in Moq is new, and one thing I decided to leave out for the first version (for performance reasons) is support for such "composite" / "nested" types. See https://github.com/moq/moq4/pull/908#issue-310714329, where I wrote:

[ ] Add support for composite types making use of type matchers, e.g. It.IsAnyType?, It.IsAnyType[], It.IsAnyType[,], IEnumerable<It.IsAnyType>, ref/in/out It.IsAnyType, etc. Same for custom matcher types. It's possible that this cannot be made to work with custom argument matchers.

Update: While that would be great, it would also negatively affect performance as every type parameter would have to be decomposed just to discover whether it includes a type matcher. For now, we're going the opposite direction and try to make type matcher discovery as fast as possible.

(Sorry for not making that clearer in the changelog or quickstart. I was quite excited to finally be able to get the feature out there so that people can start using it. But I suppose we could spend some more time on documentation. :wink:)

stakx on 3 Sep 2019

👍20 🎉2

Ah cool, thanks for your quick response. I'm very excited about this feature too. I can confirm that your suggested workaround works and that I'm happy with it. I guess you can close this issue now.

hannahchan on 4 Sep 2019

Can it be used also with the It.Is ?
I was using it before like
It.Is<FormattedLogValues>(v => v.ToString().Contains(message))

with .NET Core 3 and Moq 4.13.0

It.Is<It.IsAnyType>(v => v.ToString().Contains(message))

does not seem to work, I get the following: It is impossible to call the provided strongly-typed predicate due to the use of a type matcher. Provide a weakly-typed predicate with two parameters (object, Type) instead. (Parameter 'match')
What are my options if I want to validate the value of the AnyType?

ghost on 17 Sep 2019

👀1

What are my options if I want to validate the value of the AnyType?

Think about it: AnyType is a type placeholder. At runtime, there will never be an actual argument of that type. So it doesn't make sense to have a predicate that tests an AnyType argument... where could such a value possibly come from?

Do what the error message tells you to do and rewrite the It.Is as follows:

-It.Is<It.IsAnyType>(v => v.ToString().Contains(message))
+It.Is<It.IsAnyType>((object v, Type _) => v.ToString().Contains(message))

but it might be simpler in this case to just write It.Is<object>(v => ...).

stakx on 17 Sep 2019

👍9 🚀3

Thanks for that, just doing It.Is<object>(v => ...) doesn't work because of ambiguity in the method.
Your suggestion It.Is<It.IsAnyType>((object v, Type _) => v.ToString().Contains(message))
works great though, thanks

ghost on 18 Sep 2019

👍2 ❤1

A bit of information that might be related to why this worked in ASP.NET Core 2.2 and not in ASP.NET Core 3.0: FormattedLogValues was changed from a class to a struct in .NET Core 3.0.

nphmuller on 18 Sep 2019

Does not seem to be working:
_loggerMock.Verify(l => l.Log(LogLevel.Error, It.IsAny<EventId>(), It.Is<It.IsAnyType>((object v, Type _) => true), null, It.IsAny<Func<object, Exception, string>>()));

Getting "Expected invocation on the mock at least once, but was never performed: l => l.Log

Moq4: Cannot verify calls to ILogger in .NET Core 3.0 Preview 8 (Generic Type Matcher doesn't work with Verify)

Most helpful comment

All 21 comments

pragma warning disable CS8620

pragma warning restore CS8620

Related issues