Cara menguji unit dengan ILogger di ASP.NET Core

Ini pengontrol saya:

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

Seperti yang Anda lihat, saya memiliki 2 dependensi, a IDAOdan aILogger

Dan ini adalah kelas pengujian saya, saya menggunakan xUnit untuk menguji dan Moq untuk membuat tiruan dan rintisan, saya dapat mengejek dengan DAOmudah, tetapi dengan ILoggersaya tidak tahu apa yang harus dilakukan jadi saya hanya memberikan null dan mengomentari panggilan untuk masuk pengontrol saat uji coba. Apakah ada cara untuk menguji tetapi tetap mempertahankan logger?

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

Hanya mengejeknya serta ketergantungan lainnya:

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

Anda mungkin perlu menginstal Microsoft.Extensions.Logging.Abstractionspaket untuk digunakan ILogger<T>.

Selain itu, Anda dapat membuat logger nyata:

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

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

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

Sebenarnya, saya telah menemukan Microsoft.Extensions.Logging.Abstractions.NullLogger<>solusi yang tampaknya sempurna. Instal paketnya Microsoft.Extensions.Logging.Abstractions, lalu ikuti contoh untuk mengkonfigurasi dan menggunakannya:

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

dan uji unit

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

Gunakan logger khusus yang menggunakan ITestOutputHelper(dari xunit) untuk menangkap keluaran dan log. Berikut ini adalah contoh kecil yang hanya menulis stateke output.

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

Gunakan di unittests Anda seperti

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

Untuk jawaban .net core 3 yang menggunakan Moq

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

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

  tidak lagi berfungsi karena perubahan yang dijelaskan dalam masalah TState di ILogger.Log dulu objek, sekarang FormattedLogValues

Untungnya stakx memberikan solusi yang bagus . Jadi saya mempostingnya dengan harapan dapat menghemat waktu untuk orang lain (butuh beberapa saat untuk mencari tahu):

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

Menambahkan 2 sen saya, Ini adalah metode ekstensi pembantu yang biasanya dimasukkan ke dalam kelas pembantu statis:

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

Kemudian, Anda menggunakannya seperti ini:

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

//Act

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

Dan tentu saja Anda dapat dengan mudah memperluasnya untuk mengejek ekspektasi apa pun (mis. Ekspektasi, pesan, dll…)

Sangat mudah karena jawaban lain menyarankan untuk melewatkan tiruan ILogger, tetapi tiba-tiba menjadi jauh lebih bermasalah untuk memverifikasi bahwa panggilan benar-benar dibuat ke logger. Alasannya adalah bahwa sebagian besar panggilan sebenarnya bukan milik ILoggerantarmuka itu sendiri.

Jadi, sebagian besar panggilan adalah metode ekstensi yang memanggil satu-satunya Logmetode antarmuka. Alasannya tampaknya adalah jauh lebih mudah untuk membuat implementasi antarmuka jika Anda hanya memiliki satu dan tidak banyak kelebihan beban yang bermuara pada metode yang sama.

Kekurangannya adalah tiba-tiba lebih sulit untuk memverifikasi bahwa panggilan telah dibuat karena panggilan yang harus Anda verifikasi sangat berbeda dari panggilan yang Anda buat. Ada beberapa pendekatan berbeda untuk mengatasi ini, dan saya telah menemukan bahwa metode ekstensi khusus untuk kerangka kerja tiruan akan membuatnya paling mudah untuk ditulis.

Berikut adalah contoh metode yang telah saya buat untuk dikerjakan 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>>());
    }

}

Dan inilah cara penggunaannya:

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

Tampaknya persis seperti jika Anda menggunakan metode secara langsung, triknya di sini adalah metode ekstensi kami mendapat prioritas karena "lebih dekat" dalam ruang nama daripada yang asli, jadi metode ekstensi akan digunakan sebagai gantinya.

Sayangnya itu tidak memberikan 100% apa yang kita inginkan, yaitu pesan kesalahan tidak akan sebaik, karena kita tidak memeriksa langsung pada string melainkan pada lambda yang melibatkan string, tetapi 95% lebih baik daripada tidak sama sekali :) Selain itu pendekatan ini akan membuat kode uji

PS Untuk MOQ satu dapat menggunakan pendekatan menulis metode ekstensi untuk Mock<ILogger<T>>yang melakukan Verifyuntuk mencapai hasil yang sama.

PPS Ini tidak berfungsi di .Net Core 3 lagi, periksa utas ini untuk detail lebih lanjut: https://github.com/nsubstitute/NSubstitute/issues/597#issuecomment-573742574

Sudah disebutkan, Anda dapat mengejeknya seperti antarmuka lainnya.

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

Sejauh ini baik.

Hal yang menyenangkan adalah Anda dapat menggunakan Moquntuk memverifikasi bahwa panggilan tertentu telah dilakukan . Misalnya di sini saya memeriksa bahwa log telah dipanggil dengan tertentu 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>>()));

Saat menggunakan Verifyintinya adalah melakukannya melawan Logmetode nyata dari ILoogerantarmuka dan bukan metode ekstensi.

Membangun lebih jauh dari pekerjaan @ ivan-samygin dan @stakx, berikut adalah metode ekstensi yang juga bisa cocok dengan Exception dan semua nilai log (KeyValuePairs).

Ini bekerja (pada mesin saya;)) dengan .Net Core 3, Moq 4.13.0 dan 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));
}

Dan saat menggunakan StructureMap / Lamar:

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

Dokumen:

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

Hanya membuat boneka ILoggertidak terlalu berharga untuk pengujian unit. Anda juga harus memverifikasi bahwa panggilan logging telah dilakukan. Anda dapat menyuntikkan ejekan ILoggerdengan Moq tetapi memverifikasi panggilan itu bisa sedikit rumit. Artikel ini membahas lebih dalam tentang memverifikasi dengan Moq.

Berikut adalah contoh yang sangat sederhana dari artikel tersebut:

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

Ini memverifikasi bahwa pesan informasi telah dicatat. Tetapi, jika kita ingin memverifikasi informasi yang lebih kompleks tentang pesan seperti template pesan dan properti bernama, itu menjadi lebih rumit:

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

Saya yakin Anda dapat melakukan hal yang sama dengan kerangka kerja tiruan lainnya, tetapi ILoggerantarmuka memastikan bahwa itu sulit.

Jika masih aktual. Cara sederhana lakukan log ke output dalam pengujian untuk .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();
}

Gunakan Telerik Just Mock untuk membuat contoh logger yang diejek:

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

Saya telah mencoba untuk mengejek antarmuka Logger menggunakan NSubstitute (dan gagal karena Arg.Any<T>()memerlukan parameter tipe, yang tidak dapat saya berikan), tetapi akhirnya membuat logger percobaan (mirip dengan jawaban @ jehof) dengan cara berikut:

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

Anda dapat dengan mudah mengakses semua pesan yang dicatat dan menegaskan semua parameter penting yang disediakan dengannya.