Diferencia entre Mock / Stub / Spy en el marco de prueba de Spock

Atención: Voy a simplificar demasiado y tal vez incluso falsificar ligeramente en los próximos párrafos. Para obtener información más detallada, consulte El sitio web de Martin Fowler .

Un mock es una clase ficticia que reemplaza a una real, devolviendo algo como null o 0 para cada llamada al método. Usted usa un mock si necesita una instancia ficticia de una clase compleja que de otra manera usaría recursos externos como conexiones de red, archivos o bases de datos o tal vez usaría docenas de otros objetos. La ventaja de se burla es que puede aislar la clase bajo prueba del resto del sistema.

Un stub es también una clase ficticia que proporciona algunos resultados más específicos, preparados o pregrabados, reproducidos a ciertas solicitudes bajo prueba. Se podría decir que un trozo es una burla elegante. En Spock a menudo leerá acerca de los métodos de talón.

Un espía es una especie de híbrido entre objeto real y stub, es decir, es básicamente el objeto real con algunos (no todos) métodos sombreados por métodos stub. Los métodos no stubbed son solo enrutado al objeto original. De esta manera puede tener un comportamiento original para métodos "baratos" o triviales y un comportamiento falso para métodos "caros" o complejos.

Actualización 2017-02-06: En realidad la respuesta del usuario mikhail es más específica para Spock que mi respuesta original anterior. Así que dentro del alcance de Spock, lo que él describe es correcto, pero eso no falsifica mi respuesta general:

• Un stub se refiere a la simulación de un comportamiento específico. En Spock esto es todo un trozo puede hacer, por lo que es una especie de la cosa más simple.
• Un mock se ocupa de sustituir un objeto real (posiblemente caro), proporcionando respuestas no-op para todas las llamadas a métodos. En este sentido, un simulacro es más simple que un trozo. Pero en Spock, un simulacro también puede ser resultado del método stub, es decir, ser tanto un simulacro como un stub. Además, en Spock podemos contar con qué frecuencia se han llamado métodos simulados específicos con ciertos parámetros durante una prueba.
• Un espía siempre envuelve un objeto real y el valor predeterminado enruta todas las llamadas a los métodos al objeto original, pasando también por los resultados originales. Método de conteo de llamadas también funciona para los espías. En Spock, un espía también puede modificar el comportamiento del objeto original, manipulando parámetros de llamada al método y / o resultados o bloqueando la llamada a los métodos originales.

Ahora aquí hay una prueba de ejemplo ejecutable, que demuestra lo que es posible y lo que no lo es. Es un poco más instructivo que los fragmentos de Mikhail. Muchas gracias a él por inspirarme a mejorar mi propia respuesta! :-)

package de.scrum_master.stackoverflow

import org.spockframework.mock.TooFewInvocationsError
import org.spockframework.runtime.InvalidSpecException
import spock.lang.FailsWith
import spock.lang.Specification

class MockStubSpyTest extends Specification {

  static class Publisher {
    List<Subscriber> subscribers = new ArrayList<>()

    void addSubscriber(Subscriber subscriber) {
      subscribers.add(subscriber)
    }

    void send(String message) {
      for (Subscriber subscriber : subscribers)
        subscriber.receive(message);
    }
  }

  static interface Subscriber {
    String receive(String message)
  }

  static class MySubscriber implements Subscriber {
    @Override
    String receive(String message) {
      if (message ==~ /[A-Za-z ]+/)
        return "ok"
      return "uh-oh"
    }
  }

  Subscriber realSubscriber1 = new MySubscriber()
  Subscriber realSubscriber2 = new MySubscriber()
  Publisher publisher = new Publisher(subscribers: [realSubscriber1, realSubscriber2])

  def "Real objects can be tested normally"() {
    expect:
    realSubscriber1.receive("Hello subscribers") == "ok"
    realSubscriber1.receive("Anyone there?") == "uh-oh"
  }

  @FailsWith(TooFewInvocationsError)
  def "Real objects cannot have interactions"() {
    when:
    publisher.send("Hello subscribers")
    publisher.send("Anyone there?")

    then:
    2 * realSubscriber1.receive(_)
  }

  def "Stubs can simulate behaviour"() {
    given:
    def stubSubscriber = Stub(Subscriber) {
      receive(_) >>> ["hey", "ho"]
    }

    expect:
    stubSubscriber.receive("Hello subscribers") == "hey"
    stubSubscriber.receive("Anyone there?") == "ho"
    stubSubscriber.receive("What else?") == "ho"
  }

  @FailsWith(InvalidSpecException)
  def "Stubs cannot have interactions"() {
    given: "stubbed subscriber registered with publisher"
    def stubSubscriber = Stub(Subscriber) {
      receive(_) >> "hey"
    }
    publisher.addSubscriber(stubSubscriber)

    when:
    publisher.send("Hello subscribers")
    publisher.send("Anyone there?")

    then:
    2 * stubSubscriber.receive(_)
  }

  def "Mocks can simulate behaviour and have interactions"() {
    given:
    def mockSubscriber = Mock(Subscriber) {
      3 * receive(_) >>> ["hey", "ho"]
    }
    publisher.addSubscriber(mockSubscriber)

    when:
    publisher.send("Hello subscribers")
    publisher.send("Anyone there?")

    then: "check interactions"
    1 * mockSubscriber.receive("Hello subscribers")
    1 * mockSubscriber.receive("Anyone there?")

    and: "check behaviour exactly 3 times"
    mockSubscriber.receive("foo") == "hey"
    mockSubscriber.receive("bar") == "ho"
    mockSubscriber.receive("zot") == "ho"
  }

  def "Spies can have interactions"() {
    given:
    def spySubscriber = Spy(MySubscriber)
    publisher.addSubscriber(spySubscriber)

    when:
    publisher.send("Hello subscribers")
    publisher.send("Anyone there?")

    then: "check interactions"
    1 * spySubscriber.receive("Hello subscribers")
    1 * spySubscriber.receive("Anyone there?")

    and: "check behaviour for real object (a spy is not a mock!)"
    spySubscriber.receive("Hello subscribers") == "ok"
    spySubscriber.receive("Anyone there?") == "uh-oh"
  }

  def "Spies can modify behaviour and have interactions"() {
    given:
    def spyPublisher = Spy(Publisher) {
      send(_) >> { String message -> callRealMethodWithArgs("#" + message) }
    }
    def mockSubscriber = Mock(MySubscriber)
    spyPublisher.addSubscriber(mockSubscriber)

    when:
    spyPublisher.send("Hello subscribers")
    spyPublisher.send("Anyone there?")

    then: "check interactions"
    1 * mockSubscriber.receive("#Hello subscribers")
    1 * mockSubscriber.receive("#Anyone there?")
  }
}