正如投票最多的答案所提到的，Martin Fowler在《Mocks不是存根》中讨论了这些区别，特别是副标题《Mocks和存根之间的区别》，所以一定要阅读那篇文章。

与其关注这些东西有何不同，我认为关注为什么这些是不同的概念更有启发性。每一种都有不同的目的。

假货

fake是一种行为“自然”，但不是“真实”的实现。这些都是模糊的概念，所以不同的人对什么是假的有不同的理解。

一个假的例子是内存中的数据库(例如使用sqlite和:memory: store)。您永远不会在生产中使用它(因为数据不是持久化的)，但是作为一个数据库在测试环境中使用它是完全足够的。它也比“真正的”数据库轻量级得多。

作为另一个例子，也许您在生产中使用某种对象存储(例如Amazon S3)，但是在测试中您可以简单地将对象保存到磁盘上的文件;那么您的“保存到磁盘”实现将是一个假的。(或者您甚至可以通过使用内存文件系统来代替“保存到磁盘”操作。)

作为第三个例子，想象一个提供缓存API的对象;如果一个对象实现了正确的接口，但根本不执行缓存，但总是返回缓存失败，那么这个对象就是一种假的。

pseudo的目的不是为了影响被测系统的行为，而是为了简化测试的实现(通过删除不必要的或重量级的依赖项)。

存根

存根是一种行为“不自然”的实现。它是预先配置的(通常由测试设置)，以响应具有特定输出的特定输入。

存根的目的是让测试中的系统进入特定的状态。例如，如果您正在为一些与REST API交互的代码编写测试，那么您可以使用一个始终返回固定响应的API来stub REST API，或者使用一个响应带有特定错误的API请求。通过这种方式，您可以编写关于系统如何对这些状态做出反应的断言测试;例如，如果API返回404错误，测试用户得到的响应。

存根通常被实现为只响应您告诉它响应的确切交互。但是使某些东西成为存根的关键特性是它的目的:存根是关于设置您的测试用例的。

模拟

mock类似于存根，但是添加了验证。mock的目的是断言被测系统如何与依赖项交互。

例如，如果您正在为一个向网站上传文件的系统编写测试，您可以构建一个接受文件的模拟，并且可以使用它来断言上传的文件是正确的。或者，在较小的范围内，通常使用对象的模拟来验证被测系统是否调用了被模拟对象的特定方法。

模拟与交互测试绑定在一起，这是一种特定的测试方法。那些更喜欢测试系统状态而不是系统交互的人会谨慎地使用模拟。

测试双打

假的、存根的和模拟的都属于测试替身的范畴。测试double是您在测试中使用的任何对象或系统，而不是其他东西。大多数自动化软件测试都涉及到使用某种类型的测试替身。其他类型的测试双重对象包括虚值、间谍和I/O黑洞。

Stub, Fakes和Mocks在不同的来源中有不同的含义。我建议你介绍一下你的团队内部术语，并就其含义达成一致。

我认为区分两种方法很重要: -行为验证(暗示行为替换) -最终状态验证(暗示行为模拟)

考虑发送电子邮件以防出错。当做行为验证时，你检查IEmailSender的Send方法是否执行了一次。并且您需要模拟此方法的返回结果，返回发送消息的Id。所以你说:“我期望Send会被调用。我只会为任何调用返回虚拟(或随机)Id”。这就是行为验证: emailSender.Expect(es=> . send (anyThing)).Return((subject,body) => "dummyId")

在进行状态验证时，您需要创建实现IEmailSender的TestEmailSender。并实现发送方法-通过将输入保存到一些数据结构，将用于未来的状态验证，如一些对象的数组，然后它测试你将检查sentemail包含预期的电子邮件。这是状态验证: 断言。emailSender.SentEmails.Count AreEqual (1)

从我的阅读中，我了解到行为验证通常被称为mock。 状态验证通常被称为存根或假。

为了说明存根和模拟的用法，我还想包括一个基于Roy Osherove的“单元测试的艺术”的例子。

想象一下，我们有一个LogAnalyzer应用程序，它的唯一功能是打印日志。它不仅需要与web服务对话，而且如果web服务抛出错误，LogAnalyzer必须将错误记录到不同的外部依赖项，通过电子邮件发送给web服务管理员。

下面是我们想要在LogAnalyzer中测试的逻辑:

if(fileName.Length<8)
{
 try
  {
    service.LogError("Filename too short:" + fileName);
  }
 catch (Exception e)
  {
    email.SendEmail("a","subject",e.Message);
  }
}

当web服务抛出异常时，如何测试LogAnalyzer正确地调用电子邮件服务? 以下是我们面临的问题:

我们如何替换web服务? 我们如何模拟来自web服务的异常，以便我们可以 测试对电子邮件服务的调用? 我们如何知道电子邮件服务是否被正确调用 所有的吗?

我们可以通过使用web服务的存根来处理前两个问题。为了解决第三个问题，我们可以为电子邮件服务使用一个模拟对象。

A fake is a generic term that can be used to describe either a stub or a mock.In our test, we’ll have two fakes. One will be the email service mock, which we’ll use to verify that the correct parameters were sent to the email service. The other will be a stub that we’ll use to simulate an exception thrown from the web service. It’s a stub because we won’t be using the web service fake to verify the test result, only to make sure the test runs correctly. The email service is a mock because we’ll assert against it that it was called correctly.

[TestFixture]
public class LogAnalyzer2Tests
{
[Test]
 public void Analyze_WebServiceThrows_SendsEmail()
 {
   StubService stubService = new StubService();
   stubService.ToThrow= new Exception("fake exception");
   MockEmailService mockEmail = new MockEmailService();

   LogAnalyzer2 log = new LogAnalyzer2();
   log.Service = stubService
   log.Email=mockEmail;
   string tooShortFileName="abc.ext";
   log.Analyze(tooShortFileName);

   Assert.AreEqual("a",mockEmail.To); //MOCKING USED
   Assert.AreEqual("fake exception",mockEmail.Body); //MOCKING USED
   Assert.AreEqual("subject",mockEmail.Subject);
 }
}

这是一个让测试富有表现力的问题。如果我想让测试描述两个对象之间的关系，我就在Mock上设置期望。我存根返回值，如果我设置一个支持对象，让我在测试中有趣的行为。

单元测试——是一种控制单元(类、方法)的测试方法。

Test double -不是一个主对象(来自OOP世界)。这是一种临时创建的实现，用于测试、检查或在开发期间。它们是为关闭被测试单元(方法、类……)的依赖关系而创建的。

测试双工类型:

伪对象是接口(协议)的真实实现或扩展，它使用继承或其他方法来创建- is依赖。通常，它是由开发人员创建的，作为替代某些依赖项的最简单解决方案 存根对象是一个裸对象(0,nil和没有逻辑的方法)，具有(由开发人员)预定义的额外状态，以定义返回值。通常是由框架创建的

class StubA: A {
    override func foo() -> String {
        return "My Stub"
    }
}

模拟对象与存根对象非常相似，但是额外的状态在程序执行期间被改变，以检查是否发生了什么(方法被调用，参数，时间，频率……)

class MockA: A {
    var isFooCalled = false
    override func foo() -> String {
        isFooCalled = true
        return "My Mock"
    }
}

间谍对象是一个具有“部分嘲讽性”的真实对象。这意味着除了模拟行为外，您使用的是一个非双精度对象 虚拟对象是运行测试所必需的对象，但该对象的任何变量或方法都没有被调用。

Stub vs mock

马丁·福勒说

存根使用状态验证，而mock使用行为验证，这是不同的。

[Mockito mock vs spy]

Stub和fake是对象，因为它们可以根据输入参数改变响应。它们之间的主要区别是Fake比存根更接近真实世界的实现。存根基本上包含对预期请求的硬编码响应。让我们看一个例子:

public class MyUnitTest {

 @Test
 public void testConcatenate() {
  StubDependency stubDependency = new StubDependency();
  int result = stubDependency.toNumber("one", "two");
  assertEquals("onetwo", result);
 }
}

public class StubDependency() {
 public int toNumber(string param) {
  if (param == “one”) {
   return 1;
  }
  if (param == “two”) {
   return 2;
  }
 }
}

A mock is a step up from fakes and stubs. Mocks provide the same functionality as stubs but are more complex. They can have rules defined for them that dictate in what order methods on their API must be called. Most mocks can track how many times a method was called and can react based on that information. Mocks generally know the context of each call and can react differently in different situations. Because of this, mocks require some knowledge of the class they are mocking. a stub generally cannot track how many times a method was called or in what order a sequence of methods was called. A mock looks like:

public class MockADependency {

 private int ShouldCallTwice;
 private boolean ShouldCallAtEnd;
 private boolean ShouldCallFirst;

 public int StringToInteger(String s) {
  if (s == "abc") {
   return 1;
  }
  if (s == "xyz") {
   return 2;
  }
  return 0;
 }

 public void ShouldCallFirst() {
  if ((ShouldCallTwice > 0) || ShouldCallAtEnd)
   throw new AssertionException("ShouldCallFirst not first thod called");
  ShouldCallFirst = true;
 }

 public int ShouldCallTwice(string s) {
  if (!ShouldCallFirst)
   throw new AssertionException("ShouldCallTwice called before ShouldCallFirst");
  if (ShouldCallAtEnd)
   throw new AssertionException("ShouldCallTwice called after ShouldCallAtEnd");
  if (ShouldCallTwice >= 2)
   throw new AssertionException("ShouldCallTwice called more than twice");
  ShouldCallTwice++;
  return StringToInteger(s);
 }

 public void ShouldCallAtEnd() {
  if (!ShouldCallFirst)
   throw new AssertionException("ShouldCallAtEnd called before ShouldCallFirst");
  if (ShouldCallTwice != 2) throw new AssertionException("ShouldCallTwice not called twice");
  ShouldCallAtEnd = true;
 }

}