Question

我有一个由hosted services在.NET Core中实现的后台任务。此类中的逻辑很少：

public class IndexingService : IHostedService, IDisposable
{
    private readonly int indexingFrequency;

    private readonly IIndexService indexService;

    private readonly ILogger logger;

    private bool isRunning;

    private Timer timer;

    public IndexingService(ILogger<IndexingService> logger, IIndexService indexService, IndexingSettings indexingSettings)
    {
        this.logger = logger;
        this.indexService = indexService;

        this.indexingFrequency = indexingSettings.IndexingFrequency;
    }

    public void Dispose()
    {
        this.timer?.Dispose();
    }

    public Task StartAsync(CancellationToken cancellationToken)
    {
        this.timer = new Timer(this.DoWork, null, TimeSpan.Zero, TimeSpan.FromSeconds(this.indexingFrequency));
        return Task.CompletedTask;
    }

    public Task StopAsync(CancellationToken cancellationToken)
    {
        this.timer?.Change(Timeout.Infinite, 0);
        return Task.CompletedTask;
    }

    private void DoWork(object state)
    {
        if (this.isRunning)
        {
            // Log
            return;
        }

        try
        {
            this.isRunning = true;
            this.indexService.IndexAll();
        }
        catch (Exception e)
        {
            // Log, The background task should never throw.
        }
        finally
        {
            this.isRunning = false;
        }
    }
}

我的Startup如下：

public void ConfigureServices(IServiceCollection services)
{
    services.AddHostedService<IndexingService>();
    services.AddTransient<IIndexService, IndexService>();
    // 'IndexingSettings' is read from appsetting and registered as singleton
}

如何对DoWork方法中的逻辑进行单元测试？问题在于托管服务是由框架管理的，我不知道如何隔离此类。

Answer 1

不确定隔离类的意思。这些不是魔术。 ASP.NET Core仅使用任何必需的依赖关系实例化该类，然后在应用程序关闭时调用StartAsync，然后调用StopAsync。没有什么是您无法手动完成的。

换句话说，要对其进行单元测试，您可以模拟依赖项，实例化该类，然后在其上调用StartAsync。但是，我认为总体托管服务更适合集成测试。您可以将任何实际的工作分解为助手类，以简化单元测试，然后只需在服务上运行集成测试以确保其通常能够完成预期的工作即可。

.NET Core中的单元测试托管服务

1 个答案: