How can I write unit test for my background service?

Question

I'm working with the HostBuilder in .NET Core (not the WebHost !).

I have one Hosted Service running in my application that overrides the ExecuteAsync/StopAsync methods of the background Service and I want to unit test it.

Here is my HostedService:

public class DeviceToCloudMessageHostedService : BackgroundService
{
    private readonly IDeviceToCloudMessageService _deviceToCloudMessageService;
    private readonly AppConfig _appConfig;

    public DeviceToCloudMessageHostedService(IDeviceToCloudMessageService deviceToCloudMessageService, IOptionsMonitor<AppConfig> appConfig)
    {
        _deviceToCloudMessageService = deviceToCloudMessageService;
        _appConfig = appConfig.CurrentValue;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            await _deviceToCloudMessageService.DoStuff(stoppingToken);
            await Task.Delay(_appConfig.Parameter1, stoppingToken);
        }
    }
    
    public override Task StopAsync(CancellationToken cancellationToken)
    {
        Log.Information("Task Cancelled");
        _deviceToCloudMessageService.EndStuff();
        return base.StopAsync(cancellationToken);
    }

I already found this post: Integration Test for Hosted Service in .NET Core

But it's explained for a QueuedBackgroundService and I don't really know if I can test mine the same way.

I just want to know if my code is executed. I don't want any specific result. Do you have any idea of how I can test it?

You should be able to follow the same format. mock the dependencies and inject them, invoke the methods under test and assert the expected behavior — Nkosi, Jun 18 '19 at 09:54

score 24 · Answer 1 · edited Oct 15 '21 at 12:03

You should still be able to follow a similar format as the linked answer.

Mock the dependencies and inject them, invoke the methods under test and assert the expected behavior.

The following uses Moq to mock the dependencies along with ServiceCollection to do the heavy lifting of injecting the dependencies.

using System;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Moq;

[TestMethod]
public async Task DeviceToCloudMessageHostedService_Should_DoStuff() {
    //Arrange
    IServiceCollection services = new ServiceCollection();
    services.AddSingleton<IHostedService, DeviceToCloudMessageHostedService>();
    //mock the dependencies for injection
    services.AddSingleton(Mock.Of<IDeviceToCloudMessageService>(_ =>
        _.DoStuff(It.IsAny<CancellationToken>()) == Task.CompletedTask
    ));
    services.AddSingleton(Mock.Of<IOptionsMonitor<AppConfig>>(_ =>
        _.CurrentValue == Mock.Of<AppConfig>(c => 
            c.Parameter1 == TimeSpan.FromMilliseconds(1000)
        )
    ));
    var serviceProvider = services.BuildServiceProvider();
    var hostedService = serviceProvider.GetService<IHostedService>();

    //Act
    await hostedService.StartAsync(CancellationToken.None);
    await Task.Delay(1000);//Give some time to invoke the methods under test
    await hostedService.StopAsync(CancellationToken.None);

    //Assert
    var deviceToCloudMessageService = serviceProvider
        .GetRequiredService<IDeviceToCloudMessageService>();
    //extracting mock to do verifications
    var mock = Mock.Get(deviceToCloudMessageService);
    //assert expected behavior
    mock.Verify(_ => _.DoStuff(It.IsAny<CancellationToken>()), Times.AtLeastOnce);
    mock.Verify(_ => _.EndStuff(), Times.AtLeastOnce());
}

Now, ideally this would count as testing framework code since you are basically testing that a BackgroundService behaves as expected when run, but it should demonstrate enough about how one would test such a service in isolation

There are a couple of issues with this approach though. Firstly, you have time-based unit-tests which are inherently fragile. Secondly, you won't get meaningful exception messages out if something goes wrong - you will merely discover that your verify calls fail, and you'll need to step through with a debugger. A couple of better approaches: (1) Put as much of the service code into a testable class as possible, and inject an instance of that class into the `BackgroundService`. Then you only need to prove the injected class gets called (2) use reflection to call the ExecuteAsync method. — RB., Dec 16 '20 at 21:55
@RB. If you have a better suggestion, why not make it an answer? — Jimenemex, Feb 10 '21 at 00:44
`hostedService.StartAsync` is blocking, so your code does not work. — JobaDiniz, Aug 24 '21 at 20:51
@RB. if you were going to do with that approach I'd suggest using [MediatR](https://github.com/jbogard/MediatR). — WBuck, Oct 15 '21 at 12:12

score 0 · Answer 2 · answered Jul 21 '23 at 02:07

The above solution is not work for me. Because the background service will run infinitely. My solution use CancellationToken and create a Thread to cancel it after a time . The code look like:

CancellationTokenSource source = new CancellationTokenSource();
CancellationToken token = source.Token;
new Thread(async () =>
{
     Thread.CurrentThread.IsBackground = true;
     await Task.Delay(500);
     hostedService.StopAsync(token);
}).Start();

await hostedService.StartAsync(token)

How can I write unit test for my background service?

2 Answers2

Linked