Tutorial JUnit. Equipe: Pyxis Solutions IFSP - A6PGP. São Paulo 21 de Agosto de 2017.

(1)

Tutorial

_JUnit

Equipe:

_{Pyxis Solutions}

IFSP

_{- A6PGP}

(2)

Objetivo 4

O_{que é o JUnit?} 4

Observações 4

Anotações 5

Estrutura_{do JUnit} 7

Utilizando_{o JUnit durante os testes} 9

JaCoCo 13

(3)

Versão:

Autor

Versão

Descrição

Arion

_Melkan

1.0 Criação

_{do documento}

(4)

Objetivo

Capacitar_{a equipe Pyxis Solutions a trabalhar com o framework JUnit.}

O

_{que é o JUnit?}

O JUnit é um framework que disponibiliza um conjunto de classes, para aplicações java, com o objetivo de automatizar os testes dos desenvolvedores. Isto não significa que os desenvolvedores poderão se preocupar em somente programar e_{os testes serão criados “sozinhos”.}

Observa-se que com a utilização do JUnit, usa-se o conceito TDD (Test Driven Developer)_{e as principais vantagens desse conceito são:}

1. Cada funcionalidade que o programador desenvolver será validada. Ou seja, evita do desenvolvedor programar tudo e depois perder um tempo refazendo diversas_{funcionalidades por causa de um determinado erro;}

2. Entra o conceito de refatoração, o desenvolvedor não se preocupará que o seu teste inicial dê erro, aliás isto é importante que aconteça. E depois da implementação da funcionalidade, o método, deve passar naquele teste. Desse modo, o desenvolvimento sofrerá refatorações até chegar a um escopo_{que a funcionalidade atenda a proposta;}

3. Garante confiabilidade e qualidade no desenvolvimento do sistema, pois confirma o que foi testado antes mesmo de passar o código para o ambiente de_{produção, por exemplo;}

Portanto a utilização do JUnit traz uma maior eficiência, produtividade e qualidade_{nos códigos desenvolvidos.}

Observações

Geralmente o JUnit vem agregado em algumas IDEs, no caso: Eclipse, STS (Spring_{Tools Suite), entre outros…}

Sendo_{assim, não há necessidade de instalá-lo manualmente!}

Mas_{caso queiram ver a instalação do JUnit, recomendam-se estes dois links:} ● https://www.youtube.com/watch?v=AzQGk-j0E34

(5)

São vídeos para uma introdução, mas que servem para auxiliá-lo(a) durante uma_{instalação e um conhecimento sobre este framework.}

Anotações

Neste_{tópico o núcleo do assunto é mostrar as principais anotações do JUnit.} As anotações têm por objetivo dar informações sobre um código ou programa escrito e por isso, assemelham-se aos comentários. Porém, as anotações podem ser interpretadas por compiladores, adicionando certas funções que automatizam ou facilitam algumas tarefas. Podem ser utilizadas para informar ao compilador para suprimir avisos e mensagens de erro, gerar código (XML) e executar testes. No JUnit,_{as principais anotações são:}

● @SpringBootTest_{: Esta anotação}diz ao Spring Boot para procurar uma classe de configuração principal (uma com @SpringBootApplication, por exemplo)_{e usá-la para iniciar um contexto de aplicativo Spring;}

● @RunWith_{: Invoca uma classe (que contém rotinas de testes) para a} realização de testes sobre uma determinada classe. O JUnit possui sua própria classe de testes (JUnit Core) que contém vários métodos, mas também permite que o desenvolvedor escreva uma classe com métodos de testes_{personalizados, inclusive com métodos escritos por ele;}

● @Test_{: Esta anotação define a execução de um método em modo de teste.} Para executar o método, primeiro o JUnit constrói uma nova instância da classe e então invoca o método anotado. Quaisquer exceções lançadas pelo teste serão relatadas pelo JUnit como uma falha. Se nenhuma exceção for lançada, o teste é finalizado como concluído com sucesso. Também suporta dois parâmetros opcionais: expected e timeout. O parâmetro expected declara que o retorno de um método deve ser uma exceção. Desta forma, se o método não retorna uma exceção ou de ela é diferente da que foi declarada,_{o teste é considerado com falha. Por exemplo:}

@Test(_{expected=IndexOutOfBoundsException.class)} public void outOfBounds()_{

new ArrayList<Object>().get(1); }

Deverá_{ser executado com sucesso.}

O parâmetro timeout especifica o tempo máximo de execução de um teste. Se ele demorar mais do que o especificado, o teste é considerado como_{falha. Por exemplo:}

(6)

@Test(_{timeout=100) public void infinity() {} while(true);

}

Deverá_{ser considerado como falha.}

Imagem_{01: Estrutura dos métodos outOfBouns e infinity;}

Imagem_{02: Resultado da execução dos métodos da primeira imagem;}

Observa-se, na _{imagem 02, que o método outOfBounds executou com} sucesso_{e o método infinity não executou com sucesso.}

(7)

Estrutura

_{do JUnit}

Neste tópico a abordagem do tutorial é o foco da estrutura do JUnit num projeto de_sistema.

Imagem_{02: Estrutura de diretório, pacote e classe do JUnit;}

Percebe-se que dentro do diretório da aplicação, os códigos de testes desenvolvidos no JUnit são guardados/salvados numa classe que possui o mesmo nome_{da classe da aplicação, no entanto inclui-se o nome teste.}

Desse modo, atente-se, também, que o pacote se encontra numa pasta java, entretanto_{esta pasta está dentro da pasta test e, por sua vez, está na pasta src.}

Estas dicas são essenciais para um desenvolvimento de trabalho digno, pois mantendo uma estrutura segundo a _{imagem 02, a equipe de desenvolvimento deixa} de_{contar com a sorte e potencializa a qualidade da entrega final do projeto.}

(8)

Imagem_{03: Estrutura da classe do JUnit;}

Observa-se na _{imagem 03 que a estrutura de uma classe de testes, possui} algumas importações. Destacam-se as importações das anotações: Test, SpringBootTest,_{RunWith e o SpringRunner.}

Este será o padrão utilizado em todas as classes de testes criadas, portanto o usuário_{necessitará seguí-lo.}

Imagem_{04: Classe UtilSocketTest com os métodos de testes declarados;}

Repare-se_{que foram criados diversos métodos para os seguintes cenários:} ● Fluxo_{perfeito, quando a aplicação gera o retorno que é o correto, esperado;} ● Fluxo_{com exceção, quando a aplicação gera alguma exceção esperada;}

(9)

Este_{método com exceção serve para os demais serviços.}

Utilizando

_{o JUnit durante os testes}

A_{intenção deste tópico é discorrer sobre a utilização do JUnit durante a} execução_{dos testes.}

Imagem_{05: Exemplo de uma execução da classe de teste.}

Imagem_{06: Exemplo de uma execução de teste ocorrida com sucesso;}

Atente-se que a _{imagem 05 exibe um exemplo de método que validará a} funcionalidade,_{método, que o desenvolvedor criará.}

O que seja, realmente, interessante em mostrar é que dentro do método existe uma classe chamada: assertTrue. Esta classe, junto com os métodos, permitem diversas maneiras de serem implementadas. Na classe de exemplo, obtém-se um teste com o assertTrue, isto faz com a resposta esperada seja validada com a resposta_{atual, mesmo estando diferentes.}

O intuito de colocar um assertTrue foi mostrar que o teste executado passou, de_{acordo com a imagem 06.}

(10)

Imagem_{07: Estatística de execução dos testes em JUnit.}

Repare-se que o JUnit possui uma área que mostra as estatísticas geradas após_{a execução dos testes, conforme imagem 07.}

No caso, a barra vinho demonstra que houve algum erro ou alguma falha. Pela

imagem 07 aconteceu uma falha num dos métodos e outro foi executado com

sucesso_{dentro da classe LibraryTest.}

Imagem_{08: Amostra de testes construídos;}

Repare-se que dentro da classe WordFinderTest possui métodos que esperam algumas_{exceções, por exemplo: Null pointer exception.}

É relevante ressaltar que durante a criação dos testes é de suma importância criar métodos que validem exceções. Até para analisar se um determinado método implementa_{o try/catch ou se ele repassa, throw, para quem o chamou.}

(11)

No caso da _{imagem 08, tem-se métodos com a validação de exceção, null} pointer_{exception, quando o texto é nulo, ou quando uma letra é nula.}

Imagem_{09: Amostra de outros testes construídos na classe WordFinderTest;}

Observa-se que existem outros métodos que fazem a validação desde encontrar a primeira letra, como encontrar a “maior” letra dentro de um array. Segundo_{imagem 09.}

Imagem_{10: Execução dos testes, na classe WordFinderTest, com sucesso;}

A estatística gerada na classe WordFinderTest, _{imagem 10, mostra que foram} executados_{oito (8) métodos e todos foram executados com sucesso.}

(12)

Imagem_{11: Amostra de métodos, test, da classe PalindromeCheckTest;}

Imagem_{12: Execução com sucesso da classe PalindromeCheckTest;}

Nas _{imagens 11 e 12 exemplificam os testes construídos e feitos na classe} PalindromeCheckTest. Observa-se que todos os testes construídos foram executados_{com sucesso.}

(13)

JaCoCo

Tópico_{que discorre um pouco sobre JaCoCo.}

Resumidamente, o JaCoCo é uma ferramenta que traz cobertura nos testes realizados no JUnit, trazendo métricas de conclusão a cerca dos testes feitos ou não.

Se_{caso não houvesse o maven ou o gradle, opte pela seguinte instalação:}

Imagem_{12: Instalação do plugin EcliEmma Java Code Coverage;}

A imagem 12 mostra a tela do _{install new software com a opção de instalar o} plugin_{EclEmma Java Code Coverage.}

Observa-se_{que a busca foi feita por JaCoCo no site: Oxygen.}

http://download.eclipse.org/releases/Oxygen

(14)

Imagem_{13: Cobertura dos testes com JaCoCo;}

De_{acordo com a imagem 13 a cobertura dos testes foi 80,8%;}

LEMBRE-SE:_{ESTE NÃO É O SEU CASO, POIS EXISTE O GRADLE.}

A esta altura o arquivo build.gradle já está configurado, portanto a execução do Jacoco_{fica mais simples e com dois comandos resolve esta situação.}

Imagem_{14: Visualização de uma parte da configuração do jacoco no build.gradle;}

A _{imagem 14 contém, apenas, para exibição uma parte da configuração do} jacoco_{no arquivo gradle.}

(15)

Imagem_{15: Opção do Run As no projeto Dedicatories;}

De acordo com a _{imagem 15, necessita pressionar com o botão direito em} cima do projeto, Dedicatories no caso, e selecionar a opção _{Run As e Run}

Configurations…

A partir dessa seleção, procure _{Gradle Project e pressione duas vezes. Isto} abrirá_{um new_configuration, conforme a imagem 15.}

Faça_{as seguintes modificações:}

● Gradle_{Tasks: Escreva clean build;}

Isto faz com que o gradle verifique as modificações do seu arquivo e as instale.

● Working_{Directory: Escolha o diretório do Dedicatories;}

● name_{: Caso mude o name, o nome deixará de ser new_configuration para}

outro_{nome qualquer, neste exemplo está clean build;}

Depois das configurações, aperte_{Run. Após o término do run, dentro da pasta} build, que está no diretório Dedicatories, haverá a pasta _{Jacoco, conforme imagem}

(16)

Imagem_{16: Pasta jacoco dentro da pasta build;}

Mas ainda não terminou, necessita criar outra _{Run Configuration do gradle} para_{configurar os tests reports do jacoco.}

Faça conforme o procedimento na _{imagem 15, escreva o name, para não} confundir com o que já existe, e, _{principalmente, escreva um novo comando no}

gradle_{task, isso é muito importante!}

● Gradle_{Task: Escreva clean build jacocoTestReport;}

Feito as configurações, execute _{Run. Após o término, deverá estar de acordo} com_{a imagem 17.}

(17)

Imagem_{17: jacocoTestReport build com sucesso;}

Pronto,_{está finalizado!}

Para_{verificar o arquivo html, acesse o caminho:}

\Dedicatories\build\reports\jacoco\test\html

Selecione_{o arquivo index.html, conforme imagem 18.}

(18)

Referências

● https://www.youtube.com/watch?v=r-CbsG7x0h8 ● http://www.devmedia.com.br/entendendo-anotacoes-em-java/26772 ● http://www.tiexpert.net/programacao/java/annotations.php ● http://junit.sourceforge.net/javadoc/org/junit/Test.html ● http://tdd.caelum.com.br/ ● https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-te sting.html