Como testo uma função privada ou uma classe que possui métodos, campos ou classes internas?

Como faço para testar a unidade (usando xUnit) uma classe que possui métodos privados, campos ou classes aninhadas? Ou uma função que é tornada privada por ter ligação interna ( staticem C / C ++) ou está em um espaço para nome privado ( anônimo )?

Parece ruim alterar o modificador de acesso de um método ou função apenas para poder executar um teste.

Atualizar:

Cerca de 10 anos depois, talvez a melhor maneira de testar um método privado, ou qualquer membro inacessível, seja via estrutura @Jailbreakdo Manifold .

@Jailbreak Foo foo = new Foo();
// Direct, *type-safe* access to *all* foo's members
foo.privateMethod(x, y, z);
foo.privateField = value;

Dessa forma, seu código permanecerá seguro e legível. Sem comprometimentos no projeto, sem métodos e campos de superexposição para fins de teste.

Se você possui um aplicativo Java herdado e não tem permissão para alterar a visibilidade de seus métodos, a melhor maneira de testar métodos privados é usar a reflexão .

Internamente, estamos usando ajudantes para obter / definir privatee private staticvariáveis, além de invocar privatee private staticmétodos. Os seguintes padrões permitem fazer praticamente qualquer coisa relacionada aos métodos e campos privados. Obviamente, você não pode alterar private static finalvariáveis ​​através da reflexão.

Method method = TargetClass.getDeclaredMethod(methodName, argClasses);
method.setAccessible(true);
return method.invoke(targetObject, argObjects);

E para campos:

Field field = TargetClass.getDeclaredField(fieldName);
field.setAccessible(true);
field.set(object, value);

Notas:
1. TargetClass.getDeclaredMethod(methodName, argClasses)permite examinar privatemétodos. O mesmo se aplica getDeclaredField.
2. setAccessible(true)É necessário brincar com os soldados.

A melhor maneira de testar um método privado é através de outro método público. Se isso não puder ser feito, uma das seguintes condições será verdadeira:

1. O método privado é código morto
2. Há um cheiro de design perto da classe que você está testando
3. O método que você está tentando testar não deve ser privado

Quando tenho métodos particulares em uma classe que são suficientemente complicados, sinto a necessidade de testar diretamente os métodos privados, isso é um cheiro de código: minha classe é muito complicada.

Minha abordagem usual para resolver esses problemas é provocar uma nova classe que contém os bits interessantes. Frequentemente, esse método e os campos com os quais interage, e talvez outro método ou dois possam ser extraídos para uma nova classe.

A nova classe expõe esses métodos como 'públicos', para que sejam acessíveis para testes de unidade. As classes novas e antigas agora são mais simples que a classe original, o que é ótimo para mim (eu preciso manter as coisas simples ou me perco!).

Note que não estou sugerindo que as pessoas criem classes sem usar o cérebro! O objetivo aqui é usar as forças do teste de unidade para ajudá-lo a encontrar boas novas classes.

Eu usei a reflexão para fazer isso no Java no passado e, na minha opinião, foi um grande erro.

A rigor, você não deve escrever testes de unidade que testem diretamente métodos privados. O que você deve testar é o contrato público que a classe possui com outros objetos; você nunca deve testar diretamente as partes internas de um objeto. Se outro desenvolvedor quiser fazer uma pequena alteração interna na classe, o que não afeta o contrato público da classe, ele deverá modificar seu teste baseado em reflexão para garantir que funcione. Se você fizer isso repetidamente em um projeto, os testes de unidade deixarão de ser uma medida útil da integridade do código e começarão a se tornar um obstáculo ao desenvolvimento e um aborrecimento para a equipe de desenvolvimento.

O que eu recomendo fazer é usar uma ferramenta de cobertura de código como Cobertura, para garantir que os testes de unidade que você escreve forneçam uma cobertura decente do código em métodos privados. Dessa forma, você indiretamente testa o que os métodos privados estão fazendo e mantém um nível mais alto de agilidade.

Neste artigo: Testando métodos privados com JUnit e SuiteRunner (Bill Venners), você basicamente tem 4 opções:

1. Não teste métodos particulares.
2. Conceda acesso ao pacote de métodos.
3. Use uma classe de teste aninhada.
4. Use reflexão.

Geralmente, um teste de unidade destina-se a exercer a interface pública de uma classe ou unidade. Portanto, métodos privados são detalhes de implementação que você não esperaria testar explicitamente.

Apenas dois exemplos de onde eu gostaria de testar um método privado:

1. Rotinas de descriptografia - eu não gostaria de torná-las visíveis para qualquer pessoa ver apenas para fins de teste; caso contrário, alguém pode usá-las para descriptografar. Mas eles são intrínsecos ao código, complicados e precisam sempre funcionar (a exceção óbvia é a reflexão que pode ser usada para exibir até métodos privados na maioria dos casos, quando SecurityManagernão está configurada para evitar isso).
2. Criando um SDK para consumo da comunidade. Aqui, o público assume um significado totalmente diferente, pois esse é o código que o mundo inteiro pode ver (não apenas interno ao meu aplicativo). Coloco o código em métodos privados se não quero que os usuários do SDK o vejam - não vejo isso como cheiro de código, apenas como funciona a programação do SDK. Mas é claro que ainda preciso testar meus métodos particulares, e eles são onde a funcionalidade do meu SDK realmente vive.

Entendo a ideia de apenas testar o "contrato". Mas não vejo como alguém possa advogar na verdade não testar o código - sua milhagem pode variar.

Portanto, minha troca envolve complicar as JUnits com reflexão, em vez de comprometer minha segurança e SDK.

Os métodos privados são chamados por um método público, portanto, as entradas para seus métodos públicos também devem testar métodos privados chamados por esses métodos públicos. Quando um método público falha, isso pode ser uma falha no método privado.

Outra abordagem que usei é alterar um método privado para empacotar privado ou protegido e complementá-lo com o @VisibleForTesting anotação da biblioteca do Google Guava.

Isso instruirá qualquer pessoa que use esse método a tomar cuidado e não acessá-lo diretamente, mesmo em um pacote. Também uma classe de teste não precisa estar no mesmo pacote fisicamente , mas no mesmo pacote sob o teste pasta de .

Por exemplo, se um método a ser testado estiver presente src/main/java/mypackage/MyClass.java, sua chamada de teste deverá ser efetuada src/test/java/mypackage/MyClassTest.java. Dessa forma, você tem acesso ao método de teste em sua classe de teste.

Para testar código legado com classes grandes e peculiares, geralmente é muito útil poder testar o único método privado (ou público) que estou escrevendo agora .

Eu uso o pacote junitx.util.PrivateAccessor para Java. Muitas linhas de ajuda úteis para acessar métodos e campos particulares.

import junitx.util.PrivateAccessor;

PrivateAccessor.setField(myObjectReference, "myCrucialButHardToReachPrivateField", myNewValue);
PrivateAccessor.invoke(myObjectReference, "privateMethodName", java.lang.Class[] parameterTypes, java.lang.Object[] args);

No Spring Framework, você pode testar métodos privados usando este método:

ReflectionTestUtils.invokeMethod()

Por exemplo:

ReflectionTestUtils.invokeMethod(TestClazz, "createTest", "input data");

Tendo experimentado a solução da Cem Catikkas usando reflexão para Java, eu diria que a solução dele era mais elegante do que descrevi aqui. No entanto, se você estiver procurando uma alternativa ao uso da reflexão e tiver acesso à fonte que está testando, isso ainda será uma opção.

Existe mérito possível ao testar métodos particulares de uma classe, principalmente no desenvolvimento orientado a testes , no qual você deseja projetar pequenos testes antes de escrever qualquer código.

A criação de um teste com acesso a membros e métodos privados pode testar áreas de código difíceis de atingir especificamente com acesso apenas a métodos públicos. Se um método público tiver várias etapas envolvidas, ele poderá consistir em vários métodos particulares, que poderão ser testados individualmente.

Vantagens:

• Pode testar com uma granularidade mais fina

Desvantagens:

• O código de teste deve residir no mesmo arquivo que o código-fonte, o que pode ser mais difícil de manter
• Da mesma forma com os arquivos de saída .class, eles devem permanecer no mesmo pacote declarado no código-fonte

No entanto, se o teste contínuo exigir esse método, pode ser um sinal de que os métodos privados devem ser extraídos, o que pode ser testado da maneira tradicional e pública.

Aqui está um exemplo complicado de como isso funcionaria:

// Import statements and package declarations

public class ClassToTest
{
    private int decrement(int toDecrement) {
        toDecrement--;
        return toDecrement;
    }

    // Constructor and the rest of the class

    public static class StaticInnerTest extends TestCase
    {
        public StaticInnerTest(){
            super();
        }

        public void testDecrement(){
            int number = 10;
            ClassToTest toTest= new ClassToTest();
            int decremented = toTest.decrement(number);
            assertEquals(9, decremented);
        }

        public static void main(String[] args) {
            junit.textui.TestRunner.run(StaticInnerTest.class);
        }
    }
}

A classe interna seria compilada para ClassToTest$StaticInnerTest.

Veja também: Dica Java 106: Classes internas estáticas para diversão e lucro

Como outros já disseram ... não teste métodos privados diretamente. Aqui estão alguns pensamentos:

1. Mantenha todos os métodos pequenos e focados (fácil de testar, fácil de encontrar o que está errado)
2. Use ferramentas de cobertura de código. Gosto de Cobertura (feliz dia, parece que uma nova versão foi lançada!)

Execute a cobertura do código nos testes de unidade. Se você perceber que os métodos não foram totalmente testados, adicione-os aos testes para aumentar a cobertura. Procure 100% de cobertura do código, mas saiba que você provavelmente não conseguirá.

Métodos privados são consumidos por métodos públicos. Caso contrário, eles são código morto. É por isso que você testa o método público, afirmando os resultados esperados do método público e, portanto, os métodos privados que ele consome.

O teste de métodos particulares deve ser testado por depuração antes de executar seus testes de unidade em métodos públicos.

Eles também podem ser depurados usando desenvolvimento orientado a testes, depurando seus testes de unidade até que todas as suas asserções sejam atendidas.

Pessoalmente, acredito que é melhor criar classes usando TDD; criando os stubs de método público e, em seguida, gerando testes de unidade com todas as asserções definidas anteriormente, para que o resultado esperado do método seja determinado antes da codificação. Dessa forma, você não segue o caminho errado de fazer com que as asserções de teste de unidade se ajustem aos resultados. Sua classe é robusta e atende aos requisitos quando todos os seus testes de unidade passam.

Se você estiver usando o Spring, o ReflectionTestUtils fornece algumas ferramentas úteis que ajudam aqui com o mínimo esforço. Por exemplo, para configurar uma simulação em um membro privado sem ser forçado a adicionar um configurador público indesejável:

ReflectionTestUtils.setField(theClass, "theUnsettableField", theMockObject);

Se você está tentando testar o código existente que não está disposto a mudar, a reflexão é uma boa escolha.

Se o design da classe ainda for flexível e você tiver um método privado complicado que você deseja testar separadamente, sugiro que você o puxe para uma classe separada e teste essa classe separadamente. Isso não precisa alterar a interface pública da classe original; ele pode criar internamente uma instância da classe auxiliar e chamar o método auxiliar.

Se você deseja testar condições de erro difíceis provenientes do método auxiliar, pode dar um passo adiante. Extraia uma interface da classe auxiliar, adicione um getter e setter público à classe original para injetar a classe auxiliar (usada por meio de sua interface) e, em seguida, injete uma versão simulada da classe auxiliar na classe original para testar como a classe original responde a exceções do ajudante. Essa abordagem também é útil se você quiser testar a classe original sem também testar a classe auxiliar.

O teste de métodos particulares interrompe o encapsulamento de sua classe, pois toda vez que você altera a implementação interna, o código do cliente é interrompido (nesse caso, os testes).

Portanto, não teste métodos particulares.

A resposta da página de perguntas frequentes do JUnit.org :

Mas se você deve ...

Se você estiver usando o JDK 1.3 ou superior, poderá usar a reflexão para subverter o mecanismo de controle de acesso com a ajuda do PrivilegedAccessor . Para detalhes sobre como usá-lo, leia este artigo .

Se você estiver usando o JDK 1.6 ou superior e anotar seus testes com o @Test, poderá usar o Dp4j para injetar reflexão nos seus métodos de teste. Para detalhes sobre como usá-lo, consulte este script de teste .

PS: Eu sou o principal colaborador do Dp4j , pergunte- me se você precisar de ajuda. :)

Se você deseja testar métodos particulares de um aplicativo herdado em que não pode alterar o código, uma opção para Java é o jMockit , que permitirá criar simulações para um objeto, mesmo quando elas são privadas para a classe.

Costumo não testar métodos particulares. Aí está a loucura. Pessoalmente, acredito que você só deve testar suas interfaces expostas publicamente (e isso inclui métodos internos e protegidos).

Se você estiver usando o JUnit, consulte os junit-addons . Ele tem a capacidade de ignorar o modelo de segurança Java e acessar métodos e atributos privados.

Eu sugiro que você refatorar seu código um pouco. Quando você começa a pensar em usar reflexão ou outro tipo de coisa, apenas para testar seu código, algo está errado com seu código.

Você mencionou diferentes tipos de problemas. Vamos começar com campos particulares. No caso de campos particulares, eu teria adicionado um novo construtor e injetado campos nele. Em vez disso:

public class ClassToTest {

    private final String first = "first";
    private final List<String> second = new ArrayList<>();
    ...
}

Eu teria usado isso:

public class ClassToTest {

    private final String first;
    private final List<String> second;

    public ClassToTest() {
        this("first", new ArrayList<>());
    }

    public ClassToTest(final String first, final List<String> second) {
        this.first = first;
        this.second = second;
    }
    ...
}

Isso não será um problema, mesmo com algum código legado. O código antigo usará um construtor vazio e, se você me perguntar, o código refatorado parecerá mais limpo e você poderá injetar os valores necessários no teste sem reflexão.

Agora sobre métodos privados. Na minha experiência pessoal, quando você precisa stubar um método privado para teste, esse método não tem nada a ver nessa classe. Um padrão comum, nesse caso, seria envolvê- lo em uma interface, como Callablee você passará nessa interface também no construtor (com esse truque de vários construtores):

public ClassToTest() {
    this(...);
}

public ClassToTest(final Callable<T> privateMethodLogic) {
    this.privateMethodLogic = privateMethodLogic;
}

Principalmente tudo o que escrevi parece ser um padrão de injeção de dependência. Na minha experiência pessoal, é realmente útil durante os testes, e acho que esse tipo de código é mais limpo e será mais fácil de manter. Eu diria o mesmo sobre classes aninhadas. Se uma classe aninhada contiver lógica pesada, seria melhor se você a tivesse movido como uma classe privada de pacote e a injetado em uma classe que precisa.

Também existem vários outros padrões de design que eu usei ao refatorar e manter o código legado, mas tudo depende dos casos do seu código para testar. Usar a reflexão principalmente não é um problema, mas quando você tem um aplicativo corporativo que é fortemente testado e os testes são executados antes de cada implantação, tudo fica realmente lento (é irritante e eu não gosto desse tipo de coisa).

Também há injeção de setter, mas eu não recomendaria usá-lo. É melhor ficar com um construtor e inicializar tudo quando for realmente necessário, deixando a possibilidade de injetar dependências necessárias.

Um método privado deve ser acessado apenas na mesma classe. Portanto, não há como testar um método "privado" de uma classe de destino de qualquer classe de teste. Uma saída é que você pode executar o teste de unidade manualmente ou pode mudar seu método de "privado" para "protegido".

E, em seguida, um método protegido pode ser acessado apenas dentro do mesmo pacote em que a classe está definida. Portanto, testar um método protegido de uma classe de destino significa que precisamos definir sua classe de teste no mesmo pacote que a classe de destino.

Se todas as opções acima não atenderem aos seus requisitos, use a maneira de reflexão para acessar o método privado.

Como muitos sugeriram acima, uma boa maneira é testá-los por meio de suas interfaces públicas.

Se você fizer isso, é uma boa ideia usar uma ferramenta de cobertura de código (como Emma) para ver se seus métodos privados estão de fato sendo executados a partir de seus testes.

Aqui está minha função genérica para testar campos particulares:

protected <F> F getPrivateField(String fieldName, Object obj)
    throws NoSuchFieldException, IllegalAccessException {
    Field field =
        obj.getClass().getDeclaredField(fieldName);

    field.setAccessible(true);
    return (F)field.get(obj);
}

Por favor, veja abaixo um exemplo;

A seguinte declaração de importação deve ser adicionada:

import org.powermock.reflect.Whitebox;

Agora você pode transmitir diretamente o objeto que possui o método privado, o nome do método a ser chamado e parâmetros adicionais, como abaixo.

Whitebox.invokeMethod(obj, "privateMethod", "param1");

Hoje, instalei uma biblioteca Java para ajudar a testar métodos e campos privados. Ele foi projetado com o Android em mente, mas pode realmente ser usado para qualquer projeto Java.

Se você obteve algum código com métodos, campos ou construtores particulares, pode usar o BoundBox . Faz exatamente o que você está procurando. Aqui está um exemplo de teste que acessa dois campos particulares de uma atividade do Android para testá-la:

@UiThreadTest
public void testCompute() {

    // Given
    boundBoxOfMainActivity = new BoundBoxOfMainActivity(getActivity());

    // When
    boundBoxOfMainActivity.boundBox_getButtonMain().performClick();

    // Then
    assertEquals("42", boundBoxOfMainActivity.boundBox_getTextViewMain().getText());
}

O BoundBox facilita o teste de campos, métodos e construtores privados / protegidos. Você pode até acessar coisas ocultas por herança. De fato, o BoundBox quebra o encapsulamento. Isso lhe dará acesso a tudo isso através da reflexão, MAS tudo será verificado no momento da compilação.

É ideal para testar algum código legado. Use-o com cuidado. ;)

https://github.com/stephanenicolas/boundbox

Primeiro, jogarei essa pergunta fora: Por que seus membros privados precisam de testes isolados? Eles são tão complexos, fornecendo comportamentos tão complicados que exigem testes separados da superfície pública? É um teste de unidade, não um teste de 'linha de código'. Não se preocupe com as pequenas coisas.

Se eles são tão grandes, grandes o suficiente para que esses membros privados sejam uma 'unidade' grande em complexidade - considere refatorar esses membros privados dessa classe.

Se a refatoração for inadequada ou inviável, você pode usar o padrão de estratégia para substituir o acesso a essas funções-membro privadas / classes-membro quando estiver em teste de unidade? Sob teste de unidade, a estratégia forneceria validação adicional, mas nas versões lançadas seria uma passagem simples.

Recentemente, tive esse problema e escrevi uma pequena ferramenta, chamada Picklock , que evita os problemas de usar explicitamente a API de reflexão Java, dois exemplos:

Métodos de chamada, por exemplo private void method(String s)- por reflexão Java

Method method = targetClass.getDeclaredMethod("method", String.class);
method.setAccessible(true);
return method.invoke(targetObject, "mystring");

Métodos de chamada, por exemplo private void method(String s)- por Picklock

interface Accessible {
  void method(String s);
}

...
Accessible a = ObjectAccess.unlock(targetObject).features(Accessible.class);
a.method("mystring");

Definir campos, por exemplo private BigInteger amount;- por reflexão Java

Field field = targetClass.getDeclaredField("amount");
field.setAccessible(true);
field.set(object, BigInteger.valueOf(42));

Definir campos, por exemplo private BigInteger amount;- por Picklock

interface Accessible {
  void setAmount(BigInteger amount);
}

...
Accessible a = ObjectAccess.unlock(targetObject).features(Accessible.class);
a.setAmount(BigInteger.valueOf(42));

PowerMockito é feito para isso. Usar dependência maven

<dependency>
    <groupId>org.powermock</groupId>
    <artifactId>powermock-mockito-release-full</artifactId>
    <version>1.6.4</version>
</dependency>

Então você pode fazer

import org.powermock.reflect.Whitebox;
...
MyClass sut = new MyClass();
SomeType rval = Whitebox.invokeMethod(sut, "myPrivateMethod", params, moreParams);