Package spock.lang
Class MockingApi
java.lang.Object
org.spockframework.lang.SpecInternals
spock.lang.MockingApi
- Direct Known Subclasses:
Specification
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.
- 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.
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 -
Method Summary
Modifier and TypeMethodDescriptionCreates a Groovy mock whose type and name are inferred from the left-hand side of the enclosing variable assignment.GroovyMock
(groovy.lang.Closure interactions) Creates a Groovy mock with the specified interactions whose type and name are inferred from the left-hand side of the enclosing assignment.<T> T
GroovyMock
(Class<T> type) Creates a Groovy mock with the specified type.<T> T
GroovyMock
(Class<T> type, groovy.lang.Closure interactions) Creates a Groovy mock with the specified type and interactions.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.GroovyMock
(Map<String, Object> options, groovy.lang.Closure interactions) Creates a Groovy mock with the specified options and interactions whose type and name are inferred from the left-hand side of the enclosing assignment.<T> T
GroovyMock
(Map<String, Object> options, Class<T> type) Creates a Groovy mock with the specified options and type.<T> T
GroovyMock
(Map<String, Object> options, Class<T> type, groovy.lang.Closure interactions) Creates a Groovy mock with the specified options, type, and interactions.Creates a Groovy spy whose type and name are inferred from the left-hand side of the enclosing variable assignment.GroovySpy
(groovy.lang.Closure interactions) Creates a Groovy spy with the specified interactions whose type and name are inferred from the left-hand side of the enclosing assignment.<T> T
Creates a Groovy spy with the specified type.<T> T
Creates a Groovy spy with the specified type and interactions.Creates a Groovy spy with the specified options whose type and name are inferred from the left-hand side of the enclosing variable assignment.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
Creates a Groovy spy with the specified options and type.<T> T
Creates a Groovy spy with the specified options, type, and interactions.Creates a Groovy stub whose type and name are inferred from the left-hand side of the enclosing variable assignment.GroovyStub
(groovy.lang.Closure interactions) Creates a Groovy stub with the specified interactions whose type and name are inferred from the left-hand side of the enclosing assignment.<T> T
GroovyStub
(Class<T> type) Creates a Groovy stub with the specified type.<T> T
GroovyStub
(Class<T> type, groovy.lang.Closure interactions) Creates a Groovy stub with the specified type and interactions.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.GroovyStub
(Map<String, Object> options, groovy.lang.Closure interactions) Creates a Groovy stub with the specified options and interactions whose type and name are inferred from the left-hand side of the enclosing assignment.<T> T
GroovyStub
(Map<String, Object> options, Class<T> type) Creates a Groovy stub with the specified options and type.<T> T
GroovyStub
(Map<String, Object> options, Class<T> type, groovy.lang.Closure interactions) Creates a Groovy stub with the specified options, type, and interactions.void
interaction
(groovy.lang.Closure block) Encloses one or more interaction definitions in a then block.Mock()
Creates a mock whose type and name are inferred from the left-hand side of the enclosing variable assignment.Mock
(groovy.lang.Closure interactions) Creates a mock with the specified interactions whose type and name are inferred from the left-hand side of the enclosing assignment.<T> T
Creates a mock with the specified type.<T> T
Creates a mock with the specified type and interactions.Creates a mock with the specified options whose type and name are inferred from the left-hand side of the enclosing variable assignment.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
Creates a mock with the specified options and type.<T> T
Creates a mock with the specified options, type, and interactions.Spy()
Creates a spy whose type and name are inferred from the left-hand side of the enclosing variable assignment.Spy
(groovy.lang.Closure interactions) Creates a spy with the specified interactions whose type and name are inferred from the left-hand side of the enclosing assignment.<T> T
Creates a spy with the specified type.<T> T
Creates a spy with the specified type and interactions.Creates a spy with the specified options whose type and name are inferred from the left-hand side of the enclosing variable assignment.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
Creates a spy with the specified options and type.<T> T
Creates a spy with the specified options, type, and interactions.Stub()
Creates a stub whose type and name are inferred from the left-hand side of the enclosing variable assignment.Stub
(groovy.lang.Closure interactions) Creates a stub with the specified interactions whose type and name are inferred from the left-hand side of the enclosing assignment.<T> T
Creates a stub with the specified type.<T> T
Creates a stub with the specified type and interactions.Creates a stub with the specified options whose type and name are inferred from the left-hand side of the enclosing variable assignment.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
Creates a stub with the specified options and type.<T> T
Creates a stub with the specified options, type, and interactions.Methods inherited from class org.spockframework.lang.SpecInternals
createMock, getSpecificationContext
-
Constructor Details
-
MockingApi
public MockingApi()
-
-
Method Details
-
interaction
public void interaction(groovy.lang.Closure block) Encloses one or more interaction definitions in a then block. Required when an interaction definition uses a statement that doesn't match one of the following patterns, and therefore isn't automatically recognized as belonging to an interaction definition:- num * target.method(args)
- target.method(args) >>(>) result(s)
- num * target.method(args) >>(>) result(s)
Regular interaction definition:
def "published messages are received at least once"() { when: publisher.send(msg) then: (1.._) * subscriber.receive(msg) }
Equivalent definition that uses a helper variable:
def "published messages are received at least once"() { when: publisher.send(msg) then: interaction { def num = (1.._) num * subscriber.receive(msg) } }
Equivalent definition that uses a helper method:
def "published messages are received at least once"() { when: publisher.send(msg) then: interaction { messageReceived(msg) } } def messageReceived(msg) { (1.._) * subscriber.receive(msg) }
- Parameters:
block
- a block of code containing one or more interaction definitions
-
Mock
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
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
Creates a mock with the specified type. If enclosed in a variable assignment, the variable name will be used as the mock's name. Example:def person = Mock(Person) // type is Person.class, name is "person"
- Type Parameters:
T
- the interface or class type of the mock- Parameters:
type
- the interface or class type of the mock- Returns:
- a mock with the specified type
-
Mock
Creates a mock with the specified options and type. If enclosed in an variable assignment, the variable name will be used as the mock's name. Example:def person = Mock(Person, name: "myPerson") // type is Person.class, name is "myPerson"
- Type Parameters:
T
- the interface or class type of the mock- Parameters:
options
- optional options for creating the mocktype
- the interface or class type of the mock- Returns:
- a mock with the specified options and type
-
Mock
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 tosing()
Person person = Mock { name invalid input: '<'invalid input: '<' "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
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 tosing()
Person person = Mock(name: "myPerson") { name invalid input: '<'invalid input: '<' "Fred" 1 * sing() }- Parameters:
options
- optional options for creating the mockinteractions
- 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
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 tosing()
def person = Mock(Person) { name invalid input: '<'invalid input: '<' "Fred" 1 * sing() }- Type Parameters:
T
- the interface or class type of the mock- Parameters:
type
- the interface or class type of the mockinteractions
- a description of the mock's interactions- Returns:
- a mock with the specified type and interactions
-
Mock
@Beta public <T> T Mock(Map<String, Object> options, Class<T> type, groovy.lang.Closure interactions) Creates a mock with the specified options, type, and interactions. If enclosed in a variable assignment, the variable name will be used as the mock's name. Example:// type is Person.class, name is "myPerson", returns hard-coded value
name
, expects one call tosing()
def person = Mock(Person, name: "myPerson") { name invalid input: '<'invalid input: '<' "Fred" 1 * sing() }- Type Parameters:
T
- the interface or class type of the mock- Parameters:
options
- options for creating the mock (seeIMockConfiguration
for available options})type
- the interface or class type of the mockinteractions
- a description of the mock's interactions- Returns:
- a mock with the specified options, type, and interactions
-
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
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
Creates a stub with the specified type. If enclosed in a variable assignment, the variable name will be used as the stub's name. Example:def person = Stub(Person) // type is Person.class, name is "person"
- Type Parameters:
T
- the interface or class type of the stub- Parameters:
type
- the interface or class type of the stub- Returns:
- a stub with the specified type
-
Stub
Creates a stub with the specified options and type. If enclosed in an variable assignment, the variable name will be used as the stub's name. Example:def person = Stub(Person, name: "myPerson") // type is Person.class, name is "myPerson"
- Type Parameters:
T
- the interface or class type of the stub- Parameters:
options
- optional options for creating the stubtype
- the interface or class type of the stub- Returns:
- a stub with the specified options and type
-
Stub
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 methodsing()
Person person = Stub { name invalid input: '<'invalid input: '<' "Fred" sing() invalid input: '<'invalid input: '<' "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
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 methodsing()
Person person = Stub(name: "myPerson") { name invalid input: '<'invalid input: '<' "Fred" sing() invalid input: '<'invalid input: '<' "Tra-la-la" }- Parameters:
options
- optional options for creating the stubinteractions
- 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
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 methodsing()
def person = Stub(Person) { name invalid input: '<'invalid input: '<' "Fred" sing() invalid input: '<'invalid input: '<' "Tra-la-la" }- Type Parameters:
T
- the interface or class type of the stub- Parameters:
type
- the interface or class type of the stubinteractions
- a description of the stub's interactions- Returns:
- a stub with the specified type and interactions
-
Stub
@Beta public <T> T Stub(Map<String, Object> options, Class<T> type, groovy.lang.Closure interactions) Creates a stub with the specified options, type, and interactions. If enclosed in a variable assignment, the variable name will be used as the stub's name. Example:// type is Person.class, name is "myPerson", returns hard-coded values for property
name
and methodsing()
def person = Stub(Person, name: "myPerson") { name invalid input: '<'invalid input: '<' "Fred" sing() invalid input: '<'invalid input: '<' "Tra-la-la" }- Type Parameters:
T
- the interface or class type of the stub- Parameters:
options
- options for creating the stub (seeIMockConfiguration
for available options})type
- the interface or class type of the stubinteractions
- a description of the stub's interactions- Returns:
- a stub with the specified options, type, and interactions
-
Spy
Creates a spy whose type and name are inferred from the left-hand side of the enclosing variable assignment. 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
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
Creates a spy with the specified type. If enclosed in a variable assignment, the variable name will be used as the spy's name. Example:def person = Spy(Person) // type is Person.class, name is "person"
- Type Parameters:
T
- the class type of the spy- Parameters:
type
- the class type of the spy- Returns:
- a spy with the specified type
-
Spy
Creates a spy with the specified options and type. If enclosed in an variable assignment, the variable name will be used as the spy's name. Example:def person = Spy(Person, name: "myPerson") // type is Person.class, name is "myPerson"
- Type Parameters:
T
- the class type of the spy- Parameters:
options
- optional options for creating the spytype
- the class type of the spy- Returns:
- a spy with the specified options and type
-
Spy
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 invalid input: '<'invalid input: '<' "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
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 invalid input: '<'invalid input: '<' "Fred" }- Parameters:
options
- optional options for creating the spyinteractions
- 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
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 invalid input: '<'invalid input: '<' "Fred" 1 * sing() }- Type Parameters:
T
- the class type of the spy- Parameters:
type
- the class type of the spyinteractions
- a description of the spy's interactions- Returns:
- a spy with the specified type and interactions
-
Spy
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 invalid input: '<'invalid input: '<' "Fred" }- Type Parameters:
T
- the class type of the spy- Parameters:
options
- options for creating the spy (seeIMockConfiguration
for available options})type
- the class type of the spyinteractions
- a description of the spy's interactions- Returns:
- a spy with the specified options, type, and interactions
-
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
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
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
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 mocktype
- the interface or class type of the Groovy mock- Returns:
- a Groovy mock with the specified options and type
-
GroovyMock
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 tosing()
Person person = GroovyMock { name invalid input: '<'invalid input: '<' "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
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 tosing()
Person person = GroovyMock(name: "myPerson") { name invalid input: '<'invalid input: '<' "Fred" 1 * sing() }- Parameters:
options
- optional options for creating the Groovy mockinteractions
- 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
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 tosing()
def person = GroovyMock(Person) { name invalid input: '<'invalid input: '<' "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 mockinteractions
- a description of the Groovy mock's interactions- Returns:
- a Groovy mock with the specified type and interactions
-
GroovyMock
@Beta public <T> T GroovyMock(Map<String, Object> options, Class<T> type, groovy.lang.Closure interactions) Creates a Groovy mock with the specified options, type, and interactions. If enclosed in a variable assignment, the variable name will be used as the mock's name. Example:// type is Person.class, name is "myPerson", returns hard-coded value
name
, expects one call tosing()
def person = GroovyMock(Person, name: "myPerson") { name invalid input: '<'invalid input: '<' "Fred" 1 * sing() }- Type Parameters:
T
- the interface or class type of the Groovy mock- Parameters:
options
- options for creating the Groovy mock (seeIMockConfiguration
for available options})type
- the interface or class type of the mockinteractions
- a description of the Groovy mock's interactions- Returns:
- a Groovy mock with the specified options, type, and interactions
-
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
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
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
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 stubtype
- the interface or class type of the Groovy stub- Returns:
- a Groovy stub with the specified options and type
-
GroovyStub
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 methodsing()
Person person = GroovyStub { name invalid input: '<'invalid input: '<' "Fred" sing() invalid input: '<'invalid input: '<' "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
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 methodsing()
Person person = GroovyStub(name: "myPerson") { name invalid input: '<'invalid input: '<' "Fred" sing() invalid input: '<'invalid input: '<' "Tra-la-la" }- Parameters:
options
- optional options for creating the Groovy stubinteractions
- 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
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 methodsing()
def person = GroovyStub(Person) { name invalid input: '<'invalid input: '<' "Fred" sing() invalid input: '<'invalid input: '<' "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 stubinteractions
- a description of the Groovy stub's interactions- Returns:
- a Groovy stub with the specified type and interactions
-
GroovyStub
@Beta public <T> T GroovyStub(Map<String, Object> options, Class<T> type, groovy.lang.Closure interactions) Creates a Groovy stub with the specified options, type, and interactions. If enclosed in a variable assignment, the variable name will be used as the stub's name. Example:// type is Person.class, name is "myPerson", returns hard-coded values for property
name
and methodsing()
def person = GroovyStub(Person, name: "myPerson") { name invalid input: '<'invalid input: '<' "Fred" sing() invalid input: '<'invalid input: '<' "Tra-la-la" }- Type Parameters:
T
- the interface or class type of the Groovy stub- Parameters:
options
- options for creating the Groovy stub (seeIMockConfiguration
for available options})type
- the interface or class type of the Groovy stubinteractions
- a description of the Groovy stub's interactions- Returns:
- a Groovy stub with the specified options, type, and interactions
-
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
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
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
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 spytype
- the class type of the Groovy spy- Returns:
- a Groovy spy with the specified options and type
-
GroovySpy
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 invalid input: '<'invalid input: '<' "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
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 invalid input: '<'invalid input: '<' "Fred" }- Parameters:
options
- optional options for creating the Groovy spyinteractions
- 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
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 invalid input: '<'invalid input: '<' "Fred" 1 * sing() }- Type Parameters:
T
- the class type of the Groovy spy- Parameters:
type
- the class type of the Groovy spyinteractions
- a description of the Groovy spy's interactions- Returns:
- a Groovy spy with the specified type and interactions
-
GroovySpy
@Beta public <T> T GroovySpy(Map<String, Object> options, Class<T> type, groovy.lang.Closure interactions) Creates a Groovy spy with the specified options, type, and interactions. If enclosed in a variable assignment, the variable name will be used as the spy's name. Example:// type is Person.class, name is "myPerson", returns hard-coded value
name
, calls real method otherwise def person = GroovySpy(Person, name: "myPerson") { name invalid input: '<'invalid input: '<' "Fred" }- Type Parameters:
T
- the class type of the Groovy spy- Parameters:
options
- options for creating the Groovy spy (seeIMockConfiguration
for available options})type
- the class type of the Groovy spyinteractions
- a description of the Groovy spy's interactions- Returns:
- a Groovy spy with the specified options, type, and interactions
-