Invocaciones del método de conteo en Pruebas unitarias

Question

¿Cuál es la mejor manera de contar las invocaciones de métodos en una Prueba Unitaria? ¿Alguno de los marcos de prueba lo permiten?

Answer 1

usted tiene un par de opciones

1) Añadir un código especial que cuenta invocaciones en la función. Funcionará, pero no es una gran solución.

2) Después de ejecutar las pruebas de su unidad, verifique la cobertura del código. La mayoría de las herramientas de cobertura contarán las invocaciones, pero están realmente diseñadas para el procesamiento posterior.

3) Utilice un perfilador. Un generador de perfiles le permitirá contar cuántas veces se invoca una función. Este es un proceso muy manual, por lo que no está diseñado para pruebas unitarias.

Una mejor solución sería comprobar que la salida es lo que espera en lugar de comprobar cómo funciona internamente.

Answer 2

Parece que es posible que desee un test spy. Ver, por ejemplo, Mockito.spy().

Answer 3

Dependiendo de cuáles son los métodos que desea contar, puede crear una configuración de prueba, con un consejo @Before que coincidan con su clase/paquete/método:

import org.aspectj.lang.annotation.Aspect; 
import org.aspectj.lang.annotation.Before; 
import org.aspectj.lang.annotation.Pointcut; 

@Aspect 
public class MethodCounterAspect { 

    private int counter = 0 // or inject the Counter object into this aspect 

    @Pointcut("execution(* com.sample.your.package.*.*(..))") 
    public void methodsToCount() {} 

    @Before("methodsToCount()") 
    public void execute() throws Throwable { 
     counter++; // or update the counter injected into this aspect.. 
    } 

    // get the counter 
} 

Puede utilizar la vainilla AspectJ o primavera AOP a través encima o Configuraciones XML si lo encuentras más fácil.

Puede crear diferentes puntos de corte/aspecto si es necesario.

Answer 4

Parece que es posible que desee utilizar los métodos .expects (1) que suelen proporcionar los frameworks de prueba.

Usando Mockito, si estuviera probando una lista y quería comprobar que claro se llama 3 veces y añada fue llamado al menos una vez con estos parámetros hace lo siguiente:

List mock = mock(List.class);   

someCodeThatInteractsWithMock();     

verify(mock, times(3)).clear(); 
verify(mock, atLeastOnce()).add(anyObject());  

(De http://code.google.com/p/mockito/wiki/MockitoVSEasyMock)

Answer 5

Puede contar el número de invocación de método utilizando la interfaz Respuesta en Mockito.

ConnectionPool mockedConnectionPool = mock(ConnectionPool.class); 

    final int[] counter = new int[1]; 

    when(mockedConnectionPool.getConnection()).then(new Answer<Connection>() { 

     @Override 
     public Connection answer(InvocationOnMock invocation) throws Throwable { 
      counter[0]++; 
      return conn; 
     } 

    }); 
    // some your code 

    assertTrue(counter[0] == 1); 

Answer 6

En Mockito se puede hacer algo como esto:

YourService serviceMock = Mockito.mock(YourService.class); 

// code using YourService 

// details of all invocations including methods and arguments 
Collection<Invocation> invocations = Mockito.mockingDetails(serviceMock).getInvocations(); 
// just a number of calls of any mock's methods 
int numberOfCalls = invocations.size(); 

Answer 7

Dado un "RoleRepository" ejemplo de la clase con un único método "getRole (usuario String)", que devolvería un papel.

Suponiendo que ha declarado este objeto como Mock o Spy y desea comprobar si se llama al método getRole (String) una vez.

Se podría hacer algo como: Mockito.verify(roleRepository, Mockito.times(1)).getRole(Mockito.anyString());

import org.junit.Test; 
import org.junit.runner.RunWith; 
import org.mockito.Mockito; 
import org.mockito.Spy; 
import org.mockito.junit.MockitoJUnitRunner; 

@RunWith(MockitoJUnitRunner.class) 
public class RoleRepositoryTest { 

    @Spy 
    private RoleRepository roleRepository = new RoleRepository(); 

    @Test 
    public void test() { 
     roleRepository.getRole("toto"); 
     Mockito.verify(roleRepository, Mockito.times(1)).getRole(Mockito.anyString()); 
    } 

    public static class RoleRepository { 

     public String getRole(String user) { 
      return "MyRole"; 
     } 
    } 
}