Comment effectuer un test unitaire avec ILogger dans ASP.NET Core

Ceci est mon contrôleur:

public class BlogController : Controller
{
    private IDAO<Blog> _blogDAO;
    private readonly ILogger<BlogController> _logger;

    public BlogController(ILogger<BlogController> logger, IDAO<Blog> blogDAO)
    {
        this._blogDAO = blogDAO;
        this._logger = logger;
    }
    public IActionResult Index()
    {
        var blogs = this._blogDAO.GetMany();
        this._logger.LogInformation("Index page say hello", new object[0]);
        return View(blogs);
    }
}

Comme vous pouvez le voir, j'ai 2 dépendances, une IDAOet uneILogger

Et ceci est ma classe de test, j'utilise xUnit pour tester et Moq pour créer une maquette et un stub, je peux me moquer DAOfacilement, mais avec le ILoggerje ne sais pas quoi faire, je passe simplement null et commente l'appel pour se connecter au contrôleur lors de l'exécution du test. Existe-t-il un moyen de tester tout en conservant l'enregistreur d'une manière ou d'une autre?

public class BlogControllerTest
{
    [Fact]
    public void Index_ReturnAViewResult_WithAListOfBlog()
    {
        var mockRepo = new Mock<IDAO<Blog>>();
        mockRepo.Setup(repo => repo.GetMany(null)).Returns(GetListBlog());
        var controller = new BlogController(null,mockRepo.Object);

        var result = controller.Index();

        var viewResult = Assert.IsType<ViewResult>(result);
        var model = Assert.IsAssignableFrom<IEnumerable<Blog>>(viewResult.ViewData.Model);
        Assert.Equal(2, model.Count());
    }
}

Il suffit de le moquer ainsi que de toute autre dépendance:

var mock = new Mock<ILogger<BlogController>>();
ILogger<BlogController> logger = mock.Object;

//or use this short equivalent 
logger = Mock.Of<ILogger<BlogController>>()

var controller = new BlogController(logger);

Vous devrez probablement installer le Microsoft.Extensions.Logging.Abstractionspackage à utiliser ILogger<T>.

De plus, vous pouvez créer un véritable enregistreur:

var serviceProvider = new ServiceCollection()
    .AddLogging()
    .BuildServiceProvider();

var factory = serviceProvider.GetService<ILoggerFactory>();

var logger = factory.CreateLogger<BlogController>();

En fait, j'ai trouvé Microsoft.Extensions.Logging.Abstractions.NullLogger<>ce qui ressemble à une solution parfaite. Installez le package Microsoft.Extensions.Logging.Abstractions, puis suivez l'exemple pour le configurer et l'utiliser:

using Microsoft.Extensions.Logging;

public void ConfigureServices(IServiceCollection services)
{
    ...

    services.AddSingleton<ILoggerFactory, NullLoggerFactory>();

    ...
}

using Microsoft.Extensions.Logging;

public class MyClass : IMyClass
{
    public const string ErrorMessageILoggerFactoryIsNull = "ILoggerFactory is null";

    private readonly ILogger<MyClass> logger;

    public MyClass(ILoggerFactory loggerFactory)
    {
        if (null == loggerFactory)
        {
            throw new ArgumentNullException(ErrorMessageILoggerFactoryIsNull, (Exception)null);
        }

        this.logger = loggerFactory.CreateLogger<MyClass>();
    }
}

et test unitaire

//using Microsoft.VisualStudio.TestTools.UnitTesting;
//using Microsoft.Extensions.Logging;

[TestMethod]
public void SampleTest()
{
    ILoggerFactory doesntDoMuch = new Microsoft.Extensions.Logging.Abstractions.NullLoggerFactory();
    IMyClass testItem = new MyClass(doesntDoMuch);
    Assert.IsNotNull(testItem);
}   

Utilisez un enregistreur personnalisé qui utilise ITestOutputHelper(à partir de xunit) pour capturer la sortie et les journaux. Voici un petit exemple qui n'écrit que le statedans la sortie.

public class XunitLogger<T> : ILogger<T>, IDisposable
{
    private ITestOutputHelper _output;

    public XunitLogger(ITestOutputHelper output)
    {
        _output = output;
    }
    public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
    {
        _output.WriteLine(state.ToString());
    }

    public bool IsEnabled(LogLevel logLevel)
    {
        return true;
    }

    public IDisposable BeginScope<TState>(TState state)
    {
        return this;
    }

    public void Dispose()
    {
    }
}

Utilisez-le dans vos unittests comme

public class BlogControllerTest
{
  private XunitLogger<BlogController> _logger;

  public BlogControllerTest(ITestOutputHelper output){
    _logger = new XunitLogger<BlogController>(output);
  }

  [Fact]
  public void Index_ReturnAViewResult_WithAListOfBlog()
  {
    var mockRepo = new Mock<IDAO<Blog>>();
    mockRepo.Setup(repo => repo.GetMany(null)).Returns(GetListBlog());
    var controller = new BlogController(_logger,mockRepo.Object);
    // rest
  }
}

Pour les réponses .net core 3 utilisant Moq

• https://stackoverflow.com/a/54646657/2164198
• https://stackoverflow.com/a/54809607/2164198

• https://stackoverflow.com/a/56728528/2164198

  ne fonctionnent plus en raison d'un changement décrit dans le problème TState dans ILogger.Log était autrefois un objet, maintenant FormattedLogValues

Heureusement, stakx a fourni une belle solution de contournement . Je le publie donc dans l'espoir que cela puisse faire gagner du temps aux autres (il a fallu un certain temps pour comprendre les choses):

 loggerMock.Verify(
                x => x.Log(
                    LogLevel.Information,
                    It.IsAny<EventId>(),
                    It.Is<It.IsAnyType>((o, t) => string.Equals("Index page say hello", o.ToString(), StringComparison.InvariantCultureIgnoreCase)),
                    It.IsAny<Exception>(),
                    (Func<It.IsAnyType, Exception, string>) It.IsAny<object>()),
                Times.Once);

En ajoutant mes 2 cents, c'est une méthode d'extension d'assistance généralement placée dans une classe d'assistance statique:

static class MockHelper
{
    public static ISetup<ILogger<T>> MockLog<T>(this Mock<ILogger<T>> logger, LogLevel level)
    {
        return logger.Setup(x => x.Log(level, It.IsAny<EventId>(), It.IsAny<object>(), It.IsAny<Exception>(), It.IsAny<Func<object, Exception, string>>()));
    }

    private static Expression<Action<ILogger<T>>> Verify<T>(LogLevel level)
    {
        return x => x.Log(level, 0, It.IsAny<object>(), It.IsAny<Exception>(), It.IsAny<Func<object, Exception, string>>());
    }

    public static void Verify<T>(this Mock<ILogger<T>> mock, LogLevel level, Times times)
    {
        mock.Verify(Verify<T>(level), times);
    }
}

Ensuite, vous l'utilisez comme ceci:

//Arrange
var logger = new Mock<ILogger<YourClass>>();
logger.MockLog(LogLevel.Warning)

//Act

//Assert
logger.Verify(LogLevel.Warning, Times.Once());

Et bien sûr, vous pouvez facilement l'étendre pour vous moquer de toute attente (ex: attente, message, etc.)

Il est facile, comme d'autres réponses le suggèrent, de passer des simulations ILogger, mais il devient soudainement beaucoup plus problématique de vérifier que des appels ont effectivement été passés à l'enregistreur. La raison en est que la plupart des appels n'appartiennent pas réellement à l' ILoggerinterface elle-même.

Donc, la plupart des appels sont des méthodes d'extension qui appellent la seule Logméthode de l'interface. La raison semble être qu'il est beaucoup plus facile de faire la mise en œuvre de l'interface si vous n'avez qu'une seule et pas beaucoup de surcharges qui se résument à la même méthode.

L'inconvénient est bien sûr qu'il est soudainement beaucoup plus difficile de vérifier qu'un appel a été passé car l'appel que vous devez vérifier est très différent de l'appel que vous avez passé. Il existe différentes approches pour contourner ce problème, et j'ai constaté que les méthodes d'extension personnalisées pour le framework moqueur faciliteraient l'écriture.

Voici un exemple de méthode que j'ai conçue pour travailler NSubstitute:

public static class LoggerTestingExtensions
{
    public static void LogError(this ILogger logger, string message)
    {
        logger.Log(
            LogLevel.Error,
            0,
            Arg.Is<FormattedLogValues>(v => v.ToString() == message),
            Arg.Any<Exception>(),
            Arg.Any<Func<object, Exception, string>>());
    }

}

Et voici comment il peut être utilisé:

_logger.Received(1).LogError("Something bad happened");   

Il semble exactement que vous utilisiez la méthode directement, l'astuce ici est que notre méthode d'extension a la priorité parce qu'elle est "plus proche" dans les espaces de noms que l'original, donc elle sera utilisée à la place.

Cela ne donne malheureusement pas 100% de ce que nous voulons, à savoir que les messages d'erreur ne seront pas aussi bons, car nous ne vérifions pas directement sur une chaîne mais plutôt sur un lambda qui implique la chaîne, mais 95% c'est mieux que rien :) cette approche rendra le code de test

PS Pour Moq, on peut utiliser l'approche consistant à écrire une méthode d'extension pour le Mock<ILogger<T>>faire Verifypour obtenir des résultats similaires.

PPS Cela ne fonctionne plus dans .Net Core 3, consultez ce fil pour plus de détails: https://github.com/nsubstitute/NSubstitute/issues/597#issuecomment-573742574

Déjà mentionné, vous pouvez vous en moquer comme n'importe quelle autre interface.

var logger = new Mock<ILogger<QueuedHostedService>>();

Jusqu'ici tout va bien.

Une bonne chose est que vous pouvez utiliser Moqpour vérifier que certains appels ont été effectués . Par exemple ici je vérifie que le journal a été appelé avec un particulier Exception.

logger.Verify(m => m.Log(It.Is<LogLevel>(l => l == LogLevel.Information), 0,
            It.IsAny<object>(), It.IsAny<TaskCanceledException>(), It.IsAny<Func<object, Exception, string>>()));

Lorsque vous utilisez Verifyle point est de le faire contre la Logméthode réelle de l' ILoogerinterface et non les méthodes d'extension.

En s'appuyant encore plus sur le travail de @ ivan-samygin et @stakx, voici des méthodes d'extension qui peuvent également correspondre à l'exception et à toutes les valeurs de journal (KeyValuePairs).

Ceux-ci fonctionnent (sur ma machine;)) avec .Net Core 3, Moq 4.13.0 et Microsoft.Extensions.Logging.Abstractions 3.1.0.

/// <summary>
/// Verifies that a Log call has been made, with the given LogLevel, Message and optional KeyValuePairs.
/// </summary>
/// <typeparam name="T">Type of the class for the logger.</typeparam>
/// <param name="loggerMock">The mocked logger class.</param>
/// <param name="expectedLogLevel">The LogLevel to verify.</param>
/// <param name="expectedMessage">The Message to verify.</param>
/// <param name="expectedValues">Zero or more KeyValuePairs to verify.</param>
public static void VerifyLog<T>(this Mock<ILogger<T>> loggerMock, LogLevel expectedLogLevel, string expectedMessage, params KeyValuePair<string, object>[] expectedValues)
{
    loggerMock.Verify(mock => mock.Log(
        expectedLogLevel,
        It.IsAny<EventId>(),
        It.Is<It.IsAnyType>((o, t) => MatchesLogValues(o, expectedMessage, expectedValues)),
        It.IsAny<Exception>(),
        It.IsAny<Func<object, Exception, string>>()
        )
    );
}

/// <summary>
/// Verifies that a Log call has been made, with LogLevel.Error, Message, given Exception and optional KeyValuePairs.
/// </summary>
/// <typeparam name="T">Type of the class for the logger.</typeparam>
/// <param name="loggerMock">The mocked logger class.</param>
/// <param name="expectedMessage">The Message to verify.</param>
/// <param name="expectedException">The Exception to verify.</param>
/// <param name="expectedValues">Zero or more KeyValuePairs to verify.</param>
public static void VerifyLog<T>(this Mock<ILogger<T>> loggerMock, string expectedMessage, Exception expectedException, params KeyValuePair<string, object>[] expectedValues)
{
    loggerMock.Verify(logger => logger.Log(
        LogLevel.Error,
        It.IsAny<EventId>(),
        It.Is<It.IsAnyType>((o, t) => MatchesLogValues(o, expectedMessage, expectedValues)),
        It.Is<Exception>(e => e == expectedException),
        It.Is<Func<It.IsAnyType, Exception, string>>((o, t) => true)
    ));
}

private static bool MatchesLogValues(object state, string expectedMessage, params KeyValuePair<string, object>[] expectedValues)
{
    const string messageKeyName = "{OriginalFormat}";

    var loggedValues = (IReadOnlyList<KeyValuePair<string, object>>)state;

    return loggedValues.Any(loggedValue => loggedValue.Key == messageKeyName && loggedValue.Value.ToString() == expectedMessage) &&
           expectedValues.All(expectedValue => loggedValues.Any(loggedValue => loggedValue.Key == expectedValue.Key && loggedValue.Value == expectedValue.Value));
}

Et lors de l'utilisation de StructureMap / Lamar:

var c = new Container(_ =>
{
    _.For(typeof(ILogger<>)).Use(typeof(NullLogger<>));
});

Documents:

• https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.abstractions.nulllogger?view=aspnetcore-2.1
• http://structuremap.github.io/generics/

Créer simplement un mannequin ILoggern'est pas très utile pour les tests unitaires. Vous devez également vérifier que les appels de journalisation ont été effectués. Vous pouvez injecter une simulation ILoggeravec Moq, mais la vérification de l'appel peut être un peu délicate. Cet article approfondit la vérification avec Moq.

Voici un exemple très simple de l'article:

_loggerMock.Verify(l => l.Log(
LogLevel.Information,
It.IsAny<EventId>(),
It.IsAny<It.IsAnyType>(),
It.IsAny<Exception>(),
(Func<It.IsAnyType, Exception, string>)It.IsAny<object>()), Times.Exactly(1));

Il vérifie qu'un message d'information a été enregistré. Mais, si nous voulons vérifier des informations plus complexes sur le message comme le modèle de message et les propriétés nommées, cela devient plus délicat:

_loggerMock.Verify
(
    l => l.Log
    (
        //Check the severity level
        LogLevel.Error,
        //This may or may not be relevant to your scenario
        It.IsAny<EventId>(),
        //This is the magical Moq code that exposes internal log processing from the extension methods
        It.Is<It.IsAnyType>((state, t) =>
            //This confirms that the correct log message was sent to the logger. {OriginalFormat} should match the value passed to the logger
            //Note: messages should be retrieved from a service that will probably store the strings in a resource file
            CheckValue(state, LogTest.ErrorMessage, "{OriginalFormat}") &&
            //This confirms that an argument with a key of "recordId" was sent with the correct value
            //In Application Insights, this will turn up in Custom Dimensions
            CheckValue(state, recordId, nameof(recordId))
    ),
    //Confirm the exception type
    It.IsAny<NotImplementedException>(),
    //Accept any valid Func here. The Func is specified by the extension methods
    (Func<It.IsAnyType, Exception, string>)It.IsAny<object>()),
    //Make sure the message was logged the correct number of times
    Times.Exactly(1)
);

Je suis sûr que vous pourriez faire la même chose avec d'autres frameworks moqueurs, mais l' ILoggerinterface garantit que c'est difficile.

Si un encore réel. Manière simple de se connecter pour générer des tests pour .net core> = 3

[Fact]
public void SomeTest()
{
    using var logFactory = LoggerFactory.Create(builder => builder.AddConsole());
    var logger = logFactory.CreateLogger<AccountController>();
    
    var controller = new SomeController(logger);

    var result = controller.SomeActionAsync(new Dto{ ... }).GetAwaiter().GetResult();
}

Utilisez Telerik Just Mock pour créer une instance simulée de l'enregistreur:

using Telerik.JustMock;
...
context = new XDbContext(Mock.Create<ILogger<XDbContext>>());

J'ai essayé de me moquer de cette interface Logger en utilisant NSubstitute (et j'ai échoué parce que Arg.Any<T>()requiert un paramètre de type, que je ne peux pas fournir), mais j'ai fini par créer un enregistreur de test (similaire à la réponse de @ jehof) de la manière suivante:

    internal sealed class TestLogger<T> : ILogger<T>, IDisposable
    {
        private readonly List<LoggedMessage> _messages = new List<LoggedMessage>();

        public IReadOnlyList<LoggedMessage> Messages => _messages;

        public void Dispose()
        {
        }

        public IDisposable BeginScope<TState>(TState state)
        {
            return this;
        }

        public bool IsEnabled(LogLevel logLevel)
        {
            return true;
        }

        public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
        {
            var message = formatter(state, exception);
            _messages.Add(new LoggedMessage(logLevel, eventId, exception, message));
        }

        public sealed class LoggedMessage
        {
            public LogLevel LogLevel { get; }
            public EventId EventId { get; }
            public Exception Exception { get; }
            public string Message { get; }

            public LoggedMessage(LogLevel logLevel, EventId eventId, Exception exception, string message)
            {
                LogLevel = logLevel;
                EventId = eventId;
                Exception = exception;
                Message = message;
            }
        }
    }

Vous pouvez facilement accéder à tous les messages enregistrés et affirmer tous les paramètres significatifs fournis avec.