Повторяющиеся экземпляры универсального типа с универсальным методом

Я работаю над тестовой инфраструктурой, которая может помочь разработчикам в проекте веб-API. Ниже я завершил классы утверждений. Однако, когда мы увеличим количество классов проверки, это будет выглядеть странно, как сейчас 🙂

У вас есть четкая идея по рефакторингу этого фрагмента кода?

public class TestModuleVerificationWrapper
{
    private Lazy<CompanyTestVerificationWrapper> inCompany;
    private Lazy<LookUpTestVerificationWrapper> inLookUp;
    private Lazy<LookUpTypeTestVerificationWrapper> inLookUpType;
    public CompanyTestVerificationWrapper InCompany => CreateVerificationWrapper<CompanyTestVerificationWrapper>(inCompany);
    public LookUpTestVerificationWrapper InLookUp => CreateVerificationWrapper<LookUpTestVerificationWrapper>(inLookUp);
    public LookUpTypeTestVerificationWrapper InLookUpType => CreateVerificationWrapper<LookUpTypeTestVerificationWrapper>(inLookUpType);

    private T CreateVerificationWrapper<T>(Lazy<T> lazy)
    {
        if (lazy == null)
        {
            lazy = new Lazy<T>(() => Activator.CreateInstance<T>(), true);
        }
        if (!lazy.IsValueCreated)
        {
            return lazy.Value;
        }
        return lazy.Value;
    }
}

public class CompanyTestVerificationWrapper
{
    public CompanyTestVerification<T> WithResult<T>(T result) where T : class
    {
        return new CompanyTestVerification<T>(result);
    }
}

public class LookUpTestVerificationWrapper
{
    public LookUpTestVerification<T> WithResult<T>(T result) where T : class
    {
        return new LookUpTestVerification<T>(result);
    }
}

public class LookUpTypeTestVerificationWrapper
{
    public LookUpTypeTestVerification<T> WithResult<T>(T result) where T : class
    {
        return new LookUpTypeTestVerification<T>(result);
    }
}

Я использую этот класс в другом базовом классе, чтобы обернуть все модули, как показано ниже

public abstract class IntegrationTest : ApplicationFactory
{
    private Lazy<TestModuleWrapper> when;
    private Lazy<TestModuleVerificationWrapper> then;
    public TestModuleWrapper When => GetWhen();
    public TestModuleVerificationWrapper Then => GetThen();

    private TestModuleWrapper GetWhen()
    {
        if (when is null)
        {
            when = new Lazy<TestModuleWrapper>(() => new TestModuleWrapper(base.Self()), true);
        }
        return when.Value;
    }

    private TestModuleVerificationWrapper GetThen()
    {
        if (then is null)
        {
            then = new Lazy<TestModuleVerificationWrapper>(() => new TestModuleVerificationWrapper(), true);
        }
        return then.Value;
    }
}

И образец использования, как показано ниже

[Test]
public async Task CanList_OnePage_Company()
{
    var result = await When.InCompany.IListCompanies(With.PageNumber(1).Items(10));
    Then.InCompany.WithResult(result).ResultShouldBeLoaded()
            .And.TotalCompanyCountShouldBe(20)
            .And.CompanyCounOnPageShouldBe(10)
            .And.PageNumberShouldBe(1);
}