[MÚSICA] [MÚSICA]
Bem-vindo de volta ao nosso hands-on, certo?
Estávamos aqui pensando como vamos fazer aqui o teste
para verificar aí se a gente consegue fazer com que,
fazer esse teste, né, se o Mock der problema,
se o Mock jogar uma exceção, eu quero que os próximos, né,
se o Mock não, se observador do carrinho jogar uma exceção,
eu quero que os próximos continuem a ser notificados, tá?
Então, eu vou fazer o seguinte,
eu vou copiar aqui, né, eu vou colocar aqui
o nome do teste vai ser: continua notificando
com erro observador.
Tá? Os meus nomes não são os melhores do
mundo, mas são nomes que conseguem me remeter ali o que o teste,
o cenário do teste está verificando, tá?
Então, vamos fazer o seguinte: eu vou adicionar 3 observadores na minha classe,
então, 1, 2, 3, tá?
Eu vou chamar aqui o mock2, né,
quando eu criar ele, eu vou colocar aqui, mock2 ponto
[SEM_ÁUDIO] vou botar aqui
quero QueVoceDePau, certo?
Não é nome muito convencional, né, mas fica aí uma...
para você refletir aí nome melhor, tá?
Então, eu quero que o mock2 dê pau.
Tá? Então, eu vou adicionar né,
os 3 mocks aqui no meu carrinho, tá?
[SEM_ÁUDIO] E aí eu quero
que o mock1 e o mock3, né, o 2, ele vai dar pau ali,
mas eu quero que o mock1 e o mock3, eles tenham recebido ali o produto, tá?
Então, vou salvar como eu falei, fazer aqui o mock faz parte, né,
então, vou vir aqui, vou criar esse método queroQueVoceDePau,
né, e vou colocar aqui uma variável booleana,
que é, darpau.
Só que o darpau vai ser falso a princípio, tá?
Então, quando eu falar que eu quero que aquele mock dê pau,
então, eu vou fazer o darPau igual a true.
Então, quando o produto, ele for adicionado,
né, eu vou vir aqui eu vou verificar, se for para dar pau,
então, eu vou dar throw
new RuntimeException.
E aí eu vou colocar aqui uma mensagem, né,
Problema simulado pelo mock.
Certo?
Então, eu posso salvar aqui, rodo aqui,
ele está dando erro, qual que é o problema dele?
Ele está dando aquela exceção, certo?
Então, vou vir aqui, no meu carrinho de compras,
vou ter que fazer ele não jogar aquela exceção, né, então,
nessa parte que ele notifica aqui eu vou colocar aqui por exemplo,
vamos ver aqui, Surround With, Try/catch Block,
né, então se der uma exceção, eu não quero que ele faça nada, né,
por enquanto é lógico que não é uma boa prática deixar catch vazio,
mas eu deveria guardar esse problema algum lugar, né,
por enquanto eu não tenho nenhum requisito relação àquilo.
De repente poderia guardar,
mas o que é importante para mim é que o fato de observador dar problema,
não quero que os outros parem de receber, então, aqui,
eu estava tendo, o meu teste estava dando esse problema simulado pelo mock,
vou rodar de novo, agora né, ele mudou, ele está, continua dando pau,
mas o problema agora é que o mock3 não está recebendo a notificação.
Tá? Então,
o que é que será que eu fiz aqui errado né?
Quando ele estava fazendo o try/catch, né, ele sai do for,
então, eu quero que esse for aqui,
seja fora, né, aqui então,
o meu try/catch vai ser só com o que está dentro do for, aí começou a ficar
complicado aqui essa questão do que é que está dentro, o que é que está fora.
Então, vou vou colocar aqui,
né, o, as chaves aqui, será que agora vai dar certo?
Então, salvo aqui, rodo, vamos ver.
Agora funcionou!
Tá? Então, o objetivo aí desse hands-on foi
mostrar pouquinho para vocês essa parte da criação do mock, como é que isso funciona,
né, e mostrar aqui por exemplo, esse último teste, eu acho bem interessante,
né, onde a gente tem a presença ali de vários mocks que são instâncias do mesmo,
né, você viu que a gente criou primeiro o mock, depois a gente conseguiu reutilizar
ele exatamente da forma que ele tinha sido criado no próximo teste,
já para esse teste, a gente precisou de mock diferente, tá?
E com isso a gente vai fazendo aí a nossa implementação.
Só para mostrar aqui para vocês, para a gente poder
fechar aqui mesmo com chave de ouro, né, o que eu fiz aqui foi...
eu tenho duas alternativas quando eu precisar de mock diferente,
eu posso tanto vir aqui, e criar, né, uma configuração
que eu diga que eu quero que dê pau, etcetera,
ou eu posso criar novo mock, uma nova classe, né?
Eu posso criar, por exemplo, aqui só para a gente ilustrar a classe
que seria aqui o MockObservadorComProblema.
Tá?
Ele ia implementar a classe ObservadorCarrinho
implementar a interface ObservadorCarrinho, tá?
E aí aqui, eu simplesmente
jogaria essa exceção.
[SEM_ÁUDIO] Certo?
Então, o que eu faria aqui no teste ao invés de eu criar o mock e dizer que
eu quero que ele dê pau, eu criaria o MockObservadorComProblema.
Tá? E aí aqui,
simplesmente observador carrinho.
Tá? Funcionaria exatamente da mesma forma e de
repente eu não precisaria ficar...
Está faltando ponto e vírgula aqui, eu não precisaria ficar...
A gente pode rodar aqui, ele funciona igualzinho, tá?
A gente não precisaria ficar criando aqui monte de if e etcetera no mock.
A gente tem essas duas formas de fazer, eu deixo aí a opção para você utilizar,
né, verificar que cada cenário o que é que é mais adequado ou não.
Então, foi isso, espero que vocês tenham aprendido aí com esse hands-on de uma
forma mais prática como trabalhar com Mock Object.
Muito obrigado, continue assistindo o nosso curso.
[MÚSICA]
Clovis FernandesProfessor Titular in Portuguese
Eduardo GuerraProfessor Colaborador
