C# 最小起订量设置单元测试

我有一个简单的方法，比如：

public class MyService : IMyService
{
    public int Add(int x, int y)
    {
        return x + y;
    }
}

public interface IMyService
{
    int Add(int x, int y);
}

我为该方法编写了一个单元测试：

public void PassingTest()
{
    var mock = new Mock<IMyService>();

    mock.Setup(x => x.Add(It.IsAny<int>(), It.IsAny<int>())).Returns<int, int>((x, y) => { return x + y; });

    var svc = mock.Object;

    var result = svc.Add(3, 3);
    var result2 = svc.Add(2, 5);
    result.Should().Be(6);
    result2.Should().Be(7);
}

public void PassingTest（）
{
var mock=new mock（）；
mock.Setup（x=>x.Add（It.IsAny（），It.IsAny（））.Returns（（x，y）=>{return x+y；}）；
var svc=mock.Object；
var结果=svc.Add（3,3）；
var result2=svc.Add（2,5）；
result.Should（）为（6）；
结果2.Should（）为（7）；
}

---

这个密码可以吗？为什么我必须编写

返回

语句，该语句与整个方法几乎相同？

如果要将

IMyService

用作要测试的另一个类的依赖项，则只会执行类似的操作。如果

IMyService

是正在测试的系统，那么您不会这样做，因为您不会模拟您尝试测试的系统。使用目标类的实际实例

在一个非常简单的例子中，我们有这样一个类

public class SomeClass {
    public SomeClass(IMyService service) {
        this.service = service;
    }
    private readonly IMyService service;

    public int SomeMethodThatUsesMyService(int input) {
        int someConstant = 10;

        var result = service.Add(someConstant, input);
        return result;
    }
}

如果

IMyService

的实现执行了一些依赖于IO的处理，并且很难单独测试。然后，模拟

IMyService

对于尝试测试该类是有意义的

[Fact]
public void Given_Input_SomeMethodThatUsesMyService_Should_Increase_By_Ten() {
    //Arrange
    var expected = 14;

    var mock = new Mock<IMyService>();

    mock.Setup(x => x.Add(It.IsAny<int>(), It.IsAny<int>())).Returns<int, int>((x, y) => { return x + y; });

    var svc = mock.Object;

    var sut = new SomeClass(svc);

    //Act
    var result = sut.SomeMethodThatUsesMyService(4);

    //Assert
    result.Should().Be(expected);
}

[事实]
公共无效提供了使用服务的某些方法应该增加10（）{
//安排
预期风险价值=14；
var mock=new mock（）；
mock.Setup（x=>x.Add（It.IsAny（），It.IsAny（））.Returns（（x，y）=>{return x+y；}）；
var svc=mock.Object；
var sut=新的SomeClass（svc）；
//表演
var result=sut.somemethodthatsusemyservice（4）；
//断言
result.Should（）.是（预期的）；
}

只有当

IMyService

被用作要测试的另一个类的依赖项时，才会执行类似的操作。如果

IMyService

是正在测试的系统，那么您不会这样做，因为您不会模拟您尝试测试的系统。使用目标类的实际实例

在一个非常简单的例子中，我们有这样一个类

public class SomeClass {
    public SomeClass(IMyService service) {
        this.service = service;
    }
    private readonly IMyService service;

    public int SomeMethodThatUsesMyService(int input) {
        int someConstant = 10;

        var result = service.Add(someConstant, input);
        return result;
    }
}

如果

IMyService

的实现执行了一些依赖于IO的处理，并且很难单独测试。然后，模拟

IMyService

对于尝试测试该类是有意义的

[Fact]
public void Given_Input_SomeMethodThatUsesMyService_Should_Increase_By_Ten() {
    //Arrange
    var expected = 14;

    var mock = new Mock<IMyService>();

    mock.Setup(x => x.Add(It.IsAny<int>(), It.IsAny<int>())).Returns<int, int>((x, y) => { return x + y; });

    var svc = mock.Object;

    var sut = new SomeClass(svc);

    //Act
    var result = sut.SomeMethodThatUsesMyService(4);

    //Assert
    result.Should().Be(expected);
}

[事实]
公共无效提供了使用服务的某些方法应该增加10（）{
//安排
预期风险价值=14；
var mock=new mock（）；
mock.Setup（x=>x.Add（It.IsAny（），It.IsAny（））.Returns（（x，y）=>{return x+y；}）；
var svc=mock.Object；
var sut=新的SomeClass（svc）；
//表演
var result=sut.somemethodthatsusemyservice（4）；
//断言
result.Should（）.是（预期的）；
}

只有当

IMyService

被用作要测试的另一个类的依赖项时，您才会这样做。如果

IMyService

是正在测试的系统，那么您不会这样做，因为您不会模拟您尝试测试的系统。您使用的是目标类的一个实际实例，只有当

IMyService

被用作要测试的另一个类的依赖项时，您才会这样做。如果

IMyService

是正在测试的系统，那么您不会这样做，因为您不会模拟您尝试测试的系统。使用目标类的实际实例