Package spock.lang

Class MockingApi

Direct Known Subclasses:
Specification

public class MockingApi extends SpecInternals
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.
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
     
  • Method Summary

    Modifier and Type
    Method
    Description
    Creates a Groovy mock whose type and name are inferred from the left-hand side of the enclosing variable assignment.
    GroovyMock(groovy.lang.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, groovy.lang.Closure interactions)
    Creates a Groovy mock with the specified type and interactions.
    Creates a Groovy mock with the specified options whose type and name are inferred from the left-hand side of the enclosing variable assignment.
    GroovyMock(Map<String,Object> options, groovy.lang.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, groovy.lang.Closure interactions)
    Creates a Groovy mock with the specified options, type, and interactions.
    Creates a Groovy spy whose type and name are inferred from the left-hand side of the enclosing variable assignment.
    GroovySpy(groovy.lang.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, groovy.lang.Closure interactions)
    Creates a Groovy spy with the specified type and interactions.
    Creates a Groovy spy with the specified options whose type and name are inferred from the left-hand side of the enclosing variable assignment.
    GroovySpy(Map<String,Object> options, groovy.lang.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, groovy.lang.Closure interactions)
    Creates a Groovy spy with the specified options, type, and interactions.
    Creates a Groovy stub whose type and name are inferred from the left-hand side of the enclosing variable assignment.
    GroovyStub(groovy.lang.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, groovy.lang.Closure interactions)
    Creates a Groovy stub with the specified type and interactions.
    Creates a Groovy stub with the specified options whose type and name are inferred from the left-hand side of the enclosing variable assignment.
    GroovyStub(Map<String,Object> options, groovy.lang.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, groovy.lang.Closure interactions)
    Creates a Groovy stub with the specified options, type, and interactions.
    void
    interaction(groovy.lang.Closure block)
    Encloses one or more interaction definitions in a then block.
    Creates a mock whose type and name are inferred from the left-hand side of the enclosing variable assignment.
    Mock(groovy.lang.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, groovy.lang.Closure interactions)
    Creates a mock with the specified type and interactions.
    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.
    Mock(Map<String,Object> options, groovy.lang.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, groovy.lang.Closure interactions)
    Creates a mock with the specified options, type, and interactions.
    Spy()
    Creates a spy whose type and name are inferred from the left-hand side of the enclosing variable assignment.
    Spy(groovy.lang.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, groovy.lang.Closure interactions)
    Creates a spy with the specified type and interactions.
    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.
    Spy(Map<String,Object> options, groovy.lang.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, groovy.lang.Closure interactions)
    Creates a spy with the specified options, type, and interactions.
    Creates a stub whose type and name are inferred from the left-hand side of the enclosing variable assignment.
    Stub(groovy.lang.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, groovy.lang.Closure interactions)
    Creates a stub with the specified type and interactions.
    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.
    Stub(Map<String,Object> options, groovy.lang.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, groovy.lang.Closure interactions)
    Creates a stub with the specified options, type, and interactions.

    Methods inherited from class org.spockframework.lang.SpecInternals

    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(groovy.lang.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 Object 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 Object 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"
       
      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"
       
      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 Object Mock(groovy.lang.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 Object Mock(Map<String,Object> options, groovy.lang.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, groovy.lang.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, groovy.lang.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 Object 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 Object 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"
       
      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"
       
      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 Object Stub(groovy.lang.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 Object Stub(Map<String,Object> options, groovy.lang.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, groovy.lang.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, groovy.lang.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 Object 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 Object 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"
       
      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(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"
       
      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 Object Spy(groovy.lang.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 Object Spy(Map<String,Object> options, groovy.lang.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, groovy.lang.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, groovy.lang.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 Object 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 Object 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 Object GroovyMock(groovy.lang.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 Object GroovyMock(Map<String,Object> options, groovy.lang.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, groovy.lang.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, groovy.lang.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 Object 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 Object 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 Object GroovyStub(groovy.lang.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 Object GroovyStub(Map<String,Object> options, groovy.lang.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, groovy.lang.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, groovy.lang.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 Object 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 Object 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(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 Object GroovySpy(groovy.lang.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 Object GroovySpy(Map<String,Object> options, groovy.lang.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, groovy.lang.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, groovy.lang.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