Download - Teste Driven Development
![Page 1: Teste Driven Development](https://reader034.vdocuments.us/reader034/viewer/2022042607/5563a47ed8b42a2d538b54ea/html5/thumbnails/1.jpg)
Autor: Eduardo R. Carvalhoemail: [email protected]
[ TDD]
$ 1.0
Autor: Eduardo R. Carvalhoemail: [email protected]@ercarvalFacebook : ercarval
Test Driven Development
![Page 2: Teste Driven Development](https://reader034.vdocuments.us/reader034/viewer/2022042607/5563a47ed8b42a2d538b54ea/html5/thumbnails/2.jpg)
[ TDD ] • O que é • Metodologia • Testes e Ciclo de Desenvolvimento de SW• JUnit• JUnit & NetBeans• Best Practices• Resumo
12/04/2023 Eduardo R Carvalho 2
![Page 3: Teste Driven Development](https://reader034.vdocuments.us/reader034/viewer/2022042607/5563a47ed8b42a2d538b54ea/html5/thumbnails/3.jpg)
[TDD] – Test-Driven Development• Metodologia que utiliza de Testes para prover informações para
tomada decisões de forma rápida e eficaz.• Promove o desenvolvimento de software de uma maneira simples
e incremental. Não somente maximiza a qualidade e o design do software, como também simplifica o processo de desenvolvimento.
• TDD é uma das práticas do Extreme Programming (XP). As práticas do XP foram formuladas por Kent Beck e Ron Jeffries a partir de suas experiências no desenvolvimento de uma sistema de pagamento para a Chrysler. As idéias gerais por trás do XP são simplificar o processo de desenvolvimento simples e manter um processo contínuo de desenvolvimento em um ciclo curto que fornece um feedback constante do estado do software. As idéias do TDD tem ganho uma grande aceitação nos meio dos desenvolvimento e projetos de software.
12/04/2023 Introução a Java 3
![Page 4: Teste Driven Development](https://reader034.vdocuments.us/reader034/viewer/2022042607/5563a47ed8b42a2d538b54ea/html5/thumbnails/4.jpg)
[TDD] - Metodologia Baseada em dois Conceitos Básicos.
Testes Unitários “Refactoring”
Composto nos seguintes passos:
1. Escrever um teste que define como você acha que pequeno pedaço da aplicação deveria se comportar.
2. Fazer o teste rodar da maneira mais fácil e rápida que você pode. Não se preocupe com a qualidade do código, apenas faça funcionar.
3. Enxugue o código. Agora que o código esta funcionando corretamente, dê um passo para trás e refatore para remover qualquer duplicação ou qualquer outro problema que foi apresentado para tornar o teste executável.
12/04/2023 Introução a Java 4
![Page 5: Teste Driven Development](https://reader034.vdocuments.us/reader034/viewer/2022042607/5563a47ed8b42a2d538b54ea/html5/thumbnails/5.jpg)
[TDD] - Metodologia TDD é um processo iterativo e você repete estes passos
inúmeras vezes até que você fique satisfeito com o novo código. A maneira que TDD trabalha é através de requisitos, ou casos de
uso que são decompostos em um conjunto de comportamentos que são premissas para atender o requisito.Para cada comportamento do sistema, a primeira coisa a se fazer é escrever um teste unitário que irá testar este comportamento. O teste unitário primeiro, portanto temos um conjunto bem definido de critérios que podemos utilizar para mensurar a quantidade de código necessário que foi escrito para implementar este comportamento. Um dos benefícios de se escrever o teste primeiro é que ele ajuda a definir o comportamento do sistema de uma maneira mais clara e responder algumas perguntas do modelo.
12/04/2023 Introução a Java 5
![Page 6: Teste Driven Development](https://reader034.vdocuments.us/reader034/viewer/2022042607/5563a47ed8b42a2d538b54ea/html5/thumbnails/6.jpg)
[TDD] - Como Adotar ? Convencendo as pessoas a utilizar TDD
Desenvolver software é um risco assumido. É quase impossível entregar um projeto dentro do orçamento e do prazo. De acordo com um estudo da Gartner Group, 30% dos projetos falham e não chegam aos seus objetivos, e 70% são entregues em atraso ou fora do orçamento previsto. Claramente existe a necessidade de melhorar este processo, mas a questão é como. TDD pode ser parte da resposta, mas antes de convencer as pessoas a utilizar TDD é preciso entender e apresentar os problemas do processo atual. Uma vez entendido as falhas do processo corrente, é preciso entender como utilizar TDD para suprir estas falhas e utilizar este conhecimento para convencer as outras pessoas que isso irá funcionar.
12/04/2023 Introução a Java 6
![Page 7: Teste Driven Development](https://reader034.vdocuments.us/reader034/viewer/2022042607/5563a47ed8b42a2d538b54ea/html5/thumbnails/7.jpg)
[TDD] - Como Adotar ? Encontrando as falhas no processo corrente.
O processo mais usual quando não se pratica TDD é o famoso modelo cascata ( análise dos requisitos, modelo, código e o teste). A maioria dos problemas relacionados ao desenvolvimento de software é má comunicação da equipe e uma execução falha. Para entender as falhas do processo corrente, devemos responder algumas perguntas básicas como:
– Qual é a maior causa dos bugs no softwares ?– Qual é a maor causa dos atrasos no cronograma ?– Qual é a média de bugs a cada 1000 linhas de código escrito ?– Como o processo reage a uma mudança de requisito.– Qual a fase do projeto que mais tenho problemas ? (Desing, código, integração, etc..)
12/04/2023 Introução a Java 7
![Page 8: Teste Driven Development](https://reader034.vdocuments.us/reader034/viewer/2022042607/5563a47ed8b42a2d538b54ea/html5/thumbnails/8.jpg)
[TDD] - Testes no ciclo de vida do SW Testes formais podem e devem ser definidos em todas as etapas do desenvolvimento de um
software. Mesmo no caso de não poderem ser automatizados, defini-los precisamente permite identificar desde cedo problemas mais sérios com os requisitos ou a modelagem de uma aplicação. Podemos dizer que, quando faltam informações para a definição formal de um teste em termos de entradas exatas e de resultados esperados, isso significa que os requisitos ainda não foram suficientemente entendidos e documentados.
Passado o levantamento de requisitos e a modelagem de negócios de uma aplicação, os testes passam a se focar mais em aspectos particulares da implementação, o que aumenta a demanda pela sua automação. Neste momento, a falta de informações suficientes para se implementar um teste automatizado pode indicar que as especificações de classes, pacotes, componentes, formatos de dados etc. ainda estão incompletas, ou então que surgiram requisitos novos ainda não completamente documentados.
O desenvolvimento orientado a testes traz o benefício de validar de modo objetivo os requisitos documentados desde o início do ciclo de vida. O TDD expõe erros, omissões e inconsistências que de outra forma só seriam detectados quando já houvesse código executável entregue ao usuário.
12/04/2023 Introução a Java 8
![Page 9: Teste Driven Development](https://reader034.vdocuments.us/reader034/viewer/2022042607/5563a47ed8b42a2d538b54ea/html5/thumbnails/9.jpg)
[TDD] - Testes no ciclo de vida do SW Um exemplo de processo de desenvolvimento e os tipos de testes que são produzidos em cada
etapa. Vale a pena ressaltar aqui que em muitos casos as mesmas tecnologias e ferramentas podem ser utilizadas para construir diferentes tipos de testes. A distinção entre, por exemplo, “testes de unidade” e “testes de sistema” é feita em relação à finalidade de cada teste, e não em relação à sua forma.
12/04/2023 Introução a Java 9
![Page 10: Teste Driven Development](https://reader034.vdocuments.us/reader034/viewer/2022042607/5563a47ed8b42a2d538b54ea/html5/thumbnails/10.jpg)
[TDD] Alguns Frameworks de apoio JUnit
http://www.junit.org EasyMock
http://easymock.org JMock
http://www.jmock.org/ Mockito
http://code.google.com/p/mockito/ Spring
http://www.springsource.org/ iMacros
http://www.iopus.com/download/
12/04/2023 Introução a Java 10
![Page 11: Teste Driven Development](https://reader034.vdocuments.us/reader034/viewer/2022042607/5563a47ed8b42a2d538b54ea/html5/thumbnails/11.jpg)
[TDD] – JUnit : O que é ? Um framework que facilita o desenvolvimento e execução de
testes de unidade em código Java Uma API para construir os testes Aplicações para executar testes
A API Classes Test, TestCase, TestSuite, etc. oferecem a infraestrutura
necessária para criar os testes Métodos assertTrue(), assertEquals(), fail(), etc. são usados para
testar os resultados. Suportado por varias IDES (Eclipse, NetBeans, JDeveloper, etc...).
12/04/2023 Introução a Java 11
![Page 12: Teste Driven Development](https://reader034.vdocuments.us/reader034/viewer/2022042607/5563a47ed8b42a2d538b54ea/html5/thumbnails/12.jpg)
[TDD] – JUnit : Para que Serve ? Testar é uma boa prática, mas é chato; JUnit torna as coisas
mais agradáveis, facilitando: A criação e execução automática de testes A apresentação dos resultados
JUnit pode verificar se cada unidade de código funciona da forma esperada Permite agrupar e rodar vários testes ao mesmo tempo Na falha, mostra a causa em cada teste
Serve de base para extensões
12/04/2023 Introução a Java 12
![Page 13: Teste Driven Development](https://reader034.vdocuments.us/reader034/viewer/2022042607/5563a47ed8b42a2d538b54ea/html5/thumbnails/13.jpg)
[TDD] – JUnit : Arquitetura
Diagrama de Classes
12/04/2023 Introução a Java 13
![Page 14: Teste Driven Development](https://reader034.vdocuments.us/reader034/viewer/2022042607/5563a47ed8b42a2d538b54ea/html5/thumbnails/14.jpg)
[TDD] – JUnit : Como Usar ?
Há várias formas de usar o JUnit. Depende da metodologia de testes que está sendo usada Código existente: precisa-se escrever testes para
classes que já foram implementadas Desenvolvimento guiado por testes (TDD): código
novo só é escrito se houver um teste sem funcionar
12/04/2023 Introução a Java 14
![Page 15: Teste Driven Development](https://reader034.vdocuments.us/reader034/viewer/2022042607/5563a47ed8b42a2d538b54ea/html5/thumbnails/15.jpg)
[TDD] – JUnit : Testar Código Existente Exemplo de um roteiro típico1. Crie uma classe que estenda junit.framework.TestCase para cada classe a ser
testadaimport junit.framework.*;
class SuaClasseTest extends TestCase {...}
2. Para cada método xxx(args) a ser testado defina um método public void testXxx() no test case SuaClasse:
public boolean equals(Object o) { ... } SuaClasseTest:
public void testEquals() {...}
Sobre escreva o método setUp(), se necessário Sobre escreva o método tearDown(), se necessário
12/04/2023 Introução a Java 15
![Page 16: Teste Driven Development](https://reader034.vdocuments.us/reader034/viewer/2022042607/5563a47ed8b42a2d538b54ea/html5/thumbnails/16.jpg)
[TDD] – JUnit : Guiar Desenvolvimento Cenário de Test-Driven Development (TDD)
1. Defina uma lista de tarefas a implementar2. Escreva uma classe (test case) e implemente um método de teste para uma
tarefa da lista.3. Rode o JUnit e certifique-se que o teste falha4. Implemente o código mais simples que rode o teste
Crie classes, métodos, etc. para que código compile Código pode ser código feio, óbvio, mas deve rodar!
5. Refatore o código para remover a duplicação de dados6. Escreva mais um teste ou refine o teste existente7. Repita os passos 2 a 6 até implementar toda a lista
12/04/2023 Introução a Java 16
![Page 17: Teste Driven Development](https://reader034.vdocuments.us/reader034/viewer/2022042607/5563a47ed8b42a2d538b54ea/html5/thumbnails/17.jpg)
[TDD] – JUnit : Como Implementar Dentro de cada teste, utilize os métodos herdados da classe
TestCase assertEquals(objetoEsperado, objetoRecebido), assertTrue(valorBooleano), assertNotNull(objeto) assertSame(objetoUm, objetoDois), fail (), ...
Exemplo de test case com um setUp() e um teste:1. public class CoisaTest extends TestCase {2. // construtor padrão omitido3. private Coisa coisa;4. public void setUp(){ coisa = new Coisa("Bit"); }5. public void testToString() {6. assertEquals("<coisa>Bit</coisa>",7. coisa.toString() );8. } 9. }
12/04/2023 Eduardo R Carvalho 17
![Page 18: Teste Driven Development](https://reader034.vdocuments.us/reader034/viewer/2022042607/5563a47ed8b42a2d538b54ea/html5/thumbnails/18.jpg)
[TDD] – JUnit : Como Funciona ? O TestRunner recebe uma subclasse de junit.framework.TestCase
Usa reflection para achar métodos Para cada método testXXX(), executa:
o método setUp() o próprio método testXXX() o método tearDown()
O test case é instanciado para executar um método testXXX() de cada vez. As alterações que ele fizer ao estado do objeto não afetarão os
demais testes Método pode terminar, falhar ou provocar exceção
12/04/2023 Eduardo R Carvalho 18
![Page 19: Teste Driven Development](https://reader034.vdocuments.us/reader034/viewer/2022042607/5563a47ed8b42a2d538b54ea/html5/thumbnails/19.jpg)
[TDD] – JUnit : Exemplo de Test Casepackage junitdemo;import junit.framework.*;import java.io.IOException;
public class TextUtilsTest extends TestCase {public TextUtilsTest(String name) {
super(name);}public void testRemoveWhiteSpaces() throws IOException {
String testString = "one, ( two | three+) , " +"(((four+ |\t five)?\n \n, six? ";
String expectedString = "one,(two|three+) " + ",(((four+|five)?,six? ";
String results = TextUtils.removeWhiteSpaces(testString);assertEquals(expectedString, results);
}}
12/04/2023 Eduardo R Carvalho 19
![Page 20: Teste Driven Development](https://reader034.vdocuments.us/reader034/viewer/2022042607/5563a47ed8b42a2d538b54ea/html5/thumbnails/20.jpg)
[TDD] – JUnit : Fazendo o Teste Passar 1. package junitdemo;2. import java.io.*;3. public class TextUtils {4. public static String removeWhiteSpaces(String text) throws ...{5. return "one,(two|three+),(((four+|five)?,six?";6. }7. }
O teste passa... e daí? A solução está pronta? Não! Tem dados duplicados! Remova-os!
Escreva um novo teste que faça com que esta solução falhe, por exemplo: String test2 = " a b\nc "; assertEquals("abc", TextUtils.removeWhiteSpaces(test2));
12/04/2023 Eduardo R Carvalho 20
![Page 21: Teste Driven Development](https://reader034.vdocuments.us/reader034/viewer/2022042607/5563a47ed8b42a2d538b54ea/html5/thumbnails/21.jpg)
[TDD] – JUnit : Fazendo o Teste Passar!! 1. package junitdemo;2. import java.io.*;3. public class TextUtils {4. public static String removeWhiteSpaces(String text) 5. throws IOException {6. StringReader reader = new StringReader(text);7. StringBuffer buffer = new StringBuffer(text.length());8. int c;9. while( (c = reader.read()) != -1) {10. if (c ==' '||c =='\n'||c =='\r'|| c =='\f'||c =='\t')
{11. ; /* do nothing */12. } else {13. buffer.append((char)c);14. }15. }16. return buffer.toString();17. }18.}
12/04/2023 Eduardo R Carvalho 21
![Page 22: Teste Driven Development](https://reader034.vdocuments.us/reader034/viewer/2022042607/5563a47ed8b42a2d538b54ea/html5/thumbnails/22.jpg)
[TDD] – JUnit : TestSuite Permite executar uma coleção de testes
Método addTest(TestSuite) adiciona um teste na lista Padrão de codificação (usando reflection):
retornar um TestSuite em cada test-case:1. public static TestSuite suite() {2. return new TestSuite(SuaClasseTest.class);3. }
Criar uma classe AllTests que combina as suites:1. public class AllTests {2. public static Test suite() {3. TestSuite testSuite = new TestSuite("Roda tudo");4. testSuite.addTest(pacote.AllTests.suite());5. testSuite.addTest(MinhaClasseTest.suite());6. testSuite.addTest(SuaClasseTest.suite());7. return testSuite;8. }9. }
12/04/2023 Eduardo R Carvalho 22
![Page 23: Teste Driven Development](https://reader034.vdocuments.us/reader034/viewer/2022042607/5563a47ed8b42a2d538b54ea/html5/thumbnails/23.jpg)
[TDD] – JUnit : Fixture São os dados reutilizados por vários testes1. public class AttributeEnumerationTest extends TestCase {2. String testString; String[] testArray; 3. AttributeEnumeration testEnum;4. public void setUp() {5. testString = "(alpha|beta|gamma)";6. testArray = new String[]{"alpha", "beta", "gamma"};7. testEnum = new AttributeEnumeration(testArray);8. }9. public void testGetNames() {10. assertEquals(testEnum.getNames(), testArray);11. }12. public void testToString() {13. assertEquals(testEnum.toString(), testString);14. }15.....
Se os mesmos dados são usados em vários testes, inicialize-os no setUp() e faça a faxina no tearDown() (se necessário)
Não perca tempo pensando nisto antes. Escreva seus testes. Depois, se achar que há duplicação,
monte o fixture.
12/04/2023 Eduardo R Carvalho 23
![Page 24: Teste Driven Development](https://reader034.vdocuments.us/reader034/viewer/2022042607/5563a47ed8b42a2d538b54ea/html5/thumbnails/24.jpg)
[TDD] – JUnit : Testando a Falha !!! É tão importante testar o cenário de falha do seu codigo quanto o
sucesso Método fail() provoca uma falha
Use para verificar se exceções ocorrem quando se espera que elas ocorram Exemplo:
1. public void testEntityNotFoundException() {2. resetEntityTable(); // no entities to resolve!3. try {4. // Following method call must cause exception!5. ParameterEntityTag tag = parser.resolveEntity("bogus");6. fail("Should have caused EntityNotFoundException!");7. } catch (EntityNotFoundException e) {8. // success: exception occurred as expected9. }10.}
12/04/2023 Eduardo R Carvalho 24
![Page 25: Teste Driven Development](https://reader034.vdocuments.us/reader034/viewer/2022042607/5563a47ed8b42a2d538b54ea/html5/thumbnails/25.jpg)
[TDD] – JUnit : Resumo Para o JUnit :
Um teste é um método Um caso de teste é uma classe contendo uma coleção de testes (métodos que possuem
assertions) Cada teste testa o comportamento de uma unidade de código do objeto testado (pode ser um
método, mas pode haver vários testes para o mesmo método ou um teste para todo o objeto)
Fixtures são os dados usados em testes TestSuite é uma composição de casos de teste
Pode-se agrupar vários casos de teste em uma suite
JUnit testa apenas a interface das classes Mantenha os casos de teste no mesmo diretório que as classes testadas para ter acesso a
métodos package-private Use padrões de nomenclatura: ClasseTest, AllTests Use o Ant para separar as classes em um release
12/04/2023 Eduardo R Carvalho 25
![Page 26: Teste Driven Development](https://reader034.vdocuments.us/reader034/viewer/2022042607/5563a47ed8b42a2d538b54ea/html5/thumbnails/26.jpg)
[TDD] – JUnit : NetBeans 6.7.x http://junit.netbeans.org/proposed-new-features.html
12/04/2023 Eduardo R Carvalho 26
![Page 27: Teste Driven Development](https://reader034.vdocuments.us/reader034/viewer/2022042607/5563a47ed8b42a2d538b54ea/html5/thumbnails/27.jpg)
[TDD] – JUnit 4 : Simple Test1. public class DAOTest {2. @BeforeClass3. public static void setUpClass() throws Exception { }4. @AfterClass5. public static void tearDownClass() throws Exception {}6. @Before7. public void setUp() {}8. @After9. public void tearDown() {}10. @Test11. public void testXXX() { }12. @Test13. public void testYYY() { }14.}
12/04/2023 Eduardo R Carvalho 27
![Page 28: Teste Driven Development](https://reader034.vdocuments.us/reader034/viewer/2022042607/5563a47ed8b42a2d538b54ea/html5/thumbnails/28.jpg)
[TDD] – JUnit 4 : TestSuite1. @RunWith(Suite.class)2. @Suite.SuiteClasses( {br.com.fastbuy.dao.ItemDAOTest.class ,3. br.com.fastbuy.framework.dao.DAOHelperTest.class })4. public class SampleTestSuite {5. @BeforeClass6. public static void setUpClass() throws Exception {}
7. @AfterClass8. public static void tearDownClass() throws Exception {}
9. @Before10. public void setUp() throws Exception {}
11. @After12. public void tearDown() throws Exception {}13.}
12/04/2023 Eduardo R Carvalho 28
![Page 29: Teste Driven Development](https://reader034.vdocuments.us/reader034/viewer/2022042607/5563a47ed8b42a2d538b54ea/html5/thumbnails/29.jpg)
[TDD] – Best Practices JUnit facilita bastante a criação e execução de testes, mas elaborar
bons testes exige mais O que testar? Como saber se testes estão completos?
"Teste tudo o que pode falhar" [2] Métodos triviais (get/set) não precisam ser testados. E se houver uma rotina de validação no método set?
É melhor ter testes a mais que testes a menos Escreva testes curtos (quebre testes maiores) Use assertNotNull() (reduz drasticamente erros de NullPointerException
difíceis de encontrar) Reescreva seu código para que fique mais fácil de testar
12/04/2023 Eduardo R Carvalho 29
![Page 30: Teste Driven Development](https://reader034.vdocuments.us/reader034/viewer/2022042607/5563a47ed8b42a2d538b54ea/html5/thumbnails/30.jpg)
[TDD] – Best Practices Escreva listas de tarefas (to-do list)
Comece pelas mais simples e deixe os testes "realistas” para o final Requerimentos, use-cases, diagramas UML: rescreva os requerimentos em termos de
testes
Dados Use apenas dados suficientes (não teste 10 condições se três forem suficientes)
Bugs revelam testes Achou um bug? Não conserte sem antes escrever um teste que o pegue (se você não
o fizer, ele volta)!
Teste sempre! Não escreva uma linha de código sem antes escrever um teste!
12/04/2023 Eduardo R Carvalho 30
![Page 31: Teste Driven Development](https://reader034.vdocuments.us/reader034/viewer/2022042607/5563a47ed8b42a2d538b54ea/html5/thumbnails/31.jpg)
[TDD] – Test-Driven Development Desenvolvimento guiado pelos testes
Só escreva código novo se um teste falhar Refatore até que o teste funcione Alternância: "red/green/refactor" - nunca passe mais de 10 minutos sem que
a barra do JUnit fique verde.
Técnicas "Fake It Til You Make It": faça um teste rodar simplesmente fazendo método
retornar constante Triangulação: abstraia o código apenas quando houver dois ou mais testes
que esperam respostas diferentes Implementação óbvia: se operações são simples, implemente-as e faça que
os testes rodem
12/04/2023 Eduardo R Carvalho 31
![Page 32: Teste Driven Development](https://reader034.vdocuments.us/reader034/viewer/2022042607/5563a47ed8b42a2d538b54ea/html5/thumbnails/32.jpg)
[TDD] – Como Lidar com Testes Difíceis Testes devem ser simples e suficientes
XP: design mais simples que resolva o problema; sempre pode-se escrever novos testes, quando necessário
Não complique Não teste o que é responsabilidade de outra classe/método Assuma que outras classes e métodos funcionam
Testes difíceis (ou que parecem difíceis) Aplicações gráficas: eventos, layouts, threads Objetos inacessíveis, métodos privativos, Singletons Objetos que dependem de outros objetos Objetos cujo estado varia devido a fatores imprevisíveis
Soluções Alterar o design da aplicação para facilitar os testes Simular dependências usando proxies e stubs
12/04/2023 Eduardo R Carvalho 32
![Page 33: Teste Driven Development](https://reader034.vdocuments.us/reader034/viewer/2022042607/5563a47ed8b42a2d538b54ea/html5/thumbnails/33.jpg)
[TDD] – Resumo Testar é tarefa essencial do desenvolvimento de software. Testar unidades de código durante o desenvolvimento é uma prática que
traz inúmeros benefícios Menos tempo de depuração (muito, muito menos!) Melhor qualidade do software Segurança para alterar o código Usando TDD, melhores estimativas de prazo
JUnit é uma ferramenta open-source que ajuda a implementar testes em projetos Java
TDD ou Test-Driven Development é uma técnica onde os testes são usados para guiar o desenvolvimento Ajuda a focar o desenvolvimento em seus objetivos
Mock objects ou stubs podem ser usados para representar dependência e diminuir as responsabilidades de testes
12/04/2023 Eduardo R Carvalho 33