Package spock.mock

Class MockingApi

java.lang.Object
org.spockframework.lang.SpecInternals
spock.mock.MockingApi
All Implemented Interfaces:
MockFactory
Direct Known Subclasses:
Specification
public class MockingApi extends org.spockframework.lang.SpecInternals implements MockFactory
Spock's mocking API primarily consists of the following factory methods:
Mock()
Creates a general-purpose test double that supports both stubbing and mocking.
Stub()
Creates a test double that supports stubbing but not mocking.
Spy()
Creates a test double that, by default, delegates all calls to a real object. Supports both stubbing and mocking.
GroovyMock()
Creates a Mock() with additional, Groovy-specific features.
GroovyStub()
Creates a Stub() with additional, Groovy-specific features.
GroovySpy()
Creates a Spy() with additional, Groovy-specific features.
SpyStatic()
Mocks static methods of the given type that, by default, delegates all calls to the real static methods. Supports both stubbing and mocking.
Each factory method accepts up to three parameters, each of which is optional (resulting in eight method overloads):
type
The interface or class type of the mock. If not present and the mock is created as part of a variable assignment, the type is inferred from the variable's type (if possible).
options
Additional options for creating the mock. Typically passed as named arguments. See IMockConfiguration for available options.
block
A code block that allows to specify interactions right when creating the mock.
Some examples: 
 def mock = Mock(Person)
 Person mock = Mock()

 def spy = Spy(Person, constructorArgs: ["Fred"])

 Person stub = Stub {
   getName() >> "Fred"
   sing() >> "Tra-la-la"
 }

  • Constructor Summary

    Constructors
    Constructor
    Description
    MockingApi()
     

  • Method Summary

    Modifier and Type
    Method
    Description
    <T> T
    GroovyMock()
    Creates a Groovy mock whose type and name are inferred from the left-hand side of the enclosing variable assignment.
    <T> T
    GroovyMock(Closure interactions)
    Creates a Groovy mock with the specified interactions whose type and name are inferred from the left-hand side of the enclosing assignment.
    <T> T
    GroovyMock(Class<T> type)
    Creates a Groovy mock with the specified type.
    <T> T
    GroovyMock(Class<T> type, Closure interactions)
    Creates a Groovy mock with the specified type and interactions.
    <T> T
    GroovyMock(Map<String,Object> options)
    Creates a Groovy mock with the specified options whose type and name are inferred from the left-hand side of the enclosing variable assignment.
    <T> T
    GroovyMock(Map<String,Object> options, Closure interactions)
    Creates a Groovy mock with the specified options and interactions whose type and name are inferred from the left-hand side of the enclosing assignment.
    <T> T
    GroovyMock(Map<String,Object> options, Class<T> type)
    Creates a Groovy mock with the specified options and type.
    <T> T
    GroovyMock(Map<String,Object> options, Class<T> type, Closure interactions)
    Creates a Groovy mock with the specified options, type, and interactions.
    <T> T
    GroovySpy()
    Creates a Groovy spy whose type and name are inferred from the left-hand side of the enclosing variable assignment.
    <T> T
    GroovySpy(Closure interactions)
    Creates a Groovy spy with the specified interactions whose type and name are inferred from the left-hand side of the enclosing assignment.
    <T> T
    GroovySpy(Class<T> type)
    Creates a Groovy spy with the specified type.
    <T> T
    GroovySpy(Class<T> type, Closure interactions)
    Creates a Groovy spy with the specified type and interactions.
    <T> T
    GroovySpy(Map<String,Object> options)
    Creates a Groovy spy with the specified options whose type and name are inferred from the left-hand side of the enclosing variable assignment.
    <T> T
    GroovySpy(Map<String,Object> options, Closure interactions)
    Creates a Groovy spy with the specified options and interactions whose type and name are inferred from the left-hand side of the enclosing assignment.
    <T> T
    GroovySpy(Map<String,Object> options, Class<T> type)
    Creates a Groovy spy with the specified options and type.
    <T> T
    GroovySpy(Map<String,Object> options, Class<T> type, Closure interactions)
    Creates a Groovy spy with the specified options, type, and interactions.
    <T> T
    GroovySpy(T obj)
    Creates a Groovy spy wrapping a provided instance.
    <T> T
    GroovySpy(T obj, Closure interactions)
    Creates a Groovy spy with the specified interactions wrapping a provided instance.
    <T> T
    GroovyStub()
    Creates a Groovy stub whose type and name are inferred from the left-hand side of the enclosing variable assignment.
    <T> T
    GroovyStub(Closure interactions)
    Creates a Groovy stub with the specified interactions whose type and name are inferred from the left-hand side of the enclosing assignment.
    <T> T
    GroovyStub(Class<T> type)
    Creates a Groovy stub with the specified type.
    <T> T
    GroovyStub(Class<T> type, Closure interactions)
    Creates a Groovy stub with the specified type and interactions.
    <T> T
    GroovyStub(Map<String,Object> options)
    Creates a Groovy stub with the specified options whose type and name are inferred from the left-hand side of the enclosing variable assignment.
    <T> T
    GroovyStub(Map<String,Object> options, Closure interactions)
    Creates a Groovy stub with the specified options and interactions whose type and name are inferred from the left-hand side of the enclosing assignment.
    <T> T
    GroovyStub(Map<String,Object> options, Class<T> type)
    Creates a Groovy stub with the specified options and type.
    <T> T
    GroovyStub(Map<String,Object> options, Class<T> type, Closure interactions)
    Creates a Groovy stub with the specified options, type, and interactions.
    void
    interaction(Closure block)
    Encloses one or more interaction definitions in a then block.
    <T> T
    Mock()
    Creates a mock whose type and name are inferred from the left-hand side of the enclosing variable assignment.
    <T> T
    Mock(Closure interactions)
    Creates a mock with the specified interactions whose type and name are inferred from the left-hand side of the enclosing assignment.
    <T> T
    Mock(Class<T> type)
    Creates a mock with the specified type.
    <T> T
    Mock(Class<T> type, Closure interactions)
    Creates a mock with the specified type and interactions.
    <T> T
    Mock(Map<String,Object> options)
    Creates a mock with the specified options whose type and name are inferred from the left-hand side of the enclosing variable assignment.
    <T> T
    Mock(Map<String,Object> options, Closure interactions)
    Creates a mock with the specified options and interactions whose type and name are inferred from the left-hand side of the enclosing assignment.
    <T> T
    Mock(Map<String,Object> options, Class<T> type)
    Creates a mock with the specified options and type.
    <T> T
    Mock(Map<String,Object> options, Class<T> type, Closure interactions)
    Creates a mock with the specified options, type, and interactions.
    void
    runWithThreadAwareMocks(Runnable code)
    Runs the code with the thread-aware mocks activated on the current Thread.
    <T> T
    Spy()
    Creates a spy whose type and name are inferred from the left-hand side of the enclosing variable assignment.
    <T> T
    Spy(Closure interactions)
    Creates a spy with the specified interactions whose type and name are inferred from the left-hand side of the enclosing assignment.
    <T> T
    Spy(Class<T> type)
    Creates a spy with the specified type.
    <T> T
    Spy(Class<T> type, Closure interactions)
    Creates a spy with the specified type and interactions.
    <T> T
    Spy(Map<String,Object> options)
    Creates a spy with the specified options whose type and name are inferred from the left-hand side of the enclosing variable assignment.
    <T> T
    Spy(Map<String,Object> options, Closure interactions)
    Creates a spy with the specified options and interactions whose type and name are inferred from the left-hand side of the enclosing assignment.
    <T> T
    Spy(Map<String,Object> options, Class<T> type)
    Creates a spy with the specified options and type.
    <T> T
    Spy(Map<String,Object> options, Class<T> type, Closure interactions)
    Creates a spy with the specified options, type, and interactions.
    <T> T
    Spy(T obj)
    Creates a spy wrapping a provided instance.
    <T> T
    Spy(T obj, Closure interactions)
    Creates a spy with the specified interactions wrapping a provided instance.
    <T> void
    SpyStatic(Class<T> type)
    Creates a thread-local spy for all static methods of the passed type.
    <T> void
    SpyStatic(Class<T> type, IMockMakerSettings mockMakerSettings)
    Creates a thread-local spy for all static methods of the passed type.
    <T> T
    Stub()
    Creates a stub whose type and name are inferred from the left-hand side of the enclosing variable assignment.
    <T> T
    Stub(Closure interactions)
    Creates a stub with the specified interactions whose type and name are inferred from the left-hand side of the enclosing assignment.
    <T> T
    Stub(Class<T> type)
    Creates a stub with the specified type.
    <T> T
    Stub(Class<T> type, Closure interactions)
    Creates a stub with the specified type and interactions.
    <T> T
    Stub(Map<String,Object> options)
    Creates a stub with the specified options whose type and name are inferred from the left-hand side of the enclosing variable assignment.
    <T> T
    Stub(Map<String,Object> options, Closure interactions)
    Creates a stub with the specified options and interactions whose type and name are inferred from the left-hand side of the enclosing assignment.
    <T> T
    Stub(Map<String,Object> options, Class<T> type)
    Creates a stub with the specified options and type.
    <T> T
    Stub(Map<String,Object> options, Class<T> type, Closure interactions)
    Creates a stub with the specified options, type, and interactions.
    <R> R
    withActiveThreadAwareMocks(Callable<R> code)
    Runs the code with the thread-aware mocks activated on the current Thread.

    Methods inherited from class org.spockframework.lang.SpecInternals

    createMock, createMock, getSpecificationContext

    Methods inherited from class java.lang.Object

    clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

  • Constructor Details

    • MockingApi

      public MockingApi()

  • Method Details

    • interaction

      public void interaction(Closure block)
      Encloses one or more interaction definitions in a then block. Required when an interaction definition uses a statement that doesn't match one of the following patterns, and therefore isn't automatically recognized as belonging to an interaction definition:
      • num * target.method(args)
      • target.method(args) >>(>) result(s)
      • num * target.method(args) >>(>) result(s)

      Regular interaction definition: 

       def "published messages are received at least once"() {
   when:
   publisher.send(msg)

   then:
   (1.._) * subscriber.receive(msg)
 }

      Equivalent definition that uses a helper variable: 

       def "published messages are received at least once"() {
   when:
   publisher.send(msg)

   then:
   interaction {
     def num = (1.._)
     num * subscriber.receive(msg)
   }
 }

      Equivalent definition that uses a helper method: 

       def "published messages are received at least once"() {
   when:
   publisher.send(msg)

   then:
   interaction {
     messageReceived(msg)
   }
 }

 def messageReceived(msg) {
   (1.._) * subscriber.receive(msg)
 }
      Parameters:
      block - a block of code containing one or more interaction definitions

    • Mock

      public <T> T Mock()
      Creates a mock whose type and name are inferred from the left-hand side of the enclosing variable assignment. Example: 
         Person person = Mock() // type is Person.class, name is "person"
      Returns:
      a mock whose type and name are inferred from the left-hand side of the enclosing variable assignment

    • Mock

      @Beta public <T> T Mock(Map<String,Object> options)
      Creates a mock with the specified options whose type and name are inferred from the left-hand side of the enclosing variable assignment. Example: 
         Person person = Mock(name: "myPerson") // type is Person.class, name is "myPerson"
      Parameters:
      options - optional options for creating the mock
      Returns:
      a mock with the specified options whose type and name are inferred from the left-hand side of the enclosing variable assignment

    • Mock

      public <T> T Mock(Class<T> type)
      Creates a mock with the specified type. If enclosed in a variable assignment, the variable name will be used as the mock's name. Example: 
         def person = Mock(Person) // type is Person.class, name is "person"
      Specified by:
      Mock in interface MockFactory
      Type Parameters:
      T - the interface or class type of the mock
      Parameters:
      type - the interface or class type of the mock
      Returns:
      a mock with the specified type

    • Mock

      @Beta public <T> T Mock(Map<String,Object> options, Class<T> type)
      Creates a mock with the specified options and type. If enclosed in an variable assignment, the variable name will be used as the mock's name. Example: 
         def person = Mock(Person, name: "myPerson") // type is Person.class, name is "myPerson"
      Specified by:
      Mock in interface MockFactory
      Type Parameters:
      T - the interface or class type of the mock
      Parameters:
      options - optional options for creating the mock
      type - the interface or class type of the mock
      Returns:
      a mock with the specified options and type

    • Mock

      @Beta public <T> T Mock(Closure interactions)
      Creates a mock with the specified interactions whose type and name are inferred from the left-hand side of the enclosing assignment. Example: 
         // type is Person.class, name is "person", returns hard-coded value for name, expects one call to sing()
   Person person = Mock {
     name >> "Fred"
     1 * sing()
   }
      Parameters:
      interactions - a description of the mock's interactions
      Returns:
      a mock with the specified interactions whose type and name are inferred from the left-hand side of the enclosing assignment

    • Mock

      @Beta public <T> T Mock(Map<String,Object> options, Closure interactions)
      Creates a mock with the specified options and interactions whose type and name are inferred from the left-hand side of the enclosing assignment. Example: 
         // type is Person.class, name is "myPerson", returns hard-coded value for name, expects one call to sing()
   Person person = Mock(name: "myPerson") {
     name >> "Fred"
     1 * sing()
   }
      Parameters:
      options - optional options for creating the mock
      interactions - a description of the mock's interactions
      Returns:
      a mock with the specified options and interactions whose type and name are inferred from the left-hand side of the enclosing assignment

    • Mock

      @Beta public <T> T Mock(Class<T> type, @DelegatesTo(strategy=1,genericTypeIndex=0) Closure interactions)
      Creates a mock with the specified type and interactions. If enclosed in a variable assignment, the variable name will be used as the mock's name. Example: 
         // name is "person", type is Person.class, returns hard-code value name, expects one call to sing()
   def person = Mock(Person) {
     name >> "Fred"
     1 * sing()
   }
      Type Parameters:
      T - the interface or class type of the mock
      Parameters:
      type - the interface or class type of the mock
      interactions - a description of the mock's interactions
      Returns:
      a mock with the specified type and interactions

    • Mock

      @Beta public <T> T Mock(Map<String,Object> options, Class<T> type, @DelegatesTo(strategy=1,genericTypeIndex=0) Closure interactions)
      Creates a mock with the specified options, type, and interactions. If enclosed in a variable assignment, the variable name will be used as the mock's name. Example: 
         // type is Person.class, name is "myPerson", returns hard-coded value name, expects one call to sing()
   def person = Mock(Person, name: "myPerson") {
     name >> "Fred"
     1 * sing()
   }
      Type Parameters:
      T - the interface or class type of the mock
      Parameters:
      options - options for creating the mock (see IMockConfiguration for available options})
      type - the interface or class type of the mock
      interactions - a description of the mock's interactions
      Returns:
      a mock with the specified options, type, and interactions

    • Stub

      @Beta public <T> T Stub()
      Creates a stub whose type and name are inferred from the left-hand side of the enclosing variable assignment. Example: 
         Person person = Stub() // type is Person.class, name is "person"
      Returns:
      a stub whose type and name are inferred from the left-hand side of the enclosing variable assignment

    • Stub

      @Beta public <T> T Stub(Map<String,Object> options)
      Creates a stub with the specified options whose type and name are inferred from the left-hand side of the enclosing variable assignment. Example: 
         Person person = Stub(name: "myPerson") // type is Person.class, name is "myPerson"
      Parameters:
      options - optional options for creating the stub
      Returns:
      a stub with the specified options whose type and name are inferred from the left-hand side of the enclosing variable assignment

    • Stub

      @Beta public <T> T Stub(Class<T> type)
      Creates a stub with the specified type. If enclosed in a variable assignment, the variable name will be used as the stub's name. Example: 
         def person = Stub(Person) // type is Person.class, name is "person"
      Specified by:
      Stub in interface MockFactory
      Type Parameters:
      T - the interface or class type of the stub
      Parameters:
      type - the interface or class type of the stub
      Returns:
      a stub with the specified type

    • Stub

      @Beta public <T> T Stub(Map<String,Object> options, Class<T> type)
      Creates a stub with the specified options and type. If enclosed in an variable assignment, the variable name will be used as the stub's name. Example: 
         def person = Stub(Person, name: "myPerson") // type is Person.class, name is "myPerson"
      Specified by:
      Stub in interface MockFactory
      Type Parameters:
      T - the interface or class type of the stub
      Parameters:
      options - optional options for creating the stub
      type - the interface or class type of the stub
      Returns:
      a stub with the specified options and type

    • Stub

      @Beta public <T> T Stub(Closure interactions)
      Creates a stub with the specified interactions whose type and name are inferred from the left-hand side of the enclosing assignment. Example: 
         // type is Person.class, name is "person", returns hard-coded values for property name and method sing()
   Person person = Stub {
     name >> "Fred"
     sing() >> "Tra-la-la"
   }
      Parameters:
      interactions - a description of the stub's interactions
      Returns:
      a stub with the specified interactions whose type and name are inferred from the left-hand side of the enclosing assignment

    • Stub

      @Beta public <T> T Stub(Map<String,Object> options, Closure interactions)
      Creates a stub with the specified options and interactions whose type and name are inferred from the left-hand side of the enclosing assignment. Example: 
         // type is Person.class, name is "myPerson", returns hard-coded values for property name and method sing()
   Person person = Stub(name: "myPerson") {
     name >> "Fred"
     sing() >> "Tra-la-la"
   }
      Parameters:
      options - optional options for creating the stub
      interactions - a description of the stub's interactions
      Returns:
      a stub with the specified options and interactions whose type and name are inferred from the left-hand side of the enclosing assignment

    • Stub

      @Beta public <T> T Stub(Class<T> type, @DelegatesTo(strategy=1,genericTypeIndex=0) Closure interactions)
      Creates a stub with the specified type and interactions. If enclosed in a variable assignment, the variable name will be used as the stub's name. Example: 
         // name is "person", type is Person.class, returns hard-coded values for property name and method sing()
   def person = Stub(Person) {
     name >> "Fred"
     sing() >> "Tra-la-la"
   }
      Type Parameters:
      T - the interface or class type of the stub
      Parameters:
      type - the interface or class type of the stub
      interactions - a description of the stub's interactions
      Returns:
      a stub with the specified type and interactions

    • Stub

      @Beta public <T> T Stub(Map<String,Object> options, Class<T> type, @DelegatesTo(strategy=1,genericTypeIndex=0) Closure interactions)
      Creates a stub with the specified options, type, and interactions. If enclosed in a variable assignment, the variable name will be used as the stub's name. Example: 
         // type is Person.class, name is "myPerson", returns hard-coded values for property name and method sing()
   def person = Stub(Person, name: "myPerson") {
     name >> "Fred"
     sing() >> "Tra-la-la"
   }
      Type Parameters:
      T - the interface or class type of the stub
      Parameters:
      options - options for creating the stub (see IMockConfiguration for available options})
      type - the interface or class type of the stub
      interactions - a description of the stub's interactions
      Returns:
      a stub with the specified options, type, and interactions

    • Spy

      @Beta public <T> T Spy()
      Creates a spy whose type and name are inferred from the left-hand side of the enclosing variable assignment. Example: 
         Person person = Spy() // type is Person.class, name is "person"
      Returns:
      a spy whose type and name are inferred from the left-hand side of the enclosing variable assignment

    • Spy

      @Beta public <T> T Spy(Map<String,Object> options)
      Creates a spy with the specified options whose type and name are inferred from the left-hand side of the enclosing variable assignment. Example: 
         Person person = Spy(name: "myPerson") // type is Person.class, name is "myPerson"
      Parameters:
      options - optional options for creating the spy
      Returns:
      a spy with the specified options whose type and name are inferred from the left-hand side of the enclosing variable assignment

    • Spy

      @Beta public <T> T Spy(Class<T> type)
      Creates a spy with the specified type. If enclosed in a variable assignment, the variable name will be used as the spy's name. Example: 
         def person = Spy(Person) // type is Person.class, name is "person"
      Specified by:
      Spy in interface MockFactory
      Type Parameters:
      T - the class type of the spy
      Parameters:
      type - the class type of the spy
      Returns:
      a spy with the specified type

    • Spy

      @Beta public <T> T Spy(T obj)
      Creates a spy wrapping a provided instance. Example: 
         def person = Spy(new Person()) // type is Person.class, name is "person"
      You need to use the spy returned by this method instead of the original instance, otherwise interactions won't be picked up.
      Specified by:
      Spy in interface MockFactory
      Type Parameters:
      T - the class type of the spy
      Parameters:
      obj - the instance to spy
      Returns:
      a spy wrapping the provided instance
      Since:
      1.1

    • Spy

      @Beta public <T> T Spy(T obj, @DelegatesTo(strategy=1) Closure interactions)
      Creates a spy with the specified interactions wrapping a provided instance. Example: 
         def person = Spy(new Person()) {
     name >> "Fred"
   }
      You need to use the spy returned by this method instead of the original instance, otherwise interactions won't be picked up.
      Type Parameters:
      T - the class type of the spy
      Parameters:
      obj - the instance to spy
      interactions - a description of the spy's interactions
      Returns:
      a spy with the specified interactions wrapping the provided instance
      Since:
      2.0

    • Spy

      @Beta public <T> T Spy(Map<String,Object> options, Class<T> type)
      Creates a spy with the specified options and type. If enclosed in an variable assignment, the variable name will be used as the spy's name. Example: 
         def person = Spy(Person, name: "myPerson") // type is Person.class, name is "myPerson"
      Specified by:
      Spy in interface MockFactory
      Type Parameters:
      T - the class type of the spy
      Parameters:
      options - optional options for creating the spy
      type - the class type of the spy
      Returns:
      a spy with the specified options and type

    • Spy

      @Beta public <T> T Spy(Closure interactions)
      Creates a spy with the specified interactions whose type and name are inferred from the left-hand side of the enclosing assignment. Example: 
         // type is Person.class, name is "person", returns hard-coded value for name, calls real method otherwise
   Person person = Spy {
     name >> "Fred"
   }
      Parameters:
      interactions - a description of the spy's interactions
      Returns:
      a spy with the specified interactions whose type and name are inferred from the left-hand side of the enclosing assignment

    • Spy

      @Beta public <T> T Spy(Map<String,Object> options, Closure interactions)
      Creates a spy with the specified options and interactions whose type and name are inferred from the left-hand side of the enclosing assignment. Example: 
         // type is Person.class, name is "myPerson", returns hard-coded value for name, calls real method otherwise
   Person person = Spy(name: "myPerson") {
     name >> "Fred"
   }
      Parameters:
      options - optional options for creating the spy
      interactions - a description of the spy's interactions
      Returns:
      a spy with the specified options and interactions whose type and name are inferred from the left-hand side of the enclosing assignment

    • Spy

      @Beta public <T> T Spy(Class<T> type, @DelegatesTo(strategy=1,genericTypeIndex=0) Closure interactions)
      Creates a spy with the specified type and interactions. If enclosed in a variable assignment, the variable name will be used as the spy's name. Example: 
         // name is "person", type is Person.class, returns hard-code value name, calls real method otherwise
   def person = Spy(Person) {
     name >> "Fred"
     1 * sing()
   }
      Type Parameters:
      T - the class type of the spy
      Parameters:
      type - the class type of the spy
      interactions - a description of the spy's interactions
      Returns:
      a spy with the specified type and interactions

    • Spy

      @Beta public <T> T Spy(Map<String,Object> options, Class<T> type, @DelegatesTo(strategy=1,genericTypeIndex=0) Closure interactions)
      Creates a spy with the specified options, type, and interactions. If enclosed in a variable assignment, the variable name will be used as the spy's name. Example: 
         // type is Person.class, name is "myPerson", returns hard-coded value name, calls real method otherwise
   def person = Spy(Person, name: "myPerson") {
     name >> "Fred"
   }
      Type Parameters:
      T - the class type of the spy
      Parameters:
      options - options for creating the spy (see IMockConfiguration for available options})
      type - the class type of the spy
      interactions - a description of the spy's interactions
      Returns:
      a spy with the specified options, type, and interactions

    • GroovyMock

      @Beta public <T> T GroovyMock()
      Creates a Groovy mock whose type and name are inferred from the left-hand side of the enclosing variable assignment. Example: 
         Person person = GroovyMock() // type is Person.class, name is "person"
      Returns:
      a Groovy mock whose type and name are inferred from the left-hand side of the enclosing variable assignment

    • GroovyMock

      @Beta public <T> T GroovyMock(Map<String,Object> options)
      Creates a Groovy mock with the specified options whose type and name are inferred from the left-hand side of the enclosing variable assignment. Example: 
         Person person = GroovyMock(name: "myPerson") // type is Person.class, name is "myPerson"
      Parameters:
      options - optional options for creating the Groovy mock
      Returns:
      a Groovy mock with the specified options whose type and name are inferred from the left-hand side of the enclosing variable assignment

    • GroovyMock

      @Beta public <T> T GroovyMock(Class<T> type)
      Creates a Groovy mock with the specified type. If enclosed in a variable assignment, the variable name will be used as the mock's name. Example: 
         def person = GroovyMock(Person) // type is Person.class, name is "person"
      Type Parameters:
      T - the interface or class type of the Groovy mock
      Parameters:
      type - the interface or class type of the Groovy mock
      Returns:
      a Groovy mock with the specified type

    • GroovyMock

      @Beta public <T> T GroovyMock(Map<String,Object> options, Class<T> type)
      Creates a Groovy mock with the specified options and type. If enclosed in an variable assignment, the variable name will be used as the mock's name. Example: 
         def person = GroovyMock(Person, name: "myPerson") // type is Person.class, name is "myPerson"
      Type Parameters:
      T - the interface or class type of the Groovy mock
      Parameters:
      options - optional options for creating the Groovy mock
      type - the interface or class type of the Groovy mock
      Returns:
      a Groovy mock with the specified options and type

    • GroovyMock

      @Beta public <T> T GroovyMock(Closure interactions)
      Creates a Groovy mock with the specified interactions whose type and name are inferred from the left-hand side of the enclosing assignment. Example: 
         // type is Person.class, name is "person", returns hard-coded value for name, expects one call to sing()
   Person person = GroovyMock {
     name >> "Fred"
     1 * sing()
   }
      Parameters:
      interactions - a description of the Groovy mock's interactions
      Returns:
      a Groovy mock with the specified interactions whose type and name are inferred from the left-hand side of the enclosing assignment

    • GroovyMock

      @Beta public <T> T GroovyMock(Map<String,Object> options, Closure interactions)
      Creates a Groovy mock with the specified options and interactions whose type and name are inferred from the left-hand side of the enclosing assignment. Example: 
         // type is Person.class, name is "myPerson", returns hard-coded value for name, expects one call to sing()
   Person person = GroovyMock(name: "myPerson") {
     name >> "Fred"
     1 * sing()
   }
      Parameters:
      options - optional options for creating the Groovy mock
      interactions - a description of the Groovy mock's interactions
      Returns:
      a Groovy mock with the specified options and interactions whose type and name are inferred from the left-hand side of the enclosing assignment

    • GroovyMock

      @Beta public <T> T GroovyMock(Class<T> type, @DelegatesTo(strategy=1,genericTypeIndex=0) Closure interactions)
      Creates a Groovy mock with the specified type and interactions. If enclosed in a variable assignment, the variable name will be used as the mock's name. Example: 
         // name is "person", type is Person.class, returns hard-code value name, expects one call to sing()
   def person = GroovyMock(Person) {
     name >> "Fred"
     1 * sing()
   }
      Type Parameters:
      T - the interface or class type of the Groovy mock
      Parameters:
      type - the interface or class type of the Groovy mock
      interactions - a description of the Groovy mock's interactions
      Returns:
      a Groovy mock with the specified type and interactions

    • GroovyMock

      @Beta public <T> T GroovyMock(Map<String,Object> options, Class<T> type, @DelegatesTo(strategy=1,genericTypeIndex=0) Closure interactions)
      Creates a Groovy mock with the specified options, type, and interactions. If enclosed in a variable assignment, the variable name will be used as the mock's name. Example: 
         // type is Person.class, name is "myPerson", returns hard-coded value name, expects one call to sing()
   def person = GroovyMock(Person, name: "myPerson") {
     name >> "Fred"
     1 * sing()
   }
      Type Parameters:
      T - the interface or class type of the Groovy mock
      Parameters:
      options - options for creating the Groovy mock (see IMockConfiguration for available options})
      type - the interface or class type of the mock
      interactions - a description of the Groovy mock's interactions
      Returns:
      a Groovy mock with the specified options, type, and interactions

    • GroovyStub

      @Beta public <T> T GroovyStub()
      Creates a Groovy stub whose type and name are inferred from the left-hand side of the enclosing variable assignment. Example: 
         Person person = GroovyStub() // type is Person.class, name is "person"
      Returns:
      a Groovy stub whose type and name are inferred from the left-hand side of the enclosing variable assignment

    • GroovyStub

      @Beta public <T> T GroovyStub(Map<String,Object> options)
      Creates a Groovy stub with the specified options whose type and name are inferred from the left-hand side of the enclosing variable assignment. Example: 
         Person person = GroovyStub(name: "myPerson") // type is Person.class, name is "myPerson"
      Parameters:
      options - optional options for creating the Groovy stub
      Returns:
      a Groovy stub with the specified options whose type and name are inferred from the left-hand side of the enclosing variable assignment

    • GroovyStub

      @Beta public <T> T GroovyStub(Class<T> type)
      Creates a Groovy stub with the specified type. If enclosed in a variable assignment, the variable name will be used as the stub's name. Example: 
         def person = GroovyStub(Person) // type is Person.class, name is "person"
      Type Parameters:
      T - the interface or class type of the Groovy stub
      Parameters:
      type - the interface or class type of the Groovy stub
      Returns:
      a Groovy stub with the specified type

    • GroovyStub

      @Beta public <T> T GroovyStub(Map<String,Object> options, Class<T> type)
      Creates a Groovy stub with the specified options and type. If enclosed in an variable assignment, the variable name will be used as the stub's name. Example: 
         def person = GroovyStub(Person, name: "myPerson") // type is Person.class, name is "myPerson"
      Type Parameters:
      T - the interface or class type of the Groovy stub
      Parameters:
      options - optional options for creating the Groovy stub
      type - the interface or class type of the Groovy stub
      Returns:
      a Groovy stub with the specified options and type

    • GroovyStub

      @Beta public <T> T GroovyStub(Closure interactions)
      Creates a Groovy stub with the specified interactions whose type and name are inferred from the left-hand side of the enclosing assignment. Example: 
         // type is Person.class, name is "person", returns hard-coded values for property name and method sing()
   Person person = GroovyStub {
     name >> "Fred"
     sing() >> "Tra-la-la"
   }
      Parameters:
      interactions - a description of the Groovy stub's interactions
      Returns:
      a Groovy stub with the specified interactions whose type and name are inferred from the left-hand side of the enclosing assignment

    • GroovyStub

      @Beta public <T> T GroovyStub(Map<String,Object> options, Closure interactions)
      Creates a Groovy stub with the specified options and interactions whose type and name are inferred from the left-hand side of the enclosing assignment. Example: 
         // type is Person.class, name is "myPerson", returns hard-coded values for property name and method sing()
   Person person = GroovyStub(name: "myPerson") {
     name >> "Fred"
     sing() >> "Tra-la-la"
   }
      Parameters:
      options - optional options for creating the Groovy stub
      interactions - a description of the Groovy stub's interactions
      Returns:
      a Groovy stub with the specified options and interactions whose type and name are inferred from the left-hand side of the enclosing assignment

    • GroovyStub

      @Beta public <T> T GroovyStub(Class<T> type, @DelegatesTo(strategy=1,genericTypeIndex=0) Closure interactions)
      Creates a Groovy stub with the specified type and interactions. If enclosed in a variable assignment, the variable name will be used as the stub's name. Example: 
         // name is "person", type is Person.class, returns hard-coded values for property name and method sing()
   def person = GroovyStub(Person) {
     name >> "Fred"
     sing() >> "Tra-la-la"
   }
      Type Parameters:
      T - the interface or class type of the Groovy stub
      Parameters:
      type - the interface or class type of the Groovy stub
      interactions - a description of the Groovy stub's interactions
      Returns:
      a Groovy stub with the specified type and interactions

    • GroovyStub

      @Beta public <T> T GroovyStub(Map<String,Object> options, Class<T> type, @DelegatesTo(strategy=1,genericTypeIndex=0) Closure interactions)
      Creates a Groovy stub with the specified options, type, and interactions. If enclosed in a variable assignment, the variable name will be used as the stub's name. Example: 
         // type is Person.class, name is "myPerson", returns hard-coded values for property name and method sing()
   def person = GroovyStub(Person, name: "myPerson") {
     name >> "Fred"
     sing() >> "Tra-la-la"
   }
      Type Parameters:
      T - the interface or class type of the Groovy stub
      Parameters:
      options - options for creating the Groovy stub (see IMockConfiguration for available options})
      type - the interface or class type of the Groovy stub
      interactions - a description of the Groovy stub's interactions
      Returns:
      a Groovy stub with the specified options, type, and interactions

    • GroovySpy

      @Beta public <T> T GroovySpy()
      Creates a Groovy spy whose type and name are inferred from the left-hand side of the enclosing variable assignment. Example: 
         Person person = GroovySpy() // type is Person.class, name is "person"
      Returns:
      a Groovy spy whose type and name are inferred from the left-hand side of the enclosing variable assignment

    • GroovySpy

      @Beta public <T> T GroovySpy(Map<String,Object> options)
      Creates a Groovy spy with the specified options whose type and name are inferred from the left-hand side of the enclosing variable assignment. Example: 
         Person person = GroovySpy(name: "myPerson") // type is Person.class, name is "myPerson"
      Parameters:
      options - optional options for creating the Groovy spy
      Returns:
      a Groovy spy with the specified options whose type and name are inferred from the left-hand side of the enclosing variable assignment

    • GroovySpy

      @Beta public <T> T GroovySpy(Class<T> type)
      Creates a Groovy spy with the specified type. If enclosed in a variable assignment, the variable name will be used as the spy's name. Example: 
         def person = GroovySpy(Person) // type is Person.class, name is "person"
      Type Parameters:
      T - the class type of the Groovy spy
      Parameters:
      type - the class type of the Groovy spy
      Returns:
      a Groovy spy with the specified type

    • GroovySpy

      @Beta public <T> T GroovySpy(T obj)
      Creates a Groovy spy wrapping a provided instance. Example: 
         def person = GroovySpy(new Person()) // type is Person.class, name is "person"
      You need to use the spy returned by this method instead of the original instance, otherwise interactions won't be picked up.
      Type Parameters:
      T - the class type of the spy
      Parameters:
      obj - the instance to spy
      Returns:
      a spy wrapping the provided instance
      Since:
      2.4

    • GroovySpy

      @Beta public <T> T GroovySpy(T obj, @DelegatesTo(strategy=1) Closure interactions)
      Creates a Groovy spy with the specified interactions wrapping a provided instance. Example: 
         def person = GroovySpy(new Person()) {
     name >> "Fred"
   }
      You need to use the spy returned by this method instead of the original instance, otherwise interactions won't be picked up.
      Type Parameters:
      T - the class type of the spy
      Parameters:
      obj - the instance to spy
      interactions - a description of the spy's interactions
      Returns:
      a spy with the specified interactions wrapping the provided instance
      Since:
      2.4

    • GroovySpy

      @Beta public <T> T GroovySpy(Map<String,Object> options, Class<T> type)
      Creates a Groovy spy with the specified options and type. If enclosed in an variable assignment, the variable name will be used as the spy's name. Example: 
         def person = GroovySpy(Person, name: "myPerson") // type is Person.class, name is "myPerson"
      Type Parameters:
      T - the class type of the Groovy spy
      Parameters:
      options - optional options for creating the Groovy spy
      type - the class type of the Groovy spy
      Returns:
      a Groovy spy with the specified options and type

    • GroovySpy

      @Beta public <T> T GroovySpy(Closure interactions)
      Creates a Groovy spy with the specified interactions whose type and name are inferred from the left-hand side of the enclosing assignment. Example: 
         // type is Person.class, name is "person", returns hard-coded value for name, calls real method otherwise
   Person person = GroovySpy {
     name >> "Fred"
   }
      Parameters:
      interactions - a description of the spy's interactions
      Returns:
      a Groovy spy with the specified interactions whose type and name are inferred from the left-hand side of the enclosing assignment

    • GroovySpy

      @Beta public <T> T GroovySpy(Map<String,Object> options, Closure interactions)
      Creates a Groovy spy with the specified options and interactions whose type and name are inferred from the left-hand side of the enclosing assignment. Example: 
         // type is Person.class, name is "myPerson", returns hard-coded value for name, calls real method otherwise
   Person person = GroovySpy(name: "myPerson") {
     name >> "Fred"
   }
      Parameters:
      options - optional options for creating the Groovy spy
      interactions - a description of the Groovy spy's interactions
      Returns:
      a Groovy spy with the specified options and interactions whose type and name are inferred from the left-hand side of the enclosing assignment

    • GroovySpy

      @Beta public <T> T GroovySpy(Class<T> type, @DelegatesTo(strategy=1,genericTypeIndex=0) Closure interactions)
      Creates a Groovy spy with the specified type and interactions. If enclosed in a variable assignment, the variable name will be used as the spy's name. Example: 
         // name is "person", type is Person.class, returns hard-code value name, calls real method otherwise
   def person = GroovySpy(Person) {
     name >> "Fred"
     1 * sing()
   }
      Type Parameters:
      T - the class type of the Groovy spy
      Parameters:
      type - the class type of the Groovy spy
      interactions - a description of the Groovy spy's interactions
      Returns:
      a Groovy spy with the specified type and interactions

    • GroovySpy

      @Beta public <T> T GroovySpy(Map<String,Object> options, Class<T> type, @DelegatesTo(strategy=1,genericTypeIndex=0) Closure interactions)
      Creates a Groovy spy with the specified options, type, and interactions. If enclosed in a variable assignment, the variable name will be used as the spy's name. Example: 
         // type is Person.class, name is "myPerson", returns hard-coded value name, calls real method otherwise
   def person = GroovySpy(Person, name: "myPerson") {
     name >> "Fred"
   }
      Type Parameters:
      T - the class type of the Groovy spy
      Parameters:
      options - options for creating the Groovy spy (see IMockConfiguration for available options)
      type - the class type of the Groovy spy
      interactions - a description of the Groovy spy's interactions
      Returns:
      a Groovy spy with the specified options, type, and interactions

    • SpyStatic

      @Beta public <T> void SpyStatic(Class<T> type)
      Creates a thread-local spy for all static methods of the passed type.

      Example: 

         SpyStatic(Person)

      If you want to activate the static mocks on a different Thread, please call runWithThreadAwareMocks(Runnable) on the different Thread.

      Parameters:
      type - the type of which the static methods shall be spied

    • SpyStatic

      @Beta public <T> void SpyStatic(Class<T> type, IMockMakerSettings mockMakerSettings)
      Creates a thread-local spy for all static methods of the passed type.

      Example: 

         SpyStatic(Person, spock.mock.MockMakers.mockitoInline)

      If you want to activate the static mocks on a different Thread, please call runWithThreadAwareMocks(Runnable) on the different Thread.

      Parameters:
      type - the type of which the static methods shall be spied
      mockMakerSettings - the mock maker settings to apply to the static spy

    • runWithThreadAwareMocks

      public void runWithThreadAwareMocks(Runnable code)
      Runs the code with the thread-aware mocks activated on the current Thread.

      Note: You only need this if your current Thread is not the test thread. On the test Thread, the thread-aware mocks are automatically activated.

      Parameters:
      code - the code to execute

    • withActiveThreadAwareMocks

      public <R> R withActiveThreadAwareMocks(Callable<R> code)
      Runs the code with the thread-aware mocks activated on the current Thread.

      Note: You only need this if your current Thread is not the test thread. On the test Thread, the thread-aware mocks are automatically activated.

      Type Parameters:
      R - the return type
      Parameters:
      code - the code to execute
      Returns:
      the return value of the executed code