How do I provide ILogger<T> in my unit tests of .NET Core code?

Question

Given a class with a constructor signature of

public Foo(ILogger<Foo> logger) {
    // ...
}

that I want to test, I need some way to provide an ILogger<Foo> in the test. It's been asked before, but the only answer then was to set up a full-blown service registry, configure logging and resolve the logger from there. This seems very overkill to me.

Is there a simple way to provide an implementation of ILogger<T> for testing purposes?

Note: it doesn't have to actually log anything - just not blow up when the subject under test tries to log something.

Answer 1

Starting from dotnet core 2.0 there's a generic NullLogger<T> class available:

var foo = new Foo(NullLogger<Foo>.Instance);

https://learn.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.abstractions.nulllogger-1?view=aspnetcore-2.1 (docs) https://github.com/aspnet/Logging/blob/master/src/Microsoft.Extensions.Logging.Abstractions/NullLoggerOfT.cs (source)

Or if you need it as part of your services:

services.AddSingleton<ILoggerFactory, NullLoggerFactory>();

https://learn.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.abstractions.nullloggerfactory?view=aspnetcore-2.1 (docs)

Answer 2

You can create an instance of ILogger<Foo> using NullLoggerFactory as the factory.

Consider the following controller:

public abstract class Foo: Controller
{
    public Foo(ILogger<Foo> logger) {
        Logger = logger;
    }

    public ILogger Logger { get; private set; }
}

A sample unit test could be:

[TestMethod]
public void FooConstructorUnitTest()
{
    // Arrange
    ILogger<FooController> logger = new Logger<FooController>(new NullLoggerFactory());

    // Act
    FooController target = new FooController(logger);

    // Assert
    Assert.AreSame(logger, target.Logger);
}

Answer 3

If you use generic logger (ILogger<>) in your classes those instances are generated from IServiceProvider you should register generic NullLogger<> on service provider as below. Not important what you use generic type T in ILogger<>

services.AddSingleton(typeof(ILogger<>), typeof(NullLogger<>));

Answer 4

You have two options:

1. Create empty implementation of ILogger<Foo> by hand and pass an instance of it to ctor.
2. Create same empty implementation on the fly using some mocking framework like Moq, NSubstitute, etc.

Answer 5

You could inject ILoggerFactory instead and then create the logger

public Foo(ILoggerFactory loggerFactory) {
    logger = loggerFactory.CreateLogger<Foo>();
    // ...
}

At startup you need to add the NullLoggerFactory service of course:

services.AddSingleton<ILoggerFactory, NullLoggerFactory>()

Answer 6

From the docs for ILogger<T> (emphasis mine):

A generic interface for logging where the category name is derived from the specified TCategoryName type name. Generally used to enable activation of a named ILogger from dependency injection.

So one option would be to change the implementation of the Foo method to take a plain ILogger and use the NullLogger implementation.