Hands-on: Adições no Carrinho de Compras - Parte 1

Loading...

From the course by Instituto Tecnológico de Aeronáutica

TDD – Desenvolvimento de Software Guiado por Testes

319 ratings

Instituto Tecnológico de Aeronáutica

TDD – Desenvolvimento de Software Guiado por Testes

319 ratings

Neste curso, assumimos que você já sabe projetar e desenvolver programas mais complexos em Java, com método e organização graças às boas práticas e princípios exercitados no curso anterior; mas você talvez não se sinta ainda confortável em projetar programas usando técnicas ágeis, como o desenvolvimento guiado por testes (TDD). O objetivo deste curso é expor você aos princípios e práticas de desenvolvimento guiado por testes, tanto para modelar quanto para desenvolver aplicações e componentes de software, sem abandonar os conceitos e princípios de orientação a objetos aprendidos no curso anterior. De fato, pregamos que tais conceitos e princípios fortalecem o emprego do TDD no desenvolvimento ágil de software com mais qualidade. Este curso terá um grande foco em atividades hands-on, permitindo a você captar todos os aspectos práticos da técnica e facilitar a sua aplicação quando estiver projetando e desenvolvendo software de maneira ágil nos próximos cursos. Os conceitos de desenvolvimento de software com Java apresentados neste curso incluem o seguinte: revisão de testes de unidade; automação de testes; desenvolvimento guiado por testes; ciclo do TDD; refatoração de código de produção; ciclo de refatoração; uso de objetos stubs e mocks; boas práticas no TDD; modelagem de software por meio do TDD. Ao final deste curso, você terá amadurecido de tal modo suas habilidades de programação que será capaz de implementar, agora usando o TDD, versões modificadas e estendidas do componente de gamificação constante do Trabalho de Conclusão da Especialização, com base nas boas práticas exercitadas neste curso.

From the lesson

Semana 3

Olá! Bem-vindo à Semana 3 do curso sobre TDD! Nesta semana você aprofundará seu contato prático com casos de teste e com dependências entre classes no contexto do TDD. Ao final desta semana, você será capaz de: 1) modelar casos de teste a partir de responsabilidades para uso no ciclo TDD; 2) testar classes com dependências por meio de mock objects.

Quando a dependência ainda não existe...10:50

Hands-on: Adições no Carrinho de Compras - Parte 110:52

Hands-on: Adições no Carrinho de Compras - Parte 26:55

Hands-on: Adições no Carrinho de Compras - Parte 38:32

Mockar ou não mockar? Eis a questão!16:39

Meet the Instructors

Clovis Fernandes
Professor Titular in Portuguese
Ciência da Computação
Eduardo Guerra
Professor Colaborador

[MÚSICA] [MÚSICA] Olá a todos!

O meu nome é Eduardo Guerra.

Esse é o curso de desenvolvimento de software guiado por testes.

Nesta aula vamos fazer hands on para aprender a usar Mock Objects.

Para isso a gente, eu já preparei aqui cenário não é?

Onde a gente não tem ainda nenhuma dependência,

mais para a gente já ter ponto de partida está?

A gente tem aqui uma classe chamada Produto,

que só tem aqui o nome e o valor do produto, está?

A gente tem uma classe aqui chamada CarrinhoCompras não é?

Que ela tem aqui método que permite que você adicione produtos, não é?

Tem atributo ali para guardar a lista de produtos aqui chamada itens

e tem método total, que retorna o total ali do carrinho de compras está?

E por fim, como não poderia deixar de ser, temos teste de unidade não é?

Que faz o teste aqui desse método total,

onde ele adiciona os produtos e verifica aqui o total não é?

A gente pode rodar isso daqui não é?

Esse, esse teste e a gente vê aqui que está passando está?

O quê que vamos fazer?

Eu quero que eu possa adicionar nesse carrinho observadores, não é, classes que

vão receber notificações quando produtos forem adicionados naquele carrinho.

Para quê que serve isso, não é?

Por exemplo, se eu, eu, eu posso querer ter observador

do sistema de estoque para para poder por exemplo dar baixa produto ou

deixar o produto reservado, ou posso ter observador de preferências do usuário para

quando ele adicionar produto no carrinho, eu ver de que tipo que é e querer é, é,

adicionar nas preferências dele aquele tipo, alguma coisa desse tipo está?

Só que a gente não vai entrar no detalhe, porque a gente vai fazer o seguinte:

a gente vai, na classe Carrinho, é, é, criar essa ideia do observador

a partir de uma interface e depois quem quiser que implemente aí, está?

Então a gente vai exercitar aqui a parte de Mock Object fazendo esse

exemplo aí, ok?

Então vamos lá.

A primeira coisa que eu quero não é?

É poder é, é, fazer com que o carrinho ele escute não é?

É, produto aqui não é?

Eu posso adicionar observador que vai adicionar.

Uma observação não é?

Uma observação sobre observadores é que esse é padrão chamado Observer está?

Não é o escopo da nossa aula mas fica aí para o conhecimento de vocês está?

Então como sempre eu vou começar fazendo teste aqui não é?

Opa, ficou e a mais.

É então eu vou lá public void, eu vou colocar aqui

escutaAdiçãoDeProduto, está?

Então eu vou vir aqui, vou instanciar aqui o carrinho

de compras é c é igual

a new, vamos lá, facilita aí.

Vem o carrinho de compras e eu vou aqui adicionar,

eu vou criar aqui o meu mock é, como é que eu vou chamar isso aqui?

Escuta, observador, eu vou chamar de observador carrinho não é?

Então mock é, é igual a new

MockObservadorCarrinho.

E agora eu vou vir aqui no meu carrinho não é?

E vou adicionar observador,

que vai ser o meu mock, está?

Então o quê que eu vou fazer?

Eu vou adicionar produto, está?

E é, o meu mock não é?

Ele vai ter que verificar não é?

Verifica recebimento, opa!

Produto.

No caso ali o meu mock eu não quero que ele receba, por exemplo,

essa minha classe, eu não quero que ele receba diretamente a classe Produto,

eu quero que ele receba só o nome e o preço.

Então ele vai verificar o recebimento do produto está?

Então o quê que eu tenho que fazer agora?

Eu tenho que criar o mock está?

O mock ele faz parte do teste,

então criar o mock faz parte de criar o caso de teste, está?

Então eu vou vir aqui, está?

Eu vou criar a classe MockObservadorCarrinho.

[SEM ÁUDIO] essa classe ela vai ter que implementar não é?

Uma interface, que é a que a minha, a classe lá vai aceitar.

Então eu já vou, eu já vou criar ela aqui também, que aí eu vou definir o quê que é

o método do mock, o quê que é o método da interface, está?

Então eu já vou vir aqui e mandar criar a interface ObservadorCarrinho.

[SEM ÁUDIO] Então

eu já vou definir aqui na minha interface que ela tem que ter método que é, é,

é, vai chamar aqui ó produtoAdicionado que é a,

que é a notificação que ele vai receber que produto foi adicionado, é,

e ele vai receber aqui o nome do produto e o é,

valor daquele produto, está?

Então essa aqui é a minha interface.

Então o meu mock obviamente, como ele implementa aquela interface,

ele precisa é, ter esse método, certo?

Então vamos salvar aqui é, eu ainda tenho o método do mock não é?

Eu tenho esse adicionaObservador, está?

Eu vou criar o método aqui na minha classe,

só que ao invés de ele receber o MockObservadorCarrinho,

ele vai receber só ObservadorCarrinho, que é a abstração, não é?

Então eu vou chamar aqui de observador.

Então salvo, é e eu ainda tenho aqui esse verifica o recebimento do produto.

está? Então eu vou criar esse método aqui

no mock.

E aí, como eu falei, criar o mock faz parte da criação do teste.

Então eu vou vir aqui e vou fazer: olha o produto que ele adicionar aqui,

eu vou ter que verificar se ele foi recebido ali.

Então eu vou criar aqui é,

é, uma string aqui não é?

Então eu vou chamar aqui de é,

produto, é nome produto recebido,

nomeRecebido e eu vou criar aqui uma variável

inteira que vai ser o valor recebido, está?

Então quando ele adicionar o produto, eu vou armazenar isso aqui, não é?

Então o nome recebido ele é igual ao nome,

o valor recebido ele

é igual ao valor, e aqui eu vou verificar não é?

Eu posso usar os métodos assert do próprio Eclipse não é?

Do próprio Eclipse não, do próprio JUnit.

Então eu vou usar aqui assert, aí é que eu vou usar aqui a classe Assert.

Não, eu vou importar ali, eu vou fazer o import

static aqui igual a gente faz lá no JUnit não é?

Eu vou importar os métodos ali do assert, eu acho que ele está dando errado.

Vamos ver o quê que é que ele, é junit.assert está?

Então vamos, vamos, eu vou copiar esse esse

aqui para eu poder usar os asserts aqui.

Então eu vou usar aqui o assertEquals o nome recebido.

Então na verdade aqui ó,

e aí você verifica aqui, que seria aqui o nome esperado, não é?

Que é o que eu estou passando lá no teste e aqui é o valor esperado.

Então é, o nome esperado ele tem que

ser o valor esperado ó, o nome esperado,

tem que ser o nome recebido e

o valor esperado tem que ser o valor recebido.

Então assertEquals valor esperado

é o valor recebido.

Então eu vou salvar.

Agora o meu teste está compilando, eu vou rodar e é,

é, ele está falando aqui ó, eu estava esperando o tênis

mas foi é, é, cadê?

Mostra aí.

Não está mostrando.

Então eu vou expandir aqui para a gente ver o que é.

E está lá, eu estava esperando o tênis mas foi null, está?

Ó, veja que essa verificação ele está rodando dentro do mock,

por isso que faz parte do teste, está?

Então ele quando ele chama verifica o recebimento do tênis com 100,

então ele, ele faz essa verificação, certo?

Então criamos o nosso teste, criamos o nosso mock, definimos a interface não é?

Tudo como que vai ser a partir do nosso teste.

Então eu vou deixar a implementação e a continuação do nosso TDD

para o próximo vídeo.

Muito obrigado por assistir e continue na sequência.

[MÚSICA]

Explore our Catalog

Join for free and get personalized recommendations, updates and offers.

Coursera provides universal access to the world’s best education, partnering with top universities and organizations to offer courses online.

© 2018 Coursera Inc. All rights reserved.

Download on the App Store

Get it on Google Play