Half-Mock

package halfmock
 
import groovy.lang.*;
 
import java.beans.IntrospectionException;
 
/**
 * The ProxyMetaClass for the MockInterceptor.
 * Instance and class methods are intercepted, but constructors are not to allow mocking of aggregated objects.
 * @author Stefan Roock (based on MockProxyMetaClass by Dierk Koenig)
 */
 
public class HalfMockProxyMetaClass extends ProxyMetaClass {
 
    def methodNames = []
    def propertyNames = []
    def registeredInterceptor
 
    /**
     * @param adaptee the MetaClass to decorate with interceptability
     */
    public HalfMockProxyMetaClass(MetaClassRegistry registry, Class theClass, MetaClass adaptee) throws IntrospectionException {
        super(registry, theClass, adaptee);
        methodNames = theClass.declaredMethods.name.toList()
        def clazz = theClass
        while (clazz != null) {
            propertyNames.addAll( clazz.declaredFields.name.toList() )
            clazz = clazz.superclass
        }
    }
 
    /**
     * convenience factory method for the most usual case.
     */
    public static HalfMockProxyMetaClass make(Class theClass) throws IntrospectionException {
        MetaClassRegistry metaRegistry = GroovySystem.getMetaClassRegistry();
        MetaClass meta = metaRegistry.getMetaClass(theClass);
        return new HalfMockProxyMetaClass(metaRegistry, theClass, meta);
    }
 
 
    public Object invokeMethod(final Object object, final String methodName, final Object[] arguments) {
        if (!restoreInterceptor()) {
            throw new RuntimeException("cannot invoke method ${methodName} without interceptor");
        }
        if (!methodNames.contains(methodName)) {
            return interceptor.beforeInvoke(object, methodName, arguments);
        }
        return doWithoutInterceptor {
            super.invokeMethod(object, methodName, arguments)
        }
    }
 
    public Object invokeStaticMethod(final Object object, final String methodName, final Object[] arguments) {
        if (!restoreInterceptor()) {
            throw new RuntimeException("cannot invoke static method ${methodName} without interceptor");
        }
        if (!methodNames.contains(methodName)) {
            return interceptor.beforeInvoke(object, methodName, arguments);
        }
        return doWithoutInterceptor {
            super.invokeStaticMethod(object, methodName, arguments)
        }
    }
 
    public Object getProperty(Class aClass, Object object, String property, boolean b, boolean b1) {
        if (!restoreInterceptor()) {
            throw new RuntimeException("cannot get property ${property} without interceptor");
        }
        if (interceptor instanceof PropertyAccessInterceptor && !propertyNames.contains(property)) {
            return ((PropertyAccessInterceptor) interceptor).beforeGet(object, property);
        }
        else {
            return doWithoutInterceptor {
                super.getProperty(aClass, object, property, b, b)
            }
        }
 
    }
 
    public void setProperty(Class aClass, Object object, String property, Object newValue, boolean b, boolean b1) {
        if (!restoreInterceptor()) {
            throw new RuntimeException("cannot set property ${property} without interceptor");
        }
 
        if (interceptor instanceof PropertyAccessInterceptor && !propertyNames.contains(property)) {
            ((PropertyAccessInterceptor) interceptor).beforeSet(object, property, newValue);
        }
        else {
            doWithoutInterceptor {
                super.setProperty(aClass, object, property, newValue, b, b)
            }
        }
 
    }
 
    /**
     * Unlike general impl in superclass, ctors are not intercepted but relayed
     */
    public Object invokeConstructor(final Object[] arguments) {
        return adaptee.invokeConstructor(arguments);
    }
 
    private doWithoutInterceptor(closure) {
        registeredInterceptor = interceptor
        interceptor = null
        def result = closure.call()
        restoreInterceptor()
        result
    }
 
    private restoreInterceptor() {
        interceptor = interceptor ?: registeredInterceptor
        return interceptor
    }
 
}
 
 
 
 
package halfmock
 
import groovy.mock.interceptor.*
 
/**
    Facade over the Mocking details.
    A Mock's expectation is always sequence dependent and it's use always ends with a verify().
    See also StubFor.
    @author Stefan Roock (based on MockFor from Dierk Koenig and Paul King
*/
class HalfMockFor {
 
    HalfMockProxyMetaClass proxy
    Demand demand
    def expect
    Map instanceExpectations = [:]
    Class clazz
 
    HalfMockFor(Class clazz) {
        this.clazz = clazz
        proxy = HalfMockProxyMetaClass.make(clazz)
        demand = new Demand()
        expect = new StrictExpectation(demand)
        proxy.interceptor = new MockInterceptor(expectation: expect)
    }
 
    void use(Closure closure) {
        proxy.use closure
        expect.verify()
    }
 
    void use(GroovyObject obj, Closure closure) {
        proxy.use obj, closure
        expect.verify()
    }
 
    void verify(GroovyObject obj) {
        instanceExpectations[obj].verify()
    }
 
    Object proxyInstance() {
        proxyInstance(null)
    }
 
    Object proxyInstance(args) {
        def instance = getInstance(clazz, args)
        def thisproxy = HalfMockProxyMetaClass.make(clazz)
        def thisdemand = new Demand(recorded: new ArrayList(demand.recorded))
        def thisexpect = new StrictExpectation(thisdemand)
        thisproxy.interceptor = new MockInterceptor(expectation: thisexpect)
        instance.metaClass = thisproxy
        instanceExpectations[instance] = thisexpect
        return instance
    }
 
    Object proxyDelegateInstance() {
        proxyDelegateInstance(null)
    }
 
    Object proxyDelegateInstance(args) {
        def instance = getInstance(clazz, args)
        def thisproxy = HalfMockProxyMetaClass.make(clazz)
        def thisdemand = new Demand(recorded: new ArrayList(demand.recorded))
        def thisexpect = new StrictExpectation(thisdemand)
        thisproxy.interceptor = new MockInterceptor(expectation: thisexpect)
        instance.metaClass = thisproxy
        def wrapped = null
        if (clazz.isInterface()) {
            wrapped = ProxyGenerator.instantiateDelegate([clazz], instance)
        } else {
            wrapped = ProxyGenerator.instantiateDelegate(instance)
        }
        instanceExpectations[wrapped] = thisexpect
        return wrapped
    }
 
    private getInstance(Class clazz, args) {
        def instance = null
        if (clazz.isInterface()) {
            instance = ProxyGenerator.instantiateAggregateFromInterface(clazz)
        } else if (Modifier.isAbstract(clazz.modifiers)) {
            instance = ProxyGenerator.instantiateAggregateFromBaseClass(clazz, args)
        } else if (args != null) {
            if (clazz instanceof GroovyObject) {
                instance = clazz.newInstance(args)
            } else {
                instance = ProxyGenerator.instantiateDelegate(clazz.newInstance(args))
            }
        } else {
            if (clazz instanceof GroovyObject) {
                instance = clazz.newInstance()
            } else {
                instance = ProxyGenerator.instantiateDelegate(clazz.newInstance())
            }
        }
        return instance
    }
 
}
 
 
 
 
// Test
package halfmock
 
import groovy.mock.interceptor.*
 
class Foo {
 
    static existsCalls = 0, staticExistsCalls = 0, constructorCalls = 0
    def existingProperty = 0
 
    Foo() {
        constructorCalls++
    }
 
    void exists() {
        existsCalls++
    }
 
    void callsDoesntExist() {
        doesntExist()
    }
 
    static void staticExists() {
        staticExistsCalls++
    }
}
 
class Bar extends Foo {
 
}
 
class HalfMockTest extends GroovyTestCase {
 
    void setUp() {
        Foo.constructorCalls = 0
        Foo.staticExistsCalls = 0
        Foo.existsCalls = 0
    }
 
    void testCallsConstructorOfMockedObject() {
        def mock = new HalfMockFor(Foo.class)
        mock.use {
            def foo = new Foo()
        }
        assertEquals 1, Foo.constructorCalls
    }
 
    void testMocksNonExistingMethods() {
        def mock = new HalfMockFor(Foo.class)
        mock.demand.doesntExist() {}
        mock.use {
            def foo = new Foo()
            foo.doesntExist()
        }
    }
 
    void testDoesntMockExistingMethods() {
        def mock = new HalfMockFor(Foo.class)
        mock.use {
            def foo = new Foo()
            foo.exists()
        }
        assertEquals 1, Foo.existsCalls
    }
 
 
    void testMocksIndirectlyCalledNonExistingMethods() {
        def mock = new HalfMockFor(Foo.class)
        mock.demand.doesntExist() {}
        mock.use {
            def foo = new Foo()
            foo.callsDoesntExist()
        }
    }
 
 
    void testMocksNonExistingStaticMethods() {
        def mock = new HalfMockFor(Foo.class)
        mock.demand.staticDoesntExist() {}
        mock.use {
            def foo = new Foo()
            Foo.staticDoesntExist()
        }
    }
 
    void testDoesntMockExistingStaticMethods() {
        def mock = new HalfMockFor(Foo.class)
        mock.use {
            def foo = new Foo()
            Foo.staticExists()
        }
        assertEquals 1, Foo.staticExistsCalls
    }
 
    void testMocksNonExistingProperties() {
        def mock = new HalfMockFor(Foo.class)
        mock.demand.setNonExistingProperty(1) {}
        mock.demand.getNonExistingProperty() {2}
        mock.use {
            def foo = new Foo()
            foo.nonExistingProperty = 1
            assertEquals 2, foo.nonExistingProperty
        }
    }
 
    void testDoesntMockExistingProperties() {
        def mock = new HalfMockFor(Foo.class)
        mock.use {
            def foo = new Foo()
            foo.existingProperty = 1
            assertEquals 1, foo.existingProperty
        }
    }
 
   void testDoesntMockExistingInheritedProperties() {
        def mock = new HalfMockFor(Bar.class)
        mock.use {
            def bar = new Bar()
            bar.existingProperty = 1
            assertEquals 1, bar.existingProperty
        }
    }
 
}