Se moquant de lecture / définition de la méthode de l'Interface avec Mockito

Je suis en train de tester mon application avec jUnit et Mockito et je suis en cours d'exécution dans des problèmes. Voici un exemple simplifié qui explique le problème

Interface KeyValueInterface

public interface KeyValueInterface {

    public abstract String getKey();

    public abstract void setKey(String key);

    public abstract String getValue();

    public abstract void setValue(String value);

}

Classe KeyValueImpl

public class KeyValueImpl implements KeyValueInterface {

    private String key;
    private String value;

    @Override
    public String getKey() {
        return key;
    }

    @Override
    public void setKey(String key) {
        this.key = key;
    }

    @Override
    public String getValue() {
        return value;
    }

    @Override
    public void setValue(String value) {
        this.value = value;
    }

}

Classe avec "logique d'entreprise"

public class ValueFinder {

    public KeyValueInterface findValueForKey(KeyValueInterface keyValue){
        keyValue.setValue("foo");
        return keyValue;
    }

}

de la classe de Test jUnit

import static org.junit.Assert.*;

import org.junit.Test;
import org.mockito.Mockito;

public class ValueFinderTest {

    @Test
    public void testNotMocked() {
        KeyValueInterface keyValue = new KeyValueImpl();
        keyValue = (new ValueFinder()).findValueForKey(keyValue);
        assertEquals("foo", keyValue.getValue()); //works fine
    }

    @Test
    public void testMocked1() {
        KeyValueInterface keyValue = Mockito.mock(KeyValueInterface.class);
        keyValue = (new ValueFinder()).findValueForKey(keyValue);
        assertEquals("foo", keyValue.getValue()); //java.lang.AssertionError:
                                                    //expected:<foo> but
                                                    //was:<null>

    }

    @Test
    public void testMocked2() {
        KeyValueInterface keyValue = Mockito.mock(KeyValueInterface.class);
        keyValue = (new ValueFinder()).findValueForKey(keyValue);
        Mockito.when(keyValue.getValue()).thenCallRealMethod();
        Mockito.doCallRealMethod().when(keyValue).setValue(Mockito.any(String.class));
        assertEquals("foo", keyValue.getValue()); //org.mockito.exceptions.base.MockitoException:
                                                    //Cannot call real method
                                                    //on java interface.
                                                    //Interface does not have
                                                    //any implementation!
                                                    //Calling real methods is
                                                    //only possible when
                                                    //mocking concrete classes.

    }

}

Mon problème est que j'ai besoin pour se moquer de KeyValue pour des raisons techniques qui sont hors de mon contrôle. Donc je ne peux pas juste aller avec la méthode testNotMocked(). Également pour des raisons techniques indépendantes de ma volonté, j'ai de se moquer de l'interface (et non pas la classe).

Est-il un moyen pour y parvenir?

Merci beaucoup.