静态异步类的模拟单元测试和依赖注入

Question

我有一个用于联系人列表的静态异步缓存。在缓存内部，我正在调用我的存储库以从后端获取数据。我想模拟 ContactsRepository，但我需要将存储库作为参数传递并使用依赖注入。

根据文档，它不起作用，因为我需要一个类的实例来使用依赖注入。

public interface IContactsCache
{
    Task<List<Contact>> GetContactsAsync(int inst, CancellationToken ct);
}

public class ContactsCache : IContactsCache
{
    private static readonly object _syncRoot = new object();
    private static readonly Dictionary<int, Task<List<Contact>>> _contactsTasks = new Dictionary<int, Task<List<Contact>>>();

    public static Task<List<Contact>> GetContactsAsync(int inst)
    {
        return GetContactsAsync(inst, CancellationToken.None);
    }

    public static async Task<List<Contact>> GetCodeValuesAsync(int inst, CancellationToken ct)
    {
        Task<List<Contact>> task;

        lock (_syncRoot)
        {
            if (_contactsTasks.ContainsKey(inst) && (_contactsTasks[inst].IsCanceled || _contactsTasks[inst].IsFaulted))
            {
                _contactsTasks.Remove(inst);
            }

            if (!_contactsTasks.ContainsKey(inst))
            {
                _contactsTasks[inst] = Task.Run(async () =>
                {
                    using (var rep = new ContactsRepository())
                    {
                        return await rep.LoadAsync(inst, ct).ConfigureAwait(false);
                    }
                });
            }

            task = _contactsTasks[inst];
        }

        var res = await task.ConfigureAwait(false);

        lock (_syncRoot)
        {
            return res != null ? res.ToList() : null;
        }
    }

    Task<List<CodeValue>> IContactsCache.GetContactsAsync(int inst, CancellationToken ct)
    {
        return GetContactsAsync(inst, ct);
    }
}

最后我希望有这种用法，但我不知道如何更改缓存类，否则任何其他帮助之王都会非常有帮助。

[TestMethod]
public async void GetContactAsync_WhenCalled_ReturnCodeValuesCache()
{
    var expected = new List<Contact>
    {
        new Contact() {Instance = 1, Name = "Test" }
    };

    var mock = new Mock<IContactsRepository>()
        .Setup(x => x.LoadAsync(It.IsAny<int>(), CancellationToken.None))
        .ReturnsAsync(new List<Contact>(expected));

    var actual = await ContactsCache.GetContactsAsync(It.IsAny<int>(), CancellationToken.None);

    CollectionAssert.AreEqual(actual, expected);
}

但它不能工作，我不知道如何正确编写单元测试。

我有很多这样的缓存，我正在使用这样的存储库。在这种情况下，是否有任何标准或最佳实践如何对静态异步缓存进行单元测试以及如何模拟存储库？

Answer 1

您已经通过将缓存设置为静态来关闭一些门。

快速而肮脏的解决方案：

由于您不能构造函数注入您的存储库，下一个最好的办法是将它传递给您的静态方法。

 public static async Task<List<Contact>> GetCodeValuesAsync(IContactRepository repo, int inst, CancellationToken ct)

如果您这样做，最好将存储库的生命周期管理上移一级。换句话说，将using 语句移动到调用者：

using(var repo = new ContactRepository())
{
    await ContactsCache.GetContactsAsync(repo , It.IsAny<int>(), CancellationToken.None);
}

那么在你的测试中你就可以做到这一点：

var mock = new Mock<IContactsRepository>()
        .Setup(x => x.LoadAsync(It.IsAny<int>(), CancellationToken.None))
        .ReturnsAsync(new List<Contact>(expected));

var actual = await ContactsCache.GetContactsAsync(mock , It.IsAny<int>(), CancellationToken.None);

首选解决方案：

我假设您的存储库负责会话管理（因此是 IDisposable 接口）。如果有办法让您将存储库接口与某些实现可能需要释放的任何资源分开，您可以转向构造函数注入方法。

您的代码将如下所示：

public class ContactsCache : IContactsCache
{
    private readonly IContactRepository contactRepo;

    public ContactsCache(IContactRepository contactRepo)
    {
        this.contactRepo = contactRepo;
    }

    // ...
    return await this.contactRepo.LoadAsync(inst, ct).ConfigureAwait(false);
    // ...
}

您的单元测试将如下所示：

[TestMethod]
public async void GetContactAsync_WhenCalled_ReturnCodeValuesCache()
{
    var expected = new List<Contact>
    {
        new Contact() {Instance = 1, Name = "Test" }
    };

    var mock = new Mock<IContactsRepository>()
        .Setup(x => x.LoadAsync(It.IsAny<int>(), CancellationToken.None))
        .ReturnsAsync(new List<Contact>(expected));

    var cache = new ContactsCache(mock);

    var actual = await cache .GetContactsAsync(It.IsAny<int>(), CancellationToken.None);

    CollectionAssert.AreEqual(actual, expected);
}

您还可以考虑反转缓存和存储库之间的依赖关系。换句话说，您的存储库实现可以有一个缓存。这使您可以更动态地选择缓存策略。例如，您可能有以下任何一种：

var repo = new ContactRepository(new MemoryCache<Contact>())

或

var repo = new ContactsRepository(new NullCache<Contact>())

这种方法意味着存储库的使用者不需要知道或关心数据的来源。这允许您测试您的缓存机制，而无需首先使用存储库。当然，如果您想测试存储库，则需要为其提供缓存策略。

采用这种方法还可以让您获得一个相当快速的解决方案，因为您可以使用这样的类来包装现有的静态缓存：

public class MemoryCache : ICachingStrategy<Contact>
{
    public async Task<List<Contact>> GetCodeValuesAsync(int inst, CancellationToken ct) // This comes from the interface
    {
        return await ContactsCache.GetContactsAsync(inst, ct); // Just forward the call to the existing static cache
    }
}

在访问数据库/文件系统/远程资源之前，您的存储库需要进行一些工作以使其考虑缓存。

旁注 - 如果您 new 设置“依赖项”，则您不再进行依赖项注入。