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 and Description
MockingApi()

Method Summary

Modifier and Type	Method and 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(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(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(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, 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	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	GroovySpy() Creates a Groovy spy whose type and name are inferred from the left-hand side of the enclosing variable 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(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(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, 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(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(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(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(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(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, 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.
<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.
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(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(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(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, 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	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.
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(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(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(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, 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(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(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(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(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(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, 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.
<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.
<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 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,
                       @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