O objetivo de um teste de unidade é identificar os erros em um aplicativo o mais rápido possível. Embora vários canais possam levá-lo ao mesmo objetivo, você deve procurar usar a rota mais eficiente.
Um conjunto de testes JUnit pode ter várias classes de teste que precisam dos mesmos dados, mas você não pode reutilizar os dados de teste. Nas versões anteriores do JUnit, uma boa abordagem era criar um método utilitário e, em seguida, chamar esse método sempre que uma classe de teste precisasse de seus dados.
O JUnit 5 oferece uma abordagem mais eficiente para esse problema: injeção de dependência (DI).
O que é injeção de dependência?
DI é um padrão de design em que um objeto fornece as dependências de outro objeto. Ao construir um aplicativo Java, você pode ter uma classe que depende de um objeto criado por outra classe para executar sua função.
Antes da injeção de dependência, para usar um objeto de uma classe diferente, você teria que criar uma nova instância desse objeto dentro da classe que depende dele. Então, se você tivesse várias classes que dependem do mesmo objeto, você teria que criar várias instâncias dele dentro das classes dependentes.
DI permite que você use um objeto em uma classe dependente, sem criar uma nova instância dele nessa classe.
Injeção de Dependência no JUnit 5
O JUnit 5 permite injetar dependências em métodos de teste e construtores. Isso é significativo, pois as versões anteriores da estrutura não permitiam que métodos de teste ou construtores tivessem parâmetros.
O JUnit 5 permite que você injete quantos parâmetros quiser. O único problema é que a API ParameterResolver deve ser capaz de resolver cada parâmetro em tempo de execução. Atualmente, o JUnit possui três resolvedores de parâmetros integrados que usa automaticamente. Para usar qualquer outro resolvedor, você precisa registrá-lo explicitamente usando a anotação @ExtendWith.
Injetando dependências no JUnit
Este programa de amostra usa um dos parâmetros integrados do JUnit (o TestInfoParameterResolver) para demonstrar como você pode injetar uma dependência em um teste JUnit 5. O TestInfoParameterResolver resolve objetos que pertencem à interface TestInfo. Portanto, o JUnit 5 fornecerá uma instância da interface TestInfo para qualquer método ou construtor que a utilize.
importarestático org.junit.jupiter.api. Asserções.*;
importar org.junit.jupiter.api. Nome de exibição;
importar org.junit.jupiter.api. Teste;
importar org.junit.jupiter.api. TestInfo;aulaInfoTestInterfaceTest{
// Injetando um objeto testInfo no construtor InfoTestInterfaceTest
InfoTestInterfaceTest (TestInfo testInfo) {
assertEquals("InfoTestInterfaceTest", testInfo.getDisplayName());
}// Injetando um objeto testInfo em métodos
@Teste
vaziotestMethodName(InfoTesteInfoTeste){
assertEquals("testMethodName (TestInfo)", testInfo.getDisplayName());
}
@Teste
@Nome de exibição("método usando o @Nome de exibição anotação")
vaziotestMethodNameTwo(InfoTesteInfoTeste){
assertEquals("método usando o @Nome de exibição anotação", testInfo.getDisplayName());
}
}
O teste JUnit acima demonstra como injetar um objeto em um construtor e dois métodos. O Informações de Teste JUnit interface tem quatro métodos que você pode usar com seu objeto.
O método getDisplayName() é o mais útil. Ele retorna o nome de exibição do método de teste ou construtor atual. Por padrão, esse nome é baseado na classe. Mas se você usar a anotação @DisplayName, o método getDisplayName() retornará esse texto.
A classe de teste acima gera o seguinte relatório de teste:
Use DI nos métodos @Before e @After
Existem quatro outros tipos de métodos anotados JUnit que suportam dependências. Essas são as anotações @BeforeAll, @BeforeEach, @AfterAll e @AfterEach. Assim como o método @Test, tudo o que você precisa fazer é passar um objeto para qualquer um dos métodos before ou after como um parâmetro e pronto.
As anotações @Before e @After são importantes, pois também ajudam a desenvolver um código de teste mais eficiente. Ter a capacidade de também injetar dependências nesses métodos melhorará ainda mais seu código de teste.