Teste de método privado usando mockito

public class A {

    método public void (boolean b) {
          if (b == true)
               Método 1();
          outro
               método2 ();
    }

    private void method1 () {}
    método void privado2 () {}
}

public class TestA {

    @Teste
    public void testMethod () {
      A a = simulação (classe A.);
      a.method (true);
      // como testar como verify (a) .method1 ();
    }
}

Como testar o método privado é chamado ou não, e como testar o método privado usando mockito ???

Você não pode fazer isso com o Mockito, mas pode usar o Powermock para estender o Mockito e simular métodos privados. Powermock suporta Mockito. Aqui está um exemplo.

Não é possível através do mockito. De seu wiki

Por que Mockito não zomba de métodos privados?

Em primeiro lugar, não somos dogmáticos quanto a zombar de métodos privados. Nós simplesmente não nos importamos com métodos privados porque do ponto de vista de teste, métodos privados não existem. Aqui estão alguns motivos pelos quais o Mockito não zomba de métodos privados:

Exige hackeamento de carregadores de classe que nunca é à prova de bala e muda a API (você deve usar o executor de teste personalizado, anotar a classe, etc.).

É muito fácil contornar isso - basta alterar a visibilidade do método de privado para protegido por pacote (ou protegido).

Requer que eu gaste tempo implementando e mantendo-o. E não faz sentido dado o ponto # 2 e o fato de já estar implementado em outra ferramenta (powermock).

Finalmente ... Zombar de métodos privados é uma dica de que há algo errado com o entendimento OO. Em OO, você deseja que objetos (ou funções) colaborem, não métodos. Esqueça o código pascal e procedural. Pense em objetos.

Aqui está um pequeno exemplo de como fazer isso com o powermock

public class Hello {
    private Hello obj;
    private Integer method1(Long id) {
        return id + 10;
    }
} 

Para testar o método 1, use o código:

Hello testObj = new Hello();
Integer result = Whitebox.invokeMethod(testObj, "method1", new Long(10L));

Para definir objeto particular obj usar este:

Hello testObj = new Hello();
Hello newObject = new Hello();
Whitebox.setInternalState(testObj, "obj", newObject);

Pense nisso em termos de comportamento, não em termos dos métodos que existem. O método chamado methodtem um comportamento particular se bfor verdadeiro. Ele tem um comportamento diferente se bfor falso. Isso significa que você deve escrever dois testes diferentes para method; um para cada caso. Portanto, em vez de ter três testes orientados a método (um para method, um para method1, um para method2, você tem dois testes orientados para o comportamento.

Relacionado a isso (eu sugeri isso em outro tópico do SO recentemente e fui chamado de uma palavra de quatro letras como resultado, então sinta-se à vontade para aceitar isso com um grão de sal); Acho útil escolher nomes de teste que reflitam o comportamento que estou testando, em vez do nome do método. Portanto, não chamar seus testes testMethod(), testMethod1(), testMethod2()e assim por diante. Gosto de nomes como calculatedPriceIsBasePricePlusTax()ou taxIsExcludedWhenExcludeIsTrue()que indicam o comportamento que estou testando; em seguida, em cada método de teste, teste apenas o comportamento indicado. A maioria desses comportamentos envolverá apenas uma chamada para um método público, mas pode envolver muitas chamadas para métodos privados.

Espero que isto ajude.

Embora o Mockito não forneça esse recurso, você pode obter o mesmo resultado usando Mockito + a classe JUnit ReflectionUtils ou a classe Spring ReflectionTestUtils . Veja um exemplo abaixo tirado daqui, explicando como invocar um método privado:

ReflectionTestUtils.invokeMethod(student, "saveOrUpdate", "From Unit test");

Exemplos completos com ReflectionTestUtils e Mockito podem ser encontrados no livro Mockito for Spring

Você não deve testar métodos privados. Apenas métodos não privados precisam ser testados, pois eles devem chamar os métodos privados de qualquer maneira. Se você "deseja" testar métodos privados, isso pode indicar que você precisa repensar seu design:

Estou usando injeção de dependência adequada? Eu possivelmente preciso mover os métodos privados para uma classe separada e testar isso? Esses métodos devem ser privados? ... eles não podem ser padrão ou protegidos?

No caso acima, os dois métodos chamados "aleatoriamente" podem realmente precisar ser colocados em uma classe própria, testados e, em seguida, injetados na classe acima.

Consegui testar um método privado usando mockito usando reflexão. Aqui está o exemplo, tentei nomeá-lo de forma que faça sentido

//Service containing the mock method is injected with mockObjects

@InjectMocks
private ServiceContainingPrivateMethod serviceContainingPrivateMethod;

//Using reflection to change accessibility of the private method

Class<?>[] params = new Class<?>[]{PrivateMethodParameterOne.class, PrivateMethodParameterTwo.class};
    Method m = serviceContainingPrivateMethod .getClass().getDeclaredMethod("privateMethod", params);
    //making private method accessible
    m.setAccessible(true); 
    assertNotNull(m.invoke(serviceContainingPrivateMethod, privateMethodParameterOne, privateMethodParameterTwo).equals(null));

1. Usando reflexão, métodos privados podem ser chamados de classes de teste. Nesse caso,

   // método de teste será assim ...

   public class TestA {
   
     @Test
       public void testMethod() {
   
       A a= new A();
       Method privateMethod = A.class.getDeclaredMethod("method1", null);
       privateMethod.setAccessible(true);
       // invoke the private method for test
       privateMethod.invoke(A, null);
   
       }
   }

2. Se o método privado chamar qualquer outro método privado, então precisamos espiar o objeto e fazer o stub do outro método. A classe de teste será como ...

   // método de teste será assim ...

   public class TestA {
   
     @Test
       public void testMethod() {
   
       A a= new A();
       A spyA = spy(a);
       Method privateMethod = A.class.getDeclaredMethod("method1", null);
       privateMethod.setAccessible(true);
       doReturn("Test").when(spyA, "method2"); // if private method2 is returning string data
       // invoke the private method for test
       privateMethod.invoke(spyA , null);
   
       }
   }

** A abordagem é combinar reflexão e espiar o objeto. ** método1 e ** método2 são métodos privados e método1 chama método2.

Eu realmente não entendo sua necessidade de testar o método privado. A raiz do problema é que seu método público tem void como tipo de retorno e, portanto, você não pode testar seu método público. Portanto, você é forçado a testar seu método privado. Meu palpite está correto?

Algumas soluções possíveis (AFAIK):

1. Zombando de seus métodos privados, mas ainda assim você não estará "realmente" testando seus métodos.

2. Verifique o estado do objeto usado no método. A MAIORIA dos métodos faz algum processamento dos valores de entrada e retorna uma saída, ou altera o estado dos objetos. Testar os objetos para o estado desejado também pode ser empregado.

   public class A{
   
   SomeClass classObj = null;
   
   public void publicMethod(){
      privateMethod();
   }
   
   private void privateMethod(){
        classObj = new SomeClass();
   }
   
   }

   [Aqui você pode testar o método privado, verificando a mudança de estado do classObj de nulo para não nulo.]

3. Refatore seu código um pouco (espero que este não seja um código legado). Meu fundamento para escrever um método é que sempre se deve retornar algo (um int / um booleano). O valor retornado PODE ou NÃO ser usado pela implementação, mas COM CERTEZA SERÁ usado pelo teste

   código.

   public class A
   { 
       public int method(boolean b)
       {
             int nReturn = 0;
             if (b == true)
                  nReturn = method1();
             else
                  nReturn = method2();
       }
   
       private int method1() {}
   
       private int method2() {}
   
   }

Na verdade, existe uma maneira de testar métodos de um membro privado com o Mockito. Digamos que você tenha uma aula como esta:

public class A {
    private SomeOtherClass someOtherClass;
    A() {
        someOtherClass = new SomeOtherClass();
    }
    public void method(boolean b){
        if (b == true)
            someOtherClass.method1();
        else
            someOtherClass.method2();
    }

}

public class SomeOtherClass {
    public void method1() {}
    public void method2() {}
}

Se você quiser testar a.methodirá chamar um método de SomeOtherClass, você pode escrever algo como abaixo.

@Test
public void testPrivateMemberMethodCalled() {
    A a = new A();
    SomeOtherClass someOtherClass = Mockito.spy(new SomeOtherClass());
    ReflectionTestUtils.setField( a, "someOtherClass", someOtherClass);
    a.method( true );

    Mockito.verify( someOtherClass, Mockito.times( 1 ) ).method1();
}

ReflectionTestUtils.setField(); irá stubar o membro privado com algo que você pode espionar.

Coloque seu teste no mesmo pacote, mas em uma pasta de origem diferente (src / main / java vs. src / test / java) e torne esses métodos package-private. A testabilidade do Imo é mais importante do que a privacidade.

Nos casos em que o método privado não é nulo e o valor de retorno é usado como parâmetro para um método de dependência externa, você pode simular a dependência e usar um ArgumentCaptorpara capturar o valor de retorno. Por exemplo:

ArgumentCaptor<ByteArrayOutputStream> csvOutputCaptor = ArgumentCaptor.forClass(ByteArrayOutputStream.class);
//Do your thing..
verify(this.awsService).uploadFile(csvOutputCaptor.capture());
....
assertEquals(csvOutputCaptor.getValue().toString(), "blabla");