Question

我想在下面的代码中测试FindPolicyToBeResent（）。我有几个选项，但是如果我的方法即最后一个选项没问题，我想知道其他人是如何处理这种情况的？

使FindPolicyToBeResent（）公开。这不是一个选项，因为它出于测试的唯一原因公开了一个实现，并使接口混乱
仅使用公共API进行单元测试，但这可能很困难，因为我从未公开我在return语句中直接过滤的集合，并且出于安全原因不能这样做。这意味着我只能进行有限的测试
通常我会在这种情况下将代码分解为一个新对象但在这种情况下感觉不对，我无法预见这个过滤器会在系统中的任何其他位置重复使用，所以它不会比制作方法更好公众，在任何人用单一的责任棒打击我之前（这是合理的），编码是一种平衡行为，我觉得它会打破Keep It Simple原则。它只是让一个班级服务于测试而不是实际上具有单独的单一响应性。另外，它会导致文件和类膨胀。
我可以让代码成为IEnumerable的扩展方法，这会让它变得可测试但是我再也不能预见到这个过滤器在其他任何地方被使用，所以如果它保留在这个类中会更有意义
最后一个选项并且更喜欢但可能被视为一个黑客攻击是使用verify（）在代码中进一步测试documentResenderRepository.CanPolicyBeResent（policy.Id）的模拟，以查看它被击中的时间。我不确定这是不是一个好主意？想法？

我的偏好是最后一个选项，但确实感觉有点脏，我在底部有一个例子

public class DocumentResendService : IDocumentResendService
{
    #region Member Variables
    ...
    #endregion


    #region Constructors
    ...
    #endregion


    #region Accessors
    ...
    #endregion

    #region Methods
    public IDocumentResendResponse ResendDocuments()
    {
        if (!IsInputsValid())
        {
            return response;
        }


        RecordRequestAttempt();

        if (RequestLimitIsReached())
        {
            return response;
        }


        FindPolicyToBeResent();


        if(PolicyCanNotBeResent())
        {
            return response;
        }

        RequestDocumentToBeResent();

        return response;
    }


    private bool IsInputsValid()
    {
        ..
    }


    private void RecordRequestAttempt()
    {
        ...
    }


    private bool RequestLimitIsReached()
    {
        ...
    }

    // I want to test this method which basically just filters the policies
    private void FindPolicyToBeResent()
    {
        var allPolicies = policyDocumentRepository.GetPolicy(AgentCode, Email, PostCode, SearchDate, BirthDate);

        policies = allPolicies.Where(currentPolicy => currentPolicy.IsActive() || currentPolicy.IsInTheFuture());

        if (policies.Count() == 0 )
        {
            policies = allPolicies.FilterToPolicyThatHasEndedMostRecently();          
        }
     }


    private bool PolicyCanNotBeResent()
    {
        if (policies == null || !policies.Any())
        {
            response.Add(ErrorCode.PolicyCanNotBeFound);

            return true;
        }

        foreach (var policy in policies)
        {
           // I could mock this line and use a verify here which policy id's are passed in
            if (documentResenderRepository.CanPolicyBeResent(policy.Id) == false)
            {
                response.Add(ErrorCode.UnableToResendDocument);
            }  
        }

        return response.Errors.Any();
    }


    private void RequestDocumentToBeResent()
    {
        ...
    }

    #endregion
}

以下是最后一个选项的单元测试解决方案，但

[TestFixture]
public class FindPolicyToBeResentTest : DocumentResenderTestsBase
{
    private readonly List<Policy> allPolicies = new List<Policy>();

    public FindPolicyToBeResentTest()
    {
        var day = -250;

        for (int i = 1; i < 6; i++)
        {
            var policy = new Policy
            {
                Id = i,
                StartDate = DateTime.Now.AddDays(day)
            };
            day = day + 100;
            policy.EndDate = DateTime.Now.AddDays(day);
            allPolicies.Add(policy);
        }
    }

    private void SetUpDocumentResender(IEnumerable<Policy> policies)
    {


        SetUpObjectDefaultsForDocumentResenderCreation();

        policyRepositoryMock.Setup(y => y.GetPolicy(It.IsAny<string>(),
                                                    It.IsAny<string>(),
                                                    It.IsAny<string>(),
                                                    It.IsAny<DateTime>(),
                                                    It.IsAny<DateTime>()))
            .Returns(policies);


        documentResendService = CreateDocumentResendService();

        SetDocumentResenderDefaults();
    }


    [Test]
    public void PoliciesThatAreNotActiveOrAreInThePastShouldBeFilteredOut()
    {
        SetUpDocumentResender(allPolicies);

        documentResendService.ResendDocuments();

        foreach (var policy in allPolicies)
        {
            if (policy.IsActive() || policy.IsInTheFuture())
            {
                documentResenderRepositoryMock.Verify(x => x.CanPolicyBeResent(policy.Id), Times.AtLeastOnce());
            }
            else
            {
                documentResenderRepositoryMock.Verify(x => x.CanPolicyBeResent(policy.Id), Times.Never());
            }
        }
    }

    [Test]
    public void IfNoPoliciesAreFoundThatAreSuitableForDocumentResendingThenGetThePolicyThatHasMostRecentlyExpired()
    {
        var unsuitablePolicies = allPolicies.Where(x => x.IsActive() == false && x.IsInTheFuture() == false).OrderBy(x => x.EndDate);

        var policyWithClosestToEndDateToNow = unsuitablePolicies.ToList().Last();

        SetUpDocumentResender(unsuitablePolicies);

        documentResendService.ResendDocuments();

        documentResenderRepositoryMock.Verify(x => x.CanPolicyBeResent(policyWithClosestToEndDateToNow.Id), Times.AtLeastOnce());

        foreach (var policy in allPolicies.Where(policy => policy != policyWithClosestToEndDateToNow))
        {
            documentResenderRepositoryMock.Verify(x => x.CanPolicyBeResent(policy.Id), Times.Never());
        }
    }
}

Answer 1

通过公共方法测试私有方法很好。如果你的代码足够模块化，那么不应该有太多的设置代码，以便让条件正确进入你的私有方法。如果你发现自己设置了许多东西只是为了进入你的私人方法，你可能在一堂课中做得太多了。

在你的情况下，我很想接受你的观点3），并创建一个PolicyFinder：IPolicyFinder类。也许您现在不需要重复使用它，它可以使您的代码在将来更容易修改并使两个类更容易测试

（见http://en.wikipedia.org/wiki/Single_responsibility_principle）

编辑：我没有完全阅读你的要点，很抱歉用单一责任棒击中你;）

Answer 2

您可以将方法标记为内部方法而不是私有方法，然后使用AssemblyInfo.cs文件中的InternalsVisibleTo属性来允许单元测试程序集访问这些内部方法。例如，汇编OVReadySDK的AssemblyInfo文件中的此语句：

[assembly: InternalsVisibleTo("OVReadySDKUT, PublicKey=002400000480...5baacad")]

允许单元测试程序集OVReadySDKUT中的测试方法访问OVReadySDK中的类和方法，就好像测试方法是相同的程序集一样。

您可以通过搜索“InternalsVisibleTo单元测试”找到相关技术的一些示例。请注意，如果您的程序集已签名，则需要在InternalsVisibleTo语句中提供公钥参数。

当单元测试时，在这个例子中使用验证来间接测试一个方法吗？

2 个答案: