Property Detail

• Class clazz

  Collaborator class being mocked.

• Demand demand

  Recorded demand specification for the mocked collaborator.

• Object expect

  Sequence-sensitive expectation enforcing the recorded demands.

• Ignore ignore

  Helper supporting the ignore.methodName(...) shorthand.

• Map instanceExpectations

  Per-instance expectations created for proxy-style usage.

• MockProxyMetaClass proxy

  Proxy meta class used to intercept collaborator interactions.

Constructor Detail

• MockFor(Class clazz, boolean interceptConstruction)

  The optional interceptConstruction flag allows mocking of constructor calls. These are represented in the demand specification using the class name as this example shows:

  
   import groovy.mock.interceptor.MockFor
   class Person {
     String first, last
   }
   def interceptConstructorCalls = true
   def mock = new MockFor(Person, interceptConstructorCalls)
   def dummy = new Person(first:'Tom', last:'Jones')
   mock.demand.with {
     Person() { dummy } // expect constructor call, return dummy
     getFirst() {'John'}
     getLast() {'Doe'}
   }
   mock.use {
     def p = new Person(first:'Mary', last:'Smith')
     assert p.first == 'John'
     assert p.last == 'Doe'
   }
   

Method Detail

• static GroovyObject getInstance(Class clazz, Object args)

  Creates a concrete instance suitable for proxy-style mocking.

  Parameters:

  clazz - the collaborator class to instantiate

  args - optional constructor arguments

  Returns:

  the instantiated object or delegate proxy

• Object ignore(Object filter, Closure filterBehavior)

  Allows particular method calls to be ignored and not treated as part of the required behavior specification. If you don't specify a return closure the method call will fall through to the underlying instance, i.e. half-mock style. The filter object is invoked using the normal Groovy isCase() semantics. Here are some examples:

  
   import groovy.mock.interceptor.MockFor
   class Person {
     String first, last
     def name() { "$first $last" }
     def ignoreMe() { 'baz' }
     def ignoreMeToo() { ignoreMe() }
     def ignoreMeThree() { ignoreMe() }
   }
   def mock = new MockFor(Person)
   mock.ignore(~'get.*')
   mock.ignore('ignoreMeToo') { 'boo' }
   mock.ignore(~'ignoreMe.*')
   mock.demand.name{ 'John' }
   mock.use {
     def p = new Person(first:'Mary', last:'Smith')
     assert p.first == 'Mary'
     assert p.last == 'Smith'
     assert p.name() == 'John'
     assert p.ignoreMe() == 'baz'
     assert p.ignoreMeToo() == 'boo'
     assert p.ignoreMeThree() == 'baz'
   }
   

  There is also a convenience form of ignore that matches the same style as demand. E.g. instead of mock.ignore('hasNext') you can use mock.ignore.hasNext(). A Closure variation is also provided. This convenience shorthand only applies to the String form of ignore and cannot be used with methods from java.lang.Object. Be careful using this feature while mocking some of the fundamental Java classes like String or Pattern. As these are used within the implementation of the ignore capability, strange behavior may be observed.

• GroovyObject makeProxyInstance(Object args, boolean isDelegate)

  Creates a proxy-backed instance and wires it to a dedicated expectation.

  Parameters:

  args - optional constructor arguments

  isDelegate - whether Java targets should be wrapped as delegate proxies

  Returns:

  the proxy-backed instance

• GroovyObject proxyDelegateInstance(Object args)

  Allows a more traditional instance-style mocking paradigm. This is the recommended method to call to use the instance-style with Java classes. When mocking interfaces or abstract classes, a compatible proxy instance will be returned. When mocking Java classes, a compatible Groovy class will be generated and proxy instance returned. A MockProxyMetaClass will be instantiated for the class of the instance (i.e. may be on the generated class not the original class).

• GroovyObject proxyInstance(Object args)

  Allows a more traditional instance-style mocking paradigm. This is the recommended method to call to use the instance-style with Groovy classes. When mocking interfaces or abstract classes, a compatible proxy instance will be returned. When mocking Java classes, a compatible Groovy class will be generated and proxy instance returned. A MockProxyMetaClass will be instantiated for the original class. Typical example:

  
   import groovy.mock.interceptor.MockFor
  
   class Person {
     String first, last
   }
  
   class Family {
     Person mother, father
     String nameOfMother() { fullName(mother) }
     String nameOfFather() { fullName(father) }
     private fullName(p) { "$p.first $p.last" }
   }
  
   def mock = new MockFor(Person)
   mock.demand.with {
     getFirst{ 'dummy' }
     getLast{ 'name' }
   }
   Person john = mock.proxyInstance()
   Person mary = mock.proxyInstance()
   Family f = new Family(father:john, mother:mary)
   assert f.nameOfFather() == 'dummy name'
   assert f.nameOfMother() == 'dummy name'
   [john, mary].each{ mock.verify(it) }
   

  Normally for mocks, verify() is call automatically at the end of the "use" Closure, but with this style, no "use" Closure is present, so verify() must be called manually.

• void use(Closure closure)

  Identifies the Closure where the mocked collaborator behavior will be applied and verified.

• void use(GroovyObject obj, Closure closure)

  Applies this mock to a single Groovy object for the duration of the supplied closure.

  Parameters:

  obj - the object whose meta class should be replaced temporarily

  closure - the work to run while the mock is active

• void verify(GroovyObject obj)

  If manual verification is required