Mocking ILogger

MockLogger.Moq.cs

using Microsoft.Extensions.Logging;
using Moq;

public static class MockLogger
{
    public static Mock<ILogger<T>> Create<T>()
    {
        var mock = new Mock<ILogger<T>>();
        mock.Setup(l => l.IsEnabled(It.IsAny<LogLevel>())).Returns(true);
        mock.Setup(x => x.BeginScope(It.IsAny<It.IsAnyType>())).Returns(Mock.Of<IDisposable>());
        return mock;
    }

    public static void VerifyLogging<T>(
        this Mock<ILogger<T>> loggerMock,
        LogLevel logLevel,
        Func<Times> times)
    {
        VerifyLogging(loggerMock, logLevel, _ => true, times);
    }

    public static void VerifyLogging<T>(
        this Mock<ILogger<T>> loggerMock,
        LogLevel logLevel,
        Func<string, bool> predicate,
        Func<Times> times)
    {
        loggerMock.Verify(
            l => l.Log(
                logLevel,
                It.IsAny<EventId>(),
                It.Is<It.IsAnyType>((o, type) => predicate(o.ToString()!)),
                It.IsAny<Exception>(),
                It.IsAny<Func<It.IsAnyType, Exception?, string>>()),
            times);
    }

    public static void VerifyLoggingScope<T>(
        this Mock<ILogger<T>> loggerMock,
        Func<Dictionary<string, object?>, bool> predicate,
        Func<Times> times)
    {
        VerifyLoggingScope(loggerMock, predicate, times());
    }

    public static void VerifyLoggingScope<T>(
        this Mock<ILogger<T>> loggerMock,
        Func<Dictionary<string, object?>, bool> predicate,
        Times times)
    {
        loggerMock.Verify(l => l.BeginScope(It.Is<Dictionary<string, object?>>(x => predicate(x))), times);
    }

    public static void VerifyLoggingScope<T>(
        this Mock<ILogger<T>> loggerMock,
        string key,
        Func<object?, bool> valuePredicate,
        Func<Times> times)
    {
        VerifyLoggingScope(loggerMock, key, valuePredicate, times());
    }

    public static void VerifyLoggingScope<T>(
        this Mock<ILogger<T>> loggerMock,
        string key,
        Func<object?, bool> valuePredicate,
        Times times)
    {
        VerifyLoggingScope(loggerMock, dict => dict.TryGetValue(key, out var value) && valuePredicate(value), times);
    }
}

MockLogger.NSubstitute.cs

using Microsoft.Extensions.Logging;
using NSubstitute;
using NSubstitute.ReceivedExtensions;

public static class MockLogger
{
    public static ILogger<T> Create<T>()
    {
        var logger = Substitute.For<ILogger<T>>();
        logger.IsEnabled(Arg.Any<LogLevel>()).Returns(true);
        return logger;
    }

    public static void ReceivedLogging<T>(this ILogger<T> logger, int requiredNumberOfCalls, LogLevel logLevel)
    {
        ReceivedLogging(logger, Quantity.Exactly(requiredNumberOfCalls), logLevel, _ => true);
    }

    public static void ReceivedLogging<T>(this ILogger<T> logger, Quantity quantity, LogLevel logLevel)
    {
        ReceivedLogging(logger, quantity, logLevel, _ => true);
    }

    public static void ReceivedLogging<T>(
        this ILogger<T> logger,
        int requiredNumberOfCalls,
        LogLevel logLevel,
        Func<string, bool> predicate)
    {
        ReceivedLogging(logger, Quantity.Exactly(requiredNumberOfCalls), logLevel, predicate);
    }

    public static void ReceivedLogging<T>(
        this ILogger<T> logger,
        Quantity quantity,
        LogLevel logLevel,
        Func<string, bool> predicate)
    {
        logger
            .Received(quantity)
            .Log(
                Arg.Is(logLevel),
                Arg.Any<EventId>(),
                Arg.Is<IReadOnlyList<KeyValuePair<string, object>>>(o => predicate(o.ToString()!)),
                Arg.Any<Exception>(),
                Arg.Any<Func<IReadOnlyList<KeyValuePair<string, object>>, Exception?, string>>()
            );
    }
}