Invocazione di un metodo privato tramite JMockit per verificare il risultato

Question

Sto usando JMockit 1.1 e tutto ciò che voglio fare è richiamare un metodo privato e testare il valore restituito. Tuttavia, ho difficoltà a capire esattamente come farlo dall'esempio JMockit De-Encapsulation.

Il metodo che sto cercando di testare è il metodo privato in questa classe:

public class StringToTransaction { 
    private List<String> parseTransactionString(final String input) { 
     // .. processing 
     return resultList; 
    } 
} 

E il mio codice di prova è inferiore.

@Test 
public void testParsingForCommas() { 
    final StringToTransaction tested = new StringToTransaction(); 
    final List<String> expected = new ArrayList<String>(); 
    // Add expected strings list here.. 
    new Expectations() { 
     { 
     invoke(tested, "parseTransactionString", "blah blah"); 
     returns(expected); 
     } 
    }; 
} 

E l'errore che sto ottenendo è:

java.lang.IllegalStateException: Missing invocation to mocked type at this point; please make sure such invocations appear only after the declaration of a suitable mock field or parameter

Forse mi hanno frainteso l'intera API qui, perché non credo di voler deridere la classe .. basta verificare il risultato di chiamando il metodo privato.

Answer 1

Penso che lo stiate facendo troppo complicato. Non dovresti usare affatto il blocco Expectations. Tutto quello che devi fare è qualcosa di simile:

@Test 
public void testParsingForCommas() { 
    StringToTransaction tested = new StringToTransaction(); 
    List<String> expected = new ArrayList<String>(); 
    // Add expected strings list here.. 

    List<String> actual = Deencapsulation.invoke(tested, "parseTransactionString", "blah blah"); 
    assertEquals(expected, actual); 
} 

In sostanza, chiamare un metodo privato tramite Deencapsulation e test che il reale è uguale al previsto. Proprio come faresti se il metodo fosse pubblico. Non si sta facendo il mocking, quindi non è necessario alcun blocco di Expectations.

Answer 2

Perché si desidera testare direttamente il metodo privato? La maggior parte delle volte i metodi API, ad esempio i metodi di interfaccia pubblica, sono testati come , i metodi privati ​​verranno testati indirettamente anche con lo. È possibile inserire le istruzioni di asserzione con i valori previsti dai metodi privati ​​ in cui li si chiama nei metodi pubblici. Quindi, se l'affermazione fallisce, sei sicuro che ci sia qualche problema con il metodo privato. Quindi non è necessario testarlo separatamente.

Answer 3

A questo punto, non so se JMockit può o deve essere utilizzato per questo. Il test del mio metodo privato può essere fatto con una semplice riflessione vecchia, anche se ho iniziato questo esercizio per conoscere JMockit (e testare il mio codice). Nel caso in cui JMockit non possa essere usato per questo, ecco come posso usare la riflessione.

@Test 
public void testParsingForCommas() throws Exception { 
    StringToTransaction tested = new StringToTransaction(); 
    ArrayList<String> expected = new ArrayList<>(); 
    expected.add("Test"); 

    Method declaredMethod = 
     tested.getClass().getDeclaredMethod("parseTransactionString", 
       String.class); 
    declaredMethod.setAccessible(true); 
    Object actual = declaredMethod.invoke(tested, "blah blah"); 
    assertEquals(expected, actual); 
} 

La chiamata a setAccessible(true) è importante qui o la invoke farà saltare in aria quando si chiama un metodo privato.

declaredMethod.setAccessible(true); 

Ma vuoi sapere cosa è veramente bello? Se non chiami setAccessible(true), esploderà con un java.lang.StackOverflowError! :)