Htykuut

I have two classes that I'm testing.
They both have two functions (outer and inner).

I want to see what parameters have been passed to inner.
So, I mock inner using MockFor (mock.demand.inner) with another Closure.

The first class returns a Closure which will call inner. Then the Closure is executed by the test. It works, the original inner is not called.

The second class executes inner directly. It fails, the original inner is called.

I've tried to mock it by overriding it (Can Groovy dynamically add or override a method on a POJO?) and the original inner is still called.

The thing is, I must call inner from within outer with the second class. I cannot delay it or delegate it.

So, I'm wondering what is going on there? How can I make it work?

Here is the code, stripped down, from 1500+ lines, to 66 lines, isolating and highlighting the actual behaviour.

To know if inner is not correctly mocked, it throws an exception. This will be thrown only if it's not mocked.

package org.aroundmedia.tools



import groovy.mock.interceptor.MockFor

import org.junit.Test

import sun.reflect.generics.reflectiveObjects.NotImplementedException



class ClassWithClosure {

    def outer() {

        return { this.inner('foo') }

    }



    private def inner(arg) {

        throw new NotImplementedException()

    }

}

class ClassWithoutClosure {

    def outer() {

        this.inner('foo')

    }



    private def inner(arg) {

        throw new NotImplementedException()

    }

}



class ParameterizedTestsForPostAlways extends GroovyTestCase {

    @Test

    void testWithClosure() {

        def mock = new MockFor(ClassWithClosure)

        mock.ignore('outer')

        def res = 

        mock.demand.inner {a -> res.add(a)}



        mock.use {

            def instance = new ClassWithClosure()



            def closure = instance.outer()

            closure()

        }

        assert res == ["foo"]

    }

    @Test

    void testWithoutClosure() {



        def mock = new MockFor(ClassWithoutClosure)

        mock.ignore('outer')

        def res = 

        mock.demand.inner {a -> res.add(a)}



        mock.use {

            def instance = new ClassWithoutClosure()



            instance.outer()

        }

        assert res == ["foo"]

    }



    @Test

    void testOverrideWithoutClosure() {

        ClassWithoutClosure inst = new ClassWithoutClosure()

        def res = 

        inst.metaClass.inner = {a -> res.add(a)}

        inst.outer()

        assert res == ['foo']

    }

}