Zombando de variáveis ​​de membro de uma classe usando o Mockito

Sou novato no desenvolvimento e nos testes de unidade em particular. Eu acho que meu requisito é bastante simples, mas estou interessado em saber o que os outros pensam sobre isso.

Suponha que eu tenha duas classes assim -

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 estou escrevendo teste de unidade para testar o First.doSecond()método. No entanto, suponha, eu quero a Second.doSecond()classe Mock assim. Estou usando o Mockito para fazer isso.

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

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

Estou vendo que a zombaria não entra em vigor e a afirmação falha. Não há como zombar das variáveis ​​de membro de uma classe que eu quero testar. ?

Você precisa fornecer uma maneira de acessar as variáveis ​​de membro para poder passar de forma fictícia (as formas mais comuns seriam um método setter ou um construtor que aceita um parâmetro).

Se o seu código não fornecer uma maneira de fazer isso, ele será fatorado incorretamente no TDD (Test Driven Development).

Isso não é possível se você não puder alterar seu código. Mas eu gosto de injeção de dependência e o Mockito suporta:

public class First {    
    @Resource
    Second second;

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

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

Seu teste:

@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());
   }
}

Isso é muito agradável e fácil.

Se você olhar atentamente para o seu código, verá que a secondpropriedade em seu teste ainda é uma instância Second, não uma simulação (você não passa a simulação firstno seu código).

A maneira mais simples seria criar um setter para seconda Firstclasse e passá-lo o mock explicitamente.

Como isso:

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());
}

Outra seria passar uma Secondinstância como Firstparâmetro construtor.

Se você não pode modificar o código, acho que a única opção seria usar a reflexão:

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());
}

Mas você provavelmente pode, pois é raro fazer testes no código que você não controla (embora se possa imaginar um cenário em que você precise testar uma biblioteca externa porque o autor não fez :))

Se você não pode alterar a variável de membro, o contrário é usar o powerMockit e chamar

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

Agora, o problema é que QUALQUER chamada para o novo Second retornará a mesma instância simulada. Mas no seu caso simples, isso funcionará.

Eu tive o mesmo problema em que um valor privado não foi definido porque o Mockito não chama super construtores. Aqui está como eu aumento a zombaria com a reflexão.

Primeiro, criei uma classe TestUtils que contém muitos utilitários úteis, incluindo esses métodos de reflexão. O acesso à reflexão é um pouco complicado de implementar a cada vez. Criei esses métodos para testar o código em projetos que, por um motivo ou outro, não tinham pacote de simulação e não fui convidado a incluí-lo.

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);
        }
    }

}

Então eu posso testar a classe com uma variável privada como esta. Isso é útil para zombar das árvores de classe que você não tem controle também.

@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
}

Modifiquei meu código do meu projeto atual aqui, na página. Pode haver um problema de compilação ou dois. Eu acho que você entendeu a ideia geral. Sinta-se livre para pegar o código e usá-lo, se achar útil.

Muitas pessoas já o aconselharam a repensar seu código para torná-lo mais testável - bons conselhos e geralmente mais simples do que o que estou prestes a sugerir.

Se você não pode alterar o código para torná-lo mais testável, PowerMock: https://code.google.com/p/powermock/

O PowerMock estende o Mockito (para que você não precise aprender uma nova estrutura simulada), fornecendo funcionalidade adicional. Isso inclui a capacidade de um construtor retornar um mock. Poderoso, mas um pouco complicado - portanto, use-o criteriosamente.

Você usa um corredor de simulação diferente. E você precisa preparar a classe que irá invocar o construtor. (Observe que essa é uma pegadinha comum - prepare a classe que chama o construtor, não a classe construída)

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

Em sua configuração de teste, você pode usar o método whenNew para que o construtor retorne uma simulação

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

Sim, isso pode ser feito, como mostra o seguinte teste (escrito com a API de simulação do JMockit, que eu desenvolvo):

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

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

Com o Mockito, no entanto, esse teste não pode ser gravado. Isso ocorre devido à maneira como o mocking é implementado no Mockito, onde é criada uma subclasse da classe a ser mocked; somente instâncias dessa subclasse "mock" podem ter comportamento simulado, portanto, é necessário que o código testado as use em vez de qualquer outra instância.

Se você deseja uma alternativa ao ReflectionTestUtils da Spring no mockito, use

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