[MÚSICA] [MÚSICA]
Esse é o curso de Orientação a Objetos com Java, meu
nome é Eduardo Guerra e hoje vamos falar sobre testes automatizados com JUnit.
O objetivo é que nessa aula você saia sabendo criar testes automatizados,
que você vá lá e teste a sua classe e possa cada vez simplesmente
ir lá mandar rodar de novo, reverificar todo aquele comportamento da sua classe,
hoje vamos aprender como fazer isso.
Antes de começar a explicar o JUnit,
vamos falar pouquinho sobre a importância de automatizar os seus testes.
Imagina esse cenário aqui: eu vou lá no meu projeto, crio uma funcionalidade A,
eu preciso ir lá e testar essa funcionalidade A.
Seguida eu vou lá e crio uma funcionalidade B,
o que vai acontecer é o seguinte: na hora de testar a implementação dessa
funcionalidade B, ela pode ter influenciado no código de A,
eu posso para criar esse B, eu posso ter mexido no A também.
Então na hora de testar eu não só tenho que testar a nova funcionalidade,
que é a B, mas também a funcionalidade A.
Esse tipo de teste a gente chama de teste de regressão,
a gente não deve só testar aquilo que é novo mas também testar o que já tinha para
ver se aquela coisa nova não atrapalhou nas coisas que já estavam funcionando.
E aí se eu for lá e criar uma funcionalidade C, eu vou precisar não só
testar C mas também a A e a B e com isso dá para a gente perceber que,
com o tempo, eu vou ter sempre mais coisas para testar independente se eu
estou desenvolvendo aos pouquinhos, eu vou precisando cada vez testar mais coisas.
Eu já participei de projeto que o tempo que o teste demorava,
que as pessoas demoravam para fazer os testes era maior do que o tempo de
desenvolvimento, para você ver como que esse tipo de coisa pode
influenciar e pode impactar no tempo do projeto.
E isso para o desenvolvimento ágil que trabalha com pequenas iterações,
digamos assim é inaceitável, você ter essa carga de testes.
Por isso é muito importante automatizar os testes, está?
Muitas vezes a gente não consegue automatizar todos os testes,
eu por exemplo participei a pouco tempo de projeto que mexia com
câmeras e pan tilts e software que interagia com esse tipo de hardware,
então essa parte do código a gente tinha testes manuais mas a maior parte do código
que era o que a gente conseguia era sempre importante tentar automatizar os testes.
Falando testes,
existem vários tipos de testes que a gente pode utilizar para diferentes propósitos.
Na aula anterior eu cheguei a falar alguns aqui.
Então eu vou colocar 3 tipos aqui de acordo com o escopo.
O teste de unidade ele testa uma única classe, único método ele,
digamos assim testa a unidade do software, separado do resto.
O teste de integração normalmente ele pega
componentes ou aquelas funcionalidades que têm várias classes
integradas para ver se juntas elas estão formando a funcionalidade não é?
Então por exemplo pegando aquele exemplo, lá da outra aula, do carrinho de compras
que colaborava lá por exemplo com a outra classe lá, o carrinho tinha a classe
responsável pela parte da entrega, não é, o endereço, a compra.
Então por exemplo,
testando o carrinho isolado das outras classes seria teste de unidade.
Se eu testasse, por exemplo a classe compra que utiliza o carrinho,
utiliza o endereço e tem várias coisas ali, digamos assim está combinando as
funcionalidades de várias classes para chegar numa única funcionalidade, não é,
para chegar numa execução, esse seria teste de integração.
Se eu estou testando o software do ponto de vista do usuário, eu chamo esse
teste de teste funcional, que é aquele que, eu não estou pensando se é a unidade,
se é o componente, eu estou testando o software do ponto de vista do usuário.
E o que a gente vai ver, como a gente está falando de automação de testes é que
muitas vezes não tem muita diferença como esses testes são criados,
é mais relação ao escopo deles.
Então se você está por exemplo, fazendo teste cima de uma classe
que ela está isolada do resto, você está fazendo teste de unidade.
Muitas vezes você pode fazer o teste exatamente da mesma forma só que aquele
teste ao invés de envolver uma classe ele está envolvendo várias que estão
combinando as suas funcionalidades,
então ele vai passar já a ser teste de integração.
Mas a ferramenta, a forma que você está criando o teste, muitas vezes é a mesma,
o que varia é o escopo daquele teste.
A gente vai aprender aqui, e vai utilizar durante o nosso curso, a ferramenta JUnit.
O JUnit ele é praticamente o padrão para a criação de testes Java.
Existem outras ferramentas, como o teste NJ, que você também pode utilizar,
que também são muito boas, tem funcionalidades bem interessantes,
mas no nosso curso a gente vai focar no JUnit.
Apesar do JUnit ele ser muito utilizado para testes de unidade ele também
é utilizado para outros tipos de testes como para testes funcionais,
para testes de integração.
Muitas vezes o JUnit ele é utilizado como base para outro framework,
para uma outra ferramenta para a realização desses testes.
O JUnit ele é basicamente uma biblioteca para a execução de testes,
para essa automação de testes, agora o que,
o objeto do seu teste aí fica ao seu critério.
Então a primeira coisa que a gente tem que saber é que uma classe do JUnit não
precisa ter nada de especial.
Eu simplesmente, por exemplo se eu quero fazer teste de uma calculadora eu
vou criar ali uma classe TestCalc, não é, e ela vai está fazendo aí esse teste.
Para eu criar método de teste que efetivamente vai estar testando alguma
coisa eu preciso colocar essa anotação @Test cima do método, está?
Então, por exemplo eu quero testar se a calculadora está testando corretamente
não é, então eu vou criar método chamado testeSoma onde eu vou realizar esse teste
e vou anotar com o @Test para que o JUnit saiba que aquele método é método de teste.
Não podemos esquecer de importar as classes do JUnit que a gente utilizar,
por exemplo se eu estou utilizando a anotação @Test eu preciso estar
importando essa anotação para dentro da minha classe,
então eu vou ter que ter lá import org.junit.Test.
Dentro do método de teste eu preciso exercitar aquela
funcionalidade que eu quero verificar.
Então por exemplo, eu estou criando aqui o meu objeto Calc e estou
invocando o método add nele para poder somar o 3 com
2 e retornar o resultado ali para a minha variável i, não é?
Então se eu estou fazendo o teste de uma funcionalidade eu tenho que rodar aquela
funcionalidade.
Nesse ponto é importante ressaltar que eu preciso estar
criando o cenário necessário para poder executar aquela funcionalidade.
Então de repente se eu preciso criar ali arquivo de configuração,
eu preciso setar alguma coisa no meu banco de dados, não é,
então nesse momento, antes de exercitar essa minha funcionalidade eu vou estar,
por exemplo às vezes eu preciso configurar uma variável no meu objeto ou num
objeto que eu estou passando como parâmetro eu preciso criar
objeto para passar como parâmetro então tudo isso vai, vai nessa parte.
de criar todo esse cenário, todo esse ambiente para que eu possa exercitar
a funcionalidade da forma que eu quero que ela seja exercitada.
Bom, a última coisa do teste que precisa é compara o resultado,
então por exemplo eu vou utilizar o método assert,
eu tenho vários métodos que eu posso utilizar,
bastante comum é o assertEquals que eu vou verificar por exemplo se o i que o
meu método add retornou se ele vai ser igual a 5.
Então só para vocês verem eu tenho aqui vários dos métodos
assert que eu posso utilizar eu tenho que verifica se é verdadeiro,
verifica se é falso, se compara se é igual, no caso a diferença entre o Equals
e o Same é que o Equals ele vai chamar o método Equals do objeto e o Same
vai verificar se é a mesma instância memória, verifica se é Null e
eu posso utilizar todos esses métodos e eu posso inclusivé criar o
meu próprio método de assert, não é, se eu tiver por exemplo uma comparação pouco
mais sofisticada que eu quero fazer no meu teste, nada impede de eu fazer isto.
Fique tranquilo que a gente vai, nos 'iii', não só no próximo, não é,
mas ao longo de todo o curso procurar sempre estar criando testes
e à medida que as aulas forem passando vocês vão ficar cada
vez melhor na criação de testes de unidade.
Justamente por isso que a gente decidiu colocar logo
no começo do curso essa parte de testes para que, à medida a gente for
vendo as outras partes a gente possa ir vendo como criar os testes para cada
tipo de coisa que a gente for vendo aí na orientação a objetos, não é,
com a colaboração de classes e etc.
Então por favor pare de dar print para testar,
pára de ficar imprimindo o resultado da sua classe na tela para testar,
agora você já sabe criar testes automatizados,
crie os seus testes verifica a sua funcionalidade.
Aquela mesma, aquele mesmo codigozinho que você fazia "
eu criei uma calculadora então eu vou pegar aqui,
vou mandar somar e vou imprimir o resultado e vou ver se está certo".
Ao invés de você fazer isso, pega esse código, coloca dentro de uma classe do
JUnit, ao invés de ficar vendo se o resultado está certo ou não coloca
assert para relamente verificar e utilize isso para que você sempre que precisar,
de repente você mexeu na classe ou você está mexendo no seu sistema você possa
sempre rodar aquele teste de novo e saber se ele ainda está funcionando,
se ele parou de funcionar e etc.
Eu espero que, não é complicado criar testes automatizados,
eu espero que com essa aula você já saiba agora utilizar o JUnit para a criação de
testes automatizados e espero também que você tenha visto a importância de
automatizar os testes, não só a importância de testar mas a importância de
automatizar o máximo possível os seus testes.
Muito obrigado por assistir.
[MÚSICA]
