Unit-Test mit ILogger in ASP.NET Core

Das ist mein Controller:

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);
    }
}

Wie Sie sehen können, habe ich 2 Abhängigkeiten, a IDAOund aILogger

Und dies ist meine Testklasse. Ich benutze xUnit zum Testen und Moq zum Erstellen von Mock und Stub. Ich kann DAOeinfach verspotten , aber mit dem ILoggerich nicht weiß, was ich tun soll, übergebe ich einfach null und kommentiere den Aufruf zum Anmelden des Controllers aus beim Test ausführen. Gibt es eine Möglichkeit zu testen, aber den Logger trotzdem irgendwie zu behalten?

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());
    }
}

Verspotten Sie es einfach und jede andere Abhängigkeit:

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);

Sie müssen wahrscheinlich das Microsoft.Extensions.Logging.AbstractionsPaket installieren , um es verwenden zu können ILogger<T>.

Außerdem können Sie einen echten Logger erstellen:

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

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

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

Eigentlich habe ich gefunden, Microsoft.Extensions.Logging.Abstractions.NullLogger<>was wie eine perfekte Lösung aussieht. Installieren Sie das Paket Microsoft.Extensions.Logging.Abstractionsund folgen Sie dem Beispiel, um es zu konfigurieren und zu verwenden:

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>();
    }
}

und Unit Test

//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);
}   

Verwenden Sie einen benutzerdefinierten Logger, der ITestOutputHelper(von xunit) zum Erfassen von Ausgaben und Protokollen verwendet. Das Folgende ist ein kleines Beispiel, das nur das statein die Ausgabe schreibt .

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()
    {
    }
}

Verwenden Sie es in Ihren Unittests wie

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
  }
}

Für .net Core 3 Antworten, die Moq verwenden

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

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

  funktionieren aufgrund einer Änderung, die im Problem TState in ILogger.Log beschrieben wurde, nicht mehr. Früher war es ein Objekt, jetzt FormattedLogValues

Zum Glück stakx eine schöne bereitgestellt Abhilfe . Also poste ich es in der Hoffnung, dass es Zeit für andere sparen kann (es hat eine Weile gedauert, um die Dinge herauszufinden):

 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);

Wenn ich meine 2 Cent addiere, ist dies eine Hilfserweiterungsmethode, die normalerweise in eine statische Hilfsklasse eingefügt wird:

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);
    }
}

Dann verwenden Sie es wie folgt:

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

//Act

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

Und natürlich können Sie es leicht erweitern, um jede Erwartung zu verspotten (z. B. Erwartung, Botschaft usw.).

Es ist einfach, wie andere Antworten vorschlagen, Mock zu übergeben ILogger, aber es wird plötzlich viel problematischer zu überprüfen, ob tatsächlich Anrufe an den Logger getätigt wurden. Der Grund ist, dass die meisten Anrufe nicht zur ILoggerSchnittstelle selbst gehören.

Die meisten Aufrufe sind also Erweiterungsmethoden, die die einzige LogMethode der Schnittstelle aufrufen . Der Grund dafür ist, dass die Implementierung der Schnittstelle viel einfacher ist, wenn Sie nur eine und nicht viele Überladungen haben, die auf dieselbe Methode hinauslaufen.

Der Nachteil ist natürlich, dass es plötzlich viel schwieriger ist zu überprüfen, ob ein Anruf getätigt wurde, da sich der Anruf, den Sie überprüfen sollten, stark von dem Anruf unterscheidet, den Sie getätigt haben. Es gibt verschiedene Ansätze, um dies zu umgehen, und ich habe festgestellt, dass benutzerdefinierte Erweiterungsmethoden zum Verspotten von Frameworks das Schreiben am einfachsten machen.

Hier ist ein Beispiel für eine Methode, mit der ich gearbeitet habe 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>>());
    }

}

Und so kann es verwendet werden:

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

Es sieht genau so aus, als hätten Sie die Methode direkt verwendet. Der Trick dabei ist, dass unsere Erweiterungsmethode Priorität erhält, da sie in Namespaces "näher" ist als die ursprüngliche, sodass sie stattdessen verwendet wird.

Es gibt leider nicht 100% was wir wollen, nämlich Fehlermeldungen werden nicht so gut sein, da wir nicht direkt auf eine Zeichenfolge prüfen, sondern auf ein Lambda, das die Zeichenfolge betrifft, aber 95% sind besser als nichts :) Zusätzlich Dieser Ansatz erstellt den Testcode

PS Für Moq kann man den Ansatz des Schreibens eine Erweiterungsmethode für die Verwendung , Mock<ILogger<T>>das tut Verifyähnliche Ergebnisse zu erzielen.

PPS Dies funktioniert in .Net Core 3 nicht mehr. Weitere Informationen finden Sie in diesem Thread: https://github.com/nsubstitute/NSubstitute/issues/597#issuecomment-573742574

Bereits erwähnt können Sie es wie jede andere Schnittstelle verspotten.

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

So weit, ist es gut.

Das Schöne ist, dass Sie Moqdamit überprüfen können , ob bestimmte Anrufe ausgeführt wurden . Zum Beispiel überprüfe ich hier, ob das Protokoll mit einem bestimmten aufgerufen wurde 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>>()));

Wenn Sie Verifyden Punkt verwenden, tun Sie dies gegen die reale LogMethode von der ILoogerSchnittstelle und nicht gegen die Erweiterungsmethoden.

Aufbauend auf der Arbeit von @ ivan-samygin und @stakx finden Sie hier Erweiterungsmethoden, die auch mit der Ausnahme und allen Protokollwerten (KeyValuePairs) übereinstimmen können.

Diese funktionieren (auf meinem Computer;)) mit .Net Core 3, Moq 4.13.0 und 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));
}

Und bei Verwendung von StructureMap / Lamar:

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

Docs:

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

Das bloße Erstellen eines Dummys ILoggerist für Unit-Tests nicht sehr wertvoll. Sie sollten auch überprüfen, ob die Protokollierungsaufrufe getätigt wurden. Sie können ein Mock injizieren ILoggermit Moq aber den Anruf Überprüfung kann ein wenig schwierig sein. Dieser Artikel befasst sich ausführlich mit der Überprüfung mit Moq.

Hier ist ein sehr einfaches Beispiel aus dem Artikel:

_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));

Es wird überprüft, ob eine Informationsnachricht protokolliert wurde. Wenn wir jedoch komplexere Informationen über die Nachricht wie die Nachrichtenvorlage und die genannten Eigenschaften überprüfen möchten, wird es schwieriger:

_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)
);

Ich bin mir sicher, dass Sie dasselbe mit anderen spöttischen Frameworks tun können, aber die ILoggerBenutzeroberfläche stellt sicher, dass es schwierig ist.

Ist ein noch aktueller. Einfache Protokollierung zur Ausgabe in Tests für .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();
}

Verwenden Sie Telerik Just Mock , um eine verspottete Instanz des Loggers zu erstellen:

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

Ich habe versucht, diese Logger-Schnittstelle mit NSubstitute zu verspotten (und bin fehlgeschlagen, weil Arg.Any<T>()ein Typparameter erforderlich ist, den ich nicht bereitstellen kann), habe jedoch einen Testlogger (ähnlich der Antwort von @ jehof) wie folgt erstellt:

    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;
            }
        }
    }

Sie können einfach auf alle protokollierten Nachrichten zugreifen und alle damit verbundenen wichtigen Parameter bestätigen.