[MÚSICA] [MÚSICA] Olá a todos,
meu nome é Eduardo Guerra.
Esse é o Curso de Desenvolvimento de Software Guiado por Testes.
Hoje vamos falar sobre a situação de quando a dependência ainda não existe não
é, que é pouquinho sobre o design do software utilizando o TDD, está?
Então, a gente vai aprender a fazer, vamos falar pouquinho aqui,
depois a gente vai ver hands on para ver pouquinho mais na prática,
sobre como você vai fazer o TDD numa classe que tem uma
dependência e principalmente quando essa dependência não existe ainda.
Ou seja, eu quero desenvolver uma classe que ela depende de outra que não existe
ainda, como é que eu faço para desenvolver essa classe, certo?
Então vamos lá, o caso que a gente vai pegar é esse aqui que
eu estou representando na figura: a gente vai ter que fazer o teste com a classe,
a gente já viu como é que faz o teste antes da classe existir,
só a gente vai desenvolver a classe agora antes da dependência dela existir.
Então para fazer isso,
para ficar uma coisa mais concreta para vocês a gente vai pegar exemplo, está?
Então imagina que a gente vai estar criando uma classe não é,
que seria serviço de login, está?
E esse serviço de login, não é, que tem essa lógica de " eu
tenho usuário mas sem eu quero saber quero autenticar ele no meu sistema", está?
Então essa classe ela precisa interagir aí com uma base de dados,
não é, que é responsável por fazer consultas no banco de dados.
Então eu tenho a minha classe que é o serviço de login que ela teria essa
dependência que é essa classe que acessa o banco de dados.
A questão é que essa classe que acessa o banco de dados ainda não existe no meu
sistema, está?
Então, ou seja eu tenho que dar jeito de fazer o teste sem ela existir ainda, está?
Então o que é que a gente vai fazer?
A gente vai estar fazendo o TDD não é, envolvendo somente aquela classe,
não é, somente a classe do serviço de login e aí a gente já viu que para
fazer isso a gente vai estar substituindo o mock aqui por ou mock,
a gente vai estar substituindo DAO por mock, certo?
Então vamos começar a pensar, com TDD a gente pensa a partir do teste,
então a primeira coisa que a gente faria seria "olha eu preciso instanciar
a minha classe serviço login, não é, então está ali cima.
Na segunda linha eu crio o meu mock object que eu vou colocar no lugar do DAO,
lembrando que aqui eu estou escrevendo o teste, nada disso existe ainda,
nem a classe nem o mock, está?
E aí eu vou e seto esse DAO, não é,
eu seto o mock colocando ele no lugar do DAO na classe que eu estou desenvolvendo.
Então esse é o primeiro passo, é a minha forma como a partir do teste falar
"olha eu estou criando essa classe, eu estou criando aqui mock de uma dependência
que vai ser uma dependência dessa classe e estou colocando esse mock dentro dela,
lembrando que eu poderia por exemplo estar colocando a partir de construtor não é,
a gente viu as outras formas aí de injeção de dependência nas outras aulas.
Então o primeiro passo seria esse.
O segundo passo é saber qual que seria o resultado esperado do teste.
No caso aqui, para simplificar,
observe que eu coloquei ali assertTrue, eu chamando o método login guerra e senha.
Vocês acharam que eu ia botar a minha senha de verdade ali, não é?
Lógico que eu não vou colocar, não é, vai ser só senha.
Então no caso ali eu espero que ele retorne verdadeiro está?
Então esse caso de teste, não é,
até o nome do método a gente pode ver que é loginComSucesso, não é,
eu estou falando "olha eu tenho aqui o meu serviço de login, eu tenho o mock,
coloquei o mock dentro dele, quando eu chamar o método login ele tem que,
com guerra e senha, ele tem que retornar verdadeiro, está?
Então, para isso eu preciso dizer por exemplo,
que eu espero que o meu DAO, ou seja o mock que está no lugar do DAO,
não é, eu espero que ele receba uma chamada com guerra, não é?
Então o usuário que eu espero que ele receba como parâmetro é guerra.
E eu também vou dizer que eu quero que ele retorne a senha "senha", está?
Então o que é que eu estou falando ali?
Olha eu tenho mock no lugar do DAO, eu quero que ele,
uma chamada de método dele, ele vai perguntar "olha qual que é a senha desse
usuário e esse usuário que ele vai passar tem que ser guerra, e esse método, não é,
do DAO que vai estar retornando a senha, o valor senha, está?
Então nessas duas chamadas eu estou configurando como eu
quero que o meu mock funcione.
está?
E aí, por fim, eu vou ali
e coloco depois do assert o mock.verificarChamadas.
O que é que esse cara vai fazer?
Ele vai estar verificando se a chamada recebida pelo
mock foi aquela que eu esperava está?
Como eu já disse anteriormente, você criar o mock faz parte do teste,
então, eu vou para o meu mock, antes de começar a criar a classe que eu estou
querendo desenvolver eu vou lá e vou criar o meu mock.
Vocês vão ver no hands on que o, a partir ali dos atalhos do Eclipse também
facilita bastante eu já ir fazendo esses métodos brotar ali na minha classe,
na classe que está representando o mock, está?
Então vamos ver como que seria o mock aí para poder criar
esse teste que eu estou querendo.
Então a primeira coisa do mock é que ele
precisa implementar a interface e ele precisa obviamente,
se ele está implementando a interface ter todos os métodos que ela define.
No caso ali, a minha interface do DAO seria o usuarioDAO e no caso seria,
o método que eu preciso, seria o método getSenha onde eu
passo o usuário e ele me retorna a senha desse usuário, está?
Uma pequena observação aqui, essa não é a forma mais segura de você fazer
uma autenticação, retornando a senha, certo?
A gente usa aí hash e tudo mais, tem monte de coisas, está, é realmente só exemplo,
não vá fazer dessa forma o login do seu sistema.
Seguida eu vou adicionar no meu mock todos aqueles métodos que eu defini no teste,
então esses métodos eles são métodos do mock.
Note que o método da classe, eu deixei ali @Override, não é, para a gente ver que é o
método da interface e os outros métodos não tem nada, são nada,
são métodos específicos do mock,
são métodos que eu preciso que o mock tenha para poder fazer o meu teste.
Então é o usuarioEsperado, retornaSenha e verificaChamadas.
E agora o que eu preciso fazer é implementar a lógica do mock de
acordo com o que eu quero que ele verifique para mim, está?
Então vamos lá.
Eu tenho aqui o meu usuarioEsperado, não é,
que eu configuro e note que eu guardo lá cima, então lá cima eu
tenho variáveis para guardar o usuário, a senha e o usuário esperado.
No caso esse usuário é o usuário que eu estou recebendo
efetivamente no método getSenha.
está?
Eu tirei o @Override ali só para ficar mais curtinho aqui para a gente ver, está?
Então o que é que eu faço?
No método usuarioEsperado eu simplesmente eu vou guardar isso daí.
No método retornaSenha eu também vou guardar a senha que eu quero que ele
retorne.
No método getSenha o que é que ele vai fazer?
Ele vai guardar o usuário que ele receber, no caso nessa variável
de instância usuário e vai retornar a senha que ele tem configurada,
que eu configurei pelo método retornaSenha.
E aí no método verificarChamadas ele vai verificar se o usuário
que ele recebeu é igual ao usuário que ele esperava receber.
E aí a gente consegue com isso ter teste que executa,
ter teste que falha e aí o teste falhando é tudo o que a gente precisa do TDD
para seguir frente ao desenvolvimento e continuar desenvolvendo a classe.
Quem quiser aí praticar pode pegar esse exemplo aí,
fazer o usuário logando com sucesso, o usuário falhando, não é?
Por exemplo como simular aí erro no banco de dados, não é,
que não tem a ver com o retorno que é dado, certo?
Então tudo isso daí você continuaria ali o TDD,
depois que você fizesse o primeiro teste passar, iria acrescentando novos
testes todos eles usando ali o mock para continuar o desenvolvimento.
Bom então é isso, nessa aula a gente viu pouquinho como que a gente procede,
como é que a gente cria o teste, não é?
A gente falou muito sobre o mock object nas aulas anteriores mas não falamos
muito como o uso dele dentro do TDD, como que a gente vai definindo
e criando o mock sem nem a dependência existir, sem nem a classe existir.
Então nessa aula a gente viu pouquinho desses passos,
como que a gente vai pensando "espera aí, para dar esse resultado que eu quero eu
preciso que a classe retorne tal coisa" ou eu preciso que a chamada, depois eu tenho
que verificar se ela receber tal parâmetro na chamada dela, não é?
Então a gente foi vendo como proceder dentro desse
raciocínio aí enquanto a gente está fazendo o TDD de uma classe que tem uma
dependência e a gente está utilizando o mock object para definir também
quais são os métodos que essa dependência vai ter, certo?
Muito obrigado por assistir e até à próxima aula.
[MÚSICA]
