Come simulare il metodo protetto di sottoclasse ereditato dalla classe astratta?

Question

Come utilizzare Mockito o PowerMock per simulare un metodo protetto realizzato da una sottoclasse, ma ereditato da una super classe astratta?

In altre parole, voglio testare il metodo "doSomething" mentre sto prendendo in giro "doSomethingElse".

astratta super-classe

public abstract class TypeA { 

    public void doSomething() {  

     // Calls for subclass behavior 
     doSomethingElse();  
    } 

    protected abstract String doSomethingElse(); 

} 

implementazione di sottoclasse

public class TypeB extends TypeA { 

    @Override 
    protected String doSomethingElse() { 
     return "this method needs to be mocked"; 
    } 

} 

Solution

risposte qui riportati sono corretti un d funzionerà se le classi coinvolte sono nello stesso pacchetto.

Ma se pacchetti diversi sono coinvolti, un'opzione è per l'utente PowerMock. Il seguente esempio ha funzionato per me. Naturalmente ci potrebbero essere altri modi per farlo, questo è quello che funziona.

import static org.junit.Assert.assertEquals; 
import org.junit.Test; 
import org.junit.runner.RunWith; 
import org.powermock.api.mockito.PowerMockito; 
import org.powermock.core.classloader.annotations.PrepareForTest; 
import org.powermock.modules.junit4.PowerMockRunner; 

@RunWith(PowerMockRunner.class) 
@PrepareForTest({ TypeB.class }) 
public class TestAbstract { 

    @Test 
    public void test_UsingPowerMock() throws Exception { 
     // Spy a subclass using PowerMock 
     TypeB b = PowerMockito.spy(new TypeB()); 
     String expected = "some value for mock"; 

     // Mock a method by its name using PowerMock again 
     PowerMockito.doReturn(expected).when(b, "doSomethingElse"); 

     // Calls the 
     String actual = b.doSomething(); 
     assertEquals(expected, actual);  

    } 
} 

Nota: Prove eseguite usando Java 5, JUnit 4.11, Mockito 1.9.0 e 1.4.12 PowerMock.

Answer 1

È possibile utilizzare Mockito.CALLS_REAL_METHODS quando beffardo il metodo astratto. Questo chiamerà i metodi originali della classe e potrai prendere in giro tutti i metodi astratti da solo.

TypeA typeA = mock(TypeA.class, Mockito.CALLS_REAL_METHODS); 
when(typeA.doSomethingElse()).thenReturn("Hello"); 
typeA.doSomething(); 

Oppure si prova direttamente sul TypeB con una spia:

TypeB typeB = spy(new TypeB()); 
when(typeB.doSomethingElse()).thenReturn("Hello"); 
typeB.doSomething(); 

Answer 2

È possibile verificare la classe abtract utilizzando Mockito nel seguente modo

TypeA typA = Mockito.mock(TypeA.class, Mockito.CALLS_REAL_METHODS); 
when(typA.doSomethingElse()).thenReturn("doSomethingElse"); 
Assert.assertSomething(typeA.doSomething()); 

Answer 3

Io suggerisco di usare Mockito per questo:

// Create a new Mock 
final TypeA a = Mockito.mock(TypeA.class, Mockito.CALLS_REAL_METHODS); 

// Call the method 
a.doSomething(); 

// Now verify that our mocked class' method was called 
Mockito.verify(a, Mockito.times(1)).doSomethingElse(); 

Answer 4

a metodi finta che restituisce vuoto in classi astratte abbiamo potuto usare:

MyAbstractClass abs = Mockito.mock(MyAbstractClass.class); 
Mockito.doNothing().when(abs).myMethod(arg1,arg2....)); 

possiamo sostituire gli argomenti con Mockito.anyString() ecc secondo i requisiti.