bons testes de unidade, o desenvolvedor é obrigado a fazer bom uso de orientação a
objetos.
A prática nos ajuda a escrever um software melhor, com mais qualidade, e um
código melhor, mais fácil de ser mantido e evoluído. Esses dois pontos são impor-
tantíssimos em qualquer software, e TDD nos ajuda a alcançá-los. Toda prática que
ajuda a aumentar a qualidade do software produzido deve ser estudada.
Neste livro, tentei colocar toda a experiência e tudo que aprendi ao longo des-
ses últimos anos praticando e pesquisando sobre o assunto. Mostrei também o outro
lado da prática, seus efeitos no design de classes, que é muito falada mas pouco discutida e explicada. A prática de TDD, quando bem usada, pode ser bastante produtiva.
Mas, como verá ao longo do livro, os praticantes devem estar sempre alertas as dicas
que o teste dará sobre nosso código. Aqui, passaremos por eles e o leitor ao final do livro terá em mãos uma nova e excelente ferramenta de desenvolvimento.
A quem se destina esse livro?
Esse livro é destinado a desenvolvedores que querem aprender a escrever testes
de maneira eficiente, e que desejam aprender a como melhorar ainda mais o código
v
Casa do Código
que produzem. A primeira versão deste livro foi escrita em Java. Só que dado o su-
cesso, decidi transformar os exemplos também em C#, para facilitar a vida de quem
trabalha com a plataforma .NET.
Mas, independente de sua linguagem, toda discussão feita aqui faz sentido para
outras linguagens. Mesmo que você já pratique TDD, tenho certeza que aqui encon-
trará discussões interessantes sobre como a prática dá feedback sobre problemas de
acoplamento e coesão, bem como técnicas para escrever testes melhores e mais fáceis
de serem mantidos.
Testadores também podem se beneficiar deste livro, entendendo como escrever
códigos de teste de qualidade, quando ou não usar TDD, e como reportar problemas
de código para os desenvolvedores.
Como devo estudar?
Ao longo do livro, trabalhamos em diversos exemplos, muito similares ao mundo
real. Todo capítulo possui sua parte prática e parte teórica. Na parte prática, muito código de teste é escrito. Na parte teórica, refletimos sobre o código que produzimos até aquele momento, o que foi feito de bom, o que foi feito de ruim, e melhoramos
de acordo.
O leitor pode refazer todos os códigos produzidos nos capítulos. Praticar TDD
é essencial para que as ideias fiquem naturais. Além disso, a Caelum também dispo-
nibiliza um curso online sobre testes automatizados [9], que pode ser usado como
complemento desse livro.
Boa leitura!
vi
Casa do Código
Sumário
Sumário
1
Introdução
1
1.1
Era uma vez um projeto sem testes... . . . . . . . . . . . . . . . . . . .
1
1.2
Por que devemos testar?
. . . . . . . . . . . . . . . . . . . . . . . . . .
2
1.3
Por que não testamos? . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3
1.4
Testes automatizados e TDD . . . . . . . . . . . . . . . . . . . . . . . .
3
1.5
Conclusão . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4
2
Testes de Unidade
5
2.1
O que é um teste de unidade? . . . . . . . . . . . . . . . . . . . . . . .
5
2.2
Preciso mesmo escrevê-los? . . . . . . . . . . . . . . . . . . . . . . . .
6
2.3
O Primeiro Teste
de Unidade . . . . . . . . . . . . . . . . . . . . . . . .
8
2.4
Continuando a testar . . . . . . . . . . . . . . . . . . . . . . . . . . . .
16
2.5
Conclusão . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
17
3
Introdução ao Test-Driven Development
19
3.1
O problema dos números romanos . . . . . . . . . . . . . . . . . . . . 20
3.2
O primeiro teste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
21
3.3
Refletindo sobre o assunto . . . . . . . . . . . . . . . . . . . . . . . . .
27
3.4
Quais as vantagens? . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
28
3.5
Um pouco da história de TDD . . . . . . . . . . . . . . . . . . . . . . .
30
3.6
Conclusão . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
31
4
Simplicidade e Baby Steps
33
4.1
O Problema do Cálculo de Salário . . . . . . . . . . . . . . . . . . . . .
33
4.2
Implementando da maneira mais simples possível . . . . . . . . . . .
34
vii
Sumário
Casa do Código
4.3
Passos de Bebê (ou Baby Steps) . . . . . . . . . . . . . . . . . . . . . .
37
4.4
Usando baby steps de maneira consciente . . . . . . . . . . . . . . . .
43
4.5
Conclusão . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
47
5
TDD e Design de Classes
49
5.1
O Problema do Carrinho de Compras . . . . . . . . . . . . . . . . . . 49
5.2
Testes que influenciam no design de classes . . . . . . . . . . . . . . .
55
5.3
Diferenças entre TDD e testes da maneira tradicional . . . . . . . . .
56
5.4
Testes como rascunho . . . . . . . . . . . . . . . . . . . . . . . . . . . .
57
5.5
Conclusão . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
58
6