Realizando testes no IntelliJ + Aplicando no Projeto Orange Tech
- #Testes unitários
- #Java
- #TDD
Introdução
Testes Unitários são uma excelente forma de verificar a qualidade do código escrito, revelando bugs e permitindo a evolução segura do sistema como um todo.
Neste artigo vou mostrar como realizar testes unitários usando Junit no IntelliJ. Ainda veremos como testar métodos de classes em um projeto desenvolvido no bootcamp Orange Tech Trilha BackEnd
Configurando a IDE
A documentação do IntelliJ para integrar o Junit é excelente, dando até dica das telas de atalho para melhorar a produtividade:
1- Abra o arquivo pom.xml na raiz do seu projeto.
2- Dentro do arquivo, pressione Alt+Insert e selecione Add dependency.
3- Na janela que abre, digite org.junit.jupiter:junit-jupiter no campo de pesquisa
4- Ache a dependencia correta (que possui a identificação exata acima) e adicione ao projeto.
5- Recarrege o arquivo pressionando Ctrl+Shift+O click no icone de reload do Maven.
Seu arquivo deve ter a seguinte dependência:
Se deseja realizar o teste unitário apenas para pegar o jeito, recomendo que acesse o artigo na pagina da JetBrains.
Teste à moda antiga
No projeto apresentado no bootcamp, testamos as classes inicializando-as em variáveis, aplicando os métodos e funções criados e vendo se estava tudo correndo bem. Se você seguiu o tutorial junto com a instrutora Camila Cavalcante, seu arquivo main deve ter ficado assim:
Main.java
import br.com.domain.*;
import java.time.LocalDate;
public class Main {
public static void main(String[] args) {
Curso curso1 = new Curso();
curso1.setTitle("Curso Java");
curso1.setDescription("Curso Java Iniciante");
curso1.setWorkload(10);
Curso curso2 = new Curso();
curso2.setTitle("JS Curso");
curso2.setDescription("Curso Iniciante de JavaScript");
curso2.setWorkload(10);
Mentoria mentoria1 = new Mentoria();
mentoria1.setTitle("Mentoria Java");
mentoria1.setDescription("Mentoria de Java para inciantes");
mentoria1.setDate(LocalDate.now());
Conteudo conteudo = new Curso();
Bootcamp bootcamp = new Bootcamp();
bootcamp.setName("Orange Tech");
bootcamp.setDescription("Bootcamp Java Developer");
bootcamp.getContents().add(curso1);
bootcamp.getContents().add(curso2);
bootcamp.getContents().add(mentoria1);
Dev dev1 = new Dev();
dev1.setName("Jhon");
dev1.subscribeBootcamp(bootcamp);
System.out.println(dev1.getName() + " Subscribed Content: " + dev1.getSubscribedContent());
dev1.progress();
System.out.println(dev1.getName() + " Subscribed Content: " + dev1.getSubscribedContent());
System.out.println("Earned XP: " + dev1.calcFullXp());
System.out.println(dev1.getName() + " Completed Content: "+ dev1.getCompletedContent() + "\n");
Dev dev2 = new Dev();
dev2.setName("Mary");
dev2.subscribeBootcamp(bootcamp);
System.out.println(dev2.getName() + " Subscribed Content: " + dev2.getSubscribedContent());
dev2.progress();
System.out.println(dev2.getName() + " Subscribed Content: " + dev2.getSubscribedContent());
System.out.println("Earned XP: " + dev2.calcFullXp());
dev2.progress();
dev2.progress();
System.out.println("Earned XP: " + dev2.calcFullXp());
System.out.println(dev2.getName() + " Completed Content: "+ dev2.getCompletedContent()+ "\n");
}
}
Tudo para um test drive, mas concorda comigo que ficou um tanto bagunçado né. Quem pega esse código pela primeira vez, sem ver as outras classes e métodos não entende nada. Eu mesmo tive que dar várias relidas nas classes e métodos para gerar os métodos e percebi o quão útil é seguir a abordagem de TDD no desenvolvimento de software. Se não sabe o que é TDD, leia esse artigo no DevMedia, é excelente!
Resumindo: Cursos e Mentorias compõem um BootCamp. Bootcamp é feito por Dev, que, se inscrevendo em um, tem seu progresso medido pela quantidade de cursos e mentorias concluídos. À medida que conclui as matérias, seu progresso é medido aumentando a quantidade de xp adquirida.
E é justamente a Função de calculo de Xp que queremos testar. Veja que para isso, precisamos:
- Instanciar um curso ou uma mentoria (no caso do curso, é necessário definir a carga horária que é usada no cálculo do xp adquirido;
- Instanciar um novo bootcamp e inserir nele os conteúdos criados (os conteúdos são inseridos em ordem por meio do LinkedHashSet) ;
-Criar o dev e inscrever ele em um bootcamp;
Para só ai, usar o metodo dev.progress(), onde o primeiro conteúdo é concluído, e é chamada a função para calcular o xp ganho. Com mais uns soups da vida pra ver a coisa andando, nossa função main nos custou 44 linhas, e um bom tempo de codificação.
Criando a classe de teste
Com base no projeto do Orange Tech:
- Selecione o nome da classe (Dev) e pressione Alt+Enter e clique em Create Test
- Selecione os métodos que deseja testar e clique em ok
Criada a classe, vamos testar o método que calcula o xp total do Dev.
Devtest.java
@Test
@DisplayName("Calc xp based on courses and mentors finished")
void calcFullXp() {
}
}
Test: Identifica uma função de teste;
DisplayName: Título que aparece na suíte de testes, para uma melhor identificação
Mas antes de iniciar, lembra que o xp total é o cálculo do xp ganho quando o dev conclui materiais e cursos dentro de um bootcamp que ele é inscrito? Logo, para um efetivo teste dessa função, precisamos criar no mínimo um curso ou uma mentoria, um bootcamp que irá englobar esses conteúdos e um dev que irá se inscrever no bootcamp e fazer as atividades.
Para fazer isso em testes, vamos usar a annotation @beforeEach para instanciar as classes necessárias para testar o método:
@BeforeEach
void setUp() {
curso = new Curso();
mentoria = new Mentoria();
bootcamp = new Bootcamp();
dev = new Dev();
curso.setWorkload(1);
bootcamp.getContents().add(curso);
bootcamp.getContents().add(mentoria);
dev.subscribeBootcamp(bootcamp);
dev.progress();
dev.progress();
}
Após as configurações feitas, vamos testar o método de calcular xp:
@Test
@DisplayName("Calc xp based on courses and mentors finished")
void calcFullXp() {
assertEquals(40, dev.calcFullXp());
}
Comparando com os testes feitos no arquivo main, que eram um tanto difíceis de se entender, o arquivo de testes explica bem o que o código faz:
O curso tem um peso (multiplicador) que é a carga horária, utilizada para calcular o xp;
Cursos e mentorias são adicionados ao bootcamp como conteúdos;
O Dev se inscreve no bootcamp e a cada conteúdo concluído ele realiza a progressão, aumentando seu xp com base na carga horária;
A função calcFullXp realiza o calculo do xp total do dev no bootcamp.
Resultado:
package br.com.domain;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
class DevTest {
Curso curso;
Mentoria mentoria;
Bootcamp bootcamp;
Dev dev;
@BeforeEach
void setUp() {
curso = new Curso();
mentoria = new Mentoria();
bootcamp = new Bootcamp();
dev = new Dev();
curso.setWorkload(1);
bootcamp.getContents().add(curso);
bootcamp.getContents().add(mentoria);
dev.subscribeBootcamp(bootcamp);
dev.progress();
dev.progress();
}
@Test
@DisplayName("Calc xp based on courses and mentors finished")
void calcFullXp() {
assertEquals(40, dev.calcFullXp());
}
}
Esse é o início de um TDD, que na verdade é o inverso do que costumamos a fazer: Desenvolver os testes primeiro e a solução (código depois). Pretendo aprender essa metodologia e inserir na minha rotina de desenvolvimento, pois aumenta muito a qualidade do código desenvolvido e do produto entregue.
Sinta-se à vontade para comentar, elogiar ou mesmo corrigir quaisquer erros nesse artigo. Sucesso à todos!!!
Repositório no GitHub (obrigado Gabriel Gregório por me lembrar):
https://github.com/kailera/POO-Java---bootcamp.git
