Burlándose de las variables miembro de una clase usando Mockito

Soy un novato en desarrollo y en pruebas unitarias en particular. Supongo que mi requisito es bastante simple, pero estoy ansioso por saber qué piensan los demás sobre esto.

Supongamos que tengo dos clases así:

public class First {

    Second second ;

    public First(){
        second = new Second();
    }

    public String doSecond(){
        return second.doSecond();
    }
}

class Second {

    public String doSecond(){
        return "Do Something";
    }
}

Digamos que estoy escribiendo prueba unitaria para probar el First.doSecond()método. Sin embargo, supongamos que quiero burlarme de la Second.doSecond()clase así. Estoy usando Mockito para hacer esto.

public void testFirst(){
    Second sec = mock(Second.class);
    when(sec.doSecond()).thenReturn("Stubbed Second");

    First first = new First();
    assertEquals("Stubbed Second", first.doSecond());
}

Estoy viendo que la burla no tiene efecto y la afirmación falla. ¿No hay forma de burlarse de las variables miembro de una clase que quiero probar? ?

Debe proporcionar una forma de acceder a las variables miembro para poder pasar de manera simulada (las formas más comunes serían un método de establecimiento o un constructor que toma un parámetro).

Si su código no proporciona una forma de hacerlo, está incorrectamente factorizado para TDD (Test Driven Development).

Esto no es posible si no puede cambiar su código. Pero me gusta la inyección de dependencia y Mockito lo admite:

public class First {    
    @Resource
    Second second;

    public First() {
        second = new Second();
    }

    public String doSecond() {
        return second.doSecond();
    }
}

Su prueba:

@RunWith(MockitoJUnitRunner.class)
public class YourTest {
   @Mock
   Second second;

   @InjectMocks
   First first = new First();

   public void testFirst(){
      when(second.doSecond()).thenReturn("Stubbed Second");
      assertEquals("Stubbed Second", first.doSecond());
   }
}

Esto es muy lindo y fácil.

Si observa detenidamente su código, verá que la secondpropiedad en su prueba sigue siendo una instancia Second, no un simulacro (no pasa el simulacro firsten su código).

La forma más sencilla sería crear un setter seconden Firstclase y pasarle el simulacro explícitamente.

Me gusta esto:

public class First {

Second second ;

public First(){
    second = new Second();
}

public String doSecond(){
    return second.doSecond();
}

    public void setSecond(Second second) {
    this.second = second;
    }


}

class Second {

public String doSecond(){
    return "Do Something";
}
}

....

public void testFirst(){
Second sec = mock(Second.class);
when(sec.doSecond()).thenReturn("Stubbed Second");


First first = new First();
first.setSecond(sec)
assertEquals("Stubbed Second", first.doSecond());
}

Otra sería pasar una Secondinstancia como Firstparámetro constructor.

Si no puede modificar el código, creo que la única opción sería usar la reflexión:

public void testFirst(){
    Second sec = mock(Second.class);
    when(sec.doSecond()).thenReturn("Stubbed Second");


    First first = new First();
    Field privateField = PrivateObject.class.
        getDeclaredField("second");

    privateField.setAccessible(true);

    privateField.set(first, sec);

    assertEquals("Stubbed Second", first.doSecond());
}

Pero probablemente pueda, ya que es raro hacer pruebas en el código que no controla (aunque uno puede imaginar un escenario en el que tiene que probar una biblioteca externa porque su autor no lo hizo :))

Si no puede cambiar la variable miembro, al revés, use powerMockit y llame

Second second = mock(Second.class)
when(second.doSecond()).thenReturn("Stubbed Second");
whenNew(Second.class).withAnyArguments.thenReturn(second);

Ahora el problema es que CUALQUIER llamada al nuevo Segundo devolverá la misma instancia simulada. Pero en su caso simple esto funcionará.

Tuve el mismo problema donde no se estableció un valor privado porque Mockito no llama a superconstructores. Así es como aumento la burla con la reflexión.

Primero, creé una clase TestUtils que contiene muchas utilidades útiles, incluidos estos métodos de reflexión. El acceso a la reflexión es un poco difícil de implementar cada vez. Creé estos métodos para probar el código en proyectos que, por una razón u otra, no tenían un paquete de simulación y no me invitaron a incluirlo.

public class TestUtils {
    // get a static class value
    public static Object reflectValue(Class<?> classToReflect, String fieldNameValueToFetch) {
        try {
            Field reflectField  = reflectField(classToReflect, fieldNameValueToFetch);
            reflectField.setAccessible(true);
            Object reflectValue = reflectField.get(classToReflect);
            return reflectValue;
        } catch (Exception e) {
            fail("Failed to reflect "+fieldNameValueToFetch);
        }
        return null;
    }
    // get an instance value
    public static Object reflectValue(Object objToReflect, String fieldNameValueToFetch) {
        try {
            Field reflectField  = reflectField(objToReflect.getClass(), fieldNameValueToFetch);
            Object reflectValue = reflectField.get(objToReflect);
            return reflectValue;
        } catch (Exception e) {
            fail("Failed to reflect "+fieldNameValueToFetch);
        }
        return null;
    }
    // find a field in the class tree
    public static Field reflectField(Class<?> classToReflect, String fieldNameValueToFetch) {
        try {
            Field reflectField = null;
            Class<?> classForReflect = classToReflect;
            do {
                try {
                    reflectField = classForReflect.getDeclaredField(fieldNameValueToFetch);
                } catch (NoSuchFieldException e) {
                    classForReflect = classForReflect.getSuperclass();
                }
            } while (reflectField==null || classForReflect==null);
            reflectField.setAccessible(true);
            return reflectField;
        } catch (Exception e) {
            fail("Failed to reflect "+fieldNameValueToFetch +" from "+ classToReflect);
        }
        return null;
    }
    // set a value with no setter
    public static void refectSetValue(Object objToReflect, String fieldNameToSet, Object valueToSet) {
        try {
            Field reflectField  = reflectField(objToReflect.getClass(), fieldNameToSet);
            reflectField.set(objToReflect, valueToSet);
        } catch (Exception e) {
            fail("Failed to reflectively set "+ fieldNameToSet +"="+ valueToSet);
        }
    }

}

Entonces puedo probar la clase con una variable privada como esta. Esto es útil para burlarse de los árboles profundos de la clase que tampoco tienes control.

@Test
public void testWithRectiveMock() throws Exception {
    // mock the base class using Mockito
    ClassToMock mock = Mockito.mock(ClassToMock.class);
    TestUtils.refectSetValue(mock, "privateVariable", "newValue");
    // and this does not prevent normal mocking
    Mockito.when(mock.somthingElse()).thenReturn("anotherThing");
    // ... then do your asserts
}

Modifiqué mi código de mi proyecto real aquí, en la página. Podría haber un problema de compilación o dos. Creo que entiendes la idea general. Siéntase libre de tomar el código y usarlo si lo encuentra útil.

Muchos otros ya te han aconsejado que reconsideres tu código para hacerlo más comprobable, un buen consejo y, por lo general, más simple de lo que voy a sugerir.

Si no puede cambiar el código para hacerlo más comprobable, PowerMock: https://code.google.com/p/powermock/

PowerMock extiende Mockito (para que no tenga que aprender un nuevo marco simulado), proporcionando funcionalidad adicional. Esto incluye la posibilidad de que un constructor devuelva un simulacro. Potente, pero un poco complicado, así que úsalo juiciosamente.

Utiliza un corredor simulado diferente. Y debe preparar la clase que va a invocar al constructor. (Tenga en cuenta que este es un problema común: prepare la clase que llama al constructor, no la clase construida)

@RunWith(PowerMockRunner.class)
@PrepareForTest({First.class})

Luego, en su configuración de prueba, puede usar el método whenNew para que el constructor devuelva un simulacro

whenNew(Second.class).withAnyArguments().thenReturn(mock(Second.class));

Sí, esto se puede hacer, como muestra la siguiente prueba (escrito con la API de burla de JMockit, que desarrollo):

@Test
public void testFirst(@Mocked final Second sec) {
    new NonStrictExpectations() {{ sec.doSecond(); result = "Stubbed Second"; }};

    First first = new First();
    assertEquals("Stubbed Second", first.doSecond());
}

Con Mockito, sin embargo, tal prueba no se puede escribir. Esto se debe a la forma en que se implementa la burla en Mockito, donde se crea una subclase de la clase a burlarse; solo las instancias de esta subclase "simulada" pueden tener un comportamiento simulado, por lo que debe hacer que el código probado las use en lugar de cualquier otra instancia.

Si desea una alternativa a ReflectionTestUtils de Spring en mockito, use

Whitebox.setInternalState(first, "second", sec);