Exerccios TDD

exerccios extrado de curso da Caelum

JUnit
Boto direito no projeto
Build Path
Add libraries
selecione JUnit

Pastas
Em java comum usar pastas para cdigo de produo no source folder.
Criar um segundo source folder para testes
criar a mesma estrutura de pastas para os testes, espelhando a produo.

Anatomia do mtodo de teste

O nome deve refletir um comportamento esperado
no pode ser esttico
no deve receber parmetros
@Test
usar a anotao antes do mtodo de teste
deve ser:
@Test
public void deve_apresentar_um_comportamento_especifico() {
...
}

Anatomia de um Teste
-

Constroi Cenrio
Quais elementos externos so necessrios para
exercitar o comportamento

Executa ao
invoca o comportamento que se deseja testar

Verifica sada
Estabelece expectativas do comportamento
Quais so as ps condies?

Assert
Expectativa de igualdade
assertEquals(esperado, recebido);
import static org.junit.Assert.assertEquals;
import org.junit.*;

para valores double

assertEquals(esperado, recebido, delta=0.0001);

@Before e @After ...

@Before
mtodo a ser executado antes de todos os testes
@After
mtodo a ser executado depois de todos os testes
@BeforeClass
mtodo a ser executado antes da classe de testes
@AfterClass
mtodo a ser executado aps a classe de testes

Download fontes

http://bit.ly/caelum-testes-cap1

Lance
package br.com.caelum.leilao.dominio;
public class Lance {
private Usuario usuario;
private double valor;
public Lance(Usuario usuario, double valor) {
this.usuario = usuario;
this.valor = valor;
}
public double getValor() {
return this.valor;
}
public String toString() {
return usuario.getNome()+"("+valor+")";
}
}

Leilao
package br.com.caelum.leilao.dominio;
import java.util.ArrayList;
import java.util.List;
public class Leilao {
private String produto;
private List<Lance> lances;
public Leilao(String produto) {
this.produto = produto;
this.lances = new ArrayList<Lance>();
}
public void propoe(Lance lance) {
if(lance.getValor() <= 0)
throw new RuntimeException("Valor no pode ser negativo ou zero");
this.lances.add(lance);
}
public List<Lance> getLances() {
return lances;
}
}

Usuario
package br.com.caelum.leilao.dominio;
public class Usuario {
private String nome;
public Usuario(String nome) {
this.nome = nome;
}
public String getNome() {
return nome;
}
public String toString() {
return nome;
}
}

Exerccio
Dado um leilo, devemos saber qual o maior lance que foi dado.
Criar uma classe Avaliador
Criar um mtodo avalia(Leilao)
Criar um mtodo getMaiorLance()
Criar uma classe AvaliadorTest (pacote leilao.test)
adicionar 3 lances
avaliar se o maiorLance est coerente

Estratgia
1. Dado um leilao, preciso que um Avaliador possa avaliar o leilao, pois deve
ser possvel consultar ao Avaliador qual foi o maior lance:
teste:
no pacote: leilao.teste a classe AvaliadorTeste
criar 3 Usurios
criar 1 Leilao
criar 3 lances (300, 400, 250)
criar um Avaliador: leiloeiro
executar leiloeiro.avalia()
testar se o maiorLance() funciona

Resultado
@Test
public void deve_saber_qual_o_maior_lance_dado() {
// parte 1: contexto
Avaliador leiloeiro = new Avaliador();
Usuario joao = new Usuario("Joao");
Usuario jose = new Usuario("Jose");
Usuario maria = new Usuario("Maria");
Leilao leilao = new Leilao("Playstation 3 Novo");
leilao.propoe(new Lance(joao, 250.0));
leilao.propoe(new Lance(jose, 300.0));
leilao.propoe(new Lance(maria, 400.0));
// parte 2: ao
leiloeiro.avalia(leilao);
// parte 3: validacao
assertEquals(400.0, leiloeiro.getMaiorLance(), 0.00001);
}

Produo
No pacote: leilao.servico
Avaliador.avalia()
maior = Double.NEGATIVE_INFINITY;
calcula o maior de todos;
getMaiorLance()

Execuo (control-f11)

@Before
private
private
private
private

Avaliador leiloeiro;
Usuario joao;
Usuario jose;
Usuario maria;

@Before
public void criaAvaliador() {
this.leiloeiro = new Avaliador();
joao = new Usuario("Joao");
jose = new Usuario("Jose");
maria = new Usuario("Maria");
}

Resultado
@Test
public void deve_saber_qual_o_maior_lance_dado() {
// parte 1: contexto
Leilao leilao = new Leilao("Celular Usado");
leilao.propoe(new Lance(joao, 250.0));
leilao.propoe(new Lance(jose, 300.0));
leilao.propoe(new Lance(maria, 400.0));
// parte 2: ao
leiloeiro.avalia(leilao);
// parte 3: validacao
assertEquals(400.0, leiloeiro.getMaiorLance(), 0.00001);
}

Exerccio
Dado um leilo, devemos saber qual o menor lance que foi dado.
Criar um mtodo getMenorLance()
Criar uma classe AvaliadorTest (pacote leilao.test)

Resultado
@Test
public void deve_saber_qual_o_menor_lance_dado() {
// parte 1: contexto
Leilao leilao = new Leilao("Playstation 3 Novo");
leilao.propoe(new Lance(joao, 250.0));
leilao.propoe(new Lance(jose, 300.0));
leilao.propoe(new Lance(maria, 400.0));
// parte 2: ao
leiloeiro.avalia(leilao);
// parte 3: validacao
assertEquals(250.0, leiloeiro.getMenorLance(), 0.00001);
}

Exercicio
Fazer um teste mudando ordem dos valores

Resultado
@Test
public void deveEntenderLancesForaDeOrdem() {
// parte 1: contexto
Leilao leilao = new Leilao("Playstation 3 Novo");
leilao.propoe(new Lance(joao, 250.0));
leilao.propoe(new Lance(jose, 400.0));
leilao.propoe(new Lance(maria, 300.0));
// parte 2: ao
leiloeiro.avalia(leilao);
// parte 3: validacao
assertThat(leiloeiro.getMenorLance(), equalTo(250.0));
assertThat(leiloeiro.getMaiorLance(), equalTo(400.0));
}

Exerccio
Deve ser possvel obter a mdia dos lances

Resultado
@Test
public void deve_saber_qual_a_media_dos_lances() {
// parte 1: contexto
Leilao leilao = new Leilao("Playstation 3 Novo");
leilao.propoe(new Lance(joao, 250.0));
leilao.propoe(new Lance(jose, 300.0));
leilao.propoe(new Lance(maria, 400.0));
// parte 2: ao
leiloeiro.avalia(leilao);
// parte 3: validacao
assertEquals(316.666, leiloeiro.getMedia(), 0.001);
}

Produo
class Avaliador {
private double maiorDeTodos = Double.NEGATIVE_INFINITY;
private double menorDeTodos = Double.POSITIVE_INFINITY;
private double media = 0;
public void avalia(Leilao leilao) {
double total = 0;
for(Lance lance : leilao.getLances()) {
if(lance.getValor() > maiorDeTodos) maiorDeTodos = lance.getValor();
if(lance.getValor() < menorDeTodos) menorDeTodos = lance.getValor();
total += lance.getValor();
}
media = total / leilao.getLances().size();
}
public double getMaiorLance() { return maiorDeTodos; }
public double getMenorLance() { return menorDeTodos; }
public double getMedia() { return media; }
}

Classes de equivalncia
Vrios teste mudando os valores vale a pena?
Ordem Crescente
Ordem Decrescente
Ordem Randmica
Com apenas um lance
Sem lances
Lance Negativo

Exerccio
deve entender leilao com apenas um lance

Resultado
@Test
public void deveEntenderLeilaoComApenasUmLance() {
Leilao leilao = new Leilao("Playstation");
leilao.propoe(new Lance(joao, 1000.0));
leiloeiro.avalia(leilao);
assertEquals(1000, leiloeiro.getMaiorLance(), 0.0001);
assertEquals(1000, leiloeiro.getMenorLance(), 0.0001);
}

Exerccio
Calcular os trs maiores lances
retorne um List<Lance>

Resultado
@Test
public void deveEncontrarOsTresMaioresLances() {
Leilao leilao = new Leilao("Playstation 3 Novo");
leilao.propoe(new Lance(joao, 100.0));
leilao.propoe(new Lance(maria, 200.0));
leilao.propoe(new Lance(joao, 300.0));
leilao.propoe(new Lance(maria, 400.0));
leiloeiro.avalia(leilao);
List<Lance> maiores = leiloeiro.getTresMaiores();
assertEquals(3, maiores.size());
assertThat(maiores.size(), equalTo(3));
assertEquals(400.0, maiores.get(0).getValor(), 0.00001);
assertEquals(300.0, maiores.get(1).getValor(), 0.00001);
assertEquals(200.0, maiores.get(2).getValor(), 0.00001);
}

Resultado
@Test
public void deveDevolverTodosLancesCasoNaoHajaNoMinimo3() {
Leilao leilao = new Leilao("Playstation 3 Novo");
leilao.propoe(new Lance(joao, 300.0));
leilao.propoe(new Lance(maria, 400.0));
leiloeiro.avalia(leilao);
List<Lance> maiores = leiloeiro.getTresMaiores();
assertEquals(3, maiores.size());
assertThat(maiores.size(), equalTo(2));
assertEquals(400.0, maiores.get(0).getValor(), 0.00001);
assertEquals(300.0, maiores.get(1).getValor(), 0.00001);
}

Resultado
@Test
public void deveDevolverTodosLancesCasoNaoHajamLances() {
Leilao leilao = new Leilao("Playstation 3 Novo");
leiloeiro.avalia(leilao);
List<Lance> maiores = leiloeiro.getTresMaiores();
assertEquals(0, maiores.size());
assertThat(maiores.size(), equalTo(0));
}

Produo
public List<Lance> getTresMaiores() {
List<Lance> maiores;
maiores = new ArrayList<Lance>(leilao.getLances());
Collections.sort(maiores, new Comparator<Lance>() {
public int compare(Lance o1, Lance o2) {
if(o1.getValor() < o2.getValor()) return 1;
if(o1.getValor() > o2.getValor()) return -1;
return 0;
}
});
maiores = maiores.subList(0, 3);
// maiores = maiores.subList(0, maiores.size() > 3
? 3 : maiores.size());
return maiores;
}

Exerccio
Crie um Leilao e proponha Lance com valores randmicos, como por exemplo,
200, 450, 120, 700, 630, 230. Ao final, verifique que o menor 120 e o maior
700.

Resultado
@Test
public void deveEntenderLeilaoComLancesEmOrdemRandomica() {
Usuario joao = new Usuario("Joao");
Usuario maria = new Usuario("Joao");
Leilao leilao = new Leilao("Playstation 3 Novo");
leilao.propoe(new
leilao.propoe(new
leilao.propoe(new
leilao.propoe(new
leilao.propoe(new
leilao.propoe(new

Lance(joao,200.0));
Lance(maria,450.0));
Lance(joao,120.0));
Lance(maria,700.0));
Lance(joao,630.0));
Lance(maria,230.0));

Avaliador leiloeiro = new Avaliador();

leiloeiro.avalia(leilao);
assertEquals(700.0, leiloeiro.getMaiorLance(), 0.0001);
assertEquals(120.0, leiloeiro.getMenorLance(), 0.0001);
}

Exerccio
class MatematicaMaluca {
public int contaMaluca(int numero) {
if(numero > 30) return numero * 4;
else if(numero > 10) return numero * 3;
else return numero * 2;
}
}

Resultado
class MatematicaMalucaTest {
@Test
public void deveMultiplicarNumerosMaioresQue30() {
MatematicaMaluca matematica = new MatematicaMaluca();
assertEquals(50*4, matematica.contaMaluca(50));
}
@Test
public void deveMultiplicarNumerosMaioresQue10EMenoresQue30() {
MatematicaMaluca matematica = new MatematicaMaluca();
assertEquals(20*3, matematica.contaMaluca(20));
}
@Test
public void deveMultiplicarNumerosMenoresQue10() {
MatematicaMaluca matematica = new MatematicaMaluca();
assertEquals(5*2, matematica.contaMaluca(5));
}
}

Exerccio
class FiltroDeLances {
public List<Lance> filtra(List<Lance> lances) {
ArrayList<Lance> resultado = new ArrayList<Lance>();
for(Lance lance : lances) {
if(lance.getValor() > 1000 && lance.getValor() < 3000)
resultado.add(lance);
else if(lance.getValor() > 500 && lance.getValor() < 700)
resultado.add(lance);
else if(lance.getValor() > 5000)
resultado.add(lance);
}
return resultado;
}
}

Resultado
class FiltroDeLancesTest {
@Test
public void deveSelecionarLancesEntre1000E3000() {
Usuario joao = new Usuario("Joao");
FiltroDeLances filtro = new FiltroDeLances();
List<Lance> resultado = filtro.filtra(Arrays.asList(
new Lance(joao,2000),
new Lance(joao,1000),
new Lance(joao,3000),
new Lance(joao, 800)));
assertEquals(1, resultado.size());
assertEquals(2000, resultado.get(0).getValor(), 0.00001);
}

Resultado
@Test
public void deveSelecionarLancesEntre500E700() {
Usuario joao = new Usuario("Joao");
FiltroDeLances filtro = new FiltroDeLances();
List<Lance> resultado = filtro.filtra(Arrays.asList(
new Lance(joao,600),
new Lance(joao,500),
new Lance(joao,700),
new Lance(joao, 800)));
assertEquals(1, resultado.size());
assertEquals(600, resultado.get(0).getValor(), 0.00001);
}
}

Resultados
@Test
public void deveSelecionarLancesMaioresQue5000() {
Usuario joao = new Usuario("Joao");
FiltroDeLances filtro = new FiltroDeLances();
List<Lance> resultado = filtro.filtra(Arrays.asList(
new Lance(joao, 10000),
new Lance(joao, 800)));
assertEquals(1, resultado.size());
assertEquals(10000, resultado.get(0).getValor(), 0.00001);
}

Resultados
@Test
public void deveEliminarMenoresQue500() {
Usuario joao = new Usuario("Joao");
FiltroDeLances filtro = new FiltroDeLances();
List<Lance> resultado = filtro.filtra(Arrays.asList(
new Lance(joao, 400),
new Lance(joao, 300)));
assertEquals(0, resultado.size());
}

Resultados
@Test
public void deveEliminarEntre3000E5000() {
Usuario joao = new Usuario("Joao");
FiltroDeLances filtro = new FiltroDeLances();
List<Lance> resultado = filtro.filtra(Arrays.asList(
new Lance(joao, 4000),
new Lance(joao, 3500)));
assertEquals(0, resultado.size());
}

Exerccio
Testar a classe Leilao : LeilaoTest
Testar um Leilo que receba apenas um lance

Resultado
@Test
public void deve_receber_um_lance() {
Leilao leilao = new Leilao("MacBook Pro 15");
assertEquals(0, leilao.getLances().size());
leilao.propoe(new Lance(new Usuario("Steve Jobs"), 2000));
assertEquals(1, leilao.getLances().size());
assertEquals(2000.0, leilao.getLances().get(0).getValor(), 0.0001);
}

Exerccio
Testar leilao com vrios lances

Resultado
@Test
public void deve_receber_varios_lances() {
Leilao leilao = new Leilao("MacBook Pro 15");
leilao.propoe(new Lance(new Usuario("Steve Jobs"), 2000));
leilao.propoe(new Lance(new Usuario("Steve Woznick"), 3000));
assertEquals(1, leilao.getLances().size());
assertEquals(2000.0, leilao.getLances().get(0).getValor(), 0.0001);
assertEquals(3000.0, leilao.getLances().get(1).getValor(), 0.0001);
}

Exerccio
Uma mesma pessoa no pode propor 2 lances em sequncia
deve ignorar o segundo

Resultado
@Test
public void nao_deve_receber_um_segundo_lance_do_mesmo_usuario() {
Leilao leilao = new Leilao("MacBook Pro 15");
leilao.propoe(new Lance(new Usuario("Steve Jobs"), 2000));
leilao.propoe(new Lance(new Usuario("Steve Jobs"), 3000));
assertEquals(1, leilao.getLances().size());
assertEquals(2000.0, leilao.getLances().get(0).getValor(), 0.0001);
}

Criar metodo equals

no Eclipse
na classe Usuario
Control-3
generate hashcode and equals

Usuario equals
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Usuario other = (Usuario) obj;
if (id != other.id)
return false;
if (nome == null) {
if (other.nome != null)
return false;
} else if (!nome.equals(other.nome))
return false;
return true;
}

produo
public void propoe(Lance lance) {
if(lances.isEmpty() || !ultimoLanceDado().
getUsuario().equals(lance.getUsuario())) {
lances.add(lance);
}
}
private Lance ultimoLanceDado() {
return lances.get(lances.size()-1);
}

Exerccio
Uma pessoa no pode dar mais que cinco lances em um leilo

Resultado
@Test public void naoDeveAceitarMaisDoQue5LancesDeUmMesmoUsuario() {
Leilao leilao = new Leilao("Macbook Pro 15");
Usuario steveJobs = new Usuario("Steve Jobs");
Usuario billGates = new Usuario("Bill Gates");
leilao.propoe(new Lance(steveJobs, 2000));
leilao.propoe(new Lance(billGates, 3000));
leilao.propoe(new Lance(steveJobs, 4000));
leilao.propoe(new Lance(billGates, 5000));
leilao.propoe(new Lance(steveJobs, 6000));
leilao.propoe(new Lance(billGates, 7000));
leilao.propoe(new Lance(steveJobs, 8000));
leilao.propoe(new Lance(billGates, 9000));
leilao.propoe(new Lance(steveJobs, 10000));
leilao.propoe(new Lance(billGates, 11000));
// deve ser ignorado
leilao.propoe(new Lance(steveJobs, 12000));
assertEquals(10, leilao.getLances().size());
int ultimo = leilao.getLances().size() - 1;
Lance ultimoLance = leilao.getLances().get(ultimo);
assertEquals(11000.0, ultimoLance.getValor(), 0.00001);
}

produo
public void propoe(Lance lance) {
int total = 0;
for(Lance l : lances) {
if(l.getUsuario().equals(lance.getUsuario())) total++;
}
if(lances.isEmpty() ||
(!ultimoLanceDado().getUsuario().equals(lance.getUsuario())
&& total < 5)) {
lances.add(lance);
}
}

produo
public void propoe(Lance lance) {
if(lances.isEmpty() || (
!ultimoLanceDado().getUsuario().equals(lance.getUsuario()) &&
qtdDelancesDo(lance.getUsuario()) < 5)) {
lances.add(lance);
}
}
private int qtdDelancesDo(Usuario usuario) {
int total = 0;
for(Lance lance : lances) {
if(lance.getUsuario().equals(usuario)) total++;
}
return total;
}

produo
public void propoe(Lance lance) {
if(lances.isEmpty() || podeDarLance(lance.getUsuario())) {
lances.add(lance);
}
}
private boolean podeDarLance(Usuario usuario) {
return !ultimoLanceDado().getUsuario().equals(usuario)
&& qtdDelancesDo(usuario) < 5;
}

Exerccio
Construir o mtodo criadorDeLeilao: (Test Data Builder)
@Test
public void deveEncontrarOsTresMaioresLances() {
Leilao leilao = new CriadorDeLeilao().para("Playstation 3 Novo")
.lance(joao, 100.0)
.lance(maria, 200.0)
.lance(joao, 300.0)
.lance(maria, 400.0)
.constroi();
leiloeiro.avalia(leilao);
List<Lance> maiores = leiloeiro.getTresMaiores();
assertEquals(3, maiores.size());
assertEquals(400.0, maiores.get(0).getValor(), 0.00001);
assertEquals(300.0, maiores.get(1).getValor(), 0.00001);
assertEquals(200.0, maiores.get(2).getValor(), 0.00001);
}
}

Resultado
public class CriadorDeLeilao {
private Leilao leilao;
public CriadorDeLeilao() { }
public CriadorDeLeilao para(String descricao) {
this.leilao = new Leilao(descricao);
return this;
}
public CriadorDeLeilao lance(Usuario usuario, double valor) {
leilao.propoe(new Lance(usuario, valor));
return this;
}
public Leilao constroi() {
return leilao;
}
}

Exerccio
Enviar uma exceo ao avaliar um leilo com zero lances
public void avalia(Leilao leilao) {
// lancando a excecao
if(leilao.getLances().size() ==0)
throw new RuntimeException("No possvel avaliar um leilo sem lances");

Para tratar pode-se usar try catch

Resultado
@Test
public void naoDeveAvaliarLeiloesSemNenhumLanceDado() {
try {
Leilao leilao = new CriadorDeLeilao()
.para("Playstation 3 Novo")
.constroi();
leiloeiro.avalia(leilao);
Assert.fail();
}
catch(RuntimeException e) {
// deu certo!
}
}

Resultado
Pode-se usar a anotao @Test(expected=

exceo.class)

@Test(expected=RuntimeException.class)
public void naoDeveAvaliarLeiloesSemNenhumLanceDado() {
Leilao leilao = new CriadorDeLeilao()
.para("Playstation 3 Novo")
.constroi();
leiloeiro.avalia(leilao);
}

Exerccio
assertThat (calculado ,

matcher(expectativa)

class AvaliadorTest {
@Test
public void deveEntenderLancesEmOrdemCrescente() {
Leilao leilao = new CriadorDeLeilao()
.para("Playstation 3 Novo")
.lance(joao, 250)
.lance(jose, 300)
.lance(maria, 400)
.constroi();
leiloeiro.avalia(leilao);
assertThat(leiloeiro.getMenorLance(), equalTo(250.0));
assertEquals(400.0, leiloeiro.getMaiorLance(), 0.00001);
}
}

Exerccio
Hamcrest
http://code.google.com/p/hamcrest/downloads/detail?name=hamcrest-all-1.3.0
RC1.jar
http://code.google.com/p/hamcrest/wiki/Tutorial

Exerccio
@Test
public void deveEncontrarOsTresMaioresLances() {
Leilao leilao = new CriadorDeLeilao()
.para("Playstation 3 Novo")
.lance(joao, 100)
.lance(maria, 200)
.lance(joao, 300)
.lance(maria, 400)
.constroi();
leiloeiro.avalia(leilao);
List<Lance> maiores = leiloeiro.getTresMaiores();
assertEquals(3, maiores.size());
assertEquals(400.0, maiores.get(0).getValor(), 0.00001);
assertEquals(300.0, maiores.get(1).getValor(), 0.00001);
assertEquals(200.0, maiores.get(2).getValor(), 0.00001);
}

Exerccio
assertThat(maiores,
new
new
new
));

hasItems(
Lance(maria, 400),
Lance(joao, 300),
Lance(maria, 200)

Exerccio

Resultado

Exerccio

Resultado

Exerccio

Resultado

Exerccio

Resultado

Exerccio

Resultado

Estados