Verificare che tutti i metodi getter siano chiamati

Question

Ho il seguente test in cui ho bisogno di verificare che tutti i getter della classe Person vengano chiamati. Finora ho usato mockito's verify() per assicurarmi che ogni getter venga chiamato. C'è un modo per farlo con la riflessione? Può succedere che un nuovo getter venga aggiunto alla classe Person ma il test mancherà questo.

public class GetterTest { 
    class Person{ 

     private String firstname; 
     private String lastname; 

     public String getFirstname() { 
      return firstname; 
     } 

     public String getLastname() { 
      return lastname; 
     } 
    } 

    @Test 
    public void testAllGettersCalled() throws IntrospectionException{ 
     Person personMock = mock(Person.class); 
     personMock.getFirstname(); 
     personMock.getLastname(); 

     for(PropertyDescriptor property : Introspector.getBeanInfo(Person.class).getPropertyDescriptors()) { 
      verify(personMock, atLeast(1)).getFirstname(); 
      //**How to verify against any getter method and not just getFirstName()???** 
     } 
    } 
} 

Answer 1

In generale, non deridere la classe in prova . Se il test è per una persona, non dovresti mai vedere Mockito.mock(Person.class) al suo interno, poiché è un chiaro segno che stai testando il framework di simulazione anziché il sistema sotto test.

Invece, è possibile creare uno spy(new Person()), che creerà un'implementazione di Persona reale utilizzando un vero costruttore e quindi copierà i suoi dati su un proxy generato da Mockito. È possibile utilizzare MockingDetails.getInvocations() per verificare in modo riflessivo che sia stato chiamato ogni agente.

// This code is untested, but should get the point across. Edits welcome. 
// 2016-01-20: Integrated feedback from Georgios Stathis. Thanks Georgios! 

@Test 
public void callAllGetters() throws Exception { 
    Person personSpy = spy(new Person()); 
    personSpy.getFirstname(); 
    personSpy.getLastname(); 

    assertAllGettersCalled(personSpy, Person.class); 
} 

private static void assertAllGettersCalled(Object spy, Class<?> clazz) { 
    BeanInfo beanInfo = Introspector.getBeanInfo(clazz); 
    Set<Method> setOfDescriptors = beanInfo.getPropertyDescriptors() 
     .stream() 
     .map(PropertyDescriptor::getReadMethod) 
     .filter(p -> !p.getName().contains("getClass")) 
     .collect(Collectors.toSet()); 
    MockingDetails details = Mockito.mockingDetails(spy); 
    Set<Method> setOfTestedMethods = details.getInvocations() 
     .stream() 
     .map(InvocationOnMock::getMethod) 
     .collect(Collectors.toSet()); 
    setOfDescriptors.removeAll(setOfTestedMethods); 
    // The only remaining descriptors are untested. 
    assertThat(setOfDescriptors).isEmpty(); 
} 

Ci potrebbe essere un modo per chiamare verify e invoke sulla spia Mockito generati, ma che sembra molto fragile, e molto dipende da interni Mockito.

Per inciso, testare i getter in stile bean sembra uno strano uso di tempo/sforzo. In generale, concentrarsi sulle implementazioni di test che potrebbero cambiare o rompersi.

Answer 2

Mi vengono in mente due soluzioni per il vostro problema:

1. generare il codice Builder a livello di codice, quindi non è necessario eseguire i test. Il codice Java è generato da un programma e mai modificato da un utente. Prova invece il generatore. Utilizzare un modello di testo e creare definizioni da un modello di dominio serializzato o direttamente da classi compilate Java (è necessario un modulo separato dipendente da quello del bean)

2. Scrivere i test su una libreria proxy. Il problema è che i proxy regolari possono solo implementare interfacce, non classi regolari, ed è molto complicato avere interfacce per Javabeans. Se scegli questa strada, andrei con Javassist. Ho codificato un campione eseguibile e lo metto on GitHub. I casi di test usano una fabbrica di proxy per istanziare i fagioli (invece di utilizzare new)

public class CountingCallsProxyFactory { 

    public <T> T proxy(Class<T> classToProxy) { 
     ProxyFactory factory = new ProxyFactory(); 
     factory.setSuperclass(classToProxy); 
     Class clazz = factory.createClass(); 
     T instance = (T) clazz.newInstance(); 
     ProxyObject proxy = (ProxyObject) instance; 
     MethodCallCounter handler = new MethodCallCounter(); 
     proxy.setHandler(handler); 
     return instance; 
    } 

    public void verifyAllGettersCalled(Object bean) { 
     // Query the counter against the properties in the bean 
    } 
} 

Il contatore viene mantenuto all'interno della classe MethodCallCounter