Package spock.mock

Class 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.
    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

      All Methods Instance Methods Concrete Methods 
      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 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.
      <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> 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.
      • Methods inherited from class org.spockframework.lang.SpecInternals

        createMock, createMock, getSpecificationContext
    • Constructor Detail

      • MockingApi

        public MockingApi()
    • Method Detail

      • 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,
                         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​(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