JUnit é uma estrutura de teste de unidade de código aberto de terceiros. O projeto foi iniciado por Kent Beck e Erich Gamma no final de 1995. Rapidamente atraiu o interesse da comunidade de desenvolvedores que lidam particularmente com desenvolvimento orientado a testes. O JUnit foi inicialmente introduzido no Smalltalk, mas depois foi portado para o Java, que rapidamente o adotou como um padrão de fato de teste de unidade. A popularidade do JUnit cresceu a tal ponto que, para atender às necessidades de muitas outras linguagens contemporâneas, como C#, Perl, Python, PHP, Ruby, Visual Basic, C++ e assim por diante, foi desenvolvido um framework xUnit genérico onde a letra 'x' é substituído pela primeira letra da linguagem, como JUnit para Java, RUnit para Ruby e assim por diante. Este artigo fornece uma visão geral dessa estrutura conforme usada pelo padrão de fato de teste de unidade Java.
Visão geral dos testes
O teste é uma fase importante no ciclo de vida de um desenvolvimento de aplicativo. O principal objetivo do teste é avaliar um programa com base nas especificações exigidas. O objetivo é criar certos casos de teste que mostrem erros, lacunas, discrepâncias ou resultados inesperados, tanto quanto possível. Este conceito simples tem alguns processos elaborados associados a ele. Mas, para resumir, é feito em três níveis. Quando o teste é feito em um nível de componente muito granular ou individual, ele é chamado de Teste de unidade; quando eles são combinados para verificar as interfaces entre os componentes em relação a um projeto de software, é chamado de Teste de Integração; e, finalmente, quando o sistema completo é integrado e o teste é feito para verificar se o sistema como um todo atende ao requisito especificado, ele é chamado de Teste do Sistema .
Teste Unitário
Em poucas palavras, realizar um teste de unidade é uma maneira de examinar o comportamento de uma unidade distinta de código. Em Java, uma unidade de código pode significar um método ou uma classe ou mesmo um módulo, de acordo com o contexto. Se for um método, por exemplo, o foco do teste é avaliar a referência de objeto correta permitida para invocar o método, tipo de parâmetros e valores aceitáveis, intervalos de valores primitivos, tipo e valor de retorno e assim por diante. A idéia é grelhar o método para que ele se torne robusto o suficiente para lidar com seu problema com graça e afastar aqueles que estão além de seu escopo para além do cumprimento de seu contrato.
Portanto, o teste de unidade constitui o bloco de construção básico de qualquer avaliação de programa. Na verdade, todo programador realiza algum tipo de teste de unidade enquanto escreve o código para verificar o resultado do código com alguns dados/casos fictícios. O teste unitário é, portanto, um status formal dado a essa coleção isolada de testes. É extremamente importante que um código passe pelo rigor de várias fases de testes. O teste unitário, além de sua importância, também é muito corriqueiro. Pessoas como Kent Beck e Erich Gamma pensaram em criar um framework para que os programadores tivessem um ambiente estruturado e pudessem automatizar muitas dessas tarefas. Afinal, é para isso que serve um framework. Normalmente, ele fornece uma estrutura de programa coerente que é reutilizável e compartilhável entre aplicativos. Um programador pode incorporá-los em uma aplicação existente e estendê-los de acordo com sua necessidade específica.
Um exemplo rápido
Um código de teste de unidade simples para examinar o método único em Temperatura class sem usar o framework JUnit é a seguinte:
package org.mano.unittest.examples;
public class Circle {
double area(double radius) {
returnMath.PI* radius * radius;
}
}
Agora, vamos escrever o código para testar a unidade na área método.
package org.mano.unittest.examples;
public class CircleTest {
public int errCounter= 0;
public void testCircleArea() {
Circle circle = new Circle();
double area = circle.area(12);
if (area < 452 && area > 453) {
throw new IllegalStateException("Wrong calculation!: "
+ area);
}
}
public static void main(String[] args) {
TestCircle test = new TestCircle();
try {
test.testCircleArea();
} catch (Throwable e) {
test.errCounter++;
e.printStackTrace();
}
if (test.errCounter> 0) {
throw new IllegalStateException("There were "
+ test.errCounter+ " error(s)");
}
}
}
Este é um exemplo rudimentar, mas dá uma ideia de como o teste de unidade pode ser feito sem usar nenhum framework.
Estrutura de teste JUnit
O uso da estrutura JUnit para teste de unidade tem várias vantagens. Ele fornece várias anotações que facilitam escrever e executar códigos de teste em Java:
- Primeiramente, ele separa a preocupação do teste de unidade do código do projeto real, permitindo criar uma instância de classe de teste e carregadores de classe para cada teste de unidade. Eles “imunem” o código existente de efeitos colaterais desnecessários de testes.
- As anotações fornecidas pelo JUnit, como @Before, @After, @BeforeClass, @AfterClass —têm métodos para inicialização e recuperação de recursos.
- Há uma grande variedade de métodos assert para verificar o resultado de um teste.
- Ao longo dos anos, JUnit tornou-se tão popular que várias ferramentas Java, como Ant e Maven; e IDEs populares, como Eclipse , NetBeans , IntelliJ IDEIA , e similares, vem com integração embutida do JUnit.
Para usar o JUnit Test Framework em um projeto Java, deve-se incluir um arquivo JUnit JAR no caminho da classe do projeto. Isso é explicitamente necessário se o IDE não estiver integrado à biblioteca JUnit. O processo é simples. Faça download do arquivo JAR e inclua-o no caminho da classe do projeto.
Aqui estão alguns links importantes para o framework JUnit.
- Site oficial da JUnit
- API Java JUnit
- Guia do usuário JUnit
- Código-fonte JUnit no GitHub
Ao contrário do JUnit 4 e seus antecessores, o JUnit 5 trouxe algumas mudanças significativas. Além de muitos novos recursos adicionados, como suporte a lambda, novas anotações e injeção de parâmetros de métodos de teste, a arquitetura principal recebeu algumas modificações significativas. JUnit 5 agora é uma arquitetura composta de três módulos diferentes:JUnit Jupiter, JUnit Vintage e JUnit Platform. Os desenvolvedores de casos de teste, no entanto, não precisam se preocupar com as complexidades das mudanças. As mudanças significam principalmente melhor suporte de ferramentas, consistência e APIs mais limpas. Acima de tudo, é totalmente compatível com o JUnit 4. Portanto, também não se preocupe. Consulte o guia do usuário do JUnit 5 para obter mais detalhes.
Um exemplo rápido
Aqui está um exemplo muito simples para ter uma ideia de como o teste de unidade pode ser feito com o framework JUnit. Usamos o Funcionário class para o teste de unidade e crie uma classe de teste para dar uma ideia de como funciona. O exemplo é rudimentar ao ponto de escrever um programa ‘Hello World’. Casos de teste do mundo real, ou mesmo um exemplo decente de teste de unidade, requerem uma boa quantidade de código. Talvez tentemos isso em algum outro artigo.
package org.mano.unittest.examples;
public class Employee {
private final String name;
private final double basicPay;
public Employee(String name, double basicPay) {
this.name=name;
this.basicPay=basicPay;
}
public String getName() {
return name;
}
public double getBasicPay() {
return basicPay;
}
}
package org.mano.unittest.examples;
import org.junit.Test;
import static org.junit.Assert.*;
public class EmployeeTest {
@Test
public void constructorInitTest(){
Employee emp=new Employee("Odin", 2300);
assertEquals("Odin", emp.getName());
assertEquals(2300, emp.getBasicPay(), 0.001);
}
}
package org.mano.unittest.examples;
public class EmployeeTestMain {
public static void main(String[] args){
EmployeeTest et=new EmployeeTest();
et.constructorInitTest();
}
}
Observe que a classe Employee é imutável com apenas dois campos definidos pelo construtor. Como vale a pena testar apenas o método construtor, testaremos apenas isso.
A classe de teste é denominada EmployeeTest conforme convenção. A anotação @Test permite que JUnit designe um método como um método de teste. Há uma variedade de métodos assert no Assert aula. Aqui, usamos apenas assertEquals .
Há muitas maneiras de executar um teste escrito em JUnit. Normalmente, após a execução dos casos de teste, ele imprime um resumo. No entanto, pode variar dependendo de como o teste é executado. Ele pode ser executado por meio de IDEs como Eclipse ou IntelliJ, ou ferramentas como Maven, Gradle e assim por diante. Às vezes, a única informação recebida após o teste é que ele falhou ou passou.
Conclusão
Existem vários outros frameworks para testes unitários. JUnit é uma estrutura de teste de unidade popular entre a comunidade Java. O teste como uma fase de engenharia de sistema tem muito mais processo envolvido. O teste de unidade é apenas uma parte disso e, curiosamente, muitos testes de jogo feitos pelo desenvolvedor podem ser chamados de testes de unidade. JUnit, como framework de teste, agrega valor a ele. As anotações e as APIs fornecidas pelo JUnit automatizam muitas tarefas e facilitam muito a vida dos desenvolvedores de testes de unidade.
