Property Detail

• private Class clazz

• private Demand demand

• private Object expect

• private Ignore ignore

• private Map instanceExpectations

• private MockProxyMetaClass proxy

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'
   }
   

• MockFor()

Method Detail

• static GroovyObject getInstance(Class clazz, Object args)

• 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)

• 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)

• void verify(GroovyObject obj)

  If manual verification is required