mock既是技术对象，也是功能对象。

这个模拟是技术性的。它确实是由一个模拟库(EasyMock、JMockit和最近的Mockito都以这些库而闻名)创建的，这要归功于字节代码生成。 生成模拟实现的方式是，我们可以在调用方法时将其设置为返回特定值，但也可以执行其他一些事情，例如验证模拟方法是否使用某些特定参数(严格检查)或任何参数(不严格检查)调用。

实例化一个mock:

@Mock Foo fooMock

记录行为:

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

验证调用:

verify(fooMock).hello()

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

但是mock也是功能性的，因为它是我们需要从SUT中隔离出来的类的实例。有了记录在上面的行为，我们就可以在SUT中使用它就像使用存根一样。

存根只是一个函数对象:它是我们需要从SUT中隔离出来的类的实例，仅此而已。 这意味着在单元测试期间需要的存根类和所有行为fixture都必须显式地定义。 例如，存根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; 
  }
}

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

结论

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

关于Martin Fowler文章:当我使用mock和避免存根时，我不认为我是一个“嘲笑主义者”程序员。 但是当真正需要时我使用mock(讨厌的依赖关系)，当我测试带有依赖关系的类时，我喜欢测试切片和迷你集成测试，而mock将是一种开销。

存根是为测试目的而构建的伪对象。mock是记录预期调用是否有效发生的存根。

Stub是实现组件接口的对象，但是Stub可以配置为返回适合测试的值，而不是返回调用时组件将返回的值。使用存根，单元测试可以测试一个单元是否可以处理来自合作者的各种返回值。在单元测试中使用存根而不是真正的合作者可以这样表示:

单元测试——>存根

单元测试——>单元——>存根

单元测试对结果和单元状态进行断言

首先，单元测试创建存根并配置其返回值。然后单元测试创建单元并在其上设置存根。现在，单元测试调用单元，而单元又调用存根。最后，单元测试对单元上的方法调用的结果进行断言。

A Mock is like a stub, only it also has methods that make it possible determine what methods where called on the Mock. Using a mock it is thus possible to both test if the unit can handle various return values correctly, and also if the unit uses the collaborator correctly. For instance, you cannot see by the value returned from a dao object whether the data was read from the database using a Statement or a PreparedStatement. Nor can you see if the connection.close() method was called before returning the value. This is possible with mocks. In other words, mocks makes it possible to test a units complete interaction with a collaborator. Not just the collaborator methods that return values used by the unit. Using a mock in a unit test could be expressed like this:

单元测试——>模拟

单元测试—>单元—>模拟

单元测试对单元的结果和状态进行断言

单元测试断言在mock上调用的方法

>>这里

看了上面所有的解释，让我试着总结一下:

Stub:让测试运行的一段虚拟代码，但您并不关心它会发生什么。替代实际工作代码。 Mock:在测试中验证是否正确调用的一段虚拟代码。替代实际工作代码。 间谍:一段虚拟代码，用于拦截和验证对实际工作代码的某些调用，从而避免替换所有实际代码。

他使用的通用术语是测试替身(想想特技替身)。Test Double是一个通用术语，用于为测试目的替换生产对象的任何情况。杰拉德列出了各种各样的替身:

Dummy objects are passed around but never actually used. Usually they are just used to fill parameter lists. Fake objects actually have working implementations, but usually take some shortcut which makes them not suitable for production (an InMemoryTestDatabase is a good example). Stubs provide canned answers to calls made during the test, usually not responding at all to anything outside what's programmed in for the test. Spies are stubs that also record some information based on how they were called. One form of this might be an email service that records how many messages it was sent(also called Partial Mock). Mocks are pre-programmed with expectations which form a specification of the calls they are expected to receive. They can throw an exception if they receive a call they don't expect and are checked during verification to ensure they got all the calls they were expecting.

源

在我的回答中，我使用了python示例来说明差异。

Stub - Stubbing is a software development technique used to implement methods of classes early in the development life-cycle. They are used commonly as placeholders for implementation of a known interface, where the interface is finalized or known but the implementation is not yet known or finalized. You begin with stubs, which simply means that you only write the definition of a function down and leave the actual code for later. The advantage is that you won't forget methods and you can continue to think about your design while seeing it in code. You can also have your stub return a static response so that the response can be used by other parts of your code immediately. Stub objects provide a valid response, but it's static no matter what input you pass in, you'll always get the same response:

class Foo(object):
    def bar1(self):
        pass

    def bar2(self):
        #or ...
        raise NotImplementedError

    def bar3(self):
        #or return dummy data
        return "Dummy Data"

模拟对象用于模拟测试用例，它们验证在这些对象上调用了某些方法。模拟对象是以可控的方式模拟真实对象行为的模拟对象。您通常创建一个模拟对象来测试其他对象的行为。mock让我们模拟对于单元测试来说不可用或太笨重的资源。

mymodule.py:

import os
import os.path

def rm(filename):
    if os.path.isfile(filename):
        os.remove(filename)

test.py:

from mymodule import rm
import mock
import unittest

class RmTestCase(unittest.TestCase):
    @mock.patch('mymodule.os')
    def test_rm(self, mock_os):
        rm("any path")
        # test that rm called os.remove with the right parameters
        mock_os.remove.assert_called_with("any path")

if __name__ == '__main__':
    unittest.main()

这是一个非常基本的示例，它只运行rm并断言调用它的参数。您可以对对象使用mock，而不仅仅是这里所示的函数，您还可以返回一个值，这样模拟对象就可以用来替换存根进行测试。

更多关于unittest的信息。模拟，注意python 2。X mock不包含在unittest中，但它是一个可下载的模块，可以通过PIP (PIP install mock)下载。

我还读过Roy Osherove写的《单元测试的艺术》，我认为如果有一本类似的书是用Python和Python示例编写的，那就太棒了。如果有人知道这样的书，请分享。欢呼:)