I can also reproduce this at Mac OS x with Groovy Version: 1.6.3 and JVM: 1.6.0_13 installed

Adding repro steps for java classes.
//--------------------------------------------
// REPRO 2: Override a java class instance...should work, and does
//--------------------------------------------

#JavaClass.java
public class JavaClass
{
    public Object doSomething(Object o)
    {
        throw new IllegalStateException( "This method should be overriden");
    }
}

#MyScript.groovy
class Dog
{
    String name;
}

JavaClass jc = new JavaClass();
jc.metaClass.doSomething = { Object o ->
    println o;
    return o;
}
def dog = new Dog().name="fido";
assert(jc.doSomething(dog).equals(dog));

//--------------------------------------------
// REPRO 3: Override a java class instance
// based on an interface...this does not work
//--------------------------------------------

#IWorker.java
public interface IWorker
{
    public Object doSomething(Object o);
}

#LazyWorker.java
public class LazyWorker implements IWorker
{
    @Override
    public Object doSomething( final Object o )
    {
        throw new IllegalStateException( "should be overridden");
    }
}

#MyScript.groovy
IWorker lw = new LazyWorker();
lw.metaClass.doSomething = { Object o ->
    println o;
    return o;
}

assert(lw.doSomething(dog).equals(dog));

ERROR:
The metaClass override is ignored, and the IllegalStateException from the original impl is used.

Checking into the code which causes this (around line 377 of MetaMethodIndex.java) there was special handling put in (and then tweaked) to not overwrite interface methods with instance methods in certain circumstances - e.g. to stop wierd behavior when proxies are in play. Having said that, I am not convinced that the corrent behavior is what we really want. A related issue in the past is GROOVY-2391.

I have gotten this test case to pass by modifying lines 376 and 377 of MetaMethodIndex.java to the following:

if (match.isPrivate()
  || (!isNonRealMethod(match) && match.getDeclaringClass().isInterface() && !method.getDeclaringClass().isInterface() && !(method instanceof ClosureMetaMethod))) {

I am not entirely sure what other side effects this will have, but for me, it appears to work in the simple case.

I'm assigning this issue as I think it has enough votes and is serious enough to warrant looking at

It'd also have to handle ClosureStaticMetaMethod.

What is the status of this bug?
Is still present in 1.8.4

Bug still present in 2.0.1

This passes in the console:

interface IFoo

class IFooImpl implements IFoo { int foo()

}
IFoo.metaClass.foo =

// changing to IFooImpl.metaClass fails
assert new IFooImpl().foo() == 2

In the meantime, what is the recommended way to mock methods in classes that implement and interface.
Like in the given example how do we mock doIt so that we may test another methods that uses it ?
I naively thought that using MockFor would get rid of the problem, but I get the same behavior.

Would also appreciate a recommended workaround.

Workaround to override interface methods via metaclass. Similar to what toddg reported back in 2009. Here's a working example that can be used to workaround this. Note that this modifies the class rather than a specific instance, which the original reporter was trying to do.

metaclass modification BEFORE construction:

interface I {
    def doIt()
}

class T implements I {
    def doIt() { true }
}

I.metaClass.doIt = { -> false }
T t = new T()
assert !t.doIt()

metaclass modification AFTER construction:

interface I {
    def doIt()
}

class T implements I {
    def doIt() { true }
}

T t = new T()
// Removing either of the following two lines breaks this
I.metaClass.doIt = { -> false }
t.metaClass.doIt = { -> false }
assert !t.doIt()

Will this issue be worked on?

The assignment of Closures to methods of object instances defined in Groovy provides a very useful and simple tool for mocking in our application - Java app with Groovy extensions. Most (if not all) our Groovy implement a Java interface. The desired solution is what's described - override only the object instance. This provides the ability to create multiple instances of the same class with control over which object instances have overridden methods. Reseting the method to its original state is straightforward - object.metaclass = null.

However, the workaround overrides the class definition - not desirable, because it's more permanent. Every instance of the class has an overridden method - not specific instances. Also, I cannot figure out how to reset the class definition to it's original state (reset).