模拟和模拟有什么区别？存根？

Question

我读过各种关于测试中模拟与存根的文章，包括 Martin Fowler 的模拟不是存根 ，但还是不明白其中的区别。

Answer 1

前言 对象

有多种定义，但它们并不真实。通用术语是测试替身。该术语包括：虚拟、假、存根、模拟。

参考

Martin Fowler 的文章：

• 虚拟对象被传递但从未实际使用。通常它们仅用于填充参数列表。
• 假对象实际上具有有效的实现，但通常会采取一些捷径，这使得它们不适合生产（内存数据库就是一个很好的例子）。
• 存根为测试期间拨打的电话提供预设答案，通常不会对测试编程之外的任何内容做出响应。存根还可以记录有关调用的信息，例如记住它“发送”的消息的电子邮件网关存根，或者可能只记录它“发送”的消息数量。
• 模拟就是我们在这里讨论的内容：预先编程的对象，形成了它们预期接收的调用的规范。

样式

Mocks vs Stubs = 行为测试 vs 状态测试

原理

根据每个测试只测试一件事的原则，一个测试中可能有多个 Stub，但一般只有一个 Mock。

生命周期

使用存根测试生命周期：

1. 设置 - 准备正在测试的对象及其存根协作者。
2. 练习 - 测试功能。
3. 验证状态 - 使用断言来检查对象的状态。
4. 拆卸 - 清理资源。

使用模拟测试生命周期：

1. 设置数据 - 准备正在测试的对象。
2. 设置期望 - 在主要对象使用的模拟中准备期望。
3. 练习 - 测试功能。
4. 验证期望 - 验证模拟中是否调用了正确的方法。
5. 验证状态 - 使用断言来检查对象的状态。
6. 拆卸 - 清理资源。

摘要

模拟和存根测试都给出了以下问题的答案：结果是什么？

使用模拟进行测试还感兴趣的是：结果如何已经实现了吗？

Answer 2

存根

我认为最大的区别是你已经用预定的行为编写了存根。因此，您将拥有一个实现您出于测试目的而伪造的依赖项（很可能是抽象类或接口）的类，并且这些方法将被设置的响应删除。他们不会做任何花哨的事情，并且您可能已经在测试之外为其编写了存根代码。

模拟

模拟是作为测试的一部分，您必须根据自己的期望进行设置。模拟不是以预定方式设置的，因此您可以在测试中使用代码来执行此操作。在某种程度上，模拟是在运行时确定的，因为设置期望的代码必须在执行任何操作之前运行。

模拟和存根之间的区别

用模拟编写的测试通常遵循初始化 -> 。设定期望 ->锻炼->验证 模式进行测试。虽然预先编写的存根将遵循initialize ->;锻炼->验证。

模拟和存根之间的相似性

两者的目的都是消除测试类或函数的所有依赖项，以便您的测试更加集中且更简单地尝试证明什么。

Answer 3

存根是一个简单的伪造对象。它只是确保测试顺利进行。
模拟是一个更智能的存根。您验证您的测试通过了。

Answer 4

在 codeschool.com 课程中，Rails Test for Zombies，他们给出了术语的定义：

Stub

用于用返回指定结果的代码替换方法。

嘲笑

带有调用该方法的断言的存根。

因此，正如肖恩·科本哈弗（Sean Copenhaver）在他的回答中所描述的那样，不同之处在于模拟设定了期望（即做出断言，关于它们是否或如何被调用）。

Answer 5

存根不会让你的测试失败，而模拟却可以。

Answer 6

阅读上面的所有解释，让我尝试浓缩一下：

• 存根：一段让测试运行的虚拟代码，但你不关心它会发生什么。替代实际工作代码。
• 模拟：作为测试的一部分，您验证是否正确调用了一段虚拟代码。替代实际工作代码。
• 间谍：一段虚拟代码，用于拦截并验证对真实工作代码的某些调用，从而避免替换所有真实代码。

Answer 7

我认为关于这个问题最简单、更清晰的答案来自于Roy Osherove在他的书单元测试的艺术（第85页）中

判断我们正在处理存根的最简单方法是注意存根永远不会通过测试。测试使用的断言总是反对
被测试的类。

另一方面，测试将使用模拟对象来验证是否
测试失败与否。 [...]

同样，模拟对象是我们用来查看测试是否失败的对象。

Stub 和mock 都是假的。

如果您对伪造品做出断言，则意味着您正在使用伪造品作为模拟，如果您仅使用伪造品来运行测试而不对其进行断言，那么您正在使用伪造品作为存根。

Answer 8

模拟只是测试行为，确保调用某些方法。
存根是特定对象的可测试版本（本身）。

苹果方式是什么意思？

Answer 9

如果将其与调试进行比较：

存根就像确保方法返回正确的值

Mock 就像实际上进入方法并在返回正确的值之前确保内部的所有内容都是正确的。

Answer 10

非常清楚和实用：

存根：实现要伪造的类/对象的方法并始终返回您想要的内容的类或对象。

JavaScript 中的示例：

var Stub = {
   method_a: function(param_a, param_b){
      return 'This is an static result';
   }
}

Mock：与存根相同，但它添加了一些在调用方法时“验证”的逻辑，以便您可以确定某些实现正在调用该方法。

正如 @mLevan 所说，想象一下您正在测试用户注册类的示例。调用 Save 后，应调用 SendConfirmationEmail。

一个非常愚蠢的代码示例：

var Mock = {
   calls: {
      method_a: 0
   }

   method_a: function(param_a, param_b){
     this.method_a++; 
     console.log('Mock.method_a its been called!');
   }
}

Answer 11

这张幻灯片很好地解释了主要差异。

*摘自华盛顿大学 CSE 403 第 16 讲（幻灯片由“Marty Stepp”创建）

Answer 12

使用心理模型确实帮助我理解了这一点，而不是所有没有完全“融入”的解释和文章。

想象一下你的孩子桌子上有一个玻璃盘，他开始玩它。现在，你担心它会破裂。所以，你给他一个塑料盘子。这将是一个模拟（相同的行为，相同的接口，“更软”的实现）。

现在，假设你没有塑料替代品，所以你解释说“如果你继续玩它，它就会破裂！”。这是一个存根，您提前提供了预定义的状态。

Dummy 可能是他甚至没有使用过的叉子......而 Spy 可能是提供与您已经使用过的相同的解释。

Answer 13

让我们看看测试替身：

• Fake：Fake 是具有有效实现的对象，但与生产对象不同。 例如：数据访问对象或存储库的内存中实现。

• 存根：存根是一个保存预定义数据并在测试期间使用它来应答呼叫的对象。 如：需要从数据库抓取一些数据来响应方法调用的对象。

• 模拟：模拟是注册它们收到的调用的对象。
  在测试断言中，我们可以在 Mock 上验证是否执行了所有预期操作。 如：调用电子邮件发送服务的功能。

  有关更多信息，请查看此。

Answer 14

我喜欢 Roy Osherove 在他的演讲理解模拟对象中提出的解释：

创建的每个类或对象都是假的。如果你反对它，它就是一个模拟。否则它是一个存根。

Answer 15

我认为他们之间最重要的区别是他们的意图。

让我尝试用为什么存根与为什么模拟来解释它

假设我正在为我的Mac Twitter客户端的公共时间线控制器编写测试代码

这里是测试示例代码

twitter_api.stub(:public_timeline).and_return(public_timeline_array)
client_ui.should_receive(:insert_timeline_above).with(public_timeline_array)
controller.refresh_public_timeline

• STUB：与 twitter API 的网络连接非常慢，这使我的测试变慢。我知道它会返回时间线，所以我做了一个模拟 HTTP twitter API 的存根，这样我的测试就会运行得非常快，即使我离线也可以运行测试。
• MOCK：我还没有编写任何 UI 方法，并且我不确定需要为我的 ui 对象编写什么方法。我希望通过编写测试代码了解我的控制器如何与我的 ui 对象协作。

通过编写mock，您可以通过验证是否满足期望来发现对象协作关系，而stub仅模拟对象的行为。

如果您想了解有关模拟的更多信息，我建议您阅读这篇文章：http://jmock.org/oopsla2004.pdf

Answer 16

存根

存根是一个对象，用于伪造具有预编程行为的方法。您可能希望使用此方法而不是现有方法，以避免不必要的副作用（例如，存根可能会进行虚假的提取调用，返回预编程的响应，而不实际向服务器发出请求）。

模拟

模拟是一个对象，用于伪造具有预编程行为以及预编程期望的方法。如果这些期望没有得到满足，那么模拟将导致测试失败（例如，模拟可能会进行虚假的获取调用，返回预编程的响应，而不实际向服务器发出预期的请求例如，第一个参数为 "http://localhost:3008/"，否则测试将失败。）

差异

与模拟不同，存根没有可能导致测试失败的预编程期望。

Answer 17

我正在阅读单元测试的艺术，并偶然发现了以下定义：

假是一个通用术语，可用于描述存根或模拟对象（手写或其他方式），因为它们看起来都像真实对象。假货是存根还是模拟取决于它在当前测试中的使用方式。如果它用于检查交互（断言反对），那么它是一个模拟对象。否则，它是一个存根。

Answer 18

• 存根与模拟
  • 存根
    1. 为方法调用提供具体答案
       • 例如：myStubbedService.getValues() 仅返回测试代码所需的字符串
    2. 被测试代码用来隔离它
    3. 测试不能失败
       • 例如：myStubbedService.getValues() 仅返回存根值
    4. 经常实现抽象方法
  • 模拟
    1. 存根的“超集”；可以断言某些方法被调用
       • 例如：验证 myMockedService.getValues() 仅被调用一次
    2. 用于测试被测代码的行为
    3. 可能会失败测试
       • 例如：验证 myMockedService.getValues() 是否被调用过一次；验证失败，因为我的测试代码未调用 myMockedService.getValues()
    4. 经常模拟接口

Answer 19

模拟：帮助模拟和检查结果交互。这些相互作用
SUT 对其依赖项进行调用以更改其状态。

存根：帮助模拟传入的交互。这些相互作用被称为
SUT 通过其依赖关系来获取输入数据。

来源：单元测试原则、实践和模式 - Manning

Answer 20

他使用的通用术语是测试替身（想想特技替身）。测试替身是一个通用术语，适用于出于测试目的而替换生产对象的任何情况。 Gerard 列出了各种类型的 double：

• Dummy 对象被传递但从未实际使用。通常它们仅用于填充参数列表。
• Fake 对象实际上具有有效的实现，但通常会采取一些捷径，这使得它们不适合生产（InMemoryTestDatabase 就是一个很好的例子）。
• 存根为测试期间拨打的电话提供预设答案，通常根本不响应测试编程之外的任何内容。
• 间谍是存根，还根据它们的调用方式记录一些信息。其中一种形式可能是记录发送的消息数量的电子邮件服务（也称为部分模拟）。
• 模拟是根据期望进行预编程的，这些期望形成了它们预期接收的调用的规范。如果他们收到不期望的呼叫，他们可以抛出异常，并在验证过程中进行检查，以确保他们收到了他们期望的所有呼叫。

来源

Answer 21

存根

存根是一个保存预定义数据并在测试期间使用它来应答调用的对象。当您不能或不想涉及会用真实数据回答或具有不良副作用的对象时，可以使用它。

一个示例可以是需要从数据库获取一些数据以响应方法调用的对象。我们引入了一个存根并定义了应该返回哪些数据，而不是真正的对象。

存根示例：

public class GradesService {

   private final Gradebook gradebook;

   public GradesService(Gradebook gradebook) {
       this.gradebook = gradebook;
   }

   Double averageGrades(Student student) {
       return average(gradebook.gradesFor(student));
   }
}

您无需从成绩册商店调用数据库来获取真实的学生成绩，而是预先配置存根并将返回成绩。您定义了足够的数据来测试平均计算算法。

public class GradesServiceTest {

   private Student student;
   private Gradebook gradebook;

   @Before
   public void setUp() throws Exception {
       gradebook = mock(Gradebook.class);
       student = new Student();
   }

   @Test
   public void calculates_grades_average_for_student() {
       //stubbing gradebook
       when(gradebook.gradesFor(student)).thenReturn(grades(8, 6, 10)); 

       double averageGrades = new GradesService(gradebook).averageGrades(student);

       assertThat(averageGrades).isEqualTo(8.0);
   }
}

Mock

模拟是注册它们收到的调用的对象。在测试断言中，您可以在模拟上验证是​​否执行了所有预期操作。当您不想调用生产代码或者没有简单的方法来验证预期代码是否已执行时，您可以使用模拟。没有返回值，也没有简单的方法来检查系统状态更改。一个示例可以是调用电子邮件发送服务的功能。

您不希望每次运行测试时都发送电子邮件。此外，在测试中验证是否发送了正确的电子邮件并不容易。您唯一能做的就是验证我们测试中所执行的功能的输出。在其他世界中，验证是否调用了电子邮件发送服务。

模拟示例：

public class SecurityCentral {

   private final Window window;
   private final Door door;

   public SecurityCentral(Window window, Door door) {
       this.window = window;
       this.door = door;
   }

   void securityOn() {
       window.close();
       door.close();
   }
}

您不想关闭真实的门来测试安全方法是否有效，对吗？相反，您将门和窗模拟对象放置在测试代码中。

public class SecurityCentralTest {

   Window windowMock = mock(Window.class);
   Door doorMock = mock(Door.class);

   @Test
   public void enabling_security_locks_windows_and_doors() {
       SecurityCentral securityCentral = new SecurityCentral(windowMock, doorMock);

       securityCentral.securityOn();

       verify(doorMock).close();
       verify(windowMock).close();
   }
}

非常感谢 Michał Lipski 的好文章。进一步阅读：

测试替身 – Martin Fowler https://martinfowler.com/bliki/TestDouble.html
测试替身 – xUnit 模式 http://xunitpatterns.com/Test%20Double.html
模拟不是存根 – Martin Fowler https://martinfowler.com/articles/mocksArentStubs.html
命令查询分离 – Martin Fowler https://martinfowler.com/bliki/CommandQuerySeparation.html

Answer 22

假货是一个通用术语，可用于描述存根
或模拟对象（手写或其他方式），因为它们看起来都像
真实的物体。

假货是存根还是模拟取决于它的使用方式
当前的测试。如果它用于检查交互（断言反对），那么它是
模拟对象。否则，它就是一个存根。

Fakes 确保测试顺利进行。这意味着未来测试的读者将了解伪造对象的行为，而无需阅读其源代码（无需依赖外部资源）。

试运行顺利是什么意思？
例如在下面的代码中：

 public void Analyze(string filename)
        {
            if(filename.Length<8)
            {
                try
                {
                    errorService.LogError("long file entered named:" + filename);
                }
                catch (Exception e)
                {
                    mailService.SendEMail("[email protected]", "ErrorOnWebService", "someerror");
                }
            }
        }

您想要测试 mailService.SendEMail() 方法，为此您需要在测试方法中模拟异常，因此您只需要创建一个 Fake Stub errorService 类来模拟该结果，那么您的测试代码将能够测试 mailService.SendEMail() 方法。如您所见，您需要模拟来自另一个外部依赖项 ErrorService 类的结果。

Answer 23

来自 jMock 开发人员的论文模拟角色，而不是对象：

存根是返回固定代码的生产代码的虚拟实现
结果。模拟对象充当存根，但也包括断言
检测目标对象与其邻居的交互。

因此，主要区别在于：

• 对存根设置的期望通常是通用的，而对模拟设置的期望可能更“聪明”（例如，在第一次调用时返回 this，在第二次调用时返回 this 等）。
• 存根主要用于设置SUT的间接输入，而模拟可用于测试间接输入和间接 SUT 的输出。

总而言之，同时也试图消除 Fowler 的文章标题中的混乱：模拟是存根，但它们不仅仅是存根。

Answer 24

我看到了 UncleBob The Little Mocker 写的这篇有趣的文章。它以非常容易理解的方式解释了所有术语，因此对初学者很有用。马丁·福勒斯的文章很难读，特别是对于像我这样的初学者来说。

Answer 25

那里有很多有效的答案，但我认为值得一提鲍勃叔叔的这个表格：
https://8thlight.com/blog/uncle-bob/2014 /05/14/TheLittleMocker.html

有史以来最好的解释与示例！

Answer 26

模拟既是一个技术对象，又是一个功能对象。

模拟是技术性的。由于字节代码生成，它确实是由模拟库创建的（EasyMock、JMockit 和最近的 Mockito 因这些而闻名）。
模拟实现是生成的，我们可以检测它在调用方法时返回特定值，但也可以进行其他一些操作，例如验证模拟方法是否是使用某些特定参数（严格检查）或任何参数（无严格检查）调用。

实例化模拟：

@Mock Foo fooMock

记录行为：

when(fooMock.hello()).thenReturn("hello you!");

验证调用：

verify(fooMock).hello()

这些显然不是实例化/覆盖 Foo 类/行为的自然方式。这就是为什么我提到技术方面。

但是模拟也具有功能性，因为它是我们需要与 SUT 隔离的类的实例。通过记录其行为，我们可以在 SUT 中使用它，就像使用存根一样。

---

存根只是一个功能对象：它是我们需要与 SUT 隔离的类的实例，仅此而已。
这意味着我们的单元测试期间所需的存根类和所有行为固定装置都必须明确定义。
例如，要存根 hello() 需要子类化 Foo 类（或实现其接口）并重写 hello() ：

public class HelloStub extends Hello{    
  public String hello { 
      return "hello you!"; 
  }
}

如果另一个测试场景需要另一个值返回，我们可能需要定义一个通用方法来设置返回：

public class HelloStub extends Hello{    
  public HelloStub(String helloReturn){
       this.helloReturn = helloReturn;
  }
  public String hello { 
      return helloReturn; 
  }
}

其他场景：如果我有一个副作用方法（无返回）并且我会检查该方法是否被调用，我应该可能在存根类中添加了一个布尔值或计数器来计算该方法被调用的次数。

---

结论

存根通常需要大量开销/代码来为单元测试编写。由于提供了开箱即用的记录/验证功能，模拟可以防止什么。
这就是为什么现在随着优秀的模拟库的出现，存根方法在实践中很少使用。

---

关于 Martin Fowler 的文章：当我使用模拟并且避免存根时，我不认为自己是一个“模拟主义者”程序员。
但当真正需要时我会使用模拟（烦人的依赖项），并且当我测试具有依赖项的类时，我喜欢测试切片和小型集成测试，而模拟将是一种开销。

Answer 27

Stubs 和 Mocks 都会覆盖外部依赖，但区别在于

Stubs -> 测试数据

模拟 -> 测试行为

引用 Fowler 的模拟不是存根 文章：

• 存根为测试期间拨打的电话提供预设答案，通常不会对测试编程之外的任何内容做出响应。
• 模拟就是我们在这里讨论的内容：预先编程的对象，形成了它们预期接收的调用的规范。

这显然说明了区别。

---

假/虚拟 -> 不测试（只需使用空方法覆盖功能，例如替换Logger以避免测试时出现任何日志记录噪音）

Answer 28

加上有用的答案，使用 Mocks 比 Subs 的最强大的点之一

如果协作者[主代码依赖于它]不在我们的控制之下（例如来自第三方库），
在这种情况下，存根比模拟更难编写。

Answer 29

存根帮助我们运行测试。如何？它提供有助于运行测试的值。这些值本身并不真实，我们创建这些值只是为了运行测试。例如，我们创建一个 HashMap 来为我们提供与数据库表中的值类似的值。因此，我们不是直接与数据库交互，而是与 Hashmap 交互。

Mock 是一个运行测试的假对象。我们把断言放在哪里。

Answer 30

请参阅下面使用 C# 和 Moq 框架的模拟与存根的示例。 Moq 没有 Stub 的特殊关键字，但您也可以使用 Mock 对象来创建存根。

namespace UnitTestProject2
{
    using Microsoft.VisualStudio.TestTools.UnitTesting;
    using Moq;
    [TestClass]
    public class UnitTest1
    {
        /// <summary>
        /// Test using Mock to Verify that GetNameWithPrefix method calls Repository GetName method "once" when Id is greater than Zero
        /// </summary>
        [TestMethod]
        public void GetNameWithPrefix_IdIsTwelve_GetNameCalledOnce()
        {
            // Arrange 
            var mockEntityRepository = new Mock<IEntityRepository>();
            mockEntityRepository.Setup(m => m.GetName(It.IsAny<int>()));

            var entity = new EntityClass(mockEntityRepository.Object);
            // Act 
            var name = entity.GetNameWithPrefix(12);
            // Assert
            mockEntityRepository.Verify(m => m.GetName(It.IsAny<int>()), Times.Once);
        }
        /// <summary>
        /// Test using Mock to Verify that GetNameWithPrefix method doesn't call Repository GetName method when Id is Zero
        /// </summary>
        [TestMethod]
        public void GetNameWithPrefix_IdIsZero_GetNameNeverCalled()
        {
            // Arrange 
            var mockEntityRepository = new Mock<IEntityRepository>();
            mockEntityRepository.Setup(m => m.GetName(It.IsAny<int>()));
            var entity = new EntityClass(mockEntityRepository.Object);
            // Act 
            var name = entity.GetNameWithPrefix(0);
            // Assert
            mockEntityRepository.Verify(m => m.GetName(It.IsAny<int>()), Times.Never);
        }
        /// <summary>
        /// Test using Stub to Verify that GetNameWithPrefix method returns Name with a Prefix
        /// </summary>
        [TestMethod]
        public void GetNameWithPrefix_IdIsTwelve_ReturnsNameWithPrefix()
        {
            // Arrange 
            var stubEntityRepository = new Mock<IEntityRepository>();
            stubEntityRepository.Setup(m => m.GetName(It.IsAny<int>()))
                .Returns("Stub");
            const string EXPECTED_NAME_WITH_PREFIX = "Mr. Stub";
            var entity = new EntityClass(stubEntityRepository.Object);
            // Act 
            var name = entity.GetNameWithPrefix(12);
            // Assert
            Assert.AreEqual(EXPECTED_NAME_WITH_PREFIX, name);
        }
    }
    public class EntityClass
    {
        private IEntityRepository _entityRepository;
        public EntityClass(IEntityRepository entityRepository)
        {
            this._entityRepository = entityRepository;
        }
        public string Name { get; set; }
        public string GetNameWithPrefix(int id)
        {
            string name = string.Empty;
            if (id > 0)
            {
                name = this._entityRepository.GetName(id);
            }
            return "Mr. " + name;
        }
    }
    public interface IEntityRepository
    {
        string GetName(int id);
    }
    public class EntityRepository:IEntityRepository
    {
        public string GetName(int id)
        {
            // Code to connect to DB and get name based on Id
            return "NameFromDb";
        }
    }
}