如何使用最小起订量来证明被测方法调用另一个方法

“我能想到的唯一方法是对被测班级使用模拟。”

我认为你不应该模拟考试中的课程。仅模拟被测类所具有的外部依赖项。您可以做的是创建一个 .它将是一个派生自您的 CUT 的类，在这里您可以捕获对 的调用并稍后验证其参数。它）testable-classanother method

• 示例中的可测试类被命名为MyTestableController
• 另一种方法被命名为 。InternalMethod

简短示例：

[TestClass]
public class Tests
{
    [TestMethod]
    public void MethodUnderTest_WhenServiceReturnsNull_CallsInternalMethodWithDefault()
    {
        // Arrange
        Mock<IService> serviceStub = new Mock<IService>();
        serviceStub.Setup(s => s.ServiceCall()).Returns((ReturnedFromService)null);
        MyTestableController testedController = new MyTestableController(serviceStub.Object)
        {
            FakeInternalMethod = true
        };

        // Act
        testedController.MethodUnderTest();

        // Assert
        Assert.AreEqual(testedController.SomeDefaultValue, testedController.FakeInternalMethodWasCalledWithThisParameter);
    }

    private class MyTestableController
        : MyController
    {

        public bool FakeInternalMethod { get; set; }
        public string FakeInternalMethodWasCalledWithThisParameter { get; set; }

        public MyTestableController(IService service) 
            : base(service)
        { }

        internal override void InternalMethod(string someProperty)
        {
            if (FakeInternalMethod)
                FakeInternalMethodWasCalledWithThisParameter = someProperty;
            else
                base.InternalMethod(someProperty);
        }
    }
}

CUT 可能如下所示：

public class MyController : Controller
{
    private readonly IService _service;

    public MyController(IService service)
    {
        _service = service;
    }

    public virtual string SomeDefaultValue { get { return "SomeDefaultValue"; }}

    public EmptyResult MethodUnderTest()
    {
        // We just found a bug in this method ...

        // The method under test calls a service which returns an object.
        ReturnedFromService fromService = _service.ServiceCall();

        // It then calls an internal method passing a string property of this object
        string someStringProperty = fromService == null 
            ? SomeDefaultValue 
            : fromService.SomeProperty;
        InternalMethod(someStringProperty);

        return new EmptyResult();
    }

    internal virtual void InternalMethod(string someProperty)
    {
        throw new NotImplementedException();
    }
}

我认为这里有一种代码味道。在这种情况下，我会问自己的第一个问题是，“内部”方法是否真的是被测控制器的内部/私有方法。执行“内部”任务是控制者的责任吗？当内部方法的实现发生更改时，控制器是否应该更改？可能不是。

在这种情况下，我会拉出一个新的目标类，它有一个公共方法，可以执行迄今为止控制器内部的操作。 完成此重构后，我将使用 MOQ 的回调机制并断言参数值。

所以最终，你最终会嘲笑两个依赖关系： 1. 对外服务 2. 具有控制器内部实现的新目标类

现在，您的控制器是完全隔离的，可以独立进行单元测试。此外，“内部”实现变得可进行单元测试，并且也应该有自己的一组单元测试。

因此，您的代码和测试将如下所示：

public class ControllerUnderTest
{

    private IExternalService Service { get; set; }
    private NewFocusedClass NewFocusedClass { get; set; }
    const string DefaultValue = "DefaultValue";

    public ControllerUnderTest(IExternalService service, NewFocusedClass newFocusedClass)
    {
        Service = service;
        NewFocusedClass = newFocusedClass;
    }

    public void MethodUnderTest()
    {
        var returnedValue = Service.ExternalMethod();
        string valueToBePassed;
        if (returnedValue == null)
        {
            valueToBePassed = DefaultValue;
        }
        else
        {
            valueToBePassed = returnedValue.StringProperty;
        }
        NewFocusedClass.FocusedBehvaior(valueToBePassed);
    }
}

public interface IExternalService
{
    ReturnClass ExternalMethod();
}

public class NewFocusedClass
{
    public virtual void FocusedBehvaior(string param)
    {

    }
}

public class ReturnClass
{
    public string StringProperty { get; set; }
}

[TestClass]
public class ControllerTests
{
    [TestMethod]
    public void TestMethod()
    {
        //Given
        var mockService = new Mock<IExternalService>();
        mockService.Setup(s => s.ExternalMethod()).Returns((ReturnClass)null);
        var mockFocusedClass = new Mock<NewFocusedClass>();
        var actualParam = string.Empty;
        mockFocusedClass.Setup(x => x.FocusedBehvaior(It.IsAny<string>())).Callback<string>(param => actualParam = param);

        //when
        var controller = new ControllerUnderTest(mockService.Object, mockFocusedClass.Object);
        controller.MethodUnderTest();

        //then
        Assert.AreEqual("DefaultValue", actualParam);
    }
}

编辑：根据评论中的建议，使用“验证”而不是回调。 验证参数值的更简单方法是使用严格的最小起订量行为，并在执行受测系统后对模拟进行验证调用。 修改后的测试可能如下所示：

[TestMethod]
    public void TestMethod()
    {
        //Given
        var mockService = new Mock<IExternalService>();
        mockService.Setup(s => s.ExternalMethod()).Returns((ReturnClass)null);
        var mockFocusedClass = new Mock<NewFocusedClass>(MockBehavior.Strict);
        mockFocusedClass.Setup(x => x.FocusedBehvaior(It.Is<string>(s => s == "DefaultValue")));

        //When
        var controller = new ControllerUnderTest(mockService.Object, mockFocusedClass.Object);
        controller.MethodUnderTest();

        //Then
        mockFocusedClass.Verify();
    }