c# - 模拟测试方法

Question

尝试模拟在另一个方法中调用的方法。

// code part
public virtual bool hello(string name, int age)
{
    string lastName = GetLastName();
}

public virtual string GetLastName() 
{
    return "xxx"; 
}

// unit test part
Mock<Program> p = new Mock<Program>();
p.Setup(x => x.GetLastName()).Returns("qqq");

我希望 GetLastName 方法始终返回“qqq”。

Answer 1

这应该有效，假设这些是完整的方法实现

public class MyProgram
{

    public bool hello(string name, int age)
    {
        string lastName = GetLastName();

        return string.Format("hello {0}", lastName);
    }

    public virtual string GetLastName() 
    {
        return "xxx"; 
    }
}

public class MyProgramTests
{

    [TestMethod]
    public void MyTest()
    {

        string stringToReturn = "qqq";
        Mock<MyProgram> name = new Mock<MyProgram>();
        name.CallBase = true;
        name.Setup(x => x.GetLastName()).Returns(stringToReturn );

        var results = name.Object.hello(It.IsAny<string>(), It.IsAny<int>());

        string expected = string.Format("hello {0}", results);

        Assert.AreEqual(expected, results);
    }
}

我还是不太理解你的评论:

What does the parameter really mean of Mock What should ?? be? excuse me, I don't quite understand the syntax. To clarify, mock means that when I put break points in my code I the breakpoints should skip the methods that I am mocking. Am I right?

Mock<T>允许你模拟 T 的类型- T作为一个通用指标，也意味着几乎所有属于类的东西。在传统中，你会 mock interface ，不是实际的 class ，但在上面的示例中，我们正在模拟一个类。对于发布的示例单元测试，单元测试的目的是测试 hello(string, int) 的实现。 .我们知道 hello(string, int)依赖于该类中的另一个方法 GetLastName() . GetLastName() s 的实现虽然重要，但对单元测试的范围并不重要 hello(string, int) .为此，我们模拟调用及其返回 - 以测试 hello(string, int) 的功能。无需担心其依赖项的实现。

我用实际的类名包围了上面的内容，希望能更明显地表明我们正在模拟类 MyProgram并提供 GetLastName() 的新实现(模拟)

Thanks for the answer. What if I want to test a method that calls another method that calls another method? For eg. what if the method hello called another method?

同样的原则适用，当你构建你的单元测试时(假设它们是单元测试，而不是集成测试或其他，你总是想专注于测试一个 公共(public)方法。What's the difference between unit and integration tests?

public class Foo
{

    public string Bar()
    {
        return string.Format("{0}Bar", Baz(5));;
    }

    public virtual string Baz(int someNumber)
    {
        return string.Format("{0}Baz", DoStuff(someNumber).ToString());
    }

    public virtual int DoStuff(int someNumber)
    {
        return someNumber+1;
    }

}

如果我们进行单元测试 Bar()我们不关心 Baz(int) 的执行情况甚至更糟DoStuff(int) .请注意，我们不关心实现，我们确实关心它们的返回值。来自 Bar()从我们的角度来看，唯一重要的是 Baz(int)返回一个字符串。什么字符串？ Bar()没关系单元测试。

Bar() 的样本测试:

[TestMethod]
public void Bar_ReturnsBazValueWithBarAppended
{
    // Arrange
    string testBazReturn = "test";
    Mock<Foo> mock = new Mock<Foo>();
    mock.CallBase = true;
    mock
        .Setup(s => s.Baz(It.IsAny<int>())
        .Returns(testBazReturn);

    // Act
    var results = mock.Object.Bar();

    // Assert
    Assert.AreEqual(string.Format("{0}{1}", testBazReturn, "Bar"), results);
    mock.Verify(v => v.Baz(It.IsAny<int>())); // Verifies that Baz was called
}

注意上面，我们实际实现了Baz(int) , 和 DoStuff(int)没关系，因为我们忽略了 Baz(int) 的实际执行, 和 DoStuff(int)甚至没有发挥作用。

现在，如果我们要测试 Baz(int)我们只是遵循同样的心态:

[TestMethod]
public void Baz_ReturnsDoStuffValueWithBazAppended
{
    // Arrange
    int testDoStuffReturn = 1;
    Mock<Foo> mock = new Mock<Foo>();
    mock.CallBase = true;
    mock
        .Setup(s => s.DoStuff(It.IsAny<int>())
        .Returns(testDoStuffReturn);

    // Act
    var results = mock.Object.Baz(5);

    // Assert
    Assert.AreEqual(string.Format("{0}{1}", results, "Baz"), results); // Validates the result
    mock.Verify(v => v.DoStuff(It.IsAny<int>())); // Verifies that DoStuff was called
}

在上面，现在我们正在单元测试 Baz(int) , 我们不关心 Bar() ，我们唯一关心的是 DoStuff(int)是它返回一个值(但不是如何它到达该值。)

最后 DoStuff(int) :

[TestMethod]
public void DoStuff_ReturnsParameterPlusOne()
{
    // Arrange
    Foo foo = new Foo();
    int passed = 1;
    int expected = passed + 1;

    // Act
    var results = foo.DoStuff(passed);

    // Assert
    Assert.AreEqual(expected, results);
}